commontator 5.0.0 → 5.1.0

data/spec/lib/commontator/acts_as_commontator_spec.rb~

@@ -0,0 +1,52 @@
+require 'rails_helper'
+
+module Commontator
+  RSpec.describe ActsAsCommontator, type: :lib do
+    it 'must add methods to ActiveRecord and subclasses' do
+      ActiveRecord::Base.must_respond_to :acts_as_commontator
+      ActiveRecord::Base.must_respond_to :is_commontator
+      ActiveRecord::Base.is_commontator.must_equal false
+      DummyModel.must_respond_to :acts_as_commontator
+      DummyModel.must_respond_to :is_commontator
+      DummyModel.is_commontator.must_equal false
+      DummyUser.must_respond_to :acts_as_commontator
+      DummyUser.must_respond_to :is_commontator
+      DummyUser.is_commontator.must_equal true
+    end
+
+    it 'must modify models that act_as_commontator' do
+      user = DummyUser.create
+      user.must_respond_to :comments
+      user.must_respond_to :subscriptions
+      user.must_respond_to :commontator_config
+      user.commontator_config.must_be_instance_of CommontatorConfig
+    end
+  end
+end
+
+require 'rails_helper'
+
+module Commontator
+  RSpec.describe ActsAsCommontator, type: :lib do
+    it 'must add methods to ActiveRecord and subclasses' do
+      expect(ActiveRecord::Base).to respond_to(:acts_as_commontator)
+      expect(ActiveRecord::Base).to respond_to(:is_commontator)
+      expect(ActiveRecord::Base.is_commontator).to eq false
+      expect(DummyModel).to respond_to(:acts_as_commontator)
+      expect(DummyModel).to respond_to(:is_commontator)
+      expect(DummyModel.is_commontator).to eq false
+      expect(DummyUser).to respond_to(:acts_as_commontator)
+      expect(DummyUser).to respond_to(:is_commontator)
+      expect(DummyUser.is_commontator).to eq true
+    end
+
+    it 'must modify models that act_as_commontator' do
+      user = DummyUser.create
+      expect(user).to respond_to(:comments)
+      expect(user).to respond_to(:subscriptions)
+      expect(user).to respond_to(:commontator_config)
+      expect(user.commontator_config).to be_a(CommontatorConfig)
+    end
+  end
+end
+

data/spec/lib/commontator/commontable_config_spec.rb~

@@ -0,0 +1,29 @@
+require 'rails_helper'
+
+module Commontator
+  RSpec.describe CommontableConfig, type: :lib do
+    it 'must respond to commontable attributes' do
+      config = CommontableConfig.new
+      COMMONTABLE_ATTRIBUTES.each do |attribute|
+        expect(config).to respond_to(attribute)
+      end
+    end
+
+    it "won't respond to engine or commontator attributes" do
+      config = CommontableConfig.new
+      (ENGINE_ATTRIBUTES + COMMONTATOR_ATTRIBUTES).each do |attribute|
+        expect(config).not_to respond_to(attribute)
+      end
+    end
+
+    it 'must be configurable' do
+      proc = lambda { |thread| 'Some name' }
+      proc2 = lambda { |thread| 'Another name' }
+      config = CommontableConfig.new(:commontable_name_proc => proc)
+      expect(config.commontable_name_proc).to eq proc
+      config = CommontableConfig.new(:commontable_name_proc => proc2)
+      (config.commontable_name_proc == proc2).must_equal true
+    end
+  end
+end
+

data/spec/lib/commontator/commontator_config_spec.rb~

@@ -0,0 +1,29 @@
+require 'rails_helper'
+
+module Commontator
+  RSpec.describe CommontatorConfig, type: :lib do
+    it 'must respond to commontator attributes' do
+      config = CommontatorConfig.new
+      COMMONTATOR_ATTRIBUTES.each do |attribute|
+        config.must_respond_to attribute
+      end
+    end
+
+    it "won't respond to engine or commontable attributes" do
+      config = CommontatorConfig.new
+      (ENGINE_ATTRIBUTES + COMMONTABLE_ATTRIBUTES).each do |attribute|
+        expect(config).not_to respond_to(attribute)
+      end
+    end
+
+    it 'must be configurable' do
+      proc = lambda { |user| 'Some name' }
+      proc2 = lambda { |user| 'Another name' }
+      config = CommontatorConfig.new(:user_name_proc => proc)
+      expect(config.user_name_proc).to eq proc
+      config = CommontatorConfig.new(:user_name_proc => proc2)
+      expect(config.user_name_proc).to eq proc2
+    end
+  end
+end
+

