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

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