trailblazer-finder 0.1.4 → 0.2.5

data/spec/trailblazer/finder/dsl_spec.rb

@@ -0,0 +1,213 @@
+# 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
+            adapters :NonExisting
+          end
+
+          expect(finder.errors).to eq [{adapters: "One or more of the specified adapters are invalid"}]
+        end
+
+        it "checks if multiple orm adapters are requested 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
+            adapters :ActiveRecord, :Sequel
+          end
+
+          expect(finder.errors).to eq [{adapters: "More then one ORM adapter specified"}]
+        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
+            adapters ActiveRecord
+            property :value, type: Base
+          end
+
+          expect(finder.class.config[:adapters]).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

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

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

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

@@ -1,22 +1,65 @@
-require 'spec_helper'
+# frozen_string_literal: true
+
+require "spec_helper"
 
 module Trailblazer
   class Finder
     module Utils
       describe String do
-        describe '.camelize' do
-          it "transforms :paging to 'Paging'" do
-            expect(Finder::Utils::String.camelize(:paging)).to eq 'Paging'
+        describe ".blank?" do
+          it "checks if value is blank or nil" do
+            expect(described_class.blank?("")).to eq true
+            expect(described_class.blank?(nil)).to eq true
+            expect(described_class.blank?("what")).to eq false
+            expect(described_class.blank?(1)).to eq false
+          end
+        end
+
+        describe ".numeric?" do
+          it "checks if value is numeric" do
+            expect(described_class.numeric?("")).to eq false
+            expect(described_class.numeric?(nil)).to eq false
+            expect(described_class.numeric?(1)).to eq true
+            expect(described_class.numeric?(0)).to eq true
+            expect(described_class.numeric?(1.00000)).to eq true
+            expect(described_class.numeric?("1")).to eq true
           end
         end
 
-        describe '.underscore' do
-          it "transforms 'veryPopular' to 'very_popular'" do
-            expect(Finder::Utils::String.underscore(:veryPopular)).to eq 'very_popular'
+        describe ".date?" do
+          it "checks if value is a date" do
+            expect(described_class.date?("2018-01-01")).to eq true
+            expect(described_class.date?(nil)).to eq false
+            expect(described_class.date?("random")).to eq false
+            expect(described_class.date?(1)).to eq false
+            expect(described_class.date?("2018/01/01")).to eq true
+            expect(described_class.date?("2018.01.01")).to eq true
+            expect(described_class.date?("21-12-2018")).to eq true
           end
+        end
+
+        describe ".to_date" do
+          it "transforms a date like value to a valid date" do
+            expect(described_class.to_date("28/09/2018")).to eq "2018-09-28"
+            expect(described_class.to_date("2018/09/28")).to eq "2018-09-28"
+            expect(described_class.to_date("28 september 2018")).to eq "2018-09-28"
+            expect(described_class.to_date("third month of this year")).to eq nil
+          end
+        end
+
+        describe ".camelize" do
+          it "transforms a string by capatalizing each word's first letter" do
+            expect(described_class.camelize(:paging)).to eq "Paging"
+            expect(described_class.camelize(:some_random_test)).to eq "SomeRandomTest"
+          end
+        end
 
-          it "transforms 'Very Popular' to 'very_popular'" do
-            expect(Finder::Utils::String.underscore('Very Popular')).to eq 'very_popular'
+        describe ".underscore" do
+          it "transforms a string by dividing words with underscores" do
+            expect(described_class.underscore(:veryPopular)).to eq "very_popular"
+            expect(described_class.underscore(:VeryPopular)).to eq "very_popular"
+            expect(described_class.underscore(:SomethingveryPopularButRandom)).to eq "somethingvery_popular_but_random"
+            expect(described_class.underscore("Very Popular")).to eq "very_popular"
           end
         end
       end

data/spec/trailblazer/operation/finder_spec.rb

@@ -1,32 +1,36 @@
-require 'delegate'
-require 'trailblazer'
-require 'spec_helper_active_record'
+# frozen_string_literal: true
+
+require "delegate"
+require "trailblazer"
+require "spec_helper_active_record"
 
 class Product::FinderNoEntity < Trailblazer::Finder
   adapters ActiveRecord
 
