forest_liana 7.8.0 → 8.0.0.beta.2

data/spec/requests/stats_spec.rb

@@ -4,12 +4,12 @@ require 'json'
 describe "Stats", type: :request do
 
   token = JWT.encode({
-    id: 38,
+    id: 1,
     email: 'michael.kelso@that70.show',
     first_name: 'Michael',
     last_name: 'Kelso',
     team: 'Operations',
-    rendering_id: 16,
+    rendering_id: '1',
     exp: Time.now.to_i + 2.weeks.to_i,
     permission_level: 'admin'
   }, ForestLiana.auth_secret, 'HS256')
@@ -23,7 +23,7 @@ describe "Stats", type: :request do
   let(:schema) {
     [
       ForestLiana::Model::Collection.new({
-        name: 'Products',
+        name: 'Product',
         fields: [],
         actions: []
       })
@@ -31,62 +31,113 @@ describe "Stats", type: :request do
   }
 
   before do
-    allow(ForestLiana).to receive(:apimap).and_return(schema)
-  end
+    Rails.cache.write('forest.users', {'1' => { 'id' => 1, 'roleId' => 1, 'rendering_id' => '1' }})
+    Rails.cache.write('forest.has_permission', true)
+    allow_any_instance_of(ForestLiana::Ability::Fetch)
+      .to receive(:get_permissions)
+        .and_return(
+          {
+            "stats" => [
+              {
+                "type" => "Value",
+                "filter" => nil,
+                "aggregator" => "Count",
+                "aggregateFieldName" => nil,
+                "sourceCollectionName" => "Owner"
+              },
+              {
+                "type"  => "Value",
+                "query" => "SELECT COUNT(*) AS value FROM products;"
+              }
+            ],
+          }
+        )
+
+    ForestLiana::ScopeManager.class_variable_set(:@@scopes_cache, {
+      '1' => {
+        :fetched_at => Time.now,
+        :scopes => {}
+      }
+    })
 
-  before(:each) do
+    allow(ForestLiana).to receive(:apimap).and_return(schema)
     allow(ForestLiana::IpWhitelist).to receive(:retrieve) { true }
     allow(ForestLiana::IpWhitelist).to receive(:is_ip_whitelist_retrieved) { true }
     allow(ForestLiana::IpWhitelist).to receive(:is_ip_valid) { true }
-
-    allow_any_instance_of(ForestLiana::PermissionsChecker).to receive(:is_authorized?) { true }
-
-    allow_any_instance_of(ForestLiana::ValueStatGetter).to receive(:perform) { true }
-    allow_any_instance_of(ForestLiana::QueryStatGetter).to receive(:perform) { true }
   end
 
-
-
   describe 'POST /stats/:collection' do
-    params = { type: 'Value', collection: 'User', aggregate: 'Count' }
-
+    params = { type: 'Value', collection: 'Owner', aggregator: 'Count', sourceCollectionName: 'Owner', aggregateFieldName: nil, filter: nil}
     it 'should respond 200' do
-      data = ForestLiana::Model::Stat.new(value: { countCurrent: 0, countPrevious: 0 })
-      allow_any_instance_of(ForestLiana::ValueStatGetter).to receive(:record) { data }
-      # NOTICE: bypass : find_resource error
-      allow_any_instance_of(ForestLiana::StatsController).to receive(:find_resource) { true }
-      allow(ForestLiana::QueryHelper).to receive(:get_one_association_names_symbol) { true }
+      Rails.cache.delete('forest.stats')
+      post '/forest/stats/Owner', params: JSON.dump(params), headers: headers
 
-      post '/forest/stats/Products', params: JSON.dump(params), headers: headers
       expect(response.status).to eq(200)
     end
 
-    it 'should respond 401 with no headers' do
-      post '/forest/stats/Products', params: JSON.dump(params)
-      expect(response.status).to eq(401)
+    it 'should respond 200 with Objective chart' do
+      Rails.cache.delete('forest.stats')
+      params = {type: "Objective", sourceCollectionName: "Owner", aggregateFieldName: nil, aggregator: "Count", objective: 200, filter: nil, contextVariables: {}}
+      post '/forest/stats/Owner', params: JSON.dump(params), headers: headers
+
+      expect(response.status).to eq(200)
     end
 
-    it 'should respond 404 with non existing collection' do
-      allow_any_instance_of(ForestLiana::ValueStatGetter).to receive(:record) { nil }
+    it 'should respond 200 with Pie chart' do
+      Rails.cache.delete('forest.stats')
+      params = { type: "Pie", sourceCollectionName: "Owner", aggregateFieldName: nil, groupByFieldName: "id", aggregator: "Count", filter: nil, contextVariables:nil }
+      post '/forest/stats/Owner', params: JSON.dump(params), headers: headers
 
-      post '/forest/stats/NoCollection', params: {}, headers: headers
-      expect(response.status).to eq(404)
+      expect(response.status).to eq(200)
+    end
+
+    it 'should respond 200 with Line chart' do
+      Rails.cache.delete('forest.stats')
+      params = { type: "Line", sourceCollectionName: "Owner", aggregateFieldName: nil, groupByFieldName: "hired_at", aggregator: "Count", timeRange: "Week", filter: nil, contextVariables:nil }
+      post '/forest/stats/Owner', params: JSON.dump(params), headers: headers
+
+      expect(response.status).to eq(200)
     end
 
     it 'should respond 403 Forbidden' do
-      allow_any_instance_of(ForestLiana::PermissionsChecker).to receive(:is_authorized?) { false }
+      no_admin_token = JWT.encode({
+                                    id: 1,
+                                    email: 'michael.kelso@that70.show',
+                                    first_name: 'Michael',
+                                    last_name: 'Kelso',
+                                    team: 'Operations',
+                                    rendering_id: '1',
+                                    exp: Time.now.to_i + 2.weeks.to_i,
+                                    permission_level: 'user'
+                                  }, ForestLiana.auth_secret, 'HS256')
+
+      no_admin_headers = {
+        'Accept' => 'application/json',
+        'Content-Type' => 'application/json',
+        'Authorization' => "Bearer #{no_admin_token}"
+      }
+
+      params[:aggregateFieldName] = 'foo'
+      Rails.cache.delete('forest.stats')
+      allow_any_instance_of(ForestLiana::StatsController).to receive(:find_resource).and_return(Product)
+      data = ForestLiana::Model::Stat.new(value: { countCurrent: 0, countPrevious: 0 })
+      allow_any_instance_of(ForestLiana::ValueStatGetter).to receive(:record) { data }
       # NOTICE: bypass : find_resource error
       allow_any_instance_of(ForestLiana::StatsController).to receive(:find_resource) { true }
+      allow(ForestLiana::QueryHelper).to receive(:get_one_association_names_symbol) { true }
+
+
+      post '/forest/stats/Products', params: JSON.dump(params), headers: no_admin_headers
 
-      post '/forest/stats/Products', params: JSON.dump(params), headers: headers
       expect(response.status).to eq(403)
     end
   end
 
   describe 'POST /stats' do
-    params = { query: 'SELECT COUNT(*) AS value FROM products;' }
+    params = { type: 'Value', query: 'SELECT COUNT(*) AS value FROM products;' }
 
     it 'should respond 200' do
+      allow_any_instance_of(ForestLiana::StatsController).to receive(:find_resource).and_return(Product)
       data = ForestLiana::Model::Stat.new(value: { value: 0, objective: 0 })
       allow_any_instance_of(ForestLiana::QueryStatGetter).to receive(:record) { data }
 
@@ -100,18 +151,28 @@ describe "Stats", type: :request do
     end
 
     it 'should respond 403 Forbidden' do
-      allow_any_instance_of(ForestLiana::PermissionsChecker).to receive(:is_authorized?) { false }
-
-      post '/forest/stats', params: JSON.dump(params), headers: headers
+      no_admin_token = JWT.encode({
+                                    id: 1,
+                                    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,
+                                    permission_level: 'user'
+                                  }, ForestLiana.auth_secret, 'HS256')
+
+      no_admin_headers = {
+        'Accept' => 'application/json',
+        'Content-Type' => 'application/json',
+        'Authorization' => "Bearer #{no_admin_token}"
+      }
+      params[:query] = 'SELECT COUNT(*) AS value FROM trees;'
+      Rails.cache.delete('forest.stats')
+      allow_any_instance_of(ForestLiana::StatsController).to receive(:find_resource).and_return(Product)
+
+      post '/forest/stats', params: JSON.dump(params), headers: no_admin_headers
       expect(response.status).to eq(403)
     end
-
-    it 'should respond 422 with unprocessable query' do
-      allow_any_instance_of(ForestLiana::QueryStatGetter).to receive(:perform) { raise ForestLiana::Errors::LiveQueryError.new }
-
-      post '/forest/stats', params: JSON.dump(params), headers: headers
-      expect(response.status).to eq(422)
-    end
   end
-
 end

data/spec/services/forest_liana/ability/ability_spec.rb

@@ -0,0 +1,48 @@
+module ForestLiana
+  module Ability
+    describe Ability do
+      let(:dummy_class) { Class.new { extend ForestLiana::Ability } }
+      let(:user) { { 'id' => '1', 'roleId' => '1' } }
+
+      before do
+        Island.create!(name: "L'île de la muerta")
+      end
+
+      describe 'forest authorize' do
+        it 'should call is_crud_authorized? when the action is in [browse read edit add delete export] list' do
+          allow_any_instance_of(ForestLiana::Ability::Permission).to receive(:is_crud_authorized?).and_return(true)
+          %w[browse read edit add delete export].each do |action|
+            expect(dummy_class.forest_authorize!(action, :user, Island.first)).to equal nil
+          end
+        end
+
+        it 'should call is_chart_authorized? when the action equal chart' do
+          allow_any_instance_of(ForestLiana::Ability::Permission).to receive(:is_chart_authorized?).and_return(true)
+          expect(dummy_class.forest_authorize!('chart', :user, Island.first, {parameters: []})).to equal nil
+        end
+
+        it 'should raise error 422 on a chart action when the argument parameter is nil' do
+          expect { dummy_class.forest_authorize!('chart', :user, Island.first) }.to raise_error(ForestLiana::Errors::HTTP422Error, "The argument parameters is missing")
+        end
+
+        it 'should call is_smart_action_authorized? when the action equal action' do
+          allow_any_instance_of(ForestLiana::Ability::Permission).to receive(:is_smart_action_authorized?).and_return(true)
+          expect(dummy_class.forest_authorize!('action', :user, Island.first, {parameters: [], endpoint: '...', http_method: 'POST'})).to equal true
+        end
+
+        it 'should raise error 422 on a chart smart-action when one or many arguments are missing' do
+          expect { dummy_class.forest_authorize!('action', :user, Island.first) }.to raise_error(ForestLiana::Errors::HTTP422Error, "You must implement the arguments : parameters, endpoint & http_method")
+        end
+
+        it 'should raise access denied when the action is unknown' do
+          expect { dummy_class.forest_authorize!('unknown', :user, Island.first) }.to raise_error(ForestLiana::Ability::Exceptions::AccessDenied, "You don't have permission to access this resource")
+        end
+
+        it 'should authorized user with correct permission_level to access charts' do
+          user['permission_level'] = 'admin'
+          expect(dummy_class.forest_authorize!('chart', user, Island.first, {parameters: []})).to equal nil
+        end
+      end
+    end
+  end
+end

data/spec/services/forest_liana/ability/permission/smart_action_checker_spec.rb

@@ -0,0 +1,357 @@
+module ForestLiana
+  module Ability
+    # include ForestLiana::Ability::Permission
+    describe Ability do
+      let(:user) { { 'id' => 1, 'roleId' => 1, 'rendering_id' => 1 } }
+      let(:action) {
+        {
+          'triggerEnabled' => [],
+          'triggerConditions' => [],
+          'approvalRequired' => [],
+          'approvalRequiredConditions' => [],
+          'userApprovalEnabled' => [],
+          'userApprovalConditions' => [],
+          'selfApprovalEnabled' => []
+        }
+      }
+
+      let(:params) {
+        {
+          'data' => {
+            'attributes' => {
+              'values': {},
+              'ids': [
+                '1'
+              ],
+              'collection_name': 'Island',
+              'parent_collection_name': nil,
+              'parent_collection_id': nil,
+              'parent_association_name': nil,
+              'all_records': false,
+              'all_records_subset_query': {
+                'fields[Island]': 'is,name',
+                'fields[file_attachment]': 'name',
+                'fields[file_blob]': 'id',
+                'page[number]': 1,
+                'page[size]': 15,
+                'sort': '-id',
+                'timezone': 'Europe/Paris'
+              },
+              'all_records_ids_excluded': [],
+              'smart_action_id': 'Island-my_action',
+              'signed_approval_request': nil
+            }
+            }
+          }
+      }
+
+      before do
+        Island.create!(name: "foo")
+      end
+
+      describe 'can_execute with triggerEnabled' do
+        it 'should return true if triggerConditions is empty and user can trigger' do
+          parameters = ActionController::Parameters.new(params).permit!
+          action['triggerEnabled'] = [1]
+          smart_action_checker = ForestLiana::Ability::Permission::SmartActionChecker.new(parameters, Island, action, user)
+
+          expect(smart_action_checker.can_execute?).to equal true
+        end
+
+        it 'should return true if match triggerConditions and user can trigger' do
+          parameters = ActionController::Parameters.new(params).permit!
+          action['triggerEnabled'] = [1]
+          action['triggerConditions'] = [
+            { 'filter' =>
+                { 'aggregator' => 'and',
+                  'conditions' =>
+                    [
+                      {
+                        'field' => 'name',
+                        'value' => 'foo',
+                        'source' => 'data',
+                        'operator' => 'equal'
+                      }
+                    ]
+                },
+              'roleId' => 1
+            }
+          ]
+          smart_action_checker = ForestLiana::Ability::Permission::SmartActionChecker.new(parameters, Island, action, user)
+
+          expect(smart_action_checker.can_execute?).to equal true
+        end
+
+        it 'should return true if match triggerConditions on allRecords and user can trigger' do
+          params['data']['attributes']['all_records'] = true
+          parameters = ActionController::Parameters.new(params).permit!
+          action['triggerEnabled'] = [1]
+          action['triggerConditions'] = [
+            { 'filter' =>
+                { 'aggregator' => 'and',
+                  'conditions' =>
+                    [
+                      {
+                        'field' => 'name',
+                        'value' => 'foo',
+                        'source' => 'data',
+                        'operator' => 'equal'
+                      }
+                    ]
+                },
+              'roleId' => 1
+            }
+          ]
+          smart_action_checker = ForestLiana::Ability::Permission::SmartActionChecker.new(parameters, Island, action, user)
+
+          expect(smart_action_checker.can_execute?).to equal true
+        end
+
+        it 'should raise error when user can not trigger' do
+          parameters = ActionController::Parameters.new(params).permit!
+          action['triggerEnabled'] = [2]
+          smart_action_checker = ForestLiana::Ability::Permission::SmartActionChecker.new(parameters, Island, action, user)
+
+          expect{smart_action_checker.can_execute?}.to raise_error(ForestLiana::Ability::Exceptions::TriggerForbidden)
+        end
+
+        it 'should raise error when triggerConditions not match' do
+          parameters = ActionController::Parameters.new(params).permit!
+          action['triggerEnabled'] = [1]
+          action['triggerConditions'] = [
+            { 'filter' =>
+                { 'aggregator' => 'and',
+                  'conditions' =>
+                    [
+                      {
+                        'field' => 'name',
+                        'value' => 'fake island',
+                        'source' => 'data',
+                        'operator' => 'equal'
+                      }
+                    ]
+                },
+              'roleId' => 1
+            }
+          ]
+          smart_action_checker = ForestLiana::Ability::Permission::SmartActionChecker.new(parameters, Island, action, user)
+
+          expect{smart_action_checker.can_execute?}.to raise_error ForestLiana::Ability::Exceptions::TriggerForbidden
+        end
+
+        it 'should raise error when conditions is on an unknown field' do
+          parameters = ActionController::Parameters.new(params).permit!
+          action['triggerEnabled'] = [1]
+          action['triggerConditions'] = [
+            { 'filter' =>
+                { 'aggregator' => 'and',
+                  'conditions' =>
+                    [
+                      {
+                        'field' => 'unknown-field',
+                        'value' => 'fake island',
+                        'source' => 'data',
+                        'operator' => 'equal'
+                      }
+                    ]
+                },
+              'roleId' => 1
+            }
+          ]
+          smart_action_checker = ForestLiana::Ability::Permission::SmartActionChecker.new(parameters, Island, action, user)
+
+          expect{smart_action_checker.can_execute?}.to raise_error ForestLiana::Ability::Exceptions::ActionConditionError
+        end
+      end
+
+      describe 'can_execute with approvalRequired' do
+        it 'should raise RequireApproval error if approvalRequiredConditions is empty' do
+          parameters = ActionController::Parameters.new(params).permit!
+          action['approvalRequired'] = [1]
+          smart_action_checker = ForestLiana::Ability::Permission::SmartActionChecker.new(parameters, Island, action, user)
+
+          expect{smart_action_checker.can_execute?}.to raise_error ForestLiana::Ability::Exceptions::RequireApproval
+        end
+
+        it 'should raise RequireApproval error if match approvalRequiredConditions' do
+          parameters = ActionController::Parameters.new(params).permit!
+          action['approvalRequired'] = [1]
+          action['approvalRequiredConditions'] = [
+            { 'filter' =>
+                { 'aggregator' => 'and',
+                  'conditions' =>
+                    [
+                      {
+                        'field' => 'name',
+                        'value' => 'foo',
+                        'source' => 'data',
+                        'operator' => 'equal'
+                      }
+                    ]
+                },
+              'roleId' => 1
+            }
+          ]
+          smart_action_checker = ForestLiana::Ability::Permission::SmartActionChecker.new(parameters, Island, action, user)
+
+          expect{smart_action_checker.can_execute?}.to raise_error ForestLiana::Ability::Exceptions::RequireApproval
+        end
+
+        it 'should raise error when user can not trigger' do
+          parameters = ActionController::Parameters.new(params).permit!
+          action['approvalRequired'] = [2]
+          smart_action_checker = ForestLiana::Ability::Permission::SmartActionChecker.new(parameters, Island, action, user)
+
+          expect{smart_action_checker.can_execute?}.to raise_error(ForestLiana::Ability::Exceptions::TriggerForbidden)
+        end
+
+        it 'should raise error when triggerConditions not match' do
+          parameters = ActionController::Parameters.new(params).permit!
+          action['approvalRequired'] = [1]
+          action['approvalRequiredConditions'] = [
+            { 'filter' =>
+                { 'aggregator' => 'and',
+                  'conditions' =>
+                    [
+                      {
+                        'field' => 'name',
+                        'value' => 'fake island',
+                        'source' => 'data',
+                        'operator' => 'equal'
+                      }
+                    ]
+                },
+              'roleId' => 1
+            }
+          ]
+          smart_action_checker = ForestLiana::Ability::Permission::SmartActionChecker.new(parameters, Island, action, user)
+
+          expect{smart_action_checker.can_execute?}.to raise_error ForestLiana::Ability::Exceptions::TriggerForbidden
+        end
+      end
+
+      describe 'can_execute with userApproval' do
+        before do
+          params['data']['attributes']['requester_id'] = 2
+          request = params
+          params['data']['attributes']['signed_approval_request'] = JWT::encode(request, ForestLiana.env_secret)
+          action['userApprovalEnabled'] = [1]
+        end
+
+        it 'should return true if userApprovalConditions is empty and user has userApprovalEnabled permission' do
+          parameters = ActionController::Parameters.new(params).permit!
+          smart_action_checker = ForestLiana::Ability::Permission::SmartActionChecker.new(parameters, Island, action, user)
+
+          expect(smart_action_checker.can_execute?).to equal true
+        end
+
+        it 'should return true when record match userApprovalConditions and requester_id different of current user id' do
+          action['userApprovalConditions'] = [
+            { 'filter' =>
+                { 'aggregator' => 'and',
+                  'conditions' =>
+                    [
+                      {
+                        'field' => 'name',
+                        'value' => 'foo',
+                        'source' => 'data',
+                        'operator' => 'equal'
+                      }
+                    ]
+                },
+              'roleId' => 1
+            }
+          ]
+          parameters = ActionController::Parameters.new(params).permit!
+          smart_action_checker = ForestLiana::Ability::Permission::SmartActionChecker.new(parameters, Island, action, user)
+
+          expect(smart_action_checker.can_execute?).to equal true
+        end
+
+        it 'should return true when record match userApprovalConditions and user can self approve' do
+          action['userApprovalConditions'] = [
+            { 'filter' =>
+                { 'aggregator' => 'and',
+                  'conditions' =>
+                    [
+                      {
+                        'field' => 'name',
+                        'value' => 'foo',
+                        'source' => 'data',
+                        'operator' => 'equal'
+                      }
+                    ]
+                },
+              'roleId' => 1
+            }
+          ]
+          action['selfApprovalEnabled'] = [1]
+          params['data']['attributes']['requester_id'] = 2
+          request = params
+          params['data']['attributes']['signed_approval_request'] = JWT::encode(request, ForestLiana.env_secret)
+          parameters = ActionController::Parameters.new(params).permit!
+          smart_action_checker = ForestLiana::Ability::Permission::SmartActionChecker.new(parameters, Island, action, user)
+
+          expect(smart_action_checker.can_execute?).to equal true
+        end
+
+        it 'should raise error when user has userApprovalEnabled permission' do
+          parameters = ActionController::Parameters.new(params).permit!
+          action['userApprovalEnabled'] = [2]
+          smart_action_checker = ForestLiana::Ability::Permission::SmartActionChecker.new(parameters, Island, action, user)
+
+          expect{smart_action_checker.can_execute?}.to raise_error(ForestLiana::Ability::Exceptions::TriggerForbidden)
+        end
+
+        it 'should raise error when triggerConditions not match' do
+          parameters = ActionController::Parameters.new(params).permit!
+          action['userApprovalConditions'] = [
+            { 'filter' =>
+                { 'aggregator' => 'and',
+                  'conditions' =>
+                    [
+                      {
+                        'field' => 'name',
+                        'value' => 'fake island',
+                        'source' => 'data',
+                        'operator' => 'equal'
+                      }
+                    ]
+                },
+              'roleId' => 1
+            }
+          ]
+          smart_action_checker = ForestLiana::Ability::Permission::SmartActionChecker.new(parameters, Island, action, user)
+
+          expect{smart_action_checker.can_execute?}.to raise_error(ForestLiana::Ability::Exceptions::TriggerForbidden)
+        end
+
+        it 'should raise error when requester_id equal to current user id without selfApprove permission' do
+          action['userApprovalConditions'] = [
+            { 'filter' =>
+                { 'aggregator' => 'and',
+                  'conditions' =>
+                    [
+                      {
+                        'field' => 'name',
+                        'value' => 'foo',
+                        'source' => 'data',
+                        'operator' => 'equal'
+                      }
+                    ]
+                },
+              'roleId' => 1
+            }
+          ]
+          params['data']['attributes']['requester_id'] = 1
+          request = params
+          params['data']['attributes']['signed_approval_request'] = JWT::encode(request, ForestLiana.env_secret)
+          parameters = ActionController::Parameters.new(params).permit!
+          smart_action_checker = ForestLiana::Ability::Permission::SmartActionChecker.new(parameters, Island, action, user)
+
+          expect{smart_action_checker.can_execute?}.to raise_error(ForestLiana::Ability::Exceptions::TriggerForbidden)
+        end
+      end
+    end
+  end
+end