@fluid-experimental/property-properties 0.58.1001 → 0.58.2000-58133

package/dist/test/reversibleChangeset.spec.js

@@ -2,14 +2,14 @@
  * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
  * Licensed under the MIT License.
  */
-/* globals expect*/
+/* globals expect */
 /**
  * @fileoverview In this file, we will test the functions of the property factory.
  */
 const _ = require('lodash');
-const { PropertyFactory } = require('..');
 const { ChangeSet } = require('@fluid-experimental/property-changeset');
 const { Int64, Uint64 } = require('@fluid-experimental/property-common');
+const { PropertyFactory } = require('..');
 const deepCopy = _.cloneDeep;
 describe('Reversible ChangeSets', function () {
     var testRevAndInvCS = function (initialProperty, modificationFunction, expectedRevCS, expectedAfterCS, expectedInverseCS) {
@@ -65,24 +65,24 @@ describe('Reversible ChangeSets', function () {
                 { id: 'directMember', typeid: 'autodesk.tests:ChangeSetApplyAfterTask.memberTemplate-1.0.0' },
                 {
                     id: 'nested', properties: [
-                        { id: 'member', typeid: 'autodesk.tests:ChangeSetApplyAfterTask.nestedTemplate-1.0.0' }
-                    ]
-                }
-            ]
+                        { id: 'member', typeid: 'autodesk.tests:ChangeSetApplyAfterTask.nestedTemplate-1.0.0' },
+                    ],
+                },
+            ],
         };
         var TaskSubjectMemberTemplate = {
             typeid: 'autodesk.tests:ChangeSetApplyAfterTask.memberTemplate-1.0.0',
             properties: [
                 { id: 'progress', typeid: 'Uint32' },
-                { id: 'timeRemaining', typeid: 'Uint32' }
-            ]
+                { id: 'timeRemaining', typeid: 'Uint32' },
+            ],
         };
         var TaskSubjectTestTemplate = {
             typeid: 'autodesk.tests:ChangeSetApplyAfterTask.nodeTemplate-1.0.0',
             properties: [
                 { id: 'result', typeid: 'NodeProperty' },
-                { id: 'integer', typeid: 'Uint32' }
-            ]
+                { id: 'integer', typeid: 'Uint32' },
+            ],
         };
         // Register the templates from the discussion document
         var Vec3Template = {
@@ -90,8 +90,8 @@ describe('Reversible ChangeSets', function () {
             properties: [
                 { id: 'x', typeid: 'Float32' },
                 { id: 'y', typeid: 'Float32' },
-                { id: 'z', typeid: 'Float32' }
-            ]
+                { id: 'z', typeid: 'Float32' },
+            ],
         };
         var Point2DTemplate = {
             typeid: 'autodesk.test:point2d-1.0.0',
@@ -99,37 +99,37 @@ describe('Reversible ChangeSets', function () {
                 {
                     id: 'position', properties: [
                         { id: 'x', typeid: 'Float32' },
-                        { id: 'y', typeid: 'Float32' }
-                    ]
+                        { id: 'y', typeid: 'Float32' },
+                    ],
                 },
                 { id: 'normal', typeid: 'autodesk.test:vector3-1.0.0' },
                 { id: 'neighbours', typeid: 'autodesk.test:vector3-1.0.0', context: 'map' },
-                { id: 'temperature', typeid: 'Float32' }
-            ]
+                { id: 'temperature', typeid: 'Float32' },
+            ],
         };
         var TestArrayFloat32 = {
             typeid: 'autodesk.test:test.arrayfloat32-1.0.0',
             properties: [
-                { id: 'data', typeid: 'Float32', context: 'array' }
-            ]
+                { id: 'data', typeid: 'Float32', context: 'array' },
+            ],
         };
         var SimpleStringTestPropertyTemplate = {
             typeid: 'autodesk.tests:DataStringTestProperty-1.0.0',
             properties: [
-                { id: 'data', typeid: 'String' }
-            ]
+                { id: 'data', typeid: 'String' },
+            ],
         };
         var SimpleRefTestPropertyTemplate = {
             typeid: 'autodesk.tests:DataRefTestProperty-1.0.0',
             properties: [
-                { id: 'data', typeid: 'Reference' }
-            ]
+                { id: 'data', typeid: 'Reference' },
+            ],
         };
         var SimpleMapTestPropertyTemplate = {
             typeid: 'autodesk.tests:MapTestPropertyID-1.0.0',
             properties: [
-                { id: 'data', typeid: 'Float32', context: 'map' }
-            ]
+                { id: 'data', typeid: 'Float32', context: 'map' },
+            ],
         };
         var TestPropertyTemplate = {
             typeid: 'autodesk.tests:MapTestNamedPropertyID-1.0.0',
@@ -137,20 +137,20 @@ describe('Reversible ChangeSets', function () {
             properties: [
                 { id: 'stringProperty', typeid: 'String' },
                 { id: 'stringProperty2', typeid: 'String' },
-                { id: 'map', context: 'map', typeid: 'NamedProperty' }
-            ]
+                { id: 'map', context: 'map', typeid: 'NamedProperty' },
+            ],
         };
         var AnonymousTestPropertyTemplate = {
             typeid: 'autodesk.tests:AnonymousMapTestPropertyID-1.0.0',
             properties: [
-                { id: 'stringProperty', typeid: 'String' }
-            ]
+                { id: 'stringProperty', typeid: 'String' },
+            ],
         };
         var CuststomArrayTemplate = {
             typeid: 'autodesk.tests:CustomArrayChangesetTestID-1.0.0',
             properties: [
-                { id: 'data', typeid: 'autodesk.tests:AnonymousMapTestPropertyID-1.0.0', context: 'array' }
-            ]
+                { id: 'data', typeid: 'autodesk.tests:AnonymousMapTestPropertyID-1.0.0', context: 'array' },
+            ],
         };
         var TestEnumTemplate = {
             typeid: 'autodesk.core:UnitsEnum-1.0.0',
@@ -159,19 +159,19 @@ describe('Reversible ChangeSets', function () {
             properties: [
                 { id: 'm', value: 1, annotation: { description: 'meter' } },
                 { id: 'cm', value: 2, annotation: { description: 'centimeter' } },
-                { id: 'mm', value: 3, annotation: { description: 'millimeter' } }
-            ]
+                { id: 'mm', value: 3, annotation: { description: 'millimeter' } },
+            ],
         };
         PropertyFactory._reregister(TestEnumTemplate);
         var TestBaseContainingEnumTemplate = {
             typeid: 'autodesk.core:CustomWithEnumID-1.0.0',
             properties: [{
-                    id: 'data', typeid: 'autodesk.core:UnitsEnum-1.0.0'
-                }]
+                    id: 'data', typeid: 'autodesk.core:UnitsEnum-1.0.0',
+                }],
         };
         var TestInheritsNodePropertyObject = {
             inherits: ['NodeProperty'],
-            typeid: 'autodesk.tests:SimpleInheritsNodeProperty-1.0.0'
+            typeid: 'autodesk.tests:SimpleInheritsNodeProperty-1.0.0',
         };
         PropertyFactory._reregister(TestInheritsNodePropertyObject);
         PropertyFactory._reregister(TestEnumTemplate);
