@reltio/components 1.4.2231 → 1.4.2233

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

@@ -8,7 +8,8 @@ var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
     return to.concat(ar || Array.prototype.slice.call(from));
 };
 import { DataTypes, ParticipationStatus } from '@reltio/mdm-sdk';
-import { COLUMNS_DATA, countAttributeValues, getBasicTableColumnsData, getBasicTableRowsData, getRuleTypeValues, getWinnerCrosswalks, collectRuleNames } from './helpers';
+import { COLUMNS_DATA, countAttributeValues, getBasicTableColumnsData, getBasicTableRowsData, getWinnerCrosswalks, collectRuleNames } from './helpers';
+import { RuleItemType } from './types';
 import { HeadCellRenderer } from './components/HeadCellRenderer';
 import { AttributesHeadCellRenderer } from './components/AttributesHeadCellRenderer';
 import { OvValuesRenderer } from './components/OvValuesRenderer';
@@ -268,21 +269,9 @@ describe('helpers tests', function () {
                         crosswalks: [crosswalks[0]]
                     },
                     ruleType: {
-                        ruleTypes: [
-                            {
-                                data: {
-                                    strategy: {
-                                        uri: 'configuration/survivorshipStrategies/LUD',
-                                        label: 'Recency'
-                                    },
-                                    comparisonAttributeUri: undefined,
-                                    primaryAttributeUri: undefined,
-                                    sourcesUriOrder: undefined
-                                },
-                                type: 'rule',
-                                valueUri: 'entities/1/attributes/CountryCode/1'
-                            }
-                        ]
+                        attributeType: attrTypes[0],
+                        attributeValues: [],
+                        getRuleTypeData: expect.any(Function)
                     },
                     count: 2,
                     values: {
@@ -301,21 +290,9 @@ describe('helpers tests', function () {
                         crosswalks: []
                     },
                     ruleType: {
-                        ruleTypes: [
-                            {
-                                data: {
-                                    strategy: {
-                                        uri: 'configuration/survivorshipStrategies/Frequency',
-                                        label: 'Frequency'
-                                    },
-                                    comparisonAttributeUri: undefined,
-                                    primaryAttributeUri: undefined,
-                                    sourcesUriOrder: undefined
-                                },
-                                type: 'rule',
-                                valueUri: 'entities/1/attributes/Date/1'
-                            }
-                        ]
+                        attributeType: attrTypes[1],
+                        attributeValues: [],
+                        getRuleTypeData: expect.any(Function)
                     },
                     count: 2,
                     values: {
@@ -334,21 +311,9 @@ describe('helpers tests', function () {
                         crosswalks: attributes['Address'][0]['refRelation']['crosswalks']
                     },
                     ruleType: {
-                        ruleTypes: [
-                            {
-                                data: {
-                                    strategy: {
-                                        uri: 'configuration/survivorshipStrategies/LUD',
-                                        label: 'Recency'
-                                    },
-                                    comparisonAttributeUri: undefined,
-                                    primaryAttributeUri: undefined,
-                                    sourcesUriOrder: undefined
-                                },
-                                type: 'rule',
-                                valueUri: 'entities/1/attributes/Address/1'
-                            }
-                        ]
+                        attributeType: attrTypes[2],
+                        attributeValues: [],
+                        getRuleTypeData: expect.any(Function)
                     },
                     count: 1,
                     values: {
@@ -419,7 +384,7 @@ describe('helpers tests', function () {
                 expect(countAttributeValues(DataTypes.TYPE_NESTED, undefined, crosswalksMap)).toBe(0);
             });
         });
-        describe('getRuleTypeValues', function () {
+        describe('get rule type values', function () {
             var metadata = {
                 entityTypes: [
                     {
@@ -525,6 +490,7 @@ describe('helpers tests', function () {
                     }
                 ]
             };
+            var crosswalksMap = { entity: {}, relation: {} };
             it('should return correct simple rule type', function () {
                 var attributeType = {
                     uri: 'configuration/entityTypes/HCP/attributes/Int',
@@ -532,30 +498,34 @@ describe('helpers tests', function () {
                     name: 'Int',
                     label: 'Int'
                 };
-                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: [
+                var attributes = {
+                    Int: [
                         {
-                            data: {
-                                strategy: {
-                                    uri: 'configuration/survivorshipStrategies/Aggregation',
-                                    label: 'Aggregation'
-                                },
-                                comparisonAttributeUri: undefined,
-                                primaryAttributeUri: undefined,
-                                sourcesUriOrder: undefined
-                            },
-                            type: 'rule',
-                            valueUri: 'entities/1/attributes/Int/1'
+                            uri: 'entities/1/attributes/Int/1',
+                            type: 'configuration/entityTypes/HCP/attributes/Int',
+                            value: '1005',
+                            ov: true
                         }
                     ]
+                };
+                var rows = getBasicTableRowsData(metadata, 'configuration/entityTypes/HCP', [attributeType], ['ruleType'], crosswalksMap, attributes);
+                var result = rows[0].ruleType;
+                expect(result).toEqual({
+                    attributeType: attributeType,
+                    attributeValues: [],
+                    getRuleTypeData: expect.any(Function)
+                });
+                expect(result.getRuleTypeData(attributeType, result.attributeValues[0])).toEqual({
+                    type: RuleItemType.Rule,
+                    data: {
+                        strategy: {
+                            uri: 'configuration/survivorshipStrategies/Aggregation',
+                            label: 'Aggregation'
+                        },
+                        comparisonAttributeUri: undefined,
+                        primaryAttributeUri: undefined,
+                        sourcesUriOrder: undefined
+                    }
                 });
             });
             it('should return correct rule type based on active strategy', function () {
@@ -565,30 +535,34 @@ describe('helpers tests', function () {
                     name: 'Int',
                     label: 'Int'
                 };
-                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: [
+                var attributes = {
+                    Int: [
                         {
-                            data: {
-                                strategy: {
-                                    uri: 'configuration/survivorshipStrategies/LUD',
-                                    label: 'Recency'
-                                },
-                                comparisonAttributeUri: undefined,
-                                primaryAttributeUri: undefined,
-                                sourcesUriOrder: undefined
-                            },
-                            type: 'rule',
-                            valueUri: 'entities/1/attributes/Int/1'
+                            uri: 'entities/1/attributes/Int/1',
+                            type: 'configuration/entityTypes/HCP/attributes/Int',
+                            value: '1005',
+                            ov: true
                         }
                     ]
+                };
+                var rows = getBasicTableRowsData(metadata, 'configuration/entityTypes/HCP', [attributeType], ['ruleType'], crosswalksMap, attributes, 'configuration/entityTypes/HCP/survivorshipGroups/allRecency');
+                var result = rows[0].ruleType;
+                expect(result).toEqual({
+                    attributeType: attributeType,
+                    attributeValues: [],
+                    getRuleTypeData: expect.any(Function)
+                });
+                expect(result.getRuleTypeData(attributeType, result.attributeValues[0])).toEqual({
+                    type: RuleItemType.Rule,
+                    data: {
+                        strategy: {
+                            uri: 'configuration/survivorshipStrategies/LUD',
+                            label: 'Recency'
+                        },
+                        comparisonAttributeUri: undefined,
+                        primaryAttributeUri: undefined,
+                        sourcesUriOrder: undefined
+                    }
                 });
             });
             it('should use default one if strategy url is incorrect', function () {
@@ -598,30 +572,34 @@ describe('helpers tests', function () {
                     name: 'Int',
                     label: 'Int'
                 };
-                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: [
+                var attributes = {
+                    Int: [
                         {
-                            data: {
-                                strategy: {
-                                    uri: 'configuration/survivorshipStrategies/Aggregation',
-                                    label: 'Aggregation'
-                                },
-                                comparisonAttributeUri: undefined,
-                                primaryAttributeUri: undefined,
-                                sourcesUriOrder: undefined
-                            },
-                            type: 'rule',
-                            valueUri: 'entities/1/attributes/Int/1'
+                            uri: 'entities/1/attributes/Int/1',
+                            type: 'configuration/entityTypes/HCP/attributes/Int',
+                            value: '1005',
+                            ov: true
                         }
                     ]
+                };
+                var rows = getBasicTableRowsData(metadata, 'configuration/entityTypes/HCP', [attributeType], ['ruleType'], crosswalksMap, attributes, 'configuration/entityTypes/HCP/survivorshipGroups/unexisting');
+                var result = rows[0].ruleType;
+                expect(result).toEqual({
+                    attributeType: attributeType,
+                    attributeValues: [],
+                    getRuleTypeData: expect.any(Function)
+                });
+                expect(result.getRuleTypeData(attributeType, result.attributeValues[0])).toEqual({
+                    type: RuleItemType.Rule,
+                    data: {
+                        strategy: {
+                            uri: 'configuration/survivorshipStrategies/Aggregation',
+                            label: 'Aggregation'
+                        },
+                        comparisonAttributeUri: undefined,
+                        primaryAttributeUri: undefined,
+                        sourcesUriOrder: undefined
+                    }
                 });
             });
             it('should return correct rule type with sourcesUriOrder', function () {
@@ -631,30 +609,34 @@ describe('helpers tests', function () {
                     name: 'Gender',
                     label: 'Gender'
                 };
-                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: [
+                var attributes = {
+                    Gender: [
                         {
-                            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'
+                            uri: 'entities/1/attributes/Gender/1',
+                            type: 'configuration/entityTypes/HCP/attributes/Gender',
+                            value: 'F',
+                            ov: true
                         }
                     ]
+                };
+                var rows = getBasicTableRowsData(metadata, 'configuration/entityTypes/HCP', [attributeType], ['ruleType'], crosswalksMap, attributes);
+                var result = rows[0].ruleType;
+                expect(result).toEqual({
+                    attributeType: attributeType,
+                    attributeValues: [],
+                    getRuleTypeData: expect.any(Function)
+                });
+                expect(result.getRuleTypeData(attributeType, result.attributeValues[0])).toEqual({
+                    type: RuleItemType.Rule,
+                    data: {
+                        strategy: {
+                            uri: 'configuration/survivorshipStrategies/SRC_SYS',
+                            label: 'Source system'
+                        },
+                        comparisonAttributeUri: undefined,
+                        primaryAttributeUri: undefined,
+                        sourcesUriOrder: ['configuration/sources/TEST', 'configuration/sources/Reltio']
+                    }
                 });
             });
             it('should return correct rule type with primaryAttributeUri', function () {
@@ -664,30 +646,34 @@ describe('helpers tests', function () {
                     name: 'ScheduledDrug',
                     label: 'ScheduledDrug'
                 };
-                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: [
+                var attributes = {
+                    ScheduledDrug: [
                         {
-                            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'
+                            uri: 'entities/1/attributes/ScheduledDrug/1',
+                            type: 'configuration/entityTypes/HCP/attributes/ScheduledDrug',
+                            value: 'Aspirin',
+                            ov: true
                         }
                     ]
+                };
+                var rows = getBasicTableRowsData(metadata, 'configuration/entityTypes/HCP', [attributeType], ['ruleType'], crosswalksMap, attributes);
+                var result = rows[0].ruleType;
+                expect(result).toEqual({
+                    attributeType: attributeType,
+                    attributeValues: [],
+                    getRuleTypeData: expect.any(Function)
+                });
+                expect(result.getRuleTypeData(attributeType, result.attributeValues[0])).toEqual({
+                    type: RuleItemType.Rule,
+                    data: {
+                        strategy: {
+                            uri: 'configuration/survivorshipStrategies/OtherAttributeWinnerCrosswalk',
+                            label: 'Other Attribute Winner Crosswalk'
+                        },
+                        comparisonAttributeUri: undefined,
+                        primaryAttributeUri: 'configuration/entityTypes/HCP/attributes/CountryCode',
+                        sourcesUriOrder: undefined
+                    }
                 });
             });
             it('should return correct rule type with comparisonAttributeUri', function () {
@@ -698,30 +684,34 @@ describe('helpers tests', function () {
                     label: 'Address',
                     referencedAttributeURIs: ['configuration/relationTypes/HasAddress/attributes/Status']
                 };
-                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: [
+                var attributes = {
+                    Address: [
                         {
-                            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'
+                            uri: 'entities/1/attributes/Address/1',
+                            type: 'configuration/entityTypes/HCP/attributes/Address',
+                            value: {},
+                            ov: true
                         }
                     ]
+                };
+                var rows = getBasicTableRowsData(metadata, 'configuration/entityTypes/HCP', [attributeType], ['ruleType'], crosswalksMap, attributes);
+                var result = rows[0].ruleType;
+                expect(result).toEqual({
+                    attributeType: attributeType,
+                    attributeValues: [],
+                    getRuleTypeData: expect.any(Function)
+                });
+                expect(result.getRuleTypeData(attributeType, result.attributeValues[0])).toEqual({
+                    type: RuleItemType.Rule,
+                    data: {
+                        strategy: {
+                            uri: 'configuration/survivorshipStrategies/MinValue',
+                            label: 'Minimum value'
+                        },
+                        comparisonAttributeUri: 'configuration/relationTypes/HasAddress/attributes/Status',
+                        primaryAttributeUri: undefined,
+                        sourcesUriOrder: undefined
+                    }
                 });
             });
             it('should return rule type with fallback labels if last applied survivorship rules differ from default one', function () {
@@ -731,36 +721,51 @@ describe('helpers tests', function () {
                     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']
+                var attributes = {
+                    Int: [
+                        {
+                            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: [
+                    ]
+                };
+                var rows = getBasicTableRowsData(metadata, 'configuration/entityTypes/HCP', [attributeType], ['ruleType'], crosswalksMap, attributes);
+                var result = rows[0].ruleType;
+                expect(result).toEqual({
+                    attributeType: attributeType,
+                    attributeValues: [
                         {
-                            data: {
-                                strategy: {
-                                    uri: 'configuration/survivorshipStrategies/Frequency',
-                                    label: 'Frequency'
-                                },
-                                comparisonAttributeUri: undefined,
-                                primaryAttributeUri: undefined,
-                                sourcesUriOrder: undefined
-                            },
-                            type: 'rule',
-                            valueUri: 'entities/123abc/attributes/Int/345fgh'
+                            uri: 'entities/123abc/attributes/Int/345fgh',
+                            value: '1005',
+                            ovDetails: {
+                                participationStatus: ParticipationStatus.Strategy,
+                                appliedSurvivorshipRules: {
+                                    SRC_SYS: [{ SRC_SYS: ['SRC_SYS', 'Aggregation'] }, { SRC_SYS: ['LUD'] }, 'Frequency']
+                                }
+                            }
                         }
-                    ]
+                    ],
+                    getRuleTypeData: expect.any(Function)
+                });
+                expect(result.getRuleTypeData(attributeType, result.attributeValues[0])).toEqual({
+                    type: RuleItemType.Rule,
+                    data: {
+                        strategy: {
+                            uri: 'configuration/survivorshipStrategies/Frequency',
+                            label: 'Frequency'
+                        },
+                        comparisonAttributeUri: undefined,
+                        primaryAttributeUri: undefined,
+                        sourcesUriOrder: undefined
+                    }
                 });
             });
             it('should return rule types per OV value with duplicates and ignore non-OV values', function () {
@@ -770,98 +775,119 @@ describe('helpers tests', function () {
                     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']
+                var attributes = {
+                    Int: [
+                        {
+                            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']
+                        },
+                        {
+                            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']
+                                }
                             }
-                        }
-                    },
-                    {
-                        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/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'] }]
+                        },
+                        {
+                            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: [
+                    ]
+                };
+                var rows = getBasicTableRowsData(metadata, 'configuration/entityTypes/HCP', [attributeType], ['ruleType'], crosswalksMap, attributes);
+                var result = rows[0].ruleType;
+                expect(result).toEqual({
+                    attributeType: attributeType,
+                    attributeValues: [
                         {
-                            data: {
-                                strategy: {
-                                    uri: 'configuration/survivorshipStrategies/Frequency',
-                                    label: 'Frequency'
-                                },
-                                comparisonAttributeUri: undefined,
-                                primaryAttributeUri: undefined,
-                                sourcesUriOrder: undefined
-                            },
-                            type: 'rule',
-                            valueUri: 'entities/123abc/attributes/Int/345fgh'
+                            uri: 'entities/123abc/attributes/Int/345fgh',
+                            value: '1005',
+                            ovDetails: {
+                                participationStatus: ParticipationStatus.Strategy,
+                                appliedSurvivorshipRules: {
+                                    SRC_SYS: [{ SRC_SYS: ['SRC_SYS', 'Aggregation'] }, 'Frequency']
+                                }
+                            }
                         },
                         {
-                            data: {
-                                strategy: {
-                                    uri: 'configuration/survivorshipStrategies/Frequency',
-                                    label: 'Frequency'
-                                },
-                                comparisonAttributeUri: undefined,
-                                primaryAttributeUri: undefined,
-                                sourcesUriOrder: undefined
-                            },
-                            type: 'rule',
-                            valueUri: 'entities/123abc/attributes/Int/ghj565'
+                            uri: 'entities/123abc/attributes/Int/ghj565',
+                            value: '1006',
+                            ovDetails: {
+                                participationStatus: ParticipationStatus.Strategy,
+                                appliedSurvivorshipRules: {
+                                    SRC_SYS: [{ SRC_SYS: ['SRC_SYS', 'Aggregation'] }, 'Frequency']
+                                }
+                            }
                         },
                         {
-                            data: {
-                                strategy: {
-                                    uri: 'configuration/survivorshipStrategies/LUD',
-                                    label: 'Recency'
-                                },
-                                comparisonAttributeUri: undefined,
-                                primaryAttributeUri: undefined,
-                                sourcesUriOrder: undefined
-                            },
-                            type: 'rule',
-                            valueUri: 'entities/123abc/attributes/Int/xfjhy6'
+                            uri: 'entities/123abc/attributes/Int/xfjhy6',
+                            value: '1007',
+                            ovDetails: {
+                                participationStatus: ParticipationStatus.Strategy,
+                                appliedSurvivorshipRules: {
+                                    SRC_SYS: [{ SRC_SYS: ['SRC_SYS', 'Aggregation'] }, { SRC_SYS: ['LUD'] }]
+                                }
+                            }
                         }
-                    ]
+                    ],
+                    getRuleTypeData: expect.any(Function)
+                });
+                expect(result.getRuleTypeData(attributeType, result.attributeValues[0])).toEqual({
+                    type: RuleItemType.Rule,
+                    data: {
+                        strategy: {
+                            uri: 'configuration/survivorshipStrategies/Frequency',
+                            label: 'Frequency'
+                        },
+                        comparisonAttributeUri: undefined,
+                        primaryAttributeUri: undefined,
+                        sourcesUriOrder: undefined
+                    }
+                });
+                expect(result.getRuleTypeData(attributeType, result.attributeValues[2])).toEqual({
+                    type: RuleItemType.Rule,
+                    data: {
+                        strategy: {
+                            uri: 'configuration/survivorshipStrategies/LUD',
+                            label: 'Recency'
+                        },
+                        comparisonAttributeUri: undefined,
+                        primaryAttributeUri: undefined,
+                        sourcesUriOrder: undefined
+                    }
                 });
             });
             it('should return default rule type if applied survivorship rules are invalid', function () {
@@ -871,34 +897,47 @@ describe('helpers tests', function () {
                     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: [
+                var attributes = {
+                    Int: [
                         {
-                            data: {
-                                strategy: {
-                                    uri: 'configuration/survivorshipStrategies/Aggregation',
-                                    label: 'Aggregation'
-                                },
-                                comparisonAttributeUri: undefined,
-                                primaryAttributeUri: undefined,
-                                sourcesUriOrder: undefined
-                            },
-                            type: 'rule',
-                            valueUri: 'entities/123abc/attributes/Int/345fgh'
+                            uri: 'entities/123abc/attributes/Int/345fgh',
+                            type: 'configuration/entityTypes/HCP/attributes/Int',
+                            value: '1005',
+                            ov: true,
+                            ovDetails: {
+                                participationStatus: ParticipationStatus.Strategy,
+                                appliedSurvivorshipRules: 'N/A'
+                            }
                         }
                     ]
+                };
+                var rows = getBasicTableRowsData(metadata, 'configuration/entityTypes/HCP', [attributeType], ['ruleType'], crosswalksMap, attributes);
+                var result = rows[0].ruleType;
+                expect(result).toEqual({
+                    attributeType: attributeType,
+                    attributeValues: [
+                        {
+                            uri: 'entities/123abc/attributes/Int/345fgh',
+                            value: '1005',
+                            ovDetails: {
+                                participationStatus: ParticipationStatus.Strategy,
+                                appliedSurvivorshipRules: 'N/A'
+                            }
+                        }
+                    ],
+                    getRuleTypeData: expect.any(Function)
+                });
+                expect(result.getRuleTypeData(attributeType, result.attributeValues[0])).toEqual({
+                    type: RuleItemType.Rule,
+                    data: {
+                        strategy: {
+                            uri: 'configuration/survivorshipStrategies/Aggregation',
+                            label: 'Aggregation'
+                        },
+                        comparisonAttributeUri: undefined,
+                        primaryAttributeUri: undefined,
+                        sourcesUriOrder: undefined
+                    }
                 });
             });
             it('should return rule type with sourcesUriOrder from applied survivorship rules', function () {
@@ -908,37 +947,50 @@ describe('helpers tests', function () {
                     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: [
+                var attributes = {
+                    Int: [
                         {
-                            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'
+                            uri: 'entities/123abc/attributes/Int/345fgh',
+                            type: 'configuration/entityTypes/HCP/attributes/Int',
+                            value: '1005',
+                            ov: true,
+                            ovDetails: {
+                                participationStatus: ParticipationStatus.Strategy,
+                                appliedSurvivorshipRules: 'SRC_SYS'
+                            }
                         }
                     ]
+                };
+                var rows = getBasicTableRowsData(metadata, 'configuration/entityTypes/HCP', [attributeType], ['ruleType'], crosswalksMap, attributes);
+                var result = rows[0].ruleType;
+                expect(result).toEqual({
+                    attributeType: attributeType,
+                    attributeValues: [
+                        {
+                            uri: 'entities/123abc/attributes/Int/345fgh',
+                            value: '1005',
+                            ovDetails: {
+                                participationStatus: ParticipationStatus.Strategy,
+                                appliedSurvivorshipRules: 'SRC_SYS'
+                            }
+                        }
+                    ],
+                    getRuleTypeData: expect.any(Function)
+                });
+                expect(result.getRuleTypeData(attributeType, result.attributeValues[0])).toEqual({
+                    type: RuleItemType.Rule,
+                    data: {
+                        strategy: {
+                            uri: 'configuration/survivorshipStrategies/SRC_SYS',
+                            label: 'Source system'
+                        },
+                        comparisonAttributeUri: undefined,
+                        primaryAttributeUri: undefined,
+                        sourcesUriOrder: ['configuration/sources/TEST', 'configuration/sources/Reltio']
+                    }
                 });
             });
-            it('should return default rule type for complex attribute even if there are different applied survivorship rules', function () {
+            it('should return applied survivorship rule type for reference attribute', function () {
                 var attributeType = {
                     uri: 'configuration/entityTypes/HCP/attributes/Address',
                     type: 'Reference',
@@ -946,42 +998,169 @@ describe('helpers tests', function () {
                     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'
+                var attributes = {
+                    Address: [
+                        {
+                            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'
+                            }
+                        }
+                    ]
+                };
+                var rows = getBasicTableRowsData(metadata, 'configuration/entityTypes/HCP', [attributeType], ['ruleType'], crosswalksMap, attributes);
+                var result = rows[0].ruleType;
+                expect(result).toEqual({
+                    attributeType: attributeType,
+                    attributeValues: [
+                        {
+                            uri: 'entities/123abc/attributes/Address/345fgh',
+                            value: {
+                                Status: [
+                                    {
+                                        uri: 'entities/123abc/attributes/Status/345fgh',
+                                        type: 'configuration/relationTypes/HasAddress/attributes/Status',
+                                        value: '1005'
+                                    }
+                                ]
+                            },
+                            ovDetails: {
+                                participationStatus: ParticipationStatus.Strategy,
+                                appliedSurvivorshipRules: 'Aggregation'
+                            }
+                        }
+                    ],
+                    getRuleTypeData: expect.any(Function)
+                });
+                expect(result.getRuleTypeData(attributeType, result.attributeValues[0])).toEqual({
+                    type: RuleItemType.Rule,
+                    data: {
+                        strategy: {
+                            uri: 'configuration/survivorshipStrategies/Aggregation',
+                            label: 'Aggregation'
                         }
                     }
-                ];
-                expect(getRuleTypeValues(metadata, attributeType, 'configuration/entityTypes/HCP', attributeValues)).toEqual({
-                    ruleTypes: [
+                });
+            });
+            it('should return empty attributeValues when input attributeValues is undefined', function () {
+                var attributeType = {
+                    uri: 'configuration/entityTypes/HCP/attributes/Int',
+                    type: 'Int',
+                    name: 'Int',
+                    label: 'Int'
+                };
+                var attributes = {};
+                var rows = getBasicTableRowsData(metadata, 'configuration/entityTypes/HCP', [attributeType], ['ruleType'], crosswalksMap, attributes);
+                var result = rows[0].ruleType;
+                expect(result).toEqual({
+                    attributeType: attributeType,
+                    attributeValues: [],
+                    getRuleTypeData: expect.any(Function)
+                });
+            });
+            it('should return correct rule types for nested attribute', function () {
+                var attributeType = {
+                    uri: 'configuration/entityTypes/HCP/attributes/NestedTest',
+                    type: 'Nested',
+                    name: 'NestedTest',
+                    attributes: [
+                        {
+                            uri: 'configuration/entityTypes/HCP/attributes/NestedTest/attributes/TextField',
+                            type: 'String',
+                            name: 'TextField'
+                        }
+                    ]
+                };
+                var nestedAttrType = {
+                    uri: 'configuration/entityTypes/HCP/attributes/NestedTest/attributes/TextField',
+                    type: 'String',
+                    name: 'TextField'
+                };
+                var attributes = {
+                    NestedTest: [
                         {
-                            data: {
-                                strategy: {
-                                    uri: 'configuration/survivorshipStrategies/MinValue',
-                                    label: 'Minimum value'
-                                },
-                                comparisonAttributeUri: 'configuration/relationTypes/HasAddress/attributes/Status',
-                                primaryAttributeUri: undefined,
-                                sourcesUriOrder: undefined
+                            label: 'Nested value 1',
+                            uri: 'entities/123abc/attributes/NestedTest/345fgh',
+                            value: {
+                                TextField: [
+                                    {
+                                        type: 'configuration/entityTypes/HCP/attributes/NestedTest/attributes/TextField',
+                                        uri: 'entities/123abc/attributes/NestedTest/345fgh/TextField/1',
+                                        value: 'TextField value 1',
+                                        ov: true,
+                                        ovDetails: {
+                                            participationStatus: ParticipationStatus.Strategy,
+                                            appliedSurvivorshipRules: 'Frequency'
+                                        }
+                                    },
+                                    {
+                                        type: 'configuration/entityTypes/HCP/attributes/NestedTest/attributes/TextField',
+                                        uri: 'entities/123abc/attributes/NestedTest/345fgh/TextField/2',
+                                        value: 'TextField value 2',
+                                        ov: true,
+                                        ovDetails: {
+                                            participationStatus: ParticipationStatus.Strategy,
+                                            appliedSurvivorshipRules: 'LUD'
+                                        }
+                                    }
+                                ]
                             },
-                            type: 'rule',
-                            valueUri: 'entities/123abc/attributes/Address/345fgh'
+                            ov: true,
+                            ovDetails: {
+                                participationStatus: ParticipationStatus.Strategy,
+                                appliedSurvivorshipRules: 'Aggregation'
+                            }
                         }
                     ]
+                };
+                var rows = getBasicTableRowsData(metadata, 'configuration/entityTypes/HCP', [attributeType], ['ruleType'], crosswalksMap, attributes);
+                var result = rows[0].ruleType;
+                expect(result.getRuleTypeData(attributeType, result.attributeValues[0])).toEqual({
+                    type: RuleItemType.Rule,
+                    data: {
+                        strategy: {
+                            uri: 'configuration/survivorshipStrategies/Aggregation',
+                            label: 'Aggregation'
+                        }
+                    }
+                });
+                var textFieldValue1 = result.attributeValues[0].value['TextField'][0];
+                expect(result.getRuleTypeData(nestedAttrType, textFieldValue1)).toEqual({
+                    type: RuleItemType.Rule,
+                    data: {
+                        strategy: {
+                            uri: 'configuration/survivorshipStrategies/Frequency',
+                            label: 'Frequency'
+                        },
+                        comparisonAttributeUri: undefined,
+                        primaryAttributeUri: undefined,
+                        sourcesUriOrder: undefined
+                    }
+                });
+                var textFieldValue2 = result.attributeValues[0].value['TextField'][1];
+                expect(result.getRuleTypeData(nestedAttrType, textFieldValue2)).toEqual({
+                    type: RuleItemType.Rule,
+                    data: {
+                        strategy: {
+                            uri: 'configuration/survivorshipStrategies/LUD',
+                            label: 'Recency'
+                        },
+                        comparisonAttributeUri: undefined,
+                        primaryAttributeUri: undefined,
+                        sourcesUriOrder: undefined
+                    }
                 });
             });
         });