commontator 4.10.3 → 4.10.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f5769fedf79be8ffdc8da8e46ee0bae3ea7184dd
-  data.tar.gz: 063c91fb45c1198cbc126dc57df8abddeca24e5f
+  metadata.gz: 3f4de129bb2b1ade35efdef135be03f94c8c9bc5
+  data.tar.gz: e481962df931e8d2907fb4275d54bf8144d69358
 SHA512:
-  metadata.gz: 2ed90da6359724bf48775cff080e1b25e70815d17666fd2a4aed830d25b6f385f41393f041ba92d323b3e5461afee48a34ff415d2b86800f90f88e610932cd9e
-  data.tar.gz: 4296f6861354db8f0f83f0966a75475d40ab891688ff1544644d4919efa3d3849c85d5552b07439eebe7c23eeef0a06ff87cc6674adbdde5f7c75df2fe1ad8f9
+  metadata.gz: 5522731e1e6faff67704bdc5fbc77e4c0c717fc37406afbdd1c1d27f9f4132d7678b0207a3ab3f05b6d7a6f938135a4cdceb18573e9691cf1cf4c0a1cfa879c7
+  data.tar.gz: 4d8aaf65ba574ccde30e929f24978045896ef13750dee24fd2617e659547b19a925d19ef3658184ce053b2e4df1d8e46f61d565bdae1dd21bb23d5e7d498d863

data/Rakefile

@@ -11,12 +11,13 @@ load 'rails/tasks/engine.rake'
 
 Bundler::GemHelper.install_tasks
 
-require 'rake/testtask'
+begin
+  require 'rspec/core/rake_task'
+
+  RSpec::Core::RakeTask.new(:spec)
 
-Rake::TestTask.new(:spec => 'app:db:test:prepare') do |t|
-  t.libs << 'spec'
-  t.pattern = 'spec/**/*_spec.rb'
-  t.verbose = false
+  task :default => :spec
+rescue LoadError
+  # no rspec available
 end
 
-task :default => :spec

data/app/models/commontator/subscription.rb

@@ -8,8 +8,10 @@ module Commontator
 
     def self.comment_created(comment)
       recipients = comment.thread.subscribers.reject{|s| s == comment.creator}
-      SubscriptionsMailer.comment_created(comment, recipients).deliver \
-        unless recipients.empty?
+      return if recipients.empty?
+
+      mail = SubscriptionsMailer.comment_created(comment, recipients)
+      mail.respond_to?(:deliver_later) ? mail.deliver_later : mail.deliver
     end
 
     def unread_comments

data/app/models/commontator/subscription.rb~

@@ -0,0 +1,23 @@
+module Commontator
+  class Subscription < ActiveRecord::Base
+    belongs_to :subscriber, :polymorphic => true
+    belongs_to :thread
+
+    validates_presence_of :subscriber, :thread
+    validates_uniqueness_of :thread_id, :scope => [:subscriber_type, :subscriber_id]
+
+    def self.comment_created(comment)
+      recipients = comment.thread.subscribers.reject{|s| s == comment.creator}
+      return if recipients.empty?
+
+      mail = SubscriptionsMailer.comment_created(comment, recipients)
+      (mail.respond_to?(:deliver_later) ? mail.deliver_later : mail.deliver) \
+        unless recipients.empty?
+    end
+
+    def unread_comments
+      created_at = Comment.arel_table[:created_at]
+      thread.filtered_comments.where(created_at.gt(updated_at))
+    end
+  end
+end

data/app/views/commontator/comments/_votes.html.erb

@@ -17,16 +17,16 @@
             :method => :put,
             :remote => true do %>
         <%= image_submit_tag "commontator/upvote.png",
-              :onmouseover => "this.src='/assets/commontator/upvote_hover.png'",
-              :onmouseout => "this.src='/assets/commontator/upvote.png'" %>
+              :onmouseover => "this.src='#{image_path("commontator/upvote_hover.png")}'",
+              :onmouseout => "this.src='#{image_path("commontator/upvote.png")}'" %>
       <% end %>
     <% elsif can_vote %>
       <%= form_tag commontator.unvote_comment_path(comment),
             :method => :put,
             :remote => true do %>
         <%= image_submit_tag "commontator/upvote_active.png",