-  filter_by :id
-  filter_by :name
+  property :id, type: Types::Integer
+  property :name, type: Types::String, sortable: true
   filter_by :escaped_name, with: :apply_escaped_name
 
-  def apply_escaped_name(entity_type, value)
+  def apply_escaped_name(entity, _attribute, value)
     return unless value.present?
-    entity_type.where 'lower(name) LIKE ?', Utils::Parse.term(value.downcase)
+
+    entity.where "lower(name) LIKE ?", "%#{value.downcase}%"
   end
 end
 
 class Product::FinderWithEntity < Trailblazer::Finder
   adapters ActiveRecord
 
-  entity_type { Product }
+  entity { Product }
 
-  filter_by :id
-  filter_by :name
+  property :id, type: Types::Integer
+  property :name, type: Types::String, sortable: true
   filter_by :escaped_name, with: :apply_escaped_name
 
-  def apply_escaped_name(entity_type, value)
+  def apply_escaped_name(entity, _attribute, value)
     return unless value.present?
-    entity_type.where 'lower(name) LIKE ?', Utils::Parse.term(value.downcase)
+
+    entity.where "lower(name) LIKE ?", "%#{value.downcase}%"
   end
 end
 
@@ -46,8 +50,7 @@ class Product::ShowNoEntity < Trailblazer::Operation
   step Finder(Product::FinderWithEntity, :single)
 end
 
-
-describe 'Trailblazer::Operation - Finder Macro' do
+describe "Trailblazer::Operation - Finder Macro" do
   before do
     Product.destroy_all
     Product.reset_pk_sequence
@@ -59,45 +62,45 @@ describe 'Trailblazer::Operation - Finder Macro' do
     Product.reset_pk_sequence
   end
 
-  it 'Can find a single row by id' do
-    params = { id: 5 }
+  it "Can find a single row by id" do
+    params = {id: 5}
     result = Product::Show.call(params: params)
 
-    expect(result[:finder].name).to eq 'product_4'
+    expect(result[:finder].name).to eq "product_4"
   end
 
-  it 'Can find a single row by name' do
-    params = { f: { name: 'product_2' } }
+  it "Can find a single row by name" do
+    params = {name_eq: "product_2"}
     result = Product::Show.call(params: params)
 
-    expect(result[:finder].name).to eq 'product_2'
+    expect(result[:finder].name).to eq "product_2"
   end
 
-  it 'Can find multiple rows by escaped name' do
-    params = { f: { escaped_name: 'product_1' } }
+  it "Can find multiple rows by escaped name" do
+    params = {escaped_name: "product_1"}
     result = Product::Index.call(params: params)
 
-    expect(result[:finder].results.last.name).to eq 'product_19'
+    expect(result[:finder].result.last.name).to eq "product_19"
   end
 
-  it 'Can find a single row by id when no entity type is given in macro' do
-    params = { id: 8 }
+  it "Can find a single row by id when no entity type is given in macro" do
+    params = {id: 8}
     result = Product::ShowNoEntity.call(params: params)
 
-    expect(result[:finder].name).to eq 'product_7'
+    expect(result[:finder].name).to eq "product_7"
   end
 
-  it 'Can find a single row by name when no entity type is given in macro' do
-    params = { f: { name: 'product_2' } }
+  it "Can find a single row by name when no entity type is given in macro" do
+    params = {name_eq: "product_2"}
     result = Product::ShowNoEntity.call(params: params)
 
-    expect(result[:finder].name).to eq 'product_2'
+    expect(result[:finder].name).to eq "product_2"
   end
 
-  it 'Can find multiple rows by escaped name when no entity type is given in macro' do
-    params = { f: { escaped_name: 'product_1' } }
+  it "Can find multiple rows by escaped name when no entity type is given in macro" do
+    params = {escaped_name: "product_1"}
     result = Product::IndexNoEntity.call(params: params)
 
-    expect(result[:finder].results.last.name).to eq 'product_19'
+    expect(result[:finder].result.last.name).to eq "product_19"
   end
 end