socialization 1.1.0 → 1.2.0

data/test/stores/active_record/like_store_test.rb

@@ -1,139 +0,0 @@
-require File.expand_path(File.dirname(__FILE__))+'/../../test_helper'
-
-class ActiveRecordLikeStoreTest < Test::Unit::TestCase
-  context "ActiveRecordStores::LikeStoreTest" do
-    setup do
-      @klass = Socialization::ActiveRecordStores::Like
-      @klass.touch nil
-      @klass.after_like nil
-      @klass.after_unlike nil
-      @liker = ImALiker.create
-      @likeable = ImALikeable.create
-    end
-
-    context "data store" do
-      should "inherit Socialization::ActiveRecordStores::Like" do
-        assert_equal Socialization::ActiveRecordStores::Like, Socialization.like_model
-      end
-    end
-
-    context "#like!" do
-      should "create a Like record" do
-        @klass.like!(@liker, @likeable)
-        assert_match_liker @klass.last, @liker
-        assert_match_likeable @klass.last, @likeable
-      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
-        @klass.create! do |f|
-          f.liker = @liker
-          f.likeable = @likeable
-        end
-        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_equal [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_equal [liker1.id, liker2.id], @klass.likers(@likeable, liker1.class, :pluck => :id)
-      end
-    end
-
-    context "#likeables" do
-      should "return an array of likers" do
-        likeable1 = ImALikeable.create
-        likeable2 = ImALikeable.create
-        @liker.like!(likeable1)
-        @liker.like!(likeable2)
-        assert_equal [likeable1, likeable2], @klass.likeables(@liker, likeable1.class)
-      end
-
-      should "return an array of liker ids when plucking" do
-        likeable1 = ImALikeable.create
-        likeable2 = ImALikeable.create
-        @liker.like!(likeable1)
-        @liker.like!(likeable2)
-        assert_equal [likeable1.id, likeable2.id], @klass.likeables(@liker, likeable1.class, :pluck => :id)
-      end
-    end
-
-    context "#remove_likers" do
-      should "delete all likers relationships for a likeable" do
-        @liker.like!(@likeable)
-        assert_equal 1, @likeable.likers(@liker.class).count
-        @klass.remove_likers(@likeable)
-        assert_equal 0, @likeable.likers(@liker.class).count
-      end
-    end
-
-    context "#remove_likeables" do
-      should "delete all likeables relationships for a liker" do
-        @liker.like!(@likeable)
-        assert_equal 1, @liker.likeables(@likeable.class).count
-        @klass.remove_likeables(@liker)
-        assert_equal 0, @liker.likeables(@likeable.class).count
-      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
-end

data/test/stores/active_record/mention_store_test.rb

@@ -1,138 +0,0 @@
-require File.expand_path(File.dirname(__FILE__))+'/../../test_helper'
-
-class ActiveRecordMentionStoreTest < Test::Unit::TestCase
-  context "ActiveRecordStores::MentionStoreTest" do
-    setup do
-      @klass = Socialization::ActiveRecordStores::Mention
-      @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::Mention" do
-        assert_equal Socialization::ActiveRecordStores::Mention, 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
-
-    context "#remove_mentioners" do
-      should "delete all mentioners relationships for a mentionable" do
-        @mentioner.mention!(@mentionable)
-        assert_equal 1, @mentionable.mentioners(@mentioner.class).count
-        @klass.remove_mentioners(@mentionable)
-        assert_equal 0, @mentionable.mentioners(@mentioner.class).count
-      end
-    end
-
-    context "#remove_mentionables" do
-      should "delete all mentionables relationships for a mentioner" do
-        @mentioner.mention!(@mentionable)
-        assert_equal 1, @mentioner.mentionables(@mentionable.class).count
-        @klass.remove_mentionables(@mentioner)
-        assert_equal 0, @mentioner.mentionables(@mentionable.class).count
-      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/base_test.rb

@@ -1,203 +0,0 @@
-require File.expand_path(File.dirname(__FILE__))+'/../../test_helper'
-
-class RedisBaseStoreTest < Test::Unit::TestCase
-  # Testing through RedisStores::Follow for easy testing
-  context "RedisStores::Base through RedisStores::Follow" do
-    setup 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
-
-    context "Stores" do
-      should "inherit Socialization::RedisStores::Follow" do
-        assert_equal Socialization::RedisStores::Follow, Socialization.follow_model
-      end
-    end
-
-    context "#follow!" do
-      should "create follow records" do
-        @klass.follow!(@follower1, @followable1)
-        assert_array_similarity ["#{@follower1.class}:#{@follower1.id}"], Socialization.redis.smembers(forward_key(@followable1))
-        assert_array_similarity ["#{@followable1.class}:#{@followable1.id}"], Socialization.redis.smembers(backward_key(@follower1))
-
-        @klass.follow!(@follower2, @followable1)
-        assert_array_similarity ["#{@follower1.class}:#{@follower1.id}", "#{@follower2.class}:#{@follower2.id}"], Socialization.redis.smembers(forward_key(@followable1))
-        assert_array_similarity ["#{@followable1.class}:#{@followable1.id}"], Socialization.redis.smembers(backward_key(@follower1))
-        assert_array_similarity ["#{@followable1.class}:#{@followable1.id}"], Socialization.redis.smembers(backward_key(@follower2))
-      end
-
-      should "touch follower when instructed" do
-        @klass.touch :follower
-        @follower1.expects(:touch).once
-        @followable1.expects(:touch).never
-        @klass.follow!(@follower1, @followable1)
-      end
-
-      should "touch followable when instructed" do
-        @klass.touch :followable
-        @follower1.expects(:touch).never
-        @followable1.expects(:touch).once
-        @klass.follow!(@follower1, @followable1)
-      end
-
-      should "touch all when instructed" do
-        @klass.touch :all
-        @follower1.expects(:touch).once
-        @followable1.expects(:touch).once
-        @klass.follow!(@follower1, @followable1)
-      end
-
-      should "call after follow hook" do
-        @klass.after_follow :after_follow
-        @klass.expects(:after_follow).once
-        @klass.follow!(@follower1, @followable1)
-      end
-
-      should "call after unfollow hook" do
-        @klass.after_follow :after_unfollow
-        @klass.expects(:after_unfollow).once
-        @klass.follow!(@follower1, @followable1)
-      end
-    end
-
-    context "#unfollow!" do
-      setup do
-        @klass.follow!(@follower1, @followable1)
-      end
-
-      should "remove follow records" do
-        @klass.unfollow!(@follower1, @followable1)
-        assert_empty Socialization.redis.smembers forward_key(@followable1)
-        assert_empty Socialization.redis.smembers backward_key(@follower1)
-      end
-    end
-
-    context "#follows?" do
-      should "return true when follow exists" do
-        @klass.follow!(@follower1, @followable1)
-        assert_true @klass.follows?(@follower1, @followable1)
-      end
-
-      should "return false when follow doesn't exist" do
-        assert_false @klass.follows?(@follower1, @followable1)
-      end
-    end
-
-    context "#followers" do
-      should "return an array of followers" do
-        follower1 = ImAFollower.create
-        follower2 = ImAFollower.create
-        follower1.follow!(@followable1)
-        follower2.follow!(@followable1)
-        assert_array_similarity [follower1, follower2], @klass.followers(@followable1, follower1.class)
-      end
-
-      should "return an array of follower ids when plucking" do
-        follower1 = ImAFollower.create
-        follower2 = ImAFollower.create
-        follower1.follow!(@followable1)
-        follower2.follow!(@followable1)
-        assert_array_similarity ["#{follower1.id}", "#{follower2.id}"], @klass.followers(@followable1, follower1.class, :pluck => :id)
-      end
-    end
-
-    context "#followables" do
-      should "return an array of followables" do
-        followable1 = ImAFollowable.create
-        followable2 = ImAFollowable.create
-        @follower1.follow!(followable1)
-        @follower1.follow!(followable2)
-
-        assert_array_similarity [followable1, followable2], @klass.followables(@follower1, followable1.class)
-      end
-
-      should "return an array of followables ids when plucking" do
-        followable1 = ImAFollowable.create
-        followable2 = ImAFollowable.create
-        @follower1.follow!(followable1)
-        @follower1.follow!(followable2)
-        assert_array_similarity ["#{followable1.id}", "#{followable2.id}"], @klass.followables(@follower1, followable1.class, :pluck => :id)
-      end
-    end
-
-    context "#generate_forward_key" do
-      should "return valid key when passed an object" do
-        assert_equal "Followers:#{@followable1.class.name}:#{@followable1.id}", forward_key(@followable1)
-      end
-
-      should "return valid key when passed a String" do
-        assert_equal "Followers:Followable:1", forward_key("Followable:1")
-      end
-    end
-
-    context "#generate_backward_key" do
-      should "return valid key when passed an object" do
-        assert_equal "Followables:#{@follower1.class.name}:#{@follower1.id}", backward_key(@follower1)
-      end
-
-      should "return valid key when passed a String" do
-        assert_equal "Followables:Follower:1", backward_key("Follower:1")
-      end
-    end
-
-    context "#remove_followers" do
-      should "delete all followers relationships for a followable" do
-        @follower1.follow!(@followable1)
-        @follower2.follow!(@followable1)
-        assert_equal 2, @followable1.followers(@follower1.class).count
-
-        @klass.remove_followers(@followable1)
-        assert_equal 0, @followable1.followers(@follower1.class).count
-        assert_empty Socialization.redis.smembers forward_key(@followable1)
-        assert_empty Socialization.redis.smembers backward_key(@follower1)
-        assert_empty Socialization.redis.smembers backward_key(@follower2)
-      end
-    end
-
-    context "#remove_followables" do
-      should "delete all followables relationships for a follower" do
-        @follower1.follow!(@followable1)
-        @follower1.follow!(@followable2)
-        assert_equal 2, @follower1.followables(@followable1.class).count
-
-        @klass.remove_followables(@follower1)
-        assert_equal 0, @follower1.followables(@followable1.class).count
-        assert_empty Socialization.redis.smembers backward_key(@followable1)
-        assert_empty Socialization.redis.smembers backward_key(@follower2)
-        assert_empty Socialization.redis.smembers forward_key(@follower1)
-      end
-    end
-
-    context "#key_type_to_type_names" do
-      should "return the proper arrays" do
-        assert_equal ['follower', 'followable'], @klass.send(:key_type_to_type_names, Socialization::RedisStores::Follow)
-        assert_equal ['mentioner', 'mentionable'], @klass.send(:key_type_to_type_names, Socialization::RedisStores::Mention)
-        assert_equal ['liker', 'likeable'], @klass.send(:key_type_to_type_names, Socialization::RedisStores::Like)
-      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 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