dbus-victron-virtual 0.1.0 → 0.1.2

package/README.md

@@ -1,52 +1,62 @@
 # About
 
+> [!WARNING]  
+> This package is under active development. I believe it is ready for "bleeding
+> edge" use, but its API may have to change, based on findings and bugs.
+> Please use with caution.
+
 `dbus-victron-virtual` is a wrapper around
 [dbus-native](https://www.npmjs.com/package/dbus-native), which allows you to
 connect to [dbus](https://www.freedesktop.org/wiki/Software/dbus/), and
 simplify integrating with the [Victron](https://www.victronenergy.com/)
 infrastructure: To do this, `dbus-victron-virtual` provides functions to
 
-* expose your dbus interface as a Victron service, by implementing the dbus interface `com.victronenergy.BusItem`,
-* emit the Victron-specific event `ItemsChanged`, and
-* define and modify settings which are then available through Victron's settings interface.
+- expose your dbus interface as a Victron service, by implementing the dbus interface `com.victronenergy.BusItem`,
+- emit the Victron-specific event `ItemsChanged`, and
+- define and modify settings which are then available through Victron's settings interface.
 
 See `dbus-victron-virtual` in action [here](https://github.com/Chris927/dbus-victron-virtual-test).
 
-
 This package may be for you if
 
-* you want to define virtual devices for testing on a Victron device, like a [Victron Cerbo GX](https://www.victronenergy.com/media/pg/Cerbo_GX/en/index-en.html), e.g. to use it in [Node-RED](https://www.victronenergy.com/live/venus-os:large), or
-* you need to integrate a device via dbus that is not (yet) supported by Victron natively.
-
+- you want to define virtual devices for testing on a Victron device, like a [Victron Cerbo GX](https://www.victronenergy.com/media/pg/Cerbo_GX/en/index-en.html), e.g. to use it in [Node-RED](https://www.victronenergy.com/live/venus-os:large), or
+- you need to integrate a device via dbus that is not (yet) supported by Victron natively.
 
 # Usage
 
-(TODO)
+## Prerequisites
 
+You have a NodeJS project you want to run on [Venus
+OS](https://github.com/victronenergy/venus), and you want to communicate with
+the local dbus.
 
-# Development
+## Setup Up
 
+- Add this package as a dependency: `npm add dbus-victron-virtual`.
+- Use this package, by importing or requiring it: `const { addVictronInterfaces } = require('dbus-victron-virtual');`
+- Make sure you understand how to use this package by studying the [example](https://github.com/Chris927/dbus-victron-virtual-test).
+- Have fun.
 
-## Prerequisites
+# Development
 
-You can develop on a device that runs [Venus OS](https://github.com/victronenergy/venus). This way, the dbus environment as required by this package will be available.  Alternatively, you can develop in any environment that support node 18 or higher, but you won't be able to run integration tests.
+## Prerequisites
 
+You can develop on a device that runs [Venus OS](https:/.com/victronenergy/venus). This way, the dbus environment as required by this package will be available. Alternatively, you can develop in any environment that support node 18 or higher, but you won't be able to run integration tests.
 
 ## Steps
 
-* clone the repository
-* `npm install`
-* `npm run test`
-* run integration tests with `DBUS_SESSION_BUS_ADDRESS=unix:socket=/var/run/dbus/system_bus_socket TEST_INTEGRATION=1 npm run test`
+- clone the repository
+- `npm install`
+- `npm run test`
+- run tests and include running integration tests with `DBUS_SESSION_BUS_ADDRESS=unix:socket=/var/run/dbus/system_bus_socket TEST_INTEGRATION=1 npm run test`
 
 The implementation is in `./src/index.js`, tests are in `./src/__tests__`.
 
-Test coverage stats, when run with the integration `./src/__tests__/integrationTest.js`:
-
-----------|---------|----------|---------|---------|---------------------------
-File      | % Stmts | % Branch | % Funcs | % Lines | Uncovered Line #s
-----------|---------|----------|---------|---------|---------------------------
-All files |   85.18 |    69.23 |     100 |    84.9 |
- index.js |   85.18 |    69.23 |     100 |    84.9 | 28,35,39-41,94-95,130,170
-----------|---------|----------|---------|---------|---------------------------
+Test coverage stats for unit and integration tests (append ` -- --coverage` to the test command):
 
+----------|---------|----------|---------|---------|-----------------------------
+File | % Stmts | % Branch | % Funcs | % Lines | Uncovered Line #s
+----------|---------|----------|---------|---------|-----------------------------
+All files | 87.32 | 73.91 | 100 | 86.76 |
+index.js | 87.32 | 73.91 | 100 | 86.76 | 26,35,39-43,107-108,145,169
+----------|---------|----------|---------|---------|-----------------------------

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dbus-victron-virtual",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "description": "Add interoperability with victron dbus to a given dbus interface",
   "main": "src/index.js",
   "type": "commonjs",
@@ -33,6 +33,7 @@
     "lint-staged": "^15.2.7"
   },
   "dependencies": {
-    "dbus-native": "^0.4.0"
+    "dbus-native-victron": "^0.4.2",
+    "debug": "^4.3.7"
   }
 }

package/src/__tests__/emitItemsChangedTest.js

@@ -1,31 +1,47 @@
 /* eslint-env node */
-const { addVictronInterfaces } = require('../index');
+const { addVictronInterfaces } = require("../index");
 
-describe('victron-dbus-virtual, emitItemsChanged tests', () => {
+describe("victron-dbus-virtual, emitItemsChanged tests", () => {
+  const noopBus = { exportInterface: () => {} };
 
-  const noopBus = { exportInterface: () => { } };
-
-  it('works for the case without props', () => {
-    const declaration = { name: 'foo' };
+  it("works for the case without props", () => {
+    const declaration = { name: "foo" };
     const definition = {};
-    const { emitItemsChanged } = addVictronInterfaces(noopBus, declaration, definition);
+    const { emitItemsChanged } = addVictronInterfaces(
+      noopBus,
+      declaration,
+      definition,
+      false,
+    );
     emitItemsChanged();
   });
 
-  it('works for the happy case', () => {
-    const declaration = { name: 'foo', properties: { StringProp: 's' } };
-    const definition = { StringProp: 'hello' };
+  it("works for the happy case", () => {
+    const declaration = { name: "foo", properties: { StringProp: "s" } };
+    const definition = { StringProp: "hello" };
     const emit = jest.fn();
     const bus = {
       exportInterface: (iface /* , _path, _ifaceDesc */) => {
         iface.emit = emit;
-      }
-    }
-    const { emitItemsChanged } = addVictronInterfaces(bus, declaration, definition);
+      },
+    };
+    const { emitItemsChanged } = addVictronInterfaces(
+      bus,
+      declaration,
+      definition,
+      false,
+    );
     emitItemsChanged();
     expect(emit.mock.calls.length).toBe(1);
-    expect(emit.mock.calls[0][0]).toBe('ItemsChanged');
-    expect(emit.mock.calls[0][1]).toEqual([['StringProp', [['Value', ['s', 'hello']], ['Text', ['s', 'hello']]]]]);
+    expect(emit.mock.calls[0][0]).toBe("ItemsChanged");
+    expect(emit.mock.calls[0][1]).toEqual([
+      [
+        "StringProp",
+        [
+          ["Value", ["s", "hello"]],
+          ["Text", ["s", "hello"]],
+        ],
+      ],
+    ]);
   });
-
 });

package/src/__tests__/getTextTest.js

@@ -0,0 +1,44 @@
+const { addVictronInterfaces } = require("../index");
+
+describe("victron-dbus-virtual, GetText being called on us", () => {
+  it("works for the happy case", () => {
+    const declaration = { name: "foo", properties: { IntProp: "i" } };
+    const definition = { IntProp: 42 };
+    const bus = {
+      exportInterface: jest.fn(),
+    };
+
+    addVictronInterfaces(bus, declaration, definition, false);
+
+    expect(bus.exportInterface.mock.calls.length).toBe(2);
+    expect(bus.exportInterface.mock.calls[1][0].GetText).toBeDefined();
+    expect(bus.exportInterface.mock.calls[1][1]).toBe("/IntProp");
+
+    const result = bus.exportInterface.mock.calls[1][0].GetText();
+    expect(result).toEqual("42");
+  });
+  it("works with our format, if we specify one", () => {
+    const declaration = {
+      name: "foo",
+      properties: {
+        IntProp: {
+          type: "i",
+          format: (v) => (v === 42 ? "fourty-two" : "not fourty-two"),
+        },
+      },
+    };
+    const definition = { IntProp: 42 };
+    const bus = {
+      exportInterface: jest.fn(),
+    };
+
+    addVictronInterfaces(bus, declaration, definition, false);
+
+    expect(bus.exportInterface.mock.calls.length).toBe(2);
+    expect(bus.exportInterface.mock.calls[1][0].GetText).toBeDefined();
+    expect(bus.exportInterface.mock.calls[1][1]).toBe("/IntProp");
+
+    const result = bus.exportInterface.mock.calls[1][0].GetText();
+    expect(result).toEqual("fourty-two");
+  });
+});

package/src/__tests__/getValueAndGetItemsTest.js

@@ -0,0 +1,38 @@
+const { addVictronInterfaces } = require("../index");
+
+describe("victron-dbus-virtual, GetValue and GetItems being called on us", () => {
+  it("works for the happy case", () => {
+    const declaration = { name: "foo", properties: { IntProp: "i" } };
+    const definition = { IntProp: 42 };
+    const bus = {
+      exportInterface: jest.fn(),
+    };
+
+    addVictronInterfaces(bus, declaration, definition, false);
+
+    const calls = bus.exportInterface.mock.calls;
+    expect(calls.length).toBe(2);
+    expect(calls[1][0].GetValue).toBeDefined();
+    expect(calls[1][1]).toBe("/IntProp");
+
+    // GetItems on path / returns the item with value and text
+    const rootItemsResult = calls[0][0].GetItems();
+    expect(rootItemsResult).toEqual([
+      [
+        "/IntProp",
+        [
+          ["Value", ["i", 42]],
+          ["Text", ["s", "42"]],
+        ],
+      ],
+    ]);
+
+    // GetValue on path / returns all props (therefore nested array)
+    const rootValueResult = calls[0][0].GetValue();
+    expect(rootValueResult).toEqual([["/IntProp", ["i", 42]]]);
+
+    // GetValue on path /IntProp returns the value as a variant
+    const valueResult = calls[1][0].GetValue();
+    expect(valueResult).toEqual(["i", 42]);
+  });
+});

package/src/__tests__/getValueAndSetValueTest.js

@@ -0,0 +1,51 @@
+const { addVictronInterfaces } = require("../index");
+
+describe("GetValue and SetValue called on us", () => {
+  it("returns the value if not null, returns empty int variant array in case of null", () => {
+    const declaration = { name: "foo", properties: { SomeProp: "s" } };
+    const definition = { SomeProp: "some text" };
+    const bus = {
+      exportInterface: jest.fn(),
+    };
+
+    addVictronInterfaces(bus, declaration, definition, false);
+
+    const calls = bus.exportInterface.mock.calls;
+    expect(calls.length).toBe(2);
+    expect(calls[1][0].GetValue).toBeDefined();
+    expect(calls[1][1]).toBe("/SomeProp");
+
+    // GetValue on path /SomeProp returns the value as a variant
+    const valueResult = calls[1][0].GetValue();
+    expect(valueResult).toEqual(["s", "some text"]);
+
+    definition.SomeProp = null;
+    const valueResultNull = calls[1][0].GetValue();
+    expect(valueResultNull).toEqual(["ai", []]);
+  });
+  it("sets the value given on SetValue, and sets the value to null when empty int array given", () => {
+    const declaration = { name: "foo", properties: { SomeProp: "s" } };
+    const definition = { SomeProp: "some text" };
+    const bus = {
+      exportInterface: jest.fn(),
+    };
+
+    addVictronInterfaces(bus, declaration, definition, false);
+
+    const calls = bus.exportInterface.mock.calls;
+    expect(calls.length).toBe(2);
+    expect(calls[1][0].SetValue).toBeDefined();
+    expect(calls[1][1]).toBe("/SomeProp");
+
+    // SetValue on path /SomeProp sets the value on us
+    const result = calls[1][0].SetValue([[{ type: "s" }], ["new text"]]);
+    expect(definition.SomeProp).toEqual("new text");
+    expect(result).toBe(0);
+
+    // SetValue on path /SomeProp with an empty int array sets the value on us to null
+    // TODO
+    const nullResult = calls[1][0].SetValue([[{ type: "ai" }], [[]]]);
+    expect(definition.SomeProp).toEqual(null);
+    expect(nullResult).toBe(0);
+  });
+});

package/src/__tests__/getValueForSettingsTest.js

@@ -0,0 +1,64 @@
+const { addVictronInterfaces } = require("../index");
+
+describe("victron-dbus-virtual, getValue for settings tests", () => {
+  it("works for the happy case", async () => {
+    const declaration = { name: "foo" };
+    const definition = {};
+    const bus = {
+      exportInterface: () => {},
+      invoke: function (args, cb) {
+        process.nextTick(() => cb(null, args));
+      },
+    };
+    const { getValue } = addVictronInterfaces(
+      bus,
+      declaration,
+      definition,
+      false,
+    );
+
+    // NOTE: calling getValue() is useful to retrieve the value of a setting.
+    // See https://github.com/Chris927/dbus-victron-virtual-test/blob/master/index.js for an example.
+
+    const result = await getValue({
+      path: "/StringProp",
+      interface_: "foo",
+      destination: "foo",
+    });
+    expect(result.member).toBe("GetValue");
+    expect(result.path).toBe("/StringProp");
+    expect(result.interface).toBe("foo");
+    expect(result.destination).toBe("foo");
+  });
+
+  it("fails if invoke fails", async () => {
+    const declaration = { name: "foo" };
+    const definition = {};
+    const bus = {
+      exportInterface: () => {},
+      invoke: function (args, cb) {
+        process.nextTick(() => cb(new Error("oops")));
+      },
+    };
+    const { getValue } = addVictronInterfaces(
+      bus,
+      declaration,
+      definition,
+      false,
+    );
+
+    // NOTE: calling getValue() is useful to retrieve the value of a setting.
+    // See https://github.com/Chris927/dbus-victron-virtual-test/blob/master/index.js for an example.
+
+    try {
+      await getValue({
+        path: "/StringProp",
+        interface_: "foo",
+        destination: "foo",
+      });
+      expect(false, "should have thrown");
+    } catch (err) {
+      expect(err.message).toBe("oops");
+    }
+  });
+});

package/src/__tests__/inputsTest.js

@@ -1,94 +1,108 @@
 /* eslint-env node */
-const { addVictronInterfaces } = require('../index');
-
-describe('victron-dbus-virtual, input parameters tests', () => {
+const { addVictronInterfaces } = require("../index");
 
+describe("victron-dbus-virtual, input parameters tests", () => {
   const noopBus = { exportInterface: () => { } };
 
-  it('works for the trivial case', () => {
-    const declaration = { name: 'foo' };
+  it("works for the trivial case", () => {
+    const declaration = { name: "foo" };
     const definition = {};
-    const result = addVictronInterfaces(noopBus, declaration, definition);
+    const result = addVictronInterfaces(
+      noopBus,
+      declaration,
+      definition,
+      false,
+    );
     expect(!!result).toBe(true);
   });
 
-  it('fails in some scenarios', () => {
+  it("fails in some scenarios", () => {
     try {
       addVictronInterfaces(noopBus, {}, {});
     } catch (e) {
-      expect(e.message.includes('Interface name')).toBe(true);
+      expect(e.message.includes("Interface name")).toBe(true);
     }
     try {
-      addVictronInterfaces(noopBus, { name: '' }, {});
+      addVictronInterfaces(noopBus, { name: "" }, {});
     } catch (e) {
-      expect(e.message.includes('Interface name')).toBe(true);
+      expect(e.message.includes("Interface name")).toBe(true);
     }
   });
 
-  it('works for an example with properties', () => {
+  it("works for an example with properties", () => {
     const declaration = {
-      name: 'com.victronenergy.myservice',
+      name: "com.victronenergy.myservice",
       properties: {
-        'foo': 'i',
-        'bar': 's',
-      }
+        foo: "i",
+        bar: "s",
+      },
     };
     const definition = {
       foo: 42,
-      bar: 'hello',
-      emit: function() { }
+      bar: "hello",
+      emit: function () { },
     };
-    const result = addVictronInterfaces(noopBus, declaration, definition);
+    const result = addVictronInterfaces(
+      noopBus,
+      declaration,
+      definition,
+      false,
+    );
     expect(!!result).toBe(true);
     expect(result.warnings.length).toBe(0);
   });
 
-  it('provides a warning if the interface name contains problematic characters', () => {
+  it("provides a warning if the interface name contains problematic characters", () => {
     const declaration = {
-      name: 'com.victronenergy.my-service-with-dashes',
+      name: "com.victronenergy.my-service-with-dashes",
     };
-    const { warnings } = addVictronInterfaces(noopBus, declaration, {});
+    const { warnings } = addVictronInterfaces(noopBus, declaration, {}, false);
     expect(warnings.length).toBe(1);
-    expect(warnings[0].includes('problematic characters')).toBe(true);
+    expect(warnings[0].includes("problematic characters")).toBe(true);
   });
 
-  it('provides a warning if the interface name does not start with com.victronenergy', () => {
+  it("provides a warning if the interface name does not start with com.victronenergy", () => {
     const declaration = {
-      name: 'com.example.my_service',
+      name: "com.example.my_service",
     };
-    const { warnings } = addVictronInterfaces(noopBus, declaration, {});
+    const { warnings } = addVictronInterfaces(noopBus, declaration, {}, false);
     expect(warnings.length).toBe(1);
-    expect(warnings[0].includes('start with com.victronenergy')).toBe(true);
+    expect(warnings[0].includes("start with com.victronenergy")).toBe(true);
   });
 
-  it('exports GetItems, and SetValue for each property', () => {
+  it("exports GetItems, GetValue, GetText, and SetValue for each property", () => {
     const declaration = {
-      name: 'some_name',
+      name: "some_name",
       properties: {
-        'foo': 'i',
-        'bar': 's',
-        'baz': 'b',
-      }
-    }
+        foo: "i",
+        bar: "s",
+        baz: "b",
+      },
+    };
     const bus = {
-      exportInterface: jest.fn()
+      exportInterface: jest.fn(),
     };
 
-    addVictronInterfaces(bus, declaration, {});
+    addVictronInterfaces(bus, declaration, {}, false);
     expect(bus.exportInterface.mock.calls.length).toBe(4);
 
     const call0 = bus.exportInterface.mock.calls[0];
-    expect(Object.keys(call0[0])).toStrictEqual(['GetItems', 'emit']);
+    expect(Object.keys(call0[0])).toStrictEqual([
+      "GetItems",
+      "GetValue",
+      "emit",
+    ]);
 
     const call1 = bus.exportInterface.mock.calls[1];
-    expect(Object.keys(call1[0])).toStrictEqual(['SetValue']);
-    expect(call1[1]).toStrictEqual('/foo');
-    expect(call1[2].name).toBe('com.victronenergy.BusItem');
+    expect(Object.keys(call1[0])).toStrictEqual([
+      "GetValue",
+      "GetText",
+      "SetValue",
+    ]);
+    expect(call1[1]).toStrictEqual("/foo");
+    expect(call1[2].name).toBe("com.victronenergy.BusItem");
 
     const call3 = bus.exportInterface.mock.calls[3];
-    expect(call3[1]).toStrictEqual('/baz');
-
+    expect(call3[1]).toStrictEqual("/baz");
   });
-
-
 });