socialization 1.1.0 → 1.2.0

data/test/actors/follower_test.rb

@@ -1,114 +0,0 @@
-require File.expand_path(File.dirname(__FILE__))+'/../test_helper'
-
-class FollowerTest < Test::Unit::TestCase
-  context "Follower" do
-    setup do
-      @follower = ImAFollower.new
-      @followable = ImAFollowable.create
-    end
-
-    context "#is_follower?" do
-      should "return true" do
-        assert_true @follower.is_follower?
-      end
-    end
-
-    context "#follower?" do
-      should "return true" do
-        assert_true @follower.follower?
-      end
-    end
-
-    context "#follow!" do
-      should "not accept non-followables" do
-        assert_raise(Socialization::ArgumentError) { @follower.follow!(:foo) }
-      end
-
-      should "call $Follow.follow!" do
-        $Follow.expects(:follow!).with(@follower, @followable).once
-        @follower.follow!(@followable)
-      end
-    end
-
-    context "#unfollow!" do
-      should "not accept non-followables" do
-        assert_raise(Socialization::ArgumentError) { @follower.unfollow!(:foo) }
-      end
-
-      should "call $Follow.follow!" do
-        $Follow.expects(:unfollow!).with(@follower, @followable).once
-        @follower.unfollow!(@followable)
-      end
-    end
-
-    context "#toggle_follow!" do
-      should "not accept non-followables" do
-        assert_raise(Socialization::ArgumentError) { @follower.unfollow!(:foo) }
-      end
-
-      should "unfollow when following" do
-        @follower.expects(:follows?).with(@followable).once.returns(true)
-        @follower.expects(:unfollow!).with(@followable).once
-        @follower.toggle_follow!(@followable)
-      end
-
-      should "follow when not following" do
-        @follower.expects(:follows?).with(@followable).once.returns(false)
-        @follower.expects(:follow!).with(@followable).once
-        @follower.toggle_follow!(@followable)
-      end
-    end
-
-    context "#follows?" do
-      should "not accept non-followables" do
-        assert_raise(Socialization::ArgumentError) { @follower.unfollow!(:foo) }
-      end
-
-      should "call $Follow.follows?" do
-        $Follow.expects(:follows?).with(@follower, @followable).once
-        @follower.follows?(@followable)
-      end
-    end
-
-    context "#followables" do
-      should "call $Follow.followables" do
-        $Follow.expects(:followables).with(@follower, @followable.class, { :foo => :bar })
-        @follower.followables(@followable.class, { :foo => :bar })
-      end
-    end
-
-    context "#followees" do
-      should "call $Follow.followables" do
-        $Follow.expects(:followables).with(@follower, @followable.class, { :foo => :bar })
-        @follower.followees(@followable.class, { :foo => :bar })
-      end
-    end
-
-    context "#followables_relation" do
-      should "call $Follow.followables_relation" do
-        $Follow.expects(:followables_relation).with(@follower, @followable.class, { :foo => :bar })
-        @follower.followables_relation(@followable.class, { :foo => :bar })
-      end
-    end
-
-    context "#followees_relation" do
-      should "call $Follow.followables_relation" do
-        $Follow.expects(:followables_relation).with(@follower, @followable.class, { :foo => :bar })
-        @follower.followees_relation(@followable.class, { :foo => :bar })
-      end
-    end
-
-    context "deleting a follower" do
-      setup do
-        @follower = ImAFollower.create
-        @follower.follow!(@followable)
-      end
-
-      should "remove follow relationships" do
-        Socialization.follow_model.expects(:remove_followables).with(@follower)
-        @follower.destroy
-      end
-    end
-
-  end
-end

data/test/actors/liker_test.rb

