roar 1.0.2 → 1.1.1

data/test/hal_json_test.rb

@@ -2,8 +2,8 @@ require 'test_helper'
 require 'roar/json/hal'
 
 class HalJsonTest < MiniTest::Spec
-  let(:rpr) do
-    Module.new do
+  let(:decorator_class) do
+    Class.new(Roar::Decorator) do
       include Roar::JSON
       include Roar::JSON::HAL
 
@@ -18,112 +18,107 @@ class HalJsonTest < MiniTest::Spec
     end
   end
 
-  subject { Object.new.extend(rpr) }
+  subject { decorator_class.new(Object.new) }
 
   describe "links" do
     describe "parsing" do
       it "parses link array" do # TODO: remove me.
         obj = subject.from_json("{\"_links\":{\"self\":[{\"lang\":\"en\",\"href\":\"http://en.hit\"},{\"lang\":\"de\",\"href\":\"http://de.hit\"}]}}")
-        obj.links.must_equal "self" => [link("rel" => "self", "href" => "http://en.hit", "lang" => "en"), link("rel" => "self", "href" => "http://de.hit", "lang" => "de")]
+        subject.links.must_equal "self" => [link("rel" => "self", "href" => "http://en.hit", "lang" => "en"), link("rel" => "self", "href" => "http://de.hit", "lang" => "de")]
       end
 
       it "parses single links" do # TODO: remove me.
         obj = subject.from_json("{\"_links\":{\"next\":{\"href\":\"http://next\"}}}")
-        obj.links.must_equal "next" => link("rel" => "next", "href" => "http://next")
+        subject.links.must_equal "next" => link("rel" => "next", "href" => "http://next")
       end
 
       it "parses link and link array" do
-        obj = subject.from_json("{\"_links\":{\"next\":{\"href\":\"http://next\"}, \"self\":[{\"lang\":\"en\",\"href\":\"http://en.hit\"},{\"lang\":\"de\",\"href\":\"http://de.hit\"}]}}")
-        obj.links.must_equal "next" => link("rel" => "next", "href" => "http://next"), "self" => [link("rel" => "self", "href" => "http://en.hit", "lang" => "en"), link("rel" => "self", "href" => "http://de.hit", "lang" => "de")]
+        obj = subject.from_json(%@{"_links":{"next":{"href":"http://next"}, "self":[{"lang":"en","href":"http://en.hit"},{"lang":"de","href":"http://de.hit"}]}}@)
+        subject._links.must_equal "next"=>link("rel" => "next", "href" => "http://next"), "self"=>[link("rel" => "self", "href" => "http://en.hit", "lang" => "en"), link("rel" => "self", "href" => "http://de.hit", "lang" => "de")]
       end
 
       it "parses empty link array" do
-        subject.from_json("{\"_links\":{\"self\":[]}}").links[:self].must_equal []
+        subject.from_json("{\"_links\":{\"self\":[]}}")
+        subject.links[:self].must_be_nil
       end
 
       it "parses non-existent link array" do
-        subject.from_json("{\"_links\":{}}").links[:self].must_equal nil # DISCUSS: should this be []?
+        subject.from_json("{\"_links\":{}}")
+        subject.links[:self].must_be_nil # DISCUSS: should this be []?
       end
 
-      it "rejects single links declared as array" do
-        assert_raises TypeError do
-          subject.from_json("{\"_links\":{\"self\":{\"href\":\"http://next\"}}}")
-        end
-      end
+      # it "rejects single links declared as array" do
+      #   assert_raises TypeError do
+      #     subject.from_json("{\"_links\":{\"self\":{\"href\":\"http://next\"}}}")
+      #   end
+      # end
     end
 
     describe "rendering" do
       it "renders link and link array" do
         subject.to_json.must_equal "{\"_links\":{\"self\":[{\"lang\":\"en\",\"href\":\"http://en.hit\"},{\"lang\":\"de\",\"href\":\"http://de.hit\"}],\"next\":{\"href\":\"http://next\"}}}"
       end
