src/test/java/de/todesbaum/jsite/application/Freenet7InterfaceTest.java

   1 package de.todesbaum.jsite.application;
   2
   3 import static org.hamcrest.MatcherAssert.assertThat;
   4 import static org.hamcrest.Matchers.is;
   5 import static org.mockito.Matchers.any;
   6 import static org.mockito.Matchers.anyInt;
   7 import static org.mockito.Matchers.anyString;
   8 import static org.mockito.Matchers.eq;
   9 import static org.mockito.Mockito.doThrow;
  10 import static org.mockito.Mockito.mock;
  11 import static org.mockito.Mockito.verify;
  12 import static org.mockito.Mockito.when;
  13
  14 import java.io.IOException;
  15
  16 import de.todesbaum.jsite.application.Freenet7Interface.ClientSupplier;
  17 import de.todesbaum.jsite.application.Freenet7Interface.ConnectionSupplier;
  18 import de.todesbaum.jsite.application.Freenet7Interface.NodeSupplier;
  19 import de.todesbaum.util.freenet.fcp2.Client;
  20 import de.todesbaum.util.freenet.fcp2.Connection;
  21 import de.todesbaum.util.freenet.fcp2.GenerateSSK;
  22 import de.todesbaum.util.freenet.fcp2.Message;
  23 import org.junit.Rule;
  24 import org.junit.Test;
  25 import org.junit.rules.ExpectedException;
  26
  27 /**
  28  * Unit test for {@link Freenet7Interface}.
  29  *
  30  * @author <a href="mailto:bombe@pterodactylus.net">David ‘Bombe’ Roden</a>
  31  */
  32 public class Freenet7InterfaceTest {
  33
  34         private static final String NODE_ADDRESS = "node-address";
  35         private static final int NODE_PORT = 12345;
  36         private static final String IDENTIFIER = "connection-identifier";
  37         private static final String INSERT_URI = "insert-uri";
  38         private static final String REQUEST_URI = "request-uri";
  39
  40         @Rule
  41         public final ExpectedException expectedException = ExpectedException.none();
  42
  43         private final NodeSupplier nodeSupplier = mock(NodeSupplier.class);
  44         private final ConnectionSupplier connectionSupplier = mock(ConnectionSupplier.class);
  45         private final ClientSupplier clientSupplier = mock(ClientSupplier.class);
  46         private final Freenet7Interface freenet7Interface = new Freenet7Interface(nodeSupplier, connectionSupplier, clientSupplier);
  47
  48         @Test
  49         public void defaultConstructorCanBeCalled() {
  50                 new Freenet7Interface();
  51         }
  52
  53         @Test
  54         public void defaultConstructorCreatesDefaultNode() {
  55             Freenet7Interface freenet7Interface = new Freenet7Interface();
  56                 freenet7Interface.setNode(new Node("foo", 12345));
  57                 de.todesbaum.util.freenet.fcp2.Node node = freenet7Interface.getNode();
  58                 assertThat(node.getHostname(), is("foo"));
  59                 assertThat(node.getPort(), is(12345));
  60         }
  61
  62         @Test
  63         public void withoutSettingANodeThereIsNoNode() {
  64             assertThat(freenet7Interface.hasNode(), is(false));
  65         }
  66
  67         @Test
  68         public void afterSettingANodeThereIsANode() {
  69                 when(nodeSupplier.supply(anyString(), anyInt())).thenReturn(mock(de.todesbaum.util.freenet.fcp2.Node.class));
  70                 when(connectionSupplier.supply(any(de.todesbaum.util.freenet.fcp2.Node.class), anyString())).thenReturn(mock(Connection.class));
  71             freenet7Interface.setNode(new Node("foo", 12345));
  72             assertThat(freenet7Interface.hasNode(), is(true));
  73         }
  74
  75         @Test
  76         public void withoutConnectionThereIsNoNode() {
  77                 when(nodeSupplier.supply(anyString(), anyInt())).thenReturn(mock(de.todesbaum.util.freenet.fcp2.Node.class));
  78             freenet7Interface.setNode(new Node("foo", 12345));
  79             assertThat(freenet7Interface.hasNode(), is(false));
  80         }
  81
  82         @Test
  83         public void defaultConstructorCreatesDefaultConnection() {
  84                 Freenet7Interface freenet7Interface = new Freenet7Interface();
  85                 Connection connection = freenet7Interface.getConnection("foo");
  86                 assertThat(connection.getName(), is("foo"));
  87         }
  88
  89         @Test
  90         public void settingNodeAddressUsesNodeAndConnectionSuppliers() {
  91                 Node node = new Node(NODE_ADDRESS, NODE_PORT);
  92                 freenet7Interface.setNode(node);
  93                 verify(nodeSupplier).supply(NODE_ADDRESS, NODE_PORT);
  94                 verify(connectionSupplier).supply(eq(node), anyString());
  95         }
  96
  97         @Test
  98         public void settingNodeRetainsNodeCorrectly() {
  99                 Node node = new Node(NODE_ADDRESS, NODE_PORT);
 100                 Node realNode = mock(Node.class);
 101                 when(nodeSupplier.supply(NODE_ADDRESS, NODE_PORT)).thenReturn(realNode);
 102                 freenet7Interface.setNode(node);
 103                 assertThat(freenet7Interface.getNode(), is(realNode));
 104         }
 105
 106         @Test
 107         public void newConnectionCanBeCreated() {
 108                 Connection connection = mock(Connection.class);
 109                 when(connectionSupplier.supply(any(Node.class), eq(IDENTIFIER))).thenReturn(connection);
 110                 Connection returnedConnection = freenet7Interface.getConnection(IDENTIFIER);
 111                 assertThat(returnedConnection, is(connection));
 112         }
 113
 114         @Test
 115         public void interfaceHasNoNodeBeforeNodeIsSet() {
 116                 assertThat(freenet7Interface.hasNode(), is(false));
 117         }
 118
 119         @Test
 120         public void interfaceHasNodeOnceANodeWasSet() {
 121                 Connection connection = mock(Connection.class);
 122                 when(nodeSupplier.supply(anyString(), anyInt())).thenReturn(mock(Node.class));
 123                 when(connectionSupplier.supply(any(Node.class), anyString())).thenReturn(connection);
 124                 freenet7Interface.setNode(mock(Node.class));
 125                 assertThat(freenet7Interface.hasNode(), is(true));
 126         }
 127
 128         @Test
 129         public void interfaceHasNoNodeIfNodeIsSetToNull() {
 130                 Connection connection = mock(Connection.class);
 131                 when(nodeSupplier.supply(anyString(), anyInt())).thenReturn(mock(Node.class));
 132                 when(connectionSupplier.supply(any(Node.class), anyString())).thenReturn(connection);
 133                 freenet7Interface.setNode(mock(Node.class));
 134                 freenet7Interface.setNode(null);
 135                 assertThat(freenet7Interface.hasNode(), is(false));
 136         }
 137
 138
 139         @Test
 140         public void nodeIsPresentIfConnectionIsConnected() throws IOException {
 141                 Connection connection = mock(Connection.class);
 142                 when(connection.isConnected()).thenReturn(true);
 143                 when(connectionSupplier.supply(any(Node.class), anyString())).thenReturn(connection);
 144                 freenet7Interface.setNode(mock(Node.class));
 145                 assertThat(freenet7Interface.isNodePresent(), is(true));
 146         }
 147
 148         @Test
 149         public void nodeIsPresentIfConnectionCanBeCreated() throws IOException {
 150                 Connection connection = mock(Connection.class);
 151                 when(connection.connect()).thenReturn(true);
 152                 when(connectionSupplier.supply(any(Node.class), anyString())).thenReturn(connection);
 153                 freenet7Interface.setNode(mock(Node.class));
 154                 assertThat(freenet7Interface.isNodePresent(), is(true));
 155         }
 156
 157         @Test
 158         public void exceptionIsThrownIfNodeIsNotPresentAndConnectionCanNotBeCreated() throws IOException {
 159                 Connection connection = mock(Connection.class);
 160                 doThrow(IOException.class).when(connection).connect();
 161                 when(connectionSupplier.supply(any(Node.class), anyString())).thenReturn(connection);
 162                 freenet7Interface.setNode(mock(Node.class));
 163                 expectedException.expect(IOException.class);
 164                 freenet7Interface.isNodePresent();
 165         }
 166
 167         @Test
 168         public void keyPairIsNotGeneratedIfNodeIsNotPresent() throws IOException {
 169                 Connection connection = mock(Connection.class);
 170                 when(connectionSupplier.supply(any(Node.class), anyString())).thenReturn(connection);
 171                 freenet7Interface.setNode(mock(Node.class));
 172                 expectedException.expect(IOException.class);
 173                 freenet7Interface.generateKeyPair();
 174         }
 175
 176         @Test
 177         public void keyPairIsGeneratedSuccessfully() throws IOException {
 178                 Connection connection = mock(Connection.class);
 179                 when(connection.isConnected()).thenReturn(true);
 180                 when(connectionSupplier.supply(any(Node.class), anyString())).thenReturn(connection);
 181                 freenet7Interface.setNode(mock(Node.class));
 182                 Message message = new Message("SSKKeyPair");
 183                 message.put("InsertURI", INSERT_URI);
 184                 message.put("RequestURI", REQUEST_URI);
 185                 Client client = mock(Client.class);
 186                 when(client.readMessage()).thenReturn(message);
 187                 when(clientSupplier.supply(eq(connection), any(GenerateSSK.class))).thenReturn(client);
 188                 String[] keyPair = freenet7Interface.generateKeyPair();
 189                 assertThat(keyPair[0], is(INSERT_URI));
 190                 assertThat(keyPair[1], is(REQUEST_URI));
 191         }
 192
 193 }