nelumba 0.0.13

data/spec/bookmark.rb

@@ -0,0 +1,150 @@
+require_relative 'helper'
+require_relative '../lib/nelumba/bookmark.rb'
+
+describe Nelumba::Bookmark do
+  describe "#initialize" do
+    it "should store an author" do
+      author = mock('author')
+      Nelumba::Bookmark.new(:author => author).author.must_equal author
+    end
+
+    it "should store the target url" do
+      Nelumba::Bookmark.new(:target_url => "txt").target_url.must_equal "txt"
+    end
+
+    it "should store content" do
+      Nelumba::Bookmark.new(:content => "txt").content.must_equal "txt"
+    end
+
+    it "should store the published date" do
+      time = mock('date')
+      Nelumba::Bookmark.new(:published => time).published.must_equal time
+    end
+
+    it "should store the updated date" do
+      time = mock('date')
+      Nelumba::Bookmark.new(:updated => time).updated.must_equal time
+    end
+
+    it "should store a display name" do
+      Nelumba::Bookmark.new(:display_name => "url")
+                        .display_name.must_equal "url"
+    end
+
+    it "should store a summary" do
+      Nelumba::Bookmark.new(:summary => "url").summary.must_equal "url"
+    end
+
+    it "should store a url" do
+      Nelumba::Bookmark.new(:url => "url").url.must_equal "url"
+    end
+
+    it "should store an id" do
+      Nelumba::Bookmark.new(:uid => "id").uid.must_equal "id"
+    end
+  end
+
+  describe "#to_hash" do
+    it "should contain the content" do
+      Nelumba::Bookmark.new(:content => "Hello")
+                        .to_hash[:content].must_equal "Hello"
+    end
+
+    it "should contain the author" do
+      author = mock('Nelumba::Person')
+      Nelumba::Bookmark.new(:author => author).to_hash[:author].must_equal author
+    end
+
+    it "should contain the uid" do
+      Nelumba::Bookmark.new(:uid => "Hello").to_hash[:uid].must_equal "Hello"
+    end
+
+    it "should contain the target_url" do
+      Nelumba::Bookmark.new(:target_url => "Hello")
+                     .to_hash[:target_url].must_equal "Hello"
+    end
+
+    it "should contain the url" do
+      Nelumba::Bookmark.new(:url => "Hello").to_hash[:url].must_equal "Hello"
+    end
+
+    it "should contain the summary" do
+      Nelumba::Bookmark.new(:summary=> "Hello")
+                 .to_hash[:summary].must_equal "Hello"
+    end
+
+    it "should contain the display name" do
+      Nelumba::Bookmark.new(:display_name => "Hello")
+                 .to_hash[:display_name].must_equal "Hello"
+    end
+
+    it "should contain the published date" do
+      date = mock('Time')
+      Nelumba::Bookmark.new(:published => date).to_hash[:published].must_equal date
+    end
+
+    it "should contain the updated date" do
+      date = mock('Time')
+      Nelumba::Bookmark.new(:updated => date).to_hash[:updated].must_equal date
+    end
+  end
+
+  describe "#to_json" do
+    before do
+      author = Nelumba::Person.new :display_name => "wilkie"
+      @note = Nelumba::Bookmark.new :content      => "Hello",
+                                  :author       => author,
+                                  :uid          => "id",
+                                  :target_url   => "target",
+                                  :url          => "url",
+                                  :title        => "title",
+                                  :summary      => "foo",
+                                  :display_name => "meh",
+                                  :published    => Time.now,
+                                  :updated      => Time.now
+
+      @json = @note.to_json
+      @data = JSON.parse(@json)
+    end
+
+    it "should contain the embedded json for the author" do
+      @data["author"].must_equal JSON.parse(@note.author.to_json)
+    end
+
+    it "should contain a 'bookmark' objectType" do
+      @data["objectType"].must_equal "bookmark"
+    end
+
+    it "should contain the id" do
+      @data["id"].must_equal @note.uid
+    end
+
+    it "should contain the target url" do
+      @data["targetUrl"].must_equal @note.target_url
+    end
+
+    it "should contain the content" do
+      @data["content"].must_equal @note.content
+    end
+
+    it "should contain the url" do
+      @data["url"].must_equal @note.url
+    end
+
+    it "should contain the summary" do
+      @data["summary"].must_equal @note.summary
+    end
+
+    it "should contain the display name" do
+      @data["displayName"].must_equal @note.display_name
+    end
+
+    it "should contain the published date as rfc3339" do
+      @data["published"].must_equal @note.published.to_date.rfc3339 + 'Z'
+    end
+
+    it "should contain the updated date as rfc3339" do
+      @data["updated"].must_equal @note.updated.to_date.rfc3339 + 'Z'
+    end
+  end
+end

