@ecobridge.xyz/devicemanager 3.1.0 → 3.2.0

package/test/{test.ts → test.node.ts}

@@ -32,6 +32,7 @@ tap.test('should export device factories', async () => {
 
 tap.test('should export protocol implementations', async () => {
   expect(devicemanager.EsclProtocol).toBeDefined();
+  expect(devicemanager.BrotherScanProtocol).toBeDefined();
   expect(devicemanager.SaneProtocol).toBeDefined();
   expect(devicemanager.IppProtocol).toBeDefined();
   expect(devicemanager.SnmpProtocol).toBeDefined();
@@ -127,50 +128,6 @@ tap.test('withRetry should throw after max retries', async () => {
   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({
@@ -197,6 +154,22 @@ tap.test('should create Scanner device using factory', async () => {
   expect(scanFeature.protocol).toEqual('escl');
 });
 
+tap.test('duplex-capable scanners default to duplex ADF', async () => {
+  const scanner = devicemanager.createScanner({
+    id: 'test:brother-scanner:1',
+    name: 'Brother Scanner',
+    address: '192.168.1.101',
+    port: 54921,
+    protocol: 'brother',
+    txtRecords: {},
+  });
+  const scanFeature = scanner.selectFeature<devicemanager.ScanFeature>('scan');
+  const defaults = (scanFeature as unknown as {
+    resolveOptions(options?: devicemanager.IScanOptions): Required<devicemanager.IScanOptions>;
+  }).resolveOptions();
+  expect(defaults.source).toEqual('adf-duplex');
+});
+
 // Test Printer creation using factory
 tap.test('should create Printer device using factory', async () => {
   const printer = devicemanager.createPrinter({
@@ -204,8 +177,8 @@ tap.test('should create Printer device using factory', async () => {
     name: 'Test Printer',
     address: '192.168.1.101',
     port: 631,
-    ippPath: '/ipp/print',
     txtRecords: {
+      'rp': '/ipp/print',
       'ty': 'Brother HL-L2350DW',
       'Color': 'T',
       'Duplex': 'T',
@@ -221,6 +194,25 @@ tap.test('should create Printer device using factory', async () => {
   expect(printFeature).toBeInstanceOf(devicemanager.PrintFeature);
 });
 
+tap.test('should create a Sonos speaker without an external Sonos client', async () => {
+  const speaker = devicemanager.createSpeaker({
+    id: 'test:speaker:sonos',
+    name: 'Living Room',
+    address: '192.168.1.102',
+    port: 1400,
+    protocol: 'sonos',
+  });
+
+  const playback = speaker.selectFeature<devicemanager.PlaybackFeature>('playback');
+  const volume = speaker.selectFeature<devicemanager.VolumeFeature>('volume');
+
+  expect(speaker.id).toEqual('test:speaker:sonos');
+  expect(playback.protocol).toEqual('sonos');
+  expect(playback.supportsQueue).toEqual(true);
+  expect(playback.supportsSeek).toEqual(true);
+  expect(volume.protocol).toEqual('sonos');
+});
+
 // Test UniversalDevice feature management
 tap.test('should manage features on UniversalDevice', async () => {
   const device = new devicemanager.UniversalDevice('192.168.1.50', 80, {

package/test/test.smb.node.ts

@@ -0,0 +1,123 @@
+import { tap, expect } from '@git.zone/tstest/tapbundle';
+import * as fs from 'node:fs/promises';
+import * as os from 'node:os';
+import * as path from 'node:path';
+import { filter, firstValueFrom, take, timeout, toArray } from 'rxjs';
+import {
+  DeviceManager,
+  type ISmbServerAdapter,
+  type ISmbShareProviderOptions,
+} from '../ts/index.js';
+
+class FakeSmbServer implements ISmbServerAdapter {
+  public running = false;
+
+  constructor(private readonly options: ISmbShareProviderOptions) {}
+
+  public async start() {
+    this.running = true;
+    return {
+      host: this.options.host ?? '127.0.0.1',
+      port: this.options.port ?? 445,
+      address: `smb://${this.options.host ?? '127.0.0.1'}:${this.options.port ?? 445}`,
+      shares: this.options.shares.map((share) => share.name),
+    };
+  }
+
+  public async stop(): Promise<void> {
+    this.running = false;
+  }
+
+  public async status() {
+    return {
+      running: this.running,
+      host: this.options.host,
+      port: this.options.port,
+      shares: this.options.shares.map((share) => share.name),
+    };
+  }
+
+  public getConnectionOptions() {
+    return {
+      host: this.options.host ?? '127.0.0.1',
+      port: this.options.port ?? 445,
+    };
+  }
+}
+
+tap.test('SMB provider emits settled documents through provider and manager RxJS streams', async () => {
+  const tempRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'devicemanager-smb-'));
+  const sharePath = path.join(tempRoot, 'scans');
+  const manager = new DeviceManager({ autoDiscovery: false });
+  const options: ISmbShareProviderOptions = {
+    host: '127.0.0.1',
+    port: 1445,
+    shares: [{ name: 'brother-scans', path: sharePath }],
+    pollIntervalMs: 20,
+    settleTimeMs: 60,
+  };
+
+  const provider = await manager.provideSmbShares(options, {
+    serverFactory: (serverOptions) => new FakeSmbServer({ ...options, ...serverOptions }),
+  });
+
+  try {
+    const providerEventPromise = firstValueFrom(provider.documents$.pipe(timeout({ first: 3000 })));
+    const managerEventPromise = firstValueFrom(manager.events$.pipe(
+      filter((event) => event.name === 'smb:document:arrived'),
+      timeout({ first: 3000 })
+    ));
+
+    const documentPath = path.join(sharePath, 'nested', 'scan.pdf');
+    await fs.mkdir(path.dirname(documentPath), { recursive: true });
+    await fs.writeFile(documentPath, 'first');
+    await new Promise((resolve) => setTimeout(resolve, 35));
+    await fs.appendFile(documentPath, '-complete');
+
+    const providerEvent = await providerEventPromise;
+    const managerEvent = await managerEventPromise;
+    expect(providerEvent.shareName).toEqual('brother-scans');
+    expect(providerEvent.relativePath).toEqual('nested/scan.pdf');
+    expect(providerEvent.size).toEqual('first-complete'.length);
+    expect((managerEvent.args[0] as { absolutePath: string }).absolutePath).toEqual(documentPath);
+  } finally {
+    await manager.stopSmbShareProvider(provider);
+    await fs.rm(tempRoot, { recursive: true, force: true });
+  }
+});
+
+tap.test('SMB provider keeps document events distinct for shares with the same path', async () => {
+  const tempRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'devicemanager-smb-shares-'));
+  const manager = new DeviceManager({ autoDiscovery: false });
+  const options: ISmbShareProviderOptions = {
+    host: '127.0.0.1',
+    port: 1445,
+    shares: [
+      { name: 'scanner-a', path: tempRoot },
+      { name: 'scanner-b', path: tempRoot },
+    ],
+    pollIntervalMs: 20,
+    settleTimeMs: 40,
+  };
+
+  const provider = await manager.provideSmbShares(options, {
+    serverFactory: (serverOptions) => new FakeSmbServer({ ...options, ...serverOptions }),
+  });
+
+  try {
+    const eventsPromise = firstValueFrom(provider.documents$.pipe(
+      take(2),
+      toArray(),
+      timeout({ first: 3000 })
+    ));
+
+    await fs.writeFile(path.join(tempRoot, 'scan.pdf'), 'complete');
+    const events = await eventsPromise;
+    expect(events.map((event) => event.shareName).sort()).toEqual(['scanner-a', 'scanner-b']);
+  } finally {
+    await manager.stopSmbShareProvider(provider);
+    await fs.rm(tempRoot, { recursive: true, force: true });
+  }
+});
+
+export default tap.start();