@Before
public void before() {
fixture = new DomainFixture(hibernateTemplate);
factory = new DomainFactory(fixture);
fixture.initSystemData();
fixture.createAndStoreUserAndUserGroup(
"testuser", "testuser fullname", UserType.NORMAL, "testuserstore");
httpServletRequest.setCharacterEncoding("UTF-8");
ServletRequestAccessor.setRequest(httpServletRequest);
loginUserInPortal(fixture.findUserByName("testuser").getKey());
previewService = Mockito.mock(PreviewService.class);
Mockito.when(previewService.isInPreview()).thenReturn(false);
Mockito.when(previewService.getPreviewContext()).thenReturn(PreviewContext.NO_PREVIEW);
imageController.setPreviewService(previewService);
MockTimeService timeService = new MockTimeService(new DateTime(2011, 6, 27, 12, 0, 0, 0));
imageController.setTimeService(timeService);
site1 = factory.createSite("MySite", new Date(), null, "en");
fixture.save(site1);
MenuItemEntity firstPage = createPage("Firstpage", null, "MySite");
fixture.save(firstPage);
site1.setFirstPage(firstPage);
fixture.flushAndClearHibernateSesssion();
fixture.save(
factory.createContentHandler(
"Image content", ContentHandlerName.IMAGE.getHandlerClassShortName()));
fixture.save(
factory.createContentType(
"ImageContentType", ContentHandlerName.IMAGE.getHandlerClassShortName()));
fixture.save(factory.createUnit("ImageUnit"));
fixture.save(
factory.createCategory(
"ImageCategory", "ImageContentType", "ImageUnit", "testuser", "testuser"));
fixture.save(
factory.createCategoryAccessForUser("ImageCategory", "testuser", "read, create, approve"));
fixture.flushAndClearHibernateSesssion();
}
@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"));
}
}
@Test
@Ignore
public void request_user_image() throws Exception {
byte[] bytes = loadImage("Arn.JPG");
UserEntity testUser = fixture.findUserByName("testuser");
testUser.setPhoto(bytes);
fixture.flushAndClearHibernateSesssion();
String imageRequestPath = "_image/user/" + testUser.getKey() + ".jpg";
setPathInfoAndRequestURI(httpServletRequest, imageRequestPath);
httpServletRequest.setParameter("_background", "0xffffff");
httpServletRequest.setParameter("_quality", "100");
imageController.handleRequestInternal(httpServletRequest, httpServletResponse);
assertEquals(HttpServletResponse.SC_OK, httpServletResponse.getStatus());
assertEquals("image/jpg", httpServletResponse.getContentType());
}
@Before
public void setUp() {
fixture = new DomainFixture(hibernateTemplate);
factory = new DomainFactory(fixture);
// setup needed common data for each test
fixture.initSystemData();
fixture.save(
factory.createContentHandler(
"Custom content", ContentHandlerName.CUSTOM.getHandlerClassShortName()));
MockHttpServletRequest httpRequest = new MockHttpServletRequest("GET", "/");
ServletRequestAccessor.setRequest(httpRequest);
dataSourceService = new DataSourceServiceImpl();
dataSourceService.setContentService(contentService);
dataSourceService.setSecurityService(securityService);
dataSourceService.setTimeService(new MockTimeService(new DateTime(2010, 7, 1, 12, 0, 0, 0)));
dataSourceService.setUserDao(userDao);
fixture.createAndStoreNormalUserWithUserGroup("content-creator", "Creator", "testuserstore");
fixture.createAndStoreNormalUserWithUserGroup("content-querier", "Querier", "testuserstore");
// setup content type
ContentTypeConfigBuilder ctyconf = new ContentTypeConfigBuilder("MyContent", "title");
ctyconf.startBlock("MyContent");
ctyconf.addInput("title", "text", "contentdata/title", "Title", true);
ctyconf.addRelatedContentInput(
"myRelatedContent", "contentdata/myRelatedContent", "My related content", false, true);
ctyconf.endBlock();
Document configAsXmlBytes = XMLDocumentFactory.create(ctyconf.toString()).getAsJDOMDocument();
fixture.save(
factory.createContentType(
"MyRelatedType",
ContentHandlerName.CUSTOM.getHandlerClassShortName(),
configAsXmlBytes));
fixture.save(factory.createUnit("MyUnit", "en"));
fixture.save(
factory.createCategory(
"MyCategory",
"MyRelatedType",
"MyUnit",
User.ANONYMOUS_UID,
User.ANONYMOUS_UID,
false));
fixture.save(
factory.createCategory(
"MyOtherCategory",
"MyRelatedType",
"MyUnit",
User.ANONYMOUS_UID,
User.ANONYMOUS_UID,
false));
fixture.save(
factory.createCategoryAccessForUser(
"MyCategory", "content-creator", "read, create, approve, admin_browse"));
fixture.save(
factory.createCategoryAccessForUser("MyCategory", "content-querier", "read, admin_browse"));
fixture.save(
factory.createCategoryAccessForUser(
"MyOtherCategory", "content-creator", "read, create, approve, admin_browse"));
fixture.save(
factory.createCategoryAccessForUser(
"MyOtherCategory", "content-querier", "read, admin_browse"));
fixture.flushAndClearHibernateSesssion();
}
@Before
public void setUp() {
fixture = new DomainFixture(hibernateTemplate);
factory = new DomainFactory(fixture);
// setup needed common data for each test
fixture.initSystemData();
SecurityHolder.setAnonUser(fixture.findUserByName(User.ANONYMOUS_UID).getKey());
fixture.save(
factory.createContentHandler(
"Custom content", ContentHandlerName.CUSTOM.getHandlerClassShortName()));
fixture.flushAndClearHibernateSesssion();
// Create an article conent type that will be used in the section:
ContentTypeConfigBuilder ctyconf = new ContentTypeConfigBuilder("article", "heading");
ctyconf.startBlock("intro");
ctyconf.addInput("heading", "text", "contentdata/intro/heading", "heading", true);
ctyconf.addInput("teaser", "text", "contentdata/intro/teaser", "teaser");
ctyconf.endBlock();
XMLBytes configAsXmlBytes = XMLDocumentFactory.create(ctyconf.toString()).getAsBytes();
fixture.save(
factory.createContentType(
"MenuItem", ContentHandlerName.CUSTOM.getHandlerClassShortName(), configAsXmlBytes));
fixture.flushAndClearHibernateSesssion();
// Create users that have all and no rights to work with the sections.
GroupEntity userGroup1 =
factory.createGroupInUserstore("aru_group", GroupType.USERSTORE_GROUP, "testuserstore");
GroupEntity userGroup2 =
factory.createGroupInUserstore("nru_group", GroupType.USERSTORE_GROUP, "testuserstore");
GroupEntity userGroup3 =
factory.createGroupInUserstore("publish_group", GroupType.USERSTORE_GROUP, "testuserstore");
fixture.save(userGroup1, userGroup2, userGroup3);
fixture.save(
factory.createUser("aru", "All Rights User", UserType.NORMAL, "testuserstore", userGroup1));
fixture.save(
factory.createUser("nru", "No Rights User", UserType.NORMAL, "testuserstore", userGroup2));
fixture.save(
factory.createUser(
"publish", "User with publish only", UserType.NORMAL, "testuserstore", userGroup3));
fixture.flushAndClearHibernateSesssion();
// Create a unit and a category in the archive to store the articles in, including access rights
// on the category.
fixture.save(
factory.createContentHandler(
"Custom content", ContentHandlerName.CUSTOM.getHandlerClassShortName()));
fixture.save(factory.createUnit("Archive"));
fixture.save(factory.createCategory("Articles", "article", "Archive", "aru", "aru"));
fixture.save(
factory.createCategoryAccessForUser(
"Articles", "aru", "read, admin_browse, create, delete"));
fixture.save(factory.createCategoryAccessForUser("Articles", "nru", "read"));
// Create a site and a section page for testing working with sections.
fixture.save(factory.createSite("The Newspaper", new Date(), null, "en"));
fixture.save(
factory.createPageMenuItem(
"Hello World!",
10,
"This is the top level menu item",
"Hello World!",
"The Newspaper",
"aru",
"aru",
false,
null,
"en",
null,
null,
null,
false,
null));
// fixture.save(
// factory.createMenuItemAccess( "Hello World!", 10, fixture.findUserByName( "aru"
// ).getUserGroup(), "read" ) );
fixture.flushAndClearHibernateSesssion();
}
@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());
}