data/spec/collection_spec.rb

@@ -0,0 +1,152 @@
+require_relative 'helper'
+require_relative '../lib/nelumba/collection.rb'
+
+describe Nelumba::Collection do
+  describe "#initialize" do
+    it "should store content" do
+      Nelumba::Collection.new(:content => "foo").content.must_equal "foo"
+    end
+
+    it "should store an author" do
+      author = mock('author')
+      Nelumba::Collection.new(:author => author).author.must_equal author
+    end
+
+    it "should store a summary" do
+      Nelumba::Collection.new(:summary => "url").summary.must_equal "url"
+    end
+
+    it "should store a display name" do
+      Nelumba::Collection.new(:display_name => "url")
+                       .display_name.must_equal "url"
+    end
+
+    it "should store the published date" do
+      time = mock('date')
+      Nelumba::Collection.new(:published => time).published.must_equal time
+    end
+
+    it "should store the updated date" do
+      time = mock('date')
+      Nelumba::Collection.new(:updated => time).updated.must_equal time
+    end
+
+    it "should store a url" do
+      Nelumba::Collection.new(:url => "url").url.must_equal "url"
+    end
+
+    it "should store an id" do
+      Nelumba::Collection.new(:uid => "id").uid.must_equal "id"
+    end
+
+    it "should store an array of items" do
+      Nelumba::Collection.new(:items => ["foo"]).items.must_equal ["foo"]
+    end
+
+    it "should default items to an empty array" do
+      Nelumba::Collection.new.items.must_equal []
+    end
+  end
+
+  describe "#to_hash" do
+    it "should contain the content" do
+      Nelumba::Collection.new(:content => "Hello")
+                       .to_hash[:content].must_equal "Hello"
+    end
+
+    it "should contain the author" do
+      author = mock('Nelumba::Person')
+      Nelumba::Collection.new(:author => author).to_hash[:author].must_equal author
+    end
+
+    it "should contain the uid" do
+      Nelumba::Collection.new(:uid => "Hello").to_hash[:uid].must_equal "Hello"
+    end
+
+    it "should contain the url" do
+      Nelumba::Collection.new(:url => "Hello").to_hash[:url].must_equal "Hello"
+    end
+
+    it "should contain the summary" do
+      Nelumba::Collection.new(:summary => "Hello")
+                       .to_hash[:summary].must_equal "Hello"
+    end
+
+    it "should contain the display name" do
+      Nelumba::Collection.new(:display_name => "Hello")
+                       .to_hash[:display_name].must_equal "Hello"
+    end
+
+    it "should contain the published date" do
+      date = mock('Time')
+      Nelumba::Collection.new(:published => date).to_hash[:published].must_equal date
+    end
+
+    it "should contain the updated date" do
+      date = mock('Time')
+      Nelumba::Collection.new(:updated => date).to_hash[:updated].must_equal date
+    end
+
+    it "should contain the array of items" do
+      Nelumba::Collection.new(:items => ["f"]).to_hash[:items].must_equal ["f"]
+    end
+  end
+
+  describe "#to_json" do
+    before do
+      author = Nelumba::Person.new :display_name => "wilkie"
+      @note = Nelumba::Collection.new :items        => ["Hello"],
+                                    :author       => author,
+                                    :uid          => "id",
+                                    :url          => "url",
+                                    :content      => "content",
+                                    :summary      => "foo",
+                                    :display_name => "meh",
+                                    :published    => Time.now,
+                                    :updated      => Time.now
+
+      @json = @note.to_json
+      @data = JSON.parse(@json)
+    end
+
+    it "should contain the embedded json for the author" do
+      @data["author"].must_equal JSON.parse(@note.author.to_json)
+    end
+
+    it "should contain a 'collection' objectType" do
+      @data["objectType"].must_equal "collection"
+    end
+
+    it "should contain the items" do
+      @data["items"].must_equal JSON.parse(@note.items.to_json)
+    end
+
+    it "should contain the id" do
+      @data["id"].must_equal @note.uid
+    end
+
+    it "should contain the content" do
+      @data["content"].must_equal @note.content
+    end
+
+    it "should contain the url" do
+      @data["url"].must_equal @note.url
+    end
+
+    it "should contain the summary" do
+      @data["summary"].must_equal @note.summary
+    end
+
+    it "should contain the display_name" do
+      @data["displayName"].must_equal @note.display_name
+    end
+
+    it "should contain the published date as rfc3339" do
+      @data["published"].must_equal @note.published.to_date.rfc3339 + 'Z'
+    end
+
+    it "should contain the updated date as rfc3339" do
+      @data["updated"].must_equal @note.updated.to_date.rfc3339 + 'Z'
+    end
+  end
+end

