him 0.1.0

data/spec/json_api/model_spec.rb

@@ -0,0 +1,260 @@
+require "spec_helper"
+
+describe Him::JsonApi::Model do
+  before do
+    Him::API.setup url: "https://api.example.com" do |connection|
+      connection.use Him::Middleware::JsonApiParser
+      connection.adapter :test do |stub|
+        stub.get("/users/1") do
+          [
+            200,
+            {},
+            {
+              data: {
+                id:    1,
+                type: "users",
+                attributes: {
+                  name: "Roger Federer"
+                }
+              }
+
+            }.to_json
+          ]
+        end
+
+        stub.get("/users") do
+          [
+            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
+          [
+            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
+          [
+            200,
+            {},
+            {
+              data: {
+                id:    1,
+                type: "users",
+                attributes: {
+                  name: "Fed GOAT"
+                }
+              }
+
+            }.to_json
+          ]
+        end
+
+        stub.delete("/users/1") do
+          [204, {}, {}]
+        end
+      end
+    end
+
+    spawn_model("Foo::User", type: Him::JsonApi::Model)
+  end
+
+  it "allows configuration of type" do
+    spawn_model("Foo::Bar", type: Him::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, "Him::JsonApi::Model does not support the #{method} configuration option"
+      end
+    end
+  end
+
+  context "compound document" do
+    before do
+      Him::API.setup url: "https://api.example.com" do |connection|
+        connection.use Him::Middleware::JsonApiParser
+        connection.adapter :test do |stub|
+          stub.get("/players") do
+            [
+              200,
+              {},
+              {
+                data: [
+                  {
+                    id: 1,
+                    type: "players",
+                    attributes: { name: "Roger Federer" },
+                    relationships: {
+                      sponsors: {
+                        data: [
+                          { type: "sponsors", id: 1 },
+                          { type: "sponsors", id: 2 }
+                        ]
+                      },
+                      racquet: {
+                        data: { type: "racquets", id: 1 }
+                      }
+                    }
+                  },
+                  {
+                    id: 2,
+                    type: "players",
+                    attributes: { name: "Kei Nishikori" },
+                    relationships: {
+                      sponsors: {
+                        data: [
+                          { type: "sponsors", id: 2 },
+                          { type: "sponsors", id: 3 }
+                        ]
+                      },
+                      racquet: {
+                        data: { type: "racquets", id: 2 }
+                      }
+                    }
+                  },
+                  {
+                    id: 3,
+                    type: "players",
+                    attributes: { name: "Hubert Huang", racquet_id: nil },
+                    relationships: {}
+                  }
+                ],
+                included: [
+                  { type: "sponsors", id: 1, attributes: { company: "Nike" } },
+                  { type: "sponsors", id: 2, attributes: { company: "Wilson" } },
+                  { type: "sponsors", id: 3, attributes: { company: "Uniqlo" } },
+                  { type: "racquets", id: 1, attributes: { name: "Wilson Pro Staff" } },
+                  { type: "racquets", id: 2, attributes: { name: "Wilson Steam" } }
+                ]
+              }.to_json
+            ]
+          end
+
+          stub.get("/players/3/sponsors") do
+            [200, {}, { data: [] }.to_json]
+          end
+        end
+      end
+
+      spawn_model("Foo::Sponsor", type: Him::JsonApi::Model)
+      spawn_model("Foo::Racquet", type: Him::JsonApi::Model)
+      spawn_model("Foo::Player", type: Him::JsonApi::Model) do
+        has_many :sponsors
+        belongs_to :racquet
+      end
+    end
+
+    it "parses included resources into associations from compound documents" do
+      players = Foo::Player.all.to_a
+      fed = players.detect { |p| p.name == "Roger Federer" }
+      expect(fed.sponsors.map(&:company)).to match_array ["Nike", "Wilson"]
+      expect(fed.racquet.name).to eq "Wilson Pro Staff"
+
+      kei = players.detect { |p| p.name == "Kei Nishikori" }
+      expect(kei.sponsors.map(&:company)).to match_array ["Uniqlo", "Wilson"]
+      expect(kei.racquet.name).to eq "Wilson Steam"
+
+      hubert = players.detect { |p| p.name == "Hubert Huang" }
+      expect(hubert.sponsors).to eq []
+      expect(hubert.racquet).to be_nil
+    end
+  end
+end

data/spec/middleware/accept_json_spec.rb

@@ -0,0 +1,11 @@
+# encoding: utf-8
+
+require "spec_helper"
+
+describe Him::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,63 @@
+# encoding: utf-8
+
+require "spec_helper"
+
+describe Him::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: %w[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(Him::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(Him::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,52 @@
+# encoding: utf-8
+
+require "spec_helper"
+
+describe Him::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 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
+
+  context 'with status code 304' do
+    it 'returns an empty body' do
+      env = { :status => 304 }
+      subject.on_complete(env)
+      env[:body].tap do |json|
+        expect(json[:data]).to eq({})
+      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(Him::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 Him::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(Him::Errors::ParseError, 'Response from the API must behave like a Hash or an Array (last JSON response was "\"foo\"")')
+    end
+  end
+end

data/spec/model/associations/association_proxy_spec.rb

@@ -0,0 +1,29 @@
+# encoding: utf-8
+
+require "spec_helper"
+
+describe Him::Model::Associations::AssociationProxy do
+  describe "proxy assignment methods" do
+    before do
+      Him::API.setup url: "https://api.example.com" do |builder|
+        builder.use Him::Middleware::FirstLevelParseJSON
+        builder.use Faraday::Request::UrlEncoded
+        builder.adapter :test do |stub|
+          stub.get("/users/1") { [200, {}, { id: 1, name: "Tobias Fünke" }.to_json] }
+          stub.get("/users/1/fish") { [200, {}, { id: 1, name: "Tobias's Fish" }.to_json] }
+        end
+      end
+      spawn_model "User" do
+        has_one :fish
+      end
+      spawn_model "Fish"
+    end
+
+    subject { User.find(1) }
+
+    it "should assign value" do
+      subject.fish.name = "Fishy"
+      expect(subject.fish.name).to eq "Fishy"
+    end
+  end
+end