Example #1
0
  @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();
  }
Example #2
0
  @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"));
    }
  }
Example #3
0
  @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();
  }
Example #5
0
  @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();
  }
Example #6
0
  @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();
  }
Example #7
0
  @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());
  }
Example #8
0
  @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);
  }
Example #9
0
  @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());
  }