@@ -515,7 +515,7 @@ describe('Reversible ChangeSets', function () {
                 expect(CS2).to.deep.equal(CS2_copy);
                 // CS2 should no longer contain the removal of A
                 expect(CS1.getSerializedChangeSet()).to.deep.equal({
-                    'modify': { [in_typeid]: { 'arr': { [in_type]: outputArrayOperations } } }
+                    'modify': { [in_typeid]: { 'arr': { [in_type]: outputArrayOperations } } },
                 });
             };
             it('on strings', function () {
@@ -584,10 +584,10 @@ describe('Reversible ChangeSets', function () {
                 'array<Float32>': {
                     'elements': {
                         'modify': [
-                            [1, [1, 2, 3], [0, 1, 2]]
-                        ]
-                    }
-                }
+                            [1, [1, 2, 3], [0, 1, 2]],
+                        ],
+                    },
+                },
             });
             var rebasedCS = CS._rebaseChangeSet({
                 'array<Float32>': {
@@ -596,11 +596,11 @@ describe('Reversible ChangeSets', function () {
                             [
                                 0,
                                 [0, 1, 2, 3],
-                                [1, 2, 3, 4]
-                            ]
-                        ]
-                    }
-                }
+                                [1, 2, 3, 4],
+                            ],
+                        ],
+                    },
+                },
             }, []);
             expect(rebasedCS['array<Float32>'].elements.modify[0].length).to.equal(3);
         });
