forest_liana 7.0.0.beta.2 → 7.0.0.beta.6

data/spec/services/forest_liana/permissions_checker_live_queries_spec.rb

@@ -20,7 +20,8 @@ module ForestLiana
         })
       ]
     }
-    let(:scope_permissions) { nil }
+    let(:default_rendering_id) { 1 }
+    let(:segments_permissions) { { default_rendering_id => { 'segments' => nil } } }
     let(:default_api_permissions) {
       {
         "data" => {
@@ -41,7 +42,7 @@ module ForestLiana
               }
             },
           },
-          'renderings' => scope_permissions
+          'renderings' => segments_permissions
         },
         "meta" => {
           "rolesACLActivated" => true
@@ -61,7 +62,6 @@ module ForestLiana
         },
       }
     }
-    let(:default_rendering_id) { 1 }
 
     before do
       allow(ForestLiana).to receive(:apimap).and_return(schema)

data/spec/services/forest_liana/permissions_formatter_spec.rb

@@ -14,7 +14,7 @@ module ForestLiana
         }
       }
       let(:old_format_action_permissions) { { 'allowed' => true, 'users' => nil } }
-      let(:old_format_scope_permissions) { nil }
+      let(:old_format_segments_permissions) { nil }
       let(:old_format_permissions) {
         {
           'collection_1' => {
@@ -22,7 +22,7 @@ module ForestLiana
             'actions' => {
               'action_1' => old_format_action_permissions
             },
-            'scope' => old_format_scope_permissions
+            'segments' => old_format_segments_permissions
           }
         }
       }
@@ -197,22 +197,22 @@ module ForestLiana
         end
       end
 
-      describe 'scope permissions' do
-        subject { converted_permission['renderings'][rendering_id]['collection_1']['scope'] }
-        let(:expected_new_format_permissions) { old_format_scope_permissions }
+      describe 'segments permissions' do
+        subject { converted_permission['renderings'][rendering_id]['collection_1']['segments'] }
+        let(:expected_new_format_permissions) { old_format_segments_permissions }
 
-        context 'when scope permissions are set' do
-          let(:old_format_scope_permissions) { { 'dynamicScopesValues' => {}, 'filter' => { 'aggregator' => 'and', 'conditions' => [{ 'field' => 'field_1', 'operator' => 'equal', 'value' => true }] } } }
+        context 'when segments permissions are set' do
+          let(:old_format_segments_permissions) { ['segmentQuery1', 'segmentQuery2'] }
 
-          it 'expected scope permissions should be set' do
+          it 'expected segments permissions should be set' do
             expect(subject).to eq expected_new_format_permissions
           end
         end
 
-        context 'when scope permissions are nil' do
-          let(:old_format_scope_permissions) { nil }
+        context 'when segments permissions are nil' do
+          let(:old_format_segments_permissions) { nil }
 
-          it 'expected scope permissions should be nil' do
+          it 'expected segments permissions should be nil' do
             expect(subject).to eq expected_new_format_permissions
           end
         end

data/spec/services/forest_liana/pie_stat_getter_spec.rb

@@ -0,0 +1,114 @@
+module ForestLiana
+  describe PieStatGetter do
+    let(:rendering_id) { 13 }
+    let(:user) { { 'id' => '1', 'rendering_id' => rendering_id } }
+    let(:records) { [
+      { name: 'Young Tree n1', age: 3 },
+      { name: 'Young Tree n2', age: 3 },
+      { name: 'Young Tree n3', age: 3 },
+      { name: 'Young Tree n4', age: 3 },
+      { name: 'Young Tree n5', age: 3 },
+      { name: 'Old Tree n1', age: 15 },
+      { name: 'Old Tree n2', age: 15 },
+      { name: 'Old Tree n3', age: 15 },
+      { name: 'Old Tree n4', age: 15 }
+    ] }
+
+    before(:each) do
+      ForestLiana::ScopeManager.invalidate_scope_cache(rendering_id)
+      allow(ForestLiana::ScopeManager).to receive(:fetch_scopes).and_return(scopes)
+
+      records.each { |record|
+        Tree.create!(name: record[:name], age: record[:age])
+      }
+    end
+
+    let(:model) { Tree }
+    let(:collection) { 'trees' }
+    let(:params) {
+      {
+        type: 'Pie',
+        collection: collection,
+        timezone: 'Europe/Paris',
+        aggregate: 'Count',
+        group_by_field: group_by_field
+      }
+    }
+
+    subject { PieStatGetter.new(model, params, user) }
+
+    describe 'with empty scopes' do
+      let(:scopes) { { } }
+
+      describe 'with an aggregate on the name field' do
+        let(:group_by_field) { 'name' }
+
+        it 'should be as many categories as records count' do
+          subject.perform
+          expect(subject.record.value).to eq [
+            {:key => "Old Tree n1", :value => 1},
+            {:key => "Old Tree n2", :value => 1},
+            {:key => "Old Tree n3", :value => 1},
+            {:key => "Old Tree n4", :value => 1},
+            {:key => "Young Tree n1", :value => 1},
+            {:key => "Young Tree n2", :value => 1},
+            {:key => "Young Tree n3", :value => 1},
+            {:key => "Young Tree n4", :value => 1},
+            {:key => "Young Tree n5", :value => 1}
+          ]
+        end
+      end
+
+      describe 'with an aggregate on the age field' do
+        let(:group_by_field) { 'age' }
+
+        it 'should be as many categories as different ages among records' do
+          subject.perform
+          expect(subject.record.value).to eq [{ :key => 3, :value => 5}, { :key => 15, :value => 4 }]
+        end
+      end
+    end
+
+    describe 'with scopes' do
+      let(:scopes) {
+        {
+          'Tree' => {
+            'scope'=> {
+              'filter'=> {
+                'aggregator' => 'and',
+                'conditions' => [
+                  { 'field' => 'age', 'operator' => 'less_than', 'value' => 10 }
+                ]
+              },
+              'dynamicScopesValues' => { }
+            }
+          }
+        }
+      }
+
+      describe 'with an aggregate on the name field' do
+        let(:group_by_field) { 'name' }
+
+        it 'should be as many categories as records inside the scope' do
+          subject.perform
+          expect(subject.record.value).to eq [
+            {:key => "Young Tree n1", :value => 1},
+            {:key => "Young Tree n2", :value => 1},
+            {:key => "Young Tree n3", :value => 1},
+            {:key => "Young Tree n4", :value => 1},
+            {:key => "Young Tree n5", :value => 1}
+          ]
+        end
+      end
+
+      describe 'with an aggregate on the age field' do
+        let(:group_by_field) { 'age' }
+
+        it 'should be only one category' do
+          subject.perform
+          expect(subject.record.value).to eq [{ :key => 3, :value => 5}]
+        end
+      end
+    end
+  end
+end

