X-Git-Url: https://git.pterodactylus.net/?p=Sone.git;a=blobdiff_plain;f=src%2Ftest%2Fjava%2Fnet%2Fpterodactylus%2Fsone%2Fdatabase%2Fmemory%2FMemoryDatabaseTest.java;fp=src%2Ftest%2Fjava%2Fnet%2Fpterodactylus%2Fsone%2Fdatabase%2Fmemory%2FMemoryDatabaseTest.java;h=8da6498c48484132452db175cccff57b63695cf2;hp=1d7d471dfbd3ac70264e724c6a0ab32a2a3d090e;hb=722b47810ffbe01465f104791c9f660ae161023b;hpb=0aa389b2493e19484530698e2ce056372dc2a1e9 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 1d7d471..8da6498 100644 --- a/src/test/java/net/pterodactylus/sone/database/memory/MemoryDatabaseTest.java +++ b/src/test/java/net/pterodactylus/sone/database/memory/MemoryDatabaseTest.java @@ -29,7 +29,6 @@ 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; @@ -54,6 +53,7 @@ import net.pterodactylus.sone.TestPostReplyBuilder; import net.pterodactylus.sone.TestValue; import net.pterodactylus.sone.data.Album; import net.pterodactylus.sone.data.Image; +import net.pterodactylus.sone.data.LocalSone; import net.pterodactylus.sone.data.Post; import net.pterodactylus.sone.data.PostReply; import net.pterodactylus.sone.data.Sone; @@ -81,8 +81,9 @@ public class MemoryDatabaseTest { 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>(); + private final LocalSone localSone = mock(LocalSone.class); + private final Map> stringValues = new HashMap>(); + private final Map> longValues = new HashMap>(); @Before public void prepareConfigurationValues() { @@ -90,24 +91,43 @@ public class MemoryDatabaseTest { @Override public Value answer(InvocationOnMock invocation) throws Throwable { final String key = (String) invocation.getArguments()[0]; - if (!configurationValues.containsKey(key)) { + if (!stringValues.containsKey(key)) { TestValue value = Mockito.spy(new TestValue(null) { @Override public void setValue(String newValue) throws ConfigurationException { super.setValue(newValue); - configurationValues.put(key, this); + stringValues.put(key, this); } }); - configurationValues.put(key, value); + stringValues.put(key, value); } - return configurationValues.get(key); + return stringValues.get(key); + } + }); + when(configuration.getLongValue(anyString())).thenAnswer(new Answer>() { + @Override + public Value answer(InvocationOnMock invocation) throws Throwable { + final String key = (String) invocation.getArguments()[0]; + if (!longValues.containsKey(key)) { + TestValue value = Mockito.spy(new TestValue(null) { + @Override + public void setValue(Long newValue) throws ConfigurationException { + super.setValue(newValue); + longValues.put(key, this); + } + }); + longValues.put(key, value); + } + return longValues.get(key); } }); } @Before - public void setupSone() { + public void setupSones() { when(sone.getId()).thenReturn(SONE_ID); + when(localSone.getId()).thenReturn(SONE_ID); + when(localSone.isLocal()).thenReturn(true); } @Test @@ -305,78 +325,57 @@ public class MemoryDatabaseTest { } 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)); + stringValues.put("Sone/" + SONE_ID + "/Friends/0/ID", + Mockito.spy(TestValue.from("Friend1"))); + stringValues.put("Sone/" + SONE_ID + "/Friends/1/ID", + Mockito.spy(TestValue.from("Friend2"))); + stringValues.put("Sone/" + SONE_ID + "/Friends/2/ID", + Mockito.spy(TestValue.from(null))); } @Test public void friendsAreReturnedCorrectly() { initializeFriends(); - when(sone.isLocal()).thenReturn(true); - Collection friends = memoryDatabase.getFriends(sone); + Collection friends = memoryDatabase.getFriends(localSone); assertThat(friends, containsInAnyOrder("Friend1", "Friend2")); } @Test public void friendsAreOnlyLoadedOnceFromConfiguration() { friendsAreReturnedCorrectly(); - memoryDatabase.getFriends(sone); + memoryDatabase.getFriends(localSone); 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)); + assertThat(memoryDatabase.isFriend(localSone, "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)); + assertThat(memoryDatabase.isFriend(localSone, "FriendX"), 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(), + memoryDatabase.addFriend(localSone, "Friend1"); + assertThat(stringValues.get("Sone/" + SONE_ID + "/Friends/0/ID").getValue(), is("Friend1")); - assertThat(configurationValues.get("Sone/" + SONE_ID + "/Friends/1/ID").getValue(), + assertThat(stringValues.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"); + memoryDatabase.addFriend(localSone, "Friend1"); + memoryDatabase.addFriend(localSone, "Friend1"); verify(configuration.getStringValue("Sone/" + SONE_ID + "/Friends/0/ID")).setValue( anyString()); } @@ -384,19 +383,19 @@ public class MemoryDatabaseTest { @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(), + memoryDatabase.addFriend(localSone, "Friend1"); + memoryDatabase.removeFriend(localSone, "Friend1"); + assertThat(stringValues.get("Sone/" + SONE_ID + "/Friends/0/ID").getValue(), nullValue()); - assertThat(configurationValues.get("Sone/" + SONE_ID + "/Friends/1/ID").getValue(), + assertThat(stringValues.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( + memoryDatabase.removeFriend(localSone, "Friend1"); + verify(stringValues.get("Sone/" + SONE_ID + "/Friends/0/ID"), never()).setValue( anyString()); } @@ -404,13 +403,13 @@ public class MemoryDatabaseTest { public void newDatabaseKnowsNoSones() { memoryDatabase.startAndWait(); assertThat(memoryDatabase.isSoneKnown(sone), is(false)); - assertThat(configurationValues, hasKey("KnownSones/0/ID")); - assertThat(configurationValues, not(hasKey("KnownSones/1/ID"))); + assertThat(stringValues, hasKey("KnownSones/0/ID")); + assertThat(stringValues, not(hasKey("KnownSones/1/ID"))); } @Test public void databaseLoadsKnownSonesCorrectly() { - configurationValues.put("KnownSones/0/ID", TestValue.from(SONE_ID)); + stringValues.put("KnownSones/0/ID", TestValue.from(SONE_ID)); memoryDatabase.startAndWait(); assertThat(memoryDatabase.isSoneKnown(sone), is(true)); } @@ -418,20 +417,62 @@ public class MemoryDatabaseTest { @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"))); + assertThat(stringValues, hasKey("KnownSones/0/ID")); + assertThat(stringValues.get("KnownSones/0/ID").getValue(), is(SONE_ID)); + assertThat(stringValues, hasKey("KnownSones/1/ID")); + assertThat(stringValues.get("KnownSones/1/ID").getValue(), nullValue()); + assertThat(stringValues, not(hasKey("KnownSones/2/ID"))); } @Test public void stoppingTheDatabaseSavesTheKnownSones() throws ConfigurationException { - configurationValues.put("KnownSones/0/ID", Mockito.spy(TestValue.from(SONE_ID))); + stringValues.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); + verify(stringValues.get("KnownSones/0/ID")).setValue(SONE_ID); + verify(stringValues.get("KnownSones/1/ID")).setValue(null); + } + + @Test + public void soneFollowingTimesAreLoaded() { + stringValues.put("SoneFollowingTimes/0/Sone", TestValue.from(SONE_ID)); + longValues.put("SoneFollowingTimes/0/Time", TestValue.from(1000L)); + memoryDatabase.startAndWait(); + assertThat(memoryDatabase.getSoneFollowingTime(SONE_ID).get(), is(1000L)); + } + + @Test + public void soneFollowingTimeIsSetOnFirstFollowing() { + memoryDatabase.startAndWait(); + memoryDatabase.addFriend(localSone, "Friend1"); + assertThat(stringValues, hasKey("SoneFollowingTimes/0/Sone")); + assertThat(stringValues, hasKey("SoneFollowingTimes/1/Sone")); + assertThat(stringValues, not(hasKey("SoneFollowingTimes/2/Sone"))); + assertThat(longValues, hasKey("SoneFollowingTimes/0/Time")); + assertThat(longValues, not(hasKey("SoneFollowingTimes/1/Time"))); + } + + @Test + public void soneFollowingTimeIsNotSetOnSecondFollowing() throws ConfigurationException { + memoryDatabase.startAndWait(); + memoryDatabase.addFriend(localSone, "Friend1"); + LocalSone secondLocalSone = mock(LocalSone.class); + when(secondLocalSone.getId()).thenReturn("LocalSone2"); + long followingTime = longValues.get("SoneFollowingTimes/0/Time").getValue(); + memoryDatabase.addFriend(secondLocalSone, "Friend1"); + while (followingTime == System.currentTimeMillis()); + assertThat(longValues.get("SoneFollowingTimes/0/Time").getValue(), is(followingTime)); + } + + @Test + public void soneFollowingTimesAreRemovedWhenSoneIsUnfollowedByAll() + throws ConfigurationException { + stringValues.put("Sone/" + SONE_ID + "/Friends/0/ID", TestValue.from("Friend1")); + stringValues.put("SoneFollowingTimes/0/Sone", TestValue.from("Friend1")); + longValues.put("SoneFollowingTimes/0/Time", TestValue.from(1000L)); + memoryDatabase.startAndWait(); + memoryDatabase.removeFriend(localSone, "Friend1"); + assertThat(stringValues.get("SoneFollowingTimes/0/Sone").getValue(), nullValue()); } }