radiant-comments-extension 0.0.6

data/spec/controllers/admin/comments_controller_spec.rb

@@ -0,0 +1,57 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+describe Admin::CommentsController do
+  dataset :users_and_pages, :comments
+  before(:each) do
+    login_as :admin
+  end
+
+  describe "requesting 'show' with GET" do
+    it "should redirect to the comment edit screen" do
+      id = comments(:first).id
+      get :show, :id => id
+      response.should redirect_to("http://test.host/admin/comments/#{id}/edit")
+    end
+  end
+  describe "requesting 'edit' with GET" do
+    describe "for an invalid id" do
+      it "should redirect to the comments index" do
+        get :edit, :id => 999
+        response.should redirect_to('http://test.host/admin/comments')
+      end
+    end
+  end
+  
+  describe "requesting 'destroy' with DELETE" do
+    describe "for an invalid id" do
+      it "should redirect to the comments index" do
+        delete :destroy, :id => 999
+        response.should redirect_to('http://test.host/admin/comments')
+      end
+    end
+  end
+  
+  describe "requesting 'destroy_unapproved' with DELETE" do
+    before(:each) do
+      request.env['HTTP_REFERER'] = 'http://test.host/admin/comments'
+      Comment.count.should > 0
+    end
+    it "should destroy all of the unapproved comments" do
+      Comment.should_receive(:unapproved).and_return(Comment)
+      Comment.should_receive(:destroy_all).and_return(true)
+      delete :destroy_unapproved
+    end
+    it "should leave no unapproved comments in the database" do
+      delete :destroy_unapproved
+      Comment.count.should == 0
+    end
+    it "should display the message 'You have removed all unapproved comments.'" do
+      delete :destroy_unapproved
+      flash[:notice].should == 'You have removed all unapproved comments.'
+    end
+    it "should redirect to the requesting page" do
+      delete :destroy_unapproved
+      response.should redirect_to('http://test.host/admin/comments')
+    end
+  end
+end

data/spec/controllers/admin/comments_routing_spec.rb

@@ -0,0 +1,43 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+describe Admin::CommentsController do
+  dataset :users_and_pages, :comments
+  before(:each) do
+    login_as :admin
+  end
+
+  describe "routing" do
+    it "should route to unapproved comments by default" do
+      params_from(:get, "/admin/comments").should == { :controller => "admin/comments", :action => "index", :status => 'unapproved' }
+    end
+    
+    %w(all approved unapproved).each do |status|
+      it "should route to the index action for #{status} comments" do
+        params_from(:get, "/admin/comments/#{status}").should == { :controller => "admin/comments", :action => "index", :status => status }
+      end
+      it "should route to the index action for #{status} comments on the page" do
+        params_from(:get, "/admin/pages/1/comments/#{status}").should == { :controller => "admin/comments", :action => "index", :page_id => "1", :status => status }
+      end
+      it "should route to the index action for #{status} comments with the csv format" do
+        params_from(:get, "/admin/comments/#{status}.csv").should == { :controller => "admin/comments", :action => "index", :status => status, :format => 'csv' }
+      end
+      it "should route to the index action for #{status} comments on the page with the csv format" do
+        params_from(:get, "/admin/pages/1/comments/#{status}.csv").should == { :controller => "admin/comments", :action => "index", :status => status, :page_id => "1", :format => 'csv' }
+      end
+    end
+
+    it "should route to the destroy_unapproved action" do
+      params_from(:delete, "/admin/comments/destroy_unapproved").should == { :controller => "admin/comments", :action => "destroy_unapproved" }
+    end
+
+    it "should route to the enable action for the page" do
+      params_from(:put, "/admin/pages/1/comments/enable").should == { :controller => "admin/comments", :action => "enable", :page_id => "1" }
+    end
+
+    %w(approve unapprove).each do |action|
+      it "should route to the #{action} action" do
+        params_from(:put, "/admin/comments/1/#{action}").should == { :controller => "admin/comments", :action => action, :id => "1" }
+      end
+    end
+  end
+end

data/spec/controllers/page_postback_spec.rb

