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.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 org.hamcrest.MatcherAssert.assertThat;
  25 import static org.hamcrest.Matchers.containsInAnyOrder;
  26 import static org.hamcrest.Matchers.hasSize;
  27 import static org.mockito.Matchers.anyString;
  28 import static org.mockito.Matchers.eq;
  29 import static org.mockito.Matchers.isNull;
  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.List;
  37 import java.util.Set;
  38
  39 import com.google.common.collect.ImmutableMap;
  40 import com.google.common.collect.Multimap;
  41 import org.hamcrest.Matchers;
  42 import org.junit.Before;
  43 import org.junit.Test;
  44
  45 /**
  46  * Unit test for {@link IdentityLoader}.
  47  *
  48  * @author <a href="mailto:bombe@pterodactylus.net">David ‘Bombe’ Roden</a>
  49  */
  50 public class IdentityLoaderTest {
  51
  52         private final WebOfTrustConnector webOfTrustConnector = mock(WebOfTrustConnector.class);
  53         private final IdentityLoader identityLoader = new IdentityLoader(webOfTrustConnector, of("Test"));
  54         private final IdentityLoader identityLoaderWithoutContext = new IdentityLoader(webOfTrustConnector);
  55
  56         @Before
  57         public void setup() throws WebOfTrustException {
  58                 List<OwnIdentity> ownIdentities = createOwnIdentities();
  59                 when(webOfTrustConnector.loadAllOwnIdentities()).thenReturn(newHashSet(ownIdentities));
  60                 when(webOfTrustConnector.loadTrustedIdentities(eq(ownIdentities.get(0)), anyString())).thenReturn(createTrustedIdentitiesForFirstOwnIdentity());
  61                 when(webOfTrustConnector.loadTrustedIdentities(eq(ownIdentities.get(1)), anyString())).thenReturn(createTrustedIdentitiesForSecondOwnIdentity());
  62                 when(webOfTrustConnector.loadTrustedIdentities(eq(ownIdentities.get(2)), anyString())).thenReturn(createTrustedIdentitiesForThirdOwnIdentity());
  63         }
  64
  65         private List<OwnIdentity> createOwnIdentities() {
  66                 return newArrayList(
  67                                 createOwnIdentity("O1", "ON1", "OR1", "OI1", asList("Test", "Test2"), ImmutableMap.of("KeyA", "ValueA", "KeyB", "ValueB")),
  68                                 createOwnIdentity("O2", "ON2", "OR2", "OI2", asList("Test"), ImmutableMap.of("KeyC", "ValueC")),
  69                                 createOwnIdentity("O3", "ON3", "OR3", "OI3", asList("Test2"), ImmutableMap.of("KeyE", "ValueE", "KeyD", "ValueD"))
  70                 );
  71         }
  72
  73         private Set<Identity> createTrustedIdentitiesForFirstOwnIdentity() {
  74                 return newHashSet(
  75                                 createIdentity("I11", "IN11", "IR11", asList("Test"), ImmutableMap.of("KeyA", "ValueA"))
  76                 );
  77         }
  78
  79         private Set<Identity> createTrustedIdentitiesForSecondOwnIdentity() {
  80                 return newHashSet(
  81                                 createIdentity("I21", "IN21", "IR21", asList("Test", "Test2"), ImmutableMap.of("KeyB", "ValueB"))
  82                 );
  83         }
  84
  85         private Set<Identity> createTrustedIdentitiesForThirdOwnIdentity() {
  86                 return newHashSet(
  87                                 createIdentity("I31", "IN31", "IR31", asList("Test", "Test3"), ImmutableMap.of("KeyC", "ValueC"))
  88                 );
  89         }
  90
  91         private OwnIdentity createOwnIdentity(String id, String nickname, String requestUri, String insertUri, List<String> contexts, ImmutableMap<String, String> properties) {
  92                 OwnIdentity ownIdentity = new DefaultOwnIdentity(id, nickname, requestUri, insertUri);
  93                 ownIdentity.setContexts(contexts);
  94                 ownIdentity.setProperties(properties);
  95                 return ownIdentity;
  96         }
  97
  98         private Identity createIdentity(String id, String nickname, String requestUri, List<String> contexts, ImmutableMap<String, String> properties) {
  99                 Identity identity = new DefaultIdentity(id, nickname, requestUri);
 100                 identity.setContexts(contexts);
 101                 identity.setProperties(properties);
 102                 return identity;
 103         }
 104
 105         @Test
 106         public void loadingIdentities() throws WebOfTrustException {
 107                 List<OwnIdentity> ownIdentities = createOwnIdentities();
 108                 Multimap<OwnIdentity, Identity> identities = identityLoader.loadIdentities();
 109                 verify(webOfTrustConnector).loadAllOwnIdentities();
 110                 verify(webOfTrustConnector).loadTrustedIdentities(eq(ownIdentities.get(0)), eq("Test"));
 111                 verify(webOfTrustConnector).loadTrustedIdentities(eq(ownIdentities.get(1)), eq("Test"));
 112                 verify(webOfTrustConnector, never()).loadTrustedIdentities(eq(ownIdentities.get(2)), anyString());
 113                 assertThat(identities.keySet(), hasSize(2));
 114                 assertThat(identities.keySet(), containsInAnyOrder(ownIdentities.get(0), ownIdentities.get(1)));
 115                 verifyIdentitiesForOwnIdentity(identities, ownIdentities.get(0), createTrustedIdentitiesForFirstOwnIdentity());
 116                 verifyIdentitiesForOwnIdentity(identities, ownIdentities.get(1), createTrustedIdentitiesForSecondOwnIdentity());
 117         }
 118
 119         @Test
 120         public void loadingIdentitiesWithoutContext() throws WebOfTrustException {
 121                 List<OwnIdentity> ownIdentities = createOwnIdentities();
 122                 Multimap<OwnIdentity, Identity> identities = identityLoaderWithoutContext.loadIdentities();
 123                 verify(webOfTrustConnector).loadAllOwnIdentities();
 124                 verify(webOfTrustConnector).loadTrustedIdentities(eq(ownIdentities.get(0)), isNull(String.class));
 125                 verify(webOfTrustConnector).loadTrustedIdentities(eq(ownIdentities.get(1)), isNull(String.class));
 126                 verify(webOfTrustConnector).loadTrustedIdentities(eq(ownIdentities.get(2)), isNull(String.class));
 127                 assertThat(identities.keySet(), hasSize(3));
 128                 OwnIdentity firstOwnIdentity = ownIdentities.get(0);
 129                 OwnIdentity secondOwnIdentity = ownIdentities.get(1);
 130                 OwnIdentity thirdOwnIdentity = ownIdentities.get(2);
 131                 assertThat(identities.keySet(), containsInAnyOrder(firstOwnIdentity, secondOwnIdentity, thirdOwnIdentity));
 132                 verifyIdentitiesForOwnIdentity(identities, firstOwnIdentity, createTrustedIdentitiesForFirstOwnIdentity());
 133                 verifyIdentitiesForOwnIdentity(identities, secondOwnIdentity, createTrustedIdentitiesForSecondOwnIdentity());
 134                 verifyIdentitiesForOwnIdentity(identities, thirdOwnIdentity, createTrustedIdentitiesForThirdOwnIdentity());
 135         }
 136
 137         private void verifyIdentitiesForOwnIdentity(Multimap<OwnIdentity, Identity> identities, OwnIdentity ownIdentity, Set<Identity> trustedIdentities) {
 138                 assertThat(identities.get(ownIdentity), Matchers.<Collection<Identity>>is(trustedIdentities));
 139         }
 140
 141 }