--- /dev/null
+/*
+ * Sone - MemoryDatabaseTest.java - Copyright © 2013–2019 David Roden
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+package net.pterodactylus.sone.database.memory
+
+import com.google.common.base.*
+import com.google.common.base.Optional.*
+import net.pterodactylus.sone.data.*
+import net.pterodactylus.sone.data.impl.*
+import net.pterodactylus.sone.test.*
+import net.pterodactylus.sone.test.Matchers.*
+import net.pterodactylus.util.config.*
+import org.hamcrest.MatcherAssert.*
+import org.hamcrest.Matchers.*
+import org.mockito.ArgumentMatchers.anyString
+import org.mockito.Mockito.*
+import org.mockito.invocation.*
+import java.util.Arrays.*
+import java.util.UUID.*
+import kotlin.test.*
+
+/**
+ * Tests for [MemoryDatabase].
+ */
+class MemoryDatabaseTest {
+
+ private val configuration = mock<Configuration>()
+ private val memoryDatabase = MemoryDatabase(configuration)
+ private val sone = mock<Sone>()
+
+ @BeforeTest
+ fun setupSone() {
+ whenever(sone.id).thenReturn(SONE_ID)
+ }
+
+ @Test
+ fun `stored sone is made available`() {
+ storeSone()
+ assertThat(memoryDatabase.getPost("post1"), isPost("post1", 1000L, "post1", absent()))
+ assertThat(memoryDatabase.getPost("post2"), isPost("post2", 2000L, "post2", of(RECIPIENT_ID)))
+ assertThat(memoryDatabase.getPost("post3"), nullValue())
+ assertThat(memoryDatabase.getPostReply("reply1"), isPostReply("reply1", "post1", 3000L, "reply1"))
+ assertThat(memoryDatabase.getPostReply("reply2"), isPostReply("reply2", "post2", 4000L, "reply2"))
+ assertThat(memoryDatabase.getPostReply("reply3"), isPostReply("reply3", "post1", 5000L, "reply3"))
+ assertThat(memoryDatabase.getPostReply("reply4"), nullValue())
+ assertThat(memoryDatabase.getAlbum("album1"), isAlbum("album1", null, "album1", "album-description1"))
+ assertThat(memoryDatabase.getAlbum("album2"), isAlbum("album2", null, "album2", "album-description2"))
+ assertThat(memoryDatabase.getAlbum("album3"), isAlbum("album3", "album1", "album3", "album-description3"))
+ assertThat(memoryDatabase.getAlbum("album4"), nullValue())
+ assertThat(memoryDatabase.getImage("image1"), isImage("image1", 1000L, "KSK@image1", "image1", "image-description1", 16, 9))
+ assertThat(memoryDatabase.getImage("image2"), isImage("image2", 2000L, "KSK@image2", "image2", "image-description2", 32, 18))
+ assertThat(memoryDatabase.getImage("image3"), isImage("image3", 3000L, "KSK@image3", "image3", "image-description3", 48, 27))
+ assertThat(memoryDatabase.getImage("image4"), nullValue())
+ }
+
+ private fun storeSone() {
+ val firstPost = TestPostBuilder().withId("post1")
+ .from(SONE_ID)
+ .withTime(1000L)
+ .withText("post1")
+ .build()
+ val secondPost = TestPostBuilder().withId("post2")
+ .from(SONE_ID)
+ .withTime(2000L)
+ .withText("post2")
+ .to(RECIPIENT_ID)
+ .build()
+ val posts = asList(firstPost, secondPost)
+ whenever(sone.posts).thenReturn(posts)
+ val firstPostFirstReply = TestPostReplyBuilder().withId("reply1")
+ .from(SONE_ID)
+ .to(firstPost.id)
+ .withTime(3000L)
+ .withText("reply1")
+ .build()
+ val firstPostSecondReply = TestPostReplyBuilder().withId("reply3")
+ .from(RECIPIENT_ID)
+ .to(firstPost.id)
+ .withTime(5000L)
+ .withText("reply3")
+ .build()
+ val secondPostReply = TestPostReplyBuilder().withId("reply2")
+ .from(SONE_ID)
+ .to(secondPost.id)
+ .withTime(4000L)
+ .withText("reply2")
+ .build()
+ val postReplies = setOf(firstPostFirstReply, firstPostSecondReply, secondPostReply)
+ whenever(sone.replies).thenReturn(postReplies)
+ val firstAlbum = TestAlbumBuilder().withId("album1")
+ .by(sone)
+ .build()
+ .modify()
+ .setTitle("album1")
+ .setDescription("album-description1")
+ .update()
+ val secondAlbum = TestAlbumBuilder().withId("album2")
+ .by(sone)
+ .build()
+ .modify()
+ .setTitle("album2")
+ .setDescription("album-description2")
+ .update()
+ val thirdAlbum = TestAlbumBuilder().withId("album3")
+ .by(sone)
+ .build()
+ .modify()
+ .setTitle("album3")
+ .setDescription("album-description3")
+ .update()
+ firstAlbum.addAlbum(thirdAlbum)
+ val rootAlbum = mock<Album>()
+ whenever(rootAlbum.id).thenReturn("root")
+ whenever(rootAlbum.albums).thenReturn(listOf(firstAlbum, secondAlbum))
+ whenever(sone.rootAlbum).thenReturn(rootAlbum)
+ val firstImage = TestImageBuilder().withId("image1")
+ .build()
+ .modify()
+ .setSone(sone)
+ .setCreationTime(1000L)
+ .setKey("KSK@image1")
+ .setTitle("image1")
+ .setDescription("image-description1")
+ .setWidth(16)
+ .setHeight(9)
+ .update()
+ val secondImage = TestImageBuilder().withId("image2")
+ .build()
+ .modify()
+ .setSone(sone)
+ .setCreationTime(2000L)
+ .setKey("KSK@image2")
+ .setTitle("image2")
+ .setDescription("image-description2")
+ .setWidth(32)
+ .setHeight(18)
+ .update()
+ val thirdImage = TestImageBuilder().withId("image3")
+ .build()
+ .modify()
+ .setSone(sone)
+ .setCreationTime(3000L)
+ .setKey("KSK@image3")
+ .setTitle("image3")
+ .setDescription("image-description3")
+ .setWidth(48)
+ .setHeight(27)
+ .update()
+ firstAlbum.addImage(firstImage)
+ firstAlbum.addImage(thirdImage)
+ secondAlbum.addImage(secondImage)
+ memoryDatabase.storeSone(sone)
+ }
+
+ @Test
+ fun `stored and removed sone is not available`() {
+ storeSone()
+ memoryDatabase.removeSone(sone)
+ assertThat(memoryDatabase.sones, empty())
+ }
+
+ @Test
+ fun `post recipients are detected correctly`() {
+ val postWithRecipient = createPost(of(RECIPIENT_ID))
+ memoryDatabase.storePost(postWithRecipient)
+ val postWithoutRecipient = createPost(absent())
+ memoryDatabase.storePost(postWithoutRecipient)
+ assertThat(memoryDatabase.getDirectedPosts(RECIPIENT_ID), contains(postWithRecipient))
+ }
+
+ private fun createPost(recipient: Optional<String>): Post {
+ val postWithRecipient = mock<Post>()
+ whenever(postWithRecipient.id).thenReturn(randomUUID().toString())
+ whenever(postWithRecipient.sone).thenReturn(sone)
+ whenever(postWithRecipient.recipientId).thenReturn(recipient)
+ return postWithRecipient
+ }
+
+ @Test
+ fun `post replies are managed correctly`() {
+ val firstPost = createPost(absent())
+ val firstPostFirstReply = createPostReply(firstPost, 1000L)
+ val secondPost = createPost(absent())
+ val secondPostFirstReply = createPostReply(secondPost, 1000L)
+ val secondPostSecondReply = createPostReply(secondPost, 2000L)
+ memoryDatabase.storePost(firstPost)
+ memoryDatabase.storePost(secondPost)
+ memoryDatabase.storePostReply(firstPostFirstReply)
+ memoryDatabase.storePostReply(secondPostFirstReply)
+ memoryDatabase.storePostReply(secondPostSecondReply)
+ assertThat(memoryDatabase.getReplies(firstPost.id), contains(firstPostFirstReply))
+ assertThat(memoryDatabase.getReplies(secondPost.id), contains(secondPostFirstReply, secondPostSecondReply))
+ }
+
+ private fun createPostReply(post: Post, time: Long): PostReply {
+ val postReply = mock<PostReply>()
+ whenever(postReply.id).thenReturn(randomUUID().toString())
+ whenever(postReply.time).thenReturn(time)
+ whenever(postReply.post).thenReturn(of(post))
+ val postId = post.id
+ whenever(postReply.postId).thenReturn(postId)
+ return postReply
+ }
+
+ @Test
+ fun `test basic album functionality`() {
+ val newAlbum = AlbumImpl(mock())
+ assertThat(memoryDatabase.getAlbum(newAlbum.id), nullValue())
+ memoryDatabase.storeAlbum(newAlbum)
+ assertThat(memoryDatabase.getAlbum(newAlbum.id), equalTo<Album>(newAlbum))
+ memoryDatabase.removeAlbum(newAlbum)
+ assertThat(memoryDatabase.getAlbum(newAlbum.id), nullValue())
+ }
+
+ private fun initializeFriends() {
+ whenever(configuration.getStringValue("Sone/$SONE_ID/Friends/0/ID")).thenReturn(TestValue.from("Friend1"))
+ whenever(configuration.getStringValue("Sone/$SONE_ID/Friends/1/ID")).thenReturn(TestValue.from("Friend2"))
+ whenever(configuration.getStringValue("Sone/$SONE_ID/Friends/2/ID")).thenReturn(TestValue.from(null))
+ }
+
+ @Test
+ fun `friends are returned correctly`() {
+ initializeFriends()
+ whenever(sone.isLocal).thenReturn(true)
+ val friends = memoryDatabase.getFriends(sone)
+ assertThat(friends, containsInAnyOrder("Friend1", "Friend2"))
+ }
+
+ @Test
+ fun `friends are only loaded once from configuration`() {
+ initializeFriends()
+ whenever(sone.isLocal).thenReturn(true)
+ memoryDatabase.getFriends(sone)
+ memoryDatabase.getFriends(sone)
+ verify(configuration, times(1)).getStringValue("Sone/$SONE_ID/Friends/0/ID")
+ }
+
+ @Test
+ fun `friends are only returned for local sones`() {
+ val friends = memoryDatabase.getFriends(sone)
+ assertThat(friends, emptyIterable<Any>())
+ verify(configuration, never()).getStringValue("Sone/$SONE_ID/Friends/0/ID")
+ }
+
+ @Test
+ fun `checking for a friend returns true`() {
+ initializeFriends()
+ whenever(sone.isLocal).thenReturn(true)
+ assertThat(memoryDatabase.isFriend(sone, "Friend1"), equalTo(true))
+ }
+
+ @Test
+ fun `checking for a friend that is not a friend returns false`() {
+ initializeFriends()
+ whenever(sone.isLocal).thenReturn(true)
+ assertThat(memoryDatabase.isFriend(sone, "FriendX"), equalTo(false))
+ }
+
+ @Test
+ fun `checking for a friend of remote sone returns false`() {
+ initializeFriends()
+ assertThat(memoryDatabase.isFriend(sone, "Friend1"), equalTo(false))
+ }
+
+ private fun prepareConfigurationValues(): Map<String, Value<*>> =
+ mutableMapOf<String, Value<*>>().also { configurationValues ->
+ whenever(configuration.getStringValue(anyString())).thenAnswer(createAndCacheValue(configurationValues))
+ whenever(configuration.getLongValue(anyString())).thenAnswer(createAndCacheValue(configurationValues))
+ }
+
+ private fun createAndCacheValue(configurationValues: MutableMap<String, Value<*>>) =
+ { invocation: InvocationOnMock ->
+ configurationValues[invocation[0]]
+ ?: TestValue.from(null).also {
+ configurationValues[invocation[0]] = it
+ }
+ }
+
+ @Test
+ fun `friend is added correctly to local sone`() {
+ val configurationValues = prepareConfigurationValues()
+ whenever(sone.isLocal).thenReturn(true)
+ memoryDatabase.addFriend(sone, "Friend1")
+ assertThat(configurationValues["Sone/$SONE_ID/Friends/0/ID"], equalTo<Value<*>>(TestValue.from("Friend1")))
+ assertThat(configurationValues["Sone/$SONE_ID/Friends/1/ID"], equalTo<Value<*>>(TestValue.from(null)))
+ }
+
+ @Test
+ fun `friend is not added to remote sone`() {
+ memoryDatabase.addFriend(sone, "Friend1")
+ verify(configuration, never()).getStringValue(anyString())
+ }
+
+ @Test
+ fun `friend is removed correctly from local sone`() {
+ val configurationValues = prepareConfigurationValues()
+ whenever(sone.isLocal).thenReturn(true)
+ memoryDatabase.addFriend(sone, "Friend1")
+ memoryDatabase.removeFriend(sone, "Friend1")
+ assertThat(configurationValues["Sone/$SONE_ID/Friends/0/ID"], equalTo<Value<*>>(TestValue.from(null)))
+ assertThat(configurationValues["Sone/$SONE_ID/Friends/1/ID"], equalTo<Value<*>>(TestValue.from(null)))
+ }
+
+ @Test
+ fun `configuration is not written when a non-friend is removed`() {
+ prepareConfigurationValues()
+ whenever(sone.isLocal).thenReturn(true)
+ memoryDatabase.removeFriend(sone, "Friend1")
+ verify(configuration).getStringValue(anyString())
+ }
+
+ @Test
+ fun `sone following time is returned correctly`() {
+ prepareConfigurationValues()
+ configuration.getStringValue("SoneFollowingTimes/0/Sone").value = "sone"
+ configuration.getLongValue("SoneFollowingTimes/0/Time").value = 1000L
+ assertThat(memoryDatabase.getFollowingTime("sone"), equalTo(1000L))
+ }
+
+ @Test
+ fun `null is returned when sone is not followed`() {
+ prepareConfigurationValues()
+ configuration.getStringValue("SoneFollowingTimes/0/Sone").value = "otherSone"
+ configuration.getLongValue("SoneFollowingTimes/0/Time").value = 1000L
+ assertThat(memoryDatabase.getFollowingTime("sone"), nullValue())
+ }
+
+ @Test
+ fun `time is stored in configuration when a sone is followed`() {
+ prepareConfigurationValues()
+ whenever(sone.isLocal).thenReturn(true)
+ memoryDatabase.addFriend(sone, "Friend")
+ assertThat(configuration.getStringValue("SoneFollowingTimes/0/Sone").value, equalTo("Friend"))
+ assertThat(System.currentTimeMillis() - configuration.getLongValue("SoneFollowingTimes/0/Time").value, lessThan(1000L))
+ assertThat(configuration.getStringValue("SoneFollowingTimes/1/Sone").value, nullValue())
+ }
+
+ @Test
+ fun `existing time is not overwritten when a sone is followed`() {
+ prepareConfigurationValues()
+ configuration.getStringValue("SoneFollowingTimes/0/Sone").value = "Friend"
+ configuration.getLongValue("SoneFollowingTimes/0/Time").value = 1000L
+ whenever(sone.isLocal).thenReturn(true)
+ memoryDatabase.addFriend(sone, "Friend")
+ assertThat(configuration.getStringValue("SoneFollowingTimes/0/Sone").value, equalTo("Friend"))
+ assertThat(configuration.getLongValue("SoneFollowingTimes/0/Time").value, equalTo(1000L))
+ assertThat(configuration.getStringValue("SoneFollowingTimes/1/Sone").value, nullValue())
+ }
+
+ @Test
+ fun `unfollowing a sone removes the following time`() {
+ prepareConfigurationValues()
+ configuration.getStringValue("Sone/sone/Friends/0/ID").value = "Friend"
+ configuration.getStringValue("SoneFollowingTimes/0/Sone").value = "Friend"
+ configuration.getLongValue("SoneFollowingTimes/0/Time").value = 1000L
+ whenever(sone.isLocal).thenReturn(true)
+ memoryDatabase.removeFriend(sone, "Friend")
+ assertThat(configuration.getStringValue("SoneFollowingTimes/0/Sone").value, nullValue())
+ }
+
+ @Test
+ fun `unfollowing a sone does not remove the following time if another local sone follows it`() {
+ prepareConfigurationValues()
+ configuration.getStringValue("Sone/sone/Friends/0/ID").value = "Friend"
+ configuration.getStringValue("Sone/other-sone/Friends/0/ID").value = "Friend"
+ configuration.getStringValue("SoneFollowingTimes/0/Sone").value = "Friend"
+ configuration.getLongValue("SoneFollowingTimes/0/Time").value = 1000L
+ val otherSone = mock<Sone>()
+ whenever(otherSone.isLocal).thenReturn(true)
+ whenever(otherSone.id).thenReturn("other-sone")
+ memoryDatabase.getFriends(otherSone)
+ whenever(sone.isLocal).thenReturn(true)
+ memoryDatabase.removeFriend(sone, "Friend")
+ assertThat(configuration.getStringValue("SoneFollowingTimes/0/Sone").value, equalTo("Friend"))
+ assertThat(configuration.getLongValue("SoneFollowingTimes/0/Time").value, equalTo(1000L))
+ }
+
+ @Test
+ fun `marking a post as known saves configuration`() {
+ prepareConfigurationValues()
+ val post = mock<Post>()
+ whenever(post.id).thenReturn("post-id")
+ memoryDatabase.setPostKnown(post, true)
+ assertThat(configuration.getStringValue("KnownPosts/0/ID").value, equalTo("post-id"))
+ assertThat(configuration.getStringValue("KnownPosts/1/ID").value, equalTo<Any>(null))
+ }
+
+ @Test
+ fun `marking a post reply as known saves configuration`() {
+ prepareConfigurationValues()
+ val postReply = mock<PostReply>()
+ whenever(postReply.id).thenReturn("post-reply-id")
+ memoryDatabase.setPostReplyKnown(postReply, true)
+ assertThat(configuration.getStringValue("KnownReplies/0/ID").value, equalTo("post-reply-id"))
+ assertThat(configuration.getStringValue("KnownReplies/1/ID").value, equalTo<Any>(null))
+ }
+
+}
+
+private const val SONE_ID = "sone"
+private const val RECIPIENT_ID = "recipient"
projects / Sone.git / blobdiff