fun_with_json_api 0.0.2 → 0.0.3

data/spec/fun_with_json_api/railtie_spec.rb

@@ -0,0 +1,88 @@
+require 'spec_helper'
+
+describe FunWithJsonApi::Railtie do
+  describe 'controller parameters' do
+    context 'with a application/vnd.api+json request content-type', type: :controller do
+      controller do
+        def index
+          # Concatinates /data/id and /data/type from a json_api request
+          render text: "#{params[:data][:id]}:#{params['data']['type']}"
+        end
+      end
+
+      it 'converts the request body into param values' do
+        json_api_data = { data: { id: '42', type: 'foobar' } }
+
+        get :index,
+            json_api_data.as_json,
+            'Content-Type' => 'application/vnd.api+json'
+        expect(response.body).to eq '42:foobar'
+      end
+    end
+    context 'with an implicit respond_to json_api block', type: :controller do
+      controller do
+        def index
+          respond_to do |format|
+            format.json_api { render text: 'passed' }
+            format.all { render text: 'failed' }
+          end
+        end
+      end
+
+      it 'responds to a json_api format request' do
+        get :index, format: :json_api
+        expect(response.body).to eq 'passed'
+      end
+      it 'responds to a application/vnd.api+json accept header' do
+        request.env['HTTP_ACCEPT'] = 'application/vnd.api+json'
+        get :index
+        expect(response.body).to eq 'passed'
+      end
+    end
+  end
+
+  describe 'controller rendering' do
+    context 'with an explicit render json_api call', type: :controller do
+      controller do
+        def index
+          render json_api: { data: { id: '42', type: 'foobar' } }
+        end
+      end
+
+      it 'renders out the hash as a json_api response' do
+        get :index
+        expect(response.content_type).to eq 'application/vnd.api+json'
+        expect(JSON.parse(response.body)).to eq(
+          'data' => { 'id' => '42', 'type' => 'foobar' }
+        )
+      end
+    end
+    context 'with a resource and a serializer', type: :controller do
+      controller do
+        def index
+          author = ARModels::Author.new(id: 42, name: 'Foo Bar')
+          render json_api: author, serializer: ARModels::AuthorSerializer
+        end
+      end
+
+      it 'renders the resource as a json api document' do
+        get :index
+        expect(response.content_type).to eq 'application/vnd.api+json'
+        expect(JSON.parse(response.body)).to eq(
+          'data' => {
+            'id' => '42',
+            'type' => 'person',
+            'attributes' => {
+              'name' => 'Foo Bar'
+            },
+            'relationships' => {
+              'posts' => {
+                'data' => []
+              }
+            }
+          }
+        )
+      end
+    end
+  end
+end

data/spec/fun_with_json_api/schema_validator_spec.rb

@@ -0,0 +1,94 @@
+require 'spec_helper'
+
+describe FunWithJsonApi::SchemaValidator do
+  let(:document) { { data: { id: '42', type: 'examples' } } }
+  let(:deserializer) { instance_double('FunWithJsonApi::Deserializer') }
+  let(:resource) { double('Resource') }
+  subject(:instance) { described_class.send :new, document, deserializer, resource }
+
+  describe '.check' do
+    subject { described_class.check(document, deserializer, resource) }
+
+    it 'calls all schema validator checks with an instance of itself' do
+      [
+        FunWithJsonApi::SchemaValidators::CheckDocumentTypeMatchesResource,
+        FunWithJsonApi::SchemaValidators::CheckDocumentIdMatchesResource
+      ].each do |validator_check|
+        expect(validator_check).to receive(:call).with(kind_of(described_class))
+      end
+
+      converted_document = { 'data' => { 'id' => '42', 'type' => 'examples' } }
+      [
+        FunWithJsonApi::SchemaValidators::CheckAttributes,
+        FunWithJsonApi::SchemaValidators::CheckRelationships
+      ].each do |property_check|
+        expect(property_check).to receive(:call).with(converted_document, deserializer)
+      end
+
+      subject
+    end
+  end
+
+  describe '#document_id' do
+    subject { instance.document_id }
+
+    context 'when the api document has symbolized keys' do
+      context 'when the data attribute has an id value' do
+        let(:document) { { data: { id: '42', type: 'examples' } } }
+
+        it 'returns the /data/id value' do
+          is_expected.to eq '42'
+        end
+      end
+      context 'when the data attribute does not have an id value' do
+        let(:document) { { data: { type: 'examples' } } }
+
+        it { is_expected.to eq nil }
+      end
+    end
+    context 'when the api document has string keys' do
+      context 'when the data attribute has an id value' do
+        let(:document) { { 'data' => { 'id' => '42', 'type' => 'examples' } } }
+
+        it 'returns the /data/id value' do
+          is_expected.to eq '42'
+        end
+      end
+      context 'when the data attribute does not have an id value' do
+        let(:document) { { 'data' => { 'type' => 'examples' } } }
+
+        it { is_expected.to eq nil }
+      end
+    end
+  end
+
+  describe '#resource_id' do
+    subject { instance.resource_id }
+
+    context 'when the deserializer#id_param is :id' do
+      before { allow(deserializer).to receive(:id_param).and_return(:id) }
+
+      it 'returns the resource id as a string' do
+        expect(resource).to receive(:id).and_return(42)
+        expect(subject).to eq '42'
+      end
+    end
+    context 'when the deserializer#id_param a field value' do
+      before { allow(deserializer).to receive(:id_param).and_return(:code) }
+
+      it 'returns the resource field value as a string' do
+        expect(resource).to receive(:code).and_return('foobar')
+        expect(subject).to eq 'foobar'
+      end
+    end
+  end
+
+  describe '#resource_type' do
+    subject { instance.resource_type }
+
+    it 'returns the deserializer type' do
+      expect(deserializer).to receive(:type).and_return('examples')
+      expect(subject).to eq 'examples'
+    end
+  end
+end

