socialization-cassandra 0.0.1.pre.alpha

data/test/stores/cassandra/base_test.rb

@@ -0,0 +1,186 @@
+require File.expand_path(File.dirname(__FILE__))+'/../../test_helper'
+
+class CassandraBaseStoreTest < TestCase
+  include Assertions
+  # Testing through CassandraStores::Follow for easy testing
+  context "CassandraStores::Base through CassandraStores::Follow" do
+    setup do
+      use_cassandra_store
+      @klass = Socialization::CassandraStores::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::CassandraStores::Follow" do
+        assert_equal Socialization::CassandraStores::Follow, Socialization.follow_model
+      end
+    end
+
+    context "#follow!" do
+      should "create follow records" do
+        @klass.follow!(@follower1, @followable1)
+        row = Socialization.cassandra_session.execute("SELECT actor_type, actor_id FROM #{@klass.forward_table_name} where victim_type='#{@followable1.class}' AND victim_id=#{@followable1.id} ALLOW FILTERING").rows.to_a.first
+        assert_array_similarity ["#{@follower1.class}:#{@follower1.id}"], ["#{row['actor_type']}:#{row['actor_id']}"]
+        row = Socialization.cassandra_session.execute("SELECT victim_type, victim_id FROM #{@klass.backward_table_name} where actor_type='#{@follower1.class}' AND actor_id=#{@follower1.id} ALLOW FILTERING").rows.to_a.last
+        assert_array_similarity ["#{@followable1.class}:#{@followable1.id}"], ["#{row['victim_type']}:#{row['victim_id']}"]
+
+        @klass.follow!(@follower2, @followable1)
+        rows = Socialization.cassandra_session.execute("SELECT actor_type, actor_id FROM #{@klass.forward_table_name} where victim_type='#{@followable1.class}' AND victim_id=#{@followable1.id} ALLOW FILTERING").rows
+        assert_array_similarity ["#{@follower1.class}:#{@follower1.id}", "#{@follower2.class}:#{@follower2.id}"], (rows.collect {|i| "#{i['actor_type']}:#{i['actor_id']}"})
+
+        row = Socialization.cassandra_session.execute("SELECT victim_type, victim_id FROM #{@klass.backward_table_name} where actor_type='#{@follower1.class}' AND actor_id=#{@follower1.id} ALLOW FILTERING").rows.to_a.last
+        assert_array_similarity ["#{@followable1.class}:#{@followable1.id}"], ["#{row['victim_type']}:#{row['victim_id']}"]
+        row = Socialization.cassandra_session.execute("SELECT victim_type, victim_id FROM #{@klass.backward_table_name} where actor_type='#{@follower2.class}' AND actor_id=#{@follower2.id} ALLOW FILTERING").rows.to_a.first
+        assert_array_similarity ["#{@followable1.class}:#{@followable1.id}"], ["#{row['victim_type']}:#{row['victim_id']}"]
+      end
+
+      should "touch follower when instructed" do
+        @klass.touch :follower
+        assert_send([@follower1, :touch])
+        assert_send([@followable1, :touch])
+        @klass.follow!(@follower1, @followable1)
+      end
+
+      should "touch followable when instructed" do
+        @klass.touch :followable
+        !assert_send([@follower1, :touch])
+        assert_send([@followable1, :touch])
+        @klass.follow!(@follower1, @followable1)
+      end
+
+      should "touch all when instructed" do
+        @klass.touch :all
+        assert_send([@follower1, :touch])
+        assert_send([@followable1, :touch])
+        @klass.follow!(@follower1, @followable1)
+      end
+
+      # should "call after follow hook" do
+      #   @klass.after_follow :after_follow
+      #   assert_send([@klass, :after_follow])
+      #   @klass.follow!(@follower1, @followable1)
+      # end
+
+      # should "call after unfollow hook" do
+      #   @klass.after_follow :after_unfollow
+      #   assert_send([@klass, :after_unfollow])
+      #   @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.cassandra_session.execute("SELECT * FROM #{@klass.backward_table_name} where actor_type='#{@follower1.class}' AND actor_id=#{@follower1.id} ALLOW FILTERING").rows.to_a
+        assert_empty Socialization.cassandra_session.execute("SELECT * FROM #{@klass.forward_table_name} where victim_type='#{@followable1.class}' AND victim_id=#{@followable1.id} ALLOW FILTERING").rows.to_a
+      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 "#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.cassandra_session.execute("SELECT * FROM #{@klass.forward_table_name} where victim_type='#{@followable1.class}' AND victim_id=#{@followable1.id} ALLOW FILTERING").rows.to_a
+        assert_empty Socialization.cassandra_session.execute("SELECT * FROM #{@klass.backward_table_name} where actor_type='#{@follower1.class}' AND actor_id=#{@follower1.id} ALLOW FILTERING").rows.to_a
+        assert_empty Socialization.cassandra_session.execute("SELECT * FROM #{@klass.backward_table_name} where actor_type='#{@follower2.class}' AND actor_id=#{@follower2.id} ALLOW FILTERING").rows.to_a
+      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.cassandra_session.execute("SELECT * FROM #{@klass.forward_table_name} where victim_type='#{@followable1.class}' AND victim_id=#{@followable1.id} ALLOW FILTERING").rows.to_a
+        assert_empty Socialization.cassandra_session.execute("SELECT * FROM #{@klass.backward_table_name} where actor_type='#{@follower1.class}' AND actor_id=#{@follower1.id} ALLOW FILTERING").rows.to_a
+        assert_empty Socialization.cassandra_session.execute("SELECT * FROM #{@klass.backward_table_name} where actor_type='#{@follower2.class}' AND actor_id=#{@follower2.id} ALLOW FILTERING").rows.to_a
+        # 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
+
+  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::CassandraStores::Follow.send(:forward_table_name)
+  end
+
+  def backward_key(follower)
+    Socialization::CassandraStores::Follow.send(:backward_table_name)
+  end
+end

