brainstem 1.0.0 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 115ca6ee598304821711410e09788b194b4463d3
-  data.tar.gz: eb49966eafe33595f32048f087ee7148a0b4da36
+  metadata.gz: 9bf2b0cdf9ecd18e7a90f8484238fe6e7f63ad43
+  data.tar.gz: 7be99f891a90e26715f553fcf0971931bf51c404
 SHA512:
-  metadata.gz: 45af28ac0b45a91167174b0809e79c22a20864cb2facb3c59c23fdad0d71e62dec0299db8f74748a0c0306169aa05eaf756f5564459f43d19edb2b0045bbb30c
-  data.tar.gz: 8050a810b6b1046d00d7aa961bebe48698604be562f28c73943c5160d4668b47c92ff9c4bb52a03e67eb67804d4f9d5a8391507cd5328b8138546e7febefcdc8
+  metadata.gz: 138e7db36bf3692bde7fac6c61777ea8695195d32769dec30555bc2d4b5124679dd8f22e08624503ba3148e64c058bcad31f72b24842f2bf864bb4291ca8e052
+  data.tar.gz: 37760c56b41a4fbf8dbb5e19b543229c878e61fd88a7a8400f961140565b70c9b738b1882b7aeee1dc3c41e651695e02ab43ed95efd1483a80eafbdf38abf50c

data/CHANGELOG.md

@@ -1,5 +1,8 @@
 # Changelog
 
++ **1.1.0 - _12/18/2017_
+  - Add `meta` key to API responses which includes `page_number`, `page_count`, and `page_size` keys.
+
 + **1.0.0 - _07/20/2017_
   - Add the capability to generate the documentation extracted from your properly annotated
     presenters and controllers using `bundle exec brainstem generate [ARGS]`.

data/Gemfile.lock

@@ -1,60 +1,64 @@
 PATH
   remote: .
   specs:
-    brainstem (1.0.0.pre)
+    brainstem (1.1.0)
       activerecord (>= 4.1)
       activesupport (>= 4.1)
 
 GEM
   remote: https://rubygems.org/
   specs:
-    activemodel (5.0.2)
-      activesupport (= 5.0.2)
-    activerecord (5.0.2)
-      activemodel (= 5.0.2)
-      activesupport (= 5.0.2)
-      arel (~> 7.0)
-    activesupport (5.0.2)
+    activemodel (5.1.4)
+      activesupport (= 5.1.4)
+    activerecord (5.1.4)
+      activemodel (= 5.1.4)
+      activesupport (= 5.1.4)
+      arel (~> 8.0)
+    activesupport (5.1.4)
       concurrent-ruby (~> 1.0, >= 1.0.2)
       i18n (~> 0.7)
       minitest (~> 5.1)
       tzinfo (~> 1.1)
-    arel (7.1.4)
-    coderay (1.1.1)
+    arel (8.0.0)
+    coderay (1.1.2)
     concurrent-ruby (1.0.5)
-    database_cleaner (1.5.3)
+    database_cleaner (1.6.2)
+    db-query-matchers (0.9.0)
+      activesupport (>= 4.0, <= 6.0)
+      rspec (~> 3.0)
     diff-lcs (1.3)
-    i18n (0.8.1)
-    method_source (0.8.2)
-    minitest (5.10.1)
-    pry (0.10.4)
-      coderay (~> 1.1.0)
-      method_source (~> 0.8.1)
+    i18n (0.9.1)
+      concurrent-ruby (~> 1.0)
+    method_source (0.9.0)
+    minitest (5.10.3)
+    pry (0.9.12.6)
+      coderay (~> 1.0)
+      method_source (~> 0.8)
       slop (~> 3.4)
     pry-nav (0.2.4)
       pry (>= 0.9.10, < 0.11.0)
-    rake (12.0.0)
+    rake (12.2.1)
     redcarpet (3.4.0)
-    rr (1.2.0)
-    rspec (3.5.0)
-      rspec-core (~> 3.5.0)
-      rspec-expectations (~> 3.5.0)
-      rspec-mocks (~> 3.5.0)
-    rspec-core (3.5.4)
-      rspec-support (~> 3.5.0)
-    rspec-expectations (3.5.0)
+    rr (1.2.1)
+    rspec (3.7.0)
+      rspec-core (~> 3.7.0)
+      rspec-expectations (~> 3.7.0)
+      rspec-mocks (~> 3.7.0)
+    rspec-core (3.7.0)
+      rspec-support (~> 3.7.0)
+    rspec-expectations (3.7.0)
       diff-lcs (>= 1.2.0, < 2.0)
