socialization 1.1.0 → 1.2.0

data/spec/actors/mentioner_spec.rb

@@ -0,0 +1,105 @@
+require 'spec_helper'
+
+describe Socialization::Mentioner do
+  before(:all) do
+    use_ar_store
+    @mentioner = ImAMentioner.new
+    @mentionable = ImAMentionable.create
+  end
+
+  describe "#is_mentioner?" do
+    it "returns true" do
+      expect(@mentioner.is_mentioner?).to be true
+    end
+  end
+
+  describe "#mentioner?" do
+    it "returns true" do
+      expect(@mentioner.mentioner?).to be true
+    end
+  end
+
+  describe "#mention!" do
+    it "does not accept non-mentionables" do
+      expect { @mentioner.mention!(:foo) }.to raise_error(Socialization::ArgumentError)
+    end
+
+    it "calls $Mention.mention!" do
+      expect($Mention).to receive(:mention!).with(@mentioner, @mentionable).once
+      @mentioner.mention!(@mentionable)
+    end
+  end
+
+  describe "#unmention!" do
+    it "does not accept non-mentionables" do
+      expect { @mentioner.unmention!(:foo) }.to raise_error(Socialization::ArgumentError)
+    end
+
+    it "calls $Mention.mention!" do
+      expect($Mention).to receive(:unmention!).with(@mentioner, @mentionable).once
+      @mentioner.unmention!(@mentionable)
+    end
+  end
+
+  describe "#toggle_mention!" do
+    it "does not accept non-mentionables" do
+      expect { @mentioner.unmention!(:foo) }.to raise_error(Socialization::ArgumentError)
+    end
+
+    it "unmentions when mentioning" do
+      expect(@mentioner).to receive(:mentions?).with(@mentionable).once.and_return(true)
+      expect(@mentioner).to receive(:unmention!).with(@mentionable).once
+      @mentioner.toggle_mention!(@mentionable)
+    end
+
+    it "mentions when not mentioning" do
+      expect(@mentioner).to receive(:mentions?).with(@mentionable).once.and_return(false)
+      expect(@mentioner).to receive(:mention!).with(@mentionable).once
+      @mentioner.toggle_mention!(@mentionable)
+    end
+  end
+
+  describe "#mentions?" do
+    it "does not accept non-mentionables" do
+      expect { @mentioner.unmention!(:foo) }.to raise_error(Socialization::ArgumentError)
+    end
+
+    it "calls $Mention.mentions?" do
+      expect($Mention).to receive(:mentions?).with(@mentioner, @mentionable).once
+      @mentioner.mentions?(@mentionable)
+    end
+  end
+
+  describe "#mentionables" do
+    it "calls $Mention.mentionables" do
+      expect($Mention).to receive(:mentionables).with(@mentioner, @mentionable.class, { :foo => :bar })
+      @mentioner.mentionables(@mentionable.class, { :foo => :bar })
+    end
+  end
+
+  describe "#mentionees" do
+    it "calls $Mention.mentionables" do
+      expect($Mention).to receive(:mentionables).with(@mentioner, @mentionable.class, { :foo => :bar })
+      @mentioner.mentionees(@mentionable.class, { :foo => :bar })
+    end
+  end
+
+  describe "#mentionables_relation" do
+    it "calls $Mention.mentionables_relation" do
+      expect($Mention).to receive(:mentionables_relation).with(@mentioner, @mentionable.class, { :foo => :bar })
+      @mentioner.mentionables_relation(@mentionable.class, { :foo => :bar })
+    end
+  end
+
+  describe "#mentionees_relation" do
+    it "calls $Mention.mentionables_relation" do
+      expect($Mention).to receive(:mentionables_relation).with(@mentioner, @mentionable.class, { :foo => :bar })
+      @mentioner.mentionees_relation(@mentionable.class, { :foo => :bar })
+    end
+  end
+
+  it "removes mention relationships" do
+    expect(Socialization.mention_model).to receive(:remove_mentionables).with(@mentioner)
+    @mentioner.destroy
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,21 @@
+$MOCK_REDIS = true
+
+require 'bundler/setup'
+Bundler.setup
+
+RSpec.configure do |config|
+  config.expect_with(:rspec) { |c| c.syntax = :expect }
+  config.filter_run focus: true
+  config.run_all_when_everything_filtered = true
+end
+
+$:.push File.expand_path("../lib", __FILE__)
+require 'active_record'
+require "socialization"
+require 'spec_support/data_stores'
+require 'spec_support/matchers'
+require 'logger'
+
+ActiveSupport::Inflector.inflections do |inflect|
+  inflect.irregular 'cache', 'caches'
+end

