fun_with_json_api 0.0.2 → 0.0.3

data/spec/fixtures/active_record.rb

@@ -54,6 +54,12 @@ module ARModels
     belongs_to :author, -> { AuthorDeserializer }
   end
 
+  class AuthorSerializer < ActiveModel::Serializer
+    type 'person'
+    attribute :name
+    has_many :posts
+  end
+
   class AuthorDeserializer < FunWithJsonApi::Deserializer
     type 'person'
     resource_class Author

data/spec/fun_with_json_api/controller_methods_spec.rb

@@ -4,7 +4,9 @@ describe FunWithJsonApi::ControllerMethods, type: :controller do
   describe '#render_fun_with_json_api_exception' do
     context 'with a controller that raises an exception' do
       controller do
+        # rubocop:disable RSpec/DescribedClass
         include FunWithJsonApi::ControllerMethods
+        # rubocop:enable RSpec/DescribedClass
 
         rescue_from FunWithJsonApi::Exception, with: :render_fun_with_json_api_exception
 
@@ -35,9 +37,10 @@ describe FunWithJsonApi::ControllerMethods, type: :controller do
         it 'returns a json api error status' do
           get :index
           expect(response.status).to eq 403
+          expect(response.content_type).to eq 'application/vnd.api+json'
         end
 
