tekeya 0.0.1

data/spec/rails_app/public/robots.txt

@@ -0,0 +1,5 @@
+# See http://www.robotstxt.org/wc/norobots.html for documentation on how to use the robots.txt file
+#
+# To ban all spiders from the entire site uncomment the next two lines:
+# User-Agent: *
+# Disallow: /

data/spec/rails_app/script/rails

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+# This command will automatically be run when you run "rails" with Rails 3 gems installed from the root of your application.
+
+APP_PATH = File.expand_path('../../config/application',  __FILE__)
+require File.expand_path('../../config/boot',  __FILE__)
+require 'rails/commands'

data/spec/spec_helper.rb

@@ -0,0 +1,78 @@
+require 'simplecov'
+SimpleCov.start do 
+  add_filter '/spec/'
+end
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+
+ENV["RAILS_ENV"] = "test"
+TEKEYA_ORM = (ENV["TEKEYA_ORM"] || :active_record).to_sym
+
+require 'rspec'
+require 'tekeya'
+require 'bundler'
+
+Bundler.require :default, :development, :test
+
+require 'database_cleaner'
+require "#{File.dirname(__FILE__)}/tekeya_helper"
+require "#{File.dirname(__FILE__)}/../lib/tekeya"
+require "#{File.dirname(__FILE__)}/rails_app/config/environment"
+require "#{File.dirname(__FILE__)}/orm/#{TEKEYA_ORM}"
+  
+# Requires supporting files with custom matchers and macros, etc,
+# in ./support/ and its subdirectories.
+Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each {|f| require f}
+
+RSpec.configure do |config|
+  Fabrication.configure do |config|
+    config.fabricator_path = 'fabricators'
+    config.path_prefix = File.dirname(__FILE__)
+  end
+
+  config.before(:each) do
+    DatabaseCleaner.clean
+  end
+
+  config.after(:each) do
+    Tekeya.relations.truncate
+    Tekeya.redis.flushall
+  end
+  
+  config.before(:all) do
+   %w(tmp tmp/pids tmp/cache).each do |path|
+      FileUtils.mkdir_p "#{Dir.pwd}/#{path}"
+    end
+  end
+
+  REDIS_PID = File.join(File.dirname(__FILE__), '..', 'tmp','pids','redis-test.pid')
+  REDIS_CACHE_PATH = File.join(File.dirname(__FILE__), '..', 'tmp','cache')
+
+  config.before(:suite) do
+    redis_options = {
+      "daemonize"     => 'yes',
+      "pidfile"       => REDIS_PID,
+      "port"          => 9736,
+      "timeout"       => 300,
+      "save 900"      => 1,
+      "save 300"      => 1,
+      "save 60"       => 10000,
+      "dbfilename"    => "dump.rdb",
+      "dir"           => REDIS_CACHE_PATH,
+      "loglevel"      => "debug",
+      "logfile"       => "stdout",
+      "databases"     => 16
+    }.map { |k, v| "#{k} #{v}" }.join('\n')
+    `echo '#{redis_options}' | redis-server -`
+  end
+
+  config.after(:suite) do
+    %x{
+      cat #{REDIS_PID} | xargs kill -QUIT
+      rm -f #{REDIS_CACHE_PATH}dump.rdb
+    }
+
+    FileUtils.rm_r "#{File.dirname(__FILE__)}/rails_app/db/test.sqlite3" rescue nil
+  end
+end

data/spec/tekeya/activity_spec.rb

