forest_liana 7.0.0.beta.4 → 7.0.1

data/spec/requests/resources_spec.rb

@@ -17,6 +17,8 @@ describe 'Requesting Tree resources', :type => :request  do
     allow(ForestLiana::IpWhitelist).to receive(:is_ip_valid) { true }
 
     allow_any_instance_of(ForestLiana::PermissionsChecker).to receive(:is_authorized?) { true }
+
+    allow(ForestLiana::ScopeManager).to receive(:fetch_scopes).and_return({})
   end
 
   token = JWT.encode({

data/spec/services/forest_liana/filters_parser_spec.rb

@@ -11,6 +11,7 @@ module ForestLiana
     let(:date_condition_1) { { 'field' => 'created_at', 'operator' => 'before', 'value' => 2.hours.ago } }
     let(:date_condition_2) { { 'field' => 'created_at', 'operator' => 'today' } }
     let(:date_condition_3) { { 'field' => 'created_at', 'operator' => 'previous_x_days', 'value' => 2 } }
+    let(:presence_condition) { { 'field' => 'name', 'operator' => 'present' } }
 
     before {
       island = Island.create!(name: "L'île de la muerta")
@@ -274,6 +275,11 @@ module ForestLiana
         let(:filters) { { 'aggregator' => 'or', 'conditions' => [simple_condition_2, simple_condition_3] } }
         it { expect(resource.where(query).count).to eq 2 }
       end
+
+      context "'name ends_with \"3\"' 'or' 'name is not null'" do
+        let(:filters) { { 'aggregator' => 'or', 'conditions' => [simple_condition_2, presence_condition] } }
+        it { expect(resource.where(query).count).to eq 3 }
+      end
     end
 
     describe 'parse_condition' do
@@ -281,7 +287,27 @@ module ForestLiana
       let(:result) { filter_parser.parse_condition(condition) }
 
       context 'on valid condition' do
-        it { expect(result).to eq "\"trees\".\"name\" LIKE '%3'" }
+        context 'when the condition uses the contains operator' do
+          it { expect(result).to eq "\"trees\".\"name\" LIKE '%3'" }
+        end
+
+        context 'when the condition uses the blank operator' do
+          let(:condition) { { 'field' => 'name', 'operator' => 'blank' } }
+
+          it { expect(result).to eq "\"trees\".\"name\" IS NULL" }
+        end
+
+        context 'when the condition uses the presence operator' do
+          let(:condition) { presence_condition }
+
+          it { expect(result).to eq "\"trees\".\"name\" IS NOT NULL" }
+        end
+
+        context 'when the condition uses the in operator' do
+          let(:condition) { { 'field' => 'name', 'operator' => 'in', 'value' => ['Tree n1', 'Tree n3'] } }
+
+          it { expect(result).to eq "\"trees\".\"name\" IN ('Tree n1','Tree n3')" }
+        end
       end
 
       context 'on belongs_to condition' do

data/spec/services/forest_liana/has_many_getter_spec.rb

@@ -0,0 +1,116 @@
+module ForestLiana
+  describe HasManyGetter do
+    describe 'when retrieving has many relationship related records' do
+      let(:rendering_id) { 13 }
+      let(:user) { { 'id' => '1', 'rendering_id' => rendering_id } }
+      let(:scopes) { { } }
+      let(:association) { Island.reflect_on_association(:trees) }
+      let(:params) {
+        {
+          id: Island.first.id,
+          association_name: 'trees',
+          page: { size: 15, number: 1 },
+          timezone: 'America/Nome'
+        }
+      }
+
+      subject {
+        described_class.new(Island, association, params, user)
+      }
+
+      before(:each) do
+        madagascar = Island.create(name: 'madagascar')
+        re = Island.create(name: 'ré')
+        Tree.create(name: 'lemon tree', island: madagascar)
+        Tree.create(name: 'banana tree', island: madagascar)
+        Tree.create(name: 'papaya tree', island: madagascar)
+        Tree.create(name: 'apple tree', island: re)
+        Tree.create(name: 'banana tree', island: re)
+        ForestLiana::ScopeManager.invalidate_scope_cache(rendering_id)
+        allow(ForestLiana::ScopeManager).to receive(:fetch_scopes).and_return(scopes)
+      end
+
+      after(:each) do
+        Island.destroy_all
+        Tree.destroy_all
+      end
+
+      describe 'with empty scopes' do
+        describe 'with page 1 size 15' do
+          it 'should return the 3 trees matching madagascar' do
+            subject.perform
+
+            expect(subject.records.count).to eq 3
+            expect(subject.count).to eq 3
+          end
+        end
+
+        describe 'when sorting by decreasing id' do
+          let(:params) {
+            {
+              id: Island.first.id,
+              association_name: 'trees',
+              sort: '-id',
+              page: { size: 15, number: 1 },
+              timezone: 'America/Nome'
+            }
+          }
+
+          it 'should order records properly' do
+            subject.perform
+
+            expect(subject.records.count).to eq 3
+            expect(subject.count).to eq 3
+            expect(subject.records.first.id).to be > subject.records.last.id
+          end
+        end
+
+        describe 'when searching for banana tree' do
+          let(:params) {
+            {
+              id: Island.first.id,
+              association_name: 'trees',
+              search: 'banana',
+              page: { size: 15, number: 1 },
+              timezone: 'America/Nome'
+            }
+          }
+
+          it 'should return only the banana tree linked to madagascar' do
+            subject.perform
+
+            expect(subject.records.count).to eq 1
+            expect(subject.count).to eq 1
+            expect(subject.records.first.island.name).to eq 'madagascar'
+          end
+        end
+      end
+
+      describe 'with scopes' do
+        let(:scopes) { {
+          'Tree' => {
+            'scope'=> {
+              'filter'=> {
+                'aggregator' => 'and',
+                'conditions' => [
+                  { 'field' => 'name', 'operator' => 'contains', 'value' => 'a' }
+                ]
+              },
+              'dynamicScopesValues' => { }
+            }
+          }
+        } }
+
+        describe 'when asking for all trees related to madagascar' do
+          it 'should return trees belonging to madagascar and matching the scopes' do
+            subject.perform
+
+            # Only `papaya` and `banana` contain an `a`
+            expect(subject.records.count).to eq 2
+            expect(subject.count).to eq 2
+          end
+        end
+      end
+    end
+  end
+end

data/spec/services/forest_liana/line_stat_getter_spec.rb

@@ -1,12 +1,21 @@
 module ForestLiana
   describe LineStatGetter do
+    let(:rendering_id) { 13 }
+    let(:user) { { 'id' => '1', 'rendering_id' => rendering_id } }
+    let(:scopes) { { } }
+
+    before(:each) do
+      ForestLiana::ScopeManager.invalidate_scope_cache(rendering_id)
+      allow(ForestLiana::ScopeManager).to receive(:fetch_scopes).and_return(scopes)
+    end
+
     describe 'Check client_timezone function' do
       describe 'with a SQLite database' do
         it 'should return false' do
           expect(LineStatGetter.new(Owner, {
             timezone: "Europe/Paris",
             aggregate: "Count",
-          }).client_timezone).to eq(false)
+          }, user).client_timezone).to eq(false)
         end
       end
 
