extended_her 0.5

data/lib/her/version.rb

@@ -0,0 +1,3 @@
+module Her
+  VERSION = '0.5'
+end

data/spec/api_spec.rb

@@ -0,0 +1,131 @@
+# encoding: utf-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
+        Her::API.setup :url => "https://api.example.com"
+        Her::API.default_api.base_uri.should == "https://api.example.com"
+      end
+    end
+
+    describe "#setup" do
+      context "when using :url option" do
+        before { subject.setup :url => "https://api.example.com" }
+        its(:base_uri) { should == "https://api.example.com" }
+      end
+
+      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
+
+      context "when setting custom middleware" do
+        before do
+          class Foo; end;
+          class Bar; end;
+
+          subject.setup :url => "https://api.example.com" do |connection|
+            connection.use Foo
+            connection.use Bar
+          end
+        end
+
+        specify { subject.connection.builder.handlers.should == [Foo, Bar] }
+      end
+
+      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
+      before do
+        class SimpleParser < Faraday::Response::Middleware
+          def on_complete(env)
+            env[:body] = { :data => env[:body] }
+          end
+        end
+      end
+
+      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
+
+        specify { parsed_data[:data].should == "Foo, it is." }
+      end
+
+      context "making HTTP requests while specifying custom HTTP headers" do
+        let(:parsed_data) { subject.request(:_method => :get, :_path => "/foo", :_headers => { "X-Page" => 2 }) }
+
+        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
+
+        specify { parsed_data[:data].should == "Foo, it is page 2." }
+      end
+
+      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
+
+        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
+
+      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
+
+          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
+
+        specify do
+          parsed_data[:data].should == { :id => 1, :name => "George Michael Bluth" }
+          parsed_data[:errors].should == []
+          parsed_data[:metadata].should == {}
+        end
+      end
+    end
+  end
+end

data/spec/collection_spec.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+
+describe Her::Collection do
+
+  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({}) }
+    end
+
+    context "with parameters" do
+      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'] }) }
+    end
+  end
+end

data/spec/middleware/accept_json_spec.rb

@@ -0,0 +1,10 @@
+# encoding: utf-8
+require "spec_helper"
+
+describe Her::Middleware::AcceptJSON do
+  it "adds an Accept header" do
+    described_class.new.add_header({}).tap do |headers|
+      headers["Accept"].should == "application/json"
+    end
+  end
+end

data/spec/middleware/first_level_parse_json_spec.rb

@@ -0,0 +1,42 @@
+# encoding: utf-8
+require "spec_helper"
+
+describe Her::Middleware::FirstLevelParseJSON do
+  subject { described_class.new }
+  let(:body_without_errors) { "{\"id\": 1, \"name\": \"Tobias Fünke\", \"metadata\": 3}" }
+  let(:body_with_errors) { "{\"id\": 1, \"name\": \"Tobias Fünke\", \"errors\": { \"name\": [ \"not_valid\", \"should_be_present\" ] }, \"metadata\": 3}" }
+
+  it "parses body as json" do
+    subject.parse(body_without_errors).tap do |json|
+      json[:data].should == { :id => 1, :name => "Tobias Fünke" }
+      json[:metadata].should == 3
+    end
+  end
+
+  it "parses :body key as json in the env hash" do
+    env = { :body => body_without_errors }
+    subject.on_complete(env)
+    env[:body].tap do |json|
+      json[:data].should == { :id => 1, :name => "Tobias Fünke" }
+      json[:metadata].should == 3
+    end
+  end
+
+  it 'ensures the errors are a hash if there are no errors' do
+    subject.parse(body_without_errors)[:errors].should eq({})
+  end
+
+  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/middleware/second_level_parse_json_spec.rb

@@ -0,0 +1,25 @@
+# encoding: utf-8
+require "spec_helper"
+
+describe Her::Middleware::SecondLevelParseJSON do
+  subject { described_class.new }
+  let(:body) { "{\"data\": 1, \"errors\": 2, \"metadata\": 3}" }
+
+  it "parses body as json" do
+    subject.parse(body).tap do |json|
+      json[:data].should == 1
+      json[:errors].should == 2
+      json[:metadata].should == 3
+    end
+  end
+
+  it "parses :body key as json in the env hash" do
+    env = { :body => body }
+    subject.on_complete(env)
+    env[:body].tap do |json|
+      json[:data].should == 1
+      json[:errors].should == 2
+      json[:metadata].should == 3
+    end
+  end
+end

