node-red-contrib-samsung-smartthings 1.0.0

package/test/smartthings-client.test.js

@@ -0,0 +1,270 @@
+const { expect } = require('chai');
+const sinon = require('sinon');
+const axios = require('axios');
+const { SmartThingsClient, SmartThingsError } = require('../lib/smartthings-client');
+
+describe('SmartThingsClient', function () {
+
+    let client;
+    let axiosStub;
+
+    beforeEach(function () {
+        client = new SmartThingsClient('test-token-123', 'https://api.smartthings.com');
+    });
+
+    afterEach(function () {
+        sinon.restore();
+    });
+
+    describe('constructor', function () {
+        it('should set token and default base URL', function () {
+            const c = new SmartThingsClient('my-token');
+            expect(c.token).to.equal('my-token');
+            expect(c.baseUrl).to.equal('https://api.smartthings.com');
+        });
+
+        it('should strip trailing slashes from base URL', function () {
+            const c = new SmartThingsClient('tk', 'https://example.com/api///');
+            expect(c.baseUrl).to.equal('https://example.com/api');
+        });
+
+        it('should create axios instance with auth header', function () {
+            expect(client.http.defaults.headers['Authorization']).to.equal('Bearer test-token-123');
+        });
+    });
+
+    describe('getLocations', function () {
+        it('should return items array from API response', async function () {
+            const locations = [
+                { locationId: 'loc-1', name: 'Home' },
+                { locationId: 'loc-2', name: 'Office' }
+            ];
+            sinon.stub(client.http, 'request').resolves({ data: { items: locations } });
+
+            const result = await client.getLocations();
+            expect(result).to.deep.equal(locations);
+        });
+
+        it('should return empty array when items is missing', async function () {
+            sinon.stub(client.http, 'request').resolves({ data: {} });
+            const result = await client.getLocations();
+            expect(result).to.deep.equal([]);
+        });
+    });
+
+    describe('getLocation', function () {
+        it('should fetch a single location', async function () {
+            const location = { locationId: 'loc-1', name: 'Home' };
+            sinon.stub(client.http, 'request').resolves({ data: location });
+
+            const result = await client.getLocation('loc-1');
+            expect(result).to.deep.equal(location);
+            expect(client.http.request.calledOnce).to.be.true;
+            expect(client.http.request.firstCall.args[0].url).to.equal('/v1/locations/loc-1');
+        });
+    });
+
+    describe('getRooms', function () {
+        it('should fetch rooms for a location', async function () {
+            const rooms = [{ roomId: 'rm-1', name: 'Living Room' }];
+            sinon.stub(client.http, 'request').resolves({ data: { items: rooms } });
+
+            const result = await client.getRooms('loc-1');
+            expect(result).to.deep.equal(rooms);
+            expect(client.http.request.firstCall.args[0].url).to.equal('/v1/locations/loc-1/rooms');
+        });
+    });
+
+    describe('getDevices', function () {
+        it('should fetch all devices without filters', async function () {
+            const devices = [{ deviceId: 'dev-1', label: 'Light' }];
+            sinon.stub(client.http, 'request').resolves({ data: { items: devices } });
+
+            const result = await client.getDevices();
+            expect(result).to.deep.equal(devices);
+        });
+
+        it('should pass locationId and capability as params', async function () {
+            sinon.stub(client.http, 'request').resolves({ data: { items: [] } });
+
+            await client.getDevices({ locationId: 'loc-1', capability: 'switch' });
+            const params = client.http.request.firstCall.args[0].params;
+            expect(params.locationId).to.equal('loc-1');
+            expect(params.capability).to.equal('switch');
+        });
+
+        it('should filter by roomId client-side', async function () {
+            const devices = [
+                { deviceId: 'dev-1', roomId: 'rm-1' },
+                { deviceId: 'dev-2', roomId: 'rm-2' },
+                { deviceId: 'dev-3', roomId: 'rm-1' }
+            ];
+            sinon.stub(client.http, 'request').resolves({ data: { items: devices } });
+
+            const result = await client.getDevices({ roomId: 'rm-1' });
+            expect(result).to.have.lengthOf(2);
+            expect(result[0].deviceId).to.equal('dev-1');
+            expect(result[1].deviceId).to.equal('dev-3');
+        });
+    });
+
+    describe('getDeviceStatus', function () {
+        it('should fetch full device status', async function () {
+            const status = { components: { main: { switch: { switch: { value: 'on' } } } } };
+            sinon.stub(client.http, 'request').resolves({ data: status });
+
+            const result = await client.getDeviceStatus('dev-1');
+            expect(result).to.deep.equal(status);
+            expect(client.http.request.firstCall.args[0].url).to.equal('/v1/devices/dev-1/status');
+        });
+    });
+
+    describe('getDeviceCapabilityStatus', function () {
+        it('should fetch specific capability status', async function () {
+            const status = { energy: { value: 142.5, unit: 'kWh' } };
+            sinon.stub(client.http, 'request').resolves({ data: status });
+
+            const result = await client.getDeviceCapabilityStatus('dev-1', 'main', 'energyMeter');
+            expect(result).to.deep.equal(status);
+            expect(client.http.request.firstCall.args[0].url)
+                .to.equal('/v1/devices/dev-1/components/main/capabilities/energyMeter/status');
+        });
+    });
+
+    describe('executeCommands', function () {
+        it('should send commands to a device', async function () {
+            sinon.stub(client.http, 'request').resolves({ data: {} });
+
+            const cmd = { component: 'main', capability: 'switch', command: 'on' };
+            await client.executeCommands('dev-1', cmd);
+
+            const callArgs = client.http.request.firstCall.args[0];
+            expect(callArgs.method).to.equal('POST');
+            expect(callArgs.url).to.equal('/v1/devices/dev-1/commands');
+            expect(callArgs.data.commands).to.deep.equal([cmd]);
+        });
+
+        it('should wrap array commands correctly', async function () {
+            sinon.stub(client.http, 'request').resolves({ data: {} });
+
+            const cmds = [
+                { component: 'main', capability: 'switch', command: 'on' },
+                { component: 'main', capability: 'switchLevel', command: 'setLevel', arguments: [50] }
+            ];
+            await client.executeCommands('dev-1', cmds);
+
+            const callArgs = client.http.request.firstCall.args[0];
+            expect(callArgs.data.commands).to.deep.equal(cmds);
+        });
+    });
+
+    describe('getScenes', function () {
+        it('should fetch scenes', async function () {
+            const scenes = [{ sceneId: 'sc-1', sceneName: 'Good Night' }];
+            sinon.stub(client.http, 'request').resolves({ data: { items: scenes } });
+
+            const result = await client.getScenes();
+            expect(result).to.deep.equal(scenes);
+        });
+
+        it('should pass locationId param when provided', async function () {
+            sinon.stub(client.http, 'request').resolves({ data: { items: [] } });
+
+            await client.getScenes('loc-1');
+            expect(client.http.request.firstCall.args[0].params.locationId).to.equal('loc-1');
+        });
+    });
+
+    describe('executeScene', function () {
+        it('should POST to execute a scene', async function () {
+            sinon.stub(client.http, 'request').resolves({ data: { status: 'success' } });
+
+            const result = await client.executeScene('sc-1');
+            expect(result.status).to.equal('success');
+            expect(client.http.request.firstCall.args[0].method).to.equal('POST');
+            expect(client.http.request.firstCall.args[0].url).to.equal('/v1/scenes/sc-1/execute');
+        });
+    });
+
+    describe('testConnection', function () {
+        it('should return true on successful connection', async function () {
+            sinon.stub(client.http, 'request').resolves({ data: { items: [] } });
+            const result = await client.testConnection();
+            expect(result).to.be.true;
+        });
+    });
+
+    describe('error handling', function () {
+        it('should throw SmartThingsError on API error', async function () {
+            sinon.stub(client.http, 'request').rejects({
+                response: {
+                    status: 403,
+                    statusText: 'Forbidden',
+                    data: { message: 'Insufficient permissions' },
+                    headers: {}
+                }
+            });
+
+            try {
+                await client.getLocations();
+                expect.fail('Should have thrown');
+            } catch (err) {
+                expect(err).to.be.instanceOf(SmartThingsError);
+                expect(err.statusCode).to.equal(403);
+                expect(err.message).to.contain('Insufficient permissions');
+            }
+        });
+
+        it('should throw SmartThingsError on network error', async function () {
+            sinon.stub(client.http, 'request').rejects(new Error('Network Error'));
+
+            try {
+                await client.getLocations();
+                expect.fail('Should have thrown');
+            } catch (err) {
+                expect(err).to.be.instanceOf(SmartThingsError);
+                expect(err.message).to.contain('Network Error');
+            }
+        });
+    });
+
+    describe('retry logic', function () {
+        it('should retry on 500 errors up to MAX_RETRIES', async function () {
+            this.timeout(15000);
+            const stub = sinon.stub(client.http, 'request');
+            stub.onFirstCall().rejects({
+                response: { status: 500, statusText: 'Internal Server Error', data: {}, headers: {} }
+            });
+            stub.onSecondCall().rejects({
+                response: { status: 500, statusText: 'Internal Server Error', data: {}, headers: {} }
+            });
+            stub.onThirdCall().resolves({ data: { items: [{ locationId: 'loc-1' }] } });
+
+            sinon.stub(client, '_sleep').resolves();
+
+            const result = await client.getLocations();
+            expect(result).to.have.lengthOf(1);
+            expect(stub.callCount).to.equal(3);
+        });
+
+        it('should fail after MAX_RETRIES exceeded', async function () {
+            this.timeout(15000);
+            const stub = sinon.stub(client.http, 'request');
+            for (let i = 0; i < 4; i++) {
+                stub.onCall(i).rejects({
+                    response: { status: 500, statusText: 'Internal Server Error', data: {}, headers: {} }
+                });
+            }
+
+            sinon.stub(client, '_sleep').resolves();
+
+            try {
+                await client.getLocations();
+                expect.fail('Should have thrown');
+            } catch (err) {
+                expect(err).to.be.instanceOf(SmartThingsError);
+                expect(err.statusCode).to.equal(500);
+            }
+        });
+    });
+});