rails_api_kit 1.0.0

data/spec/pagination_spec.rb

@@ -0,0 +1,335 @@
+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: api_headers)
+    end
+
+    it do
+      expect(response_json['data'].size).to eq(0)
+      expect(response_json['meta'])
+        .to eq(
+          'many' => true,
+          'pagination' => {
+            'current' => 1,
+            'total_page' => 1,
+            'total_count' => 0
+          }
+        )
+    end
+
+    def query_str(parms, page: nil)
+      parms = parms.deep_merge(page: { number: page }) if page
+
+      arg_params = parms.dup
+      if page == 1
+        arg_params.delete(:page)
+      end
+
+      "?#{CGI.unescape(arg_params.to_query)}"
+    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]['id']).to eql(third_user.id)
+          expect(response_json['data'][1]['id']).to eql(second_user.id)
+          expect(response_json['data'][2]['id']).to eql(first_user.id)
+
+          expect(response_json).to have_link('current')
+          expect(response_json).to have_link(:prev)
+          expect(response_json).to have_link(:next)
+          expect(response_json).to have_link(:first)
+          expect(response_json).to have_link(:last)
+
+          query = CGI.unescape(params.except(:page).to_query)
+          expect(URI.parse(response_json['links']['current']).query).to eq(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 'should exclude' do
+              expect(response).to have_http_status(:ok)
+              expect(response_json['data'].size).to eq(1)
+              expect(response_json['data'][0]['id']).to eql(second_user.id)
+
+              expect(response_json['meta']['pagination']).to eq(
+                'current' => 2,
+                'total_count' => 3,
+                'total_page' => 3
+              )
+              expect(response_json['links']).to eq(
+                'current' => query_str(params),
+                'first' => query_str(params, page: 1),
+                'prev' => query_str(params, page: 1),
+                'next' => query_str(params, page: 3),
+                'last' => query_str(params, page: 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]['id']).to eql(second_user.id)
+
+            expect(response_json['meta']['pagination']).to eq(
+              'current' => 2,
+              'total_count' => 3,
+              'total_page' => 3
+            )
+            expect(response_json['links']).to eq(
+              'current' => query_str(params),
+              'first' => query_str(params, page: 1),
+              'prev' => query_str(params, page: 1),
+              'next' => query_str(params, page: 3),
+              'last' => query_str(params, page: 3),
+            )
+
+            expect(response_json).to have_link(:current)
+            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']['current']).query)
+              .to eq(qry)
+
+            qry = CGI.unescape(params.deep_merge(page: { number: 2 }).to_query)
+            expect(URI.parse(response_json['links']['current']).query)
+              .to eq(qry)
+
+            qry = CGI.unescape(params.except(:page).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,
+              'total_count' => 3,
+              'total_page' => 3
+            )
+            expect(response_json['links']).to eq(
+              'current' => query_str(params),
+              'first' => query_str(params, page: 1),
+              'prev' => query_str(params, page: 2),
+              'next' => nil,
+              'last' => query_str(params, page: 3),
+            )
+
+            expect(response_json).to have_link(:current)
+            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)
+
+            expect(URI.parse(response_json['links']['current']).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.except(:page).to_query)
+            expect(URI.parse(response_json['links']['first']).query).to eq(qry)
+          end
+        end
+
+
+        context 'on page empty' do
+          let(:params) do
+            {
+              page: { number: 3 }
+            }
+          end
+
+          it do
+            expect(response).to have_http_status(:ok)
+            expect(response_json['data'].size).to eq(0)
+            expect(response_json['data']).to eql([])
+
+            expect(response_json['meta']['pagination']).to eq(
+                                                             'current' => 3,
+                                                             'total_count' => 3,
+                                                             'total_page' => 1
+                                                           )
+            expect(response_json['links']).to eq(
+                                                'current' => query_str(params),
+                                                'first' => query_str(params, page: 1),
+                                                'prev' => query_str(params, page: 2),
+                                                'next' => nil,
+                                                'last' => '?',
+                                                )
+
+            expect(response_json).to have_link(:current)
+            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)
+
+            expect(URI.parse(response_json['links']['current']).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.except(:page).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,
+                'total_count' => 3,
+                'total_page' => 3
+              )
+              expect(response_json['links']).to eq(
+                'current' => query_str(params),
+                'first' => query_str(params, page: 1),
+                'prev' => query_str(params, page: 4),
+                'next' => nil,
+                'last' => query_str(params, page: 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,
+              'total_count' => 3,
+              'total_page' => 3
+            )
+            expect(response_json['links']).to eq(
+              'current' => query_str(params),
+              'first' => query_str(params, page: 1),
+              'prev' => query_str(params, page: 4),
+              'next' => nil,
+              'last' => query_str(params, page: 3),
+            )
+
+            expect(response_json).to have_link(:current)
+            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)
+
+            expect(URI.parse(response_json['links']['current']).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.except(:page).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, number: 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]['id']).to eql(third_user.id)
+
+            expect(response_json['meta']['pagination']).to eq(
+              'current' => 1,
+              'total_count' => 3,
+              'total_page' => 3,
+            )
+            expect(response_json['links']).to eq(
+              'current' => query_str(params, page: 1),
+              'first' => query_str(params, page: 1),
+              'prev' => nil,
+              'next' => query_str(params, page: 2),
+              'last' => query_str(params, page: 3),
+            )
+
+            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(:current)
+            expect(response_json).to have_link(:last)
+
+            expect(URI.parse(response_json['links']['current']).query)
+              .to eq(CGI.unescape(params.except(:page).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'
+Dir[File.join(__dir__, 'support', '**', '*.rb')].sort.each { |file| require file }
+
+RSpec.configure do |config|
+  config.include ApiKit::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
+
+  # Silence ActiveModelSerializers logs during tests
+  if defined?(ActiveModelSerializers)
+    ActiveModelSerializers.logger = Logger.new(nil)
+  end
+end
+
+module RSpecHelpers
+  include Dummy.routes.url_helpers
+
+  # Helper to return valid API headers
+  #
+  # @return [Hash] the relevant content type &co
+  def api_headers
+    { 'Content-Type': Mime[:json].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
+end

data/spec/support/api_kit_rspec.rb

@@ -0,0 +1,41 @@
+module ApiKit
+  module RSpec
+    module_function
+
+    def as_indifferent_hash(doc)
+      return doc unless ::RSpec.configuration.apikit_indifferent_hash
+
+      if doc.respond_to?(:with_indifferent_access)
+        return doc.with_indifferent_access
+      end
+
+      JSON.parse(JSON.generate(doc))
+    end
+  end
+end
+
+::RSpec.configure do |config|
+  config.add_setting :apikit_indifferent_hash, default: true
+end
+
+::RSpec::Matchers.define :have_link do |link|
+  match do |actual|
+    actual = ApiKit::RSpec.as_indifferent_hash(actual)
+    actual.key?('links') && actual['links'].key?(link.to_s) &&
+      (!@val_set || actual['links'][link.to_s] == @val)
+  end
+
+  chain :with_value do |val|
+    @val_set = true
+    @val = val
+  end
+end
+
+::RSpec::Matchers.define :have_links do |*links|
+  match do |actual|
+    actual = ApiKit::RSpec.as_indifferent_hash(actual)
+    return false unless actual.key?('links')
+
+    links.all? { |link| actual['links'].key?(link.to_s) }
+  end
+end