-      rspec-support (~> 3.5.0)
-    rspec-mocks (3.5.0)
+      rspec-support (~> 3.7.0)
+    rspec-mocks (3.7.0)
       diff-lcs (>= 1.2.0, < 2.0)
-      rspec-support (~> 3.5.0)
-    rspec-support (3.5.0)
+      rspec-support (~> 3.7.0)
+    rspec-support (3.7.0)
     slop (3.6.0)
     sqlite3 (1.3.13)
     thread_safe (0.3.6)
-    tzinfo (1.2.2)
+    tzinfo (1.2.4)
       thread_safe (~> 0.1)
-    yard (0.9.8)
+    yard (0.9.9)
 
 PLATFORMS
   ruby
@@ -62,6 +66,7 @@ PLATFORMS
 DEPENDENCIES
   brainstem!
   database_cleaner
+  db-query-matchers
   pry
   pry-nav
   rake

data/README.md

@@ -216,6 +216,21 @@ Responses will look like the following:
   # Total number of results that matched the query.
   count: 5,
 
+  # Information about the request and response.
+  meta: {
+    # Total number of results that matched the query.
+    count: 5,
+
+    # Current page returned in the response.
+    page_number: 1,
+
+    # Total number pages available.
+    page_count: 1,
+
+    # Number of results per page.
+    page_size: 20,
+  },
+
   # A lookup table to top-level keys. Necessary
   # because some objects can have associations of
   # the same type as themselves. Also helps to

data/brainstem.gemspec

@@ -31,4 +31,5 @@ Gem::Specification.new do |gem|
   gem.add_development_dependency "yard"
   gem.add_development_dependency "pry"
   gem.add_development_dependency "pry-nav"
+  gem.add_development_dependency "db-query-matchers"
 end

data/lib/brainstem/presenter_collection.rb

@@ -53,17 +53,18 @@ module Brainstem
       options[:default_max_per_page] = default_max_per_page
       options[:default_max_filter_and_search_page] = default_max_filter_and_search_page
 
-      primary_models, count = strategy(options, scope).execute(scope)
+      strategy = get_strategy(options, scope)
+      primary_models, count = strategy.execute(scope)
 
       # Determine if an exception should be raised on an empty result set.
       if options[:raise_on_empty] && primary_models.empty?
         raise options[:empty_error_class] || ActiveRecord::RecordNotFound
       end
 
-      structure_response(presented_class, primary_models, count, options)
+      structure_response(presented_class, primary_models, strategy, count, options)
     end
 
-    def structure_response(presented_class, primary_models, count, options)
+    def structure_response(presented_class, primary_models, strategy, count, options)
       # key these models will use in the struct that is output
       brainstem_key = brainstem_key_for!(presented_class)
 
@@ -71,8 +72,19 @@ module Brainstem
       selected_associations = filter_includes(options)
 
       optional_fields = filter_optional_fields(options)
-
-      struct = { 'count' => count, brainstem_key => {}, 'results' => [] }
+      page_size = strategy.calculate_per_page
+
+      struct = {
+        'count' => count,
+        'results' => [],
+        brainstem_key => {},
+        'meta' => {
+          'count' => count,
+          'page_count' => count > 0 ? (count.to_f / page_size).ceil : 0,
+          'page_number' => count > 0 ? options[:params].fetch(:page, 1).to_i : 0,
+          'page_size' => page_size,
+        }
+      }
 
       # Build top-level keys for all requested associations.
       selected_associations.each do |association|
@@ -145,7 +157,7 @@ module Brainstem
 
     private
 
-    def strategy(options, scope)
+    def get_strategy(options, scope)
       strat = options[:primary_presenter].get_query_strategy
 
       return Brainstem::QueryStrategies::FilterAndSearch.new(options) if strat == :filter_and_search && searching?(options)

data/lib/brainstem/query_strategies/base_strategy.rb

@@ -26,6 +26,12 @@ module Brainstem
         end
       end
 
+      def calculate_per_page
+        per_page = [(@options[:params][:per_page] || @options[:per_page] || @options[:default_per_page]).to_i, (@options[:max_per_page] || @options[:default_max_per_page]).to_i].min
+        per_page = @options[:default_per_page] if per_page < 1
+        per_page
+      end
+
       private
 
       def calculate_limit
