@meri-imperiumi/signalk-triplogger 1.3.0 → 1.3.2

package/.editorconfig

@@ -0,0 +1,5 @@
+[*]
+end_of_line = lf
+insert_final_newline = true
+indent_style = space
+indent_size = 2

package/.eslintrc.json

@@ -1,3 +1,9 @@
 {
-  "extends": "airbnb-base"
+  "extends": "airbnb-base",
+  "parserOptions": {
+    "ecmaVersion": 2022
+  },
+  "rules": {
+    "linebreak-style": "warn"
+  }
 }

package/.github/workflows/publish.yml

@@ -5,14 +5,19 @@ on:
     tags:
       - "*"
 
+permissions:
+  id-token: write  # Required for OIDC
+  contents: read
+
 jobs:
   build:
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v3.0.2
-      - uses: actions/setup-node@v3.4.1
+      - uses: actions/setup-node@v3.1.1
         with:
-          node-version: 12
+          node-version: 24
+          package-manager-cache: false  # never use caching in release builds
       - run: npm install
       - run: npm test
 
@@ -21,10 +26,9 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v3.0.2
-      - uses: actions/setup-node@v3.4.1
+      - uses: actions/setup-node@v3.1.1
         with:
-          node-version: 12
+          node-version: 24
           registry-url: https://registry.npmjs.org/
+          package-manager-cache: false  # never use caching in release builds
       - run: npm publish
-        env:
-          NODE_AUTH_TOKEN: ${{secrets.NPM_TOKEN}}

package/.github/workflows/signalk-ci.yml

@@ -0,0 +1,11 @@
+name: SignalK Plugin CI
+
+on:
+  push:
+    branches: [main, master]
+  pull_request:
+    branches: [main, master]
+
+jobs:
+  test:
+    uses: SignalK/signalk-server/.github/workflows/plugin-ci.yml@master

package/.github/workflows/test.yml

@@ -8,22 +8,14 @@ jobs:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        node-version: [12.x]
+        node-version: [24.x]
     steps:
     - uses: actions/checkout@v3.0.2
     - name: Use Node.js ${{ matrix.node-version }}
-      uses: actions/setup-node@v3.4.1
+      uses: actions/setup-node@v3.1.1
       with:
         node-version: ${{ matrix.node-version }}
     - run: npm install
     - run: npm test
       env:
         CI: true
-  merge-me:
-    name: Auto-merge dependency updates
-    needs: test
-    runs-on: ubuntu-latest
-    steps:
-    - uses: ridedott/merge-me-action@v2.10.22
-      with:
-        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

package/CHANGELOG.md

@@ -0,0 +1,42 @@
+# Changelog
+
+## [1.3.2] - 2026-08-23
+
+### Added
+- Added smoke tests for the plugin entry point (start/stop, subscription,
+  state-change resets, position logging, totals)
+
+## [1.3.1] - 2026-06-16
+
+### Added
+- Added application icon for SK appstore
+
+## [1.3.0] - 2026-06-10
+
+### Fixed
+- Don't start a new trip at startup if there's an ongoing one
+
+## [1.2.0] - 2023-04-27
+
+### Added
+- Added support for populating `navigation.log` for totals
+
+## [1.1.1] - 2023-02-28
+
+### Fixed
+- Fix issue when `navigation.position` doesn't contain coordinates
+
+## [1.1.0] - 2022-03-04
+
+### Added
+- Persist logs for current day/month/year, also by sailing/motoring
+
+## [1.0.1] - 2022-02-18
+
+### Fixed
+- Fix issue with reading lat and lon
+
+## [1.0.0] - 2022-02-18
+
+### Added
+- Initial version, logging in-memory only

package/README.md

