homebridge-tuya-plus 3.14.0-dev.5 → 3.14.0-dev.51

package/scripts/cleanup-pr-tags.js

@@ -0,0 +1,122 @@
+#!/usr/bin/env node
+'use strict';
+
+/**
+ * Prune stale `pr-<N>` npm dist-tags created by the `/publish` PR-test-build
+ * workflow (.github/workflows/publish-dev.yml).
+ *
+ * Token-free by design: it shells out to `npm dist-tag`, which uses your
+ * existing local npm login — the same one you use to publish releases. No CI
+ * secret is involved. (npm's OIDC trusted publishing only covers `npm publish`,
+ * not dist-tag management, which is why this is a local maintainer script
+ * rather than a CI job.)
+ *
+ * Default: removes the `pr-<N>` tag for every PR that is MERGED or CLOSED, and
+ * keeps tags for PRs that are still open. PR state is read from the public
+ * GitHub API (unauthenticated).
+ *
+ * Usage:
+ *   npm run cleanup:pr-tags                # remove tags for merged/closed PRs
+ *   npm run cleanup:pr-tags -- --dry-run   # preview only, change nothing
+ *   npm run cleanup:pr-tags -- --all       # remove ALL pr-* tags (incl. open)
+ *
+ * Note: this removes the dist-tag pointer only. The underlying prerelease
+ * versions stay published (npm disallows unpublishing after 72h), but they sort
+ * below `latest`/`dev` and are never installed by default.
+ */
+
+const { execFileSync } = require('child_process');
+const path = require('path');
+
+const pkgJson = require(path.join(__dirname, '..', 'package.json'));
+const PKG = pkgJson.name;
+const NPM = process.platform === 'win32' ? 'npm.cmd' : 'npm';
+
+const args = process.argv.slice(2);
+const DRY_RUN = args.includes('--dry-run') || args.includes('-n');
+const ALL = args.includes('--all');
+
+// Derive "owner/repo" from package.json's repository URL.
+function repoSlug() {
+  const url = (pkgJson.repository && pkgJson.repository.url) || '';
+  const m = url.match(/github\.com[/:]([^/]+)\/(.+?)(?:\.git)?$/i);
+  if (!m) throw new Error(`Cannot parse a GitHub repo from repository.url: "${url}"`);
+  return `${m[1]}/${m[2]}`;
+}
+
+// Parse `npm dist-tag ls <pkg>` output ("pr-57: 3.14.0-pr.57.3") into pr-* tags.
+function listPrTags() {
+  let out;
+  try {
+    out = execFileSync(NPM, ['dist-tag', 'ls', PKG], { encoding: 'utf8' });
+  } catch (err) {
+    throw new Error(`Failed to list dist-tags for ${PKG}: ${err.message}`);
+  }
+  const tags = [];
+  for (const line of out.split('\n')) {
+    const m = line.match(/^(pr-(\d+)):\s*(.+)$/);
+    if (m) tags.push({ tag: m[1], pr: Number(m[2]), version: m[3].trim() });
+  }
+  return tags;
+}
+
+async function prState(slug, num) {
+  const res = await fetch(`https://api.github.com/repos/${slug}/pulls/${num}`, {
+    headers: { Accept: 'application/vnd.github+json', 'User-Agent': `${PKG}-cleanup` },
+  });
+  if (res.status === 404) return 'unknown';
+  if (!res.ok) throw new Error(`GitHub API responded ${res.status}`);
+  const data = await res.json();
+  return data.merged ? 'merged' : data.state; // 'merged' | 'open' | 'closed'
+}
+
+async function main() {
+  const slug = repoSlug();
+  const tags = listPrTags();
+  if (tags.length === 0) {
+    console.log(`No pr-* dist-tags on ${PKG}. Nothing to do.`);
+    return;
+  }
+  console.log(`Found ${tags.length} pr-* tag(s) on ${PKG}${DRY_RUN ? ' (dry run)' : ''}:`);
+
+  let removed = 0;
+  for (const { tag, pr, version } of tags) {
+    let remove = ALL;
+    let reason = 'forced by --all';
+    if (!ALL) {
+      let state;
+      try {
+        state = await prState(slug, pr);
+      } catch (err) {
+        console.log(`  • ${tag} -> ${version}: skip (could not check PR #${pr}: ${err.message})`);
+        continue;
+      }
+      remove = state === 'merged' || state === 'closed';
+      reason = `PR #${pr} is ${state}`;
+    }
+
+    if (!remove) {
+      console.log(`  • ${tag} -> ${version}: keep (${reason})`);
+      continue;
+    }
+    if (DRY_RUN) {
+      console.log(`  • ${tag} -> ${version}: would remove (${reason})`);
+      removed++;
+      continue;
+    }
+    try {
+      execFileSync(NPM, ['dist-tag', 'rm', PKG, tag], { encoding: 'utf8' });
+      console.log(`  • ${tag} -> ${version}: removed (${reason})`);
+      removed++;
+    } catch (err) {
+      console.log(`  • ${tag}: FAILED to remove (${err.message}). Are you \`npm login\`'d?`);
+    }
+  }
+
+  console.log(DRY_RUN ? `Would remove ${removed} tag(s).` : `Removed ${removed} tag(s).`);
+}
+
+main().catch((err) => {
+  console.error(err.message);
+  process.exit(1);
+});