+    end
+  end
 
-      it "renders empty link array" do
-        rpr = Module.new do
-          include Roar::JSON::HAL
-
-          links :self do [] end
-        end
-        subject = Object.new.extend(rpr)
+  describe "empty link array" do
+    let(:decorator_class) do
+      Class.new(Roar::Decorator) do
+        include Roar::JSON
+        include Roar::JSON::HAL
 
-        subject.to_json.must_equal "{\"_links\":{\"self\":[]}}"
+        links(:self) { [] }
       end
     end
-  end
 
-  # describe "#prepare_links!" do
-  #   it "should map link arrays correctly" do
-  #     subject.send :prepare_links!, {}
-  #     subject.links.must_equal :self => [link("rel" => "self", "href" => "http://en.hit", "lang" => "en"),link("rel" => :self, "href" => "http://de.hit", "lang" => "de")], "next" => link("href" => "http://next", "rel" => "next")
-  #   end
-  # end
+    subject { decorator_class.new(Object.new) }
 
-  describe "#link_array_rels" do
-    it "returns list of rels for array links" do
-      subject.send(:link_array_rels).must_equal [:self]
+    it "gets render" do
+      subject.to_json.must_equal %@{"_links":{"self":[]}}@
     end
   end
 
 
-  describe "HAL/JSON" do
-    Bla = Module.new do
-      include Roar::JSON::HAL
-      property :title
-      link :self do
-        "http://songs/#{title}"
-      end
-    end
+  describe "_links and _embedded" do
+    let(:decorator_class) do
+      Class.new(Roar::Decorator) do
+        include Roar::JSON
+        include Roar::JSON::HAL
+
+        property :id
+        collection :songs, class: Song, embedded: true do
+          include Roar::JSON::HAL
+
+          property :title
+          link(:self) { "http://songs/#{represented.title}" }
+        end
 
-    representer_for([Roar::JSON::HAL]) do
-      property :id
-      collection :songs, :class => Song, :extend => Bla, :embedded => true
-      link :self do
-        "http://albums/#{id}"
+        link(:self) { "http://albums/#{represented.id}" }
       end
     end
 
-    before do
-      @album = Album.new(:songs => [Song.new(:title => "Beer")], :id => 1).extend(rpr)
-    end
+    let(:album) { Album.new(:songs => [Song.new(:title => "Beer")], :id => 1) }
+    subject { decorator_class.new(album) }
 
     it "render links and embedded resources according to HAL" do
-      assert_equal "{\"id\":1,\"_embedded\":{\"songs\":[{\"title\":\"Beer\",\"_links\":{\"self\":{\"href\":\"http://songs/Beer\"}}}]},\"_links\":{\"self\":{\"href\":\"http://albums/1\"}}}", @album.to_json
+      subject.to_json.must_equal "{\"id\":1,\"_embedded\":{\"songs\":[{\"title\":\"Beer\",\"_links\":{\"self\":{\"href\":\"http://songs/Beer\"}}}]},\"_links\":{\"self\":{\"href\":\"http://albums/1\"}}}"
     end
 
     it "parses links and resources following the mighty HAL" do
-      @album.from_json("{\"id\":2,\"_embedded\":{\"songs\":[{\"title\":\"Coffee\",\"_links\":{\"self\":{\"href\":\"http://songs/Coffee\"}}}]},\"_links\":{\"self\":{\"href\":\"http://albums/2\"}}}")
-      assert_equal 2, @album.id
-      assert_equal "Coffee", @album.songs.first.title
-      assert_equal "http://songs/Coffee", @album.songs.first.links[:self].href
-      assert_equal "http://albums/2", @album.links[:self].href
+      subject.from_json("{\"id\":2,\"_embedded\":{\"songs\":[{\"title\":\"Coffee\",\"_links\":{\"self\":{\"href\":\"http://songs/Coffee\"}}}]},\"_links\":{\"self\":{\"href\":\"http://albums/2\"}}}")
+      assert_equal 2, album.id
+      assert_equal "Coffee", album.songs.first.title
+      # FIXME assert_equal "http://songs/Coffee", subject.songs.first.links["self"].href
+      assert_equal "http://albums/2", subject.links["self"].href
     end
 
     it "doesn't require _links and _embedded to be present" do
