castle-her 1.0.1

data/lib/castle-her/version.rb

@@ -0,0 +1,3 @@
+module Her
+  VERSION = "1.0.1"
+end

data/spec/api_spec.rb

@@ -0,0 +1,114 @@
+# 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
+      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 { expect(subject.connection.builder.handlers).to eq([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")[:parsed_data] }
+        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 { expect(parsed_data[:data]).to eq("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 })[:parsed_data] }
+
+        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 { expect(parsed_data[:data]).to eq("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")[:parsed_data] }
+        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
+          expect(parsed_data[:data]).to eq({ :id => 1, :name => "George Michael Bluth" })
+          expect(parsed_data[:errors]).to eq(["This is a single error"])
+          expect(parsed_data[:metadata]).to eq({ :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")[:parsed_data] }
+        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
+          expect(parsed_data[:data]).to eq({ :id => 1, :name => "George Michael Bluth" })
+          expect(parsed_data[:errors]).to eq([])
+          expect(parsed_data[:metadata]).to eq({})
+        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/json_api/model_spec.rb

@@ -0,0 +1,166 @@
+require 'spec_helper'
+
+describe Her::JsonApi::Model do
+  before do
+    Her::API.setup :url => "https://api.example.com" do |connection|
+      connection.use Her::Middleware::JsonApiParser
+      connection.adapter :test do |stub|
+        stub.get("/users/1") do |env| 
+          [ 
+            200,
+            {},
+            {
+              data: {
+                id:    1,
+                type: 'users',
+                attributes: {
+                  name: "Roger Federer",
+                },
+              }
+              
+            }.to_json
+          ] 
+        end
+
+        stub.get("/users") do |env| 
+          [ 
+            200,
+            {},
+            {
+              data: [
+                {
+                  id:    1,
+                  type: 'users',
+                  attributes: {
+                    name: "Roger Federer",
+                  },
+                }, 
+                {
+                  id:    2,
+                  type: 'users',
+                  attributes: {
+                    name: "Kei Nishikori",
+                  },
+                }
+              ]
+            }.to_json
+          ] 
+        end
+
+        stub.post("/users", data: {
+          type: 'users',
+          attributes: {
+            name: "Jeremy Lin",
+          },
+        }) do |env|
+          [ 
+            201,
+            {},
+            {
+              data: {
+                id:    3,
+                type: 'users',
+                attributes: {
+                  name: 'Jeremy Lin',
+                },
+              }
+              
+            }.to_json
+          ] 
+        end
+
+        stub.patch("/users/1", data: {
+          type: 'users',
+          id: 1,
+          attributes: {
+            name: "Fed GOAT",
+          },
+        }) do |env|
+          [ 
+            200,
+            {},
+            {
+              data: {
+                id:    1,
+                type: 'users',
+                attributes: {
+                  name: 'Fed GOAT',
+                },
+              }
+              
+            }.to_json
+          ] 
+        end
+
+        stub.delete("/users/1") { |env|
+          [ 204, {}, {}, ] 
+        }
+      end
+
+    end
+
+    spawn_model("Foo::User", type: Her::JsonApi::Model)
+  end
+
+  it 'allows configuration of type' do
+    spawn_model("Foo::Bar", type: Her::JsonApi::Model) do
+      type :foobars
+    end
+
+    expect(Foo::Bar.instance_variable_get('@type')).to eql('foobars')
+  end
+
+  it 'finds models by id' do
+    user = Foo::User.find(1)
+    expect(user.attributes).to eql(
+      'id' => 1,
+      'name' => 'Roger Federer',
+    )
+  end
+
+  it 'finds a collection of models' do
+    users = Foo::User.all
+    expect(users.map(&:attributes)).to match_array([
+      {
+        'id' => 1,
+        'name' => 'Roger Federer',
+      },
+      {
+        'id' => 2,
+        'name' => 'Kei Nishikori',
+      }
+    ])
+  end
+
+  it 'creates a Foo::User' do
+    user = Foo::User.new(name: 'Jeremy Lin')
+    user.save
+    expect(user.attributes).to eql(
+      'id' => 3,
+      'name' => 'Jeremy Lin',
+    )
+  end
+
+  it 'updates a Foo::User' do
+    user = Foo::User.find(1)
+    user.name = 'Fed GOAT'
+    user.save
+    expect(user.attributes).to eql(
+      'id' => 1,
+      'name' => 'Fed GOAT',
+    )
+  end
+
+  it 'destroys a Foo::User' do
+    user = Foo::User.find(1)
+    expect(user.destroy).to be_destroyed
+  end
+
+  context 'undefined methods' do
+    it 'removes methods that are not compatible with json api' do
+      [:parse_root_in_json, :include_root_in_json, :root_element, :primary_key].each do |method|
+        expect { Foo::User.new.send(method, :foo) }.to raise_error NoMethodError, "Her::JsonApi::Model does not support the #{method} configuration option"
+      end
+    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|
+      expect(headers["Accept"]).to eq("application/json")
+    end
+  end
+end

data/spec/middleware/first_level_parse_json_spec.rb

@@ -0,0 +1,62 @@
+# 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}" }
+  let(:body_with_malformed_json) { "wut." }
+  let(:body_with_invalid_json) { "true" }
+  let(:empty_body) { '' }
+  let(:nil_body) { nil }
+
+  it "parses body as json" do
+    subject.parse(body_without_errors).tap do |json|
+      expect(json[:data]).to eq({ :id => 1, :name => "Tobias Fünke" })
+      expect(json[:metadata]).to eq(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|
+      expect(json[:data]).to eq({ :id => 1, :name => "Tobias Fünke" })
+      expect(json[:metadata]).to eq(3)
+    end
+  end
+
+  it 'ensures the errors are a hash if there are no errors' do
+    expect(subject.parse(body_without_errors)[:errors]).to eq({})
+  end
+
+  it 'ensures the errors are a hash if there are no errors' do
+    expect(subject.parse(body_with_errors)[:errors]).to eq({:name => [ 'not_valid', 'should_be_present']})
+  end
+
+  it 'ensures that malformed JSON throws an exception' do
+    expect { subject.parse(body_with_malformed_json) }.to raise_error(Her::Errors::ParseError, 'Response from the API must behave like a Hash or an Array (last JSON response was "wut.")')
+  end
+
+  it 'ensures that invalid JSON throws an exception' do
+    expect { subject.parse(body_with_invalid_json) }.to raise_error(Her::Errors::ParseError, 'Response from the API must behave like a Hash or an Array (last JSON response was "true")')
+  end
+
+  it 'ensures that a nil response returns an empty hash' do
+    expect(subject.parse(nil_body)[:data]).to eq({})
+  end
+
+  it 'ensures that an empty response returns an empty hash' do
+    expect(subject.parse(empty_body)[:data]).to eq({})
+  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|
+        expect(json[:data]).to eq({})
+      end
+    end
+  end
+end

data/spec/middleware/json_api_parser_spec.rb

@@ -0,0 +1,32 @@
+# encoding: utf-8
+require "spec_helper"
+
+describe Her::Middleware::JsonApiParser do
+  subject { described_class.new }
+
+  context "with valid JSON body" do
+    let(:body) { '{"data": {"type": "foo", "id": "bar", "attributes": {"baz": "qux"} }, "meta": {"api": "json api"} }' }
+    let(:env) { { body: body } }
+
+    it "parses body as json" do
+      subject.on_complete(env)
+      env.fetch(:body).tap do |json|
+        expect(json[:data]).to eql(
+          :type => "foo",
+          :id => "bar",
+          :attributes => { :baz => "qux" } 
+        )
+        expect(json[:errors]).to eql([])
+        expect(json[:metadata]).to eql(:api => "json api")
+      end
+    end
+  end
+
+  #context "with invalid JSON body" do
+  #  let(:body) { '"foo"' }
+  #  it 'ensures that invalid JSON throws an exception' do
+  #    expect { subject.parse(body) }.to raise_error(Her::Errors::ParseError, 'Response from the API must behave like a Hash or an Array (last JSON response was "\"foo\"")')
+  #  end
+  #end
+
+end

data/spec/middleware/second_level_parse_json_spec.rb

@@ -0,0 +1,35 @@
+# encoding: utf-8
+require "spec_helper"
+
+describe Her::Middleware::SecondLevelParseJSON do
+  subject { described_class.new }
+
+  context "with valid JSON body" do
+    let(:body) { "{\"data\": 1, \"errors\": 2, \"metadata\": 3}" }
+    it "parses body as json" do
+      subject.parse(body).tap do |json|
+        expect(json[:data]).to eq(1)
+        expect(json[:errors]).to eq(2)
+        expect(json[:metadata]).to eq(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|
+        expect(json[:data]).to eq(1)
+        expect(json[:errors]).to eq(2)
+        expect(json[:metadata]).to eq(3)
+      end
+    end
+  end
+
+  context "with invalid JSON body" do
+    let(:body) { '"foo"' }
+    it 'ensures that invalid JSON throws an exception' do
+      expect { subject.parse(body) }.to raise_error(Her::Errors::ParseError, 'Response from the API must behave like a Hash or an Array (last JSON response was "\"foo\"")')
+    end
+  end
+
+end