data/spec/fun_with_json_api/schema_validators/check_attributes_spec.rb

@@ -0,0 +1,52 @@
+require 'spec_helper'
+
+describe FunWithJsonApi::SchemaValidators::CheckAttributes do
+  describe '.call' do
+    let(:document) do
+      {
+        'data' => {
+          'id' => '42',
+          'type' => 'examples',
+          'attributes' => {
+            'foobar' => 'blargh'
+          }
+        }
+      }
+    end
+    let(:deserializer) { instance_double('FunWithJsonApi::Deserializer', type: 'examples') }
+    subject { described_class.call(document, deserializer) }
+
+    context 'when the document contains an attribute supported by the deserializer' do
+      let(:attribute) { instance_double('FunWithJsonApi::Attribute', name: :foobar) }
+      before { allow(deserializer).to receive(:attributes).and_return([attribute]) }
+
+      it 'returns true' do
+        expect(subject).to eq true
+      end
+    end
+
+    context 'when the document contains an unsupported attribute' do
+      before { allow(deserializer).to receive(:attributes).and_return([]) }
+
+      it 'raises a UnknownAttribute error' do
+        expect do
+          subject
+        end.to raise_error(FunWithJsonApi::Exceptions::UnknownAttribute) do |e|
+          expect(e.payload.size).to eq 1
+
+          payload = e.payload.first
+          expect(payload.code).to eq 'unknown_attribute'
+          expect(payload.pointer).to eq '/data/attributes/foobar'
+          expect(payload.title).to eq(
+            'Request json_api attribute is unsupported by the current endpoint'
+          )
+          expect(payload.detail).to eq(
+            "The provided attribute 'foobar' can not be assigned to a 'examples' resource"\
+            ' from the current endpoint'
+          )
+          expect(payload.status).to eq '422'
+        end
+      end
+    end
+  end
+end

data/spec/fun_with_json_api/schema_validators/check_document_id_matches_resource_spec.rb

