jsonapi.rb 1.5.7 → 2.0.0

data/spec/errors_spec.rb

@@ -0,0 +1,168 @@
+require 'spec_helper'
+
+RSpec.describe NotesController, type: :request do
+  describe 'PUT /notes/:id' do
+    let(:note) { create_note }
+    let(:note_id) { note.id }
+    let(:user) { note.user }
+    let(:user_id) { user.id }
+    let(:note_params) do
+      {
+        data: {
+          attributes: { title: FFaker::Company.name },
+          relationships: { user: { data: { id: user_id } } }
+        }
+      }
+    end
+    let(:params) { note_params }
+
+    before do
+      put(note_path(note_id), params: params.to_json, headers: jsonapi_headers)
+    end
+
+    it do
+      expect(response).to have_http_status(:ok)
+      expect(response_json['data']).to have_id(note.id.to_s)
+      expect(response_json['meta']).to eq('single' => true)
+    end
+
+    context 'with a missing parameter in the payload' do
+      let(:params) { {} }
+
+      it do
+        expect(response).to have_http_status(:unprocessable_entity)
+        expect(response_json['errors'].size).to eq(1)
+        expect(response_json['errors'][0]['status']).to eq('422')
+        expect(response_json['errors'][0]['title'])
+          .to eq(Rack::Utils::HTTP_STATUS_CODES[422])
+        expect(response_json['errors'][0]['source']).to eq('pointer' => '')
+        expect(response_json['errors'][0]['detail']).to be_nil
+      end
+    end
+
+    context 'with an invalid payload' do
+      let(:params) do
+        payload = note_params.dup
+        payload[:data][:relationships][:user][:data][:id] = nil
+        payload
+      end
+
+      it do
+        expect(response).to have_http_status(:unprocessable_entity)
+        expect(response_json['errors'].size).to eq(1)
+        expect(response_json['errors'][0]['status']).to eq('422')
+        expect(response_json['errors'][0]['code']).to include('blank')
+        expect(response_json['errors'][0]['title'])
+          .to eq(Rack::Utils::HTTP_STATUS_CODES[422])
+        expect(response_json['errors'][0]['source'])
+          .to eq('pointer' => '/data/relationships/user')
+        if Rails.gem_version >= Gem::Version.new('6.1')
+          expect(response_json['errors'][0]['detail'])
+            .to eq('User must exist')
+        else
+          expect(response_json['errors'][0]['detail'])
+            .to eq('User can\'t be blank')
+        end
+      end
+
+      context 'required by validations' do
+        let(:params) do
+          payload = note_params.dup
+          payload[:data][:attributes][:title] = 'BAD_TITLE'
+          payload[:data][:attributes][:quantity] = 100 + rand(10)
+          payload
+        end
+
+        it do
+          expect(response).to have_http_status(:unprocessable_entity)
+          expect(response_json['errors'].size).to eq(3)
+          expect(response_json['errors'][0]['status']).to eq('422')
+          expect(response_json['errors'][0]['code']).to include('invalid')
+          expect(response_json['errors'][0]['title'])
+            .to eq(Rack::Utils::HTTP_STATUS_CODES[422])
+          expect(response_json['errors'][0]['source'])
+              .to eq('pointer' => '/data/attributes/title')
+          expect(response_json['errors'][0]['detail'])
+            .to eq('Title is invalid')
+
+          expect(response_json['errors'][1]['status']).to eq('422')
+
+          if Rails::VERSION::MAJOR >= 5
+            expect(response_json['errors'][1]['code']).to eq('invalid')
+          else
+            expect(response_json['errors'][1]['code']).to eq('has_typos')
+          end
+
+          expect(response_json['errors'][1]['title'])
+            .to eq(Rack::Utils::HTTP_STATUS_CODES[422])
+          expect(response_json['errors'][1]['source'])
+            .to eq('pointer' => '/data/attributes/title')
+          expect(response_json['errors'][1]['detail'])
+            .to eq('Title has typos')
+
+          expect(response_json['errors'][2]['status']).to eq('422')
+
+          if Rails::VERSION::MAJOR >= 5
+            expect(response_json['errors'][2]['code']).to eq('less_than')
+          else
+            expect(response_json['errors'][2]['code'])
+              .to eq('must_be_less_than_100')
+          end
+
+          expect(response_json['errors'][2]['title'])
+            .to eq(Rack::Utils::HTTP_STATUS_CODES[422])
+          expect(response_json['errors'][2]['source'])
+            .to eq('pointer' => '/data/attributes/quantity')
+          expect(response_json['errors'][2]['detail'])
+            .to eq('Quantity must be less than 100')
+        end
+      end
+
+      context 'as a param attribute' do
+        let(:params) do
+          payload = note_params.dup
+          payload[:data][:attributes].delete(:title)
+          # To have any attribtues in the payload...
+          payload[:data][:attributes][:created_at] = nil
+          payload
+        end
+
+        it do
+          expect(response).to have_http_status(:unprocessable_entity)
+          expect(response_json['errors'][0]['source'])
+            .to eq('pointer' => '/data/attributes/title')
+        end
+      end
+    end
+
+    context 'with a bad note ID' do
+      let(:user_id) { nil }
+      let(:note_id) { rand(10) }
+
+      it do
+        expect(response).to have_http_status(:not_found)
+        expect(response_json['errors'].size).to eq(1)
+        expect(response_json['errors'][0]['status']).to eq('404')
+        expect(response_json['errors'][0]['title'])
+          .to eq(Rack::Utils::HTTP_STATUS_CODES[404])
+        expect(response_json['errors'][0]['source']).to be_nil
+        expect(response_json['errors'][0]['detail']).to be_nil
+      end
+    end
+
+    context 'with an exception' do
+      let(:user_id) { nil }
+      let(:note_id) { 'tada' }
+
+      it do
+        expect(response).to have_http_status(:internal_server_error)
+        expect(response_json['errors'].size).to eq(1)
+        expect(response_json['errors'][0]['status']).to eq('500')
+        expect(response_json['errors'][0]['title'])
+          .to eq(Rack::Utils::HTTP_STATUS_CODES[500])
+        expect(response_json['errors'][0]['source']).to be_nil
+        expect(response_json['errors'][0]['detail']).to be_nil
+      end
+    end
+  end
+end

