socialization 1.1.0 → 1.2.0

data/test/stores/redis/config_test.rb

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

@@ -1,27 +0,0 @@
-require File.expand_path(File.dirname(__FILE__))+'/../../test_helper'
-
-class RedisFollowStoreTest < Test::Unit::TestCase
-  context "RedisStores::Follow" do
-    setup do
-      use_redis_store
-      @klass = Socialization::RedisStores::Follow
-      @base = Socialization::RedisStores::Base
-    end
-
-    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
-  end
-end

data/test/stores/redis/like_store_test.rb

@@ -1,25 +0,0 @@
-require File.expand_path(File.dirname(__FILE__))+'/../../test_helper'
-
-class RedisLikeStoreTest < Test::Unit::TestCase
-  context "RedisStores::Like" do
-    setup do
-      use_redis_store
-      @klass = Socialization::RedisStores::Like
-      @base = Socialization::RedisStores::Base
-    end
-
-    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
-  end
-end

data/test/stores/redis/mention_store_test.rb

@@ -1,25 +0,0 @@
-require File.expand_path(File.dirname(__FILE__))+'/../../test_helper'
-
-class RedisMentionStoreTest < Test::Unit::TestCase
-  context "RedisStores::Mention" do
-    setup do
-      use_redis_store
-      @klass = Socialization::RedisStores::Mention
-      @base = Socialization::RedisStores::Base
-    end
-
-    context "method aliases" do
-      should "be set properly and made public" do
-        assert_method_public @klass, :mention!
-        assert_method_public @klass, :unmention!
-        assert_method_public @klass, :mentions?
-        assert_method_public @klass, :mentioners_relation
-        assert_method_public @klass, :mentioners
-        assert_method_public @klass, :mentionables_relation
-        assert_method_public @klass, :mentionables
-        assert_method_public @klass, :remove_mentioners
-        assert_method_public @klass, :remove_mentionables
-      end
-    end
-  end
-end

data/test/string_test.rb

@@ -1,13 +0,0 @@
-require File.expand_path(File.dirname(__FILE__))+'/test_helper'
-
-class StringTest < Test::Unit::TestCase
-  context "#deep_const_get" do
-    should "return a class" do
-      assert_equal Socialization, "Socialization".deep_const_get
-      assert_equal Socialization::ActiveRecordStores, "Socialization::ActiveRecordStores".deep_const_get
-      assert_equal Socialization::ActiveRecordStores::Follow, "Socialization::ActiveRecordStores::Follow".deep_const_get
-
-      assert_raise(NameError) { "Foo::Bar".deep_const_get }
-    end
-  end
-end

data/test/victims/followable_test.rb

@@ -1,60 +0,0 @@
-require File.expand_path(File.dirname(__FILE__))+'/../test_helper'
-
-class FollowableTest < Test::Unit::TestCase
-  context "Followable" do
-    setup do
-      @follower = ImAFollower.new
-      @followable = ImAFollowable.create
-    end
-
-    context "#is_followable?" do
-      should "return true" do
-        assert_true @followable.is_followable?
-      end
-    end
-
-    context "#followable?" do
-      should "return true" do
-        assert_true @followable.followable?
-      end
-    end
-
-    context "#followed_by?" do
-      should "not accept non-followers" do
-        assert_raise(Socialization::ArgumentError) { @followable.followed_by?(:foo) }
-      end
-
-      should "call $Follow.follows?" do
-        $Follow.expects(:follows?).with(@follower, @followable).once
-        @followable.followed_by?(@follower)
-      end
-    end
-
-    context "#followers" do
-      should "call $Follow.followers" do
-        $Follow.expects(:followers).with(@followable, @follower.class, { :foo => :bar })
-        @followable.followers(@follower.class, { :foo => :bar })
-      end
-    end
-
-    context "#followers_relation" do
-      should "call $Follow.followers_relation" do
-        $Follow.expects(:followers_relation).with(@followable, @follower.class, { :foo => :bar })
-        @followable.followers_relation(@follower.class, { :foo => :bar })
-      end
-    end
-
-    context "deleting a followable" do
-      setup do
-        @follower = ImAFollower.create
-        @follower.follow!(@followable)
-      end
-
-      should "remove follow relationships" do
-        Socialization.follow_model.expects(:remove_followers).with(@followable)
-        @followable.destroy
-      end
-    end
-
-  end
-end