package/test/BaseAccessory.test.js

@@ -1,7 +1,7 @@
 'use strict';
 
 const BaseAccessory = require('../lib/BaseAccessory');
-const { makeInstance } = require('./support/mocks');
+const { makeInstance, HAP } = require('./support/mocks');
 
 // Minimal concrete subclass — BaseAccessory itself doesn't define _registerCharacteristics
 class TestAccessory extends BaseAccessory {
@@ -158,10 +158,13 @@ describe('getStateAsync', () => {
         expect(instance.getStateAsync(['1', '2'])).toEqual({ '1': true, '2': 50 });
     });
 
-    test('throws when device is not connected', () => {
+    test('throws a comm-failure HapStatusError when device is not connected', () => {
         const { instance, device } = make();
         device.connected = false;
-        expect(() => instance.getStateAsync('1')).toThrow('Not connected');
+        let err;
+        try { instance.getStateAsync('1'); } catch (e) { err = e; }
+        expect(err).toBeInstanceOf(HAP.HapStatusError);
+        expect(err.hapStatus).toBe(HAP.HAPStatus.SERVICE_COMMUNICATION_FAILURE);
     });
 });
 
@@ -178,10 +181,10 @@ describe('setStateAsync', () => {
         expect(device.update).not.toHaveBeenCalled();
     });
 
-    test('skips silently when device is not connected (issue #34)', () => {
+    test('rejects with a comm-failure HapStatusError when device is not connected', async () => {
         const { instance, device } = make({ '1': false });
         device.connected = false;
-        expect(() => instance.setStateAsync('1', true)).not.toThrow();
+        await expect(instance.setStateAsync('1', true)).rejects.toBeInstanceOf(HAP.HapStatusError);
         expect(device.update).not.toHaveBeenCalled();
     });
 });
@@ -201,12 +204,29 @@ describe('setMultiStateAsync', () => {
         expect(device.update).not.toHaveBeenCalled();
     });
 
-    test('skips silently when device is not connected (issue #34)', () => {
+    test('resolves when the device accepts the writes', async () => {
+        const { instance } = make({ '1': false });
+        await expect(instance.setMultiStateAsync({ '1': true })).resolves.toBeUndefined();
+    });
+
+    test('rejects with a comm-failure HapStatusError when device is not connected', async () => {
         const { instance, device } = make({ '1': false });
         device.connected = false;
-        expect(() => instance.setMultiStateAsync({ '1': true, '2': 50 })).not.toThrow();
+        await expect(instance.setMultiStateAsync({ '1': true, '2': 50 })).rejects.toBeInstanceOf(HAP.HapStatusError);
         expect(device.update).not.toHaveBeenCalled();
     });
+
+    test('rejects when the device write is not accepted (returns false)', async () => {
+        const { instance, device } = make({ '1': false });
+        device.update.mockReturnValue(false);
+        await expect(instance.setMultiStateAsync({ '1': true })).rejects.toBeInstanceOf(HAP.HapStatusError);
+    });
+
+    test('awaits an async device write result (cloud) and rejects on failure', async () => {
+        const { instance, device } = make({ '1': false });
+        device.update.mockResolvedValue(false);
+        await expect(instance.setMultiStateAsync({ '1': true })).rejects.toBeInstanceOf(HAP.HapStatusError);
+    });
 });
 
 describe('setMultiStateLegacyAsync', () => {
@@ -217,12 +237,34 @@ describe('setMultiStateLegacyAsync', () => {
         expect(device.update).toHaveBeenCalledWith({ '1': true, '3': '2' });
     });
 
-    test('skips silently when device is not connected (issue #34)', () => {
+    test('rejects with a comm-failure HapStatusError when device is not connected', async () => {
         const { instance, device } = make();
         device.connected = false;
-        expect(() => instance.setMultiStateLegacyAsync({ '1': true })).not.toThrow();
+        await expect(instance.setMultiStateLegacyAsync({ '1': true })).rejects.toBeInstanceOf(HAP.HapStatusError);
         expect(device.update).not.toHaveBeenCalled();
     });
+
+    test('rejects when the device write is not accepted (returns false)', async () => {
+        const { instance, device } = make();
+        device.update.mockReturnValue(false);
+        await expect(instance.setMultiStateLegacyAsync({ '1': true })).rejects.toBeInstanceOf(HAP.HapStatusError);
+    });
+});
+
+describe('background write helpers (never throw/reject)', () => {
+    test('setStateInBackground swallows a disconnected-device failure', async () => {
+        const { instance, device } = make({ '1': false });
+        device.connected = false;
+        expect(() => instance.setStateInBackground('1', true)).not.toThrow();
+        // Give the rejected inner promise a tick to settle; it must be caught.
+        await Promise.resolve();
+    });
+
+    test('setMultiStateLegacyInBackground still dispatches the write when connected', () => {
+        const { instance, device } = make();
+        instance.setMultiStateLegacyInBackground({ '1': true });
+        expect(device.update).toHaveBeenCalledWith({ '1': true });
+    });
 });
 
 describe('getDividedStateAsync', () => {
@@ -231,20 +273,57 @@ describe('getDividedStateAsync', () => {
         expect(instance.getDividedStateAsync('5', 10)).toBeCloseTo(220);
     });
 
-    test('throws when state value is not finite', () => {
+    test('throws a comm-failure HapStatusError when state value is not finite', () => {
         const { instance } = make({ '5': 'bad' });
-        expect(() => instance.getDividedStateAsync('5', 10)).toThrow();
+        let err;
+        try { instance.getDividedStateAsync('5', 10); } catch (e) { err = e; }
+        expect(err).toBeInstanceOf(HAP.HapStatusError);
+        expect(err.hapStatus).toBe(HAP.HAPStatus.SERVICE_COMMUNICATION_FAILURE);
+    });
+});
+
+describe('getState (callback)', () => {
+    test('returns the DP value via the callback when connected', done => {
+        const { instance } = make({ '1': true });
+        instance.getState('1', (err, value) => {
+            expect(err).toBeNull();
+            expect(value).toBe(true);
+            done();
+        });
+    });
+
+    test('invokes the callback with a comm-failure error when not connected', () => {
+        const { instance, device } = make({ '1': true });
+        device.connected = false;
+        const cb = jest.fn();
+        instance.getState('1', cb);
+        expect(cb).toHaveBeenCalledWith(expect.any(HAP.HapStatusError));
     });
 });
 
 describe('setMultiState (legacy callback)', () => {
-    test('skips silently and invokes callback without error when not connected (issue #34)', () => {
+    test('invokes the callback without error on a successful write', () => {
+        const { instance } = make({ '1': false });
+        const cb = jest.fn();
+        instance.setMultiState({ '1': true }, cb);
+        expect(cb).toHaveBeenCalledWith(null);
+    });
+
+    test('invokes the callback with a comm-failure error when not connected', () => {
         const { instance, device } = make({ '1': false });
         device.connected = false;
         const cb = jest.fn();
         instance.setMultiState({ '1': true }, cb);
         expect(device.update).not.toHaveBeenCalled();
-        expect(cb).toHaveBeenCalledWith();
+        expect(cb).toHaveBeenCalledWith(expect.any(HAP.HapStatusError));
+    });
+
+    test('invokes the callback with a comm-failure error when the write is not accepted', () => {
+        const { instance, device } = make({ '1': false });
+        device.update.mockReturnValue(false);
+        const cb = jest.fn();
+        instance.setMultiState({ '1': true }, cb);
+        expect(cb).toHaveBeenCalledWith(expect.any(HAP.HapStatusError));
     });
 
     test('tolerates a missing callback when not connected', () => {
@@ -255,13 +334,13 @@ describe('setMultiState (legacy callback)', () => {
 });
 
 describe('setMultiStateLegacy (legacy callback)', () => {
-    test('skips silently and invokes callback without error when not connected (issue #34)', () => {
+    test('invokes the callback with a comm-failure error when not connected', () => {
         const { instance, device } = make();
         device.connected = false;
         const cb = jest.fn();
         instance.setMultiStateLegacy({ '1': true }, cb);
         expect(device.update).not.toHaveBeenCalled();
-        expect(cb).toHaveBeenCalledWith();
+        expect(cb).toHaveBeenCalledWith(expect.any(HAP.HapStatusError));
     });
 });