acts_as_favoritor 1.0.0 → 1.0.1

data/test/acts_as_followable_test.rb

@@ -1,283 +0,0 @@
-require File.dirname(__FILE__) + '/test_helper'
-
-class ActsAsFollowableTest < ActiveSupport::TestCase
-
-  context "instance methods" do
-    setup do
-      @sam = FactoryGirl.create(:sam)
-    end
-
-    should "be defined" do
-      assert @sam.respond_to?(:followers_count)
-      assert @sam.respond_to?(:followers)
-      assert @sam.respond_to?(:followed_by?)
-    end
-  end
-
-  context "acts_as_followable" do
-    setup do
-      @sam = FactoryGirl.create(:sam)
-      @jon = FactoryGirl.create(:jon)
-      @oasis = FactoryGirl.create(:oasis)
-      @metallica = FactoryGirl.create(:metallica)
-      @green_day = FactoryGirl.create(:green_day)
-      @blink_182 = FactoryGirl.create(:blink_182)
-      @sam.follow(@jon)
-    end
-
-    context "followers_count" do
-      should "return the number of followers" do
-        assert_equal 0, @sam.followers_count
-        assert_equal 1, @jon.followers_count
-      end
-
-      should "return the proper number of multiple followers" do
-        @bob = FactoryGirl.create(:bob)
-        @sam.follow(@bob)
-        assert_equal 0, @sam.followers_count
-        assert_equal 1, @jon.followers_count
-        assert_equal 1, @bob.followers_count
-      end
-    end
-
-    context "followers" do
-      should "return users" do
-        assert_equal [], @sam.followers
-        assert_equal [@sam], @jon.followers
-      end
-
-      should "return users (multiple followers)" do
-        @bob = FactoryGirl.create(:bob)
-        @sam.follow(@bob)
-        assert_equal [], @sam.followers
-        assert_equal [@sam], @jon.followers
-        assert_equal [@sam], @bob.followers
-      end
-
-      should "return users (multiple followers, complex)" do
-        @bob = FactoryGirl.create(:bob)
-        @sam.follow(@bob)
-        @jon.follow(@bob)
-        assert_equal [], @sam.followers
-        assert_equal [@sam], @jon.followers
-        assert_equal [@sam, @jon], @bob.followers
-      end
-
-      should "accept AR options" do
-        @bob = FactoryGirl.create(:bob)
-        @bob.follow(@jon)
-        assert_equal 1, @jon.followers(limit: 1).count
-      end
-    end
-
-    context "followed_by" do
-      should "return_follower_status" do
-        assert_equal true, @jon.followed_by?(@sam)
-        assert_equal false, @sam.followed_by?(@jon)
-      end
-    end
-
-    context "destroying a followable" do
-      setup do
-        @jon.destroy
-      end
-
-      should_change("follow count", by: -1) { Follow.count }
-      should_change("@sam.all_following.size", by: -1) { @sam.all_following.size }
-    end
-
-    context "get follow record" do
-      setup do
-        @bob = FactoryGirl.create(:bob)
-        @follow = @bob.follow(@sam)
-      end
-
-      should "return follow record" do
-        assert_equal @follow, @sam.get_follow_for(@bob)
-      end
-
-      should "return nil" do
-        assert_nil @sam.get_follow_for(@jon)
-      end
-    end
-
-    context "blocks" do
-      setup do
-        @bob = FactoryGirl.create(:bob)
-        @jon.block(@sam)
-        @jon.block(@bob)
-      end
-
-      should "accept AR options" do
-        assert_equal 1, @jon.blocks(limit: 1).count
-      end
-    end
-
-    context "blocking a follower" do
-      context "in my following list" do
-        setup do
-          @jon.block(@sam)
-        end
-
-        should "remove him from followers" do
-          assert_equal 0, @jon.followers_count
-        end
-
-        should "add him to the blocked followers" do
-          assert_equal 1, @jon.blocked_followers_count
-        end
-
-        should "not be able to follow again" do
-          @jon.follow(@sam)
-          assert_equal 0, @jon.followers_count
-        end
-
-        should "not be present when listing followers" do
-          assert_equal [], @jon.followers
-        end
-
-        should "be in the list of blocks" do
-          assert_equal [@sam], @jon.blocks
-        end
-      end
-
-      context "not in my following list" do
-        setup do
-          @sam.block(@jon)
-        end
-
-        should "add him to the blocked followers" do
-          assert_equal 1, @sam.blocked_followers_count
-        end
-
-        should "not be able to follow again" do
-          @sam.follow(@jon)
-          assert_equal 0, @sam.followers_count
-        end
-
-        should "not be present when listing followers" do
-          assert_equal [], @sam.followers
-        end
-
-        should "be in the list of blocks" do
-          assert_equal [@jon], @sam.blocks
-        end
-      end
-    end
-
-    context "unblocking a blocked follow" do
-      setup do
-        @jon.block(@sam)
-        @jon.unblock(@sam)
-      end
-
-      should "not include the unblocked user in the list of followers" do
-        assert_equal [], @jon.followers
-      end
-
-      should "remove him from the blocked followers" do
-        assert_equal 0, @jon.blocked_followers_count
-        assert_equal [], @jon.blocks
-      end
-    end
-
-    context "unblock a non-existent follow" do
-      setup do
-        @sam.remove_favorite(@jon)
-        @jon.unblock(@sam)
-      end
-
-      should "not be in the list of followers" do
-        assert_equal [], @jon.followers
-      end
-
-      should "not be in the blocked followers count" do
-        assert_equal 0, @jon.blocked_followers_count
-      end
-
-      should "not be in the blocks list" do
-        assert_equal [], @jon.blocks
-      end
-    end
-
-    context "followers_by_type" do
-      setup do
-        @sam.follow(@oasis)
-        @jon.follow(@oasis)
-      end
-
-      should "return the followers for given type" do
-        assert_equal [@sam], @jon.followers_by_type('User')
-        assert_equal [@sam, @jon], @oasis.followers_by_type('User')
-      end
-
-      should "not return block followers in the followers for a given type" do
-        @oasis.block(@jon)
-        assert_equal [@sam], @oasis.followers_by_type('User')
-      end
-
-      should "return the count for followers_by_type_count for a given type" do
-        assert_equal 1, @jon.followers_by_type_count('User')
-        assert_equal 2, @oasis.followers_by_type_count('User')
-      end
-
-      should "not count blocked follows in the count" do
-        @oasis.block(@sam)
-        assert_equal 1, @oasis.followers_by_type_count('User')
-      end
-    end
-
-    context "followers_with_sti" do
-      setup do
-        @sam.follow(@green_day)
-        @sam.follow(@blink_182)
-      end
-
-      should "return the followers for given type" do
-        assert_equal @sam.follows_by_type('Band').first.followable, @green_day.becomes(Band)
-        assert_equal @sam.follows_by_type('Band').second.followable, @blink_182.becomes(Band)
-        assert @green_day.followers_by_type('User').include?(@sam)
-        assert @blink_182.followers_by_type('User').include?(@sam)
-      end
-    end
-
-    context "method_missing" do
-      setup do
-        @sam.follow(@oasis)
-        @jon.follow(@oasis)
-      end
-
-      should "return the followers for given type" do
-        assert_equal [@sam], @jon.user_followers
-        assert_equal [@sam, @jon], @oasis.user_followers
-      end
-
-      should "not return block followers in the followers for a given type" do
-        @oasis.block(@jon)
-        assert_equal [@sam], @oasis.user_followers
-      end
-
-      should "return the count for followers_by_type_count for a given type" do
-        assert_equal 1, @jon.count_user_followers
-        assert_equal 2, @oasis.count_user_followers
-      end
-
-      should "not count blocked follows in the count" do
-        @oasis.block(@sam)
-        assert_equal 1, @oasis.count_user_followers
-      end
-    end
-
-    context "respond_to?" do
-      should "advertise that it responds to following methods" do
-        assert @oasis.respond_to?(:user_followers)
-        assert @oasis.respond_to?(:user_followers_count)
-      end
-
-      should "return false when called with a nonexistent method" do
-        assert (not @oasis.respond_to?(:foobar))
-      end
-    end
-
-  end
-end

