nelumba-mongodb 0.0.1

data/lib/nelumba-mongodb/version.rb

@@ -0,0 +1,3 @@
+module Nelumba
+  MONGODB_VERSION = "0.0.1"
+end

data/nelumba-mongodb.gemspec

@@ -0,0 +1,26 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'nelumba-mongodb/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = "nelumba-mongodb"
+  gem.version       = Nelumba::MONGODB_VERSION
+  gem.authors       = ["wilkie"]
+  gem.email         = ["wilkie@xomb.com"]
+  gem.description   = %q{A persistence layer for nelumba.}
+  gem.summary       = %q{A persistence layer for nelumba.}
+  gem.homepage      = "https://github.com/hotsh/nelumba-mongodb"
+
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ["lib"]
+
+  #gem.add_dependency "nelumba"
+  gem.add_dependency "redcarpet"    # Markdown renderer
+  gem.add_dependency "bson_ext"     # Database
+  gem.add_dependency "mongo_mapper" # Database
+  gem.add_dependency "bcrypt-ruby"  # Basic Authentication
+  gem.add_dependency "rmagick"      # Used for avatar resizing
+end

data/spec/activity_spec.rb

@@ -0,0 +1,337 @@
+require_relative 'helper'
+
+describe Nelumba::Activity do
+  describe "Schema" do
+    it "should have a feed_id" do
+      Nelumba::Activity.keys.keys.must_include "feed_id"
+    end
+
+    it "should have a uid" do
+      Nelumba::Activity.keys.keys.must_include "uid"
+    end
+
+    it "should have a url" do
+      Nelumba::Activity.keys.keys.must_include "url"
+    end
+
+    it "should have a type" do
+      Nelumba::Activity.keys.keys.must_include "type"
+    end
+
+    it "should have an actor_id" do
+      Nelumba::Activity.keys.keys.must_include "actor_id"
+    end
+
+    it "should have an actor_type" do
+      Nelumba::Activity.keys.keys.must_include "actor_type"
+    end
+
+    it "should have a target_id" do
+      Nelumba::Activity.keys.keys.must_include "target_id"
+    end
+
+    it "should have a target_type" do
+      Nelumba::Activity.keys.keys.must_include "target_type"
+    end
+
+    it "should have an external_object_id" do
+      Nelumba::Activity.keys.keys.must_include "external_object_id"
+    end
+
+    it "should have an external_object_type" do
+      Nelumba::Activity.keys.keys.must_include "external_object_type"
+    end
+
+    it "should have a title" do
+      Nelumba::Activity.keys.keys.must_include "title"
+    end
+
+    it "should have a content" do
+      Nelumba::Activity.keys.keys.must_include "content"
+    end
+
+    it "should have a source" do
+      Nelumba::Activity.keys.keys.must_include "source"
+    end
+
+    it "should have an in_reply_to_ids" do
+      Nelumba::Activity.keys.keys.must_include "in_reply_to_ids"
+    end
+
+    it "should have an replies_ids" do
+      Nelumba::Activity.keys.keys.must_include "replies_ids"
+    end
+
+    it "should have an shares_ids" do
+      Nelumba::Activity.keys.keys.must_include "shares_ids"
+    end
+
+    it "should have an mentions_ids" do
+      Nelumba::Activity.keys.keys.must_include "mentions_ids"
+    end
+
+    it "should have an likes_ids" do
+      Nelumba::Activity.keys.keys.must_include "likes_ids"
+    end
+
+    it "should have a published" do
+      Nelumba::Activity.keys.keys.must_include "published"
+    end
+
+    it "should have a updated" do
+      Nelumba::Activity.keys.keys.must_include "updated"
+    end
+  end
+
+  describe "create!" do
+    it "should assign default uid" do
+      activity = Nelumba::Activity.new
+      activity.run_callbacks :create
+
+      activity.uid.must_equal "/activities/#{activity.id}"
+    end
+
+    it "should assign default url" do
+      activity = Nelumba::Activity.new
+      activity.run_callbacks :create
+
+      activity.url.must_equal "/activities/#{activity.id}"
+    end
+  end
+
+  describe "#actor=" do
+    it "should assign actor_id to the id of a given Nelumba::Person" do
+      activity = Nelumba::Activity.new
+      actor = Nelumba::Person.new
+
+      activity.actor = actor
+
+      activity.actor_id.must_equal actor.id
+    end
+
+    it "should assign actor_id to the id of a given Nelumba::Activity" do
+      activity = Nelumba::Activity.new
+      actor = Nelumba::Activity.new
+
+      activity.actor = actor
+
+      activity.actor_id.must_equal actor.id
+    end
+
+    it "should assign actor_type appropriately for a given Nelumba::Person" do
+      activity = Nelumba::Activity.new
+      actor = Nelumba::Person.new
+
+      activity.actor = actor
+
+      activity.actor_type.must_equal "Person"
+    end
+
+    it "should assign actor_type appropriately for a given Nelumba::Activity" do
+      activity = Nelumba::Activity.new
+      actor = Nelumba::Activity.new
+
+      activity.actor = actor
+
+      activity.actor_type.must_equal "Activity"
+    end
+
+    it "should return the given object instead of querying the database" do
+      activity = Nelumba::Activity.new
+      actor = Nelumba::Activity.new
+
+      activity.actor = actor
+
+      activity.actor.id.must_equal actor.id
+    end
+  end
+
+  describe "#actor" do
+    it "should retrieve a stored Nelumba::Person" do
+      actor = Nelumba::Person.create
+      activity = Nelumba::Activity.new(:actor_id => actor.id,
+                                       :actor_type => "Person")
+
+      activity.actor.id.must_equal actor.id
+      activity.actor.class.must_equal Nelumba::Person
+    end
+
+    it "should retrieve a stored Nelumba::Activity" do
+      actor = Nelumba::Activity.create
+      activity = Nelumba::Activity.new(:actor_id => actor.id,
+                                       :actor_type => "Activity")
+
+      activity.actor.id.must_equal actor.id
+      activity.actor.class.must_equal Nelumba::Activity
+    end
+  end
+
+  describe "find_or_create_by_uid!" do
+    it "should return the existing Nelumba::Activity" do
+      activity = Nelumba::Activity.create!(:uid => "UID",
+                                           :url => "URL")
+
+      Nelumba::Activity.find_or_create_by_uid!(:uid => "UID").uid.must_equal activity.uid
+    end
+
+    it "should return the existing Nelumba::Activity via Nelumba::Activity" do
+      activity = Nelumba::Activity.create!(:uid => "UID",
+                                           :url => "URL")
+
+      nelumba_activity = Nelumba::Activity.new(:uid => "UID")
+
+      Nelumba::Activity.find_or_create_by_uid!(nelumba_activity).uid.must_equal activity.uid
+    end
+
+    it "should create when the Nelumba::Activity is not found" do
+      Nelumba::Activity.expects(:create!).with({:uid => "UID"})
+      Nelumba::Activity.find_or_create_by_uid!(:uid => "UID")
+    end
+
+    it "should save the given Nelumba::Activity when not found" do
+      nelumba_activity = Nelumba::Activity.new
+      nelumba_activity.stubs(:id).returns("UID")
+
+      nelumba_activity.expects(:save)
+      Nelumba::Activity.find_or_create_by_uid!(nelumba_activity)
+    end
+
+    it "should create a Nelumba::Activity from a hash when not found" do
+      hash = {:uid => "UID"}
+
+      Nelumba::Activity.expects(:create!).with(hash)
+      Nelumba::Activity.find_or_create_by_uid!(hash)
+    end
+
+    it "should account for race condition where entry was created after find" do
+      Nelumba::Activity.stubs(:first).returns(nil).then.returns("activity")
+      Nelumba::Activity.stubs(:create!).raises("")
+      Nelumba::Activity.find_or_create_by_uid!(:uid => "UID").must_equal "activity"
+    end
+
+    it "should save the attached author found in the given hash" do
+      author_hash = {:uid => "PERSON_UID"}
+      hash = {:uid => "UID", :author => author_hash}
+
+      Nelumba::Person.expects(:find_or_create_by_uid!).with(author_hash)
+      Nelumba::Activity.find_or_create_by_uid!(hash)
+    end
+  end
+
+  describe "discover!" do
+    it "should call out to Nelumba to discover the given Nelumba::Activity" do
+      Nelumba::Discover.expects(:activity).with("activity_url")
+      Nelumba::Activity.discover!("activity_url")
+    end
+
+    it "should return false when the Nelumba::Activity cannot be discovered" do
+      Nelumba::Discover.stubs(:activity).returns(false)
+      Nelumba::Activity.discover!("activity_url").must_equal false
+    end
+
+    it "should return the existing Nelumba::Activity if it is found by url" do
+      activity = Nelumba::Activity.create!(:url => "activity_url",
+                                  :uid => "uid")
+      Nelumba::Activity.discover!("activity_url").id.must_equal activity.id
+    end
+
+    it "should return the existing Nelumba::Activity if uid matches" do
+      activity = Nelumba::Activity.create!(:url => "activity_url",
+                                         :uid => "ID")
+
+      nelumba_activity = Nelumba::Activity.new(:uid => "ID")
+
+      Nelumba::Discover.stubs(:activity).returns(nelumba_activity)
+      Nelumba::Activity.discover!("alternative_url").uid.must_equal activity.uid
+    end
+
+    it "should create a new Nelumba::Activity from the discovered Nelumba::Activity" do
+      nelumba_activity = Nelumba::Activity.new
+      nelumba_activity.stubs(:id).returns("ID")
+
+      Nelumba::Discover.stubs(:activity).returns(nelumba_activity)
+      Nelumba::Activity.expects(:create!).returns("new_activity")
+      Nelumba::Activity.discover!("alternative_url")
+    end
+
+    it "should return the new Nelumba::Activity from the discovered Nelumba::Activity" do
+      nelumba_activity = Nelumba::Activity.new
+      nelumba_activity.stubs(:id).returns("ID")
+
+      Nelumba::Discover.stubs(:activity).returns(nelumba_activity)
+      Nelumba::Activity.stubs(:create!).returns("new_activity")
+      Nelumba::Activity.discover!("alternative_url").must_equal "new_activity"
+    end
+  end
+
+  describe "create_from_notification!" do
+    before do
+      activity_author = Nelumba::Person.create :url => "acct:wilkie@rstat.us",
+                                             :uid => "AUTHOR ID"
+
+      activity = Nelumba::Activity.new :verb  => :follow,
+                                     :uid   => "1",
+                                     :title => "New Title",
+                                     :url   => "foo",
+                                     :actor => activity_author
+
+      @notification = mock('Nelumba::Notification')
+      @notification.stubs(:activity).returns(activity)
+      @notification.stubs(:account).returns("acct:wilkie@rstat.us")
+      @notification.stubs(:verified?).returns(true)
+
+      Nelumba::Person.stubs(:find_or_create_by_uid!).returns(activity_author)
+      Nelumba::Person.stubs(:find_by_id).returns(activity_author)
+
+      @identity = Nelumba::Identity.new
+      @identity.stubs(:return_or_discover_public_key).returns("RSA_PUBLIC_KEY")
+      @identity.stubs(:discover_person!)
+      @identity.stubs(:author).returns(activity_author)
+
+      Nelumba::Identity.stubs(:discover!).with("acct:wilkie@rstat.us").returns(@identity)
+    end
+
+    it "should verify the content" do
+      @notification.expects(:verified?).with("RSA_PUBLIC_KEY").returns(true)
+
+      Nelumba::Activity.create_from_notification! @notification
+    end
+
+    it "should discover the account that sent the salmon" do
+      Nelumba::Identity.expects(:discover!).with(@notification.account).returns(@identity)
+
+      Nelumba::Activity.create_from_notification! @notification
+    end
+
+    it "should return nil when the payload is not verified" do
+      @notification.stubs(:verified?).returns(false)
+      Nelumba::Activity.create_from_notification!(@notification).must_equal nil
+    end
+
+    it "should return the new activity" do
+      Nelumba::Activity.create_from_notification!(@notification)
+              .class.must_equal Nelumba::Activity
+    end
+
+    it "should return the old activity when already exists" do
+      old = Nelumba::Activity.create_from_notification!(@notification)
+      Nelumba::Activity.create_from_notification!(@notification).must_equal old
+    end
+
+    it "should return nil if the update exists under a different author" do
+      old = Nelumba::Activity.create_from_notification!(@notification)
+
+      activity_author = Nelumba::Person.create :url => "acct:bogus@rstat.us",
+                                               :uid => "AUTHOR ID"
+      activity = Nelumba::Activity.new :verb  => :follow,
+                                       :uid   => "1",
+                                       :title => "New Title",
+                                       :url   => "foo",
+                                       :actor => activity_author
+
+      @notification.stubs(:activity).returns(activity)
+
+      Nelumba::Activity.create_from_notification!(@notification).must_equal nil
+    end
+  end
+end

