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

   1 /*
   2  * Sone - IdentityLoaderTest.java - Copyright © 2013–2016 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 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.hamcrest.Matchers.is;
  29 import static org.mockito.ArgumentMatchers.any;
  30 import static org.mockito.ArgumentMatchers.eq;
  31 import static org.mockito.Mockito.mock;
  32 import static org.mockito.Mockito.never;
  33 import static org.mockito.Mockito.verify;
  34 import static org.mockito.Mockito.when;
  35
  36 import java.util.Collection;
  37 import java.util.Collections;
  38 import java.util.List;
  39 import java.util.Map;
  40 import java.util.Set;
  41
  42 import com.google.common.base.Optional;
  43 import com.google.common.collect.ImmutableMap;
  44 import org.hamcrest.Matchers;
  45 import org.junit.Before;
  46 import org.junit.Test;
  47
  48 /**
  49  * Unit test for {@link IdentityLoader}.
  50  *
  51  * @author <a href="mailto:bombe@pterodactylus.net">David ‘Bombe’ Roden</a>
  52  */
  53 public class IdentityLoaderTest {
  54
  55         private final WebOfTrustConnector webOfTrustConnector = mock(WebOfTrustConnector.class);
  56         private final IdentityLoader identityLoader = new IdentityLoader(webOfTrustConnector, of(new Context("Test")));
  57         private final IdentityLoader identityLoaderWithoutContext = new IdentityLoader(webOfTrustConnector);
  58
  59         @Before
  60         public void setup() throws WebOfTrustException {
  61                 List<OwnIdentity> ownIdentities = createOwnIdentities();
  62                 when(webOfTrustConnector.loadAllOwnIdentities()).thenReturn(newHashSet(ownIdentities));
  63                 when(webOfTrustConnector.loadTrustedIdentities(eq(ownIdentities.get(0)), any(Optional.class))).thenReturn(createTrustedIdentitiesForFirstOwnIdentity());
  64                 when(webOfTrustConnector.loadTrustedIdentities(eq(ownIdentities.get(1)), any(Optional.class))).thenReturn(createTrustedIdentitiesForSecondOwnIdentity());
  65                 when(webOfTrustConnector.loadTrustedIdentities(eq(ownIdentities.get(2)), any(Optional.class))).thenReturn(createTrustedIdentitiesForThirdOwnIdentity());
  66                 when(webOfTrustConnector.loadTrustedIdentities(eq(ownIdentities.get(3)), any(Optional.class))).thenReturn(createTrustedIdentitiesForFourthOwnIdentity());
  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                                 createOwnIdentity("O4", "ON4", "OR$", "OI4", asList("Test"), ImmutableMap.of("KeyA", "ValueA", "KeyD", "ValueD"))
  75                 );
  76         }
  77
  78         private Set<Identity> createTrustedIdentitiesForFirstOwnIdentity() {
  79                 return newHashSet(
  80                                 createIdentity("I11", "IN11", "IR11", asList("Test"), ImmutableMap.of("KeyA", "ValueA"))
  81                 );
  82         }
  83
  84         private Set<Identity> createTrustedIdentitiesForSecondOwnIdentity() {
  85                 return newHashSet(
  86                                 createIdentity("I21", "IN21", "IR21", asList("Test", "Test2"), ImmutableMap.of("KeyB", "ValueB"))
  87                 );
  88         }
  89
  90         private Set<Identity> createTrustedIdentitiesForThirdOwnIdentity() {
  91                 return newHashSet(
  92                                 createIdentity("I31", "IN31", "IR31", asList("Test", "Test3"), ImmutableMap.of("KeyC", "ValueC"))
  93                 );
  94         }
  95
  96         private Set<Identity> createTrustedIdentitiesForFourthOwnIdentity() {
  97                 return emptySet();
  98         }
  99
 100         private OwnIdentity createOwnIdentity(String id, String nickname, String requestUri, String insertUri, List<String> contexts, ImmutableMap<String, String> properties) {
 101                 OwnIdentity ownIdentity = new DefaultOwnIdentity(id, nickname, requestUri, insertUri);
 102                 ownIdentity.setContexts(contexts);
 103                 ownIdentity.setProperties(properties);
 104                 return ownIdentity;
 105         }
 106
 107         private Identity createIdentity(String id, String nickname, String requestUri, List<String> contexts, ImmutableMap<String, String> properties) {
 108                 Identity identity = new DefaultIdentity(id, nickname, requestUri);
 109                 identity.setContexts(contexts);
 110                 identity.setProperties(properties);
 111                 return identity;
 112         }
 113
 114         @Test
 115         public void loadingIdentities() throws WebOfTrustException {
 116                 List<OwnIdentity> ownIdentities = createOwnIdentities();
 117                 Map<OwnIdentity, Collection<Identity>> identities = identityLoader.loadIdentities();
 118                 verify(webOfTrustConnector).loadAllOwnIdentities();
 119                 verify(webOfTrustConnector).loadTrustedIdentities(eq(ownIdentities.get(0)), eq(of("Test")));
 120                 verify(webOfTrustConnector).loadTrustedIdentities(eq(ownIdentities.get(1)), eq(of("Test")));
 121                 verify(webOfTrustConnector, never()).loadTrustedIdentities(eq(ownIdentities.get(2)), any(Optional.class));
 122                 verify(webOfTrustConnector).loadTrustedIdentities(eq(ownIdentities.get(3)), eq(of("Test")));
 123                 assertThat(identities.keySet(), hasSize(4));
 124                 assertThat(identities.keySet(), containsInAnyOrder(ownIdentities.get(0), ownIdentities.get(1), ownIdentities.get(2), ownIdentities.get(3)));
 125                 verifyIdentitiesForOwnIdentity(identities, ownIdentities.get(0), createTrustedIdentitiesForFirstOwnIdentity());
 126                 verifyIdentitiesForOwnIdentity(identities, ownIdentities.get(1), createTrustedIdentitiesForSecondOwnIdentity());
 127                 verifyIdentitiesForOwnIdentity(identities, ownIdentities.get(2), Collections.<Identity>emptySet());
 128                 verifyIdentitiesForOwnIdentity(identities, ownIdentities.get(3), createTrustedIdentitiesForFourthOwnIdentity());
 129         }
 130
 131         @Test
 132         public void loadingIdentitiesWithoutContext() throws WebOfTrustException {
 133                 List<OwnIdentity> ownIdentities = createOwnIdentities();
 134                 Map<OwnIdentity, Collection<Identity>> identities = identityLoaderWithoutContext.loadIdentities();
 135                 verify(webOfTrustConnector).loadAllOwnIdentities();
 136                 verify(webOfTrustConnector).loadTrustedIdentities(eq(ownIdentities.get(0)), eq(Optional.<String>absent()));
 137                 verify(webOfTrustConnector).loadTrustedIdentities(eq(ownIdentities.get(1)), eq(Optional.<String>absent()));
 138                 verify(webOfTrustConnector).loadTrustedIdentities(eq(ownIdentities.get(2)), eq(Optional.<String>absent()));
 139                 verify(webOfTrustConnector).loadTrustedIdentities(eq(ownIdentities.get(3)), eq(Optional.<String>absent()));
 140                 assertThat(identities.keySet(), hasSize(4));
 141                 OwnIdentity firstOwnIdentity = ownIdentities.get(0);
 142                 OwnIdentity secondOwnIdentity = ownIdentities.get(1);
 143                 OwnIdentity thirdOwnIdentity = ownIdentities.get(2);
 144                 OwnIdentity fourthOwnIdentity = ownIdentities.get(3);
 145                 assertThat(identities.keySet(), containsInAnyOrder(firstOwnIdentity, secondOwnIdentity, thirdOwnIdentity, fourthOwnIdentity));
 146                 verifyIdentitiesForOwnIdentity(identities, firstOwnIdentity, createTrustedIdentitiesForFirstOwnIdentity());
 147                 verifyIdentitiesForOwnIdentity(identities, secondOwnIdentity, createTrustedIdentitiesForSecondOwnIdentity());
 148                 verifyIdentitiesForOwnIdentity(identities, thirdOwnIdentity, createTrustedIdentitiesForThirdOwnIdentity());
 149                 verifyIdentitiesForOwnIdentity(identities, fourthOwnIdentity, createTrustedIdentitiesForFourthOwnIdentity());
 150         }
 151
 152         private void verifyIdentitiesForOwnIdentity(Map<OwnIdentity, Collection<Identity>> identities, OwnIdentity ownIdentity, Set<Identity> trustedIdentities) {
 153                 assertThat(identities.get(ownIdentity), Matchers.<Collection<Identity>>is(trustedIdentities));
 154         }
 155
 156 }