her 0.8.2 → 0.10.4

data/spec/json_api/model_spec.rb

@@ -1,163 +1,166 @@
-require 'spec_helper'
+require "spec_helper"
 
 describe Her::JsonApi::Model do
   before do
-    Her::API.setup :url => "https://api.example.com" do |connection|
+    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| 
-          [ 
+        stub.get("/users/1") do
+          [
             200,
             {},
             {
               data: {
                 id:    1,
-                type: 'users',
+                type: "users",
                 attributes: {
-                  name: "Roger Federer",
-                },
+                  name: "Roger Federer"
+                }
               }
-              
+
             }.to_json
-          ] 
+          ]
         end
 
-        stub.get("/users") do |env| 
-          [ 
+        stub.get("/users") do
+          [
             200,
             {},
             {
               data: [
                 {
                   id:    1,
-                  type: 'users',
+                  type: "users",
                   attributes: {
-                    name: "Roger Federer",
-                  },
-                }, 
+                    name: "Roger Federer"
+                  }
+                },
                 {
                   id:    2,
-                  type: 'users',
+                  type: "users",
                   attributes: {
-                    name: "Kei Nishikori",
-                  },
+                    name: "Kei Nishikori"
+                  }
                 }
               ]
             }.to_json
-          ] 
+          ]
         end
 
-        stub.post("/users", data: {
-          type: 'users',
+        stub.post("/users", data:
+        {
+          type: "users",
           attributes: {
-            name: "Jeremy Lin",
-          },
-        }) do |env|
-          [ 
+            name: "Jeremy Lin"
+          }
+        }) do
+          [
             201,
             {},
             {
               data: {
                 id:    3,
-                type: 'users',
+                type: "users",
                 attributes: {
-                  name: 'Jeremy Lin',
-                },
+                  name: "Jeremy Lin"
+                }
               }
-              
+
             }.to_json
-          ] 
+          ]
         end
 
-        stub.patch("/users/1", data: {
-          type: 'users',
+        stub.patch("/users/1", data:
+        {
+          type: "users",
           id: 1,
           attributes: {
-            name: "Fed GOAT",
-          },
-        }) do |env|
-          [ 
+            name: "Fed GOAT"
+          }
+        }) do
+          [
             200,
             {},
             {
               data: {
                 id:    1,
-                type: 'users',
+                type: "users",
                 attributes: {
-                  name: 'Fed GOAT',
-                },
+                  name: "Fed GOAT"
+                }
               }
-              
+
             }.to_json
-          ] 
+          ]
         end
 
-        stub.delete("/users/1") { |env|
-          [ 204, {}, {}, ] 
-        }
+        stub.delete("/users/1") do
+          [204, {}, {}]
+        end
       end
-
     end
 
     spawn_model("Foo::User", type: Her::JsonApi::Model)
   end
 
-  it 'allows configuration of type' do
+  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')
+    expect(Foo::Bar.instance_variable_get("@type")).to eql("foobars")
   end
 
-  it 'finds models by id' do
+  it "finds models by id" do
     user = Foo::User.find(1)
     expect(user.attributes).to eql(
-      'id' => 1,
-      'name' => 'Roger Federer',
+      "id" => 1,
+      "name" => "Roger Federer"
     )
   end
 
-  it 'finds a collection of models' do
+  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',
-      }
-    ])
+    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')
+  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',
+      "id" => 3,
+      "name" => "Jeremy Lin"
     )
   end
 
-  it 'updates a Foo::User' do
+  it "updates a Foo::User" do
     user = Foo::User.find(1)
-    user.name = 'Fed GOAT'
+    user.name = "Fed GOAT"
     user.save
     expect(user.attributes).to eql(
-      'id' => 1,
-      'name' => 'Fed GOAT',
+      "id" => 1,
+      "name" => "Fed GOAT"
     )
   end
 
-  it 'destroys a Foo::User' do
+  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
+  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

data/spec/middleware/accept_json_spec.rb

@@ -4,7 +4,7 @@ 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"
+      expect(headers["Accept"]).to eq("application/json")
     end
   end
 end

data/spec/middleware/first_level_parse_json_spec.rb

@@ -7,55 +7,55 @@ describe Her::Middleware::FirstLevelParseJSON do
   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(:empty_body) { "" }
   let(:nil_body) { nil }
 
   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
+      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 }
+    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
+      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
-    subject.parse(body_without_errors)[:errors].should eq({})
+  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
-    subject.parse(body_with_errors)[:errors].should eq({:name => [ 'not_valid', 'should_be_present']})
+  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
+  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
+  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
-    subject.parse(nil_body)[:data].should eq({})
+  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
-    subject.parse(empty_body)[:data].should eq({})
+  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 }
+  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 == { }
+        expect(json[:data]).to eq({})
       end
     end
   end

data/spec/middleware/json_api_parser_spec.rb

@@ -12,21 +12,40 @@ describe Her::Middleware::JsonApiParser do
       subject.on_complete(env)
       env.fetch(:body).tap do |json|
         expect(json[:data]).to eql(
-          :type => "foo",
-          :id => "bar",
-          :attributes => { :baz => "qux" } 
+          type: "foo",
+          id: "bar",
+          attributes: { baz: "qux" }
         )
         expect(json[:errors]).to eql([])
-        expect(json[:metadata]).to eql(:api => "json api")
+        expect(json[:metadata]).to eql(api: "json api")
       end
     end
   end
 
-  #context "with invalid JSON body" do
+  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(Her::Errors::ParseError, 'Response from the API must behave like a Hash or an Array (last JSON response was "\"foo\"")')
   #  end
-  #end
-
+  # end
 end

data/spec/middleware/second_level_parse_json_spec.rb

@@ -8,28 +8,27 @@ describe Her::Middleware::SecondLevelParseJSON do
     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
+        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 }
+      env = { body: body }
       subject.on_complete(env)
       env[:body].tap do |json|
-        json[:data].should == 1
-        json[:errors].should == 2
-        json[:metadata].should == 3
+        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
+    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/model/associations/association_proxy_spec.rb

@@ -8,8 +8,8 @@ describe Her::Model::Associations::AssociationProxy do
         builder.use Her::Middleware::FirstLevelParseJSON
         builder.use Faraday::Request::UrlEncoded
         builder.adapter :test do |stub|
-          stub.get("/users/1") { |env| [200, {}, { :id => 1, :name => "Tobias Fünke" }.to_json ] }
-          stub.get("/users/1/fish") { |env| [200, {}, { :id => 1, :name => "Tobias's Fish" }.to_json ] }
+          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
@@ -26,6 +26,3 @@ describe Her::Model::Associations::AssociationProxy do
     end
   end
 end
-
-
-