fun_with_json_api 0.0.1

data/spec/fun_with_json_api/exception_spec.rb

@@ -0,0 +1,77 @@
+require 'spec_helper'
+
+describe FunWithJsonApi::Exception do
+  let(:message) { Faker::Lorem.sentence }
+  let(:payload) { FunWithJsonApi::ExceptionPayload.new }
+  subject(:instance) { described_class.new(message, payload) }
+
+  describe '#message' do
+    subject { instance.message }
+
+    it 'should return the developer-only message' do
+      expect(subject).to eq message
+    end
+  end
+
+  describe '#payload' do
+    subject { instance.payload }
+
+    it 'should wrap the payload in a array' do
+      expect(subject).to eq [payload]
+    end
+
+    context 'with an array of payloads' do
+      let(:payload) { Array.new(3) { FunWithJsonApi::ExceptionPayload.new } }
+
+      it 'should return the payload array' do
+        expect(subject).to eq payload
+      end
+    end
+  end
+
+  describe '#http_status' do
+    subject { instance.http_status }
+
+    it 'should default to 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
+        expect(subject).to eq 422
+      end
+    end
+
+    context 'with mutiple payloads with a single status values' do
+      let(:payload) do
+        Array.new(3) { FunWithJsonApi::ExceptionPayload.new.tap { |p| p.status = '403' } }
+      end
+
+      it 'should return the common payload status value' do
+        expect(subject).to eq 403
+      end
+    end
+
+    context 'with mutiple payloads with multiple 400-based status values' do
+      let(:payload) do
+        Array.new(3) { |i| FunWithJsonApi::ExceptionPayload.new.tap { |p| p.status = "40#{i}" } }
+      end
+
+      it 'should fall back to 400' do
+        expect(subject).to eq 400
+      end
+    end
+
+    context 'with mutiple payloads with multiple 500-based status values' do
+      let(:payload) do
+        Array.new(3) { |i| FunWithJsonApi::ExceptionPayload.new.tap { |p| p.status = "50#{i}" } }
+      end
+
+      it 'should fall back to 500' do
+        expect(subject).to eq 500
+      end
+    end
+  end
+end

data/spec/fun_with_json_api/pre_deserializer_spec.rb

