socialization 0.5.0.beta3 → 0.5.0.beta4

data/test/stores/active_record/like_store_test.rb

@@ -108,6 +108,24 @@ class ActiveRecordLikeStoreTest < Test::Unit::TestCase
       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

data/test/stores/active_record/mention_store_test.rb

@@ -108,6 +108,23 @@ class ActiveRecordMentionStoreTest < Test::Unit::TestCase
       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

data/test/stores/redis/base_test.rb

@@ -0,0 +1,203 @@
+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

data/test/stores/redis/follow_store_test.rb

@@ -1,153 +1,27 @@
 require File.expand_path(File.dirname(__FILE__))+'/../../test_helper'
 
 class RedisFollowStoreTest < Test::Unit::TestCase
-  context "RedisStores::FollowStoreTest" do
+  context "RedisStores::Follow" do
     setup do
       use_redis_store
       @klass = Socialization::RedisStores::Follow
-      @klass.touch nil
-      @klass.after_follow nil
-      @klass.after_unfollow nil
-      @follower = ImAFollower.create
-      @followable = ImAFollowable.create
+      @base = Socialization::RedisStores::Base
     end
 
-    context "Stores" do
-      should "inherit Socialization::RedisStores::Follow" do
-        assert_equal Socialization::RedisStores::Follow, Socialization.follow_model
+    context "method aliases" do
+      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!)
+        assert_method_public @klass, :follow!
+        assert_method_public @klass, :unfollow!
+        assert_method_public @klass, :follows?
+        assert_method_public @klass, :followers_relation
+        assert_method_public @klass, :followers
+        assert_method_public @klass, :followables_relation
+        assert_method_public @klass, :followables
+        assert_method_public @klass, :remove_followers
+        assert_method_public @klass, :remove_followables
       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
+end

data/test/stores/redis/like_store_test.rb

@@ -1,153 +1,25 @@
 require File.expand_path(File.dirname(__FILE__))+'/../../test_helper'
 
 class RedisLikeStoreTest < Test::Unit::TestCase
-  context "RedisStores::LikeStoreTest" do
+  context "RedisStores::Like" do
     setup do
       use_redis_store
       @klass = Socialization::RedisStores::Like
-      @klass.touch nil
-      @klass.after_like nil
-      @klass.after_unlike nil
-      @liker = ImALiker.create
-      @likeable = ImALikeable.create
+      @base = Socialization::RedisStores::Base
     end
 
-    context "Stores" do
-      should "inherit Socialization::RedisStores::Like" do
-        assert_equal Socialization::RedisStores::Like, Socialization.like_model
+    context "method aliases" do
+      should "be set properly and made public" do
+        assert_method_public @klass, :like!
+        assert_method_public @klass, :unlike!
+        assert_method_public @klass, :likes?
+        assert_method_public @klass, :likers_relation
+        assert_method_public @klass, :likers
+        assert_method_public @klass, :likeables_relation
+        assert_method_public @klass, :likeables
+        assert_method_public @klass, :remove_likers
+        assert_method_public @klass, :remove_likeables
       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
+end