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 import org.mockito.Mockito;
  27
  28 /**
  29  * Unit test for {@link Freenet7Interface}.
  30  *
  31  * @author <a href="mailto:bombe@pterodactylus.net">David ‘Bombe’ Roden</a>
  32  */
  33 public class Freenet7InterfaceTest {
  34
  35         private static final String NODE_ADDRESS = "node-address";
  36         private static final int NODE_PORT = 12345;
  37         private static final String IDENTIFIER = "connection-identifier";
  38         private static final String INSERT_URI = "insert-uri";
  39         private static final String REQUEST_URI = "request-uri";
  40
  41         @Rule
  42         public final ExpectedException expectedException = ExpectedException.none();
  43
  44         private final NodeSupplier nodeSupplier = mock(NodeSupplier.class);
  45         private final ConnectionSupplier connectionSupplier = mock(ConnectionSupplier.class);
  46         private final ClientSupplier clientSupplier = mock(ClientSupplier.class);
  47         private final Freenet7Interface freenet7Interface = new Freenet7Interface(nodeSupplier, connectionSupplier, clientSupplier);
  48
  49         @Test
  50         public void defaultConstructorCanBeCalled() {
  51                 new Freenet7Interface();
  52         }
  53
  54         @Test
  55         public void settingNodeAddressUsesNodeAndConnectionSuppliers() {
  56                 Node node = new Node(NODE_ADDRESS, NODE_PORT);
  57                 freenet7Interface.setNode(node);
  58                 verify(nodeSupplier).supply(NODE_ADDRESS, NODE_PORT);
  59                 verify(connectionSupplier).supply(eq(node), anyString());
  60         }
  61
  62         @Test
  63         public void settingNodeRetainsNodeCorrectly() {
  64                 Node node = new Node(NODE_ADDRESS, NODE_PORT);
  65                 Node realNode = mock(Node.class);
  66                 when(nodeSupplier.supply(NODE_ADDRESS, NODE_PORT)).thenReturn(realNode);
  67                 freenet7Interface.setNode(node);
  68                 assertThat(freenet7Interface.getNode(), is(realNode));
  69         }
  70
  71         @Test
  72         public void newConnectionCanBeCreated() {
  73                 Connection connection = mock(Connection.class);
  74                 when(connectionSupplier.supply(any(Node.class), eq(IDENTIFIER))).thenReturn(connection);
  75                 Connection returnedConnection = freenet7Interface.getConnection(IDENTIFIER);
  76                 assertThat(returnedConnection, is(connection));
  77         }
  78
  79         @Test
  80         public void interfaceHasNoNodeBeforeNodeIsSet() {
  81                 assertThat(freenet7Interface.hasNode(), is(false));
  82         }
  83
  84         @Test
  85         public void interfaceHasNodeOnceANodeWasSet() {
  86                 Connection connection = mock(Connection.class);
  87                 when(nodeSupplier.supply(anyString(), anyInt())).thenReturn(mock(Node.class));
  88                 when(connectionSupplier.supply(any(Node.class), anyString())).thenReturn(connection);
  89                 freenet7Interface.setNode(mock(Node.class));
  90                 assertThat(freenet7Interface.hasNode(), is(true));
  91         }
  92
  93         @Test
  94         public void interfaceHasNoNodeIfNodeIsSetToNull() {
  95                 Connection connection = mock(Connection.class);
  96                 when(nodeSupplier.supply(anyString(), anyInt())).thenReturn(mock(Node.class));
  97                 when(connectionSupplier.supply(any(Node.class), anyString())).thenReturn(connection);
  98                 freenet7Interface.setNode(mock(Node.class));
  99                 freenet7Interface.setNode(null);
 100                 assertThat(freenet7Interface.hasNode(), is(false));
 101         }
 102
 103
 104         @Test
 105         public void nodeIsPresentIfConnectionIsConnected() throws IOException {
 106                 Connection connection = mock(Connection.class);
 107                 when(connection.isConnected()).thenReturn(true);
 108                 when(connectionSupplier.supply(any(Node.class), anyString())).thenReturn(connection);
 109                 freenet7Interface.setNode(mock(Node.class));
 110                 assertThat(freenet7Interface.isNodePresent(), is(true));
 111         }
 112
 113         @Test
 114         public void nodeIsPresentIfConnectionCanBeCreated() throws IOException {
 115                 Connection connection = mock(Connection.class);
 116                 when(connection.connect()).thenReturn(true);
 117                 when(connectionSupplier.supply(any(Node.class), anyString())).thenReturn(connection);
 118                 freenet7Interface.setNode(mock(Node.class));
 119                 assertThat(freenet7Interface.isNodePresent(), is(true));
 120         }
 121
 122         @Test
 123         public void exceptionIsThrownIfNodeIsNotPresentAndConnectionCanNotBeCreated() throws IOException {
 124                 Connection connection = mock(Connection.class);
 125                 doThrow(IOException.class).when(connection).connect();
 126                 when(connectionSupplier.supply(any(Node.class), anyString())).thenReturn(connection);
 127                 freenet7Interface.setNode(mock(Node.class));
 128                 expectedException.expect(IOException.class);
 129                 freenet7Interface.isNodePresent();
 130         }
 131
 132         @Test
 133         public void keyPairIsNotGeneratedIfNodeIsNotPresent() throws IOException {
 134                 Connection connection = mock(Connection.class);
 135                 when(connectionSupplier.supply(any(Node.class), anyString())).thenReturn(connection);
 136                 freenet7Interface.setNode(mock(Node.class));
 137                 expectedException.expect(IOException.class);
 138                 freenet7Interface.generateKeyPair();
 139         }
 140
 141         @Test
 142         public void keyPairIsGeneratedSuccessfully() throws IOException {
 143                 Connection connection = mock(Connection.class);
 144                 when(connection.isConnected()).thenReturn(true);
 145                 when(connectionSupplier.supply(any(Node.class), anyString())).thenReturn(connection);
 146                 freenet7Interface.setNode(mock(Node.class));
 147                 Message message = new Message("SSKKeyPair");
 148                 message.put("InsertURI", INSERT_URI);
 149                 message.put("RequestURI", REQUEST_URI);
 150                 Client client = mock(Client.class);
 151                 when(client.readMessage()).thenReturn(message);
 152                 when(clientSupplier.supply(eq(connection), Mockito.any(GenerateSSK.class))).thenReturn(client);
 153                 String[] keyPair = freenet7Interface.generateKeyPair();
 154                 assertThat(keyPair[0], is(INSERT_URI));
 155                 assertThat(keyPair[1], is(REQUEST_URI));
 156         }
 157
 158 }