@@ -634,22 +634,22 @@ describe('Reversible ChangeSets', function () {
             var CS = new ChangeSet({
                 remove: {
                     String: {
-                        testString: 'abcde'
-                    }
-                }
+                        testString: 'abcde',
+                    },
+                },
             });
             CS._stripReversibleChangeSet();
             expect(CS.getSerializedChangeSet()).to.deep.equal({
-                remove: ['testString']
+                remove: ['testString'],
             });
         });
         it('ignore the root when passing it a flag', function () {
             var SCS = {
                 remove: {
                     String: {
-                        testString: 'abcde'
-                    }
-                }
+                        testString: 'abcde',
+                    },
+                },
             };
             var CS = new ChangeSet(SCS);
             CS._stripReversibleChangeSet(true);
@@ -699,7 +699,7 @@ describe('Reversible ChangeSets', function () {
             CS1.applyChangeSet(CS2);
             expect(CS1.getSerializedChangeSet()).to.deep.equal({
                 remove: { 'RepositoryTest:Nametag-1.0.0': { name: 'A' } },
-                insert: { 'RepositoryTest:Nametag-1.0.0': { name: 'B' } }
+                insert: { 'RepositoryTest:Nametag-1.0.0': { name: 'B' } },
             });
         });
         it('matching primitive type remove/insert operations in primitive type arrays', function () {
@@ -722,23 +722,23 @@ describe('Reversible ChangeSets', function () {
                 'data': {
                     'modify': [[1, [21, 22], [11, 12]]],
                     'remove': [[4, [14, 15, 16]]],
-                    'insert': [[0, [9]]]
-                }
-            }
+                    'insert': [[0, [9]]],
+                },
+            },
         }, {
             'array<Float32>': {
                 'data': {
-                    'insert': [[0, [9, 10, 21, 22, 13]]]
-                }
-            }
+                    'insert': [[0, [9, 10, 21, 22, 13]]],
+                },
+            },
         }, {
             'array<Float32>': {
                 'data': {
                     'modify': [[2, [11, 12], [21, 22]]],
                     'insert': [[5, [14, 15, 16]]],
-                    'remove': [[0, [9]]]
-                }
-            }
+                    'remove': [[0, [9]]],
+                },
+            },
         });
     });
     it('should work for insertions into empty primitive array properties', function () {
@@ -748,21 +748,21 @@ describe('Reversible ChangeSets', function () {
         }, {
             'array<Float32>': {
                 'data': {
-                    'insert': [[0, [1, 2, 3]]]
-                }
-            }
+                    'insert': [[0, [1, 2, 3]]],
+                },
+            },
         }, {
             'array<Float32>': {
                 'data': {
-                    'insert': [[0, [1, 2, 3]]]
-                }
-            }
+                    'insert': [[0, [1, 2, 3]]],
+                },
+            },
         }, {
             'array<Float32>': {
                 'data': {
-                    'remove': [[0, [1, 2, 3]]]
-                }
-            }
+                    'remove': [[0, [1, 2, 3]]],
+                },
+            },
         });
     });
     it('should not crash with an empty input if it is not needed in the actual CS', function () {
@@ -770,10 +770,10 @@ describe('Reversible ChangeSets', function () {
             'NodeProperty': {
                 insert: {
                     NodeProperty: {
-                        test2: {}
-                    }
-                }
-            }
+                        test2: {},
+                    },
+                },
+            },
         };
         var CS = new ChangeSet(deepCopy(initialCS));
         CS._toReversibleChangeSet({});