data/test/stores/cassandra/config_test.rb

@@ -0,0 +1,36 @@
+require File.expand_path(File.dirname(__FILE__))+'/../../test_helper'
+
+class CassandraStoreConfigTest < Minitest::Test
+  context "cassandra" do
+    setup do
+      Socialization.instance_eval {
+        @cassandra = nil
+        @cas_keyspace = nil
+        @cassandra_session = nil
+      }
+    end
+
+    should "return a new cassandra object when none were specified" do
+      assert_instance_of Cassandra::Session, Socialization.cassandra_session
+    end
+
+    #should "always return the same Cassandra object when none were specified" do
+    #  cassandra_session = Socialization.cassandra_session
+    #  assert_same cassandra_session, Socialization.cassandra_session
+    #end
+
+    # should "be able to set and get a cassandra instance" do
+    #   cluster = Cassandra.cluster
+    #   Socialization.cassandra = cluster
+    #   Socialization.keyspace = 'system'
+    #   session  = cluster.connect('system')
+    #   assert_same session, Socialization.cassandra_session
+    # 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/cassandra/follow_store_test.rb

@@ -0,0 +1,28 @@
+require File.expand_path(File.dirname(__FILE__))+'/../../test_helper'
+# require './../../test_helper'
+
+class CassandraFollowStoreTest < Minitest::Test
+  include Assertions
+  context "CassandraStores::Follow" do
+    setup do
+      @klass = Socialization::CassandraStores::Follow
+      @base = Socialization::CassandraStores::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/cassandra/like_store_test.rb

@@ -0,0 +1,26 @@
+require File.expand_path(File.dirname(__FILE__))+'/../../test_helper'
+
+
+class CassandraLikeStoreTest < Minitest::Test
+  include Assertions
+  context "CassandraStores::Like" do
+    setup do
+      @klass = Socialization::CassandraStores::Like
+      @base = Socialization::CassandraStores::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/string_test.rb

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

data/test/test_helper.rb

