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 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;
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<String, Value<String>> configurationValues =
- new HashMap<String, Value<String>>();
+ private final LocalSone localSone = mock(LocalSone.class);
+ private final Map<String, Value<String>> stringValues = new HashMap<String, Value<String>>();
+ private final Map<String, Value<Long>> longValues = new HashMap<String, Value<Long>>();
@Before
public void prepareConfigurationValues() {
@Override
public Value<String> answer(InvocationOnMock invocation) throws Throwable {
final String key = (String) invocation.getArguments()[0];
- if (!configurationValues.containsKey(key)) {
+ if (!stringValues.containsKey(key)) {
TestValue<String> value = Mockito.spy(new TestValue<String>(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<Value<Long>>() {
+ @Override
+ public Value<Long> answer(InvocationOnMock invocation) throws Throwable {
+ final String key = (String) invocation.getArguments()[0];
+ if (!longValues.containsKey(key)) {
+ TestValue<Long> value = Mockito.spy(new TestValue<Long>(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
}
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.<String>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.<String>from(null)));
}
@Test
public void friendsAreReturnedCorrectly() {
initializeFriends();
- when(sone.isLocal()).thenReturn(true);
- Collection<String> friends = memoryDatabase.getFriends(sone);
+ Collection<String> 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<String> 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());
}
@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());
}
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));
}
@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());
}
}
projects / Sone.git / blobdiff