@@ -789,11 +789,11 @@ describe('Reversible ChangeSets', function () {
                 'test': {
                     insert: {
                         NodeProperty: {
-                            test2: {}
-                        }
-                    }
-                }
-            }
+                            test2: {},
+                        },
+                    },
+                },
+            },
         };
         var CS = new ChangeSet(deepCopy(initialCS));
         CS._toReversibleChangeSet({});
@@ -803,16 +803,16 @@ describe('Reversible ChangeSets', function () {
         var cs = new ChangeSet({
             insert: {
                 'Float32': {
-                    'myFloat': 23
-                }
-            }
+                    'myFloat': 23,
+                },
+            },
         });
         var cs2 = new ChangeSet({
             modify: {
                 'Float32': {
-                    'myFloat': 42
-                }
-            }
+                    'myFloat': 42,
+                },
+            },
         });
         var cs2Rev = cs2.clone();
         cs2Rev._stripReversibleChangeSet();
@@ -842,27 +842,27 @@ describe('Reversible ChangeSets', function () {
         }, {
             'Float32': {
                 'position.x': { 'value': 2, 'oldValue': 0 },
-                'temperature': { 'value': 21, 'oldValue': 0 }
+                'temperature': { 'value': 21, 'oldValue': 0 },
             },
             'autodesk.test:vector3-1.0.0': {
-                'normal': { 'Float32': { 'y': { 'value': 4, 'oldValue': 0 } } }
-            }
+                'normal': { 'Float32': { 'y': { 'value': 4, 'oldValue': 0 } } },
+            },
         }, {
             'Float32': {
-                'position.x': 2, 'position.y': 0, 'temperature': 21
+                'position.x': 2, 'position.y': 0, 'temperature': 21,
             },
             'autodesk.test:vector3-1.0.0': {
-                'normal': { 'Float32': { 'x': 0, 'y': 4, 'z': 0 } }
+                'normal': { 'Float32': { 'x': 0, 'y': 4, 'z': 0 } },
             },
-            'map<autodesk.test:vector3-1.0.0>': { 'neighbours': {} }
+            'map<autodesk.test:vector3-1.0.0>': { 'neighbours': {} },
         }, {
             'Float32': {
                 'position.x': { 'value': 0, 'oldValue': 2 },
-                'temperature': { 'value': 0, 'oldValue': 21 }
+                'temperature': { 'value': 0, 'oldValue': 21 },
             },
             'autodesk.test:vector3-1.0.0': {
-                'normal': { 'Float32': { 'y': { 'value': 0, 'oldValue': 4 } } }
-            }
+                'normal': { 'Float32': { 'y': { 'value': 0, 'oldValue': 4 } } },
+            },
         });
     });
     it('should work for string properties initialized by set', function () {
@@ -901,23 +901,23 @@ describe('Reversible ChangeSets', function () {
                 'data': {
                     'remove': { 'B': 4, 'C': 5 },
                     'modify': { 'A': { 'value': 7, 'oldValue': 3 }, 'D': { 'value': 8, 'oldValue': 6 } },
-                    'insert': { 'F': 9 }
-                }
-            }
+                    'insert': { 'F': 9 },
+                },
+            },
         }, {
             'map<Float32>': {
                 'data': {
-                    'insert': { 'A': 7, 'D': 8, 'F': 9 }
-                }
-            }
+                    'insert': { 'A': 7, 'D': 8, 'F': 9 },
+                },
+            },
         }, {
             'map<Float32>': {
                 'data': {
                     'modify': { 'A': { 'value': 3, 'oldValue': 7 }, 'D': { 'value': 6, 'oldValue': 8 } },
                     'insert': { 'B': 4, 'C': 5 },
-                    'remove': { 'F': 9 }
-                }
-            }
+                    'remove': { 'F': 9 },
+                },
+            },
         });
     });
     it('should work for custom map properties', function () {
@@ -941,132 +941,132 @@ describe('Reversible ChangeSets', function () {
                 'map': {
                     'insert': {
                         'autodesk.tests:AnonymousMapTestPropertyID-1.0.0': {
-                            'F': { 'String': { 'stringProperty': '' } }
-                        }
+                            'F': { 'String': { 'stringProperty': '' } },
+                        },
                     },
                     'remove': {
                         'autodesk.tests:AnonymousMapTestPropertyID-1.0.0': {
-                            'B': { 'String': { 'stringProperty': '' } }, 'C': { 'String': { 'stringProperty': '' } }
-                        }
+                            'B': { 'String': { 'stringProperty': '' } }, 'C': { 'String': { 'stringProperty': '' } },
+                        },
                     },
                     'modify': {
                         'autodesk.tests:AnonymousMapTestPropertyID-1.0.0': {
-                            'A': { 'String': { 'stringProperty': { 'value': 'hello', 'oldValue': '' } } }
-                        }
-                    }
-                }
-            }
+                            'A': { 'String': { 'stringProperty': { 'value': 'hello', 'oldValue': '' } } },
+                        },
+                    },
+                },
+            },
         }, undefined, {
             'map<NamedProperty>': {
                 'map': {
                     'insert': {
                         'autodesk.tests:AnonymousMapTestPropertyID-1.0.0': {
                             'B': { 'String': { 'stringProperty': '' } },
-                            'C': { 'String': { 'stringProperty': '' } }
-                        }
+                            'C': { 'String': { 'stringProperty': '' } },
+                        },
                     },
                     'modify': {
                         'autodesk.tests:AnonymousMapTestPropertyID-1.0.0': {
-                            'A': { 'String': { 'stringProperty': { 'value': '', 'oldValue': 'hello' } } }
-                        }
+                            'A': { 'String': { 'stringProperty': { 'value': '', 'oldValue': 'hello' } } },
+                        },
                     },
                     'remove': {
                         'autodesk.tests:AnonymousMapTestPropertyID-1.0.0': {
-                            'F': { 'String': { 'stringProperty': '' } }
-                        }
-                    }
-                }
-            }
+                            'F': { 'String': { 'stringProperty': '' } },
+                        },
+                    },
+                },
+            },
         });
     });
     it('should test reversible changeset for a NodeProperty', function () {
         var originalChangeSet = {
             'insert': {
                 'autodesk.tests:AnonymousMapTestPropertyID-1.0.0': {
-                    'F': { 'String': { 'stringProperty': '' } }
-                }
+                    'F': { 'String': { 'stringProperty': '' } },
+                },
             },
             'remove': ['B', 'C'],
             'modify': {
                 'autodesk.tests:AnonymousMapTestPropertyID-1.0.0': {
-                    'A': { 'String': { 'stringProperty': 'hello' } }
-                }
-            }
+                    'A': { 'String': { 'stringProperty': 'hello' } },
+                },
+            },
         };
         var parentChangeSet = {
             'insert': {
                 'autodesk.tests:AnonymousMapTestPropertyID-1.0.0': {
                     'A': { 'String': { 'stringProperty': '' } },
                     'B': { 'String': { 'stringProperty': '' } },
-                    'C': { 'String': { 'stringProperty': '' } }
-                }
-            }
+                    'C': { 'String': { 'stringProperty': '' } },
+                },
+            },
         };
         var changeSet = new ChangeSet(originalChangeSet);
         changeSet._toReversibleChangeSet(parentChangeSet);
         expect(changeSet.getSerializedChangeSet()).to.eql({
             'insert': {
                 'autodesk.tests:AnonymousMapTestPropertyID-1.0.0': {
-                    'F': { 'String': { 'stringProperty': '' } }
-                }
+                    'F': { 'String': { 'stringProperty': '' } },
+                },
             },
             'remove': {
                 'autodesk.tests:AnonymousMapTestPropertyID-1.0.0': {
                     'B': { 'String': { 'stringProperty': '' } },
-                    'C': { 'String': { 'stringProperty': '' } }
-                }
+                    'C': { 'String': { 'stringProperty': '' } },
+                },
             }, 'modify': {
                 'autodesk.tests:AnonymousMapTestPropertyID-1.0.0': {
                     'A': {
                         'String': {
                             'stringProperty': {
                                 'value': 'hello',
-                                'oldValue': ''
-                            }
-                        }
-                    }
-                }
-            }
+                                'oldValue': '',
+                            },
+                        },
+                    },
+                },
+            },
         });
         changeSet.toInverseChangeSet();
         expect(changeSet.getSerializedChangeSet()).to.eql({
             'insert': {
                 'autodesk.tests:AnonymousMapTestPropertyID-1.0.0': {
                     'B': { 'String': { 'stringProperty': '' } },
-                    'C': { 'String': { 'stringProperty': '' } }
-                }
+                    'C': { 'String': { 'stringProperty': '' } },
+                },
             },
             'remove': {
                 'autodesk.tests:AnonymousMapTestPropertyID-1.0.0': {
-                    'F': { 'String': { 'stringProperty': '' } }
-                }
+                    'F': { 'String': { 'stringProperty': '' } },
+                },
             }, 'modify': {
                 'autodesk.tests:AnonymousMapTestPropertyID-1.0.0': {
                     'A': {
                         'String': {
                             'stringProperty': {
                                 'value': '',
-                                'oldValue': 'hello'
-                            }
-                        }
-                    }
-                }
-            }
+                                'oldValue': 'hello',
+                            },
+                        },
+                    },
+                },
+            },
         });
         var originalChangeSet2 = {
             'insert': {
                 'mysample:point2d-1.0.0': {
                     '7485af0e-c992-af6a-ef36-6a024eb4b4e5---2': {
                         'String': {
-                            'guid': 'fb5f062f-9f56-55c3-f868-06caa5d8ce26'
+                            'guid': 'fb5f062f-9f56-55c3-f868-06caa5d8ce26',
                         },
                         'Float64': {
                             'x': 0,
-                            'y': 0
-                        }
-                    }
-                }
-            }
+                            'y': 0,
+                        },
+                    },
+                },
+            },
         };
         var parentChangeSet2 = {};
         var changeSet2 = new ChangeSet(originalChangeSet2);