data/spec/fetching_spec.rb

@@ -0,0 +1,65 @@
+require 'spec_helper'
+
+RSpec.describe UsersController, type: :request do
+  describe 'GET /users' do
+    let!(:user) { }
+    let(:params) { }
+
+    before do
+      get(users_path, params: params, headers: jsonapi_headers)
+    end
+
+    context 'with users' do
+      let(:first_user) { create_user }
+      let(:second_user) { create_user }
+      let(:third_user) { create_note.user }
+      let(:users) { [first_user, second_user, third_user] }
+      let(:user) { users.last }
+      let(:note) { third_user.notes.first }
+
+      context 'returns customers and dasherized first name' do
+        let(:params) do
+          { upcase: :yes, fields: { unknown: nil } }
+        end
+
+        it do
+          expect(response).to have_http_status(:ok)
+          expect(response_json['data'].size).to eq(users.size)
+
+          response_json['data'].each do |item|
+            user = users.detect { |u| u.id == item['id'].to_i }
+            expect(item).to have_attribute('first_name')
+              .with_value(user.first_name.upcase)
+          end
+        end
+      end
+
+      context 'returns customers included and sparse fields' do
+        let(:params) do
+          {
+            include: 'notes',
+            fields:  { note: 'title,updated_at' }
+          }
+        end
+
+        it do
+          expect(response).to have_http_status(:ok)
+          expect(response_json['data'].last)
+            .to have_relationship(:notes)
+            .with_data([
+              { 'id' => note.id.to_s, 'type' => 'note' }
+          ])
+          expect(response_json['included']).to include(
+            'id' => note.id.to_s,
+            'type' => 'note',
+            'relationships' => {},
+            'attributes' => {
+              'title' => note.title,
+              'updated_at' => note.updated_at.as_json
+            }
+          )
+        end
+      end
+    end
+  end
+end

data/spec/filtering_spec.rb

