socialization 0.4.0 → 0.5.0.beta

data/test/stores/active_record/mention_store_test.rb

@@ -0,0 +1,121 @@
+require File.expand_path(File.dirname(__FILE__))+'/../../test_helper'
+
+class ActiveRecordMentionStoreTest < Test::Unit::TestCase
+  context "ActiveRecordStores::MentionStoreTest" do
+    setup do
+      @klass = Socialization::ActiveRecordStores::MentionStore
+      @klass.touch nil
+      @klass.after_mention nil
+      @klass.after_unmention nil
+      @mentioner = ImAMentioner.create
+      @mentionable = ImAMentionable.create
+    end
+
+    context "data store" do
+      should "inherit Socialization::ActiveRecordStores::MentionStore" do
+        assert_equal Socialization::ActiveRecordStores::MentionStore, Socialization.mention_model
+      end
+    end
+
+    context "#mention!" do
+      should "create a Mention record" do
+        @klass.mention!(@mentioner, @mentionable)
+        assert_match_mentioner @klass.last, @mentioner
+        assert_match_mentionable @klass.last, @mentionable
+      end
+
+      should "touch mentioner when instructed" do
+        @klass.touch :mentioner
+        @mentioner.expects(:touch).once
+        @mentionable.expects(:touch).never
+        @klass.mention!(@mentioner, @mentionable)
+      end
+
+      should "touch mentionable when instructed" do
+        @klass.touch :mentionable
+        @mentioner.expects(:touch).never
+        @mentionable.expects(:touch).once
+        @klass.mention!(@mentioner, @mentionable)
+      end
+
+      should "touch all when instructed" do
+        @klass.touch :all
+        @mentioner.expects(:touch).once
+        @mentionable.expects(:touch).once
+        @klass.mention!(@mentioner, @mentionable)
+      end
+
+      should "call after mention hook" do
+        @klass.after_mention :after_mention
+        @klass.expects(:after_mention).once
+        @klass.mention!(@mentioner, @mentionable)
+      end
+
+      should "call after unmention hook" do
+        @klass.after_mention :after_unmention
+        @klass.expects(:after_unmention).once
+        @klass.mention!(@mentioner, @mentionable)
+      end
+    end
+
+    context "#mentions?" do
+      should "return true when mention exists" do
+        @klass.create! do |f|
+          f.mentioner = @mentioner
+          f.mentionable = @mentionable
+        end
+        assert_true @klass.mentions?(@mentioner, @mentionable)
+      end
+
+      should "return false when mention doesn't exist" do
+        assert_false @klass.mentions?(@mentioner, @mentionable)
+      end
+    end
+
+    context "#mentioners" do
+      should "return an array of mentioners" do
+        mentioner1 = ImAMentioner.create
+        mentioner2 = ImAMentioner.create
+        mentioner1.mention!(@mentionable)
+        mentioner2.mention!(@mentionable)
+        assert_equal [mentioner1, mentioner2], @klass.mentioners(@mentionable, mentioner1.class)
+      end
+
+      should "return an array of mentioner ids when plucking" do
+        mentioner1 = ImAMentioner.create
+        mentioner2 = ImAMentioner.create
+        mentioner1.mention!(@mentionable)
+        mentioner2.mention!(@mentionable)
+        assert_equal [mentioner1.id, mentioner2.id], @klass.mentioners(@mentionable, mentioner1.class, :pluck => :id)
+      end
+    end
+
+    context "#mentionables" do
+      should "return an array of mentioners" do
+        mentionable1 = ImAMentionable.create
+        mentionable2 = ImAMentionable.create
+        @mentioner.mention!(mentionable1)
+        @mentioner.mention!(mentionable2)
+        assert_equal [mentionable1, mentionable2], @klass.mentionables(@mentioner, mentionable1.class)
+      end
+
+      should "return an array of mentioner ids when plucking" do
+        mentionable1 = ImAMentionable.create
+        mentionable2 = ImAMentionable.create
+        @mentioner.mention!(mentionable1)
+        @mentioner.mention!(mentionable2)
+        assert_equal [mentionable1.id, mentionable2.id], @klass.mentionables(@mentioner, mentionable1.class, :pluck => :id)
+      end
+    end
+
+  end
+
+  # Helpers
+  def assert_match_mentioner(mention_record, mentioner)
+    assert mention_record.mentioner_type ==  mentioner.class.to_s && mention_record.mentioner_id == mentioner.id
+  end
+
+  def assert_match_mentionable(mention_record, mentionable)
+    assert mention_record.mentionable_type ==  mentionable.class.to_s && mention_record.mentionable_id == mentionable.id
+  end
+end