data/{test/test_helper.rb → spec/spec_support/data_stores.rb}

@@ -1,64 +1,10 @@
-$MOCK_REDIS = true
-
-require 'rubygems'
-require 'active_record'
-require 'shoulda'
-require 'test/unit'
-require 'logger'
 require 'mock_redis' if $MOCK_REDIS
 require 'redis' unless $MOCK_REDIS
-require 'mocha' # mocha always needs to be loaded last! http://stackoverflow.com/questions/3118866/mocha-mock-carries-to-another-test/4375296#4375296
-# require 'pry'
-
-$:.push File.expand_path("../lib", __FILE__)
-require "socialization"
 
 silence_warnings do
   Redis = MockRedis if $MOCK_REDIS # Magic!
 end
 
-module Test::Unit::Assertions
-  def assert_true(object, message="")
-    assert_equal(true, object, message)
-  end
-
-  def assert_false(object, message="")
-    assert_equal(false, object, message)
-  end
-
-  def assert_array_similarity(expected, actual, message=nil)
-    full_message = build_message(message, "<?> expected but was\n<?>.\n", expected, actual)
-    assert_block(full_message) { (expected.size ==  actual.size) && (expected - actual == []) }
-  end
-
-  def assert_empty(obj, msg = nil)
-    msg = "Expected #{obj.inspect} to be empty" unless msg
-    assert_respond_to obj, :empty?
-    assert obj.empty?, msg
-  end
-
-  def assert_method_public(obj, method, msg = nil)
-    msg = "Expected method #{obj}.#{method} to be public."
-    method = if RUBY_VERSION.match(/^1\.8/)
-      method.to_s
-    else
-      method.to_s.to_sym
-    end
-
-    assert obj.public_methods.include?(method), msg
-  end
-end
-
-class Test::Unit::TestCase
-  def setup
-    use_ar_store
-  end
-
-  def teardown
-    clear_redis
-  end
-end
-
 def use_redis_store
   Socialization.follow_model = Socialization::RedisStores::Follow
   Socialization.mention_model = Socialization::RedisStores::Mention
@@ -86,7 +32,7 @@ def clear_redis
 end
 
 ActiveRecord::Base.configurations = {'sqlite3' => {:adapter => 'sqlite3', :database => ':memory:'}}
-ActiveRecord::Base.establish_connection('sqlite3')
+ActiveRecord::Base.establish_connection(:sqlite3)
 
 ActiveRecord::Base.logger = Logger.new(STDERR)
 ActiveRecord::Base.logger.level = Logger::WARN
@@ -136,44 +82,74 @@ ActiveRecord::Schema.define(:version => 0) do
   end
 
   create_table :im_a_followers do |t|
-    t.timestamps
+    t.timestamps null: true
+  end
+
+  create_table :im_a_follower_with_counter_caches do |t|
+    t.integer :followees_count, default: 0
+    t.timestamps null: true
   end
 
   create_table :im_a_followables do |t|
-    t.timestamps
+    t.timestamps null: true
+  end
+
+  create_table :im_a_followable_with_counter_caches do |t|
+    t.integer :followers_count, default: 0
+    t.timestamps null: true
   end
 
   create_table :im_a_likers do |t|
