trailblazer-finder 0.1.2 → 0.1.3

data/spec/trailblazer/finder/adapters/data_mapper/base_spec.rb

@@ -16,7 +16,7 @@ module Trailblazer
           end
         end
 
-        def finder_class(&block) 
+        def finder_class(&block)
           define_finder_class do
             adapters DataMapper
 

data/spec/trailblazer/finder/adapters/data_mapper/sorting_spec.rb

@@ -1,85 +1,85 @@
-require 'spec_helper_data_mapper'
-
-module Trailblazer
-  class Finder
-    module Adapters
-      module DataMapper
-        describe Sorting do
-          def finder_class
-            Class.new do
-              include Trailblazer::Finder::Base
-              include Trailblazer::Finder::Features::Sorting
-              include Trailblazer::Finder::Adapters::DataMapper
-
-              entity_type { DProduct }
-
-              sortable_by :name, :price, :created_at
-
-              filter_by :name
-              filter_by :price
-
-              # # Need to find a fix for this, not sure how to handle joins with data mapper properly
-              # filter_by(:d_category) { |entity_type, _| entity_type }
-            end
-          end
-
-          def finder_with_sort(sort = nil, filters = {})
-            finder_class.new filter: { sort: sort }.merge(filters)
-          end
-
-          it 'can be inherited' do
-            child_class = Class.new(finder_class)
-            expect(child_class.new.sort_attribute).to eq 'name'
-          end
-
-          describe 'sorting' do
-            after do
-              DProduct.all.destroy
-            end
-
-            it 'sorts results based on the sort option desc' do
-              5.times { |i| DProduct.create price: i }
-
-              finder = finder_with_sort 'price desc'
-              expect(finder.results.map(&:price)).to eq [4, 3, 2, 1, 0]
-            end
-
-            it 'sorts results based on the sort option asc' do
-              5.times { |i| DProduct.create price: i }
-
-              finder = finder_with_sort 'price asc'
-              expect(finder.results.map(&:price)).to eq [0, 1, 2, 3, 4]
-            end
-
-            it 'defaults to first sort by option' do
-              5.times { |i| DProduct.create name: "Name#{i}" }
-
-              finder = finder_with_sort
-              expect(finder.results.map(&:name)).to eq %w[Name4 Name3 Name2 Name1 Name0]
-            end
-
-            it 'ignores invalid sort values' do
-              finder = finder_with_sort 'invalid attribute'
-              expect { finder.results.to_a }.not_to raise_error
-            end
-
-            # TODO: Need to find a fix for this, not sure how to handle joins with data mapper properly
-            it 'can handle renames of sorting in joins' do
-              #   older_category = DCategory.create title: 'older'
-              #   newer_category = DCategory.create title: 'newer'
-              #
-              #   product_of_newer_category = DProduct.create name: 'older product', d_category: newer_category
-              #   product_of_older_category = DProduct.create name: 'newer product', d_category: older_category
-              #
-              #   finder = finder_with_sort 'created_at desc', d_category: ''
-              #
-              #   expect(finder.results.map(&:name)).to eq [product_of_older_category.name, product_of_newer_category.name]
-            end
-          end
-
-          it_behaves_like 'a sorting feature'
-        end
-      end
-    end
-  end
-end
+# require 'spec_helper_data_mapper'
+#
+# module Trailblazer
+#   class Finder
+#     module Adapters
+#       module DataMapper
+#         describe Sorting do
+#           def finder_class
+#             Class.new do
+#               include Trailblazer::Finder::Base
+#               include Trailblazer::Finder::Features::Sorting
+#               include Trailblazer::Finder::Adapters::DataMapper
+#
+#               entity_type { DProduct }
+#
+#               sortable_by :name, :price, :created_at
+#
+#               filter_by :name
+#               filter_by :price
+#
+#               # # Need to find a fix for this, not sure how to handle joins with data mapper properly
+#               # filter_by(:d_category) { |entity_type, _| entity_type }
+#             end
+#           end
+#
+#           def finder_with_sort(sort = nil, filters = {})
+#             finder_class.new filter: { sort: sort }.merge(filters)
+#           end
+#
+#           it 'can be inherited' do
+#             child_class = Class.new(finder_class)
+#             expect(child_class.new.sort_attribute).to eq 'name'
+#           end
+#
+#           describe 'sorting' do
+#             after do
+#               DProduct.all.destroy
+#             end
+#
+#             it 'sorts results based on the sort option desc' do
+#               5.times { |i| DProduct.create price: i }
+#
+#               finder = finder_with_sort 'price desc'
+#               expect(finder.results.map(&:price)).to eq [4, 3, 2, 1, 0]
+#             end
+#
+#             it 'sorts results based on the sort option asc' do
+#               5.times { |i| DProduct.create price: i }
+#
+#               finder = finder_with_sort 'price asc'
+#               expect(finder.results.map(&:price)).to eq [0, 1, 2, 3, 4]
+#             end
+#
+#             it 'defaults to first sort by option' do
+#               5.times { |i| DProduct.create name: "Name#{i}" }
+#
+#               finder = finder_with_sort
+#               expect(finder.results.map(&:name)).to eq %w[Name4 Name3 Name2 Name1 Name0]
+#             end
+#
+#             it 'ignores invalid sort values' do
+#               finder = finder_with_sort 'invalid attribute'
+#               expect { finder.results.to_a }.not_to raise_error
+#             end
+#
+#             # TODO: Need to find a fix for this, not sure how to handle joins with data mapper properly
+#             it 'can handle renames of sorting in joins' do
+#               #   older_category = DCategory.create title: 'older'
+#               #   newer_category = DCategory.create title: 'newer'
+#               #
+#               #   product_of_newer_category = DProduct.create name: 'older product', d_category: newer_category
+#               #   product_of_older_category = DProduct.create name: 'newer product', d_category: older_category
+#               #
+#               #   finder = finder_with_sort 'created_at desc', d_category: ''
+#               #
+#               #   expect(finder.results.map(&:name)).to eq [product_of_older_category.name, product_of_newer_category.name]
+#             end
+#           end
+#
+#           it_behaves_like 'a sorting feature'
+#         end
+#       end
+#     end
+#   end
+# end