-              :onmouseover => "this.src='/assets/commontator/upvote.png'",
-              :onmouseout => "this.src='/assets/commontator/upvote_active.png'"
+              :onmouseover => "this.src='#{image_path("commontator/upvote.png")}'",
+              :onmouseout => "this.src='#{image_path("commontator/upvote_active.png")}'"
         %>
       <% end %>
     <% else %>
@@ -48,16 +48,16 @@
             :method => :put,
             :remote => true do %>
         <%= image_submit_tag "commontator/downvote.png",
-              :onmouseover => "this.src='/assets/commontator/downvote_hover.png'",
-              :onmouseout => "this.src='/assets/commontator/downvote.png'" %>
+              :onmouseover => "this.src='#{image_path("commontator/downvote_hover.png")}'",
+              :onmouseout => "this.src='#{image_path("commontator/downvote.png")}'" %>
       <% end %>
     <% elsif can_vote %>
       <%= form_tag commontator.unvote_comment_path(comment),
             :method => :put,
             :remote => true do %>
         <%= image_submit_tag "commontator/downvote_active.png",
-              :onmouseover => "this.src='/assets/commontator/downvote.png'",
-              :onmouseout => "this.src='/assets/commontator/downvote_active.png'"
+              :onmouseover => "this.src='#{image_path("commontator/downvote.png")}'",
+              :onmouseout => "this.src='#{image_path("commontator/downvote_active.png")}'"
         %>
       <% end %>
     <% else %>

data/lib/commontator/engine.rb

@@ -1,8 +1,5 @@
 module Commontator
   class Engine < ::Rails::Engine
     isolate_namespace Commontator
-
-    # Load subfolders of config/locales as well
-    config.i18n.load_path += Dir[root.join('config', 'locales', '**', '*.{rb,yml}')]
   end
 end

data/lib/commontator/version.rb

@@ -1,3 +1,3 @@
 module Commontator
-  VERSION = "4.10.3"
+  VERSION = "4.10.4"
 end

data/lib/commontator/version.rb~

@@ -0,0 +1,3 @@
+module Commontator
+  VERSION = "4.10.3"
+end

data/spec/controllers/commontator/comments_controller_spec.rb

