[cascading] from release/11.4 to release/11.5 (#2661)

<!--
{"currentBranch":"release/11.4","targetBranch":"release/11.5","bypassReviewers":true,"isConflicting":false}
-->

## Cascading from release/11.4 to release/11.5


The configuration requests the cascading to bypass reviewer in case of
CI success.
To not bypass the reviewing process, please check the following
checkbox:

- [ ] <!-- !cancel bypass! --> 🚫 stop reviewing process
bypass for this Pull Request




---

<small>This Pull Request has been generated with ❤️ by the
[Otter](https://github.com/AmadeusITGroup/otter) cascading tool.</small>

Author: matthieu-crouzet

packages/@o3r/core/src/utils/deep-fill/deep-fill.spec.ts

@@ -12,6 +12,20 @@ describe('Deep fill function', () => {
     expect(deepFill(base, source)).toEqual(base);
   });
 
+  it('should support "null" value in source', () => {
+    const base = { selection: { field: 'test-field' }, a: 'string' };
+    const source = { selection: null } as any;
+
+    expect(deepFill(base, source)).toEqual({ selection: null, a: 'string' });
+  });
+
+  it('should support "null" value in base', () => {
+    const base = { selection: null, a: 'string' } as any;
+    const source = { selection: { field: 'test-field' } };
+
+    expect(deepFill(base, source)).toEqual({ selection: { field: 'test-field' }, a: 'string' });
+  });
+
   it('should keep properties from base not present in the source', () => {
     const base = Object.freeze({a: 1, b: '2', c: true});
     const source = Object.freeze({c: false, a: 3});

packages/@o3r/core/src/utils/deep-fill/deep-fill.ts

@@ -66,9 +66,11 @@ export function deepFill<T extends { [x: string]: any }>(base: T, source?: { [x:
   }
   const newObj = {...base};
   for (const key in base) {
-    if (key in source && typeof base[key] === typeof source[key]) {
+    if (source[key] === null) {
+      newObj[key] = immutablePrimitive(null, additionalMappers);
+    } else if (key in source && typeof base[key] === typeof source[key]) {
       const keyOfSource = source[key];
-      newObj[key] = typeof keyOfSource === 'undefined' ? immutablePrimitive(base[key], additionalMappers) : deepFill(base[key], source[key], additionalMappers);
+      newObj[key] = typeof keyOfSource === 'undefined' ? immutablePrimitive(base[key], additionalMappers) : deepFill(base[key], keyOfSource, additionalMappers);
     } else {
       newObj[key] = immutablePrimitive(base[key], additionalMappers);
     }

packages/@o3r/rules-engine/src/engine/helpers/filter-ruleset-event.operator.spec.ts

@@ -1,8 +1,8 @@
-import { BehaviorSubject, of } from 'rxjs';
+import { BehaviorSubject, firstValueFrom, of } from 'rxjs';
 import { Operator } from '../operator/operator.interface';
 import { operatorList } from '../operator/operators/index';
 import { RulesetExecutor } from '../ruleset-executor';
-import { ActionBlock, Ruleset } from '../structure';
+import { Ruleset } from '../structure';
 import { filterRulesetsEventStream } from './filter-ruleset-event.operator';
 
 describe('Filter rulesets event operator', () => {
@@ -134,68 +134,45 @@ describe('Filter rulesets event operator', () => {
   }, {});
 
   const firstValue = rulesets.reduce<Record<string, RulesetExecutor>>((accRuleset, ruleset) => {
-    accRuleset[ruleset.id] = new RulesetExecutor(ruleset, {retrieveOrCreateFactStream: () => of(undefined), operators} as any);
+    accRuleset[ruleset.id] = new RulesetExecutor(ruleset, { retrieveOrCreateFactStream: () => of(undefined), operators } as any);
     return accRuleset;
   }, {});
 
   const rulesetsMapSubject$ = new BehaviorSubject<Record<string, RulesetExecutor>>(firstValue);
 
-  test('should consider only first ruleset', (done) => {
+  test('should consider only first ruleset', async () => {
 
-    rulesetsMapSubject$.pipe(
-      filterRulesetsEventStream(['ruleset1'])
-    ).subscribe(data => {
-      expect(data.length).toBe(2);
-      done();
-    });
+    const data = await firstValueFrom(rulesetsMapSubject$.pipe(filterRulesetsEventStream(['ruleset1'])));
+    expect(data.length).toBe(2);
 
   });
 
-  test('should consider only second ruleset', (done) => {
+  test('should consider only second ruleset', async () => {
 
-    rulesetsMapSubject$.pipe(
-      filterRulesetsEventStream(['ruleset2'])
-    ).subscribe(data => {
-      expect(data.length).toBe(1);
-      done();
-    });
+    const data = await firstValueFrom(rulesetsMapSubject$.pipe(filterRulesetsEventStream(['ruleset2'])));
+    expect(data.length).toBe(1);
 
   });
 
-  test('should consider all rulesets by not passing any filter', (done) => {
+  test('should consider all rulesets by not passing any filter', async () => {
 
-    rulesetsMapSubject$.pipe(
-      filterRulesetsEventStream()
-    ).subscribe(data => {
-      expect(data.length).toBe(3);
-      done();
-    });
+    const data = await firstValueFrom(rulesetsMapSubject$.pipe(filterRulesetsEventStream()));
+    expect(data.length).toBe(3);
 
   });
 
-  test('should consider all rulesets ids passed', (done) => {
+  test('should consider all rulesets ids passed', async () => {
 
-    rulesetsMapSubject$.pipe(
-      filterRulesetsEventStream(['ruleset1', 'ruleset2'])
-    ).subscribe(data => {
-      expect(data.length).toBe(3);
-      done();
-    });
+    const data = await firstValueFrom(rulesetsMapSubject$.pipe(filterRulesetsEventStream(['ruleset1', 'ruleset2'])));
+    expect(data.length).toBe(3);
 
   });
 
-  test('should not emit if ruleset id does not match any registered ruleset', async () => {
+  test('should emit an empty array when no rulesets remain active', async () => {
 
-    let emittedActions: ActionBlock[] | undefined;
+    const data = await firstValueFrom(rulesetsMapSubject$.pipe(filterRulesetsEventStream(['ruleset3'])));
+    expect(data.length).toBe(0);
 
-    rulesetsMapSubject$.pipe(
-      filterRulesetsEventStream(['ruleset3'])
-    ).subscribe(data => {
-      emittedActions = data;
-    });
-
-    await jest.advanceTimersByTimeAsync(500);
-    expect(emittedActions).toBe(undefined);
   });
 
 });

packages/@o3r/rules-engine/src/engine/helpers/filter-ruleset-event.operator.ts

@@ -1,4 +1,4 @@
-import { combineLatest, Observable } from 'rxjs';
+import { combineLatest, Observable, of } from 'rxjs';
 import { map, shareReplay, switchMap } from 'rxjs/operators';
 import { RulesetExecutor } from '../ruleset-executor';
 
@@ -14,11 +14,13 @@ export function filterRulesetsEventStream(restrictiveRuleSets?: string[]) {
         Object.values(rulesets).filter((ruleSet) => restrictiveRuleSets.indexOf(ruleSet.id) > -1) :
         Object.values(rulesets);
 
-      return combineLatest(activeRulesets.map((ruleset) => ruleset.rulesResultsSubject$)).pipe(
-        map((item) => item.reduce((acc, currentValue) => {
-          acc.push(...currentValue);
-          return acc;
-        }, [])));
+      return activeRulesets?.length > 0
+        ? combineLatest(activeRulesets.map((ruleset) => ruleset.rulesResultsSubject$)).pipe(
+          map((item) => item.reduce((acc, currentValue) => {
+            acc.push(...currentValue);
+            return acc;
+          }, [])))
+        : of([]);
     }),
     shareReplay(1)
   );

packages/@o3r/rules-engine/src/services/runner/rules-engine.runner.service.spec.ts

@@ -273,7 +273,7 @@ describe('Rules engine service', () => {
       next: value => nextFn(value)
     });
     // should output no actions as all rulesets are on demand
-    expect(nextFn).not.toHaveBeenCalled();
+    expect(nextFn).toHaveBeenCalledWith([]);
     sub.unsubscribe();
 
     // activate ruleset 1 via his own linked component