@@ -36,12 +42,6 @@ module Brainstem
         [@options[:params][:offset].to_i, 0].max
       end
 
-      def calculate_per_page
-        per_page = [(@options[:params][:per_page] || @options[:per_page] || @options[:default_per_page]).to_i, (@options[:max_per_page] || @options[:default_max_per_page]).to_i].min
-        per_page = @options[:default_per_page] if per_page < 1
-        per_page
-      end
-
       def calculate_page
         [(@options[:params][:page] || 1).to_i, 1].max
       end
@@ -57,6 +57,33 @@ module Brainstem
           end
         end
       end
+
+      def order_for_search(records, ordered_search_ids, options = {})
+        ids_to_position = {}
+        ordered_records = []
+
+        ordered_search_ids.each_with_index do |id, index|
+          ids_to_position[id] = index
+        end
+
+        records.each do |record|
+          ordered_records[ids_to_position[options[:with_ids] ? record : record.id]] = record
+        end
+
+        ordered_records.compact
+      end
+
+      def calculate_limit_and_offset
+        if @options[:params][:limit].present? && @options[:params][:offset].present?
+          limit = calculate_limit
+          offset = calculate_offset
+        else
+          limit = calculate_per_page
+          offset = limit * (calculate_page - 1)
+        end
+
+        [limit, offset]
+      end
     end
   end
 end

data/lib/brainstem/query_strategies/filter_and_search.rb

@@ -2,13 +2,31 @@ module Brainstem
   module QueryStrategies
     class FilterAndSearch < BaseStrategy
       def execute(scope)
-        ordered_search_ids = run_search(scope, filter_includes.map(&:name))
-        scope = scope.where(id: ordered_search_ids)
+        scope, ordered_search_ids = run_search(scope, filter_includes.map(&:name))
         scope = @options[:primary_presenter].apply_filters_to_scope(scope, @options[:params], @options)
-        scope = @options[:primary_presenter].apply_ordering_to_scope(scope, @options[:params])
-        count = scope.count
-        scope = paginate(scope)
-        primary_models = evaluate_scope(scope)
+
+        if ordering?
+          count = scope.count
+          scope = paginate(scope)
+          scope = @options[:primary_presenter].apply_ordering_to_scope(scope, @options[:params])
+          primary_models = evaluate_scope(scope)
+        else
+          filtered_ids = scope.pluck(:id)
+          count = filtered_ids.size
+
+          # order a potentially large set of ids
+          ordered_ids = order_for_search(filtered_ids, ordered_search_ids, with_ids: true)
+          ordered_paginated_ids = paginate_array(ordered_ids)
+
+          scope = scope.unscoped.where(id: ordered_paginated_ids)
+          # not using `evaluate_scope` because we are already instantiating
+          # a scope based on ids
+          primary_models = scope.to_a
+
+          # Once hydrated, a page worth of models needs to be reordered
+          # due to the `scope.unscoped.where(id: ...` clobbering our ordering
+          primary_models = order_for_search(primary_models, ordered_paginated_ids)
+        end
 
         [primary_models, count]
       end
@@ -16,10 +34,8 @@ module Brainstem
       private
 
       def run_search(scope, includes)
-        sort_name, direction = @options[:primary_presenter].calculate_sort_name_and_direction @options[:params]
         search_options = HashWithIndifferentAccess.new(
           include: includes,
-          order: { sort_order: sort_name, direction: direction },
           limit: @options[:default_max_filter_and_search_page],
           offset: 0
         )
@@ -28,23 +44,28 @@ module Brainstem
 
         result_ids, _ = @options[:primary_presenter].run_search(@options[:params][:search], search_options)
         if result_ids
-          result_ids
+          resulting_scope = scope.where(id: result_ids)
+          [resulting_scope, result_ids]
         else
           raise(SearchUnavailableError, 'Search is currently unavailable')
         end
       end
 
-      def paginate(scope)
-        if @options[:params][:limit].present? && @options[:params][:offset].present?
-          limit = calculate_limit
-          offset = calculate_offset
-        else
-          limit = calculate_per_page
-          offset = limit * (calculate_page - 1)
-        end
+      def ordering?
+        sort_name = @options[:params][:order].to_s.split(":").first
+        sort_orders = @options[:primary_presenter].configuration[:sort_orders]
+        sort_name.present? && sort_orders && sort_orders[sort_name].present?
+      end
 
