fun_with_json_api 0.0.2 → 0.0.3

data/spec/fun_with_json_api/exception_spec.rb

@@ -8,7 +8,7 @@ describe FunWithJsonApi::Exception do
   describe '#message' do
     subject { instance.message }
 
-    it 'should return the developer-only message' do
+    it 'returns the developer-only exception message' do
       expect(subject).to eq message
     end
   end
@@ -16,14 +16,14 @@ describe FunWithJsonApi::Exception do
   describe '#payload' do
     subject { instance.payload }
 
-    it 'should wrap the payload in a array' do
+    it 'wraps the payload in a array' do
       expect(subject).to eq [payload]
     end
 
-    context 'with an array of payloads' do
+    context 'with an array of exceptions payloads' do
       let(:payload) { Array.new(3) { FunWithJsonApi::ExceptionPayload.new } }
 
-      it 'should return the payload array' do
+      it 'returns all exception payloads' do
         expect(subject).to eq payload
       end
     end
@@ -32,14 +32,14 @@ describe FunWithJsonApi::Exception do
   describe '#http_status' do
     subject { instance.http_status }
 
-    it 'should default to 400' do
+    it 'defaults to returning 400' do
       expect(subject).to eq 400
     end
 
     context 'with a payload with a status value' do
       let(:payload) { FunWithJsonApi::ExceptionPayload.new.tap { |p| p.status = '422' } }
 
-      it 'should return the payload status' do
+      it 'returns the payload status value' do
         expect(subject).to eq 422
       end
     end
@@ -49,7 +49,7 @@ describe FunWithJsonApi::Exception do
         Array.new(3) { FunWithJsonApi::ExceptionPayload.new.tap { |p| p.status = '403' } }
       end
 
-      it 'should return the common payload status value' do
+      it 'returns the common payload status value' do
         expect(subject).to eq 403
       end
     end
@@ -59,7 +59,7 @@ describe FunWithJsonApi::Exception do
         Array.new(3) { |i| FunWithJsonApi::ExceptionPayload.new.tap { |p| p.status = "40#{i}" } }
       end
 
-      it 'should fall back to 400' do
+      it 'falls back to returning 400' do
         expect(subject).to eq 400
       end
     end
@@ -69,7 +69,7 @@ describe FunWithJsonApi::Exception do
         Array.new(3) { |i| FunWithJsonApi::ExceptionPayload.new.tap { |p| p.status = "50#{i}" } }
       end
 
-      it 'should fall back to 500' do
+      it 'falls back to returning 500' do
         expect(subject).to eq 500
       end
     end

data/spec/fun_with_json_api/find_collection_from_document_spec.rb

