her 0.4 → 0.4.1

data/lib/her/model/relationships.rb

@@ -43,7 +43,7 @@ module Her
                 when :has_many
                   Her::Model::ORM.initialize_collection(klass, :data => data[name])
                 when :has_one, :belongs_to
-                  klass.new(data[name])
+                  klass.new(klass.parse(data[name]))
                 else
                   nil
               end

data/lib/her/version.rb

@@ -1,3 +1,3 @@
 module Her
-  VERSION = "0.4"
+  VERSION = "0.4.1"
 end

data/spec/api_spec.rb

@@ -2,6 +2,8 @@
 require File.join(File.dirname(__FILE__), "spec_helper.rb")
 
 describe Her::API do
+  subject { Her::API.new }
+
   context "initialization" do
     describe ".setup" do
       it "creates a default connection" do
@@ -11,119 +13,118 @@ describe Her::API do
     end
 
     describe "#setup" do
-      it "sets a base URI" do
-        @api = Her::API.new
-        @api.setup :url => "https://api.example.com"
-        @api.base_uri.should == "https://api.example.com"
+      context "when using :url option" do
+        before { subject.setup :url => "https://api.example.com" }
+        its(:base_uri) { should == "https://api.example.com" }
       end
 
-      it "supports the base_uri legacy option" do
-        @api = Her::API.new
-        @api.setup :base_uri => "https://api.example.com"
-        @api.base_uri.should == "https://api.example.com"
+      context "when using the legacy :base_uri option" do
+        before { subject.setup :base_uri => "https://api.example.com" }
+        its(:base_uri) { should == "https://api.example.com" }
       end
 
-      it "sets custom middleware with #use" do
-        class Foo; end;
-        class Bar; end;
+      context "when setting custom middleware" do
+        before do
+          class Foo; end;
+          class Bar; end;
 
-        @api = Her::API.new
-        @api.setup :url => "https://api.example.com" do |builder|
-          builder.use Foo
-          builder.use Bar
+          subject.setup :url => "https://api.example.com" do |connection|
+            connection.use Foo
+            connection.use Bar
+          end
         end
-        @api.connection.builder.handlers.should == [Foo, Bar]
+
+        specify { subject.connection.builder.handlers.should == [Foo, Bar] }
       end
 
-      it "takes custom options" do
-        @api = Her::API.new
-        @api.setup :foo => { :bar => "baz" }, :url => "https://api.example.com"
-        @api.options.should == { :foo => { :bar => "baz" }, :url => "https://api.example.com" }
+      context "when setting custom options" do
+        before { subject.setup :foo => { :bar => "baz" }, :url => "https://api.example.com" }
+        its(:options) { should == { :foo => { :bar => "baz" }, :url => "https://api.example.com" } }
       end
     end
 
     describe "#request" do
-      it "makes HTTP requests" do
+      before do
         class SimpleParser < Faraday::Response::Middleware
           def on_complete(env)
             env[:body] = { :data => env[:body] }
           end
         end
+      end
 
-        @api = Her::API.new
-        @api.setup :url => "https://api.example.com" do |builder|
-          builder.use SimpleParser
-          builder.use Faraday::Request::UrlEncoded
-          builder.adapter :test do |stub|
-            stub.get("/foo") { |env| [200, {}, "Foo it is"] }
+      context "making HTTP requests" do
+        let(:parsed_data) { subject.request(:_method => :get, :_path => "/foo") }
+        before do
+          subject.setup :url => "https://api.example.com" do |builder|
+            builder.use SimpleParser
+            builder.adapter(:test) { |stub| stub.get("/foo") { |env| [200, {}, "Foo, it is."] } }
           end
         end
 
-        parsed_data = @api.request(:_method => :get, :_path => "/foo")
-        parsed_data[:data] == "Foo, it is."
+        specify { parsed_data[:data].should == "Foo, it is." }
       end
 
-      it "makes HTTP requests while specifying custom HTTP headers" do
-        class SimpleParser < Faraday::Response::Middleware
-          def on_complete(env)
-            env[:body] = { :data => env[:body] }
-          end
-        end
+      context "making HTTP requests while specifying custom HTTP headers" do
+        let(:parsed_data) { subject.request(:_method => :get, :_path => "/foo", :_headers => { "X-Page" => 2 }) }
 