+      def paginate(scope)
+        limit, offset = calculate_limit_and_offset
         scope.limit(limit).offset(offset).distinct
       end
+
+      def paginate_array(array)
+        limit, offset = calculate_limit_and_offset
+        array.drop(offset).first(limit) # do we need to uniq this?
+      end
     end
   end
 end

data/lib/brainstem/query_strategies/filter_or_search.rb

@@ -68,14 +68,7 @@ module Brainstem
       end
 
       def paginate(scope)
-        if @options[:params][:limit].present? && @options[:params][:offset].present?
-          limit = calculate_limit
-          offset = calculate_offset
-        else
-          limit = calculate_per_page
-          offset = limit * (calculate_page - 1)
-        end
-
+        limit, offset = calculate_limit_and_offset
         [scope.limit(limit).offset(offset).distinct, scope.select("distinct #{scope.connection.quote_table_name @options[:table_name]}.id").count]
       end
 
@@ -83,21 +76,6 @@ module Brainstem
         ids = (only || "").split(",").select {|id| id =~ /\A\d+\z/}.uniq
         [scope.where(:id => ids), scope.where(:id => ids).count]
       end
-
-      def order_for_search(records, ordered_search_ids)
-        ids_to_position = {}
-        ordered_records = []
-
-        ordered_search_ids.each_with_index do |id, index|
-          ids_to_position[id] = index
-        end
-
-        records.each do |record|
-          ordered_records[ids_to_position[record.id]] = record
-        end
-
-        ordered_records.compact
-      end
     end
   end
 end

data/lib/brainstem/version.rb

@@ -1,3 +1,3 @@
 module Brainstem
-  VERSION = "1.0.0"
+  VERSION = "1.1.0"
 end

data/spec/brainstem/presenter_collection_spec.rb

@@ -10,7 +10,7 @@ describe Brainstem::PresenterCollection do
   let(:jane) { User.where(:username => "jane").first }
 
   describe "#presenting" do
-    describe "#pagination" do
+    describe "pagination" do
       before do
         @presenter_collection.default_per_page = 2
         @presenter_collection.default_max_per_page = 3
@@ -159,6 +159,64 @@ describe Brainstem::PresenterCollection do
           expect(result['count']).to eq(Workspace.count)
         end
       end
+
+      describe "meta keys" do
+        let(:max_per_page) { nil }
+        let(:meta_keys) { result["meta"] }
+        let(:result) { @presenter_collection.presenting("workspaces", params: params, max_per_page: max_per_page) { Workspace.unscoped } }
+
+        describe "count" do
+          let(:params) { {} }
+
+          it "includes the count" do
+            expect(meta_keys["count"]).to eq(6)
+          end
+        end
+
+        describe "page_number" do
+          describe "when page is provided" do
+            let(:params) { { page: 2 } }
+
+            it "indicates the provided page" do
+              expect(meta_keys["page_number"]).to eq(2)
+            end
+          end
+
+          describe "when page is not profided" do
+            let(:params) { {} }
+
+            it "indicates the first page" do
+              expect(meta_keys["page_number"]).to eq(1)
+            end
+          end
+        end
+
+        describe "page_count" do
+          describe "when per_page is provided" do
+            let(:params) { { per_page: 4 } }
+
+            it "calculates the correct page count" do
+              expect(meta_keys["page_count"]).to eq(2)
+            end
+          end
+
+          describe "when per_page is not provided" do
+            let(:params) { {} }
+
+            it "calculates the correct page count based on the default page size" do
+              expect(meta_keys["page_count"]).to eq(3)
+            end
+          end
+        end
+
+        describe "page_size" do
+          let(:params) { {} }
+
+          it "calculates the correct page size" do
+            expect(meta_keys["page_count"]).to eq(3)
+          end
+        end
+      end
     end
 
     describe 'strategies' do
@@ -256,7 +314,7 @@ describe Brainstem::PresenterCollection do
     describe "the 'results' top level key" do
       it "comes back with an explicit list of the matching results" do
         structure = @presenter_collection.presenting("workspaces", :params => { :include => "tasks" }, :max_per_page => 2) { Workspace.where(:id => 1) }
-        expect(structure.keys).to match_array %w[workspaces tasks count results]
+        expect(structure.keys).to match_array %w[workspaces tasks count results meta]
         expect(structure['results']).to eq(Workspace.where(:id => 1).limit(2).map {|w| { 'key' => 'workspaces', 'id' => w.id.to_s } })
         expect(structure['workspaces'].keys).to eq(%w[1])
       end
