trailblazer-finder 0.1.4 → 0.2.5

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

@@ -1,89 +0,0 @@
-require 'spec_helper_sequel'
-# require 'spec_helper'
-
-      describe "Trailblazer::Finder::Adapters::Sequel::Predicates" do
-        class TestSequelFinder < Trailblazer::Finder
-            features Predicate
-            adapters Sequel
-
-            entity_type { SProduct }
-
-            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 = {})
-          TestSequelFinder.new filter: { filter => value }.merge(filters)
-        end
-
-        describe 'equals' do
-          before do
-            SProduct.order(:id).delete
-            10.times do |i|
-              next SProduct.create name: "", price: "1#{i}" if i == 7
-              next SProduct.create name: nil, price: "1#{i}" if i == 8
-              next SProduct.create name: "product_4", price: "1#{i}" if i == 9
-              SProduct.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.all.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.all.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.all.map(&:name)).to eq ["product_0", "product_1", "product_2", "product_3", "product_5", "product_6", ""]
-            expect(finder.results.all.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.all.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.all.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.all.map(&:name)).to eq ["product_0", "product_1", "product_2", "product_3", "product_4"]
-            expect(finder.results.all.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.all.map(&:name)).to eq ["product_0", "product_1", "product_2", "product_3", "product_4", "product_5"]
-            expect(finder.results.all.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.all.map(&:name)).to eq ["product_6", "", nil, "product_4"]
-            expect(finder.results.all.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.all.map(&:name)).to eq ["product_5", "product_6", "", nil, "product_4"]
-            expect(finder.results.all.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

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

@@ -1,110 +0,0 @@
-require 'spec_helper_sequel'
-
-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, with: :apply_name_filter
-    filter_by :price
-    filter_by(:s_category) { |entity_type, _| entity_type.association_join(:s_category) }
-
-    def apply_name_filter(entity_type, value)
-    end
-  end
-
-  def finder_with_sort(sort = nil, filters = {})
-    TestSequelSortFinder.new filter: (sort.nil? ? {} : { name: 'test', 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/adapters_spec.rb

@@ -1,110 +0,0 @@
-require 'spec_helper'
-require 'active_record'
-
-module Trailblazer
-  class Finder
-    describe Adapters do
-      def define_finder_class(&block)
-        Class.new do
-          include Trailblazer::Finder::Base
-          include Trailblazer::Finder::Adapters
-
-          instance_eval(&block) if block_given?
-        end
-      end
-
-      describe '.adapters' do
-        it 'responds to adapters method' do
-          finder_class = define_finder_class do
-            entity_type { 'entity_type' }
-          end
-
-          expect(finder_class).to respond_to(:adapters)
-        end
-      end
-
-      describe ActiveRecord do
-        it 'can load ActiveRecord adapter' do
-          expect do
-            define_finder_class do
-              entity_type { 'entity_type' }
-              adapters ActiveRecord
-            end
-          end.not_to raise_error
-        end
-      end
-
-      describe Sequel do
-        it 'can load Sequel adapter' do
-          expect do
-            define_finder_class do
-              entity_type { 'entity_type' }
-              adapters Sequel
-            end
-          end.not_to raise_error
-        end
-      end
-
-      describe DataMapper do
-        it 'can load DataMapper adapter' do
-          expect do
-            define_finder_class do
-              entity_type { 'entity_type' }
-              adapters DataMapper
-            end
-          end.not_to raise_error
-        end
-      end
-
-      describe Kaminari do
-        it 'can load Kaminari adapter' do
-          expect do
-            define_finder_class do
-              entity_type { 'entity_type' }
-              adapters Kaminari
-            end
-          end.not_to raise_error
-        end
-      end
-
-      describe WillPaginate do
-        it 'can load WillPaginate adapter' do
-          expect do
-            define_finder_class do
-              entity_type { 'entity_type' }
-              adapters WillPaginate
-            end
-          end.not_to raise_error
-        end
-      end
-      describe FriendlyId do
-        it 'can load FriendlyId adapter' do
-          expect do
-            define_finder_class do
-              entity_type { 'entity_type' }
-              adapters FriendlyId
-            end
-          end.not_to raise_error
-        end
-      end
-
-      it 'raises an error on non-existing adapter' do
-        expect do
-          define_finder_class do
-            entity_type { 'entity_type' }
-            adapters Unknown
-          end
-        end.to raise_error NameError
-      end
-
-      it 'can load multiple adapters' do
-        expect do
-          define_finder_class do
-            entity_type { 'entity_type' }
-            adapters ActiveRecord, Kaminari
-          end
-        end.not_to raise_error
-      end
-    end
-  end
-end

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

@@ -1,104 +0,0 @@
-require 'spec_helper'
-require 'support/paging_shared_example'
-
-module Trailblazer
-  class Finder
-    module Features
-      describe Paging do
-        it_behaves_like 'a paging feature'
-
-        it 'uses a pre-defined Hash entity_type instead of any ORM' do
-          true
-        end
-
-        def define_finder_class(&block)
-          Class.new do
-            include Trailblazer::Finder::Base
-            include Trailblazer::Finder::Features::Paging
-
-            instance_eval(&block) if block_given?
-          end
-        end
-
-        def finder_class
-          define_finder_class do
-            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
-                },
-                {
-                  id: 6,
-                  name: 'product_6',
-                  price: '15',
-                  created_at: Time.now,
-                  updated_at: Time.now
-                }
-              ]
-            end
-
-            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
-            finder = finder_with_page 2, 2
-            expect(finder.results.map { |n| n[:name] }).to eq %w[product_3 product_4]
-          end
-        end
-
-        describe '#count' do
-          it 'gives the real count' do
-            finder = finder_with_page 1
-            expect(finder.count).to eq 6
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,99 +0,0 @@
-# require 'spec_helper_sequel'
-require 'spec_helper'
-
-module Trailblazer
-  class Finder
-    module Features
-      describe Predicate do
-        class TestFinder < Trailblazer::Finder
-          features Predicate
-
-          def create_product(id, name, price)
-            {
-              id: id,
-              name: name,
-              price: price,
-              created_at: Time.now,
-              updated_at: Time.now
-            }
-          end
-
-          entity_type do
-            Array.new(10) do |i|
-              next create_product(i+1, "", "1#{i}".to_i)if i == 7
-              next create_product(i+1, nil, "1#{i}".to_i) if i == 8
-              next create_product(i+1, "product_4", "1#{i}".to_i) if i == 9
-              create_product(i+1, "product_#{i}", "1#{i}".to_i)
-            end
-          end
-
-          predicates_for :name, :price, :created_at
-        end
-
-        def finder_with_predicate(filter = nil, value = nil, filters = {})
-          TestFinder.new filter: { filter => value }.merge(filters)
-        end
-
-        describe 'eqauls' do
-          it 'it finds single row with name equal to product_5' do
-            finder = finder_with_predicate 'name_eq', 'product_5'
-            expect(finder.results.map { |n| n[: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 { |n| n[: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 { |n| n[:name] }).to eq ["product_0", "product_1", "product_2", "product_3", "product_5", "product_6", ""]
-            expect(finder.results.map { |n| n[: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 { |n| n[: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 { |n| n[: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 { |n| n[:name] }).to eq ["product_0", "product_1", "product_2", "product_3", "product_4"]
-            expect(finder.results.map { |n| n[: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 { |n| n[:name] }).to eq ["product_0", "product_1", "product_2", "product_3", "product_4", "product_5"]
-            expect(finder.results.map { |n| n[: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 { |n| n[:name] }).to eq ["product_6", "", nil, "product_4"]
-            expect(finder.results.map { |n| n[: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 { |n| n[:name] }).to eq ["product_5", "product_6", "", nil, "product_4"]
-            expect(finder.results.map { |n| n[: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 { |n| n[:name] }).to eq ["product_5", "product_6"]
-            expect(finder.results.map { |n| n[:price] }).to eq [15, 16]
-          end
-        end
-      end
-    end
-  end
-end