data/test/victims/likeable_test.rb

@@ -1,60 +0,0 @@
-require File.expand_path(File.dirname(__FILE__))+'/../test_helper'
-
-class LikeableTest < Test::Unit::TestCase
-  context "Likeable" do
-    setup do
-      @liker = ImALiker.new
-      @likeable = ImALikeable.create
-    end
-
-    context "#is_likeable?" do
-      should "return true" do
-        assert_true @likeable.is_likeable?
-      end
-    end
-
-    context "#likeable?" do
-      should "return true" do
-        assert_true @likeable.likeable?
-      end
-    end
-
-    context "#liked_by?" do
-      should "not accept non-likers" do
-        assert_raise(Socialization::ArgumentError) { @likeable.liked_by?(:foo) }
-      end
-
-      should "call $Like.likes?" do
-        $Like.expects(:likes?).with(@liker, @likeable).once
-        @likeable.liked_by?(@liker)
-      end
-    end
-
-    context "#likers" do
-      should "call $Like.likers" do
-        $Like.expects(:likers).with(@likeable, @liker.class, { :foo => :bar })
-        @likeable.likers(@liker.class, { :foo => :bar })
-      end
-    end
-
-    context "#likers_relation" do
-      should "call $Like.likers_relation" do
-        $Like.expects(:likers_relation).with(@likeable, @liker.class, { :foo => :bar })
-        @likeable.likers_relation(@liker.class, { :foo => :bar })
-      end
-    end
-
-    context "deleting a likeable" do
-      setup do
-        @liker = ImALiker.create
-        @liker.like!(@likeable)
-      end
-
-      should "remove like relationships" do
-        Socialization.like_model.expects(:remove_likers).with(@likeable)
-        @likeable.destroy
-      end
-    end
-
-  end
-end

data/test/victims/mentionable_test.rb

@@ -1,60 +0,0 @@
-require File.expand_path(File.dirname(__FILE__))+'/../test_helper'
-
-class MentionableTest < Test::Unit::TestCase
-  context "Mentionable" do
-    setup do
-      @mentioner = ImAMentioner.new
-      @mentionable = ImAMentionable.create
-    end
-
-    context "#is_mentionable?" do
-      should "return true" do
-        assert_true @mentionable.is_mentionable?
-      end
-    end
-
-    context "#mentionable?" do
-      should "return true" do
-        assert_true @mentionable.mentionable?
-      end
-    end
-
-    context "#mentioned_by?" do
-      should "not accept non-mentioners" do
-        assert_raise(Socialization::ArgumentError) { @mentionable.mentioned_by?(:foo) }
-      end
-
-      should "call $Mention.mentions?" do
-        $Mention.expects(:mentions?).with(@mentioner, @mentionable).once
-        @mentionable.mentioned_by?(@mentioner)
-      end
-    end
-
-    context "#mentioners" do
-      should "call $Mention.mentioners" do
-        $Mention.expects(:mentioners).with(@mentionable, @mentioner.class, { :foo => :bar })
-        @mentionable.mentioners(@mentioner.class, { :foo => :bar })
-      end
-    end
-
-    context "#mentioners_relation" do
-      should "call $Mention.mentioners" do
-        $Mention.expects(:mentioners_relation).with(@mentionable, @mentioner.class, { :foo => :bar })
-        @mentionable.mentioners_relation(@mentioner.class, { :foo => :bar })
-      end
-    end
-
-    context "deleting a mentionable" do
-      setup do
-        @mentioner = ImAMentioner.create
-        @mentioner.mention!(@mentionable)
-      end
-
-      should "remove mention relationships" do
-        Socialization.mention_model.expects(:remove_mentioners).with(@mentionable)
-        @mentionable.destroy
-      end
-    end
-
-  end
-end

