nelumba-mongodb 0.0.1

data/spec/avatar_spec.rb

@@ -0,0 +1,418 @@
+require_relative 'helper'
+
+module Net
+  class HTTPSuccess; end
+
+  class HTTPNotFound; def initialize; end; end
+  class HTTPRedirection; def initialize; end; end
+  class HTTPOK < HTTPSuccess; def initialize; end; end
+
+  class HTTP
+    class Get; end
+    class Post; end
+  end
+end
+
+module Base64; end
+
+describe Nelumba::Avatar do
+  before do
+    Nelumba::Avatar.class_variable_set :@@grid, nil
+  end
+
+  describe "Schema" do
+    it "should have an author_id" do
+      Nelumba::Avatar.keys.keys.must_include "author_id"
+    end
+
+    it "should have a sizes array" do
+      Nelumba::Avatar.keys.keys.must_include "sizes"
+    end
+
+    it "should has a default sizes array of []" do
+      Nelumba::Avatar.new.sizes.must_equal []
+    end
+
+    it "should have a content_type" do
+      Nelumba::Avatar.keys.keys.must_include "content_type"
+    end
+
+    it "should have a created_at" do
+      Nelumba::Avatar.keys.keys.must_include "created_at"
+    end
+
+    it "should have a updated_at" do
+      Nelumba::Avatar.keys.keys.must_include "updated_at"
+    end
+  end
+
+  describe "from_url!" do
+    it "should return nil if url is not found" do
+      uri = stub('URI')
+      uri.stubs(:request_uri)
+      uri.stubs(:hostname)
+      uri.stubs(:port)
+      uri.stubs(:scheme)
+      Nelumba::Avatar.stubs(:URI).returns(uri)
+
+      request = stub('Net::HTTP::Request')
+      Net::HTTP::Get.stubs(:new).returns(request)
+
+      http = stub('Net::HTTP')
+      http.stubs(:use_ssl=)
+      http.stubs(:verify_mode=)
+      Net::HTTP.stubs(:new).returns(http)
+
+      response = stub('Net::HTTP::Response')
+      response.stubs(:class).returns(Net::HTTPNotFound)
+      response.stubs(:is_a?).returns false
+      http.stubs(:request).returns(response)
+
+      Magick::ImageList.stubs(:new)
+
+      author = Nelumba::Person.create
+      Nelumba::Avatar.from_url!(author, "bogus").must_equal nil
+    end
+
+    it "should destroy any previous avatar" do
+      uri = stub('URI')
+      uri.stubs(:request_uri)
+      uri.stubs(:hostname)
+      uri.stubs(:port)
+      uri.stubs(:scheme).returns("https")
+      Nelumba::Avatar.stubs(:URI).with("valid").returns(uri)
+
+      request = stub('Net::HTTP::Request')
+      Net::HTTP::Get.stubs(:new).returns(request)
+
+      http = stub('Net::HTTP')
+      http.stubs(:use_ssl=)
+      http.stubs(:verify_mode=)
+      Net::HTTP.stubs(:new).returns(http)
+
+      response = Net::HTTPOK.new
+      response.stubs(:body)
+      http.stubs(:request).returns(response)
+
+      new_image = stub('Magick::ImageList')
+      new_image.stubs(:to_blob).returns("NEW IMAGE")
+
+      image = stub('Magick::ImageList')
+      image.stubs(:from_blob)
+      image.stubs(:mime_type).returns("MIME")
+      image.stubs(:resize_to_fill).with(48, 48).returns(new_image)
+      Magick::ImageList.stubs(:new).returns(image)
+
+      author = Nelumba::Person.create
+
+      io = stub('IO')
+      io.stubs(:put)
+
+      gridfs = stub('Mongo::Grid')
+      Mongo::Grid.stubs(:new).returns(gridfs)
+
+      avatar = stub('Avatar')
+      avatar.stubs(:id).returns("ID")
+      avatar.stubs(:content_type=)
+      avatar.stubs(:save)
+      avatar.stubs(:_id).returns("ID")
+      Nelumba::Avatar.stubs(:new).returns(avatar)
+
+      gridfs.stubs(:put).with("NEW IMAGE", :_id => "avatar_ID_48x48")
+
+      old = Nelumba::Avatar.new
+      Nelumba::Avatar.stubs(:first).with(has_entry(:author_id => author.id)).returns(old)
+      old.expects(:destroy)
+
+      Nelumba::Avatar.from_url!(author, "valid", :sizes => [[48, 48]])
+    end
+
+    it "should use ssl and verify when given" do
+      uri = stub('URI')
+      uri.stubs(:request_uri)
+      uri.stubs(:hostname)
+      uri.stubs(:port)
+      uri.stubs(:scheme).returns("https")
+      Nelumba::Avatar.stubs(:URI).with("valid").returns(uri)
+
+      request = stub('Net::HTTP::Request')
+      Net::HTTP::Get.stubs(:new).returns(request)
+
+      http = stub('Net::HTTP')
+      Net::HTTP.stubs(:new).returns(http)
+
+      response = stub('Net::HTTP::Response')
+      response.stubs(:class).returns(Net::HTTPNotFound)
+      http.stubs(:request).returns(response)
+
+      Magick::ImageList.stubs(:new)
+
+      author = Nelumba::Person.create
+      Nelumba::Avatar.stubs(:first).with(has_entry(:author_id => author.id)).returns(nil)
+
+      http.expects(:use_ssl=).with(true)
+      http.expects(:verify_mode=).with(OpenSSL::SSL::VERIFY_PEER)
+      Nelumba::Avatar.from_url!(author, "valid")
+    end
+
+    it "should query ImageMagick for the content type" do
+      uri = stub('URI')
+      uri.stubs(:request_uri)
+      uri.stubs(:hostname)
+      uri.stubs(:port)
+      uri.stubs(:scheme).returns("https")
+      Nelumba::Avatar.stubs(:URI).with("valid").returns(uri)
+
+      request = stub('Net::HTTP::Request')
+      Net::HTTP::Get.stubs(:new).returns(request)
+
+      http = stub('Net::HTTP')
+      http.stubs(:use_ssl=)
+      http.stubs(:verify_mode=)
+      Net::HTTP.stubs(:new).returns(http)
+
+      response = Net::HTTPOK.new
+      response.stubs(:body)
+      http.stubs(:request).returns(response)
+
+      image = stub('Magick::ImageList')
+      image.stubs(:from_blob)
+      image.stubs(:mime_type).returns("MIME")
+      Magick::ImageList.stubs(:new).returns(image)
+
+      author = Nelumba::Person.create
+
+      Nelumba::Avatar.stubs(:first).with(has_entry(:author_id => author.id)).returns(nil)
+
+      Nelumba::Avatar.from_url!(author, "valid").content_type.must_equal "MIME"
+    end
+
+    it "should query ImageMagick to resize and fill to the given sizes" do
+      uri = stub('URI')
+      uri.stubs(:request_uri)
+      uri.stubs(:hostname)
+      uri.stubs(:port)
+      uri.stubs(:scheme).returns("https")
+      Nelumba::Avatar.stubs(:URI).with("valid").returns(uri)
+
+      request = stub('Net::HTTP::Request')
+      Net::HTTP::Get.stubs(:new).returns(request)
+
+      http = stub('Net::HTTP')
+      http.stubs(:use_ssl=)
+      http.stubs(:verify_mode=)
+      Net::HTTP.stubs(:new).returns(http)
+
+      response = Net::HTTPOK.new
+      response.stubs(:body)
+      http.stubs(:request).returns(response)
+
+      image = stub('Magick::ImageList')
+      image.stubs(:from_blob)
+      image.stubs(:mime_type).returns("MIME")
+      Magick::ImageList.stubs(:new).returns(image)
+
+      author = Nelumba::Person.create
+
+      io = stub('IO')
+      io.stubs(:put)
+
+      gridfs = stub('Mongo::Grid')
+      gridfs.stubs(:put)
+      Mongo::Grid.stubs(:new).returns(gridfs)
+
+      new_image = stub('Magick::ImageList')
+      new_image.stubs(:to_blob).returns("NEW IMAGE")
+
+      image.expects(:resize_to_fill).with(48, 48).returns(new_image)
+
+      Nelumba::Avatar.stubs(:first).with(has_entry(:author_id => author.id)).returns(nil)
+
+      Nelumba::Avatar.from_url!(author, "valid", :sizes => [[48, 48]])
+    end
+
+    it "should store the resultant image to GridFS" do
+      uri = stub('URI')
+      uri.stubs(:request_uri)
+      uri.stubs(:hostname)
+      uri.stubs(:port)
+      uri.stubs(:scheme).returns("https")
+      Nelumba::Avatar.stubs(:URI).with("valid").returns(uri)
+
+      request = stub('Net::HTTP::Request')
+      Net::HTTP::Get.stubs(:new).returns(request)
+
+      http = stub('Net::HTTP')
+      http.stubs(:use_ssl=)
+      http.stubs(:verify_mode=)
+      Net::HTTP.stubs(:new).returns(http)
+
+      response = Net::HTTPOK.new
+      response.stubs(:body)
+      http.stubs(:request).returns(response)
+
+      new_image = stub('Magick::ImageList')
+      new_image.stubs(:to_blob).returns("NEW IMAGE")
+
+      image = stub('Magick::ImageList')
+      image.stubs(:from_blob)
+      image.stubs(:mime_type).returns("MIME")
+      image.stubs(:resize_to_fill).with(48, 48).returns(new_image)
+      Magick::ImageList.stubs(:new).returns(image)
+
+      author = Nelumba::Person.create
+
+      io = stub('IO')
+      io.stubs(:put)
+
+      gridfs = stub('Mongo::Grid')
+      Mongo::Grid.stubs(:new).returns(gridfs)
+
+      avatar = stub('Avatar')
+      avatar.stubs(:id).returns("ID")
+      avatar.stubs(:content_type=)
+      avatar.stubs(:save)
+      avatar.stubs(:_id).returns("ID")
+      Nelumba::Avatar.stubs(:new).returns(avatar)
+
+      Nelumba::Avatar.stubs(:first).with(has_entry(:author_id => author.id)).returns(nil)
+
+      gridfs.expects(:put).with("NEW IMAGE", :_id => "avatar_ID_48x48")
+      Nelumba::Avatar.from_url!(author, "valid", :sizes => [[48, 48]])
+    end
+  end
+
+  describe "#url" do
+    it "should return a url crafted from the given size" do
+      avatar = Nelumba::Avatar.create(:sizes => [[48, 48]])
+
+      avatar.url([48, 48]).must_equal "/avatars/#{avatar.id}/48x48"
+    end
+
+    it "should return nil if the given size doesn't exist" do
+      avatar = Nelumba::Avatar.create(:sizes => [[50, 50]])
+
+      avatar.url([48, 48]).must_equal nil
+    end
+
+    it "should return nil when no sizes exist" do
+      avatar = Nelumba::Avatar.create
+
+      avatar.url([48, 48]).must_equal nil
+    end
+
+    it "should return nil when no sizes exist and none where given" do
+      avatar = Nelumba::Avatar.create
+
+      avatar.url.must_equal nil
+    end
+
+    it "should return first size given upon creation when none where given" do
+      avatar = Nelumba::Avatar.create(:sizes => [[48, 48], [64, 64]])
+
+      avatar.url([48, 48]).must_equal "/avatars/#{avatar.id}/48x48"
+    end
+  end
+
+  describe "#read" do
+    it "should call out to GridFS with the correct id" do
+      avatar = Nelumba::Avatar.create(:sizes => [[48, 48]])
+
+      io = stub('IO')
+      io.stubs(:read).returns("bytes")
+
+      gridfs = stub('Mongo::Grid')
+      gridfs.expects(:get).with("avatar_#{avatar.id}_48x48").returns(io)
+
+      Mongo::Grid.stubs(:new).returns(gridfs)
+
+      avatar.read.must_equal "bytes"
+    end
+
+    it "should call out to GridFS with the correct id when size is given" do
+      avatar = Nelumba::Avatar.create(:sizes => [[48, 48]])
+
+      io = stub('IO')
+      io.stubs(:read).returns("bytes")
+
+      gridfs = stub('Mongo::Grid')
+      gridfs.expects(:get).with("avatar_#{avatar.id}_48x48").returns(io)
+
+      Mongo::Grid.stubs(:new).returns(gridfs)
+
+      avatar.read([48, 48]).must_equal "bytes"
+    end
+
+    it "should return nil when no sizes exist and no size is given" do
+      avatar = Nelumba::Avatar.create
+
+      avatar.read([48, 48]).must_equal nil
+    end
+
+    it "should return nil when no sizes exist and size is given" do
+      avatar = Nelumba::Avatar.create
+
+      avatar.read([48, 48]).must_equal nil
+    end
+
+    it "should return nil when sizes exist but wrong size is given" do
+      avatar = Nelumba::Avatar.create(:sizes => [[48, 48]])
+
+      avatar.read([64, 64]).must_equal nil
+    end
+  end
+
+  describe "#read_base64" do
+    before do
+      Base64.stubs(:encode64).returns("data_as_base64")
+    end
+
+    it "should call out to GridFS with the correct id" do
+      avatar = Nelumba::Avatar.create(:sizes => [[48, 48]],
+                             :content_type => "mime")
+
+      io = stub('IO')
+      io.stubs(:read).returns("bytes")
+
+      gridfs = stub('Mongo::Grid')
+      gridfs.expects(:get).with("avatar_#{avatar.id}_48x48").returns(io)
+
+      Mongo::Grid.stubs(:new).returns(gridfs)
+
+      avatar.read_base64([48, 48]).must_equal "data:mime;base64,data_as_base64"
+    end
+
+    it "should call out to GridFS with the correct id when size is given" do
+      avatar = Nelumba::Avatar.create(:sizes => [[48, 48]],
+                             :content_type => "mime")
+
+      io = stub('IO')
+      io.stubs(:read).returns("bytes")
+
+      gridfs = stub('Mongo::Grid')
+      gridfs.expects(:get).with("avatar_#{avatar.id}_48x48").returns(io)
+
+      Mongo::Grid.stubs(:new).returns(gridfs)
+
+      avatar.read_base64([48, 48]).must_equal "data:mime;base64,data_as_base64"
+    end
+
+    it "should return nil when no sizes exist and no size is given" do
+      avatar = Nelumba::Avatar.create
+
+      avatar.read_base64([48, 48]).must_equal nil
+    end
+
+    it "should return nil when no sizes exist and size is given" do
+      avatar = Nelumba::Avatar.create(:content_type => "mime")
+
+      avatar.read_base64([48, 48]).must_equal nil
+    end
+
+    it "should return nil when sizes exist but wrong size is given" do
+      avatar = Nelumba::Avatar.create(:content_type => "mime")
+
+      avatar.read_base64([64, 64]).must_equal nil
+    end
+  end
+end