@@ -0,0 +1,101 @@
+require 'spec_helper'
+
+RSpec.describe UsersController, type: :request do
+  describe '#extract_attributes_and_predicate' do
+    context 'mixed attributes (and/or)' do
+      it 'extracts ANDs' do
+        attributes, predicates = JSONAPI::Filtering
+          .extract_attributes_and_predicates('attr1_and_attr2_eq')
+        expect(attributes).to eq(['attr1', 'attr2'])
+        expect(predicates.size).to eq(1)
+        expect(predicates[0].name).to eq('eq')
+      end
+    end
+
+    context 'mixed predicates' do
+      it 'extracts in order' do
+        attributes, predicates = JSONAPI::Filtering
+          .extract_attributes_and_predicates('attr1_sum_eq')
+        expect(attributes).to eq(['attr1'])
+        expect(predicates.size).to eq(2)
+        expect(predicates[0].name).to eq('sum')
+        expect(predicates[1].name).to eq('eq')
+      end
+    end
+  end
+
+  describe 'GET /users' do
+    let!(:user) { }
+    let(:params) { }
+
+    before do
+      get(users_path, params: params, headers: jsonapi_headers)
+    end
+
+    context 'with users' do
+      let(:first_user) { create_user }
+      let(:second_user) { create_note.user }
+      let(:third_user) { create_user }
+      let(:users) { [first_user, second_user, third_user] }
+      let(:user) { users.last }
+
+      context 'returns filtered users' do
+        let(:params) do
+          {
+            filter: {
+              last_name_or_first_name_cont_any: (
+                "#{third_user.first_name[0..5]}%,#{self.class.name}"
+              )
+            }
+          }
+        end
+
+        it do
+          expect(response).to have_http_status(:ok)
+          expect(response_json['data'].size).to eq(1)
+          expect(response_json['data'][0]).to have_id(third_user.id.to_s)
+        end
+
+        context 'with a comma' do
+          let(:params) do
+            third_user.update(first_name: third_user.first_name + ',')
+
+            {
+              filter: { first_name_eq: third_user.first_name }
+            }
+          end
+
+          it do
+            expect(response).to have_http_status(:ok)
+            expect(response_json['data'].size).to eq(1)
+            expect(response_json['data'][0]).to have_id(third_user.id.to_s)
+          end
+        end
+      end
+
+      context 'returns sorted users by notes quantity sum' do
+        let(:params) do
+          { sort: '-notes_quantity_sum' }
+        end
+
+        it do
+          expect(response).to have_http_status(:ok)
+          expect(response_json['data'].size).to eq(3)
+          expect(response_json['data'][0]).to have_id(second_user.id.to_s)
+        end
+      end
+
+      context 'returns sorted users by notes' do
+        let(:params) do
+          { sort: '-notes_created_at' }
+        end
+
+        it do
+          expect(response).to have_http_status(:ok)
+          expect(response_json['data'].size).to eq(3)
+          expect(response_json['data'][0]).to have_id(second_user.id.to_s)
+        end
+      end
+    end
+  end
+end

data/spec/pagination_spec.rb

