nelumba 0.0.13

data/spec/link_spec.rb

@@ -0,0 +1,30 @@
+require_relative 'helper'
+require_relative '../lib/nelumba/link.rb'
+
+describe Nelumba::Link do
+  describe "#initialize" do
+    it "should store an href" do
+      Nelumba::Link.new(:href => "object").href.must_equal "object"
+    end
+
+    it "should store an type" do
+      Nelumba::Link.new(:type => "html").type.must_equal "html"
+    end
+
+    it "should store a hreflang" do
+      Nelumba::Link.new(:hreflang => :follow).hreflang.must_equal :follow
+    end
+
+    it "should store a title" do
+      Nelumba::Link.new(:title => "Title").title.must_equal "Title"
+    end
+
+    it "should store a rel" do
+      Nelumba::Link.new(:rel => "alternate").rel.must_equal "alternate"
+    end
+
+    it "should store a length" do
+      Nelumba::Link.new(:length => 12345).length.must_equal 12345
+    end
+  end
+end

data/spec/note_spec.rb

@@ -0,0 +1,163 @@
+require_relative 'helper'
+require_relative '../lib/nelumba/note.rb'
+
+describe Nelumba::Note do
+  describe "#initialize" do
+    it "should store a title" do
+      Nelumba::Note.new(:title => "My Title").title.must_equal "My Title"
+    end
+
+    it "should store an author" do
+      author = mock('author')
+      Nelumba::Note.new(:author => author).author.must_equal author
+    end
+
+    it "should store text" do
+      Nelumba::Note.new(:text => "Hello").text.must_equal "Hello"
+    end
+
+    it "should store html" do
+      Nelumba::Note.new(:html => "txt").html.must_equal "txt"
+    end
+
+    it "should store the published date" do
+      time = mock('date')
+      Nelumba::Note.new(:published => time).published.must_equal time
+    end
+
+    it "should store the updated date" do
+      time = mock('date')
+      Nelumba::Note.new(:updated => time).updated.must_equal time
+    end
+
+    it "should store a summary" do
+      Nelumba::Note.new(:summary => "url").summary.must_equal "url"
+    end
+
+    it "should store a display name" do
+      Nelumba::Note.new(:display_name => "url")
+                 .display_name.must_equal "url"
+    end
+
+    it "should store a url" do
+      Nelumba::Note.new(:url => "url").url.must_equal "url"
+    end
+
+    it "should store an id" do
+      Nelumba::Note.new(:uid => "id").uid.must_equal "id"
+    end
+
+    it "should default the text to '' if not given" do
+      Nelumba::Note.new.text.must_equal ''
+    end
+
+    it "should default the title to 'Untitled' if not given" do
+      Nelumba::Note.new.title.must_equal "Untitled"
+    end
+  end
+
+  describe "#to_hash" do
+    it "should contain the text" do
+      Nelumba::Note.new(:text => "Hello").to_hash[:text].must_equal "Hello"
+    end
+
+    it "should contain the html" do
+      Nelumba::Note.new(:html => "Hello").to_hash[:html].must_equal "Hello"
+    end
+
+    it "should contain the title" do
+      Nelumba::Note.new(:title => "Hello").to_hash[:title].must_equal "Hello"
+    end
+
+    it "should contain the author" do
+      author = mock('Nelumba::Person')
+      Nelumba::Note.new(:author => author).to_hash[:author].must_equal author
+    end
+
+    it "should contain the uid" do
+      Nelumba::Note.new(:uid => "Hello").to_hash[:uid].must_equal "Hello"
+    end
+
+    it "should contain the url" do
+      Nelumba::Note.new(:url => "Hello").to_hash[:url].must_equal "Hello"
+    end
+
+    it "should contain the summary" do
+      Nelumba::Note.new(:summary => "Hello")
+                 .to_hash[:summary].must_equal "Hello"
+    end
+
+    it "should contain the display name" do
+      Nelumba::Note.new(:display_name => "Hello")
+                 .to_hash[:display_name].must_equal "Hello"
+    end
+
+    it "should contain the published date" do
+      date = mock('Time')
+      Nelumba::Note.new(:published => date).to_hash[:published].must_equal date
+    end
+
+    it "should contain the updated date" do
+      date = mock('Time')
+      Nelumba::Note.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::Note.new :text         => "Hello",
+                              :author       => author,
+                              :uid          => "id",
+                              :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 'note' objectType" do
+      @data["objectType"].must_equal "note"
+    end
+
+    it "should contain the id" do
+      @data["id"].must_equal @note.uid
+    end
+
+    it "should contain the content as the html" do
+      @data["content"].must_equal @note.html
+    end
+
+    it "should contain the title" do
+      @data["title"].must_equal @note.title
+    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/notification_spec.rb

