trailblazer-finder 0.1.4 → 0.2.5

data/spec/trailblazer/finder/base_spec.rb

@@ -1,23 +1,23 @@
-require 'spec_helper'
-puts 'AR is loaded' if Gem.loaded_specs.key?('active_record')
+# frozen_string_literal: true
+
+require "spec_helper"
+
 module Trailblazer
   class Finder # rubocop:disable Metrics/ClassLength
     describe Base do
       def define_finder_class(&block)
-        Class.new do
-          include Finder::Base
-
+        Class.new(Trailblazer::Finder) do
           class_eval(&block)
         end
       end
 
-      def finder_class(default_entity_type = [], &block)
+      def finder_class(default_entity = [], &block)
         define_finder_class do
-          entity_type { default_entity_type }
+          entity { default_entity }
 
           if block.nil?
-            filter_by :value do |entity_type, value|
-              entity_type.select { |v| v == value }
+            filter_by :value do |entity, _attribute, value|
+              entity.select { |v| v == value }
             end
           else
             class_eval(&block)
@@ -25,11 +25,11 @@ module Trailblazer
         end
       end
 
-      def new_finder(default_entity_type = [], filter = {}, &block)
-        finder_class(default_entity_type, &block).new filter: filter
+      def new_finder(default_entity = [], filter = {}, &block)
+        finder_class(default_entity, &block).new params: filter
       end
 
-      it 'can have its #initialize method overwritten' do
+      it "can have its #initialize method overwritten" do
         finder = new_finder do
           attr_reader :initialized
 
@@ -44,284 +44,372 @@ module Trailblazer
         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 }
+      it "can have multiple subclasses" do
+        finder_1 = new_finder [1, 2, 3], filter: 1 do
+          filter_by :filter do |entity, _attribute, value|
+            entity.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 }
+        finder_2 = new_finder [1, 2, 3], other_filter: 1 do
+          filter_by :other_filter do |entity, _attribute, value|
+            entity.reject { |v| v == value }
           end
         end
 
-        expect(finder1.results).not_to eq finder2.results
+        expect(finder_1.result).not_to eq finder_2.result
       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
+      describe ".result" do
+        it "returns only the filtered finder results" do
+          finder = new_finder [1, 2, 3], value: 1
+          expect(finder.result).to eq [1]
         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
+        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, _attribute, value|
+              entity.select { |v| v > value }
+            end
 
-      describe 'entity_type' do
-        def finder_class
-          define_finder_class do
-            filter_by :name do
+            filter_by :odd do |entity, _attribute, value|
+              entity.select(&:odd?) if value
             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
+          expect(finder.result).to eq [5, 7]
         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'
+        it "ignores invalid filters" do
+          finder = new_finder [1, 2, 3], invalid: "filter_by"
+          expect(finder.result).to eq [1, 2, 3]
         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
+        it "can be overwritten by overwriting #fetch_result" do
+          finder = new_finder [1, 2, 3], value: 1 do
+            filter_by :value do |entity, _attribute, value|
+              entity.select { |v| v == value }
+            end
 
-            def initialize
-              @inner_entity_type = 'entity_type'
-              super
+            def fetch_result
+              super.map { |v| "~#{v}~" }
             end
           end
 
-          expect(finder_class.new.results).to eq 'entity_type'
+          expect(finder.result).to eq ["~1~"]
         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' }
+        it "applies to default filters" do
+          finder = new_finder [1, 2, 3], value: 1 do
+            filter_by :value do |entity, _attribute, value|
+              entity.select { |v| v == value }
+            end
+          end
+          expect(finder.result).to eq [1]
+        end
+
+        it "shows the all results if no paging options are specified" do
+          entity = [
+            {id: 1, value: "Test 1"},
+            {id: 2, value: "Test 2"},
+            {id: 3, value: "Test 1"},
+            {id: 4, value: "Test 4"},
+            {id: 5, value: "Test 1"},
+            {id: 6, value: "Test 1"},
+            {id: 7, value: "Test 2"},
+            {id: 8, value: "Test 1"},
+            {id: 9, value: "Test 4"},
+            {id: 10, value: "Test 1"}
+          ]
+
+          finder = new_finder entity, value_cont: "Test", sort: "id desc" do
+            property :value, type: Types::String, sortable: true
+            property :id, type: Types::Integer, sortable: true
           end
 