data/spec/article_spec.rb

@@ -0,0 +1,71 @@
+require_relative 'helper'
+
+describe Nelumba::Article do
+  describe "Schema" do
+    it "should have a title" do
+      Nelumba::Article.keys.keys.must_include "title"
+    end
+
+    it "should have a content" do
+      Nelumba::Article.keys.keys.must_include "content"
+    end
+
+    it "should have a uid" do
+      Nelumba::Article.keys.keys.must_include "uid"
+    end
+
+    it "should have a url" do
+      Nelumba::Article.keys.keys.must_include "url"
+    end
+
+    it "should have a display_name" do
+      Nelumba::Article.keys.keys.must_include "display_name"
+    end
+
+    it "should have a summary" do
+      Nelumba::Article.keys.keys.must_include "summary"
+    end
+
+    it "should have an image" do
+      Nelumba::Article.keys.keys.must_include "image"
+    end
+
+    it "should have an author_id" do
+      Nelumba::Article.keys.keys.must_include "author_id"
+    end
+
+    it "should have a published" do
+      Nelumba::Article.keys.keys.must_include "published"
+    end
+
+    it "should have a updated" do
+      Nelumba::Article.keys.keys.must_include "updated"
+    end
+  end
+
+  describe "self.find_by_id" do
+    it "should not find a different type of object" do
+      note = Nelumba::Note.new(:content => "foo",
+                             :title   => "bar")
+      activity = Nelumba::Activity.create :object => note
+
+      Nelumba::Article.find_by_id(note.id).must_equal nil
+    end
+
+    it "should not find by BSON id" do
+      article = Nelumba::Article.new(:content => "foo",
+                                   :title   => "bar")
+      activity = Nelumba::Activity.create :object => article
+
+      Nelumba::Article.find_by_id(article.id).must_equal article
+    end
+
+    it "should not find by string id" do
+      article = Nelumba::Article.new(:content => "foo",
+                                   :title   => "bar")
+      activity = Nelumba::Activity.create :object => article
+
+      Nelumba::Article.find_by_id(article.id).must_equal article
+    end
+  end
+end

