socialization 0.4.0 → 0.5.0.beta

data/test/stores/redis/mention_store_test.rb

@@ -0,0 +1,153 @@
+require File.expand_path(File.dirname(__FILE__))+'/../../test_helper'
+
+class RedisMentionStoreTest < Test::Unit::TestCase
+  context "RedisStores::MentionStoreTest" do
+    setup do
+      use_redis_store
+      @klass = Socialization::RedisStores::MentionStore
+      @klass.touch nil
+      @klass.after_mention nil
+      @klass.after_unmention nil
+      @mentioner = ImAMentioner.create
+      @mentionable = ImAMentionable.create
+    end
+
+    context "Stores" do
+      should "inherit Socialization::RedisStores::MentionStore" do
+        assert_equal Socialization::RedisStores::MentionStore, Socialization.mention_model
+      end
+    end
+
+    context "#mention!" do
+      should "create a Mention record" do
+        @klass.mention!(@mentioner, @mentionable)
+        assert_equal ["#{@mentioner.id}"], Socialization.redis.smembers(mentioners_key)
+        assert_equal ["#{@mentionable.id}"], Socialization.redis.smembers(mentionables_key)
+      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
+        Socialization.redis.sadd mentioners_key, @mentioner.id
+        Socialization.redis.sadd mentionables_key, @mentionable.id
+        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_array_similarity [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_array_similarity [mentioner1.id, mentioner2.id], @klass.mentioners(@mentionable, mentioner1.class, :pluck => :id)
+      end
+    end
+
+    context "#mentionables" do
+      should "return an array of mentionables" do
+        mentionable1 = ImAMentionable.create
+        mentionable2 = ImAMentionable.create
+        @mentioner.mention!(mentionable1)
+        @mentioner.mention!(mentionable2)
+
+        assert_array_similarity [mentionable1, mentionable2], @klass.mentionables(@mentioner, mentionable1.class)
+      end
+
+      should "return an array of mentionables ids when plucking" do
+        mentionable1 = ImAMentionable.create
+        mentionable2 = ImAMentionable.create
+        @mentioner.mention!(mentionable1)
+        @mentioner.mention!(mentionable2)
+        assert_array_similarity [mentionable1.id, mentionable2.id], @klass.mentionables(@mentioner, mentionable1.class, :pluck => :id)
+      end
+    end
+
+    context "#generate_mentioners_key" do
+      should "return valid key when passed objects" do
+        assert_equal "Mentioners:ImAMentionable:#{@mentionable.id}:ImAMentioner", mentioners_key(@mentioner, @mentionable)
+      end
+
+      should "return valid key when mentioner is a class" do
+        assert_equal "Mentioners:ImAMentionable:#{@mentionable.id}:ImAMentioner", mentioners_key(@mentioner.class, @mentionable)
+      end
+    end
+
+    context "#generate_mentionables_key" do
+      should "return valid key when passed objects" do
+        assert_equal "Mentionables:ImAMentioner:#{@mentioner.id}:ImAMentionable", mentionables_key(@mentioner, @mentionable)
+      end
+
+      should "return valid key when mentionable is a class" do
+        assert_equal "Mentionables:ImAMentioner:#{@mentioner.id}:ImAMentionable", mentionables_key(@mentioner, @mentionable.class)
+      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
+
+  def mentioners_key(mentioner = nil, mentionable = nil)
+    mentioner ||= @mentioner
+    mentionable ||= @mentionable
+    @klass.send(:generate_mentioners_key, mentioner, mentionable)
+  end
+
+  def mentionables_key(mentioner = nil, mentionable = nil)
+    mentioner ||= @mentioner
+    mentionable ||= @mentionable
+    @klass.send(:generate_mentionables_key, mentioner, mentionable)
+  end
+end

data/test/string_test.rb

@@ -0,0 +1,13 @@
+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::FollowStore, "Socialization::ActiveRecordStores::FollowStore".deep_const_get
+
+      assert_raise(NameError) { "Foo::Bar".deep_const_get }
+    end
+  end
+end

data/test/test_helper.rb

@@ -1,19 +1,79 @@
+$MOCK_REDIS = true
+
 require 'rubygems'
 require 'active_record'
-require 'mocha'
 require 'shoulda'
 require 'test/unit'
 require 'logger'
+require 'mock_redis' if $MOCK_REDIS
+require 'redis' unless $MOCK_REDIS
+require 'mocha' # mocha always needs to be loaded last! http://stackoverflow.com/questions/3118866/mocha-mock-carries-to-another-test/4375296#4375296
 
 $:.push File.expand_path("../lib", __FILE__)
 require "socialization"
 
+silence_warnings do
+  Redis = MockRedis if $MOCK_REDIS # Magic!
+end
+
+module Test::Unit::Assertions
+  def assert_true(object, message="")
+    assert_equal(true, object, message)
+  end
+
+  def assert_false(object, message="")
+    assert_equal(false, object, message)
+  end
+
+  def assert_array_similarity(expected, actual, message=nil)
+    full_message = build_message(message, "<?> expected but was\n<?>.\n", expected, actual)
+    assert_block(full_message) { (expected.size ==  actual.size) && (expected - actual == []) }
+  end
+end
+
+class Test::Unit::TestCase
+  def setup
+    use_ar_store
+  end
+
+  def teardown
+    clear_redis
+  end
+end
+
+def use_redis_store
+  Socialization.follow_model = Socialization::RedisStores::FollowStore
+  Socialization.mention_model = Socialization::RedisStores::MentionStore
+  Socialization.like_model = Socialization::RedisStores::LikeStore
+  setup_model_shortcuts
+end
+
+def use_ar_store
+  Socialization.follow_model = Socialization::ActiveRecordStores::FollowStore
+  Socialization.mention_model = Socialization::ActiveRecordStores::MentionStore
+  Socialization.like_model = Socialization::ActiveRecordStores::LikeStore
+  setup_model_shortcuts
+end
+
+def setup_model_shortcuts
+  $Follow = Socialization.follow_model
+  $Mention = Socialization.mention_model
+  $Like = Socialization.like_model
+end
+
+def clear_redis
+  Socialization.redis.keys(nil).each do |k|
+    Socialization.redis.del k
+  end
+end
+
 ActiveRecord::Base.configurations = {'sqlite3' => {:adapter => 'sqlite3', :database => ':memory:'}}
 ActiveRecord::Base.establish_connection('sqlite3')
 
 ActiveRecord::Base.logger = Logger.new(STDERR)
 ActiveRecord::Base.logger.level = Logger::WARN
 
+ActiveRecord::Migration.verbose = false
 ActiveRecord::Schema.define(:version => 0) do
   create_table :users do |t|
     t.string :name
@@ -116,41 +176,39 @@ class Movie < ActiveRecord::Base
   has_many :comments
 end
 
-class Follow < ActiveRecord::Base
-  acts_as_follow_store
-end
-
-class Like < ActiveRecord::Base
-  acts_as_like_store
-end
-
-class Mention < ActiveRecord::Base
-  acts_as_mention_store
-end
+# class Follow < Socialization::ActiveRecordStores::FollowStore; end
+# class Like < Socialization::ActiveRecordStores::LikeStore; end
+# class Mention < Socialization::ActiveRecordStores::MentionStore; end
 
 class ImAFollower < ActiveRecord::Base
   acts_as_follower
 end
+class ImAFollowerChild < ImAFollower; end
 
 class ImAFollowable < ActiveRecord::Base
   acts_as_followable
 end
+class ImAFollowableChild < ImAFollowable; end
 
 class ImALiker < ActiveRecord::Base
   acts_as_liker
 end
+class ImALikerChild < ImALiker; end
 
 class ImALikeable < ActiveRecord::Base
   acts_as_likeable
 end
+class ImALikeableChild < ImALikeable; end
 
 class ImAMentioner < ActiveRecord::Base
   acts_as_mentioner
 end
+class ImAMentionerChild < ImAMentioner; end
 
 class ImAMentionable < ActiveRecord::Base
   acts_as_mentionable
 end
+class ImAMentionableChild < ImAMentionable; end
 
 class ImAMentionerAndMentionable < ActiveRecord::Base
   acts_as_mentioner

data/test/victims/followable_test.rb

@@ -0,0 +1,34 @@
+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 "#followed_by?" do
+      should "not accept non-followers" do
+        assert_raise(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
+  end
+end

data/test/victims/likeable_test.rb

@@ -0,0 +1,34 @@
+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 "#liked_by?" do
+      should "not accept non-likers" do
+        assert_raise(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
+  end
+end

data/test/victims/mentionable_test.rb

@@ -0,0 +1,34 @@
+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 "#mentioned_by?" do
+      should "not accept non-mentioners" do
+        assert_raise(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 $Mentionmentioners" do
+        $Mention.expects(:mentioners).with(@mentionable, @mentioner.class, { :foo => :bar })
+        @mentionable.mentioners(@mentioner.class, { :foo => :bar })
+      end
+    end
+  end
+end

data/test/world_test.rb

@@ -2,99 +2,110 @@ 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
-  attr_reader :users, :movies, :celebs, :comments
+  cattr_reader :users, :movies, :celebs, :comments
 
   context "The World" do
     setup do
       seed
     end
 
-    should "be social" do
-      john.like!(pulp)
-      john.follow!(jane)
-      john.follow!(travolta)
-
-      assert john.likes?(pulp)
-      assert john.follows?(jane)
-      assert john.follows?(travolta)
+    context "ActiveRecord store" do
+      setup { use_ar_store }
+      should "be social" do
+        test_the_world
+      end
+    end
 
-      assert pulp.liked_by?(john)
-      assert travolta.followed_by?(john)
+    context "Redis store" do
+      setup { use_redis_store }
+      should "be social" do
+        test_the_world
+      end
+    end
+  end
 
-      carl.like!(pulp)
-      camilo.like!(pulp)
-      assert_equal 3, pulp.likers(User).size
+  def test_the_world
+    john.like!(pulp)
+    john.follow!(jane)
+    john.follow!(travolta)
 
-      assert pulp.likers(User).include?(carl)
-      assert pulp.likers(User).include?(john)
-      assert pulp.likers(User).include?(camilo)
-      assert !pulp.likers(User).include?(mat)
+    assert john.likes?(pulp)
+    assert john.follows?(jane)
+    assert john.follows?(travolta)
 
-      carl.follow!(mat)
-      mat.follow!(carl)
-      camilo.follow!(carl)
+    assert pulp.liked_by?(john)
+    assert travolta.followed_by?(john)
 
-      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)
+    carl.like!(pulp)
+    camilo.like!(pulp)
+    assert_equal 3, pulp.likers(User).size
 
-      assert_raise ArgumentError do
-        john.like!(travolta) # Can't like a Celeb
-      end
+    assert pulp.likers(User).include?(carl)
+    assert pulp.likers(User).include?(john)
+    assert pulp.likers(User).include?(camilo)
+    assert !pulp.likers(User).include?(mat)
 
-      assert_raise ArgumentError do
-        john.follow!(kill_bill) # Can't follow a movie
-      end
+    carl.follow!(mat)
+    mat.follow!(carl)
+    camilo.follow!(carl)
 
-      assert_raise ArgumentError do
-        john.follow!(john) # Can't follow yourself, duh!
-      end
+    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 ArgumentError do
-        john.like!(john) # Can't like yourself, duh!
-      end
+    assert_raise ArgumentError do
+      john.like!(travolta) # Can't like a Celeb
+    end
 
-      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)
+    assert_raise 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'
+    @@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[sym]
-    return celebs[sym] if celebs[sym]
-    return movies[sym] if movies[sym]
-    return comments[sym] if comments[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