@@ -16,7 +25,7 @@ module ForestLiana
           expect(LineStatGetter.new(Owner, {
             timezone: "Europe/Paris",
             aggregate: "Count",
-          }).client_timezone).to eq('Europe/Paris')
+          }, user).client_timezone).to eq('Europe/Paris')
         end
       end
     end
@@ -25,7 +34,6 @@ module ForestLiana
       describe 'Using a Count aggregation' do
         describe 'Using a Week time range' do
           it 'should return consistent data based on monday as week_start ' do
-            
             # Week should start on monday
             # 08-05-2021 was a Saturday
             Owner.create(name: 'Michel', hired_at: Date.parse('08-05-2021'));
@@ -38,8 +46,8 @@ module ForestLiana
               aggregate: "Count",
               time_range: "Week",
               group_by_date_field: "hired_at",
-            }).perform
-            
+            }, user).perform
+
             expect(stat.value.find { |item| item[:label] == "W18-2021" }[:values][:value]).to eq(2)
             expect(stat.value.find { |item| item[:label] == "W19-2021" }[:values][:value]).to eq(2)
           end
@@ -47,4 +55,4 @@ module ForestLiana
       end
     end
   end
-end
+end

data/spec/services/forest_liana/permissions_checker_acl_disabled_spec.rb

@@ -191,7 +191,6 @@ module ForestLiana
       end
     end
 
-
     context 'renderings cache' do
       let(:fake_ressource) { collection_name }
       let(:rendering_id) { 1 }
@@ -499,7 +498,7 @@ module ForestLiana
                   expect(subject.is_authorized?).to be false
                 end
               end
-            
+
             end
 
             context 'when user has not the required permission' do
@@ -519,7 +518,6 @@ module ForestLiana
                 expect(subject.is_authorized?).to be false
               end
             end
-
           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