activity_feed 1.4.0 → 2.0.0.rc1

data/lib/activity_feed/feed.rb

@@ -1,29 +1,98 @@
-require 'leaderboard'
-
 module ActivityFeed
-  class Feed
-    def initialize(user_id)
-      @feederboard = Leaderboard.new(ActivityFeed.feed_key(user_id), Leaderboard::DEFAULT_OPTIONS, {:redis_connection => ActivityFeed.redis})
-      @feederboard_aggregate = Leaderboard.new(ActivityFeed.feed_key(user_id, true), Leaderboard::DEFAULT_OPTIONS, {:redis_connection => ActivityFeed.redis})
+  module Feed
+    # Retrieve a page from the activity feed for a given +user_id+. You can configure 
+    # +ActivityFeed.item_loader+ with a Proc to retrieve an item from, for example, 
+    # your ORM (e.g. ActiveRecord) or your ODM (e.g. Mongoid), and have the page 
+    # returned with loaded items rather than item IDs.
+    #
+    # @param user_id [String] User ID.
+    # @param page [int] Page in the feed to be retrieved.
+    # @param aggregate [boolean, false] Whether to retrieve the aggregate feed for +user_id+.
+    # 
+    # @return page from the activity feed for a given +user_id+.
+    def feed(user_id, page, aggregate = ActivityFeed.aggregate)
+      feederboard = ActivityFeed.feederboard_for(user_id, aggregate)
+      feed = feederboard.members(page, :page_size => ActivityFeed.page_size).inject([]) do |feed_items, feed_item|
+        item = if ActivityFeed.item_loader
+          ActivityFeed.item_loader.call(feed_item[:member])
+        else
+          feed_item[:member]
+        end
+
+        feed_items << item unless item.nil?
+        feed_items
+      end
+
+      feed.nil? ? [] : feed
     end
-    
-    def page(page, aggregate = false)
-      feed_items = []
-      
-      feed = aggregate ? @feederboard_aggregate : @feederboard
-      feed.leaders(page).each do |feed_item|
-        feed_items << ActivityFeed.load_item(feed_item[:member])
+
+    # Retrieve a page from the activity feed for a given +user_id+ between a 
+    # +starting_timestamp+ and an +ending_timestamp+. You can configure 
+    # +ActivityFeed.item_loader+ with a Proc to retrieve an item from, for example, 
+    # your ORM (e.g. ActiveRecord) or your ODM (e.g. Mongoid), and have the feed data  
+    # returned with loaded items rather than item IDs.
+    #
+    # @param user_id [String] User ID.
+    # @param starting_timestamp [int] Starting timestamp between which items in the feed are to be retrieved.
+    # @param ending_timestamp [int] Ending timestamp between which items in the feed are to be retrieved.
+    # @param aggregate [boolean, false] Whether to retrieve items from the aggregate feed for +user_id+.
+    # 
+    # @return feed items from the activity feed for a given +user_id+ between the +starting_timestamp+ and +ending_timestamp+.
+    def feed_between_timestamps(user_id, starting_timestamp, ending_timestamp, aggregate = ActivityFeed.aggregate)
+      feederboard = ActivityFeed.feederboard_for(user_id, aggregate)
+      feed = feederboard.members_from_score_range(starting_timestamp, ending_timestamp).inject([]) do |feed_items, feed_item|
+        item = if ActivityFeed.item_loader
+          ActivityFeed.item_loader.call(feed_item[:member])
+        else
+          feed_item[:member]
+        end
+
+        feed_items << item unless item.nil?
+        feed_items
       end
 
-      feed_items
+      feed.nil? ? [] : feed
     end
-    
-    def total_pages(aggregate = false)
-      aggregate ? @feederboard_aggregate.total_pages : @feederboard.total_pages
+
+    # Return the total number of pages in the activity feed.
+    #
+    # @param user_id [String] User ID.
+    # @param aggregate [boolean, false] Whether to check the total number of pages in the aggregate activity feed or not.
+    # @param page_size [int, ActivityFeed.page_size] Page size to be used in calculating the total number of pages in the activity feed.
+    #
+    # @return the total number of pages in the activity feed.
+    def total_pages_in_feed(user_id, aggregate = ActivityFeed.aggregate, page_size = ActivityFeed.page_size)
+      ActivityFeed.feederboard_for(user_id, aggregate).total_pages_in(ActivityFeed.feed_key(user_id, aggregate), page_size)
     end
