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