data/spec/comment_spec.rb

@@ -0,0 +1,128 @@
+require_relative 'helper'
+require_relative '../lib/nelumba/comment.rb'
+
+describe Nelumba::Comment do
+  describe "#initialize" do
+    it "should store content" do
+      Nelumba::Comment.new(:content => "foo").content.must_equal "foo"
+    end
+
+    it "should store an author" do
+      author = mock('author')
+      Nelumba::Comment.new(:author => author).author.must_equal author
+    end
+
+    it "should store the display_name" do
+      Nelumba::Comment.new(:display_name => "Hello").display_name.must_equal "Hello"
+    end
+
+    it "should store the published date" do
+      time = mock('date')
+      Nelumba::Comment.new(:published => time).published.must_equal time
+    end
+
+    it "should store the updated date" do
+      time = mock('date')
+      Nelumba::Comment.new(:updated => time).updated.must_equal time
+    end
+
+    it "should store a url" do
+      Nelumba::Comment.new(:url => "url").url.must_equal "url"
+    end
+
+    it "should store an id" do
+      Nelumba::Comment.new(:uid => "id").uid.must_equal "id"
+    end
+  end
+
+  describe "#to_hash" do
+    it "should contain the content" do
+      Nelumba::Comment.new(:content => "Hello").to_hash[:content].must_equal "Hello"
+    end
+
+    it "should contain the author" do
+      author = mock('Nelumba::Person')
+      Nelumba::Comment.new(:author => author).to_hash[:author].must_equal author
+    end
+
+    it "should contain the uid" do
+      Nelumba::Comment.new(:uid => "Hello").to_hash[:uid].must_equal "Hello"
+    end
+
+    it "should contain the url" do
+      Nelumba::Comment.new(:url => "Hello").to_hash[:url].must_equal "Hello"
+    end
+
+    it "should contain the display_name" do
+      Nelumba::Comment.new(:display_name => "Hello")
+                 .to_hash[:display_name].must_equal "Hello"
+    end
+
+    it "should contain the published date" do
+      date = mock('Time')
+      Nelumba::Comment.new(:published => date).to_hash[:published].must_equal date
+    end
+
+    it "should contain the updated date" do
+      date = mock('Time')
+      Nelumba::Comment.new(:updated => date).to_hash[:updated].must_equal date
+    end
+  end
+
+  describe "#to_json" do
+    before do
+      author = Nelumba::Person.new :display_name => "wilkie"
+      @note = Nelumba::Comment.new :content      => "Hello",
+                                 :author       => author,
+                                 :summary      => "foo",
+                                 :display_name => "Foo",
+                                 :uid          => "id",
+                                 :url          => "url",
+                                 :published    => Time.now,
+                                 :updated      => Time.now
+
+      @json = @note.to_json
+      @data = JSON.parse(@json)
+    end
+
+    it "should contain the embedded json for the author" do
+      @data["author"].must_equal JSON.parse(@note.author.to_json)
+    end
+
+    it "should contain a 'comment' objectType" do
+      @data["objectType"].must_equal "comment"
+    end
+
+    it "should contain the id" do
+      @data["id"].must_equal @note.uid
+    end
+
+    it "should contain the content" do
+      @data["content"].must_equal @note.content
+    end
+
+    it "should contain the displayName" do
+      @data["displayName"].must_equal @note.display_name
+    end
+
+    it "should contain the summary" do
+      @data["summary"].must_equal @note.summary
+    end
+
+    it "should contain the display name" do
+      @data["displayName"].must_equal @note.display_name
+    end
+
+    it "should contain the url" do
+      @data["url"].must_equal @note.url
+    end
+
+    it "should contain the published date as rfc3339" do
+      @data["published"].must_equal @note.published.to_date.rfc3339 + 'Z'
+    end
+
+    it "should contain the updated date as rfc3339" do
+      @data["updated"].must_equal @note.updated.to_date.rfc3339 + 'Z'
+    end
+  end
+end

data/spec/crypto_spec.rb

