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

   1 /*
   2  * Sone - MemoryDatabaseTest.java - Copyright © 2013 David Roden
   3  *
   4  * This program is free software: you can redistribute it and/or modify
   5  * it under the terms of the GNU General Public License as published by
   6  * the Free Software Foundation, either version 3 of the License, or
   7  * (at your option) any later version.
   8  *
   9  * This program is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  * GNU General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License
  15  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  16  */
  17
  18 package net.pterodactylus.sone.database.memory;
  19
  20 import static com.google.common.base.Optional.of;
  21 import static java.util.Arrays.asList;
  22 import static java.util.UUID.randomUUID;
  23 import static net.pterodactylus.sone.Matchers.isAlbum;
  24 import static net.pterodactylus.sone.Matchers.isImage;
  25 import static net.pterodactylus.sone.Matchers.isPost;
  26 import static net.pterodactylus.sone.Matchers.isPostReply;
  27 import static org.hamcrest.CoreMatchers.is;
  28 import static org.hamcrest.MatcherAssert.assertThat;
  29 import static org.hamcrest.Matchers.contains;
  30 import static org.hamcrest.Matchers.containsInAnyOrder;
  31 import static org.hamcrest.Matchers.empty;
  32 import static org.hamcrest.Matchers.emptyIterable;
  33 import static org.mockito.Matchers.anyString;
  34 import static org.mockito.Mockito.mock;
  35 import static org.mockito.Mockito.never;
  36 import static org.mockito.Mockito.times;
  37 import static org.mockito.Mockito.verify;
  38 import static org.mockito.Mockito.when;
  39
  40 import java.util.Collection;
  41 import java.util.HashMap;
  42 import java.util.HashSet;
  43 import java.util.List;
  44 import java.util.Map;
  45 import java.util.Set;
  46
  47 import net.pterodactylus.sone.Matchers.IncompletePostMatcher;
  48 import net.pterodactylus.sone.TestAlbumBuilder;
  49 import net.pterodactylus.sone.TestImageBuilder;
  50 import net.pterodactylus.sone.TestPostBuilder;
  51 import net.pterodactylus.sone.TestPostReplyBuilder;
  52 import net.pterodactylus.sone.TestValue;
  53 import net.pterodactylus.sone.data.Album;
  54 import net.pterodactylus.sone.data.impl.AlbumImpl;
  55 import net.pterodactylus.sone.data.Image;
  56 import net.pterodactylus.sone.data.Post;
  57 import net.pterodactylus.sone.data.PostReply;
  58 import net.pterodactylus.sone.data.Sone;
  59 import net.pterodactylus.util.config.Configuration;
  60 import net.pterodactylus.util.config.Value;
  61
  62 import com.google.common.base.Optional;
  63 import org.junit.Before;
  64 import org.junit.Test;
  65 import org.mockito.invocation.InvocationOnMock;
  66 import org.mockito.stubbing.Answer;
  67
  68 /**
  69  * Tests for {@link MemoryDatabase}.
  70  *
  71  * @author <a href="mailto:bombe@pterodactylus.net">David ‘Bombe’ Roden</a>
  72  */
  73 public class MemoryDatabaseTest {
  74
  75         private static final String SONE_ID = "sone";
  76         private static final String RECIPIENT_ID = "recipient";
  77         private final Configuration configuration = mock(Configuration.class);
  78         private final MemoryDatabase memoryDatabase = new MemoryDatabase(null, configuration);
  79         private final Sone sone = mock(Sone.class);
  80
  81         @Before
  82         public void setupSone() {
  83                 when(sone.getId()).thenReturn(SONE_ID);
  84         }
  85
  86         @Test
  87         public void storedSoneIsMadeAvailable() {
  88                 Post firstPost = new TestPostBuilder().withId("post1")
  89                                 .from(SONE_ID)
  90                                 .withTime(1000L)
  91                                 .withText("post1")
  92                                 .build();
  93                 Post secondPost = new TestPostBuilder().withId("post2")
  94                                 .from(SONE_ID)
  95                                 .withTime(2000L)
  96                                 .withText("post2")
  97                                 .to(RECIPIENT_ID)
  98                                 .build();
  99                 List<Post> posts = asList(firstPost, secondPost);
 100                 when(sone.getPosts()).thenReturn(posts);
 101                 PostReply firstPostFirstReply =
 102                                 new TestPostReplyBuilder().withId("reply1")
 103                                                 .from(SONE_ID)
 104                                                 .to(firstPost.getId())
 105                                                 .withTime(3000L)
 106                                                 .withText("reply1")
 107                                                 .build();
 108                 PostReply firstPostSecondReply =
 109                                 new TestPostReplyBuilder().withId("reply3")
 110                                                 .from(RECIPIENT_ID)
 111                                                 .to(firstPost.getId())
 112                                                 .withTime(5000L)
 113                                                 .withText("reply3")
 114                                                 .build();
 115                 PostReply secondPostReply =
 116                                 new TestPostReplyBuilder().withId("reply2")
 117                                                 .from(SONE_ID)
 118                                                 .to(secondPost.getId())
 119                                                 .withTime(4000L)
 120                                                 .withText("reply2")
 121                                                 .build();
 122                 Set<PostReply> postReplies = new HashSet<PostReply>(
 123                                 asList(firstPostFirstReply, firstPostSecondReply,
 124                                                 secondPostReply));
 125                 when(sone.getReplies()).thenReturn(postReplies);
 126                 Album firstAlbum = new TestAlbumBuilder().withId("album1")
 127                                 .by(sone)
 128                                 .build()
 129                                 .modify()
 130                                 .setTitle("album1")
 131                                 .setDescription("album-description1")
 132                                 .update();
 133                 Album secondAlbum = new TestAlbumBuilder().withId("album2").by(
 134                                 sone).build().modify().setTitle("album2").setDescription(
 135                                 "album-description2").setAlbumImage("image1").update();
 136                 Album thirdAlbum = new TestAlbumBuilder().withId("album3").by(
 137                                 sone).build().modify().setTitle("album3").setDescription(
 138                                 "album-description3").update();
 139                 firstAlbum.addAlbum(thirdAlbum);
 140                 Album rootAlbum = mock(Album.class);
 141                 when(rootAlbum.getAlbums()).thenReturn(
 142                                 asList(firstAlbum, secondAlbum));
 143                 when(sone.getRootAlbum()).thenReturn(rootAlbum);
 144                 Image firstImage = new TestImageBuilder().withId("image1")
 145                                 .build()
 146                                 .modify()
 147                                 .setSone(sone)
 148                                 .setCreationTime(1000L)
 149                                 .setKey("KSK@image1")
 150                                 .setTitle("image1")
 151                                 .setDescription("image-description1")
 152                                 .setWidth(16)
 153                                 .setHeight(9)
 154                                 .update();
 155                 Image secondImage = new TestImageBuilder().withId("image2")
 156                                 .build()
 157                                 .modify()
 158                                 .setSone(sone)
 159                                 .setCreationTime(2000L)
 160                                 .setKey("KSK@image2")
 161                                 .setTitle("image2")
 162                                 .setDescription("image-description2")
 163                                 .setWidth(32)
 164                                 .setHeight(18)
 165                                 .update();
 166                 Image thirdImage = new TestImageBuilder().withId("image3")
 167                                 .build()
 168                                 .modify()
 169                                 .setSone(sone)
 170                                 .setCreationTime(3000L)
 171                                 .setKey("KSK@image3")
 172                                 .setTitle("image3")
 173                                 .setDescription("image-description3")
 174                                 .setWidth(48)
 175                                 .setHeight(27)
 176                                 .update();
 177                 firstAlbum.addImage(firstImage);
 178                 firstAlbum.addImage(thirdImage);
 179                 secondAlbum.addImage(secondImage);
 180                 memoryDatabase.storeSone(sone);
 181                 assertThat(memoryDatabase.getPost("post1").get(),
 182                                 isPost(firstPost.getId(), 1000L, "post1",
 183                                                 Optional.<String>absent()));
 184                 assertThat(memoryDatabase.getPost("post2").get(),
 185                                 isPost(secondPost.getId(), 2000L, "post2", of(RECIPIENT_ID)));
 186                 assertThat(memoryDatabase.getPost("post3").isPresent(), is(false));
 187                 assertThat(memoryDatabase.getPostReply("reply1").get(),
 188                                 isPostReply("reply1", "post1", 3000L, "reply1"));
 189                 assertThat(memoryDatabase.getPostReply("reply2").get(),
 190                                 isPostReply("reply2", "post2", 4000L, "reply2"));
 191                 assertThat(memoryDatabase.getPostReply("reply3").get(),
 192                                 isPostReply("reply3", "post1", 5000L, "reply3"));
 193                 assertThat(memoryDatabase.getPostReply("reply4").isPresent(),
 194                                 is(false));
 195                 assertThat(memoryDatabase.getAlbum("album1").get(),
 196                                 isAlbum("album1", null, "album1", "album-description1",
 197                                                 null));
 198                 assertThat(memoryDatabase.getAlbum("album2").get(),
 199                                 isAlbum("album2", null, "album2", "album-description2",
 200                                                 "image1"));
 201                 assertThat(memoryDatabase.getAlbum("album3").get(),
 202                                 isAlbum("album3", "album1", "album3", "album-description3",
 203                                                 null));
 204                 assertThat(memoryDatabase.getAlbum("album4").isPresent(), is(false));
 205                 assertThat(memoryDatabase.getImage("image1").get(),
 206                                 isImage("image1", 1000L, "KSK@image1", "image1",
 207                                                 "image-description1", 16, 9));
 208                 assertThat(memoryDatabase.getImage("image2").get(),
 209                                 isImage("image2", 2000L, "KSK@image2", "image2",
 210                                                 "image-description2", 32, 18));
 211                 assertThat(memoryDatabase.getImage("image3").get(),
 212                                 isImage("image3", 3000L, "KSK@image3", "image3",
 213                                                 "image-description3", 48, 27));
 214                 assertThat(memoryDatabase.getImage("image4").isPresent(), is(false));
 215         }
 216
 217         @Test
 218         public void storedAndRemovedSoneIsNotAvailable() {
 219             storedSoneIsMadeAvailable();
 220                 memoryDatabase.removeSone(sone);
 221                 assertThat(memoryDatabase.getSones(), empty());
 222         }
 223
 224         @Test
 225         public void postRecipientsAreDetectedCorrectly() {
 226                 Post postWithRecipient = createPost(of(RECIPIENT_ID));
 227                 memoryDatabase.storePost(postWithRecipient);
 228                 Post postWithoutRecipient = createPost(Optional.<String>absent());
 229                 memoryDatabase.storePost(postWithoutRecipient);
 230                 assertThat(memoryDatabase.getDirectedPosts(RECIPIENT_ID),
 231                                 contains(IncompletePostMatcher.matches().recipient(RECIPIENT_ID)));
 232         }
 233
 234         private Post createPost(Optional<String> recipient) {
 235                 Post postWithRecipient = mock(Post.class);
 236                 when(postWithRecipient.getId()).thenReturn(randomUUID().toString());
 237                 when(postWithRecipient.getSone()).thenReturn(sone);
 238                 when(postWithRecipient.getRecipientId()).thenReturn(recipient);
 239                 return postWithRecipient;
 240         }
 241
 242         @Test
 243         public void postRepliesAreManagedCorrectly() {
 244                 Post firstPost = createPost(Optional.<String>absent());
 245                 PostReply firstPostFirstReply = createPostReply(firstPost, 1000L);
 246                 Post secondPost = createPost(Optional.<String>absent());
 247                 PostReply secondPostFirstReply = createPostReply(secondPost, 1000L);
 248                 PostReply secondPostSecondReply = createPostReply(secondPost, 2000L);
 249                 memoryDatabase.storePost(firstPost);
 250                 memoryDatabase.storePost(secondPost);
 251                 memoryDatabase.storePostReply(firstPostFirstReply);
 252                 memoryDatabase.storePostReply(secondPostFirstReply);
 253                 memoryDatabase.storePostReply(secondPostSecondReply);
 254                 assertThat(memoryDatabase.getReplies(firstPost.getId()),
 255                                 contains(firstPostFirstReply));
 256                 assertThat(memoryDatabase.getReplies(secondPost.getId()),
 257                                 contains(secondPostFirstReply, secondPostSecondReply));
 258         }
 259
 260         private PostReply createPostReply(Post post, long time) {
 261                 PostReply postReply = mock(PostReply.class);
 262                 when(postReply.getId()).thenReturn(randomUUID().toString());
 263                 when(postReply.getTime()).thenReturn(time);
 264                 when(postReply.getPost()).thenReturn(of(post));
 265                 final String postId = post.getId();
 266                 when(postReply.getPostId()).thenReturn(postId);
 267                 return postReply;
 268         }
 269
 270         @Test
 271         public void testBasicAlbumFunctionality() {
 272                 Album newAlbum = new AlbumImpl(mock(Sone.class));
 273                 assertThat(memoryDatabase.getAlbum(newAlbum.getId()), is(Optional.<Album>absent()));
 274                 memoryDatabase.storeAlbum(newAlbum);
 275                 assertThat(memoryDatabase.getAlbum(newAlbum.getId()), is(of(newAlbum)));
 276                 memoryDatabase.removeAlbum(newAlbum);
 277                 assertThat(memoryDatabase.getAlbum(newAlbum.getId()), is(Optional.<Album>absent()));
 278         }
 279
 280         private void initializeFriends() {
 281                 when(configuration.getStringValue("Sone/" + SONE_ID + "/Friends/0/ID")).thenReturn(
 282                                 TestValue.from("Friend1"));
 283                 when(configuration.getStringValue("Sone/" + SONE_ID + "/Friends/1/ID")).thenReturn(
 284                                 TestValue.from("Friend2"));
 285                 when(configuration.getStringValue("Sone/" + SONE_ID + "/Friends/2/ID")).thenReturn(
 286                                 TestValue.<String>from(null));
 287         }
 288
 289         @Test
 290         public void friendsAreReturnedCorrectly() {
 291                 initializeFriends();
 292                 when(sone.isLocal()).thenReturn(true);
 293                 Collection<String> friends = memoryDatabase.getFriends(sone);
 294                 assertThat(friends, containsInAnyOrder("Friend1", "Friend2"));
 295         }
 296
 297         @Test
 298         public void friendsAreOnlyLoadedOnceFromConfiguration() {
 299                 friendsAreReturnedCorrectly();
 300                 memoryDatabase.getFriends(sone);
 301                 verify(configuration).getStringValue("Sone/" + SONE_ID + "/Friends/0/ID");
 302         }
 303
 304         @Test
 305         public void friendsAreOnlyReturnedForLocalSones() {
 306                 Collection<String> friends = memoryDatabase.getFriends(sone);
 307                 assertThat(friends, emptyIterable());
 308                 verify(configuration, never()).getStringValue("Sone/" + SONE_ID + "/Friends/0/ID");
 309         }
 310
 311         @Test
 312         public void checkingForAFriendReturnsTrue() {
 313                 initializeFriends();
 314                 when(sone.isLocal()).thenReturn(true);
 315                 assertThat(memoryDatabase.isFriend(sone, "Friend1"), is(true));
 316         }
 317
 318         @Test
 319         public void checkingForAFriendThatIsNotAFriendReturnsFalse() {
 320                 initializeFriends();
 321                 when(sone.isLocal()).thenReturn(true);
 322                 assertThat(memoryDatabase.isFriend(sone, "FriendX"), is(false));
 323         }
 324
 325         @Test
 326         public void checkingForAFriendOfRemoteSoneReturnsFalse() {
 327                 initializeFriends();
 328                 assertThat(memoryDatabase.isFriend(sone, "Friend1"), is(false));
 329         }
 330
 331         private Map<String, Value<String>> prepareConfigurationValues() {
 332                 final Map<String, Value<String>> configurationValues = new HashMap<String, Value<String>>();
 333                 when(configuration.getStringValue(anyString())).thenAnswer(new Answer<Value<String>>() {
 334                         @Override
 335                         public Value<String> answer(InvocationOnMock invocation) throws Throwable {
 336                                 Value<String> stringValue = TestValue.from(null);
 337                                 configurationValues.put((String) invocation.getArguments()[0], stringValue);
 338                                 return stringValue;
 339                         }
 340                 });
 341                 return configurationValues;
 342         }
 343
 344         @Test
 345         public void friendIsAddedCorrectlyToLocalSone() {
 346                 Map<String, Value<String>> configurationValues = prepareConfigurationValues();
 347                 when(sone.isLocal()).thenReturn(true);
 348                 memoryDatabase.addFriend(sone, "Friend1");
 349                 assertThat(configurationValues.get("Sone/" + SONE_ID + "/Friends/0/ID"),
 350                                 is(TestValue.from("Friend1")));
 351                 assertThat(configurationValues.get("Sone/" + SONE_ID + "/Friends/1/ID"),
 352                                 is(TestValue.<String>from(null)));
 353         }
 354
 355         @Test
 356         public void friendIsNotAddedToRemoteSone() {
 357                 memoryDatabase.addFriend(sone, "Friend1");
 358                 verify(configuration, never()).getStringValue(anyString());
 359         }
 360
 361         @Test
 362         public void configurationIsWrittenOnceIfFriendIsAddedTwice() {
 363                 prepareConfigurationValues();
 364                 when(sone.isLocal()).thenReturn(true);
 365                 memoryDatabase.addFriend(sone, "Friend1");
 366                 memoryDatabase.addFriend(sone, "Friend1");
 367                 verify(configuration, times(3)).getStringValue(anyString());
 368         }
 369
 370         @Test
 371         public void friendIsRemovedCorrectlyFromLocalSone() {
 372                 Map<String, Value<String>> configurationValues = prepareConfigurationValues();
 373                 when(sone.isLocal()).thenReturn(true);
 374                 memoryDatabase.addFriend(sone, "Friend1");
 375                 memoryDatabase.removeFriend(sone, "Friend1");
 376                 assertThat(configurationValues.get("Sone/" + SONE_ID + "/Friends/0/ID"),
 377                                 is(TestValue.<String>from(null)));
 378                 assertThat(configurationValues.get("Sone/" + SONE_ID + "/Friends/1/ID"),
 379                                 is(TestValue.<String>from(null)));
 380         }
 381
 382         @Test
 383         public void configurationIsNotWrittenWhenANonFriendIsRemoved() {
 384                 prepareConfigurationValues();
 385                 when(sone.isLocal()).thenReturn(true);
 386                 memoryDatabase.removeFriend(sone, "Friend1");
 387                 verify(configuration).getStringValue(anyString());
 388         }
 389
 390 }