-    t.timestamps
+    t.timestamps null: true
+  end
+
+  create_table :im_a_liker_with_counter_caches do |t|
+    t.integer :likees_count, default: 0
+    t.timestamps null: true
   end
 
   create_table :im_a_likeables do |t|
-    t.timestamps
+    t.timestamps null: true
+  end
+
+  create_table :im_a_likeable_with_counter_caches do |t|
+    t.integer :likers_count, default: 0
+    t.timestamps null: true
   end
 
   create_table :im_a_mentioners do |t|
-    t.timestamps
+    t.timestamps null: true
+  end
+
+  create_table :im_a_mentioner_with_counter_caches do |t|
+    t.integer :mentionees_count, default: 0
+    t.timestamps null: true
   end
 
   create_table :im_a_mentionables do |t|
-    t.timestamps
+    t.timestamps null: true
+  end
+
+  create_table :im_a_mentionable_with_counter_caches do |t|
+    t.integer :mentioners_count, default: 0
+    t.timestamps null: true
   end
 
   create_table :im_a_mentioner_and_mentionables do |t|
-    t.timestamps
+    t.timestamps null: true
   end
 
   create_table :vanillas do |t|
-    t.timestamps
+    t.timestamps null: true
   end
 end
 
-class Celebrity < ActiveRecord::Base
+class ::Celebrity < ActiveRecord::Base
   acts_as_followable
   acts_as_mentionable
 end
 
-class User < ActiveRecord::Base
+class ::User < ActiveRecord::Base
   acts_as_follower
   acts_as_followable
   acts_as_liker
@@ -183,13 +159,13 @@ class User < ActiveRecord::Base
   has_many :comments
 end
 
-class Comment < ActiveRecord::Base
+class ::Comment < ActiveRecord::Base
   acts_as_mentioner
   belongs_to :user
   belongs_to :movie
 end
 
-class Movie < ActiveRecord::Base
+class ::Movie < ActiveRecord::Base
   acts_as_likeable
   has_many :comments
 end
@@ -198,40 +174,59 @@ end
 # class Like < Socialization::ActiveRecordStores::Like; end
 # class Mention < Socialization::ActiveRecordStores::Mention; end
 
-class ImAFollower < ActiveRecord::Base
+class ::ImAFollower < ActiveRecord::Base
+  acts_as_follower
+end
+class ::ImAFollowerWithCounterCache < ActiveRecord::Base
   acts_as_follower
 end
-class ImAFollowerChild < ImAFollower; end
+class ::ImAFollowerChild < ImAFollower; end
 
-class ImAFollowable < ActiveRecord::Base
+class ::ImAFollowable < ActiveRecord::Base
   acts_as_followable
 end
-class ImAFollowableChild < ImAFollowable; end
+class ::ImAFollowableWithCounterCache < ActiveRecord::Base
+  acts_as_followable
+end
+class ::ImAFollowableChild < ImAFollowable; end
 
-class ImALiker < ActiveRecord::Base
+class ::ImALiker < ActiveRecord::Base
+  acts_as_liker
+end
+class ::ImALikerWithCounterCache < ActiveRecord::Base
   acts_as_liker
 end
-class ImALikerChild < ImALiker; end
+class ::ImALikerChild < ImALiker; end
 
-class ImALikeable < ActiveRecord::Base
+class ::ImALikeable < ActiveRecord::Base
+  acts_as_likeable
+end
+class ::ImALikeableWithCounterCache < ActiveRecord::Base
   acts_as_likeable
 end
-class ImALikeableChild < ImALikeable; end
+class ::ImALikeableChild < ImALikeable; end
 
-class ImAMentioner < ActiveRecord::Base
+class ::ImAMentioner < ActiveRecord::Base
   acts_as_mentioner
 end