@@ -0,0 +1,287 @@
+require 'spec_helper'
+
+describe FunWithJsonApi::PreDeserializer do
+  describe '.parse' do
+    describe 'document attributes parsing' do
+      it 'should pass through attribute values' do
+        deserializer = Class.new(FunWithJsonApi::Deserializer) do
+          attribute :foo
+        end.create
+
+        document = {
+          data: {
+            attributes: {
+              foo: 'bar'
+            }
+          }
+        }.deep_stringify_keys!
+
+        expect(FunWithJsonApi::PreDeserializer.parse(document, deserializer)).to eq(
+          foo: 'bar'
+        )
+      end
+      it 'should handle renamed attributes' do
+        deserializer = Class.new(FunWithJsonApi::Deserializer) do
+          attribute :foo, as: :blargh
+        end.create
+
+        document = {
+          data: {
+            attributes: {
+              foo: 'bar'
+            }
+          }
+        }.deep_stringify_keys!
+
+        expect(FunWithJsonApi::PreDeserializer.parse(document, deserializer)).to eq(
+          blargh: 'bar'
+        )
+      end
+      it 'should only return known attributes' do
+        deserializer = Class.new(FunWithJsonApi::Deserializer) do
+          attribute :foo
+        end.create
+
+        document = {
+          data: {
+            attributes: {
+              foo: 'bar',
+              blargh: 'baz'
+            }
+          }
+        }.deep_stringify_keys!
+
+        expect(FunWithJsonApi::PreDeserializer.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
+        foo_deserializer_class = Class.new(FunWithJsonApi::Deserializer)
+        deserializer = Class.new(FunWithJsonApi::Deserializer) do
+          belongs_to :foo, foo_deserializer_class
+        end.create
+
+        document = {
+          data: {
+            relationships: {
+              foo: {
+                data: { id: '42', type: 'foos' }
+              }
+            }
+          }
+        }.deep_stringify_keys!
+
+        expect(FunWithJsonApi::PreDeserializer.parse(document, deserializer)).to eq(
+          foo_id: '42'
+        )
+      end
+      it 'should handle renamed relationships' do
+        foo_deserializer_class = Class.new(FunWithJsonApi::Deserializer)
+        deserializer = Class.new(FunWithJsonApi::Deserializer) do
+          belongs_to :foo, foo_deserializer_class, as: :blargh
+        end.create
+
+        document = {
+          data: {
+            relationships: {
+              foo: {
+                data: { id: '42', type: 'foos' }
+              }
+            }
+          }
+        }.deep_stringify_keys!
+
+        expect(FunWithJsonApi::PreDeserializer.parse(document, deserializer)).to eq(
+          blargh_id: '42'
+        )
+      end
+      it 'should only return known relationships' do
+        foo_deserializer_class = Class.new(FunWithJsonApi::Deserializer)
+        deserializer = Class.new(FunWithJsonApi::Deserializer) do
+          belongs_to :foo, foo_deserializer_class
+        end.create
+
+        document = {
+          data: {
+            relationships: {
+              foo: {
+                data: { id: '42', type: 'foos' }
+              },
+              blargh: {
+                data: { id: '24', type: 'blarghs' }
+              }
+            }
+          }
+        }.deep_stringify_keys!
+
+        expect(FunWithJsonApi::PreDeserializer.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
+        foo_deserializer_class = Class.new(FunWithJsonApi::Deserializer)
+        deserializer = Class.new(FunWithJsonApi::Deserializer) do
+          has_many :foos, foo_deserializer_class
+        end.create
+
+        document = {
+          data: {
+            relationships: {
+              foos: {
+                data: [{ id: '42', type: 'foos' }, { id: '24', type: 'foos' }]
+              }
+            }
+          }
+        }.deep_stringify_keys!
+
+        expect(FunWithJsonApi::PreDeserializer.parse(document, deserializer)).to eq(
+          foo_ids: %w(42 24)
+        )
+      end
+      it 'should handle renamed relationships' do
+        foo_deserializer_class = Class.new(FunWithJsonApi::Deserializer)
+        deserializer = Class.new(FunWithJsonApi::Deserializer) do
+          has_many :foos, foo_deserializer_class, as: :blargh
+        end.create
+
+        document = {
+          data: {
+            relationships: {
+              foos: {
+                data: [{ id: '42', type: 'foos' }, { id: '11', type: 'foos' }]
+              }
+            }
+          }
+        }.deep_stringify_keys!
+
+        expect(FunWithJsonApi::PreDeserializer.parse(document, deserializer)).to eq(
+          blargh_ids: %w(42 11)
+        )
+      end
+      it 'should only return known relationships' do
+        foo_deserializer_class = Class.new(FunWithJsonApi::Deserializer)
+        deserializer = Class.new(FunWithJsonApi::Deserializer) do
+          has_many :foos, foo_deserializer_class
+        end.create
+
+        document = {
+          data: {
+            relationships: {
+              foos: {
+                data: [{ id: '42', type: 'foos' }]
+              },
+              blargh: {
+                data: [{ id: '24', type: 'blarghs' }]
+              }
+            }
+          }
+        }.deep_stringify_keys!
+
+        expect(FunWithJsonApi::PreDeserializer.parse(document, deserializer)).to eq(
+          foo_ids: ['42']
+        )
+      end
+    end
+
+    describe 'parser exceptions' do
+      it 'should handle an invalid /data values' do
+        deserializer = Class.new(FunWithJsonApi::Deserializer).create
+        [
+          nil,
+          {},
+          {
+            'data' => nil
+          }
+        ].each do |document|
+          expect do
+            FunWithJsonApi::PreDeserializer.parse(document, deserializer)
+          end.to raise_error(FunWithJsonApi::Exceptions::InvalidDocument) 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_document'
+            expect(payload.title).to eq I18n.t('fun_with_json_api.exceptions.invalid_document')
+            expect(payload.pointer).to eq '/data'
+            expect(payload.detail).to be_kind_of(String)
+          end
+        end
+      end
+      it 'should handle invalid /data/attributes values' do
+        deserializer = Class.new(FunWithJsonApi::Deserializer).create
+        [
+          {
+            'data' => { 'attributes' => [] }
+          }
+        ].each do |document|
+          expect do
+            FunWithJsonApi::PreDeserializer.parse(document, deserializer)
+          end.to raise_error(FunWithJsonApi::Exceptions::InvalidDocument) 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_document'
+            expect(payload.title).to eq I18n.t('fun_with_json_api.exceptions.invalid_document')
+            expect(payload.pointer).to eq '/data/attributes'
+            expect(payload.detail).to be_kind_of(String)
+          end
+        end
+      end
+      it 'should handle invalid /data/relationships values' do
+        deserializer = Class.new(FunWithJsonApi::Deserializer).create
+        [
+          {
+            'data' => { 'relationships' => [] }
+          }
+        ].each do |document|
+          expect do
+            FunWithJsonApi::PreDeserializer.parse(document, deserializer)
+          end.to raise_error(FunWithJsonApi::Exceptions::InvalidDocument) 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_document'
+            expect(payload.title).to eq I18n.t('fun_with_json_api.exceptions.invalid_document')
+            expect(payload.pointer).to eq '/data/relationships'
+            expect(payload.detail).to be_kind_of(String)
+          end
+        end
+      end
+      it 'should handle a invalid relationship value' do
+        deserializer = Class.new(FunWithJsonApi::Deserializer).create
+        [
+          {
+            'data' => {
+              'relationships' => { 'rel' => nil }
+            }
+          }, {
+            'data' => {
+              'relationships' => { 'rel' => {} }
+            }
+          }
+        ].each do |document|
+          expect do
+            FunWithJsonApi::PreDeserializer.parse(document, deserializer)
+          end.to raise_error(FunWithJsonApi::Exceptions::InvalidDocument) 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_document'
+            expect(payload.title).to eq I18n.t('fun_with_json_api.exceptions.invalid_document')
+            expect(payload.pointer).to eq '/data/relationships/rel'
+            expect(payload.detail).to be_kind_of(String)
+          end
+        end
+      end
+    end
+  end
+end

data/spec/fun_with_json_api_spec.rb

@@ -0,0 +1,55 @@
+require 'spec_helper'
+
+describe FunWithJsonApi do
+  it 'should have a Semantic Versioning compatible VERSION' do
+    # based on https://github.com/npm/node-semver/issues/32
+    version_regex = /
+      \A([0-9]+) # major
+      \.([0-9]+) # minor
+      \.([0-9]+) # patch
+      (?:-([0-9A-Za-z-]+(?:\.[0-9a-z-]+)*))? # build
+      (?:\+[0-9a-z-]+)?\z # tag
+    /x
+    expect(FunWithJsonApi::VERSION).to match(version_regex)
+  end
+
+  describe '.deserialize' do
+    context 'with an PostDeserializer' do
+      it 'should convert a json api to post params' do
+        ARModels::Author.create(id: 9)
+        ARModels::Comment.create(id: 5)
+        ARModels::Comment.create(id: 12)
+
+        post_json = {
+          'data': {
+            'type': 'posts',
+            'id': '1',
+            'attributes': {
+              'title': 'Rails is Omakase',
+              'body': 'This is my post body'
+            },
+            'relationships': {
+              'author': {
+                'data': { 'type': 'people', 'id': '9' }
+              },
+              'comments': {
+                'data': [
+                  { 'type': 'comments', 'id': '5' },
+                  { 'type': 'comments', 'id': '12' }
+                ]
+              }
+            }
+          }
+        }
+
+        post_params = FunWithJsonApi.deserialize(post_json, ARModels::PostDeserializer)
+        expect(post_params).to eq(
+          title: 'Rails is Omakase',
+          body: 'This is my post body',
+          author_id: 9,
+          comment_ids: [5, 12]
+        )
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,33 @@
+require 'simplecov'
+SimpleCov.minimum_coverage 80
+SimpleCov.start
+
+ENV['RAILS_ENV'] ||= 'test'
+
+require File.expand_path('../dummy/config/environment.rb', __FILE__)
+
+require 'rails'
+require 'action_controller'
+require 'action_controller/test_case'
+require 'action_controller/railtie'
+require 'active_support/json'
+require 'active_support/inflector'
+
+require 'fun_with_json_api'
+
+require 'fixtures/active_record'
+require 'rspec/rails'
+require 'faker'
+require 'factory_girl_rails'
+
+Rails.backtrace_cleaner.remove_silencers!
+
+# Load support files
+Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each { |f| require f }
+
+RSpec.configure do |config|
+  config.mock_with :rspec
+  config.use_transactional_fixtures = true
+  config.infer_base_class_for_anonymous_controllers = false
+  config.order = 'random'
+end