wot/src/test/java/net/pterodactylus/freenet/wot/IdentityLoaderTest.java

   1 /*
   2  * Sone - IdentityLoaderTest.java - Copyright © 2013 David Roden
   3  *
   4  * This program is free software: you can redistribute it and/or modify
   5  * it under the terms of the GNU General Public License as published by
   6  * the Free Software Foundation, either version 3 of the License, or
   7  * (at your option) any later version.
   8  *
   9  * This program is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  * GNU General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License
  15  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  16  */
  17
  18 package net.pterodactylus.freenet.wot;
  19
  20 import static com.google.common.base.Optional.of;
  21 import static com.google.common.collect.Lists.newArrayList;
  22 import static com.google.common.collect.Sets.newHashSet;
  23 import static java.util.Arrays.asList;
  24 import static java.util.Collections.emptySet;
  25 import static org.hamcrest.MatcherAssert.assertThat;
  26 import static org.hamcrest.Matchers.containsInAnyOrder;
  27 import static org.hamcrest.Matchers.hasSize;
  28 import static org.mockito.Matchers.any;
  29 import static org.mockito.Matchers.eq;
  30 import static org.mockito.Mockito.mock;
  31 import static org.mockito.Mockito.never;
  32 import static org.mockito.Mockito.verify;
  33 import static org.mockito.Mockito.when;
  34
  35 import java.util.Collection;
  36 import java.util.Collections;
  37 import java.util.List;
  38 import java.util.Map;
  39 import java.util.Set;
  40
  41 import net.pterodactylus.freenet.plugin.PluginException;
  42
  43 import com.google.common.base.Optional;
  44 import com.google.common.collect.ImmutableMap;
  45 import org.hamcrest.Matchers;
  46 import org.junit.Before;
  47 import org.junit.Test;
  48
  49 /**
  50  * Unit test for {@link IdentityLoader}.
  51  *
  52  * @author <a href="mailto:bombe@pterodactylus.net">David ‘Bombe’ Roden</a>
  53  */
  54 public class IdentityLoaderTest {
  55
  56         private final WebOfTrustConnector webOfTrustConnector = mock(
  57                         WebOfTrustConnector.class);
  58         private final IdentityLoader identityLoader = new IdentityLoader(webOfTrustConnector, of(new Context("Test")));
  59         private final IdentityLoader identityLoaderWithoutContext = new IdentityLoader(webOfTrustConnector);
  60
  61         @Before
  62         public void setup() throws PluginException {
  63                 List<OwnIdentity> ownIdentities = createOwnIdentities();
  64                 when(webOfTrustConnector.loadAllOwnIdentities()).thenReturn(newHashSet(ownIdentities));
  65                 when(webOfTrustConnector.loadTrustedIdentities(eq(ownIdentities.get(0)), any(Optional.class))).thenReturn(createTrustedIdentitiesForFirstOwnIdentity());
  66                 when(webOfTrustConnector.loadTrustedIdentities(eq(ownIdentities.get(1)), any(Optional.class))).thenReturn(createTrustedIdentitiesForSecondOwnIdentity());
  67                 when(webOfTrustConnector.loadTrustedIdentities(eq(ownIdentities.get(2)), any(Optional.class))).thenReturn(createTrustedIdentitiesForThirdOwnIdentity());
  68                 when(webOfTrustConnector.loadTrustedIdentities(eq(ownIdentities.get(3)), any(Optional.class))).thenReturn(createTrustedIdentitiesForFourthOwnIdentity());
  69         }
  70
  71         private List<OwnIdentity> createOwnIdentities() {
  72                 return newArrayList(
  73                                 createOwnIdentity("O1", "ON1", "OR1", "OI1", asList("Test", "Test2"), ImmutableMap.of("KeyA", "ValueA",
  74                                                 "KeyB", "ValueB")),
  75                                 createOwnIdentity("O2", "ON2", "OR2", "OI2", Collections.singletonList("Test"), ImmutableMap.of("KeyC", "ValueC")),
  76                                 createOwnIdentity("O3", "ON3", "OR3", "OI3", Collections.singletonList("Test2"), ImmutableMap.of("KeyE", "ValueE", "KeyD",
  77                                                 "ValueD")),
  78                                 createOwnIdentity("O4", "ON4", "OR$", "OI4", Collections.singletonList("Test"), ImmutableMap.of("KeyA", "ValueA", "KeyD",
  79                                                 "ValueD"))
  80                 );
  81         }
  82
  83         private Set<Identity> createTrustedIdentitiesForFirstOwnIdentity() {
  84                 return newHashSet(
  85                                 createIdentity("I11", "IN11", "IR11", Collections.singletonList("Test"), ImmutableMap.of("KeyA", "ValueA"))
  86                 );
  87         }
  88
  89         private Set<Identity> createTrustedIdentitiesForSecondOwnIdentity() {
  90                 return newHashSet(
  91                                 createIdentity("I21", "IN21", "IR21", asList("Test", "Test2"), ImmutableMap.of("KeyB", "ValueB"))
  92                 );
  93         }
  94
  95         private Set<Identity> createTrustedIdentitiesForThirdOwnIdentity() {
  96                 return newHashSet(
  97                                 createIdentity("I31", "IN31", "IR31", asList("Test", "Test3"), ImmutableMap.of("KeyC", "ValueC"))
  98                 );
  99         }
 100
 101         private Set<Identity> createTrustedIdentitiesForFourthOwnIdentity() {
 102                 return emptySet();
 103         }
 104
 105         private OwnIdentity createOwnIdentity(String id, String nickname, String requestUri, String insertUri, List<String> contexts, ImmutableMap<String, String> properties) {
 106                 OwnIdentity ownIdentity = new DefaultOwnIdentity(id, nickname, requestUri, insertUri);
 107                 ownIdentity.setContexts(contexts);
 108                 ownIdentity.setProperties(properties);
 109                 return ownIdentity;
 110         }
 111
 112         private Identity createIdentity(String id, String nickname, String requestUri, List<String> contexts, ImmutableMap<String, String> properties) {
 113                 Identity identity = new DefaultIdentity(id, nickname, requestUri);
 114                 identity.setContexts(contexts);
 115                 identity.setProperties(properties);
 116                 return identity;
 117         }
 118
 119         @Test
 120         public void loadingIdentities() throws PluginException {
 121                 List<OwnIdentity> ownIdentities = createOwnIdentities();
 122                 Map<OwnIdentity, Collection<Identity>> identities = identityLoader.loadIdentities();
 123                 verify(webOfTrustConnector).loadAllOwnIdentities();
 124                 verify(webOfTrustConnector).loadTrustedIdentities(eq(ownIdentities.get(0)), eq(of("Test")));
 125                 verify(webOfTrustConnector).loadTrustedIdentities(eq(ownIdentities.get(1)), eq(of("Test")));
 126                 verify(webOfTrustConnector, never()).loadTrustedIdentities(eq(ownIdentities.get(2)), any(Optional.class));
 127                 verify(webOfTrustConnector).loadTrustedIdentities(eq(ownIdentities.get(3)), eq(of("Test")));
 128                 assertThat(identities.keySet(), hasSize(4));
 129                 assertThat(identities.keySet(), containsInAnyOrder(ownIdentities.get(0), ownIdentities.get(1), ownIdentities.get(2), ownIdentities.get(3)));
 130                 verifyIdentitiesForOwnIdentity(identities, ownIdentities.get(0), createTrustedIdentitiesForFirstOwnIdentity());
 131                 verifyIdentitiesForOwnIdentity(identities, ownIdentities.get(1), createTrustedIdentitiesForSecondOwnIdentity());
 132                 verifyIdentitiesForOwnIdentity(identities, ownIdentities.get(2), Collections.<Identity>emptySet());
 133                 verifyIdentitiesForOwnIdentity(identities, ownIdentities.get(3), createTrustedIdentitiesForFourthOwnIdentity());
 134         }
 135
 136         @Test
 137         public void loadingIdentitiesWithoutContext() throws PluginException {
 138                 List<OwnIdentity> ownIdentities = createOwnIdentities();
 139                 Map<OwnIdentity, Collection<Identity>> identities = identityLoaderWithoutContext.loadIdentities();
 140                 verify(webOfTrustConnector).loadAllOwnIdentities();
 141                 verify(webOfTrustConnector).loadTrustedIdentities(eq(ownIdentities.get(0)), eq(Optional.<String>absent()));
 142                 verify(webOfTrustConnector).loadTrustedIdentities(eq(ownIdentities.get(1)), eq(Optional.<String>absent()));
 143                 verify(webOfTrustConnector).loadTrustedIdentities(eq(ownIdentities.get(2)), eq(Optional.<String>absent()));
 144                 verify(webOfTrustConnector).loadTrustedIdentities(eq(ownIdentities.get(3)), eq(Optional.<String>absent()));
 145                 assertThat(identities.keySet(), hasSize(4));
 146                 OwnIdentity firstOwnIdentity = ownIdentities.get(0);
 147                 OwnIdentity secondOwnIdentity = ownIdentities.get(1);
 148                 OwnIdentity thirdOwnIdentity = ownIdentities.get(2);
 149                 OwnIdentity fourthOwnIdentity = ownIdentities.get(3);
 150                 assertThat(identities.keySet(), containsInAnyOrder(firstOwnIdentity, secondOwnIdentity, thirdOwnIdentity, fourthOwnIdentity));
 151                 verifyIdentitiesForOwnIdentity(identities, firstOwnIdentity, createTrustedIdentitiesForFirstOwnIdentity());
 152                 verifyIdentitiesForOwnIdentity(identities, secondOwnIdentity, createTrustedIdentitiesForSecondOwnIdentity());
 153                 verifyIdentitiesForOwnIdentity(identities, thirdOwnIdentity, createTrustedIdentitiesForThirdOwnIdentity());
 154                 verifyIdentitiesForOwnIdentity(identities, fourthOwnIdentity, createTrustedIdentitiesForFourthOwnIdentity());
 155         }
 156
 157         private void verifyIdentitiesForOwnIdentity(Map<OwnIdentity, Collection<Identity>> identities, OwnIdentity ownIdentity, Set<Identity> trustedIdentities) {
 158                 assertThat(identities.get(ownIdentity), Matchers.<Collection<Identity>>is(trustedIdentities));
 159         }
 160
 161 }