twrk-socialization 0.0.1

data/spec/stores/active_record/mention_store_spec.rb

@@ -0,0 +1,148 @@
+require 'spec_helper'
+
+describe Socialization::ActiveRecordStores::Mention do
+  before do
+    @klass = Socialization::ActiveRecordStores::Mention
+    @klass.touch nil
+    @klass.after_mention nil
+    @klass.after_unmention nil
+    @mentioner = ImAMentioner.create
+    @mentionable = ImAMentionable.create
+  end
+
+  describe "data store" do
+    it "inherits Socialization::ActiveRecordStores::Mention" do
+      expect(Socialization.mention_model).to eq Socialization::ActiveRecordStores::Mention
+    end
+  end
+
+  describe "#mention!" do
+    it "creates a Mention record" do
+      @klass.mention!(@mentioner, @mentionable)
+      expect(@mentioner).to match_mentioner(@klass.last)
+      expect(@mentionable).to match_mentionable(@klass.last)
+    end
+
+    it "increments counter caches" do
+      mentioner   = ImAMentionerWithCounterCache.create
+      mentionable = ImAMentionableWithCounterCache.create
+      @klass.mention!(mentioner, mentionable)
+      expect(mentioner.reload.mentionees_count).to eq 1
+      expect(mentionable.reload.mentioners_count).to eq 1
+    end
+
+    it "touchs mentioner when instructed" do
+      @klass.touch :mentioner
+      expect(@mentioner).to receive(:touch).once
+      expect(@mentionable).to receive(:touch).never
+      @klass.mention!(@mentioner, @mentionable)
+    end
+
+    it "touchs mentionable when instructed" do
+      @klass.touch :mentionable
+      expect(@mentioner).to receive(:touch).never
+      expect(@mentionable).to receive(:touch).once
+      @klass.mention!(@mentioner, @mentionable)
+    end
+
+    it "touchs all when instructed" do
+      @klass.touch :all
+      expect(@mentioner).to receive(:touch).once
+      expect(@mentionable).to receive(:touch).once
+      @klass.mention!(@mentioner, @mentionable)
+    end
+
+    it "calls after mention hook" do
+      @klass.after_mention :after_mention
+      expect(@klass).to receive(:after_mention).once
+      @klass.mention!(@mentioner, @mentionable)
+    end
+
+    it "calls after unmention hook" do
+      @klass.after_mention :after_unmention
+      expect(@klass).to receive(:after_unmention).once
+      @klass.mention!(@mentioner, @mentionable)
+    end
+  end
+
+  describe "#unmention!" do
+    it "decrements counter caches" do
+      mentioner   = ImAMentionerWithCounterCache.create
+      mentionable = ImAMentionableWithCounterCache.create
+      @klass.mention!(mentioner, mentionable)
+      @klass.unmention!(mentioner, mentionable)
+      expect(mentioner.reload.mentionees_count).to eq 0
+      expect(mentionable.reload.mentioners_count).to eq 0
+    end
+  end
+
+
+  describe "#mentions?" do
+    it "returns true when mention exists" do
+      @klass.create! do |f|
+        f.mentioner = @mentioner
+        f.mentionable = @mentionable
+      end
+      expect(@klass.mentions?(@mentioner, @mentionable)).to be true
+    end
+
+    it "returns false when mention doesn't exist" do
+      expect(@klass.mentions?(@mentioner, @mentionable)).to be false
+    end
+  end
+
+  describe "#mentioners" do
+    it "returns an array of mentioners" do
+      mentioner1 = ImAMentioner.create
+      mentioner2 = ImAMentioner.create
+      mentioner1.mention!(@mentionable)
+      mentioner2.mention!(@mentionable)
+      expect(@klass.mentioners(@mentionable, mentioner1.class)).to eq [mentioner1, mentioner2]
+    end
+
+    it "returns an array of mentioner ids when plucking" do
+      mentioner1 = ImAMentioner.create
+      mentioner2 = ImAMentioner.create
+      mentioner1.mention!(@mentionable)
+      mentioner2.mention!(@mentionable)
+      expect(@klass.mentioners(@mentionable, mentioner1.class, :pluck => :id)).to eq [mentioner1.id, mentioner2.id]
+    end
+  end
+
+  describe "#mentionables" do
+    it "returns an array of mentioners" do
+      mentionable1 = ImAMentionable.create
+      mentionable2 = ImAMentionable.create
+      @mentioner.mention!(mentionable1)
+      @mentioner.mention!(mentionable2)
+      expect(@klass.mentionables(@mentioner, mentionable1.class)).to eq [mentionable1, mentionable2]
+    end
+
+    it "returns an array of mentioner ids when plucking" do
+      mentionable1 = ImAMentionable.create
+      mentionable2 = ImAMentionable.create
+      @mentioner.mention!(mentionable1)
+      @mentioner.mention!(mentionable2)
+      expect(@klass.mentionables(@mentioner, mentionable1.class, :pluck => :id)).to eq [mentionable1.id, mentionable2.id]
+    end
+  end
+
+  describe "#remove_mentioners" do
+    it "deletes all mentioners relationships for a mentionable" do
+      @mentioner.mention!(@mentionable)
+      expect(@mentionable.mentioners(@mentioner.class).count).to eq 1
+      @klass.remove_mentioners(@mentionable)
+      expect(@mentionable.mentioners(@mentioner.class).count).to eq 0
+    end
+  end
+
+  describe "#remove_mentionables" do
+    it "deletes all mentionables relationships for a mentioner" do
+      @mentioner.mention!(@mentionable)
+      expect(@mentioner.mentionables(@mentionable.class).count).to eq 1
+      @klass.remove_mentionables(@mentioner)
+      expect(@mentioner.mentionables(@mentionable.class).count).to eq 0
+    end
+  end
+end
+

