Merge branch 'main' into feature/O2B-1508/lhcfills-beam-types-filter

Author: isaachilly

lib/database/utilities/QueryBuilder.js

@@ -145,7 +145,55 @@ class WhereQueryBuilder {
     }
 
     /**
-     * Set the next filter condition according to a comparison operator ("<", "<=", ">=", ">")
+     * Set a min range limit using the provided value OR null (useful when 0 is stored as null)
+     *
+     * @param {*} min the lower limit criteria
+     * @param {boolean} strict if true, the comparison is exclusive, else it will be inclusive (equality match)
+     *
+     * @return {void}
+     */
+    greaterThanOrNull(min, strict) {
+        if (this.notFlag) {
+            this.notFlag = !this.notFlag;
+            this.lowerThan(min, !strict);
+            this.notFlag = !this.notFlag;
+            return;
+        }
+        const operation = {
+            [Op.or]: [
+                { [Op.is]: null },
+                { [strict ? Op.gt : Op.gte]: min },
+            ],
+        };
+        this._op(operation);
+    }
+
+    /**
+     * Set a max range limit using the provided value OR null (useful when 0 is stored as null)
+     *
+     * @param {*} max the upper limit criteria
+     * @param {boolean} strict if true, the comparison is exclusive, else it will be inclusive (equality match)
+     *
+     * @return {void}
+     */
+    lowerThanOrNull(max, strict) {
+        if (this.notFlag) {
+            this.notFlag = !this.notFlag;
+            this.greaterThan(max, !strict);
+            this.notFlag = !this.notFlag;
+            return;
+        }
+        const operation = {
+            [Op.or]: [
+                { [Op.is]: null },
+                { [strict ? Op.lt : Op.lte]: max },
+            ],
+        };
+        this._op(operation);
+    }
+
+    /**
+     * Set the next filter condition according to a comparison operator ("<", "<=", ">=", ">", "=")
      *
      * @param {"<"|"<="|"="|">="|">"} operator the operator to apply
      * @param {*} limit the limit to compare to

lib/usecases/lhcFill/GetAllLhcFillsUseCase.js

@@ -65,14 +65,13 @@ class GetAllLhcFillsUseCase {
                 }
             }
 
-            // Run duration filter and corresponding operator.
             if (runDuration?.limit !== undefined && runDuration?.operator) {
                 associatedStatisticsRequired = true;
                 // 00:00:00 aka 0 value is saved in the DB as null (bookkeeping.fill_statistics.runs_coverage)
-                if ((runDuration.operator === '>=' || runDuration.operator === '<=') && Number(runDuration.limit) === 0) {
-                    // Include 00:00:00 = 0 = null AND everything above 00:00:00 which is more or less than 0.
-                    queryBuilder.whereAssociation('statistics', 'runsCoverage').applyOperator(runDuration.operator, 0);
-                    queryBuilder.whereAssociation('statistics', 'runsCoverage').applyOperator('=', null);
+                if (runDuration.operator === '<=' && Number(runDuration.limit) === 0) {
+                    queryBuilder.whereAssociation('statistics', 'runsCoverage').lowerThanOrNull(0, false);
+                } else if (runDuration.operator === '>=' && Number(runDuration.limit) === 0) {
+                    queryBuilder.whereAssociation('statistics', 'runsCoverage').greaterThanOrNull(0, false);
                 } else if ((runDuration.operator === '>' || runDuration.operator === '<') && Number(runDuration.limit) === 0) {
                     queryBuilder.whereAssociation('statistics', 'runsCoverage').applyOperator(runDuration.operator, 0);
                 } else if (Number(runDuration.limit) === 0) {
@@ -81,6 +80,7 @@ class GetAllLhcFillsUseCase {
                     queryBuilder.whereAssociation('statistics', 'runsCoverage').applyOperator(runDuration.operator, runDuration.limit);
                 }
             }
+
             // Beam duration filter, limit and corresponding operator.
             if (beamDuration?.limit !== undefined && beamDuration?.operator) {
                 queryBuilder.where('stableBeamsDuration').applyOperator(beamDuration.operator, beamDuration.limit);
@@ -99,10 +99,13 @@ class GetAllLhcFillsUseCase {
                 where: { definition: RunDefinition.PHYSICS },
                 required: false,
             });
-            queryBuilder.include({
-                association: 'statistics',
-                required: associatedStatisticsRequired,
-            });
+
+            if (associatedStatisticsRequired) {
+                queryBuilder.include({
+                    association: 'statistics',
+                    required: true,
+                });
+            }
 
             queryBuilder.orderBy('fillNumber', 'desc');
             queryBuilder.limit(limit);

test/lib/database/utilities/QueryBuilder.test.js

@@ -14,6 +14,7 @@
 const {
     repositories: {
         LogRepository,
+        RunRepository,
     },
     utilities: {
         QueryBuilder,
@@ -208,5 +209,84 @@ module.exports = () => {
                 });
             });
         });
+
+        // 104 runs with null inelastic_interaction_rate_avg
+        // 5 runs with inelastic_interaction_rate_avg values: 20000, 40000, 500000, 600000, 755311
+
+        describe('greaterThanOrNull', () => {
+            it('should return entities with inelastic_interaction_rate_avg greater than or equal to 40000 or null', async () => {
+                const queryBuilder = new QueryBuilder();
+                queryBuilder.where('inelastic_interaction_rate_avg').greaterThanOrNull(40000);
+
+                const result = await RunRepository.findAll(queryBuilder);
+                expect(result).to.not.be.null;
+                expect(result).to.have.lengthOf(108);
+                result.forEach(({ inelasticInteractionRateAvg }) => {
+                    expect(inelasticInteractionRateAvg === null || inelasticInteractionRateAvg >= 40000).to.be.true;
+                });
+            });
+
+            it('should return entities with inelastic_interaction_rate_avg greater than 40000 or null', async () => {
+                const queryBuilder = new QueryBuilder();
+                queryBuilder.where('inelastic_interaction_rate_avg').greaterThanOrNull(40000, true);
+
+                const result = await RunRepository.findAll(queryBuilder);
+                expect(result).to.not.be.null;
+                expect(result).to.have.lengthOf(107);
+                result.forEach(({ inelasticInteractionRateAvg }) => {
+                    expect(inelasticInteractionRateAvg === null || inelasticInteractionRateAvg > 40000).to.be.true;
+                });
+            });
+
+            it('should return entities with not (inelasticInteractionRateAvg >= 40000 or null)', async () => {
+                const queryBuilder = new QueryBuilder();
+                queryBuilder.where('inelastic_interaction_rate_avg').not().greaterThanOrNull(40000);
+
+                const result = await RunRepository.findAll(queryBuilder);
+                expect(result).to.not.be.null;
+                expect(result).to.have.lengthOf(1);
+                result.forEach(({ inelasticInteractionRateAvg }) => {
+                    expect(inelasticInteractionRateAvg < 40000).to.be.true;
+                });
+            });
+        });
+
+        describe('lowerThanOrNull', () => {
+            it('should return entities with inelastic_interaction_rate_avg lower than or equal to 500000 or null', async () => {
+                const queryBuilder = new QueryBuilder();
+                queryBuilder.where('inelastic_interaction_rate_avg').lowerThanOrNull(500000);
+
+                const result = await RunRepository.findAll(queryBuilder);
+                expect(result).to.not.be.null;
+                expect(result).to.have.lengthOf(107);
+                result.forEach(({ inelasticInteractionRateAvg }) => {
+                    expect(inelasticInteractionRateAvg === null || inelasticInteractionRateAvg <= 500000).to.be.true;
+                });
+            });
+
+            it('should return entities with inelastic_interaction_rate_avg lower than 500000 or null', async () => {
+                const queryBuilder = new QueryBuilder();
+                queryBuilder.where('inelastic_interaction_rate_avg').lowerThanOrNull(500000, true);
+
+                const result = await RunRepository.findAll(queryBuilder);
+                expect(result).to.not.be.null;
+                expect(result).to.have.lengthOf(106);
+                result.forEach(({ inelasticInteractionRateAvg }) => {
+                    expect(inelasticInteractionRateAvg === null || inelasticInteractionRateAvg < 500000).to.be.true;
+                });
+            });
+
+            it('should return entities with not (inelastic_interaction_rate_avg <= 500000 or null)', async () => {
+                const queryBuilder = new QueryBuilder();
+                queryBuilder.where('inelastic_interaction_rate_avg').not().lowerThanOrNull(500000);
+
+                const result = await RunRepository.findAll(queryBuilder);
+                expect(result).to.not.be.null;
+                expect(result).to.have.lengthOf(2);
+                result.forEach(({ inelasticInteractionRateAvg }) => {
+                    expect(inelasticInteractionRateAvg > 500000).to.be.true;
+                });
+            });
+        });
     });
 };

test/lib/usecases/lhcFill/GetAllLhcFillsUseCase.test.js

@@ -111,7 +111,7 @@ module.exports = () => {
         });
     });
 
-     it('should only contain specified stable beam durations, <= 12:00:00', async () => {
+    it('should only contain specified stable beam durations, <= 12:00:00', async () => {
         getAllLhcFillsDto.query = { filter: { beamDuration: {limit: '43200', operator: '<='} } };
         const { lhcFills } = await new GetAllLhcFillsUseCase().execute(getAllLhcFillsDto)
         expect(lhcFills).to.be.an('array').and.lengthOf(4)
@@ -129,32 +129,70 @@ module.exports = () => {
         });
     });
 
-     it('should only contain specified stable beam durations, >= 00:01:40', async () => {
+    it('should only contain specified stable beam durations, >= 00:01:40', async () => {
         getAllLhcFillsDto.query = { filter: { beamDuration: {limit: '100', operator: '>='} } };
         const { lhcFills } = await new GetAllLhcFillsUseCase().execute(getAllLhcFillsDto)
 
         expect(lhcFills).to.be.an('array').and.lengthOf(4)
         lhcFills.forEach((lhcFill) => {
             expect(lhcFill.stableBeamsDuration).greaterThanOrEqual(100)
         });
-     })
+    })
 
-     it('should only contain specified stable beam durations, > 00:01:40', async () => {
+    it('should only contain specified stable beam durations, > 00:01:40', async () => {
         getAllLhcFillsDto.query = { filter: { beamDuration: {limit: '100', operator: '>'} } };
         const { lhcFills } = await new GetAllLhcFillsUseCase().execute(getAllLhcFillsDto)
 
         expect(lhcFills).to.be.an('array').and.lengthOf(1)
         lhcFills.forEach((lhcFill) => {
             expect(lhcFill.stableBeamsDuration).greaterThan(100)
         });
-     })
+    })
 
-     it('should only contain specified stable beam durations, = 00:00:00', async () => {
+    it('should only contain specified stable beam durations, = 00:00:00', async () => {
         getAllLhcFillsDto.query = { filter: { hasStableBeams: true, beamDuration: {limit: '0', operator: '='} } };
         const { lhcFills } = await new GetAllLhcFillsUseCase().execute(getAllLhcFillsDto)
 
         expect(lhcFills).to.be.an('array').and.lengthOf(0)
-     })
+    })
+
+    it('should only contain specified total run duration, < 00:00:00', async () => {
+        getAllLhcFillsDto.query = { filter: { runDuration: {limit: '0', operator: '<'} } };
+        const { lhcFills } = await new GetAllLhcFillsUseCase().execute(getAllLhcFillsDto)
+
+        expect(lhcFills).to.be.an('array').and.lengthOf(0)
+    });
+
+    it('should only contain specified total run duration, > 00:00:00', async () => {
+        getAllLhcFillsDto.query = { filter: { runDuration: {limit: '0', operator: '>'} } };
+        const { lhcFills } = await new GetAllLhcFillsUseCase().execute(getAllLhcFillsDto)
+
+        expect(lhcFills).to.be.an('array').and.lengthOf(1)
+        lhcFills.forEach((lhcFill) => {
+            expect(lhcFill.statistics.runsCoverage).greaterThan(0)
+        });
+    });
+
+    it('should only contain specified total run duration, <= 00:00:00', async () => {
+        getAllLhcFillsDto.query = { filter: { runDuration: {limit: '0', operator: '<='} } };
+        const { lhcFills } = await new GetAllLhcFillsUseCase().execute(getAllLhcFillsDto)
+
+        expect(lhcFills).to.be.an('array').and.lengthOf(4)
+        lhcFills.forEach((lhcFill) => {
+            expect(lhcFill.statistics.runsCoverage).equals(0)
+        });
+    });
+
+    it('should only contain specified total run duration, >= 00:00:00', async () => {
+        getAllLhcFillsDto.query = { filter: { runDuration: {limit: '0', operator: '>='} } };
+        const { lhcFills } = await new GetAllLhcFillsUseCase().execute(getAllLhcFillsDto)
+
+        expect(lhcFills).to.be.an('array').and.lengthOf(5)
+        lhcFills.forEach((lhcFill) => {
+            expect(lhcFill.statistics.runsCoverage).greaterThanOrEqual(0)
+        });
+    });
+
 
     it('should only contain specified total run duration, > 04:00:00', async () => {
         getAllLhcFillsDto.query = { filter: { runDuration: {limit: '14400', operator: '>'} } };