trailblazer-finder 0.1.4 → 0.2.5

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

@@ -1,96 +0,0 @@
-# require 'spec_helper_sequel'
-require 'spec_helper'
-
-module Trailblazer
-  class Finder
-    module Features
-      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
-
-          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 = {})
-          TestSortingFinder.new filter: (sort.nil? ? {} : { sort: sort }).merge(filters)
-        end
-
-        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 [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 [8, 10, 11, 12, 13, 14]
-          end
-
-          it 'defaults to original sorted hash' do
-            finder = finder_with_sort
-            expect(finder.results.map { |n| n[:name] }).to eq ['Name0', 'Name1', 'Name2', 'Name3', 'Name4', 'Name3']
-          end
-
-          it 'ignores invalid sort values' do
-            finder = finder_with_sort 'invalid attribute'
-            expect { finder.results.to_a }.not_to raise_error
-          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
-  end
-end

data/spec/trailblazer/finder/features_spec.rb

@@ -1,55 +0,0 @@
-require 'spec_helper'
-
-module Trailblazer
-  class Finder
-    describe Features do
-      def define_finder_class(&block)
-        Class.new do
-          include Trailblazer::Finder::Base
-          include Trailblazer::Finder::Features
-
-          instance_eval(&block) if block_given?
-        end
-      end
-
-      it '.adapters' do
-        finder_class = define_finder_class do
-          entity_type { 'entity_type' }
-        end
-
-        expect(finder_class).to respond_to(:features)
-      end
-
-      describe Paging do
-        it 'can load Paging feature' do
-          expect do
-            define_finder_class do
-              entity_type { 'entity_type' }
-              features Paging
-            end
-          end.not_to raise_error
-        end
-      end
-
-      describe Sorting do
-        it 'can load Sorting feature' do
-          expect do
-            define_finder_class do
-              entity_type { 'entity_type' }
-              features Sorting
-            end
-          end.not_to raise_error
-        end
-      end
-
-      it 'raises an error on non-existing feature' do
-        expect do
-          define_finder_class do
-            entity_type { 'entity_type' }
-            features Unknown
-          end
-        end.to raise_error NameError
-      end
-    end
-  end
-end

data/spec/trailblazer/finder/filter_spec.rb

@@ -1,133 +0,0 @@
-require 'spec_helper'
-require 'ostruct'
-
-module Trailblazer
-  class Finder
-    describe Filter do
-      class TestFind
-        include Trailblazer::Finder::Base
-        include Trailblazer::Finder::Filter
-
-        entity_type { [1, 2, 3, 4, 5] }
-
-        filter_by :filter, defined_by: %w[odd even]
-
-        private
-
-        def apply_filter_with_odd(entity_type)
-          entity_type.select(&:odd?)
-        end
-
-        def apply_filter_with_even(entity_type)
-          entity_type.select(&:even?)
-        end
-
-        def handle_invalid_filter(_entity_type, value)
-          "invalid filter - #{value}"
-        end
-      end
-
-      it 'can filter by defined values' do
-        expect(TestFind.results(filter: { filter: 'odd' })).to eq [1, 3, 5]
-        expect(TestFind.results(filter: { filter: 'even' })).to eq [2, 4]
-      end
-
-      it 'ignores blank values' do
-        expect(TestFind.results(filter: { filter: nil })).to eq [1, 2, 3, 4, 5]
-        expect(TestFind.results(filter: { filter: '' })).to eq [1, 2, 3, 4, 5]
-      end
-
-      it 'handles wrongly defined values' do
-        expect(TestFind.results(filter: { filter: 'foo' })).to eq 'invalid filter - foo'
-      end
-
-      it 'raises when block is passed with defined filter' do
-        expect do
-          Class.new do
-            include Trailblazer::Finder::Base
-            include Trailblazer::Finder::Filter
-
-            filter_by(:filter, defined_by: %w[a b]) { |_entity_type, _value| nil }
-          end
-        end.to raise_error Trailblazer::Finder::Error::BlockIgnored
-      end
-
-      it 'raises when :with is passed with defined filter_by' do
-        expect do
-          Class.new do
-            include Trailblazer::Finder::Base
-            include Trailblazer::Finder::Filter
-
-            filter_by :filter, defined_by: %w[a b], with: :method_name
-          end
-        end.to raise_error Trailblazer::Finder::Error::WithIgnored
-      end
-    end
-
-    describe Filter::Handler do
-      describe 'apply_filter' do
-        def new_object(&block)
-          klass = Class.new(&block)
-          klass.new
-        end
-
-        def call(object: nil, filter_by: nil, defined_bys: nil, entity_type: nil, value:)
-          described_class.apply_filter(
-            object: object || new_object,
-            filter_by: filter_by || 'filter_by',
-            defined_bys: defined_bys || [value],
-            entity_type: entity_type || [],
-            value: value
-          )
-        end
-
-        it 'filters by methods based on the defined value' do
-          object = new_object do
-            private
-
-            def apply_select_with_name(entity_type)
-              entity_type.select { |value| value == 'name' }
-            end
-
-            def apply_select_with_age(entity_type)
-              entity_type.select { |value| value == 'age' }
-            end
-          end
-
-          entity_type = %w[name age location]
-
-          expect(call(object: object, filter_by: 'select', entity_type: entity_type, value: 'name')).to eq %w[name]
-          expect(call(object: object, filter_by: 'select', entity_type: entity_type, value: 'age')).to eq %w[age]
-        end
-
-        it 'raises NoMethodError when object can not handle defined method' do
-          expect { call(defined_bys: ['a'], value: 'a') }.to raise_error NoMethodError
-        end
-
-        it 'raises error when value is not defined' do
-          expect { call(defined_bys: [], value: 'invalid') }.to raise_error Trailblazer::Finder::Error::InvalidDefinedByValue
-        end
-
-        it 'can delegate missing defined value to object' do
-          object = new_object do
-            def handle_invalid_filter_by(_entity_type, value)
-              "handles #{value} value"
-            end
-          end
-
-          expect(call(object: object, defined_bys: [], value: 'invalid')).to eq 'handles invalid value'
-        end
-
-        it 'can delegate missing defined value to object (cath all)' do
-          object = new_object do
-            def handle_invalid_defined_by(filter_by, _entity_type, value)
-              "handles #{value} value for #{filter_by}"
-            end
-          end
-
-          expect(call(object: object, defined_bys: [], value: 'invalid')).to eq 'handles invalid value for filter_by'
-        end
-      end
-    end
-  end
-end

data/spec/trailblazer/finder/find_spec.rb

@@ -1,72 +0,0 @@
-require 'spec_helper'
-require 'ostruct'
-
-module Trailblazer
-  describe Finder::Find do
-    describe '.params' do
-      it 'returns the passed params' do
-        finder = Finder::Find.new('entity_type', 'params', {})
-        expect(finder.params).to eq 'params'
-      end
-    end
-
-    describe '.param' do
-      it 'returns the param value' do
-        finder = Finder::Find.new('entity_type', { name: 'value' }, {})
-        expect(finder.param(:name)).to eq 'value'
-      end
-    end
-
-    describe '.query' do
-      it 'returns filtered result' do
-        actions = {
-          min: ->(entity_type, min) { entity_type.select { |v| v > min } }
-        }
-
-        finder = Finder::Find.new [1, 2, 3], { min: 2 }, actions
-        expect(finder.query(Object.new)).to eq [3]
-      end
-
-      it 'applies actions to params' do
-        actions = {
-          min: ->(entity_type, min) { entity_type.select { |v| v > min } },
-          max: ->(entity_type, max) { entity_type.select { |v| v < max } }
-        }
-
-        finder = Finder::Find.new [1, 2, 3, 4, 5], { min: 2, max: 5 }, actions
-        expect(finder.query(Object.new)).to eq [3, 4]
-      end
-
-      it 'handles nil returned from action' do
-        actions = {
-          odd: ->(entity_type, odd) { entity_type.select(&:odd?) if odd }
-        }
-
-        finder = Finder::Find.new [1, 2, 3, 4, 5], { odd: false }, actions
-        expect(finder.query(Object.new)).to eq [1, 2, 3, 4, 5]
-      end
-
-      it 'executes action in the passed context' do
-        actions = {
-          finder: ->(entity_type, _) { entity_type.select { |v| v == target_value } }
-        }
-
-        context = OpenStruct.new target_value: 2
-
-        finder = Finder::Find.new [1, 2, 3, 4, 5], { finder: true }, actions
-        expect(finder.query(context)).to eq [2]
-      end
-    end
-
-    describe '.count' do
-      it 'counts the results of the query' do
-        actions = {
-          value: ->(entity_type, value) { entity_type.select { |v| v == value } }
-        }
-
-        finder = Finder::Find.new [1, 2, 3], { value: 2 }, actions
-        expect(finder.count(Object.new)).to eq 1
-      end
-    end
-  end
-end

data/spec/trailblazer/finder/utils/extra_spec.rb

@@ -1,41 +0,0 @@
-require 'spec_helper'
-
-module Trailblazer
-  class Finder
-    module Utils
-      describe Extra do
-        describe '.deep_copy' do
-          it 'returns a deep copy on the given object' do
-            original = {
-              array: [1, 2, 3],
-              hash: { key: 'value' },
-              boolean: true,
-              number: 1,
-              null: nil
-            }
-
-            deep_copy = Finder::Utils::Extra.deep_copy(original)
-
-            original[:array][0] = 42
-            original[:hash][:key] = 'other value'
-
-            expect(deep_copy).to eq(
-              array: [1, 2, 3],
-              hash: { key: 'value' },
-              boolean: true,
-              number: 1,
-              null: nil
-            )
-          end
-        end
-
-        describe '.ensure_included' do
-          it 'works' do
-            str = Utils::Extra.ensure_included '1 2'.to_s.split(' ', 2).last, %w[1]
-            expect(str).to eq('1')
-          end
-        end
-      end
-    end
-  end
-end

data/spec/trailblazer/finder/utils/params_spec.rb

@@ -1,39 +0,0 @@
-require 'spec_helper'
-
-module Trailblazer
-  class Finder
-    module Utils
-      describe Params do
-        describe '.slice_keys' do
-          it 'selects only given keys' do
-            hash = Finder::Utils::Params.slice_keys({ a: 1, b: 2, c: 3 }, %i[a b])
-            expect(hash).to eq a: 1, b: 2
-          end
-
-          it 'ignores not existing keys' do
-            hash = Finder::Utils::Params.slice_keys({}, %i[a b])
-            expect(hash).to eq({})
-          end
-        end
-
-        describe '.normalize_params' do
-          it 'combines defaults and filters' do
-            expect(Finder::Utils::Params.normalize_params({ 'a' => 1, 'b' => 2 }, { a: 2 }, %w[a b])).to eq 'a' => 2, 'b' => 2
-          end
-
-          it 'excludes non specified keys' do
-            expect(Finder::Utils::Params.normalize_params({ 'a' => 1 }, { b: 2 }, %w[a])).to eq 'a' => 1
-          end
-
-          it 'handles missing defaults' do
-            expect(Finder::Utils::Params.normalize_params(nil, { a: 1 }, %w[a])).to eq 'a' => 1
-          end
-
-          it 'handles missing filters' do
-            expect(Finder::Utils::Params.normalize_params(nil, nil, ['a'])).to eq({})
-          end
-        end
-      end
-    end
-  end
-end

data/spec/trailblazer/finder/utils/parse_spec.rb

@@ -1,33 +0,0 @@
-require 'spec_helper'
-
-module Trailblazer
-  class Finder
-    module Utils
-      describe Parse do
-        describe '.parse_date' do
-          it 'returns when value is a date' do
-            expect(Finder::Utils::Parse.date('2018-01-01')).to eq '2018-01-01'
-          end
-
-          it 'returns when value is a screwed up date like 02-2018-01 10:10:10' do
-            expect(Finder::Utils::Parse.date('02-2018-01 10:10')).to eq '2018-01-02'
-          end
-
-          it 'returns nil value is not date worthy' do
-            expect(Finder::Utils::Parse.date('Unknown')).to eq nil
-          end
-        end
-
-        describe '.escape_term' do
-          it 'returns escaped value' do
-            expect(Finder::Utils::Parse.term('term')).to eq '%term%'
-          end
-
-          it 'returns mutliple escaped values' do
-            expect(Finder::Utils::Parse.term('term term')).to eq '%term%term%'
-          end
-        end
-      end
-    end
-  end
-end