src/test/java/net/pterodactylus/sone/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.sone.freenet.wot;
  19
  20 import static com.google.common.base.Optional.absent;
  21 import static com.google.common.base.Optional.of;
  22 import static com.google.common.collect.Lists.newArrayList;
  23 import static com.google.common.collect.Sets.newHashSet;
  24 import static java.util.Arrays.asList;
  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.hamcrest.Matchers.is;
  29 import static org.mockito.Matchers.any;
  30 import static org.mockito.Matchers.anyString;
  31 import static org.mockito.Matchers.eq;
  32 import static org.mockito.Matchers.isNull;
  33 import static org.mockito.Mockito.mock;
  34 import static org.mockito.Mockito.never;
  35 import static org.mockito.Mockito.verify;
  36 import static org.mockito.Mockito.when;
  37
  38 import java.util.Collection;
  39 import java.util.List;
  40 import java.util.Set;
  41
  42 import com.google.common.base.Optional;
  43 import com.google.common.collect.ImmutableMap;
  44 import com.google.common.collect.Multimap;
  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(WebOfTrustConnector.class);
  57         private final IdentityLoader identityLoader = new IdentityLoader(webOfTrustConnector, of(new Context("Test")));
  58         private final IdentityLoader identityLoaderWithoutContext = new IdentityLoader(webOfTrustConnector);
  59
  60         @Before
  61         public void setup() throws WebOfTrustException {
  62                 List<OwnIdentity> ownIdentities = createOwnIdentities();
  63                 when(webOfTrustConnector.loadAllOwnIdentities()).thenReturn(newHashSet(ownIdentities));
  64                 when(webOfTrustConnector.loadTrustedIdentities(eq(ownIdentities.get(0)), any(Optional.class))).thenReturn(createTrustedIdentitiesForFirstOwnIdentity());
  65                 when(webOfTrustConnector.loadTrustedIdentities(eq(ownIdentities.get(1)), any(Optional.class))).thenReturn(createTrustedIdentitiesForSecondOwnIdentity());
  66                 when(webOfTrustConnector.loadTrustedIdentities(eq(ownIdentities.get(2)), any(Optional.class))).thenReturn(createTrustedIdentitiesForThirdOwnIdentity());
  67         }
  68
  69         private List<OwnIdentity> createOwnIdentities() {
  70                 return newArrayList(
  71                                 createOwnIdentity("O1", "ON1", "OR1", "OI1", asList("Test", "Test2"), ImmutableMap.of("KeyA", "ValueA", "KeyB", "ValueB")),
  72                                 createOwnIdentity("O2", "ON2", "OR2", "OI2", asList("Test"), ImmutableMap.of("KeyC", "ValueC")),
  73                                 createOwnIdentity("O3", "ON3", "OR3", "OI3", asList("Test2"), ImmutableMap.of("KeyE", "ValueE", "KeyD", "ValueD"))
  74                 );
  75         }
  76
  77         private Set<Identity> createTrustedIdentitiesForFirstOwnIdentity() {
  78                 return newHashSet(
  79                                 createIdentity("I11", "IN11", "IR11", asList("Test"), ImmutableMap.of("KeyA", "ValueA"))
  80                 );
  81         }
  82
  83         private Set<Identity> createTrustedIdentitiesForSecondOwnIdentity() {
  84                 return newHashSet(
  85                                 createIdentity("I21", "IN21", "IR21", asList("Test", "Test2"), ImmutableMap.of("KeyB", "ValueB"))
  86                 );
  87         }
  88
  89         private Set<Identity> createTrustedIdentitiesForThirdOwnIdentity() {
  90                 return newHashSet(
  91                                 createIdentity("I31", "IN31", "IR31", asList("Test", "Test3"), ImmutableMap.of("KeyC", "ValueC"))
  92                 );
  93         }
  94
  95         private OwnIdentity createOwnIdentity(String id, String nickname, String requestUri, String insertUri, List<String> contexts, ImmutableMap<String, String> properties) {
  96                 OwnIdentity ownIdentity = new DefaultOwnIdentity(id, nickname, requestUri, insertUri);
  97                 ownIdentity.setContexts(contexts);
  98                 ownIdentity.setProperties(properties);
  99                 return ownIdentity;
 100         }
 101
 102         private Identity createIdentity(String id, String nickname, String requestUri, List<String> contexts, ImmutableMap<String, String> properties) {
 103                 Identity identity = new DefaultIdentity(id, nickname, requestUri);
 104                 identity.setContexts(contexts);
 105                 identity.setProperties(properties);
 106                 return identity;
 107         }
 108
 109         @Test
 110         public void loadingIdentities() throws WebOfTrustException {
 111                 List<OwnIdentity> ownIdentities = createOwnIdentities();
 112                 Multimap<OwnIdentity, Identity> identities = identityLoader.loadIdentities();
 113                 verify(webOfTrustConnector).loadAllOwnIdentities();
 114                 verify(webOfTrustConnector).loadTrustedIdentities(eq(ownIdentities.get(0)), eq(of("Test")));
 115                 verify(webOfTrustConnector).loadTrustedIdentities(eq(ownIdentities.get(1)), eq(of("Test")));
 116                 verify(webOfTrustConnector, never()).loadTrustedIdentities(eq(ownIdentities.get(2)), any(Optional.class));
 117                 assertThat(identities.keySet(), hasSize(2));
 118                 assertThat(identities.keySet(), containsInAnyOrder(ownIdentities.get(0), ownIdentities.get(1)));
 119                 verifyIdentitiesForOwnIdentity(identities, ownIdentities.get(0), createTrustedIdentitiesForFirstOwnIdentity());
 120                 verifyIdentitiesForOwnIdentity(identities, ownIdentities.get(1), createTrustedIdentitiesForSecondOwnIdentity());
 121         }
 122
 123         @Test
 124         public void loadingIdentitiesWithoutContext() throws WebOfTrustException {
 125                 List<OwnIdentity> ownIdentities = createOwnIdentities();
 126                 Multimap<OwnIdentity, Identity> identities = identityLoaderWithoutContext.loadIdentities();
 127                 verify(webOfTrustConnector).loadAllOwnIdentities();
 128                 verify(webOfTrustConnector).loadTrustedIdentities(eq(ownIdentities.get(0)), eq(Optional.<String>absent()));
 129                 verify(webOfTrustConnector).loadTrustedIdentities(eq(ownIdentities.get(1)), eq(Optional.<String>absent()));
 130                 verify(webOfTrustConnector).loadTrustedIdentities(eq(ownIdentities.get(2)), eq(Optional.<String>absent()));
 131                 assertThat(identities.keySet(), hasSize(3));
 132                 OwnIdentity firstOwnIdentity = ownIdentities.get(0);
 133                 OwnIdentity secondOwnIdentity = ownIdentities.get(1);
 134                 OwnIdentity thirdOwnIdentity = ownIdentities.get(2);
 135                 assertThat(identities.keySet(), containsInAnyOrder(firstOwnIdentity, secondOwnIdentity, thirdOwnIdentity));
 136                 verifyIdentitiesForOwnIdentity(identities, firstOwnIdentity, createTrustedIdentitiesForFirstOwnIdentity());
 137                 verifyIdentitiesForOwnIdentity(identities, secondOwnIdentity, createTrustedIdentitiesForSecondOwnIdentity());
 138                 verifyIdentitiesForOwnIdentity(identities, thirdOwnIdentity, createTrustedIdentitiesForThirdOwnIdentity());
 139         }
 140
 141         private void verifyIdentitiesForOwnIdentity(Multimap<OwnIdentity, Identity> identities, OwnIdentity ownIdentity, Set<Identity> trustedIdentities) {
 142                 assertThat(identities.get(ownIdentity), Matchers.<Collection<Identity>>is(trustedIdentities));
 143         }
 144
 145 }