@@ -0,0 +1,89 @@
+require_relative 'helper'
+require_relative '../lib/nelumba/notification.rb'
+
+describe Nelumba::Notification do
+  describe "from_xml" do
+    it "should return nil if source is empty string" do
+      Nelumba::Notification.from_xml("").must_equal(nil)
+    end
+
+    it "should return nil if source is nil" do
+      Nelumba::Notification.from_xml(nil).must_equal(nil)
+    end
+  end
+
+  describe "from_data" do
+    it "should relegate for xml mime types" do
+      Nelumba::Notification.expects(:from_xml).times(5)
+      Nelumba::Notification.from_data("content", "xml")
+      Nelumba::Notification.from_data("content", "magic-envelope+xml")
+      Nelumba::Notification.from_data("content", "application/xml")
+      Nelumba::Notification.from_data("content", "application/text+xml")
+      Nelumba::Notification.from_data("content", "application/magic-envelope+xml")
+    end
+
+    it "should relegate for json mime types" do
+      Nelumba::Notification.expects(:from_json).times(5)
+      Nelumba::Notification.from_data("content", "json")
+      Nelumba::Notification.from_data("content", "magic-envelope+json")
+      Nelumba::Notification.from_data("content", "application/json")
+      Nelumba::Notification.from_data("content", "application/text+json")
+      Nelumba::Notification.from_data("content", "application/magic-envelope+json")
+    end
+  end
+
+  describe "from_unfollow" do
+    before do
+      @user   = Nelumba::Person.new(:name => "wilkie")
+      @follow = Nelumba::Person.new(:name => "wilkie")
+      @salmon = Nelumba::Notification.from_unfollow(@user, @follow)
+    end
+
+    it "should create a new Notification representing the given user author" do
+      @salmon.activity.actor.must_equal @user
+    end
+
+    it "should create a new Notification representing the given user author" do
+      @salmon.activity.object.must_equal @follow
+    end
+  end
+
+  describe "from_follow" do
+    before do
+      @user   = Nelumba::Person.new(:name => "wilkie")
+      @follow = Nelumba::Person.new(:name => "wilkie")
+      @salmon = Nelumba::Notification.from_follow(@user, @follow)
+    end
+
+    it "should create a new Notification representing the given user author" do
+      @salmon.activity.actor.must_equal @user
+    end
+
+    it "should create a new Notification representing the given user author" do
+      @salmon.activity.object.must_equal @follow
+    end
+  end
+
+  describe "from_profile_update" do
+    before do
+      @user   = Nelumba::Person.new(:name => "wilkie")
+      @salmon = Nelumba::Notification.from_profile_update(@user)
+    end
+
+    it "should create a new Notification representing the given user author" do
+      @salmon.activity.actor.must_equal @user
+    end
+  end
+
+  describe "account" do
+    before do
+      @user   = Nelumba::Person.new(:name => "wilkie", :uri => "acct:wilkie@rstat.us")
+      @follow = Nelumba::Person.new(:name => "wilkie")
+      @salmon = Nelumba::Notification.from_follow(@user, @follow)
+    end
+
+    it "should provide the uri of the actor when the uri is an account" do
+      @salmon.account.must_equal @salmon.activity.actor.uri
+    end
+  end
+end

data/spec/person_spec.rb