@@ -0,0 +1,170 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe "Tekeya" do
+  describe "Activity" do
+    before :each do
+      @user = Fabricate(:user)
+      @user2 = Fabricate(:user)
+      @user3 = Fabricate(:user)
+
+      @user2.track(@user)
+      @user3.track(@user)
+
+      # Normal Activities (1 & 2 should be grouped)
+      @act1 = @user.activities.liked Fabricate(:status), Fabricate(:status)
+      @act2 = @user.activities.liked Fabricate(:status)
+      @act3 = @user.activities.shared Fabricate(:status)
+
+      # Created after the grouping interval
+      @act4 = @user.activities.new activity_type: :liked, attachments: [Fabricate.build(:attachment)]
+      @act4.stub(:current_time_from_proper_timezone => @act1.created_at + 20.minutes)
+      @act4.save!
+
+      # Manually not grouped
+      @act5 = @user.activities.liked Fabricate(:status), group: false
+    end
+
+    it "should return the same aggregate key" do 
+      @act1.activity_key.should == @act2.activity_key
+    end
+
+    it "should return different aggregate keys" do
+      @act1.activity_key.should_not == @act3.activity_key
+    end
+
+    it "should create an aggregate in redis" do
+      @act1.cached_in_redis?.should == true
+      @act2.cached_in_redis?.should == true
+      @act3.cached_in_redis?.should == true
+      @act4.cached_in_redis?.should == true
+      @act5.cached_in_redis?.should == true
+    end
+
+    it "should add the activity to the owner's profile feed and group activities of the same type within 15 min" do
+      id_array = @user.profile_feed.map(&:activity_id)
+      id_array.include?(@act1.id.to_s).should == true
+      id_array.include?(@act3.id.to_s).should == true
+      id_array.include?(@act4.id.to_s).should == true
+      id_array.include?(@act5.id.to_s).should == true
+    end
+
+    it "should not save the activity in the DB if its grouped with another" do
+      @act2.persisted?.should_not == true
+    end
+
+    it "should save the activity's attachments in the parent activity if its grouped" do
+      @act1.reload
+      (@act1.attachments & @act2.attachments).should == @act2.attachments
+    end
+
+    it "should fanout activities to the entity's trackers" do
+      id_array = (@user2.feed.map(&:activity_id) + @user3.feed.map(&:activity_id)).uniq
+      id_array.include?(@act1.id.to_s).should == true
+      id_array.include?(@act3.id.to_s).should == true
+      id_array.include?(@act4.id.to_s).should == true
+      id_array.include?(@act5.id.to_s).should == true
+    end
+
+    describe "invalid profile feed cache" do
+      it "should return profile activities from the DB when the profile cache is empty" do
+        ::Tekeya.redis.del(@user.profile_feed_key)
+        ::Tekeya.redis.del(@act1.activity_key)
+        ::Tekeya.redis.del(@act3.activity_key)
+        ::Tekeya.redis.del(@act4.activity_key)
+        ::Tekeya.redis.del(@act5.activity_key)
+
+        @act1.cached_in_redis?.should == false
+        @act3.cached_in_redis?.should == false
+        @act4.cached_in_redis?.should == false
+        @act5.cached_in_redis?.should == false
+        
+        id_array = @user.profile_feed.map(&:activity_id)
+        id_array.include?(@act1.id.to_s).should == true
+        id_array.include?(@act3.id.to_s).should == true
+        id_array.include?(@act4.id.to_s).should == true
+        id_array.include?(@act5.id.to_s).should == true
+      end
+    end
+
+    describe "invalid feed cache" do
+      it "should return feed activities from the DB when the feed cache is empty" do
+        ::Tekeya.redis.del(@user2.feed_key)
+        ::Tekeya.redis.del(@user3.feed_key)
+
+        ::Tekeya.redis.zcard(@user2.feed_key).should == 0
+        ::Tekeya.redis.zcard(@user3.feed_key).should == 0
+
+        @user2.feed.count == 4
+        @user3.feed.count == 4
+      end
+    end
+
+    describe "activity deletion" do
+      before :each do
+        @act1.destroy
+        @act3.destroy
+        @act4.destroy
+        @act5.destroy
+      end
+
+      it "should remove the activity from the cache when its deleted from the db" do
+        @act1.cached_in_redis?.should_not == true
+        @act3.cached_in_redis?.should_not == true
+        @act4.cached_in_redis?.should_not == true
+        @act5.cached_in_redis?.should_not == true
+      end
+
+      it "should remove the activity from the profile cache when its deleted from the db" do 
+        id_array = @user.profile_feed.map(&:activity_id)
+        id_array.include?(@act1.id.to_s).should_not == true
+        id_array.include?(@act3.id.to_s).should_not == true
+        id_array.include?(@act4.id.to_s).should_not == true
+        id_array.include?(@act5.id.to_s).should_not == true
+      end
+
+      it "should remove the activity from the trackers' feed when its deleted from the db" do
+        id_array = (@user2.feed.map(&:activity_id) + @user3.feed.map(&:activity_id)).uniq
+        id_array.include?(@act1.id.to_s).should_not == true
+        id_array.include?(@act3.id.to_s).should_not == true
+        id_array.include?(@act4.id.to_s).should_not == true
+        id_array.include?(@act5.id.to_s).should_not == true
+      end
+    end
+
+    describe "untracking" do
+      before :each do
+        @user2.untrack(@user)
+      end
+
+      it "should remove the feed of the untracked entity from the tracker's cache" do
+        id_array = @user2.feed.map(&:activity_id)
+        id_array.include?(@act1.id.to_s).should_not == true
+        id_array.include?(@act3.id.to_s).should_not == true
+        id_array.include?(@act4.id.to_s).should_not == true
+        id_array.include?(@act5.id.to_s).should_not == true
+
+        id_array = @user3.feed.map(&:activity_id)
+        id_array.include?(@act1.id.to_s).should == true
+        id_array.include?(@act3.id.to_s).should == true
+        id_array.include?(@act4.id.to_s).should == true
+        id_array.include?(@act5.id.to_s).should == true
+      end
+    end
+
+    describe "tracking" do
+      before :each do
+        @user4 = Fabricate(:user)
+
+        @user4.track(@user)
+      end
+
+      it "should copy the feed of the tracked entity into the tracker's feed" do
+        id_array = @user4.feed.map(&:activity_id)
+        id_array.include?(@act1.id.to_s).should == true
+        id_array.include?(@act3.id.to_s).should == true
+        id_array.include?(@act4.id.to_s).should == true
+        id_array.include?(@act5.id.to_s).should == true
+      end
+    end
+  end
+end