@@ -0,0 +1,126 @@
+require_relative 'helper'
+require_relative '../lib/nelumba/crypto.rb'
+
+describe Nelumba::Crypto do
+  # To make things faster, we can stub key generation:
+  # But we will _actually_ generate one good key for the test run
+  before do
+    $__key ||= RSA::KeyPair.generate(2048)
+    RSA::KeyPair.stubs(:generate).returns($__key)
+  end
+
+  describe "new_keypair" do
+    it "should return a KeyPair structure" do
+      Nelumba::Crypto.new_keypair.class.must_equal Nelumba::Crypto::KeyPair
+    end
+
+    it "should return a KeyPair structure with an RSA public key" do
+      Nelumba::Crypto.new_keypair.public_key.must_match /^RSA\.(.*?)\.(.*)$/
+    end
+
+    it "should return a KeyPair structure with an RSA private key" do
+      Nelumba::Crypto.new_keypair.private_key.must_match /^RSA\.(.*?)\.(.*)$/
+    end
+
+    it "should relegate to RSA::KeyPair" do
+      ret = RSA::KeyPair.generate(4)
+      RSA::KeyPair.expects(:generate).returns(ret)
+
+      Nelumba::Crypto.new_keypair
+    end
+  end
+
+  describe "emsa_sign" do
+    it "should return a string with the EMSA prefix" do
+      keypair = Nelumba::Crypto.new_keypair
+
+      sequence = "^\x00\x01\xFF*?\x00\x30\x31\x30\x0d\x06\x09\x60\x86\x48\x01\x65\x03\x04\x02\x01\x05\x00\x04\x20"
+      matcher = Regexp.new(sequence, nil, 'n')
+
+      RSA::KeyPair.any_instance.expects(:decrypt).with(regexp_matches(matcher))
+
+      Nelumba::Crypto.emsa_sign "payload", keypair.private_key
+    end
+
+    it "should return the result of decryption with the private key" do
+      keypair = Nelumba::Crypto.new_keypair
+
+      # This is a heavily implementation driven test to avoid testing RSA
+
+      Nelumba::Crypto.stubs(:generate_key).with(keypair.private_key).returns("keypair")
+      Nelumba::Crypto.stubs(:emsa_signature).with("payload", "keypair").returns("signature")
+      Nelumba::Crypto.stubs(:decrypt).with("keypair", "signature").returns("DECRYPTED")
+
+      Nelumba::Crypto.emsa_sign("payload", keypair.private_key)
+                     .must_equal "DECRYPTED"
+    end
+
+    it "should end the signature with the SHA2 of the plaintext" do
+      keypair = Nelumba::Crypto.new_keypair
+
+      Digest::SHA2.any_instance.expects(:digest)
+                               .with("payload")
+                               .returns("SHA2")
+
+      matcher = /\x20SHA2$/
+      RSA::KeyPair.any_instance.expects(:decrypt).with(regexp_matches(matcher))
+
+      Nelumba::Crypto.emsa_sign("payload", keypair.private_key)
+    end
+  end
+
+  describe "emsa_verify" do
+    it "should return true when the message matches" do
+      keypair = Nelumba::Crypto.new_keypair
+
+      signature = Nelumba::Crypto.emsa_sign("payload", keypair.private_key)
+
+      Nelumba::Crypto.emsa_verify("payload", signature, keypair.public_key)
+                     .must_equal true
+    end
+
+    it "should return false when the message does not match" do
+      keypair = Nelumba::Crypto.new_keypair
+
+      bogus_signature =
+        "\x00\x01\x00\x30\x31\x30\x0d\x06\x09\x60\x86\x48\x01\x65\x03\x04\x02\x01\x05\x00\x04\x20BOGUS"
+
+      bogus_signature.force_encoding('binary')
+
+      signature = Nelumba::Crypto.emsa_sign("payload", keypair.private_key)
+
+      RSA::KeyPair.any_instance.expects(:encrypt)
+                               .with(signature)
+                               .returns(bogus_signature)
+
+      Nelumba::Crypto.emsa_verify("payload", signature, keypair.public_key)
+                     .must_equal false
+    end
+  end
+
+  describe "decrypt" do
+    it "should relegate to RSA::KeyPair" do
+      keypair = Nelumba::Crypto.new_keypair
+
+      RSA::KeyPair.any_instance.expects(:decrypt)
+                               .with("payload")
+                               .returns("OBSCURED")
+
+      Nelumba::Crypto.decrypt(keypair.private_key, "payload")
+                     .must_equal "OBSCURED"
+    end
+  end
+
+  describe "encrypt" do
+    it "should relegate to RSA::KeyPair" do
+      keypair = Nelumba::Crypto.new_keypair
+
+      RSA::KeyPair.any_instance.expects(:encrypt)
+                               .with("payload")
+                               .returns("OBSCURED")
+
+      Nelumba::Crypto.encrypt(keypair.public_key, "payload")
+                     .must_equal "OBSCURED"
+    end
+  end
+end