-    
-    def total_items(aggregate = false)
-      aggregate ? @feederboard_aggregate.total_members : @feederboard.total_members
+
+    # Return the total number of items in the activity feed.
+    #
+    # @param user_id [String] User ID.
+    # @param aggregate [boolean, false] Whether to check the total number of items in the aggregate activity feed or not.
+    #
+    # @return the total number of items in the activity feed.
+    def total_items_in_feed(user_id, aggregate = ActivityFeed.aggregate)
+      ActivityFeed.feederboard_for(user_id, aggregate).total_members
+    end
+
+    # Remove the activity feeds for a given +user_id+.
+    #
+    # @param user_id [String] User ID.
+    def remove_feeds(user_id)
+      ActivityFeed.redis.multi do |transaction|
+        transaction.del(ActivityFeed.feed_key(user_id, false))
+        transaction.del(ActivityFeed.feed_key(user_id, true))
+      end
+    end
+
+    # Trim an activity feed between two timestamps.
+    #
+    # @param user_id [String] User ID.
+    # @param starting_timestamp [int] Starting timestamp after which activity feed items will be cut.
+    # @param ending_timestamp [int] Ending timestamp before which activity feed items will be cut.
+    # @param aggregate [boolean, false] Whether or not to trim the aggregate activity feed or not.
+    def trim_feed(user_id, starting_timestamp, ending_timestamp, aggregate = ActivityFeed.aggregate)
+      ActivityFeed.feederboard_for(user_id, aggregate).remove_members_in_score_range(starting_timestamp, ending_timestamp)
     end
   end
 end

data/lib/activity_feed/item.rb

@@ -0,0 +1,44 @@
+module ActivityFeed
+  module Item
+    # Add or update an item in the activity feed for a given +user_id+.
+    #
+    # @param user_id [String] User ID.
+    # @param item_id [String] Item ID.
+    # @param timestamp [int] Timestamp for the item being added or updated.
+    # @param aggregate [boolean, false] Whether to add or update the item in the aggregate feed for +user_id+.
+    def update_item(user_id, item_id, timestamp, aggregate = ActivityFeed.aggregate)
+      feederboard = ActivityFeed.feederboard_for(user_id, false)
+      feederboard.rank_member(item_id, timestamp)
+
+      if aggregate
+        feederboard = ActivityFeed.feederboard_for(user_id, true)
+        feederboard.rank_member(item_id, timestamp)
+      end
+    end
+
+    # Specifically aggregate an item in the activity feed for a given +user_id+. 
+    # This is useful if you are going to background the process of populating 
+    # a user's activity feed from friend's activities.
+    #
+    # @param user_id [String] User ID.
+    # @param item_id [String] Item ID.
+    # @param timestamp [int] Timestamp for the item being added or updated.
+    def aggregate_item(user_id, item_id, timestamp)
+      feederboard = ActivityFeed.feederboard_for(user_id, true)
+      feederboard.rank_member(item_id, timestamp)
+    end
+
+    # Remove an item from the activity feed for a given +user_id+. This 
+    # will also remove the item from the aggregate activity feed for the
+    # user.
+    # 
+    # @param user_id [String] User ID.
+    # @param item_id [String] Item ID.
+    def remove_item(user_id, item_id)
+      feederboard = ActivityFeed.feederboard_for(user_id, false)
+      feederboard.remove_member(item_id)
+      feederboard = ActivityFeed.feederboard_for(user_id, true)
+      feederboard.remove_member(item_id)
+    end
+  end
+end

data/lib/activity_feed/utility.rb

@@ -0,0 +1,25 @@
+module ActivityFeed
+  module Utility
+    # Feed key for a +user_id+ composed of:
+    #
+    # Feed: +ActivityFeed.namespace:user_id+
+    # Aggregate feed: +ActivityFeed.namespace:ActivityFeed.aggregate_key:user_id+
+    # 
+    # @return feed key.
+    def feed_key(user_id, aggregate = ActivityFeed.aggregate)
+      aggregate ? 
+        "#{ActivityFeed.namespace}:#{ActivityFeed.aggregate_key}:#{user_id}" :
+        "#{ActivityFeed.namespace}:#{user_id}"
+    end
+
+    # Retrieve a reference to the activity feed for a given +user_id+.
+    #
+    # @param user_id [String] User ID.
+    # @param aggregate [boolean, false] Whether to retrieve the aggregate feed for +user_id+ or not.
+    #
+    # @return reference to the activity feed for a given +user_id+.
+    def feederboard_for(user_id, aggregate = ActivityFeed.aggregate)
+      ::Leaderboard.new(feed_key(user_id, aggregate), ::Leaderboard::DEFAULT_OPTIONS, {:redis_connection => ActivityFeed.redis})
+    end
+  end
+end