-        @api = Her::API.new
-        @api.setup :url => "https://api.example.com" do |builder|
-          builder.use SimpleParser
-          builder.use Faraday::Request::UrlEncoded
-          builder.adapter :test do |stub|
-            stub.get("/foo") { |env| [200, {}, "Foo it is #{env[:request_headers]["X-Page"]}"] }
+        before do
+          subject.setup :url => "https://api.example.com" do |builder|
+            builder.use SimpleParser
+            builder.adapter(:test) { |stub| stub.get("/foo") { |env| [200, {}, "Foo, it is page #{env[:request_headers]["X-Page"]}."] } }
           end
         end
 
-        parsed_data = @api.request(:_method => :get, :_path => "/foo", :_headers => { "X-Page" => 2 })
-        parsed_data[:data] == "Foo, it is page 2."
+        specify { parsed_data[:data].should == "Foo, it is page 2." }
       end
 
-      it "parses a request with the default parser" do
-        @api = Her::API.new
-        @api.setup :url => "https://api.example.com" do |builder|
-          builder.use Her::Middleware::FirstLevelParseJSON
-          builder.use Faraday::Request::UrlEncoded
-          builder.adapter :test do |stub|
-            stub.get("/users/1") { |env| [200, {}, MultiJson.dump({ :id => 1, :name => "George Michael Bluth", :errors => ["This is a single error"], :metadata => { :page => 1, :per_page => 10 } })] }
+      context "parsing a request with the default parser" do
+        let(:parsed_data) { subject.request(:_method => :get, :_path => "users/1") }
+        before do
+          subject.setup :url => "https://api.example.com" do |builder|
+            builder.use Her::Middleware::FirstLevelParseJSON
+            builder.adapter :test do |stub|
+              stub.get("/users/1") { |env| [200, {}, MultiJson.dump({ :id => 1, :name => "George Michael Bluth", :errors => ["This is a single error"], :metadata => { :page => 1, :per_page => 10 } })] }
+            end
           end
         end
-        parsed_data = @api.request(:_method => :get, :_path => "users/1")
-        parsed_data[:data].should == { :id => 1, :name => "George Michael Bluth" }
-        parsed_data[:errors].should == ["This is a single error"]
-        parsed_data[:metadata].should == { :page => 1, :per_page => 10 }
+
+        specify do
+          parsed_data[:data].should == { :id => 1, :name => "George Michael Bluth" }
+          parsed_data[:errors].should == ["This is a single error"]
+          parsed_data[:metadata].should == { :page => 1, :per_page => 10 }
+        end
       end
 
-      it "parses a request with a custom parser" do
-        class CustomParser < Faraday::Response::Middleware
-          def on_complete(env)
-            json = MultiJson.load(env[:body], :symbolize_keys => true)
-            errors = json.delete(:errors) || []
-            metadata = json.delete(:metadata) || {}
-            env[:body] = {
-              :data => json,
-              :errors => errors,
-              :metadata => metadata,
-            }
+      context "parsing a request with a custom parser" do
+        let(:parsed_data) { subject.request(:_method => :get, :_path => "users/1") }
+        before do
+          class CustomParser < Faraday::Response::Middleware
+            def on_complete(env)
+              json = MultiJson.load(env[:body], :symbolize_keys => true)
+              errors = json.delete(:errors) || []
+              metadata = json.delete(:metadata) || {}
+              env[:body] = {
+                :data => json,
+                :errors => errors,
+                :metadata => metadata,
+              }
+            end
           end
-        end
 
-        @api = Her::API.new
-        @api.setup :url => "https://api.example.com" do |builder|
-          builder.use CustomParser
-          builder.use Faraday::Request::UrlEncoded
-          builder.adapter :test do |stub|
-            stub.get("/users/1") { |env| [200, {}, MultiJson.dump(:id => 1, :name => "George Michael Bluth")] }
+          subject.setup :url => "https://api.example.com" do |builder|
+            builder.use CustomParser
+            builder.use Faraday::Request::UrlEncoded
+            builder.adapter :test do |stub|
+              stub.get("/users/1") { |env| [200, {}, MultiJson.dump(:id => 1, :name => "George Michael Bluth")] }
+            end
           end
         end