-class ImAMentionerChild < ImAMentioner; end
+class ::ImAMentionerWithCounterCache < ActiveRecord::Base
+  acts_as_mentioner
+end
+class ::ImAMentionerChild < ImAMentioner; end
 
-class ImAMentionable < ActiveRecord::Base
+class ::ImAMentionable < ActiveRecord::Base
   acts_as_mentionable
 end
-class ImAMentionableChild < ImAMentionable; end
+class ::ImAMentionableWithCounterCache < ActiveRecord::Base
+  acts_as_mentionable
+end
+class ::ImAMentionableChild < ImAMentionable; end
 
-class ImAMentionerAndMentionable < ActiveRecord::Base
+class ::ImAMentionerAndMentionable < ActiveRecord::Base
   acts_as_mentioner
   acts_as_mentionable
 end
 
-class Vanilla < ActiveRecord::Base
+class ::Vanilla < ActiveRecord::Base
 end
+

data/spec/spec_support/matchers.rb

@@ -0,0 +1,54 @@
+RSpec::Matchers.define :be_a_public_method_of do |obj|
+  match do |actual|
+    method = RUBY_VERSION.match(/^1\.8/) ? actual.to_s : actual.to_s.to_sym
+    obj.public_methods.include?(method)
+  end
+
+  failure_message do |actual|
+    "expected that #{actual} would be a public method of #{actual.class}"
+  end
+
+  failure_message_when_negated do |actual|
+    "expected that #{actual} would not be a public method of #{actual.class}"
+  end
+
+  description do
+    "be a public method"
+  end
+end
+
+RSpec::Matchers.define :match_follower do |expected|
+  match do |actual|
+    expected.follower_type == actual.class.to_s && expected.follower_id == actual.id
+  end
+end
+
+RSpec::Matchers.define :match_followable do |expected|
+  match do |actual|
+    expected.followable_type == actual.class.to_s && expected.followable_id == actual.id
+  end
+end
+
+RSpec::Matchers.define :match_liker do |expected|
+  match do |actual|
+    expected.liker_type == actual.class.to_s && expected.liker_id == actual.id
+  end
+end
+
+RSpec::Matchers.define :match_likeable do |expected|
+  match do |actual|
+    expected.likeable_type == actual.class.to_s && expected.likeable_id == actual.id
+  end
+end
+
+RSpec::Matchers.define :match_mentioner do |expected|
+  match do |actual|
+    expected.mentioner_type == actual.class.to_s && expected.mentioner_id == actual.id
+  end
+end
+
+RSpec::Matchers.define :match_mentionable do |expected|
+  match do |actual|
+    expected.mentionable_type == actual.class.to_s && expected.mentionable_id == actual.id
+  end
+end

data/spec/stores/active_record/follow_store_spec.rb