data/spec/feed_spec.rb

@@ -0,0 +1,485 @@
+require_relative 'helper'
+
+describe Nelumba::Feed do
+  describe "Schema" do
+    it "should have a url" do
+      Nelumba::Feed.keys.keys.must_include "url"
+    end
+
+    it "should have a uid" do
+      Nelumba::Feed.keys.keys.must_include "uid"
+    end
+
+    it "should have categories" do
+      Nelumba::Feed.keys.keys.must_include "categories"
+    end
+
+    it "should default categories to []" do
+      Nelumba::Feed.new.categories.must_equal []
+    end
+
+    it "should have a rights field" do
+      Nelumba::Feed.keys.keys.must_include "rights"
+    end
+
+    it "should have a title" do
+      Nelumba::Feed.keys.keys.must_include "title"
+    end
+
+    it "should have a title_type" do
+      Nelumba::Feed.keys.keys.must_include "title_type"
+    end
+
+    it "should have a subtitle" do
+      Nelumba::Feed.keys.keys.must_include "subtitle"
+    end
+
+    it "should have a subtitle_type" do
+      Nelumba::Feed.keys.keys.must_include "subtitle_type"
+    end
+
+    it "should have contributors_ids" do
+      Nelumba::Feed.keys.keys.must_include "contributors_ids"
+    end
+
+    it "should have authors_ids" do
+      Nelumba::Feed.keys.keys.must_include "authors_ids"
+    end
+
+    it "should have items_ids" do
+      Nelumba::Feed.keys.keys.must_include "items_ids"
+    end
+
+    it "should have a generator" do
+      Nelumba::Feed.keys.keys.must_include "generator"
+    end
+
+    it "should have a published" do
+      Nelumba::Feed.keys.keys.must_include "published"
+    end
+
+    it "should have a updated" do
+      Nelumba::Feed.keys.keys.must_include "updated"
+    end
+
+    it "should have a person_id" do
+      Nelumba::Feed.keys.keys.must_include "person_id"
+    end
+
+    it "should have a following_ids array" do
+      Nelumba::Feed.keys.keys.must_include "following_ids"
+    end
+
+    it "should have many following" do
+      Nelumba::Feed.has_many?(:following).must_equal true
+    end
+
+    it "should have a followers_ids array" do
+      Nelumba::Feed.keys.keys.must_include "followers_ids"
+    end
+
+    it "should have many followers" do
+      Nelumba::Feed.has_many?(:followers).must_equal true
+    end
+
+    it "should have a subscription_secret" do
+      Nelumba::Feed.keys.keys.must_include "subscription_secret"
+    end
+
+    it "should have a verification_token" do
+      Nelumba::Feed.keys.keys.must_include "verification_token"
+    end
+
+    it "should belong to person" do
+      Nelumba::Feed.belongs_to?(:person).must_equal true
+    end
+  end
+
+  describe "find_or_create_by_uid!" do
+    it "should return the existing Nelumba::Feed" do
+      feed = Nelumba::Feed.create!(:uid => "UID")
+
+      Nelumba::Feed.find_or_create_by_uid!(:uid => "UID").id.must_equal feed.id
+    end
+
+    it "should return the existing Nelumba::Feed via Nelumba::Feed" do
+      feed = Nelumba::Feed.create!(:uid => "UID")
+
+      nelumba_feed = Nelumba::Feed.new
+      nelumba_feed.stubs(:uid).returns("UID")
+
+      Nelumba::Feed.find_or_create_by_uid!(nelumba_feed).uid.must_equal feed.uid
+    end
+
+    it "should create when the Nelumba::Feed is not found" do
+      Nelumba::Feed.expects(:create!).with({:uid => "UID"})
+      Nelumba::Feed.find_or_create_by_uid!(:uid => "UID")
+    end
+
+    it "should create via Nelumba::Feed when the Nelumba::Feed is not found" do
+      nelumba_feed = Nelumba::Feed.new
+      nelumba_feed.stubs(:id).returns("UID")
+
+      Nelumba::Feed.expects(:create!).with(nelumba_feed)
+      Nelumba::Feed.find_or_create_by_uid!(nelumba_feed)
+    end
+
+    it "should account for race condition where entry was created after find" do
+      Nelumba::Feed.stubs(:first).returns(nil).then.returns("feed")
+      Nelumba::Feed.stubs(:create!).raises("")
+      Nelumba::Feed.find_or_create_by_uid!(:uid => "UID").must_equal "feed"
+    end
+  end
+
+  describe "#initialize" do
+    it "should allow a Nelumba::Feed" do
+      nelumba_feed = Nelumba::Feed.new(:uid => "UID",
+                                   :authors => [],
+                                   :contributors => [],
+                                   :items => [])
+
+      Nelumba::Feed.new(nelumba_feed).uid.must_equal "UID"
+    end
+
+    it "should find or create Nelumba::Persons for those given in Nelumba::Feed" do
+      author = Nelumba::Person.new
+      Nelumba::Person.expects(:find_or_create_by_uid!).returns(author)
+
+      Nelumba::Feed.new(:id => "UID",
+                      :authors => [{:uid => "author UID",
+                                    :url => "author URL"}],
+                      :contributors => [],
+                      :items => [])
+    end
+
+    it "should find or create Nelumba::Persons for contributors given in Nelumba::Feed" do
+      author = Nelumba::Person.new
+      Nelumba::Person.expects(:find_or_create_by_uid!).returns(author)
+
+      Nelumba::Feed.new(:id => "UID",
+                      :contributors => [{:uid => "author UID",
+                                         :url => "author URL"}],
+                      :authors => [],
+                      :items => [])
+    end
+
+    it "should find or create Nelumba::Activities for items given in Nelumba::Feed" do
+      activity = Nelumba::Activity.new
+      Nelumba::Activity.expects(:find_or_create_by_uid!).returns(activity)
+
+      Nelumba::Feed.new(:id => "UID",
+                      :items => [{:uid => "author UID",
+                                  :url => "author URL"}],
+                      :authors => [],
+                      :contributors => [])
+    end
+  end
+
+  describe "discover!" do
+    it "should use Nelumba to discover the feed given by the url" do
+      Nelumba::Discover.expects(:feed).with("feed_url")
+      Nelumba::Feed.discover!("feed_url")
+    end
+
+    it "should return false when the feed cannot be discovered" do
+      Nelumba::Discover.stubs(:feed).returns(nil)
+      Nelumba::Feed.discover!("feed_url").must_equal false
+    end
+
+    it "should create a new feed when the discovered feed does not exist" do
+      nelumba_feed = Nelumba::Feed.new
+      nelumba_feed.stubs(:id).returns("UID")
+      Nelumba::Discover.stubs(:feed).returns(nelumba_feed)
+
+      Nelumba::Feed.expects(:create!).with(nelumba_feed)
+      Nelumba::Feed.discover!("feed_url")
+    end
+
+    it "should return a known feed when url matches given" do
+      feed = Nelumba::Feed.new
+      Nelumba::Feed.stubs(:first).with(has_entry(:url, "feed_url")).returns(feed)
+
+      Nelumba::Feed.discover!("feed_url").must_equal feed
+    end
+
+    it "should return a known feed when uids match" do
+      nelumba_feed = Nelumba::Feed.new
+      nelumba_feed.stubs(:uid).returns("UID")
+      Nelumba::Discover.stubs(:feed).returns(nelumba_feed)
+
+      feed = Nelumba::Feed.new
+      Nelumba::Feed.stubs(:first).with(has_entry(:url, "feed_url")).returns(nil)
+      Nelumba::Feed.stubs(:first).with(has_entry(:uid, "UID")).returns(feed)
+      Nelumba::Discover.stubs(:feed).returns(nelumba_feed)
+
+      Nelumba::Feed.discover!("feed_url").must_equal feed
+    end
+  end
+
+  describe "#post!" do
+    it "should allow a Hash to be given" do
+      feed = Nelumba::Feed.new
+      feed.stubs(:save)
+
+      activity = Nelumba::Activity.new
+      activity.stubs(:save)
+
+      hash = {}
+      Nelumba::Activity.expects(:create!).with(hash).returns(activity)
+
+      feed.post! hash
+    end
+
+    it "should allow a Nelumba::Activity to be given" do
+      feed = Nelumba::Feed.new
+      feed.stubs(:save)
+
+      activity = Nelumba::Activity.new
+      activity.stubs(:save)
+
+      nelumba_activity = Nelumba::Activity.new
+      Nelumba::Activity.expects(:create!).never
+      nelumba_activity.expects(:save).at_least 1
+
+      feed.post! nelumba_activity
+    end
+
+    it "should save the association to this feed" do
+      feed = Nelumba::Feed.new
+      feed.stubs(:save)
+
+      activity = Nelumba::Activity.new
+      activity.expects(:feed_id=).with(feed.id)
+      activity.expects(:save).at_least 1
+
+      feed.post! activity
+    end
+
+    it "should add the activity to the items" do
+      feed = Nelumba::Feed.new
+      feed.stubs(:save)
+
+      activity = Nelumba::Activity.new
+      activity.stubs(:save)
+
+      feed.post! activity
+
+      feed.items_ids.must_include activity.id
+    end
+
+    it "should save" do
+      feed = Nelumba::Feed.new
+
+      activity = Nelumba::Activity.new
+      activity.stubs(:save)
+
+      feed.expects(:save)
+
+      feed.post! activity
+    end
+  end
+
+  describe "#repost!" do
+    it "should simply add the activity to items" do
+      feed = Nelumba::Feed.new
+      feed.stubs(:save)
+
+      activity = Nelumba::Activity.new
+      activity.stubs(:save)
+
+      feed.repost! activity
+
+      feed.items_ids.must_include activity.id
+    end
+
+    it "should save" do
+      feed = Nelumba::Feed.new
+
+      activity = Nelumba::Activity.new
+      activity.stubs(:save)
+
+      feed.expects(:save)
+
+      feed.repost! activity
+    end
+  end
+
+  describe "#delete!" do
+    it "should remove the given activity from items" do
+      feed = Nelumba::Feed.new
+      feed.stubs(:save)
+
+      activity = Nelumba::Activity.new
+      activity.stubs(:save)
+
+      feed.items << activity
+
+      feed.delete! activity
+      feed.items_ids.wont_include activity.id
+    end
+
+    it "should save" do
+      feed = Nelumba::Feed.new
+
+      activity = Nelumba::Activity.new
+      activity.stubs(:save)
+
+      feed.items << activity
+
+      feed.expects(:save)
+      feed.delete! activity
+    end
+  end
+
+  describe "#merge!" do
+    it "should update base attributes" do
+      feed = Nelumba::Feed.new
+      feed.stubs(:save)
+      feed.stubs(:save!)
+
+      nelumba_feed = Nelumba::Feed.new
+      nelumba_feed.stubs(:authors).returns([])
+      nelumba_feed.stubs(:contributors).returns([])
+      nelumba_feed.stubs(:items).returns([])
+      nelumba_feed.stubs(:to_hash).returns({:rights => "NEW RIGHTS",
+                                          :url => "NEW URL",
+                                          :subtitle => "NEW SUBTITLE"})
+
+      feed.merge! nelumba_feed
+
+      feed.subtitle.must_equal "NEW SUBTITLE"
+    end
+  end
+
+  describe "#ordered" do
+    it "should return a query for the items in descending order" do
+      feed = Nelumba::Feed.new
+      feed.stubs(:save)
+      feed.items_ids = ["id1", "id2"]
+
+      query = stub('Plucky')
+      query.expects(:order)
+        .with(has_entry(:published, :desc))
+        .returns("ordered")
+
+      Nelumba::Activity
+        .expects(:where)
+        .with(has_entry(:id, ["id1", "id2"]))
+        .returns(query)
+
+      feed.ordered.must_equal "ordered"
+    end
+  end
+
+  describe "#follow!" do
+    it "should add the given feed to the following list" do
+      aggregate = Nelumba::Feed.new
+      aggregate.stubs(:save)
+
+      feed = Nelumba::Feed.new
+      feed.stubs(:save)
+
+      aggregate.follow! feed
+
+      aggregate.following_ids.must_include feed.id
+    end
+
+    it "should save" do
+      aggregate = Nelumba::Feed.new
+      feed = Nelumba::Feed.new
+      feed.stubs(:save)
+
+      aggregate.expects(:save)
+
+      aggregate.follow! feed
+    end
+  end
+
+  describe "#unfollow!" do
+    it "should remove the given feed from the following list" do
+      aggregate = Nelumba::Feed.new
+      aggregate.stubs(:save)
+
+      feed = Nelumba::Feed.new
+      feed.stubs(:save)
+
+      aggregate.unfollow! feed
+
+      aggregate.following_ids.wont_include feed.id
+    end
+
+    it "should save" do
+      aggregate = Nelumba::Feed.new
+      feed = Nelumba::Feed.new
+      feed.stubs(:save)
+
+      aggregate.expects(:save)
+
+      aggregate.unfollow! feed
+    end
+  end
+
+  describe "#followed_by!" do
+    it "should add the given feed to the followers list" do
+      aggregate = Nelumba::Feed.new
+      aggregate.stubs(:save)
+
+      feed = Nelumba::Feed.new
+      feed.stubs(:save)
+
+      aggregate.followed_by! feed
+
+      aggregate.followers_ids.must_include feed.id
+    end
+
+    it "should save" do
+      aggregate = Nelumba::Feed.new
+      feed = Nelumba::Feed.new
+      feed.stubs(:save)
+
+      aggregate.expects(:save)
+
+      aggregate.followed_by! feed
+    end
+  end
+
+  describe "#unfollowed_by!" do
+    it "should remove the given feed from the followers list" do
+      aggregate = Nelumba::Feed.new
+      aggregate.stubs(:save)
+
+      feed = Nelumba::Feed.new
+      feed.stubs(:save)
+
+      aggregate.unfollowed_by! feed
+
+      aggregate.followers_ids.wont_include feed.id
+    end
+
+    it "should save" do
+      aggregate = Nelumba::Feed.new
+      feed = Nelumba::Feed.new
+      feed.stubs(:save)
+
+      aggregate.expects(:save)
+
+      aggregate.unfollowed_by! feed
+    end
+  end
+
+  describe "#publish" do
+    it "should repost in every feed that follows this aggregate" do
+      activity = Nelumba::Activity.new
+
+      aggregate = Nelumba::Feed.new
+      feeds = [Nelumba::Feed.new, Nelumba::Feed.new, Nelumba::Feed.new]
+
+      feeds.each do |f|
+        f.expects(:repost!).with(activity)
+      end
+
+      aggregate.stubs(:followers).returns(feeds)
+      aggregate.publish activity
+    end
+  end
+end