@@ -265,10 +323,10 @@ describe Brainstem::PresenterCollection do
     describe "includes" do
       it "reads allowed includes from the presenter" do
         result = @presenter_collection.presenting("workspaces", :params => { :include => "drop table,tasks,users" }) { Workspace.unscoped }
-        expect(result.keys).to match_array %w[count workspaces tasks results]
+        expect(result.keys).to match_array %w[count meta workspaces tasks results]
 
         result = @presenter_collection.presenting("workspaces", :params => { :include => "foo,tasks,lead_user" }) { Workspace.unscoped }
-        expect(result.keys).to match_array %w[count workspaces tasks users results]
+        expect(result.keys).to match_array %w[count meta workspaces tasks users results]
       end
 
       it "defaults to not include any allowed includes" do
@@ -304,7 +362,7 @@ describe Brainstem::PresenterCollection do
         result = @presenter_collection.presenting("tasks", :params => { :include => "workspace" }, :max_per_page => 2) { Task.where(:id => t.id) }
         expect(result['tasks'].keys).to eq([ t.id.to_s ])
         expect(result['workspaces']).to eq({})
-        expect(result.keys).to match_array %w[tasks workspaces count results]
+        expect(result.keys).to match_array %w[tasks workspaces count meta results]
       end
 
       context 'when including something of the same type as the primary model' do
@@ -911,7 +969,7 @@ describe Brainstem::PresenterCollection do
       context "when there is no sort provided" do
         it "returns an empty array when there are no objects" do
           result = @presenter_collection.presenting("workspaces") { Workspace.where(:id => nil) }
-          expect(result).to eq('count' => 0, 'workspaces' => {}, 'results' => [])
+          expect(result).to eq('count' => 0, 'meta' => { 'count' => 0, 'page_count' => 0, 'page_number' => 0, 'page_size' => 20 }, 'workspaces' => {}, 'results' => [])
         end
 
         it "falls back to the object's sort order when nothing is provided" do
@@ -966,7 +1024,7 @@ describe Brainstem::PresenterCollection do
 
         result = @presenter_collection.presenting("workspaces", :params => { :order => "description:drop table" }) { Workspace.where("id is not null") }
         expect(last_direction).to eq('asc')
-        expect(result.keys).to match_array %w[count workspaces results]
+        expect(result.keys).to match_array %w[count meta workspaces results]
 
         result = @presenter_collection.presenting("workspaces", :params => { :order => "description:;;hacker;;" }) { Workspace.where("id is not null") }
         expect(last_direction).to eq('asc')
@@ -1087,7 +1145,8 @@ describe Brainstem::PresenterCollection do
 
   describe '#structure_response' do
     let(:options) { {params: {}, primary_presenter: @presenter_collection.for!(Workspace) } }
-    let(:response_body) { @presenter_collection.structure_response(Workspace, Workspace.all, 17, options) }
+    let(:response_body) { @presenter_collection.structure_response(Workspace, Workspace.all, strategy, 17, options) }
+    let(:strategy) { OpenStruct.new(calculate_per_page: 25) }
 
     it 'has a count' do
       expect(response_body['count']).to eq(17)

data/spec/brainstem/query_strategies/filter_and_search_spec.rb

@@ -2,11 +2,10 @@ require 'spec_helper'
 
 describe Brainstem::QueryStrategies::FilterAndSearch do
   let(:bob) { User.find_by_username('bob') }
+  let(:jane) { User.find_by_username('jane') }
 
-  let(:params) { {
+  let(:default_params) { {
     "owned_by" => bob.id.to_s,
-    per_page: 7,
-    page: 1,
     search: 'toot, otto, toot',
   } }
 
@@ -19,28 +18,150 @@ describe Brainstem::QueryStrategies::FilterAndSearch do
     params: params
   } }
 
+  it_behaves_like Brainstem::QueryStrategies::BaseStrategy
+
   describe '#execute' do
+    def run_query
+      described_class.new(options).execute(Cheese.all)
+    end
+
+    let(:owned_by_bob) { Cheese.owned_by(bob.id)}
+    let(:owned_by_jane) { Cheese.owned_by(jane.id)}
+
     before do
