forest_liana 9.1.10 → 9.2.0

data/spec/services/forest_liana/scope_manager_spec.rb

@@ -1,199 +1,187 @@
 module ForestLiana
   describe ScopeManager do
     let(:rendering_id) { 13 }
-    let(:user) { { 'id' => '1', 'rendering_id' => rendering_id } }
-    let(:collection_name) { 'Users' }
-    let(:first_collection_scope) {
+    let(:user) {
       {
-        'scope'=> {
-          'filter'=> {
-            'aggregator' => 'and',
-            'conditions' => [
-              { 'field' => 'description', 'operator' => 'contains', 'value' => 'check' }
-            ]
-          },
-          'dynamicScopesValues' => { }
-        }
-      }
-    }
-    let(:second_collection_scope) {
-      {
-        'scope'=> {
-          'filter'=> {
-            'aggregator' => 'and',
-            'conditions' => [
-              { 'field' => 'description', 'operator' => 'contains', 'value' => 'toto' }
-            ]
-          },
-          'dynamicScopesValues' => { }
-        }
+        'id' => '1',
+        'email' => 'jd@forestadmin.com',
+        'first_name' => 'John',
+        'last_name' => 'Doe',
+        'team' => 'Operations',
+        'role' => 'role-test',
+        'tags' => [{'key' => 'tag1'}],
+        'rendering_id'=> rendering_id
       }
     }
-    let(:first_json_scopes) { JSON.generate({ collection_name => first_collection_scope }) }
-    let(:second_json_scopes) { JSON.generate({ collection_name => second_collection_scope }) }
-    let(:first_scopes_api_call_response) { Net::HTTPOK.new({}, 200, first_json_scopes) }
-    let(:second_scopes_api_call_response) { Net::HTTPOK.new({}, 200, second_json_scopes) }
+    let(:collection_name) { 'User' }
 
     before do
       described_class.invalidate_scope_cache(rendering_id)
-      allow(ForestLiana::ForestApiRequester).to receive(:get).and_return(first_scopes_api_call_response, second_scopes_api_call_response)
-      allow(first_scopes_api_call_response).to receive(:body).and_return(first_json_scopes)
-      allow(second_scopes_api_call_response).to receive(:body).and_return(second_json_scopes)
     end
 
-    describe '#get_scope_for_user' do
-      describe 'with invalid inputs' do
-        it 'should raise an error on missing rendering_id' do
-          expect {
-            described_class.get_scope_for_user({}, collection_name)
-          }.to raise_error 'Missing required rendering_id'
-        end
-
-        it 'should raise an error on missing collection_name' do
-          expect {
-            described_class.get_scope_for_user(user, nil)
-          }.to raise_error 'Missing required collection_name'
-        end
-      end
+    describe '#get_scope' do
+      let(:api_call_response_error) { Net::HTTPNotFound.new({}, 404, nil) }
 
       describe 'when the backend return an errored response' do
-        let(:first_scopes_api_call_response) { Net::HTTPNotFound.new({}, 404, nil) }
+        before do
+          allow(ForestLiana::ForestApiRequester).to receive(:get).and_return(api_call_response_error)
+        end
 
         it 'should raise an error' do
           expect {
-            described_class.get_scope_for_user(user, collection_name)
+            described_class.get_scope(collection_name, user)
           }.to raise_error 'Unable to fetch scopes'
         end
       end
 
-      describe 'when retrieving scopes once with no cached value' do
-        let(:scope) { described_class.get_scope_for_user(user, collection_name) }
-
-        it 'should fetch the relevant scope and return it' do
-          expect(scope).to eq first_collection_scope['scope']['filter']
-          expect(ForestLiana::ForestApiRequester).to have_received(:get).once
-          expect(ForestLiana::ForestApiRequester).to have_received(:get).with('/liana/scopes', query: { 'renderingId' => rendering_id })
-        end
-      end
-
-      describe 'when retrieving scopes twice before the refresh cache delta' do
-        let(:scope_first_fetch) { described_class.get_scope_for_user(user, collection_name) }
-        let(:scope_second_fetch) { described_class.get_scope_for_user(user, collection_name) }
-
-        it 'should return the same value twice and have fetch the scopes from the backend only once' do
-          expect(scope_first_fetch).to eq first_collection_scope['scope']['filter']
-          expect(scope_second_fetch).to eq first_collection_scope['scope']['filter']
-          expect(ForestLiana::ForestApiRequester).to have_received(:get).once.with('/liana/scopes', query: { 'renderingId' => rendering_id })
-        end
-      end
-
-      describe 'when retrieving scopes twice after the refresh cache delta' do
-        let(:scope_first_fetch) { described_class.get_scope_for_user(user, collection_name) }
-        let(:scope_second_fetch) { described_class.get_scope_for_user(user, collection_name) }
+      describe 'when retrieving scopes' do
+        let(:filled_scope) {
+          JSON.generate(
+            {
+              'collections' => {
+                'User' => {
+                  'scope' => {
+                    'aggregator' => 'and',
+                    'conditions' => [{'field' => 'id', 'operator' => 'greater_than', 'value' => '1'}]
+                  },
+                  'segments' => []
+                }
+              },
+              'stats' => [],
+              'team' => {'id' => '1', 'name' => 'Operations'}
+            }
+          )
+        }
+        let(:api_call_response_success) { Net::HTTPOK.new({}, 200, filled_scope) }
 
-        it 'should return same value but trigger a fetch twice' do
-          expect(scope_first_fetch).to eq first_collection_scope['scope']['filter']
-          allow(Time).to receive(:now).and_return(Time.now + 20.minutes)
-          expect(scope_second_fetch).to eq first_collection_scope['scope']['filter']
-          # sleep to wait for the Thread to trigger the call to the `ForestApiRequester`
-          sleep(0.001)
-          expect(ForestLiana::ForestApiRequester).to have_received(:get).twice.with('/liana/scopes', query: { 'renderingId' => rendering_id })
+        before do
+          allow(ForestLiana::ForestApiRequester).to receive(:get).and_return(api_call_response_success)
+          allow(api_call_response_success).to receive(:body).and_return(filled_scope)
         end
-      end
 
-      describe 'when retrieving scopes three times after the refresh cache delta' do
-        let(:scope_first_fetch) { described_class.get_scope_for_user(user, collection_name) }
-        let(:scope_second_fetch) { described_class.get_scope_for_user(user, collection_name) }
-        let(:scope_third_fetch) { described_class.get_scope_for_user(user, collection_name) }
+        it 'should fetch the relevant scope and return it' do
+          expect(described_class.get_scope(collection_name, user)).to eq(
+            {
+              'aggregator' => 'and',
+              'conditions' => [{'field' => 'id', 'operator' => 'greater_than', 'value' => '1'}]
+            }
+          )
 
-        it 'should return a new value on third call and have fetch the scopes from the backend only twice' do
-          expect(scope_first_fetch).to eq first_collection_scope['scope']['filter']
-          allow(Time).to receive(:now).and_return(Time.now + 20.minutes)
-          expect(scope_second_fetch).to eq first_collection_scope['scope']['filter']
-          # sleep to wait for the Thread to update the cache
-          sleep(0.001)
-          expect(scope_third_fetch).to eq second_collection_scope['scope']['filter']
-          expect(ForestLiana::ForestApiRequester).to have_received(:get).twice.with('/liana/scopes', query: { 'renderingId' => rendering_id })
+          expect(Rails.cache.read('forest.scopes.' + rendering_id.to_s)).to eq(
+            {
+              'scopes' => {'User' => {'aggregator' => 'and', 'conditions'=>[{'field' => 'id', 'operator' => 'greater_than', 'value' => '1'}]}},
+              'team' => {'id' => '1', 'name' => 'Operations'},
+            })
         end
       end
 
       describe 'when scope contains dynamic values' do
-        let(:first_collection_scope) {
-          {
-            'scope' => {
-              'filter'=> {
-                'aggregator' => 'and',
-                'conditions' => [
-                  { 'field' => 'description', 'operator' => 'contains', 'value' => '$currentUser.firstName' }
-                ]
+        let(:filled_scope) {
+          JSON.generate(
+            {
+              'collections' => {
+                'User' => {
+                  'scope' => {
+                    'aggregator' => 'and',
+                    'conditions' => [{'field' => 'email', 'operator' => 'equal', 'value' => '{{currentUser.email}}'}]
+                  },
+                  'segments' => []
+                }
               },
-              'dynamicScopesValues' => {
-                'users' => { '1' => { '$currentUser.firstName' => 'Valentin' } }
-              }
+              'stats' => [],
+              'team' => {'id' => '1', 'name' => 'Operations'}
             }
-          }
-        }
-        let(:scope_filter) { described_class.get_scope_for_user(user, collection_name) }
-        let(:expected_filter) {
-          {
-            'aggregator' => 'and',
-            'conditions' => [
-              { 'field' => 'description', 'operator' => 'contains', 'value' => 'Valentin' }
-            ]
-          }
+          )
         }
 
-        it 'should replace the dynamic values properly' do
-          expect(scope_filter).to eq expected_filter
-          expect(ForestLiana::ForestApiRequester).to have_received(:get).once
-          expect(ForestLiana::ForestApiRequester).to have_received(:get).with('/liana/scopes', query: { 'renderingId' => rendering_id })
+        let(:api_call_response_success) { Net::HTTPOK.new({}, 200, filled_scope) }
+
+        before do
+          allow(ForestLiana::ForestApiRequester).to receive(:get).and_return(api_call_response_success)
+          allow(api_call_response_success).to receive(:body).and_return(filled_scope)
         end
-      end
 
-      describe 'when target collection has no scopes' do
-        let(:first_collection_scope) { { } }
-        let(:scope_filter) { described_class.get_scope_for_user(user, collection_name) }
+        it 'should fetch the relevant scope and return it' do
+          expect(described_class.get_scope(collection_name, user)).to eq(
+            {
+              'aggregator' => 'and',
+              'conditions' => [{'field' => 'email', 'operator' => 'equal', 'value' => 'jd@forestadmin.com'}]
+            }
+          )
 
-        it 'should return nil' do
-          expect(scope_filter).to eq nil
-          expect(ForestLiana::ForestApiRequester).to have_received(:get).once
-          expect(ForestLiana::ForestApiRequester).to have_received(:get).with('/liana/scopes', query: { 'renderingId' => rendering_id })
+          expect(Rails.cache.read('forest.scopes.' + rendering_id.to_s)).to eq(
+            {
+              'scopes' => {'User' => {'aggregator' => 'and', 'conditions'=>[{'field' => 'email', 'operator' => 'equal', 'value' => '{{currentUser.email}}'}]}},
+              'team' => {'id' => '1', 'name' => 'Operations'},
+            }
+          )
         end
       end
 
       describe 'when target collection has no scopes' do
-        let(:first_collection_scope) { { } }
-        let(:scope_filter) { described_class.get_scope_for_user(user, collection_name) }
+        let(:empty_scope) {
+          JSON.generate(
+            {
+              'collections' => {
+                'User' => {
+                  'scope' => nil,
+                  'segments' => []
+                }
+              },
+              'stats' => [],
+              'team' => {'id' => '1', 'name' => 'Operations'}
+            }
+          )
+        }
 
-        it 'should return nil' do
-          expect(scope_filter).to eq nil
-          expect(ForestLiana::ForestApiRequester).to have_received(:get).once
-          expect(ForestLiana::ForestApiRequester).to have_received(:get).with('/liana/scopes', query: { 'renderingId' => rendering_id })
+        let(:api_call_response_empty) { Net::HTTPOK.new({}, 200, empty_scope) }
+
+        before do
+          allow(ForestLiana::ForestApiRequester).to receive(:get).and_return(api_call_response_empty)
+          allow(api_call_response_empty).to receive(:body).and_return(empty_scope)
         end
-      end
 
-      describe 'when asking for filters as string' do
-        let(:scope) { described_class.get_scope_for_user(user, collection_name, as_string: true) }
-        let(:expected_filters) { "{\"aggregator\":\"and\",\"conditions\":[{\"field\":\"description\",\"operator\":\"contains\",\"value\":\"check\"}]}" }
+        it 'should return nil' do
+          expect(described_class.get_scope(collection_name, user)).to eq nil
 
-        it 'should fetch the relevant scope and return it as a string' do
-          expect(scope).to eq expected_filters
-          expect(ForestLiana::ForestApiRequester).to have_received(:get).once
-          expect(ForestLiana::ForestApiRequester).to have_received(:get).with('/liana/scopes', query: { 'renderingId' => rendering_id })
+          expect(Rails.cache.read('forest.scopes.' + rendering_id.to_s)).to eq(
+                                                                              {
+                                                                                'scopes' => {},
+                                                                                'team' => {'id' => '1', 'name' => 'Operations'},
+                                                                              }
+                                                                            )
         end
       end
     end
 
     describe '#append_scope_for_user' do
-      let(:existing_filter) { "{\"aggregator\":\"and\",\"conditions\":[{\"field\":\"shipping_status\",\"operator\":\"equal\",\"value\":\"Shipped\"}]}" }
-      let(:first_collection_scope_filter_as_string) { "{\"aggregator\":\"and\",\"conditions\":[{\"field\":\"description\",\"operator\":\"contains\",\"value\":\"check\"}]}" }
+      let(:filters) { described_class.append_scope_for_user(existing_filter, user, collection_name) }
 
       describe 'when the target collection has NO scopes defined' do
-        let(:first_collection_scope) { { } }
+        let(:api_call_response_empty) { Net::HTTPOK.new({}, 200, empty_scope) }
+
+        let(:empty_scope) {
+          JSON.generate(
+            {
+              'collections' => {
+                'User' => {
+                  'scope' => nil,
+                  'segments' => []
+                }
+              },
+              'stats' => [],
+              'team' => {'id' => '1', 'name' => 'Operations'}
+            }
+          )
+        }
+
+        before do
+          allow(ForestLiana::ForestApiRequester).to receive(:get).and_return(api_call_response_empty)
+          allow(api_call_response_empty).to receive(:body).and_return(empty_scope)
+        end
 
         describe 'when providing NO existing filters' do
           let(:existing_filter) { nil }
-          let(:filters) { described_class.append_scope_for_user(existing_filter, user, collection_name) }
 
           it 'should return nil' do
             expect(filters).to eq nil
@@ -201,9 +189,9 @@ module ForestLiana
         end
 
         describe 'when providing existing filters' do
-          let(:filters) { described_class.append_scope_for_user(existing_filter, user, collection_name) }
+          let(:existing_filter) { {'aggregator' => 'and', 'conditions' => [{'field' => 'shipping_status', 'operator' => 'equal', 'value' => 'Shipped'}]} }
 
-          it 'should return only the exisitng filters' do
+          it 'should return only the existing filters' do
             expect(filters).to eq existing_filter
           end
         end
@@ -212,21 +200,124 @@ module ForestLiana
       describe 'when the target collection has scopes defined' do
         describe 'when providing NO existing filters' do
           let(:existing_filter) { nil }
-          let(:filters) { described_class.append_scope_for_user(existing_filter, user, collection_name) }
+
+          let(:filled_scope) {
+            JSON.generate(
+              {
+                'collections' => {
+                  'User' => {
+                    'scope' => {
+                      'aggregator' => 'and',
+                      'conditions' => [{'field' => 'id', 'operator' => 'greater_than', 'value' => '1'}]
+                    },
+                    'segments' => []
+                  }
+                },
+                'stats' => [],
+                'team' => {'id' => '1', 'name' => 'Operations'}
+              }
+            )
+          }
+
+          let(:api_call_response_success) { Net::HTTPOK.new({}, 200, filled_scope) }
+
+          before do
+            allow(ForestLiana::ForestApiRequester).to receive(:get).and_return(api_call_response_success)
+            allow(api_call_response_success).to receive(:body).and_return(filled_scope)
+          end
 
           it 'should return only the scope filters' do
-            expect(filters).to eq first_collection_scope_filter_as_string
+            expect(filters).to eq filters
           end
-        end
 
-        describe 'when providing existing filters' do
-          let(:filters) { described_class.append_scope_for_user(existing_filter, user, collection_name) }
+          describe 'when providing existing filters' do
+            let(:existing_filter) { {'aggregator' => 'and', 'conditions' => [{'field' => 'shipping_status', 'operator' => 'equal', 'value' => 'Shipped'}]} }
 
-          it 'should return the aggregation between the exisitng filters and the scope filters' do
-            expect(filters).to eq "{\"aggregator\":\"and\",\"conditions\":[#{existing_filter},#{first_collection_scope_filter_as_string}]}"
+            it 'should return the aggregation between the existing filters and the scope filters' do
+              expect(filters).to eq(
+                {
+                  'aggregator' => 'and',
+                  'conditions' => [
+                    existing_filter,
+                    { 'aggregator' => 'and', 'conditions' => [{ 'field' => 'id', 'operator' => 'greater_than', 'value' => '1' }] }
+                  ]
+                }
+              )
+            end
           end
         end
       end
     end
+
+    describe '#apply_scopes_on_records' do
+      let(:resource) { User }
+
+      describe 'when the collection has NO scopes' do
+        let(:empty_scope) {
+          JSON.generate(
+            {
+              'collections' => {
+                'User' => {
+                  'scope' => nil,
+                  'segments' => []
+                }
+              },
+              'stats' => [],
+              'team' => {'id' => '1', 'name' => 'Operations'}
+            }
+          )
+        }
+        let(:api_call_response_empty) { Net::HTTPOK.new({}, 200, empty_scope) }
+
+        before do
+          allow(ForestLiana::ForestApiRequester).to receive(:get).and_return(api_call_response_empty)
+          allow(api_call_response_empty).to receive(:body).and_return(empty_scope)
+        end
+
+        it 'should return the records as is' do
+          expect(described_class.apply_scopes_on_records(resource.all, user, collection_name, nil)).to eq resource.all
+        end
+      end
+
+      describe 'when the collection has scopes' do
+        let(:filled_scope) {
+          JSON.generate(
+            {
+              'collections' => {
+                'User' => {
+                  'scope' => {
+                    'aggregator' => 'and',
+                    'conditions' => [{'field' => 'id', 'operator' => 'greater_than', 'value' => '1'}]
+                  },
+                  'segments' => []
+                }
+              },
+              'stats' => [],
+              'team' => {'id' => '1', 'name' => 'Operations'}
+            }
+          )
+        }
+        let(:api_call_response_success) { Net::HTTPOK.new({}, 200, filled_scope) }
+
+        before do
+          allow(ForestLiana::ForestApiRequester).to receive(:get).and_return(api_call_response_success)
+          allow(api_call_response_success).to receive(:body).and_return(filled_scope)
+        end
+
+        it 'should apply the scope filters on the records' do
+          filters_parser = instance_double(ForestLiana::FiltersParser, apply_filters: resource)
+          allow(ForestLiana::FiltersParser).to receive(:new).and_return(filters_parser)
+
+          described_class.apply_scopes_on_records(resource, user, collection_name, nil)
+
+          expect(ForestLiana::FiltersParser).to have_received(:new).with(
+            {'aggregator' => 'and','conditions' => [{'field' => 'id', 'operator' => 'greater_than', 'value' => '1'}]},
+            resource,
+            nil
+          ).once
+          expect(filters_parser).to have_received(:apply_filters).once
+        end
+      end
+    end
   end
 end

data/spec/services/forest_liana/utils/context_variables_injector_spec.rb

@@ -0,0 +1,107 @@
+module ForestLiana
+  module Utils
+    describe ContextVariablesInjector do
+      let(:team) { { 'id' => 100, 'name' => 'Ninja' } }
+
+      let(:user) do
+        {
+          'id' => 1,
+          'firstName' => 'John',
+          'lastName' => 'Doe',
+          'fullName' => 'John Doe',
+          'email' => 'john.doe@domain.com',
+          'tags' => [{ 'planet' => 'Death Star' }],
+          'roleId' => 1,
+          'permissionLevel' => 'admin'
+        }
+      end
+
+      let(:context_variables) do
+        ContextVariables.new(
+          team,
+          user,
+          {
+            'siths.selectedRecord.rank' => 3,
+            'siths.selectedRecord.power' => 'electrocute'
+          }
+        )
+      end
+
+      context 'when inject_context_in_filter is called' do
+        it 'returns it as it is with a number' do
+          result = described_class.inject_context_in_value_custom(8) { {} }
+
+          expect(result).to eq(8)
+        end
+
+        it 'returns it as it is with a array' do
+          value = ['test', 'me']
+          result = described_class.inject_context_in_value_custom(value) { {} }
+
+          expect(result).to eq(value)
+        end
+
+        it 'replaces all variables with a string' do
+          replace_function = ->(key) { key.split('.').pop.upcase }
+          result = described_class.inject_context_in_value_custom(
+            'It should be {{siths.selectedRecord.power}} of rank {{siths.selectedRecord.rank}}. But {{siths.selectedRecord.power}} can be duplicated.'
+          ) do |key|
+            replace_function.call(key)
+          end
+
+          expect(result).to eq('It should be POWER of rank RANK. But POWER can be duplicated.')
+        end
+      end
+
+      context('when inject_context_in_value is called') do
+        it 'returns it as it is with a number' do
+          result = described_class.inject_context_in_value(8, context_variables)
+
+          expect(result).to eq(8)
+        end
+
+        it 'returns it as it is with a array' do
+          value = ['test', 'me']
+          result = described_class.inject_context_in_value(value, context_variables)
+
+          expect(result).to eq(value)
+        end
+
+        it 'replaces all variables with a string' do
+          first_value_part = 'It should be {{siths.selectedRecord.power}} of rank {{siths.selectedRecord.rank}}.'
+          second_value_part = 'But {{siths.selectedRecord.power}} can be duplicated.'
+          result = described_class.inject_context_in_value(
+            "#{first_value_part} #{second_value_part}",
+            context_variables
+          )
+
+          expect(result).to eq('It should be electrocute of rank 3. But electrocute can be duplicated.')
+        end
+
+        it 'replaces all currentUser variables' do
+          [
+            { key: 'email', expected_value: user['email'] },
+            { key: 'firstName', expected_value: user['firstName'] },
+            { key: 'lastName', expected_value: user['lastName'] },
+            { key: 'fullName', expected_value: user['fullName'] },
+            { key: 'id', expected_value: user['id'] },
+            { key: 'permissionLevel', expected_value: user['permissionLevel'] },
+            { key: 'roleId', expected_value: user['roleId'] },
+            { key: 'tags.planet', expected_value: user['tags'][0]['planet'] },
+            { key: 'team.id', expected_value: team['id'] },
+            { key: 'team.name', expected_value: team['name'] }
+          ].each do |value|
+            key = value[:key]
+            expected_value = value[:expected_value]
+            expect(
+              described_class.inject_context_in_value(
+                "{{currentUser.#{key}}}",
+                context_variables
+              )
+            ).to eq(expected_value.to_s)
+          end
+        end
+      end
+    end
+  end
+end

data/spec/services/forest_liana/utils/context_variables_spec.rb

@@ -0,0 +1,43 @@
+module ForestLiana
+  module Utils
+    describe ContextVariables do
+      let(:user) do
+        {
+           'id' => '1',
+           'email' => 'jd@forestadmin.com',
+           'first_name' => 'John',
+           'last_name' => 'Doe',
+           'team' => 'Operations',
+           'role' => 'role-test',
+           'tags' => [{'key' => 'tag1', 'value' => 'value1' }, {'key' => 'tag2', 'value' => 'value2'}],
+           'rendering_id'=> '1'
+        }
+      end
+
+      let(:team) do
+        {
+          'id' => 1,
+          'name' => 'Operations'
+        }
+      end
+
+      let(:request_context_variables) do
+        {
+          'foo.id' => 100
+        }
+      end
+
+      it 'returns the request context variable key when the key is not present into the user data' do
+        context_variables = described_class.new(team, user, request_context_variables)
+        expect(context_variables.get_value('foo.id')).to eq(100)
+      end
+
+      it 'returns the corresponding value from the key provided of the user data' do
+        context_variables = described_class.new(team, user, request_context_variables)
+        expect(context_variables.get_value('currentUser.first_name')).to eq('John')
+        expect(context_variables.get_value('currentUser.tags.key')).to eq('tag1')
+        expect(context_variables.get_value('currentUser.team.id')).to eq(1)
+      end
+    end
+  end
+end