Add test for page that shows bookmarked posts
[Sone.git] / src / test / java / net / pterodactylus / sone / core / SoneParserTest.java
1 package net.pterodactylus.sone.core;
2
3 import static com.google.common.base.Optional.of;
4 import static freenet.keys.InsertableClientSSK.createRandom;
5 import static java.lang.System.currentTimeMillis;
6 import static java.util.UUID.randomUUID;
7 import static java.util.concurrent.TimeUnit.DAYS;
8 import static org.hamcrest.MatcherAssert.assertThat;
9 import static org.hamcrest.Matchers.hasSize;
10 import static org.hamcrest.Matchers.is;
11 import static org.hamcrest.Matchers.not;
12 import static org.hamcrest.Matchers.notNullValue;
13 import static org.hamcrest.Matchers.nullValue;
14 import static org.mockito.ArgumentMatchers.any;
15 import static org.mockito.ArgumentMatchers.anyLong;
16 import static org.mockito.ArgumentMatchers.anyString;
17 import static org.mockito.Mockito.doAnswer;
18 import static org.mockito.Mockito.mock;
19 import static org.mockito.Mockito.when;
20
21 import java.io.InputStream;
22 import java.net.MalformedURLException;
23 import java.util.ArrayList;
24 import java.util.HashMap;
25 import java.util.HashSet;
26 import java.util.List;
27 import java.util.Map;
28 import java.util.Set;
29
30 import net.pterodactylus.sone.data.Album;
31 import net.pterodactylus.sone.data.Album.Modifier;
32 import net.pterodactylus.sone.data.Client;
33 import net.pterodactylus.sone.data.Image;
34 import net.pterodactylus.sone.data.Post;
35 import net.pterodactylus.sone.data.PostReply;
36 import net.pterodactylus.sone.data.Profile;
37 import net.pterodactylus.sone.data.Sone;
38 import net.pterodactylus.sone.database.AlbumBuilder;
39 import net.pterodactylus.sone.database.ImageBuilder;
40 import net.pterodactylus.sone.database.PostBuilder;
41 import net.pterodactylus.sone.database.PostReplyBuilder;
42 import net.pterodactylus.sone.database.SoneBuilder;
43 import net.pterodactylus.sone.database.memory.MemorySoneBuilder;
44 import net.pterodactylus.sone.freenet.wot.Identity;
45 import net.pterodactylus.sone.freenet.wot.OwnIdentity;
46
47 import freenet.crypt.DummyRandomSource;
48 import freenet.keys.FreenetURI;
49 import freenet.keys.InsertableClientSSK;
50
51 import com.google.common.base.Optional;
52 import com.google.common.collect.ArrayListMultimap;
53 import com.google.common.collect.ImmutableSet;
54 import com.google.common.collect.ListMultimap;
55 import org.junit.Before;
56 import org.junit.Test;
57 import org.mockito.invocation.InvocationOnMock;
58 import org.mockito.stubbing.Answer;
59
60 /**
61  * Unit test for {@link SoneParser}.
62  *
63  * @author <a href="mailto:bombe@pterodactylus.net">David ‘Bombe’ Roden</a>
64  */
65 public class SoneParserTest {
66
67         private final Core core = mock(Core.class);
68         private final SoneParser soneParser = new SoneParser(core);
69         private final Sone sone = mock(Sone.class);
70         private FreenetURI requestUri = mock(FreenetURI.class);
71         private final PostBuilder postBuilder = mock(PostBuilder.class);
72         private final List<Post> createdPosts = new ArrayList<Post>();
73         private Post post = mock(Post.class);
74         private final PostReplyBuilder postReplyBuilder = mock(PostReplyBuilder.class);
75         private final Set<PostReply> createdPostReplies = new HashSet<PostReply>();
76         private PostReply postReply = mock(PostReply.class);
77         private final AlbumBuilder albumBuilder = mock(AlbumBuilder.class);
78         private final ListMultimap<Album, Album>
79                         nestedAlbums = ArrayListMultimap.create();
80         private final ListMultimap<Album, Image> albumImages = ArrayListMultimap.create();
81         private Album album = mock(Album.class);
82         private final Map<String, Album> albums = new HashMap<String, Album>();
83         private final ImageBuilder imageBuilder = mock(ImageBuilder.class);
84         private Image image = mock(Image.class);
85         private final Map<String, Image> images = new HashMap<String, Image>();
86
87         @Before
88         public void setupSone() {
89                 setupSone(this.sone, Identity.class);
90         }
91
92         private void setupSone(Sone sone, Class<? extends Identity> identityClass) {
93                 Identity identity = mock(identityClass);
94                 InsertableClientSSK clientSSK =
95                                 createRandom(new DummyRandomSource(), "WoT");
96                 when(identity.getRequestUri()).thenReturn(clientSSK.getURI().toString());
97                 when(identity.getId()).thenReturn("identity");
98                 when(sone.getId()).thenReturn("identity");
99                 when(sone.getIdentity()).thenReturn(identity);
100                 requestUri = clientSSK.getURI().setKeyType("USK").setDocName("Sone");
101                 when(sone.getRequestUri()).thenAnswer(new Answer<FreenetURI>() {
102                         @Override
103                         public FreenetURI answer(InvocationOnMock invocation)
104                         throws Throwable {
105                                 return requestUri;
106                         }
107                 });
108                 when(sone.getTime())
109                                 .thenReturn(currentTimeMillis() - DAYS.toMillis(1));
110         }
111
112         @Before
113         public void setupSoneBuilder() {
114                 when(core.soneBuilder()).thenAnswer(new Answer<SoneBuilder>() {
115                         @Override
116                         public SoneBuilder answer(InvocationOnMock invocation) {
117                                 return new MemorySoneBuilder(null);
118                         }
119                 });
120         }
121
122         @Before
123         public void setupPost() {
124                 when(post.getRecipientId()).thenReturn(Optional.<String>absent());
125         }
126
127         @Before
128         public void setupPostBuilder() {
129                 when(postBuilder.withId(anyString())).thenAnswer(new Answer<PostBuilder>() {
130                         @Override
131                         public PostBuilder answer(InvocationOnMock invocation) throws Throwable {
132                                 when(post.getId()).thenReturn((String) invocation.getArguments()[0]);
133                                 return postBuilder;
134                         }
135                 });
136                 when(postBuilder.from(anyString())).thenAnswer(new Answer<PostBuilder>() {
137                         @Override
138                         public PostBuilder answer(InvocationOnMock invocation) throws Throwable {
139                                 final Sone sone = mock(Sone.class);
140                                 when(sone.getId()).thenReturn((String) invocation.getArguments()[0]);
141                                 when(post.getSone()).thenReturn(sone);
142                                 return postBuilder;
143                         }
144                 });
145                 when(postBuilder.withTime(anyLong())).thenAnswer(new Answer<PostBuilder>() {
146                         @Override
147                         public PostBuilder answer(InvocationOnMock invocation) throws Throwable {
148                                 when(post.getTime()).thenReturn((Long) invocation.getArguments()[0]);
149                                 return postBuilder;
150                         }
151                 });
152                 when(postBuilder.withText(anyString())).thenAnswer(new Answer<PostBuilder>() {
153                         @Override
154                         public PostBuilder answer(InvocationOnMock invocation) throws Throwable {
155                                 when(post.getText()).thenReturn((String) invocation.getArguments()[0]);
156                                 return postBuilder;
157                         }
158                 });
159                 when(postBuilder.to(anyString())).thenAnswer(new Answer<PostBuilder>() {
160                         @Override
161                         public PostBuilder answer(InvocationOnMock invocation) throws Throwable {
162                                 when(post.getRecipientId()).thenReturn(of((String) invocation.getArguments()[0]));
163                                 return postBuilder;
164                         }
165                 });
166                 when(postBuilder.build()).thenAnswer(new Answer<Post>() {
167                         @Override
168                         public Post answer(InvocationOnMock invocation) throws Throwable {
169                                 Post post = SoneParserTest.this.post;
170                                 SoneParserTest.this.post = mock(Post.class);
171                                 setupPost();
172                                 createdPosts.add(post);
173                                 return post;
174                         }
175                 });
176                 when(core.postBuilder()).thenReturn(postBuilder);
177         }
178
179         @Before
180         public void setupPostReplyBuilder() {
181                 when(postReplyBuilder.withId(anyString())).thenAnswer(new Answer<PostReplyBuilder>() {
182                         @Override
183                         public PostReplyBuilder answer(InvocationOnMock invocation) throws Throwable {
184                                 when(postReply.getId()).thenReturn((String) invocation.getArguments()[0]);
185                                 return postReplyBuilder;
186                         }
187                 });
188                 when(postReplyBuilder.from(anyString())).thenAnswer(
189                                 new Answer<PostReplyBuilder>() {
190                                         @Override
191                                         public PostReplyBuilder answer(
192                                                         InvocationOnMock invocation) throws Throwable {
193                                                 Sone sone = when(mock(Sone.class).getId()).thenReturn(
194                                                                 (String) invocation.getArguments()[0])
195                                                                 .getMock();
196                                                 when(postReply.getSone()).thenReturn(sone);
197                                                 return postReplyBuilder;
198                                         }
199                                 });
200                 when(postReplyBuilder.to(anyString())).thenAnswer(
201                                 new Answer<PostReplyBuilder>() {
202                                         @Override
203                                         public PostReplyBuilder answer(
204                                                         InvocationOnMock invocation) throws Throwable {
205                                                 when(postReply.getPostId()).thenReturn(
206                                                                 (String) invocation.getArguments()[0]);
207                                                 Post post = when(mock(Post.class).getId()).thenReturn(
208                                                                 (String) invocation.getArguments()[0])
209                                                                 .getMock();
210                                                 when(postReply.getPost()).thenReturn(of(post));
211                                                 return postReplyBuilder;
212                                         }
213                                 });
214                 when(postReplyBuilder.withTime(anyLong())).thenAnswer(
215                                 new Answer<PostReplyBuilder>() {
216                                         @Override
217                                         public PostReplyBuilder answer(
218                                                         InvocationOnMock invocation) throws Throwable {
219                                                 when(postReply.getTime()).thenReturn(
220                                                                 (Long) invocation.getArguments()[0]);
221                                                 return postReplyBuilder;
222                                         }
223                                 });
224                 when(postReplyBuilder.withText(anyString())).thenAnswer(new Answer<PostReplyBuilder>() {
225                         @Override
226                         public PostReplyBuilder answer(InvocationOnMock invocation) throws Throwable {
227                                 when(postReply.getText()).thenReturn((String) invocation.getArguments()[0]);
228                                 return postReplyBuilder;
229                         }
230                 });
231                 when(postReplyBuilder.build()).thenAnswer(new Answer<PostReply>() {
232                         @Override
233                         public PostReply answer(InvocationOnMock invocation) throws Throwable {
234                                 PostReply postReply = SoneParserTest.this.postReply;
235                                 createdPostReplies.add(postReply);
236                                 SoneParserTest.this.postReply = mock(PostReply.class);
237                                 return postReply;
238                         }
239                 });
240                 when(core.postReplyBuilder()).thenReturn(postReplyBuilder);
241         }
242
243         @Before
244         public void setupAlbum() {
245                 final Album album = SoneParserTest.this.album;
246                 doAnswer(new Answer<Void>() {
247                         @Override
248                         public Void answer(InvocationOnMock invocation) {
249                                 nestedAlbums.put(album, (Album) invocation.getArguments()[0]);
250                                 return null;
251                         }
252                 }).when(album).addAlbum(any(Album.class));
253                 doAnswer(new Answer<Void>() {
254                         @Override
255                         public Void answer(InvocationOnMock invocation) {
256                                 albumImages.put(album, (Image) invocation.getArguments()[0]);
257                                 return null;
258                         }
259                 }).when(album).addImage(any(Image.class));
260                 when(album.getAlbums()).thenAnswer(new Answer<List<Album>>() {
261                         @Override
262                         public List<Album> answer(InvocationOnMock invocation) {
263                                 return nestedAlbums.get(album);
264                         }
265                 });
266                 when(album.getImages()).thenAnswer(new Answer<List<Image>>() {
267                         @Override
268                         public List<Image> answer(InvocationOnMock invocation) {
269                                 return albumImages.get(album);
270                         }
271                 });
272                 final Modifier albumModifier = new Modifier() {
273                         private String title = album.getTitle();
274                         private String description = album.getDescription();
275
276                         @Override
277                         public Modifier setTitle(String title) {
278                                 this.title = title;
279                                 return this;
280                         }
281
282                         @Override
283                         public Modifier setDescription(String description) {
284                                 this.description = description;
285                                 return this;
286                         }
287
288                         @Override
289                         public Album update() throws IllegalStateException {
290                                 when(album.getTitle()).thenReturn(title);
291                                 when(album.getDescription()).thenReturn(description);
292                                 return album;
293                         }
294                 };
295                 when(album.modify()).thenReturn(albumModifier);
296         }
297
298         @Before
299         public void setupAlbumBuilder() {
300                 when(albumBuilder.withId(anyString())).thenAnswer(new Answer<AlbumBuilder>() {
301                         @Override
302                         public AlbumBuilder answer(InvocationOnMock invocation) {
303                                 when(album.getId()).thenReturn((String) invocation.getArguments()[0]);
304                                 return albumBuilder;
305                         }
306                 });
307                 when(albumBuilder.randomId()).thenAnswer(new Answer<AlbumBuilder>() {
308                         @Override
309                         public AlbumBuilder answer(InvocationOnMock invocation) {
310                                 when(album.getId()).thenReturn(randomUUID().toString());
311                                 return albumBuilder;
312                         }
313                 });
314                 when(albumBuilder.by(any(Sone.class))).thenAnswer(new Answer<AlbumBuilder>() {
315                         @Override
316                         public AlbumBuilder answer(InvocationOnMock invocation) {
317                                 when(album.getSone()).thenReturn((Sone) invocation.getArguments()[0]);
318                                 return albumBuilder;
319                         }
320                 });
321                 when(albumBuilder.build()).thenAnswer(new Answer<Album>() {
322                         @Override
323                         public Album answer(InvocationOnMock invocation) {
324                                 Album album = SoneParserTest.this.album;
325                                 albums.put(album.getId(), album);
326                                 SoneParserTest.this.album = mock(Album.class);
327                                 setupAlbum();
328                                 return album;
329                         }
330                 });
331                 when(core.albumBuilder()).thenReturn(albumBuilder);
332         }
333
334         @Before
335         public void setupAlbums() {
336                 when(core.getAlbum(anyString())).thenAnswer(new Answer<Album>() {
337                         @Override
338                         public Album answer(InvocationOnMock invocation)
339                         throws Throwable {
340                                 return albums.get(invocation.getArguments()[0]);
341                         }
342                 });
343         }
344
345         @Before
346         public void setupImage() {
347                 final Image image = SoneParserTest.this.image;
348                 Image.Modifier modifier = new Image.Modifier() {
349                         private Sone sone = image.getSone();
350                         private long creationTime = image.getCreationTime();
351                         private String key = image.getKey();
352                         private String title = image.getTitle();
353                         private String description = image.getDescription();
354                         private int width = image.getWidth();
355                         private int height = image.getHeight();
356
357                         @Override
358                         public Image.Modifier setSone(Sone sone) {
359                                 this.sone = sone;
360                                 return this;
361                         }
362
363                         @Override
364                         public Image.Modifier setCreationTime(long creationTime) {
365                                 this.creationTime = creationTime;
366                                 return this;
367                         }
368
369                         @Override
370                         public Image.Modifier setKey(String key) {
371                                 this.key = key;
372                                 return this;
373                         }
374
375                         @Override
376                         public Image.Modifier setTitle(String title) {
377                                 this.title = title;
378                                 return this;
379                         }
380
381                         @Override
382                         public Image.Modifier setDescription(String description) {
383                                 this.description = description;
384                                 return this;
385                         }
386
387                         @Override
388                         public Image.Modifier setWidth(int width) {
389                                 this.width = width;
390                                 return this;
391                         }
392
393                         @Override
394                         public Image.Modifier setHeight(int height) {
395                                 this.height = height;
396                                 return this;
397                         }
398
399                         @Override
400                         public Image update() throws IllegalStateException {
401                                 when(image.getSone()).thenReturn(sone);
402                                 when(image.getCreationTime()).thenReturn(creationTime);
403                                 when(image.getKey()).thenReturn(key);
404                                 when(image.getTitle()).thenReturn(title);
405                                 when(image.getDescription()).thenReturn(description);
406                                 when(image.getWidth()).thenReturn(width);
407                                 when(image.getHeight()).thenReturn(height);
408                                 return image;
409                         }
410                 };
411                 when(image.getSone()).thenReturn(sone);
412                 when(image.modify()).thenReturn(modifier);
413         }
414
415         @Before
416         public void setupImageBuilder() {
417                 when(imageBuilder.randomId()).thenAnswer(new Answer<ImageBuilder>() {
418                         @Override
419                         public ImageBuilder answer(InvocationOnMock invocation) {
420                                 when(image.getId()).thenReturn(randomUUID().toString());
421                                 return imageBuilder;
422                         }
423                 });
424                 when(imageBuilder.withId(anyString())).thenAnswer(new Answer<ImageBuilder>() {
425                         @Override
426                         public ImageBuilder answer(InvocationOnMock invocation) {
427                                 when(image.getId()).thenReturn(
428                                                 (String) invocation.getArguments()[0]);
429                                 return imageBuilder;
430                         }
431                 });
432                 when(imageBuilder.build()).thenAnswer(new Answer<Image>() {
433                         @Override
434                         public Image answer(InvocationOnMock invocation) {
435                                 Image image = SoneParserTest.this.image;
436                                 images.put(image.getId(), image);
437                                 SoneParserTest.this.image = mock(Image.class);
438                                 setupImage();
439                                 return image;
440                         }
441                 });
442                 when(core.imageBuilder()).thenReturn(imageBuilder);
443         }
444
445         @Before
446         public void setupImages() {
447                 when(core.getImage(anyString())).thenAnswer(new Answer<Image>() {
448                         @Override
449                         public Image answer(InvocationOnMock invocation)
450                         throws Throwable {
451                                 return images.get(invocation.getArguments()[0]);
452                         }
453                 });
454         }
455         @Test
456         public void parsingASoneFailsWhenDocumentIsNotXml() throws SoneException {
457                 InputStream inputStream = getClass().getResourceAsStream("sone-parser-not-xml.xml");
458                 assertThat(soneParser.parseSone(sone, inputStream), nullValue());
459         }
460
461         @Test
462         public void parsingASoneFailsWhenDocumentHasNegativeProtocolVersion() throws SoneException {
463                 InputStream inputStream = getClass().getResourceAsStream("sone-parser-negative-protocol-version.xml");
464                 assertThat(soneParser.parseSone(sone, inputStream), nullValue());
465         }
466
467         @Test
468         public void parsingASoneFailsWhenProtocolVersionIsTooLarge() throws SoneException {
469                 InputStream inputStream = getClass().getResourceAsStream("sone-parser-too-large-protocol-version.xml");
470                 assertThat(soneParser.parseSone(sone, inputStream), nullValue());
471         }
472
473         @Test
474         public void parsingASoneFailsWhenThereIsNoTime() throws SoneException {
475                 InputStream inputStream = getClass().getResourceAsStream("sone-parser-no-time.xml");
476                 assertThat(soneParser.parseSone(sone, inputStream), nullValue());
477         }
478
479         @Test
480         public void parsingASoneFailsWhenTimeIsNotNumeric() throws SoneException {
481                 InputStream inputStream = getClass().getResourceAsStream("sone-parser-time-not-numeric.xml");
482                 assertThat(soneParser.parseSone(sone, inputStream), nullValue());
483         }
484
485         @Test
486         public void parsingASoneFailsWhenProfileIsMissing() throws SoneException {
487                 InputStream inputStream = getClass().getResourceAsStream("sone-parser-no-profile.xml");
488                 assertThat(soneParser.parseSone(sone, inputStream), nullValue());
489         }
490
491         @Test
492         public void parsingASoneFailsWhenProfileFieldIsMissingAFieldName() throws SoneException {
493                 InputStream inputStream = getClass().getResourceAsStream("sone-parser-profile-missing-field-name.xml");
494                 assertThat(soneParser.parseSone(sone, inputStream), nullValue());
495         }
496
497         @Test
498         public void parsingASoneFailsWhenProfileFieldNameIsEmpty() throws SoneException {
499                 InputStream inputStream = getClass().getResourceAsStream("sone-parser-profile-empty-field-name.xml");
500                 assertThat(soneParser.parseSone(sone, inputStream), nullValue());
501         }
502
503         @Test
504         public void parsingASoneFailsWhenProfileFieldNameIsNotUnique() throws SoneException {
505                 InputStream inputStream = getClass().getResourceAsStream("sone-parser-profile-duplicate-field-name.xml");
506                 assertThat(soneParser.parseSone(sone, inputStream), nullValue());
507         }
508
509         @Test
510         public void parsingASoneSucceedsWithoutPayload() throws SoneException {
511                 InputStream inputStream = getClass().getResourceAsStream("sone-parser-no-payload.xml");
512                 assertThat(soneParser.parseSone(sone, inputStream).getTime(), is(
513                                 1407197508000L));
514         }
515
516         @Test
517         public void parsingALocalSoneSucceedsWithoutPayload() throws SoneException {
518                 InputStream inputStream = getClass().getResourceAsStream("sone-parser-no-payload.xml");
519                 Sone localSone = mock(Sone.class);
520                 setupSone(localSone, OwnIdentity.class);
521                 when(localSone.isLocal()).thenReturn(true);
522                 Sone parsedSone = soneParser.parseSone(localSone, inputStream);
523                 assertThat(parsedSone.getTime(), is(1407197508000L));
524                 assertThat(parsedSone.isLocal(), is(true));
525         }
526
527         @Test
528         public void parsingASoneSucceedsWithoutProtocolVersion() throws SoneException {
529                 InputStream inputStream = getClass().getResourceAsStream("sone-parser-missing-protocol-version.xml");
530                 assertThat(soneParser.parseSone(sone, inputStream), not(
531                                 nullValue()));
532         }
533
534         @Test
535         public void parsingASoneFailsWithMissingClientName() throws SoneException {
536                 InputStream inputStream = getClass().getResourceAsStream("sone-parser-missing-client-name.xml");
537                 assertThat(soneParser.parseSone(sone, inputStream), nullValue());
538         }
539
540         @Test
541         public void parsingASoneFailsWithMissingClientVersion() throws SoneException {
542                 InputStream inputStream = getClass().getResourceAsStream("sone-parser-missing-client-version.xml");
543                 assertThat(soneParser.parseSone(sone, inputStream), nullValue());
544         }
545
546         @Test
547         public void parsingASoneSucceedsWithClientInfo() throws SoneException {
548                 InputStream inputStream = getClass().getResourceAsStream("sone-parser-with-client-info.xml");
549                 assertThat(soneParser.parseSone(sone, inputStream).getClient(), is(new Client("some-client", "some-version")));
550         }
551
552         @Test
553         public void parsingASoneSucceedsWithProfile() throws SoneException,
554         MalformedURLException {
555                 InputStream inputStream = getClass().getResourceAsStream("sone-parser-with-profile.xml");
556                 final Profile profile = soneParser.parseSone(sone, inputStream).getProfile();
557                 assertThat(profile.getFirstName(), is("first"));
558                 assertThat(profile.getMiddleName(), is("middle"));
559                 assertThat(profile.getLastName(), is("last"));
560                 assertThat(profile.getBirthDay(), is(18));
561                 assertThat(profile.getBirthMonth(), is(12));
562                 assertThat(profile.getBirthYear(), is(1976));
563         }
564
565         @Test
566         public void parsingASoneSucceedsWithoutProfileFields() throws SoneException, MalformedURLException {
567                 InputStream inputStream = getClass().getResourceAsStream("sone-parser-without-fields.xml");
568                 assertThat(soneParser.parseSone(sone, inputStream), notNullValue());
569         }
570
571         @Test
572         public void parsingASoneFailsWithoutPostId() throws SoneException, MalformedURLException {
573                 InputStream inputStream = getClass().getResourceAsStream("sone-parser-without-post-id.xml");
574                 assertThat(soneParser.parseSone(sone, inputStream), nullValue());
575         }
576
577         @Test
578         public void parsingASoneFailsWithoutPostTime() throws SoneException, MalformedURLException {
579                 InputStream inputStream = getClass().getResourceAsStream("sone-parser-without-post-time.xml");
580                 assertThat(soneParser.parseSone(sone, inputStream), nullValue());
581         }
582
583         @Test
584         public void parsingASoneFailsWithoutPostText() throws SoneException, MalformedURLException {
585                 InputStream inputStream = getClass().getResourceAsStream("sone-parser-without-post-text.xml");
586                 assertThat(soneParser.parseSone(sone, inputStream), nullValue());
587         }
588
589         @Test
590         public void parsingASoneFailsWithInvalidPostTime() throws SoneException, MalformedURLException {
591                 InputStream inputStream = getClass().getResourceAsStream("sone-parser-with-invalid-post-time.xml");
592                 assertThat(soneParser.parseSone(sone, inputStream), nullValue());
593         }
594
595         @Test
596         public void parsingASoneSucceedsWithValidPostTime() throws SoneException, MalformedURLException {
597                 InputStream inputStream = getClass().getResourceAsStream("sone-parser-with-valid-post-time.xml");
598                 final List<Post> posts = soneParser.parseSone(sone, inputStream).getPosts();
599                 assertThat(posts, is(createdPosts));
600                 assertThat(posts.get(0).getSone().getId(), is(sone.getId()));
601                 assertThat(posts.get(0).getId(), is("post-id"));
602                 assertThat(posts.get(0).getTime(), is(1407197508000L));
603                 assertThat(posts.get(0).getRecipientId(), is(Optional.<String>absent()));
604                 assertThat(posts.get(0).getText(), is("text"));
605         }
606
607         @Test
608         public void parsingASoneSucceedsWithRecipient() throws SoneException, MalformedURLException {
609                 InputStream inputStream = getClass().getResourceAsStream("sone-parser-with-recipient.xml");
610                 final List<Post> posts = soneParser.parseSone(sone, inputStream).getPosts();
611                 assertThat(posts, is(createdPosts));
612                 assertThat(posts.get(0).getSone().getId(), is(sone.getId()));
613                 assertThat(posts.get(0).getId(), is("post-id"));
614                 assertThat(posts.get(0).getTime(), is(1407197508000L));
615                 assertThat(posts.get(0).getRecipientId(), is(of(
616                                 "1234567890123456789012345678901234567890123")));
617                 assertThat(posts.get(0).getText(), is("text"));
618         }
619
620         @Test
621         public void parsingASoneSucceedsWithInvalidRecipient() throws SoneException, MalformedURLException {
622                 InputStream inputStream = getClass().getResourceAsStream("sone-parser-with-invalid-recipient.xml");
623                 final List<Post> posts = soneParser.parseSone(sone, inputStream).getPosts();
624                 assertThat(posts, is(createdPosts));
625                 assertThat(posts.get(0).getSone().getId(), is(sone.getId()));
626                 assertThat(posts.get(0).getId(), is("post-id"));
627                 assertThat(posts.get(0).getTime(), is(1407197508000L));
628                 assertThat(posts.get(0).getRecipientId(), is(Optional.<String>absent()));
629                 assertThat(posts.get(0).getText(), is("text"));
630         }
631
632         @Test
633         public void parsingASoneFailsWithoutPostReplyId() throws SoneException, MalformedURLException {
634                 InputStream inputStream = getClass().getResourceAsStream("sone-parser-without-post-reply-id.xml");
635                 assertThat(soneParser.parseSone(sone, inputStream), nullValue());
636         }
637
638         @Test
639         public void parsingASoneFailsWithoutPostReplyPostId() throws SoneException, MalformedURLException {
640                 InputStream inputStream = getClass().getResourceAsStream("sone-parser-without-post-reply-post-id.xml");
641                 assertThat(soneParser.parseSone(sone, inputStream), nullValue());
642         }
643
644         @Test
645         public void parsingASoneFailsWithoutPostReplyTime() throws SoneException, MalformedURLException {
646                 InputStream inputStream = getClass().getResourceAsStream("sone-parser-without-post-reply-time.xml");
647                 assertThat(soneParser.parseSone(sone, inputStream), nullValue());
648         }
649
650         @Test
651         public void parsingASoneFailsWithoutPostReplyText() throws SoneException, MalformedURLException {
652                 InputStream inputStream = getClass().getResourceAsStream("sone-parser-without-post-reply-text.xml");
653                 assertThat(soneParser.parseSone(sone, inputStream), nullValue());
654         }
655
656         @Test
657         public void parsingASoneFailsWithInvalidPostReplyTime() throws SoneException, MalformedURLException {
658                 InputStream inputStream = getClass().getResourceAsStream("sone-parser-with-invalid-post-reply-time.xml");
659                 assertThat(soneParser.parseSone(sone, inputStream), nullValue());
660         }
661
662         @Test
663         public void parsingASoneSucceedsWithValidPostReplyTime() throws SoneException, MalformedURLException {
664                 InputStream inputStream = getClass().getResourceAsStream("sone-parser-with-valid-post-reply-time.xml");
665                 final Set<PostReply> postReplies = soneParser.parseSone(sone, inputStream).getReplies();
666                 assertThat(postReplies, is(createdPostReplies));
667                 PostReply postReply = createdPostReplies.iterator().next();
668                 assertThat(postReply.getId(), is("reply-id"));
669                 assertThat(postReply.getPostId(), is("post-id"));
670                 assertThat(postReply.getPost().get().getId(), is("post-id"));
671                 assertThat(postReply.getSone().getId(), is("identity"));
672                 assertThat(postReply.getTime(), is(1407197508000L));
673                 assertThat(postReply.getText(), is("reply-text"));
674         }
675
676         @Test
677         public void parsingASoneSucceedsWithoutLikedPostIds() throws SoneException, MalformedURLException {
678                 InputStream inputStream = getClass().getResourceAsStream("sone-parser-without-liked-post-ids.xml");
679                 assertThat(soneParser.parseSone(sone, inputStream), not(
680                                 nullValue()));
681         }
682
683         @Test
684         public void parsingASoneSucceedsWithLikedPostIds() throws SoneException, MalformedURLException {
685                 InputStream inputStream = getClass().getResourceAsStream("sone-parser-with-liked-post-ids.xml");
686                 assertThat(soneParser.parseSone(sone, inputStream).getLikedPostIds(), is(
687                                 (Set<String>) ImmutableSet.of("liked-post-id")));
688         }
689
690         @Test
691         public void parsingASoneSucceedsWithoutLikedPostReplyIds() throws SoneException, MalformedURLException {
692                 InputStream inputStream = getClass().getResourceAsStream("sone-parser-without-liked-post-reply-ids.xml");
693                 assertThat(soneParser.parseSone(sone, inputStream), not(
694                                 nullValue()));
695         }
696
697         @Test
698         public void parsingASoneSucceedsWithLikedPostReplyIds() throws SoneException, MalformedURLException {
699                 InputStream inputStream = getClass().getResourceAsStream("sone-parser-with-liked-post-reply-ids.xml");
700                 assertThat(soneParser.parseSone(sone, inputStream).getLikedReplyIds(), is(
701                                 (Set<String>) ImmutableSet.of("liked-post-reply-id")));
702         }
703
704         @Test
705         public void parsingASoneSucceedsWithoutAlbums() throws SoneException, MalformedURLException {
706                 InputStream inputStream = getClass().getResourceAsStream("sone-parser-without-albums.xml");
707                 assertThat(soneParser.parseSone(sone, inputStream), not(
708                                 nullValue()));
709         }
710
711         @Test
712         public void parsingASoneFailsWithoutAlbumId() throws SoneException, MalformedURLException {
713                 InputStream inputStream = getClass().getResourceAsStream("sone-parser-without-album-id.xml");
714                 assertThat(soneParser.parseSone(sone, inputStream), nullValue());
715         }
716
717         @Test
718         public void parsingASoneFailsWithoutAlbumTitle() throws SoneException, MalformedURLException {
719                 InputStream inputStream = getClass().getResourceAsStream("sone-parser-without-album-title.xml");
720                 assertThat(soneParser.parseSone(sone, inputStream), nullValue());
721         }
722
723         @Test
724         public void parsingASoneSucceedsWithNestedAlbums() throws SoneException, MalformedURLException {
725                 InputStream inputStream = getClass().getResourceAsStream("sone-parser-with-multiple-albums.xml");
726                 final Sone parsedSone = soneParser.parseSone(sone, inputStream);
727                 assertThat(parsedSone, not(nullValue()));
728                 assertThat(parsedSone.getRootAlbum().getAlbums(), hasSize(1));
729                 Album album = parsedSone.getRootAlbum().getAlbums().get(0);
730                 assertThat(album.getId(), is("album-id-1"));
731                 assertThat(album.getTitle(), is("album-title"));
732                 assertThat(album.getDescription(), is("album-description"));
733                 assertThat(album.getAlbums(), hasSize(1));
734                 Album nestedAlbum = album.getAlbums().get(0);
735                 assertThat(nestedAlbum.getId(), is("album-id-2"));
736                 assertThat(nestedAlbum.getTitle(), is("album-title-2"));
737                 assertThat(nestedAlbum.getDescription(), is("album-description-2"));
738                 assertThat(nestedAlbum.getAlbums(), hasSize(0));
739         }
740
741         @Test
742         public void parsingASoneFailsWithInvalidParentAlbumId() throws SoneException, MalformedURLException {
743                 InputStream inputStream = getClass().getResourceAsStream("sone-parser-with-invalid-parent-album-id.xml");
744                 assertThat(soneParser.parseSone(sone, inputStream), nullValue());
745         }
746
747         @Test
748         public void parsingASoneSucceedsWithoutImages() throws SoneException, MalformedURLException {
749                 InputStream inputStream = getClass().getResourceAsStream("sone-parser-without-images.xml");
750                 assertThat(soneParser.parseSone(sone, inputStream), not(
751                                 nullValue()));
752         }
753
754         @Test
755         public void parsingASoneFailsWithoutImageId() throws SoneException, MalformedURLException {
756                 InputStream inputStream = getClass().getResourceAsStream("sone-parser-without-image-id.xml");
757                 assertThat(soneParser.parseSone(sone, inputStream), nullValue());
758         }
759
760         @Test
761         public void parsingASoneFailsWithoutImageTime() throws SoneException, MalformedURLException {
762                 InputStream inputStream = getClass().getResourceAsStream("sone-parser-without-image-time.xml");
763                 assertThat(soneParser.parseSone(sone, inputStream), nullValue());
764         }
765
766         @Test
767         public void parsingASoneFailsWithoutImageKey() throws SoneException, MalformedURLException {
768                 InputStream inputStream = getClass().getResourceAsStream("sone-parser-without-image-key.xml");
769                 assertThat(soneParser.parseSone(sone, inputStream), nullValue());
770         }
771
772         @Test
773         public void parsingASoneFailsWithoutImageTitle() throws SoneException, MalformedURLException {
774                 InputStream inputStream = getClass().getResourceAsStream("sone-parser-without-image-title.xml");
775                 assertThat(soneParser.parseSone(sone, inputStream), nullValue());
776         }
777
778         @Test
779         public void parsingASoneFailsWithoutImageWidth() throws SoneException, MalformedURLException {
780                 InputStream inputStream = getClass().getResourceAsStream("sone-parser-without-image-width.xml");
781                 assertThat(soneParser.parseSone(sone, inputStream), nullValue());
782         }
783
784         @Test
785         public void parsingASoneFailsWithoutImageHeight() throws SoneException, MalformedURLException {
786                 InputStream inputStream = getClass().getResourceAsStream("sone-parser-without-image-height.xml");
787                 assertThat(soneParser.parseSone(sone, inputStream), nullValue());
788         }
789
790         @Test
791         public void parsingASoneFailsWithInvalidImageWidth() throws SoneException, MalformedURLException {
792                 InputStream inputStream = getClass().getResourceAsStream("sone-parser-with-invalid-image-width.xml");
793                 assertThat(soneParser.parseSone(sone, inputStream), nullValue());
794         }
795
796         @Test
797         public void parsingASoneFailsWithInvalidImageHeight() throws SoneException, MalformedURLException {
798                 InputStream inputStream = getClass().getResourceAsStream("sone-parser-with-invalid-image-height.xml");
799                 assertThat(soneParser.parseSone(sone, inputStream), nullValue());
800         }
801
802         @Test
803         public void parsingASoneSucceedsWithImage() throws SoneException, MalformedURLException {
804                 InputStream inputStream = getClass().getResourceAsStream("sone-parser-with-image.xml");
805                 final Sone sone = soneParser.parseSone(this.sone, inputStream);
806                 assertThat(sone, not(nullValue()));
807                 assertThat(sone.getRootAlbum().getAlbums(), hasSize(1));
808                 assertThat(sone.getRootAlbum().getAlbums().get(0).getImages(), hasSize(1));
809                 Image image = sone.getRootAlbum().getAlbums().get(0).getImages().get(0);
810                 assertThat(image.getId(), is("image-id"));
811                 assertThat(image.getCreationTime(), is(1407197508000L));
812                 assertThat(image.getKey(), is("KSK@GPLv3.txt"));
813                 assertThat(image.getTitle(), is("image-title"));
814                 assertThat(image.getDescription(), is("image-description"));
815                 assertThat(image.getWidth(), is(1920));
816                 assertThat(image.getHeight(), is(1080));
817                 assertThat(sone.getProfile().getAvatar(), is("image-id"));
818         }
819
820
821 }