@@ -0,0 +1,51 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe SiteController, "Comments form posting to page" do
+  dataset :pages
+  
+  before :each do
+    Radiant::Config['comments.post_to_page?'] = true
+  end
+  
+  def do_post(comment_params={})
+    post :show_page, :url => "/", :comment => {
+      :author => "Jim Gay",
+      :author_email => "test@test.com",
+      :content => "That's all I have to say about that."
+    }.merge(comment_params)
+  end
+  
+  describe "when the comment succeeds in saving" do
+    it "should create the comment" do
+      lambda { do_post }.should change(Comment, :count).by(1)
+    end
+    
+    it "should redirect back to the page, with the comment anchor" do
+      do_post
+      response.should be_redirect
+      response.redirect_url.should =~ /#comment-\d+$/
+    end
+  end
+  
+  describe "when the comment fails to save" do
+    before :each do
+      @comment_mock = mock_model(Comment)
+      Comment.should_receive(:new).and_return(@comment_mock)
+      @comment_mock.stub!(:[]=)
+      @comment_mock.stub!(:request=)
+      @comment_mock.errors.stub!(:full_messages).and_return([])
+      @comment_mock.should_receive(:save!).and_raise(ActiveRecord::RecordInvalid.new(@comment_mock))
+    end
+    
+    it "should re-render the page and not cache the result" do
+      do_post
+      response.should be_success
+      response.headers['Cache-Control'].should =~ /private/
+    end
+    
+    it "should assign the failed comment to loaded page" do
+      do_post
+      assigns[:page].last_comment.should == @comment_mock
+    end
+  end
+end

data/spec/datasets/comments_dataset.rb

@@ -0,0 +1,7 @@
+class CommentsDataset < Dataset::Base
+  uses :pages
+  
+  def load
+    create_record Comment, :first, :page_id => pages(:home).id, :author => 'Jim Gay', :author_email => 'test@spec.com', :content => "That's all I have to say about that."
+  end
+end

data/spec/models/akismet_spam_filter_spec.rb

@@ -0,0 +1,61 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe AkismetSpamFilter do
+  dataset :comments
+  
+  before :each do
+    @akismet = mock("akismet", :valid? => true, :commentCheck => false)
+  end
+  
+  it "should always allow comments to save" do
+    @comment = comments(:first)
+    AkismetSpamFilter.valid?(@comment).should be_true
+  end
+  
+  it "should be configured if the api key and blog url are set" do
+    Radiant::Config['comments.akismet_key'] = 'foo'
+    Radiant::Config['comments.akismet_url'] = 'bar'
+    AkismetSpamFilter.should be_configured
+  end
+
+  it "should not be configured if either the public or private key are empty" do
+    Radiant::Config['comments.akismet_key'] = ''
+    Radiant::Config['comments.akismet_url'] = 'bar'
+    AkismetSpamFilter.should_not be_configured
+    
+    Radiant::Config['comments.akismet_key'] = 'foo'
+    Radiant::Config['comments.akismet_url'] = ''
+    AkismetSpamFilter.should_not be_configured
+  end
+  
+  
+  it "should initialize an Akismet API object" do
+    AkismetSpamFilter.akismet.should be_kind_of(Akismet)
+  end
+  
+  describe "when approving a comment" do
+    before :each do
+      @comment = comments(:first)
+      AkismetSpamFilter.instance.stub!(:akismet).and_return(@akismet)
+    end
+    
+    it "should be approved when the Akismet API is valid and returns false (message is not spam)" do
+      AkismetSpamFilter.should be_approved(@comment)
+    end
+    
+    it "should not be approved when the API is invalid" do
+      @akismet.stub!(:valid?).and_return(false)
+      AkismetSpamFilter.should_not be_approved(@comment)
+    end
+    
+    it "should not be approved when the API call returns true (message is spam)" do
+      @akismet.stub!(:commentCheck).and_return(true)
+      AkismetSpamFilter.should_not be_approved(@comment)
+    end
+    
+    it "should not be approved when the API is unreachable" do
+      @akismet.stub!(:commentCheck).and_raise(TimeoutError)
+      AkismetSpamFilter.should_not be_approved(@comment)
+    end
+  end
+end

