trailblazer-finder 0.70.0 → 0.80.1

data/spec/trailblazer/finder/base_spec.rb

@@ -1,417 +0,0 @@
-# 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(Trailblazer::Finder) do
-          class_eval(&block)
-        end
-      end
-
-      def finder_class(default_entity = [], &block)
-        define_finder_class do
-          entity { default_entity }
-
-          if block.nil?
-            filter_by :value do |entity, _attribute, value|
-              entity.select { |v| v == value }
-            end
-          else
-            class_eval(&block)
-          end
-        end
-      end
-
-      def new_finder(default_entity = [], filter = {}, &block)
-        finder_class(default_entity, &block).new params: 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
-        finder_1 = new_finder [1, 2, 3], filter: 1 do
-          filter_by :filter do |entity, _attribute, value|
-            entity.select { |v| v == value }
-          end
-        end
-
-        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(finder_1.result).not_to eq finder_2.result
-      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
-
-        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
-
-            filter_by :odd do |entity, _attribute, value|
-              entity.select(&:odd?) if value
-            end
-          end
-
-          expect(finder.result).to eq [5, 7]
-        end
-
-        it "ignores invalid filters" do
-          finder = new_finder [1, 2, 3], invalid: "filter_by"
-          expect(finder.result).to eq [1, 2, 3]
-        end
-
-        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 fetch_result
-              super.map { |v| "~#{v}~" }
-            end
-          end
-
-          expect(finder.result).to eq ["~1~"]
-        end
-
-        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.count).to eq 10
-        end
-      end
-
-      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.result?).to eq true
-        end
-
-        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.result?).to eq false
-        end
-      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
-
-            filter_by :odd do |entity, _attribute, value|
-              entity.select(&:odd?) if value
-            end
-          end
-
-          expect(finder.count).to eq 2
-        end
-      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(finder.params).to eq per_page: 2, page: 1, sort: nil
-        end
-
-        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"}
-          ]
-
-          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.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 ".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.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 ".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
-
-          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
-
-      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.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
-
-      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.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
-
-      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.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 ".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
-
-          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 ".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.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
-
-        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"}
-          ]
-
-          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
-
-          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
-
-          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
-
-      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_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
-  end
-end

data/spec/trailblazer/finder/dsl_spec.rb