-      CheesePresenter.search do |string, options|
-        [[2,3,4,5,6,8,9,10,11,12], 11]
+      @search_results = search_results = Cheese.all.pluck(:id).shuffle
+
+      CheesePresenter.search do
+        [search_results, search_results.count]
       end
 
       CheesePresenter.filter(:owned_by) { |scope, user_id| scope.owned_by(user_id.to_i) }
       CheesePresenter.sort_order(:id)   { |scope, direction| scope.order("cheeses.id #{direction}") }
     end
 
-    it 'takes the intersection of the search and filter results' do
-      results, count = described_class.new(options).execute(Cheese.unscoped)
-      expect(count).to eq(8)
-      expect(results.map(&:id)).to eq([2,3,4,5,8,10,11])
+    context 'when an order is specified' do
+      let(:order) { 'id:asc' }
+      let(:params) { default_params.merge({ order: order })}
+      let(:expected_ordered_ids) { owned_by_bob.order("cheeses.id ASC").pluck(:id) }
+
+      it 'returns the filtered, ordered search results' do
+        results, count = run_query
+        expect(count).to eq(owned_by_bob.count)
+        expect(results.map(&:id)).to eq(expected_ordered_ids)
+      end
+
+      context 'with limit and offset params' do
+        let(:limit) { 2 }
+        let(:offset) { 4 }
+        let(:params) { default_params.merge({ order: order, limit: limit, offset: offset })}
+        let(:expected_paginated_ids) { expected_ordered_ids.drop(offset).first(limit) }
+
+        it 'returns the filtered, ordered, paginated results' do
+          results, count = run_query
+          expect(count).to eq(owned_by_bob.count)
+          expect(results.map(&:id)).to eq(expected_paginated_ids)
+        end
+      end
+
+      context 'with page and per_page params' do
+        let(:page) { 2 }
+        let(:per_page) { 3 }
+        let(:params) { default_params.merge({ order: order, page: page, per_page: per_page })}
+        let(:expected_paginated_ids) { expected_ordered_ids.drop(per_page).first(per_page) }
+
+        it 'returns the filtered, ordered, paginated results' do
+          results, count = run_query
+          expect(count).to eq(owned_by_bob.count)
+          expect(results.map(&:id)).to eq(expected_paginated_ids)
+        end
+      end
+    end
+
+    context 'when no order is specified' do
+      let(:params) { default_params }
+      let(:expected_ordered_ids) { @search_results - owned_by_jane.pluck(:id) }
+
+      before do
+        expect(params[:order]).not_to be_present
+      end
+
+      it 'returns the filtered results ordered by search' do
+        results, count = run_query
+        expect(count).to eq(owned_by_bob.count)
+        expect(results.map(&:id)).to eq(expected_ordered_ids)
+      end
+
+      it 'only does two database queries' do
+        expect { run_query }.to make_database_queries(count: 2)
+      end
+
+      context 'with limit and offset params' do
+        let(:limit) { 2 }
+        let(:offset) { 4 }
+        let(:params) { default_params.merge({ limit: limit, offset: offset })}
+        let(:expected_paginated_ids) { expected_ordered_ids.drop(offset).first(limit) }
+
+        it 'returns the filtered, ordered, paginated results' do
+          results, count = run_query
+          expect(count).to eq(owned_by_bob.count)
+          expect(results.map(&:id)).to eq(expected_paginated_ids)
+        end
+      end
+
+      context 'with page and per_page params' do
+        let(:page) { 2 }
+        let(:per_page) { 3 }
+        let(:params) { default_params.merge({ page: page, per_page: per_page })}
+        let(:expected_paginated_ids) { expected_ordered_ids.drop(per_page).first(per_page) }
+
+        it 'returns the filtered, ordered, paginated results' do
+          results, count = run_query
+          expect(count).to eq(owned_by_bob.count)
+          expect(results.map(&:id)).to eq(expected_paginated_ids)
+        end
+      end
+    end
+  end
+
+  describe '#ordering?' do
+    context 'when the order param is passed' do
+      let(:params) { default_params.merge({ order: 'canadianness' })}
+
+      context 'and it exists on the presenter' do
+        before do
+          CheesePresenter.sort_order(:canadianness) { |scope, direction| scope.order("cheeses.hockey #{direction}") }
+          expect(CheesePresenter.configuration[:sort_orders][:canadianness]).to be_present
+        end
+
+        it 'returns true' do
+          query_strat = described_class.new(options)
+          expect(query_strat.send(:ordering?)).to eq(true)
+        end
+      end
+
+      context 'and it does not exist on the presenter' do
+        before do
+         expect(CheesePresenter.configuration[:sort_orders][:canadianness]).not_to be_present
+        end
+
+        it 'returns false' do
+          query_strat = described_class.new(options)
+          expect(query_strat.send(:ordering?)).to eq(false)
+        end
+      end
     end
 