data/spec/models/comment_spec.rb

@@ -0,0 +1,148 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe "Comment" do
+  dataset :comments
+
+  before do
+    @page = pages(:home)
+    Radiant::Config['comments.auto_approve'] = 'true'
+  end
+  
+  describe "self.per_page" do
+    it "should be 50 when Radiant::Config['comments.per_page'] is not set" do
+      Comment.per_page.should == 50
+    end
+    it "should be 50 when Radiant::Config['comments.per_page'] is 0" do
+      Radiant::Config['comments.per_page'] = 0
+      Comment.per_page.should == 50
+    end
+    it "should be the integer value when Radiant::Config['comments.per_page'] is an integer" do
+      Radiant::Config['comments.per_page'] = 123
+      Comment.per_page.should == 123
+    end
+    it "should be the absolute value when Radiant::Config['comments.per_page'] is a negative number" do
+      Radiant::Config['comments.per_page'] = -99
+      Comment.per_page.should == 99
+    end
+    
+  end
+
+  describe "when creating" do
+    before do
+      @comment = comments(:first)
+      @comment.stub!(:using_logic_spam_filter?).and_return(false)
+      Radiant::Config['comments.filters_enabled'] = "true"
+    end
+    
+    it "should escape html for content_html when a filter is not selected" do
+      @comment.content = %{<script type="text/javascript">alert('hello')</script>}
+      @comment.save!  
+      @comment.content_html.should == %{<p>alert(&#39;hello&#39;)</p>}
+    end
+    it "should sanitize the content" do
+      @comment.content = %{*hello* <script type="text/javascript">alert('hello')</script>}
+      @comment.save!
+      @comment.content_html.should_not include_text('script')
+    end
+    it "should filter the content for content_html when a filter is selected" do
+      @comment.filter_id = 'Textile'
+      @comment.content = %{*hello* <script type="text/javascript">alert('hello')</script>}
+      @comment.save!
+      @comment.content_html.should match(/<strong>hello<\/strong>/)
+    end
+    it "should escape the content for content_html when a filter is not selected" do
+      Radiant::Config['comments.filters_enabled'] = 'true'
+      @comment.filter_id = ''
+      @comment.content = %{*hello* <script type="text/javascript">alert('hello')</script>}
+      @comment.save!
+      @comment.content_html.should_not include_text('script')
+    end
+
+    it "should successfully create comment" do
+      @comment.valid?.should be_true
+      lambda{@comment.save!}.should_not raise_error
+    end
+
+    it "should set content_html with filter when saving" do
+      @comment.save
+      @comment.content_html.should eql("<p>That&#39;s all I have to say about that.</p>")
+    end
+
+    it "should validate that author is supplied" do
+      comment = create_comment(:author => nil)
+      comment.valid?.should be_false
+    end
+
+    it "should validate that author_email is supplied" do
+      comment = create_comment(:author_email => nil)
+      comment.valid?.should be_false
+    end
+
+    it "should validate that content is supplied" do
+      comment = create_comment(:content => nil)
+      comment.valid?.should be_false
+    end
+
+    it "should add a http:// prefix when author_url does not include a protocol" do
+      url = 'www.example.com'
+      @comment.author_url = url
+      @comment.save!
+      @comment.author_url.should == "http://#{url}"
+    end
+
+    it "should not alter author_url with a http:// prefix" do
+      url = 'http://www.example.com'
+      @comment.author_url = url
+      @comment.save!
+      @comment.author_url.should == url
+    end
+
+    it "should not alter author_url with a https:// prefix" do
+      url = 'https://www.example.com'
+      @comment.author_url = url
+      @comment.save!
+      @comment.author_url.should == url
+    end
+
+    it "should encode special characters in author_url" do
+      url = 'http://example.com/~foo/q?a=1&b=2'
+      @comment.author_url = url
+      @comment.save!
+      @comment.author_url.should == CGI.escapeHTML(url)
+    end
+    
+    it "should not alter author_url with a HTTP:// prefix" do
+      url = 'HTTP://Www.Example.Com'
+      @comment.author_url = url
+      @comment.save!
+      @comment.author_url.should == url
+    end
+  end
+  
+  def create_comment(opts={})
+    Comment.new({ :page => @page, :author => "Test", :author_email => "test@test.com", :author_ip => "10.1.10.1",
+                  :content => "Test..." }.merge(opts))
+  end
+
+  def page_params(attributes={})
+    title = attributes[:title] || unique_page_title
+
+    attributes = {
+      :title => title,
+      :breadcrumb => title,
+      :slug => title.symbolize.to_s.gsub("_", "-"),
+      :class_name => nil,
+      :status_id => Status[:published].id,
+      :published_at => Time.now.to_s(:db)
+    }.update(attributes)
+    attributes[:parent_id] = 10
+    attributes
+  end
+
+  @@unique_page_title_call_count = 0
+  def unique_page_title
+    @@unique_page_title_call_count += 1
+    "Page #{@@unique_page_title_call_count}"
+  end
+
+end

data/spec/models/comment_tags_spec.rb

@@ -0,0 +1,55 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe Page do
+  dataset :users_and_pages, :comments
+  
+  describe "r:comments:field:spam_answer_tag" do
+    it "should render the spam_answer input and the valid_spam_answer hidden input" do
+      answer_as_set = 'no spam'
+      correct_answer = Digest::MD5.hexdigest(answer_as_set.to_slug)
+      pages(:home).should render("<r:comments:field:spam_answer_tag answer='#{answer_as_set}' />").as(%{<input type="text" id="comment_spam_answer" name="comment[spam_answer]" value=""  /><input type="hidden" name="comment[valid_spam_answer]" value="#{correct_answer}" />})
+    end
+  end
+  describe "r:if_comments_simple_spam_filter_enabled" do
+    it "should render the content when required in Radiant::Config" do
+      Radiant::Config['comments.simple_spam_filter_required?'] = true
+      tag = %{<r:if_comments_simple_spam_filter_enabled>foo</r:if_comments_simple_spam_filter_enabled>}
+      expected = 'foo'
+      pages(:home).should render(tag).as(expected)
+    end
+    it "should not render the content when not required in Radiant::Config" do
+      Radiant::Config['comments.simple_spam_filter_required?'] = false
+      tag = %{<r:if_comments_simple_spam_filter_enabled>foo</r:if_comments_simple_spam_filter_enabled>}
+      expected = ''
+      pages(:home).should render(tag).as(expected)
+    end
+  end
+  describe "r:unless_comments_use_simple_spam_filter" do
+    it "should not render the content when required in Radiant::Config" do
+      Radiant::Config['comments.simple_spam_filter_required?'] = true
+      tag = %{<r:unless_comments_simple_spam_filter_enabled>foo</r:unless_comments_simple_spam_filter_enabled>}
+      expected = ''
+      pages(:home).should render(tag).as(expected)
+    end
+    it "should render the content when not required in Radiant::Config" do
+      Radiant::Config['comments.simple_spam_filter_required?'] = false
+      tag = %{<r:unless_comments_simple_spam_filter_enabled>foo</r:unless_comments_simple_spam_filter_enabled>}
+      expected = 'foo'
+      pages(:home).should render(tag).as(expected)
+    end
+  end
+  describe "<r:comments:form>" do
+    before :each do
+      @page = pages(:first)
+    end
+    it "should postback to the comments controller by default" do
+      Radiant::Config['comments.post_to_page?'] = false
+      @page.should render('<r:comments:form></r:comments:form>').matching(%r[#{@page.url}comments])
+    end
+    
+    it "should postback to the page when comments.post_to_page? is set to true" do
+      Radiant::Config['comments.post_to_page?'] = true
+      @page.should render('<r:comments:form></r:comments:form>').matching(%r[#{@page.url}"])
+    end
+  end
+end

data/spec/models/mollom_spam_filter_spec.rb

@@ -0,0 +1,103 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe MollomSpamFilter do
+  dataset :comments
+  
+  before :each do
+    @mollom_response = mock("response", :ham? => true, :session_id => '00011001')
+    @mollom = mock("mollom", :key_ok? => true, :check_content => @mollom_response, :server_list= => '', :server_list => [])
+    MollomSpamFilter.instance.instance_variable_set(:@mollom, nil)
+  end
+  
+  it "should always allow comments to save" do
+    @comment = comments(:first)
+    MollomSpamFilter.valid?(@comment).should be_true
+  end
+  
+  it "should be configured if the public and private key are set" do
+    Radiant::Config['comments.mollom_publickey'] = 'foo'
+    Radiant::Config['comments.mollom_privatekey'] = 'bar'
+    MollomSpamFilter.should be_configured
+  end
+
+  it "should not be configured if either the public or private key are empty" do
+    Radiant::Config['comments.mollom_publickey'] = ''
+    Radiant::Config['comments.mollom_privatekey'] = 'bar'
+    MollomSpamFilter.should_not be_configured
+    
+    Radiant::Config['comments.mollom_publickey'] = 'foo'
+    Radiant::Config['comments.mollom_privatekey'] = ''
+    MollomSpamFilter.should_not be_configured
+  end
+
+  
+  it "should initialize a Mollom API object" do
+    MollomSpamFilter.mollom.should be_kind_of(Mollom)
+  end
+  
+  it "should load the server list from the cache when possible" do
+    Rails.cache.write('MOLLOM_SERVER_CACHE', [{:proto=>"http", :host=>"88.151.243.81"}].to_yaml)
+    MollomSpamFilter.mollom.server_list.should == [{:proto=>"http", :host=>"88.151.243.81"}]
+  end
+  
+  describe "when approving a comment" do
+    before :each do
+      @comment = comments(:first)
+      MollomSpamFilter.instance.stub!(:mollom).and_return(@mollom)
+    end
+    
+    it "should not be approved when the Mollom key is invalid" do
+      @mollom.stub!(:key_ok?).and_return(false)
+      MollomSpamFilter.should_not be_approved(@comment)
+    end
+    
+    it "should not be approved when the response is not ham" do
+      @mollom_response.stub!(:ham?).and_return(false)
+      MollomSpamFilter.should_not be_approved(@comment)
+    end
+    
+    it "should not be approved when the API is unreachable" do
+      @mollom.stub!(:key_ok?).and_raise(Mollom::Error)
+      MollomSpamFilter.should_not be_approved(@comment)
+    end
+    
+    it "should be approved when the key is valid and response is ham" do
+      MollomSpamFilter.should be_approved(@comment)
+    end
+    
+    it "should cache the Mollom server list after a successful response" do
+      Rails.cache.should_receive(:write).with('MOLLOM_SERVER_CACHE', anything())
+      MollomSpamFilter.should be_approved(@comment)
+    end
+  end
+  
+  describe "when submitting a comment as spam" do
+    before :each do
+      @comment = comments(:first)
+      @comment.mollom_id = '1010101010001'
+      MollomSpamFilter.instance.stub!(:mollom).and_return(@mollom)
+    end
+    
+    it "should send the feedback to mollom" do
+      @mollom.should_receive(:send_feedback).with(hash_including(:feedback => 'spam')).and_return(true)
+      MollomSpamFilter.spam!(@comment)
+    end
+    
+    it "should not submit the spam if the comment has no Mollom response id" do
+      @comment.mollom_id = ''
+      @mollom.should_not_receive(:send_feedback)
+      MollomSpamFilter.spam!(@comment)
+    end
+    
+    it "should not submit the spam if the Mollom key is invalid" do
+      @mollom.stub(:key_ok?).and_return(false)
+      @mollom.should_not_receive(:send_feedback)
+      MollomSpamFilter.spam!(@comment)
+    end
+    
+    it "should raise a antispam error if Mollom raised an error" do
+      @mollom.should_receive(:send_feedback).and_raise(Mollom::Error)
+      lambda { MollomSpamFilter.spam!(@comment) }.should raise_error(Comment::AntispamWarning)
+    end
+  end
+end