@@ -6,15 +6,4 @@ The plugin monitors vessel `navigation.state` as set by the [signalk-autostate](
 
 ## Changes
 
-* 1.3.0 (June 10th 2026)
-  - Don't start a new trip at startup if there's an ongoing one
-* 1.2.0 (April 27th 2023)
-  - Added support for populating `navigation.log` for totals
-* 1.1.1 (February 28th 2023)
-  - Fix issue when `navigation.position` doesn't contain coordinates
-* 1.1.0 (March 4th 2022)
-  - Persist logs for current day/month/year, also by sailing/motoring
-* 1.0.1 (February 18th 2022)
-  - Fix issue with reading lat and lon
-* 1.0.0 (February 18th 2022)
-  - Initial version, logging in-memory only
+See [Changelog](CHANGELOG.md)

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "@meri-imperiumi/signalk-triplogger",
-  "version": "1.3.0",
+  "version": "1.3.2",
   "description": "Log the length of the current trip",
   "main": "index.js",
   "scripts": {
-    "lint": "eslint .",
-    "test": "npm run lint"
+    "test": "node --test --test-force-exit \"tests/*.test.js\" && eslint .",
+    "lint": "eslint ."
   },
   "repository": {
     "type": "git",
@@ -16,6 +16,13 @@
     "signalk-category-utility"
   ],
   "signalk-plugin-enabled-by-default": true,
+  "signalk": {
+    "appIcon": "./doc/appicon.png",
+    "displayName": "Automatic Trip Length Logger",
+    "requires": [
+      "@meri-imperiumi/signalk-autostate"
+    ]
+  },
   "author": "Henri Bergius <henri.bergius@iki.fi>",
   "license": "MIT",
   "bugs": {

package/tests/fake-app.js

@@ -0,0 +1,78 @@
+/**
+ * Shared test fakes: a mock Signal K app matching the patterns used by the
+ * signalk-aprsfi-ais-reporter test suite, adapted for the triplogger's
+ * needs (subscriptionmanager + handleMessage + setPluginStatus + data dir).
+ *
+ * @file fake-app.js
+ */
+
+/* eslint-disable class-methods-use-this */
+
+const { join } = require('node:path');
+const { mkdtempSync } = require('node:fs');
+const { tmpdir } = require('node:os');
+
+/**
+ * Minimal Signal K app fake with subscriptionmanager + handleMessage +
+ * setPluginStatus + setProviderStatus + getDataDirPath + error.
+ *
+ * The data path is a fresh temp directory per instance so the Logger can
+ * write log files without touching the project tree.
+ */
+class FakeSignalKApp {
+  constructor() {
+    this.selfId = 'urn:mrn:imo:mmsi:230999999';
+    this.subscriptionmanager = {
+      subscriptions: [],
+      subscribe(subscription, unsubscribes, onError, onDelta) {
+        this.subscriptions.push({ subscription, onDelta });
+        unsubscribes.push(() => {
+          const idx = this.subscriptions.findIndex(
+            (s) => s.subscription === subscription,
+          );
+          if (idx >= 0) this.subscriptions.splice(idx, 1);
+        });
+      },
+    };
+    this.statusMessages = [];
+    this.errors = [];
+    this.messages = [];
+    this.dataPath = mkdtempSync(join(tmpdir(), 'triplogger-test-'));
+  }
+
+  getDataDirPath() {
+    return this.dataPath;
+  }
+
+  setPluginStatus = (msg) => {
+    this.statusMessages.push({ type: 'status', msg });
+  };
+
+  setProviderStatus = (msg) => {
+    this.statusMessages.push({ type: 'status', msg });
+  };
+
+  handleMessage = (sourceId, message) => {
+    this.messages.push({ sourceId, message });
+  };
+
+  debug() {}
+
+  error(msg) {
+    this.errors.push(msg);
+  }
+}
+
+/**
+ * Emits a delta into the subscriptionmanager's registered handlers, for
+ * tests that want to feed navigation values.
+ *
+ * @param {FakeSignalKApp} app
+ * @param {object} delta
+ * @returns {void}
+ */
+function emitDelta(app, delta) {
+  app.subscriptionmanager.subscriptions.forEach(({ onDelta }) => onDelta(delta));
+}
+
+module.exports = { FakeSignalKApp, emitDelta };

package/tests/plugin.test.js

@@ -0,0 +1,268 @@
+/**
+ * Smoke tests for the plugin entry point (plugin shape, start/stop,
+ * subscription, state-change resets, position logging, totals).
+ * @file plugin.test.js
+ */
+
+const test = require('node:test');
+const assert = require('node:assert/strict');
+const { readFileSync, writeFileSync } = require('node:fs');
+const { join } = require('node:path');
+
+const makePlugin = require('../index');
+const { FakeSignalKApp, emitDelta } = require('./fake-app');
+
+/**
+ * Poll until `predicate` returns truthy, retrying every ~10ms up to `timeout`
+ * milliseconds. Resolves true on success, false on timeout. Useful for
+ * awaiting async plugin side-effects (file I/O) without fixed sleeps.
+ *
+ * @param {() => boolean} predicate
+ * @param {number} [timeout]
+ * @returns {Promise<boolean>}
+ */
+function waitFor(predicate, timeout = 500) {
+  return new Promise((resolve) => {
+    const start = Date.now();
+    const tick = () => {
+      if (predicate()) {
+        resolve(true);
+        return;
+      }
+      if (Date.now() - start >= timeout) {
+        resolve(false);
+        return;
+      }
+      setTimeout(tick, 10);
+    };
+    tick();
+  });
+}
+
+/**
+ * Build a started plugin instance wired to a fresh fake app with the
+ * given settings (defaulted).
+ *
+ * @param {object} [overrides]
+ * @returns {{app: FakeSignalKApp, plugin: object}}
+ */
+function makeStarted(overrides) {
+  const app = new FakeSignalKApp();
+  const plugin = makePlugin(app);
+  plugin.start({
+    update_interval: 10000,
+    totals: true,
+    totals_base: 0,
+    ...overrides,
+  });
+  return { app, plugin };
+}
+
+/**
+ * Read a log file written by the Logger from the app's data dir.
+ *
+ * @param {FakeSignalKApp} app
+ * @param {string} name
+ * @returns {object}
+ */
+function readLog(app, name) {
+  return JSON.parse(readFileSync(join(app.dataPath, `${name}.json`), 'utf-8'));
+}
+
+/**
+ * Pre-seed a log file in the app's data dir before start, so the Logger
+ * loads an existing state instead of starting fresh. Used to make the
+ * "new trip" transition deterministic without racing two state emits.
+ *
+ * @param {FakeSignalKApp} app
+ * @param {string} name
+ * @param {object} contents
+ * @returns {void}
+ */
+function seedLog(app, name, contents) {
+  writeFileSync(join(app.dataPath, `${name}.json`), JSON.stringify(contents, null, 2));
+}
+
+test('creates a plugin object with the right id/name', () => {
+  const app = new FakeSignalKApp();
+  const plugin = makePlugin(app);
+  assert.strictEqual(plugin.id, 'signalk-triplogger');
+  assert.strictEqual(plugin.name, 'Trip logger');
+  assert.ok(plugin.description);
+});
+
+test('schema is a JSON object with the expected options', () => {
+  const app = new FakeSignalKApp();
+  const plugin = makePlugin(app);
+  assert.strictEqual(plugin.schema.type, 'object');
+  assert.ok(plugin.schema.properties.update_interval);
+  assert.ok(plugin.schema.properties.totals);
+  assert.ok(plugin.schema.properties.totals_base);
+});
+
+test('start subscribes to navigation.state and navigation.position', () => {
+  const { app, plugin } = makeStarted();
+  assert.strictEqual(app.subscriptionmanager.subscriptions.length, 1);
+  const sub = app.subscriptionmanager.subscriptions[0].subscription;
+  assert.strictEqual(sub.context, 'vessels.self');
+  const paths = sub.subscribe.map((s) => s.path);
+  assert.ok(paths.includes('navigation.state'));
+  assert.ok(paths.includes('navigation.position'));
+  plugin.stop();
+});
+
+test('start sets an initial status message', () => {
+  const { app, plugin } = makeStarted();
+  assert.ok(
+    app.statusMessages.some(
+      (m) => m.type === 'status' && /waiting/i.test(m.msg),
+    ),
+    `got ${JSON.stringify(app.statusMessages)}`,
+  );
+  plugin.stop();
+});
+
+test('transitioning into a trip resets the log and posts a status', async () => {
+  const app = new FakeSignalKApp();
+  // A fresh current log is considered already in-trip. To make the
+  // transition into a trip deterministic (instead of racing two async
+  // state emits), seed an *ended* current log so inTrip() starts false,
+  // then emit a single trip-starting state.
+  seedLog(app, 'current', {
+    started: '2026-01-01T00:00:00.000Z',
+    ended: '2026-01-01T01:00:00.000Z',
+    total: 0,
+    states: {},
+  });
+  const plugin = makePlugin(app);
+  plugin.start({});
+  emitDelta(app, {
+    context: 'vessels.self',
+    updates: [
+      { values: [{ path: 'navigation.state', value: 'sailing' }] },
+    ],
+  });
+  await waitFor(
+    () => app.statusMessages.some((m) => /new trip/i.test(m.msg)),
+  );
+  plugin.stop();
+  assert.ok(
+    app.statusMessages.some(
+      (m) => m.type === 'status' && /new trip/i.test(m.msg),
+    ),
+    `got ${JSON.stringify(app.statusMessages)}`,
+  );
+});
+
+test('position updates append distance to the trip log and emit deltas', async () => {
+  const app = new FakeSignalKApp();
+  // Seed an ended current log so start isn't considered in-trip, then emit
+  // a single trip-starting state. This avoids racing two async state emits.
+  seedLog(app, 'current', {
+    started: '2026-01-01T00:00:00.000Z',
+    ended: '2026-01-01T01:00:00.000Z',
+    total: 0,
+    states: {},
+  });
+  const plugin = makePlugin(app);
+  plugin.start({ totals: true });
+  emitDelta(app, {
+    context: 'vessels.self',
+    updates: [{ values: [{ path: 'navigation.state', value: 'sailing' }] }],
+  });
+  // Wait for the new-trip reset to settle before sending positions.
+  await waitFor(
+    () => app.statusMessages.some((m) => /new trip/i.test(m.msg)),
+  );
+
+  // First position just establishes lastPosition; no distance yet.
+  emitDelta(app, {
+    context: 'vessels.self',
+    updates: [
+      { values: [{ path: 'navigation.position', value: { latitude: 60.0, longitude: 24.0 } }] },
+    ],
+  });
+
+  // Second position ~111m east of the first → appendTrip writes log files.
+  emitDelta(app, {
+    context: 'vessels.self',
+    updates: [
+      { values: [{ path: 'navigation.position', value: { latitude: 60.001, longitude: 24.0 } }] },
+    ],
+  });
+  await waitFor(() => {
+    const tripValue = app.messages
+      .flatMap(({ message }) => message.updates.flatMap((u) => u.values))
+      .find((v) => v.path === 'navigation.trip.log' && v.value > 0);
+    return !!tripValue;
+  });
+
+  plugin.stop();
+
+  // A trip.log delta should have been published to the app.
+  const tripMsgs = app.messages.filter(
+    ({ message }) => message.updates.some((u) => u.values.some((v) => v.path === 'navigation.trip.log')),
+  );
+  assert.ok(tripMsgs.length > 0, 'no navigation.trip.log delta was emitted');
+
+  // The current trip log file should be persisted with a positive total.
+  const current = readLog(app, 'current');
+  assert.ok(current.total > 0, `current.total was ${current.total}`);
+});
+
+test('totals option also publishes navigation.log', async () => {
+  const app = new FakeSignalKApp();
+  seedLog(app, 'current', {
+    started: '2026-01-01T00:00:00.000Z',
+    ended: '2026-01-01T01:00:00.000Z',
+    total: 0,
+    states: {},
+  });
+  const plugin = makePlugin(app);
+  plugin.start({ totals: true, totals_base: 100 });
+  emitDelta(app, {
+    context: 'vessels.self',
+    updates: [{ values: [{ path: 'navigation.state', value: 'motoring' }] }],
+  });
+  await waitFor(
+    () => app.statusMessages.some((m) => /new trip/i.test(m.msg)),
+  );
+
+  emitDelta(app, {
+    context: 'vessels.self',
+    updates: [
+      { values: [{ path: 'navigation.position', value: { latitude: 60.0, longitude: 24.0 } }] },
+    ],
+  });
+  emitDelta(app, {
+    context: 'vessels.self',
+    updates: [
+      { values: [{ path: 'navigation.position', value: { latitude: 60.002, longitude: 24.0 } }] },
+    ],
+  });
+  await waitFor(() => {
+    const logValue = app.messages
+      .flatMap(({ message }) => message.updates.flatMap((u) => u.values))
+      .find((v) => v.path === 'navigation.log' && v.value > 100);
+    return !!logValue;
+  });
+  plugin.stop();
+
+  const logMsgs = app.messages.filter(
+    ({ message }) => message.updates.some((u) => u.values.some((v) => v.path === 'navigation.log')),
+  );
+  assert.ok(logMsgs.length > 0, 'no navigation.log delta was emitted');
+  const last = logMsgs[logMsgs.length - 1];
+  const { value } = last.message.updates
+    .flatMap((u) => u.values)
+    .find((v) => v.path === 'navigation.log');
+  // totals_base of 100 should be added on top of the logged distance.
+  assert.ok(value > 100, `navigation.log value was ${value}`);
+});
+
+test('stop clears subscriptions', () => {
+  const { app, plugin } = makeStarted();
+  assert.strictEqual(app.subscriptionmanager.subscriptions.length, 1);
+  plugin.stop();
+  assert.strictEqual(app.subscriptionmanager.subscriptions.length, 0);
+});

package/.github/dependabot.yml

@@ -1,11 +0,0 @@
-version: 2
-updates:
-  - package-ecosystem: npm
-    directory: "/"
-    schedule:
-      interval: daily
-    versioning-strategy: increase-if-necessary
-  - package-ecosystem: github-actions
-    directory: "/"
-    schedule:
-      interval: weekly