-    it "applies ordering to the scope" do
-      options[:params]["order"] = 'id:desc'
-      proxy.instance_of(Brainstem::Presenter).apply_ordering_to_scope(anything, anything).times(1)
-      results, count = described_class.new(options).execute(Cheese.unscoped)
-      expect(count).to eq(8)
-      expect(results.map(&:id)).to eq([12,11,10,8,5,4,3])
+    context 'when the order param is not passed' do
+      let(:params) { default_params }
+
+      before do
+        expect(params[:order]).not_to be_present
+      end
+
+      it 'returns false' do
+        query_strat = described_class.new(options)
+        expect(query_strat.send(:ordering?)).to eq(false)
+      end
     end
   end
 end

data/spec/brainstem/query_strategies/filter_or_search_spec.rb

@@ -3,6 +3,8 @@ require 'spec_helper'
 # The functionality of this is mainly tested in more integration-y tests in presenter_collection_spec.rb
 
 describe Brainstem::QueryStrategies::FilterOrSearch do
+  it_behaves_like Brainstem::QueryStrategies::BaseStrategy
+
   describe '#execute' do
     context 'we are searching' do
       let(:subject) { described_class.new(@options) }

data/spec/shared/base_strategy.rb

@@ -0,0 +1,36 @@
+require "spec_helper"
+
+shared_examples_for Brainstem::QueryStrategies::BaseStrategy do
+  let(:strategy) { described_class.new(options) }
+
+  describe "#calculate_per_page" do
+    let(:result) { strategy.calculate_per_page }
+
+    [
+      # per_page  default_per_page  max_per_page  default_max_per_page  expected   situation                             used
+      [       10,               20,          100,                  200,       10,  "per page < max",                     "the per page"],
+      [      nil,               20,          100,                  200,       20,  "no per page and default < max",      "the default"],
+      [      nil,              200,          100,                  200,      100,  "no per page and default > max",      "the max"],
+      [      150,               20,          100,                  200,      100,  "per page > max",                     "the max"],
+      [      150,               20,          nil,                  200,      150,  "no max and per page < default max",  "the per page"],
+      [      250,               20,          nil,                  200,      200,  "no max and per page > default max",  "the default max"],
+    ].each do |per_page, default_per_page, max_per_page, default_max_per_page, expected, situation, used|
+      describe "when #{situation}" do
+        let(:options) {
+          {
+            params: {
+              per_page: per_page,
+            },
+            default_per_page: default_per_page,
+            default_max_per_page: default_max_per_page,
+            max_per_page: max_per_page,
+          }
+        }
+
+        it "uses #{used}" do
+          expect(result).to eq(expected)
+        end
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -6,6 +6,7 @@ require 'sqlite3'
 require 'database_cleaner'
 require 'pry'
 require 'pry-nav'
+require 'db-query-matchers'
 
 require 'brainstem'
 require_relative 'spec_helpers/schema'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: brainstem
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.1.0
 platform: ruby
 authors:
 - Mavenlink
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-07-20 00:00:00.000000000 Z
+date: 2018-01-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -164,6 +164,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: db-query-matchers
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: Brainstem allows you to create rich API presenters that know how to filter,
   sort, and include associations.
 email:
@@ -291,6 +305,7 @@ files:
 - spec/brainstem_spec.rb
 - spec/dummy/rails.rb
 - spec/shared/atlas_taker.rb
+- spec/shared/base_strategy.rb
 - spec/shared/formattable.rb
 - spec/spec_helper.rb
 - spec/spec_helpers/db.rb
@@ -317,7 +332,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.5.2
+rubygems_version: 2.6.13
 signing_key: 
 specification_version: 4
 summary: ActiveRecord presenters with a rich request API
@@ -368,6 +383,7 @@ test_files:
 - spec/brainstem_spec.rb
 - spec/dummy/rails.rb
 - spec/shared/atlas_taker.rb
+- spec/shared/base_strategy.rb
 - spec/shared/formattable.rb
 - spec/spec_helper.rb
 - spec/spec_helpers/db.rb