Java tutorial
/* $HeadURL$ * $Id$ * * Copyright (c) 2006-2010 by Public Library of Science * http://plos.org * http://ambraproject.org * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ package org.ambraproject.service.annotation; import org.ambraproject.action.BaseTest; import org.ambraproject.models.Annotation; import org.ambraproject.models.AnnotationType; import org.ambraproject.models.Article; import org.ambraproject.models.ArticleAuthor; import org.ambraproject.models.Flag; import org.ambraproject.models.FlagReasonCode; import org.ambraproject.models.UserProfile; import org.ambraproject.views.AnnotationView; import org.apache.commons.lang.ArrayUtils; import org.springframework.beans.factory.annotation.Autowired; import org.testng.annotations.DataProvider; import org.testng.annotations.Test; import java.net.URISyntaxException; import java.text.ParseException; import java.util.ArrayList; import java.util.Arrays; import java.util.Calendar; import java.util.Collection; import java.util.Date; import java.util.EnumSet; import java.util.HashMap; import java.util.HashSet; import java.util.List; import java.util.Map; import java.util.Set; import static org.testng.Assert.assertEquals; import static org.testng.Assert.assertEqualsNoOrder; import static org.testng.Assert.assertNotNull; import static org.testng.Assert.assertTrue; /** * Test for methods of {@link AnnotationService}. The test just references methods of the interface so that different * implementations can be autowired in. The test creates it's own dummy data and so shouldn't be dependent on external * databases * * @author Alex Kudlick */ public class AnnotationServiceTest extends BaseTest { @Autowired protected AnnotationService annotationService; @DataProvider(name = "articleAnnotations") public Object[][] getArticleAnnotations() { Article article = new Article("id:doi-for-annotationsTopLevel-test"); article.setJournal("test journal"); article.setTitle("test article title"); article.seteLocationId("1234"); article.setAuthors(Arrays.asList(new ArticleAuthor("article", "author", "1"), new ArticleAuthor("article", "author", "2"))); article.setDate(Calendar.getInstance().getTime()); article.setCollaborativeAuthors(Arrays.asList("Collab Author 1", "Collab Author 2", "Collab Author 3")); dummyDataStore.store(article); UserProfile creator = new UserProfile("email@annotationsTopLevel.org", "user-1-annotationsTopLevel", "pass"); dummyDataStore.store(creator); //dates to be able to differentiate expected order of results Calendar lastYear = Calendar.getInstance(); lastYear.add(Calendar.YEAR, -1); Calendar lastMonth = Calendar.getInstance(); lastMonth.add(Calendar.MONTH, -1); Map<Long, List<Annotation>> replyMap = new HashMap<Long, List<Annotation>>(2); Annotation comment = new Annotation(creator, AnnotationType.COMMENT, article.getID()); comment.setAnnotationUri("comment-annotationsTopLevel-uri"); comment.setTitle("comment-annotationsTopLevel-title"); comment.setBody("comment-annotationsTopLevel-body"); comment.setCreated(lastMonth.getTime()); dummyDataStore.store(comment); Article article1 = new Article("id:doi-for-annotationsTopLevel-test-1"); article1.setJournal("test journal"); article1.seteLocationId("1234"); article1.setTitle("test article1 title"); article1.setAuthors(Arrays.asList(new ArticleAuthor("article", "author", "1"), new ArticleAuthor("article", "author", "2"))); article1.setDate(Calendar.getInstance().getTime()); article1.setCollaborativeAuthors(Arrays.asList("Collab Author 1", "Collab Author 2", "Collab Author 3")); dummyDataStore.store(article1); Annotation comment1 = new Annotation(creator, AnnotationType.COMMENT, article1.getID()); comment1.setAnnotationUri("comment-1-annotationsTopLevel-uri"); comment1.setTitle("formal-correction-1-annotationsTopLevel-title"); comment1.setBody("formal-correction-1-annotationsTopLevel-body"); comment1.setCreated(lastMonth.getTime()); dummyDataStore.store(comment1); Annotation commentReply1 = new Annotation(creator, AnnotationType.REPLY, comment1.getArticleID()); commentReply1.setParentID(comment1.getID()); commentReply1.setAnnotationUri("reply1-to-comment1-uri"); commentReply1.setTitle("reply1-to-comment1-title"); commentReply1.setBody("reply1-to-comment1-body"); commentReply1.setCreated(lastMonth.getTime()); dummyDataStore.store(commentReply1); Annotation comment1ReplyToReply = new Annotation(creator, AnnotationType.REPLY, comment1.getArticleID()); comment1ReplyToReply.setParentID(commentReply1.getID()); comment1ReplyToReply.setAnnotationUri("reply-to-reply-to-comment1-uri"); comment1ReplyToReply.setTitle("reply-to-reply-to-comment1-title"); comment1ReplyToReply.setBody("reply-to-reply-to-comment1-body"); dummyDataStore.store(comment1ReplyToReply); replyMap.put(comment1.getID(), Arrays.asList(commentReply1)); replyMap.put(commentReply1.getID(), Arrays.asList(comment1ReplyToReply)); Article article2 = new Article("id:doi-for-annotationsTopLevel-test-2"); article2.setJournal("test journal"); article2.setTitle("test article2 title"); article2.seteLocationId("1234"); article2.setAuthors(Arrays.asList(new ArticleAuthor("article", "author", "1"), new ArticleAuthor("article", "author", "2"))); article2.setDate(Calendar.getInstance().getTime()); article2.setCollaborativeAuthors(Arrays.asList("Collab Author 1", "Collab Author 2", "Collab Author 3")); dummyDataStore.store(article2); UserProfile creator2 = new UserProfile("email2@annotationsTopLevel.org", "user-2-annotationsTopLevel", "pass"); dummyDataStore.store(creator2); Annotation comment2 = new Annotation(creator2, AnnotationType.COMMENT, article2.getID()); comment2.setAnnotationUri("comment2-annotationsTopLevel-uri"); comment2.setTitle("comment2-annotationsTopLevel-title"); comment2.setBody("comment2-annotationsTopLevel-body-body"); comment.setCreated(lastMonth.getTime()); dummyDataStore.store(comment); Annotation comment2Reply1 = new Annotation(creator, AnnotationType.REPLY, comment2.getArticleID()); comment2Reply1.setParentID(comment2.getID()); comment2Reply1.setAnnotationUri("reply1-comment2-uri"); comment2Reply1.setTitle("reply1-to-comment2-title"); comment2Reply1.setBody("reply1-to-comment2-body"); comment2Reply1.setCreated(lastMonth.getTime()); dummyDataStore.store(comment2Reply1); Annotation comment2Reply2 = new Annotation(creator, AnnotationType.REPLY, comment2.getArticleID()); comment2Reply1.setParentID(comment2.getID()); comment2Reply1.setAnnotationUri("reply2-to-comment2-uri"); comment2Reply1.setTitle("reply2-to-comment2-title"); comment2Reply1.setBody("reply2-to-comment2-body"); comment2Reply1.setCreated(lastMonth.getTime()); dummyDataStore.store(comment2Reply1); replyMap.put(comment2.getID(), Arrays.asList(comment2Reply1)); replyMap.put(comment2.getID(), Arrays.asList(comment2Reply2)); AnnotationView commentView = new AnnotationView(comment, article.getDoi(), article.getTitle(), replyMap); AnnotationView comment1View = new AnnotationView(comment1, article1.getDoi(), article1.getTitle(), replyMap); AnnotationView comment2View = new AnnotationView(comment2, article2.getDoi(), article2.getTitle(), replyMap); //Pass in query parameters and expected results for each set of articles return new Object[][] { { article, EnumSet.of(AnnotationType.COMMENT), AnnotationService.AnnotationOrder.MOST_RECENT_REPLY, new AnnotationView[] { commentView }, replyMap }, { article, EnumSet.of(AnnotationType.COMMENT), AnnotationService.AnnotationOrder.OLDEST_TO_NEWEST, new AnnotationView[] { commentView }, replyMap }, { article1, EnumSet.of(AnnotationType.COMMENT), AnnotationService.AnnotationOrder.MOST_RECENT_REPLY, new AnnotationView[] { comment1View }, replyMap }, { article1, EnumSet.of(AnnotationType.COMMENT), AnnotationService.AnnotationOrder.OLDEST_TO_NEWEST, new AnnotationView[] { comment1View }, replyMap }, { article2, EnumSet.of(AnnotationType.COMMENT), AnnotationService.AnnotationOrder.MOST_RECENT_REPLY, new AnnotationView[] { comment2View, //comment has more recent created date }, replyMap }, { article2, EnumSet.of(AnnotationType.COMMENT), AnnotationService.AnnotationOrder.OLDEST_TO_NEWEST, new AnnotationView[] { comment2View //comment has more recent created date }, replyMap }, }; } @Test(dataProvider = "articleAnnotations") public void testListAnnotations(final Article article, final Set<AnnotationType> annotationTypes, final AnnotationService.AnnotationOrder order, final AnnotationView[] expectedViews, final Map<Long, List<Annotation>> fullReplyMap) { AnnotationView[] resultViews = annotationService.listAnnotations(article.getID(), annotationTypes, order); //Not just calling assertEquals here, so we can give a more informative message (the .toSting() on the arrays is huge) assertNotNull(resultViews, "returned null array of results"); assertEquals(resultViews.length, expectedViews.length, "returned incorrect number of results"); for (int i = 0; i < resultViews.length; i++) { assertEquals(resultViews[i], expectedViews[i], "Result " + (i + 1) + " was incorrect with order " + order); recursivelyCheckReplies(resultViews[i], fullReplyMap); } } @Test(dataProvider = "articleAnnotations") public void testListAnnotationsNoReplies(final Article article, final Set<AnnotationType> annotationTypes, final AnnotationService.AnnotationOrder order, final AnnotationView[] expectedViews, final Map<Long, List<Annotation>> notUsed) { if (order != AnnotationService.AnnotationOrder.MOST_RECENT_REPLY) { AnnotationView[] resultViews = annotationService.listAnnotationsNoReplies(article.getID(), annotationTypes, order); //Not just calling assertEquals here, so we can give a more informative message (the .toSting() on the arrays is huge) assertNotNull(resultViews, "returned null array of results"); assertEquals(resultViews.length, expectedViews.length, "returned incorrect number of results"); for (int i = 0; i < resultViews.length; i++) { assertEquals(resultViews[i], expectedViews[i], "Result " + (i + 1) + " was incorrect with order " + order); assertTrue(ArrayUtils.isEmpty(resultViews[i].getReplies()), "returned annotation with replies loaded up"); } } } @Test(expectedExceptions = { IllegalArgumentException.class }) public void testListAnnotationNoRepliesWithBadOrderArgument() { annotationService.listAnnotationsNoReplies(1231l, null, AnnotationService.AnnotationOrder.MOST_RECENT_REPLY); } @Test public void testCreateComment() throws Exception { Article article = new Article("id:doiForCreateCommentByService"); UserProfile user = new UserProfile("email@createCommentService.org", "displayNAmeForCreateCommentService", "pass"); dummyDataStore.store(article); dummyDataStore.store(user); String body = "Test body"; String title = "test title"; String ciStatement = "ciStatement"; Long id = annotationService.createComment(user, article.getDoi(), title, body, ciStatement); assertNotNull(id, "Returned null annotation id"); Annotation storedAnnotation = dummyDataStore.get(Annotation.class, id); assertNotNull(storedAnnotation, "didn't store annotation to the db"); assertEquals(storedAnnotation.getArticleID(), article.getID(), "stored annotation had incorrect article id"); assertEquals(storedAnnotation.getBody(), body, "stored annotation had incorrect body"); assertEquals(storedAnnotation.getTitle(), title, "stored annotation had incorrect title"); assertEquals(storedAnnotation.getCompetingInterestBody(), ciStatement, "stored annotation had incorrect ci statement"); assertEquals(storedAnnotation.getType(), AnnotationType.COMMENT, "Stored annotation had incorrect type"); assertNotNull(storedAnnotation.getAnnotationUri(), "Service didn't generate an annotation uri"); } @DataProvider(name = "annotationsByDate") public Object[][] getAnnotationsByDate() { Calendar lastYear = Calendar.getInstance(); lastYear.add(Calendar.YEAR, -1); Calendar twoMonthsAgo = Calendar.getInstance(); twoMonthsAgo.add(Calendar.MONTH, -2); Calendar oneMonthAgo = Calendar.getInstance(); oneMonthAgo.add(Calendar.MONTH, -1); Calendar yesterday = Calendar.getInstance(); yesterday.add(Calendar.DAY_OF_MONTH, -1); UserProfile creator = new UserProfile("email@getAnnotationsByDate.org", "displayNameForTestGetAnnotationsByDate", "pass"); dummyDataStore.store(creator); Article article1 = new Article("id:doi-for-get-annotations-by-date1"); article1.setTitle("Article title for testGetAnnotations1"); article1.seteIssn(defaultJournal.geteIssn()); dummyDataStore.store(article1); Article article2 = new Article("id:doi-for-get-annotations-by-date2"); article2.setTitle("Article title for testGetAnnotations2"); article2.seteIssn(defaultJournal.geteIssn()); dummyDataStore.store(article2); List<AnnotationView> results = new ArrayList<AnnotationView>(4); for (int i = 1; i <= 3; i++) { Annotation annotation = new Annotation(creator, AnnotationType.COMMENT, article1.getID()); annotation.setTitle("comment on " + article1.getDoi() + i); annotation.setBody("comment on " + article1.getDoi() + i); annotation.setCreated(twoMonthsAgo.getTime()); dummyDataStore.store(annotation); results.add(new AnnotationView(annotation, article1.getDoi(), article1.getTitle(), null)); } return new Object[][] { { lastYear.getTime(), oneMonthAgo.getTime(), Arrays.asList("Comment"), 100, defaultJournal.getJournalKey(), results }, }; } @Test(dataProvider = "annotationsByDate") public void testGetAnnotations(Date startDate, Date endDate, Collection<String> annotationTypes, int maxResults, String journal, List<AnnotationView> expectedResults) throws URISyntaxException, ParseException { List<AnnotationView> results = annotationService.getAnnotations(startDate, endDate, new HashSet<String>(annotationTypes), maxResults, journal); assertNotNull(results, "returned null results"); assertEqualsNoOrder(results.toArray(), expectedResults.toArray(), "returned incorrect results"); } @Test public void testCreateInlineNote() throws Exception { Article article = new Article("id:doiForCreateInlineNoteByService"); UserProfile user = new UserProfile("email@createInlineNoteByService.org", "displayNAmeForCreateInlineNoteByService", "pass"); dummyDataStore.store(article); dummyDataStore.store(user); String body = "Test body"; String title = "test title"; String ciStatement = "ciStatement"; String expectedXpath = article.getDoi() + "#xpointer(string-range%28%2Farticle%5B1%5D%2Fbody%5B1%5D%2Fsec%5B1%5D%2Fp%5B3%5D%2C+%27%27%2C+107%2C+533%29%5B1%5D)"; Long id = annotationService.createComment(user, article.getDoi(), title, body, ciStatement); assertNotNull(id, "Returned null annotation id"); Annotation storedAnnotation = dummyDataStore.get(Annotation.class, id); assertNotNull(storedAnnotation, "didn't store annotation to the db"); assertEquals(storedAnnotation.getArticleID(), article.getID(), "stored annotation had incorrect article id"); assertEquals(storedAnnotation.getBody(), body, "stored annotation had incorrect body"); assertEquals(storedAnnotation.getTitle(), title, "stored annotation had incorrect title"); assertEquals(storedAnnotation.getCompetingInterestBody(), ciStatement, "stored annotation had incorrect ci statement"); assertEquals(storedAnnotation.getType(), AnnotationType.COMMENT, "Stored annotation had incorrect type"); assertNotNull(storedAnnotation.getAnnotationUri(), "Service didn't generate an annotation uri"); } @Test(expectedExceptions = { IllegalArgumentException.class }) public void testCreateCommentWithNullBody() throws Exception { Article article = new Article("id:doiForCreateWithNullBody"); UserProfile user = new UserProfile("email@CreateWithNullBody.org", "displayNAmeForCreateWithNullBody", "pass"); dummyDataStore.store(article); dummyDataStore.store(user); annotationService.createComment(user, article.getDoi(), "foo", null, "foo"); } @Test(expectedExceptions = { IllegalArgumentException.class }) public void testCreateCommentWithNullUser() throws Exception { Article article = new Article("id:doiForCreateWithNullUser"); dummyDataStore.store(article); annotationService.createComment(null, article.getDoi(), "foo", "foo", "foo"); } @Test(expectedExceptions = { IllegalArgumentException.class }) public void testCreateCommentWithBadDoi() throws Exception { Article article = new Article("id:doiForCreateWithBadDoi"); UserProfile user = new UserProfile("email@CreateWithBadDoi.org", "displayNAmeForCreateWithBadDoi", "pass"); dummyDataStore.store(user); annotationService.createComment(user, article.getDoi(), "foo", "foo", "foo"); } @DataProvider(name = "storedAnnotation") public Object[][] getStoredAnnotation() { Article article = new Article("id:doi-for-annotationService-test"); article.setJournal("test journal"); article.seteLocationId("12340-37951"); article.setVolume("articl volume"); article.setTitle("article test title"); article.setIssue("article issue"); article.setDate(Calendar.getInstance().getTime()); article.setCollaborativeAuthors( Arrays.asList("The Skoll Foundation", "The Bill and Melinda Gates Foundation")); dummyDataStore.store(article); UserProfile creator = new UserProfile("email@annotationService.org", "displayNameForAnnotationService", "pass"); dummyDataStore.store(creator); Annotation annotation = new Annotation(creator, AnnotationType.COMMENT, article.getID()); annotation.setTitle("test title for annotation service test"); annotation.setBody("test body for annotation service test"); annotation.setAnnotationUri("id:annotationWithReplies"); dummyDataStore.store(annotation); /* the reply tree structure is ... original / \ reply1 reply2 / \ reply3 reply4 \ reply5 */ Map<Long, List<Annotation>> replies = new HashMap<Long, List<Annotation>>(3); List<Annotation> repliesToOriginal = new ArrayList<Annotation>(3); List<Annotation> repliesToReply2 = new ArrayList<Annotation>(2); List<Annotation> repliesToReply4 = new ArrayList<Annotation>(1); replies.put(annotation.getID(), repliesToOriginal); //set created dates for replies so we can check ordering by date Calendar lastYear = Calendar.getInstance(); lastYear.add(Calendar.YEAR, -1); //Reply to the original annotation Annotation reply1 = new Annotation(creator, AnnotationType.REPLY, article.getID()); reply1.setParentID(annotation.getID()); reply1.setTitle("title for reply to original comment"); reply1.setBody("body for reply to original comment"); reply1.setAnnotationUri("id:reply1ForTestAnnotationView"); dummyDataStore.store(reply1); repliesToOriginal.add(reply1); //Reply to the original annotation. This should show up first since it has last year as created date Annotation reply2 = new Annotation(creator, AnnotationType.REPLY, article.getID()); reply2.setParentID(annotation.getID()); reply2.setTitle("title for 2nd reply to original comment"); reply2.setBody("body for 2nd reply to original comment"); reply2.setAnnotationUri("id:reply2ForTestAnnotationView"); reply2.setCreated(lastYear.getTime()); dummyDataStore.store(reply2); repliesToOriginal.add(reply2); replies.put(reply2.getID(), repliesToReply2); //reply to reply2 Annotation reply3 = new Annotation(creator, AnnotationType.REPLY, article.getID()); reply3.setParentID(reply2.getID()); reply3.setTitle("title for 1st reply to reply"); reply3.setBody("body for 1st reply to reply"); reply3.setAnnotationUri("id:reply3ForTestAnnotationView"); dummyDataStore.store(reply3); repliesToReply2.add(reply3); //reply to reply2. This should show up first since it has last year as created date Annotation reply4 = new Annotation(creator, AnnotationType.REPLY, article.getID()); reply4.setParentID(reply2.getID()); reply4.setTitle("title for 2nd reply to reply"); reply4.setBody("body for 2nd reply to reply"); reply4.setAnnotationUri("id:reply4ForTestAnnotationView"); reply4.setCreated(lastYear.getTime()); dummyDataStore.store(reply4); repliesToReply2.add(reply4); replies.put(reply4.getID(), repliesToReply4); //reply to reply4 Annotation reply5 = new Annotation(creator, AnnotationType.REPLY, article.getID()); reply5.setParentID(reply4.getID()); reply5.setTitle("title for 3rd level reply"); reply5.setBody("body for 3rd level reply"); reply5.setAnnotationUri("id:reply5ForTestAnnotationView"); dummyDataStore.store(reply5); repliesToReply4.add(reply5); return new Object[][] { { annotation, replies }, { reply1, replies }, { reply2, replies }, { reply3, replies }, { reply4, replies } }; } @Test(dataProvider = "storedAnnotation") public void testGetFullAnnotationView(Annotation annotation, Map<Long, List<Annotation>> fullReplyMap) { AnnotationView result = annotationService.getFullAnnotationView(annotation.getID()); assertNotNull(result, "Returned null annotation view"); String expectedDoi = dummyDataStore.get(Article.class, annotation.getArticleID()).getDoi(); String expectedTitle = dummyDataStore.get(Article.class, annotation.getArticleID()).getTitle(); assertEquals(result.getArticleDoi(), expectedDoi, "AnnotationView had incorrect article doi"); assertEquals(result.getArticleTitle(), expectedTitle, "AnnotationView had incorrect article title"); checkAnnotationProperties(result, annotation); recursivelyCheckReplies(result, fullReplyMap); //check ordering of replies for (int i = 0; i < result.getReplies().length - 1; i++) { assertTrue(result.getReplies()[i].getCreated().before(result.getReplies()[i + 1].getCreated()), "Replies were out of order for annotation " + annotation.getAnnotationUri() + " (should be earliest -> latest)"); } } private void recursivelyCheckReplies(AnnotationView annotationView, Map<Long, List<Annotation>> fullReplyMap) { List<Annotation> expectedReplies = fullReplyMap.get(annotationView.getID()); if (expectedReplies != null) { assertEquals(annotationView.getReplies().length, expectedReplies.size(), "Returned incorrect number of replies"); for (AnnotationView actual : annotationView.getReplies()) { boolean foundMatch = false; for (Annotation expected : expectedReplies) { if (actual.getID().equals(expected.getID())) { foundMatch = true; assertEquals(actual.getTitle(), expected.getTitle(), "Annotation view had incorrect title"); assertEquals(actual.getBody(), "<p>" + expected.getBody() + "</p>", "Annotation view had incorrect body"); assertEquals(actual.getCompetingInterestStatement(), expected.getCompetingInterestBody() == null ? "" : expected.getCompetingInterestBody(), "Annotation view had incorrect ci statement"); assertEquals(actual.getAnnotationUri(), expected.getAnnotationUri(), "Annotation view had incorrect annotation uri"); } } assertTrue(foundMatch, "Returned unexpected reply: " + actual); //recursively check the replies recursivelyCheckReplies(actual, fullReplyMap); } } else { assertTrue(ArrayUtils.isEmpty(annotationView.getReplies()), "Returned replies when none were expected: " + Arrays.deepToString(annotationView.getReplies())); } } @Test public void testAnnotationViewEscapesHtml() { UserProfile creator = new UserProfile("email@EscapesHtml.org", "displayNameForAnnotationViewEscapesHtml", "pass"); dummyDataStore.store(creator); Long articleId = Long .valueOf(dummyDataStore.store(new Article("id:doi-for-AnnotationViewEscapesViewHtml"))); String title = "hello <p /> world!"; String expectedTitle = "hello <p /> world!"; String body = "You & I"; String expectedBody = "<p>You & I</p>"; Annotation annotation = new Annotation(creator, AnnotationType.COMMENT, articleId); annotation.setTitle(title); annotation.setBody(body); dummyDataStore.store(annotation); AnnotationView result = annotationService.getFullAnnotationView(annotation.getID()); assertNotNull(result, "returned null annotation view"); assertEquals(result.getTitle(), expectedTitle, "AnnotationView didn't escape html in title"); assertEquals(result.getBody(), expectedBody, "AnnotationView didn't escape html in body"); } @Test(dataProvider = "storedAnnotation") public void testGetBasicAnnotationViewById(Annotation annotation, Map<Long, List<Annotation>> fullReplyMap) { AnnotationView result = annotationService.getBasicAnnotationView(annotation.getID()); assertNotNull(result, "Returned null annotation view"); String expectedDoi = dummyDataStore.get(Article.class, annotation.getArticleID()).getDoi(); String expectedTitle = dummyDataStore.get(Article.class, annotation.getArticleID()).getTitle(); assertEquals(result.getArticleDoi(), expectedDoi, "AnnotationView had incorrect article doi"); assertEquals(result.getArticleTitle(), expectedTitle, "AnnotationView had incorrect article title"); checkAnnotationProperties(result, annotation); assertTrue(ArrayUtils.isEmpty(result.getReplies()), "Returned annotation with replies"); } @Test(dataProvider = "storedAnnotation") public void testGetBasicAnnotationViewByURI(Annotation annotation, Map<Long, List<Annotation>> fullReplyMap) { AnnotationView result = annotationService.getBasicAnnotationViewByUri(annotation.getAnnotationUri()); assertNotNull(result, "Returned null annotation view"); String expectedDoi = dummyDataStore.get(Article.class, annotation.getArticleID()).getDoi(); String expectedTitle = dummyDataStore.get(Article.class, annotation.getArticleID()).getTitle(); assertEquals(result.getArticleDoi(), expectedDoi, "AnnotationView had incorrect article doi"); assertEquals(result.getArticleTitle(), expectedTitle, "AnnotationView had incorrect article title"); checkAnnotationProperties(result, annotation); assertTrue(ArrayUtils.isEmpty(result.getReplies()), "Returned annotation with replies"); } @Test public void testCreateFlag() throws Exception { UserProfile creator = new UserProfile("email@createFlag.org", "displayNameForCreateFlag", "pass"); dummyDataStore.store(creator); Annotation annotation = new Annotation(creator, AnnotationType.COMMENT, 123l); Long annotationId = Long.valueOf(dummyDataStore.store(annotation)); String comment = "This is spam"; Long flagId = annotationService.createFlag(creator, annotationId, FlagReasonCode.SPAM, comment); assertNotNull(flagId, "returned null flag id"); Flag storedFlag = dummyDataStore.get(Flag.class, flagId); assertNotNull(storedFlag, "didn't store flag to the database"); assertEquals(storedFlag.getReason(), FlagReasonCode.SPAM, "stored flag had incorrect reason code"); assertEquals(storedFlag.getComment(), comment, "stored flag had incorrect comment"); assertNotNull(storedFlag.getFlaggedAnnotation(), "stored flag had null annotation"); assertEquals(storedFlag.getFlaggedAnnotation().getID(), annotationId, "stored flag had incorrect annotation id"); } @Test public void testCreateReply() { UserProfile creator = new UserProfile("email@createReply.org", "displayNameForCreateReply", "pass"); dummyDataStore.store(creator); Article article = new Article("id:doi-for-create-reply"); Long articleId = Long.valueOf(dummyDataStore.store(article)); Annotation annotation = new Annotation(creator, AnnotationType.COMMENT, articleId); Long annotationId = Long.valueOf(dummyDataStore.store(annotation)); String title = "test title for reply"; String body = "test body for reply"; Long replyId = annotationService.createReply(creator, annotationId, title, body, null); assertNotNull(replyId, "returned null reply id"); Annotation storedReply = dummyDataStore.get(Annotation.class, replyId); assertNotNull(storedReply, "didn't store reply to the database"); assertEquals(storedReply.getType(), AnnotationType.REPLY, "Stored reply had incorrect type"); assertEquals(storedReply.getParentID(), annotation.getID(), "Stored reply had incorrect parent id"); assertEquals(storedReply.getArticleID(), annotation.getArticleID(), "stored reply had incorrect article id"); assertNotNull(storedReply.getAnnotationUri(), "reply didn't get an annotation uri generated"); assertEquals(storedReply.getTitle(), title, "reply had incorrect title"); assertEquals(storedReply.getBody(), body, "reply had incorrect body"); } @Test public void testCountComments() { UserProfile user = new UserProfile("email@testCountComments.org", "displayNameTestCountComments", "pass"); dummyDataStore.store(user); Article article = new Article("id:doi-test-count-comments"); dummyDataStore.store(article); Long commentId = Long .valueOf(dummyDataStore.store(new Annotation(user, AnnotationType.COMMENT, article.getID()))); Annotation reply = new Annotation(user, AnnotationType.REPLY, article.getID()); reply.setParentID(commentId); dummyDataStore.store(reply); assertEquals(annotationService.countAnnotations(article.getID(), EnumSet.of(AnnotationType.COMMENT)), 1, "annotation service returned incorrect count of comments and notes"); assertEquals(annotationService.countAnnotations(article.getID(), EnumSet.allOf(AnnotationType.class)), 2, "annotation service returned incorrect count of comments and notes"); } }