@@ -0,0 +1,244 @@
+require_relative 'helper'
+require_relative '../lib/nelumba/person.rb'
+
+describe Nelumba::Person do
+  describe "#initialize" do
+    it "should store an uri" do
+      Nelumba::Person.new(:uri => "http://example.com/1").uri.must_equal "http://example.com/1"
+    end
+
+    it "should store a name" do
+      Nelumba::Person.new(:name => "foo").name.must_equal "foo"
+    end
+
+    it "should store a email" do
+      Nelumba::Person.new(:email => "foo@example.com").email.must_equal "foo@example.com"
+    end
+
+    it "should store a id" do
+      Nelumba::Person.new(:uid => "1").uid.must_equal "1"
+    end
+
+    it "should store a gender" do
+      Nelumba::Person.new(:gender => "androgynous").gender.must_equal "androgynous"
+    end
+
+    it "should store nickname" do
+      Nelumba::Person.new(:nickname => "foobar").nickname.must_equal "foobar"
+    end
+
+    it "should store the display name" do
+      Nelumba::Person.new(:display_name => "foobar").display_name.must_equal "foobar"
+    end
+
+    it "should store the preferred username" do
+      Nelumba::Person.new(:preferred_username => "foobar")
+        .preferred_username.must_equal "foobar"
+    end
+
+    it "should store the pronoun" do
+      pronoun = mock('hash')
+      Nelumba::Person.new(:pronoun => pronoun).pronoun.must_equal pronoun
+    end
+
+    it "should store the birthday" do
+      time = mock('datetime')
+      Nelumba::Person.new(:birthday => time).birthday.must_equal time
+    end
+
+    it "should store the anniversary" do
+      time = mock('datetime')
+      Nelumba::Person.new(:anniversary => time).anniversary.must_equal time
+    end
+
+    it "should store the note" do
+      Nelumba::Person.new(:note => "note").note.must_equal "note"
+    end
+
+    it "should store the published date" do
+      time = mock('datetime')
+      Nelumba::Person.new(:published => time).published.must_equal time
+    end
+
+    it "should store the updated date" do
+      time = mock('datetime')
+      Nelumba::Person.new(:updated => time).updated.must_equal time
+    end
+
+    it "should store an address hash" do
+      address = mock('hash')
+      Nelumba::Person.new(:address => address).address.must_equal address
+    end
+
+    it "should store an organization hash" do
+      organization = mock('hash')
+      Nelumba::Person.new(:organization => organization).organization.must_equal organization
+    end
+
+    it "should store an extended name hash" do
+      name = mock('hash')
+      Nelumba::Person.new(:extended_name => name).extended_name.must_equal name
+    end
+
+    it "should store an account hash" do
+      account = mock('hash')
+      Nelumba::Person.new(:account => account).account.must_equal account
+    end
+  end
+
+  describe "#to_hash" do
+    it "should return a Hash containing the uid" do
+      Nelumba::Person.new(:uid => "1").to_hash[:uid].must_equal "1"
+    end
+
+    it "should return a Hash containing the gender" do
+      Nelumba::Person.new(:gender => "androgynous").to_hash[:gender].must_equal "androgynous"
+    end
+
+    it "should return a Hash containing nickname" do
+      Nelumba::Person.new(:nickname => "foobar").to_hash[:nickname].must_equal "foobar"
+    end
+
+    it "should return a Hash containing the display name" do
+      Nelumba::Person.new(:display_name => "foobar").display_name.must_equal "foobar"
+    end
+
+    it "should return a Hash containing the preferred username" do
+      Nelumba::Person.new(:preferred_username => "foobar")
+        .preferred_username.must_equal "foobar"
+    end
+
+    it "should return a Hash containing the preferred username" do
+      pronoun = mock('hash')
+      Nelumba::Person.new(:pronoun => pronoun).to_hash[:pronoun].must_equal pronoun
+    end
+
+    it "should return a Hash containing the birthday" do
+      time = mock('datetime')
+      Nelumba::Person.new(:birthday => time).to_hash[:birthday].must_equal time
+    end
+
+    it "should return a Hash containing the anniversary" do
+      time = mock('datetime')
+      Nelumba::Person.new(:anniversary => time).to_hash[:anniversary].must_equal time
+    end
+
+    it "should return a Hash containing the note" do
+      Nelumba::Person.new(:note => "note").to_hash[:note].must_equal "note"
+    end
+
+    it "should return a Hash containing the published date" do
+      time = mock('datetime')
+      Nelumba::Person.new(:published => time).to_hash[:published].must_equal time
+    end
+
+    it "should return a Hash containing the updated date" do
+      time = mock('datetime')
+      Nelumba::Person.new(:updated => time).to_hash[:updated].must_equal time
+    end
+
+    it "should return a Hash containing the address hash" do
+      address = mock('hash')
+      Nelumba::Person.new(:address => address).to_hash[:address].must_equal address
+    end
+
+    it "should return a Hash containing the organization hash" do
+      organization = mock('hash')
+      Nelumba::Person.new(:organization => organization).to_hash[:organization].must_equal organization
+    end
+
+    it "should return a Hash containing the extended name hash" do
+      name = mock('hash')
+      Nelumba::Person.new(:extended_name => name).to_hash[:extended_name].must_equal name
+    end
+
+    it "should return a Hash containing the account hash" do
+      account = mock('hash')
+      Nelumba::Person.new(:account => account).to_hash[:account].must_equal account
+    end
+  end
+
+  describe "#preferred_display_name" do
+    it "should use display_name over all else" do
+      author = Nelumba::Person.new(:display_name       => "display",
+                                   :name               => "name",
+                                   :preferred_username => "preferred",
+                                   :nickname           => "nickname",
+                                   :uid                => "unique")
+
+      author.preferred_display_name.must_equal "display"
+    end
+
+    it "should use name over all else when display name doesn't exist" do
+      author = Nelumba::Person.new(:name               => "name",
+                                   :preferred_username => "preferred",
+                                   :nickname           => "nickname",
+                                   :uid                => "unique")
+
+      author.preferred_display_name.must_equal "name"
+    end
+
+    it "should use preferred_username when name and display_name don't exist" do
+      author = Nelumba::Person.new(:preferred_username => "preferred",
+                                   :nickname           => "nickname",
+                                   :uid                => "unique")
+
+      author.preferred_display_name.must_equal "preferred"
+    end
+
+    it "should use nickname when it exists and others do not" do
+      author = Nelumba::Person.new(:nickname => "nickname",
+                                   :uid      => "unique")
+
+      author.preferred_display_name.must_equal "nickname"
+    end
+
+    it "should use uid when all else fails" do
+      author = Nelumba::Person.new(:uid => "unique")
+
+      author.preferred_display_name.must_equal "unique"
+    end
+  end
+
+  describe "#preferred_short_name" do
+    it "should use preferred_username over all else" do
+      author = Nelumba::Person.new(:display_name       => "display",
+                                   :name               => "name",
+                                   :preferred_username => "preferred",
+                                   :nickname           => "nickname",
+                                   :uid                => "unique")
+
+      author.preferred_short_name.must_equal "preferred"
+    end
+
+    it "should use nickname over all else when preferred_username name doesn't exist" do
+      author = Nelumba::Person.new(:name         => "name",
+                                   :display_name => "display",
+                                   :nickname     => "nickname",
+                                   :uid          => "unique")
+
+      author.preferred_short_name.must_equal "nickname"
+    end
+
+    it "should use display_name when nickname and preferred_username don't exist" do
+      author = Nelumba::Person.new(:name         => "name",
+                                   :display_name => "display",
+                                   :uid          => "unique")
+
+      author.preferred_short_name.must_equal "display"
+    end
+
+    it "should use name when it exists and others do not" do
+      author = Nelumba::Person.new(:name => "name",
+                                   :uid  => "unique")
+
+      author.preferred_short_name.must_equal "name"
+    end
+
+    it "should use uid when all else fails" do
+      author = Nelumba::Person.new(:uid => "unique")
+
+      author.preferred_short_name.must_equal "unique"
+    end
+  end
+end