@@ -0,0 +1,203 @@
+require 'spec_helper'
+
+describe FunWithJsonApi::FindCollectionFromDocument do
+  describe '.find' do
+    let(:deserializer) { instance_double('FunWithJsonApi::Deserializer') }
+    subject { described_class.find(document, deserializer) }
+
+    context 'with a deserializer' do
+      before { allow(deserializer).to receive(:type).and_return('person') }
+
+      context 'with a document containing a resource that matches the expected type' do
+        let(:document) { { data: [{ id: '42', type: 'person' }] } }
+
+        context 'with a resource matching the document' do
+          let!(:resource) { double('resource') }
+          before do
+            allow(deserializer).to receive(:load_collection_from_id_values)
+              .with(['42'])
+              .and_return([resource])
+          end
+
+          it 'returns the resource in a array' do
+            expect(subject).to eq [resource]
+          end
+        end
+
+        context 'with a single resource that cannot be found' do
+          let!(:resource) { double('resource') }
+          before do
+            allow(deserializer).to receive(:load_collection_from_id_values)
+              .with(['42'])
+              .and_return([])
+          end
+
+          it 'raises a MissingResource error' do
+            allow(deserializer).to receive(:id_param).and_return(:id)
+            allow(deserializer).to receive(:resource_class).and_return(
+              class_double('ActiveRecord::Base')
+            )
+            allow(deserializer).to receive(:format_collection_ids).with([]).and_return([])
+
+            expect { subject }.to raise_error(FunWithJsonApi::Exceptions::MissingResource) do |e|
+              expect(e.payload.size).to eq 1
+
+              payload = e.payload.first
+              expect(payload.status).to eq '404'
+              expect(payload.code).to eq 'missing_resource'
+              expect(payload.title).to eq 'Unable to find the requested resource'
+              expect(payload.detail).to eq "Unable to find 'person' with matching id: '42'"
+              expect(payload.pointer).to eq '/data/0/id'
+            end
+          end
+        end
+      end
+
+      context 'with a document containing multiple resource that matches the expected type' do
+        let(:document) do
+          {
+            data: [
+              { id: '42', type: 'person' },
+              { id: '43', type: 'person' },
+              { id: '44', type: 'person' }
+            ]
+          }
+        end
+
+        context 'when all resources can be found' do
+          let!(:resource_a) { double('resource', code: '42') }
+          let!(:resource_b) { double('resource', code: '43') }
+          let!(:resource_c) { double('resource', code: '44') }
+          before do
+            allow(deserializer).to receive(:load_collection_from_id_values)
+              .with(%w(42 43 44))
+              .and_return([resource_a, resource_b, resource_c])
+          end
+
+          it 'returns all resources in a array' do
+            expect(subject).to eq [resource_a, resource_b, resource_c]
+          end
+        end
+
+        context 'when not all resources could be found' do
+          let!(:resource_a) { double('resource', code: '42') }
+          let!(:resource_b) { double('resource', code: '43') }
+          let!(:resource_c) { double('resource', code: '44') }
+          before do
+            allow(deserializer).to receive(:load_collection_from_id_values)
+              .with(%w(42 43 44))
+              .and_return([resource_b])
+          end
+
+          it 'raises a MissingResource error with a payload for each error' do
+            allow(deserializer).to receive(:id_param).and_return(:code)
+            allow(deserializer).to receive(:resource_class).and_return(
+              class_double('ActiveRecord::Base')
+            )
+            allow(deserializer).to receive(:format_collection_ids).with(
+              [resource_b]
+            ).and_return([resource_b.code])
+
+            expect { subject }.to raise_error(FunWithJsonApi::Exceptions::MissingResource) do |e|
+              expect(e.payload.size).to eq 2
+
+              payload_a = e.payload.first
+              expect(payload_a.status).to eq '404'
+              expect(payload_a.code).to eq 'missing_resource'
+              expect(payload_a.title).to eq 'Unable to find the requested resource'
+              expect(payload_a.detail).to eq "Unable to find 'person' with matching id: '42'"
+              expect(payload_a.pointer).to eq '/data/0/id'
+
+              payload_b = e.payload.last
+              expect(payload_b.status).to eq '404'
+              expect(payload_b.code).to eq 'missing_resource'
+              expect(payload_b.title).to eq 'Unable to find the requested resource'
+              expect(payload_b.detail).to eq "Unable to find 'person' with matching id: '44'"
+              expect(payload_b.pointer).to eq '/data/2/id'
+            end
+          end
+        end
+      end
+
+      context 'with a document containing a resource that does not match the expected type' do
+        let(:document) { { data: [{ id: '42', type: 'blargh' }] } }
+
+        it 'raises a InvalidDocumentType error' do
+          expect { subject }.to raise_error(FunWithJsonApi::Exceptions::InvalidDocumentType) do |e|
+            expect(e.payload.size).to eq 1
+
+            payload = e.payload.first
+            expect(payload.code).to eq 'invalid_document_type'
+            expect(payload.pointer).to eq '/data/0/type'
+            expect(payload.title).to eq 'Request json_api data type does not match endpoint'
+            expect(payload.detail).to eq "Expected 'blargh' to be a 'person' resource"
+            expect(payload.status).to eq '409'
+          end
+        end
+      end
+
+      context 'with a document containing multiple resources that does not match' do
+        let(:document) do
+          {
+            data: [
+              { id: '42', type: 'person' },
+              { id: '43', type: 'foobar' },
+              { id: '44', type: 'blargh' }
+            ]
+          }
+        end
+
+        it 'raises a InvalidDocumentType error with a payload for each error' do
+          expect { subject }.to raise_error(FunWithJsonApi::Exceptions::InvalidDocumentType) do |e|
+            expect(e.payload.size).to eq 2
+
+            payload_a = e.payload.first
+            expect(payload_a.code).to eq 'invalid_document_type'
+            expect(payload_a.pointer).to eq '/data/1/type'
+            expect(payload_a.title).to eq 'Request json_api data type does not match endpoint'
+            expect(payload_a.detail).to eq "Expected 'foobar' to be a 'person' resource"
+            expect(payload_a.status).to eq '409'
+
+            payload_b = e.payload.last
+            expect(payload_b.code).to eq 'invalid_document_type'
+            expect(payload_b.pointer).to eq '/data/2/type'
+            expect(payload_b.title).to eq 'Request json_api data type does not match endpoint'
+            expect(payload_b.detail).to eq "Expected 'blargh' to be a 'person' resource"
+            expect(payload_b.status).to eq '409'
+          end
+        end
+      end
+
+      context 'with a document containing an empty array' do
+        let(:document) { { data: [] } }
+
+        it 'returns an empty array' do
+          expect(subject).to eq([])
+        end
+      end
+    end
+
+    context 'with a malformed document' do
+      it 'raises a InvalidDocument error' do
+        [
+          { id: 'foo' },
+          { data: 'string' },
+          { data: { id: '42', type: 'person' } }
+        ].each do |invalid_document|
+          expect do
+            described_class.find(invalid_document, deserializer)
+          end.to raise_error(FunWithJsonApi::Exceptions::InvalidDocument) do |e|
+            expect(e.payload.size).to eq 1
+
+            payload = e.payload.first
+            expect(payload.code).to eq 'invalid_document'
+            expect(payload.pointer).to eq '/data'
+            expect(payload.title).to eq 'Request json_api document is invalid'
+            expect(payload.detail).to eq 'Expected data to be an Array of resources'
+            expect(payload.status).to eq '400'
+          end
+        end
+      end
+    end
+  end
+end

