@Test
  public void testContentRequest_contentOnRoot() {

    SitePath sitePath = new SitePath(siteKey, "/123/contentName");

    final ContentKey contentKey = new ContentKey(123);

    final MenuItemEntity rootMenuItem = new MenuItemEntity();
    rootMenuItem.setName("");
    rootMenuItem.setKey(1);

    injectMenuItemToSiteEntityResolver("/", rootMenuItem);
    injectContentIntoContentDao(contentKey, "contentName");

    PageRequestContextResolver pageRequestContextResolver =
        new PageRequestContextResolver(contentDao);
    PageRequestContext resolvedContext =
        pageRequestContextResolver.resolvePageRequestContext(site, sitePath);

    ContentPath resolvedContentPath = resolvedContext.getContentPath();
    assertNotNull(resolvedContentPath);
    assertNotNull(resolvedContext.getRequestedMenuItem());

    assertEquals(new ContentKey("123"), resolvedContentPath.getContentKey());
    assertEquals("/", resolvedContentPath.getPathToMenuItem().getPathAsString());
  }
  private void addSectionContentToMenuItem(
      MenuItemEntity menuItem, SectionContentEntity sectionContent) {
    if (menuItem.getSectionContents() == null) {
      menuItem.setSectionContent(new HashSet<SectionContentEntity>());
    }

    menuItem.getSectionContents().add(sectionContent);
  }
Beispiel #3
0
 private MenuItemEntity createMenuItem(String key, String name, MenuItemEntity parent) {
   MenuItemEntity mi = new MenuItemEntity();
   mi.setKey(Integer.parseInt(key));
   mi.setName(name);
   if (parent != null) {
     mi.setParent(parent);
     parent.addChild(mi);
   }
   return mi;
 }
Beispiel #4
0
  public Element createPathElement(final MenuItemEntity child) {
    final Element pathEl = new Element("path");

    final List<MenuItemEntity> menItemPath = child.getMenuItemPath();
    for (final MenuItemEntity mi : menItemPath) {
      pathEl.addContent(createResourceElement(mi));
    }

    return pathEl;
  }
  @Test
  public void testContentRequest_contentOnRoot_extraElementInPath() {
    SitePath sitePath = new SitePath(siteKey, "/123/test/contentName");

    final ContentKey contentKey = new ContentKey(123);

    final MenuItemEntity rootMenuItem = new MenuItemEntity();
    rootMenuItem.setName("");
    rootMenuItem.setKey(1);

    injectRootPageOnSite(rootMenuItem);
    injectContentIntoContentDao(contentKey, "contentName");

    PageRequestContextResolver pageRequestContextResolver =
        new PageRequestContextResolver(contentDao);
    PageRequestContext resolvedContext =
        pageRequestContextResolver.resolvePageRequestContext(site, sitePath);

    ContentPath resolvedContentPath = resolvedContext.getContentPath();
    assertNull(resolvedContentPath);
  }
 private void VerifyFinalResultOfApproveUnapproveTest(int proKey, int againstKey) {
   MenuItemEntity testSection;
   Set<SectionContentEntity> storedSectionContents;
   Iterator<SectionContentEntity> secCntIterator;
   boolean proContentChecked = false;
   boolean againstContentChecked = false;
   testSection = fixture.findMenuItemByName("Opinion", 40);
   storedSectionContents = testSection.getSectionContents();
   assertEquals(2, storedSectionContents.size());
   secCntIterator = storedSectionContents.iterator();
   while (secCntIterator.hasNext()) {
     SectionContentEntity secCntLoopHolder = secCntIterator.next();
     int loopHolderKey = secCntLoopHolder.getContent().getKey().toInt();
     if (loopHolderKey == againstKey) {
       assertEquals(true, secCntLoopHolder.isApproved());
       againstContentChecked = true;
     } else if (loopHolderKey == proKey) {
       assertEquals(false, secCntLoopHolder.isApproved());
       proContentChecked = true;
     }
   }
   assertTrue(proContentChecked && againstContentChecked);
 }
 private void verifyFinalReorderingResult(
     int chessContentKey, int footballContentKey, int golfContentKey, int icehockeyContentKey) {
   MenuItemEntity testSection;
   Set<SectionContentEntity> storedSectionContents;
   Iterator<SectionContentEntity> secCntIterator;
   testSection = fixture.findMenuItemByName("Sports", 30);
   storedSectionContents = testSection.getSectionContents();
   assertEquals(4, storedSectionContents.size());
   secCntIterator = storedSectionContents.iterator();
   boolean chessContentChecked = false;
   boolean footballContentChecked = false;
   boolean golfContentChecked = false;
   boolean icehockeyContentChecked = false;
   while (secCntIterator.hasNext()) {
     SectionContentEntity secCntLoopHolder = secCntIterator.next();
     int loopHolderKey = secCntLoopHolder.getContent().getKey().toInt();
     if (loopHolderKey == chessContentKey) {
       assertEquals(2, secCntLoopHolder.getOrder());
       chessContentChecked = true;
     } else if (loopHolderKey == footballContentKey) {
       assertEquals(1, secCntLoopHolder.getOrder());
       footballContentChecked = true;
     } else if (loopHolderKey == golfContentKey) {
       assertEquals(4, secCntLoopHolder.getOrder());
       golfContentChecked = true;
     } else if (loopHolderKey == icehockeyContentKey) {
       assertEquals(3, secCntLoopHolder.getOrder());
       icehockeyContentChecked = true;
     }
   }
   assertTrue(
       chessContentChecked
           && footballContentChecked
           && golfContentChecked
           && icehockeyContentChecked);
 }