@@ -1,204 +0,0 @@
-# frozen_string_literal: true
-
-require "spec_helper"
-
-module Trailblazer
-  class Finder # rubocop:disable Metrics/ClassLength
-    describe Dsl do
-      def define_finder_class(&block)
-        Class.new(Trailblazer::Finder) do
-          class_eval(&block)
-        end
-      end
-
-      def finder_class(default_entity = [], &block)
-        define_finder_class do
-          entity { default_entity }
-
-          class_eval(&block) unless block.nil?
-        end
-      end
-
-      def new_finder(default_entity = [], filter = {}, &block)
-        finder_class(default_entity, &block).new params: filter
-      end
-
-      describe "entity" do
-        def empty_finder_class
-          define_finder_class do
-            filter_by :name do
-            end
-          end
-        end
-
-        it "accepts entity as argument" do
-          expect(finder_class.new(entity: "entity").result).to eq "entity"
-        end
-
-        it "raises an error if no entity is provided" do
-          expect(empty_finder_class.new.errors).to eq [{entity: "Invalid entity specified"}]
-        end
-
-        it "can overwrite the finder entity" do
-          finder_class = define_finder_class do
-            entity { "entity" }
-          end
-
-          expect(finder_class.new(entity: "other entity").result).to eq "other entity"
-        end
-
-        it "passing nil as entity in constructor, falls back to default entity" do
-          finder_class = define_finder_class do
-            entity { "entity" }
-          end
-
-          expect(finder_class.new(entity: nil).result).to eq "entity"
-        end
-      end
-
-      describe "#adapters" do
-        it "checks for a valid adapter and returns an error" do
-          entity = [{id: 1, value: "Test 1"}, {id: 2, value: "Test 2"}, {id: 3, value: "Test 3"}]
-          finder = new_finder entity, value_eq: "Test 1" do
-            adapter :NonExisting
-          end
-
-          expect(finder.errors).to eq [{adapter: "The specified adapter are invalid"}]
-        end
-
-        it "sets the adapter in the config" do
-          entity = [{id: 1, value: "Test 1"}, {id: 2, value: "Test 2"}, {id: 3, value: "Test 3"}]
-          finder = new_finder entity, value_eq: "Test 1" do
-            adapter "ActiveRecord"
-            property :value, type: Base
-          end
-
-          expect(finder.class.config[:adapter]).to eq "ActiveRecord"
-        end
-      end
-
-      describe "#property" do
-        it "checks for a valid property type and returns an error" do
-          entity = [{id: 1, value: "Test 1"}, {id: 2, value: "Test 2"}, {id: 3, value: "Test 3"}]
-          finder = new_finder entity, value_eq: "Test 1" do
-            property :value, type: Base
-          end
-
-          expect(finder.errors).to eq [{properties: "One or more properties are missing a valid type"}]
-        end
-
-        it "sets the property and it's type properly in the config" do
-          entity = [{id: 1, value: "Test 1"}, {id: 2, value: "Test 2"}, {id: 3, value: "Test 3"}]
-          finder = new_finder entity, value_eq: "Test 1" do
-            property :value, type: Base
-          end
-
-          expect(finder.class.config[:properties]).to eq value: {type: Trailblazer::Finder::Base}
-        end
-      end
-
-      describe "#paging" do
-        it "sets the paging values" 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(finder.class.config[:paging][:per_page]).to eq 2
-          expect(finder.class.config[:paging][:min_per_page]).to eq 1
-          expect(finder.class.config[:paging][:max_per_page]).to eq 5
-        end
-
-        it "does not load paging stuff if paging isn't called in the finder class" do
-          entity = [{id: 1, value: "Test 1"}, {id: 2, value: "Test 2"}, {id: 3, value: "Test 3"}]
-          finder = new_finder entity do
-            property :value, type: Types::String
-          end
-
-          expect(finder.class.config[:paging]).to be_empty
-        end
-      end
-
-      describe "#filter_by" do
-        it "returns an error when supplied with a non symbol" do
-          entity = [1, 2, 3]
-          finder = new_finder entity, value_test: "some" do
-            filter_by :value_test, with: "test"
-          end
-
-          expect(finder.result).to eq errors: [{filters: "One or more filters are missing a with method definition"}]
-        end
-
-        it "has a default filter" do
-          entity = [{id: 1, value: "Test 1"}, {id: 2, value: "Test 2"}, {id: 3, value: "Test 3"}]
-          finder = new_finder entity, value: "Test 1" do
-            filter_by :value
-          end
-
-          expect(finder.result.map { |n| n[:value] }).to eq ["Test 1"]
-        end
-
-        it "has a default filter working when it's nested" do
-          entity = [{id: 1, value: [id: 4, value: "Test 1"]}, {id: 2, value: "Test 2"}, {id: 3, value: "Test 3"}]
-          finder = new_finder entity, value: "Test 1" do
-            filter_by :value
-          end
-
-          expect(finder.result.map { |n| n[:value] }).to eq ["Test 1"]
-          expect(finder.result.map { |n| n[:id] }).to eq [4]
-        end
-
-        it "has another default filter" do
-          entity = [{id: 1, value: "Test 1"}, {id: 2, value: "Test 2"}, {id: 3, value: "Test 3"}]
-          finder = new_finder entity, id: 2 do
-            filter_by :id
-          end
-
-          expect(finder.result.map { |n| n[:value] }).to eq ["Test 2"]
-        end
-
-        it "returns the entity if nil is returned" do
-          entity = [1, 2, 3]
-          finder = new_finder entity, value_test: "some" do
-            filter_by :value_test do
-              nil
-            end
-          end
-
-          expect(finder.result).to eq entity
-        end
-
-        it "can use methods from the object" do
-          finder_1 = new_finder [1, 2, 3], filter: 1 do
-            filter_by :filter do |entity, attribute, value|
-              some_instance_method(entity, attribute, value)
-            end
-
-            private
-
-            def some_instance_method(entity, _attribute, _value)
-              entity - [2, 3]
-            end
-          end
-
-          expect(finder_1.result).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, _attribute, value)
-              entity.select { |v| v == value }
-            end
-          end
-
-          expect(finder.result).to eq [1]
-        end
-      end
-    end
-  end
-end

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

@@ -1,26 +0,0 @@
-# frozen_string_literal: true
-
-require "spec_helper"
-
-module Trailblazer
-  class Finder
-    module Utils
-      describe Hash do
-        let(:hash) do
-          [{id: 1, value: "Test 1"}, {id: 2, value: "Test 2"}, {id: 3, value: ""}, {id: 4, value: "Test 4"}]
-        end
-
-        describe ".deep_locate" do
-          it "locates enumerables for which the given comparator returns true for at least one element" do
-            expect(described_class.deep_locate(->(k, v, _) { k == :value && v.to_s == "Test 2" && !v.nil? }, hash))
-              .to eq [{id: 2, value: "Test 2"}]
-          end
-        end
-
-        it "returns an empty array if nothing was found" do
-          expect(described_class.deep_locate(:muff, foo: "bar")).to eq([])
-        end
-      end
-    end
-  end
-end

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

@@ -1,39 +0,0 @@
-# frozen_string_literal: true
-
-require "spec_helper"
-
-module Trailblazer
-  class Finder
-    module Utils
-      describe Splitter do
-        describe ".initialize" do
-          it "sets key and value" do
-            splitter = described_class.new "attribute_eq", "value"
-            expect(splitter.key).to eq "attribute_eq"
-            expect(splitter.value).to eq "value"
-          end
-        end
-
-        describe ".split_key" do
-          it "checks if specified split key exists" do
-            splitter = described_class.new "attribute_eq", "value"
-            expect(splitter.split_key("random")).to eq false
-            expect(splitter.split_key("eq")).to eq true
-          end
-
-          it "fills field value when split key exists" do
-            splitter = described_class.new "attribute_eq", "value"
-            splitter.split_key("eq")
-            expect(splitter.field).to eq "attribute"
-          end
-
-          it "fills predicate value when split key exists" do
-            splitter = described_class.new "attribute_eq", "value"
-            splitter.split_key("eq")
-            expect(splitter.predicate).to eq :eq
-          end
-        end
-      end
-    end
-  end
-end