-          expect(finder_class.new(entity_type: nil).results).to eq 'entity_type'
+          expect(finder.count).to eq 10
         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
+      describe ".result?" do
+        it "has a result" do
+          finder = new_finder [1, 2, 3], value: 1 do
+            filter_by :value do |entity, _attribute, value|
+              entity.select { |v| v == value }
+            end
           end
-
-          expect(finder.results.map { |n| n[:value] }).to eq ['Test 1']
+          expect(finder.result?).to eq true
         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
+        it "has no result" do
+          finder = new_finder [1, 2, 3], value: 4 do
+            filter_by :value do |entity, _attribute, value|
+              entity.select { |v| v == value }
+            end
           end
-
-          expect(finder.results.map { |n| n[:value] }).to eq ['Test 1']
-          expect(finder.results.map { |n| n[:id] }).to eq [4]
+          expect(finder.result?).to eq false
         end
+      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
+      describe ".count" do
+        it "can apply several filters and have a correct count" 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, _attribute, value|
+              entity.select { |v| v > value }
+            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
+            filter_by :odd do |entity, _attribute, value|
+              entity.select(&:odd?) if value
             end
           end
 
-          expect(finder.results).to eq entity_type
+          expect(finder.count).to eq 2
         end
+      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
+      describe ".params" do
+        it "shows the default parameters when none are given" do
+          entity = [{id: 1, value: "Test 1"}, {id: 2, value: "Test 2"}, {id: 3, value: "Test 3"}]
+          finder = new_finder entity do
+            paging per_page: 2, min_per_page: 1, max_per_page: 5
+            property :value, type: Types::String
           end
 
-          expect(finder1.results).to eq [1]
+          expect(finder.params).to eq per_page: 2, page: 1, sort: nil
         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
+        it "shows the parameters that are given" do
+          entity = [
+            {id: 1, value: "Test 1"},
+            {id: 2, value: "Test 2"},
+            {id: 3, value: "Test 1"},
+            {id: 4, value: "Test 4"},
+            {id: 5, value: "Test 1"}
+          ]
 
-            def some_instance_method(entity_type, value)
-              entity_type.select { |v| v == value }
-            end
+          finder = new_finder entity, value_eq: "Test 1", sort: "id desc", page: 2 do
+            paging per_page: 2, min_per_page: 1, max_per_page: 5
+            property :value, type: Types::String, sortable: true
+            property :id, type: Types::Integer, sortable: true
           end
 
-          expect(finder.results).to eq [1]
+          expect(finder.result.map { |n| n[:id] }).to eq [1]
+          expect(finder.params).to eq value_eq: "Test 1", sort: "id desc", page: 2, per_page: 2
         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
+      describe ".sorting" do
+        it "shows the sorters that have been applied on the result" do
+          entity = [
+            {id: 1, value: "Test 1"},
+            {id: 2, value: "Test 2"},
+            {id: 3, value: "Test 1"},
+            {id: 4, value: "Test 4"},
+            {id: 5, value: "Test 1"}
+          ]
+
+          finder = new_finder entity, value_eq: "Test 1", sort: "value asc, id desc", page: 2 do
+            paging per_page: 2, min_per_page: 1, max_per_page: 5
+            property :value, type: Types::String, sortable: true
+            property :id, type: Types::Integer, sortable: true
           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
+          expect(finder.params).to eq value_eq: "Test 1", sort: "value asc, id desc", page: 2, per_page: 2
+          expect(finder.sorting).to eq "value asc, id desc"
         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 ".filters" do