data/spec/stores/active_record/mixins/base_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+
+describe Socialization::ActiveRecordStores::Mixins::Base do
+  describe ".update_counter" do
+    it "increments counter cache if column exists" do
+      followable = ImAFollowableWithCounterCache.create
+
+      update_counter(followable, followers_count: +1)
+
+      expect(followable.reload.followers_count).to eq(1)
+    end
+
+    it "does not raise any errors if column doesn't exist" do
+      followable = ImAFollowable.create
+      update_counter(followable, followers_count: +1)
+    end
+  end
+
+  def update_counter(model, counter)
+    klass = Object.new
+    klass.extend(Socialization::ActiveRecordStores::Mixins::Base)
+    klass.update_counter(model, counter)
+  end
+end
+

data/spec/stores/redis/base_spec.rb

@@ -0,0 +1,195 @@
+require 'spec_helper'
+
+describe Socialization::RedisStores::Base do
+  # Testing through RedisStores::Follow for easy testing
+  before(:each) do
+    use_redis_store
+    @klass = Socialization::RedisStores::Follow
+    @klass.touch nil
+    @klass.after_follow nil
+    @klass.after_unfollow nil
+    @follower1 = ImAFollower.create
+    @follower2 = ImAFollower.create
+    @followable1 = ImAFollowable.create
+    @followable2 = ImAFollowable.create
+  end
+
+  describe "RedisStores::Base through RedisStores::Follow" do
+    describe "Stores" do
+      it "inherits Socialization::RedisStores::Follow" do
+        expect(Socialization.follow_model).to eq(Socialization::RedisStores::Follow)
+      end
+    end
+
+    describe "#follow!" do
+      it "creates follow records" do
+        @klass.follow!(@follower1, @followable1)
+        expect(Socialization.redis.smembers(forward_key(@followable1))).to match_array ["#{@follower1.class}:#{@follower1.id}"]
+        expect(Socialization.redis.smembers(backward_key(@follower1))).to match_array ["#{@followable1.class}:#{@followable1.id}"]
+
+        @klass.follow!(@follower2, @followable1)
+        expect(Socialization.redis.smembers(forward_key(@followable1))).to match_array ["#{@follower1.class}:#{@follower1.id}", "#{@follower2.class}:#{@follower2.id}"]
+        expect(Socialization.redis.smembers(backward_key(@follower1))).to match_array ["#{@followable1.class}:#{@followable1.id}"]
+        expect(Socialization.redis.smembers(backward_key(@follower2))).to match_array ["#{@followable1.class}:#{@followable1.id}"]
+      end
+
+      it "touches follower when instructed" do
+        @klass.touch :follower
+        expect(@follower1).to receive(:touch).once
+        expect(@followable1).to receive(:touch).never
+        @klass.follow!(@follower1, @followable1)
+      end
+
+      it "touches followable when instructed" do
+        @klass.touch :followable
+        expect(@follower1).to receive(:touch).never
+        expect(@followable1).to receive(:touch).once
+        @klass.follow!(@follower1, @followable1)
+      end
+
+      it "touches all when instructed" do
+        @klass.touch :all
+        expect(@follower1).to receive(:touch).once
+        expect(@followable1).to receive(:touch).once
+        @klass.follow!(@follower1, @followable1)
+      end
+
+      it "calls after follow hook" do
+        @klass.after_follow :after_follow
+        expect(@klass).to receive(:after_follow).once
+        @klass.follow!(@follower1, @followable1)
+      end
+
+      it "calls after unfollow hook" do
+        @klass.after_follow :after_unfollow
+        expect(@klass).to receive(:after_unfollow).once
+        @klass.follow!(@follower1, @followable1)
+      end
+    end
+
+    describe "#unfollow!" do
+      before(:each) do
+        @klass.follow!(@follower1, @followable1)
+      end
+
+      it "removes follow records" do
+        @klass.unfollow!(@follower1, @followable1)
+        expect(Socialization.redis.smembers(forward_key(@followable1))).to be_empty
+        expect(Socialization.redis.smembers(backward_key(@follower1))).to be_empty
+      end
+    end
+
+    describe "#follows?" do
+      it "returns true when follow exists" do
+        @klass.follow!(@follower1, @followable1)
+        expect(@klass.follows?(@follower1, @followable1)).to be true
+      end
+
+      it "returns false when follow doesn't exist" do
+        expect(@klass.follows?(@follower1, @followable1)).to be false
+      end
+    end
+
+    describe "#followers" do
+      it "returns an array of followers" do
+        follower1 = ImAFollower.create
+        follower2 = ImAFollower.create
+        follower1.follow!(@followable1)
+        follower2.follow!(@followable1)
+        expect(@klass.followers(@followable1, follower1.class)).to match_array [follower1, follower2]
+      end
+
+      it "returns an array of follower ids when plucking" do
+        follower1 = ImAFollower.create
+        follower2 = ImAFollower.create
+        follower1.follow!(@followable1)
+        follower2.follow!(@followable1)
+        expect(@klass.followers(@followable1, follower1.class, :pluck => :id)).to match_array ["#{follower1.id}", "#{follower2.id}"]
+      end
+    end
+
+    describe "#followables" do
+      it "returns an array of followables" do
+        followable1 = ImAFollowable.create
+        followable2 = ImAFollowable.create
+        @follower1.follow!(followable1)
+        @follower1.follow!(followable2)
+
+        expect(@klass.followables(@follower1, followable1.class)).to match_array [followable1, followable2]
+      end
+
+      it "returns an array of followables ids when plucking" do
+        followable1 = ImAFollowable.create
+        followable2 = ImAFollowable.create
+        @follower1.follow!(followable1)
+        @follower1.follow!(followable2)
+        expect(@klass.followables(@follower1, followable1.class, :pluck => :id)).to match_array ["#{followable1.id}", "#{followable2.id}"]
+      end
+    end
+
+    describe "#generate_forward_key" do
+      it "returns valid key when passed an object" do
+        expect(forward_key(@followable1)).to eq("Followers:#{@followable1.class.name}:#{@followable1.id}")
+      end
+
+      it "returns valid key when passed a String" do
+        expect(forward_key("Followable:1")).to eq("Followers:Followable:1")
+      end
+    end
+
+    describe "#generate_backward_key" do
+      it "returns valid key when passed an object" do
+        expect(backward_key(@follower1)).to eq("Followables:#{@follower1.class.name}:#{@follower1.id}")
+      end
+
+      it "returns valid key when passed a String" do
+        expect(backward_key("Follower:1")).to eq("Followables:Follower:1")
+      end
+    end
+
+    describe "#remove_followers" do
+      it "deletes all followers relationships for a followable" do
+        @follower1.follow!(@followable1)
+        @follower2.follow!(@followable1)
+        expect(@followable1.followers(@follower1.class).count).to eq(2)
+
+        @klass.remove_followers(@followable1)
+        expect(@followable1.followers(@follower1.class).count).to eq(0)
+        expect(Socialization.redis.smembers(forward_key(@followable1))).to be_empty
+        expect(Socialization.redis.smembers(backward_key(@follower1))).to be_empty
+        expect(Socialization.redis.smembers(backward_key(@follower2))).to be_empty
+      end
+    end
+
+    describe "#remove_followables" do
+      it "deletes all followables relationships for a follower" do
+        @follower1.follow!(@followable1)
+        @follower1.follow!(@followable2)
+        expect(@follower1.followables(@followable1.class).count).to eq(2)
+
+        @klass.remove_followables(@follower1)
+        expect(@follower1.followables(@followable1.class).count).to eq(0)
+        expect(Socialization.redis.smembers backward_key(@followable1)).to be_empty
+        expect(Socialization.redis.smembers backward_key(@follower2)).to be_empty
+        expect(Socialization.redis.smembers forward_key(@follower1)).to be_empty
+      end
+    end
+
+    describe "#key_type_to_type_names" do
+      it "returns the proper arrays" do
+        expect(@klass.send(:key_type_to_type_names, Socialization::RedisStores::Follow)).to eq(['follower', 'followable'])
+        expect(@klass.send(:key_type_to_type_names, Socialization::RedisStores::Mention)).to eq(['mentioner', 'mentionable'])
+        expect(@klass.send(:key_type_to_type_names, Socialization::RedisStores::Like)).to eq(['liker', 'likeable'])
+      end
+    end
+  end
+
+  # Helpers
+  def forward_key(followable)
+    Socialization::RedisStores::Follow.send(:generate_forward_key, followable)
+  end
+
+  def backward_key(follower)
+    Socialization::RedisStores::Follow.send(:generate_backward_key, follower)
+  end
+end