-      @album.from_json("{\"id\":2}")
-      assert_equal 2, @album.id
+      subject.from_json("{\"id\":2}")
+      assert_equal 2, album.id
 
       # in newer representables, this is not overwritten to an empty [] anymore.
-      assert_equal ["Beer"], @album.songs.map(&:title)
-      @album.links.must_equal nil
+      assert_equal ["Beer"], album.songs.map(&:title)
+      album.links.must_be_nil
     end
   end
 
@@ -134,58 +129,70 @@ class JsonHalTest < MiniTest::Spec
   Artist = Struct.new(:name)
   Song = Struct.new(:title)
 
-  def self.representer!
-    super([Roar::JSON::HAL])
-  end
-
-  def representer
-    rpr
-  end
-
   describe "render_nil: false" do
-    representer! do
-      property :artist, embedded: true, render_nil: false do
-        property :name
-      end
+    let(:decorator_class) do
+      Class.new(Roar::Decorator) do
+        include Roar::JSON
+        include Roar::JSON::HAL
+
+        property :artist, embedded: true, render_nil: false do
+          property :name
+        end
 
-      collection :songs, embedded: true, render_empty: false do
-        property :title
+        collection :songs, embedded: true, render_empty: false do
+          property :title
+        end
       end
     end
 
-    it { Album.new(Artist.new("Bare, Jr."), [Song.new("Tobacco Spit")]).extend(representer).to_hash.must_equal({"_embedded"=>{"artist"=>{"name"=>"Bare, Jr."}, "songs"=>[{"title"=>"Tobacco Spit"}]}}) }
-    it { Album.new.extend(representer).to_hash.must_equal({}) }
+    it { decorator_class.new(Album.new(Artist.new("Bare, Jr."), [Song.new("Tobacco Spit")])).to_hash.must_equal({"_embedded"=>{"artist"=>{"name"=>"Bare, Jr."}, "songs"=>[{"title"=>"Tobacco Spit"}]}}) }
+    it { decorator_class.new(Album.new).to_hash.must_equal({}) }
   end
-end
 
+  describe "as: alias" do
+    let(:decorator_class) do
+      Class.new(Roar::Decorator) do
+        include Roar::JSON
+        include Roar::JSON::HAL
 
-class LinkCollectionTest < MiniTest::Spec
-  subject { Roar::JSON::HAL::LinkCollection.new([:self, "next"]) }
-  describe "#is_array?" do
-    it "returns true for array link" do
-      subject.is_array?(:self).must_equal true
-      subject.is_array?("self").must_equal true
-    end
+        property :artist, as: :my_artist, class: Artist, embedded: true do
+          property :name
+        end
 
-    it "returns false otherwise" do
-      subject.is_array?("prev").must_equal false
+        collection :songs, as: :my_songs, class: Song, embedded: true do
+          property :title
+        end
+      end
     end
+
+    it { decorator_class.new(Album.new(Artist.new("Bare, Jr."), [Song.new("Tobacco Spit")])).to_hash.must_equal({"_embedded"=>{"my_artist"=>{"name"=>"Bare, Jr."}, "my_songs"=>[{"title"=>"Tobacco Spit"}]}}) }
+    it { decorator_class.new(Album.new).from_hash({"_embedded"=>{"my_artist"=>{"name"=>"Bare, Jr."}, "my_songs"=>[{"title"=>"Tobacco Spit"}]}}).inspect.must_equal "#<struct JsonHalTest::Album artist=#<struct JsonHalTest::Artist name=\"Bare, Jr.\">, songs=[#<struct JsonHalTest::Song title=\"Tobacco Spit\">]>" }
   end
 end
 