+        it "shows the filters that have been applied on the result" do
+          entity = [
+            {id: 1, value: "Test 1"},
+            {id: 2, value: "Test 2"},
+            {id: 3, value: "Test 1"},
+            {id: 4, value: "Test 4"},
+            {id: 5, value: "Test 1"}
+          ]
+
+          finder = new_finder entity, value_eq: "Test 1", sort: "value asc, id desc", page: 2 do
+            paging per_page: 2, min_per_page: 1, max_per_page: 5
+            property :value, type: Types::String, sortable: true
+            property :id, type: Types::Integer, sortable: true
+          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]
+          expect(finder.params).to eq value_eq: "Test 1", sort: "value asc, id desc", page: 2, per_page: 2
+          expect(finder.filters[:value_eq][:predicate]).to eq "eq"
         end
+      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
+      describe ".signal" do
+        it "shows the end signal from the trailblazer activity" do
+          entity = [
+            {id: 1, value: "Test 1"},
+            {id: 2, value: "Test 2"},
+            {id: 3, value: "Test 1"},
+            {id: 4, value: "Test 4"},
+            {id: 5, value: "Test 1"}
+          ]
+
+          finder = new_finder entity, value_eq: "Test 1", sort: "value asc, id desc", page: 2 do
+            paging per_page: 2, min_per_page: 1, max_per_page: 5
+            property :value, type: Types::String, sortable: true
+            property :id, type: Types::Integer, sortable: true
           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]
+          expect(finder.params).to eq value_eq: "Test 1", sort: "value asc, id desc", page: 2, per_page: 2
+          expect(finder.signal.to_json).to include("success")
         end
+      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
+      describe ".sort?" do
+        it "returns if an attribute is sorted on or not" do
+          entity = [
+            {id: 1, value: "Test 1"},
+            {id: 2, value: "Test 2"},
+            {id: 3, value: "Test 1"},
+            {id: 4, value: "Test 4"},
+            {id: 5, value: "Test 1"}
+          ]
+
+          finder = new_finder entity, value_eq: "Test 1", sort: "value asc", page: 2 do
+            paging per_page: 2, min_per_page: 1, max_per_page: 5
+            property :value, type: Types::String, sortable: true
+            property :id, type: Types::Integer, sortable: true
           end
 
-          expect(finder.results).to eq ['~1~']
+          expect(finder.params).to eq value_eq: "Test 1", sort: "value asc", page: 2, per_page: 2
+          expect(finder.sort?(:id)).to eq false
+          expect(finder.sort?(:value)).to eq true
         end
+      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
+      describe ".sort_direction_for" do
+        it "shows the sort direction for an attribute" do
+          entity = [
+            {id: 1, value: "Test 1"},
+            {id: 2, value: "Test 2"},
+            {id: 3, value: "Test 1"},
+            {id: 4, value: "Test 4"},
+            {id: 5, value: "Test 1"}
+          ]
+
+          finder = new_finder entity, value_eq: "Test 1", sort: "value asc, id desc", page: 2 do
+            paging per_page: 2, min_per_page: 1, max_per_page: 5
+            property :value, type: Types::String, sortable: true
+            property :id, type: Types::Integer, sortable: true
           end
-          expect(finder.results).to eq [1]
+
+          expect(finder.params).to eq value_eq: "Test 1", sort: "value asc, id desc", page: 2, per_page: 2
+          expect(finder.sort_direction_for(:id)).to eq "desc"
+          expect(finder.sort_direction_for(:value)).to eq "asc"
         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
+      describe ".reverse_sort_direction_for" do
+        it "shows the reversed sort direction for an attribute" do
+          entity = [
+            {id: 1, value: "Test 1"},
+            {id: 2, value: "Test 2"},
+            {id: 3, value: "Test 1"},
+            {id: 4, value: "Test 4"},
+            {id: 5, value: "Test 1"}
+          ]
+
+          finder = new_finder entity, value_eq: "Test 1", sort: "value asc, id desc", page: 2 do
+            paging per_page: 2, min_per_page: 1, max_per_page: 5
+            property :value, type: Types::String, sortable: true
+            property :id, type: Types::Integer, sortable: true
+          end
 
-        it 'returns false if there are no results' do
-          expect(new_finder([1, 2, 3], value: 4)).not_to be_results
+          expect(finder.params).to eq value_eq: "Test 1", sort: "value asc, id desc", page: 2, per_page: 2
+          expect(finder.reverse_sort_direction_for(:id)).to eq "asc"
+          expect(finder.reverse_sort_direction_for(:value)).to eq "desc"
         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