data/spec/model/hooks_spec.rb

@@ -0,0 +1,406 @@
+# encoding: utf-8
+require File.join(File.dirname(__FILE__), "../spec_helper.rb")
+
+describe Her::Model::Hooks do
+  context "adding hooks to a model" do
+    before do
+      spawn_model "Foo::User"
+    end
+
+    describe "method hooks" do
+      it "handles “before save” method hooks" do
+        Foo::User.before_save :set_internal_id
+        Foo::User.hooks[:before_save].length.should == 1
+        Foo::User.hooks[:before_save].first.class.should == Symbol
+      end
+
+      it "handles “before create” method hooks" do
+        Foo::User.before_create :set_internal_id
+        Foo::User.hooks[:before_create].length.should == 1
+        Foo::User.hooks[:before_create].first.class.should == Symbol
+      end
+
+      it "handles “before update” method hooks" do
+        Foo::User.before_update :set_internal_id
+        Foo::User.hooks[:before_update].length.should == 1
+        Foo::User.hooks[:before_update].first.class.should == Symbol
+      end
+
+      it "handles “before destroy” method hooks" do
+        Foo::User.before_destroy :set_internal_id
+        Foo::User.hooks[:before_destroy].length.should == 1
+        Foo::User.hooks[:before_destroy].first.class.should == Symbol
+      end
+
+      it "does not handle “before find” method hooks" do
+        expect {
+          Foo::User.before_find :set_internal_id
+        }.to raise_error(NoMethodError)
+      end
+
+      it "handles “after save” method hooks" do
+        Foo::User.after_save :set_internal_id
+        Foo::User.hooks[:after_save].length.should == 1
+        Foo::User.hooks[:after_save].first.class.should == Symbol
+      end
+
+      it "handles “after create” method hooks" do
+        Foo::User.after_create :set_internal_id
+        Foo::User.hooks[:after_create].length.should == 1
+        Foo::User.hooks[:after_create].first.class.should == Symbol
+      end
+
+      it "handles “after update” method hooks" do
+        Foo::User.after_update :set_internal_id
+        Foo::User.hooks[:after_update].length.should == 1
+        Foo::User.hooks[:after_update].first.class.should == Symbol
+      end
+
+      it "handles “after destroy” method hooks" do
+        Foo::User.after_destroy :set_internal_id
+        Foo::User.hooks[:after_destroy].length.should == 1
+        Foo::User.hooks[:after_destroy].first.class.should == Symbol
+      end
+
+      it "handles “after find” method hooks" do
+        Foo::User.after_find :set_internal_id
+        Foo::User.hooks[:after_find].length.should == 1
+        Foo::User.hooks[:after_find].first.class.should == Symbol
+      end
+    end
+
+    describe "block hooks" do
+      it "handles “before save” block hooks" do
+        Foo::User.before_save { |record| record.internal_id = 42 }
+        Foo::User.hooks[:before_save].length.should == 1
+        Foo::User.hooks[:before_save].first.class.should == Proc
+      end
+
+      it "handles “before create” block hooks" do
+        Foo::User.before_create { |record| record.internal_id = 42 }
+        Foo::User.hooks[:before_create].length.should == 1
+        Foo::User.hooks[:before_create].first.class.should == Proc
+      end
+
+      it "handles “before update” block hooks" do
+        Foo::User.before_update { |record| record.internal_id = 42 }
+        Foo::User.hooks[:before_update].length.should == 1
+        Foo::User.hooks[:before_update].first.class.should == Proc
+      end
+
+      it "handles “before destroy” block hooks" do
+        Foo::User.before_destroy { |record| record.internal_id = 42 }
+        Foo::User.hooks[:before_destroy].length.should == 1
+        Foo::User.hooks[:before_destroy].first.class.should == Proc
+      end
+
+      it "does not handle “before find” block hooks" do
+        expect {
+          Foo::User.before_find :set_internal_id
+        }.to raise_error(NoMethodError)
+      end
+
+      it "handles “after save” block hooks" do
+        Foo::User.after_save { |record| record.internal_id = 42 }
+        Foo::User.hooks[:after_save].length.should == 1
+        Foo::User.hooks[:after_save].first.class.should == Proc
+      end
+
+      it "handles “after create” block hooks" do
+        Foo::User.after_create { |record| record.internal_id = 42 }
+        Foo::User.hooks[:after_create].length.should == 1
+        Foo::User.hooks[:after_create].first.class.should == Proc
+      end
+
+      it "handles “after update” block hooks" do
+        Foo::User.after_update { |record| record.internal_id = 42 }
+        Foo::User.hooks[:after_update].length.should == 1
+        Foo::User.hooks[:after_update].first.class.should == Proc
+      end
+
+      it "handles “after destroy” block hooks" do
+        Foo::User.after_destroy { |record| record.internal_id = 42 }
+        Foo::User.hooks[:after_destroy].length.should == 1
+        Foo::User.hooks[:after_destroy].first.class.should == Proc
+      end
+
+      it "handles “after find” block hooks" do
+        Foo::User.after_find { |record| record.internal_id = 42 }
+        Foo::User.hooks[:after_find].length.should == 1
+        Foo::User.hooks[:after_find].first.class.should == Proc
+      end
+    end
+
+    context "inheriting hooks from a superclass" do
+      it "copies hooks to the subclass" do
+        Foo::User.before_save :set_internal_id
+        Foo::User.after_create { |record| record.internal_id = 42 }
+        subclass = Class.new(Foo::User)
+        subclass.hooks.object_id.should_not == Foo::User.hooks.object_id
+        subclass.hooks[:before_save].should == [:set_internal_id]
+        subclass.hooks[:after_create].length.should == 1
+      end
+    end
+  end
+
+  context "perform hooks on a model" 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|
+          stub.get("/users")      { |env| [200, {}, [{ :id => 1, :name => "Tobias Fünke" }, { :id => 2, :name => "Lindsay Fünke" }].to_json] }
+          stub.post("/users")     { |env| [200, {}, { :id => 1, :name => "Tobias Fünke" }.to_json] }
+          stub.get("/users/1")    { |env| [200, {}, { :id => 1, :name => "Tobias Fünke" }.to_json] }
+          stub.get("/users/2")    { |env| [200, {}, { :id => 2, :name => "Lindsay Fünke" }.to_json] }
+          stub.put("/users/1")    { |env| [200, {}, { :id => 1, :name => "Tobias Fünke" }.to_json] }
+          stub.delete("/users/1") { |env| [200, {}, { :id => 1, :name => "Tobias Fünke" }.to_json] }
+        end
+      end
+
+      spawn_model "Foo::User" do
+        attr_accessor :internal_save_id, :internal_create_id, :internal_update_id, :internal_destroy_id
+        attr_accessor :internal_after_save_id, :internal_after_create_id, :internal_after_update_id, :internal_after_destroy_id
+        attr_accessor :internal_after_find_id
+
+        def change_internal_save_id; @internal_save_id = 100; end
+        def change_internal_create_id; @internal_create_id = 101; end
+        def change_internal_update_id; @internal_update_id = 102; end
+        def change_internal_destroy_id; @internal_destroy_id = 103; end
+
+        def change_internal_after_save_id; @internal_after_save_id = 100; end
+        def change_internal_after_create_id; @internal_after_create_id = 101; end
+        def change_internal_after_update_id; @internal_after_update_id = 102; end
+        def change_internal_after_destroy_id; @internal_after_destroy_id = 103; end
+
+        def change_internal_after_find_id; @internal_after_find_id = 104; end
+      end
+    end
+
+    describe "method hooks" do
+      before do
+        Foo::User.before_save :change_internal_save_id
+        Foo::User.before_update :change_internal_update_id
+        Foo::User.before_create :change_internal_create_id
+        Foo::User.before_destroy :change_internal_destroy_id
+
+        Foo::User.after_save :change_internal_after_save_id
+        Foo::User.after_update :change_internal_after_update_id
+        Foo::User.after_create :change_internal_after_create_id
+        Foo::User.after_destroy :change_internal_after_destroy_id
+
+        Foo::User.after_find :change_internal_after_find_id
+      end
+
+      it "perform “before save” “before create” method hook on Model#save without an ID" do
+        @user = Foo::User.new(:fullname => "Tobias Fünke")
+        @user.save
+        @user.internal_save_id.should == 100
+        @user.internal_create_id.should == 101
+        @user.internal_update_id.should == nil
+        @user.internal_after_find_id.should == nil
+      end
+
+      it "perform “before save” and “before update” method hook on Model#save with an ID" do
+        @user = Foo::User.find(1)
+        @user.save
+        @user.internal_save_id.should == 100
+        @user.internal_create_id.should == nil
+        @user.internal_update_id.should == 102
+        @user.internal_after_find_id.should == 104
+      end
+
+      it "perform “before destroy” method hook on Model#destroy" do
+        @user = Foo::User.find(1)
+        @user.destroy
+        @user.internal_save_id.should == nil
+        @user.internal_create_id.should == nil
+        @user.internal_update_id.should == nil
+        @user.internal_destroy_id.should == 103
+        @user.internal_after_find_id.should == 104
+      end
+
+      it "perform “after save” “after create” method hook on Model#save without an ID" do
+        @user = Foo::User.new(:fullname => "Tobias Fünke")
+        @user.save
+        @user.internal_after_save_id.should == 100
+        @user.internal_after_create_id.should == 101
+        @user.internal_after_update_id.should == nil
+        @user.internal_after_find_id.should == nil
+      end
+
+      it "perform “after save” “after update” method hook on Model#save with an ID" do
+        @user = Foo::User.find(1)
+        @user.save
+        @user.internal_after_save_id.should == 100
+        @user.internal_after_create_id.should == nil
+        @user.internal_after_update_id.should == 102
+        @user.internal_after_find_id.should == 104
+      end
+
+      it "perform “after save” “after update” method hook on Model.save_existing" do
+        @user = Foo::User.save_existing(1, { :fullname => "Tobias Fünke" })
+        @user.internal_after_save_id.should == 100
+        @user.internal_after_create_id.should == nil
+        @user.internal_after_update_id.should == 102
+        @user.internal_after_find_id.should == nil
+      end
+
+      it "perform “after save” “after create” method hook on Model.create" do
+        @user = Foo::User.create({ :fullname => "Tobias Fünke" })
+        @user.internal_after_save_id.should == 100
+        @user.internal_after_create_id.should == 101
+        @user.internal_after_update_id.should == nil
+        @user.internal_after_find_id.should == nil
+      end
+
+      it "perform “after find” method hook on Model.find" do
+        @user = Foo::User.find(1)
+        @user.internal_after_find_id.should == 104
+        @user.internal_save_id.should == nil
+        @user.internal_create_id.should == nil
+        @user.internal_update_id.should == nil
+        @user.internal_destroy_id.should == nil
+      end
+
+      it "perform “after find” method hook on Model#find with IDs" do
+        @users = Foo::User.find([1,2])
+        @users.each do |user|
+          user.internal_after_find_id.should == 104
+          user.internal_save_id.should == nil
+          user.internal_create_id.should == nil
+          user.internal_update_id.should == nil
+          user.internal_destroy_id.should == nil
+        end
+      end
+
+      it "perform “after find” method hook on Model.all" do
+        @users = Foo::User.all
+        @users.each do |user|
+          user.internal_after_find_id.should == 104
+          user.internal_save_id.should == nil
+          user.internal_create_id.should == nil
+          user.internal_update_id.should == nil
+          user.internal_destroy_id.should == nil
+        end
+      end
+    end
+
+    describe "block hooks" do
+      before do
+        Foo::User.before_save { |record| record.internal_save_id = 200 }
+        Foo::User.before_create { |record| record.internal_create_id = 201 }
+        Foo::User.before_update { |record| record.internal_update_id = 202 }
+        Foo::User.before_destroy { |record| record.internal_destroy_id = 203 }
+
+        Foo::User.after_save { |record| record.internal_after_save_id = 200 }
+        Foo::User.after_create { |record| record.internal_after_create_id = 201 }
+        Foo::User.after_update { |record| record.internal_after_update_id = 202 }
+        Foo::User.after_destroy { |record| record.internal_after_destroy_id = 203 }
+        Foo::User.after_find { |record| record.internal_after_find_id = 204 }
+      end
+
+      it "perform “before save” and “before create” block hook on Model#save without an ID" do
+        @user = Foo::User.new(:fullname => "Tobias Fünke")
+        @user.save
+        @user.internal_save_id.should == 200
+        @user.internal_create_id.should == 201
+        @user.internal_update_id.should == nil
+        @user.internal_after_find_id.should == nil
+      end
+
+      it "perform “before save” and “before update” block hook on Model#save with an ID" do
+        @user = Foo::User.find(1)
+        @user.save
+        @user.internal_save_id.should == 200
+        @user.internal_create_id.should == nil
+        @user.internal_update_id.should == 202
+        @user.internal_after_find_id.should == 204
+      end
+
+      it "perform “before destroy” block hook on Model#destroy" do
+        @user = Foo::User.find(1)
+        @user.destroy
+        @user.internal_save_id.should == nil
+        @user.internal_create_id.should == nil
+        @user.internal_update_id.should == nil
+        @user.internal_destroy_id.should == 203
+        @user.internal_after_find_id.should == 204
+      end
+
+      it "perform “after save” “after create” block hook on Model#save without an ID" do
+        @user = Foo::User.new(:fullname => "Tobias Fünke")
+        @user.save
+        @user.internal_after_save_id.should == 200
+        @user.internal_after_create_id.should == 201
+        @user.internal_after_update_id.should == nil
+        @user.internal_after_find_id.should == nil
+      end
+
+      it "perform “after save” “after update” block hook on Model#save with an ID" do
+        @user = Foo::User.find(1)
+        @user.save
+        @user.internal_after_find_id.should == 204
+        @user.internal_after_save_id.should == 200
+        @user.internal_after_create_id.should == nil
+        @user.internal_after_update_id.should == 202
+      end
+
+      it "perform “after find” block hook on Model#find" do
+        @user = Foo::User.find(1)
+        @user.internal_after_find_id.should == 204
+        @user.internal_save_id.should == nil
+        @user.internal_create_id.should == nil
+        @user.internal_update_id.should == nil
+      end
+
+      it "perform “after find” method hook on Model#find with IDs" do
+        @users = Foo::User.find([1,2])
+        @users.each do |user|
+          user.internal_after_find_id.should == 204
+          user.internal_save_id.should == nil
+          user.internal_create_id.should == nil
+          user.internal_update_id.should == nil
+        end
+      end
+
+      it "perform “after find” method hook on Model.all" do
+        @users = Foo::User.all
+        @users.each do |user|
+          user.internal_after_find_id.should == 204
+          user.internal_save_id.should == nil
+          user.internal_create_id.should == nil
+          user.internal_update_id.should == nil
+        end
+      end
+
+      it "perform “after find” block hook on Model#find" do
+        @user = Foo::User.find(1)
+        @user.internal_after_find_id.should == 204
+        @user.internal_save_id.should == nil
+        @user.internal_create_id.should == nil
+        @user.internal_update_id.should == nil
+      end
+
+      it "perform “after find” method hook on Model#find with IDs" do
+        @users = Foo::User.find([1,2])
+        @users.each do |user|
+          user.internal_after_find_id.should == 204
+          user.internal_save_id.should == nil
+          user.internal_create_id.should == nil
+          user.internal_update_id.should == nil
+        end
+      end
+
+      it "perform “after find” method hook on Model.all" do
+        @users = Foo::User.all
+        @users.each do |user|
+          user.internal_after_find_id.should == 204
+          user.internal_save_id.should == nil
+          user.internal_create_id.should == nil
+          user.internal_update_id.should == nil
+        end
+      end
+    end
+  end
+end