data/spec/authorization_spec.rb

@@ -0,0 +1,514 @@
+require_relative 'helper'
+
+require 'xml'
+
+module Nelumba
+  BCRYPT_ROUNDS = 1234
+end
+
+def create_authorization(params)
+  params["domain"] ||= "www.example.com"
+
+  Nelumba::Authorization.stubs(:hash_password).returns("hashed")
+
+  keypair = Struct.new(:public_key, :private_key).new("PUBKEY", "PRIVKEY")
+  Nelumba::Crypto.stubs(:new_keypair).returns(keypair)
+
+  authorization = Nelumba::Authorization.new(params)
+
+  authorization
+end
+
+describe Nelumba::Authorization do
+  describe "Schema" do
+    it "should have a person_id" do
+      Nelumba::Authorization.keys.keys.must_include "person_id"
+    end
+
+    it "should have an identity_id" do
+      Nelumba::Authorization.keys.keys.must_include "identity_id"
+    end
+
+    it "should belong to a identity" do
+      Nelumba::Authorization.belongs_to?(:identity).must_equal true
+    end
+
+    it "should have a username" do
+      Nelumba::Authorization.keys.keys.must_include "username"
+    end
+
+    it "should have a private_key" do
+      Nelumba::Authorization.keys.keys.must_include "private_key"
+    end
+
+    it "should have a hashed_password" do
+      Nelumba::Authorization.keys.keys.must_include "hashed_password"
+    end
+
+    it "should have an updated_at" do
+      Nelumba::Authorization.keys.keys.must_include "updated_at"
+    end
+
+    it "should have a created_at" do
+      Nelumba::Authorization.keys.keys.must_include "created_at"
+    end
+
+    it "should not have a password" do
+      Nelumba::Authorization.keys.keys.wont_include "password"
+    end
+  end
+
+  describe "create" do
+    before do
+      Nelumba::Authorization.stubs(:hash_password).returns("hashed")
+
+      keypair = Struct.new(:public_key, :private_key).new("PUBKEY", "PRIVKEY")
+      Nelumba::Crypto.stubs(:new_keypair).returns(keypair)
+    end
+
+    it "should create a person attached to this authorization" do
+      person = Nelumba::Person.new_local "wilkie", "www.example.com", nil, true
+      Nelumba::Person.expects(:new_local).returns(person)
+
+      Nelumba::Authorization.new("username" => "wilkie",
+                               "password" => "foobar",
+                               "domain" => "www.example.com",
+                               "ssl" => true)
+    end
+
+    it "should save the person attached to this authorization" do
+      person = Nelumba::Person.new_local "wilkie", "www.example.com", nil, true
+      Nelumba::Person.stubs(:new_local).returns(person)
+
+      Nelumba::Authorization.new("username" => "wilkie",
+                                 "password" => "foobar",
+                                 "domain"   => "www.example.com",
+                                 "ssl"      => true)
+
+      Nelumba::Person.first(:id => person.id).activities_id.wont_equal nil
+    end
+
+    it "should create a Person with the given username" do
+      person = Nelumba::Person.new_local "wilkie", "www.example.com", nil, true
+      Nelumba::Person.expects(:new_local)
+                     .with("wilkie", anything, anything, anything)
+                     .returns(person)
+
+      Nelumba::Authorization.new("username" => "wilkie",
+                                 "password" => "foobar",
+                                 "domain"   => "www.example.com",
+                                 "ssl"      => true)
+    end
+
+    it "should create a Person with the given domain" do
+      person = Nelumba::Person.new_local "wilkie", "www.example.com", nil, true
+      Nelumba::Person.expects(:new_local)
+                   .with(anything, "www.example.com", anything, anything)
+                   .returns(person)
+
+      Nelumba::Authorization.new("username" => "wilkie",
+                                 "password" => "foobar",
+                                 "domain"   => "www.example.com",
+                                 "ssl"      => true)
+    end
+
+    it "should create a Person with the given ssl requirements" do
+      person = Nelumba::Person.new_local "wilkie", "www.example.com", nil, true
+      Nelumba::Person.expects(:new_local)
+                   .with(anything, anything, anything, true)
+                   .returns(person)
+
+      Nelumba::Authorization.new("username" => "wilkie",
+                                 "password" => "foobar",
+                                 "domain"   => "www.example.com",
+                                 "ssl"      => true)
+    end
+
+    it "should create an Nelumba::Identity" do
+      Nelumba::Identity.expects(:new_local)
+                     .returns(Nelumba::Identity.new)
+
+      Nelumba::Authorization.new("username" => "wilkie",
+                                 "password" => "foobar",
+                                 "domain"   => "www.example.com",
+                                 "ssl"      => true)
+    end
+
+    it "should create an Nelumba::Identity with the generated public key" do
+      Nelumba::Identity.expects(:new_local)
+                     .with(anything, anything, anything, anything, anything, "PUBKEY")
+                     .returns(Nelumba::Identity.new)
+
+      Nelumba::Authorization.new("username" => "wilkie",
+                                 "password" => "foobar",
+                                 "domain"   => "www.example.com",
+                                 "ssl"      => true)
+    end
+
+    it "should create an Nelumba::Identity with the given username" do
+      Nelumba::Identity.expects(:new_local)
+                     .with(anything, "wilkie", anything, anything, anything, anything)
+                     .returns(Nelumba::Identity.new)
+
+      Nelumba::Authorization.new("username" => "wilkie",
+                                 "password" => "foobar",
+                                 "domain"   => "www.example.com",
+                                 "ssl"      => true)
+    end
+
+    it "should create an Nelumba::Identity with the given domain" do
+      Nelumba::Identity.expects(:new_local)
+        .with(anything, anything, "www.example.com", anything, anything, anything)
+        .returns(Nelumba::Identity.new)
+
+      Nelumba::Authorization.new("username" => "wilkie",
+                                 "password" => "foobar",
+                                 "domain"   => "www.example.com",
+                                 "ssl"      => true)
+    end
+
+    it "should create an Nelumba::Identity with the given ssl requirements" do
+      Nelumba::Identity.expects(:new_local)
+                       .with(anything, anything, anything, anything, true, anything)
+                       .returns(Nelumba::Identity.new)
+
+      Nelumba::Authorization.new("username" => "wilkie",
+                                 "password" => "foobar",
+                                 "domain"   => "www.example.com",
+                                 "ssl"      => true)
+    end
+
+    it "should create an Nelumba::Identity with the new person's author" do
+      person = Nelumba::Person.new_local "wilkie", "www.example.com", nil, true
+      Nelumba::Person.stubs(:new_local).returns(person)
+
+      Nelumba::Identity.expects(:new_local)
+                       .with(person, anything, anything, anything, anything, anything)
+                       .returns(Nelumba::Identity.new)
+
+      Nelumba::Authorization.new("username" => "wilkie",
+                                 "password" => "foobar",
+                                 "domain"   => "www.example.com",
+                                 "ssl"      => true)
+    end
+
+    it "should associate a new Nelumba::Identity with this Nelumba::Authorization" do
+      person = Nelumba::Person.new_local "wilkie", "www.example.com", nil, true
+      Nelumba::Person.stubs(:new_local).returns(person)
+
+      auth = Nelumba::Authorization.new("username" => "wilkie",
+                                      "password" => "foobar",
+                                      "domain" => "www.example.com",
+                                      "ssl" => true)
+
+      auth.identity_id.must_equal person.identity.id
+    end
+
+    it "should store the private key" do
+      auth = Nelumba::Authorization.new("username" => "wilkie",
+                                      "password" => "foobar",
+                                      "domain" => "www.example.com",
+                                      "ssl" => true)
+
+      auth.private_key.must_equal "PRIVKEY"
+    end
+  end
+
+  describe "lrdd" do
+    it "returns nil when the username cannot be found" do
+      Nelumba::Authorization.stubs(:find_by_username).returns(nil)
+      Nelumba::Authorization.lrdd("bogus@www.example.com").must_equal nil
+    end
+
+    it "should contain a subject matching their webfinger" do
+      authorization = create_authorization("username" => "wilkie",
+                                           "password" => "foobar")
+      Nelumba::Authorization.stubs(:find_by_username).returns(authorization)
+      Nelumba::Authorization.lrdd("wilkie@www.example.com")[:subject]
+                   .must_equal "acct:wilkie@www.example.com"
+    end
+
+    it "should contain an alias to the profile" do
+      authorization = create_authorization("username" => "wilkie",
+                                           "password" => "foobar")
+      Nelumba::Authorization.stubs(:find_by_username).returns(authorization)
+      Nelumba::Authorization.lrdd("wilkie@www.example.com")[:aliases]
+        .must_include "http://www.example.com/people/#{authorization.person.id}"
+    end
+
+    it "should contain an alias to the profile" do
+      authorization = create_authorization("username" => "wilkie",
+                                           "password" => "foobar")
+      Nelumba::Authorization.stubs(:find_by_username).returns(authorization)
+      Nelumba::Authorization.lrdd("wilkie@www.example.com")[:aliases]
+        .must_include "http://www.example.com/people/#{authorization.person.id}"
+    end
+
+    it "should contain an alias to the feed" do
+      authorization = create_authorization("username" => "wilkie",
+                                           "password" => "foobar")
+      Nelumba::Authorization.stubs(:find_by_username).returns(authorization)
+      Nelumba::Authorization.lrdd("wilkie@www.example.com")[:aliases].must_include(
+        "http://www.example.com/feeds/#{authorization.identity.outbox.id}")
+    end
+
+    it "should contain profile-page link" do
+      authorization = create_authorization("username" => "wilkie",
+                                           "password" => "foobar")
+      person_id = authorization.person.id
+
+      Nelumba::Authorization.stubs(:find_by_username).returns(authorization)
+      Nelumba::Authorization.lrdd("wilkie@www.example.com")[:links]
+        .must_include({:rel  => "http://webfinger.net/rel/profile-page",
+                       :href => "http://www.example.com/people/#{person_id}"})
+    end
+
+    it "should contain updates-from link" do
+      authorization = create_authorization("username" => "wilkie",
+                                           "password" => "foobar")
+      feed_id = authorization.identity.outbox.id
+
+      Nelumba::Authorization.stubs(:find_by_username).returns(authorization)
+      Nelumba::Authorization.lrdd("wilkie@www.example.com")[:links]
+        .must_include({:rel  => "http://schemas.google.com/g/2010#updates-from",
+                       :href => "http://www.example.com/feeds/#{feed_id}"})
+    end
+
+    it "should contain salmon link" do
+      authorization = create_authorization("username" => "wilkie",
+                                           "password" => "foobar")
+      person_id = authorization.person.id
+
+      Nelumba::Authorization.stubs(:find_by_username).returns(authorization)
+      Nelumba::Authorization.lrdd("wilkie@www.example.com")[:links]
+        .must_include(:rel  => "salmon",
+                      :href => "http://www.example.com/people/#{person_id}/salmon")
+    end
+
+    it "should contain salmon-replies link" do
+      authorization = create_authorization("username" => "wilkie",
+                                           "password" => "foobar")
+      person_id = authorization.person.id
+
+      Nelumba::Authorization.stubs(:find_by_username).returns(authorization)
+      Nelumba::Authorization.lrdd("wilkie@www.example.com")[:links]
+        .must_include(:rel  => "http://salmon-protocol.org/ns/salmon-replies",
+                      :href => "http://www.example.com/people/#{person_id}/salmon")
+    end
+
+    it "should contain salmon-mention link" do
+      authorization = create_authorization("username" => "wilkie",
+                                           "password" => "foobar")
+      person_id = authorization.person.id
+
+      Nelumba::Authorization.stubs(:find_by_username).returns(authorization)
+      Nelumba::Authorization.lrdd("wilkie@www.example.com")[:links]
+        .must_include(:rel  => "http://salmon-protocol.org/ns/salmon-mention",
+                      :href => "http://www.example.com/people/#{person_id}/salmon")
+    end
+
+    it "should contain magic-public-key link" do
+      authorization = create_authorization("username" => "wilkie",
+                                           "password" => "foobar")
+      person_id = authorization.person.id
+
+      authorization.identity.public_key = "PUBLIC_KEY"
+
+      Nelumba::Authorization.stubs(:find_by_username).returns(authorization)
+      Nelumba::Authorization.lrdd("wilkie@www.example.com")[:links]
+        .must_include(:rel  => "magic-public-key",
+                      :href => "data:application/magic-public-key,PUBLIC_KEY")
+    end
+
+    it "should contain an expires link that is 1 month away from retrieval" do
+      authorization = create_authorization("username" => "wilkie",
+                                           "password" => "foobar")
+
+      check_date = Date.new(2012, 1, 1)
+      Date.any_instance.expects(:>>).with(1).returns(check_date)
+
+      Nelumba::Authorization.stubs(:find_by_username).returns(authorization)
+      Nelumba::Authorization.lrdd("wilkie@www.example.com")[:expires].must_equal(
+        "#{check_date.xmlschema}Z")
+    end
+  end
+
+  describe "jrd" do
+    it "should simply take the lrdd and run to_json" do
+      lrdd_hash = {}
+      Nelumba::Authorization.stubs(:lrdd).with("wilkie@www.example.com").returns(lrdd_hash)
+      lrdd_hash.stubs(:to_json).returns("JSON")
+
+      Nelumba::Authorization.jrd("wilkie@www.example.com").must_equal "JSON"
+    end
+
+    it "should return nil when lrdd returns nil" do
+      Nelumba::Authorization.stubs(:lrdd).returns(nil)
+      Nelumba::Authorization.jrd("bogus@www.example.com").must_equal nil
+    end
+  end
+
+  describe "xrd" do
+    before do
+      @authorization = create_authorization("username" => "wilkie",
+                                            "password" => "foobar")
+
+      Nelumba::Authorization.stubs(:lrdd).returns(:subject => "Subject",
+                                         :expires => "Date",
+                                         :aliases => ["alias_a",
+                                                      "alias_b"],
+                                         :links   => [
+                                           {:rel  => "a rel",
+                                            :href => "a href"},
+                                           {:rel  => "b rel",
+                                            :href => "b href"}])
+
+      @xrd = Nelumba::Authorization.xrd("wilkie@www.example.com")
+
+      @xml = XML::Parser.string(@xrd).parse
+    end
+
+    it "should return nil when lrdd returns nil" do
+      Nelumba::Authorization.stubs(:lrdd).returns(nil)
+      Nelumba::Authorization.xrd("bogus@www.example.com").must_equal nil
+    end
+
+    it "should publish a version of 1.0" do
+      @xrd.must_match /^<\?xml[^>]*\sversion="1\.0"/
+    end
+
+    it "should encode in utf-8" do
+      @xrd.must_match /^<\?xml[^>]*\sencoding="UTF-8"/
+    end
+
+    it "should contain the XRD namespace" do
+      @xml.root.namespaces
+               .find_by_href('http://docs.oasis-open.org/ns/xri/xrd-1.0').to_s
+               .must_equal 'http://docs.oasis-open.org/ns/xri/xrd-1.0'
+    end
+
+    it "should contain the xsi namespace" do
+      @xml.root.namespaces
+               .find_by_prefix('xsi').to_s
+               .must_equal 'xsi:http://www.w3.org/2001/XMLSchema-instance'
+    end
+
+    it "should contain the <Subject>" do
+      @xml.root.find_first('xmlns:Subject',
+                           'xmlns:http://docs.oasis-open.org/ns/xri/xrd-1.0')
+        .content.must_equal Nelumba::Authorization.lrdd("wilkie@www.example.com")[:subject]
+    end
+
+    it "should contain the <Expires>" do
+      @xml.root.find_first('xmlns:Expires',
+                           'xmlns:http://docs.oasis-open.org/ns/xri/xrd-1.0')
+        .content.must_equal Nelumba::Authorization.lrdd("wilkie@www.example.com")[:expires]
+    end
+
+    it "should contain the <Alias> tags" do
+      aliases = Nelumba::Authorization.lrdd("wilkie@www.example.com")[:aliases]
+      @xml.root.find('xmlns:Alias',
+                  'xmlns:http://docs.oasis-open.org/ns/xri/xrd-1.0').each do |t|
+        index = aliases.index(t.content)
+        index.wont_equal nil
+
+        aliases.delete_at index
+      end
+    end
+
+    it "should contain the <Link> tags" do
+      links = Nelumba::Authorization.lrdd("wilkie@www.example.com")[:links]
+      @xml.root.find('xmlns:Link',
+                  'xmlns:http://docs.oasis-open.org/ns/xri/xrd-1.0').each do |t|
+        link = {:rel  => t.attributes.get_attribute('rel').value,
+                :href => t.attributes.get_attribute('href').value}
+        index = links.index(link)
+        index.wont_equal nil
+
+        links.delete_at index
+      end
+    end
+  end
+
+  describe "hash_password" do
+    it "should call bcrypt with the application specified number of rounds" do
+      BCrypt::Password.expects(:create).with(anything, has_entry(:cost, 1234))
+      Nelumba::Authorization.hash_password("foobar")
+    end
+
+    it "should call bcrypt with the given password" do
+      BCrypt::Password.expects(:create).with("foobar", anything)
+      Nelumba::Authorization.hash_password("foobar")
+    end
+
+    it "should return the hashed password" do
+      BCrypt::Password.expects(:create).returns("hashed!")
+      Nelumba::Authorization.hash_password("foobar").must_equal "hashed!"
+    end
+  end
+
+  describe "#authenticated?" do
+    it "should compare the given password with the stored password" do
+      authorization = create_authorization("username" => "wilkie",
+                                           "password" => "foobar")
+
+      checker = stub('String')
+      BCrypt::Password.stubs(:new).with("hashed").returns(checker)
+
+      checker.expects(:==).with("foobar")
+      authorization.authenticated?("foobar")
+    end
+  end
+
+  describe "sanitize_params" do
+    it "should allow Nelumba::Authorization keys" do
+      hash = {}
+      Nelumba::Authorization.keys.keys.each do |k|
+        next if ["_id"].include? k
+        hash[k] = "foobar"
+      end
+
+      hash = Nelumba::Authorization.sanitize_params(hash)
+
+      Nelumba::Authorization.keys.keys.each do |k|
+        next if ["_id"].include? k
+        hash[k.intern].must_equal "foobar"
+      end
+    end
+
+    it "should remove password key" do
+      hash = {"password" => "foobar"}
+      hash = Nelumba::Authorization.sanitize_params(hash)
+      hash.keys.wont_include :password
+    end
+
+    it "should convert strings to symbols" do
+      hash = {}
+      Nelumba::Authorization.keys.keys.each do |k|
+        next if ["_id"].include? k
+        hash[k] = "foobar"
+      end
+
+      hash = Nelumba::Authorization.sanitize_params(hash)
+
+      Nelumba::Authorization.keys.keys.each do |k|
+        next if ["_id"].include? k
+        hash[k.intern].must_equal "foobar"
+      end
+    end
+
+    it "should not allow _id" do
+      hash = {"_id" => "bogus"}
+      hash = Nelumba::Authorization.sanitize_params(hash)
+      hash.keys.wont_include :_id
+    end
+
+    it "should not allow arbitrary keys" do
+      hash = {:bogus => "foobar"}
+
+      hash = Nelumba::Authorization.sanitize_params(hash)
+
+      hash.keys.wont_include :bogus
+    end
+  end
+end