+      describe ".sort_params_for" do
+        it "returns the sort parameters for a requested attribute (added to existing ones)" do
+          entity = [
+            {id: 1, value: "Test 1"},
+            {id: 2, value: "Test 2"},
+            {id: 3, value: "Test 1"},
+            {id: 4, value: "Test 4"},
+            {id: 5, value: "Test 1"}
+          ]
+
+          finder = new_finder entity, value_eq: "Test 1", sort: "value asc", page: 2 do
+            paging per_page: 2, min_per_page: 1, max_per_page: 5
+            property :value, type: Types::String, sortable: true
+            property :id, type: Types::Integer, sortable: true
           end
 
-          expect(finder.count).to eq 3
+          expect(finder.params).to eq value_eq: "Test 1", sort: "value asc", page: 2, per_page: 2
+          expect(finder.sort_params_for(:id)[:sort]).to eq "value asc, id desc"
+          expect(finder.sort_params_for(:value)[:sort]).to eq "value desc"
         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 "returns the sort parameters for a requested attribute (when none existed)" do
+          entity = [
+            {id: 1, value: "Test 1"},
+            {id: 2, value: "Test 2"},
+            {id: 3, value: "Test 1"},
+            {id: 4, value: "Test 4"},
+            {id: 5, value: "Test 1"}
+          ]
 
-        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
+          finder = new_finder entity, value_eq: "Test 1", page: 2 do
+            paging per_page: 2, min_per_page: 1, max_per_page: 5
+            property :value, type: Types::String, sortable: true
+            property :id, type: Types::Integer, sortable: true
+          end
 
-        it 'ignores missing filters' do
-          finder = new_finder
-          expect(finder.params).to eq({})
+          expect(finder.params).to eq value_eq: "Test 1", sort: nil, page: 2, per_page: 2
+          expect(finder.sort_params_for(:id)[:sort]).to eq "id desc"
+          expect(finder.sort_params_for(:value)[:sort]).to eq "value desc"
         end
+      end
+
+      describe ".new_sort_params_for" do
+        it "returns the sort parameters for a requested attribute while cleaning old ones" do
+          entity = [
+            {id: 1, value: "Test 1"},
+            {id: 2, value: "Test 2"},
+            {id: 3, value: "Test 1"},
+            {id: 4, value: "Test 4"},
+            {id: 5, value: "Test 1"}
+          ]
+
+          finder = new_finder entity, value_eq: "Test 1", sort: "value asc", page: 2 do
+            paging per_page: 2, min_per_page: 1, max_per_page: 5
+            property :value, type: Types::String, sortable: true
+            property :id, type: Types::Integer, sortable: true
+          end
 
-        it 'ignores invalid filters' do
-          finder = new_finder [], invalid: 'option'
-          expect(finder.params).to eq({})
+          expect(finder.params).to eq value_eq: "Test 1", sort: "value asc", page: 2, per_page: 2
+          expect(finder.new_sort_params_for(:id)[:sort]).to eq "id desc"
         end
+      end
 
-        it 'includes default filters' do
-          finder = new_finder do
-            filter_by :value, 1
+      describe ".remove_sort_params_for" do
+        it "returns the sort parameters for a requested attribute while cleaning old ones" do
+          entity = [
+            {id: 1, value: "Test 1"},
+            {id: 2, value: "Test 2"},
+            {id: 3, value: "Test 1"},
+            {id: 4, value: "Test 4"},
+            {id: 5, value: "Test 1"}
+          ]
+
+          finder = new_finder entity, value_eq: "Test 1", sort: "value asc, id desc", page: 2 do
+            paging per_page: 2, min_per_page: 1, max_per_page: 5
+            property :value, type: Types::String, sortable: true
+            property :id, type: Types::Integer, sortable: true
           end
-          expect(finder.params).to eq 'value' => 1
+
+          expect(finder.params).to eq value_eq: "Test 1", sort: "value asc, id desc", page: 2, per_page: 2
+          expect(finder.remove_sort_params_for(:id)[:sort]).to eq "value asc"
         end
       end
     end