forest_liana 3.3.0 → 4.0.0.pre.beta.0

data/app/services/forest_liana/pie_stat_getter.rb

@@ -5,22 +5,13 @@ module ForestLiana
     def perform
       if @params[:group_by_field]
         timezone_offset = @params[:timezone].to_i
-        conditions = []
-        filter_operator = ''
+        resource = get_resource().eager_load(@includes)
 
-        if @params[:filterType] && @params[:filters]
-          filter_operator = " #{@params[:filterType]} ".upcase
-
-          @params[:filters].try(:each) do |filter|
-            operator, filter_value = OperatorValueParser.parse(filter[:value])
-            conditions <<  OperatorValueParser.get_condition(filter[:field],
-              operator, filter_value, @resource, @params[:timezone])
-          end
+        if @params[:filters]
+          resource = FiltersParser.new(@params[:filters], resource, @params[:timezone]).apply_filters
         end
 
-        result = get_resource()
-          .eager_load(@includes)
-          .where(conditions.join(filter_operator))
+        result = resource
           .group(group_by_field)
           .order(order)
           .send(@params[:aggregate].downcase, @params[:aggregate_field])

data/app/services/forest_liana/search_query_builder.rb

@@ -17,8 +17,10 @@ module ForestLiana
       @tables_associated_to_relations_name =
         ForestLiana::QueryHelper.get_tables_associated_to_relations_name(@resource)
       @records = search_param
-      @records = has_many_filter
-      @records = belongs_to_and_params_filter
+
+      if @params[:filters]
+        @records = FiltersParser.new(@params[:filters], @records, @params[:timezone]).apply_filters
+      end
 
       if @search
         ForestLiana.schema_for_resource(@resource).fields.each do |field|
@@ -36,11 +38,6 @@ module ForestLiana
       @records
     end
 
-    def belongs_to_and_params_filter
-      conditions = filter_param + belongs_to_filter
-      @records.where(conditions.join(" #{@params[:filterType]} ".upcase))
-    end
-
     def format_column_name(table_name, column_name)
       ForestLiana::AdapterHelper.format_column_name(table_name, column_name)
     end
@@ -154,127 +151,11 @@ module ForestLiana
       "LOWER(#{column_name}) LIKE :search_value_for_string"
     end
 
-    def filter_param
-      conditions = []
-
-      if @params[:filterType] && @params[:filter]
-
-        @params[:filter].each do |field, values|
-          # ActsAsTaggable
-          if acts_as_taggable?(field)
-            tagged_records = @records.tagged_with(values.tr('*', ''))
-
-            if @params[:filterType] == 'and'
-              @records = tagged_records
-            elsif @params[:filterType] == 'or'
-              conditions << acts_as_taggable_query(tagged_records)
-            end
-          else
-            next if association?(field)
-
-            values.split(',').each do |value|
-              operator, value = OperatorValueParser.parse(value)
-              conditions << OperatorValueParser.get_condition(field, operator,
-                value, @resource, @params[:timezone])
-            end
-          end
-        end
-      end
-
-      conditions
-    end
-
-    def association?(field)
-      field = field.split(':').first if field.include?(':')
-      @resource.reflect_on_association(field.to_sym).present?
-    end
-
-    def has_many_association?(field)
-      field = field.split(':').first if field.include?(':')
-      association = @resource.reflect_on_association(field.to_sym)
-
-      [:has_many, :has_and_belongs_to_many].include?(association.try(:macro))
-    end
-
     def acts_as_taggable?(field)
       @resource.try(:taggable?) && @resource.respond_to?(:acts_as_taggable) &&
         @resource.acts_as_taggable.include?(field)
     end
 