data/spec/trailblazer/finder/adapters/sequel/predicates_spec.rb

@@ -2,7 +2,7 @@ require 'spec_helper_sequel'
 # require 'spec_helper'
 
       describe "Trailblazer::Finder::Adapters::Sequel::Predicates" do
-        class TestFinder < Trailblazer::Finder
+        class TestSequelFinder < Trailblazer::Finder
             features Predicate
             adapters Sequel
 
@@ -14,7 +14,7 @@ require 'spec_helper_sequel'
         end
 
         def finder_with_predicate(filter = nil, value = nil, filters = {})
-          TestFinder.new filter: { filter => value }.merge(filters)
+          TestSequelFinder.new filter: { filter => value }.merge(filters)
         end
 
         describe 'equals' do

data/spec/trailblazer/finder/adapters/sequel/sorting_spec.rb

@@ -1,86 +1,107 @@
 require 'spec_helper_sequel'
 
-module Trailblazer
-  class Finder
-    module Adapters
-      module Sequel
-        describe Sorting do
-          def finder_class
-            Class.new do
-              include Trailblazer::Finder::Base
-              include Trailblazer::Finder::Features::Sorting
-              include Trailblazer::Finder::Adapters::Sequel
-
-              entity_type { SProduct }
-
-              sortable_by :name, :price, :created_at
-
-              filter_by :name
-              filter_by :price
-              filter_by(:s_category) { |entity_type, _| entity_type.association_join(:s_category) }
-            end
-          end
-
-          def finder_with_sort(sort = nil, filters = {})
-            finder_class.new filter: { sort: sort }.merge(filters)
-          end
-
-          it 'can be inherited' do
-            child_class = Class.new(finder_class)
-            expect(child_class.new.sort_attribute).to eq 'name'
-          end
-
-          describe 'sorting' do
-            before do
-              SProduct.order(:id).delete
-            end
-
-            after do
-              SProduct.order(:id).delete
-            end
-
-            it 'sorts results based on the sort option desc' do
-              5.times { |i| SProduct.create price: i }
-
-              finder = finder_with_sort 'price desc'
-              expect(finder.results.map(&:price)).to eq [4, 3, 2, 1, 0]
-            end
-
-            it 'sorts results based on the sort option asc' do
-              5.times { |i| SProduct.create price: i }
-
-              finder = finder_with_sort 'price asc'
-              expect(finder.results.map(&:price)).to eq [0, 1, 2, 3, 4]
-            end
-
-            it 'defaults to first sort by option' do
-              5.times { |i| SProduct.create name: "Name#{i}" }
-
-              finder = finder_with_sort
-              expect(finder.results.map(&:name)).to eq %w[Name4 Name3 Name2 Name1 Name0]
-            end
-
-            it 'ignores invalid sort values' do
-              finder = finder_with_sort 'invalid attribute'
-              expect { finder.results.to_a }.not_to raise_error
-            end
-
-            it 'can handle renames of sorting in joins' do
-              older_category = SCategory.create title: 'older'
-              newer_category = SCategory.create title: 'newer'
-
-              product_of_newer_category = SProduct.create name: 'older product', s_category: newer_category
-              product_of_older_category = SProduct.create name: 'newer product', s_category: older_category
-
-              finder = finder_with_sort 'created_at desc', s_category: ''
-
-              expect(finder.results.map(&:name)).to eq [product_of_older_category.name, product_of_newer_category.name]
-            end
-          end
-
-          it_behaves_like 'a sorting feature'
-        end
+describe 'Trailblazer::Finder::Adapters::Sequel::Sorting', :sorting do
+  after do
+    SProduct.order(:id).delete
+  end
+
+  before do
+    SProduct.order(:id).delete
+  end
+
+  class TestSequelSortFinder < Trailblazer::Finder
+    features Sorting
+    adapters Sequel
+
+    entity_type { SProduct }
+
+    sortable_by :name, :price, :created_at
+
+    filter_by :name
+    filter_by :price
+    filter_by(:s_category) { |entity_type, _| entity_type.association_join(:s_category) }
+  end
+
+  def finder_with_sort(sort = nil, filters = {})
+    TestSequelSortFinder.new filter: (sort.nil? ? {} : { sort: sort }).merge(filters)
+  end
+
+  def finder_with_nil_sort
+    TestSequelSortFinder.new filter: { sort: nil }
+  end
+
+  describe 'sorting' do
+    it 'loads results if no sort options are supplied in the params' do
+      5.times { |i| SProduct.create price: i }
+      finder = finder_with_nil_sort
+      expect(finder.results.map(&:price)).to eq [0, 1, 2, 3, 4]
+    end
+
+    it 'sorts results based on the sort option desc' do
+      5.times { |i| SProduct.create price: i }
+
+      finder = finder_with_sort 'price desc'
+      expect(finder.results.map(&:price)).to eq [4, 3, 2, 1, 0]
+    end
+
+    it 'sorts results based on the sort option asc' do
+      5.times { |i| SProduct.create price: i }
+
+      finder = finder_with_sort 'price asc'
+      expect(finder.results.map(&:price)).to eq [0, 1, 2, 3, 4]
+    end
+
+    it 'defaults to first sort by option' do
+      5.times { |i| SProduct.create name: "Name#{i}" }
+
+      finder = finder_with_sort
+      expect(finder.results.map(&:name)).to eq %w[Name0 Name1 Name2 Name3 Name4]
+    end
+
+    it 'ignores invalid sort values' do
+      finder = finder_with_sort 'invalid attribute'
+      expect { finder.results.to_a }.not_to raise_error
+    end
+
+    it 'can handle renames of sorting in joins' do
+      older_category = SCategory.create title: 'older'
+      newer_category = SCategory.create title: 'newer'
+
+      product_of_newer_category = SProduct.create name: 'older product', s_category: newer_category
+      product_of_older_category = SProduct.create name: 'newer product', s_category: older_category
+
+      finder = finder_with_sort 'created_at desc', s_category: ''
+
+      expect(finder.results.map(&:name)).to eq [product_of_older_category.name, product_of_newer_category.name]
+    end
+  end
+
+  describe 'sorting by multiple' do
+    before do
+      5.times do |i|
+        SProduct.create name: "Name#{i}", price: "1#{i}"
       end
