trailblazer-finder 0.1.0

data/spec/trailblazer/finder/base_spec.rb

@@ -0,0 +1,329 @@
+require 'spec_helper'
+puts 'AR is loaded' if Gem.loaded_specs.key?('active_record')
+module Trailblazer
+  class Finder # rubocop:disable Metrics/ClassLength
+    describe Base do
+      def define_finder_class(&block)
+        Class.new do
+          include Finder::Base
+
+          class_eval(&block)
+        end
+      end
+
+      def finder_class(default_entity_type = [], &block)
+        define_finder_class do
+          entity_type { default_entity_type }
+
+          if block.nil?
+            filter_by :value do |entity_type, value|
+              entity_type.select { |v| v == value }
+            end
+          else
+            class_eval(&block)
+          end
+        end
+      end
+
+      def new_finder(default_entity_type = [], filter = {}, &block)
+        finder_class(default_entity_type, &block).new filter: filter
+      end
+
+      it 'can have its #initialize method overwritten' do
+        finder = new_finder do
+          attr_reader :initialized
+
+          alias_method :initialized?, :initialized
+
+          def initialize(filter = {})
+            @initialized = true
+            super filter
+          end
+        end
+
+        expect(finder).to be_initialized
+      end
+
+      it 'can have multiple subclasses' do
+        finder1 = new_finder [1, 2, 3], filter: 1 do
+          filter_by :filter do |entity_type, value|
+            entity_type.select { |v| v == value }
+          end
+        end
+
+        finder2 = new_finder [1, 2, 3], filter: 1 do
+          filter_by :filter, 2 do |entity_type, value|
+            entity_type.reject { |v| v == value }
+          end
+        end
+
+        expect(finder1.results).not_to eq finder2.results
+      end
+
+      it 'can be inherited' do
+        equality_finder = Class.new(finder_class([1, 2, 3])) do
+          filter_by :value do |entity_type, value|
+            entity_type.select { |v| v == value }
+          end
+        end
+
+        inequality_finder = Class.new(finder_class([1, 2, 3])) do
+          filter_by :value do |entity_type, value|
+            entity_type.select { |v| v > value }
+          end
+        end
+
+        expect(equality_finder.new(filter: { value: 1 }).results).to eq [1]
+        expect(inequality_finder.new(filter: { value: 1 }).results).to eq [2, 3]
+      end
+
+      describe 'entity_type' do
+        def finder_class
+          define_finder_class do
+            filter_by :name do
+            end
+          end
+        end
+
+        it 'accepts entity_type as argument' do
+          expect(finder_class.new(entity_type: 'entity_type').results).to eq 'entity_type'
+        end
+
+        it 'raises an error if no entity_type is provided' do
+          expect { finder_class.new }.to raise_error Finder::Error::MissingEntityType
+        end
+
+        it 'can overwrite the finder entity_type' do
+          finder_class = define_finder_class do
+            entity_type { 'entity_type' }
+          end
+
+          expect(finder_class.new(entity_type: 'other entity_type').results).to eq 'other entity_type'
+        end
+
+        it 'accepts a block in context of finder object' do
+          finder_class = define_finder_class do
+            entity_type { inner_entity_type }
+
+            attr_reader :inner_entity_type
+
+            def initialize
+              @inner_entity_type = 'entity_type'
+              super
+            end
+          end
+
+          expect(finder_class.new.results).to eq 'entity_type'
+        end
+
+        it 'passing nil as entity_type in constructor, falls back to default entity_type' do
+          finder_class = define_finder_class do
+            entity_type { 'entity_type' }
+          end
+
+          expect(finder_class.new(entity_type: nil).results).to eq 'entity_type'
+        end
+      end
+
+      describe 'filter_by' do
+        it 'has a default filter' do
+          entity_type = [{ id: 1, value: 'Test 1' }, { id: 2, value: 'Test 2' }, { id: 3, value: 'Test 3' }]
+          finder = new_finder entity_type, value: 'Test 1' do
+            filter_by :value
+          end
+
+          expect(finder.results.map { |n| n[:value] }).to eq ['Test 1']
+        end
+
+        it 'has a default filter working when it\'s nested' do
+          entity_type = [{ id: 1, value: [id: 4, value: 'Test 1'] }, { id: 2, value: 'Test 2' }, { id: 3, value: 'Test 3' }]
+          finder = new_finder entity_type, value: 'Test 1' do
+            filter_by :value
+          end
+
+          expect(finder.results.map { |n| n[:value] }).to eq ['Test 1']
+          expect(finder.results.map { |n| n[:id] }).to eq [4]
+        end
+
+        it 'has another default filter' do
+          entity_type = [{ id: 1, value: 'Test 1' }, { id: 2, value: 'Test 2' }, { id: 3, value: 'Test 3' }]
+          finder = new_finder entity_type, id: 2 do
+            filter_by :id
+          end
+
+          expect(finder.results.map { |n| n[:value] }).to eq ['Test 2']
+        end
+
+        it 'returns the entity_type if nil is returned' do
+          entity_type = [1, 2, 3]
+          finder = new_finder entity_type, value: 'some' do
+            filter_by :value do
+              nil
+            end
+          end
+
+          expect(finder.results).to eq entity_type
+        end
+
+        it 'can use methods from the object' do
+          finder1 = new_finder [1, 2, 3], filter: 1 do
+            filter_by :filter do |entity_type, value|
+              some_instance_method(entity_type, value)
+            end
+
+            private
+
+            def some_instance_method(entity_type, value)
+              entity_type.select { |v| v == value }
+            end
+          end
+
+          expect(finder1.results).to eq [1]
+        end
+
+        it 'can dispatch with instance methods' do
+          finder = new_finder [1, 2, 3], filter: 1 do
+            filter_by :filter, with: :some_instance_method
+
+            private
+
+            def some_instance_method(entity_type, value)
+              entity_type.select { |v| v == value }
+            end
+          end
+
+          expect(finder.results).to eq [1]
+        end
+      end
+
+      describe 'filter_by attributes' do
+        it 'accesses filter values' do
+          finder = new_finder [], value: 1
+          expect(finder.value).to eq 1
+        end
+
+        it 'returns default filter value if filter_by is not specified' do
+          finder = new_finder do
+            filter_by :value, 1
+          end
+          expect(finder.value).to eq 1
+        end
+
+        it 'does not include invalid filters' do
+          finder = new_finder [], invalid: 'option'
+          expect { finder.invalid }.to raise_error NoMethodError
+        end
+      end
+
+      describe '.results' do
+        it 'shortcut for creating new finder and immediately returning results' do
+          klass = finder_class [1, 2, 3]
+          expect(klass.results(filter: { value: 1 })).to eq [1]
+        end
+      end
+
+      describe '#results' do
+        it 'returns only the filtered finder results' do
+          finder = new_finder [1, 2, 3], value: 1
+          expect(finder.results).to eq [1]
+        end
+
+        it 'can apply several filters' do
+          values = [1, 2, 3, 4, 5, 6, 7]
+          finder = new_finder values, bigger_than: 3, odd: true do
+            filter_by :bigger_than do |entity_type, value|
+              entity_type.select { |v| v > value }
+            end
+
+            filter_by :odd do |entity_type, value|
+              entity_type.select(&:odd?) if value
+            end
+          end
+
+          expect(finder.results).to eq [5, 7]
+        end
+
+        it 'ignores invalid filters' do
+          finder = new_finder [1, 2, 3], invalid: 'filter_by'
+          expect(finder.results).to eq [1, 2, 3]
+        end
+
+        it 'can be overwritten by overwriting #fetch_results' do
+          finder = new_finder [1, 2, 3], value: 1 do
+            filter_by :value do |entity_type, value|
+              entity_type.select { |v| v == value }
+            end
+
+            def fetch_results
+              super.map { |v| "~#{v}~" }
+            end
+          end
+
+          expect(finder.results).to eq ['~1~']
+        end
+
+        it 'applies to default filters' do
+          finder = new_finder [1, 2, 3] do
+            filter_by :value, 1 do |entity_type, value|
+              entity_type.select { |v| v == value }
+            end
+          end
+          expect(finder.results).to eq [1]
+        end
+      end
+
+      describe '#results?' do
+        it 'returns true if there are results' do
+          expect(new_finder([1, 2, 3], value: 1)).to be_results
+        end
+
+        it 'returns false if there are no results' do
+          expect(new_finder([1, 2, 3], value: 4)).not_to be_results
+        end
+      end
+
+      describe '#count' do
+        it 'counts the number of results' do
+          expect(new_finder([1, 2, 3], value: 1).count).to eq 1
+        end
+
+        it 'can not be bypassed by features' do
+          finder = new_finder [1, 2, 3] do
+            def fetch_results; end
+          end
+
+          expect(finder.count).to eq 3
+        end
+      end
+
+      describe '#params' do
+        it 'exports filters as params' do
+          finder = new_finder [], value: 1
+          expect(finder.params).to eq 'value' => 1
+        end
+
+        it 'can overwrite filters (mainly used for url handers)' do
+          finder = new_finder [], value: 1
+          expect(finder.params(value: 2)).to eq 'value' => 2
+        end
+
+        it 'ignores missing filters' do
+          finder = new_finder
+          expect(finder.params).to eq({})
+        end
+
+        it 'ignores invalid filters' do
+          finder = new_finder [], invalid: 'option'
+          expect(finder.params).to eq({})
+        end
+
+        it 'includes default filters' do
+          finder = new_finder do
+            filter_by :value, 1
+          end
+          expect(finder.params).to eq 'value' => 1
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,104 @@
+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 # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
+          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/sorting_spec.rb

@@ -0,0 +1,100 @@
+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
+
+        def finder_class # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
+          Class.new do
+            include Trailblazer::Finder::Base
+            include Trailblazer::Finder::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) }
+          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
+          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]
+          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]
+          end
+
+          it 'defaults to first sort by option' 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]
+          end
+
+          it 'ignores invalid sort values' do
+            finder = finder_with_sort 'invalid attribute'
+            expect { finder.results.to_a }.not_to raise_error
+          end
+        end
+
+        it_behaves_like 'a sorting feature'
+      end
+    end
+  end
+end

data/spec/trailblazer/finder/features_spec.rb

@@ -0,0 +1,55 @@
+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