forest_liana 7.0.0.beta.4 → 7.0.0.beta.5

data/app/services/forest_liana/scope_validator.rb

@@ -1,98 +0,0 @@
-module ForestLiana
-  class ScopeValidator
-    def initialize(scope_permissions, users_variable_values)
-      @scope_filters = scope_permissions
-      @users_variable_values = users_variable_values
-    end
-
-    def is_scope_in_request?(scope_request)
-      begin
-        filters = JSON.parse(scope_request[:filters])
-      rescue JSON::ParserError
-        raise ForestLiana::Errors::HTTP422Error.new('Invalid filters JSON format')
-      end
-      @computed_scope = compute_condition_filters_from_scope(scope_request[:user_id])
-
-      # NOTICE: Perfom a travel in the request condition filters tree to find the scope
-      tagged_scope_filters = get_scope_found_in_request(filters)
-
-      # NOTICE: Permission system always send an aggregator even if there is only one condition
-      #         In that case, if the condition is valid, then request was not edited
-      return !tagged_scope_filters.nil? if @scope_filters['conditions'].length == 1
-
-      # NOTICE: If there is more than one condition, do a final validation on the condition filters
-      return tagged_scope_filters != nil &&
-        tagged_scope_filters[:aggregator] == @scope_filters['aggregator'] &&
-        tagged_scope_filters[:conditions] &&
-        tagged_scope_filters[:conditions].length == @scope_filters['conditions'].length
-    end
-
-    private
-
-    def compute_condition_filters_from_scope(user_id)
-      computed_condition_filters = @scope_filters.clone
-      computed_condition_filters['conditions'].each do |condition|
-        if condition.include?('value') &&
-          !condition['value'].nil? &&
-          condition['value'].instance_of?(String) &&
-          condition['value'].start_with?('$') &&
-          @users_variable_values.include?(user_id)
-          condition['value'] = @users_variable_values[user_id][condition['value']]
-        end
-      end
-      return computed_condition_filters
-    end
-
-    def get_scope_found_in_request(filters)
-      return nil unless filters
-      return search_scope_aggregation(filters)
-    end
-
-    def search_scope_aggregation(node)
-      ensure_valid_aggregation(node)
-
-      return is_scope_condition?(node) unless node['aggregator']
-
-      # NOTICE: Remove conditions that are not from the scope
-      filtered_conditions = node['conditions'].map { |condition|
-        search_scope_aggregation(condition)
-      }.select { |condition|
-        condition
-      }
-
-      # NOTICE: If there is only one condition filter left and its current aggregator is
-      #         an "and", this condition filter is the searched scope
-      if (filtered_conditions.length == 1 &&
-        filtered_conditions.first.is_a?(Hash) &&
-        filtered_conditions.first.include?(:aggregator) &&
-        node['aggregator'] == 'and')
-        return filtered_conditions.first
-      end
-
-      # NOTICE: Otherwise, validate if the current node is the scope and return nil
-      #         if it's not
-      return (filtered_conditions.length == @scope_filters['conditions'].length &&
-        node['aggregator'] == @scope_filters['aggregator']) ?
-        { aggregator: node['aggregator'], conditions: filtered_conditions } :
-        nil
-    end
-
-    def is_scope_condition?(condition)
-      ensure_valid_condition(condition)
-      return @computed_scope['conditions'].include?(condition)
-    end
-
-    def ensure_valid_aggregation(node)
-      raise ForestLiana::Errors::HTTP422Error.new('Filters cannot be a raw value') unless node.is_a?(Hash)
-      raise_empty_condition_in_filter_error if node.empty?
-    end
-
-    def ensure_valid_condition(condition)
-      raise_empty_condition_in_filter_error if condition.empty?
-      raise ForestLiana::Errors::HTTP422Error.new('Condition cannot be a raw value') unless condition.is_a?(Hash)
-      unless condition['field'].is_a?(String) and condition['operator'].is_a?(String)
-        raise ForestLiana::Errors::HTTP422Error.new('Invalid condition format')
-      end
-    end
-  end
-end