data/test/stores/redis/config_test.rb

@@ -0,0 +1,30 @@
+require File.expand_path(File.dirname(__FILE__))+'/../../test_helper'
+
+class RedisStoreConfigTest < Test::Unit::TestCase
+  context "redis" do
+    setup do
+      Socialization.instance_eval { @redis = nil }
+    end
+
+    should "return a new Redis object when none were specified" do
+      assert_instance_of Redis, Socialization.redis
+    end
+
+    should "always return the same Redis object when none were specified" do
+      redis = Socialization.redis
+      assert_same redis, Socialization.redis
+    end
+
+    should "be able to set and get a redis instance" do
+      redis = Redis.new
+      Socialization.redis = redis
+      assert_same redis, Socialization.redis
+    end
+
+    should "always return the same Redis object when it was specified" do
+      redis = Redis.new
+      Socialization.redis = redis
+      assert_same redis, Socialization.redis
+    end
+  end
+end

data/test/stores/redis/follow_store_test.rb

@@ -0,0 +1,153 @@
+require File.expand_path(File.dirname(__FILE__))+'/../../test_helper'
+
+class RedisFollowStoreTest < Test::Unit::TestCase
+  context "RedisStores::FollowStoreTest" do
+    setup do
+      use_redis_store
+      @klass = Socialization::RedisStores::FollowStore
+      @klass.touch nil
+      @klass.after_follow nil
+      @klass.after_unfollow nil
+      @follower = ImAFollower.create
+      @followable = ImAFollowable.create
+    end
+
+    context "Stores" do
+      should "inherit Socialization::RedisStores::FollowStore" do
+        assert_equal Socialization::RedisStores::FollowStore, Socialization.follow_model
+      end
+    end
+
+    context "#follow!" do
+      should "create a Follow record" do
+        @klass.follow!(@follower, @followable)
+        assert_equal ["#{@follower.id}"], Socialization.redis.smembers(followers_key)
+        assert_equal ["#{@followable.id}"], Socialization.redis.smembers(followables_key)
+      end
+
+      should "touch follower when instructed" do
+        @klass.touch :follower
+        @follower.expects(:touch).once
+        @followable.expects(:touch).never
+        @klass.follow!(@follower, @followable)
+      end
+
+      should "touch followable when instructed" do
+        @klass.touch :followable
+        @follower.expects(:touch).never
+        @followable.expects(:touch).once
+        @klass.follow!(@follower, @followable)
+      end
+
+      should "touch all when instructed" do
+        @klass.touch :all
+        @follower.expects(:touch).once
+        @followable.expects(:touch).once
+        @klass.follow!(@follower, @followable)
+      end
+
+      should "call after follow hook" do
+        @klass.after_follow :after_follow
+        @klass.expects(:after_follow).once
+        @klass.follow!(@follower, @followable)
+      end
+
+      should "call after unfollow hook" do
+        @klass.after_follow :after_unfollow
+        @klass.expects(:after_unfollow).once
+        @klass.follow!(@follower, @followable)
+      end
+    end
+
+    context "#follows?" do
+      should "return true when follow exists" do
+        Socialization.redis.sadd followers_key, @follower.id
+        Socialization.redis.sadd followables_key, @followable.id
+        assert_true @klass.follows?(@follower, @followable)
+      end
+
+      should "return false when follow doesn't exist" do
+        assert_false @klass.follows?(@follower, @followable)
+      end
+    end
+
+    context "#followers" do
+      should "return an array of followers" do
+        follower1 = ImAFollower.create
+        follower2 = ImAFollower.create
+        follower1.follow!(@followable)
+        follower2.follow!(@followable)
+        assert_array_similarity [follower1, follower2], @klass.followers(@followable, follower1.class)
+      end
+
+      should "return an array of follower ids when plucking" do
+        follower1 = ImAFollower.create
+        follower2 = ImAFollower.create
+        follower1.follow!(@followable)
+        follower2.follow!(@followable)
+        assert_array_similarity [follower1.id, follower2.id], @klass.followers(@followable, follower1.class, :pluck => :id)
+      end
+    end
+
+    context "#followables" do
+      should "return an array of followables" do
+        followable1 = ImAFollowable.create
+        followable2 = ImAFollowable.create
+        @follower.follow!(followable1)
+        @follower.follow!(followable2)
+
+        assert_array_similarity [followable1, followable2], @klass.followables(@follower, followable1.class)
+      end
+
+      should "return an array of followables ids when plucking" do
+        followable1 = ImAFollowable.create
+        followable2 = ImAFollowable.create
+        @follower.follow!(followable1)
+        @follower.follow!(followable2)
+        assert_array_similarity [followable1.id, followable2.id], @klass.followables(@follower, followable1.class, :pluck => :id)
+      end
+    end
+
+    context "#generate_followers_key" do
+      should "return valid key when passed objects" do
+        assert_equal "Followers:ImAFollowable:#{@followable.id}:ImAFollower", followers_key(@follower, @followable)
+      end
+
+      should "return valid key when follower is a class" do
+        assert_equal "Followers:ImAFollowable:#{@followable.id}:ImAFollower", followers_key(@follower.class, @followable)
+      end
+    end
+
+    context "#generate_followables_key" do
+      should "return valid key when passed objects" do
+        assert_equal "Followables:ImAFollower:#{@follower.id}:ImAFollowable", followables_key(@follower, @followable)
+      end
+
+      should "return valid key when followable is a class" do
+        assert_equal "Followables:ImAFollower:#{@follower.id}:ImAFollowable", followables_key(@follower, @followable.class)
+      end
+    end
+
+  end
+
+  # Helpers
+  def assert_match_follower(follow_record, follower)
+    assert follow_record.follower_type ==  follower.class.to_s && follow_record.follower_id == follower.id
+  end
+
+  def assert_match_followable(follow_record, followable)
+    assert follow_record.followable_type ==  followable.class.to_s && follow_record.followable_id == followable.id
+  end
+
+  def followers_key(follower = nil, followable = nil)
+    follower ||= @follower
+    followable ||= @followable
+    @klass.send(:generate_followers_key, follower, followable)
+  end
+
+  def followables_key(follower = nil, followable = nil)
+    follower ||= @follower
+    followable ||= @followable
+    @klass.send(:generate_followables_key, follower, followable)
+  end
+end

