api-pagination 6.0.0 → 7.0.0

data/spec/api-pagination_spec.rb

@@ -1,76 +0,0 @@
-require 'spec_helper'
-
-describe ApiPagination do
-  let(:collection) {(1..100).to_a}
-  let(:active_record_relation) {double("ActiveRecord_Relation").as_null_object}
-  let(:paginate_array_options) {{ total_count: 1000 }}
-
-  describe "#paginate" do
-    if ENV['PAGINATOR'].to_sym == :kaminari
-      context 'Using kaminari' do
-        describe '.paginate' do
-          it 'should accept paginate_array_options option' do
-            expect(Kaminari).to receive(:paginate_array)
-              .with(collection, **paginate_array_options)
-              .and_call_original
-
-            ApiPagination.paginate(
-              collection,
-              {
-                per_page: 30,
-                paginate_array_options: paginate_array_options
-              }
-            )
-          end
-
-          context 'configured not to include the total' do
-            before { ApiPagination.config.include_total = false }
-
-            context 'and paginating an array' do
-              it 'should not call without_count on the collection' do
-                expect(collection).to_not receive :without_count
-                ApiPagination.paginate(collection)
-              end
-            end
-            context 'and paginating an active record relation' do
-              it 'should call without_count on the relation' do
-                expect(active_record_relation).to receive :without_count
-                ApiPagination.paginate(active_record_relation)
-              end
-            end
-
-            after { ApiPagination.config.include_total = true }
-          end
-        end
-
-        describe '.pages_from' do
-          subject { described_class.pages_from(collection) }
-
-          context 'on empty collection' do
-            let(:collection) { ApiPagination.paginate([], page: 1).first }
-
-            it { is_expected.to be_empty }
-          end
-        end
-      end
-    end
-
-    if ENV['PAGINATOR'].to_sym == :will_paginate
-      context 'Using will_paginate' do
-        context 'passing in total_entries in options' do
-          it 'should set total_entries using the passed in value' do
-            paginated_collection = ApiPagination.paginate(collection, total_entries: 3000).first
-            expect(paginated_collection.total_entries).to eq(3000)
-          end
-        end
-
-        context 'passing in collection only' do
-          it 'should set total_entries using the size of the collection ' do
-            paginated_collection = ApiPagination.paginate(collection).first
-            expect(paginated_collection.total_entries).to eq(100)
-          end
-        end
-      end
-    end
-  end
-end

data/spec/grape_spec.rb

