Alex2Node/test/connection.test.js

"use strict";
// The broker connection: the default host, an outage reported as events that never crash the host, disconnect() then
// connect(), and a publish that fails without rejecting.
const { test } = require("node:test");
const assert = require("node:assert/strict");
const { Alex2MQTT, AlexaInterfaceType, DisplayCategory, PowerController, DEFAULT_HOST } = require("alex2node");
const { broker, setup, connected, directive, until, sleep, cleanup } = require("./helpers/harness.js");

// Nothing listens on port 1, so every attempt is refused at once.
const DEAD_BROKER = { host: "mqtt://127.0.0.1:1", mqtt: { reconnectPeriod: 50, connectTimeout: 200 } };

test("defaults: the 1.4.0 host stays the default; options.host overrides it", () => {
  assert.equal(DEFAULT_HOST, "mqtt://Alex2MQTT.stormysdream.club:1883");
  assert.equal(new Alex2MQTT("u", "p", "root").getHost(), DEFAULT_HOST);
  assert.equal(new Alex2MQTT("u", "p", "root", false, { host: "mqtt://127.0.0.1:1" }).getHost(), "mqtt://127.0.0.1:1");
});

test("a dead broker: 'offline'/'error' events when listened to, and NO crash when nobody listens (1.4.0 killed the host)", async () => {
  const unheard = new Alex2MQTT("u", "p", "root", false, DEAD_BROKER);
  unheard.connect();
  cleanup(() => unheard.disconnect());
  await sleep(300);
  assert.equal(unheard.connected, false, "still alive, not connected");

  const seen = [];
  const heard = new Alex2MQTT("u", "p", "root", false, DEAD_BROKER);
  heard.on("error", (e) => seen.push(e.code || e.message));
  heard.on("offline", () => seen.push("offline"));
  heard.on("reconnect", () => seen.push("reconnect"));
  heard.connect();
  cleanup(() => heard.disconnect());
  await until(() => seen.includes("ECONNREFUSED") && seen.includes("reconnect"), 3000, "error + reconnect events");
});

test("registerDevice before connect throws (unchanged from 1.4.0)", () => {
  assert.throws(() => new Alex2MQTT("u", "p", "root").registerDevice("x", "1", null), /connect before/);
});

test("disconnect() then connect(): devices registered before still answer (1.5.1 left them on the closed client)", async () => {
  const { alexa, bridge } = await setup(Alex2MQTT, "root");
  const lamp = bridge.registerDevice("Lamp", "lamp-1", DisplayCategory.LIGHT);
  lamp.addCapability(AlexaInterfaceType.POWER_CONTROLLER);
  lamp.on("Event", (d) => {
    lamp.getStatusMessage(d.header.correlationToken, true).addPowerControllerProp(PowerController.ON).send();
  });
  const turnOn = (token) => alexa.send("root", directive("Alexa.PowerController", "TurnOn", "lamp-1", token));
  const tokens = () => alexa.on("root/lamp-1/alexaResponce").map((m) => m.event.header.correlationToken);
  const answered = (token) => tokens().includes(token);

  turnOn("before");
  await until(() => answered("before"), 3000, "response before disconnect");
  await bridge.disconnect();
  assert.equal(bridge.connected, false);

  await connected(bridge);
  assert.equal(bridge.getDevices().length, 1, "the devices stay registered");
  turnOn("after");
  await until(() => answered("after"), 3000, "response after disconnect() + connect()");
});

test("1.5.2: a failed publish never rejects send() - it resolves \"\" and reaches the bridge's error listener", async () => {
  const { url } = await broker();
  const bridge = new Alex2MQTT("u", "p", "root-send", false, { host: url });
  const errors = [];
  bridge.on("error", (e) => errors.push(e.message));
  await connected(bridge);
  const lamp = bridge.registerDevice("Lamp", "lamp-send", null);
  lamp.addCapability(AlexaInterfaceType.POWER_CONTROLLER);
  await bridge.disconnect(); // the device still holds the ended client until the next connect(): every publish now fails

  const status = await lamp.getStatusMessage("ct", true).addPowerControllerProp(PowerController.ON).send();
  const error = await lamp.getErrorMessage("ct").send();
  const scene = await lamp.sendSceneResponse("ct", true);
  const change = await lamp.getChangeReport("PHYSICAL_INTERACTION").addPowerControllerProp(PowerController.OFF).send();
  assert.deepEqual([status, error, scene, change], ["", "", "", ""], "each resolves \"\" instead of rejecting");
  assert.ok(errors.length >= 4, `every failure reached the error listener: ${errors.join(" | ")}`);

  // With no listener the same failure is swallowed: an "error" event without a listener would throw.
  const quiet = await connected(new Alex2MQTT("u", "p", "root-send-quiet", false, { host: url }));
  const q = quiet.registerDevice("Q", "q-1", null);
  await quiet.disconnect();
  assert.equal(await q.getStatusMessage("ct", true).addPowerControllerProp(PowerController.ON).send(), "");
});