-    def has_many_filter
-      if @params[:filter]
-        @params[:filter].each do |field, values|
-          next if !has_many_association?(field) || acts_as_taggable?(field)
-
-          values.split(',').each do |value|
-            if field.include?(':')
-              @records = has_many_subfield_filter(field, value)
-            else
-              @records = has_many_field_filter(field, value)
-            end
-          end
-        end
-      end
-
-      @records
-    end
-
-    def has_many_field_filter(field, value)
-      association = @resource.reflect_on_association(field.to_sym)
-      return if association.blank?
-
-      operator, value = OperatorValueParser.parse(value)
-
-      @records = @records
-        .select("#{@resource.table_name}.*,
-                COUNT(#{association.table_name}.id)
-                #{association.table_name}_has_many_count")
-        .joins(ArelHelpers.join_association(@resource, association.name,
-          Arel::Nodes::OuterJoin))
-        .group("#{@resource.table_name}.id")
-        .having("COUNT(#{association.table_name}) #{operator} #{value}")
-    end
-
-    def has_many_subfield_filter(field, value)
-      field, subfield = field.split(':')
-
-      association = @resource.reflect_on_association(field.to_sym)
-      return if association.blank?
-
-      operator, value = OperatorValueParser.parse(value)
-
-      @records = @records
-        .select("#{@resource.table_name}.*,
-                COUNT(#{association.table_name}.id)
-                #{association.table_name}_has_many_count")
-        .joins(ArelHelpers.join_association(@resource, association.name,
-          Arel::Nodes::OuterJoin))
-        .group("#{@resource.table_name}.id, #{association.table_name}.#{subfield}")
-        .having("#{association.table_name}.#{subfield} #{operator} '#{value}'")
-    end
-
-    def belongs_to_association?(field)
-      field = field.split(':').first if field.include?(':')
-      association = @resource.reflect_on_association(field.to_sym)
-      [:belongs_to, :has_one].include?(association.try(:macro))
-    end
-
-    def belongs_to_filter
-      conditions = []
-
-      if @params[:filter]
-        @params[:filter].each do |field, values|
-          next unless belongs_to_association?(field)
-
-          values.split(',').each do |value|
-            conditions << OperatorValueParser.get_has_one_condition(@resource, field, value, @params[:timezone])
-          end
-        end
-      end
-
-      conditions
-    end
-
     private
 
     def text_type?(type_sym)

data/app/services/forest_liana/value_stat_getter.rb

@@ -4,49 +4,21 @@ module ForestLiana
 
     def perform
       return if @params[:aggregate].blank?
-      valueCurrent = get_resource().eager_load(@includes)
-      valuePrevious = get_resource().eager_load(@includes)
-      filter_date_interval = false
+      resource = get_resource().eager_load(@includes)
 
-      if @params[:filterType] && @params[:filters]
-        conditions = []
-        filter_operator = " #{@params[:filterType]} ".upcase
+      if @params[:filters]
+        filter_parser = FiltersParser.new(@params[:filters], resource, @params[:timezone])
+        resource = filter_parser.apply_filters
+        raw_previous_interval = filter_parser.get_previous_interval_condition
 
-        @params[:filters].try(:each) do |filter|
-          operator, filter_value = OperatorValueParser.parse(filter[:value])
-          conditions << OperatorValueParser.get_condition(filter[:field],
-            operator, filter_value, @resource, @params[:timezone])
-        end
-
-        valueCurrent = valueCurrent.where(conditions.join(filter_operator))
-
-        # NOTICE: Search for previous interval value only if the filterType is
-        #         'AND', it would not be pertinent for a 'OR' filterType.
-        if @params[:filterType] == 'and'
-          conditions = []
-          @params[:filters].try(:each) do |filter|
-            operator, filter_value = OperatorValueParser.parse(filter[:value])
-            operator_date_interval_parser = OperatorDateIntervalParser
-              .new(filter_value, @params[:timezone])
-            if operator_date_interval_parser.has_previous_interval()
-              field_name = OperatorValueParser.get_field_name(filter[:field], @resource)
-              filter = operator_date_interval_parser
-                .get_interval_date_filter_for_previous_interval()
-              conditions << "#{field_name} #{filter}"
-              filter_date_interval = true
-            else
-              conditions << OperatorValueParser.get_condition(filter[:field],
-                operator, filter_value, @resource, @params[:timezone])
-            end
-          end
-
-          valuePrevious = valuePrevious.where(conditions.join(filter_operator))
+        if raw_previous_interval
+          previous_value = filter_parser.apply_filters_on_previous_interval(raw_previous_interval)
         end
       end
 
       @record = Model::Stat.new(value: {
-        countCurrent: count(valueCurrent),
-        countPrevious: filter_date_interval ? count(valuePrevious) : nil
+        countCurrent: count(resource),
+        countPrevious: previous_value ? count(previous_value) : nil
       })
     end
 
@@ -62,8 +34,7 @@ module ForestLiana
         end
         value.send(@params[:aggregate].downcase, aggregate_field)
       else
-        value.send(@params[:aggregate].downcase, aggregate_field,
-                   distinct: uniq)
+        value.send(@params[:aggregate].downcase, aggregate_field, distinct: uniq)
       end
     end
 

data/lib/forest_liana.rb

@@ -37,19 +37,9 @@ module ForestLiana
   self.names_overriden = {}
   self.meta = {}
 
-  @config_dir = 'lib/forest_liana/**/*.rb'
-
   # TODO: Remove once lianas prior to 2.0.0 are not supported anymore.
   self.names_old_overriden = {}
 
-  def self.config_dir=(config_dir)
-    @config_dir = config_dir
-  end
-
-  def self.config_dir
-    Rails.root.join(@config_dir)
-  end
-
   def self.schema_for_resource resource
     self.apimap.find do |collection|
       SchemaUtils.find_model_from_collection_name(collection.name)

data/lib/forest_liana/bootstraper.rb

@@ -211,7 +211,8 @@ module ForestLiana
     end
 
     def require_lib_forest_liana
-      Dir.glob(ForestLiana.config_dir).each do |file|
+      path = Rails.root.join('lib', 'forest_liana', '**', '*.rb')
+      Dir.glob(File.expand_path(path, __FILE__)).each do |file|
         load file
       end
     end

data/lib/forest_liana/version.rb

@@ -1,3 +1,3 @@
 module ForestLiana
-  VERSION = "3.3.0"
+  VERSION = "4.0.0-beta.0"
 end

data/spec/dummy/app/models/user.rb

@@ -1,4 +1,6 @@
 class User < ActiveRecord::Base
   has_many :trees_owned, class_name: 'Tree', inverse_of: :owner
   has_many :trees_cut, class_name: 'Tree', inverse_of: :cutter
+
+  enum title: [ :king, :villager, :outlaw ]
 end

data/spec/dummy/db/migrate/20190716130830_add_age_to_tree.rb

@@ -0,0 +1,5 @@
+class AddAgeToTree < ActiveRecord::Migration
+  def up
+    add_column :trees, :age, :integer
+  end
+end

data/spec/dummy/db/migrate/20190716135241_add_type_to_user.rb

@@ -0,0 +1,5 @@
+class AddTypeToUser < ActiveRecord::Migration
+  def up
+    add_column :users, :title, :integer
+  end
+end

data/spec/dummy/db/schema.rb

@@ -11,7 +11,7 @@
 #
 # It's strongly recommended that you check this file into your version control system.
 
-ActiveRecord::Schema.define(version: 20190226174951) do
+ActiveRecord::Schema.define(version: 20190716135241) do
 
   create_table "isle", force: :cascade do |t|
     t.string   "name"
@@ -27,6 +27,7 @@ ActiveRecord::Schema.define(version: 20190226174951) do
     t.integer  "island_id"
     t.datetime "created_at"
     t.datetime "updated_at"
+    t.integer  "age"
   end
 
   add_index "trees", ["cutter_id"], name: "index_trees_on_cutter_id"
@@ -37,6 +38,7 @@ ActiveRecord::Schema.define(version: 20190226174951) do
     t.string   "name"
     t.datetime "created_at"
     t.datetime "updated_at"
+    t.integer  "title"
   end
 
 end

data/spec/requests/resources_spec.rb

@@ -19,10 +19,20 @@ describe 'Requesting Tree resources', :type => :request  do
     allow_any_instance_of(ForestLiana::PermissionsChecker).to receive(:is_authorized?) { true }
   end
 
+  token = JWT.encode({
+    id: 38,
+    email: 'michael.kelso@that70.show',
+    first_name: 'Michael',
+    last_name: 'Kelso',
+    team: 'Operations',
+    rendering_id: 16,
+    exp: Time.now.to_i + 2.weeks.to_i
+  }, ForestLiana.auth_secret, 'HS256')
+
   headers = {
     'Accept' => 'application/json',
     'Content-Type' => 'application/json',
-    'Authorization' => 'Bearer eyJhbGciOiJIUzI1NiJ9.eyJleHAiOiIxODQ5ODc4ODYzIiwiZGF0YSI6eyJpZCI6IjM4IiwidHlwZSI6InVzZXJzIiwiZGF0YSI6eyJlbWFpbCI6Im1pY2hhZWwua2Vsc29AdGhhdDcwLnNob3ciLCJmaXJzdF9uYW1lIjoiTWljaGFlbCIsImxhc3RfbmFtZSI6IktlbHNvIiwidGVhbXMiOiJPcGVyYXRpb25zIn0sInJlbGF0aW9uc2hpcHMiOnsicmVuZGVyaW5ncyI6eyJkYXRhIjpbeyJ0eXBlIjoicmVuZGVyaW5ncyIsImlkIjoxNn1dfX19fQ.U4Mxi0tq0Ce7y5FRXP47McNPRPhUx37LznQ5E3mJIp4'
+    'Authorization' => "Bearer #{token}"
   }
 
   describe 'index' do
@@ -62,8 +72,10 @@ describe 'Requesting Tree resources', :type => :request  do
     describe 'with a filter on an association that is not a displayed column' do
       params = {
         fields: { 'Tree' => 'id,name' },
-        filterType: 'and',
-        filter: { 'owner:id' => '$present' },
+        filters: JSON.generate({
+          field: 'owner:id',
+          operator: 'present'
+        }),
         page: { 'number' => '1', 'size' => '10' },
         searchExtended: '0',
         sort: '-id',

data/spec/services/forest_liana/filters_parser_spec.rb

@@ -0,0 +1,476 @@
+module ForestLiana
+  describe FiltersParser do
+    let(:timezone) { 'Europe/Paris' }
+    let(:resource) { Tree }
+    let(:filters) { {} }
+    let(:filter_parser) { described_class.new(filters.to_json, resource, timezone) }
+    let(:simple_condition_1) { { 'field' => 'name', 'operator' => 'contains', 'value' => 'Tree' } }
+    let(:simple_condition_2) { { 'field' => 'name', 'operator' => 'ends_with', 'value' => '3' } }
+    let(:simple_condition_3) { { 'field' => 'age', 'operator' => 'greater_than', 'value' => 2 } }
+    let(:belongs_to_condition) { { 'field' => 'trees:age', 'operator' => 'less_than', 'value' => 3 } }
+    let(:date_condition_1) { { 'field' => 'created_at', 'operator' => 'before', 'value' => 2.hours.ago } }
+    let(:date_condition_2) { { 'field' => 'created_at', 'operator' => 'today' } }
+    let(:date_condition_3) { { 'field' => 'created_at', 'operator' => 'previous_x_days', 'value' => 2 } }
+
+    before {
+      island = Island.create!(name: "L'île de la muerta")
+      king = User.create!(title: :king, name: 'Ben E.')
+      villager = User.create!(title: :villager)
+      Tree.create!(name: 'Tree n1', age: 1, island: island, owner: king)
+      Tree.create!(name: 'Tree n2', age: 3, island: island, created_at: 3.day.ago, owner: king)
+      Tree.create!(name: 'Tree n3', age: 4, island: island, owner: king, cutter: villager)
+    }
+
+    after {
+      Tree.destroy_all
+      User.destroy_all
+      Island.destroy_all
+    }
+
+    describe 'initialization' do
+      context 'badly formated filters' do
+        let(:filter_parser) { described_class.new('{ toto: 1', resource, timezone) }
+
+        it {
+          expect {
+            described_class.new('{ toto: 1', resource, timezone)
+          }.to raise_error(ForestLiana::Errors::HTTP422Error, 'Invalid filters JSON format')
+        }
+      end
+    end
+
+    describe 'apply_filters' do
+      let(:parsed_filters) { filter_parser.apply_filters }
+
+      context 'on valid filters' do
+        context 'single condtions' do
+          context 'not_equal' do
+            let(:filters) { { field: 'age', operator: 'not_equal', value: 4 } }
+            it { expect(parsed_filters.count).to eq 2 }
+          end
+
+          context 'equal' do
+            let(:filters) { { field: 'age', operator: 'equal', value: 4 } }
+            it { expect(parsed_filters.count).to eq 1 }
+          end
+
+          context 'greater_than' do
+            let(:filters) { { field: 'age', operator: 'greater_than', value: 2 } }
+            it { expect(parsed_filters.count).to eq 2 }
+          end
+
+          context 'less_than' do
+            let(:filters) { { field: 'age', operator: 'less_than', value: 2 } }
+            it { expect(parsed_filters.count).to eq 1 }
+          end
+
+          context 'after' do
+            let(:filters) { { field: 'created_at', operator: 'after', value: 1.day.ago } }
+            it { expect(parsed_filters.count).to eq 2 }
+          end
+
+          context 'before' do
+            let(:filters) { { field: 'created_at', operator: 'before', value: 1.day.ago } }
+            it { expect(parsed_filters.count).to eq 1 }
+          end
+
+          context 'contains' do
+            let(:filters) { { field: 'name', operator: 'contains', value: 'ree' } }
+            it { expect(parsed_filters.count).to eq 3 }
+          end
+
+          context 'not_contains' do
+            let(:filters) { { field: 'name', operator: 'not_contains', value: ' ' } }
+            it { expect(parsed_filters.count).to eq 0 }
+          end
+
+          context 'starts_with' do
+            let(:filters) { { field: 'name', operator: 'starts_with', value: 'o' } }
+            it { expect(parsed_filters.count).to eq 0 }
+          end
+
+          context 'ends_with' do
+            let(:filters) { { field: 'name', operator: 'ends_with', value: '3' } }
+            it { expect(parsed_filters.count).to eq 1 }
+          end
+
+          context 'present' do
+            let(:filters) { { field: 'cutter_id', operator: 'present', value: nil } }
+            it { expect(parsed_filters.count).to eq 1 }
+          end
+
+          context 'blank' do
+            let(:filters) { { field: 'cutter_id', operator: 'blank', value: nil } }
+            it { expect(parsed_filters.count).to eq 2 }
+          end
+        end
+
+        context 'belongsTo conditions' do
+          context 'not_equal' do
+            let(:filters) { { field: 'cutter:title', operator: 'not_equal', value: 'king' } }
+            it { expect(parsed_filters.count).to eq 1 }
+          end
+
+          context 'equal' do
+            let(:filters) { { field: 'cutter:title', operator: 'equal', value: 'king' } }
+            it { expect(parsed_filters.count).to eq 0 }
+          end
+
+          context 'contains' do
+            let(:filters) { { field: 'owner:title', operator: 'contains', value: 'in' } }
+            it { expect(parsed_filters.count).to eq 3 }
+          end
+
+          context 'not_contains' do
+            let(:filters) { { field: 'owner:title', operator: 'not_contains', value: 'g' } }
+            it { expect(parsed_filters.count).to eq 0 }
+          end
+
+          context 'starts_with' do
+            let(:filters) { { field: 'cutter:title', operator: 'starts_with', value: 'v' } }
+            it { expect(parsed_filters.count).to eq 1 }
+          end
+
+          context 'two belongsTo' do
+            context 'different fields' do
+              let(:filters) {
+                {
+                  aggregator: 'or', conditions: [
+                    { field: 'owner:name', operator: 'contains', value: 'E.' },
+                    { field: 'cutter:title', operator: 'starts_with', value: 'v' }
+                  ]
+                }
+              }
+              it { expect(parsed_filters.count).to eq 3 }
+            end
+
+            context 'same fields' do
+              let(:filters) {
+                {
+                  aggregator: 'and', conditions: [
+                    { field: 'owner:name', operator: 'contains', value: 'E.' },
+                    { field: 'owner:title', operator: 'starts_with', value: 'v' }
+                  ]
+                }
+              }
+              it { expect(parsed_filters.count).to eq 3 }
+            end
+          end
+        end
+
+        context 'and aggregator on simple conditions' do
+          let(:filters) { { aggregator: 'and', conditions: [simple_condition_1, simple_condition_2] } }
+          it { expect(parsed_filters.count).to eq 1 }
+        end
+
+
+        context 'complex conditions' do
+          context 'and aggregator on simple conditions' do
+            let(:filters) {
+              {
+                aggregator: 'or',
+                conditions: [
+                  {
+                    aggregator: 'and', conditions: [
+                      { aggregator: 'or', conditions: [date_condition_1, simple_condition_1] },
+                      simple_condition_2
+                    ]
+                  },
+                  { field: 'cutter:title', operator: 'starts_with', value: 'v' }
+                ]
+              }
+            }
+            it { expect(parsed_filters.count).to eq 1 }
+          end
+        end
+      end
+
+      context 'on invalid filters' do
+        context 'invalid condition format' do
+          let(:filters) { { toto: 'Why nut?' } }
+          it {
+            expect { parsed_filters }.to raise_error(ForestLiana::Errors::HTTP422Error, 'Invalid condition format')
+          }
+        end
+
+        context 'array as filter' do
+          let(:filters) { [] }
+          it {
+            expect { parsed_filters }.to raise_error(ForestLiana::Errors::HTTP422Error, 'Filters cannot be a raw value')
+          }
+        end
+
+        context 'empty filter' do
+          let(:filters) { { } }
+          it {
+            expect { parsed_filters }.to raise_error(ForestLiana::Errors::HTTP422Error, 'Empty condition in filter')
+          }
+        end
+
+        context 'raw value in conditions' do
+          let(:filters) { { aggregator: 'and', conditions: [4] } }
+          it {
+            expect { parsed_filters }.to raise_error(ForestLiana::Errors::HTTP422Error, 'Filters cannot be a raw value')
+          }
+        end
+
+        context 'bad field type' do
+          let(:filters) { { field: 4, operator: 'oss 117', value: 'tuorp' } }
+          it {
+            expect { parsed_filters }.to raise_error(ForestLiana::Errors::HTTP422Error, 'Invalid condition format')
+          }
+        end
+
+        context 'bad operator type' do
+          let(:filters) { { field: 'magnetic', operator: true, value: 'tuorp' } }
+          it {
+            expect { parsed_filters }.to raise_error(ForestLiana::Errors::HTTP422Error, 'Invalid condition format')
+          }
+        end
+
+        context 'unexisting field' do
+          let(:filters) { { field: 'magnetic', operator: 'archer', value: 'tuorp' } }
+          it {
+            expect { parsed_filters }.to raise_error(ForestLiana::Errors::HTTP422Error, 'Field \'magnetic\' not found')
+          }
+        end
+      end
+    end
+
+    describe 'parse_aggregation' do
+      let(:query) { filter_parser.parse_aggregation(filters) }
+
+      context 'when no aggregator' do
+        let(:filters) { simple_condition_1 }
+        it { expect(resource.where(query).count).to eq 3 }
+      end
+
+      context "'name contains \"Tree\"' 'and' 'name ends_with \"3\"'" do
+        let(:filters) { { 'aggregator' => 'and', 'conditions' => [simple_condition_1, simple_condition_2] } }
+        it { expect(resource.where(query).count).to eq 1 }
+      end
+
+      context "'name contains \"Tree\"' 'and' 'age greater_than 2'" do
+        let(:filters) { { 'aggregator' => 'and', 'conditions' => [simple_condition_1, simple_condition_3] } }
+        it { expect(resource.where(query).count).to eq 2 }
+      end
+
+      context "'name ends_with \"3\"' 'and' 'age greater_than 2'" do
+        let(:filters) { { 'aggregator' => 'and', 'conditions' => [simple_condition_2, simple_condition_3] } }
+        it { expect(resource.where(query).count).to eq 1 }
+      end
+
+      context "'name contains \"Tree\"' 'or' 'name ends_with \"3\"'" do
+        let(:filters) { { 'aggregator' => 'or', 'conditions' => [simple_condition_1, simple_condition_2] } }
+        it { expect(resource.where(query).count).to eq 3 }
+      end
+
+      context "'name contains \"Tree\"' 'or' 'age greater_than 2'" do
+        let(:filters) { { 'aggregator' => 'or', 'conditions' => [simple_condition_1, simple_condition_3] } }
+        it { expect(resource.where(query).count).to eq 3 }
+      end
+
+      context "'name ends_with \"3\"' 'or' 'age greater_than 2'" do
+        let(:filters) { { 'aggregator' => 'or', 'conditions' => [simple_condition_2, simple_condition_3] } }
+        it { expect(resource.where(query).count).to eq 2 }
+      end
+    end
+
+    describe 'parse_condition' do
+      let(:condition) { simple_condition_2 }
+      let(:result) { filter_parser.parse_condition(condition) }
+
+      context 'on valid condition' do
+        it { expect(result).to eq "\"trees\".\"name\" LIKE '%3'" }
+      end
+
+      context 'on belongs_to condition' do
+        let(:resource) { Island }
+        context 'valid association' do
+          let(:condition) { belongs_to_condition }
+          it { expect(resource.joins(:trees).where(result).count).to eq 1 }
+        end
+
+        context 'wrong association' do
+          let(:condition) { { 'field' => 'rosters:id', 'operator' => 'less_than', 'value' => 3 } }
+          it {
+            expect {
+              filter_parser.parse_condition(condition)
+            }.to raise_error(ForestLiana::Errors::HTTP422Error, "Association 'rosters' not found")
+          }
+        end
+      end
+
+      context 'on time based condition' do
+        let(:condition) { date_condition_1 }
+        it { expect(resource.where(result).count).to eq 1 }
+      end
+
+      context 'on enum condition field type' do
+        let(:resource) { User }
+        let(:condition) { { 'field' => 'title', 'operator' => 'equal', 'value' => 'king' } }
+        it { expect(resource.where(result).count).to eq 1 }
+      end
+    end
+
+    describe 'parse_aggregation_operator' do
+      context 'on valid aggregator' do
+        it { expect(filter_parser.parse_aggregation_operator('and')).to eq 'AND' }
+        it { expect(filter_parser.parse_aggregation_operator('or')).to eq 'OR' }
+      end
+
+      context 'on unknown aggregator' do
+        it {
+          expect {
+            filter_parser.parse_aggregation_operator('sfr')
+          }.to raise_error(ForestLiana::Errors::HTTP422Error, "Unknown provided operator 'sfr'")
+        }
+      end
+    end
+
+    describe 'parse_operator' do
+      context 'on valid operators' do
+        it { expect(filter_parser.parse_operator 'not').to eq 'NOT' }
+        it { expect(filter_parser.parse_operator 'greater_than').to eq '>' }
+        it { expect(filter_parser.parse_operator 'after').to eq '>' }
+        it { expect(filter_parser.parse_operator 'less_than').to eq '<' }
+        it { expect(filter_parser.parse_operator 'before').to eq '<' }
+        it { expect(filter_parser.parse_operator 'contains').to eq 'LIKE' }
+        it { expect(filter_parser.parse_operator 'starts_with').to eq 'LIKE' }
+        it { expect(filter_parser.parse_operator 'ends_with').to eq 'LIKE' }
+        it { expect(filter_parser.parse_operator 'not_contains').to eq 'NOT LIKE' }
+        it { expect(filter_parser.parse_operator 'not_equal').to eq '!=' }
+        it { expect(filter_parser.parse_operator 'present').to eq 'IS NOT' }
+        it { expect(filter_parser.parse_operator 'equal').to eq '=' }
+        it { expect(filter_parser.parse_operator 'blank').to eq 'IS' }
+      end
+
+      context 'on unknown operator' do
+        it {
+          expect {
+            filter_parser.parse_operator('orange')
+          }.to raise_error(ForestLiana::Errors::HTTP422Error, "Unknown provided operator 'orange'")
+        }
+      end
+    end
+
+    describe 'parse_value' do
+      context 'on valid operator' do
+        let(:now) { Time.now }
+        it { expect(filter_parser.parse_value('not', true)).to eq true }
+        it { expect(filter_parser.parse_value('greater_than', 34)).to eq 34 }
+        it { expect(filter_parser.parse_value('after', now)).to eq now }
+        it { expect(filter_parser.parse_value('less_than', 45)).to eq 45 }
+        it { expect(filter_parser.parse_value('before', now)).to eq now }
+        it { expect(filter_parser.parse_value('contains', 'toto')).to eq '%toto%'}
+        it { expect(filter_parser.parse_value('starts_with', 'a')).to eq 'a%'}
+        it { expect(filter_parser.parse_value('ends_with', 'b')).to eq '%b' }
+        it { expect(filter_parser.parse_value('not_contains', 'o')).to eq '%o%'}
+        it { expect(filter_parser.parse_value('not_equal', 'test')).to eq 'test' }
+        it { expect(filter_parser.parse_value('present', nil)).to eq nil }
+        it { expect(filter_parser.parse_value('equal', 'yes')).to eq 'yes' }
+        it { expect(filter_parser.parse_value('blank', nil)).to eq nil }
+      end
+
+      context 'on unknown operator' do
+        it {
+          expect {
+            filter_parser.parse_value('bouygues', 76)
+          }.to raise_error(ForestLiana::Errors::HTTP422Error, "Unknown provided operator 'bouygues'")
+        }
+      end
+    end
+
+    describe 'parse_field_name' do
+      let(:resource) { Island }
+      let(:result) { filter_parser.parse_field_name(field_name) }
+
+      context 'on basic field' do
+        context 'existing field' do
+          let(:field_name) { 'name' }
+          it { expect(result).to eq "\"isle\".\"name\""}
+        end
+
+        context 'not existing field' do
+          let(:field_name) { 'gender' }
+          it {
+            expect { result }
+              .to raise_error(ForestLiana::Errors::HTTP422Error, "Field '#{field_name}' not found")
+          }
+        end
+      end
+
+      context 'on belongs to field' do
+        context 'existing field' do
+          let(:field_name) { 'trees:age' }
+          it { expect(result).to eq "\"trees\".\"age\""}
+        end
+        context 'not existing field' do
+          let(:field_name) { 'hero:age' }
+          it {
+            expect { result }
+              .to raise_error(ForestLiana::Errors::HTTP422Error, "Field '#{field_name}' not found")
+          }
+        end
+        context 'not existing sub field' do
+          let(:field_name) { 'trees:super_power' }
+          it {
+            expect { result }
+              .to raise_error(ForestLiana::Errors::HTTP422Error, "Field '#{field_name}' not found")
+          }
+        end
+      end
+    end
+
+    describe 'get_previous_interval_condition' do
+      let(:result) { filter_parser.get_previous_interval_condition }
+
+      context 'flat condition at root' do
+        context 'has previous interval' do
+          let(:filters) { date_condition_2 }
+          it { expect(result).to eq date_condition_2 }
+        end
+
+        context 'has no previous interval' do
+          let(:filters) { simple_condition_1 }
+          it { expect(result).to eq nil }
+        end
+      end
+
+      context "has 'and' aggregator" do
+        let(:filters) { { 'aggregator' => 'and', 'conditions' => conditions } }
+
+        context 'has no interval conditions' do
+          let(:conditions) { [simple_condition_2, simple_condition_3] }
+          it { expect(result).to eq nil }
+        end
+
+        context 'has nested conditions' do
+          let(:conditions) { [date_condition_2, { 'aggregator' => 'and', 'conditions' => [simple_condition_2, simple_condition_3] }] }
+          it { expect(result).to eq nil }
+        end
+
+        context 'has more than one interval condition' do
+          let(:conditions) { [date_condition_2, date_condition_3] }
+          it { expect(result).to eq nil }
+        end
+
+        context 'has only one interval condition' do
+          let(:conditions) { [date_condition_2, simple_condition_1] }
+          it { expect(result).to eq date_condition_2 }
+        end
+      end
+
+      context "has 'or' aggregator" do
+        let(:filters) { { 'aggregator' => 'or', 'conditions' => [date_condition_2, simple_condition_2] } }
+        it { expect(result).to eq nil }
+      end
+    end
+
+    describe 'apply_filters_on_previous_interval' do
+      let(:filters) { { 'aggregator' => 'and', 'conditions' => [date_condition_3, simple_condition_1] } }
+
+      it { expect(filter_parser.apply_filters_on_previous_interval(date_condition_3).count).to eq 1 }
+    end
+  end
+end