@@ -1,165 +0,0 @@
-require 'spec_helper'
-require 'support/shared_examples/existing_headers'
-require 'support/shared_examples/first_page'
-require 'support/shared_examples/middle_page'
-require 'support/shared_examples/last_page'
-
-describe NumbersAPI do
-  it { is_expected.to be_kind_of(Grape::Pagination) }
-
-  describe 'GET #index' do
-    let(:link) { last_response.headers['Link'] }
-    let(:links) { link.split(', ') }
-    let(:total) { last_response.headers['Total'].to_i }
-    let(:per_page) { last_response.headers['Per-Page'].to_i }
-
-    context 'without enough items to give more than one page' do
-      before { get '/numbers', :count => 10 }
-
-      it 'should not paginate' do
-        expect(last_response.headers.keys).not_to include('Link')
-      end
-
-      it 'should give a Total header' do
-        expect(total).to eq(10)
-      end
-
-      it 'should give a Per-Page header' do
-        expect(per_page).to eq(10)
-      end
-
-      it 'should list all numbers in the response body' do
-        body = '[1,2,3,4,5,6,7,8,9,10]'
-        expect(last_response.body).to eq(body)
-      end
-    end
-
-    context 'with existing Link headers' do
-      before { get '/numbers', :count => 30, :with_headers => true }
-
-      it_behaves_like 'an endpoint with existing Link headers'
-    end
-
-    context 'with enough items to paginate' do
-      context 'when on the first page' do
-        before { get '/numbers', :count => 100 }
-
-        it_behaves_like 'an endpoint with a first page'
-      end
-
-      context 'when on the last page' do
-        before { get '/numbers', :count => 100, :page => 10 }
-
-        it_behaves_like 'an endpoint with a last page'
-      end
-
-      context 'when somewhere comfortably in the middle' do
-        before { get '/numbers', :count => 100, :page => 2 }
-
-        it_behaves_like 'an endpoint with a middle page'
-      end
-
-      context 'without a max_per_page setting' do
-        before { get '/numbers', :count => 100, :per_page => 30 }
-
-        it 'should list all numbers within per page in the response body' do
-          body = '[1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30]'
-
-          expect(last_response.body).to eq(body)
-        end
-      end
-
-      context 'with a max_per_page setting not enforced' do
-        before { get '/numbers_with_max_per_page', :count => 100, :per_page => 30 }
-
-        it 'should not go above the max_per_page_limit' do
-          body = '[1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25]'
-
-          expect(last_response.body).to eq(body)
-        end
-      end
-
-      context 'with a max_per_page setting enforced' do
-        before { get '/numbers_with_enforced_max_per_page', :count => 100, :per_page => 30 }
-
-        it 'should not allow value above the max_per_page_limit' do
-          body = '{"error":"per_page does not have a valid value"}'
-
-          expect(last_response.body).to eq(body)
-        end
-      end
-    end
-
-    context 'with custom response headers' do
-      before do
-        ApiPagination.config.total_header    = 'X-Total-Count'
-        ApiPagination.config.per_page_header = 'X-Per-Page'
-        ApiPagination.config.page_header     = 'X-Page'
-
-        get '/numbers', count: 10
-      end
-
-      after do
-        ApiPagination.config.total_header    = 'Total'
-        ApiPagination.config.per_page_header = 'Per-Page'
-        ApiPagination.config.page_header     = nil
-      end
-
-      let(:total) { last_response.header['X-Total-Count'].to_i }
-      let(:per_page) { last_response.header['X-Per-Page'].to_i }
-      let(:page) { last_response.header['X-Page'].to_i }
-
-      it 'should give a X-Total-Count header' do
-        headers_keys = last_response.headers.keys
-
-        expect(headers_keys).not_to include('Total')
-        expect(headers_keys).to include('X-Total-Count')
-        expect(total).to eq(10)
-      end
-
-      it 'should give a X-Per-Page header' do
-        headers_keys = last_response.headers.keys
-
-        expect(headers_keys).not_to include('Per-Page')
-        expect(headers_keys).to include('X-Per-Page')
-        expect(per_page).to eq(10)
-      end
-
-      it 'should give a X-Page header' do
-        headers_keys = last_response.headers.keys
-
-        expect(headers_keys).to include('X-Page')
-        expect(page).to eq(1)
-      end
-    end
-
-    context 'configured not to include the total' do
-      before { ApiPagination.config.include_total = false }
-
-      it 'should not include a Total header' do
-        get '/numbers', count: 10
-
-        expect(last_response.header['Total']).to be_nil
-      end
-
-      it 'should not include a link with rel "last"' do
-        get '/numbers', count: 100
-
-        expect(link).to_not include('rel="last"')
-      end
-
-      after { ApiPagination.config.include_total = true }
-    end
-
-    context 'with query string including array parameter' do
-      before do
-        get '/numbers', { count: 100, parity: ['odd', 'even']}
-      end
-
-      it 'returns links with with same received parameters' do
-        expect(links).to include('<http://example.org/numbers?count=100&page=10&parity%5B%5D=odd&parity%5B%5D=even>; rel="last"')
-        expect(links).to include('<http://example.org/numbers?count=100&page=2&parity%5B%5D=odd&parity%5B%5D=even>; rel="next"')
-      end
-    end
-  end
-end

data/spec/rails_spec.rb

