src/test/java/net/pterodactylus/sone/core/SoneRescuerTest.java

   1 package net.pterodactylus.sone.core;
   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.eq;
   7 import static org.mockito.Mockito.doAnswer;
   8 import static org.mockito.Mockito.mock;
   9 import static org.mockito.Mockito.never;
  10 import static org.mockito.Mockito.verify;
  11 import static org.mockito.Mockito.when;
  12
  13 import net.pterodactylus.sone.data.LocalSone;
  14 import net.pterodactylus.sone.data.Sone;
  15
  16 import freenet.keys.FreenetURI;
  17
  18 import org.junit.Before;
  19 import org.junit.Test;
  20 import org.mockito.invocation.InvocationOnMock;
  21 import org.mockito.stubbing.Answer;
  22
  23 /**
  24  * Unit test for {@link SoneRescuer}.
  25  *
  26  * @author <a href="mailto:bombe@pterodactylus.net">David ‘Bombe’ Roden</a>
  27  */
  28 public class SoneRescuerTest {
  29
  30         private static final long CURRENT_EDITION = 12L;
  31         private static final long SOME_OTHER_EDITION = 15L;
  32         private final Core core = mock(Core.class);
  33         private final SoneDownloader soneDownloader = mock(SoneDownloader.class);
  34         private final LocalSone sone = mock(LocalSone.class);
  35         private SoneRescuer soneRescuer;
  36
  37         @Before
  38         public void setupSone() {
  39                 FreenetURI soneUri = mock(FreenetURI.class);
  40                 when(soneUri.getEdition()).thenReturn(CURRENT_EDITION);
  41                 when(sone.getRequestUri()).thenReturn(soneUri);
  42         }
  43
  44         @Before
  45         public void setupSoneRescuer() {
  46                 soneRescuer = new SoneRescuer(core, soneDownloader, sone);
  47         }
  48
  49         @Test
  50         public void newSoneRescuerIsNotFetchingAnything() {
  51                 assertThat(soneRescuer.isFetching(), is(false));
  52         }
  53
  54         @Test
  55         public void newSoneRescuerStartsAtCurrentEditionOfSone() {
  56                 assertThat(soneRescuer.getCurrentEdition(), is(CURRENT_EDITION));
  57         }
  58
  59         @Test
  60         public void newSoneRescuerHasANextEditionToGet() {
  61                 assertThat(soneRescuer.hasNextEdition(), is(true));
  62         }
  63
  64         @Test
  65         public void soneRescuerDoesNotHaveANextEditionIfCurrentEditionIsZero() {
  66                 when(sone.getRequestUri().getEdition()).thenReturn(0L);
  67                 soneRescuer = new SoneRescuer(core, soneDownloader, sone);
  68                 assertThat(soneRescuer.hasNextEdition(), is(false));
  69         }
  70
  71         @Test
  72         public void nextEditionIsOneSmallerThanTheCurrentEdition() {
  73                 assertThat(soneRescuer.getNextEdition(), is(CURRENT_EDITION - 1));
  74         }
  75
  76         @Test
  77         public void currentEditionCanBeSet() {
  78                 soneRescuer.setEdition(SOME_OTHER_EDITION);
  79                 assertThat(soneRescuer.getCurrentEdition(), is(SOME_OTHER_EDITION));
  80         }
  81
  82         @Test
  83         public void lastFetchOfANewSoneRescuerWasSuccessful() {
  84                 assertThat(soneRescuer.isLastFetchSuccessful(), is(true));
  85         }
  86
  87         @Test
  88         public void mainLoopStopsWhenItShould() {
  89                 soneRescuer.stop();
  90                 soneRescuer.serviceRun();
  91         }
  92
  93         @Test
  94         public void successfulInsert() {
  95                 final Sone fetchedSone = mock(Sone.class);
  96                 returnUriOnInsert(fetchedSone);
  97                 soneRescuer.startNextFetch();
  98                 soneRescuer.serviceRun();
  99                 verify(core).lockSone(eq(sone));
 100                 verify(core).updateSone(eq(fetchedSone), eq(true));
 101                 assertThat(soneRescuer.isLastFetchSuccessful(), is(true));
 102                 assertThat(soneRescuer.isFetching(), is(false));
 103         }
 104
 105         @Test
 106         public void nonSuccessfulInsertIsRecognized() {
 107                 returnUriOnInsert(null);
 108                 soneRescuer.startNextFetch();
 109                 soneRescuer.serviceRun();
 110                 verify(core).lockSone(eq(sone));
 111                 verify(core, never()).updateSone(any(Sone.class), eq(true));
 112                 assertThat(soneRescuer.isLastFetchSuccessful(), is(false));
 113                 assertThat(soneRescuer.isFetching(), is(false));
 114         }
 115
 116         private void returnUriOnInsert(final Sone fetchedSone) {
 117                 FreenetURI keyWithMetaStrings = setupFreenetUri();
 118                 doAnswer(new Answer<Sone>() {
 119                         @Override
 120                         public Sone answer(InvocationOnMock invocation) throws Throwable {
 121                                 soneRescuer.stop();
 122                                 return fetchedSone;
 123                         }
 124                 }).when(soneDownloader).fetchSone(eq(sone), eq(keyWithMetaStrings), eq(true));
 125         }
 126
 127         private FreenetURI setupFreenetUri() {
 128                 FreenetURI sskKey = mock(FreenetURI.class);
 129                 FreenetURI keyWithDocName = mock(FreenetURI.class);
 130                 FreenetURI keyWithMetaStrings = mock(FreenetURI.class);
 131                 when(keyWithDocName.setMetaString(eq(new String[] { "sone.xml" }))).thenReturn(keyWithMetaStrings);
 132                 when(sskKey.setDocName(eq("Sone-" + CURRENT_EDITION))).thenReturn(keyWithDocName);
 133                 when(sone.getRequestUri().setKeyType(eq("SSK"))).thenReturn(sskKey);
 134                 return keyWithMetaStrings;
 135         }
 136
 137 }