-        parsed_data = @api.request(:_method => :get, :_path => "users/1")
-        parsed_data[:data].should == { :id => 1, :name => "George Michael Bluth" }
-        parsed_data[:errors].should == []
-        parsed_data[:metadata].should == {}
+
+        specify do
+          parsed_data[:data].should == { :id => 1, :name => "George Michael Bluth" }
+          parsed_data[:errors].should == []
+          parsed_data[:metadata].should == {}
+        end
       end
     end
   end

data/spec/collection_spec.rb

@@ -2,26 +2,25 @@ require 'spec_helper'
 
 describe Her::Collection do
 
-  let(:items) { [1,2,3,4] }
-  let(:metadata) { {:name => 'Testname'} }
-  let(:errors) { {:name => ['not_present']} }
+  let(:items) { [1, 2, 3, 4] }
+  let(:metadata) { { :name => 'Testname' } }
+  let(:errors) { { :name => ['not_present'] } }
 
   describe "#new" do
     context "without parameters" do
-
       subject { Her::Collection.new }
 
-      it { should eq([])}
-      its(:metadata) { should eq({})}
-      its(:errors) { should eq({})}
+      it { should eq([]) }
+      its(:metadata) { should eq({}) }
+      its(:errors) { should eq({}) }
     end
 
     context "with parameters" do
-      subject { Her::Collection.new(items, metadata, errors)}
+      subject { Her::Collection.new(items, metadata, errors) }
 
-      it { should eq([1,2,3,4])}
-      its(:metadata) { should eq({:name => 'Testname'})}
-      its(:errors) { should eq({:name => ['not_present']})}
+      it { should eq([1,2,3,4]) }
+      its(:metadata) { should eq({ :name => 'Testname' }) }
+      its(:errors) { should eq({ :name => ['not_present'] }) }
     end
   end
 end

data/spec/middleware/first_level_parse_json_spec.rb

@@ -29,4 +29,14 @@ describe Her::Middleware::FirstLevelParseJSON do
   it 'ensures the errors are a hash if there are no errors' do
     subject.parse(body_with_errors)[:errors].should eq({:name => [ 'not_valid', 'should_be_present']})
   end
+
+  context 'with status code 204' do
+    it 'returns an empty body' do
+      env = { :status => 204 }
+      subject.on_complete(env)
+      env[:body].tap do |json|
+        json[:data].should == { }
+      end
+    end
+  end
 end

data/spec/model/http_spec.rb

@@ -3,105 +3,62 @@ require File.join(File.dirname(__FILE__), "../spec_helper.rb")
 
 describe Her::Model::HTTP do
   context "binding a model with an API" do
-    it "binds a model to an instance of Her::API" do
-      api = Her::API.new
-      api.setup :url => "https://api.example.com"
+    let(:api1) { Her::API.new :url => "https://api1.example.com" }
+    let(:api2) { Her::API.new :url => "https://api2.example.com" }
 
-      spawn_model "Foo::User"
-      Foo::User.uses_api api
-      Foo::User.her_api.should_not == nil
-      Foo::User.her_api.base_uri.should == "https://api.example.com"
-    end
-
-    it "binds a model directly to Her::API" do
+    before do
+      spawn_model("Foo::User")
+      spawn_model("Foo::Comment")
       Her::API.setup :url => "https://api.example.com"
-
-      spawn_model "Foo::User"
-
-      Foo::User.her_api.should_not == nil
-      Foo::User.her_api.base_uri.should == "https://api.example.com"
     end
 