data/lib/activity_feed/version.rb

@@ -1,3 +1,3 @@
 module ActivityFeed
-  VERSION = "1.4.0"
+  VERSION = "2.0.0.rc1"
 end

data/lib/activity_feed.rb

@@ -1,113 +1,14 @@
-require 'activity_feed/version'
+require 'activity_feed/configuration'
+require 'activity_feed/item'
 require 'activity_feed/feed'
-require 'active_support/core_ext/module/attribute_accessors'
-require 'active_support/inflector'
+require 'activity_feed/utility'
+require 'activity_feed/version'
 
-require 'redis'
+require 'leaderboard'
 
 module ActivityFeed
-  mattr_accessor :redis
-  mattr_accessor :namespace
-  mattr_accessor :key
-  mattr_accessor :persistence
-  mattr_accessor :aggregate_key
-  mattr_accessor :aggregate  
-    
-  def self.persistence=(type = :memory)
-    @@persistence_type = type
-    
-    case type
-    when :active_record
-      require 'activity_feed/active_record/item'
-      klazz = ActivityFeed::ActiveRecord::Item
-    when :memory
-      require 'activity_feed/memory/item'
-      klazz = ActivityFeed::Memory::Item      
-    when :mongo_mapper
-      require 'activity_feed/mongo_mapper/item'
-      klazz = ActivityFeed::MongoMapper::Item
-    when :mongoid
-      require 'activity_feed/mongoid/item'
-      klazz = ActivityFeed::Mongoid::Item
-    when :ohm
-      require 'activity_feed/ohm/item'
-      klazz = ActivityFeed::Ohm::Item
-    else
-      klazz = "ActivityFeed::#{type.to_s.classify}::Item".constantize
-    end
-    
-    @@persistence = klazz
-  end
-  
-  def self.create_item(attributes, aggregate = ActivityFeed.aggregate)
-    item = @@persistence.new(attributes)
-    item.save
-    if aggregate
-      ([item.user_id] | Array(aggregate)).each do |aggregation_id|
-        ActivityFeed.aggregate_item(item, aggregation_id)
-      end
-    end
-    item    
-  end
-  
-  def self.aggregate_item(item, user_id = nil)
-    user_id_for_aggregate = user_id.nil? ? item.user_id : user_id
-    case @@persistence_type
-    when :active_record, :mongo_mapper, :mongoid
-      ActivityFeed.redis.zadd(ActivityFeed.feed_key(user_id_for_aggregate, true), item.created_at.to_i, item.id)
-    when :ohm
-      ActivityFeed.redis.zadd(ActivityFeed.feed_key(user_id_for_aggregate, true), DateTime.parse(item.created_at).to_i, item.id)
-    else
-      ActivityFeed.redis.zadd(ActivityFeed.feed_key(user_id_for_aggregate, true), DateTime.now.to_i, item.attributes.to_json)
-    end
-  end  
-  
-  def self.load_item(item_or_item_id)
-    case @@persistence_type
-    when :active_record
-      ActivityFeed::ActiveRecord::Item.find(item_or_item_id)
-    when :memory
-      JSON.parse(item_or_item_id)
-    when :mongo_mapper
-      ActivityFeed::MongoMapper::Item.find(item_or_item_id)
-    when :mongoid
-      ActivityFeed::Mongoid::Item.find(item_or_item_id)
-    when :ohm
-      ActivityFeed::Ohm::Item[item_or_item_id]
-    else
-      @@persistence.find(item_or_item_id)    
-    end
-  end
-
-  def self.update_item(user_id, item_id, timestamp, aggregate = false)
-    unless @@persistence_type == :memory
-      key = feed_key(user_id, aggregate)
-      ActivityFeed.redis.zadd(key, timestamp, item_id)
-    end
-  end
-
-  def self.delete_item(user_id, item_id, aggregate = false)
-    unless @@persistence_type == :memory
-      key = feed_key(user_id, aggregate)
-      ActivityFeed.redis.zrem(key, item_id)
-    end
-  end
-
-  def self.feed_key(user_id, aggregate = false)
-    if aggregate
-      "#{ActivityFeed.namespace}:#{ActivityFeed.key}:#{ActivityFeed.aggregate_key}:#{user_id}"
-    else
-      "#{ActivityFeed.namespace}:#{ActivityFeed.key}:#{user_id}"
-    end
-  end
-  
-  def self.feed(user_id)
-    ActivityFeed::Feed.new(user_id)
-  end
-  
-  self.namespace = 'activity'
-  self.key = 'feed'
-  self.aggregate_key = 'aggregate'
-  self.aggregate = []
-  self.persistence = :memory
-end
+  extend Configuration
+  extend Item
+  extend Feed
+  extend Utility  
+end

