twrk-socialization 0.0.1

data/spec/spec_support/data_stores.rb

@@ -0,0 +1,232 @@
+require 'mock_redis' if $MOCK_REDIS
+require 'redis' unless $MOCK_REDIS
+
+silence_warnings do
+  Redis = MockRedis if $MOCK_REDIS # Magic!
+end
+
+def use_redis_store
+  Socialization.follow_model = Socialization::RedisStores::Follow
+  Socialization.mention_model = Socialization::RedisStores::Mention
+  Socialization.like_model = Socialization::RedisStores::Like
+  setup_model_shortcuts
+end
+
+def use_ar_store
+  Socialization.follow_model = Socialization::ActiveRecordStores::Follow
+  Socialization.mention_model = Socialization::ActiveRecordStores::Mention
+  Socialization.like_model = Socialization::ActiveRecordStores::Like
+  setup_model_shortcuts
+end
+
+def setup_model_shortcuts
+  $Follow = Socialization.follow_model
+  $Mention = Socialization.mention_model
+  $Like = Socialization.like_model
+end
+
+def clear_redis
+  Socialization.redis.keys(nil).each do |k|
+    Socialization.redis.del k
+  end
+end
+
+ActiveRecord::Base.configurations = {'sqlite3' => {:adapter => 'sqlite3', :database => ':memory:'}}
+ActiveRecord::Base.establish_connection(:sqlite3)
+
+ActiveRecord::Base.logger = Logger.new(STDERR)
+ActiveRecord::Base.logger.level = Logger::WARN
+
+ActiveRecord::Migration.verbose = false
+ActiveRecord::Schema.define(:version => 0) do
+  create_table :users do |t|
+    t.string :name
+  end
+
+  create_table :celebrities do |t|
+    t.string :name
+  end
+
+  create_table :movies do |t|
+    t.string :name
+  end
+
+  create_table :comments do |t|
+    t.integer :user_id
+    t.integer :movie_id
+    t.string :body
+  end
+
+  create_table :follows do |t|
+    t.string  :follower_type
+    t.integer :follower_id
+    t.string  :followable_type
+    t.integer :followable_id
+    t.datetime :created_at
+  end
+
+  create_table :likes do |t|
+    t.string  :liker_type
+    t.integer :liker_id
+    t.string  :likeable_type
+    t.integer :likeable_id
+    t.datetime :created_at
+  end
+
+  create_table :mentions do |t|
+    t.string  :mentioner_type
+    t.integer :mentioner_id
+    t.string  :mentionable_type
+    t.integer :mentionable_id
+    t.datetime :created_at
+  end
+
+  create_table :im_a_followers do |t|
+    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 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 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 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 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 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 null: true
+  end
+
+  create_table :vanillas do |t|
+    t.timestamps null: true
+  end
+end
+
+class ::Celebrity < ActiveRecord::Base
+  acts_as_followable
+  acts_as_mentionable
+end
+
+class ::User < ActiveRecord::Base
+  acts_as_follower
+  acts_as_followable
+  acts_as_liker
+  acts_as_likeable
+  acts_as_mentionable
+
+  has_many :comments
+end
+
+class ::Comment < ActiveRecord::Base
+  acts_as_mentioner
+  belongs_to :user
+  belongs_to :movie
+end
+
+class ::Movie < ActiveRecord::Base
+  acts_as_likeable
+  has_many :comments
+end
+
+# class Follow < Socialization::ActiveRecordStores::Follow; end
+# class Like < Socialization::ActiveRecordStores::Like; end
+# class Mention < Socialization::ActiveRecordStores::Mention; end
+
+class ::ImAFollower < ActiveRecord::Base
+  acts_as_follower
+end
+class ::ImAFollowerWithCounterCache < ActiveRecord::Base
+  acts_as_follower
+end
+class ::ImAFollowerChild < ImAFollower; end
+
+class ::ImAFollowable < ActiveRecord::Base
+  acts_as_followable
+end
+class ::ImAFollowableWithCounterCache < ActiveRecord::Base
+  acts_as_followable
+end
+class ::ImAFollowableChild < ImAFollowable; end
+
+class ::ImALiker < ActiveRecord::Base
+  acts_as_liker
+end
+class ::ImALikerWithCounterCache < ActiveRecord::Base
+  acts_as_liker
+end
+class ::ImALikerChild < ImALiker; end
+
+class ::ImALikeable < ActiveRecord::Base
+  acts_as_likeable
+end
+class ::ImALikeableWithCounterCache < ActiveRecord::Base
+  acts_as_likeable
+end
+class ::ImALikeableChild < ImALikeable; end
+
+class ::ImAMentioner < ActiveRecord::Base
+  acts_as_mentioner
+end
+class ::ImAMentionerWithCounterCache < ActiveRecord::Base
+  acts_as_mentioner
+end
+class ::ImAMentionerChild < ImAMentioner; end
+
+class ::ImAMentionable < ActiveRecord::Base
+  acts_as_mentionable
+end
+class ::ImAMentionableWithCounterCache < ActiveRecord::Base
+  acts_as_mentionable
+end
+class ::ImAMentionableChild < ImAMentionable; end
+
+class ::ImAMentionerAndMentionable < ActiveRecord::Base
+  acts_as_mentioner
+  acts_as_mentionable
+end
+
+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
+

