commontator 4.11.0 → 4.11.1

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

@@ -1,52 +0,0 @@
-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~

@@ -1,29 +0,0 @@
-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~

@@ -1,29 +0,0 @@
-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~

@@ -1,18 +0,0 @@
-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~

@@ -1,18 +0,0 @@
-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~

@@ -1,22 +0,0 @@
-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~

@@ -1,26 +0,0 @@
-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~

@@ -1,30 +0,0 @@
-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~

@@ -1,82 +0,0 @@
-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~

@@ -1,38 +0,0 @@
-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~

@@ -1,122 +0,0 @@
-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
-