@@ -0,0 +1,246 @@
+require 'spec_helper'
+
+RSpec.describe UsersController, type: :request do
+  describe 'GET /users' do
+    let!(:user) { }
+    let(:params) do
+      {
+        page: { number: 'Nan', size: 'NaN' },
+        sort: '-created_at'
+      }
+    end
+
+    before do
+      get(users_path, params: params, headers: jsonapi_headers)
+    end
+
+    it do
+      expect(response_json['data'].size).to eq(0)
+      expect(response_json['meta'])
+        .to eq(
+          'many' => true,
+          'pagination' => {
+            'current' => 1,
+            'records' => 0
+          }
+        )
+    end
+
+    context 'with users' do
+      let(:first_user) { create_user }
+      let(:second_user) { create_user }
+      let(:third_user) { create_user }
+      let(:users) { [first_user, second_user, third_user] }
+      let(:user) { users.last }
+
+      context 'returns users with pagination links' do
+        it do
+          expect(response).to have_http_status(:ok)
+          expect(response_json['data'].size).to eq(3)
+          expect(response_json['data'][0]).to have_id(third_user.id.to_s)
+          expect(response_json['data'][1]).to have_id(second_user.id.to_s)
+          expect(response_json['data'][2]).to have_id(first_user.id.to_s)
+
+          expect(response_json).to have_link('self')
+          expect(response_json).not_to have_link(:prev)
+          expect(response_json).not_to have_link(:next)
+          expect(response_json).not_to have_link(:first)
+          expect(response_json).not_to have_link(:last)
+
+          expect(URI.parse(response_json['links']['self']).query)
+            .to eq(CGI.unescape(params.to_query))
+        end
+
+        context 'on page 2 out of 3' do
+          let(:as_list) { }
+          let(:params) do
+            {
+              page: { number: 2, size: 1 },
+              sort: '-created_at',
+              as_list: as_list
+            }.reject { |_k, _v| _v.blank? }
+          end
+
+          context 'on an array of resources' do
+            let(:as_list) { true }
+
+            it do
+              expect(response).to have_http_status(:ok)
+              expect(response_json['data'].size).to eq(1)
+              expect(response_json['data'][0]).to have_id(second_user.id.to_s)
+
+              expect(response_json['meta']['pagination']).to eq(
+                'current' => 2,
+                'first' => 1,
+                'prev' => 1,
+                'next' => 3,
+                'last' => 3,
+                'records' => 3
+              )
+            end
+          end
+
+          it do
+            expect(response).to have_http_status(:ok)
+            expect(response_json['data'].size).to eq(1)
+            expect(response_json['data'][0]).to have_id(second_user.id.to_s)
+
+            expect(response_json['meta']['pagination']).to eq(
+              'current' => 2,
+              'first' => 1,
+              'prev' => 1,
+              'next' => 3,
+              'last' => 3,
+              'records' => 3
+            )
+
+            expect(response_json).to have_link(:self)
+            expect(response_json).to have_link(:prev)
+            expect(response_json).to have_link(:first)
+            expect(response_json).to have_link(:next)
+            expect(response_json).to have_link(:last)
+
+            qry = CGI.unescape(params.to_query)
+            expect(URI.parse(response_json['links']['self']).query).to eq(qry)
+
+            qry = CGI.unescape(params.deep_merge(page: { number: 2 }).to_query)
+            expect(URI.parse(response_json['links']['self']).query).to eq(qry)
+
+            qry = CGI.unescape(params.deep_merge(page: { number: 1 }).to_query)
+            expect(URI.parse(response_json['links']['prev']).query).to eq(qry)
+            expect(URI.parse(response_json['links']['first']).query).to eq(qry)
+
+            qry = CGI.unescape(params.deep_merge(page: { number: 3 }).to_query)
+            expect(URI.parse(response_json['links']['next']).query).to eq(qry)
+            expect(URI.parse(response_json['links']['last']).query).to eq(qry)
+          end
+        end
+
+        context 'on page 3 out of 3' do
+          let(:params) do
+            {
+              page: { number: 3, size: 1 }
+            }
+          end
+
+          it do
+            expect(response).to have_http_status(:ok)
+            expect(response_json['data'].size).to eq(1)
+
+            expect(response_json['meta']['pagination']).to eq(
+              'current' => 3,
+              'first' => 1,
+              'prev' => 2,
+              'records' => 3
+            )
+
+            expect(response_json).to have_link(:self)
+            expect(response_json).to have_link(:prev)
+            expect(response_json).to have_link(:first)
+            expect(response_json).not_to have_link(:next)
+            expect(response_json).not_to have_link(:last)
+
+            expect(URI.parse(response_json['links']['self']).query)
+              .to eq(CGI.unescape(params.to_query))
+
+            qry = CGI.unescape(params.deep_merge(page: { number: 2 }).to_query)
+            expect(URI.parse(response_json['links']['prev']).query).to eq(qry)
+
+            qry = CGI.unescape(params.deep_merge(page: { number: 1 }).to_query)
+            expect(URI.parse(response_json['links']['first']).query).to eq(qry)
+          end
+        end
+
+        context 'on paging beyond the last page' do
+          let(:as_list) { }
+          let(:params) do
+            {
+              page: { number: 5, size: 1 },
+              as_list: as_list
+            }.reject { |_k, _v| _v.blank? }
+          end
+
+          context 'on an array of resources' do
+            let(:as_list) { true }
+
+            it do
+              expect(response).to have_http_status(:ok)
+              expect(response_json['data'].size).to eq(0)
+
+              expect(response_json['meta']['pagination']).to eq(
+                'current' => 5,
+                'first' => 1,
+                'prev' => 4,
+                'records' => 3
+              )
+            end
+          end
+
+          it do
+            expect(response).to have_http_status(:ok)
+            expect(response_json['data'].size).to eq(0)
+
+            expect(response_json['meta']['pagination']).to eq(
+              'current' => 5,
+              'first' => 1,
+              'prev' => 4,
+              'records' => 3
+            )
+
+            expect(response_json).to have_link(:self)
+            expect(response_json).to have_link(:prev)
+            expect(response_json).to have_link(:first)
+            expect(response_json).not_to have_link(:next)
+            expect(response_json).not_to have_link(:last)
+
+            expect(URI.parse(response_json['links']['self']).query)
+              .to eq(CGI.unescape(params.to_query))
+
+            qry = CGI.unescape(params.deep_merge(page: { number: 4 }).to_query)
+            expect(URI.parse(response_json['links']['prev']).query).to eq(qry)
+
+            qry = CGI.unescape(params.deep_merge(page: { number: 1 }).to_query)
+            expect(URI.parse(response_json['links']['first']).query).to eq(qry)
+          end
+        end
+
+        context 'on page 1 out of 3' do
+          let(:params) do
+            {
+              page: { size: 1 },
+              sort: '-created_at'
+            }
+          end
+
+          it do
+            expect(response).to have_http_status(:ok)
+            expect(response_json['data'].size).to eq(1)
+            expect(response_json['data'][0]).to have_id(third_user.id.to_s)
+
+            expect(response_json['meta']['pagination']).to eq(
+              'current' => 1,
+              'next' => 2,
+              'last' => 3,
+              'records' => 3
+            )
+
+            expect(response_json).not_to have_link(:prev)
+            expect(response_json).not_to have_link(:first)
+            expect(response_json).to have_link(:next)
+            expect(response_json).to have_link(:self)
+            expect(response_json).to have_link(:last)
+
+            expect(URI.parse(response_json['links']['self']).query)
+              .to eq(CGI.unescape(params.to_query))
+
+            qry = CGI.unescape(params.deep_merge(page: { number: 2 }).to_query)
+            expect(URI.parse(response_json['links']['next']).query).to eq(qry)
+
+            qry = CGI.unescape(params.deep_merge(page: { number: 3 }).to_query)
+            expect(URI.parse(response_json['links']['last']).query).to eq(qry)
+          end
+        end
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,87 @@
+require 'bundler/setup'
+require 'simplecov'
+
+SimpleCov.start do
+  add_group 'Lib', 'lib'
+  add_group 'Tests', 'spec'
+end
+SimpleCov.minimum_coverage 90
+
+require 'dummy'
+require 'ffaker'
+require 'rspec/rails'
+require 'jsonapi/rspec'
+
+RSpec.configure do |config|
+  config.include JSONAPI::RSpec
+
+  config.use_transactional_fixtures = true
+  config.mock_with :rspec
+  config.filter_run_when_matching :focus
+  config.disable_monkey_patching!
+
+  config.expect_with :rspec do |c|
+    c.syntax = :expect
+  end
+end
+
+module RSpecHelpers
+  include Dummy.routes.url_helpers
+
+  # Helper to return JSONAPI valid headers
+  #
+  # @return [Hash] the relevant content type &co
+  def jsonapi_headers
+    { 'Content-Type': Mime[:jsonapi].to_s }
+  end
+
+  # Parses and returns a deserialized JSON
+  #
+  # @return [Hash]
+  def response_json
+    JSON.parse(response.body)
+  end
+
+  # Creates an user
+  #
+  # @return [User]
+  def create_user
+    User.create!(
+      first_name: FFaker::Name.first_name,
+      last_name: FFaker::Name.last_name
+    )
+  end
+
+  # Creates a note
+  #
+  # @return [Note]
+  def create_note(user = nil)
+    Note.create!(
+      title: FFaker::Company.name,
+      quantity: rand(10),
+      user: (user || create_user)
+    )
+  end
+end
+
+module Rails4RequestMethods
+  [:get, :post, :put, :delete].each do |method_name|
+    define_method(method_name) do |path, named_args|
+      super(
+        path,
+        named_args.delete(:params),
+        named_args.delete(:headers)
+      )
+    end
+  end
+end
+
+RSpec.configure do |config|
+  config.include RSpecHelpers, type: :request
+  config.include RSpecHelpers, type: :controller
+
+  if ::Rails::VERSION::MAJOR == 4
+    config.include Rails4RequestMethods, type: :request
+    config.include Rails4RequestMethods, type: :controller
+  end
+end