@@ -1,312 +0,0 @@
-require 'spec_helper'
-require 'support/shared_examples/existing_headers'
-require 'support/shared_examples/first_page'
-require 'support/shared_examples/middle_page'
-require 'support/shared_examples/last_page'
-
-describe NumbersController, :type => :controller do
-  before { request.host = 'example.org' }
-
-  describe 'GET #index' do
-    let(:link) { response.headers['Link'] }
-    let(:links) { link.split(', ') }
-    let(:total) { response.headers['Total'].to_i }
-    let(:per_page) { response.headers['Per-Page'].to_i }
-
-    context 'without enough items to give more than one page' do
-      before { get :index, params: {count: 10} }
-
-      it 'should not paginate' do
-        expect(response.headers.keys).not_to include('Link')
-      end
-
-      it 'should give a Total header' do
-        expect(total).to eq(10)
-      end
-
-      it 'should give a Per-Page header' do
-        expect(per_page).to eq(10)
-      end
-
-      it 'should list all numbers in the response body' do
-        body = '[1,2,3,4,5,6,7,8,9,10]'
-        expect(response.body).to eq(body)
-      end
-    end
-
-    context 'with existing Link headers' do
-      before { get :index, params: {count: 30, with_headers: true} }
-
-      it_behaves_like 'an endpoint with existing Link headers'
-    end
-
-    context 'with enough items to paginate' do
-      context 'when on the first page' do
-        before { get :index, params: {count: 100} }
-
-        it_behaves_like 'an endpoint with a first page'
-      end
-
-      context 'when on the last page' do
-        before { get :index, params: {count: 100, page: 10} }
-
-        it_behaves_like 'an endpoint with a last page'
-      end
-
-      context 'when somewhere comfortably in the middle' do
-        before { get :index, params: {count: 100, page: 2} }
-
-        it_behaves_like 'an endpoint with a middle page'
-      end
-    end
-
-    context 'providing a block' do
-      it 'yields to the block instead of implicitly rendering' do
-        get :index_with_custom_render, params: {count: 100}
-
-        json = { numbers: (1..10).map { |n| { number: n } } }.to_json
-
-        expect(response.body).to eq(json)
-      end
-    end
-
-    context 'with custom response headers' do
-      before do
-        ApiPagination.config.total_header    = 'X-Total-Count'
-        ApiPagination.config.per_page_header = 'X-Per-Page'
-        ApiPagination.config.page_header     = 'X-Page'
-        ApiPagination.config.base_url        = 'http://guybrush:3000'
-
-        get :index, params: params
-      end
-
-      after do
-        ApiPagination.config.total_header    = 'Total'
-        ApiPagination.config.per_page_header = 'Per-Page'
-        ApiPagination.config.page_header     = nil
-        ApiPagination.config.base_url        = nil
-      end
-
-      let(:params) { { count: 10 } }
-      let(:total) { response.header['X-Total-Count'].to_i }
-      let(:per_page) { response.header['X-Per-Page'].to_i }
-      let(:page) { response.header['X-Page'].to_i }
-      let(:link) { response.header['Link'] }
-
-      it 'should give a X-Total-Count header' do
-        headers_keys = response.headers.keys
-
-        expect(headers_keys).not_to include('Total')
-        expect(headers_keys).to include('X-Total-Count')
-        expect(total).to eq(10)
-      end
-
-      it 'should give a X-Per-Page header' do
-        headers_keys = response.headers.keys
-
-        expect(headers_keys).not_to include('Per-Page')
-        expect(headers_keys).to include('X-Per-Page')
-        expect(per_page).to eq(10)
-      end
-
-      it 'should give a X-Page header' do
-        headers_keys = response.headers.keys
-
-        expect(headers_keys).to include('X-Page')
-        expect(page).to eq(1)
-      end
-
-      context 'with paginated result' do
-        let(:params) { { count: 20 } }
-        it 'should use custom base_url in the Link header' do
-
-          expect(response.headers['Link']).to eq(
-            '<http://guybrush:3000/numbers?count=20&page=2>; rel="last", <http://guybrush:3000/numbers?count=20&page=2>; rel="next"')
-        end
-      end
-    end
-
-    context 'configured not to include the total' do
-      before { ApiPagination.config.include_total = false }
-
-      it 'should not include a Total header' do
-        get :index, params: {count: 10}
-
-        expect(response.header['Total']).to be_nil
-      end
-
-      it 'should not include a link with rel "last"' do
-        get :index, params: { count: 100 }
-
-        expect(link).to_not include('rel="last"')
-      end
-
-      after { ApiPagination.config.include_total = true }
-    end
-
-    context 'custom page param' do
-      context 'page_param as a symbol' do
-        before do
-          ApiPagination.config.page_param = :foo
-          ApiPagination.config.page_header = 'Page'
-        end
-
-        after do
-          ApiPagination.config.page_param = :page
-          ApiPagination.config.page_header = nil
-        end
-
-        it 'should work' do
-          get :index, params: {foo: 2, count: 100}
-
-          expect(response.header['Page']).to eq('2')
-        end
-      end
-
-      context 'page_param as a block' do
-        before do
-          ApiPagination.config.page_param do |params|
-            params[:foo][:bar]
-          end
-
-          ApiPagination.config.page_header = 'Page'
-        end
-
-        after do
-          ApiPagination.config.page_param = :page
-          ApiPagination.config.page_header = nil
-        end
-
-        it 'should work' do
-          get :index, params: {foo: {bar:  2}, count: 100}
-
-          expect(response.header['Page']).to eq('2')
-        end
-      end
-    end
-
-    context 'custom per_page param' do
-      context 'per_page_param as a symbol' do
-        before do
-          ApiPagination.config.per_page_param = :foo
-        end
-
-        after do
-          ApiPagination.config.per_page_param = :per_page
-        end
-
-        it 'should work' do
-          get :index_with_no_per_page, params: {foo: 2, count: 100}
-
-          expect(response.header['Per-Page']).to eq('2')
-        end
-      end
-
-      context 'page_param as a block' do
-        before do
-          ApiPagination.config.per_page_param do |params|
-            params[:foo][:bar]
-          end
-        end
-
-        after do
-          ApiPagination.config.per_page_param = :per_page
-        end
-
-        it 'should work' do
-          get :index_with_no_per_page, params: {foo: {bar: 2}, count: 100}
-
-          expect(response.header['Per-Page']).to eq('2')
-        end
-      end
-    end
-
-    if ApiPagination.config.paginator.to_sym == :kaminari
-      context 'paginate array options' do
-        let(:paginate_array_total_count) { 300 }
-        let(:total_header) { 300 }
-        let(:count) { 50 }
-        let(:params) do
-          {
-            paginate_array_total_count: paginate_array_total_count,
-            count: count,
-          }
-        end
-
-        it 'has a properly set Total header' do
-          get :index_with_paginate_array_options, params: params
-
-          expect(response.header['Total']).to be_kind_of(String)
-          expect(response.header['Total'].to_i).to eq total_header
-        end
-      end
-    end
-
-    if [:will_paginate, :kaminari].include?(ApiPagination.config.paginator.to_sym)
-      context 'default per page in model' do
-        before do
-          class Fixnum
-            @default_per_page = 6
-            @per_page = 6
-
-            class << self
-              attr_accessor :default_per_page, :per_page
-            end
-          end
-        end
-
-        after do
-          class Fixnum
-            @default_per_page = 25
-            @per_page = 25
-          end
-        end
-
-        after :all do
-          class Fixnum
-            class << self
-              undef_method :default_per_page, :per_page
-            end
-          end
-        end
-
-        it 'should use default per page from model' do
-          get :index_with_no_per_page, params: {count: 100}
-
-          expect(response.header['Per-Page']).to eq('6')
-        end
-
-        it 'should not fail if the model yields nil for per page' do
-          class Fixnum
-            @default_per_page = nil
-            @per_page = nil
-          end
-
-          get :index_with_no_per_page, params: {count: 100}
-
-          expect(response.header['Per-Page']).to eq(
-            case ApiPagination.config.paginator
-            when :pagy          then Pagy::DEFAULT[:limit].to_s
-            when :kaminari      then Kaminari.config.default_per_page.to_s
-            when :will_paginate then WillPaginate.per_page.to_s
-            end
-          )
-        end
-      end
-    end
-
-    context 'default per page in objects without paginator defaults' do
-      it 'should not fail if model does not respond to per page' do
-        get :index_with_no_per_page, params: {count: 100}
-
-        expect(response.header['Per-Page']).to eq(
-          case ApiPagination.config.paginator
-          when :pagy          then Pagy::DEFAULT[:limit].to_s
-          when :kaminari      then Kaminari.config.default_per_page.to_s
-          when :will_paginate then WillPaginate.per_page.to_s
-          end
-        )
-      end
-    end
-  end
-end

