X-Git-Url: https://git.pterodactylus.net/?a=blobdiff_plain;f=src%2Ftest%2Fjava%2Fnet%2Fpterodactylus%2Fsone%2Fdatabase%2Fmemory%2FMemoryDatabaseTest.java;h=1d7d471dfbd3ac70264e724c6a0ab32a2a3d090e;hb=cf9ad7f5398f8a15af01d1578d8b8f41b2b72eb0;hp=0753021de74d114e21d837fda3db8c9a3fca072a;hpb=01540cbd527e955dac1e41c2e6855a89ab12605c;p=Sone.git diff --git a/src/test/java/net/pterodactylus/sone/database/memory/MemoryDatabaseTest.java b/src/test/java/net/pterodactylus/sone/database/memory/MemoryDatabaseTest.java index 0753021..1d7d471 100644 --- a/src/test/java/net/pterodactylus/sone/database/memory/MemoryDatabaseTest.java +++ b/src/test/java/net/pterodactylus/sone/database/memory/MemoryDatabaseTest.java @@ -27,27 +27,47 @@ import static net.pterodactylus.sone.Matchers.isPostReply; import static org.hamcrest.CoreMatchers.is; import static org.hamcrest.MatcherAssert.assertThat; import static org.hamcrest.Matchers.contains; +import static org.hamcrest.Matchers.containsInAnyOrder; +import static org.hamcrest.Matchers.empty; +import static org.hamcrest.Matchers.emptyIterable; +import static org.hamcrest.Matchers.hasKey; +import static org.hamcrest.Matchers.not; +import static org.hamcrest.Matchers.nullValue; +import static org.mockito.Matchers.anyString; import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.never; +import static org.mockito.Mockito.verify; import static org.mockito.Mockito.when; +import java.util.Collection; +import java.util.HashMap; import java.util.HashSet; import java.util.List; +import java.util.Map; import java.util.Set; +import net.pterodactylus.sone.Matchers.IncompletePostMatcher; import net.pterodactylus.sone.TestAlbumBuilder; import net.pterodactylus.sone.TestImageBuilder; import net.pterodactylus.sone.TestPostBuilder; import net.pterodactylus.sone.TestPostReplyBuilder; +import net.pterodactylus.sone.TestValue; import net.pterodactylus.sone.data.Album; -import net.pterodactylus.sone.data.AlbumImpl; import net.pterodactylus.sone.data.Image; import net.pterodactylus.sone.data.Post; import net.pterodactylus.sone.data.PostReply; import net.pterodactylus.sone.data.Sone; +import net.pterodactylus.sone.data.impl.AlbumImpl; +import net.pterodactylus.util.config.Configuration; +import net.pterodactylus.util.config.ConfigurationException; +import net.pterodactylus.util.config.Value; import com.google.common.base.Optional; import org.junit.Before; import org.junit.Test; +import org.mockito.Mockito; +import org.mockito.invocation.InvocationOnMock; +import org.mockito.stubbing.Answer; /** * Tests for {@link MemoryDatabase}. @@ -58,8 +78,32 @@ public class MemoryDatabaseTest { private static final String SONE_ID = "sone"; private static final String RECIPIENT_ID = "recipient"; - private final MemoryDatabase memoryDatabase = new MemoryDatabase(null, null); + private final Configuration configuration = mock(Configuration.class); + private final MemoryDatabase memoryDatabase = new MemoryDatabase(null, configuration); private final Sone sone = mock(Sone.class); + private final Map> configurationValues = + new HashMap>(); + + @Before + public void prepareConfigurationValues() { + when(configuration.getStringValue(anyString())).thenAnswer(new Answer>() { + @Override + public Value answer(InvocationOnMock invocation) throws Throwable { + final String key = (String) invocation.getArguments()[0]; + if (!configurationValues.containsKey(key)) { + TestValue value = Mockito.spy(new TestValue(null) { + @Override + public void setValue(String newValue) throws ConfigurationException { + super.setValue(newValue); + configurationValues.put(key, this); + } + }); + configurationValues.put(key, value); + } + return configurationValues.get(key); + } + }); + } @Before public void setupSone() { @@ -198,13 +242,20 @@ public class MemoryDatabaseTest { } @Test + public void storedAndRemovedSoneIsNotAvailable() { + storedSoneIsMadeAvailable(); + memoryDatabase.removeSone(sone); + assertThat(memoryDatabase.getSones(), empty()); + } + + @Test public void postRecipientsAreDetectedCorrectly() { Post postWithRecipient = createPost(of(RECIPIENT_ID)); memoryDatabase.storePost(postWithRecipient); Post postWithoutRecipient = createPost(Optional.absent()); memoryDatabase.storePost(postWithoutRecipient); assertThat(memoryDatabase.getDirectedPosts(RECIPIENT_ID), - contains(postWithRecipient)); + contains(IncompletePostMatcher.matches().recipient(RECIPIENT_ID))); } private Post createPost(Optional recipient) { @@ -253,4 +304,134 @@ public class MemoryDatabaseTest { assertThat(memoryDatabase.getAlbum(newAlbum.getId()), is(Optional.absent())); } + private void initializeFriends() { + when(configuration.getStringValue("Sone/" + SONE_ID + "/Friends/0/ID")).thenReturn( + TestValue.from("Friend1")); + when(configuration.getStringValue("Sone/" + SONE_ID + "/Friends/1/ID")).thenReturn( + TestValue.from("Friend2")); + when(configuration.getStringValue("Sone/" + SONE_ID + "/Friends/2/ID")).thenReturn( + TestValue.from(null)); + } + + @Test + public void friendsAreReturnedCorrectly() { + initializeFriends(); + when(sone.isLocal()).thenReturn(true); + Collection friends = memoryDatabase.getFriends(sone); + assertThat(friends, containsInAnyOrder("Friend1", "Friend2")); + } + + @Test + public void friendsAreOnlyLoadedOnceFromConfiguration() { + friendsAreReturnedCorrectly(); + memoryDatabase.getFriends(sone); + verify(configuration).getStringValue("Sone/" + SONE_ID + "/Friends/0/ID"); + } + + @Test + public void friendsAreOnlyReturnedForLocalSones() { + Collection friends = memoryDatabase.getFriends(sone); + assertThat(friends, emptyIterable()); + verify(configuration, never()).getStringValue("Sone/" + SONE_ID + "/Friends/0/ID"); + } + + @Test + public void checkingForAFriendReturnsTrue() { + initializeFriends(); + when(sone.isLocal()).thenReturn(true); + assertThat(memoryDatabase.isFriend(sone, "Friend1"), is(true)); + } + + @Test + public void checkingForAFriendThatIsNotAFriendReturnsFalse() { + initializeFriends(); + when(sone.isLocal()).thenReturn(true); + assertThat(memoryDatabase.isFriend(sone, "FriendX"), is(false)); + } + + @Test + public void checkingForAFriendOfRemoteSoneReturnsFalse() { + initializeFriends(); + assertThat(memoryDatabase.isFriend(sone, "Friend1"), is(false)); + } + + @Test + public void friendIsAddedCorrectlyToLocalSone() throws ConfigurationException { + when(sone.isLocal()).thenReturn(true); + memoryDatabase.addFriend(sone, "Friend1"); + assertThat(configurationValues.get("Sone/" + SONE_ID + "/Friends/0/ID").getValue(), + is("Friend1")); + assertThat(configurationValues.get("Sone/" + SONE_ID + "/Friends/1/ID").getValue(), + nullValue()); + } + + @Test + public void friendIsNotAddedToRemoteSone() throws ConfigurationException { + memoryDatabase.addFriend(sone, "Friend1"); + verify(configuration.getStringValue("Sone/" + SONE_ID + "/Friends/0/ID"), never()).setValue( + anyString()); + } + + @Test + public void configurationIsWrittenOnceIfFriendIsAddedTwice() throws ConfigurationException { + when(sone.isLocal()).thenReturn(true); + memoryDatabase.addFriend(sone, "Friend1"); + memoryDatabase.addFriend(sone, "Friend1"); + verify(configuration.getStringValue("Sone/" + SONE_ID + "/Friends/0/ID")).setValue( + anyString()); + } + + @Test + public void friendIsRemovedCorrectlyFromLocalSone() throws ConfigurationException { + when(sone.isLocal()).thenReturn(true); + memoryDatabase.addFriend(sone, "Friend1"); + memoryDatabase.removeFriend(sone, "Friend1"); + assertThat(configurationValues.get("Sone/" + SONE_ID + "/Friends/0/ID").getValue(), + nullValue()); + assertThat(configurationValues.get("Sone/" + SONE_ID + "/Friends/1/ID").getValue(), + nullValue()); + } + + @Test + public void configurationIsNotWrittenWhenANonFriendIsRemoved() throws ConfigurationException { + when(sone.isLocal()).thenReturn(true); + memoryDatabase.removeFriend(sone, "Friend1"); + verify(configurationValues.get("Sone/" + SONE_ID + "/Friends/0/ID"), never()).setValue( + anyString()); + } + + @Test + public void newDatabaseKnowsNoSones() { + memoryDatabase.startAndWait(); + assertThat(memoryDatabase.isSoneKnown(sone), is(false)); + assertThat(configurationValues, hasKey("KnownSones/0/ID")); + assertThat(configurationValues, not(hasKey("KnownSones/1/ID"))); + } + + @Test + public void databaseLoadsKnownSonesCorrectly() { + configurationValues.put("KnownSones/0/ID", TestValue.from(SONE_ID)); + memoryDatabase.startAndWait(); + assertThat(memoryDatabase.isSoneKnown(sone), is(true)); + } + + @Test + public void databaseStoresKnownSonesCorrectly() throws ConfigurationException { + memoryDatabase.setSoneKnown(sone); + assertThat(configurationValues, hasKey("KnownSones/0/ID")); + assertThat(configurationValues.get("KnownSones/0/ID").getValue(), is(SONE_ID)); + assertThat(configurationValues, hasKey("KnownSones/1/ID")); + assertThat(configurationValues.get("KnownSones/1/ID").getValue(), nullValue()); + assertThat(configurationValues, not(hasKey("KnownSones/2/ID"))); + } + + @Test + public void stoppingTheDatabaseSavesTheKnownSones() throws ConfigurationException { + configurationValues.put("KnownSones/0/ID", Mockito.spy(TestValue.from(SONE_ID))); + memoryDatabase.startAndWait(); + memoryDatabase.stopAndWait(); + verify(configurationValues.get("KnownSones/0/ID")).setValue(SONE_ID); + verify(configurationValues.get("KnownSones/1/ID")).setValue(null); + } + }