Beispiel #8
0
  public Element createResourceElement(final MenuItemEntity menuItem) {
    final Element objectEl = new Element("resource");
    objectEl.setAttribute("key", menuItem.getMenuItemKey().toString());
    objectEl.setAttribute("type", "menuitem");

    objectEl.addContent(createElement("name", menuItem.getName()));
    objectEl.addContent(createElement("menu-name", asEmptyIfNull(menuItem.getMenuName())));
    Element altElem = createElement("display-name", asEmptyIfNull(menuItem.getDisplayName()));
    objectEl.addContent(altElem);

    objectEl.addContent(createElement("show-in-menu", menuItem.getHidden() ? "false" : "true"));
    objectEl.addContent(createElement("keywords", asEmptyIfNull(menuItem.getKeywords())));
    objectEl.addContent(createElement("description", asEmptyIfNull(menuItem.getDescription())));
    objectEl.addContent(createElement("type", menuItem.getType().getName()));

    return objectEl;
  }
Beispiel #9
0
  private SiteEntity createSiteFixture1() {

    SiteEntity siteEntity = new SiteEntity();
    siteEntity.setKey(1);
    siteEntity.setLanguage(createLanguage("no", "Norwegian"));
    mi_forside = createMenuItem("1", "forside", null);
    mi_nyheter = createMenuItem("2", "nyheter", mi_forside);
    mi_innenriks = createMenuItem("3", "innenriks", mi_nyheter);
    siteEntity.setFirstPage(mi_forside);

    Map<CaseInsensitiveString, MenuItemEntity> topMenuItems =
        new LinkedHashMap<CaseInsensitiveString, MenuItemEntity>();
    topMenuItems.put(new CaseInsensitiveString(mi_forside.getName()), mi_forside);
    siteEntity.setTopMenuItems(topMenuItems);
    return siteEntity;
  }
