Move storage of known Sones into database.

[Sone.git] / src / test / java / net / pterodactylus / sone / database / memory / MemoryDatabaseTest.java

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 7cba93b..ac53a5d 100644 (file)
--- a/src/test/java/net/pterodactylus/sone/database/memory/MemoryDatabaseTest.java
+++ b/src/test/java/net/pterodactylus/sone/database/memory/MemoryDatabaseTest.java
@@ -30,10 +30,12 @@ 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.times;
 import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.when;
 
@@ -51,17 +53,19 @@ 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.impl.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;
 
@@ -77,6 +81,29 @@ 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<String, Value<String>> configurationValues =
+                       new HashMap<String, Value<String>>();
+
+       @Before
+       public void prepareConfigurationValues() {
+               when(configuration.getStringValue(anyString())).thenAnswer(new Answer<Value<String>>() {
+                       @Override
+                       public Value<String> answer(InvocationOnMock invocation) throws Throwable {
+                               final String key = (String) invocation.getArguments()[0];
+                               if (!configurationValues.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);
+                                               }
+                                       });
+                                       configurationValues.put(key, value);
+                               }
+                               return configurationValues.get(key);
+                       }
+               });
+       }
 
        @Before
        public void setupSone() {
@@ -216,7 +243,7 @@ public class MemoryDatabaseTest {
 
        @Test
        public void storedAndRemovedSoneIsNotAvailable() {
-           storedSoneIsMadeAvailable();
+               storedSoneIsMadeAvailable();
                memoryDatabase.removeSone(sone);
                assertThat(memoryDatabase.getSones(), empty());
        }
@@ -328,63 +355,81 @@ public class MemoryDatabaseTest {
                assertThat(memoryDatabase.isFriend(sone, "Friend1"), is(false));
        }
 
-       private Map<String, Value<String>> prepareConfigurationValues() {
-               final Map<String, Value<String>> configurationValues = new HashMap<String, Value<String>>();
-               when(configuration.getStringValue(anyString())).thenAnswer(new Answer<Value<String>>() {
-                       @Override
-                       public Value<String> answer(InvocationOnMock invocation) throws Throwable {
-                               Value<String> stringValue = TestValue.from(null);
-                               configurationValues.put((String) invocation.getArguments()[0], stringValue);
-                               return stringValue;
-                       }
-               });
-               return configurationValues;
-       }
-
        @Test
-       public void friendIsAddedCorrectlyToLocalSone() {
-               Map<String, Value<String>> configurationValues = prepareConfigurationValues();
+       public void friendIsAddedCorrectlyToLocalSone() throws ConfigurationException {
                when(sone.isLocal()).thenReturn(true);
                memoryDatabase.addFriend(sone, "Friend1");
-               assertThat(configurationValues.get("Sone/" + SONE_ID + "/Friends/0/ID"),
-                               is(TestValue.from("Friend1")));
-               assertThat(configurationValues.get("Sone/" + SONE_ID + "/Friends/1/ID"),
-                               is(TestValue.<String>from(null)));
+               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() {
+       public void friendIsNotAddedToRemoteSone() throws ConfigurationException {
                memoryDatabase.addFriend(sone, "Friend1");
-               verify(configuration, never()).getStringValue(anyString());
+               verify(configuration.getStringValue("Sone/" + SONE_ID + "/Friends/0/ID"), never()).setValue(
+                               anyString());
        }
 
        @Test
-       public void configurationIsWrittenOnceIfFriendIsAddedTwice() {
-               prepareConfigurationValues();
+       public void configurationIsWrittenOnceIfFriendIsAddedTwice() throws ConfigurationException {
                when(sone.isLocal()).thenReturn(true);
                memoryDatabase.addFriend(sone, "Friend1");
                memoryDatabase.addFriend(sone, "Friend1");
-               verify(configuration, times(3)).getStringValue(anyString());
+               verify(configuration.getStringValue("Sone/" + SONE_ID + "/Friends/0/ID")).setValue(
+                               anyString());
        }
 
        @Test
-       public void friendIsRemovedCorrectlyFromLocalSone() {
-               Map<String, Value<String>> configurationValues = prepareConfigurationValues();
+       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"),
-                               is(TestValue.<String>from(null)));
-               assertThat(configurationValues.get("Sone/" + SONE_ID + "/Friends/1/ID"),
-                               is(TestValue.<String>from(null)));
+               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() {
-               prepareConfigurationValues();
+       public void configurationIsNotWrittenWhenANonFriendIsRemoved() throws ConfigurationException {
                when(sone.isLocal()).thenReturn(true);
                memoryDatabase.removeFriend(sone, "Friend1");
-               verify(configuration).getStringValue(anyString());
+               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 {
+               memoryDatabase.startAndWait();
+               memoryDatabase.stopAndWait();
+               verify(configurationValues.get("KnownSones/0/ID")).setValue(null);
        }
 
 }