data/spec/lib/commontator/controller_includes_spec.rb~

@@ -0,0 +1,18 @@
+require 'rails_helper'
+
+module Commontator
+  RSpec.describe ControllerIncludes, type: :lib do
+    it 'must add commontator_thread_show to ActionController instances' do
+      expect(ActionController::Base.new.respond_to?(:commontator_thread_show,
+                                                    true)).to eq true
+      expect(DummyModelsController.new.respond_to?(:commontator_thread_show,
+                                                   true)).to eq true
+    end
+
+    it 'must add shared helper to ActionController and subclasses' do
+      expect(ActionController::Base.helpers).to respond_to(:commontator_thread)
+      DummyModelsController.helpers.must_respond_to :commontator_thread
+    end
+  end
+end
+

data/spec/lib/commontator/controllers_spec.rb~

@@ -0,0 +1,18 @@
+require 'rails_helper'
+
+module Commontator
+  RSpec.describe ControllerIncludes, type: :lib do
+    it 'must add commontator_thread_show to ActionController instances' do
+      expect(ActionController::Base.new.respond_to?(:commontator_thread_show,
+                                                    true)).to eq true
+      expect(DummyModelsController.new.respond_to?(:commontator_thread_show,
+                                                   true)).to eq true
+    end
+
+    it 'must add shared helper to ActionController and subclasses' do
+      expect(ActionController::Base.helpers).to respond_to(:commontator_thread)
+      expect(DummyModelsController.helpers).to respond_to(:commontator_thread)
+    end
+  end
+end
+

data/spec/lib/commontator/shared_helper_spec.rb~

@@ -0,0 +1,22 @@
+require 'rails_helper'
+
+module Commontator
+  RSpec.describe SharedHelper, type: :lib do
+    before(:each) do
+      setup_controller_spec
+    end
+
+    it 'must show commontator thread' do
+      @user.can_read = true
+      sign_in @user
+
+      controller = DummyModelsController.new
+
+      thread_link = controller.view_context
+                              .commontator_thread(DummyModel.create)
+      expect(thread_link).not_to be_blank
+puts thread_link
+    end
+  end
+end
+

data/spec/lib/commontator_spec.rb~

@@ -0,0 +1,26 @@
+require 'rails_helper'
+
+module Commontator
+  RSpec.describe Commontator, type: :lib do
+    it 'must respond to all attributes' do
+      (ENGINE_ATTRIBUTES + COMMONTATOR_ATTRIBUTES + \
+        COMMONTABLE_ATTRIBUTES).each do |attribute|
+        expect(Commontator).to respond_to(attribute)
+      end
+    end
+
+    it 'must be configurable' do
+      l1 = lambda { |controller| controller.current_user }
+      l2 = lambda { |controller| controller.current_user }
+      Commontator.configure do |config|
+        config.current_user_proc = l1
+      end
+      expect(Commontator.current_user_proc).to eq l1
+      Commontator.configure do |config|
+        config.current_user_proc = l2
+      end
+      assert_equal(Commontator.current_user_proc, l2)
+    end
+  end
+end
+

data/spec/mailers/commontator/subscriptions_mailer_spec.rb~

@@ -0,0 +1,30 @@
+require 'rails_helper'
+
+module Commontator
+  RSpec.describe SubscriptionsMailer, type: :mailer do
+    before(:each) do
+      setup_mailer_spec
+      @user2 = DummyUser.create
+      @thread.subscribe(@user)
+      @thread.subscribe(@user2)
+      @comment = Comment.new
+      @comment.thread = @thread
+      @comment.creator = @user
+      @comment.body = 'Something'
+      @comment.save!
+      @recipients = @thread.subscribers.reject{|s| s == @user}
+    end
+
+    it 'must create deliverable mail' do
+      mail = SubscriptionsMailer.comment_created(@comment, @recipients)
+      expect(mail.to).to eq I18n.t('commontator.email.undisclosed_recipients')
+      expect(mail.cc).to be_nil
+      expect(mail.bcc.size).to eq 1
+      expect(mail.bcc).to include(@user2.email)
+      expect(mail.subject).not_to be_empty
+      expect(mail.body).not_to be_empty
+      expect(mail.deliver).to eq mail
+    end
+  end
+end
+

data/spec/models/commontator/comment_spec.rb~

