@foxglove/ros1/dist/RosNode.test.js

Standalone TypeScript implementation of the ROS 1 (Robot Operating System) protocol with a pluggable transport layer

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const nodejs_1 = require("@foxglove/xmlrpc/nodejs");
const RosMaster_1 = require("./RosMaster");
const RosNode_1 = require("./RosNode");
const TcpServerNode_1 = require("./nodejs/TcpServerNode");
const TcpSocketNode_1 = require("./nodejs/TcpSocketNode");
describe("RosNode", () => {
    it("Publishes and subscribes to topics and parameters", async () => {
        const rosMaster = new RosMaster_1.RosMaster(new nodejs_1.HttpServerNodejs());
        await rosMaster.start("localhost");
        const rosMasterUri = rosMaster.url();
        expect(typeof rosMasterUri).toBe("string");
        let errA;
        let errB;
        const nodeA = new RosNode_1.RosNode({
            name: "/nodeA",
            hostname: "localhost",
            pid: 1,
            rosMasterUri,
            httpServer: new nodejs_1.HttpServerNodejs(),
            tcpSocketCreate: TcpSocketNode_1.TcpSocketNode.Create,
            tcpServer: await TcpServerNode_1.TcpServerNode.Listen({ host: "localhost" }),
        });
        nodeA.on("error", (err) => (errA = err));
        const nodeB = new RosNode_1.RosNode({
            name: "/nodeB",
            hostname: "localhost",
            pid: 2,
            rosMasterUri,
            httpServer: new nodejs_1.HttpServerNodejs(),
            tcpSocketCreate: TcpSocketNode_1.TcpSocketNode.Create,
            tcpServer: await TcpServerNode_1.TcpServerNode.Listen({ host: "localhost" }),
        });
        nodeB.on("error", (err) => (errB = err));
        await nodeA.start();
        const received = new Promise((r) => {
            nodeA
                .subscribe({ topic: "/a", dataType: "std_msgs/Bool" })
                .on("message", (msg, data, pub) => {
                r([msg, data, pub]);
            });
        });
        await nodeB.start();
        await nodeB.advertise({
            topic: "/a",
            dataType: "std_msgs/Bool",
            messageDefinitionText: "bool data",
            latching: true,
        });
        await nodeB.publish("/a", { data: true });
        const [msg, data, pub] = await received;
        expect(msg.data).toEqual(true);
        expect(data).toHaveLength(1);
        expect(pub.connection.connected()).toEqual(true);
        expect(pub.connection.getTransportInfo().startsWith("TCPROS connection on port ")).toBe(true);
        expect(pub.connection.stats().bytesReceived).toEqual(143);
        expect(pub.connection.transportType()).toEqual("TCPROS");
        expect(pub.connectionId).toEqual(0);
        expect(pub.subscription.md5sum).toEqual("*");
        expect(pub.subscription.publishers().size).toEqual(1);
        expect(pub.subscription.receivedBytes()).toEqual(143);
        const initParamValue = await nodeB.subscribeParam("a");
        expect(initParamValue).toBeUndefined();
        const paramUpdated = new Promise((r) => {
            nodeB.on("paramUpdate", (args) => {
                r(args);
            });
        });
        await nodeA.setParameter("a", 42);
        const args = await paramUpdated;
        expect(args.callerId).toEqual("/nodeA");
        expect(args.key).toEqual("a");
        expect(args.value).toEqual(42);
        expect(args.prevValue).toBeUndefined();
        nodeB.shutdown();
        nodeA.shutdown();
        await new Promise((r) => setTimeout(r, 100));
        rosMaster.close();
        expect(errA).toBeUndefined();
        expect(errB).toBeUndefined();
    });
});
//# sourceMappingURL=RosNode.test.js.map