@sebbo2002/node-pyatv 4.3.4-develop.4 → 5.1.0-develop.1

package/test/device.ts

@@ -1,7 +1,7 @@
 'use strict';
 
 import assert from 'assert';
-import NodePyATVDevice from '../src/lib/device';
+import NodePyATVDevice from '../src/lib/device.js';
 import {
     NodePyATVDeviceState,
     NodePyATVKeys,
@@ -9,9 +9,9 @@ import {
     NodePyATVProtocol,
     NodePyATVRepeatState,
     NodePyATVShuffleState
-} from '../src/lib/types';
-import NodePyATVInstance from '../src/lib/instance';
-import {createFakeSpawn} from '../src/lib/fake-spawn';
+} from '../src/lib/types.js';
+import NodePyATVInstance from '../src/lib/instance.js';
+import { createFakeSpawn } from '../src/lib/fake-spawn.js';
 
 describe('NodePyATVDevice', function () {
     describe('get name()', function () {
@@ -60,6 +60,129 @@ describe('NodePyATVDevice', function () {
         });
     });
 
+    describe('get model()', function () {
+        it('should return the model if set by scan', function () {
+            const device = new NodePyATVDevice({
+                name: 'Vardagsrum',
+                host: '10.0.10.81',
+                id: 'xxx',
+                model: 'Gen4K'
+            });
+
+            assert.strictEqual(device.model, 'Gen4K');
+        });
+        it('should return undefined otherwise', function () {
+            const device = new NodePyATVDevice({
+                name: 'Vardagsrum',
+                host: '10.0.10.81'
+            });
+
+            assert.strictEqual(device.model, undefined);
+        });
+    });
+
+    describe('get modelName()', function () {
+        it('should return the model name if set by scan', function () {
+            const device = new NodePyATVDevice({
+                name: 'Vardagsrum',
+                host: '10.0.10.81',
+                id: 'xxx',
+                modelName: 'Apple TV 4K'
+            });
+
+            assert.strictEqual(device.modelName, 'Apple TV 4K');
+        });
+        it('should return undefined otherwise', function () {
+            const device = new NodePyATVDevice({
+                name: 'Vardagsrum',
+                host: '10.0.10.81'
+            });
+
+            assert.strictEqual(device.modelName, undefined);
+        });
+    });
+
+    describe('get os()', function () {
+        it('should return the operating system if set by scan', function () {
+            const device = new NodePyATVDevice({
+                name: 'Vardagsrum',
+                host: '10.0.10.81',
+                id: 'xxx',
+                os: 'TvOS'
+            });
+
+            assert.strictEqual(device.os, 'TvOS');
+        });
+        it('should return undefined otherwise', function () {
+            const device = new NodePyATVDevice({
+                name: 'Vardagsrum',
+                host: '10.0.10.81'
+            });
+
+            assert.strictEqual(device.os, undefined);
+        });
+    });
+
+    describe('get version()', function () {
+        it('should return the version if set by scan', function () {
+            const device = new NodePyATVDevice({
+                name: 'Vardagsrum',
+                host: '10.0.10.81',
+                id: 'xxx',
+                version: '15.5.1'
+            });
+
+            assert.strictEqual(device.version, '15.5.1');
+        });
+        it('should return undefined otherwise', function () {
+            const device = new NodePyATVDevice({
+                name: 'Vardagsrum',
+                host: '10.0.10.81'
+            });
+
+            assert.strictEqual(device.version, undefined);
+        });
+    });
+
+    describe('get services()', function () {
+        it('should return the services if set by scan', function () {
+            const device = new NodePyATVDevice({
+                name: 'Vardagsrum',
+                host: '10.0.10.81',
+                id: 'xxx',
+                services: [
+                    {
+                        protocol: NodePyATVProtocol.mrp,
+                        port: 49152
+                    },
+                    {
+                        protocol: NodePyATVProtocol.airplay,
+                        port: 7000
+                    }
+                ]
+            });
+
+            assert.deepStrictEqual(device.services, [
+                {
+                    protocol: 'mrp',
+                    port: 49152
+                },
+                {
+                    protocol: 'airplay',
+                    port: 7000
+                }
+            ]);
+        });
+        it('should return undefined otherwise', function () {
+            const device = new NodePyATVDevice({
+                name: 'Vardagsrum',
+                host: '10.0.10.81'
+            });
+
+            assert.strictEqual(device.services, undefined);
+        });
+    });
+
     describe('get debug()', function () {
         it('should return true if set to true', function () {
             const device = new NodePyATVDevice({

package/test/instance.ts

@@ -1,18 +1,26 @@
 'use strict';
 
 import assert from 'assert';
-import {createFakeSpawn} from '../src/lib/fake-spawn';
+import { readFileSync } from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+import { createFakeSpawn } from '../src/lib/fake-spawn.js';
 import NodePyATVInstance, {
-    NodePyATVProtocol,
-    NodePyATVMediaType,
     NodePyATVDeviceEvent,
     NodePyATVDeviceState,
-    NodePyATVRepeatState,
-    NodePyATVShuffleState,
     NodePyATVKeys,
     NodePyATVListenerState,
-    NodePyATVPowerState
-} from '../src/lib/index';
+    NodePyATVMediaType,
+    NodePyATVPowerState,
+    NodePyATVProtocol,
+    NodePyATVRepeatState,
+    NodePyATVShuffleState
+} from '../src/lib/index.js';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const version = JSON.parse(readFileSync(__dirname + '/../package.json', 'utf8'))?.version || null;
 
 describe('NodePyATVInstance', function () {
     describe('static version()', function () {
@@ -25,9 +33,7 @@ describe('NodePyATVInstance', function () {
 
             assert.equal(typeof result.pyatv, 'string', 'result.pyatv is a string');
             assert.ok(result.pyatv.length >= 5, 'result.pyatv has content');
-
-            // eslint-disable-next-line @typescript-eslint/no-var-requires
-            assert.strictEqual(result.module, require(__dirname + '/../package.json').version || null);
+            assert.strictEqual(result.module, version);
         });
         it('should return the pyatv version', async function () {
             const result = await NodePyATVInstance.version({
@@ -48,8 +54,7 @@ describe('NodePyATVInstance', function () {
                 )
             });
 
-            // eslint-disable-next-line @typescript-eslint/no-var-requires
-            assert.strictEqual(result.module, require(__dirname + '/../package.json').version || null);
+            assert.strictEqual(result.module, version);
         });
         it('should handle option.atvremotePath', async function () {
             await NodePyATVInstance.version({
@@ -70,7 +75,9 @@ describe('NodePyATVInstance', function () {
         });
         it('should work with option.noColors', async function () {
             await NodePyATVInstance.version({
-                debug: () => {}, // eslint-disable-line @typescript-eslint/no-empty-function
+                debug: () => {
+                    // no debug log
+                },
                 noColors: true,
                 spawn: createFakeSpawn(cp =>
                     cp.code(1).end()
@@ -104,7 +111,7 @@ describe('NodePyATVInstance', function () {
 
             assert.strictEqual(result.pyatv, null);
         });
-        it('should return null on empty module version', async function () {
+        /* it('should return null on empty module version', async function () {
             const path = require.resolve(__dirname + '/../package.json');
             require(path);
 
@@ -119,8 +126,8 @@ describe('NodePyATVInstance', function () {
             });
 
             assert.strictEqual(result.module, null);
-        });
-        it('should return null on invalid module version', async function () {
+        }); */
+        /* it('should return null on invalid module version', async function () {
             const path = require.resolve(__dirname + '/../package.json');
             require(path);
 
@@ -135,7 +142,7 @@ describe('NodePyATVInstance', function () {
             });
 
             assert.strictEqual(result.module, null);
-        });
+        }); */
     });
 
     describe('static check()', function () {
@@ -143,7 +150,7 @@ describe('NodePyATVInstance', function () {
             this.timeout(12000);
             await NodePyATVInstance.check();
         });
-        it('should return nice error message if pyatv was not found', async function() {
+        it('should return nice error message if pyatv was not found', async function () {
             await assert.rejects(async () => {
                 await NodePyATVInstance.check({
                     spawn: createFakeSpawn(cp => {
@@ -161,12 +168,12 @@ describe('NodePyATVInstance', function () {
                 });
             }, /Found pyatv, but unforunately it's too old. Please update pyatv./);
         });
-        it('should return nice error message if scan failed', async function() {
+        it('should return nice error message if scan failed', async function () {
             let i = 0;
             await assert.rejects(async () => {
                 await NodePyATVInstance.check({
                     spawn: createFakeSpawn(cp => {
-                        if(i === 0) {
+                        if (i === 0) {
                             cp.stdout('atvremote 0.7.0').code(1).end();
                             i++;
                         } else {
@@ -250,19 +257,98 @@ describe('NodePyATVInstance', function () {
                 });
             }, /Unable to parse pyatv response: /);
         });
+        it('should work if devices are without device_info / services', async function () {
+            const devices = await NodePyATVInstance.find({
+                spawn: createFakeSpawn(cp => {
+                    cp.stdout({
+                        result: 'success',
+                        datetime: '2020-11-06T20:47:30.840022+01:00',
+                        devices: [
+                            {
+                                name: 'Vardagsrum',
+                                address: '10.0.10.81',
+                                identifier: 'xxx'
+                            }
+                        ]
+                    }).code(1).end();
+                })
+            });
+
+            assert.strictEqual(devices.length, 1);
+            assert.strictEqual(devices[0].name, 'Vardagsrum');
+            assert.strictEqual(devices[0].host, '10.0.10.81');
+            assert.strictEqual(devices[0].id, 'xxx');
+            assert.strictEqual(devices[0].model, undefined);
+            assert.strictEqual(devices[0].modelName, undefined);
+            assert.strictEqual(devices[0].os, undefined);
+            assert.strictEqual(devices[0].version, undefined);
+            assert.deepStrictEqual(devices[0].services, undefined);
+        });
+        it('should work if devices are with device_info / services', async function () {
+            const devices = await NodePyATVInstance.find({
+                spawn: createFakeSpawn(cp => {
+                    cp.stdout({
+                        result: 'success',
+                        datetime: '2020-11-06T20:47:30.840022+01:00',
+                        devices: [
+                            {
+                                name: 'Vardagsrum',
+                                address: '10.0.10.81',
+                                identifier: 'xxx',
+                                device_info: {
+                                    'model': 'Gen4K',
+                                    'model_str': 'Apple TV 4K',
+                                    'operating_system': 'TvOS',
+                                    'version': '15.5.1'
+                                },
+                                services: [
+                                    {
+                                        protocol: 'mrp',
+                                        port: 49152
+                                    },
+                                    {
+                                        protocol: 'airplay',
+                                        port: 7000
+                                    }
+                                ]
+                            }
+                        ]
+                    }).code(1).end();
+                })
+            });
+
+            assert.strictEqual(devices.length, 1);
+            assert.strictEqual(devices[0].name, 'Vardagsrum');
+            assert.strictEqual(devices[0].host, '10.0.10.81');
+            assert.strictEqual(devices[0].id, 'xxx');
+            assert.strictEqual(devices[0].model, 'Gen4K');
+            assert.strictEqual(devices[0].modelName, 'Apple TV 4K');
+            assert.strictEqual(devices[0].os, 'TvOS');
+            assert.strictEqual(devices[0].version, '15.5.1');
+            assert.deepStrictEqual(devices[0].services, [
+                {
+                    protocol: NodePyATVProtocol.mrp,
+                    port: 49152
+                },
+                {
+                    protocol: NodePyATVProtocol.airplay,
+                    port: 7000
+                }
+            ]);
+        });
     });
 
     describe('static device()', function () {
         it('should pass options to constructor', function () {
-            const device = NodePyATVInstance.device({host: '192.168.178.6', name: 'My Testdevice'});
+            const device = NodePyATVInstance.device({ host: '192.168.178.6', name: 'My Testdevice' });
             assert.strictEqual(device.host, '192.168.178.6');
             assert.strictEqual(device.name, 'My Testdevice');
         });
     });
 
-    describe('version()', function() {
-        it('should merge options from constructor', async function() {
-            const i = new NodePyATVInstance({atvremotePath: 'test'});
+    describe('version()', function () {
+        it('should merge options from constructor', async function () {
+            const i = new NodePyATVInstance({ atvremotePath: 'test' });
             await i.version({
                 spawn: createFakeSpawn(cp => {
                     assert.strictEqual(cp.cmd(), 'test');
@@ -272,9 +358,9 @@ describe('NodePyATVInstance', function () {
         });
     });
 
-    describe('check()', function() {
-        it('should merge options from constructor', async function() {
-            const i = new NodePyATVInstance({atvremotePath: 'test'});
+    describe('check()', function () {
+        it('should merge options from constructor', async function () {
+            const i = new NodePyATVInstance({ atvremotePath: 'test' });
             await assert.rejects(async () => {
                 await i.check({
                     spawn: createFakeSpawn(cp => {
@@ -286,9 +372,9 @@ describe('NodePyATVInstance', function () {
         });
     });
 
-    describe('find()', function() {
-        it('should merge options from constructor', async function() {
-            const i = new NodePyATVInstance({atvscriptPath: 'test'});
+    describe('find()', function () {
+        it('should merge options from constructor', async function () {
+            const i = new NodePyATVInstance({ atvscriptPath: 'test' });
             await i.find({
                 spawn: createFakeSpawn(cp => {
                     assert.strictEqual(cp.cmd(), 'test');
@@ -303,39 +389,39 @@ describe('NodePyATVInstance', function () {
     });
 
     describe('device()', function () {
-        it('should merge options from constructor', async function() {
-            const i = new NodePyATVInstance({debug: true});
-            const d = i.device({name: 'My Testdevice', host: '192.168.178.2'});
+        it('should merge options from constructor', async function () {
+            const i = new NodePyATVInstance({ debug: true });
+            const d = i.device({ name: 'My Testdevice', host: '192.168.178.2' });
             assert.deepStrictEqual(d.debug, true);
         });
     });
 
     describe('Type Exports', function () {
-        it('Type NodePyATVProtocol should be exported', function() {
+        it('Type NodePyATVProtocol should be exported', function () {
             assert.ok(NodePyATVProtocol);
         });
-        it('Type NodePyATVMediaType should be exported', function() {
+        it('Type NodePyATVMediaType should be exported', function () {
             assert.ok(NodePyATVMediaType);
         });
-        it('Type NodePyATVDeviceEvent should be exported', function() {
+        it('Type NodePyATVDeviceEvent should be exported', function () {
             assert.ok(NodePyATVDeviceEvent);
         });
-        it('Type NodePyATVDeviceState should be exported', function() {
+        it('Type NodePyATVDeviceState should be exported', function () {
             assert.ok(NodePyATVDeviceState);
         });
-        it('Type NodePyATVRepeatState should be exported', function() {
+        it('Type NodePyATVRepeatState should be exported', function () {
             assert.ok(NodePyATVRepeatState);
         });
-        it('Type NodePyATVShuffleState should be exported', function() {
+        it('Type NodePyATVShuffleState should be exported', function () {
             assert.ok(NodePyATVShuffleState);
         });
-        it('Type NodePyATVKeys should be exported', function() {
+        it('Type NodePyATVKeys should be exported', function () {
             assert.ok(NodePyATVKeys);
         });
-        it('Type NodePyATVInstanceOptions should be exported', function() {
+        it('Type NodePyATVInstanceOptions should be exported', function () {
             assert.ok(NodePyATVListenerState);
         });
-        it('Type NodePyATVPowerState should be exported', function() {
+        it('Type NodePyATVPowerState should be exported', function () {
             assert.ok(NodePyATVPowerState);
         });
     });

package/test/tools.ts

@@ -1,7 +1,7 @@
 'use strict';
 
 import assert from 'assert';
-import { addRequestId, debug, getExecutable, getParamters, parseState, removeRequestId } from '../src/lib/tools';
+import { addRequestId, debug, getExecutable, getParamters, parseState, removeRequestId } from '../src/lib/tools.js';
 import {
     NodePyATVDeviceState,
     NodePyATVExecutableType,
@@ -9,7 +9,7 @@ import {
     NodePyATVProtocol,
     NodePyATVRepeatState,
     NodePyATVShuffleState
-} from '../src/lib/types';
+} from '../src/lib/types.js';
 
 describe('Tools', function () {
     describe('addRequestId() / removeRequestId()', function () {

package/tsconfig.json

@@ -2,7 +2,7 @@
     "compilerOptions": {
         "declaration": true,
         "esModuleInterop": true,
-        "module": "none",
+        "module": "es2020",
         "moduleResolution": "node",
         "outDir": "./dist",
         "sourceMap": true,