npm - @reltio/components - Versions diffs - 1.4.2226 → 1.4.2228 - Mend

@reltio/components 1.4.2226 → 1.4.2228

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (83) hide show

package/features/crosswalks/AttributesTable/helpers.test.js CHANGED Viewed

@@ -7,8 +7,8 @@ var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
     }
     return to.concat(ar || Array.prototype.slice.call(from));
 };
-import { DataTypes } from '@reltio/mdm-sdk';
-import { COLUMNS_DATA, countAttributeValues, getBasicTableColumnsData, getBasicTableRowsData, getRuleTypeValues, getWinnerCrosswalks } from './helpers';
+import { DataTypes, ParticipationStatus } from '@reltio/mdm-sdk';
+import { COLUMNS_DATA, countAttributeValues, getBasicTableColumnsData, getBasicTableRowsData, getRuleTypeValues, getWinnerCrosswalks, collectRuleNames } from './helpers';
 import { HeadCellRenderer } from './components/HeadCellRenderer';
 import { AttributesHeadCellRenderer } from './components/AttributesHeadCellRenderer';
 import { OvValuesRenderer } from './components/OvValuesRenderer';
@@ -268,13 +268,21 @@ describe('helpers tests', function () {
                         crosswalks: [crosswalks[0]]
                     },
                     ruleType: {
-                        ruleType: {
-                            uri: 'configuration/survivorshipStrategies/LUD',
-                            label: 'Recency'
-                        },
-                        comparisonAttributeUri: undefined,
-                        primaryAttributeUri: undefined,
-                        sourcesUriOrder: undefined
+                        ruleTypes: [
+                            {
+                                data: {
+                                    strategy: {
+                                        uri: 'configuration/survivorshipStrategies/LUD',
+                                        label: 'Recency'
+                                    },
+                                    comparisonAttributeUri: undefined,
+                                    primaryAttributeUri: undefined,
+                                    sourcesUriOrder: undefined
+                                },
+                                type: 'rule',
+                                valueUri: 'entities/1/attributes/CountryCode/1'
+                            }
+                        ]
                     },
                     count: 2,
                     values: {
@@ -293,13 +301,21 @@ describe('helpers tests', function () {
                         crosswalks: []
                     },
                     ruleType: {
-                        ruleType: {
-                            uri: 'configuration/survivorshipStrategies/Frequency',
-                            label: 'Frequency'
-                        },
-                        comparisonAttributeUri: undefined,
-                        primaryAttributeUri: undefined,
-                        sourcesUriOrder: undefined
+                        ruleTypes: [
+                            {
+                                data: {
+                                    strategy: {
+                                        uri: 'configuration/survivorshipStrategies/Frequency',
+                                        label: 'Frequency'
+                                    },
+                                    comparisonAttributeUri: undefined,
+                                    primaryAttributeUri: undefined,
+                                    sourcesUriOrder: undefined
+                                },
+                                type: 'rule',
+                                valueUri: 'entities/1/attributes/Date/1'
+                            }
+                        ]
                     },
                     count: 2,
                     values: {
@@ -318,10 +334,21 @@ describe('helpers tests', function () {
                         crosswalks: attributes['Address'][0]['refRelation']['crosswalks']
                     },
                     ruleType: {
-                        ruleType: {
-                            uri: 'configuration/survivorshipStrategies/LUD',
-                            label: 'Recency'
-                        }
+                        ruleTypes: [
+                            {
+                                data: {
+                                    strategy: {
+                                        uri: 'configuration/survivorshipStrategies/LUD',
+                                        label: 'Recency'
+                                    },
+                                    comparisonAttributeUri: undefined,
+                                    primaryAttributeUri: undefined,
+                                    sourcesUriOrder: undefined
+                                },
+                                type: 'rule',
+                                valueUri: 'entities/1/attributes/Address/1'
+                            }
+                        ]
                     },
                     count: 1,
                     values: {
@@ -404,6 +431,12 @@ describe('helpers tests', function () {
                                 name: 'CountryCode',
                                 type: 'String',
                                 uri: 'configuration/entityTypes/HCP/attributes/CountryCode'
+                            },
+                            {
+                                label: 'Int',
+                                name: 'Int',
+                                type: 'Int',
+                                uri: 'configuration/entityTypes/HCP/attributes/Int'
                             }
                         ],
                         survivorshipGroups: [
@@ -458,13 +491,17 @@ describe('helpers tests', function () {
                 ],
                 survivorshipStrategies: [
                     {
-                        uri: 'configuration/survivorshipStrategies/Recency',
+                        uri: 'configuration/survivorshipStrategies/LUD',
                         label: 'Recency'
                     },
                     {
                         uri: 'configuration/survivorshipStrategies/Aggregation',
                         label: 'Aggregation'
                     },
+                    {
+                        uri: 'configuration/survivorshipStrategies/Frequency',
+                        label: 'Frequency'
+                    },
                     {
                         uri: 'configuration/survivorshipStrategies/SRC_SYS',
                         label: 'Source system'
@@ -495,11 +532,30 @@ describe('helpers tests', function () {
                     name: 'Int',
                     label: 'Int'
                 };
-                expect(getRuleTypeValues(metadata, attributeType, 'configuration/entityTypes/HCP')).toEqual({
-                    ruleType: {
-                        uri: 'configuration/survivorshipStrategies/Aggregation',
-                        label: 'Aggregation'
+                var attributeValues = [
+                    {
+                        uri: 'entities/1/attributes/Int/1',
+                        type: 'configuration/entityTypes/HCP/attributes/Int',
+                        value: '1005',
+                        ov: true
                     }
+                ];
+                expect(getRuleTypeValues(metadata, attributeType, 'configuration/entityTypes/HCP', attributeValues)).toEqual({
+                    ruleTypes: [
+                        {
+                            data: {
+                                strategy: {
+                                    uri: 'configuration/survivorshipStrategies/Aggregation',
+                                    label: 'Aggregation'
+                                },
+                                comparisonAttributeUri: undefined,
+                                primaryAttributeUri: undefined,
+                                sourcesUriOrder: undefined
+                            },
+                            type: 'rule',
+                            valueUri: 'entities/1/attributes/Int/1'
+                        }
+                    ]
                 });
             });
             it('should return correct rule type based on active strategy', function () {
@@ -509,11 +565,30 @@ describe('helpers tests', function () {
                     name: 'Int',
                     label: 'Int'
                 };
-                expect(getRuleTypeValues(metadata, attributeType, 'configuration/entityTypes/HCP', 'configuration/entityTypes/HCP/survivorshipGroups/allRecency')).toEqual({
-                    ruleType: {
-                        uri: 'configuration/survivorshipStrategies/Recency',
-                        label: 'Recency'
+                var attributeValues = [
+                    {
+                        uri: 'entities/1/attributes/Int/1',
+                        type: 'configuration/entityTypes/HCP/attributes/Int',
+                        value: '1005',
+                        ov: true
                     }
+                ];
+                expect(getRuleTypeValues(metadata, attributeType, 'configuration/entityTypes/HCP', attributeValues, 'configuration/entityTypes/HCP/survivorshipGroups/allRecency')).toEqual({
+                    ruleTypes: [
+                        {
+                            data: {
+                                strategy: {
+                                    uri: 'configuration/survivorshipStrategies/LUD',
+                                    label: 'Recency'
+                                },
+                                comparisonAttributeUri: undefined,
+                                primaryAttributeUri: undefined,
+                                sourcesUriOrder: undefined
+                            },
+                            type: 'rule',
+                            valueUri: 'entities/1/attributes/Int/1'
+                        }
+                    ]
                 });
             });
             it('should use default one if strategy url is incorrect', function () {
@@ -523,41 +598,96 @@ describe('helpers tests', function () {
                     name: 'Int',
                     label: 'Int'
                 };
-                expect(getRuleTypeValues(metadata, attributeType, 'configuration/entityTypes/HCP', 'configuration/entityTypes/HCP/survivorshipGroups/unexisting')).toEqual({
-                    ruleType: {
-                        uri: 'configuration/survivorshipStrategies/Aggregation',
-                        label: 'Aggregation'
+                var attributeValues = [
+                    {
+                        uri: 'entities/1/attributes/Int/1',
+                        type: 'configuration/entityTypes/HCP/attributes/Int',
+                        value: '1005',
+                        ov: true
                     }
+                ];
+                expect(getRuleTypeValues(metadata, attributeType, 'configuration/entityTypes/HCP', attributeValues, 'configuration/entityTypes/HCP/survivorshipGroups/unexisting')).toEqual({
+                    ruleTypes: [
+                        {
+                            data: {
+                                strategy: {
+                                    uri: 'configuration/survivorshipStrategies/Aggregation',
+                                    label: 'Aggregation'
+                                },
+                                comparisonAttributeUri: undefined,
+                                primaryAttributeUri: undefined,
+                                sourcesUriOrder: undefined
+                            },
+                            type: 'rule',
+                            valueUri: 'entities/1/attributes/Int/1'
+                        }
+                    ]
                 });
             });
             it('should return correct rule type with sourcesUriOrder', function () {
                 var attributeType = {
                     uri: 'configuration/entityTypes/HCP/attributes/Gender',
-                    type: 'Gender',
+                    type: 'String',
                     name: 'Gender',
                     label: 'Gender'
                 };
-                expect(getRuleTypeValues(metadata, attributeType, 'configuration/entityTypes/HCP')).toEqual({
-                    ruleType: {
-                        uri: 'configuration/survivorshipStrategies/SRC_SYS',
-                        label: 'Source system'
-                    },
-                    sourcesUriOrder: ['configuration/sources/TEST', 'configuration/sources/Reltio']
+                var attributeValues = [
+                    {
+                        uri: 'entities/1/attributes/Gender/1',
+                        type: 'configuration/entityTypes/HCP/attributes/Gender',
+                        value: 'F',
+                        ov: true
+                    }
+                ];
+                expect(getRuleTypeValues(metadata, attributeType, 'configuration/entityTypes/HCP', attributeValues)).toEqual({
+                    ruleTypes: [
+                        {
+                            data: {
+                                strategy: {
+                                    uri: 'configuration/survivorshipStrategies/SRC_SYS',
+                                    label: 'Source system'
+                                },
+                                comparisonAttributeUri: undefined,
+                                primaryAttributeUri: undefined,
+                                sourcesUriOrder: ['configuration/sources/TEST', 'configuration/sources/Reltio']
+                            },
+                            type: 'rule',
+                            valueUri: 'entities/1/attributes/Gender/1'
+                        }
+                    ]
                 });
             });
             it('should return correct rule type with primaryAttributeUri', function () {
                 var attributeType = {
                     uri: 'configuration/entityTypes/HCP/attributes/ScheduledDrug',
-                    type: 'ScheduledDrug',
+                    type: 'String',
                     name: 'ScheduledDrug',
                     label: 'ScheduledDrug'
                 };
-                expect(getRuleTypeValues(metadata, attributeType, 'configuration/entityTypes/HCP')).toEqual({
-                    ruleType: {
-                        uri: 'configuration/survivorshipStrategies/OtherAttributeWinnerCrosswalk',
-                        label: 'Other Attribute Winner Crosswalk'
-                    },
-                    primaryAttributeUri: 'configuration/entityTypes/HCP/attributes/CountryCode'
+                var attributeValues = [
+                    {
+                        uri: 'entities/1/attributes/ScheduledDrug/1',
+                        type: 'configuration/entityTypes/HCP/attributes/ScheduledDrug',
+                        value: 'Aspirin',
+                        ov: true
+                    }
+                ];
+                expect(getRuleTypeValues(metadata, attributeType, 'configuration/entityTypes/HCP', attributeValues)).toEqual({
+                    ruleTypes: [
+                        {
+                            data: {
+                                strategy: {
+                                    uri: 'configuration/survivorshipStrategies/OtherAttributeWinnerCrosswalk',
+                                    label: 'Other Attribute Winner Crosswalk'
+                                },
+                                comparisonAttributeUri: undefined,
+                                primaryAttributeUri: 'configuration/entityTypes/HCP/attributes/CountryCode',
+                                sourcesUriOrder: undefined
+                            },
+                            type: 'rule',
+                            valueUri: 'entities/1/attributes/ScheduledDrug/1'
+                        }
+                    ]
                 });
             });
             it('should return correct rule type with comparisonAttributeUri', function () {
@@ -568,12 +698,290 @@ describe('helpers tests', function () {
                     label: 'Address',
                     referencedAttributeURIs: ['configuration/relationTypes/HasAddress/attributes/Status']
                 };
-                expect(getRuleTypeValues(metadata, attributeType, 'configuration/entityTypes/HCP')).toEqual({
-                    ruleType: {
-                        uri: 'configuration/survivorshipStrategies/MinValue',
-                        label: 'Minimum value'
+                var attributeValues = [
+                    {
+                        uri: 'entities/1/attributes/Address/1',
+                        type: 'configuration/entityTypes/HCP/attributes/Address',
+                        value: {},
+                        ov: true
+                    }
+                ];
+                expect(getRuleTypeValues(metadata, attributeType, 'configuration/entityTypes/HCP', attributeValues)).toEqual({
+                    ruleTypes: [
+                        {
+                            data: {
+                                strategy: {
+                                    uri: 'configuration/survivorshipStrategies/MinValue',
+                                    label: 'Minimum value'
+                                },
+                                comparisonAttributeUri: 'configuration/relationTypes/HasAddress/attributes/Status',
+                                primaryAttributeUri: undefined,
+                                sourcesUriOrder: undefined
+                            },
+                            type: 'rule',
+                            valueUri: 'entities/1/attributes/Address/1'
+                        }
+                    ]
+                });
+            });
+            it('should return rule type with fallback labels if last applied survivorship rules differ from default one', function () {
+                var attributeType = {
+                    uri: 'configuration/entityTypes/HCP/attributes/Int',
+                    type: 'Int',
+                    name: 'Int',
+                    label: 'Int'
+                };
+                var attributeValues = [
+                    {
+                        uri: 'entities/123abc/attributes/Int/345fgh',
+                        type: 'configuration/entityTypes/HCP/attributes/Int',
+                        value: '1005',
+                        ov: true,
+                        ovDetails: {
+                            participationStatus: ParticipationStatus.Strategy,
+                            appliedSurvivorshipRules: {
+                                SRC_SYS: [{ SRC_SYS: ['SRC_SYS', 'Aggregation'] }, { SRC_SYS: ['LUD'] }, 'Frequency']
+                            }
+                        }
+                    }
+                ];
+                expect(getRuleTypeValues(metadata, attributeType, 'configuration/entityTypes/HCP', attributeValues)).toEqual({
+                    ruleTypes: [
+                        {
+                            data: {
+                                strategy: {
+                                    uri: 'configuration/survivorshipStrategies/Frequency',
+                                    label: 'Frequency'
+                                },
+                                comparisonAttributeUri: undefined,
+                                primaryAttributeUri: undefined,
+                                sourcesUriOrder: undefined
+                            },
+                            type: 'rule',
+                            valueUri: 'entities/123abc/attributes/Int/345fgh'
+                        }
+                    ]
+                });
+            });
+            it('should return rule types per OV value with duplicates and ignore non-OV values', function () {
+                var attributeType = {
+                    uri: 'configuration/entityTypes/HCP/attributes/Int',
+                    type: 'Int',
+                    name: 'Int',
+                    label: 'Int'
+                };
+                var attributeValues = [
+                    {
+                        uri: 'entities/123abc/attributes/Int/345fgh',
+                        type: 'configuration/entityTypes/HCP/attributes/Int',
+                        value: '1005',
+                        ov: true,
+                        ovDetails: {
+                            participationStatus: ParticipationStatus.Strategy,
+                            appliedSurvivorshipRules: {
+                                SRC_SYS: [{ SRC_SYS: ['SRC_SYS', 'Aggregation'] }, 'Frequency']
+                            }
+                        }
+                    },
+                    {
+                        uri: 'entities/123abc/attributes/Int/ghj565',
+                        type: 'configuration/entityTypes/HCP/attributes/Int',
+                        value: '1006',
+                        ov: true,
+                        ovDetails: {
+                            participationStatus: ParticipationStatus.Strategy,
+                            appliedSurvivorshipRules: {
+                                SRC_SYS: [{ SRC_SYS: ['SRC_SYS', 'Aggregation'] }, 'Frequency']
+                            }
+                        }
                     },
-                    comparisonAttributeUri: 'configuration/relationTypes/HasAddress/attributes/Status'
+                    {
+                        uri: 'entities/123abc/attributes/Int/nonOvValue',
+                        type: 'configuration/entityTypes/HCP/attributes/Int',
+                        value: '1006-non-ov',
+                        ov: false,
+                        ovDetails: {
+                            participationStatus: ParticipationStatus.Strategy,
+                            appliedSurvivorshipRules: {
+                                SRC_SYS: [{ SRC_SYS: ['SRC_SYS', 'Aggregation'] }, 'Aggregation']
+                            }
+                        }
+                    },
+                    {
+                        uri: 'entities/123abc/attributes/Int/xfjhy6',
+                        type: 'configuration/entityTypes/HCP/attributes/Int',
+                        value: '1007',
+                        ov: true,
+                        ovDetails: {
+                            participationStatus: ParticipationStatus.Strategy,
+                            appliedSurvivorshipRules: {
+                                SRC_SYS: [{ SRC_SYS: ['SRC_SYS', 'Aggregation'] }, { SRC_SYS: ['LUD'] }]
+                            }
+                        }
+                    }
+                ];
+                expect(getRuleTypeValues(metadata, attributeType, 'configuration/entityTypes/HCP', attributeValues)).toEqual({
+                    ruleTypes: [
+                        {
+                            data: {
+                                strategy: {
+                                    uri: 'configuration/survivorshipStrategies/Frequency',
+                                    label: 'Frequency'
+                                },
+                                comparisonAttributeUri: undefined,
+                                primaryAttributeUri: undefined,
+                                sourcesUriOrder: undefined
+                            },
+                            type: 'rule',
+                            valueUri: 'entities/123abc/attributes/Int/345fgh'
+                        },
+                        {
+                            data: {
+                                strategy: {
+                                    uri: 'configuration/survivorshipStrategies/Frequency',
+                                    label: 'Frequency'
+                                },
+                                comparisonAttributeUri: undefined,
+                                primaryAttributeUri: undefined,
+                                sourcesUriOrder: undefined
+                            },
+                            type: 'rule',
+                            valueUri: 'entities/123abc/attributes/Int/ghj565'
+                        },
+                        {
+                            data: {
+                                strategy: {
+                                    uri: 'configuration/survivorshipStrategies/LUD',
+                                    label: 'Recency'
+                                },
+                                comparisonAttributeUri: undefined,
+                                primaryAttributeUri: undefined,
+                                sourcesUriOrder: undefined
+                            },
+                            type: 'rule',
+                            valueUri: 'entities/123abc/attributes/Int/xfjhy6'
+                        }
+                    ]
+                });
+            });
+            it('should return default rule type if applied survivorship rules are invalid', function () {
+                var attributeType = {
+                    uri: 'configuration/entityTypes/HCP/attributes/Int',
+                    type: 'Int',
+                    name: 'Int',
+                    label: 'Int'
+                };
+                var attributeValues = [
+                    {
+                        uri: 'entities/123abc/attributes/Int/345fgh',
+                        type: 'configuration/entityTypes/HCP/attributes/Int',
+                        value: '1005',
+                        ov: true,
+                        ovDetails: {
+                            participationStatus: ParticipationStatus.Strategy,
+                            appliedSurvivorshipRules: 'N/A'
+                        }
+                    }
+                ];
+                expect(getRuleTypeValues(metadata, attributeType, 'configuration/entityTypes/HCP', attributeValues)).toEqual({
+                    ruleTypes: [
+                        {
+                            data: {
+                                strategy: {
+                                    uri: 'configuration/survivorshipStrategies/Aggregation',
+                                    label: 'Aggregation'
+                                },
+                                comparisonAttributeUri: undefined,
+                                primaryAttributeUri: undefined,
+                                sourcesUriOrder: undefined
+                            },
+                            type: 'rule',
+                            valueUri: 'entities/123abc/attributes/Int/345fgh'
+                        }
+                    ]
+                });
+            });
+            it('should return rule type with sourcesUriOrder from applied survivorship rules', function () {
+                var attributeType = {
+                    uri: 'configuration/entityTypes/HCP/attributes/Int',
+                    type: 'Int',
+                    name: 'Int',
+                    label: 'Int'
+                };
+                var attributeValues = [
+                    {
+                        uri: 'entities/123abc/attributes/Int/345fgh',
+                        type: 'configuration/entityTypes/HCP/attributes/Int',
+                        value: '1005',
+                        ov: true,
+                        ovDetails: {
+                            participationStatus: ParticipationStatus.Strategy,
+                            appliedSurvivorshipRules: 'SRC_SYS'
+                        }
+                    }
+                ];
+                expect(getRuleTypeValues(metadata, attributeType, 'configuration/entityTypes/HCP', attributeValues)).toEqual({
+                    ruleTypes: [
+                        {
+                            data: {
+                                strategy: {
+                                    uri: 'configuration/survivorshipStrategies/SRC_SYS',
+                                    label: 'Source system'
+                                },
+                                comparisonAttributeUri: undefined,
+                                primaryAttributeUri: undefined,
+                                sourcesUriOrder: ['configuration/sources/TEST', 'configuration/sources/Reltio']
+                            },
+                            type: 'rule',
+                            valueUri: 'entities/123abc/attributes/Int/345fgh'
+                        }
+                    ]
+                });
+            });
+            it('should return default rule type for complex attribute even if there are different applied survivorship rules', function () {
+                var attributeType = {
+                    uri: 'configuration/entityTypes/HCP/attributes/Address',
+                    type: 'Reference',
+                    name: 'Address',
+                    label: 'Address',
+                    referencedAttributeURIs: ['configuration/relationTypes/HasAddress/attributes/Status']
+                };
+                var attributeValues = [
+                    {
+                        uri: 'entities/123abc/attributes/Address/345fgh',
+                        type: 'configuration/entityTypes/HCP/attributes/Address',
+                        value: {
+                            Status: [
+                                {
+                                    uri: 'entities/123abc/attributes/Status/345fgh',
+                                    type: 'configuration/relationTypes/HasAddress/attributes/Status',
+                                    value: '1005'
+                                }
+                            ]
+                        },
+                        ov: true,
+                        ovDetails: {
+                            participationStatus: ParticipationStatus.Strategy,
+                            appliedSurvivorshipRules: 'Aggregation'
+                        }
+                    }
+                ];
+                expect(getRuleTypeValues(metadata, attributeType, 'configuration/entityTypes/HCP', attributeValues)).toEqual({
+                    ruleTypes: [
+                        {
+                            data: {
+                                strategy: {
+                                    uri: 'configuration/survivorshipStrategies/MinValue',
+                                    label: 'Minimum value'
+                                },
+                                comparisonAttributeUri: 'configuration/relationTypes/HasAddress/attributes/Status',
+                                primaryAttributeUri: undefined,
+                                sourcesUriOrder: undefined
+                            },
+                            type: 'rule',
+                            valueUri: 'entities/123abc/attributes/Address/345fgh'
+                        }
+                    ]
                 });
             });
         });
@@ -744,5 +1152,46 @@ describe('helpers tests', function () {
                 expect(getWinnerCrosswalks(undefined, crosswalksMap)).toEqual([]);
             });
         });
+        describe('collectRuleNames', function () {
+            it('should return single rule when input is a string', function () {
+                expect(collectRuleNames('LUD')).toEqual(['LUD']);
+            });
+            it('should return empty array for empty object', function () {
+                expect(collectRuleNames({})).toEqual([]);
+            });
+            it('should flatten nested applied survivorship rules', function () {
+                var rules = {
+                    SRC_SYS: [{ SRC_SYS: ['SRC_SYS', 'Aggregation'] }, { SRC_SYS: ['LUD'] }, 'Frequency']
+                };
+                expect(collectRuleNames(rules)).toEqual([
+                    'SRC_SYS',
+                    'SRC_SYS',
+                    'SRC_SYS',
+                    'Aggregation',
+                    'SRC_SYS',
+                    'LUD',
+                    'Frequency'
+                ]);
+            });
+            it('should handle rules with multiple top-level keys', function () {
+                var rules = {
+                    SRC_SYS: ['LUD', { SRC_SYS: ['SRC_SYS', 'Aggregation'] }],
+                    SRC_SYS2: ['Aggregation']
+                };
+                expect(collectRuleNames(rules)).toEqual([
+                    'SRC_SYS',
+                    'LUD',
+                    'SRC_SYS',
+                    'SRC_SYS',
+                    'Aggregation',
+                    'SRC_SYS2',
+                    'Aggregation'
+                ]);
+            });
+            it('should handle rules with empty nested arrays', function () {
+                var rules = { SRC_SYS: ['LUD', { SRC_SYS: [] }] };
+                expect(collectRuleNames(rules)).toEqual(['SRC_SYS', 'LUD', 'SRC_SYS']);
+            });
+        });
     });
 });