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