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

   1 /*
   2  * Sone - IdentityLoaderTest.java - Copyright © 2013–2019 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 public class IdentityLoaderTest {
  52
  53         private final WebOfTrustConnector webOfTrustConnector = mock(WebOfTrustConnector.class);
  54         private final IdentityLoader identityLoader = new IdentityLoader(webOfTrustConnector, of(new Context("Test")));
  55         private final IdentityLoader identityLoaderWithoutContext = new IdentityLoader(webOfTrustConnector);
  56
  57         @Before
  58         public void setup() throws WebOfTrustException {
  59                 List<OwnIdentity> ownIdentities = createOwnIdentities();
  60                 when(webOfTrustConnector.loadAllOwnIdentities()).thenReturn(newHashSet(ownIdentities));
  61                 when(webOfTrustConnector.loadTrustedIdentities(eq(ownIdentities.get(0)), any(Optional.class))).thenReturn(createTrustedIdentitiesForFirstOwnIdentity());
  62                 when(webOfTrustConnector.loadTrustedIdentities(eq(ownIdentities.get(1)), any(Optional.class))).thenReturn(createTrustedIdentitiesForSecondOwnIdentity());
  63                 when(webOfTrustConnector.loadTrustedIdentities(eq(ownIdentities.get(2)), any(Optional.class))).thenReturn(createTrustedIdentitiesForThirdOwnIdentity());
  64                 when(webOfTrustConnector.loadTrustedIdentities(eq(ownIdentities.get(3)), any(Optional.class))).thenReturn(createTrustedIdentitiesForFourthOwnIdentity());
  65         }
  66
  67         private List<OwnIdentity> createOwnIdentities() {
  68                 return newArrayList(
  69                                 createOwnIdentity("O1", "ON1", "OR1", "OI1", asList("Test", "Test2"), ImmutableMap.of("KeyA", "ValueA", "KeyB", "ValueB")),
  70                                 createOwnIdentity("O2", "ON2", "OR2", "OI2", asList("Test"), ImmutableMap.of("KeyC", "ValueC")),
  71                                 createOwnIdentity("O3", "ON3", "OR3", "OI3", asList("Test2"), ImmutableMap.of("KeyE", "ValueE", "KeyD", "ValueD")),
  72                                 createOwnIdentity("O4", "ON4", "OR$", "OI4", asList("Test"), ImmutableMap.of("KeyA", "ValueA", "KeyD", "ValueD"))
  73                 );
  74         }
  75
  76         private Set<Identity> createTrustedIdentitiesForFirstOwnIdentity() {
  77                 return newHashSet(
  78                                 createIdentity("I11", "IN11", "IR11", asList("Test"), ImmutableMap.of("KeyA", "ValueA"))
  79                 );
  80         }
  81
  82         private Set<Identity> createTrustedIdentitiesForSecondOwnIdentity() {
  83                 return newHashSet(
  84                                 createIdentity("I21", "IN21", "IR21", asList("Test", "Test2"), ImmutableMap.of("KeyB", "ValueB"))
  85                 );
  86         }
  87
  88         private Set<Identity> createTrustedIdentitiesForThirdOwnIdentity() {
  89                 return newHashSet(
  90                                 createIdentity("I31", "IN31", "IR31", asList("Test", "Test3"), ImmutableMap.of("KeyC", "ValueC"))
  91                 );
  92         }
  93
  94         private Set<Identity> createTrustedIdentitiesForFourthOwnIdentity() {
  95                 return emptySet();
  96         }
  97
  98         private OwnIdentity createOwnIdentity(String id, String nickname, String requestUri, String insertUri, List<String> contexts, ImmutableMap<String, String> properties) {
  99                 OwnIdentity ownIdentity = new DefaultOwnIdentity(id, nickname, requestUri, insertUri);
 100                 ownIdentity.setContexts(contexts);
 101                 ownIdentity.setProperties(properties);
 102                 return ownIdentity;
 103         }
 104
 105         private Identity createIdentity(String id, String nickname, String requestUri, List<String> contexts, ImmutableMap<String, String> properties) {
 106                 Identity identity = new DefaultIdentity(id, nickname, requestUri);
 107                 identity.setContexts(contexts);
 108                 identity.setProperties(properties);
 109                 return identity;
 110         }
 111
 112         @Test
 113         public void loadingIdentities() throws WebOfTrustException {
 114                 List<OwnIdentity> ownIdentities = createOwnIdentities();
 115                 Map<OwnIdentity, Collection<Identity>> identities = identityLoader.loadIdentities();
 116                 verify(webOfTrustConnector).loadAllOwnIdentities();
 117                 verify(webOfTrustConnector).loadTrustedIdentities(eq(ownIdentities.get(0)), eq(of("Test")));
 118                 verify(webOfTrustConnector).loadTrustedIdentities(eq(ownIdentities.get(1)), eq(of("Test")));
 119                 verify(webOfTrustConnector, never()).loadTrustedIdentities(eq(ownIdentities.get(2)), any(Optional.class));
 120                 verify(webOfTrustConnector).loadTrustedIdentities(eq(ownIdentities.get(3)), eq(of("Test")));
 121                 assertThat(identities.keySet(), hasSize(4));
 122                 assertThat(identities.keySet(), containsInAnyOrder(ownIdentities.get(0), ownIdentities.get(1), ownIdentities.get(2), ownIdentities.get(3)));
 123                 verifyIdentitiesForOwnIdentity(identities, ownIdentities.get(0), createTrustedIdentitiesForFirstOwnIdentity());
 124                 verifyIdentitiesForOwnIdentity(identities, ownIdentities.get(1), createTrustedIdentitiesForSecondOwnIdentity());
 125                 verifyIdentitiesForOwnIdentity(identities, ownIdentities.get(2), Collections.<Identity>emptySet());
 126                 verifyIdentitiesForOwnIdentity(identities, ownIdentities.get(3), createTrustedIdentitiesForFourthOwnIdentity());
 127         }
 128
 129         @Test
 130         public void loadingIdentitiesWithoutContext() throws WebOfTrustException {
 131                 List<OwnIdentity> ownIdentities = createOwnIdentities();
 132                 Map<OwnIdentity, Collection<Identity>> identities = identityLoaderWithoutContext.loadIdentities();
 133                 verify(webOfTrustConnector).loadAllOwnIdentities();
 134                 verify(webOfTrustConnector).loadTrustedIdentities(eq(ownIdentities.get(0)), eq(Optional.<String>absent()));
 135                 verify(webOfTrustConnector).loadTrustedIdentities(eq(ownIdentities.get(1)), eq(Optional.<String>absent()));
 136                 verify(webOfTrustConnector).loadTrustedIdentities(eq(ownIdentities.get(2)), eq(Optional.<String>absent()));
 137                 verify(webOfTrustConnector).loadTrustedIdentities(eq(ownIdentities.get(3)), eq(Optional.<String>absent()));
 138                 assertThat(identities.keySet(), hasSize(4));
 139                 OwnIdentity firstOwnIdentity = ownIdentities.get(0);
 140                 OwnIdentity secondOwnIdentity = ownIdentities.get(1);
 141                 OwnIdentity thirdOwnIdentity = ownIdentities.get(2);
 142                 OwnIdentity fourthOwnIdentity = ownIdentities.get(3);
 143                 assertThat(identities.keySet(), containsInAnyOrder(firstOwnIdentity, secondOwnIdentity, thirdOwnIdentity, fourthOwnIdentity));
 144                 verifyIdentitiesForOwnIdentity(identities, firstOwnIdentity, createTrustedIdentitiesForFirstOwnIdentity());
 145                 verifyIdentitiesForOwnIdentity(identities, secondOwnIdentity, createTrustedIdentitiesForSecondOwnIdentity());
 146                 verifyIdentitiesForOwnIdentity(identities, thirdOwnIdentity, createTrustedIdentitiesForThirdOwnIdentity());
 147                 verifyIdentitiesForOwnIdentity(identities, fourthOwnIdentity, createTrustedIdentitiesForFourthOwnIdentity());
 148         }
 149
 150         private void verifyIdentitiesForOwnIdentity(Map<OwnIdentity, Collection<Identity>> identities, OwnIdentity ownIdentity, Set<Identity> trustedIdentities) {
 151                 assertThat(identities.get(ownIdentity), Matchers.<Collection<Identity>>is(trustedIdentities));
 152         }
 153
 154 }