-
 class HalCurieTest < MiniTest::Spec
-  representer!([Roar::JSON::HAL]) do
-    link "doc:self" do
-      "/"
-    end
+  let(:decorator_class) do
+    Class.new(Roar::Decorator) do
+      include Roar::JSON
+      include Roar::JSON::HAL
+
+      link "doc:self" do
+        "/"
+      end
+
+      links "doc:link_collection" do
+        [{:name => "link_collection", :href => "/"}]
+      end
 
-    curies do
-      [{:name => :doc,
-        :href => "//docs/{rel}",
-        :templated => true}]
+      curies do
+        [{:name => :doc,
+          :href => "//docs/{rel}",
+          :templated => true}]
+      end
     end
   end
 
-  it { Object.new.extend(rpr).to_hash.must_equal({"_links"=>{"doc:self"=>{"href"=>"/"}, :curies=>[{"name"=>:doc, "href"=>"//docs/{rel}", "templated"=>true}]}}) }
+  subject { decorator_class.new(Object.new) }
+
+  it { subject.to_hash.must_equal({"_links"=>{"doc:self"=>{"href"=>"/"}, "doc:link_collection"=>[{"name"=>"link_collection", "href"=>"/"}], "curies"=>[{"name"=>:doc, "href"=>"//docs/{rel}", "templated"=>true}]}}) }
 end

data/test/hypermedia_feature_test.rb

@@ -1,4 +1,4 @@
-require 'test_helper'
+  require 'test_helper'
 
 class HypermediaTest < MiniTest::Spec
 
@@ -30,7 +30,7 @@ class HypermediaTest < MiniTest::Spec
 
     describe "#to_xml" do
       it "works when no links defined" do
-        repr = Module.new do
+        decorator_class = Class.new(Roar::Decorator) do
           include Roar::XML
           include Roar::Hypermedia
 
@@ -38,22 +38,22 @@ class HypermediaTest < MiniTest::Spec
           property :title
         end
 
-        song.extend(repr).to_xml.must_equal_xml "<song><title>Brandy Wine</title></song>"
+        decorator_class.new(song).to_xml.must_equal_xml "<song><title>Brandy Wine</title></song>"
       end
 