data/spec/fun_with_json_api/find_resource_from_document_spec.rb

@@ -0,0 +1,100 @@
+require 'spec_helper'
+
+describe FunWithJsonApi::FindResourceFromDocument do
+  describe '.find' do
+    let(:deserializer) { instance_double('FunWithJsonApi::Deserializer') }
+    subject { described_class.find(document, deserializer) }
+
+    context 'with a document containing a resource' do
+      let(:document) { { data: { id: '42', type: 'person' } } }
+
+      context 'with a deserializer that matches the document' do
+        before { allow(deserializer).to receive(:type).and_return('person') }
+
+        context 'with a resource matching the document' do
+          let!(:resource) { double('resource') }
+          before do
+            allow(deserializer).to receive(:load_resource_from_id_value)
+              .with('42')
+              .and_return(resource)
+          end
+
+          it 'returns the resource' do
+            expect(subject).to eq resource
+          end
+        end
+        context 'when a resource cannot be found' do
+          let!(:resource) { double('resource') }
+          before do
+            allow(deserializer).to receive(:load_resource_from_id_value)
+              .with('42')
+              .and_return(nil)
+          end
+
+          it 'raises a MissingResource error' do
+            allow(deserializer).to receive(:id_param).and_return(:id)
+
+            expect { subject }.to raise_error(FunWithJsonApi::Exceptions::MissingResource) do |e|
+              expect(e.payload.size).to eq 1
+
+              payload = e.payload.first
+              expect(payload.status).to eq '404'
+              expect(payload.code).to eq 'missing_resource'
+              expect(payload.title).to eq 'Unable to find the requested resource'
+              expect(payload.detail).to eq "Unable to find 'person' with matching id: '42'"
+              expect(payload.pointer).to eq '/data/id'
+            end
+          end
+        end
+      end
+
+      context 'when the deserializer type does not match the document' do
+        before { allow(deserializer).to receive(:type).and_return('blargh') }
+
+        it 'raises a InvalidDocumentType error' do
+          expect { subject }.to raise_error(FunWithJsonApi::Exceptions::InvalidDocumentType) do |e|
+            expect(e.payload.size).to eq 1
+
+            payload = e.payload.first
+            expect(payload.code).to eq 'invalid_document_type'
+            expect(payload.pointer).to eq '/data/type'
+            expect(payload.title).to eq 'Request json_api data type does not match endpoint'
+            expect(payload.detail).to eq "Expected data type to be a 'blargh' resource"
+            expect(payload.status).to eq '409'
+          end
+        end
+      end
+    end
+
+    context 'with a document containing a null data atttribute' do
+      let(:document) { { data: nil } }
+
+      it 'returns nil' do
+        expect(subject).to eq(nil)
+      end
+    end
+
+    context 'with a malformed document' do
+      it 'raises a InvalidDocument error' do
+        [
+          { id: 'foo' },
+          { data: 'string' },
+          { data: [{ id: 'foo', type: 'bar' }] }
+        ].each do |invalid_document|
+          expect do
+            described_class.find(invalid_document, deserializer)
+          end.to raise_error(FunWithJsonApi::Exceptions::InvalidDocument) do |e|
+            expect(e.payload.size).to eq 1
+
+            payload = e.payload.first
+            expect(payload.code).to eq 'invalid_document'
+            expect(payload.pointer).to eq '/data'
+            expect(payload.title).to eq 'Request json_api document is invalid'
+            expect(payload.detail).to eq 'Expected data to be a Hash or null'
+            expect(payload.status).to eq '400'
+          end
+        end
+      end
+    end
+  end
+end

