@ecobridge.xyz/devicemanager 3.0.2

package/test/test.ts

@@ -0,0 +1,261 @@
+import { expect, tap } from '@git.zone/tstest/tapbundle';
+import * as devicemanager from '../ts/index.js';
+
+// Test core exports
+tap.test('should export DeviceManager', async () => {
+  expect(devicemanager.DeviceManager).toBeDefined();
+  expect(typeof devicemanager.DeviceManager).toEqual('function');
+});
+
+tap.test('should export UniversalDevice', async () => {
+  expect(devicemanager.UniversalDevice).toBeDefined();
+  expect(typeof devicemanager.UniversalDevice).toEqual('function');
+});
+
+tap.test('should export Features', async () => {
+  expect(devicemanager.ScanFeature).toBeDefined();
+  expect(devicemanager.PrintFeature).toBeDefined();
+  expect(devicemanager.PlaybackFeature).toBeDefined();
+  expect(devicemanager.VolumeFeature).toBeDefined();
+  expect(devicemanager.PowerFeature).toBeDefined();
+  expect(devicemanager.SnmpFeature).toBeDefined();
+});
+
+tap.test('should export device factories', async () => {
+  expect(devicemanager.createScanner).toBeDefined();
+  expect(devicemanager.createPrinter).toBeDefined();
+  expect(devicemanager.createSpeaker).toBeDefined();
+  expect(devicemanager.createUpsDevice).toBeDefined();
+  expect(typeof devicemanager.createScanner).toEqual('function');
+  expect(typeof devicemanager.createPrinter).toEqual('function');
+});
+
+tap.test('should export protocol implementations', async () => {
+  expect(devicemanager.EsclProtocol).toBeDefined();
+  expect(devicemanager.SaneProtocol).toBeDefined();
+  expect(devicemanager.IppProtocol).toBeDefined();
+  expect(devicemanager.SnmpProtocol).toBeDefined();
+});
+
+tap.test('should export retry helpers', async () => {
+  expect(devicemanager.withRetry).toBeDefined();
+  expect(devicemanager.createRetryable).toBeDefined();
+  expect(devicemanager.defaultRetryOptions).toBeDefined();
+});
+
+// Test DeviceManager creation
+tap.test('should create DeviceManager instance', async () => {
+  const dm = new devicemanager.DeviceManager({
+    autoDiscovery: false,
+  });
+
+  expect(dm).toBeInstanceOf(devicemanager.DeviceManager);
+  expect(dm.isDiscovering).toEqual(false);
+  expect(dm.getScanners()).toEqual([]);
+  expect(dm.getPrinters()).toEqual([]);
+  expect(dm.getDevices()).toEqual([]);
+});
+
+// Test device selector
+tap.test('should support device selection with IDeviceSelector', async () => {
+  const dm = new devicemanager.DeviceManager({
+    autoDiscovery: false,
+  });
+
+  // Empty manager should return empty array
+  expect(dm.getDevices({ hasFeature: 'scan' })).toEqual([]);
+  expect(dm.getDevices({ name: 'Test' })).toEqual([]);
+
+  // selectDevice should throw when no devices match
+  let error: Error | null = null;
+  try {
+    dm.selectDevice({ address: '192.168.1.100' });
+  } catch (e) {
+    error = e as Error;
+  }
+  expect(error).not.toBeNull();
+  expect(error?.message).toContain('No device found');
+});
+
+// Test retry helper
+tap.test('withRetry should succeed on first try', async () => {
+  let callCount = 0;
+  const result = await devicemanager.withRetry(async () => {
+    callCount++;
+    return 'success';
+  });
+
+  expect(result).toEqual('success');
+  expect(callCount).toEqual(1);
+});
+
+tap.test('withRetry should retry on failure', async () => {
+  let callCount = 0;
+  const result = await devicemanager.withRetry(
+    async () => {
+      callCount++;
+      if (callCount < 3) {
+        throw new Error('Temporary failure');
+      }
+      return 'success after retries';
+    },
+    { maxRetries: 5, baseDelay: 10, maxDelay: 100 }
+  );
+
+  expect(result).toEqual('success after retries');
+  expect(callCount).toEqual(3);
+});
+
+tap.test('withRetry should throw after max retries', async () => {
+  let callCount = 0;
+  let error: Error | null = null;
+
+  try {
+    await devicemanager.withRetry(
+      async () => {
+        callCount++;
+        throw new Error('Persistent failure');
+      },
+      { maxRetries: 2, baseDelay: 10, maxDelay: 100 }
+    );
+  } catch (e) {
+    error = e as Error;
+  }
+
+  expect(error).not.toBeNull();
+  expect(error?.message).toEqual('Persistent failure');
+  expect(callCount).toEqual(3); // Initial + 2 retries
+});
+
+// Test discovery (non-blocking)
+tap.test('should start and stop discovery', async () => {
+  const dm = new devicemanager.DeviceManager();
+
+  // Track events
+  let discoveryStarted = false;
+  let discoveryStopped = false;
+
+  dm.on('discovery:started', () => {
+    discoveryStarted = true;
+  });
+
+  dm.on('discovery:stopped', () => {
+    discoveryStopped = true;
+  });
+
+  await dm.startDiscovery();
+  expect(dm.isDiscovering).toEqual(true);
+  expect(discoveryStarted).toEqual(true);
+
+  // Wait a bit for potential device discovery
+  await new Promise((resolve) => setTimeout(resolve, 2000));
+
+  // Log discovered devices using new API
+  const scanners = dm.getDevices({ hasFeature: 'scan' });
+  const printers = dm.getDevices({ hasFeature: 'print' });
+  console.log(`Discovered ${scanners.length} scanner(s) and ${printers.length} printer(s)`);
+
+  for (const scanner of scanners) {
+    const scanFeature = scanner.getFeature<devicemanager.ScanFeature>('scan');
+    console.log(`  Scanner: ${scanner.name} (${scanner.address}) - ${scanFeature?.protocol || 'unknown'}`);
+  }
+
+  for (const printer of printers) {
+    console.log(`  Printer: ${printer.name} (${printer.address})`);
+  }
+
+  await dm.stopDiscovery();
+  expect(dm.isDiscovering).toEqual(false);
+  expect(discoveryStopped).toEqual(true);
+
+  await dm.shutdown();
+});
+
+// Test Scanner creation using factory
+tap.test('should create Scanner device using factory', async () => {
+  const scanner = devicemanager.createScanner({
+    id: 'test:scanner:1',
+    name: 'Test Scanner',
+    address: '192.168.1.100',
+    port: 443,
+    protocol: 'escl',
+    txtRecords: {
+      'ty': 'HP LaserJet MFP',
+      'pdl': 'image/jpeg,application/pdf',
+      'cs': 'color,grayscale',
+      'is': 'platen,adf',
+    },
+  });
+
+  expect(scanner).toBeInstanceOf(devicemanager.UniversalDevice);
+  expect(scanner.name).toEqual('Test Scanner');
+  expect(scanner.address).toEqual('192.168.1.100');
+  expect(scanner.hasFeature('scan')).toEqual(true);
+
+  const scanFeature = scanner.selectFeature<devicemanager.ScanFeature>('scan');
+  expect(scanFeature).toBeInstanceOf(devicemanager.ScanFeature);
+  expect(scanFeature.protocol).toEqual('escl');
+});
+
+// Test Printer creation using factory
+tap.test('should create Printer device using factory', async () => {
+  const printer = devicemanager.createPrinter({
+    id: 'test:printer:1',
+    name: 'Test Printer',
+    address: '192.168.1.101',
+    port: 631,
+    ippPath: '/ipp/print',
+    txtRecords: {
+      'ty': 'Brother HL-L2350DW',
+      'Color': 'T',
+      'Duplex': 'T',
+    },
+  });
+
+  expect(printer).toBeInstanceOf(devicemanager.UniversalDevice);
+  expect(printer.name).toEqual('Test Printer');
+  expect(printer.address).toEqual('192.168.1.101');
+  expect(printer.hasFeature('print')).toEqual(true);
+
+  const printFeature = printer.selectFeature<devicemanager.PrintFeature>('print');
+  expect(printFeature).toBeInstanceOf(devicemanager.PrintFeature);
+});
+
+// Test UniversalDevice feature management
+tap.test('should manage features on UniversalDevice', async () => {
+  const device = new devicemanager.UniversalDevice('192.168.1.50', 80, {
+    name: 'Test Device',
+  });
+
+  expect(device.name).toEqual('Test Device');
+  expect(device.address).toEqual('192.168.1.50');
+  expect(device.featureCount).toEqual(0);
+  expect(device.hasFeature('scan')).toEqual(false);
+
+  // selectFeature should throw when feature doesn't exist
+  let error: Error | null = null;
+  try {
+    device.selectFeature('scan');
+  } catch (e) {
+    error = e as Error;
+  }
+  expect(error).not.toBeNull();
+  expect(error?.message).toContain("does not have feature 'scan'");
+
+  // getFeature should return undefined
+  expect(device.getFeature('scan')).toBeUndefined();
+});
+
+// Test IP helpers
+tap.test('should export IP helper utilities', async () => {
+  expect(devicemanager.isValidIp).toBeDefined();
+  expect(devicemanager.cidrToIps).toBeDefined();
+  expect(devicemanager.getLocalSubnet).toBeDefined();
+
+  // Test isValidIp
+  expect(devicemanager.isValidIp('192.168.1.1')).toEqual(true);
+  expect(devicemanager.isValidIp('invalid')).toEqual(false);
+  expect(devicemanager.isValidIp('256.1.1.1')).toEqual(false);
+});
+
+export default tap.start();

package/ts/00_commitinfo_data.ts

@@ -0,0 +1,8 @@
+/**
+ * autocreated commitinfo by @push.rocks/commitinfo
+ */
+export const commitinfo = {
+  name: '@ecobridge.xyz/devicemanager',
+  version: '3.0.2',
+  description: 'a device manager for talking to devices on network and over usb'
+}