@@ -0,0 +1,259 @@
+$MOCK_REDIS = true
+
+require 'rubygems'
+require 'active_record'
+require 'shoulda'
+# require 'test/unit'
+require 'logger'
+require 'mocha' # mocha always needs to be loaded last! http://stackoverflow.com/questions/3118866/mocha-mock-carries-to-another-test/4375296#4375296
+# require 'pry'
+require 'minitest/autorun'
+require 'cassandra'
+
+$:.push File.expand_path("../lib", __FILE__)
+require "socialization"
+
+module Assertions
+  def assert_true(object, message="")
+    assert_equal(true, object, message)
+  end
+
+  def assert_false(object, message="")
+    assert_equal(false, object, message)
+  end
+
+  def build_message(head, template=nil, *arguments) #:nodoc:
+    template &&= template.chomp
+    template.gsub(/\G((?:[^\\]|\\.)*?)(\\)?\?/) { $1 + ($2 ? "?" : mu_pp(arguments.shift))  }
+  end
+
+  def assert_array_similarity(expected, actual, message=nil)
+    full_message = build_message(message, "<?> expected but was\n<?>.\n", expected, actual)
+    assert((expected.size ==  actual.size) && (expected - actual == []), full_message)
+    # assert_block(full_message) { (expected.size ==  actual.size) && (expected - actual == []) }
+  end
+
+  def assert_empty(obj, msg = nil)
+    msg = "Expected #{obj.inspect} to be empty" unless msg
+    assert_respond_to obj, :empty?
+    assert obj.empty?, msg
+  end
+
+  def assert_method_public(obj, method, msg = nil)
+    msg = "Expected method #{obj}.#{method} to be public."
+    method = if RUBY_VERSION.match(/^1\.8/)
+      method.to_s
+    else
+      method.to_s.to_sym
+    end
+
+    assert obj.public_methods.include?(method), msg
+  end
+end
+
+class TestCase < Minitest::Test
+  def setup
+    use_cassandra_store
+  end
+
+  def teardown
+    session = Socialization.cassandra_session
+    # ['likes', 'likers', 'liker_counter', 'followings', 'followers', 'following_counter', 'follower_counter', 'comments', 'comment_counter', 'shares', 'share_counter'].each {|t| session.execute("TRUNCATE #{t}")}
+    ['likes', 'likers', 'liker_counter', 'followings', 'followers', 'following_counter', 'follower_counter'].each {|t| session.execute("TRUNCATE #{t}")}
+  end
+end
+
+def use_cassandra_store
+  Socialization.follow_model = Socialization::CassandraStores::Follow
+  Socialization.comment_model = Socialization::CassandraStores::Comment
+  Socialization.share_model = Socialization::CassandraStores::Share
+  Socialization.like_model = Socialization::CassandraStores::Like
+  setup_model_shortcuts
+end
+
+def setup_model_shortcuts
+  $Follow = Socialization.follow_model
+  $Comment = Socialization.comment_model
+  $Share = Socialization.share_model
+  $Like = Socialization.like_model
+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
+  end
+
+  create_table :celebrities do |t|
+    t.string :name
+  end
+
+  create_table :movies do |t|
+    t.string :name
+  end
+
+  create_table :follows do |t|
+    t.string  :follower_type
+    t.integer :follower_id
+    t.string  :followable_type
+    t.integer :followable_id
+    t.datetime :created_at
+  end
+
+  create_table :likes do |t|
+    t.string  :liker_type
+    t.integer :liker_id
+    t.string  :likeable_type
+    t.integer :likeable_id
+    t.datetime :created_at
+  end
+
+  create_table :comments do |t|
+    t.string  :commenter_type
+    t.integer :commenter_id
+    t.string  :commentable_type
+    t.integer :commentable_id
+    t.datetime :created_at
+  end
+
+  create_table :shares do |t|
+    t.string  :sharer_type
+    t.integer :sharer_id
+    t.string  :shareable_type
+    t.integer :shareable_id
+    t.datetime :created_at
+  end
+
+  create_table :im_a_followers do |t|
+    t.datetime :created_at
+    t.datetime :updated_at
+  end
+
+  create_table :im_a_followables do |t|
+    t.datetime :created_at
+    t.datetime :updated_at
+  end
+
+  create_table :im_a_likers do |t|
+    t.datetime :created_at
+    t.datetime :updated_at
+  end
+
+  create_table :im_a_likeables do |t|
+    t.datetime :created_at
+    t.datetime :updated_at
+  end
+
+  create_table :im_a_commenters do |t|
+    t.datetime :created_at
+    t.datetime :updated_at
+  end
+
+  create_table :im_a_commentables do |t|
+    t.datetime :created_at
+    t.datetime :updated_at
+  end
+
+  create_table :im_a_commenter_and_commentables do |t|
+    t.datetime :created_at
+    t.datetime :updated_at
+  end
+
+  create_table :im_a_sharers do |t|
+    t.datetime :created_at
+    t.datetime :updated_at
+  end
+
+  create_table :im_a_shareables do |t|
+    t.datetime :created_at
+    t.datetime :updated_at
+  end
+
+  create_table :im_a_sharer_and_shareables do |t|
+    t.datetime :created_at
+    t.datetime :updated_at
+  end
+
+  create_table :vanillas do |t|
+    t.datetime :created_at
+    t.datetime :updated_at
+  end
+end
+
+class Celebrity < ActiveRecord::Base
+  acts_as_followable
+end
+
+class User < ActiveRecord::Base
+  acts_as_follower
+  acts_as_followable
+  acts_as_liker
+  acts_as_likeable
+  acts_as_commenter
+  acts_as_sharer
+end
+
+class Movie < ActiveRecord::Base
+  acts_as_likeable
+  acts_as_commentable
+  acts_as_shareable
+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 ImACommenter < ActiveRecord::Base
+  acts_as_commenter
+end
+class ImACommenterChild < ImACommenter; end
+
+class ImACommentable < ActiveRecord::Base
+  acts_as_commentable
+end
+class ImACommentableChild < ImACommentable; end
+
+class ImACommenterAndCommentable < ActiveRecord::Base
+  acts_as_commenter
+  acts_as_commentable
+end
+
+class ImASharer < ActiveRecord::Base
+  acts_as_sharer
+end
+class ImASharerChild < ImASharer; end
+
+class ImAShareable < ActiveRecord::Base
+  acts_as_shareable
+end
+class ImAShareableChild < ImAShareable; end
+
+class ImASharerAndShareable < ActiveRecord::Base
+  acts_as_sharer
+  acts_as_shareable
+end
+
+class Vanilla < ActiveRecord::Base
+end