@@ -0,0 +1,566 @@
+require 'rails_helper'
+require 'acts_as_votable'
+
+module Commontator
+  RSpec.describe CommentsController, type: :controller do
+    routes { Commontator::Engine.routes }
+
+    before(:each) do
+      setup_controller_spec
+      @comment = Comment.new
+      @comment.thread = @thread
+      @comment.creator = @user
+      @comment.body = 'Something'
+      @comment.save!
+      expect(@comment.is_votable?).to eq true
+    end
+
+    it "won't get new unless authorized" do
+      get :new, :thread_id => @thread.id
+      expect(response).to have_http_status(:forbidden)
+
+      sign_in @user
+      get :new, :thread_id => @thread.id
+      expect(response).to have_http_status(:forbidden)
+    end
+
+    it 'must get new if authorized' do
+      sign_in @user
+
+      @user.can_read = true
+      get :new, :thread_id => @thread.id
+      expect(response).to redirect_to @thread
+      expect(assigns(:comment).errors).to be_empty
+
+      @user.can_read = false
+      @user.can_edit = true
+      get :new, :thread_id => @thread.id
+      expect(response).to redirect_to @thread
+      expect(assigns(:comment).errors).to be_empty
+
+      @user.can_edit = false
+      @user.is_admin = true
+      get :new, :thread_id => @thread.id
+      expect(response).to redirect_to @thread
+      expect(assigns(:comment).errors).to be_empty
+    end
+
+    it "won't create unless authorized" do
+      attributes = Hash.new
+      attributes[:body] = 'Something else'
+
+      post :create, :thread_id => @thread.id, :comment => attributes
+      expect(response).to have_http_status(:forbidden)
+
+      sign_in @user
+      post :create, :thread_id => @thread.id, :comment => attributes
+      expect(response).to have_http_status(:forbidden)
+
+      @user.can_read = true
+      @user.can_edit = true
+      @user.is_admin = true
+      expect(@thread.close).to eq true
+      post :create, :thread_id => @thread.id, :comment => attributes
+      expect(response).to have_http_status(:forbidden)
+    end
+
+    it 'must create if authorized' do
+      sign_in @user
+      attributes = Hash.new
+
+      attributes[:body] = 'Something else'
+      @user.can_read = true
+      post :create, :thread_id => @thread.id, :comment => attributes
+      expect(response).to redirect_to @thread
+      expect(assigns(:comment).errors).to be_empty
+      expect(assigns(:comment).body).to eq 'Something else'
+      expect(assigns(:comment).creator).to eq @user
+      expect(assigns(:comment).editor).to be_nil
+      expect(assigns(:comment).thread).to eq @thread
+
+      attributes[:body] = 'Another thing'
+      @user.can_read = false
+      @user.can_edit = true
+      post :create, :thread_id => @thread.id, :comment => attributes
+      expect(response).to redirect_to @thread
+      expect(assigns(:comment).errors).to be_empty
+      expect(assigns(:comment).body).to eq 'Another thing'
+      expect(assigns(:comment).creator).to eq @user
+      expect(assigns(:comment).editor).to be_nil
+      expect(assigns(:comment).thread).to eq @thread
+
+      attributes[:body] = 'And this too'
+      @user.can_edit = false
+      @user.is_admin = true
+      post :create, :thread_id => @thread.id, :comment => attributes
+      expect(response).to redirect_to @thread
+      expect(assigns(:comment).errors).to be_empty
+      expect(assigns(:comment).body).to eq 'And this too'
+      expect(assigns(:comment).creator).to eq @user
+      expect(assigns(:comment).editor).to be_nil
+      expect(assigns(:comment).thread).to eq @thread
+    end
+
+    it "won't create if double posting" do
+      sign_in @user
+      @user.can_read = true
+      attributes = Hash.new
+
+      attributes[:body] = 'Something'
+      post :create, :thread_id => @thread.id, :comment => attributes
+      assert_redirected_to @thread
+      expect(assigns(:comment).errors).not_to be_empty
+
+      attributes[:body] = 'Something else'
+      post :create, :thread_id => @thread.id, :comment => attributes
+      expect(response).to redirect_to @thread
+      expect(assigns(:comment).errors).to be_empty
+      expect(assigns(:comment).body).to eq 'Something else'
+      expect(assigns(:comment).creator).to eq @user
+      expect(assigns(:comment).editor).to be_nil
+      expect(assigns(:comment).thread).to eq @thread
+
+      attributes[:body] = 'Something else'
+      post :create, :thread_id => @thread.id, :comment => attributes
+      expect(response).to redirect_to @thread
+      expect(assigns(:comment).errors).not_to be_empty
+    end
+
+    it "won't edit unless authorized" do
+      get :edit, :id => @comment.id
+      expect(response).to have_http_status(:forbidden)
+
+      sign_in @user
+      get :edit, :id => @comment.id
+      expect(response).to have_http_status(:forbidden)
+
+      user2 = DummyUser.create
+      user2.can_read = true
+      user2.can_edit = true
+      user2.is_admin = true
+      sign_in user2
+      get :edit, :id => @comment.id
+      expect(response).to have_http_status(:forbidden)
+
+      @user.can_read = true
+      @user.can_edit = true
+      @user.is_admin = true
+      sign_in @user
+      comment2 = Comment.new
+      comment2.thread = @thread
+      comment2.creator = @user
+      comment2.body = 'Something else'
+      comment2.save!
+      get :edit, :id => @comment.id
+      expect(response).to have_http_status(:forbidden)
+    end
+
+    it 'must edit if authorized' do
+      sign_in @user
+
+      @user.can_read = true
+      get :edit, :id => @comment.id
+      expect(response).to redirect_to @thread
+      expect(assigns(:comment).errors).to be_empty
+
+      @user.can_read = false
+      @user.can_edit = true
+      get :edit, :id => @comment.id
+      expect(response).to redirect_to @thread
+      expect(assigns(:comment).errors).to be_empty
+
+      @user.can_edit = false
+      @user.is_admin = true
+      get :edit, :id => @comment.id
+      expect(response).to redirect_to @thread
+      expect(assigns(:comment).errors).to be_empty
+    end
+
+    it "won't update unless authorized" do
+      attributes = Hash.new
+      attributes[:body] = 'Something else'
+
+      put :update, :id => @comment.id, :comment => attributes
+      expect(response).to have_http_status(:forbidden)
+      @comment.reload
+      expect(@comment.body).to eq 'Something'
+      expect(@comment.editor).to be_nil
+
+      sign_in @user
+      put :update, :id => @comment.id, :comment => attributes
+      expect(response).to have_http_status(:forbidden)
+      @comment.reload
+      expect(@comment.body).to eq 'Something'
+      expect(@comment.editor).to be_nil
+
+      user2 = DummyUser.create
+      user2.can_read = true
+      user2.can_edit = true
+      user2.is_admin = true
+      sign_in user2
+      put :update, :id => @comment.id, :comment => attributes
+      expect(response).to have_http_status(:forbidden)
+      @comment.reload
+      expect(@comment.body).to eq 'Something'
+      expect(@comment.editor).to be_nil
+
+      @user.can_read = true
+      @user.can_edit = true
+      @user.is_admin = true
+      sign_in @user
+      comment2 = Comment.new
+      comment2.thread = @thread
+      comment2.creator = @user
+      comment2.body = 'Something else'
+      comment2.save!
+      put :update, :id => @comment.id, :comment => attributes
+      expect(response).to have_http_status(:forbidden)
+      @comment.reload
+      expect(@comment.body).to eq 'Something'
+      expect(@comment.editor).to be_nil
+    end
+
+    it 'must update if authorized' do
+      sign_in @user
+      attributes = Hash.new
+      attributes[:body] = 'Something else'
+
+      @user.can_read = true
+      put :update, :id => @comment.id, :comment => attributes
+      expect(response).to redirect_to @thread
+      expect(assigns(:comment).errors).to be_empty
+      expect(assigns(:comment).editor).to eq @user
+
+      @user.can_read = false
+      @user.can_edit = true
+      put :update, :id => @comment.id, :comment => attributes
+      expect(response).to redirect_to @thread
+      expect(assigns(:comment).errors).to be_empty
+      expect(assigns(:comment).editor).to eq @user
+
+      @user.can_edit = false
+      @user.is_admin = true
+      put :update, :id => @comment.id, :comment => attributes
+      expect(response).to redirect_to @thread
+      expect(assigns(:comment).errors).to be_empty
+      expect(assigns(:comment).editor).to eq @user
+    end
+
+    it "won't delete unless authorized and not deleted" do
+      put :delete, :id => @comment.id
+      expect(response).to have_http_status(:forbidden)
+      @comment.reload
+      expect(@comment.is_deleted?).to eq false
+
+      sign_in @user
+
+      put :delete, :id => @comment.id
+      expect(response).to have_http_status(:forbidden)
+      @comment.reload
+      expect(@comment.is_deleted?).to eq false
+
+      @user.can_read = true
+      expect(@comment.delete_by(@user)).to eq true
+      put :delete, :id => @comment.id
+      expect(response).to redirect_to @thread
+      expect(assigns(:comment).errors).not_to be_empty
+
+      comment2 = Comment.new
+      comment2.thread = @thread
+      comment2.creator = @user
+      comment2.body = 'Something else'
+      comment2.save!
+      expect(@comment.undelete_by(@user)).to eq true
+      put :delete, :id => @comment.id
+      expect(response).to have_http_status(:forbidden)
+      @comment.reload
+      expect(@comment.is_deleted?).to eq false
+    end
+
+    it 'must delete if authorized and not deleted' do
+      sign_in @user
+
+      @user.can_read = true
+      put :delete, :id => @comment.id
+      expect(response).to redirect_to @thread
+      expect(assigns(:comment).errors).to be_empty
+      expect(assigns(:comment).is_deleted?).to eq true
+      expect(assigns(:comment).editor).to eq @user
+
+      user2 = DummyUser.create
+      sign_in user2
+      comment2 = Comment.new
+      comment2.thread = @thread
+      comment2.creator = @user
+      comment2.body = 'Something else'
+      comment2.save!
+
+      expect(assigns(:comment).undelete_by(@user)).to eq true
+      user2.can_edit = true
+      put :delete, :id => @comment.id
+      expect(response).to redirect_to @thread
+      expect(assigns(:comment).errors).to be_empty
+      expect(assigns(:comment).is_deleted?).to eq true
+      expect(assigns(:comment).editor).to eq user2
+
+      expect(assigns(:comment).undelete_by(@user)).to eq true
+      user2.can_edit = false
+      user2.is_admin = true
+      put :delete, :id => @comment.id
+      expect(response).to redirect_to @thread
+      expect(assigns(:comment).errors).to be_empty
+      expect(assigns(:comment).is_deleted?).to eq true
+      expect(assigns(:comment).editor).to eq user2
+    end
+
+    it "won't undelete unless authorized and deleted" do
+      expect(@comment.delete_by(@user)).to eq true
+      put :undelete, :id => @comment.id
+      expect(response).to have_http_status(:forbidden)
+      @comment.reload
+      expect(@comment.is_deleted?).to eq true
+
+      sign_in @user
+
+      put :undelete, :id => @comment.id
+      expect(response).to have_http_status(:forbidden)
+      @comment.reload
+      expect(@comment.is_deleted?).to eq true
+
+      @user.can_read = true
+      expect(@comment.undelete_by(@user)).to eq true
+      put :undelete, :id => @comment.id
+      expect(response).to redirect_to @thread
+      expect(assigns(:comment).errors).not_to be_empty
+
+      user2 = DummyUser.create
+      user2.can_read = true
+      user2.can_edit = true
+      user2.is_admin = true
+      expect(@comment.delete_by(user2)).to eq true
+      put :undelete, :id => @comment.id
+      expect(response).to have_http_status(:forbidden)
+      @comment.reload
+      expect(@comment.is_deleted?).to eq true
+
+      comment2 = Comment.new
+      comment2.thread = @thread
+      comment2.creator = @user
+      comment2.body = 'Something else'
+      comment2.save!
+      expect(@comment.undelete_by(@user)).to eq true
+      expect(@comment.delete_by(@user)).to eq true
+      put :undelete, :id => @comment.id
+      expect(response).to have_http_status(:forbidden)
+      @comment.reload
+      expect(@comment.is_deleted?).to eq true
+    end
+
+    it 'must undelete if authorized and deleted' do
+      sign_in @user
+
+      expect(@comment.delete_by(@user)).to eq true
+      @user.can_read = true
+      put :undelete, :id => @comment.id
+      expect(response).to redirect_to @thread
+      expect(assigns(:comment).errors).to be_empty
+      expect(assigns(:comment).is_deleted?).to eq false
+
+      user2 = DummyUser.create
+      sign_in user2
+      comment2 = Comment.new
+      comment2.thread = @thread
+      comment2.creator = @user
+      comment2.body = 'Something else'
+      comment2.save!
+
+      expect(assigns(:comment).delete_by(@user)).to eq true
+      user2.can_edit = true
+      put :undelete, :id => @comment.id
+      expect(response).to redirect_to @thread
+      expect(assigns(:comment).errors).to be_empty
+      expect(assigns(:comment).is_deleted?).to eq false
+
+      expect(assigns(:comment).delete_by(@user)).to eq true
+      user2.can_edit = false
+      user2.is_admin = true
+      put :undelete, :id => @comment.id
+      expect(response).to redirect_to @thread
+      expect(assigns(:comment).errors).to be_empty
+      expect(assigns(:comment).is_deleted?).to eq false
+    end
+
+    it "won't upvote unless authorized" do
+      put :upvote, :id => @comment.id
+      expect(response).to have_http_status(:forbidden)
+      @comment.reload
+      expect(@comment.get_upvotes).to be_empty
+      expect(@comment.get_downvotes).to be_empty
+
+      sign_in @user
+      @user.can_read = true
+      put :upvote, :id => @comment.id
+      expect(response).to have_http_status(:forbidden)
+      @comment.reload
+      expect(@comment.get_upvotes).to be_empty
+      expect(@comment.get_downvotes).to be_empty
+
+      user2 = DummyUser.create
+      sign_in user2
+      put :upvote, :id => @comment.id
+      expect(response).to have_http_status(:forbidden)
+      @comment.reload
+      expect(@comment.get_upvotes).to be_empty
+      expect(@comment.get_downvotes).to be_empty
+    end
+
+    it 'must upvote if authorized' do
+      user2 = DummyUser.create
+      user2.can_read = true
+      sign_in user2
+
+      put :upvote, :id => @comment.id
+      expect(response).to redirect_to @thread
+      expect(assigns(:comment).get_upvotes.count).to eq 1
+      expect(assigns(:comment).get_downvotes).to be_empty
+
+      put :upvote, :id => @comment.id
+      expect(response).to redirect_to @thread
+      expect(assigns(:comment).get_upvotes.count).to eq 1
+      expect(assigns(:comment).get_downvotes).to be_empty
+
+      expect(@comment.downvote_from(user2)).to eq true
+
+      put :upvote, :id => @comment.id
+      expect(response).to redirect_to @thread
+      expect(assigns(:comment).get_upvotes.count).to eq 1
+      expect(assigns(:comment).get_downvotes).to be_empty
+    end
+
+    it "won't downvote unless authorized" do
+      put :downvote, :id => @comment.id
+      expect(response).to have_http_status(:forbidden)
+      @comment.reload
+      expect(@comment.get_upvotes).to be_empty
+      expect(@comment.get_downvotes).to be_empty
+
+      sign_in @user
+      @user.can_read = true
+      put :downvote, :id => @comment.id
+      expect(response).to have_http_status(:forbidden)
+      @comment.reload
+      expect(@comment.get_upvotes).to be_empty
+      expect(@comment.get_downvotes).to be_empty
+
+      user2 = DummyUser.create
+      sign_in user2
+      put :downvote, :id => @comment.id
+      expect(response).to have_http_status(:forbidden)
+      @comment.reload
+      expect(@comment.get_upvotes).to be_empty
+      expect(@comment.get_downvotes).to be_empty
+    end
+
+    it 'must downvote if authorized' do
+      user2 = DummyUser.create
+      user2.can_read = true
+      sign_in user2
+
+      put :downvote, :id => @comment.id
+      expect(response).to redirect_to @thread
+      expect(@comment.get_upvotes).to be_empty
+      expect(@comment.get_downvotes.count).to eq 1
+
+      put :downvote, :id => @comment.id
+      expect(response).to redirect_to @thread
+      expect(@comment.get_upvotes).to be_empty
+      expect(@comment.get_downvotes.count).to eq 1
+
+      expect(@comment.upvote_from(user2)).to eq true
+
+      put :downvote, :id => @comment.id
+      expect(response).to redirect_to @thread
+      expect(@comment.get_upvotes).to be_empty
+      expect(@comment.get_downvotes.count).to eq 1
+    end
+
+    it "won't unvote unless authorized" do
+      expect(@comment.upvote_from(@user)).to eq true
+
+      put :unvote, :id => @comment.id
+      expect(response).to have_http_status(:forbidden)
+      @comment.reload
+      expect(@comment.get_upvotes.count).to eq 1
+      expect(@comment.get_downvotes).to be_empty
+
+      sign_in @user
+      @user.can_read = true
+      put :unvote, :id => @comment.id
+      expect(response).to have_http_status(:forbidden)
+      @comment.reload
+      expect(@comment.get_upvotes.count).to eq 1
+      expect(@comment.get_downvotes).to be_empty
+
+      user2 = DummyUser.create
+      sign_in user2
+      put :unvote, :id => @comment.id
+      expect(response).to have_http_status(:forbidden)
+      @comment.reload
+      expect(@comment.get_upvotes.count).to eq 1
+      expect(@comment.get_downvotes).to be_empty
+    end
+
+    it 'must unvote if authorized' do
+      user2 = DummyUser.create
+      user2.can_read = true
+      sign_in user2
+
+      expect(@comment.upvote_from(user2)).to eq true
+      put :unvote, :id => @comment.id
+      expect(response).to redirect_to @thread
+      expect(assigns(:comment).get_upvotes).to be_empty
+      expect(assigns(:comment).get_downvotes).to be_empty
+
+      put :unvote, :id => @comment.id
+      expect(response).to redirect_to @thread
+      expect(assigns(:comment).get_upvotes).to be_empty
+      expect(assigns(:comment).get_downvotes).to be_empty
+
+      expect(@comment.downvote_from(user2)).to eq true
+      put :unvote, :id => @comment.id
+      expect(response).to redirect_to @thread
+      expect(assigns(:comment).get_upvotes).to be_empty
+      expect(assigns(:comment).get_downvotes).to be_empty
+    end
+
+    it "won't send mail if recipients empty" do
+      user2 = DummyUser.create
+      user2.can_read = true
+
+      @user.can_read = true
+      sign_in @user
+
+      attributes = { :body => 'Something else' }
+      expect {
+        post :create, :thread_id => @thread.id, :comment => attributes
+      }.not_to change{ ActionMailer::Base.deliveries.count }
+      expect(assigns(:comment).errors).to be_empty
+    end
+
+    it 'must send mail if recipients not empty' do
+      user2 = DummyUser.create
+      user2.can_read = true
+      @thread.subscribe(user2)
+
+      @user.can_read = true
+      sign_in @user
+
+      attributes = { :body => 'Something else' }
+      expect {
+        post :create, :thread_id => @thread.id, :comment => attributes
+      }.to change{ ActionMailer::Base.deliveries.count }.by(1)
+      expect(assigns(:comment).errors).to be_empty
+    end
+  end
+end
+