예제 #1
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());
  }
예제 #2
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);
  }