trailblazer-finder 0.1.4 → 0.2.5

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

@@ -1,112 +0,0 @@
-require 'spec_helper_active_record'
-
-module Trailblazer
-  class Finder
-    module Adapters
-      describe ActiveRecord do
-        # it_behaves_like 'a base orm adapter'
-
-        after do
-          Product.delete_all
-        end
-
-        def define_finder_class(&block)
-          Class.new(Trailblazer::Finder) do
-            class_eval(&block)
-          end
-        end
-
-        def finder_class(&block) 
-          define_finder_class do
-            adapters ActiveRecord
-
-            entity_type { Product }
-
-            filter_by :id
-            filter_by :name
-            filter_by :slug
-
-            if block.nil?
-              filter_by :value do |entity_type, value|
-                entity_type.where(slug: value)
-              end
-            else
-              class_eval(&block)
-            end
-          end
-        end
-
-        def finder_with_filter(key = nil, name = nil, &block)
-          finder_class(&block).new filter: { key => name }
-        end
-
-        describe 'filter_by' do
-          it 'has a default filter' do
-            10.times { |i| Product.create name: "product_#{i}" }
-            finder = finder_with_filter :name, 'product_2'
-
-            expect(finder.results.first.name).to eq 'product_2'
-          end
-
-          it 'has another default filter' do
-            10.times { |i| Product.create slug: "product_#{i}" }
-            finder = finder_with_filter :value, 'product_2'
-
-            expect(finder.results.first.slug).to eq 'product_2'
-          end
-        end
-
-        it 'can use methods from the object' do
-          2.times { |i| Product.create name: "product_#{i}" }
-          finder1 = finder_with_filter :id, 1 do
-            filter_by :id do |entity_type, value|
-              some_instance_method(entity_type, value)
-            end
-
-            private
-
-            def some_instance_method(entity_type, value)
-              entity_type.where(id: value)
-            end
-          end
-
-          expect(finder1.results.first.id).to eq 1
-        end
-
-        it 'can dispatch with instance methods' do
-          2.times { |i| Product.create name: "product_#{i}" }
-          finder = finder_with_filter :id, 3 do
-            filter_by :id, with: :some_instance_method
-
-            private
-
-            def some_instance_method(entity_type, value)
-              entity_type.where(id: value)
-            end
-          end
-
-          expect(finder.results.first.id).to eq 3
-        end
-
-        describe 'filter_by attributes' do
-          it 'accesses filter values' do
-            finder = finder_with_filter :value, 1
-            expect(finder.value).to eq 1
-          end
-
-          it 'returns default filter value if filter_by is not specified' do
-            finder = finder_with_filter do
-              filter_by :value, 1
-            end
-            expect(finder.value).to eq 1
-          end
-
-          it 'does not include invalid filters' do
-            finder = finder_with_filter invalid: 'option'
-            expect { finder.invalid }.to raise_error NoMethodError
-          end
-        end
-      end
-    end
-  end
-end

data/spec/trailblazer/finder/adapters/active_record/paging_spec.rb

