socialization 1.1.0 → 1.2.0

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

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