data/spec/activity_feed/configuration_spec.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+
+describe ActivityFeed::Configuration do
+  describe '#configure' do
+    it 'should have default attributes' do
+      ActivityFeed.configure do |configuration|
+        configuration.namespace.should == 'activity_feed'
+        configuration.aggregate.should be_false
+        configuration.aggregate_key.should == 'aggregate'
+        configuration.page_size.should== 25
+      end
+    end
+  end
+end

data/spec/activity_feed/feed_spec.rb

@@ -0,0 +1,270 @@
+require 'spec_helper'
+
+describe ActivityFeed::Feed do
+  describe '#feed' do
+    describe 'without aggregation' do
+      it 'should return an activity feed with the items correctly ordered' do
+        add_items_to_feed('david')
+
+        feed = ActivityFeed.feed('david', 1)
+        feed.length.should == 5
+        feed[0].to_i.should == 5
+        feed[4].to_i.should == 1
+      end
+    end
+
+    describe 'with aggregation' do
+      it 'should return an aggregate activity feed with the items correctly ordered' do
+        add_items_to_feed('david', 5, true)
+
+        feed = ActivityFeed.feed('david', 1, true)
+        feed.length.should == 5
+        feed[0].to_i.should == 5
+        feed[4].to_i.should == 1
+      end
+    end
+  end
+
+  describe '#feed_between_timestamps' do
+    describe 'without aggregation' do
+      it 'should return activity feed items between the starting and ending timestamps' do
+        Timecop.travel(Time.local(2012, 6, 19, 4, 0, 0))
+        ActivityFeed.update_item('david', 1, DateTime.now.to_i)
+        Timecop.travel(Time.local(2012, 6, 19, 4, 30, 0))
+        ActivityFeed.update_item('david', 2, DateTime.now.to_i)
+        Timecop.travel(Time.local(2012, 6, 19, 5, 30, 0))
+        ActivityFeed.update_item('david', 3, DateTime.now.to_i)
+        Timecop.travel(Time.local(2012, 6, 19, 6, 37, 0))
+        ActivityFeed.update_item('david', 4, DateTime.now.to_i)
+        Timecop.travel(Time.local(2012, 6, 19, 8, 17, 0))
+        ActivityFeed.update_item('david', 5, DateTime.now.to_i)
+        Timecop.return
+
+        feed = ActivityFeed.feed_between_timestamps('david', Time.local(2012, 6, 19, 4, 43, 0).to_i, Time.local(2012, 6, 19, 8, 16, 0).to_i)
+        feed.length.should == 2
+        feed[0].to_i.should == 4
+        feed[1].to_i.should == 3
+      end
+    end
+
+    describe 'with aggregation' do
+      it 'should return activity feed items between the starting and ending timestamps' do
+        Timecop.travel(Time.local(2012, 6, 19, 4, 0, 0))
+        ActivityFeed.update_item('david', 1, DateTime.now.to_i, true)
+        Timecop.travel(Time.local(2012, 6, 19, 4, 30, 0))
+        ActivityFeed.update_item('david', 2, DateTime.now.to_i, true)
+        Timecop.travel(Time.local(2012, 6, 19, 5, 30, 0))
+        ActivityFeed.update_item('david', 3, DateTime.now.to_i, true)
+        Timecop.travel(Time.local(2012, 6, 19, 6, 37, 0))
+        ActivityFeed.update_item('david', 4, DateTime.now.to_i, true)
+        Timecop.travel(Time.local(2012, 6, 19, 8, 17, 0))
+        ActivityFeed.update_item('david', 5, DateTime.now.to_i, true)
+        Timecop.return
+
+        feed = ActivityFeed.feed_between_timestamps('david', Time.local(2012, 6, 19, 4, 43, 0).to_i, Time.local(2012, 6, 19, 8, 16, 0).to_i, true)
+        feed.length.should == 2
+        feed[0].to_i.should == 4
+        feed[1].to_i.should == 3
+      end
+    end
+  end
+
+  describe '#total_pages_in_feed' do
+    describe 'without aggregation' do
+      it 'should return the correct number of pages in the activity feed' do
+        add_items_to_feed('david', Leaderboard::DEFAULT_PAGE_SIZE + 1)
+
+        ActivityFeed.total_pages_in_feed('david').should == 2
+      end
+    end
+
+    describe 'with aggregation' do
+      it 'should return the correct number of pages in the aggregate activity feed' do
+        add_items_to_feed('david', Leaderboard::DEFAULT_PAGE_SIZE + 1, true)
+
+        ActivityFeed.total_pages_in_feed('david', true).should == 2
+      end
+    end
+
+    describe 'changing page_size parameter' do
+      it 'should return the correct number of pages in the activity feed' do
+        add_items_to_feed('david', 25)
+
+        ActivityFeed.total_pages_in_feed('david', false, 4).should == 7
+      end
+    end
+  end
+
+  describe '#remove_feeds' do
+    it 'should remove the activity feeds for a given user ID' do
+      add_items_to_feed('david', Leaderboard::DEFAULT_PAGE_SIZE + 1, true)
+
+      ActivityFeed.total_items_in_feed('david').should == Leaderboard::DEFAULT_PAGE_SIZE + 1
+      ActivityFeed.total_items_in_feed('david', true).should == Leaderboard::DEFAULT_PAGE_SIZE + 1
+
+      ActivityFeed.remove_feeds('david')
+
+      ActivityFeed.total_items_in_feed('david').should == 0
+      ActivityFeed.total_items_in_feed('david', true).should == 0
+    end
+  end
+
+  describe '#total_items_in_feed' do
+    describe 'without aggregation' do
+      it 'should return the correct number of items in the activity feed' do
+        add_items_to_feed('david', Leaderboard::DEFAULT_PAGE_SIZE + 1)
+
+        ActivityFeed.total_items_in_feed('david').should == Leaderboard::DEFAULT_PAGE_SIZE + 1
+      end
+    end
+
+    describe 'with aggregation' do
+      it 'should return the correct number of items in the aggregate activity feed' do
+        add_items_to_feed('david', Leaderboard::DEFAULT_PAGE_SIZE + 1, true)
+
+        ActivityFeed.total_items_in_feed('david', true).should == Leaderboard::DEFAULT_PAGE_SIZE + 1
+      end
+    end
+  end
+
+  describe '#trim_feed' do
+    describe 'without aggregation' do
+      it 'should trim activity feed items between the starting and ending timestamps' do
+        t1 = Timecop.travel(Time.local(2012, 6, 19, 4, 0, 0))
+        ActivityFeed.update_item('david', 1, DateTime.now.to_i)
+        t2 = Timecop.travel(Time.local(2012, 6, 19, 4, 30, 0))
+        ActivityFeed.update_item('david', 2, DateTime.now.to_i)
+        t3 = Timecop.travel(Time.local(2012, 6, 19, 5, 30, 0))
+        ActivityFeed.update_item('david', 3, DateTime.now.to_i)
+        t4 = Timecop.travel(Time.local(2012, 6, 19, 6, 37, 0))
+        ActivityFeed.update_item('david', 4, DateTime.now.to_i)
+        t5 = Timecop.travel(Time.local(2012, 6, 19, 8, 17, 0))
+        ActivityFeed.update_item('david', 5, DateTime.now.to_i)
+        Timecop.return
+
+        ActivityFeed.trim_feed('david', Time.local(2012, 6, 19, 4, 29, 0).to_i, Time.local(2012, 6, 19, 8, 16, 0).to_i)
+        feed = ActivityFeed.feed('david', 1)
+        feed.length.should == 2
+        feed[0].to_i.should == 5
+        feed[1].to_i.should == 1
+      end
+    end
+
+    describe 'with aggregation' do
+      it 'should trim activity feed items between the starting and ending timestamps' do
+        t1 = Timecop.travel(Time.local(2012, 6, 19, 4, 0, 0))
+        ActivityFeed.update_item('david', 1, DateTime.now.to_i, true)
+        t2 = Timecop.travel(Time.local(2012, 6, 19, 4, 30, 0))
+        ActivityFeed.update_item('david', 2, DateTime.now.to_i, true)
+        t3 = Timecop.travel(Time.local(2012, 6, 19, 5, 30, 0))
+        ActivityFeed.update_item('david', 3, DateTime.now.to_i, true)
+        t4 = Timecop.travel(Time.local(2012, 6, 19, 6, 37, 0))
+        ActivityFeed.update_item('david', 4, DateTime.now.to_i, true)
+        t5 = Timecop.travel(Time.local(2012, 6, 19, 8, 17, 0))
+        ActivityFeed.update_item('david', 5, DateTime.now.to_i, true)
+        Timecop.return
+
+        ActivityFeed.trim_feed('david', Time.local(2012, 6, 19, 4, 29, 0).to_i, Time.local(2012, 6, 19, 8, 16, 0).to_i, true)
+        feed = ActivityFeed.feed('david', 1, true)
+        feed.length.should == 2
+        feed[0].to_i.should == 5
+        feed[1].to_i.should == 1
+      end
+    end
+  end
+
+  describe 'ORM or ODM loading' do
+    describe 'ActiveRecord' do
+      it 'should be able to load an item via ActiveRecord when requesting a feed' do
+        ActivityFeed.item_loader = Proc.new do |id| 
+          ActivityFeed::ActiveRecord::Item.find(id)
+        end
+      
+        feed = ActivityFeed.feed('david', 1)
+        feed.length.should == 0
+
+        item = ActivityFeed::ActiveRecord::Item.create(
+          :user_id => 'david', 
+          :nickname => 'David Czarnecki',
+          :type => 'some_activity',
+          :title => 'Great activity',
+          :body => 'This is text for the feed item'
+        )
+
+        feed = ActivityFeed.feed('david', 1)
+        feed.length.should == 1
+        feed[0].should == item
+      end
+    end
+
+    describe 'Mongoid' do
+      it 'should be able to load an item via Mongoid when requesting a feed' do
+        ActivityFeed.item_loader = Proc.new { |id| ActivityFeed::Mongoid::Item.find(id) }
+      
+        feed = ActivityFeed.feed('david', 1)
+        feed.length.should == 0
+
+        item = ActivityFeed::Mongoid::Item.create(
+          :user_id => 'david', 
+          :nickname => 'David Czarnecki',
+          :type => 'some_activity',
+          :title => 'Great activity',
+          :text => 'This is text for the feed item',
+          :url => 'http://url.com'
+        )
+
+        feed = ActivityFeed.feed('david', 1)
+        feed.length.should == 1
+        feed[0].should == item
+      end
+    end
+
+    describe 'item_loader exception handling' do
+      it 'should call the item_loader_exception_handler if it is set and there is an exception loading an activity feed item' do
+        ActivityFeed.item_loader = Proc.new do |id|
+          begin
+            ActivityFeed::Mongoid::Item.find(id)
+          rescue Mongoid::Errors::DocumentNotFound
+          end
+        end
+
+        ActivityFeed.update_item('david', '4fe4c5f3421aa9b89c000001', Time.now.to_i, false)
+        feed = ActivityFeed.feed('david', 1)
+        feed.length.should == 0
+      end
+
+      it 'should still load an activity feed, but call the item_loader_exception_handler if it is set and there is an exception loading an activity feed item' do
+        ActivityFeed.item_loader = Proc.new do |id|
+          begin
+            ActivityFeed::Mongoid::Item.find(id)
+          rescue Mongoid::Errors::DocumentNotFound
+          end
+        end
+
+        item = ActivityFeed::Mongoid::Item.create(
+          :user_id => 'david', 
+          :nickname => 'David Czarnecki',
+          :type => 'some_activity',
+          :title => 'Great activity',
+          :text => 'This is text for the feed item',
+          :url => 'http://url.com'
+        )
+
+        ActivityFeed.update_item('david', '4fe4c5f3421aa9b89c000001', DateTime.now.to_i)
+
+        another_item = ActivityFeed::Mongoid::Item.create(
+          :user_id => 'david', 
+          :nickname => 'David Czarnecki',
+          :type => 'some_activity',
+          :title => 'Great activity',
+          :text => 'This is more text for the feed item',
+          :url => 'http://url.com'
+        )
+
+        feed = ActivityFeed.feed('david', 1)
+
+        feed.length.should == 2
+      end
+    end
+  end
+end