@@ -0,0 +1,115 @@
+require 'spec_helper'
+
+describe FunWithJsonApi::SchemaValidators::CheckDocumentIdMatchesResource do
+  describe '.call' do
+    let(:schema_validator) do
+      instance_double('FunWithJsonApi::SchemaValidator', resource_type: 'examples')
+    end
+    subject { described_class.call(schema_validator) }
+
+    context 'when the resource is persisted' do
+      let(:resource) { instance_double('ActiveRecord::Base', persisted?: true) }
+      before { allow(schema_validator).to receive(:resource).and_return(resource) }
+
+      context 'when /data/id does not match the resource id' do
+        before do
+          allow(schema_validator).to receive(:resource_id).and_return('11')
+          allow(schema_validator).to receive(:document_id).and_return('42')
+        end
+
+        it 'raises a InvalidDocumentIdentifier error' do
+          expect do
+            subject
+          end.to raise_error(FunWithJsonApi::Exceptions::InvalidDocumentIdentifier) do |e|
+            expect(e.payload.size).to eq 1
+
+            payload = e.payload.first
+            expect(payload.code).to eq 'invalid_document_identifier'
+            expect(payload.pointer).to eq '/data/id'
+            expect(payload.title).to eq 'Request json_api data id is invalid'
+            expect(payload.detail).to eq 'Expected data id to match resource at endpoint: 11'
+            expect(payload.status).to eq '409'
+          end
+        end
+      end
+    end
+
+    context 'when the resource is not persisted' do
+      let(:resource) { instance_double('ActiveRecord::Base', persisted?: false) }
+      before { allow(schema_validator).to receive(:resource).and_return(resource) }
+
+      context 'when a document_id has been supplied' do
+        before { allow(schema_validator).to receive(:document_id).and_return('42') }
+
+        context 'when the deserializer does not have an id attribute' do
+          let(:deserializer) { instance_double('FunWithJsonApi::Deserializer') }
+          before do
+            allow(schema_validator).to receive(:deserializer).and_return(deserializer)
+            allow(deserializer).to receive(:attributes).and_return([])
+          end
+
+          it 'raises a IllegalClientGeneratedIdentifier error' do
+            expect do
+              subject
+            end.to raise_error(FunWithJsonApi::Exceptions::IllegalClientGeneratedIdentifier) do |e|
+              expect(e.payload.size).to eq 1
+
+              payload = e.payload.first
+              expect(payload.code).to eq 'illegal_client_generated_identifier'
+              expect(payload.pointer).to eq '/data/id'
+              expect(payload.title).to eq(
+                'Request json_api attempted to set an unsupported client-generated id'
+              )
+              expect(payload.detail).to eq(
+                "The current endpoint does not allow you to set an id for a new 'examples' resource"
+              )
+              expect(payload.status).to eq '403'
+            end
+          end
+        end
+        context 'when the deserializer has an id attribute' do
+          let(:deserializer) { instance_double('FunWithJsonApi::Deserializer') }
+          before do
+            allow(schema_validator).to receive(:deserializer).and_return(deserializer)
+            allow(deserializer).to receive(:attributes).and_return(
+              [
+                instance_double('FunWithJsonApi::Attribute', name: :id)
+              ]
+            )
+          end
+
+          context 'when a resource matching id exists' do
+            before do
+              allow(deserializer).to receive(:load_resource_from_id_value)
+                .with('42')
+                .and_return(double('existing_resource', id: '24'))
+            end
+
+            it 'raises a InvalidClientGeneratedIdentifier error' do
+              expect do
+                subject
+              end.to raise_error(
+                FunWithJsonApi::Exceptions::InvalidClientGeneratedIdentifier
+              ) do |e|
+                expect(e.payload.size).to eq 1
+
+                payload = e.payload.first
+                expect(payload.code).to eq 'invalid_client_generated_identifier'
+                expect(payload.pointer).to eq '/data/id'
+                expect(payload.title).to eq(
+                  'Request json_api data id has already been used for an existing'\
+                  ' resource'
+                )
+                expect(payload.detail).to eq(
+                  "The provided id for a new 'examples' resource has already been used by another"\
+                  ' resource: 42'
+                )
+                expect(payload.status).to eq '409'
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/spec/fun_with_json_api/schema_validators/check_document_type_matches_resource_spec.rb

@@ -0,0 +1,30 @@
+require 'spec_helper'
+
+describe FunWithJsonApi::SchemaValidators::CheckDocumentTypeMatchesResource do
+  describe '.call' do
+    let(:schema_validator) do
+      instance_double('FunWithJsonApi::SchemaValidator')
+    end
+    subject { described_class.call(schema_validator) }
+
+    context 'when document_type does not match resource_type' do
+      before do
+        allow(schema_validator).to receive(:document_type).and_return('examples')
+        allow(schema_validator).to receive(:resource_type).and_return('foobar')
+      end
+
+      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 'foobar' resource"
+          expect(payload.status).to eq '409'
+        end
+      end
+    end
+  end
+end

data/spec/fun_with_json_api/schema_validators/check_relationships_spec.rb