@@ -1,106 +0,0 @@
-require File.expand_path(File.dirname(__FILE__))+'/../test_helper'
-
-class LikerTest < Test::Unit::TestCase
-  context "Liker" do
-    setup do
-      @liker = ImALiker.new
-      @likeable = ImALikeable.create
-    end
-
-    context "#is_liker?" do
-      should "return true" do
-        assert_true @liker.is_liker?
-      end
-    end
-
-    context "#liker?" do
-      should "return true" do
-        assert_true @liker.liker?
-      end
-    end
-
-    context "#like!" do
-      should "not accept non-likeables" do
-        assert_raise(Socialization::ArgumentError) { @liker.like!(:foo) }
-      end
-
-      should "call $Like.like!" do
-        $Like.expects(:like!).with(@liker, @likeable).once
-        @liker.like!(@likeable)
-      end
-    end
-
-    context "#unlike!" do
-      should "not accept non-likeables" do
-        assert_raise(Socialization::ArgumentError) { @liker.unlike!(:foo) }
-      end
-
-      should "call $Like.like!" do
-        $Like.expects(:unlike!).with(@liker, @likeable).once
-        @liker.unlike!(@likeable)
-      end
-    end
-
-    context "#toggle_like!" do
-      should "not accept non-likeables" do
-        assert_raise(Socialization::ArgumentError) { @liker.unlike!(:foo) }
-      end
-
-      should "unlike when likeing" do
-        @liker.expects(:likes?).with(@likeable).once.returns(true)
-        @liker.expects(:unlike!).with(@likeable).once
-        @liker.toggle_like!(@likeable)
-      end
-
-      should "like when not likeing" do
-        @liker.expects(:likes?).with(@likeable).once.returns(false)
-        @liker.expects(:like!).with(@likeable).once
-        @liker.toggle_like!(@likeable)
-      end
-    end
-
-    context "#likes?" do
-      should "not accept non-likeables" do
-        assert_raise(Socialization::ArgumentError) { @liker.unlike!(:foo) }
-      end
-
-      should "call $Like.likes?" do
-        $Like.expects(:likes?).with(@liker, @likeable).once
-        @liker.likes?(@likeable)
-      end
-    end
-
-    context "#likeables" do
-      should "call $Like.likeables" do
-        $Like.expects(:likeables).with(@liker, @likeable.class, { :foo => :bar })
-        @liker.likeables(@likeable.class, { :foo => :bar })
-      end
-    end
-
-    context "#likees" do
-      should "call $Like.likeables" do
-        $Like.expects(:likeables).with(@liker, @likeable.class, { :foo => :bar })
-        @liker.likees(@likeable.class, { :foo => :bar })
-      end
-    end
-
-    context "#likeables_relation" do
-      should "call $Follow.likeables_relation" do
-        $Like.expects(:likeables_relation).with(@liker, @likeable.class, { :foo => :bar })
-        @liker.likeables_relation(@likeable.class, { :foo => :bar })
-      end
-    end
-
-    context "#likees_relation" do
-      should "call $Follow.likeables_relation" do
-        $Like.expects(:likeables_relation).with(@liker, @likeable.class, { :foo => :bar })
-        @liker.likees_relation(@likeable.class, { :foo => :bar })
-      end
-    end
-
-    should "remove like relationships" do
-      Socialization.like_model.expects(:remove_likeables).with(@liker)
-      @liker.destroy
-    end
-  end
-end

data/test/actors/mentioner_test.rb