@@ -1078,15 +1078,15 @@ describe('Reversible ChangeSets', function () {
                 'mysample:point2d-1.0.0': {
                     '7485af0e-c992-af6a-ef36-6a024eb4b4e5---2': {
                         'String': {
-                            'guid': 'fb5f062f-9f56-55c3-f868-06caa5d8ce26'
+                            'guid': 'fb5f062f-9f56-55c3-f868-06caa5d8ce26',
                         },
                         'Float64': {
                             'x': 0,
-                            'y': 0
-                        }
-                    }
-                }
-            }
+                            'y': 0,
+                        },
+                    },
+                },
+            },
         });
     });
     it('should test reversible changeset for an array of non primitive types', function () {
@@ -1100,29 +1100,29 @@ describe('Reversible ChangeSets', function () {
                                 [
                                     {
                                         'Float64': {
-                                            'x': 15.104284463262685
+                                            'x': 15.104284463262685,
                                         },
-                                        'typeid': 'mysample:point2d-1.0.0'
-                                    }
-                                ]
-                            ]
-                        ]
-                    }
-                }
-            }
+                                        'typeid': 'mysample:point2d-1.0.0',
+                                    },
+                                ],
+                            ],
+                        ],
+                    },
+                },
+            },
         };
         var parentChangeSet = {
             'insert': {
                 'mysample:point2d-1.0.0': {
                     'test': {
                         'String': {
-                            'guid': 'cd36cd32-0bd3-5c55-f94c-b95933fdc58b'
+                            'guid': 'cd36cd32-0bd3-5c55-f94c-b95933fdc58b',
                         },
                         'Float64': {
                             'x': 65.18242364168808,
-                            'y': 0
-                        }
-                    }
+                            'y': 0,
+                        },
+                    },
                 },
                 'array<mysample:point2d-1.0.0>': {
                     'test2': {
@@ -1132,30 +1132,30 @@ describe('Reversible ChangeSets', function () {
                                 [
                                     {
                                         'String': {
-                                            'guid': 'e66540ff-9e5e-d599-033e-d3dd55efc2a3'
+                                            'guid': 'e66540ff-9e5e-d599-033e-d3dd55efc2a3',
                                         },
                                         'Float64': {
                                             'x': 0,
-                                            'y': 0
+                                            'y': 0,
                                         },
-                                        'typeid': 'mysample:point2d-1.0.0'
+                                        'typeid': 'mysample:point2d-1.0.0',
                                     },
                                     {
                                         'String': {
-                                            'guid': 'daeb5439-baef-7986-f90a-6a3a2f082250'
+                                            'guid': 'daeb5439-baef-7986-f90a-6a3a2f082250',
                                         },
                                         'Float64': {
                                             'x': 0,
-                                            'y': 0
+                                            'y': 0,
                                         },
-                                        'typeid': 'mysample:point2d-1.0.0'
-                                    }
-                                ]
-                            ]
-                        ]
+                                        'typeid': 'mysample:point2d-1.0.0',
+                                    },
+                                ],
+                            ],
+                        ],
                     },