-    it "binds two models to two different instances of Her::API" do
-      api1 = Her::API.new
-      api1.setup :url => "https://api1.example.com" do |builder|
-        builder.use Her::Middleware::FirstLevelParseJSON
-        builder.use Faraday::Request::UrlEncoded
-      end
-
-      spawn_model "Foo::User"
-      Foo::User.uses_api api1
-      Foo::User.her_api.base_uri.should == "https://api1.example.com"
-
-      api2 = Her::API.new
-      api2.setup :url => "https://api2.example.com" do |builder|
-        builder.use Her::Middleware::FirstLevelParseJSON
-        builder.use Faraday::Request::UrlEncoded
-      end
-
-      spawn_model "Foo::Comment"
-      Foo::Comment.uses_api api2
-      Foo::Comment.her_api.base_uri.should == "https://api2.example.com"
+    context "when binding a model to an instance of Her::API" do
+      before { Foo::User.uses_api api1 }
+      subject { Foo::User.her_api }
+      its(:base_uri) { should == "https://api1.example.com" }
     end
 
-    it "binds one model to Her::API and another one to an instance of Her::API" do
-      Her::API.setup :url => "https://api1.example.com" do |builder|
-        builder.use Her::Middleware::FirstLevelParseJSON
-        builder.use Faraday::Request::UrlEncoded
-      end
-
-      spawn_model "Foo::User"
-
-      Foo::User.her_api.base_uri.should == "https://api1.example.com"
-
-      api = Her::API.new
-      api.setup :url => "https://api2.example.com" do |builder|
-        builder.use Her::Middleware::FirstLevelParseJSON
-        builder.use Faraday::Request::UrlEncoded
-      end
-
-      spawn_model "Foo::Comment"
-      Foo::Comment.uses_api api
-      Foo::Comment.her_api.base_uri.should == "https://api2.example.com"
+    context "when binding a model directly to Her::API" do
+      before { spawn_model "Foo::User" }
+      subject { Foo::User.her_api }
+      its(:base_uri) { should == "https://api.example.com" }
     end
 
-    it "binds a a model to it's superclass' her_api" do
-      api = Her::API.new
-      api.setup :url => "http://api.example.com" do |builder|
-        builder.use Her::Middleware::FirstLevelParseJSON
-        builder.use Faraday::Request::UrlEncoded
+    context "when binding two models to two different instances of Her::API" do
+      before do
+        Foo::User.uses_api api1
+        Foo::Comment.uses_api api2
       end
 
-      spawn_model "Foo::Superclass" do
-        uses_api api
-      end
-
-      Foo::Subclass = Class.new(Foo::Superclass)
-      Foo::Subclass.her_api.should == Foo::Superclass.her_api
+      specify { Foo::User.her_api.base_uri.should == "https://api1.example.com" }
+      specify { Foo::Comment.her_api.base_uri.should == "https://api2.example.com" }
     end
 
-    it "allows subclasses to change her_api without changing the parent class' her_api" do
-      api1 = Her::API.new
-      api1.setup :url => "http://api.example.com" do |builder|
-        builder.use Her::Middleware::FirstLevelParseJSON
-        builder.use Faraday::Request::UrlEncoded
-      end
+    context "binding one model to Her::API and another one to an instance of Her::API" do
+      before { Foo::Comment.uses_api api2 }
+      specify { Foo::User.her_api.base_uri.should == "https://api.example.com" }
+      specify { Foo::Comment.her_api.base_uri.should == "https://api2.example.com" }
+    end
 
-      spawn_model "Foo::Superclass" do
-        uses_api api1
+    context "when binding a model to its superclass' her_api" do
+      before do
+        spawn_model "Foo::Superclass"
+        Foo::Superclass.uses_api api1
+        Foo::Subclass = Class.new(Foo::Superclass)
       end
 
-      api2 = Her::API.new
-      api2.setup :url => "http://api.example.com" do |builder|
-        builder.use Her::Middleware::FirstLevelParseJSON
-        builder.use Faraday::Request::UrlEncoded
-      end
+      specify { Foo::Subclass.her_api.should == Foo::Superclass.her_api }
+    end
 
-      Foo::Subclass = Class.new(Foo::Superclass) do
-        uses_api api2
+    context "when changing her_api without changing the parent class' her_api" do
+      before do
+        spawn_model "Foo::Superclass"
+        Foo::Subclass = Class.new(Foo::Superclass)
+        Foo::Superclass.uses_api api1
+        Foo::Subclass.uses_api api2
       end
 
-      Foo::Subclass.her_api.should_not == Foo::Superclass.her_api
+      specify { Foo::Subclass.her_api.should_not == Foo::Superclass.her_api }
     end
   end
 
