src/test/java/net/pterodactylus/sone/database/memory/MemoryBookmarkDatabaseTest.java

   1 package net.pterodactylus.sone.database.memory;
   2
   3 import static com.google.common.base.Optional.fromNullable;
   4 import static org.hamcrest.MatcherAssert.assertThat;
   5 import static org.hamcrest.Matchers.is;
   6 import static org.mockito.Matchers.any;
   7 import static org.mockito.Matchers.anyString;
   8 import static org.mockito.Mockito.mock;
   9 import static org.mockito.Mockito.times;
  10 import static org.mockito.Mockito.verify;
  11 import static org.mockito.Mockito.when;
  12
  13 import java.util.HashMap;
  14 import java.util.HashSet;
  15 import java.util.Map;
  16 import java.util.Set;
  17
  18 import net.pterodactylus.sone.data.Post;
  19
  20 import com.google.common.base.Optional;
  21 import org.junit.Before;
  22 import org.junit.Test;
  23 import org.mockito.invocation.InvocationOnMock;
  24 import org.mockito.stubbing.Answer;
  25
  26 /**
  27  * Unit test for {@link MemoryBookmarkDatabase}.
  28  *
  29  * @author <a href="mailto:bombe@pterodactylus.net">David ‘Bombe’ Roden</a>
  30  */
  31 public class MemoryBookmarkDatabaseTest {
  32
  33         private final MemoryDatabase memoryDatabase = mock(MemoryDatabase.class);
  34         private final ConfigurationLoader configurationLoader =
  35                         mock(ConfigurationLoader.class);
  36         private final MemoryBookmarkDatabase bookmarkDatabase =
  37                         new MemoryBookmarkDatabase(memoryDatabase, configurationLoader);
  38         private final Map<String, Post> posts = new HashMap<String, Post>();
  39
  40         @Before
  41         public void setupMemoryDatabase() {
  42                 when(memoryDatabase.getPost(anyString())).thenAnswer(
  43                                 new Answer<Optional<Post>>() {
  44                                         @Override
  45                                         public Optional<Post> answer(
  46                                                         InvocationOnMock invocation) {
  47                                                 return fromNullable(
  48                                                                 posts.get(invocation.getArguments()[0]));
  49                                         }
  50                                 });
  51         }
  52
  53         @Before
  54         public void setupPosts() {
  55                 createPost("PostId1");
  56                 createPost("PostId2");
  57         }
  58
  59         private void createPost(String postId) {
  60                 Post post = mock(Post.class);
  61                 when(post.getId()).thenReturn(postId);
  62                 posts.put(postId, post);
  63         }
  64
  65         @Test
  66         public void bookmarkDatabaseRetainsBookmarkedPosts() {
  67                 Set<Post> allPosts = new HashSet<Post>(posts.values());
  68                 for (Post post : allPosts) {
  69                         bookmarkDatabase.bookmarkPost(post);
  70                 }
  71                 assertThat(bookmarkDatabase.getBookmarkedPosts(), is(allPosts));
  72                 for (Post post : allPosts) {
  73                         assertThat(bookmarkDatabase.isPostBookmarked(post), is(true));
  74                 }
  75         }
  76
  77         @Test
  78         public void bookmarkingAPostSavesTheDatabase() {
  79                 for (Post post : posts.values()) {
  80                         bookmarkDatabase.bookmarkPost(post);
  81                 }
  82                 verify(configurationLoader, times(posts.size()))
  83                                 .saveBookmarkedPosts(any(Set.class));
  84         }
  85
  86         @Test
  87         public void unbookmarkingAPostSavesTheDatabase() {
  88                 for (Post post : posts.values()) {
  89                         bookmarkDatabase.bookmarkPost(post);
  90                         bookmarkDatabase.unbookmarkPost(post);
  91                 }
  92                 verify(configurationLoader, times(posts.size() * 2))
  93                                 .saveBookmarkedPosts(any(Set.class));
  94         }
  95
  96         @Test
  97         public void removingABookmarkRemovesTheCorrectBookmark() {
  98                 Set<Post> allPosts = new HashSet<Post>(posts.values());
  99                 for (Post post : allPosts) {
 100                         bookmarkDatabase.bookmarkPost(post);
 101                 }
 102                 Post randomPost = posts.values().iterator().next();
 103                 bookmarkDatabase.unbookmarkPost(randomPost);
 104                 allPosts.remove(randomPost);
 105                 assertThat(bookmarkDatabase.getBookmarkedPosts(), is(allPosts));
 106                 for (Post post : posts.values()) {
 107                         assertThat(bookmarkDatabase.isPostBookmarked(post),
 108                                         is(!post.equals(randomPost)));
 109                 }
 110         }
 111
 112         @Test
 113         public void startingTheDatabaseLoadsBookmarkedPosts() {
 114                 bookmarkDatabase.start();
 115                 verify(configurationLoader).loadBookmarkedPosts();
 116         }
 117
 118         @Test
 119         public void stoppingTheDatabaseSavesTheBookmarkedPosts() {
 120                 bookmarkDatabase.stop();
 121                 verify(configurationLoader).saveBookmarkedPosts(any(Set.class));
 122         }
 123
 124 }