data/spec/stores/redis/config_spec.rb

@@ -0,0 +1,28 @@
+require "spec_helper"
+
+context "RedisStoreConfigTest" do
+  before do
+    Socialization.instance_eval { @redis = nil }
+  end
+
+  it "returns a new Redis object when none were specified" do
+    expect(Socialization.redis).to be_a Redis
+  end
+
+  it "always returns the same Redis object when none were specified" do
+    redis = Socialization.redis
+    expect(Socialization.redis).to eq(redis)
+  end
+
+  it "is able to set and get a redis instance" do
+    redis = Redis.new
+    Socialization.redis = redis
+    expect(Socialization.redis).to eq(redis)
+  end
+
+  it "always return the same Redis object when it was specified" do
+    redis = Redis.new
+    Socialization.redis = redis
+    expect(Socialization.redis).to eq(redis)
+  end
+end

data/spec/stores/redis/follow_store_spec.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+
+describe Socialization::RedisStores::Follow do
+  before do
+    use_redis_store
+    @klass = Socialization::RedisStores::Follow
+    @base = Socialization::RedisStores::Base
+  end
+
+  describe "method aliases" do
+    it "should be set properly and made public" do
+      # TODO: Can't figure out how to test method aliases properly. The following doesn't work:
+      # assert @klass.method(:follow!) == @base.method(:relation!)
+      expect(:follow!).to be_a_public_method_of(@klass)
+      expect(:unfollow!).to be_a_public_method_of(@klass)
+      expect(:follows?).to be_a_public_method_of(@klass)
+      expect(:followers_relation).to be_a_public_method_of(@klass)
+      expect(:followers).to be_a_public_method_of(@klass)
+      expect(:followables_relation).to be_a_public_method_of(@klass)
+      expect(:followables).to be_a_public_method_of(@klass)
+      expect(:remove_followers).to be_a_public_method_of(@klass)
+      expect(:remove_followables).to be_a_public_method_of(@klass)
+    end
+  end
+
+end