data/spec/tekeya/entity_spec.rb

@@ -0,0 +1,158 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe "Tekeya" do
+  describe "Entity" do
+    before :each do
+      @user = Fabricate(:user)
+      @user2 = Fabricate(:user)
+      @group = Fabricate(:group)
+    end
+
+    it "should inherit all the relations and feed methods" do
+      # Public methods
+      User.method_defined?(:track).should == true
+      User.method_defined?(:tracking).should == true
+      User.method_defined?(:"tracks?").should == true
+      User.method_defined?(:untrack).should == true
+      User.method_defined?(:block).should == true
+      User.method_defined?(:blocked).should == true
+      User.method_defined?(:"blocks?").should == true
+      User.method_defined?(:unblock).should == true
+      User.method_defined?(:join).should == true
+      User.method_defined?(:groups).should == true
+      User.method_defined?(:"member_of?").should == true
+      User.method_defined?(:leave).should == true
+      User.method_defined?(:profile_feed).should == true
+      User.method_defined?(:feed).should == true
+      User.method_defined?(:profile_feed_key).should == true
+      User.method_defined?(:feed_key).should == true
+      # Private methods
+      User.private_method_defined?(:add_tekeya_relation).should == true
+      User.private_method_defined?(:delete_tekeya_relation).should == true
+      User.private_method_defined?(:tekeya_relations_of).should == true
+      User.private_method_defined?(:"tekeya_relation_exists?").should == true
+    end
+
+    describe "errors" do
+      it "should raise a non entity error when tracking or blocking a non entity" do
+        expect { @user.track(nil) }.to raise_error(Tekeya::Errors::TekeyaNonEntity)
+        expect { @user.block(nil) }.to raise_error(Tekeya::Errors::TekeyaNonEntity)
+      end
+
+      it "should raise a non group error if a non group is given when joining a non group" do
+        expect { @user.join(nil) }.to raise_error(Tekeya::Errors::TekeyaNonGroup)
+      end
+
+      it "should raise a relation already exists error when tracking, blocking or joining an already tracked, blocked or joined entity/group" do
+        @user.track(@user2)
+        expect { @user.track(@user2) }.to raise_error(Tekeya::Errors::TekeyaRelationAlreadyExists)
+        @user.block(@user2)
+        expect { @user.block(@user2) }.to raise_error(Tekeya::Errors::TekeyaRelationAlreadyExists)
+        @user.join(@group)
+        expect { @user.join(@group) }.to raise_error(Tekeya::Errors::TekeyaRelationAlreadyExists)
+      end
+
+      it "should raise a relation non existent error when untracking, unblocking or leaving an untracked, unblocked or unjoined entity/group" do
+        expect { @user.untrack(@user2) }.to raise_error(Tekeya::Errors::TekeyaRelationNonExistent)
+        expect { @user.unblock(@user2) }.to raise_error(Tekeya::Errors::TekeyaRelationNonExistent)
+        expect { @user.leave(@group) }.to raise_error(Tekeya::Errors::TekeyaRelationNonExistent)
+      end
+    end
+
+    describe "relations" do
+      it "should track another entity" do
+        @user.track(@user2).should == true
+        @user.tracks?(@user2).should == true
+      end
+
+      it "should untrack a tracked entity" do
+        @user.track(@user2)
+        @user.untrack(@user2).should == true
+        @user.tracks?(@user2).should_not == true
+      end
+
+      it "should block another entity/group" do
+        @user.block(@user2).should == true
+        @user.blocks?(@user2).should == true
+        @user.block(@group).should == true
+        @user.blocks?(@group).should == true
+      end
+
+      it "should unblock a blocked entity/group" do
+        @user.block(@user2)
+        @user.unblock(@user2).should == true
+        @user.blocks?(@user2).should_not == true
+
+        @user.block(@group)
+        @user.unblock(@group).should == true
+        @user.blocks?(@group).should_not == true
+      end
+
+      it "should join a group" do
+        @user.join(@group).should == true
+        @user.member_of?(@group).should == true
+      end
+
+      it "should leave a group" do
+        @user.join(@group)
+        @user.leave(@group).should == true
+        @user.member_of?(@group).should_not == true
+      end
+
+      describe "retrieval" do
+        before :each do
+          @user3 = Fabricate(:user)
+          @user.track(@user2)
+          @user.block(@user3)
+          @user.join(@group)
+          @user2.join(@group)
+          @user3.join(@group)
+        end
+
+        it "should return tracked entities" do
+          @user.tracking.include?(@user2).should == true
+        end
+
+        it "should return trackers" do
+          @user2.trackers.include?(@user).should == true
+        end
+
+        it "should return blocked entities" do
+          @user.blocked.include?(@user3).should == true
+        end
+
+        it "should return joined groups" do
+          @user.groups.include?(@group).should == true
+        end
+
+        it "should return group members" do
+          @group.members.should == [@user, @user2, @user3]
+        end
+      end
+
+      describe "blocking entities" do
+        it "should remove the tracking relation if it exists" do
+          @user.track(@user2)
+          @user2.track(@user)
+          @user.block(@user2)
+
+          @user.tracks?(@user2).should_not == true
+          @user2.tracks?(@user).should_not == true
+        end
+      end
+
+      describe "groups" do
+        it "should track the group automatically when an entity joins" do
+          @user.join(@group)
+          @user.tracks?(@group).should == true
+        end
+
+        it "should untrack the group automatically when an entity leaves" do
+          @user.join(@group)
+          @user.leave(@group)
+          @user.tracks?(@group).should_not == true
+        end
+      end
+    end
+  end
+end

