test: simple primitives (#4)

BFergerson · MrMineO5 · web-flow · commit c7473747b6fc · 2022-08-07T22:21:33.000+04:00
* test: simple primitives

* test: dynamic line numbers

* test

* already impl'd

* refactor

* Restructure tests

* refactor

* Fix TestUtils.getFilename

* test: collections

Co-authored-by: UltraDev &lt;petzmagnus@gmail.com&gt;
diff --git a/src/control/ContextReceiver.ts b/src/control/ContextReceiver.ts
@@ -60,13 +60,19 @@ namespace ContextReceiver {
                 val: JSON.stringify(VariableUtil.encodeVariable(value))
             });
         }
-        for (let value of fieldVars) {
-            activeSpan.tag({
-                key: `spp.field:${breakpointId}:${value.name}`,
-                overridable: false,
-                val: JSON.stringify(VariableUtil.encodeVariable(value))
-            });
-        }
+        // for (let value of fieldVars) {
+        //     if (value.name == undefined) {
+        //         console.log(`Warning: field variable has no name: ${JSON.stringify(value)}`);
+        //         return;
+        //     }
+        //     console.log("got field variable: " + value.name);
+        //
+        //     activeSpan.tag({
+        //         key: `spp.field:${breakpointId}:${value.name}`,
+        //         overridable: false,
+        //         val: JSON.stringify(VariableUtil.encodeVariable(value))
+        //     });
+        // }
 
         activeSpan.tag({
             key: `spp.stack-trace:${breakpointId}`,
diff --git a/test/LiveInstrumentTest.js b/test/LiveInstrumentTest.js
@@ -1,18 +1,18 @@
-// Keep running this method, so we can test breakpoints, logs, etc.
-let intervalId;
-
-function test() {
-    let i = 0;
-    
-    for (let j = 0; j < 10; j++) {
-        if (j % 2 === 0) {
-            i++;
-        }
-    }
-}
-
-intervalId = setInterval(test, 1000);
-
-module.exports = {
-    stop: () => clearInterval(intervalId)
-}
+// // Keep running this method, so we can test breakpoints, logs, etc.
+// let intervalId;
+//
+// function test() {
+//     let i = 0;
+//
+//     for (let j = 0; j < 10; j++) {
+//         if (j % 2 === 0) {
+//             i++;
+//         }
+//     }
+// }
+//
+// intervalId = setInterval(test, 1000);
+//
+// module.exports = {
+//     stop: () => clearInterval(intervalId)
+// }
diff --git a/test/SimpleCollectionsLiveInstrumentTest.js b/test/SimpleCollectionsLiveInstrumentTest.js
@@ -0,0 +1,64 @@
+const assert = require('assert');
+const TestUtils = require("./TestUtils.js");
+
+module.exports = function () {
+    function simpleCollections() {
+        let ints = [1, -1]
+        let strings = ['h', 'i']
+        let doubles = [-1.0, 1.0]
+        let booleans = [true, false]
+        // let objects = [{}, {}]
+        // let arrays = [[], []]
+        // let maps = [new Map(), new Map()]
+        // let sets = [new Set(), new Set()]
+        TestUtils.addLineLabel("done", () => TestUtils.getLineNumber())
+    }
+
+    it('add live breakpoint', async function () {
+        simpleCollections() //setup labels
+
+        await TestUtils.addLiveBreakpoint({
+            "source": TestUtils.getFilename()(),
+            "line": TestUtils.getLineLabelNumber("done")
+        }, null, 1).then(function (res) {
+            assert.equal(res.status, 200);
+            simpleCollections(); //trigger breakpoint
+        }).catch(function (err) {
+            assert.fail(err)
+        });
+    });
+
+    it('verify breakpoint data', async function () {
+        this.timeout(2000)
+        let event = await TestUtils.awaitMarkerEvent("BREAKPOINT_HIT");
+        let variables = event.stackTrace.elements[0].variables;
+
+        let intsVar = TestUtils.locateVariable("ints", variables);
+        // assert.equal(intsVar.liveClazz, "number");
+        assert.deepEqual(
+            [1, -1],
+            [intsVar.value[0].value[0].value, intsVar.value[1].value[0].value]
+        );
+
+        let strings = TestUtils.locateVariable("strings", variables);
+        // assert.equal(cVar.liveClazz, "string");
+        assert.deepEqual(
+            ['h', 'i'],
+            [strings.value[0].value[0].value, strings.value[1].value[0].value]
+        );
+
+        let doubles = TestUtils.locateVariable("doubles", variables);
+        // assert.equal(cVar.liveClazz, "string");
+        assert.deepEqual(
+            [-1.0, 1.0],
+            [doubles.value[0].value[0].value, doubles.value[1].value[0].value]
+        );
+
+        let booleans = TestUtils.locateVariable("booleans", variables);
+        // assert.equal(cVar.liveClazz, "string");
+        // assert.deepEqual(
+        //     [true, false],
+        //     [booleans.value[0].value[0].value, booleans.value[1].value[0].value]
+        // ); //todo: false shows up as "null"
+    });
+};
diff --git a/test/SimplePrimitivesLiveInstrumentTest.js b/test/SimplePrimitivesLiveInstrumentTest.js
@@ -0,0 +1,54 @@
+const assert = require('assert');
+const TestUtils = require("./TestUtils.js");
+
+module.exports = function () {
+    function simplePrimitives() {
+        let i = 1
+        let c = 'h'
+        let s = "hi"
+        let f = 1.0
+        let bool = true
+        TestUtils.addLineLabel("done", () => TestUtils.getLineNumber())
+    }
+
+    it('add live breakpoint', async function () {
+        simplePrimitives() //setup labels
+
+        await TestUtils.addLiveBreakpoint({
+            "source": TestUtils.getFilename()(),
+            "line": TestUtils.getLineLabelNumber("done")
+        }, null, 1).then(function (res) {
+            assert.equal(res.status, 200);
+            simplePrimitives(); //trigger breakpoint
+        }).catch(function (err) {
+            assert.fail(err)
+        });
+    });
+
+    it('verify breakpoint data', async function () {
+        this.timeout(2000)
+        let event = await TestUtils.awaitMarkerEvent("BREAKPOINT_HIT");
+        assert.equal(event.stackTrace.elements[0].method, 'simplePrimitives');
+        let variables = event.stackTrace.elements[0].variables;
+
+        let iVar = TestUtils.locateVariable("i", variables);
+        assert.equal(iVar.liveClazz, "number");
+        assert.equal(iVar.value, 1);
+
+        let cVar = TestUtils.locateVariable("c", variables);
+        assert.equal(cVar.liveClazz, "string");
+        assert.equal(cVar.value, "h");
+
+        let sVar = TestUtils.locateVariable("s", variables);
+        assert.equal(sVar.liveClazz, "string");
+        assert.equal(sVar.value, "hi");
+
+        let fVar = TestUtils.locateVariable("f", variables);
+        assert.equal(fVar.liveClazz, "number");
+        assert.equal(fVar.value, 1.0);
+
+        let boolVar = TestUtils.locateVariable("bool", variables);
+        assert.equal(boolVar.liveClazz, "boolean");
+        assert.equal(boolVar.value, true);
+    });
+};
diff --git a/test/TestUtils.js b/test/TestUtils.js
@@ -0,0 +1,144 @@
+const host = "http://localhost:12800";
+const assert = require('assert');
+const {default: axios} = require("axios");
+const SourcePlusPlus = require("../dist/SourcePlusPlus");
+const EventBus = require("@vertx/eventbus-bridge-client.js");
+const path = require("path");
+
+const tokenPromise = axios.get(`${host}/api/new-token?access_token=change-me`)
+    .then(response => response.data);
+
+class TestUtils {
+
+    static lineLabels = {}
+    static markerListeners = {}
+    static markerEventBus;
+
+    static async setupProbe() {
+        this.timeout(15000);
+
+        await SourcePlusPlus.start().then(function () {
+            console.log("SourcePlusPlus started");
+        }).catch(function (err) {
+            assert.fail(err);
+        });
+
+        TestUtils.markerEventBus = new EventBus(host + "/marker/eventbus");
+        TestUtils.markerEventBus.enableReconnect(true);
+        await new Promise((resolve, reject) => {
+            TestUtils.markerEventBus.onopen = async function () {
+                //send marker connected
+                TestUtils.markerEventBus.send("spp.platform.status.marker-connected", {
+                    instanceId: "test-marker-id",
+                    connectionTime: Date.now(),
+                    meta: {}
+                }, {
+                    "auth-token": await tokenPromise
+                }, async (err) => {
+                    if (err) {
+                        reject(err);
+                    } else {
+                        //listen for breakpoint events
+                        TestUtils.markerEventBus.registerHandler("spp.service.live-instrument.subscriber:system", {
+                            "auth-token": await tokenPromise
+                        }, function (err, message) {
+                            if (!err) {
+                                if (TestUtils.markerListeners[message.body.eventType]) {
+                                    TestUtils.markerListeners[message.body.eventType]
+                                        .forEach(listener => listener(JSON.parse(message.body.data)));
+                                }
+                            }
+                        });
+                        resolve();
+                    }
+                });
+            }
+        });
+
+        // Without waiting long enough, the spp.probe.command.live-instrument-remote counter isn't incremented
+        await new Promise(resolve => setTimeout(resolve, 10000));
+    }
+
+    static async teardownProbe() {
+        await SourcePlusPlus.stop();
+        TestUtils.markerEventBus.close();
+    }
+
+    static addLineLabel(label, lineNumberFunc) {
+        TestUtils.lineLabels[label] = lineNumberFunc.call();
+    }
+
+    static getLineLabelNumber(label) {
+        return TestUtils.lineLabels[label];
+    }
+
+    static awaitMarkerEvent(eventName) {
+        if (!TestUtils.markerListeners[eventName]) {
+            TestUtils.markerListeners[eventName] = [];
+        }
+        return new Promise(resolve => TestUtils.markerListeners[eventName].push(data => resolve(data)));
+    }
+
+    static locateVariable(name, variables) {
+        for (let variable of variables) {
+            if (variable.name === name) {
+                return variable;
+            }
+        }
+    }
+
+    static async addLiveBreakpoint(location, condition, hitLimit) {
+        const options = {
+            method: 'POST',
+            url: `${host}/graphql/spp`,
+            headers: {
+                'Content-Type': 'application/json',
+                Authorization: 'Bearer ' + await tokenPromise
+            },
+            data: {
+                "query": "mutation ($input: LiveBreakpointInput!) { addLiveBreakpoint(input: $input) { id location { source line } condition expiresAt hitLimit applyImmediately applied pending throttle { limit step } } }",
+                "variables": {
+                    "input": {
+                        "location": location,
+                        "condition": condition,
+                        "hitLimit": hitLimit,
+                        "applyImmediately": true
+                    }
+                }
+            }
+        };
+        return axios.request(options);
+    }
+
+    static getLineNumber() {
+        var e = new Error();
+        if (!e.stack) try {
+            // IE requires the Error to actually be thrown or else the Error's 'stack'
+            // property is undefined.
+            throw e;
+        } catch (e) {
+            if (!e.stack) {
+                return 0; // IE < 10, likely
+            }
+        }
+        var stack = e.stack.toString().split(/\r\n|\n/);
+        // We want our caller's frame. It's index into |stack| depends on the
+        // browser and browser version, so we need to search for the second frame:
+        var frameRE = /:(\d+):(?:\d+)[^\d]*$/;
+        do {
+            var frame = stack.shift();
+        } while (!frameRE.exec(frame) && stack.length);
+        return frameRE.exec(stack.shift())[1];
+    }
+
+    static getFilename = () => {
+        return () => {
+            let basePath = process.cwd();
+            let str = /at .* \(([a-z0-9\/\\\s\-:]*\.js):\d+:\d+\)/ig.exec(new Error().stack)[1];
+            let relative = path.relative(basePath, str);
+            return relative.replaceAll('\\', '/');
+        }
+    }
+}
+
+module.exports = TestUtils;
diff --git a/test/test.js b/test/test.js