+      SProduct.create name: 'Name3', price: '8'
+    end
+
+    it 'sorts by multiple columns name asc and price asc' do
+      finder = finder_with_sort 'name asc, price asc'
+      expect(finder.results.map(&:name)).to eq %w[Name0 Name1 Name2 Name3 Name3 Name4]
+      expect(finder.results.map(&:price)).to eq [10, 11, 12, 8, 13, 14]
+    end
+
+    it 'sorts by multiple columns name asc and price desc' do
+      finder = finder_with_sort 'name asc, price desc'
+      expect(finder.results.map(&:name)).to eq %w[Name0 Name1 Name2 Name3 Name3 Name4]
+      expect(finder.results.map(&:price)).to eq [10, 11, 12, 13, 8, 14]
+    end
+
+    it 'sorts by multiple columns name desc and price desc' do
+      finder = finder_with_sort 'name desc, price desc'
+      expect(finder.results.map(&:name)).to eq %w[Name4 Name3 Name3 Name2 Name1 Name0]
+      expect(finder.results.map(&:price)).to eq [14, 13, 8, 12, 11, 10]
     end
   end
+
+  it_behaves_like 'a sorting feature'
 end

data/spec/trailblazer/finder/features/sorting_spec.rb

@@ -1,89 +1,65 @@
+# require 'spec_helper_sequel'
 require 'spec_helper'