data/spec/tekeya/notification_spec.rb

@@ -0,0 +1,49 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe "Tekeya" do
+  describe "Notification" do
+    before :each do
+      @user = Fabricate(:user)
+      @user1 = Fabricate(:user)
+    end
+
+    describe "DSL" do
+      before :each do
+        @user1.track @user
+        @user.notifications.poked_by @user1
+
+        @user2 = Fabricate(:user)
+        @user3 = Fabricate(:user)
+        @user4 = Fabricate(:user)
+
+        @status = Fabricate(:status)
+      end
+
+      it "should notify the entity with the proper notification data" do
+        tracked_notification = @user.notifications.first
+
+        tracked_notification.notification_type.should == "tracked_by"
+        tracked_notification.subject.should == @user
+        tracked_notification.actors.map(&:attachable_id).include?(@user1.id).should == true
+
+        poked_notification = @user.notifications.last
+
+        poked_notification.notification_type.should == "poked_by"
+        poked_notification.subject.should == @user
+        poked_notification.actors.map(&:attachable_id).include?(@user1.id).should == true
+      end
+
+      it "should notify multiple entities" do
+        Tekeya::Notification.notify! [@user2, @user3, @user4], :posted, @status, @user
+
+        ((@user2.notifications == @user3.notifications) == (@user4.notifications == 1)).should == true
+      end
+
+      it "should return unread notifications correctly" do
+        @user.notifications.first.read!
+        @user.notifications.unread.count.should == 1
+      end
+    end
+
+  end
+end