diff --git a/src/plugins/CreateExecution/CreateExecution.js b/src/plugins/CreateExecution/CreateExecution.js
index dbe369c84..886c17030 100644
--- a/src/plugins/CreateExecution/CreateExecution.js
+++ b/src/plugins/CreateExecution/CreateExecution.js
@@ -221,11 +221,10 @@ define([
         return [];
     };
 
-    CreateExecution.prototype.snapshotNode = function (op, dst) {
+    CreateExecution.prototype.snapshotNode = async function (op, dst) {
         // If we are making a snapshot, we should copy the base operation
         // and set the attributes, add the child nodes, etc
         var base = this.core.getBase(this.core.getBase(op)),
-            names,
             values,
             snapshot = this.core.createNode({
                 base: base,
@@ -233,54 +232,56 @@ define([
             });
 
         // Copy over the attributes
-        names = this.core.getValidAttributeNames(op);
+        const names = this.core.getValidAttributeNames(op);
         values = names.map(name => this.core.getAttribute(op, name));
         names.forEach((name, i) =>
             this.core.setAttribute(snapshot, name, values[i]));
 
         // Copy the pointers
-        names = this.core.getValidPointerNames(op);
-        return Q.all(names
-            .map(name => this.core.getPointerPath(op, name))
-            .map(id => this.core.loadByPath(this.rootNode, id)))
-        .then(values => {
-
-            names.forEach((name, i) =>
-                this.core.setPointer(snapshot, name, values[i]));
-
-            // Copy the data I/O
-            var srcCntrs = this.core.getChildrenPaths(op),
-                dstCntrs = this.core.getChildrenPaths(snapshot);
-
-            return Q.all([srcCntrs, dstCntrs].map(ids =>
-                Q.all(ids.map(id => this.core.loadByPath(this.rootNode, id)))));
-        })
-        .then(cntrs => {
-            var srcCntrs,
-                dstCntrs;
-
-            // Sort all containers by metatype id
-            cntrs.map(l => l.sort((a, b) => {
-                var aId = this.core.getPath(this.core.getMetaType(a)),
-                    bId = this.core.getPath(this.core.getMetaType(b));
-
-                return aId < bId ? -1 : 1;
-            }));
-
-            srcCntrs = cntrs[0];
-            dstCntrs = cntrs[1];
-            return Q.all(srcCntrs.map(ctr => Q.all(this.core.getChildrenPaths(ctr)
+        const ptrNames = this.core.getValidPointerNames(op);
+        const setPointers = Promise.all(
+            ptrNames.map(async name => {
+                const targetPath = this.core.getPointerPath(op, name);
+                if (targetPath) {
+                    const target = await this.core.loadByPath(this.rootNode, targetPath);
+                    this.core.setPointer(snapshot, name, target);
+                }
+            })
+        );
+        await setPointers;
+
+        // Copy the data I/O
+        var srcCntrs = this.core.getChildrenPaths(op),
+            dstCntrs = this.core.getChildrenPaths(snapshot);
+
+        return Q.all([srcCntrs, dstCntrs].map(ids =>
+            Q.all(ids.map(id => this.core.loadByPath(this.rootNode, id)))))
+            .then(cntrs => {
+                var srcCntrs,
+                    dstCntrs;
+
+                // Sort all containers by metatype id
+                cntrs.map(l => l.sort((a, b) => {
+                    var aId = this.core.getPath(this.core.getMetaType(a)),
+                        bId = this.core.getPath(this.core.getMetaType(b));
+
+                    return aId < bId ? -1 : 1;
+                }));
+
+                srcCntrs = cntrs[0];
+                dstCntrs = cntrs[1];
+                return Q.all(srcCntrs.map(ctr => Q.all(this.core.getChildrenPaths(ctr)
                     .map(id => this.core.loadByPath(this.rootNode, id)))))
-                .then(cntrs =>
-                    cntrs.map((nodes, i) =>
-                        nodes.map(n => [n, this.copyDataNode(n, dstCntrs[i])]))
-                );
-        })
-        .then(nodes => {
-            nodes = nodes.reduce((l1, l2) => l1.concat(l2), []);
-            nodes.push([op, snapshot]);
-            return nodes;
-        });
+                    .then(cntrs =>
+                        cntrs.map((nodes, i) =>
+                            nodes.map(n => [n, this.copyDataNode(n, dstCntrs[i])]))
+                    );
+            })
+            .then(nodes => {
+                nodes = nodes.reduce((l1, l2) => l1.concat(l2), []);
+                nodes.push([op, snapshot]);
+                return nodes;
+            });
     };
 
     CreateExecution.prototype.copyDataNode = function (original, dst) {
diff --git a/test/unit/plugins/CreateExecution/CreateExecution.spec.js b/test/unit/plugins/CreateExecution/CreateExecution.spec.js
index e15f095cd..7f4808c4d 100644
--- a/test/unit/plugins/CreateExecution/CreateExecution.spec.js
+++ b/test/unit/plugins/CreateExecution/CreateExecution.spec.js
@@ -2,8 +2,8 @@
 
 describe('CreateExecution', function () {
     const testFixture = require('../../../globals');
+    const assert = require('assert');
     var gmeConfig = testFixture.getGmeConfig(),
-        expect = testFixture.expect,
         logger = testFixture.logger.fork('CreateExecution'),
         PluginCliManager = testFixture.WebGME.PluginCliManager,
         manager = new PluginCliManager(null, logger, gmeConfig),
@@ -14,81 +14,73 @@ describe('CreateExecution', function () {
         storage,
         commitHash;
 
-    before(function (done) {
-        testFixture.clearDBAndGetGMEAuth(gmeConfig, projectName)
-            .then(function (gmeAuth_) {
-                gmeAuth = gmeAuth_;
-                // This uses in memory storage. Use testFixture.getMongoStorage to persist test to database.
-                storage = testFixture.getMemoryStorage(logger, gmeConfig, gmeAuth);
-                return storage.openDatabase();
-            })
-            .then(function () {
-                var importParam = {
-                    projectSeed: testFixture.path.join(testFixture.DF_SEED_DIR, 'devProject', 'devProject.webgmex'),
-                    projectName: projectName,
-                    branchName: 'master',
-                    logger: logger,
-                    gmeConfig: gmeConfig
-                };
+    before(async function () {
+        gmeAuth = await testFixture.clearDBAndGetGMEAuth(gmeConfig, projectName);
+        storage = testFixture.getMemoryStorage(logger, gmeConfig, gmeAuth);
+        await storage.openDatabase();
+        const importParam = {
+            projectSeed: testFixture.path.join(testFixture.DF_SEED_DIR, 'devProject', 'devProject.webgmex'),
+            projectName: projectName,
+            branchName: 'master',
+            logger: logger,
+            gmeConfig: gmeConfig
+        };
 
-                return testFixture.importProject(storage, importParam);
-            })
-            .then(function (importResult) {
-                project = importResult.project;
-                commitHash = importResult.commitHash;
-                return project.createBranch('test', commitHash);
-            })
-            .nodeify(done);
+        const importResult = await testFixture.importProject(storage, importParam);
+        project = importResult.project;
+        commitHash = importResult.commitHash;
+        await project.createBranch('test', commitHash);
     });
 
-    after(function (done) {
-        storage.closeDatabase()
-            .then(function () {
-                return gmeAuth.unload();
-            })
-            .nodeify(done);
+    after(async function () {
+        await storage.closeDatabase();
+        await gmeAuth.unload();
     });
 
-    var plugin,
-        preparePlugin = function(done) {
-            var context = {
-                project: project,
-                commitHash: commitHash,
-                namespace: 'pipeline',
-                branchName: 'test',
-                activeNode: '/K/R/p'  // hello world job
-            };
-
-            return manager.initializePlugin(pluginName)
-                .then(plugin_ => {
-                    plugin = plugin_;
-                    return manager.configurePlugin(plugin, {}, context);
-                })
-                .nodeify(done);
+    const preparePlugin = async function(nodeId = '/f/h') {
+        var context = {
+            project: project,
+            commitHash: commitHash,
+            namespace: 'pipeline',
+            branchName: 'test',
+            activeNode: nodeId
         };
 
-    describe('getUniqueExecName', function() {
+        const plugin = await manager.initializePlugin(pluginName);
+        await manager.configurePlugin(plugin, {}, context);
+        return plugin;
+    };
+
+    describe('snapshotNode', function() {
+        let plugin;
+        before(async () => plugin = await preparePlugin());
+
+        it('should be able to snapshot node w/ unset ptr', async () => {
+            const {core, rootNode, META} = plugin;
+            const helloWorldNode = await core.loadByPath(rootNode, '/f/h/d');
+            core.setPointerMetaLimits(helloWorldNode, 'testPtr', 1, 1);
+            core.setPointerMetaTarget(helloWorldNode, 'testPtr', META.Job, 1, 1);
 
-        before(preparePlugin);
+            await plugin.snapshotNode(helloWorldNode, plugin.activeNode);
+        });
+    });
+
+    describe('getUniqueExecName', function() {
+        let plugin;
 
-        it('should trim whitespace', function(done) {
-            var name = '   abc   ';
+        before(async () => plugin = await preparePlugin());
 
-            plugin.getUniqueExecName(name)
-                .then(name => {
-                    expect(name).to.equal('abc');
-                })
-                .nodeify(done);
+        it('should trim whitespace', async function() {
+            const originalName = '   abc   ';
+            const name = await plugin.getUniqueExecName(originalName);
+            assert.equal(name, originalName.trim());
         });
 
-        it('should replace whitespace with _', function(done) {
-            var name = 'a b c';
+        it('should replace whitespace with _', async function() {
+            const originalName = 'a b c';
 
-            plugin.getUniqueExecName(name)
-                .then(name => {
-                    expect(name).to.equal('a_b_c');
-                })
-                .nodeify(done);
+            const name = await plugin.getUniqueExecName(originalName);
+            assert.equal(name, 'a_b_c');
         });
 
     });