Beispiel #10
0
  @Test
  public void testGetPageKeyByPath() {
    String keys;

    MenuItemEntity menuItem1 =
        factory.createSectionMenuItem(
            "name1",
            40,
            "menuName1",
            "displayName1",
            "The Newspaper",
            "aru",
            "aru",
            "en",
            "Hello World!",
            10,
            false,
            null,
            false,
            null);
    fixture.save(menuItem1);

    MenuItemEntity menuItem2 =
        factory.createSectionMenuItem(
            "name2",
            40,
            "menuName2",
            "displayName2",
            "The Newspaper",
            "aru",
            "aru",
            "en",
            "Hello World!",
            10,
            false,
            null,
            false,
            null);
    fixture.save(menuItem2);

    MenuItemEntity section = fixture.findMenuItemByName("Hello World!", 10);

    Collection<MenuItemEntity> children = section.getChildren();
    assertEquals(2, children.size());

    keys = menuItemService.getPageKeyByPath(section, "/");
    assertEquals(keys, "" + section.getKey());

    keys = menuItemService.getPageKeyByPath(section, "/Hello World!");
    assertEquals(keys, "" + section.getKey());

    keys = menuItemService.getPageKeyByPath(section, "/Hello World!/name1");
    assertEquals(keys, "" + menuItem1.getKey());

    keys = menuItemService.getPageKeyByPath(section, "/Hello World!/name2");
    assertEquals(keys, "" + menuItem2.getKey());

    keys = menuItemService.getPageKeyByPath(section, "/Hello World!/name2/nope");
    assertEquals(keys, "");

    keys = menuItemService.getPageKeyByPath(section, "/../");
    assertEquals(keys, "");

    keys = menuItemService.getPageKeyByPath(section, "/nope");
    assertEquals(keys, "");

    keys = menuItemService.getPageKeyByPath(section, "/Hello World!/");
    assertEquals(keys, "" + menuItem1.getKey() + "," + menuItem2.getKey());

    keys = menuItemService.getPageKeyByPath(section, ".");
    assertEquals(keys, "" + section.getKey());

    keys = menuItemService.getPageKeyByPath(section, "./");
    assertEquals(keys, "" + menuItem1.getKey() + "," + menuItem2.getKey());

    keys = menuItemService.getPageKeyByPath(section, "./name2");
    assertEquals(keys, "" + menuItem2.getKey());

    keys = menuItemService.getPageKeyByPath(section, "./../Hello World!/name2");
    assertEquals(keys, "" + menuItem2.getKey());

    keys = menuItemService.getPageKeyByPath(section, "./../../Hello World!/name2");
    assertEquals(keys, "");

    keys = menuItemService.getPageKeyByPath(section, "..");
    assertEquals(keys, "");

    keys = menuItemService.getPageKeyByPath(section, "../.");
    assertEquals(keys, "");

    keys = menuItemService.getPageKeyByPath(section, "../");
    assertEquals(keys, "" + section.getKey());

    keys = menuItemService.getPageKeyByPath(section, "../nope");
    assertEquals(keys, "");

    keys = menuItemService.getPageKeyByPath(section, "../../");
    assertEquals(keys, "");

    keys = menuItemService.getPageKeyByPath(section, "../..");
    assertEquals(keys, "");

    keys = menuItemService.getPageKeyByPath(section, "../../..");
    assertEquals(keys, "");

    keys = menuItemService.getPageKeyByPath(section, "nope");
    assertEquals(keys, "");

    keys = menuItemService.getPageKeyByPath(section, "./nope");
    assertEquals(keys, "");

    keys = menuItemService.getPageKeyByPath(menuItem1, ".");
    assertEquals(keys, "" + menuItem1.getKey());

    keys = menuItemService.getPageKeyByPath(menuItem1, "./");
    assertEquals(keys, "");

    keys = menuItemService.getPageKeyByPath(menuItem1, "..");
    assertEquals(keys, "" + section.getKey());

    keys = menuItemService.getPageKeyByPath(menuItem1, "./..");
    assertEquals(keys, "" + section.getKey());

    keys = menuItemService.getPageKeyByPath(menuItem1, "../");
    assertEquals(keys, "" + menuItem1.getKey() + "," + menuItem2.getKey());

    keys = menuItemService.getPageKeyByPath(menuItem1, "./../");
    assertEquals(keys, "" + menuItem1.getKey() + "," + menuItem2.getKey());

    keys = menuItemService.getPageKeyByPath(menuItem1, "./.././././");
    assertEquals(keys, "" + menuItem1.getKey() + "," + menuItem2.getKey());

    keys = menuItemService.getPageKeyByPath(menuItem1, "./././.././././");
    assertEquals(keys, "" + menuItem1.getKey() + "," + menuItem2.getKey());

    keys = menuItemService.getPageKeyByPath(menuItem1, "../name1");
    assertEquals(keys, "" + menuItem1.getKey());

    keys = menuItemService.getPageKeyByPath(menuItem1, "../name2");
    assertEquals(keys, "" + menuItem2.getKey());

    keys = menuItemService.getPageKeyByPath(menuItem1, "./../name1");
    assertEquals(keys, "" + menuItem1.getKey());

    keys = menuItemService.getPageKeyByPath(menuItem1, "./../name2");
    assertEquals(keys, "" + menuItem2.getKey());

    keys = menuItemService.getPageKeyByPath(menuItem1, "../../Hello World!");
    assertEquals(keys, "" + section.getKey());

    keys = menuItemService.getPageKeyByPath(menuItem1, "./../../Hello World!");
    assertEquals(keys, "" + section.getKey());

    keys = menuItemService.getPageKeyByPath(menuItem1, "../..");
    assertEquals(keys, "");

    keys = menuItemService.getPageKeyByPath(menuItem1, "../../..");
    assertEquals(keys, "");

    keys = menuItemService.getPageKeyByPath(menuItem1, "nope");
    assertEquals(keys, "");

    keys = menuItemService.getPageKeyByPath(menuItem1, "./nope");
    assertEquals(keys, "");

    keys = menuItemService.getPageKeyByPath(menuItem1, "./nope/.");
    assertEquals(keys, "");

    keys = menuItemService.getPageKeyByPath(menuItem1, "./nope/..");
    assertEquals(keys, "");

    keys = menuItemService.getPageKeyByPath(menuItem1, "../nope");
    assertEquals(keys, "");
  }
Beispiel #11
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();
  }
Beispiel #12
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());
  }
Beispiel #13
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);
  }
Beispiel #14
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());
  }