data/spec/stores/redis/like_store_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+
+describe Socialization::RedisStores::Like do
+  before do
+    use_redis_store
+    @klass = Socialization::RedisStores::Like
+    @base = Socialization::RedisStores::Base
+  end
+
+  describe "method aliases" do
+    it "should be set properly and made public" do
+      expect(:like!).to be_a_public_method_of(@klass)
+      expect(:unlike!).to be_a_public_method_of(@klass)
+      expect(:likes?).to be_a_public_method_of(@klass)
+      expect(:likers_relation).to be_a_public_method_of(@klass)
+      expect(:likers).to be_a_public_method_of(@klass)
+      expect(:likeables_relation).to be_a_public_method_of(@klass)
+      expect(:likeables).to be_a_public_method_of(@klass)
+      expect(:remove_likers).to be_a_public_method_of(@klass)
+      expect(:remove_likeables).to be_a_public_method_of(@klass)
+    end
+  end
+end

data/spec/stores/redis/mention_store_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+
+describe Socialization::RedisStores::Follow do
+  before do
+    use_redis_store
+    @klass = Socialization::RedisStores::Mention
+    @base = Socialization::RedisStores::Base
+  end
+
+  describe "method aliases" do
+    it "should be set properly and made public" do
+      expect(:mention!).to be_a_public_method_of(@klass)
+      expect(:unmention!).to be_a_public_method_of(@klass)
+      expect(:mentions?).to be_a_public_method_of(@klass)
+      expect(:mentioners_relation).to be_a_public_method_of(@klass)
+      expect(:mentioners).to be_a_public_method_of(@klass)
+      expect(:mentionables_relation).to be_a_public_method_of(@klass)
+      expect(:mentionables).to be_a_public_method_of(@klass)
+      expect(:remove_mentioners).to be_a_public_method_of(@klass)
+      expect(:remove_mentionables).to be_a_public_method_of(@klass)
+    end
+  end
+end