data/spec/services/forest_liana/resource_updater_spec.rb

@@ -0,0 +1,116 @@
+module ForestLiana
+  describe ResourceUpdater do
+    describe 'when updating a record' do
+      let(:params) {
+        ActionController::Parameters.new(
+          id: 1,
+          data: {
+            id: 1,
+            type: 'User',
+            attributes: attributes
+          }
+        )
+      }
+      let(:rendering_id) { 13 }
+      let(:user) { { 'id' => '1', 'rendering_id' => rendering_id } }
+      let(:scopes) { { } }
+
+      subject {
+        described_class.new(User, params, user)
+      }
+
+      before(:each) do
+        User.create(name: 'Merry')
+        ForestLiana::ScopeManager.invalidate_scope_cache(rendering_id)
+        allow(ForestLiana::ScopeManager).to receive(:fetch_scopes).and_return(scopes)
+      end
+
+      after(:each) do
+        User.destroy_all
+      end
+
+      describe 'with empty scopes' do
+        describe 'with a missing name in attributes' do
+          let(:attributes) { { } }
+
+          it 'should not update the record name' do
+            subject.perform
+
+            expect(subject.record.valid?).to be true
+            expect(subject.record.name).to eq 'Merry'
+          end
+        end
+
+        describe 'with a null name in attributes' do
+          let(:attributes) { { name: nil } }
+
+          it 'should set the record name to null' do
+            subject.perform
+
+            expect(subject.record.valid?).to be true
+            expect(subject.record.name).to eq nil
+          end
+        end
+
+        describe 'with a new value as name in attributes' do
+          let(:attributes) { { name: 'Pippin' } }
+
+          it 'should set the record name to null' do
+            subject.perform
+
+            expect(subject.record.valid?).to be true
+            expect(subject.record.name).to eq 'Pippin'
+          end
+        end
+      end
+
+      describe 'with scope excluding target record' do
+        let(:attributes) { { name: 'Gandalf' } }
+        let(:scopes) { {
+          'User' => {
+            'scope'=> {
+              'filter'=> {
+                'aggregator' => 'and',
+                'conditions' => [
+                  { 'field' => 'id', 'operator' => 'greater_than', 'value' => 2 }
+                ]
+              },
+              'dynamicScopesValues' => { }
+            }
+          }
+        } }
+
+        it 'should not update the record name' do
+          subject.perform
+
+          expect(subject.record).to be nil
+          expect(subject.errors[0][:detail]).to eq 'Couldn\'t find User with \'id\'=1 [WHERE (("users"."id" > (2)))]'
+        end
+      end
+
+      describe 'with scope including target record' do
+        let(:attributes) { { name: 'Gandalf' } }
+        let(:scopes) { {
+          'User' => {
+            'scope'=> {
+              'filter'=> {
+                'aggregator' => 'and',
+                'conditions' => [
+                  { 'field' => 'id', 'operator' => 'less_than', 'value' => 2 }
+                ]
+              },
+              'dynamicScopesValues' => { }
+            }
+          }
+        } }
+
+        it 'should not update the record name' do
+          subject.perform
+
+          expect(subject.record.valid?).to be true
+          expect(subject.record.name).to eq 'Gandalf'
+        end
+      end
+    end
+  end
+end