data/spec/stores/active_record/like_store_spec.rb

@@ -0,0 +1,146 @@
+require 'spec_helper'
+
+describe Socialization::ActiveRecordStores::Like do
+  before do
+    @klass = Socialization::ActiveRecordStores::Like
+    @klass.touch nil
+    @klass.after_like nil
+    @klass.after_unlike nil
+    @liker = ImALiker.create
+    @likeable = ImALikeable.create
+  end
+
+  describe "data store" do
+    it "inherits Socialization::ActiveRecordStores::Like" do
+      expect(Socialization.like_model).to eq Socialization::ActiveRecordStores::Like
+    end
+  end
+
+  describe "#like!" do
+    it "creates a Like record" do
+      @klass.like!(@liker, @likeable)
+      expect(@liker).to match_liker @klass.last
+      expect(@likeable).to match_likeable @klass.last
+    end
+
+    it "increments counter caches" do
+      liker    = ImALikerWithCounterCache.create
+      likeable = ImALikeableWithCounterCache.create
+      @klass.like!(liker, likeable)
+      expect(liker.reload.likees_count).to eq(1)
+      expect(likeable.reload.likers_count).to eq(1)
+    end
+
+    it "touches liker when instructed" do
+      @klass.touch :liker
+      expect(@liker).to receive(:touch).once
+      expect(@likeable).to receive(:touch).never
+      @klass.like!(@liker, @likeable)
+    end
+
+    it "touches likeable when instructed" do
+      @klass.touch :likeable
+      expect(@liker).to receive(:touch).never
+      expect(@likeable).to receive(:touch).once
+      @klass.like!(@liker, @likeable)
+    end
+
+    it "touches all when instructed" do
+      @klass.touch :all
+      expect(@liker).to receive(:touch).once
+      expect(@likeable).to receive(:touch).once
+      @klass.like!(@liker, @likeable)
+    end
+
+    it "calls after like hook" do
+      @klass.after_like :after_like
+      expect(@klass).to receive(:after_like).once
+      @klass.like!(@liker, @likeable)
+    end
+
+    it "calls after unlike hook" do
+      @klass.after_like :after_unlike
+      expect(@klass).to receive(:after_unlike).once
+      @klass.like!(@liker, @likeable)
+    end
+  end
+
+  describe "#unlike!" do
+    it "decrements counter caches" do
+      liker    = ImALikerWithCounterCache.create
+      likeable = ImALikeableWithCounterCache.create
+      @klass.like!(liker, likeable)
+      @klass.unlike!(liker, likeable)
+      expect(liker.reload.likees_count).to eq 0
+      expect(likeable.reload.likers_count).to eq 0
+    end
+  end
+
+  describe "#likes?" do
+    it "returns true when like exists" do
+      @klass.create! do |f|
+        f.liker = @liker
+        f.likeable = @likeable
+      end
+      expect(@klass.likes?(@liker, @likeable)).to be true
+    end
+
+    it "returns false when like doesn't exist" do
+      expect(@klass.likes?(@liker, @likeable)).to be false
+    end
+  end
+
+  describe "#likers" do
+    it "returns an array of likers" do
+      liker1 = ImALiker.create
+      liker2 = ImALiker.create
+      liker1.like!(@likeable)
+      liker2.like!(@likeable)
+      expect(@klass.likers(@likeable, liker1.class)).to eq [liker1, liker2]
+    end
+
+    it "returns an array of liker ids when plucking" do
+      liker1 = ImALiker.create
+      liker2 = ImALiker.create
+      liker1.like!(@likeable)
+      liker2.like!(@likeable)
+      expect(@klass.likers(@likeable, liker1.class, :pluck => :id)).to eq [liker1.id, liker2.id]
+    end
+  end
+
+  describe "#likeables" do
+    it "returns an array of likers" do
+      likeable1 = ImALikeable.create
+      likeable2 = ImALikeable.create
+      @liker.like!(likeable1)
+      @liker.like!(likeable2)
+      expect(@klass.likeables(@liker, likeable1.class)).to eq [likeable1, likeable2]
+    end
+
+    it "returns an array of liker ids when plucking" do
+      likeable1 = ImALikeable.create
+      likeable2 = ImALikeable.create
+      @liker.like!(likeable1)
+      @liker.like!(likeable2)
+      expect(@klass.likeables(@liker, likeable1.class, :pluck => :id)).to eq [likeable1.id, likeable2.id]
+    end
+  end
+
+  describe "#remove_likers" do
+    it "deletes all likers relationships for a likeable" do
+      @liker.like!(@likeable)
+      expect(@likeable.likers(@liker.class).count).to eq 1
+      @klass.remove_likers(@likeable)
+      expect(@likeable.likers(@liker.class).count).to eq 0
+    end
+  end
+
+  describe "#remove_likeables" do
+    it "deletes all likeables relationships for a liker" do
+      @liker.like!(@likeable)
+      expect(@liker.likeables(@likeable.class).count).to eq 1
+      @klass.remove_likeables(@liker)
+      expect(@liker.likeables(@likeable.class).count).to eq 0
+    end
+  end
+end