data/spec/sequel_spec.rb

@@ -1,30 +0,0 @@
-require 'spec_helper'
-
-if ApiPagination.config.paginator == :will_paginate
-  require 'sqlite3'
-  require 'sequel'
-  require 'will_paginate/sequel'
-
-  DB = Sequel.sqlite
-  DB.extension :pagination
-  DB.create_table :people do
-    primary_key :id
-    String :name
-  end
-
-  describe 'Using will_paginate with Sequel' do
-    let(:people) do
-      DB[:people]
-    end
-
-    before(:each) do
-      people.insert(name: 'John')
-      people.insert(name: 'Mary')
-    end
-
-    it 'returns a Sequel::Dataset' do
-      collection = ApiPagination.paginate(people).first
-      expect(collection.kind_of?(Sequel::Dataset)).to be_truthy
-    end
-  end
-end

data/spec/spec_helper.rb

@@ -1,39 +0,0 @@
-require 'support/numbers_controller'
-require 'support/numbers_api'
-require 'api-pagination'
-
-if ENV['PAGINATOR'].nil?
-  warn <<-WARNING
-No PAGINATOR set. Defaulting to pagy.
-
-To test against kaminari, run `PAGINATOR=kaminari bundle exec rspec`
-To test against will_paginate, run `PAGINATOR=will_paginate bundle exec rspec`
-WARNING
-
-  ENV['PAGINATOR'] = 'pagy'
-end
-
-require ENV['PAGINATOR']
-ApiPagination.config.paginator = ENV['PAGINATOR'].to_sym
-
-require 'will_paginate/array' if ENV['PAGINATOR'].to_sym == :will_paginate
-
-RSpec.configure do |config|
-  config.include Rack::Test::Methods
-  config.include ControllerExampleGroup, :type => :controller
-
-  # Disable the 'should' syntax.
-  config.expect_with :rspec do |c|
-    c.syntax = :expect
-  end
-
-  # Run specs in random order to surface order dependencies. If you find an
-  # order dependency and want to debug it, you can fix the order by providing
-  # the seed, which is printed after each run.
-  #     --seed 1234
-  config.order = 'random'
-
-  def app
-    NumbersAPI
-  end
-end