-require 'support/sorting_shared_example'
 
 module Trailblazer
   class Finder
     module Features
-      describe Sorting do
-        it 'uses a pre-defined Hash entity_type instead of any ORM' do
-          true
-        end
+      describe Sorting, :sorting do
+        class TestSortingFinder < Trailblazer::Finder
+          features Sorting
+
+          def create_product(id, name, price)
+            {
+              id: id,
+              name: name,
+              price: price,
+              created_at: Time.now,
+              updated_at: Time.now
+            }
+          end
 
-        def finder_class
-          Class.new(Trailblazer::Finder) do
-            features Sorting
-
-            entity_type do
-              [
-                {
-                  id: 1,
-                  name: 'product_1',
-                  price: '11',
-                  created_at: Time.now,
-                  updated_at: Time.now
-                },
-                {
-                  id: 2,
-                  name: 'product_2',
-                  price: '12',
-                  created_at: Time.now,
-                  updated_at: Time.now
-                },
-                {
-                  id: 3,
-                  name: 'product_3',
-                  price: '13',
-                  created_at: Time.now,
-                  updated_at: Time.now
-                },
-                {
-                  id: 4,
-                  name: 'product_4',
-                  price: '14',
-                  created_at: Time.now,
-                  updated_at: Time.now
-                },
-                {
-                  id: 5,
-                  name: 'product_5',
-                  price: '15',
-                  created_at: Time.now,
-                  updated_at: Time.now
-                }
-              ]
-            end
-
-            sortable_by :name, :price, :created_at
-
-            filter_by :name
-            filter_by :price
-            filter_by(:category) { |entity_type, _| entity_type.joins(:category) }
+          entity_type do
+            Array.new(5) do |i|
+              next create_product(i + 1, '', "1#{i}".to_i) if i == 7
+              next create_product(i + 1, 'Name4', "1#{i}".to_i) if i == 9
+              create_product(i + 1, "Name#{i}", "1#{i}".to_i)
+            end.push(create_product(6, 'Name3', 8))
           end