data/test/services/forest_liana/has_many_getter_test.rb

@@ -1,75 +0,0 @@
-module ForestLiana
-  class HasManyGetterTest < ActiveSupport::TestCase
-
-    collectionOwner = ForestLiana::Model::Collection.new({
-      name: 'Owner',
-      fields: []
-    })
-
-    collectionTree = ForestLiana::Model::Collection.new({
-      name: 'Tree',
-      fields: []
-    })
-
-    ForestLiana.apimap << collectionOwner
-    ForestLiana.apimap << collectionTree
-    ForestLiana.models << Owner
-    ForestLiana.models << Tree
-
-    test 'HasMany Getter page 1 size 15' do
-      association = Owner.reflect_on_association(:trees)
-
-      getter = HasManyGetter.new(Owner, association, {
-        id: 1,
-        association_name: 'trees',
-        page: { size: 15, number: 1 },
-        timezone: 'America/Nome'
-      })
-      getter.perform
-      records = getter.records
-      count = getter.count
-
-      assert records.count == 3
-      assert count = 3
-      assert records.first.id == 7
-    end
-
-    test 'HasMany Getter with sort parameter' do
-      association = Owner.reflect_on_association(:trees)
-
-      getter = HasManyGetter.new(Owner, association, {
-        id: 1,
-        association_name: 'trees',
-        sort: '-id',
-        page: { size: 15, number: 1 },
-        timezone: 'America/Nome'
-      })
-      getter.perform
-      records = getter.records
-      count = getter.count
-
-      assert records.count == 3
-      assert count = 3
-      assert records.first.id == 8
-    end
-
-    test 'HasMany Getter with search parameter' do
-      association = Owner.reflect_on_association(:trees)
-
-      getter = HasManyGetter.new(Owner, association, {
-        id: 1,
-        association_name: 'trees',
-        search: 'Fir',
-        page: { size: 15, number: 1 },
-        timezone: 'America/Nome'
-      })
-      getter.perform
-      records = getter.records
-      count = getter.count
-
-      assert records.count == 1
-      assert count = 1
-      assert records.first.id == 8
-    end
-  end
-end

data/test/services/forest_liana/pie_stat_getter_test.rb

@@ -1,29 +0,0 @@
-module ForestLiana
-  class PieStatGetterTest < ActiveSupport::TestCase
-    test 'Pie stat getter with an aggregate on a boolean field' do
-      stat = PieStatGetter.new(BooleanField, {
-        type: "Pie",
-        collection: "boolean_field",
-        timezone: "Europe/Paris",
-        aggregate: "Count",
-        group_by_field: "field"
-      })
-
-      stat.perform
-      assert stat.record.value.count == 0
-    end
-
-    test 'Pie stat getter with an aggregate on a foreign key' do
-      stat = PieStatGetter.new(BelongsToField, {
-        type: "Pie",
-        collection: "belongs_to_field",
-        timezone: "Europe/Paris",
-        aggregate: "Count",
-        group_by_field: "has_one_field_id"
-      })
-
-      stat.perform
-      assert stat.record.value.count == 30
-    end
-  end
-end

data/test/services/forest_liana/resource_updater_test.rb