-        it 'renders the exception payload as a json api errors response ' do
+        it 'renders the exception payload as a json api errors response' do
           get :index
           expect(JSON.parse(response.body)).to eq(
             'errors' => [
@@ -74,9 +77,10 @@ describe FunWithJsonApi::ControllerMethods, type: :controller do
         it 'returns a json api error status' do
           get :index
           expect(response.status).to eq 403
+          expect(response.content_type).to eq 'application/vnd.api+json'
         end
 
-        it 'renders all exception payload items ' do
+        it 'renders all exception payload items' do
           get :index
           expect(JSON.parse(response.body)).to eq(
             'errors' => [
@@ -104,9 +108,10 @@ describe FunWithJsonApi::ControllerMethods, type: :controller do
         it 'returns a json api error status' do
           get :index
           expect(response.status).to eq 422
+          expect(response.content_type).to eq 'application/vnd.api+json'
         end
 
-        it 'only renders the non-nil params ' do
+        it 'only renders the non-nil params' do
           get :index
           expect(JSON.parse(response.body)).to eq(
             'errors' => [

data/spec/fun_with_json_api/deserializer_class_methods_spec.rb

@@ -2,14 +2,18 @@ require 'spec_helper'
 
 describe FunWithJsonApi::DeserializerClassMethods do
   describe '.belongs_to' do
-    it 'should add a Relationship attribute' do
+    it 'adds a Relationship attribute' do
       foos_deserializer_class = Class.new(FunWithJsonApi::Deserializer) do
         attribute :blargh
+        has_many :foos, -> { foos_deserializer_class }
       end
       deserializer_class = Class.new(FunWithJsonApi::Deserializer) do
         belongs_to :foo, -> { foos_deserializer_class }
       end
-      relationship = deserializer_class.relationships.last
+
+      deserializer = deserializer_class.create
+
+      relationship = deserializer.relationships.last
       expect(relationship).to be_kind_of(FunWithJsonApi::Attributes::Relationship)
 
       expect(relationship.name).to eq :foo
@@ -22,14 +26,18 @@ describe FunWithJsonApi::DeserializerClassMethods do
   end
 
   describe '.has_many' do
-    it 'should add a RelationshipCollection attribute' do
+    it 'adds a RelationshipCollection attribute' do
       foos_deserializer_class = Class.new(FunWithJsonApi::Deserializer) do
         attribute :blargh
+        has_many :foos, -> { foos_deserializer_class }
       end
       deserializer_class = Class.new(FunWithJsonApi::Deserializer) do
         has_many :foos, -> { foos_deserializer_class }
       end
-      relationship = deserializer_class.relationships.last
+
+      deserializer = deserializer_class.create
+
+      relationship = deserializer.relationships.last
       expect(relationship).to be_kind_of(FunWithJsonApi::Attributes::RelationshipCollection)
 
       expect(relationship.name).to eq :foos
@@ -40,12 +48,12 @@ describe FunWithJsonApi::DeserializerClassMethods do
       expect(relationship.deserializer.relationships).to eq []
     end
 
-    it 'should not allow pluralized as values' do
+    it 'does not allow pluralized "as" values' do
       foos_deserializer_class = Class.new(FunWithJsonApi::Deserializer)
       expect do
         Class.new(FunWithJsonApi::Deserializer) do
           has_many :foos, -> { foos_deserializer_class }, as: 'foos'
-        end
+        end.relationships
       end.to raise_error(ArgumentError, 'Use a singular relationship as value: {as: :foo}')
     end
   end

data/spec/fun_with_json_api/deserializer_spec.rb

@@ -37,40 +37,115 @@ def deserializer_with_attribute(attribute, attribute_options = {})
 end
 
 describe FunWithJsonApi::Deserializer do
+  describe '.id_param' do
+    context 'with no arguments' do
+      it 'sets id_param to id for all new deserializer instances' do
+        instance = Class.new(described_class).create
+        expect(instance.id_param).to eq :id
+        expect(instance.attributes.size).to eq 0
+      end
+    end
+    context 'with a name argument' do
+      it 'adds an aliased id attribute for all new deserializer instances' do
+        instance = Class.new(described_class) do
+          id_param :code
+        end.create
+        expect(instance.id_param).to eq :code
+        expect(instance.attributes.size).to eq 0
+      end
+      it 'converts the name parameter to a symbol' do
+        instance = Class.new(described_class) do
+          id_param 'code'
+        end.create
+        expect(instance.id_param).to eq :code
+        expect(instance.attributes.size).to eq 0
+      end
+    end
+    context 'with a format argument' do
+      it 'adds an id attribute with format to all new deserializer instances' do
+        instance = Class.new(described_class) do
+          id_param format: :integer
+        end.create
+        expect(instance.id_param).to eq :id
+        expect(instance.attributes.size).to eq 1
+
+        attribute = instance.attributes.first
+        expect(attribute).to be_kind_of(FunWithJsonApi::Attributes::IntegerAttribute)
+        expect(attribute.name).to eq :id
+        expect(attribute.as).to eq :id
+      end
+    end
+    context 'with a name and format argument' do
+      it 'adds an aliased id attribute with format to all new deserializer instances' do
+        instance = Class.new(described_class) do
+          id_param :code, format: :uuid_v4
+        end.create
+        expect(instance.id_param).to eq :code
+        expect(instance.attributes.size).to eq 1
+
+        attribute = instance.attributes.first
+        expect(attribute).to be_kind_of(FunWithJsonApi::Attributes::UuidV4Attribute)
+        expect(attribute.name).to eq :id
+        expect(attribute.as).to eq :code
+      end
+    end
+  end
+
   describe '#parse_{attribute}' do
     context 'with an alias value' do
-      it 'should generated an attribute from the alias value' do
+      it 'defines a parse method from the alias value' do
         deserializer = deserializer_with_attribute(:original_key, as: :assigned_key)
         expect(deserializer.parse_assigned_key('Foo Bar')).to eq 'Foo Bar'
-        expect(deserializer).to_not respond_to(:original_key)
+        expect(deserializer).not_to respond_to(:original_key)
       end
     end
 
     context 'with no format argument (string)' do
-      it 'should allow a String value' do
+      it 'allows a String value' do
         deserializer = deserializer_with_attribute(:example)
         expect(deserializer.parse_example('Foo Bar')).to eq 'Foo Bar'
       end
-      it 'should allow a nil value' do
+      it 'allows a nil value' do
         deserializer = deserializer_with_attribute(:example)
         expect(deserializer.parse_example(nil)).to be nil
       end
+      it 'raises an InvalidAttribute error an for non string value' do
+        deserializer = deserializer_with_attribute(:example)
+        [1, true, false, [], {}].each do |value|
+          expect do
+            deserializer.parse_example(value)
+          end.to raise_error(FunWithJsonApi::Exceptions::InvalidAttribute) do |e|
+            expect(e.payload.size).to eq 1
+
+            payload = e.payload.first
+            expect(payload.status).to eq '400'
+            expect(payload.code).to eq 'invalid_attribute'
+            expect(payload.title).to eq(
+              I18n.t('fun_with_json_api.exceptions.invalid_attribute')
+            )
+            expect(payload.detail).to eq(
+              I18n.t('fun_with_json_api.exceptions.invalid_string_attribute')
+            )
+            expect(payload.pointer).to eq '/data/attributes/example'
+          end
+        end
+      end
     end
 
     context 'with a boolean format' do
-      it 'should allow a Boolean.TRUE value' do
+      it 'allows a Boolean.TRUE value' do
         deserializer = deserializer_with_attribute(:example, format: :boolean)
         expect(deserializer.parse_example(true)).to eq true
       end
-      it 'should allow a Boolean.FALSE value' do
+      it 'allows a Boolean.FALSE value' do
         deserializer = deserializer_with_attribute(:example, format: :boolean)
         expect(deserializer.parse_example(false)).to eq false
       end
-      it 'should allow a nil value' do
+      it 'allows a nil value' do
         deserializer = deserializer_with_attribute(:example, format: :boolean)
         expect(deserializer.parse_example(nil)).to be nil
       end
-      it 'should raise an InvalidAttribute for invalid boolean values' do
+      it 'raises an InvalidAttribute error an for invalid boolean values' do
         deserializer = deserializer_with_attribute(:example, format: :boolean)
         ['true', 'True', 'TRUE', 1, 'false', 'False', 'FALSE', 0].each do |value|
           expect do
@@ -94,15 +169,15 @@ describe FunWithJsonApi::Deserializer do
     end
 
     context 'with a date format' do
-      it 'should allow a "YYYY-MM-DD" formatted value' do
+      it 'allows a "YYYY-MM-DD" formatted date String' do
         deserializer = deserializer_with_attribute(:example, format: :date)
         expect(deserializer.parse_example('2016-03-12')).to eq Date.new(2016, 03, 12)
       end
-      it 'should allow a nil value' do
+      it 'allows a nil value' do
         deserializer = deserializer_with_attribute(:example, format: :date)
         expect(deserializer.parse_example(nil)).to be nil
       end
-      it 'should raise an InvalidAttribute for invalid date value' do
+      it 'raises an InvalidAttribute error an for invalid date value' do
         deserializer = deserializer_with_attribute(:example, format: :date)
         ['2016-12', 'Last Wednesday', 'April'].each do |value|
           expect do
@@ -126,7 +201,7 @@ describe FunWithJsonApi::Deserializer do
     end
 
     context 'with a datetime format' do
-      it 'should allow a ISO 8601 formatted values' do
+      it 'allows a ISO 8601 formatted values' do
         deserializer = deserializer_with_attribute(:example, format: :datetime)
         [
           '2016-03-11T03:45:40+00:00',
@@ -139,11 +214,11 @@ describe FunWithJsonApi::Deserializer do
           )
         end
       end
-      it 'should allow a nil value' do
+      it 'allows a nil value' do
         deserializer = deserializer_with_attribute(:example, format: :datetime)
         expect(deserializer.parse_example(nil)).to be nil
       end
-      it 'should raise an InvalidAttribute for invalid date value' do
+      it 'raises an InvalidAttribute error an for invalid date value' do
         deserializer = deserializer_with_attribute(:example, format: :datetime)
         [
           'Last Wednesday',
@@ -170,27 +245,27 @@ describe FunWithJsonApi::Deserializer do
     end
 
     context 'with a decimal format' do
-      it 'should allow integers' do
+      it 'allows integers' do
         deserializer = deserializer_with_attribute(:example, format: :decimal)
         expect(deserializer.parse_example(12)).to eq BigDecimal.new('12')
       end
-      it 'should allow floats' do
+      it 'allows floats' do
         deserializer = deserializer_with_attribute(:example, format: :decimal)
         expect(deserializer.parse_example(12.34)).to eq BigDecimal.new('12.34')
       end
-      it 'should allow integer numbers as strings' do
+      it 'allows integer numbers as strings' do
         deserializer = deserializer_with_attribute(:example, format: :decimal)
         expect(deserializer.parse_example('12')).to eq BigDecimal.new('12')
       end
-      it 'should allow floating point numbers as strings' do
+      it 'allows floating point numbers as strings' do
         deserializer = deserializer_with_attribute(:example, format: :decimal)
         expect(deserializer.parse_example('12.30')).to eq BigDecimal.new('12.30')
       end
-      it 'should allow a nil value' do
+      it 'allows a nil value' do
         deserializer = deserializer_with_attribute(:example, format: :decimal)
         expect(deserializer.parse_example(nil)).to be nil
       end
-      it 'should raise an InvalidAttribute for invalid decimal value' do
+      it 'raises an InvalidAttribute error an for invalid decimal value' do
         deserializer = deserializer_with_attribute(:example, format: :decimal)
         [
           'twelve',
@@ -218,23 +293,23 @@ describe FunWithJsonApi::Deserializer do
     end
 
     context 'with a float format' do
-      it 'should allow floats' do
+      it 'allows floats' do
         deserializer = deserializer_with_attribute(:example, format: :float)
         expect(deserializer.parse_example(12.34)).to eq 12.34
       end
-      it 'should allow float numbers as strings' do
+      it 'allows float numbers as strings' do
         deserializer = deserializer_with_attribute(:example, format: :float)
         expect(deserializer.parse_example('12.34')).to eq 12.34
       end
-      it 'should allow integer numbers as strings' do
+      it 'allows integer numbers as strings' do
         deserializer = deserializer_with_attribute(:example, format: :float)
         expect(deserializer.parse_example('12')).to eq 12.0
       end
-      it 'should allow a nil value' do
+      it 'allows a nil value' do
         deserializer = deserializer_with_attribute(:example, format: :float)
         expect(deserializer.parse_example(nil)).to be nil
       end
-      it 'should raise an InvalidAttribute for invalid float value' do
+      it 'raises an InvalidAttribute error an for invalid float value' do
         deserializer = deserializer_with_attribute(:example, format: :float)
         [
           'twelve',
@@ -262,15 +337,15 @@ describe FunWithJsonApi::Deserializer do
     end
 
     context 'with a integer format' do
-      it 'should allow integer numbers as strings' do
+      it 'allows integer numbers as strings' do
         deserializer = deserializer_with_attribute(:example, format: :integer)
         expect(deserializer.parse_example('12')).to eq BigDecimal.new('12')
       end
-      it 'should allow a nil value' do
+      it 'allows a nil value' do
         deserializer = deserializer_with_attribute(:example, format: :integer)
         expect(deserializer.parse_example(nil)).to be nil
       end
-      it 'should raise an InvalidAttribute for invalid integer value' do
+      it 'raises an InvalidAttribute error an for invalid integer value' do
         deserializer = deserializer_with_attribute(:example, format: :integer)
         [
           12.0,
@@ -299,6 +374,46 @@ describe FunWithJsonApi::Deserializer do
       end
     end
 
+    context 'with a uuid_v4 format' do
+      it 'allows uuid_v4 numbers as strings' do
+        deserializer = deserializer_with_attribute(:example, format: :uuid_v4)
+        expect(deserializer.parse_example('f47ac10b-58cc-4372-a567-0e02b2c3d479')).to eq(
+          'f47ac10b-58cc-4372-a567-0e02b2c3d479'
+        )
+      end
+      it 'allows a nil value' do
+        deserializer = deserializer_with_attribute(:example, format: :uuid_v4)
+        expect(deserializer.parse_example(nil)).to be nil
+      end
+      it 'raises an InvalidAttribute error an for invalid uuid_v4 value' do
+        deserializer = deserializer_with_attribute(:example, format: :uuid_v4)
+        [
+          'abc',
+          12.0,
+          '12.0',
+          '6ba7b810-9dad-11d1-80b4-00c04fd430c8', # RFC 4122 version 3
+          'f47ac10b58cc4372a5670e02b2c3d479' # uuid without dashes
+        ].each do |value|
+          expect do
+            deserializer.parse_example(value)
+          end.to raise_error(FunWithJsonApi::Exceptions::InvalidAttribute) do |e|
+            expect(e.payload.size).to eq 1
+
+            payload = e.payload.first
+            expect(payload.status).to eq '400'
+            expect(payload.code).to eq 'invalid_attribute'
+            expect(payload.title).to eq(
+              I18n.t('fun_with_json_api.exceptions.invalid_attribute')
+            )
+            expect(payload.detail).to eq(
+              I18n.t('fun_with_json_api.exceptions.invalid_uuid_v4_attribute')
+            )
+            expect(payload.pointer).to eq '/data/attributes/example'
+          end
+        end
+      end
+    end
+
     it 'raises an ArgumentError with an unknown format' do
       expect do
         deserializer_class_with_attribute(:example, format: :blarg)
@@ -315,14 +430,14 @@ describe FunWithJsonApi::Deserializer do
   describe '#parse_{relationship}_id' do
     context 'with a ARModels::Author relationship with a "code" id param' do
       let(:deserializer) do
-        author_deserializer_class = Class.new(FunWithJsonApi::Deserializer) do
+        author_deserializer_class = Class.new(described_class) do
           id_param 'code'
           type 'persons'
           resource_class ARModels::Author
         end
 
         # Build the Deserializer
-        Class.new(FunWithJsonApi::Deserializer) do
+        Class.new(described_class) do
           belongs_to :example, author_deserializer_class
         end.create
       end
@@ -336,13 +451,13 @@ describe FunWithJsonApi::Deserializer do
         expect do
           deserializer.parse_example_id 'foobar'
         end.to raise_error(FunWithJsonApi::Exceptions::MissingRelationship) do |e|
-          expect(e.message).to start_with "Couldn't find ARModels::Author where code = \"foobar\": "
+          expect(e.message).to eq "Couldn't find ARModels::Author where code = \"foobar\""
           expect(e.payload.size).to eq 1
 
           payload = e.payload.first
           expect(payload.status).to eq '404'
           expect(payload.code).to eq 'missing_relationship'
-          expect(payload.title).to eq I18n.t('fun_with_json_api.exceptions.missing_relationship')
+          expect(payload.title).to eq 'Unable to find the requested relationship'
           expect(payload.pointer).to eq '/data/relationships/example/id'
           expect(payload.detail).to eq "Unable to find 'persons' with matching id: \"foobar\""
         end
@@ -368,14 +483,14 @@ describe FunWithJsonApi::Deserializer do
   describe '#parse_{relationship}_ids' do
     context 'with a ARModels::Author relationship with a "code" id param' do
       let(:deserializer) do
-        author_deserializer_class = Class.new(FunWithJsonApi::Deserializer) do
+        author_deserializer_class = Class.new(described_class) do
           id_param 'code'
           type 'persons'
           resource_class ARModels::Author
         end
 
         # Build the Deserializer
-        Class.new(FunWithJsonApi::Deserializer) do
+        Class.new(described_class) do
           has_many :examples, author_deserializer_class
         end.create
       end
@@ -400,8 +515,8 @@ describe FunWithJsonApi::Deserializer do
           payload = e.payload.first
           expect(payload.status).to eq '404'
           expect(payload.code).to eq 'missing_relationship'
-          expect(payload.title).to eq I18n.t('fun_with_json_api.exceptions.missing_relationship')
-          expect(payload.pointer).to eq '/data/relationships/examples/id'
+          expect(payload.title).to eq 'Unable to find the requested relationship'
+          expect(payload.pointer).to eq '/data/relationships/examples/1/id'
           expect(payload.detail).to eq "Unable to find 'persons' with matching id: \"blargh\""
         end
       end
@@ -418,15 +533,15 @@ describe FunWithJsonApi::Deserializer do
           payload_a = e.payload.first
           expect(payload_a.status).to eq '404'
           expect(payload_a.code).to eq 'missing_relationship'
-          expect(payload_a.title).to eq I18n.t('fun_with_json_api.exceptions.missing_relationship')
-          expect(payload_a.pointer).to eq '/data/relationships/examples/id'
+          expect(payload_a.title).to eq 'Unable to find the requested relationship'
+          expect(payload_a.pointer).to eq '/data/relationships/examples/0/id'
           expect(payload_a.detail).to eq "Unable to find 'persons' with matching id: \"foobar\""
 
           payload_b = e.payload.last
           expect(payload_b.status).to eq '404'
           expect(payload_b.code).to eq 'missing_relationship'
-          expect(payload_b.title).to eq I18n.t('fun_with_json_api.exceptions.missing_relationship')
-          expect(payload_b.pointer).to eq '/data/relationships/examples/id'
+          expect(payload_b.title).to eq 'Unable to find the requested relationship'
+          expect(payload_b.pointer).to eq '/data/relationships/examples/1/id'
           expect(payload_b.detail).to eq "Unable to find 'persons' with matching id: \"blargh\""
         end
       end