@Test @Ignore public void request_content_image_that_binary_is_on_main_version() throws Exception { // setup: content byte[] bytes = loadImage("Arn.JPG"); ContentKey contentKey = createImageContent( "MyImage.jpg", 2, bytes, "ImageCategory", new DateTime(2011, 6, 27, 10, 0, 0, 0), null); // setup: draft version of content ContentEntity content = fixture.findContentByKey(contentKey); BinaryDataEntity binaryDataOfMainVersion = content.getMainVersion().getBinaryData("source"); // exercise & verify String imageRequestPath = "_image/" + contentKey + "/binary/" + binaryDataOfMainVersion.getKey() + ".jpg"; setPathInfoAndRequestURI(httpServletRequest, imageRequestPath); httpServletRequest.setParameter("_background", "0xffffff"); httpServletRequest.setParameter("_quality", "100"); imageController.handleRequestInternal(httpServletRequest, httpServletResponse); assertEquals(HttpServletResponse.SC_OK, httpServletResponse.getStatus()); assertTrue("Content Length", httpServletResponse.getContentLength() > 0); assertEquals("image/jpg", httpServletResponse.getContentType()); }
private void injectContentIntoContentDao(ContentKey contentKey, String contentName) { ContentEntity content = new ContentEntity(); content.setKey(contentKey); content.setName(contentName); when(contentDao.findByKey(contentKey)).thenReturn(content); }
@Test public void request_content_image_that_is_deleted() throws Exception { byte[] bytes = loadImage("Arn.JPG"); ContentKey contentKey = createImageContent( "MyImage.jpg", 2, bytes, "ImageCategory", new DateTime(2011, 6, 27, 10, 0, 0, 0), null); ContentEntity content = fixture.findContentByKey(contentKey); content.setDeleted(true); String imageRequestPath = "_image/" + contentKey + ".jpg"; setPathInfoAndRequestURI(httpServletRequest, imageRequestPath); httpServletRequest.setParameter("_background", "0xffffff"); httpServletRequest.setParameter("_quality", "100"); try { imageController.handleRequestInternal(httpServletRequest, httpServletResponse); fail("Expected exception"); } catch (Exception e) { assertTrue(e instanceof ImageRequestException); ImageRequestException imageRequestException = (ImageRequestException) e; assertTrue( imageRequestException .getMessage() .contains("Resource '/_image/" + contentKey + ".jpg' not found")); } }
public int getBinaryDataKey(int contentKey, String label) { ContentEntity content = contentDao.findByKey(new ContentKey(contentKey)); if (content != null) { BinaryDataEntity binaryData = content.getMainVersion().getSingleBinaryData(label); if (binaryData != null) { return binaryData.getKey(); } } return -1; }
@Test @Ignore public void exception_thrown_for_request_to_content_image_that_binary_is_not_on_main_version() throws Exception { // setup: content byte[] bytes = loadImage("Arn.JPG"); ContentKey contentKey = createImageContent( "MyImage.jpg", 2, bytes, "ImageCategory", new DateTime(2011, 6, 27, 10, 0, 0, 0), null); // setup: draft version of content ContentEntity content = fixture.findContentByKey(contentKey); ContentVersionEntity draftVersion = createDraftVersion("Arn.JPG"); draftVersion.setContentDataXml(content.getMainVersion().getContentDataAsXmlString()); content.setDraftVersion(draftVersion); content.addVersion(draftVersion); fixture.save(draftVersion); BinaryDataEntity binaryDataForDraftVersion = factory.createBinaryData("Arn.JPG", bytes.length); binaryDataForDraftVersion.setBlobKey( content.getMainVersion().getBinaryData("source").getBlobKey()); fixture.save(binaryDataForDraftVersion); ContentBinaryDataEntity contentBinaryDataForDraftVersion = factory.createContentBinaryData("source", binaryDataForDraftVersion, draftVersion); draftVersion.addContentBinaryData(contentBinaryDataForDraftVersion); fixture.save(contentBinaryDataForDraftVersion); fixture.flushAndClearHibernateSesssion(); // exercise & verify String imageRequestPath = "_image/" + contentKey + "/binary/" + binaryDataForDraftVersion.getKey() + ".jpg"; setPathInfoAndRequestURI(httpServletRequest, imageRequestPath); httpServletRequest.setParameter("_version", draftVersion.getKey().toString()); httpServletRequest.setParameter("_background", "0xffffff"); httpServletRequest.setParameter("_quality", "100"); try { imageController.handleRequestInternal(httpServletRequest, httpServletResponse); fail("Expected exception"); } catch (Exception e) { assertTrue(e instanceof ImageRequestException); ImageRequestException imageRequestException = (ImageRequestException) e; assertTrue( imageRequestException .getMessage() .contains( "Resource '/_image/" + contentKey + "/binary/" + binaryDataForDraftVersion.getKey() + ".jpg' not found")); } }
private SectionContentEntity createSectionContent(ContentKey contentKey, String contentName) { ContentEntity content = new ContentEntity(); content.setKey(contentKey); content.setName(contentName); SectionContentEntity sectionContent = new SectionContentEntity(); sectionContent.setKey(new SectionContentKey(contentKey.toString())); sectionContent.setContent(content); return sectionContent; }
public BinaryData getBinaryData(User oldUser, int binaryKey, long timestamp) { UserEntity user = securityService.getUser(oldUser); BinaryDataEntity binaryData = binaryDataDao.findByKey(new BinaryDataKey(binaryKey)); if (!binaryAccessResolver.hasReadAndIsAccessibleOnline(binaryData, user, new DateTime())) { return null; } ContentBinaryDataEntity contentBinaryData = contentBinaryDataDao.findByBinaryKey(binaryData.getKey()); ContentVersionEntity contentVersion = contentBinaryData.getContentVersion(); ContentEntity content = contentVersion.getContent(); // fast check if anonymous have read UserEntity anonymousUser = securityService.getUser(securityService.getAnonymousUserKey()); boolean anonAccess = content.hasAccessRightSet(anonymousUser.getUserGroup(), ContentAccessType.READ); return getBinaryData(contentBinaryData, anonAccess, timestamp); }
@Test(expected = MenuItemAccessException.class) public void testApproveContentAccessRight_noPublish() { // Data for test: MenuItemEntity menuItemPolitics = factory.createSectionMenuItem( "Opinion", 40, "Unordered", "Opinion", "The Newspaper", "aru", "aru", "en", "Hello World!", 10, false, null, false, null); fixture.save(menuItemPolitics); MenuItemAccessEntity allRightsUserAccess = factory.createMenuItemAccess( "Opinion", 40, fixture.findGroupByName("aru_group"), "read, create, update, delete, add, publish"); MenuItemAccessEntity readOnlyUserAccess = factory.createMenuItemAccess( "Opinion", 40, fixture.findGroupByName("nru_group"), "read, update, delete, add"); fixture.save(allRightsUserAccess, readOnlyUserAccess); ContentEntity contentOpinionPro = factory.createContent("Articles", "en", "aru", "0", new Date()); ContentEntity contentOpinionAgainst = factory.createContent("Articles", "en", "aru", "0", new Date()); fixture.save(contentOpinionPro, contentOpinionAgainst); ContentKey proKey = contentOpinionPro.getKey(); ContentKey againstKey = contentOpinionAgainst.getKey(); SectionContentEntity sectionContentPro = factory.createContentSection("Opinion", 40, proKey, true, 1); SectionContentEntity sectionContentAgainst = factory.createContentSection("Opinion", 40, againstKey, true, 2); fixture.save(sectionContentPro, sectionContentAgainst); fixture.flushAndClearHibernateSesssion(); // Assert that all data is set up correctly MenuItemEntity section = fixture.findMenuItemByName("Opinion", 40); assertEquals(2, section.getSectionContents().size()); final UserEntity noPublishRightUser = fixture.findUserByName("nru"); // Try unapprove content UnapproveSectionContentCommand unapproveCommand = new UnapproveSectionContentCommand(); unapproveCommand.setUpdater(noPublishRightUser.getKey()); unapproveCommand.setSection(fixture.findMenuItemByName("Opinion", 40).getMenuItemKey()); unapproveCommand.addUnapprovedContentToUpdate(contentOpinionAgainst.getKey()); menuItemService.unapproveSectionContent(unapproveCommand); fixture.flushAndClearHibernateSesssion(); }
@Test public void testApprovingAndUnapprovingContentInSection() { // Data for test: MenuItemEntity menuItemPolitics = factory.createSectionMenuItem( "Opinion", 40, "Unordered", "Opinion", "The Newspaper", "aru", "aru", "en", "Hello World!", 10, false, null, false, null); fixture.save(menuItemPolitics); MenuItemAccessEntity allRightsUserAccess = factory.createMenuItemAccess( "Opinion", 40, fixture.findGroupByName("aru_group"), "read, create, update, delete, add, publish"); MenuItemAccessEntity readOnlyUserAccess = factory.createMenuItemAccess("Opinion", 40, fixture.findGroupByName("nru_group"), "read"); MenuItemAccessEntity publishOnlyUserAccess = factory.createMenuItemAccess( "Opinion", 40, fixture.findGroupByName("publish_group"), "read, publish"); fixture.save(allRightsUserAccess, readOnlyUserAccess, publishOnlyUserAccess); ContentEntity contentOpinionPro = factory.createContent("Articles", "en", "aru", "0", new Date()); ContentEntity contentOpinionAgainst = factory.createContent("Articles", "en", "aru", "0", new Date()); fixture.save(contentOpinionPro, contentOpinionAgainst); ContentKey proKey = contentOpinionPro.getKey(); ContentKey againstKey = contentOpinionAgainst.getKey(); SectionContentEntity sectionContentPro = factory.createContentSection("Opinion", 40, proKey, true, 1); SectionContentEntity sectionContentAgainst = factory.createContentSection("Opinion", 40, againstKey, true, 2); fixture.save(sectionContentPro, sectionContentAgainst); fixture.flushAndClearHibernateSesssion(); // Assert that all data is set up correctly MenuItemEntity section = fixture.findMenuItemByName("Opinion", 40); assertEquals(2, section.getSectionContents().size()); final UserEntity publishOnlyUser = fixture.findUserByName("publish"); // Unapprove content UnapproveSectionContentCommand unapproveCommand = new UnapproveSectionContentCommand(); unapproveCommand.setUpdater(publishOnlyUser.getKey()); unapproveCommand.setSection(fixture.findMenuItemByName("Opinion", 40).getMenuItemKey()); unapproveCommand.addUnapprovedContentToUpdate(contentOpinionAgainst.getKey()); menuItemService.unapproveSectionContent(unapproveCommand); fixture.flushAndClearHibernateSesssion(); // Assert that all data is updated correctly MenuItemEntity testSection = fixture.findMenuItemByName("Opinion", 40); Set<SectionContentEntity> storedSectionContents = testSection.getSectionContents(); assertEquals(2, storedSectionContents.size()); Iterator<SectionContentEntity> secCntIterator = storedSectionContents.iterator(); boolean proContentChecked = false, againstContentChecked = false; while (secCntIterator.hasNext()) { SectionContentEntity secCntLoopHolder = secCntIterator.next(); int loopHolderKey = secCntLoopHolder.getContent().getKey().toInt(); if (loopHolderKey == contentOpinionAgainst.getKey().toInt()) { assertEquals(false, secCntLoopHolder.isApproved()); againstContentChecked = true; } else if (loopHolderKey == contentOpinionPro.getKey().toInt()) { assertEquals(true, secCntLoopHolder.isApproved()); proContentChecked = true; } } assertTrue(proContentChecked && againstContentChecked); // Switch approved and unapproved content: unapproveCommand = new UnapproveSectionContentCommand(); unapproveCommand.setUpdater(publishOnlyUser.getKey()); unapproveCommand.setSection(fixture.findMenuItemByName("Opinion", 40).getMenuItemKey()); unapproveCommand.addUnapprovedContentToUpdate(contentOpinionPro.getKey()); menuItemService.unapproveSectionContent(unapproveCommand); ApproveSectionContentCommand approveCommand = new ApproveSectionContentCommand(); approveCommand.setUpdater(publishOnlyUser.getKey()); approveCommand.setSection(fixture.findMenuItemByName("Opinion", 40).getMenuItemKey()); approveCommand.addApprovedContentToUpdate(contentOpinionAgainst.getKey()); menuItemService.approveSectionContent(approveCommand); fixture.flushAndClearHibernateSesssion(); // Assert that all data is updated correctly VerifyFinalResultOfApproveUnapproveTest( contentOpinionPro.getKey().toInt(), contentOpinionAgainst.getKey().toInt()); // Try switching the approved unapproved setting, with a user that does not have the necessary // rights to do so: unapproveCommand = new UnapproveSectionContentCommand(); unapproveCommand.setUpdater(fixture.findUserByName("nru").getKey()); unapproveCommand.setSection(fixture.findMenuItemByName("Opinion", 40).getMenuItemKey()); unapproveCommand.addUnapprovedContentToUpdate(contentOpinionAgainst.getKey()); try { menuItemService.unapproveSectionContent(unapproveCommand); fail("Not in the catch block. Unapproving content should not be allowed for this user."); } catch (MenuItemAccessException e) { // All OK } approveCommand = new ApproveSectionContentCommand(); approveCommand.setUpdater(fixture.findUserByName("nru").getKey()); approveCommand.setSection(fixture.findMenuItemByName("Opinion", 40).getMenuItemKey()); approveCommand.addApprovedContentToUpdate(contentOpinionPro.getKey()); try { menuItemService.approveSectionContent(approveCommand); fail("Not in the catch block. Approving content should not be allowed for this user."); } catch (MenuItemAccessException e) { // All OK } // That nothing has changed VerifyFinalResultOfApproveUnapproveTest( contentOpinionPro.getKey().toInt(), contentOpinionAgainst.getKey().toInt()); }
@Test public void testReorderingContentInASection() { MenuItemEntity menuItemArchive = factory.createSectionMenuItem( "Sports", 30, "Ordered", "Sports", "The Newspaper", "aru", "aru", "en", "Hello World!", 10, true, new Date(), false, null); fixture.save(menuItemArchive); MenuItemAccessEntity aruMenuAR = factory.createMenuItemAccess( "Sports", 30, fixture.findGroupByName("aru_group"), "read, create, update, delete, add, publish"); MenuItemAccessEntity nruMenuAR = factory.createMenuItemAccess("Sports", 30, fixture.findGroupByName("nru_group"), "read"); fixture.save(aruMenuAR, nruMenuAR); ContentEntity sportsContentChess = factory.createContent("Articles", "en", "aru", "0", new Date()); ContentEntity sportsContentFootball = factory.createContent("Articles", "en", "aru", "0", new Date()); ContentEntity sportsContentGolf = factory.createContent("Articles", "en", "aru", "0", new Date()); ContentEntity sportsContentIcehockey = factory.createContent("Articles", "en", "aru", "0", new Date()); fixture.save( sportsContentChess, sportsContentFootball, sportsContentGolf, sportsContentIcehockey); int chessContentKey = sportsContentChess.getKey().toInt(); int footballContentKey = sportsContentFootball.getKey().toInt(); int golfContentKey = sportsContentGolf.getKey().toInt(); int icehockeyContentKey = sportsContentIcehockey.getKey().toInt(); SectionContentEntity secCntChess = factory.createContentSection("Sports", 30, sportsContentChess.getKey(), true, 1); SectionContentEntity secCntFootball = factory.createContentSection("Sports", 30, sportsContentFootball.getKey(), true, 2); SectionContentEntity secCntGolf = factory.createContentSection("Sports", 30, sportsContentGolf.getKey(), true, 3); SectionContentEntity secCntIcehockey = factory.createContentSection("Sports", 30, sportsContentIcehockey.getKey(), true, 4); fixture.save(secCntChess, secCntFootball, secCntGolf, secCntIcehockey); fixture.flushAndClearHibernateSesssion(); // Assert that all data is set up correctly MenuItemEntity testSection = fixture.findMenuItemByName("Sports", 30); Set<SectionContentEntity> storedSectionContents = testSection.getSectionContents(); assertEquals(4, storedSectionContents.size()); Iterator<SectionContentEntity> secCntIterator = storedSectionContents.iterator(); boolean chessContentChecked = false, footballContentChecked = false, golfContentChecked = false, icehockeyContentChecked = false; while (secCntIterator.hasNext()) { SectionContentEntity secCntLoopHolder = secCntIterator.next(); int loopHolderKey = secCntLoopHolder.getContent().getKey().toInt(); if (loopHolderKey == chessContentKey) { assertEquals(1, secCntLoopHolder.getOrder()); chessContentChecked = true; } else if (loopHolderKey == footballContentKey) { assertEquals(2, secCntLoopHolder.getOrder()); footballContentChecked = true; } else if (loopHolderKey == golfContentKey) { assertEquals(3, secCntLoopHolder.getOrder()); golfContentChecked = true; } else if (loopHolderKey == icehockeyContentKey) { assertEquals(4, secCntLoopHolder.getOrder()); icehockeyContentChecked = true; } } assertTrue( chessContentChecked && footballContentChecked && golfContentChecked && icehockeyContentChecked); // Execute reorder command ApproveSectionContentCommand approveCommand = new ApproveSectionContentCommand(); approveCommand.setUpdater(fixture.findUserByName("aru").getKey()); approveCommand.setSection(fixture.findMenuItemByName("Sports", 30).getMenuItemKey()); approveCommand.addApprovedContentToUpdate(sportsContentFootball.getKey()); approveCommand.addApprovedContentToUpdate(sportsContentChess.getKey()); approveCommand.addApprovedContentToUpdate(sportsContentIcehockey.getKey()); approveCommand.addApprovedContentToUpdate(sportsContentGolf.getKey()); menuItemService.approveSectionContent(approveCommand); fixture.flushAndClearHibernateSesssion(); // Assert that all data is updated correctly verifyFinalReorderingResult( chessContentKey, footballContentKey, golfContentKey, icehockeyContentKey); // Execute reorder command without enough rights. approveCommand = new ApproveSectionContentCommand(); approveCommand.setUpdater(fixture.findUserByName("nru").getKey()); approveCommand.setSection(fixture.findMenuItemByName("Sports", 30).getMenuItemKey()); approveCommand.addApprovedContentToUpdate(sportsContentIcehockey.getKey()); approveCommand.addApprovedContentToUpdate(sportsContentGolf.getKey()); approveCommand.addApprovedContentToUpdate(sportsContentChess.getKey()); approveCommand.addApprovedContentToUpdate(sportsContentFootball.getKey()); try { menuItemService.approveSectionContent(approveCommand); fail( "Not in the catch block. Updating the order of the content should not be allowed for this user."); } catch (MenuItemAccessException e) { // All Ok } // Assert that data has not been changed: verifyFinalReorderingResult( chessContentKey, footballContentKey, golfContentKey, icehockeyContentKey); }
@Test public void testRemoveContentFromSection() { // Data for test: MenuItemEntity menuItemPolitics = factory.createSectionMenuItem( "News", 20, "Unordered", "News", "The Newspaper", "aru", "aru", "en", "Hello World!", 10, false, null, false, null); fixture.save(menuItemPolitics); MenuItemAccessEntity aruMenuAR = factory.createMenuItemAccess( "News", 20, fixture.findGroupByName("aru_group"), "read, create, update, delete, add, publish"); MenuItemAccessEntity nruMenuAR = factory.createMenuItemAccess("News", 20, fixture.findGroupByName("nru_group"), "read"); fixture.save(aruMenuAR, nruMenuAR); ContentEntity contentPolitics1 = factory.createContent("Articles", "en", "aru", "0", new Date()); ContentEntity contentPolitics2 = factory.createContent("Articles", "en", "aru", "0", new Date()); fixture.save(contentPolitics1, contentPolitics2); ContentKey politicsKey1 = contentPolitics1.getKey(); ContentKey politicsKey2 = contentPolitics2.getKey(); SectionContentEntity sectionContent1 = factory.createContentSection("News", 20, politicsKey1, true, 1); SectionContentEntity sectionContent2 = factory.createContentSection("News", 20, politicsKey2, true, 2); fixture.save(sectionContent1, sectionContent2); fixture.flushAndClearHibernateSesssion(); // Assert that all data is set up correctly MenuItemEntity section = fixture.findMenuItemByName("News", 20); assertEquals(2, section.getSectionContents().size()); // Execute remove command RemoveContentFromSectionCommand allRightsRemoveCommand = new RemoveContentFromSectionCommand(); allRightsRemoveCommand.setRemover(fixture.findUserByName("aru").getKey()); allRightsRemoveCommand.setSection(fixture.findMenuItemByName("News", 20).getMenuItemKey()); allRightsRemoveCommand.addContentToRemove(contentPolitics1.getKey()); menuItemService.removeContentFromSection(allRightsRemoveCommand); fixture.flushAndClearHibernateSesssion(); // Assert result (Only 1 content left in section, and correct content) section = fixture.findMenuItemByName("News", 20); Set<SectionContentEntity> testResultAfterRemovingOneContent = section.getSectionContents(); assertEquals(1, testResultAfterRemovingOneContent.size()); SectionContentEntity testDetailResult = testResultAfterRemovingOneContent.iterator().next(); assertEquals(politicsKey2, testDetailResult.getContent().getKey()); // Verify that a user with only list rights can not remove from the section. RemoveContentFromSectionCommand noRightsRemoveCommand = new RemoveContentFromSectionCommand(); noRightsRemoveCommand.setRemover(fixture.findUserByName("nru").getKey()); noRightsRemoveCommand.setSection(fixture.findMenuItemByName("News", 20).getMenuItemKey()); noRightsRemoveCommand.addContentToRemove(contentPolitics2.getKey()); try { menuItemService.removeContentFromSection(noRightsRemoveCommand); fail( "Not in the catch block. The removeContentFromSection method should throw a MenuItemAccessException in this case."); } catch (MenuItemAccessException e) { // All ok! } fixture.flushAndClearHibernateSesssion(); // Assert result section = fixture.findMenuItemByName("News", 20); Set<SectionContentEntity> testResultAfterFailingToRemoveOneContent = section.getSectionContents(); assertEquals(1, testResultAfterFailingToRemoveOneContent.size()); SectionContentEntity testDetailResult2 = testResultAfterFailingToRemoveOneContent.iterator().next(); assertEquals(politicsKey2, testDetailResult2.getContent().getKey()); }