yoto-nodejs-client 0.0.6 → 0.0.7

package/lib/yoto-account.js

@@ -1,6 +1,7 @@
 /**
  * @import { YotoClientConstructorOptions } from './api-client.js'
- * @import { YotoDeviceModelOptions } from './yoto-device.js'
+ * @import { YotoDeviceModelOptions, YotoDeviceModelConfig, YotoDeviceStatus, YotoDeviceOnlineMetadata, YotoDeviceOfflineMetadata, YotoPlaybackState, YotoMqttConnectMetadata, YotoMqttDisconnectMetadata, YotoMqttCloseMetadata } from './yoto-device.js'
+ * @import { YotoEventsMessage, YotoStatusMessage, YotoStatusLegacyMessage, YotoResponseMessage } from './mqtt/client.js'
  */
 
 import { EventEmitter } from 'events'
@@ -33,14 +34,189 @@ import { YotoDeviceModel } from './yoto-device.js'
  * @property {string[]} devices - Array of device IDs
  */
 
+/**
+ * Device event wrapper
+ * @template T
+ * @typedef {{ deviceId: string } & T} YotoAccountDeviceEvent
+ */
+
+/**
+ * Device added event data
+ * @typedef {YotoAccountDeviceEvent<{}>} YotoAccountDeviceAddedEvent
+ */
+
+/**
+ * Device removed event data
+ * @typedef {YotoAccountDeviceEvent<{}>} YotoAccountDeviceRemovedEvent
+ */
+
+/**
+ * Device status update event data
+ * @typedef {YotoAccountDeviceEvent<{
+ *   status: YotoDeviceStatus,
+ *   source: string,
+ *   changedFields: Set<keyof YotoDeviceStatus>
+ * }>} YotoAccountStatusUpdateEvent
+ */
+
+/**
+ * Device config update event data
+ * @typedef {YotoAccountDeviceEvent<{
+ *   config: YotoDeviceModelConfig,
+ *   changedFields: Set<keyof YotoDeviceModelConfig>
+ * }>} YotoAccountConfigUpdateEvent
+ */
+
+/**
+ * Device playback update event data
+ * @typedef {YotoAccountDeviceEvent<{
+ *   playback: YotoPlaybackState,
+ *   changedFields: Set<keyof YotoPlaybackState>
+ * }>} YotoAccountPlaybackUpdateEvent
+ */
+
+/**
+ * Device online event data
+ * @typedef {YotoAccountDeviceEvent<{
+ *   metadata: YotoDeviceOnlineMetadata
+ * }>} YotoAccountOnlineEvent
+ */
+
+/**
+ * Device offline event data
+ * @typedef {YotoAccountDeviceEvent<{
+ *   metadata: YotoDeviceOfflineMetadata
+ * }>} YotoAccountOfflineEvent
+ */
+
+/**
+ * MQTT connect event data
+ * @typedef {YotoAccountDeviceEvent<{
+ *   metadata: YotoMqttConnectMetadata
+ * }>} YotoAccountMqttConnectEvent
+ */
+
+/**
+ * MQTT disconnect event data
+ * @typedef {YotoAccountDeviceEvent<{
+ *   metadata: YotoMqttDisconnectMetadata
+ * }>} YotoAccountMqttDisconnectEvent
+ */
+
+/**
+ * MQTT close event data
+ * @typedef {YotoAccountDeviceEvent<{
+ *   metadata: YotoMqttCloseMetadata
+ * }>} YotoAccountMqttCloseEvent
+ */
+
+/**
+ * MQTT reconnect event data
+ * @typedef {YotoAccountDeviceEvent<{}>} YotoAccountMqttReconnectEvent
+ */
+
+/**
+ * MQTT offline event data
+ * @typedef {YotoAccountDeviceEvent<{}>} YotoAccountMqttOfflineEvent
+ */
+
+/**
+ * MQTT end event data
+ * @typedef {YotoAccountDeviceEvent<{}>} YotoAccountMqttEndEvent
+ */
+
+/**
+ * MQTT status event data
+ * @typedef {YotoAccountDeviceEvent<{
+ *   topic: string,
+ *   message: YotoStatusMessage
+ * }>} YotoAccountMqttStatusEvent
+ */
+
+/**
+ * MQTT events event data
+ * @typedef {YotoAccountDeviceEvent<{
+ *   topic: string,
+ *   message: YotoEventsMessage
+ * }>} YotoAccountMqttEventsEvent
+ */
+
+/**
+ * MQTT legacy status event data
+ * @typedef {YotoAccountDeviceEvent<{
+ *   topic: string,
+ *   message: YotoStatusLegacyMessage
+ * }>} YotoAccountMqttStatusLegacyEvent
+ */
+
+/**
+ * MQTT response event data
+ * @typedef {YotoAccountDeviceEvent<{
+ *   topic: string,
+ *   message: YotoResponseMessage
+ * }>} YotoAccountMqttResponseEvent
+ */
+
+/**
+ * MQTT unknown event data
+ * @typedef {YotoAccountDeviceEvent<{
+ *   topic: string,
+ *   message: unknown
+ * }>} YotoAccountMqttUnknownEvent
+ */
+
+/**
+ * Account error event data
+ * @typedef {Object} YotoAccountErrorEvent
+ * @property {Error} error - Error instance
+ * @property {YotoAccountErrorContext} context - Error context
+ */
+
+/**
+ * Device event handler set
+ * @typedef {Object} YotoAccountDeviceEventHandlers
+ * @property {(status: YotoDeviceStatus, source: string, changedFields: Set<keyof YotoDeviceStatus>) => void} statusUpdate
+ * @property {(config: YotoDeviceModelConfig, changedFields: Set<keyof YotoDeviceModelConfig>) => void} configUpdate
+ * @property {(playback: YotoPlaybackState, changedFields: Set<keyof YotoPlaybackState>) => void} playbackUpdate
+ * @property {(metadata: YotoDeviceOnlineMetadata) => void} online
+ * @property {(metadata: YotoDeviceOfflineMetadata) => void} offline
+ * @property {(metadata: YotoMqttConnectMetadata) => void} mqttConnect
+ * @property {(metadata: YotoMqttDisconnectMetadata) => void} mqttDisconnect
+ * @property {(metadata: YotoMqttCloseMetadata) => void} mqttClose
+ * @property {() => void} mqttReconnect
+ * @property {() => void} mqttOffline
+ * @property {() => void} mqttEnd
+ * @property {(topic: string, message: YotoStatusMessage) => void} mqttStatus
+ * @property {(topic: string, message: YotoEventsMessage) => void} mqttEvents
+ * @property {(topic: string, message: YotoStatusLegacyMessage) => void} mqttStatusLegacy
+ * @property {(topic: string, message: YotoResponseMessage) => void} mqttResponse
+ * @property {(topic: string, message: unknown) => void} mqttUnknown
+ */
+
 /**
  * Event map for YotoAccount
  * @typedef {{
  *   'started': [YotoAccountStartedMetadata],
  *   'stopped': [],
- *   'deviceAdded': [string, YotoDeviceModel],
- *   'deviceRemoved': [string],
- *   'error': [Error, YotoAccountErrorContext]
+ *   'deviceAdded': [YotoAccountDeviceAddedEvent],
+ *   'deviceRemoved': [YotoAccountDeviceRemovedEvent],
+ *   'statusUpdate': [YotoAccountStatusUpdateEvent],
+ *   'configUpdate': [YotoAccountConfigUpdateEvent],
+ *   'playbackUpdate': [YotoAccountPlaybackUpdateEvent],
+ *   'online': [YotoAccountOnlineEvent],
+ *   'offline': [YotoAccountOfflineEvent],
+ *   'mqttConnect': [YotoAccountMqttConnectEvent],
+ *   'mqttDisconnect': [YotoAccountMqttDisconnectEvent],
+ *   'mqttClose': [YotoAccountMqttCloseEvent],
+ *   'mqttReconnect': [YotoAccountMqttReconnectEvent],
+ *   'mqttOffline': [YotoAccountMqttOfflineEvent],
+ *   'mqttEnd': [YotoAccountMqttEndEvent],
+ *   'mqttStatus': [YotoAccountMqttStatusEvent],
+ *   'mqttEvents': [YotoAccountMqttEventsEvent],
+ *   'mqttStatusLegacy': [YotoAccountMqttStatusLegacyEvent],
+ *   'mqttResponse': [YotoAccountMqttResponseEvent],
+ *   'mqttUnknown': [YotoAccountMqttUnknownEvent],
+ *   'error': [YotoAccountErrorEvent]
  * }} YotoAccountEventMap
  */
 