data/spec/string_spec.rb

@@ -0,0 +1,13 @@
+require 'spec_helper'
+
+describe String do
+  describe "#deep_const_get" do
+    it "should return a class" do
+      expect("Socialization".deep_const_get).to eq(Socialization)
+      expect("Socialization::ActiveRecordStores".deep_const_get).to eq(Socialization::ActiveRecordStores)
+      expect("Socialization::ActiveRecordStores::Follow".deep_const_get).to eq(Socialization::ActiveRecordStores::Follow)
+
+      expect { "Foo::Bar".deep_const_get }.to raise_error(NameError)
+    end
+  end
+end

data/spec/victims/followable_spec.rb

@@ -0,0 +1,59 @@
+require 'spec_helper'
+
+describe Socialization::Followable do
+  before(:all) do
+    use_ar_store
+    @follower = ImAFollower.new
+    @followable = ImAFollowable.create
+  end
+
+  describe "#is_followable?" do
+    it "returns true" do
+      expect(@followable.is_followable?).to be true
+    end
+  end
+
+  describe "#followable?" do
+    it "returns true" do
+      expect(@followable.followable?).to be true
+    end
+  end
+
+  describe "#followed_by?" do
+    it "does not accept non-followers" do
+      expect { @followable.followed_by?(:foo) }.to raise_error(Socialization::ArgumentError)
+    end
+
+    it "calls $Follow.follows?" do
+      expect($Follow).to receive(:follows?).with(@follower, @followable).once
+      @followable.followed_by?(@follower)
+    end
+  end
+
+  describe "#followers" do
+    it "calls $Follow.followers" do
+      expect($Follow).to receive(:followers).with(@followable, @follower.class, { :foo => :bar })
+      @followable.followers(@follower.class, { :foo => :bar })
+    end
+  end
+
+  describe "#followers_relation" do
+    it "calls $Follow.followers_relation" do
+      expect($Follow).to receive(:followers_relation).with(@followable, @follower.class, { :foo => :bar })
+      @followable.followers_relation(@follower.class, { :foo => :bar })
+    end
+  end
+
+  describe "deleting a followable" do
+    before(:all) do
+      @follower = ImAFollower.create
+      @follower.follow!(@followable)
+    end
+
+    it "removes follow relationships" do
+      expect(Socialization.follow_model).to receive(:remove_followers).with(@followable)
+      @followable.destroy
+    end
+  end
+end
+