data/test/stores/redis/like_store_test.rb

@@ -0,0 +1,153 @@
+require File.expand_path(File.dirname(__FILE__))+'/../../test_helper'
+
+class RedisLikeStoreTest < Test::Unit::TestCase
+  context "RedisStores::LikeStoreTest" do
+    setup do
+      use_redis_store
+      @klass = Socialization::RedisStores::LikeStore
+      @klass.touch nil
+      @klass.after_like nil
+      @klass.after_unlike nil
+      @liker = ImALiker.create
+      @likeable = ImALikeable.create
+    end
+
+    context "Stores" do
+      should "inherit Socialization::RedisStores::LikeStore" do
+        assert_equal Socialization::RedisStores::LikeStore, Socialization.like_model
+      end
+    end
+
+    context "#like!" do
+      should "create a Like record" do
+        @klass.like!(@liker, @likeable)
+        assert_equal ["#{@liker.id}"], Socialization.redis.smembers(likers_key)
+        assert_equal ["#{@likeable.id}"], Socialization.redis.smembers(likeables_key)
+      end
+
+      should "touch liker when instructed" do
+        @klass.touch :liker
+        @liker.expects(:touch).once
+        @likeable.expects(:touch).never
+        @klass.like!(@liker, @likeable)
+      end
+
+      should "touch likeable when instructed" do
+        @klass.touch :likeable
+        @liker.expects(:touch).never
+        @likeable.expects(:touch).once
+        @klass.like!(@liker, @likeable)
+      end
+
+      should "touch all when instructed" do
+        @klass.touch :all
+        @liker.expects(:touch).once
+        @likeable.expects(:touch).once
+        @klass.like!(@liker, @likeable)
+      end
+
+      should "call after like hook" do
+        @klass.after_like :after_like
+        @klass.expects(:after_like).once
+        @klass.like!(@liker, @likeable)
+      end
+
+      should "call after unlike hook" do
+        @klass.after_like :after_unlike
+        @klass.expects(:after_unlike).once
+        @klass.like!(@liker, @likeable)
+      end
+    end
+
+    context "#likes?" do
+      should "return true when like exists" do
+        Socialization.redis.sadd likers_key, @liker.id
+        Socialization.redis.sadd likeables_key, @likeable.id
+        assert_true @klass.likes?(@liker, @likeable)
+      end
+
+      should "return false when like doesn't exist" do
+        assert_false @klass.likes?(@liker, @likeable)
+      end
+    end
+
+    context "#likers" do
+      should "return an array of likers" do
+        liker1 = ImALiker.create
+        liker2 = ImALiker.create
+        liker1.like!(@likeable)
+        liker2.like!(@likeable)
+        assert_array_similarity [liker1, liker2], @klass.likers(@likeable, liker1.class)
+      end
+
+      should "return an array of liker ids when plucking" do
+        liker1 = ImALiker.create
+        liker2 = ImALiker.create
+        liker1.like!(@likeable)
+        liker2.like!(@likeable)
+        assert_array_similarity [liker1.id, liker2.id], @klass.likers(@likeable, liker1.class, :pluck => :id)
+      end
+    end
+
+    context "#likeables" do
+      should "return an array of likeables" do
+        likeable1 = ImALikeable.create
+        likeable2 = ImALikeable.create
+        @liker.like!(likeable1)
+        @liker.like!(likeable2)
+
+        assert_array_similarity [likeable1, likeable2], @klass.likeables(@liker, likeable1.class)
+      end
+
+      should "return an array of likeables ids when plucking" do
+        likeable1 = ImALikeable.create
+        likeable2 = ImALikeable.create
+        @liker.like!(likeable1)
+        @liker.like!(likeable2)
+        assert_array_similarity [likeable1.id, likeable2.id], @klass.likeables(@liker, likeable1.class, :pluck => :id)
+      end
+    end
+
+    context "#generate_likers_key" do
+      should "return valid key when passed objects" do
+        assert_equal "Likers:ImALikeable:#{@likeable.id}:ImALiker", likers_key(@liker, @likeable)
+      end
+
+      should "return valid key when liker is a class" do
+        assert_equal "Likers:ImALikeable:#{@likeable.id}:ImALiker", likers_key(@liker.class, @likeable)
+      end
+    end
+
+    context "#generate_likeables_key" do
+      should "return valid key when passed objects" do
+        assert_equal "Likeables:ImALiker:#{@liker.id}:ImALikeable", likeables_key(@liker, @likeable)
+      end
+
+      should "return valid key when likeable is a class" do
+        assert_equal "Likeables:ImALiker:#{@liker.id}:ImALikeable", likeables_key(@liker, @likeable.class)
+      end
+    end
+
+  end
+
+  # Helpers
+  def assert_match_liker(like_record, liker)
+    assert like_record.liker_type ==  liker.class.to_s && like_record.liker_id == liker.id
+  end
+
+  def assert_match_likeable(like_record, likeable)
+    assert like_record.likeable_type ==  likeable.class.to_s && like_record.likeable_id == likeable.id
+  end
+
+  def likers_key(liker = nil, likeable = nil)
+    liker ||= @liker
+    likeable ||= @likeable
+    @klass.send(:generate_likers_key, liker, likeable)
+  end
+
+  def likeables_key(liker = nil, likeable = nil)
+    liker ||= @liker
+    likeable ||= @likeable
+    @klass.send(:generate_likeables_key, liker, likeable)
+  end
+end