-      let (:rpr) { Module.new do
+      let(:decorator_class) { Class.new(Roar::Decorator) do
         include Roar::XML
         include Roar::Hypermedia
 
         self.representation_wrap = "song"
         property :title
 
-        link(:self) { "/songs/#{title}" }
+        link(:self) { "/songs/#{represented.title}" }
         link(:all) { "/songs" }
       end }
 
       it "includes links in rendered document" do
-        song.extend(rpr).to_xml.must_equal_xml %{
+        decorator_class.new(song).to_xml.must_equal_xml %{
           <song>
             <title>Brandy Wine</title>
             <link rel="self" href="/songs/Brandy Wine"/>
@@ -62,23 +62,22 @@ class HypermediaTest < MiniTest::Spec
       end
 
       it "suppresses links when links: false" do
-        song.extend(rpr).to_xml(:links => false).must_equal_xml "<song><title>Brandy Wine</title></song>"
+        decorator_class.new(song).to_xml(user_options: {links: false}).must_equal_xml "<song><title>Brandy Wine</title></song>"
       end
 
       it "renders nested links" do
-        song_rpr = rpr
-
-        album_rpr = Module.new do
+        song_decorator_class  = decorator_class
+        album_decorator_class = Class.new(Roar::Decorator) do
           include Roar::XML
           include Roar::Hypermedia
 
           self.representation_wrap = "album"
-          collection :songs, :extend => song_rpr
+          collection :songs, :extend => song_decorator_class
 
           link(:self) { "/albums/mixed" }
         end
 
-        Album.new(:songs => [song]).extend(album_rpr).to_xml.must_equal_xml %{
+        album_decorator_class.new(Album.new(:songs => [song])).to_xml.must_equal_xml %{
           <album>
             <song>
               <title>Brandy Wine</title>
@@ -125,30 +124,13 @@ class HypermediaTest < MiniTest::Spec
         </bookmarks>
         })
 
-        assert_kind_of Roar::Hypermedia::LinkCollection, doc.links
+        assert_kind_of Hash, doc.links
         assert_equal 1, doc.links.size
         assert_equal(["self", "http://bookmarks"], [doc.links["self"].rel, doc.links["self"].href])
       end
 
       it "sets up an empty link list if no links found in the document" do
-        @bookmarks_with_links.new.from_xml(%{<bookmarks/>}).links.must_equal nil
-      end
-    end
-  end
-end
-
-
-class LinkCollectionTest < MiniTest::Spec
-  describe "LinkCollection" do
-    subject {
-      Roar::Hypermedia::LinkCollection[
-        @self_link = link(:rel => :self), @next_link = link(:rel => :next)
-      ]
-    }
-
-    describe "::[]" do
-      it "keys by using rel string" do
-        subject.values.must_equal [@self_link, @next_link]
+        @bookmarks_with_links.new.from_xml(%{<bookmarks/>}).links.must_equal({})
       end
     end
   end

data/test/hypermedia_test.rb

@@ -1,52 +1,39 @@
 require 'test_helper'
+require 'roar/decorator'
 
 class HypermediaTest < MiniTest::Spec
   describe "inheritance" do
-    before do
-      module BaseRepresenter
-        include Roar::JSON
-        include Roar::Hypermedia
+    class BaseRepresenter < Roar::Decorator
+      include Roar::JSON
+      include Roar::Hypermedia
 
-        link(:base) { "http://base" }
-      end
-
-      module Bar
-        include Roar::JSON
-        include Roar::Hypermedia
-
-        link(:bar) { "http://bar" }
-      end
+      link(:base) { "http://base" }
+    end
 
-      module Foo
-        include Roar::JSON
-        include Roar::Hypermedia
-        include BaseRepresenter
-        include Bar
+    class Bar < BaseRepresenter
+      link(:bar) { "http://bar" }
+    end
 
-        link(:foo) { "http://foo" }
-      end
+    class Foo < Bar
+      link(:foo) { "http://foo" }
     end
 
     it "inherits parent links" do
-      foo = Object.new.extend(Foo)
-
-      assert_equal "{\"links\":[{\"rel\":\"base\",\"href\":\"http://base\"},{\"rel\":\"bar\",\"href\":\"http://bar\"},{\"rel\":\"foo\",\"href\":\"http://foo\"}]}", foo.to_json
+      Foo.new(Object.new).to_json.must_equal "{\"links\":[{\"rel\":\"base\",\"href\":\"http://base\"},{\"rel\":\"bar\",\"href\":\"http://bar\"},{\"rel\":\"foo\",\"href\":\"http://foo\"}]}"
     end
 
     it "inherits links from all mixed-in representers" do
-      skip
-      Object.new.extend(BaseRepresenter).extend(Bar).to_json.must_equal "{\"links\":[{\"rel\":\"base\",\"href\":\"http://base\"},{\"rel\":\"bar\",\"href\":\"http://bar\"}]}"
+      Bar.new(Object.new).to_json.must_equal "{\"links\":[{\"rel\":\"base\",\"href\":\"http://base\"},{\"rel\":\"bar\",\"href\":\"http://bar\"}]}"
     end
   end
 
   describe "#links_array" do
-    subject { Object.new.extend(rpr) }
+    subject { decorator_class.new(Object.new) }
 
-    representer_for do
+    decorator_for do
       link(:self) { "//self" }
     end
 
-
     describe "#to_json" do
       it "renders" do
         subject.to_json.must_equal "{\"links\":[{\"rel\":\"self\",\"href\":\"//self\"}]}"
@@ -56,7 +43,7 @@ class HypermediaTest < MiniTest::Spec
     describe "#from_json" do
       it "parses" do
         subject.from_json "{\"links\":[{\"rel\":\"self\",\"href\":\"//self\"}]}"
-        subject.links.must_equal({"self" => link("rel" => "self", "href" => "//self")})
+        subject.links.must_equal("self" => link("rel" => "self", "href" => "//self"))
       end
     end
 
@@ -64,7 +51,7 @@ class HypermediaTest < MiniTest::Spec
     describe "#link" do
 
       describe "with any options" do
-        representer_for do
+        decorator_for do
           link(:rel => :self, :title => "Hey, @myabc") { "//self" }
         end
 
@@ -74,38 +61,39 @@ class HypermediaTest < MiniTest::Spec
       end
 
       describe "with string rel" do
-        representer_for do
+        decorator_for do
           link("ns:self") { "//self" }
         end
 
         it "renders rel" do
+          # raise subject.inspect
           subject.to_json.must_equal "{\"links\":[{\"rel\":\"ns:self\",\"href\":\"//self\"}]}"
         end
       end
 
       describe "passing options to serialize" do
-        representer_for do
+        decorator_for do
           link(:self) { |opts| "//self/#{opts[:id]}" }
         end
 
         it "receives options when rendering" do
-          subject.to_json(:id => 1).must_equal "{\"links\":[{\"rel\":\"self\",\"href\":\"//self/1\"}]}"
+          subject.to_json(user_options: { id: 1 }).must_equal "{\"links\":[{\"rel\":\"self\",\"href\":\"//self/1\"}]}"
         end
 
         describe "in a composition" do
-          representer_for do
+          decorator_for do
             property :entity, :extend => self
             link(:self) { |opts| "//self/#{opts[:id]}" }
           end
 
           it "propagates options" do
-            Song.new(:entity => Song.new).extend(rpr).to_json(:id => 1).must_equal "{\"entity\":{\"links\":[{\"rel\":\"self\",\"href\":\"//self/1\"}]},\"links\":[{\"rel\":\"self\",\"href\":\"//self/1\"}]}"
+            decorator_class.new(Song.new(:entity => Song.new)).to_json(user_options: { id: 1 }).must_equal "{\"entity\":{\"links\":[{\"rel\":\"self\",\"href\":\"//self/1\"}]},\"links\":[{\"rel\":\"self\",\"href\":\"//self/1\"}]}"
           end
         end
       end
 
       describe "returning option hash from block" do
-        representer_for do
+        decorator_for do
           link(:self) do {:href => "//self", :type => "image/jpg"} end
           link(:other) do |params|
             hash = { :href => "//other" }
@@ -119,13 +107,13 @@ class HypermediaTest < MiniTest::Spec
         end
 
         it "is rendered according to context" do
-          subject.to_json(type: true).must_equal "{\"links\":[{\"rel\":\"self\",\"href\":\"//self\",\"type\":\"image/jpg\"},{\"rel\":\"other\",\"href\":\"//other\",\"type\":\"image/jpg\"}]}"
+          subject.to_json(user_options: { type: true }).must_equal "{\"links\":[{\"rel\":\"self\",\"href\":\"//self\",\"type\":\"image/jpg\"},{\"rel\":\"other\",\"href\":\"//other\",\"type\":\"image/jpg\"}]}"
           subject.to_json.must_equal "{\"links\":[{\"rel\":\"self\",\"href\":\"//self\",\"type\":\"image/jpg\"},{\"rel\":\"other\",\"href\":\"//other\"}]}"
         end
       end
 
       describe "not calling #link" do
-        representer_for {}
+        decorator_for {}
 
         it "still allows rendering" do
           subject.to_json.must_equal "{}"
@@ -134,57 +122,3 @@ class HypermediaTest < MiniTest::Spec
     end
   end
 end
-
-class HyperlinkTest < MiniTest::Spec
-  describe "Hyperlink" do
-    subject { link(:rel => "self", "href" => "http://self", "data-whatever" => "Hey, @myabc") }
-
-    it "accepts string keys in constructor" do
-      assert_equal "Hey, @myabc", subject.send("data-whatever")
-    end
-
-    it "responds to #rel" do
-      assert_equal "self", subject.rel
-    end
-
-    it "responds to #href" do
-      assert_equal "http://self", subject.href
-    end
-
-    it "responds to #replace with string keys" do
-      subject.replace("rel" => "next")
-      assert_equal nil, subject.href
-      assert_equal "next", subject.rel
-    end
-
-    it "responds to #each and implements Enumerable" do
-      assert_equal ["rel:self", "href:http://self", "data-whatever:Hey, @myabc"], subject.collect { |k,v| "#{k}:#{v}" }
-    end
-  end
-
-  describe "Config inheritance" do
-      it "doesn't mess up with inheritable_array" do  # FIXME: remove this test when uber is out.
-        OpenStruct.new.extend( Module.new do
-                  include Roar::JSON
-                  include(Module.new do
-                                      include Roar::JSON
-                                      include Roar::Hypermedia
-
-                                      property :bla
-
-                                      link( :self) {"bo"}
-
-                                      #puts "hey ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~"
-                                      #puts representable_attrs.inheritable_array(:links).inspect
-                                    end)
-
-
-                  #puts representable_attrs.inheritable_array(:links).inspect
-
-                  property :blow
-                  include Roar::Hypermedia
-                  link(:bla) { "boo" }
-                end).to_hash.must_equal({"links"=>[{"rel"=>"self", "href"=>"bo"}, {"rel"=>"bla", "href"=>"boo"}]})
-    end
-  end
-end

data/test/{decorator_client_test.rb → integration/decorator_client_test.rb}

@@ -1,4 +1,5 @@
 require 'test_helper'
+require 'integration/runner'
 require 'roar/decorator'
 require 'roar/client'
 
@@ -6,7 +7,7 @@ class DecoratorClientTest < MiniTest::Spec
   class Crew
     attr_accessor :moniker, :company
   end
-  
+
   class CrewDecorator < Roar::Decorator
     include Roar::JSON
     include Roar::Hypermedia
@@ -26,7 +27,7 @@ class DecoratorClientTest < MiniTest::Spec
   before do
     @crew = Crew.new
     @client = CrewClient.new(@crew)
-  end    
+  end
 
   describe 'HttpVerbs integration' do
     describe '#get' do
@@ -54,11 +55,11 @@ class DecoratorClientTest < MiniTest::Spec
       @crew.moniker = 'Silence'
       @client.to_json.must_equal %{{\"name\":\"Silence\",\"links\":[]}}
     end
-    
+
     # since this is considered dangerous, we test the mutuable options.
     it "adds links: false to options" do
       @client.to_hash(options = {})
-      options.must_equal({:links => false})
+      options.must_equal(user_options: {links: false})
     end
   end
 end

data/test/{faraday_http_transport_test.rb → integration/faraday_http_transport_test.rb}

@@ -1,4 +1,5 @@
 require 'test_helper'
+require 'integration/runner'
 require 'roar/transport/faraday'
 
 class FaradayHttpTransportTest < MiniTest::Spec

data/test/{http_verbs_test.rb → integration/http_verbs_test.rb}

@@ -1,4 +1,5 @@
 require 'test_helper'
+require 'integration/runner'
 require 'roar/http_verbs'
 require 'roar/json'
 
@@ -80,11 +81,11 @@ class HttpVerbsTest < MiniTest::Spec
     describe "#post" do
       it "updates instance with incoming representation" do
         @band.name = "Strung Out"
-        assert_equal nil, @band.label
+        assert_nil @band.label
 
         @band.post(:uri => "http://localhost:4567/bands", :as => "application/xml")
         assert_equal "STRUNG OUT", @band.name
-        assert_equal nil, @band.label
+        assert_nil @band.label
       end
     end