/*
* Sone - MemoryDatabaseTest.java - Copyright © 2013 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 .
*/
package net.pterodactylus.sone.database.memory;
import static com.google.common.base.Optional.of;
import static java.util.Arrays.asList;
import static java.util.UUID.randomUUID;
import static net.pterodactylus.sone.Matchers.isAlbum;
import static net.pterodactylus.sone.Matchers.isImage;
import static net.pterodactylus.sone.Matchers.isPost;
import static net.pterodactylus.sone.Matchers.isPostReply;
import static org.hamcrest.CoreMatchers.is;
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.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;
import java.util.Collection;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
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.util.config.Configuration;
import net.pterodactylus.util.config.Value;
import com.google.common.base.Optional;
import org.junit.Before;
import org.junit.Test;
import org.mockito.invocation.InvocationOnMock;
import org.mockito.stubbing.Answer;
/**
* Tests for {@link MemoryDatabase}.
*
* @author David ‘Bombe’ Roden
*/
public class MemoryDatabaseTest {
private static final String SONE_ID = "sone";
private static final String RECIPIENT_ID = "recipient";
private final Configuration configuration = mock(Configuration.class);
private final MemoryDatabase memoryDatabase = new MemoryDatabase(null, configuration);
private final Sone sone = mock(Sone.class);
@Before
public void setupSone() {
when(sone.getId()).thenReturn(SONE_ID);
}
@Test
public void storedSoneIsMadeAvailable() {
Post firstPost = new TestPostBuilder().withId("post1")
.from(SONE_ID)
.withTime(1000L)
.withText("post1")
.build();
Post secondPost = new TestPostBuilder().withId("post2")
.from(SONE_ID)
.withTime(2000L)
.withText("post2")
.to(RECIPIENT_ID)
.build();
List posts = asList(firstPost, secondPost);
when(sone.getPosts()).thenReturn(posts);
PostReply firstPostFirstReply =
new TestPostReplyBuilder().withId("reply1")
.from(SONE_ID)
.to(firstPost.getId())
.withTime(3000L)
.withText("reply1")
.build();
PostReply firstPostSecondReply =
new TestPostReplyBuilder().withId("reply3")
.from(RECIPIENT_ID)
.to(firstPost.getId())
.withTime(5000L)
.withText("reply3")
.build();
PostReply secondPostReply =
new TestPostReplyBuilder().withId("reply2")
.from(SONE_ID)
.to(secondPost.getId())
.withTime(4000L)
.withText("reply2")
.build();
Set postReplies = new HashSet(
asList(firstPostFirstReply, firstPostSecondReply,
secondPostReply));
when(sone.getReplies()).thenReturn(postReplies);
Album firstAlbum = new TestAlbumBuilder().withId("album1")
.by(sone)
.build()
.modify()
.setTitle("album1")
.setDescription("album-description1")
.update();
Album secondAlbum = new TestAlbumBuilder().withId("album2").by(
sone).build().modify().setTitle("album2").setDescription(
"album-description2").setAlbumImage("image1").update();
Album thirdAlbum = new TestAlbumBuilder().withId("album3").by(
sone).build().modify().setTitle("album3").setDescription(
"album-description3").update();
firstAlbum.addAlbum(thirdAlbum);
Album rootAlbum = mock(Album.class);
when(rootAlbum.getAlbums()).thenReturn(
asList(firstAlbum, secondAlbum));
when(sone.getRootAlbum()).thenReturn(rootAlbum);
Image firstImage = new TestImageBuilder().withId("image1")
.build()
.modify()
.setSone(sone)
.setCreationTime(1000L)
.setKey("KSK@image1")
.setTitle("image1")
.setDescription("image-description1")
.setWidth(16)
.setHeight(9)
.update();
Image secondImage = new TestImageBuilder().withId("image2")
.build()
.modify()
.setSone(sone)
.setCreationTime(2000L)
.setKey("KSK@image2")
.setTitle("image2")
.setDescription("image-description2")
.setWidth(32)
.setHeight(18)
.update();
Image thirdImage = new 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);
assertThat(memoryDatabase.getPost("post1").get(),
isPost(firstPost.getId(), 1000L, "post1",
Optional.absent()));
assertThat(memoryDatabase.getPost("post2").get(),
isPost(secondPost.getId(), 2000L, "post2", of(RECIPIENT_ID)));
assertThat(memoryDatabase.getPost("post3").isPresent(), is(false));
assertThat(memoryDatabase.getPostReply("reply1").get(),
isPostReply("reply1", "post1", 3000L, "reply1"));
assertThat(memoryDatabase.getPostReply("reply2").get(),
isPostReply("reply2", "post2", 4000L, "reply2"));
assertThat(memoryDatabase.getPostReply("reply3").get(),
isPostReply("reply3", "post1", 5000L, "reply3"));
assertThat(memoryDatabase.getPostReply("reply4").isPresent(),
is(false));
assertThat(memoryDatabase.getAlbum("album1").get(),
isAlbum("album1", null, "album1", "album-description1",
null));
assertThat(memoryDatabase.getAlbum("album2").get(),
isAlbum("album2", null, "album2", "album-description2",
"image1"));
assertThat(memoryDatabase.getAlbum("album3").get(),
isAlbum("album3", "album1", "album3", "album-description3",
null));
assertThat(memoryDatabase.getAlbum("album4").isPresent(), is(false));
assertThat(memoryDatabase.getImage("image1").get(),
isImage("image1", 1000L, "KSK@image1", "image1",
"image-description1", 16, 9));
assertThat(memoryDatabase.getImage("image2").get(),
isImage("image2", 2000L, "KSK@image2", "image2",
"image-description2", 32, 18));
assertThat(memoryDatabase.getImage("image3").get(),
isImage("image3", 3000L, "KSK@image3", "image3",
"image-description3", 48, 27));
assertThat(memoryDatabase.getImage("image4").isPresent(), is(false));
}
@Test
public void storedAndRemovedSoneIsNotAvailable() {
storedSoneIsMadeAvailable();
memoryDatabase.removeSone(sone);
assertThat(memoryDatabase.getSones(), empty());
}
@Test
public void postRecipientsAreDetectedCorrectly() {
Post postWithRecipient = createPost(of(RECIPIENT_ID));
memoryDatabase.storePost(postWithRecipient);
Post postWithoutRecipient = createPost(Optional.absent());
memoryDatabase.storePost(postWithoutRecipient);
assertThat(memoryDatabase.getDirectedPosts(RECIPIENT_ID),
contains(postWithRecipient));
}
private Post createPost(Optional recipient) {
Post postWithRecipient = mock(Post.class);
when(postWithRecipient.getId()).thenReturn(randomUUID().toString());
when(postWithRecipient.getSone()).thenReturn(sone);
when(postWithRecipient.getRecipientId()).thenReturn(recipient);
return postWithRecipient;
}
@Test
public void postRepliesAreManagedCorrectly() {
Post firstPost = createPost(Optional.absent());
PostReply firstPostFirstReply = createPostReply(firstPost, 1000L);
Post secondPost = createPost(Optional.absent());
PostReply secondPostFirstReply = createPostReply(secondPost, 1000L);
PostReply secondPostSecondReply = createPostReply(secondPost, 2000L);
memoryDatabase.storePost(firstPost);
memoryDatabase.storePost(secondPost);
memoryDatabase.storePostReply(firstPostFirstReply);
memoryDatabase.storePostReply(secondPostFirstReply);
memoryDatabase.storePostReply(secondPostSecondReply);
assertThat(memoryDatabase.getReplies(firstPost.getId()),
contains(firstPostFirstReply));
assertThat(memoryDatabase.getReplies(secondPost.getId()),
contains(secondPostFirstReply, secondPostSecondReply));
}
private PostReply createPostReply(Post post, long time) {
PostReply postReply = mock(PostReply.class);
when(postReply.getId()).thenReturn(randomUUID().toString());
when(postReply.getTime()).thenReturn(time);
when(postReply.getPost()).thenReturn(of(post));
final String postId = post.getId();
when(postReply.getPostId()).thenReturn(postId);
return postReply;
}
@Test
public void testBasicAlbumFunctionality() {
Album newAlbum = new AlbumImpl(mock(Sone.class));
assertThat(memoryDatabase.getAlbum(newAlbum.getId()), is(Optional.absent()));
memoryDatabase.storeAlbum(newAlbum);
assertThat(memoryDatabase.getAlbum(newAlbum.getId()), is(of(newAlbum)));
memoryDatabase.removeAlbum(newAlbum);
assertThat(memoryDatabase.getAlbum(newAlbum.getId()), is(Optional.absent()));
}
private void initializeFriends() {
when(configuration.getStringValue("Sone/" + SONE_ID + "/Friends/0/ID")).thenReturn(
new TestValue("Friend1"));
when(configuration.getStringValue("Sone/" + SONE_ID + "/Friends/1/ID")).thenReturn(
new TestValue("Friend2"));
when(configuration.getStringValue("Sone/" + SONE_ID + "/Friends/2/ID")).thenReturn(
new TestValue(null));
}
@Test
public void friendsAreReturnedCorrectly() {
initializeFriends();
when(sone.isLocal()).thenReturn(true);
Collection friends = memoryDatabase.getFriends(sone);
assertThat(friends, containsInAnyOrder("Friend1", "Friend2"));
}
@Test
public void friendsAreOnlyLoadedOnceFromConfiguration() {
friendsAreReturnedCorrectly();
memoryDatabase.getFriends(sone);
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));
}
@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));
}
private Map> prepareConfigurationValues() {
final Map> configurationValues = new HashMap>();
when(configuration.getStringValue(anyString())).thenAnswer(new Answer>() {
@Override
public Value answer(InvocationOnMock invocation) throws Throwable {
Value stringValue = new TestValue(null);
configurationValues.put((String) invocation.getArguments()[0], stringValue);
return stringValue;
}
});
return configurationValues;
}
@Test
public void friendIsAddedCorrectlyToLocalSone() {
Map> configurationValues = prepareConfigurationValues();
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.from(null)));
}
@Test
public void friendIsNotAddedToRemoteSone() {
memoryDatabase.addFriend(sone, "Friend1");
verify(configuration, never()).getStringValue(anyString());
}
@Test
public void configurationIsWrittenOnceIfFriendIsAddedTwice() {
prepareConfigurationValues();
when(sone.isLocal()).thenReturn(true);
memoryDatabase.addFriend(sone, "Friend1");
memoryDatabase.addFriend(sone, "Friend1");
verify(configuration, times(2)).getStringValue(anyString());
}
@Test
public void friendIsRemovedCorrectlyFromLocalSone() {
Map> configurationValues = prepareConfigurationValues();
when(sone.isLocal()).thenReturn(true);
memoryDatabase.addFriend(sone, "Friend1");
memoryDatabase.removeFriend(sone, "Friend1");
assertThat(configurationValues.get("Sone/" + SONE_ID + "/Friends/0/ID"),
is(TestValue.from(null)));
assertThat(configurationValues.get("Sone/" + SONE_ID + "/Friends/1/ID"),
is(TestValue.from(null)));
}
@Test
public void configurationIsNotWrittenWhenANonFriendIsRemoved() {
when(sone.isLocal()).thenReturn(true);
memoryDatabase.removeFriend(sone, "Friend1");
verify(configuration, never()).getStringValue(anyString());
}
}