@@ -0,0 +1,147 @@
+require 'spec_helper'
+
+describe Socialization::ActiveRecordStores::Follow do
+  before do
+    @klass = Socialization::ActiveRecordStores::Follow
+    @klass.touch nil
+    @klass.after_follow nil
+    @klass.after_unfollow nil
+    @follower = ImAFollower.create
+    @followable = ImAFollowable.create
+  end
+
+  describe "data store" do
+    it "inherits Socialization::ActiveRecordStores::Follow" do
+      expect(Socialization.follow_model).to eq(Socialization::ActiveRecordStores::Follow)
+    end
+  end
+
+  describe "#follow!" do
+    it "creates a Follow record" do
+      @klass.follow!(@follower, @followable)
+      expect(@follower).to match_follower(@klass.last)
+      expect(@followable).to match_followable(@klass.last)
+    end
+
+    it "increments counter caches" do
+      follower   = ImAFollowerWithCounterCache.create
+      followable = ImAFollowableWithCounterCache.create
+      @klass.follow!(follower, followable)
+      expect(follower.reload.followees_count).to eq(1)
+      expect(followable.reload.followers_count).to eq(1)
+    end
+
+    it "touches follower when instructed" do
+      @klass.touch :follower
+      expect(@follower).to receive(:touch).once
+      expect(@followable).to receive(:touch).never
+      @klass.follow!(@follower, @followable)
+    end
+
+    it "touches followable when instructed" do
+      @klass.touch :followable
+      expect(@follower).to receive(:touch).never
+      expect(@followable).to receive(:touch).once
+      @klass.follow!(@follower, @followable)
+    end
+
+    it "touches all when instructed" do
+      @klass.touch :all
+      expect(@follower).to receive(:touch).once
+      expect(@followable).to receive(:touch).once
+      @klass.follow!(@follower, @followable)
+    end
+
+    it "calls after follow hook" do
+      @klass.after_follow :after_follow
+      expect(@klass).to receive(:after_follow).once
+      @klass.follow!(@follower, @followable)
+    end
+
+    it "calls after unfollow hook" do
+      @klass.after_follow :after_unfollow
+      expect(@klass).to receive(:after_unfollow).once
+      @klass.follow!(@follower, @followable)
+    end
+  end
+
+  describe "#unfollow!" do
+    it "decrements counter caches" do
+      follower   = ImAFollowerWithCounterCache.create
+      followable = ImAFollowableWithCounterCache.create
+      @klass.follow!(follower, followable)
+      @klass.unfollow!(follower, followable)
+      expect(follower.reload.followees_count).to eq(0)
+      expect(followable.reload.followers_count).to eq(0)
+    end
+  end
+
+  describe "#follows?" do
+    it "returns true when follow exists" do
+      @klass.create! do |f|
+        f.follower = @follower
+        f.followable = @followable
+      end
+      expect(@klass.follows?(@follower, @followable)).to be true
+    end
+
+    it "returns false when follow doesn't exist" do
+      expect(@klass.follows?(@follower, @followable)).to be false
+    end
+  end
+
+  describe "#followers" do
+    it "returns an array of followers" do
+      follower1 = ImAFollower.create
+      follower2 = ImAFollower.create
+      follower1.follow!(@followable)
+      follower2.follow!(@followable)
+      expect(@klass.followers(@followable, follower1.class)).to eq([follower1, follower2])
+    end
+
+    it "returns an array of follower ids when plucking" do
+      follower1 = ImAFollower.create
+      follower2 = ImAFollower.create
+      follower1.follow!(@followable)
+      follower2.follow!(@followable)
+      expect(@klass.followers(@followable, follower1.class, :pluck => :id)).to eq([follower1.id, follower2.id])
+    end
+  end
+
+  describe "#followables" do
+    it "returns an array of followers" do
+      followable1 = ImAFollowable.create
+      followable2 = ImAFollowable.create
+      @follower.follow!(followable1)
+      @follower.follow!(followable2)
+      expect(@klass.followables(@follower, followable1.class)).to eq([followable1, followable2])
+    end
+
+    it "returns an array of follower ids when plucking" do
+      followable1 = ImAFollowable.create
+      followable2 = ImAFollowable.create
+      @follower.follow!(followable1)
+      @follower.follow!(followable2)
+      expect(@klass.followables(@follower, followable1.class, :pluck => :id)).to eq([followable1.id, followable2.id])
+    end
+  end
+
+  describe "#remove_followers" do
+    it "deletes all followers relationships for a followable" do
+      @follower.follow!(@followable)
+      expect(@followable.followers(@follower.class).count).to eq(1)
+      @klass.remove_followers(@followable)
+      expect(@followable.followers(@follower.class).count).to eq(0)
+    end
+  end
+
+  describe "#remove_followables" do
+    it "deletes all followables relationships for a follower" do
+      @follower.follow!(@followable)
+      expect(@follower.followables(@followable.class).count).to eq(1)
+      @klass.remove_followables(@follower)
+      expect(@follower.followables(@followable.class).count).to eq(0)
+    end
+  end
+end
+