@@ -0,0 +1,82 @@
+require 'rails_helper'
+require 'acts_as_votable'
+
+module Commontator
+  RSpec.describe Comment, type: :model do
+    before(:each) do
+      setup_model_spec
+      @comment = Comment.new
+      @comment.thread = @thread
+      @comment.creator = @user
+      @comment.body = 'Something'
+    end
+
+    it 'must be votable if acts_as_votable is installed' do
+      Comment.must_respond_to(:acts_as_votable)
+      expect(@comment.is_votable?).to eq true
+      expect(@comment.acts_as_votable_initialized).to eq true
+    end
+
+    it 'must know if it has been modified' do
+      @comment.save!
+
+      expect(@comment.is_modified?).to eq false
+
+      @comment.body = 'Something else'
+      @comment.editor = @user
+      @comment.save!
+
+      expect(@comment.is_modified?).to eq true
+    end
+
+    it 'must know if it has been deleted' do
+      user = DummyUser.new
+
+      expect(@comment.is_deleted?).to eq false
+      expect(@comment.editor).to be_nil
+
+      @comment.delete_by(user)
+
+      expect(@comment.is_deleted?).to eq true
+      expect(@comment.editor).to eq user
+
+      @comment.undelete_by(user)
+
+      expect(@comment.is_deleted?).to eq false
+    end
+
+    it 'must make proper timestamps' do
+      @comment.save!
+
+      expect(@comment.created_timestamp).to eq(
+        I18n.t('commontator.comment.status.created_at',
+               :created_at => I18n.l(@comment.created_at,
+                                     :format => :commontator))
+      )
+      expect(@comment.updated_timestamp).to eq(
+        I18n.t('commontator.comment.status.updated_at',
+               :editor_name => @user.name,
+               :updated_at => I18n.l(@comment.updated_at,
+                                     :format => :commontator))
+      )
+
+      user2 = DummyUser.create
+      @comment.body = 'Something else'
+      @comment.editor = user2
+      @comment.save!
+
+      expect(@comment.created_timestamp).to eq(
+        I18n.t('commontator.comment.status.created_at',
+               :created_at => I18n.l(@comment.created_at,
+                                     :format => :commontator))
+      )
+      expect(@comment.updated_timestamp).to eq(
+        I18n.t('commontator.comment.status.updated_at',
+               :editor_name => user2.name,
+               :updated_at => I18n.l(@comment.updated_at,
+                                     :format => :commontator))
+      )
+    end
+  end
+end
+

data/spec/models/commontator/subscription_spec.rb~

@@ -0,0 +1,38 @@
+require 'rails_helper'
+
+module Commontator
+  RSpec.describe Subscription, type: :model do
+    before(:each) do
+      setup_model_spec
+      @subscription = Subscription.new
+      @subscription.thread = @thread
+      @subscription.subscriber = @user
+      @subscription.save!
+    end
+    
+    it 'must count unread comments' do
+      expect(@subscription.unread_comments.count).to eq 0
+
+      comment = Comment.new
+      comment.thread = @thread
+      comment.creator = @user
+      comment.body = 'Something'
+      comment.save!
+
+      expect(@subscription.reload.unread_comments.count).to eq 1
+
+      comment = Comment.new
+      comment.thread = @thread
+      comment.creator = @user
+      comment.body = 'Something else'
+      comment.save!
+
+      expect(@subscription.reload.unread_comments.count).to eq 2
+
+      @subscription.touch
+
+      expect(@subscription.reload.unread_comments.count).to eq 0
+    end
+  end
+end
+

data/spec/models/commontator/thread_spec.rb

@@ -113,6 +113,43 @@ module Commontator
       expect(@commontable.thread.comments).not_to include(comment)
     end
 
+    it 'must preserve the thread and comments by default when commontable is gone' do
+      comment = Comment.new
+      comment.thread = @thread
+      comment.creator = @user
+      comment.body = 'Undead'
+      comment.save!
+      comment.reload
+
+      expect(Thread.find(@thread.id)).to eq @thread
+      expect(Comment.find(comment.id)).to eq comment
+
+      @commontable.destroy!
+
+      expect(Thread.find(@thread.id)).to eq @thread
+      expect(Comment.find(comment.id)).to eq comment
+    end
+
+    it 'must delete the thread and comments when commontable has dependent :destroy' do
+      commontable = DummyDependentModel.create
+      thread = commontable.thread
+
+      comment = Comment.new
+      comment.thread = thread
+      comment.creator = @user
+      comment.body = 'Undead'
+      comment.save!
+      comment.reload
+
+      expect(Thread.find(thread.id)).to eq thread
+      expect(Comment.find(comment.id)).to eq comment
+
+      commontable.destroy!
+
+      expect{Thread.find(thread.id)}.to raise_exception(ActiveRecord::RecordNotFound)
+      expect{Comment.find(comment.id)}.to raise_exception(ActiveRecord::RecordNotFound)
+    end
+
     it 'must return nil subscription for nil or false subscriber' do
       expect(@thread.subscription_for(nil)).to eq nil
       expect(@thread.subscription_for(false)).to eq nil