data/spec/fun_with_json_api/pre_deserializer_spec.rb

@@ -3,7 +3,7 @@ require 'spec_helper'
 describe FunWithJsonApi::PreDeserializer do
   describe '.parse' do
     describe 'document attributes parsing' do
-      it 'should pass through attribute values' do
+      it 'converts known attribute values into a hash' do
         deserializer = Class.new(FunWithJsonApi::Deserializer) do
           attribute :foo
         end.create
@@ -16,11 +16,11 @@ describe FunWithJsonApi::PreDeserializer do
           }
         }.deep_stringify_keys!
 
-        expect(FunWithJsonApi::PreDeserializer.parse(document, deserializer)).to eq(
+        expect(described_class.parse(document, deserializer)).to eq(
           foo: 'bar'
         )
       end
-      it 'should handle renamed attributes' do
+      it 'handles renamed attributes' do
         deserializer = Class.new(FunWithJsonApi::Deserializer) do
           attribute :foo, as: :blargh
         end.create
@@ -33,11 +33,11 @@ describe FunWithJsonApi::PreDeserializer do
           }
         }.deep_stringify_keys!
 
-        expect(FunWithJsonApi::PreDeserializer.parse(document, deserializer)).to eq(
+        expect(described_class.parse(document, deserializer)).to eq(
           blargh: 'bar'
         )
       end
-      it 'should only return known attributes' do
+      it 'only returns known attributes' do
         deserializer = Class.new(FunWithJsonApi::Deserializer) do
           attribute :foo
         end.create
@@ -51,14 +51,14 @@ describe FunWithJsonApi::PreDeserializer do
           }
         }.deep_stringify_keys!
 
-        expect(FunWithJsonApi::PreDeserializer.parse(document, deserializer)).to eq(
+        expect(described_class.parse(document, deserializer)).to eq(
           foo: 'bar'
         )
       end
     end
 
     describe 'single relationship parsing' do
-      it 'should pass through relationship values with a _id suffix' do
+      it 'outputs single relationship values with a _id suffix' do
         foo_deserializer_class = Class.new(FunWithJsonApi::Deserializer)
         deserializer = Class.new(FunWithJsonApi::Deserializer) do
           belongs_to :foo, foo_deserializer_class
@@ -74,11 +74,11 @@ describe FunWithJsonApi::PreDeserializer do
           }
         }.deep_stringify_keys!
 
-        expect(FunWithJsonApi::PreDeserializer.parse(document, deserializer)).to eq(
+        expect(described_class.parse(document, deserializer)).to eq(
           foo_id: '42'
         )
       end
-      it 'should handle renamed relationships' do
+      it 'handles renamed relationships' do
         foo_deserializer_class = Class.new(FunWithJsonApi::Deserializer)
         deserializer = Class.new(FunWithJsonApi::Deserializer) do
           belongs_to :foo, foo_deserializer_class, as: :blargh
@@ -94,11 +94,11 @@ describe FunWithJsonApi::PreDeserializer do
           }
         }.deep_stringify_keys!
 
-        expect(FunWithJsonApi::PreDeserializer.parse(document, deserializer)).to eq(
+        expect(described_class.parse(document, deserializer)).to eq(
           blargh_id: '42'
         )
       end
-      it 'should only return known relationships' do
+      it 'only returns known relationships' do
         foo_deserializer_class = Class.new(FunWithJsonApi::Deserializer)
         deserializer = Class.new(FunWithJsonApi::Deserializer) do
           belongs_to :foo, foo_deserializer_class
@@ -117,14 +117,14 @@ describe FunWithJsonApi::PreDeserializer do
           }
         }.deep_stringify_keys!
 
-        expect(FunWithJsonApi::PreDeserializer.parse(document, deserializer)).to eq(
+        expect(described_class.parse(document, deserializer)).to eq(
           foo_id: '42'
         )
       end
     end
 
     describe 'relationship collection parsing' do
-      it 'should pass through singular relationship values with a _ids suffix' do
+      it 'outputs singular relationship values with a _ids suffix' do
         foo_deserializer_class = Class.new(FunWithJsonApi::Deserializer)
         deserializer = Class.new(FunWithJsonApi::Deserializer) do
           has_many :foos, foo_deserializer_class
@@ -140,11 +140,11 @@ describe FunWithJsonApi::PreDeserializer do
           }
         }.deep_stringify_keys!
 