data/test/world_test.rb

@@ -1,112 +0,0 @@
-require File.expand_path(File.dirname(__FILE__))+'/test_helper'
-
-# Test Socialization as it would be used in a "real world" scenario
-class WorldTest < Test::Unit::TestCase
-  cattr_reader :users, :movies, :celebs, :comments
-
-  context "The World" do
-    setup do
-      seed
-    end
-
-    context "ActiveRecord store" do
-      setup { use_ar_store }
-      should "be social" do
-        test_the_world
-      end
-    end
-
-    context "Redis store" do
-      setup { use_redis_store }
-      should "be social" do
-        test_the_world
-      end
-    end
-  end
-
-  def test_the_world
-    john.like!(pulp)
-    john.follow!(jane)
-    john.follow!(travolta)
-
-    assert john.likes?(pulp)
-    assert john.follows?(jane)
-    assert john.follows?(travolta)
-
-    assert pulp.liked_by?(john)
-    assert travolta.followed_by?(john)
-
-    carl.like!(pulp)
-    camilo.like!(pulp)
-    assert_equal 3, pulp.likers(User).size
-
-    assert pulp.likers(User).include?(carl)
-    assert pulp.likers(User).include?(john)
-    assert pulp.likers(User).include?(camilo)
-    assert !pulp.likers(User).include?(mat)
-
-    carl.follow!(mat)
-    mat.follow!(carl)
-    camilo.follow!(carl)
-
-    assert carl.follows?(mat)
-    assert mat.followed_by?(carl)
-    assert mat.follows?(carl)
-    assert carl.followed_by?(mat)
-    assert camilo.follows?(carl)
-    assert !carl.follows?(camilo)
-
-    assert_raise Socialization::ArgumentError do
-      john.like!(travolta) # Can't like a Celeb
-    end
-
-    assert_raise Socialization::ArgumentError do
-      john.follow!(kill_bill) # Can't follow a movie
-    end
-
-    # You can even follow or like yourself if your ego is that big.
-    assert john.follow!(john)
-    assert john.like!(john)
-
-    comment = john.comments.create(:body => "I think Tami and Carl would like this movie!", :movie_id => pulp.id)
-    comment.mention!(tami)
-    comment.mention!(carl)
-    assert comment.mentions?(carl)
-    assert carl.mentioned_by?(comment)
-    assert comment.mentions?(tami)
-    assert tami.mentioned_by?(comment)
-  end
-
-  def seed
-    @@users    = {}
-    @@celebs   = {}
-    @@movies   = {}
-    @@comments = {}
-
-    @@users[:john]       = User.create :name => 'John Doe'
-    @@users[:jane]       = User.create :name => 'Jane Doe'
-    @@users[:mat]        = User.create :name => 'Mat'
-    @@users[:carl]       = User.create :name => 'Carl'
-    @@users[:camilo]     = User.create :name => 'Camilo'
-    @@users[:tami]       = User.create :name => 'Tami'
-
-    @@movies[:pulp]      = Movie.create :name => 'Pulp Fiction'
-    @@movies[:reservoir] = Movie.create :name => 'Reservoir Dogs'
-    @@movies[:kill_bill] = Movie.create :name => 'Kill Bill'
-
-    @@celebs[:willis]    = Celebrity.create :name => 'Bruce Willis'
-    @@celebs[:travolta]  = Celebrity.create :name => 'John Travolta'
-    @@celebs[:jackson]   = Celebrity.create :name => 'Samuel L. Jackson'
-  end
-
-  def method_missing(meth, *args, &block)
-    sym = meth.to_sym
-    return users[sym] if users && users[sym]
-    return celebs[sym] if celebs && celebs[sym]
-    return movies[sym] if movies && movies[sym]
-    return comments[sym] if comments && comments[sym]
-    require 'pry'; binding.pry
-    super
-  end
-
-end