blogentrytest.java

pebble-blog 博客源码博客源码博客源码

  /**
   * Tests that listeners are not fired when a comment is added/removed on a clone.
   */
  public void testCommentListenersNotFiredFromClone() {
    final Comment comment = blogEntry.createComment("title", "body", "author", "email", "website", "127.0.0.1");
    blogEntry = (BlogEntry)blogEntry.clone();
    blogEntry.addComment(comment);
    assertTrue(blogEntry.getEvents().isEmpty());
  }

  /**
   * Tests that listeners are not fired when a TrackBack is added/removed on a clone.
   */
  public void testTrackBackListenersNotFiredFromClone() {
    final TrackBack trackBack = blogEntry.createTrackBack("title", "excerpt", "url", "blogName", "127.0.0.1");
    blogEntry = (BlogEntry)blogEntry.clone();
    blogEntry.addTrackBack(trackBack);
    blogEntry.removeTrackBack(trackBack.getId());
    assertTrue(blogEntry.getEvents().isEmpty());
  }

  public void testPropertyChangedEventsNotFiredWhenEventsDisabled() {
    assertFalse(blogEntry.isDirty());
    blogEntry.setEventsEnabled(false);
    blogEntry.setBody("New body");
    assertFalse(blogEntry.isDirty());
  }

  public void testPropertyChangedEventsFiredForBodyProperty() {
    assertFalse(blogEntry.isDirty());

    blogEntry.setBody(blogEntry.getBody());
    assertFalse(blogEntry.isDirty());

    blogEntry.setBody("New body");
    assertTrue(blogEntry.isDirty());
    PropertyChangeEvent event = (PropertyChangeEvent)blogEntry.getPropertyChangeEvents().get(0);
    assertEquals(blogEntry, event.getSource());
    assertEquals(BlogEntry.BODY_PROPERTY, event.getPropertyName());
    assertEquals("Some body", event.getOldValue());
    assertEquals("New body", event.getNewValue());
  }

  public void testPropertyChangedEventsFiredForExcerptProperty() {
    assertFalse(blogEntry.isDirty());

    blogEntry.setExcerpt(blogEntry.getExcerpt());
    assertFalse(blogEntry.isDirty());

    blogEntry.setExcerpt("New excerpt");
    assertTrue(blogEntry.isDirty());
    PropertyChangeEvent event = (PropertyChangeEvent)blogEntry.getPropertyChangeEvents().get(0);
    assertEquals(blogEntry, event.getSource());
    assertEquals(BlogEntry.EXCERPT_PROPERTY, event.getPropertyName());
    assertEquals("Some excerpt", event.getOldValue());
    assertEquals("New excerpt", event.getNewValue());
  }

  public void testPropertyChangedEventsFiredForTitleProperty() {
    assertFalse(blogEntry.isDirty());

    blogEntry.setTitle(blogEntry.getTitle());
    assertFalse(blogEntry.isDirty());

    blogEntry.setTitle("New title");
    assertTrue(blogEntry.isDirty());
    PropertyChangeEvent event = (PropertyChangeEvent)blogEntry.getPropertyChangeEvents().get(0);
    assertEquals(blogEntry, event.getSource());
    assertEquals(BlogEntry.TITLE_PROPERTY, event.getPropertyName());
    assertEquals("A title", event.getOldValue());
    assertEquals("New title", event.getNewValue());
  }

  public void testPropertyChangedEventsNotFiredForAuthorProperty() {
    assertFalse(blogEntry.isDirty());

    blogEntry.setAuthor(blogEntry.getAuthor());
    assertFalse(blogEntry.isDirty());

    blogEntry.setAuthor("New author");
    assertFalse(blogEntry.isDirty());
    //PropertyChangeEvent event = (PropertyChangeEvent)blogEntry.getPropertyChangeEvents().get(0);
    //assertEquals(blogEntry, event.getSource());
    //assertEquals(BlogEntry.AUTHOR_PROPERTY, event.getPropertyName());
    //assertEquals("An author", event.getOldValue());
    //assertEquals("New author", event.getNewValue());
  }

  public void testPropertyChangedEventsFiredForOriginalPermalinkProperty() {
    assertFalse(blogEntry.isDirty());

    blogEntry.setOriginalPermalink(null);
    assertFalse(blogEntry.isDirty());

    blogEntry.setOriginalPermalink("New permalink");
    assertTrue(blogEntry.isDirty());
    PropertyChangeEvent event = (PropertyChangeEvent)blogEntry.getPropertyChangeEvents().get(0);
    assertEquals(blogEntry, event.getSource());
    assertEquals(BlogEntry.ORIGINAL_PERMALINK_PROPERTY, event.getPropertyName());
    assertNull(event.getOldValue());
    assertEquals("New permalink", event.getNewValue());

    blogEntry.clearPropertyChangeEvents();
    blogEntry.setOriginalPermalink(blogEntry.getOriginalPermalink());
    assertFalse(blogEntry.isDirty());
  }

  public void testPropertyChangedEventsFiredForAttachmentProperty() {
    assertFalse(blogEntry.isDirty());

    blogEntry.setAttachment(null);
    assertFalse(blogEntry.isDirty());

    Attachment newAttachment = new Attachment("url", 1234, "image/jpeg");
    blogEntry.setAttachment(newAttachment);
    assertTrue(blogEntry.isDirty());
    PropertyChangeEvent event = (PropertyChangeEvent)blogEntry.getPropertyChangeEvents().get(0);
    assertEquals(blogEntry, event.getSource());
    assertEquals(BlogEntry.ATTACHMENT_PROPERTY, event.getPropertyName());
    assertNull(event.getOldValue());
    assertEquals(newAttachment, event.getNewValue());

    blogEntry.clearPropertyChangeEvents();
    blogEntry.setAttachment(newAttachment);
    assertFalse(blogEntry.isDirty());
  }

  public void testPropertyChangedEventsFiredForCommentsEnabledProperty() {
    assertFalse(blogEntry.isDirty());

    blogEntry.setCommentsEnabled(true);
    assertFalse(blogEntry.isDirty());

    blogEntry.setCommentsEnabled(false);
    assertTrue(blogEntry.isDirty());
    PropertyChangeEvent event = (PropertyChangeEvent)blogEntry.getPropertyChangeEvents().get(0);
    assertEquals(blogEntry, event.getSource());
    assertEquals(BlogEntry.COMMENTS_ENABLED_PROPERTY, event.getPropertyName());
    assertEquals(Boolean.TRUE, event.getOldValue());
    assertEquals(Boolean.FALSE, event.getNewValue());
  }

  public void testPropertyChangedEventsFiredForTrackBacksEnabledProperty() {
    assertFalse(blogEntry.isDirty());

    blogEntry.setTrackBacksEnabled(true);
    assertFalse(blogEntry.isDirty());

    blogEntry.setTrackBacksEnabled(false);
    assertTrue(blogEntry.isDirty());
    PropertyChangeEvent event = (PropertyChangeEvent)blogEntry.getPropertyChangeEvents().get(0);
    assertEquals(blogEntry, event.getSource());
    assertEquals(BlogEntry.TRACKBACKS_ENABLED_PROPERTY, event.getPropertyName());
    assertEquals(Boolean.TRUE, event.getOldValue());
    assertEquals(Boolean.FALSE, event.getNewValue());
  }

  public void testPropertyChangedEventsFiredForCategoriesProperty() {
    assertFalse(blogEntry.isDirty());

    blogEntry.removeAllCategories();
    assertFalse(blogEntry.isDirty());

    Category c1 = new Category("/c1", "Category 1");
    blog.addCategory(c1);
    Category c2 = new Category("/c2", "Category 2");
    blog.addCategory(c1);
    blogEntry.addCategory(c1);
    assertTrue(blogEntry.isDirty());
    PropertyChangeEvent event = (PropertyChangeEvent)blogEntry.getPropertyChangeEvents().get(0);
    assertEquals(blogEntry, event.getSource());
    assertEquals(BlogEntry.CATEGORIES_PROPERTY, event.getPropertyName());
    assertTrue(((Set)event.getOldValue()).isEmpty());
    assertTrue(((Set)event.getNewValue()).contains(c1));

    blogEntry.clearPropertyChangeEvents();
    blogEntry.addCategory(c2);
    assertTrue(blogEntry.isDirty());
    event = (PropertyChangeEvent)blogEntry.getPropertyChangeEvents().get(0);
    assertEquals(blogEntry, event.getSource());
    assertEquals(BlogEntry.CATEGORIES_PROPERTY, event.getPropertyName());
    assertTrue(((Set)event.getOldValue()).contains(c1));
    assertTrue(((Set)event.getNewValue()).contains(c1));
    assertTrue(((Set)event.getNewValue()).contains(c2));

    blogEntry.removeAllCategories();
    blogEntry.clearPropertyChangeEvents();
    Set categories = new HashSet();
    categories.add(c1);
    categories.add(c2);
    blogEntry.setCategories(categories);
    assertTrue(blogEntry.isDirty());
    event = (PropertyChangeEvent)blogEntry.getPropertyChangeEvents().get(0);
    assertEquals(blogEntry, event.getSource());
    assertEquals(BlogEntry.CATEGORIES_PROPERTY, event.getPropertyName());
    assertTrue(((Set)event.getOldValue()).isEmpty());
    assertTrue(((Set)event.getNewValue()).contains(c1));
    assertTrue(((Set)event.getNewValue()).contains(c2));

    blogEntry.clearPropertyChangeEvents();
    categories = new HashSet();
    categories.add(c2);
    blogEntry.setCategories(categories);
    assertTrue(blogEntry.isDirty());
    event = (PropertyChangeEvent)blogEntry.getPropertyChangeEvents().get(0);
    assertEquals(blogEntry, event.getSource());
    assertEquals(BlogEntry.CATEGORIES_PROPERTY, event.getPropertyName());
    assertTrue(((Set)event.getOldValue()).contains(c1));
    assertTrue(((Set)event.getOldValue()).contains(c2));
    assertTrue(((Set)event.getNewValue()).contains(c2));
  }

  public void testPropertyChangedEventsFiredForTagsProperty() {
    assertFalse(blogEntry.isDirty());

    blogEntry.setTags(blogEntry.getTags());
    assertFalse(blogEntry.isDirty());

    blogEntry.setTags("some tags");
    assertTrue(blogEntry.isDirty());
    PropertyChangeEvent event = (PropertyChangeEvent)blogEntry.getPropertyChangeEvents().get(0);
    assertEquals(blogEntry, event.getSource());
    assertEquals(BlogEntry.TAGS_PROPERTY, event.getPropertyName());
    assertEquals("", event.getOldValue());
    assertEquals("some tags", event.getNewValue());
  }

  /**
   * Tests that all tags can be retrieved.
   */
  public void testGetAllTags() {
    CategoryBuilder builder = new CategoryBuilder(blog);
    Category apple = new Category("/apple", "Apple");
    Category java = new Category("/java", "Java");
    Category junit = new Category("/java/junit", "JUnit");
    builder.getRootCategory().setTags("myblog");
    builder.addCategory(apple);
    apple.setTags("apple");
    builder.addCategory(java);
    java.setTags("java");
    builder.addCategory(junit);
    junit.setTags("junit automated+testing");

    blogEntry.addCategory(apple);
    blogEntry.addCategory(junit);
    blogEntry.setTags("entry+specific+tag");

    List tags = blogEntry.getAllTags();
    assertTrue(tags.contains(blog.getTag("entry+specific+tag")));
    assertTrue(tags.contains(blog.getTag("junit")));
    assertTrue(tags.contains(blog.getTag("automated+testing")));
    assertTrue(tags.contains(blog.getTag("java")));
    assertTrue(tags.contains(blog.getTag("apple")));
    assertTrue(tags.contains(blog.getTag("myblog")));
  }

  /**
   * Tests that all tags can be retrieved, even when the blog entry
   * hasn't been associated with any categories.
   */
  public void testGetAllTagsWhenNotAssociatedWithACategory() {
    CategoryBuilder builder = new CategoryBuilder(blog);
    builder.getRootCategory().setTags("myblog");
    blog.setRootCategory(builder.getRootCategory());

    List tags = blogEntry.getAllTags();
    assertEquals(blog.getTag("myblog"), tags.get(0));
  }

  /**
   * Tests the hasTag() method.
   */
  public void testHasTag() {
    CategoryBuilder builder = new CategoryBuilder(blog);
    Category apple = new Category("/apple", "Apple");
    Category java = new Category("/java", "Java");
    Category junit = new Category("/java/junit", "JUnit");
    builder.getRootCategory().setTags("myblog");
    builder.addCategory(apple);
    apple.setTags("apple");
    builder.addCategory(java);
    java.setTags("java");
    builder.addCategory(junit);
    junit.setTags("junit automated+testing");

    assertFalse(blogEntry.hasTag(null));
    assertFalse(blogEntry.hasTag(""));
    assertFalse(blogEntry.hasTag("java"));

    blogEntry.setTags("entryspecifictag");
    assertTrue(blogEntry.hasTag("entryspecifictag"));

    blogEntry.addCategory(apple);
    assertTrue(blogEntry.hasTag("apple"));
    blogEntry.addCategory(junit);
    assertTrue(blogEntry.hasTag("junit"));
  }

  public void testLastModifiedDate() {
    blogEntry.setDate(new Date(100));
    blogEntry.addComment(blogEntry.createComment("", "Body", "Author", "[e-mail]", "http://www.google.com", "127.0.0.1", new Date(123), State.APPROVED));
    blogEntry.addComment(blogEntry.createComment("", "Body", "Author", "[e-mail]", "http://www.google.com", "127.0.0.1", new Date(456), State.APPROVED));
    blogEntry.addComment(blogEntry.createComment("", "Body", "Author", "[e-mail]", "http://www.google.com", "127.0.0.1", new Date(789), State.APPROVED));

    assertEquals(new Date(789), blogEntry.getLastModified());

    blogEntry.addTrackBack(blogEntry.createTrackBack("Title", "Excerpt", "http://www.somedomain.com", "Some blog", "127.0.0.1", new Date(123), State.APPROVED));
    blogEntry.addTrackBack(blogEntry.createTrackBack("Title", "Excerpt", "http://www.somedomain.com", "Some blog", "127.0.0.1", new Date(543), State.APPROVED));
    blogEntry.addTrackBack(blogEntry.createTrackBack("Title", "Excerpt", "http://www.somedomain.com", "Some blog", "127.0.0.1", new Date(987), State.APPROVED));

    assertEquals(new Date(987), blogEntry.getLastModified());
   }

  public void testRemoveCommentViaRemoveResponse() {
    Comment comment = blogEntry.createComment("", "Body", "Author", "[e-mail]", "http://www.google.com", "127.0.0.1", new Date(123), State.APPROVED);
    blogEntry.addComment(comment);
    assertEquals(1, blogEntry.getNumberOfComments());
    blogEntry.removeResponse(comment);
    assertEquals(0, blogEntry.getNumberOfComments());
   }

  public void testRemoveTrackBackViaRemoveResponse() {
    TrackBack trackBack = blogEntry.createTrackBack("Title", "Excerpt", "http://www.somedomain.com", "Some blog", "127.0.0.1", new Date(123), State.APPROVED);
    blogEntry.addTrackBack(trackBack);
    assertEquals(1, blogEntry.getNumberOfTrackBacks());
    blogEntry.removeResponse(trackBack);
    assertEquals(0, blogEntry.getNumberOfTrackBacks());
   }

 }