-        expect(FunWithJsonApi::PreDeserializer.parse(document, deserializer)).to eq(
+        expect(described_class.parse(document, deserializer)).to eq(
           foo_ids: %w(42 24)
         )
       end
-      it 'should handle renamed relationships' do
+      it 'handles renamed relationships' do
         foo_deserializer_class = Class.new(FunWithJsonApi::Deserializer)
         deserializer = Class.new(FunWithJsonApi::Deserializer) do
           has_many :foos, foo_deserializer_class, as: :blargh
@@ -160,11 +160,11 @@ describe FunWithJsonApi::PreDeserializer do
           }
         }.deep_stringify_keys!
 
-        expect(FunWithJsonApi::PreDeserializer.parse(document, deserializer)).to eq(
+        expect(described_class.parse(document, deserializer)).to eq(
           blargh_ids: %w(42 11)
         )
       end
-      it 'should only return known relationships' do
+      it 'only returns known relationship collections' do
         foo_deserializer_class = Class.new(FunWithJsonApi::Deserializer)
         deserializer = Class.new(FunWithJsonApi::Deserializer) do
           has_many :foos, foo_deserializer_class
@@ -183,14 +183,14 @@ describe FunWithJsonApi::PreDeserializer do
           }
         }.deep_stringify_keys!
 
-        expect(FunWithJsonApi::PreDeserializer.parse(document, deserializer)).to eq(
+        expect(described_class.parse(document, deserializer)).to eq(
           foo_ids: ['42']
         )
       end
     end
 
     describe 'parser exceptions' do
-      it 'should handle an invalid /data values' do
+      it 'handles an invalid /data value' do
         deserializer = Class.new(FunWithJsonApi::Deserializer).create
         [
           nil,
@@ -200,7 +200,7 @@ describe FunWithJsonApi::PreDeserializer do
           }
         ].each do |document|
           expect do
-            FunWithJsonApi::PreDeserializer.parse(document, deserializer)
+            described_class.parse(document, deserializer)
           end.to raise_error(FunWithJsonApi::Exceptions::InvalidDocument) do |e|
             expect(e.payload.size).to eq 1
 
@@ -213,7 +213,7 @@ describe FunWithJsonApi::PreDeserializer do
           end
         end
       end
-      it 'should handle invalid /data/attributes values' do
+      it 'handles an invalid /data/attributes value' do
         deserializer = Class.new(FunWithJsonApi::Deserializer).create
         [
           {
@@ -221,7 +221,7 @@ describe FunWithJsonApi::PreDeserializer do
           }
         ].each do |document|
           expect do
-            FunWithJsonApi::PreDeserializer.parse(document, deserializer)
+            described_class.parse(document, deserializer)
           end.to raise_error(FunWithJsonApi::Exceptions::InvalidDocument) do |e|
             expect(e.payload.size).to eq 1
 
@@ -234,7 +234,7 @@ describe FunWithJsonApi::PreDeserializer do
           end
         end
       end
-      it 'should handle invalid /data/relationships values' do
+      it 'handles an invalid /data/relationships value' do
         deserializer = Class.new(FunWithJsonApi::Deserializer).create
         [
           {
@@ -242,7 +242,7 @@ describe FunWithJsonApi::PreDeserializer do
           }
         ].each do |document|
           expect do
-            FunWithJsonApi::PreDeserializer.parse(document, deserializer)
+            described_class.parse(document, deserializer)
           end.to raise_error(FunWithJsonApi::Exceptions::InvalidDocument) do |e|
             expect(e.payload.size).to eq 1
 
@@ -255,7 +255,7 @@ describe FunWithJsonApi::PreDeserializer do
           end
         end
       end
-      it 'should handle a invalid relationship value' do
+      it 'handles an invalid relationship value' do
         deserializer = Class.new(FunWithJsonApi::Deserializer).create
         [
           {
@@ -269,7 +269,7 @@ describe FunWithJsonApi::PreDeserializer do
           }
         ].each do |document|
           expect do
-            FunWithJsonApi::PreDeserializer.parse(document, deserializer)
+            described_class.parse(document, deserializer)
           end.to raise_error(FunWithJsonApi::Exceptions::InvalidDocument) do |e|
             expect(e.payload.size).to eq 1