data/test/acts_as_follower_test.rb

@@ -1,224 +0,0 @@
-require File.dirname(__FILE__) + '/test_helper'
-
-class ActsAsFollowerTest < ActiveSupport::TestCase
-
-  context "instance methods" do
-    setup do
-      @sam = FactoryGirl.create(:sam)
-    end
-
-    should "be defined" do
-      assert @sam.respond_to?(:following?)
-      assert @sam.respond_to?(:follow_count)
-      assert @sam.respond_to?(:follow)
-      assert @sam.respond_to?(:remove_favorite)
-      assert @sam.respond_to?(:follows_by_type)
-      assert @sam.respond_to?(:all_follows)
-    end
-  end
-
-  context "acts_as_follower" do
-    setup do
-      @sam = FactoryGirl.create(:sam)
-      @jon = FactoryGirl.create(:jon)
-      @oasis = FactoryGirl.create(:oasis)
-      @sam.follow(@jon)
-      @sam.follow(@oasis)
-    end
-
-    context "following" do
-      should "return following_status" do
-        assert_equal true, @sam.following?(@jon)
-        assert_equal false, @jon.following?(@sam)
-      end
-
-      should "return follow_count" do
-        assert_equal 2, @sam.follow_count
-        assert_equal 0, @jon.follow_count
-      end
-    end
-
-    context "follow a friend" do
-      setup do
-        @jon.follow(@sam)
-      end
-
-      should_change("Follow count", by: 1) { Follow.count }
-      should_change("@jon.follow_count", by: 1) { @jon.follow_count }
-
-      should "set the follower" do
-        assert_equal @jon, Follow.last.follower
-      end
-
-      should "set the followable" do
-        assert_equal @sam, Follow.last.followable
-      end
-    end
-
-    context "follow yourself" do
-      setup do
-        @jon.follow(@jon)
-      end
-
-      should_not_change("Follow count") { Follow.count }
-      should_not_change("@jon.follow_count") { @jon.follow_count }
-
-      should "not set the follower" do
-        assert_not_equal @jon, Follow.last.follower
-      end
-
-      should "not set the followable" do
-        assert_not_equal @jon, Follow.last.followable
-      end
-    end
-
-    context "remove_favorite" do
-      setup do
-        @sam.remove_favorite(@jon)
-      end
-
-      should_change("Follow count", by: -1) { Follow.count }
-      should_change("@sam.follow_count", by: -1) { @sam.follow_count }
-    end
-
-    context "follows" do
-      setup do
-        @band_follow = Follow.where("follower_id = ? and follower_type = 'User' and followable_id = ? and followable_type = 'Band'", @sam.id, @oasis.id).first
-        @user_follow = Follow.where("follower_id = ? and follower_type = 'User' and followable_id = ? and followable_type = 'User'", @sam.id, @jon.id).first
-      end
-
-      context "follows_by_type" do
-        should "only return requested follows" do
-          assert_equal [@band_follow], @sam.follows_by_type('Band')
-          assert_equal [@user_follow], @sam.follows_by_type('User')
-        end
-
-        should "accept AR options" do
-          @metallica = FactoryGirl.create(:metallica)
-          @sam.follow(@metallica)
-          assert_equal 1, @sam.follows_by_type('Band', limit: 1).count
-        end
-      end
-
-      context "following_by_type_count" do
-        should "return the count of the requested type" do
-          @metallica = FactoryGirl.create(:metallica)
-          @sam.follow(@metallica)
-          assert_equal 2, @sam.following_by_type_count('Band')
-          assert_equal 1, @sam.following_by_type_count('User')
-          assert_equal 0, @jon.following_by_type_count('Band')
-          @jon.block(@sam)
-          assert_equal 0, @sam.following_by_type_count('User')
-        end
-      end
-
-      context "all_follows" do
-        should "return all follows" do
-          assert_equal 2, @sam.all_follows.size
-          assert @sam.all_follows.include?(@band_follow)
-          assert @sam.all_follows.include?(@user_follow)
-          assert_equal [], @jon.all_follows
-        end
-
-        should "accept AR options" do
-          assert_equal 1, @sam.all_follows(limit: 1).count
-        end
-      end
-    end
-
-    context "all_following" do
-      should "return the actual follow records" do
-        assert_equal 2, @sam.all_following.size
-        assert @sam.all_following.include?(@oasis)
-        assert @sam.all_following.include?(@jon)
-        assert_equal [], @jon.all_following
-      end
-
-      should "accept AR limit option" do
-        assert_equal 1, @sam.all_following(limit: 1).count
-      end
-
-      should "accept AR where option" do
-        assert_equal 1, @sam.all_following(where: { id: @oasis.id }).count
-      end
-    end
-
-    context "following_by_type" do
-      should "return only requested records" do
-        assert_equal [@oasis], @sam.following_by_type('Band')
-        assert_equal [@jon], @sam.following_by_type('User')
-      end
-
-      should "accept AR options" do
-        @metallica = FactoryGirl.create(:metallica)
-        @sam.follow(@metallica)
-        assert_equal 1, @sam.following_by_type('Band', limit: 1).to_a.size
-      end
-    end
-
-    context "method_missing" do
-      should "call following_by_type" do
-        assert_equal [@oasis], @sam.following_bands
-        assert_equal [@jon], @sam.following_users
-      end
-
-      should "call following_by_type_count" do
-        @metallica = FactoryGirl.create(:metallica)
-        @sam.follow(@metallica)
-        assert_equal 2, @sam.following_bands_count
-        assert_equal 1, @sam.following_users_count
-        assert_equal 0, @jon.following_bands_count
-        @jon.block(@sam)
-        assert_equal 0, @sam.following_users_count
-      end
-
-      should "raise on no method" do
-        assert_raises (NoMethodError){ @sam.foobar }
-      end
-    end
-
-    context "respond_to?" do
-      should "advertise that it responds to following methods" do
-        assert @sam.respond_to?(:following_users)
-        assert @sam.respond_to?(:following_users_count)
-      end
-
-      should "return false when called with a nonexistent method" do
-        assert (not @sam.respond_to?(:foobar))
-      end
-    end
-
-    context "destroying follower" do
-      setup do
-        @jon.destroy
-      end
-
-      should_change("Follow.count", by: -1) { Follow.count }
-      should_change("@sam.follow_count", by: -1) { @sam.follow_count }
-    end
-
-    context "blocked by followable" do
-      setup do
-        @jon.block(@sam)
-      end
-
-      should "return following_status" do
-        assert_equal false, @sam.following?(@jon)
-      end
-
-      should "return follow_count" do
-        assert_equal 1, @sam.follow_count
-      end
-
-      should "not return record of the blocked follows" do
-        assert_equal 1, @sam.all_follows.size
-        assert !@sam.all_follows.include?(@user_follow)
-        assert !@sam.all_following.include?(@jon)
-        assert_equal [], @sam.following_by_type('User')
-        assert_equal [], @sam.follows_by_type('User')
-        assert_equal [], @sam.following_users
-      end
-    end
-  end
-
-end