@@ -1,86 +0,0 @@
-module ForestLiana
-  class ResourceUpdaterTest < ActiveSupport::TestCase
-
-    collection = ForestLiana::Model::Collection.new({
-      name: 'SerializeField',
-      fields: [{
-        type: 'String',
-        field: 'field'
-      }]
-    })
-
-    ForestLiana.apimap << collection
-    ForestLiana.models << SerializeField
-
-    test 'Update a record on a "serialize" attribute with a missing value' do
-      params = ActionController::Parameters.new(
-        id: 1,
-        data: {
-          id: 1,
-          type: "SerializeField",
-          attributes: {}
-        }
-      )
-      updater = ResourceUpdater.new(SerializeField, params)
-      updater.perform
-
-      assert updater.record.valid?
-      assert updater.record.field == "value 1"
-    end
-
-    test 'Update a record on a "serialize" attribute with a null value' do
-      params = ActionController::Parameters.new(
-        id: 1,
-        data: {
-          id: 1,
-          type: "SerializeField",
-          attributes: {
-            field: nil
-          }
-        }
-      )
-      updater = ResourceUpdater.new(SerializeField, params)
-      updater.perform
-
-      assert updater.record.valid?
-      assert updater.record.field == []
-    end
-
-    test 'Update a record on a "serialize" attribute with a bad format value' do
-      params = ActionController::Parameters.new(
-        id: 1,
-        data: {
-          id: 1,
-          type: "SerializeField",
-          attributes: {
-            field: "Lucas"
-          }
-        }
-      )
-      updater = ResourceUpdater.new(SerializeField, params)
-      updater.perform
-
-      assert updater.record.valid?
-      assert updater.record.field == "value 1"
-      assert updater.errors[0][:detail] == "Bad format for 'field' attribute value."
-    end
-
-    test 'Update a record on a "serialize" attribute with a well formated value' do
-      params = ActionController::Parameters.new(
-        id: 1,
-        data: {
-          id: 1,
-          type: "SerializeField",
-          attributes: {
-            field: "[\"test\", \"test\"]"
-          }
-        }
-      )
-      updater = ResourceUpdater.new(SerializeField, params)
-      updater.perform
-
-      assert updater.record.valid?
-      assert updater.record.field == ["test", "test"]
-    end
-  end
-end

data/test/services/forest_liana/scope_validator_test.rb

