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=ac23a81a2038e587d238333ba5947a9fb64202e9;hpb=1a3f2a00bb5180470db1515e646615dff2744e39;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 ac23a81..1d7d471 100644
--- 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;
 
@@ -44,23 +46,26 @@ 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.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;
 
@@ -76,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() {
@@ -215,7 +243,7 @@ public class MemoryDatabaseTest {
 
 	@Test
 	public void storedAndRemovedSoneIsNotAvailable() {
-	    storedSoneIsMadeAvailable();
+		storedSoneIsMadeAvailable();
 		memoryDatabase.removeSone(sone);
 		assertThat(memoryDatabase.getSones(), empty());
 	}
@@ -227,7 +255,7 @@ public class MemoryDatabaseTest {
 		Post postWithoutRecipient = createPost(Optional.<String>absent());
 		memoryDatabase.storePost(postWithoutRecipient);
 		assertThat(memoryDatabase.getDirectedPosts(RECIPIENT_ID),
-				contains(postWithRecipient));
+				contains(IncompletePostMatcher.matches().recipient(RECIPIENT_ID)));
 	}
 
 	private Post createPost(Optional<String> recipient) {
@@ -327,62 +355,83 @@ 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(2)).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() {
+	public void configurationIsNotWrittenWhenANonFriendIsRemoved() throws ConfigurationException {
 		when(sone.isLocal()).thenReturn(true);
 		memoryDatabase.removeFriend(sone, "Friend1");
-		verify(configuration, never()).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 {
+		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);
 	}
 
 }