data/spec/activity_feed/item_spec.rb

@@ -0,0 +1,65 @@
+require 'spec_helper'
+require 'active_support/core_ext/date_time/conversions'
+
+describe ActivityFeed::Item do
+  describe '#update_item' do
+    describe 'without aggregation' do
+      it 'should correctly build an activity feed' do
+        ActivityFeed.redis.exists(ActivityFeed.feed_key('david')).should be_false
+        ActivityFeed.update_item('david', 1, DateTime.now.to_i)
+        ActivityFeed.redis.exists(ActivityFeed.feed_key('david')).should be_true
+      end
+    end
+
+    describe 'with aggregation' do
+      it 'should correctly build an activity feed with an aggregate activity_feed' do
+        ActivityFeed.redis.exists(ActivityFeed.feed_key('david')).should be_false
+        ActivityFeed.redis.exists(ActivityFeed.feed_key('david', true)).should be_false
+        ActivityFeed.update_item('david', 1, DateTime.now.to_i, true)
+        ActivityFeed.redis.exists(ActivityFeed.feed_key('david')).should be_true
+        ActivityFeed.redis.exists(ActivityFeed.feed_key('david', true)).should be_true
+      end
+    end
+  end
+
+  describe '#aggregate_item' do
+    it 'should correctly add an item into an aggregate activity feed' do
+      ActivityFeed.redis.exists(ActivityFeed.feed_key('david')).should be_false
+      ActivityFeed.redis.exists(ActivityFeed.feed_key('david', true)).should be_false
+      ActivityFeed.aggregate_item('david', 1, DateTime.now.to_i)
+      ActivityFeed.redis.exists(ActivityFeed.feed_key('david')).should be_false
+      ActivityFeed.redis.exists(ActivityFeed.feed_key('david', true)).should be_true
+    end
+  end
+
+  describe '#remove_item' do
+    describe 'without aggregation' do
+      it 'should remove an item from an activity feed' do
+        ActivityFeed.redis.exists(ActivityFeed.feed_key('david')).should be_false
+        ActivityFeed.redis.zcard(ActivityFeed.feed_key('david')).should == 0
+        ActivityFeed.update_item('david', 1, DateTime.now.to_i)
+        ActivityFeed.redis.exists(ActivityFeed.feed_key('david')).should be_true
+        ActivityFeed.redis.zcard(ActivityFeed.feed_key('david')).should == 1
+        ActivityFeed.remove_item('david', 1)
+        ActivityFeed.redis.zcard(ActivityFeed.feed_key('david')).should == 0
+      end
+    end
+
+    describe 'with aggregation' do
+      it 'should remove an item from an activity feed and the aggregate feed' do
+        ActivityFeed.redis.exists(ActivityFeed.feed_key('david')).should be_false
+        ActivityFeed.redis.exists(ActivityFeed.feed_key('david', true)).should be_false
+        ActivityFeed.redis.zcard(ActivityFeed.feed_key('david')).should == 0
+        ActivityFeed.redis.zcard(ActivityFeed.feed_key('david', true)).should == 0
+        ActivityFeed.update_item('david', 1, DateTime.now.to_i, true)
+        ActivityFeed.redis.exists(ActivityFeed.feed_key('david')).should be_true
+        ActivityFeed.redis.exists(ActivityFeed.feed_key('david', true)).should be_true
+        ActivityFeed.redis.zcard(ActivityFeed.feed_key('david')).should == 1
+        ActivityFeed.redis.zcard(ActivityFeed.feed_key('david', true)).should == 1
+        ActivityFeed.remove_item('david', 1)
+        ActivityFeed.redis.zcard(ActivityFeed.feed_key('david')).should == 0
+        ActivityFeed.redis.zcard(ActivityFeed.feed_key('david', true)).should == 0
+      end
+    end
+  end
+end