@@ -54,9 +230,10 @@ import { YotoDeviceModel } from './yoto-device.js'
  * Events:
  * - 'started' - Emitted when account starts, passes metadata with deviceCount and devices array
  * - 'stopped' - Emitted when account stops
- * - 'deviceAdded' - Emitted when a device is added, passes (deviceId, deviceModel)
- * - 'deviceRemoved' - Emitted when a device is removed, passes deviceId
- * - 'error' - Emitted when an error occurs, passes (error, context)
+ * - 'deviceAdded' - Emitted when a device is added, passes { deviceId }
+ * - 'deviceRemoved' - Emitted when a device is removed, passes { deviceId }
+ * - Device events are re-emitted with device context, see event map for signatures
+ * - 'error' - Emitted when an error occurs, passes { error, context }
  *
  * Note: To listen to individual device events (statusUpdate, configUpdate, playbackUpdate, online, offline, etc.),
  * access the device models directly via account.devices or account.getDevice(deviceId) and attach listeners.
@@ -66,6 +243,7 @@ import { YotoDeviceModel } from './yoto-device.js'
 export class YotoAccount extends EventEmitter {
   /** @type {YotoClient} */ #client
   /** @type {Map<string, YotoDeviceModel>} */ #devices = new Map()
+  /** @type {Map<string, YotoAccountDeviceEventHandlers>} */ #deviceEventHandlers = new Map()
   /** @type {YotoAccountOptions} */ #options
   /** @type {boolean} */ #running = false
   /** @type {boolean} */ #initialized = false
@@ -152,6 +330,7 @@ export class YotoAccount extends EventEmitter {
 
         // Set up device error forwarding
         this.#setupDeviceErrorHandling(deviceModel, device.deviceId)
+        this.#setupDeviceEventForwarding(deviceModel, device.deviceId)
 
         // Track device
         this.#devices.set(device.deviceId, deviceModel)
@@ -161,14 +340,19 @@ export class YotoAccount extends EventEmitter {
           await deviceModel.start()
         } catch (err) {
           const error = /** @type {Error} */ (err)
-          this.emit('error', error, {
-            source: device.deviceId,
-            deviceId: device.deviceId,
-            operation: 'start'
+          this.emit('error', {
+            error,
+            context: {
+              source: device.deviceId,
+              deviceId: device.deviceId,
+              operation: 'start'
+            }
           })
         }
 
-        this.emit('deviceAdded', device.deviceId, deviceModel)
+        this.emit('deviceAdded', {
+          deviceId: device.deviceId
+        })
       }
 
       // Mark as initialized and running
@@ -181,9 +365,12 @@ export class YotoAccount extends EventEmitter {
       })
     } catch (err) {
       const error = /** @type {Error} */ (err)
-      this.emit('error', error, {
-        source: 'account',
-        operation: 'start'
+      this.emit('error', {
+        error,
+        context: {
+          source: 'account',
+          operation: 'start'
+        }
       })
       throw error
     }
@@ -202,12 +389,16 @@ export class YotoAccount extends EventEmitter {
       // Stop all devices
       const stopPromises = []
       for (const [deviceId, deviceModel] of this.#devices) {
+        this.#removeDeviceEventForwarding(deviceModel, deviceId)
         stopPromises.push(
           deviceModel.stop().catch((error) => {
-            this.emit('error', error, {
-              source: deviceId,
-              deviceId,
-              operation: 'stop'
+            this.emit('error', {
+              error,
+              context: {
+                source: deviceId,
+                deviceId,
+                operation: 'stop'
+              }
             })
           })
         )
@@ -218,6 +409,7 @@ export class YotoAccount extends EventEmitter {
 
       // Clear devices
       this.#devices.clear()
+      this.#deviceEventHandlers.clear()
 
       // Mark as stopped
       this.#running = false
@@ -225,9 +417,12 @@ export class YotoAccount extends EventEmitter {
       this.emit('stopped')
     } catch (err) {
       const error = /** @type {Error} */ (err)
-      this.emit('error', error, {
-        source: 'account',
-        operation: 'stop'
+      this.emit('error', {
+        error,
+        context: {
+          source: 'account',
+          operation: 'stop'
+        }
       })
       throw error
     }
@@ -271,15 +466,19 @@ export class YotoAccount extends EventEmitter {
       for (const deviceId of devicesToRemove) {
         const deviceModel = this.#devices.get(deviceId)
         if (deviceModel) {
+          this.#removeDeviceEventForwarding(deviceModel, deviceId)
           await deviceModel.stop().catch((error) => {
-            this.emit('error', error, {
-              source: deviceId,
-              deviceId,
-              operation: 'remove'
+            this.emit('error', {
+              error,
+              context: {
+                source: deviceId,
+                deviceId,
+                operation: 'remove'
+              }
             })
           })
           this.#devices.delete(deviceId)
-          this.emit('deviceRemoved', deviceId)
+          this.emit('deviceRemoved', { deviceId })
         }
       }
 
@@ -293,26 +492,35 @@ export class YotoAccount extends EventEmitter {
 
         // Set up device error forwarding
         this.#setupDeviceErrorHandling(deviceModel, device.deviceId)
+        this.#setupDeviceEventForwarding(deviceModel, device.deviceId)
 
         // Track device
         this.#devices.set(device.deviceId, deviceModel)
 
         // Start device
         await deviceModel.start().catch((error) => {
-          this.emit('error', error, {
-            source: device.deviceId,
-            deviceId: device.deviceId,
-            operation: 'add'
+          this.emit('error', {
+            error,
+            context: {
+              source: device.deviceId,
+              deviceId: device.deviceId,
+              operation: 'add'
+            }
           })
         })
 
-        this.emit('deviceAdded', device.deviceId, deviceModel)
+        this.emit('deviceAdded', {
+          deviceId: device.deviceId
+        })
       }
     } catch (err) {
       const error = /** @type {Error} */ (err)
-      this.emit('error', error, {
-        source: 'account',
-        operation: 'refreshDevices'
+      this.emit('error', {
+        error,
+        context: {
+          source: 'account',
+          operation: 'refreshDevices'
+        }
       })
       throw error
     }
@@ -330,11 +538,175 @@ export class YotoAccount extends EventEmitter {
   #setupDeviceErrorHandling (deviceModel, deviceId) {
     // Forward device errors to account-level error event
     deviceModel.on('error', (error) => {
-      this.emit('error', error, {
-        source: deviceId,
-        deviceId,
-        operation: 'device-error'
+      this.emit('error', {
+        error,
+        context: {
+          source: deviceId,
+          deviceId,
+          operation: 'device-error'
+        }
       })
     })
   }
+
+  /**
+   * Forward device events through the account event bus with device context
+   * @param {YotoDeviceModel} deviceModel - Device model instance
+   * @param {string} deviceId - Device ID
+   */
+  #setupDeviceEventForwarding (deviceModel, deviceId) {
+    /** @type {YotoAccountDeviceEventHandlers} */
+    const handlers = {
+      statusUpdate: (status, source, changedFields) => {
+        this.emit('statusUpdate', {
+          deviceId,
+          status,
+          source,
+          changedFields
+        })
+      },
+      configUpdate: (config, changedFields) => {
+        this.emit('configUpdate', {
+          deviceId,
+          config,
+          changedFields
+        })
+      },
+      playbackUpdate: (playback, changedFields) => {
+        this.emit('playbackUpdate', {
+          deviceId,
+          playback,
+          changedFields
+        })
+      },
+      online: (metadata) => {
+        this.emit('online', {
+          deviceId,
+          metadata
+        })
+      },
+      offline: (metadata) => {
+        this.emit('offline', {
+          deviceId,
+          metadata
+        })
+      },
+      mqttConnect: (metadata) => {
+        this.emit('mqttConnect', {
+          deviceId,
+          metadata
+        })
+      },
+      mqttDisconnect: (metadata) => {
+        this.emit('mqttDisconnect', {
+          deviceId,
+          metadata
+        })
+      },
+      mqttClose: (metadata) => {
+        this.emit('mqttClose', {
+          deviceId,
+          metadata
+        })
+      },
+      mqttReconnect: () => {
+        this.emit('mqttReconnect', {
+          deviceId
+        })
+      },
+      mqttOffline: () => {
+        this.emit('mqttOffline', {
+          deviceId
+        })
+      },
+      mqttEnd: () => {
+        this.emit('mqttEnd', {
+          deviceId
+        })
+      },
+      mqttStatus: (topic, message) => {
+        this.emit('mqttStatus', {
+          deviceId,
+          topic,
+          message
+        })
+      },
+      mqttEvents: (topic, message) => {
+        this.emit('mqttEvents', {
+          deviceId,
+          topic,
+          message
+        })
+      },
+      mqttStatusLegacy: (topic, message) => {
+        this.emit('mqttStatusLegacy', {
+          deviceId,
+          topic,
+          message
+        })
+      },
+      mqttResponse: (topic, message) => {
+        this.emit('mqttResponse', {
+          deviceId,
+          topic,
+          message
+        })
+      },
+      mqttUnknown: (topic, message) => {
+        this.emit('mqttUnknown', {
+          deviceId,
+          topic,
+          message
+        })
+      }
+    }
+
+    deviceModel.on('statusUpdate', handlers.statusUpdate)
+    deviceModel.on('configUpdate', handlers.configUpdate)
+    deviceModel.on('playbackUpdate', handlers.playbackUpdate)
+    deviceModel.on('online', handlers.online)
+    deviceModel.on('offline', handlers.offline)
+    deviceModel.on('mqttConnect', handlers.mqttConnect)
+    deviceModel.on('mqttDisconnect', handlers.mqttDisconnect)
+    deviceModel.on('mqttClose', handlers.mqttClose)
+    deviceModel.on('mqttReconnect', handlers.mqttReconnect)
+    deviceModel.on('mqttOffline', handlers.mqttOffline)
+    deviceModel.on('mqttEnd', handlers.mqttEnd)
+    deviceModel.on('mqttStatus', handlers.mqttStatus)
+    deviceModel.on('mqttEvents', handlers.mqttEvents)
+    deviceModel.on('mqttStatusLegacy', handlers.mqttStatusLegacy)
+    deviceModel.on('mqttResponse', handlers.mqttResponse)
+    deviceModel.on('mqttUnknown', handlers.mqttUnknown)
+
+    this.#deviceEventHandlers.set(deviceId, handlers)
+  }
+
+  /**
+   * Remove forwarded device event handlers
+   * @param {YotoDeviceModel} deviceModel - Device model instance
+   * @param {string} deviceId - Device ID
+   */
+  #removeDeviceEventForwarding (deviceModel, deviceId) {
+    const handlers = this.#deviceEventHandlers.get(deviceId)
+    if (!handlers) return
+
+    deviceModel.off('statusUpdate', handlers.statusUpdate)
+    deviceModel.off('configUpdate', handlers.configUpdate)
+    deviceModel.off('playbackUpdate', handlers.playbackUpdate)
+    deviceModel.off('online', handlers.online)
+    deviceModel.off('offline', handlers.offline)
+    deviceModel.off('mqttConnect', handlers.mqttConnect)
+    deviceModel.off('mqttDisconnect', handlers.mqttDisconnect)
+    deviceModel.off('mqttClose', handlers.mqttClose)
+    deviceModel.off('mqttReconnect', handlers.mqttReconnect)
+    deviceModel.off('mqttOffline', handlers.mqttOffline)
+    deviceModel.off('mqttEnd', handlers.mqttEnd)
+    deviceModel.off('mqttStatus', handlers.mqttStatus)
+    deviceModel.off('mqttEvents', handlers.mqttEvents)
+    deviceModel.off('mqttStatusLegacy', handlers.mqttStatusLegacy)
+    deviceModel.off('mqttResponse', handlers.mqttResponse)
+    deviceModel.off('mqttUnknown', handlers.mqttUnknown)
+
+    this.#deviceEventHandlers.delete(deviceId)
+  }
 }

package/lib/yoto-account.test.js

@@ -0,0 +1,139 @@
+/** @import { YotoDeviceModel } from './yoto-device.js' */
+
+import test from 'node:test'
+import assert from 'node:assert/strict'
+import { once } from 'node:events'
+import { setTimeout as sleep } from 'node:timers/promises'
+import { join } from 'node:path'
+import { YotoAccount } from './yoto-account.js'
+import { loadTestTokens } from './api-endpoints/endpoint-test-helpers.js'
+import { saveTokensToEnv } from '../bin/lib/token-helpers.js'
+import {
+  assertConfigShape,
+  assertPlaybackShape,
+  toLower,
+  withTimeout
+} from './test-helpers/device-model-test-helpers.js'
+
+const envPath = join(import.meta.dirname, '..', '.env')
+
+/**
+ * @returns {YotoAccount}
+ */
+function createTestAccount () {
+  const clientId = process.env['YOTO_CLIENT_ID']
+  const refreshToken = process.env['YOTO_REFRESH_TOKEN']
+  const accessToken = process.env['YOTO_ACCESS_TOKEN']
+
+  assert.ok(clientId, 'YOTO_CLIENT_ID is required')
+  assert.ok(refreshToken, 'YOTO_REFRESH_TOKEN is required')
+  assert.ok(accessToken, 'YOTO_ACCESS_TOKEN is required')
+
+  return new YotoAccount({
+    clientOptions: {
+      clientId,
+      refreshToken,
+      accessToken,
+      onTokenRefresh: async (tokens) => {
+        const { resolvedPath } = await saveTokensToEnv(envPath, {
+          access_token: tokens.updatedAccessToken,
+          refresh_token: tokens.updatedRefreshToken,
+          token_type: 'Bearer',
+          expires_in: tokens.updatedExpiresAt - Math.floor(Date.now() / 1000)
+        }, tokens.clientId)
+        console.log(`Token Refreshed: ${resolvedPath}`)
+      }
+    },
+    deviceOptions: {
+      httpPollIntervalMs: 600000
+    }
+  })
+}
+
+/**
+ * @param {YotoAccount} account
+ * @returns {Promise<void>}
+ */
+async function waitForAccountReady (account) {
+  const started = withTimeout(once(account, 'started'), 30000, 'started')
+  await account.start()
+  await started
+  await sleep(1500)
+}
+
+/**
+ * @param {YotoDeviceModel} model
+ */
+function assertDeviceModelState (model) {
+  assert.ok(model.running, 'device model should be running')
+  assertConfigShape(model.config)
+  assertPlaybackShape(model.playback)
+
+  // TODO: Add mutation coverage (updateConfig, sendCommand, etc.)
+}
+
+test('YotoAccount - online devices', async (t) => {
+  /** @type {YotoAccount | null} */
+  let account = null
+  /** @type {YotoDeviceModel[]} */
+  let deviceModels = []
+  /** @type {{ deviceId: string }[]} */
+  const deviceAddedEvents = []
+  /** @type {YotoDeviceModel | undefined} */
+  let onlineMini
+  /** @type {YotoDeviceModel | undefined} */
+  let onlineV3
+
+  t.before(async () => {
+    loadTestTokens()
+    account = createTestAccount()
+    account.on('deviceAdded', (event) => {
+      deviceAddedEvents.push(event)
+    })
+    await waitForAccountReady(account)
+
+    deviceModels = Array.from(account.devices.values())
+    onlineMini = deviceModels.find(model => {
+      const { deviceType, deviceFamily, online } = model.device
+      const family = toLower(deviceFamily)
+      const type = toLower(deviceType)
+      return online && (family === 'mini' || type.includes('mini'))
+    })
+    onlineV3 = deviceModels.find(model => {
+      const { deviceType, deviceFamily, online } = model.device
+      const family = toLower(deviceFamily)
+      const type = toLower(deviceType)
+      return online && (family === 'v3' || type.includes('v3'))
+    })
+  })
+
+  t.after(async () => {
+    if (account) {
+      await account.stop()
+    }
+  })
+
+  await t.test('account state', async () => {
+    assert.ok(account, 'account should exist')
+    assert.ok(account.running, 'account should be running')
+    assert.ok(account.initialized, 'account should be initialized')
+    assert.ok(account.devices.size > 0, 'account should have devices')
+    assert.equal(account.getDeviceIds().length, account.devices.size, 'device IDs should match map size')
+    assert.equal(deviceAddedEvents.length, account.devices.size, 'deviceAdded events should match device count')
+    for (const event of deviceAddedEvents) {
+      assert.equal(typeof event.deviceId, 'string', 'deviceAdded should include a deviceId')
+      assert.ok(!('deviceModel' in event), 'deviceAdded should not include deviceModel')
+      assert.equal(Object.keys(event).length, 1, 'deviceAdded should only include deviceId')
+    }
+  })
+
+  await t.test('online mini', { skip: !onlineMini }, async () => {
+    assert.ok(onlineMini, 'No online mini device found')
+    assertDeviceModelState(onlineMini)
+  })
+
+  await t.test('online v3', { skip: !onlineV3 }, async () => {
+    assert.ok(onlineV3, 'No online v3 device found')
+    assertDeviceModelState(onlineV3)
+  })
+})