data/test/victims/followable_test.rb

@@ -0,0 +1,65 @@
+require File.expand_path('../../test_helper', __FILE__)
+
+class FollowableTest < TestCase
+  include Assertions
+  context "Followable" do
+    setup do
+      # @follower = ImAFollower.new
+      @follower = ImAFollower.create
+      @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_raises(Socialization::ArgumentError) { @followable.followed_by?(:foo) }
+      end
+
+      should "call $Follow.follows?" do
+        Minitest::Mock.new.expect(:check, false) do
+          $Follow.follows?(@follower, @followable)
+        end
+        # assert_send([$Follow, :follows?, *[@follower, @followable]])
+        @followable.followed_by?(@follower)
+      end
+    end
+
+    context "#followers" do
+      should "call $Follow.followers" do
+        assert_send([$Follow, :followers, *[@followable, @follower.class, { :foo => :bar }]])
+        @followable.followers(@follower.class, { :foo => :bar })
+      end
+    end
+
+    context "#followers_relation" do
+      should "call $Follow.followers_relation" do
+        assert_send([$Follow, :followers_relation, *[@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
+        assert_send([Socialization.follow_model, :remove_followers, *[@followable]])
+        @followable.destroy
+      end
+    end
+
+  end
+end

data/test/victims/likeable_test.rb

@@ -0,0 +1,67 @@
+require File.expand_path(File.dirname(__FILE__))+'/../test_helper'
+
+class LikeableTest < TestCase
+  include Assertions
+  context "Likeable" do
+    setup do
+      #@liker = ImALiker.new
+      @liker = ImALiker.create
+      @likeable = ImALikeable.create
+    end
+
+    context "#is_likeable?" do
+      should "return true" do
+        assert @likeable.is_likeable?
+      end
+    end
+
+    context "#likeable?" do
+      should "return true" do
+        assert @likeable.likeable?
+      end
+    end
+
+    context "#liked_by?" do
+      should "not accept non-likers" do
+        assert_raises(Socialization::ArgumentError) { @likeable.liked_by?(:foo) }
+      end
+
+      # should "call $Like.likes?" do
+      #   # $Like.expect(:likes?).with(@liker, @likeable).once
+      #   assert_send([$Like, :likes?, *[@liker, @likeable]])
+      #   @likeable.liked_by?(@liker)
+      # end
+    end
+
+    context "#likers" do
+      should "call $Like.likers" do
+        # $Like.expect(:likers).with(@likeable, @liker.class, { :foo => :bar })
+        assert_send([$Like, :likers, *[@likeable, @liker.class, { :foo => :bar  }]])
+        @likeable.likers(@liker.class, { :foo => :bar })
+      end
+    end
+
+    context "#likers_relation" do
+      should "call $Like.likers_relation" do
+        # $Like.expect(:likers_relation).with(@likeable, @liker.class, { :foo => :bar })
+        assert_send([$Like, :likers_relation, *[@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.save!
+        @liker.like!(@likeable)
+      end
+
+      should "remove like relationships" do
+        assert_send([Socialization.like_model, :remove_likers, *[@likeable]])
+        # Socialization.like_model.expect(:remove_likers).with(@likeable)
+        @likeable.destroy
+      end
+    end
+
+  end
+end