data/spec/victims/likeable_spec.rb

@@ -0,0 +1,58 @@
+require 'spec_helper'
+
+describe Socialization::Likeable do
+  before(:all) do
+    use_ar_store
+    @liker = ImALiker.new
+    @likeable = ImALikeable.create
+  end
+
+  describe "#is_likeable?" do
+    it "returns true" do
+      expect(@likeable.is_likeable?).to be true
+    end
+  end
+
+  describe "#likeable?" do
+    it "returns true" do
+      expect(@likeable.likeable?).to be true
+    end
+  end
+
+  describe "#liked_by?" do
+    it "does not accept non-likers" do
+      expect { @likeable.liked_by?(:foo) }.to raise_error(Socialization::ArgumentError)
+    end
+
+    it "calls $Like.likes?" do
+      expect($Like).to receive(:likes?).with(@liker, @likeable).once
+      @likeable.liked_by?(@liker)
+    end
+  end
+
+  describe "#likers" do
+    it "calls $Like.likers" do
+      expect($Like).to receive(:likers).with(@likeable, @liker.class, { :foo => :bar })
+      @likeable.likers(@liker.class, { :foo => :bar })
+    end
+  end
+
+  describe "#likers_relation" do
+    it "calls $Like.likers_relation" do
+      expect($Like).to receive(:likers_relation).with(@likeable, @liker.class, { :foo => :bar })
+      @likeable.likers_relation(@liker.class, { :foo => :bar })
+    end
+  end
+
+  describe "deleting a likeable" do
+    before(:all) do
+      @liker = ImALiker.create
+      @liker.like!(@likeable)
+    end
+
+    it "removes like relationships" do
+      expect(Socialization.like_model).to receive(:remove_likers).with(@likeable)
+      @likeable.destroy
+    end
+  end
+end

data/spec/victims/mentionable_spec.rb

@@ -0,0 +1,59 @@
+require 'spec_helper'
+
+describe Socialization::Mentionable do
+  before(:all) do
+    use_ar_store
+    @mentioner = ImAMentioner.new
+    @mentionable = ImAMentionable.create
+  end
+
+  describe "#is_mentionable?" do
+    it "returns true" do
+      expect(@mentionable.is_mentionable?).to be true
+    end
+  end
+
+  describe "#mentionable?" do
+    it "returns true" do
+      expect(@mentionable.mentionable?).to be true
+    end
+  end
+
+  describe "#mentioned_by?" do
+    it "does not accept non-mentioners" do
+      expect { @mentionable.mentioned_by?(:foo) }.to raise_error(Socialization::ArgumentError)
+    end
+
+    it "calls $Mention.mentions?" do
+      expect($Mention).to receive(:mentions?).with(@mentioner, @mentionable).once
+      @mentionable.mentioned_by?(@mentioner)
+    end
+  end
+
+  describe "#mentioners" do
+    it "calls $Mention.mentioners" do
+      expect($Mention).to receive(:mentioners).with(@mentionable, @mentioner.class, { :foo => :bar })
+      @mentionable.mentioners(@mentioner.class, { :foo => :bar })
+    end
+  end
+
+  describe "#mentioners_relation" do
+    it "calls $Mention.mentioners" do
+      expect($Mention).to receive(:mentioners_relation).with(@mentionable, @mentioner.class, { :foo => :bar })
+      @mentionable.mentioners_relation(@mentioner.class, { :foo => :bar })
+    end
+  end
+
+  describe "deleting a mentionable" do
+    before(:all) do
+      @mentioner = ImAMentioner.create
+      @mentioner.mention!(@mentionable)
+    end
+
+    it "removes mention relationships" do
+      expect(Socialization.mention_model).to receive(:remove_mentioners).with(@mentionable)
+      @mentionable.destroy
+    end
+  end
+
+end