@@ -1,64 +0,0 @@
-require 'spec_helper_active_record'
-
-module Trailblazer
-  class Finder
-    module Adapters
-      module ActiveRecord
-        describe Paging do
-          it_behaves_like 'a paging feature'
-
-          after do
-            Product.delete_all
-          end
-
-          def define_finder_class(&block)
-            Class.new do
-              include Trailblazer::Finder::Base
-              include Trailblazer::Finder::Features::Paging
-              include Trailblazer::Finder::Adapters::ActiveRecord
-
-              instance_eval(&block) if block_given?
-            end
-          end
-
-          def finder_class
-            define_finder_class do
-              entity_type { Product }
-
-              per_page 2
-
-              min_per_page 2
-              max_per_page 10
-            end
-          end
-
-          def finder_with_page(page = nil, per_page = nil)
-            finder_class.new page: page, per_page: per_page
-          end
-
-          it 'can be inherited' do
-            child_class = Class.new(finder_class)
-            expect(child_class.new.per_page).to eq 2
-          end
-
-          describe '#results' do
-            it 'paginates results' do
-              6.times { |i| Product.create name: "product_#{i}" }
-              finder = finder_with_page 2, 2
-
-              expect(finder.results.map(&:name)).to eq %w[product_2 product_3]
-            end
-          end
-
-          describe '#count' do
-            it 'gives the real count' do
-              10.times { |i| Product.create name: "product_#{i}" }
-              finder = finder_with_page 1
-              expect(finder.count).to eq 10
-            end
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,101 +0,0 @@
-require 'spec_helper_active_record'
-# require 'spec_helper'
-
-module Trailblazer
-  class Finder
-    module Adapters
-      module ActiveRecord
-        describe Predicates do
-          after do
-            Product.delete_all
-            Product.reset_pk_sequence
-          end
-
-          class TestFinder < Trailblazer::Finder
-            features Predicate
-            adapters ActiveRecord
-
-            entity_type { Product }
-
-            predicates_for :name, :price, :created_at
-
-            filter_by(:category) { |entity_type, _| entity_type.joins(:category) }
-          end
-
-          def finder_with_predicate(filter = nil, value = nil, filters = {})
-            TestFinder.new filter: { filter => value }.merge(filters)
-          end
-
-          describe 'equals' do
-            before do
-              10.times do |i|
-                next Product.create name: "", price: "1#{i}" if i == 7
-                next Product.create name: nil, price: "1#{i}" if i == 8
-                next Product.create name: "product_4", price: "1#{i}" if i == 9
-                Product.create name: "product_#{i}", price: "1#{i}"
-              end
-            end
-
-            it 'it finds single row with name equal to product_5' do
-              finder = finder_with_predicate 'name_eq', 'product_5'
-              expect(finder.results.map(&:price)).to eq [15]
-            end
-
-            it 'it finds multiple rows with name equal to product_4' do
-              finder = finder_with_predicate 'name_eq', 'product_4'
-              expect(finder.results.map(&:price)).to eq [14, 19]
-            end
-
-            it 'it finds rows with name not equal to product_4' do
-              finder = finder_with_predicate 'name_not_eq', 'product_4'
-              expect(finder.results.map(&:name)).to eq ["product_0", "product_1", "product_2", "product_3", "product_5", "product_6", ""]
-              expect(finder.results.map(&:price)).to eq [10, 11, 12, 13, 15, 16, 17]
-            end
-
-            it 'it finds multiple rows with name blank (empty/nil)' do
-              finder = finder_with_predicate 'name_blank', ''
-              expect(finder.results.map(&:price)).to eq [17, 18]
-            end
-
-            it 'it finds multiple rows with name not blank (empty/nil)' do
-              finder = finder_with_predicate 'name_not_blank', ''
-              expect(finder.results.map(&:name)).to eq ["product_0", "product_1", "product_2", "product_3", "product_4", "product_5", "product_6", "product_4"]
-            end
-
-            it 'it finds multiple rows with price less than 15' do
-              finder = finder_with_predicate 'price_lt', 15
-              expect(finder.results.map(&:name)).to eq ["product_0", "product_1", "product_2", "product_3", "product_4"]
-              expect(finder.results.map(&:price)).to eq [10, 11, 12, 13, 14]
-            end
-
-            it 'it finds multiple rows with price equal to and less than 15' do
-              finder = finder_with_predicate 'price_lte', 15
-              expect(finder.results.map(&:name)).to eq ["product_0", "product_1", "product_2", "product_3", "product_4", "product_5"]
-              expect(finder.results.map(&:price)).to eq [10, 11, 12, 13, 14, 15]
-            end
-
-            it 'it finds multiple rows with price greater than 15' do
-              finder = finder_with_predicate 'price_gt', 15
-              expect(finder.results.map(&:name)).to eq ["product_6", "", nil, "product_4"]
-              expect(finder.results.map(&:price)).to eq [16, 17, 18, 19]
-            end
-
-            it 'it finds multiple rows with price equal to and greater than 15' do
-              finder = finder_with_predicate 'price_gte', 15
-              expect(finder.results.map(&:name)).to eq ["product_5", "product_6", "", nil, "product_4"]
-              expect(finder.results.map(&:price)).to eq [15, 16, 17, 18, 19]
-            end
-
-            it 'it finds rows with name not equal to product_4 and name not blank and price greater than 14' do
-              params = { name_not_blank: true, price_gt: 14 }
-              finder = finder_with_predicate 'name_not_eq', 'product_4', params
-
-              expect(finder.results.map(&:name)).to eq ["product_5", "product_6"]
-              expect(finder.results.map(&:price)).to eq [15, 16]
-            end
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,99 +0,0 @@
-require 'spec_helper_active_record'
-
-describe "Trailblazer::Finder::Adapters::ActiveRecord::Sorting", :sorting do
-  after do
-    Product.delete_all
-    Product.reset_pk_sequence
-  end
-
-  before do
-    Product.delete_all
-    Product.reset_pk_sequence
-  end
-
-  class TestARFinder < Trailblazer::Finder
-    features Sorting
-    adapters ActiveRecord
-
-    entity_type { Product.all }
-
-    sortable_by :name, :price, :created_at
-
-    filter_by :name
-    filter_by :price
-  end
-
-  def finder_with_sort(sort = nil, filters = {})
-    TestARFinder.new filter: (sort.nil? ? {} : { sort: sort }).merge(filters)
-  end
-
-  describe 'sorting' do
-
-    it 'sorts results based on the sort option desc' do
-      5.times { |i| Product.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| Product.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 defaulted database sort if none is set' do
-      5.times { |i| Product.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 = Category.create! title: 'older'
-      newer_category = Category.create! title: 'newer'
-
-      product_of_newer_category = Product.create! name: 'older product', category: newer_category
-      product_of_older_category = Product.create! name: 'newer product', category: older_category
-
-      finder = finder_with_sort 'created_at desc', 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|
-        Product.create name: "Name#{i}", price: "1#{i}"
-      end
-      Product.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/adapters/data_mapper/base_spec.rb

@@ -1,112 +0,0 @@
-require 'spec_helper_data_mapper'
-
-module Trailblazer
-  class Finder
-    module Adapters
-      describe DataMapper do
-        # it_behaves_like 'a base orm adapter'
-
-        after do
-          DProduct.all.destroy
-        end
-
-        def define_finder_class(&block)
-          Class.new(Trailblazer::Finder) do
-            class_eval(&block)
-          end
-        end
-
-        def finder_class(&block)
-          define_finder_class do
-            adapters DataMapper
-
-            entity_type { DProduct }
-
-            filter_by :id
-            filter_by :name
-            filter_by :slug
-
-            if block.nil?
-              filter_by :value do |entity_type, value|
-                entity_type.all(slug: value)
-              end
-            else
-              class_eval(&block)
-            end
-          end
-        end
-
-        def finder_with_filter(key = nil, name = nil, &block)
-          finder_class(&block).new filter: { key => name }
-        end
-
-        describe 'filter_by' do
-          it 'has a default filter' do
-            10.times { |i| DProduct.create name: "product_#{i}" }
-            finder = finder_with_filter :name, 'product_2'
-
-            expect(finder.results.first.name).to eq 'product_2'
-          end
-
-          it 'has another default filter' do
-            10.times { |i| DProduct.create slug: "product_#{i}" }
-            finder = finder_with_filter :value, 'product_2'
-
-            expect(finder.results.first.slug).to eq 'product_2'
-          end
-        end
-
-        it 'can use methods from the object' do
-          2.times { |i| DProduct.create name: "product_#{i}" }
-          finder1 = finder_with_filter :id, 1 do
-            filter_by :id do |entity_type, value|
-              some_instance_method(entity_type, value)
-            end
-
-            private
-
-            def some_instance_method(entity_type, value)
-              entity_type.all(id: value)
-            end
-          end
-
-          expect(finder1.results.first.id).to eq 1
-        end
-
-        it 'can dispatch with instance methods' do
-          2.times { |i| DProduct.create name: "product_#{i}" }
-          finder = finder_with_filter :id, 3 do
-            filter_by :id, with: :some_instance_method
-
-            private
-
-            def some_instance_method(entity_type, value)
-              entity_type.all(id: value)
-            end
-          end
-
-          expect(finder.results.first.id).to eq 3
-        end
-
-        describe 'filter_by attributes' do
-          it 'accesses filter values' do
-            finder = finder_with_filter :value, 1
-            expect(finder.value).to eq 1
-          end
-
-          it 'returns default filter value if filter_by is not specified' do
-            finder = finder_with_filter do
-              filter_by :value, 1
-            end
-            expect(finder.value).to eq 1
-          end
-
-          it 'does not include invalid filters' do
-            finder = finder_with_filter invalid: 'option'
-            expect { finder.invalid }.to raise_error NoMethodError
-          end
-        end
-      end
-    end
-  end
-end