data/spec/services/forest_liana/resources_getter_spec.rb

@@ -6,13 +6,21 @@ module ForestLiana
     let(:sort) { 'id' }
     let(:fields) { }
     let(:filters) { }
+    let(:scopes) { { } }
+    let(:rendering_id) { 13 }
+    let(:user) { { 'id' => '1', 'rendering_id' => rendering_id } }
 
     let(:getter) { described_class.new(resource, {
       page: { size: pageSize, number: pageNumber },
       sort: sort,
       fields: fields,
       filters: filters,
-    })}
+    }, user) }
+
+    def init_scopes
+      ForestLiana::ScopeManager.invalidate_scope_cache(rendering_id)
+      allow(ForestLiana::ScopeManager).to receive(:fetch_scopes).and_return(scopes)
+    end
 
     before(:each) do
       users = ['Michel', 'Robert', 'Vince', 'Sandro', 'Olesya', 'Romain', 'Valentin', 'Jason', 'Arnaud', 'Jeff', 'Steve', 'Marc', 'Xavier', 'Paul', 'Mickael', 'Mike', 'Maxime', 'Gertrude', 'Monique', 'Mia', 'Rachid', 'Edouard', 'Sacha', 'Caro', 'Amand', 'Nathan', 'Noémie', 'Robin', 'Gaelle', 'Isabelle']
@@ -43,6 +51,7 @@ module ForestLiana
       ].map { |location| Location.create(coordinates: location[:coordinates], island: location[:island]) }
 
       reference = Reference.create()
+      init_scopes
     end
 
     after(:each) do
@@ -355,5 +364,63 @@ module ForestLiana
         )
       end
     end
+
+    describe 'when scopes are defined' do
+      let(:resource) { Island }
+      let(:pageSize) { 15 }
+      let(:fields) { }
+      let(:filters) { }
+      let(:scopes) {
+        {
+          'Island' => {
+            'scope'=> {
+              'filter'=> {
+                'aggregator' => 'and',
+                'conditions' => [
+                  { 'field' => 'name', 'operator' => 'contains', 'value' => 'u' }
+                ]
+              },
+              'dynamicScopesValues' => { }
+            }
+          }
+        }
+      }
+
+      describe 'when there are NO filters already defined' do
+        it 'should get only the records matching the scope' do
+          getter.perform
+          records = getter.records
+          count = getter.count
+
+          expect(records.count).to eq 3
+          expect(count).to eq 3
+          expect(records.first.name).to eq 'Skull'
+          expect(records.second.name).to eq 'Muerta'
+          expect(records.third.name).to eq 'Treasure'
+        end
+      end
+
+      describe 'when there are filters already defined' do
+        let(:filters) { {
+          aggregator: 'and',
+          conditions: [{
+            field: 'name',
+            operator: 'contains',
+            value: 'a',
+          }]
+        }.to_json }
+
+        it 'should get only the records matching the scope' do
+          getter.perform
+          records = getter.records
+          count = getter.count
+
+          expect(records.count).to eq 2
+          expect(count).to eq 2
+          expect(records.first.name).to eq 'Muerta'
+          expect(records.second.name).to eq 'Treasure'
+        end
+      end
+    end
   end
 end

data/spec/services/forest_liana/scope_manager_spec.rb

@@ -0,0 +1,232 @@
+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) {
+      {
+        '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' => { }
+        }
+      }
+    }
+    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) }
+
+    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 'when the backend return an errored response' do
+        let(:first_scopes_api_call_response) { Net::HTTPNotFound.new({}, 404, nil) }
+
+        it 'should raise an error' do
+          expect {
+            described_class.get_scope_for_user(user, collection_name)
+          }.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) }
+
+        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 })
+        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 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 })
+        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' }
+                ]
+              },
+              'dynamicScopesValues' => {
+                'users' => { '1' => { '$currentUser.firstName' => 'Valentin' } }
+              }
+            }
+          }
+        }
+        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 })
+        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 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 })
+        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 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 })
+        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 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 })
+        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\"}]}" }
+
+      describe 'when the target collection has NO scopes defined' do
+        let(:first_collection_scope) { { } }
+
+        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
+          end
+        end
+
+        describe 'when providing existing filters' do
+          let(:filters) { described_class.append_scope_for_user(existing_filter, user, collection_name) }
+
+          it 'should return only the exisitng filters' do
+            expect(filters).to eq existing_filter
+          end
+        end
+      end
+
+      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) }
+
+          it 'should return only the scope filters' do
+            expect(filters).to eq first_collection_scope_filter_as_string
+          end
+        end
+
+        describe 'when providing existing filters' do
+          let(:filters) { described_class.append_scope_for_user(existing_filter, user, collection_name) }
+
+          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}]}"
+          end
+        end
+      end
+    end
+  end
+end