@@ -111,155 +68,117 @@ describe Her::Model::HTTP do
         builder.use Her::Middleware::FirstLevelParseJSON
         builder.use Faraday::Request::UrlEncoded
         builder.adapter :test do |stub|
-          stub.get("/users") do |env|
+          stub.get("/users") { |env| [200, {}, [{ :id => 1 }].to_json] }
+          stub.get("/users/1") { |env| [200, {}, { :id => 1 }.to_json] }
+          stub.get("/users/popular") do |env|
             if env[:params]["page"] == "2"
-              [200, {}, [{ :id => 2 }].to_json]
+              [200, {}, [{ :id => 3 }, { :id => 4 }].to_json]
             else
-              [200, {}, [{ :id => 1 }].to_json]
+              [200, {}, [{ :id => 1 }, { :id => 2 }].to_json]
             end
           end
-          stub.get("/users/popular") { |env| [200, {}, [{ :id => 1 }, { :id => 2 }].to_json] }
-          stub.get("/users/1") { |env| [200, {}, { :id => 1 }.to_json] }
-          stub.post("/users") { |env| [200, {}, [{ :id => 3 }].to_json] }
-          stub.put("/users/4") { |env| [200, {}, [{ :id => 4 }].to_json] }
-          stub.patch("/users/6") { |env| [200, {}, [{ :id => 6 }].to_json] }
-          stub.delete("/users/5") { |env| [200, {}, [{ :id => 5 }].to_json] }
         end
       end
 
       spawn_model "Foo::User"
     end
 
-    it "handles GET wrapper method" do
-      @users = Foo::User.get(:popular)
-      @users.length.should == 2
-      @users.first.id.should == 1
-
-      @user = Foo::User.get(:"1")
-      @user.id.should == 1
+    describe :get do
+      subject { Foo::User.get(:popular) }
+      its(:length) { should == 2 }
+      specify { subject.first.id.should == 1 }
     end
 
-    it "handles raw GET with a block" do
-      Foo::User.get_raw("/users") do |parsed_data|
-        parsed_data[:data].should == [{ :id => 1 }]
+    describe :get_raw do
+      context "with a block" do
+        specify do
+          Foo::User.get_raw("/users") do |parsed_data|
+            parsed_data[:data].should == [{ :id => 1 }]
+          end
+        end
       end
-    end
-
-    it "handles raw GET with return value" do
-      parsed_data = Foo::User.get_raw("/users")
-      parsed_data[:data].should == [{ :id => 1 }]
-    end
 
-    it "handles raw POST with a block" do
-      Foo::User.post_raw("/users") do |parsed_data|
-        parsed_data[:data].should == [{ :id => 3 }]
+      context "with a return value" do
+        subject { Foo::User.get_raw("/users") }
+        specify { subject[:data].should == [{ :id => 1 }] }
       end
     end
 
-    it "handles raw POST with return value" do
-      parsed_data = Foo::User.post_raw("/users")
-      parsed_data[:data].should == [{ :id => 3 }]
-    end
-
-    it "handles raw PUT with a block" do
-      Foo::User.put_raw("/users/4") do |parsed_data|
-        parsed_data[:data].should == [{ :id => 4 }]
+    describe :get_collection do
+      context "with a String path" do
+        subject { Foo::User.get_collection("/users/popular") }
+        its(:length) { should == 2 }
+        specify { subject.first.id.should == 1 }
       end
-    end
-
-    it "handles raw PUT with return value" do
-      parsed_data = Foo::User.put_raw("/users/4")
-      parsed_data[:data].should == [{ :id => 4 }]
-    end
 
-    it "handles raw PATCH with a block" do
-      Foo::User.patch_raw("/users/6") do |parsed_data|
-        parsed_data[:data].should == [{ :id => 6 }]
+      context "with a Symbol" do
+        subject { Foo::User.get_collection(:popular) }
+        its(:length) { should == 2 }
+        specify { subject.first.id.should == 1 }
       end
-    end
-
-    it "handles raw PATCH with return value" do
-      parsed_data = Foo::User.patch_raw("/users/6")
-      parsed_data[:data].should == [{ :id => 6 }]
-    end
 
