Takes per page setting into account when paginate

`Gitlab::Pagination::OffsetPagination` now takes into account already
specified per page settings configured via `#per` method of Kaminari

Changelog: fixed

lib/gitlab/pagination/offset_pagination.rb

@@ -19,11 +19,10 @@ module Gitlab
       private
 
       def paginate_with_limit_optimization(relation)
-        # do not paginate relation if it is already paginated
-        pagination_data = if relation.respond_to?(:current_page) && relation.current_page == params[:page] && relation.limit_value == params[:per_page]
-                            relation
-                          else
+        pagination_data = if needs_pagination?(relation)
                             relation.page(params[:page]).per(params[:per_page])
+                          else
+                            relation
                           end
 
         return pagination_data unless pagination_data.is_a?(ActiveRecord::Relation)
@@ -39,6 +38,14 @@ module Gitlab
         end
       end
 
+      def needs_pagination?(relation)
+        return true unless relation.respond_to?(:current_page)
+        return true if params[:page].present? && relation.current_page != params[:page].to_i
+        return true if params[:per_page].present? && relation.limit_value != params[:per_page].to_i
+
+        false
+      end
+
       def add_default_order(relation)
         if relation.is_a?(ActiveRecord::Relation) && relation.order_values.empty?
           relation = relation.order(:id) # rubocop: disable CodeReuse/ActiveRecord

spec/lib/gitlab/pagination/offset_pagination_spec.rb

@@ -130,6 +130,80 @@ RSpec.describe Gitlab::Pagination::OffsetPagination do
           end
         end
 
+        context 'when resource already paginated' do
+          let(:resource) { Project.all.page(1).per(1) }
+
+          context 'when per_page param is specified' do
+            let(:query) { base_query.merge(page: 1, per_page: 2) }
+
+            it 'returns appropriate amount of resources based on per_page param' do
+              expect(subject.paginate(resource).count).to eq 2
+            end
+          end
+
+          context 'when page and per page params are strings' do
+            let(:query) { base_query.merge(page: '1', per_page: '1') }
+
+            it 'returns appropriate amount of resources' do
+              expect(subject.paginate(resource).count).to eq 1
+            end
+          end
+
+          context 'when per_page param is blank' do
+            let(:query) { base_query.merge(page: 1) }
+
+            it 'returns appropriate amount of resources' do
+              expect(subject.paginate(resource).count).to eq 1
+            end
+          end
+
+          context 'when page param is blank' do
+            let(:query) { base_query }
+
+            it 'returns appropriate amount of resources based on resource per(N)' do
+              expect(subject.paginate(resource).count).to eq 1
+            end
+          end
+        end
+
+        context 'when resource does not respond to limit_value' do
+          let(:custom_collection) do
+            Class.new do
+              include Enumerable
+
+              def initialize(items)
+                @collection = items
+              end
+
+              def each
+                @collection.each { |item| yield item }
+              end
+
+              def page(number)
+                Kaminari.paginate_array(@collection).page(number)
+              end
+            end
+          end
+
+          let(:resource) { custom_collection.new(Project.all).page(query[:page]) }
+
+          context 'when page param is blank' do
+            let(:query) { base_query }
+
+            it 'returns appropriate amount of resources' do
+              expect(subject.paginate(resource).count).to eq 3
+            end
+          end
+
+          context 'when per_page param is blank' do
+            let(:query) { base_query.merge(page: 1) }
+
+            it 'returns appropriate amount of resources with default per page value' do
+              expect(subject.paginate(resource).count).to eq 3
+            end
+          end
+        end
+
         context 'when resource is a paginatable array' do
           let(:resource) { Kaminari.paginate_array(Project.all.to_a) }