@@ -1,106 +0,0 @@
-require File.expand_path(File.dirname(__FILE__))+'/../test_helper'
-
-class MentionerTest < Test::Unit::TestCase
-  context "Mentioner" do
-    setup do
-      @mentioner = ImAMentioner.new
-      @mentionable = ImAMentionable.create
-    end
-
-    context "#is_mentioner?" do
-      should "return true" do
-        assert_true @mentioner.is_mentioner?
-      end
-    end
-
-    context "#mentioner?" do
-      should "return true" do
-        assert_true @mentioner.mentioner?
-      end
-    end
-
-    context "#mention!" do
-      should "not accept non-mentionables" do
-        assert_raise(Socialization::ArgumentError) { @mentioner.mention!(:foo) }
-      end
-
-      should "call $Mention.mention!" do
-        $Mention.expects(:mention!).with(@mentioner, @mentionable).once
-        @mentioner.mention!(@mentionable)
-      end
-    end
-
-    context "#unmention!" do
-      should "not accept non-mentionables" do
-        assert_raise(Socialization::ArgumentError) { @mentioner.unmention!(:foo) }
-      end
-
-      should "call $Mention.mention!" do
-        $Mention.expects(:unmention!).with(@mentioner, @mentionable).once
-        @mentioner.unmention!(@mentionable)
-      end
-    end
-
-    context "#toggle_mention!" do
-      should "not accept non-mentionables" do
-        assert_raise(Socialization::ArgumentError) { @mentioner.unmention!(:foo) }
-      end
-
-      should "unmention when mentioning" do
-        @mentioner.expects(:mentions?).with(@mentionable).once.returns(true)
-        @mentioner.expects(:unmention!).with(@mentionable).once
-        @mentioner.toggle_mention!(@mentionable)
-      end
-
-      should "mention when not mentioning" do
-        @mentioner.expects(:mentions?).with(@mentionable).once.returns(false)
-        @mentioner.expects(:mention!).with(@mentionable).once
-        @mentioner.toggle_mention!(@mentionable)
-      end
-    end
-
-    context "#mentions?" do
-      should "not accept non-mentionables" do
-        assert_raise(Socialization::ArgumentError) { @mentioner.unmention!(:foo) }
-      end
-
-      should "call $Mention.mentions?" do
-        $Mention.expects(:mentions?).with(@mentioner, @mentionable).once
-        @mentioner.mentions?(@mentionable)
-      end
-    end
-
-    context "#mentionables" do
-      should "call $Mention.mentionables" do
-        $Mention.expects(:mentionables).with(@mentioner, @mentionable.class, { :foo => :bar })
-        @mentioner.mentionables(@mentionable.class, { :foo => :bar })
-      end
-    end
-
-    context "#mentionees" do
-      should "call $Mention.mentionables" do
-        $Mention.expects(:mentionables).with(@mentioner, @mentionable.class, { :foo => :bar })
-        @mentioner.mentionees(@mentionable.class, { :foo => :bar })
-      end
-    end
-
-    context "#mentionables_relation" do
-      should "call $Mention.mentionables_relation" do
-        $Mention.expects(:mentionables_relation).with(@mentioner, @mentionable.class, { :foo => :bar })
-        @mentioner.mentionables_relation(@mentionable.class, { :foo => :bar })
-      end
-    end
-
-    context "#mentionees_relation" do
-      should "call $Mention.mentionables_relation" do
-        $Mention.expects(:mentionables_relation).with(@mentioner, @mentionable.class, { :foo => :bar })
-        @mentioner.mentionees_relation(@mentionable.class, { :foo => :bar })
-      end
-    end
-
-    should "remove mention relationships" do
-      Socialization.mention_model.expects(:remove_mentionables).with(@mentioner)
-      @mentioner.destroy
-    end
-  end
-end

data/test/stores/active_record/follow_store_test.rb

@@ -1,138 +0,0 @@
-require File.expand_path(File.dirname(__FILE__))+'/../../test_helper'
-
-class ActiveRecordFollowStoreTest < Test::Unit::TestCase
-  context "ActiveRecordStores::FollowStoreTest" do
-    setup do
-      @klass = Socialization::ActiveRecordStores::Follow
-      @klass.touch nil
-      @klass.after_follow nil
-      @klass.after_unfollow nil
-      @follower = ImAFollower.create
-      @followable = ImAFollowable.create
-    end
-
-    context "data store" do
-      should "inherit Socialization::ActiveRecordStores::Follow" do
-        assert_equal Socialization::ActiveRecordStores::Follow, Socialization.follow_model
-      end
-    end
-
-    context "#follow!" do
-      should "create a Follow record" do
-        @klass.follow!(@follower, @followable)
-        assert_match_follower @klass.last, @follower
-        assert_match_followable @klass.last, @followable
-      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
-        @klass.create! do |f|
-          f.follower = @follower
-          f.followable = @followable
-        end
-        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_equal [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_equal [follower1.id, follower2.id], @klass.followers(@followable, follower1.class, :pluck => :id)
-      end
-    end
-
-    context "#followables" do
-      should "return an array of followers" do
-        followable1 = ImAFollowable.create
-        followable2 = ImAFollowable.create
-        @follower.follow!(followable1)
-        @follower.follow!(followable2)
-        assert_equal [followable1, followable2], @klass.followables(@follower, followable1.class)
-      end
-
-      should "return an array of follower ids when plucking" do
-        followable1 = ImAFollowable.create
-        followable2 = ImAFollowable.create
-        @follower.follow!(followable1)
-        @follower.follow!(followable2)
-        assert_equal [followable1.id, followable2.id], @klass.followables(@follower, followable1.class, :pluck => :id)
-      end
-    end
-
-    context "#remove_followers" do
-      should "delete all followers relationships for a followable" do
-        @follower.follow!(@followable)
-        assert_equal 1, @followable.followers(@follower.class).count
-        @klass.remove_followers(@followable)
-        assert_equal 0, @followable.followers(@follower.class).count
-      end
-    end
-
-    context "#remove_followables" do
-      should "delete all followables relationships for a follower" do
-        @follower.follow!(@followable)
-        assert_equal 1, @follower.followables(@followable.class).count
-        @klass.remove_followables(@follower)
-        assert_equal 0, @follower.followables(@followable.class).count
-      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
-end