+
+          sortable_by :name, :price, :created_at, :id
+
+          filter_by :name
+          filter_by :price
+          filter_by(:category) { |entity_type, _| entity_type.joins(:category) }
         end
 
         def finder_with_sort(sort = nil, filters = {})
-          finder_class.new filter: { sort: sort }.merge(filters)
+          TestSortingFinder.new filter: (sort.nil? ? {} : { sort: sort }).merge(filters)
         end
 
-        it 'can be inherited' do
-          child_class = Class.new(finder_class)
-          expect(child_class.new.sort_attribute).to eq 'name'
+        def finder_with_nil_sort
+          TestSortingFinder.new filter: { sort: nil }
         end
 
         describe 'sorting' do
+          it 'loads results if no sort options are supplied in the params' do
+            finder = finder_with_nil_sort
+            expect(finder.results.map { |n| n[:price] }).to eq [14, 13, 8, 12, 11, 10]
+          end
+
           it 'sorts results based on the sort option desc' do
             finder = finder_with_sort 'price desc'
-            expect(finder.results.map { |n| n[:price] }).to eq %w[15 14 13 12 11]
+            expect(finder.results.map { |n| n[:price] }).to eq [14, 13, 12, 11, 10, 8]
           end
 
           it 'sorts results based on the sort option asc' do
             finder = finder_with_sort 'price asc'
-            expect(finder.results.map { |n| n[:price] }).to eq %w[11 12 13 14 15]
+            expect(finder.results.map { |n| n[:price] }).to eq [8, 10, 11, 12, 13, 14]
           end
 
-          it 'defaults to first sort by option' do
+          it 'defaults to original sorted hash' do
             finder = finder_with_sort
-            expect(finder.results.map { |n| n[:name] }).to eq %w[product_5 product_4 product_3 product_2 product_1]
+            expect(finder.results.map { |n| n[:name] }).to eq ['Name0', 'Name1', 'Name2', 'Name3', 'Name4', 'Name3']
           end
 
           it 'ignores invalid sort values' do
@@ -92,6 +68,27 @@ module Trailblazer
           end
         end
 
+        describe 'sorting by multiple' do
+
+          it 'sorts by multiple columns name asc and price asc' do
+            finder = finder_with_sort 'name asc, price asc'
+            expect(finder.results.map { |n| n[:name] }).to eq ['Name0', 'Name1', 'Name2', 'Name3', 'Name3', 'Name4']
+            expect(finder.results.map { |n| n[:price] }).to eq [10, 11, 12, 8, 13, 14]
+          end
+
+          it 'sorts by multiple columns name asc and price desc' do
+            finder = finder_with_sort 'name asc, price desc'
+            expect(finder.results.map { |n| n[:name] }).to eq ['Name0', 'Name1', 'Name2', 'Name3', 'Name3', 'Name4']
+            expect(finder.results.map { |n| n[:price] }).to eq [10, 11, 12, 13, 8, 14]
+          end
+
+          it 'sorts by multiple columns name desc and price desc' do
+            finder = finder_with_sort 'name desc, price desc'
+            expect(finder.results.map { |n| n[:name] }).to eq ['Name4', 'Name3', 'Name3', 'Name2', 'Name1', 'Name0']
+            expect(finder.results.map { |n| n[:price] }).to eq [14, 13, 8, 12, 11, 10]
+          end
+        end
+
         it_behaves_like 'a sorting feature'
       end
     end