-                    'test3': {}
-                }
+                    'test3': {},
+                },
             },
             'insertTemplates': {
                 'mysample:point2d-1.0.0': {
@@ -1164,15 +1164,15 @@ describe('Reversible ChangeSets', function () {
                     'properties': [
                         {
                             'id': 'x',
-                            'typeid': 'Float64'
+                            'typeid': 'Float64',
                         },
                         {
                             'id': 'y',
-                            'typeid': 'Float64'
-                        }
-                    ]
-                }
-            }
+                            'typeid': 'Float64',
+                        },
+                    ],
+                },
+            },
         };
         var changeSet = new ChangeSet(originalChangeSet);
         changeSet._toReversibleChangeSet(parentChangeSet);
@@ -1188,17 +1188,17 @@ describe('Reversible ChangeSets', function () {
                                         'Float64': {
                                             'x': {
                                                 value: 15.104284463262685,
-                                                oldValue: 0
-                                            }
+                                                oldValue: 0,
+                                            },
                                         },
-                                        'typeid': 'mysample:point2d-1.0.0'
-                                    }
-                                ]
-                            ]
-                        ]
-                    }
-                }
-            }
+                                        'typeid': 'mysample:point2d-1.0.0',
+                                    },
+                                ],
+                            ],
+                        ],
+                    },
+                },
+            },
         });
         changeSet.toInverseChangeSet();
         expect(changeSet.getSerializedChangeSet()).to.eql({
@@ -1213,34 +1213,34 @@ describe('Reversible ChangeSets', function () {
                                         'Float64': {
                                             'x': {
                                                 value: 0,
-                                                oldValue: 15.104284463262685
-                                            }
+                                                oldValue: 15.104284463262685,
+                                            },
                                         },
-                                        'typeid': 'mysample:point2d-1.0.0'
-                                    }
-                                ]
-                            ]
-                        ]
-                    }
-                }
-            }
+                                        'typeid': 'mysample:point2d-1.0.0',
+                                    },
+                                ],
+                            ],
+                        ],
+                    },
+                },
+            },
         });
     });
     it('should correctly reverse inserts of strings', function () {
         let CS = new ChangeSet({
             insert: {
                 'String': {
-                    'test': 'xxx'
-                }
-            }
+                    'test': 'xxx',
+                },
+            },
         });
         CS.toInverseChangeSet();
         expect(CS.getSerializedChangeSet()).to.deep.equal({
             'remove': {
                 'String': {
-                    'test': 'xxx'
-                }
-            }
+                    'test': 'xxx',
+                },
+            },
         });
     });
     it('should correctly reverse inserts of literal strings within NodeProperties', function () {
@@ -1250,12 +1250,12 @@ describe('Reversible ChangeSets', function () {
                     'test': {
                         insert: {
                             'String': {
-                                'test': 'xxx'
-                            }
-                        }
-                    }
-                }
-            }
+                                'test': 'xxx',
+                            },
+                        },
+                    },
+                },
+            },
         });
         CS.toInverseChangeSet();
         expect(CS.getSerializedChangeSet()).to.deep.equal({
@@ -1264,12 +1264,12 @@ describe('Reversible ChangeSets', function () {
                     'test': {
                         'remove': {
                             'String': {
-                                'test': 'xxx'
-                            }
-                        }
-                    }
-                }
-            }
+                                'test': 'xxx',
+                            },
+                        },
+                    },
+                },
+            },
         });
     });
     it('@regression should not fail when building reversible change sets', function () {
@@ -1289,7 +1289,7 @@ describe('Reversible ChangeSets', function () {
                                     'autodesk.compute:fanOut-1.0.0': {
                                         'a7e7d213-1202-9ee4-a3c1-8a33d6f36122': {
                                             'autodesk.compute:context-1.0.0': {
-                                                'computeContext': { 'Reference<autodesk.compute:resource-2.0.0>': { 'resource': '/8ce10fdd-b2b6-7152-21dc-c0e199b579e3' } }
+                                                'computeContext': { 'Reference<autodesk.compute:resource-2.0.0>': { 'resource': '/8ce10fdd-b2b6-7152-21dc-c0e199b579e3' } },
                                             },
                                             'map<autodesk.compute:node-2.0.0>': {
                                                 'computeNodes': {
@@ -1299,26 +1299,26 @@ describe('Reversible ChangeSets', function () {
                                                                 'enum<Enum>': { 'status': 1 }, 'autodesk.compute:context-1.0.0': {
                                                                     'computeContext': {
                                                                         'Reference<autodesk.compute:resource-2.0.0>': {
-                                                                            'resource': '/c1a811ea-608e-5fcc-1487-c74ab6939dee'
-                                                                        }
-                                                                    }
+                                                                            'resource': '/c1a811ea-608e-5fcc-1487-c74ab6939dee',
+                                                                        },
+                                                                    },
                                                                 }, 'Reference<autodesk.core:user-1.0.0>': {
                                                                     'inputs.input': '/5eb6ebe1-92c8-52fa-984b-b0b65c46d2a7.computeNodes[a7e7d213-1202-9ee4-a3c1-8a33d6f36122]' +
-                                                                        '.intermediateProperties[2c06da5c-8614-e9c2-3bd6-75ae739eba4f]'
-                                                                }
-                                                            }
-                                                        }
-                                                    }
-                                                }
-                                            }
-                                        }
-                                    }
-                                }
-                            }
-                        }
-                    }
-                }
-            }
+                                                                        '.intermediateProperties[2c06da5c-8614-e9c2-3bd6-75ae739eba4f]',
+                                                                },
+                                                            },
+                                                        },
+                                                    },
+                                                },
+                                            },
+                                        },
+                                    },
+                                },
+                            },
+                        },
+                    },
+                },
+            },
         };
         var parent = {
             'insert': {
@@ -1330,28 +1330,28 @@ describe('Reversible ChangeSets', function () {
                                     'autodesk.compute:fanOut-1.0.0': {
                                         'a7e7d213-1202-9ee4-a3c1-8a33d6f36122': {
                                             'autodesk.compute:context-1.0.0': {
-                                                'computeContext': { 'Reference<autodesk.compute:resource-2.0.0>': { 'resource': '' } }
+                                                'computeContext': { 'Reference<autodesk.compute:resource-2.0.0>': { 'resource': '' } },
                                             }, 'map<autodesk.compute:node-2.0.0>': {
                                                 'computeNodes': {
                                                     'insert': {
                                                         'autodesk.test:testCN-1.0.0': {
                                                             '1e924300-92ef-eaad-391f-53b77fe01099': {
                                                                 'enum<Enum>': { 'status': 0 }, 'autodesk.compute:context-1.0.0': {
-                                                                    'computeContext': { 'Reference<autodesk.compute:resource-2.0.0>': { 'resource': '' } }
-                                                                }, 'Reference<autodesk.core:user-1.0.0>': { 'inputs.input': '' }
-                                                            }
-                                                        }
-                                                    }
-                                                }
-                                            }
-                                        }
-                                    }
-                                }
-                            }
-                        }
-                    }
-                }
-            }
+                                                                    'computeContext': { 'Reference<autodesk.compute:resource-2.0.0>': { 'resource': '' } },
+                                                                }, 'Reference<autodesk.core:user-1.0.0>': { 'inputs.input': '' },
+                                                            },
+                                                        },
+                                                    },
+                                                },
+                                            },
+                                        },
+                                    },
+                                },
+                            },
+                        },
+                    },
+                },
+            },
         };
         var b = new ChangeSet(cs);
         b._toReversibleChangeSet(parent);