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

   1 package net.pterodactylus.sone.database.memory;
   2
   3 import static net.pterodactylus.sone.test.Matchers.isPostWithId;
   4 import static org.hamcrest.MatcherAssert.assertThat;
   5 import static org.hamcrest.Matchers.contains;
   6 import static org.hamcrest.Matchers.is;
   7 import static org.mockito.ArgumentMatchers.any;
   8 import static org.mockito.ArgumentMatchers.anyString;
   9 import static org.mockito.Mockito.mock;
  10 import static org.mockito.Mockito.times;
  11 import static org.mockito.Mockito.verify;
  12 import static org.mockito.Mockito.when;
  13
  14 import java.util.HashMap;
  15 import java.util.HashSet;
  16 import java.util.Map;
  17 import java.util.Set;
  18
  19 import net.pterodactylus.sone.data.Post;
  20
  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<Post>() {
  44                                         @Override
  45                                         public Post answer(
  46                                                         InvocationOnMock invocation) {
  47                                                 return posts.get(invocation.getArguments()[0]);
  48                                         }
  49                                 });
  50         }
  51
  52         @Before
  53         public void setupPosts() {
  54                 createAndRegisterPost("PostId1");
  55                 createAndRegisterPost("PostId2");
  56         }
  57
  58         private Post createAndRegisterPost(String postId) {
  59                 Post post = createPost(postId);
  60                 posts.put(postId, post);
  61                 return post;
  62         }
  63
  64         private Post createPost(String postId) {
  65                 Post post = mock(Post.class);
  66                 when(post.getId()).thenReturn(postId);
  67                 return post;
  68         }
  69
  70         @Test
  71         public void bookmarkDatabaseRetainsBookmarkedPosts() {
  72                 Set<Post> allPosts = new HashSet<Post>(posts.values());
  73                 for (Post post : allPosts) {
  74                         bookmarkDatabase.bookmarkPost(post);
  75                 }
  76                 assertThat(bookmarkDatabase.getBookmarkedPosts(), is(allPosts));
  77                 for (Post post : allPosts) {
  78                         assertThat(bookmarkDatabase.isPostBookmarked(post), is(true));
  79                 }
  80         }
  81
  82         @Test
  83         public void bookmarkingAPostSavesTheDatabase() {
  84                 for (Post post : posts.values()) {
  85                         bookmarkDatabase.bookmarkPost(post);
  86                 }
  87                 verify(configurationLoader, times(posts.size()))
  88                                 .saveBookmarkedPosts(any(Set.class));
  89         }
  90
  91         @Test
  92         public void unbookmarkingAPostSavesTheDatabase() {
  93                 for (Post post : posts.values()) {
  94                         bookmarkDatabase.bookmarkPost(post);
  95                         bookmarkDatabase.unbookmarkPost(post);
  96                 }
  97                 verify(configurationLoader, times(posts.size() * 2))
  98                                 .saveBookmarkedPosts(any(Set.class));
  99         }
 100
 101         @Test
 102         public void removingABookmarkRemovesTheCorrectBookmark() {
 103                 Set<Post> allPosts = new HashSet<Post>(posts.values());
 104                 for (Post post : allPosts) {
 105                         bookmarkDatabase.bookmarkPost(post);
 106                 }
 107                 Post randomPost = posts.values().iterator().next();
 108                 bookmarkDatabase.unbookmarkPost(randomPost);
 109                 allPosts.remove(randomPost);
 110                 assertThat(bookmarkDatabase.getBookmarkedPosts(), is(allPosts));
 111                 for (Post post : posts.values()) {
 112                         assertThat(bookmarkDatabase.isPostBookmarked(post),
 113                                         is(!post.equals(randomPost)));
 114                 }
 115         }
 116
 117         @Test
 118         public void startingTheDatabaseLoadsBookmarkedPosts() {
 119                 bookmarkDatabase.start();
 120                 verify(configurationLoader).loadBookmarkedPosts();
 121         }
 122
 123         @Test
 124         public void stoppingTheDatabaseSavesTheBookmarkedPosts() {
 125                 bookmarkDatabase.stop();
 126                 verify(configurationLoader).saveBookmarkedPosts(any(Set.class));
 127         }
 128
 129         @Test
 130         public void bookmarkedPostsIncludeNotYetLoadedPosts() {
 131                 bookmarkDatabase.bookmarkPost(posts.get("PostId1"));
 132                 bookmarkDatabase.bookmarkPost(createPost("PostId3"));
 133                 final Set<Post> bookmarkedPosts =
 134                                 bookmarkDatabase.getBookmarkedPosts();
 135                 assertThat(bookmarkedPosts,
 136                                 contains(isPostWithId("PostId1"), isPostWithId("PostId3")));
 137         }
 138
 139 }