data/spec/support/active_record/foo.rb

@@ -1,3 +0,0 @@
-require 'active_record'
-
-class Foo < ActiveRecord::Base; end

data/spec/support/active_record/schema.rb

@@ -1,5 +0,0 @@
-ActiveRecord::Schema.define(version: 0) do
-  create_table "foos", :force => true do |t|
-    t.string   "foo"
-  end
-end

data/spec/support/numbers_api.rb

@@ -1,41 +0,0 @@
-require 'grape'
-require 'api-pagination'
-
-class NumbersAPI < Grape::API
-  format :json
-
-  desc 'Return some paginated set of numbers'
-  paginate :per_page => 10
-  params do
-    requires :count, :type => Integer
-    optional :with_headers, :default => false, :type => Boolean
-  end
-  get :numbers do
-    if params[:with_headers]
-      url   = request.url.sub(/\?.*/, '')
-      query = Rack::Utils.parse_query(request.query_string)
-      query.delete('with_headers')
-      header 'Link', %(<#{url}?#{query.to_query}>; rel="without")
-    end
-
-    paginate (1..params[:count]).to_a
-  end
-
-  desc 'Return some paginated set of numbers with max_per_page'
-  paginate :per_page => 10, :max_per_page => 25
-  params do
-    requires :count, :type => Integer
-  end
-  get :numbers_with_max_per_page  do
-    paginate (1..params[:count]).to_a
-  end
-
-  desc 'Return some paginated set of numbers with max_per_page enforced'
-  paginate :per_page => 10, :max_per_page => 25, :enforce_max_per_page => true
-  params do
-    requires :count, :type => Integer
-  end
-  get :numbers_with_enforced_max_per_page  do
-    paginate (1..params[:count]).to_a
-  end
-end