@@ -0,0 +1,150 @@
+require 'spec_helper'
+
+describe FunWithJsonApi::SchemaValidators::CheckRelationships do
+  describe '.call' do
+    let(:document) do
+      {
+        'data' => {
+          'id' => '42',
+          'type' => 'examples',
+          'relationships' => {
+            'foobar' => {
+              'data' => relationship_data
+            }
+          }
+        }
+      }
+    end
+    let(:relationship_data) { double('relationship_data') }
+    let(:deserializer) { instance_double('FunWithJsonApi::Deserializer', type: 'examples') }
+    subject { described_class.call(document, deserializer) }
+
+    context 'with a has-one relationship' do
+      let(:relationship) do
+        instance_double('FunWithJsonApi::Relationship', name: :foobar, has_many?: false)
+      end
+      before { allow(deserializer).to receive(:relationships).and_return([relationship]) }
+
+      context 'when the relationship item is a hash' do
+        let(:relationship_data) { { 'id' => '24', 'type' => 'foobars' } }
+
+        context 'when the type matches the relationship' do
+          before { allow(relationship).to receive(:type).and_return('foobars') }
+
+          it { is_expected.to eq true }
+        end
+
+        context 'when the type does not match the relationship' do
+          before { allow(relationship).to receive(:type).and_return('invalid') }
+
+          it 'raises a InvalidRelationshipType error' do
+            expect do
+              subject
+            end.to raise_error(FunWithJsonApi::Exceptions::InvalidRelationshipType) do |e|
+              expect(e.payload.size).to eq 1
+
+              payload = e.payload.first
+              expect(payload.code).to eq 'invalid_relationship_type'
+              expect(payload.pointer).to eq '/data/relationships/foobar/type'
+              expect(payload.title).to eq(
+                'Request json_api relationship type does not match expected resource'
+              )
+              expect(payload.detail).to eq(
+                "Expected 'foobar' relationship to be null or a 'invalid' resource identifier Hash"
+              )
+              expect(payload.status).to eq '409'
+            end
+          end
+        end
+      end
+
+      context 'when the relationship item is nil' do
+        let(:relationship_data) { nil }
+
+        it { is_expected.to eq true }
+      end
+
+      context 'when the relationship item is a array' do
+        let(:relationship_data) { [{ 'id' => '24', 'type' => 'foobars' }] }
+
+        it { is_expected.to eq true }
+      end
+    end
+
+    context 'with a has-many relationship' do
+      let(:relationship) do
+        instance_double('FunWithJsonApi::RelationshipCollection', name: :foobar, has_many?: true)
+      end
+      before { allow(deserializer).to receive(:relationships).and_return([relationship]) }
+
+      context 'when the relationship item is a array' do
+        let(:relationship_data) { [{ 'id' => '24', 'type' => 'foobars' }] }
+
+        context 'when the type matches the relationship' do
+          before { allow(relationship).to receive(:type).and_return('foobars') }
+
+          it { is_expected.to eq true }
+        end
+
+        context 'when the type does not match the deserializer' do
+          before { allow(relationship).to receive(:type).and_return('invalid') }
+
+          it 'raises a InvalidRelationshipType error' do
+            expect do
+              subject
+            end.to raise_error(FunWithJsonApi::Exceptions::InvalidRelationshipType) do |e|
+              expect(e.payload.size).to eq 1
+
+              payload = e.payload.first
+              expect(payload.code).to eq 'invalid_relationship_type'
+              expect(payload.pointer).to eq '/data/relationships/foobar/0/type'
+              expect(payload.title).to eq(
+                'Request json_api relationship type does not match expected resource'
+              )
+              expect(payload.detail).to eq(
+                "Expected 'foobar' relationship to be an Array of 'invalid' resource identifiers"
+              )
+              expect(payload.status).to eq '409'
+            end
+          end
+        end
+      end
+
+      context 'when the relationship item is a hash' do
+        let(:relationship_data) { { 'id' => '24', 'type' => 'foobars' } }
+
+        it { is_expected.to eq true }
+      end
+
+      context 'when the relationship item is nil' do
+        let(:relationship_data) { nil }
+
+        it { is_expected.to eq true }
+      end
+    end
+
+    context 'when the document contains an unsupported relationships' do
+      before { allow(deserializer).to receive(:relationships).and_return([]) }
+
+      it 'raises a UnknownRelationship error' do
+        expect do
+          subject
+        end.to raise_error(FunWithJsonApi::Exceptions::UnknownRelationship) do |e|
+          expect(e.payload.size).to eq 1
+
+          payload = e.payload.first
+          expect(payload.code).to eq 'unknown_relationship'
+          expect(payload.pointer).to eq '/data/relationships/foobar'
+          expect(payload.title).to eq(
+            'Request json_api relationship is unsupported by the current endpoint'
+          )
+          expect(payload.detail).to eq(
+            "The provided relationship 'foobar' can not be assigned to a 'examples' resource"\
+            ' from the current endpoint'
+          )
+          expect(payload.status).to eq '422'
+        end
+      end
+    end
+  end
+end