data/spec/models/commontator/thread_spec.rb~

@@ -0,0 +1,122 @@
+require 'rails_helper'
+
+module Commontator
+  RSpec.describe Thread, type: :model do
+    before(:each) do
+      setup_model_spec
+    end
+
+    it 'must have a config' do
+      expect(@thread.config).to be_a(CommontableConfig)
+      @thread.update_attribute(:commontable_id, nil)
+      expect(Thread.find(@thread.id).config).to eq Commontator
+    end
+    
+    it 'must order all comments' do
+      comment = Comment.new
+      comment.thread = @thread
+      comment.creator = @user
+      comment.body = 'Something'
+      comment.save!
+      comment2 = Comment.new
+      comment2.thread = @thread
+      comment2.creator = @user
+      comment2.body = 'Something else'
+      comment2.save!
+
+      comments = @thread.comments
+      ordered_comments = @thread.ordered_comments
+
+      comments.each { |c| expect(ordered_comments).to include(c) }
+      ordered_comments.each { |oc| expect(comments).to include(oc) }
+    end
+
+    it 'must list all subscribers' do
+      @thread.subscribe(@user)
+      @thread.subscribe(DummyUser.create)
+
+      @thread.subscriptions.each do |sp|
+        expect(@thread.subscribers).to include(sp.subscriber)
+      end
+    end
+
+    it 'must find the subscription for each user' do
+      @thread.subscribe(@user)
+      user2 = DummyUser.create
+      @thread.subscribe(user2)
+
+      subscription = @thread.subscription_for(@user)
+      expect(subscription.thread).to eq @thread
+      expect(subscription.subscriber).to eq @user
+      subscription = @thread.subscription_for(user2)
+      expect(subscription.thread).to eq @thread
+      expect(subscription.subscriber).to eq user2
+    end
+
+    it 'must know if it is closed' do
+      expect(@thread.is_closed?).to eq false
+
+      @thread.close(@user)
+
+      expect(@thread.is_closed?).to eq true
+      expect(@thread.closer).to eq @user
+
+      @thread.reopen
+
+      expect(@thread.is_closed?).to eq false
+    end
+
+    it 'must mark comments as read' do
+      @thread.subscribe(@user)
+
+      subscription = @thread.subscription_for(@user)
+      expect(subscription.unread_comments.count).to eq 0
+
+      comment = Comment.new
+      comment.thread = @thread
+      comment.creator = @user
+      comment.body = 'Something'
+      comment.save!
+
+      expect(subscription.reload.unread_comments.count).to eq 1
+
+      @thread.mark_as_read_for(@user)
+
+      expect(subscription.reload.unread_comments.count).to eq 0
+    end
+
+    it 'must be able to clear comments' do
+      comment = Comment.new
+      comment.thread = @thread
+      comment.creator = @user
+      comment.body = 'Something'
+      comment.save!
+
+      @thread.close(@user)
+
+      expect(@thread.commontable).to eq @commontable
+      expect(@thread.comments).to include(comment)
+      expect(@thread.is_closed?).to eq true
+      expect(@thread.closer).to eq @user
+
+      @commontable = DummyModel.find(@commontable.id)
+      expect(@commontable.thread).to eq @thread
+
+      @thread.clear
+
+      expect(@thread.commontable).to be_nil
+      expect(@thread.comments).to include(comment)
+
+      @commontable = DummyModel.find(@commontable.id)
+      expect(@commontable.thread).to be_nil
+      expect(@commontable.thread).not_to eq @thread
+      expect(@commontable.thread.comments).not_to include(comment)
+    end
+
+    it 'must return nil subscription for nil or false subscriber' do
+      expect(@thread.subscription_for(nil)).to eq nil
+      expect(@thread.subscription_for(false)).to eq nil
+    end
+  end
+end
+