Fix patching when used without pre-computed NodeSelections. Close #40

src/common/JSONImporter.js

@@ -234,10 +234,7 @@ define([
         }
 
         async patch(node, diffs, resolvedSelectors=new NodeSelections()) {
-            const diffIds = diffs.map(diff => {
-                return {id: diff.nodeId};
-            });
-            await Promise.all(diffIds.map(async diffId => await this.resolveSelectorsForExistingNodes(node, diffId, resolvedSelectors)));
+            await this.resolveSelectorsFromDiffs(node, diffs, resolvedSelectors);
             await this._patch(diffs, resolvedSelectors);
         }
 
@@ -372,6 +369,17 @@ define([
             await this.resolveSelectors(node, state, resolvedSelectors, false);
         }
 
+        async resolveSelectorsFromDiffs(node, diffs, resolvedSelectors) {
+            await Promise.all(diffs.map(async diff => {
+                const selector = new NodeSelector(diff.nodeId);
+                const parent = await this.core.loadByPath(this.rootNode, diff.parentPath);
+                const node = await selector.findNode(this.core, this.rootNode, parent, resolvedSelectors);
+                if(node) {
+                    resolvedSelectors.record(diff.parentPath, selector, node);
+                }
+            }));
+        }
+
         async resolveSelectors(node, state, resolvedSelectors, create=true) {
             const parent = this.core.getParent(node);
             if(parent) {

test/common/JSONImporter.spec.js

@@ -7,7 +7,7 @@ describe('JSONImporter', function () {
     const _ = testFixture.requirejs('underscore');
     const Core = testFixture.requirejs('common/core/coreQ');
     const Importer = testFixture.requirejs('webgme-json-importer/JSONImporter');
-    const {OmittedProperties, NodeSelections} = Importer;
+    const {OmittedProperties, NodeSelections, NodeChangeSet} = Importer;
     const assert = require('assert');
     const gmeConfig = testFixture.getGmeConfig();
     const path = testFixture.path;
@@ -1366,6 +1366,90 @@ describe('JSONImporter', function () {
             }));
         });
     });
+
+    describe('patch', function () {
+        let node1, children;
+        beforeEach(async function () {
+            node1 = core.createNode({
+                parent: root,
+                base: fco
+            });
+            children = range(5).map(idx => {
+                const node = core.createNode({
+                    parent: node1,
+                    base: fco
+                });
+                core.setAttribute(node, 'name', `child${idx}`);
+                return node;
+            });
+
+        });
+
+        it('should apply attribute changeset to appropriate node in the subtree (@path)', async () => {
+            const changeSets = [
+                new NodeChangeSet(
+                    core.getPath(node1),
+                    core.getPath(children[0]),
+                    'put',
+                    ['attributes', 'name'],
+                    'changedNameChild0'
+                ),
+                new NodeChangeSet(
+                    core.getPath(node1),
+                    core.getPath(children[3]),
+                    'put',
+                    ['attributes', 'name'],
+                    'changedNameChild3'
+                ),
+            ];
+            await importer.patch(node1, changeSets);
+            assert.equal(core.getAttribute(children[0], 'name'), 'changedNameChild0');
+            assert.equal(core.getAttribute(children[3], 'name'), 'changedNameChild3');
+        });
+
+        it('should apply attribute changeset to appropriate node in the subtree (@guid)', async () => {
+            const changeSets = [
+                new NodeChangeSet(
+                    core.getPath(node1),
+                    core.getGuid(children[0]),
+                    'put',
+                    ['attributes', 'name'],
+                    'changedNameChild0'
+                ),
+                new NodeChangeSet(
+                    core.getPath(node1),
+                    core.getGuid(children[3]),
+                    'put',
+                    ['attributes', 'name'],
+                    'changedNameChild3'
+                ),
+            ];
+
+            await importer.patch(node1, changeSets);
+            assert.equal(core.getAttribute(children[0], 'name'), 'changedNameChild0');
+            assert.equal(core.getAttribute(children[3], 'name'), 'changedNameChild3');
+        });
+
+        it('should apply base pointer changeset to appropriate node in the subtree (@guid)', async () => {
+            const node2 = core.createNode({
+                parent: node1,
+                base: fco
+            });
+
+            core.setAttribute(node2, 'name', 'newName');
+
+            const changeSets = [new NodeChangeSet(
+                core.getPath(node1),
+                core.getGuid(children[3]),
+                'put',
+                ['pointers', 'base'],
+                core.getGuid(node2)
+            )];
+
+            await importer.patch(node1, changeSets);
+            assert(core.getPointerPath(children[3], 'base') === core.getPath(node2));
+        });
+    });
 });
 
 function range(size, startAt = 0) {