-    it "handles raw DELETE with a block" do
-      Foo::User.delete_raw("/users/5") do |parsed_data|
-        parsed_data[:data].should == [{ :id => 5 }]
+      context "with extra parameters" do
+        subject { Foo::User.get_collection(:popular, :page => 2) }
+        its(:length) { should == 2 }
+        specify { subject.first.id.should == 3 }
       end
     end
 
-    it "handles raw DELETE with return value" do
-      parsed_data = Foo::User.delete_raw("/users/5")
-      parsed_data[:data].should == [{ :id => 5 }]
-    end
-
-    it "handles querystring parameters" do
-      Foo::User.get_raw("/users", :page => 2) do |parsed_data|
-        parsed_data[:data].should == [{ :id => 2 }]
+    describe :get_resource do
+      context "with a String path" do
+        subject { Foo::User.get_resource("/users/1") }
+        its(:id) { should == 1 }
       end
-    end
-
-    it "handles GET collection" do
-      @users = Foo::User.get_collection("/users/popular")
-      @users.length.should == 2
-      @users.first.id.should == 1
-    end
-
-    it "handles GET resource" do
-      @user = Foo::User.get_resource("/users/1")
-      @user.id.should == 1
-    end
-
-    it "handles GET collection through a symbol" do
-      @users = Foo::User.get_collection(:popular)
-      @users.length.should == 2
-      @users.first.id.should == 1
-    end
 
-    it "handles GET resource through a symbol" do
-      @user = Foo::User.get_resource(:"1")
-      @user.id.should == 1
+      context "with a Symbol" do
+        subject { Foo::User.get_resource(:"1") }
+        its(:id) { should == 1 }
+      end
     end
 
-    it "handles raw GET through a symbol" do
-      Foo::User.get_raw(:popular) do |parsed_data|
-        parsed_data[:data].should == [{ :id => 1 }, { :id => 2 }]
+    describe :get_raw do
+      specify do
+        Foo::User.get_raw(:popular) do |parsed_data|
+          parsed_data[:data].should == [{ :id => 1 }, { :id => 2 }]
+        end
       end
     end
   end
 
-  context "setting custom requests" do
+  context "setting custom HTTP requests" do
     before do
-      Her::API.setup :url => "https://api.example.com" do |builder|
-        builder.use Her::Middleware::FirstLevelParseJSON
-        builder.use Faraday::Request::UrlEncoded
-        builder.adapter :test do |stub|
+      Her::API.setup :url => "https://api.example.com" do |connection|
+        connection.use Her::Middleware::FirstLevelParseJSON
+        connection.adapter :test do |stub|
           stub.get("/users/popular") { |env| [200, {}, [{ :id => 1 }, { :id => 2 }].to_json] }
           stub.post("/users/from_default") { |env| [200, {}, { :id => 4 }.to_json] }
         end
       end
 
       spawn_model "Foo::User"
-      Foo::User.custom_get :popular, :foobar
-      Foo::User.custom_post :from_default
     end
 
-    it "handles custom methods" do
-      Foo::User.respond_to?(:popular).should be_true
-      Foo::User.respond_to?(:foobar).should be_true
-      Foo::User.respond_to?(:from_default).should be_true
-    end
+    subject { Foo::User }
 
-    it "handles custom GET requests" do
-      @users = Foo::User.popular
-      @users.length.should == 2
-      @users.first.id.should == 1
+    describe :custom_get do
+      before { Foo::User.custom_get :popular, :recent }
+      it { should respond_to(:popular) }
+      it { should respond_to(:recent) }
+
+      context "making the HTTP request" do
+        subject { Foo::User.popular }
+        its(:length) { should == 2 }
+      end
     end
 
-    it "handles custom POST requests" do
-      @user = Foo::User.from_default(:name => "Tobias Fünke")
-      @user.id.should be_true
+    describe :custom_post do
+      before { Foo::User.custom_post :from_default }
+      it { should respond_to(:from_default) }
+
+      context "making the HTTP request" do
+        subject { Foo::User.from_default(:name => "Tobias Fünke") }
+        its(:id) { should == 4 }
+      end
     end
   end
 end