@@ -1,185 +0,0 @@
-module ForestLiana
-  class ScopeValidatorTest < ActiveSupport::TestCase
-    test 'Request with aggregated condition filters should be allowed if it matches the scope exactly' do
-      scope_validator = ForestLiana::ScopeValidator.new({
-          'aggregator' => 'and',
-          'conditions' => [
-            { 'field' => 'name', 'value' => 'john', 'operator' => 'equal' },
-            { 'field' => 'price', 'value' => '2500', 'operator' => 'equal' }
-          ]
-        }, [])
-
-      allowed = scope_validator.is_scope_in_request?({
-        user_id: '1',
-        filters: JSON.generate({
-          aggregator: 'and',
-          conditions: [
-            { field: 'name', value: 'john', operator: 'equal' },
-            { field: 'price', value: '2500', operator: 'equal' }              
-          ]
-        })
-      })
-      assert allowed == true
-    end
-
-    test 'Request with simple condition filter should be allowed if it matches the scope exactly' do
-      scope_validator = ForestLiana::ScopeValidator.new({
-          'aggregator' => 'and',
-          'conditions' => [
-            { 'field' => 'field', 'value' => 'value', 'operator' => 'equal' }
-          ]
-        }, [])
-      allowed = scope_validator.is_scope_in_request?({
-        user_id: '1',
-        filters: JSON.generate({
-          field: 'field', value: 'value', operator: 'equal'
-        })
-      })
-      assert allowed == true
-    end
-
-    test 'Request with multiples condition filters should be allowed if it contains the scope ' do
-      scope_validator = ForestLiana::ScopeValidator.new({
-          'aggregator' => 'and',
-          'conditions' => [
-            { 'field' => 'name', 'value' => 'doe', 'operator' => 'equal' }
-          ]
-        }, []
-        )
-        
-      allowed = scope_validator.is_scope_in_request?({
-        user_id: '1',
-        filters: JSON.generate({
-          aggregator: 'and',
-          conditions: [
-            { field: 'name', value: 'doe', operator: 'equal' },
-            { field: 'field2', value: 'value2', operator: 'equal' }              
-          ]
-        })
-      })
-      assert allowed == true
-    end
-
-    test 'Request with dynamic user values should be allowed if it matches the scope exactly' do
-      scope_validator = ForestLiana::ScopeValidator.new({
-          'aggregator' => 'and',
-          'conditions' => [
-            { 'field' => 'name', 'value' => '$currentUser.lastname', 'operator' => 'equal' }
-          ],
-        }, {
-          '1' => { '$currentUser.lastname' => 'john' }
-        })
-
-      allowed = scope_validator.is_scope_in_request?({
-        user_id: '1',
-        filters: JSON.generate({
-          'field' => 'name', 'value' => 'john', 'operator' => 'equal'
-        })
-      })
-      assert allowed == true
-    end
-
-    test 'Request with multiples aggregation and dynamic values should be allowed if it contains the scope' do
-      scope_validator = ForestLiana::ScopeValidator.new({
-        'aggregator' => 'or',
-        'conditions' => [
-            { 'field' => 'price', 'value' => '2500', 'operator' => 'equal' },
-            { 'field' => 'name', 'value' => '$currentUser.lastname', 'operator' => 'equal' }
-          ]
-        }, {
-          '1' => { '$currentUser.lastname' => 'john' }
-        })
-        
-      allowed = scope_validator.is_scope_in_request?({
-        user_id: '1',
-        filters: JSON.generate({
-          aggregator: 'and',
-          conditions: [
-            { field: 'field', value: 'value', operator: 'equal' },
-            { 
-              aggregator: 'or',
-              conditions: [
-                { field: 'price', value: '2500', operator: 'equal' },
-                { field: 'name', value: 'john', operator: 'equal' }   
-              ]
-            }
-          ]
-        })
-      })
-      assert allowed == true
-    end
-
-    test 'Request that does not match the expect scope should not be allowed' do
-      scope_validator = ForestLiana::ScopeValidator.new({
-          'aggregator' => 'and',
-          'conditions' => [
-            { 'field' => 'name', 'value' => 'john', 'operator' => 'equal' },
-            { 'field' => 'price', 'value' => '2500', 'operator' => 'equal' }
-          ]
-        }, [])
-        
-      allowed = scope_validator.is_scope_in_request?({
-        user_id: '1',
-        filters: JSON.generate({
-          aggregator: 'and',
-          conditions: [
-            { field: 'name', value: 'definitely_not_john', operator: 'equal' },
-            { field: 'price', value: '0', operator: 'equal' }              
-          ]
-        })
-      })
-      assert allowed == false
-    end
-
-    test 'Request that are missing part of the scope should not be allowed' do
-      scope_validator = ForestLiana::ScopeValidator.new({
-          'aggregator' => 'and',
-          'conditions' => [
-            { 'field' => 'name', 'value' => 'john', 'operator' => 'equal' },
-            { 'field' => 'price', 'value' => '2500', 'operator' => 'equal' }
-          ]
-        }, [])
-        
-      allowed = scope_validator.is_scope_in_request?({
-        user_id: '1',
-        filters: JSON.generate({
-          aggregator: 'and',
-          conditions: [
-            { field: 'name', value: 'john', operator: 'equal' },
-          ]
-        })
-      })
-      assert allowed == false
-    end
-
-    test 'Request that does not have a top aggregator being "and" should not be allowed' do
-      scope_validator = ForestLiana::ScopeValidator.new({
-        'aggregator' => 'and',
-        'conditions' => [
-            { 'field' => 'price', 'value' => '2500', 'operator' => 'equal' },
-            { 'field' => 'name', 'value' => '$currentUser.lastname', 'operator' => 'equal' }
-          ]
-        }, {
-          '1' => { '$currentUser.lastname' => 'john' }
-        })
-
-      allowed = scope_validator.is_scope_in_request?({
-        user_id: '1',
-        filters: JSON.generate({
-          aggregator: 'or',
-          conditions: [
-            { field: 'field', value: 'value', operator: 'equal' },
-            { 
-              aggregator: 'and',
-              conditions: [
-                { field: 'price', value: '2500', operator: 'equal' },
-                { field: 'name', value: 'john', operator: 'equal' }   
-              ]
-            }
-          ]
-        })
-      })
-      assert allowed == false
-    end
-  end
-end