ring-client-api 14.0.0-beta.0 → 14.0.0-beta.1

package/lib/test/rest-client.spec.js

@@ -0,0 +1,241 @@
+import { http, HttpResponse } from 'msw';
+import { setupServer } from 'msw/node';
+import { RingRestClient } from "../rest-client.js";
+import { clearTimeouts, getHardwareId, toBase64 } from "../util.js";
+import { firstValueFrom } from 'rxjs';
+import { afterAll, afterEach, beforeAll, beforeEach, describe, expect, it, } from 'vitest';
+let sessionCreatedCount = 0, client;
+const email = 'some@one.com', password = 'abc123!', phone = '+1xxxxxxxx89', twoFactorAuthCode = '123456', hardwareIdPromise = getHardwareId(), accessToken = 'ey__accees_token', secondAccessToken = 'ey__second_accees_token', refreshToken = 'ey__refresh_token', secondRefreshToken = 'ey__second_refresh_token', thirdRefreshToken = 'ey__third_refresh_token', server = setupServer(http.post('https://oauth.ring.com/oauth/token', async ({ request: req }) => {
+    const body = await req.json();
+    if (req.headers.get('2fa-support') !== 'true' ||
+        req.headers.get('User-Agent') !== 'android:com.ringapp' ||
+        req.headers.get('hardware_id') !== (await hardwareIdPromise)) {
+        return HttpResponse.json({
+            code: 1,
+            error: 'Invalid auth headers: ' + JSON.stringify(req.headers, null, 2),
+        }, { status: 400 });
+    }
+    if (body.grant_type === 'refresh_token') {
+        if (body.refresh_token === refreshToken) {
+            // Valid refresh token
+            return HttpResponse.json({
+                access_token: accessToken,
+                expires_in: 3600,
+                refresh_token: secondRefreshToken,
+                scope: 'client',
+                token_type: 'Bearer',
+            }, { status: 200 });
+        }
+        if (body.refresh_token === secondRefreshToken) {
+            // Valid refresh token
+            return HttpResponse.json({
+                access_token: secondAccessToken,
+                expires_in: 3600,
+                refresh_token: thirdRefreshToken,
+                scope: 'client',
+                token_type: 'Bearer',
+            }, { status: 200 });
+        }
+        // Invalid refresh token
+        return HttpResponse.json({
+            error: 'invalid_grant',
+            error_description: 'token is invalid or does not exists',
+        }, { status: 401 });
+    }
+    if (body.grant_type !== 'password' ||
+        body.client_id !== 'ring_official_android' ||
+        body.scope !== 'client') {
+        return HttpResponse.json({
+            code: 1,
+            error: 'Invalid auth request: ' + JSON.stringify(body),
+        }, { status: 400 });
+    }
+    if (body.username !== email || body.password !== password) {
+        // Wrong username or password
+        return HttpResponse.json({
+            error: 'access_denied',
+            error_description: 'invalid user credentials',
+        }, { status: 401 });
+    }
+    if (req.headers.get('2fa-code') &&
+        req.headers.get('2fa-code') !== twoFactorAuthCode) {
+        // Wrong 2fa code
+        return HttpResponse.json({
+            err_msg: 'bad request response from dependency service',
+            error: 'Verification Code is invalid or expired',
+        }, { status: 400 });
+    }
+    if (req.headers.get('2fa-code') === twoFactorAuthCode) {
+        // Successfull login with correct 2fa code
+        return HttpResponse.json({
+            access_token: accessToken,
+            expires_in: 3600,
+            refresh_token: refreshToken,
+            scope: 'client',
+            token_type: 'Bearer',
+            responseTimestamp: Date.now(),
+        });
+    }
+    // 2fa code not provided, so return the 2fa prompt
+    return HttpResponse.json({
+        next_time_in_secs: 60,
+        phone,
+        tsv_state: 'sms',
+    }, { status: 412 });
+}), http.post('https://api.ring.com/clients_api/session', async ({ request: req }) => {
+    const authHeader = req.headers.get('Authorization');
+    if (authHeader !== `Bearer ${accessToken}` &&
+        authHeader !== `Bearer ${secondAccessToken}`) {
+        // Invalid access token used
+        return HttpResponse.json({}, { status: 401 });
+    }
+    const body = await req.json();
+    if (body.device.hardware_id !== (await getHardwareId()) ||
+        body.device.metadata.api_version !== 11 ||
+        body.device.metadata.device_model !== 'ring-client-api' ||
+        body.device.os !== 'android') {
+        return HttpResponse.text('Bad session request: ' + JSON.stringify(body, null, 2), { status: 400 });
+    }
+    // Fake a response from the session endpoint, incrementing the sessionCreatedCount
+    sessionCreatedCount++;
+    return HttpResponse.json({
+        profile: {
+            id: 1234,
+        },
+    });
+}));
+async function wrapRefreshToken(rt) {
+    return toBase64(JSON.stringify({
+        rt,
+        hid: await hardwareIdPromise,
+    }));
+}
+beforeEach(() => {
+    sessionCreatedCount = 0;
+});
+beforeAll(() => {
+    // Establish requests interception layer before all tests.
+    server.listen();
+});
+afterAll(() => {
+    // Clean up after all tests are done, preventing this
+    // interception layer from affecting irrelevant tests.
+    server.close();
+});
+afterEach(() => {
+    client.clearTimeouts();
+    clearTimeouts();
+});
+describe('getAuth', () => {
+    it('should throw and set the 2fa prompt', async () => {
+        client = new RingRestClient({
+            password,
+            email,
+        });
+        await expect(() => client.getAuth()).rejects.toThrow('Your Ring account is configured to use 2-factor authentication (2fa).  See https://github.com/dgreif/ring/wiki/Refresh-Tokens for details.');
+        expect(client.promptFor2fa).toEqual(`Please enter the code sent to ${phone} via sms`);
+        expect(client.using2fa).toEqual(true);
+    });
+    it('should accept a 2fa code', async () => {
+        client = new RingRestClient({
+            password,
+            email,
+        });
+        // ignore the first reject, it's tested above
+        await expect(() => client.getAuth()).rejects.toThrow();
+        // call getAuth again with the 2fa code, which should succeed
+        const auth = await client.getAuth(twoFactorAuthCode);
+        expect(auth).toMatchObject({
+            access_token: accessToken,
+            refresh_token: await wrapRefreshToken(refreshToken),
+        });
+        expect(client.refreshToken).toEqual(await wrapRefreshToken(refreshToken));
+    });
+    it('should handle invalid credentials', async () => {
+        client = new RingRestClient({
+            password: 'incorrect password',
+            email,
+        });
+        await expect(() => client.getAuth()).rejects.toThrow('Failed to fetch oauth token from Ring. Verify that your email and password are correct. (error: access_denied)');
+    });
+    it('should handle invalid 2fa code', async () => {
+        client = new RingRestClient({
+            password,
+            email,
+        });
+        // ignore the first reject, it's it('ove
+        await expect(() => client.getAuth()).rejects.toThrow();
+        // call getAuth again with an invalid 2fa code, which should fail
+        await expect(() => client.getAuth('invalid 2fa code')).rejects.toThrow('Verification Code is invalid or expired');
+        expect(client.promptFor2fa).toEqual('Invalid 2fa code entered.  Please try again.');
+    });
+    it('should establish a valid auth token with a valid refresh token', async () => {
+        client = new RingRestClient({
+            refreshToken,
+        });
+        expect(await client.getCurrentAuth()).toMatchObject({
+            access_token: accessToken,
+            refresh_token: await wrapRefreshToken(secondRefreshToken),
+        });
+        expect(client.refreshToken).toEqual(await wrapRefreshToken(secondRefreshToken));
+    });
+    it('should emit an event when a new refresh token is created', async () => {
+        client = new RingRestClient({
+            refreshToken,
+        });
+        const refreshedPromise = firstValueFrom(client.onRefreshTokenUpdated), auth = await client.getAuth();
+        expect(auth).toMatchObject({
+            access_token: accessToken,
+            refresh_token: await wrapRefreshToken(secondRefreshToken),
+        });
+        expect(await refreshedPromise).toEqual({
+            oldRefreshToken: refreshToken,
+            newRefreshToken: await wrapRefreshToken(secondRefreshToken),
+        });
+    });
+});
+describe('fetch', () => {
+    let invalidateFirstAccessToken = false;
+    beforeEach(() => {
+        invalidateFirstAccessToken = false;
+        server.use(http.get('https://api.ring.com/clients_api/some_endpoint', ({ request: req }) => {
+            const authHeader = req.headers.get('Authorization');
+            if (invalidateFirstAccessToken &&
+                authHeader === `Bearer ${accessToken}`) {
+                // Original access token used, but no longer valid
+                return HttpResponse.json({}, { status: 401 });
+            }
+            if (authHeader !== `Bearer ${accessToken}` &&
+                authHeader !== `Bearer ${secondAccessToken}`) {
+                // Invalid access token used
+                return HttpResponse.json({}, { status: 401 });
+            }
+            if (sessionCreatedCount === 0) {
+                // Session not created yet
+                return HttpResponse.json({
+                    error: 'Session not found for ' + req.headers.get('hardware_id'),
+                }, { status: 404 });
+            }
+            return HttpResponse.json([]);
+        }));
+    });
+    it('should include the auth token as a header', async () => {
+        client = new RingRestClient({
+            refreshToken,
+        });
+        const response = await client.request({
+            url: 'https://api.ring.com/clients_api/some_endpoint',
+        });
+        expect(response).toEqual([]);
+    });
+    it('should fetch a new auth token if the first is no longer valid', async () => {
+        client = new RingRestClient({
+            refreshToken,
+        });
+        invalidateFirstAccessToken = true;
+        const response = await client.request({
+            url: 'https://api.ring.com/clients_api/some_endpoint',
+        });
+        expect(response).toEqual([]);
+    });
+});

package/lib/test/ring-camera.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/test/ring-camera.spec.js

@@ -0,0 +1,36 @@
+import { getBatteryLevel, cleanSnapshotUuid } from "../ring-camera.js";
+import { describe, expect, it } from 'vitest';
+describe('Ring Camera', () => {
+    describe('battery level', () => {
+        it('should handle string battery life', () => {
+            expect(getBatteryLevel({
+                battery_life: '49',
+            })).toEqual(49);
+        });
+        it('should handle null battery life', () => {
+            expect(getBatteryLevel({ battery_life: null })).toEqual(null);
+        });
+        it('should handle right battery only', () => {
+            expect(getBatteryLevel({ battery_life: null, battery_life_2: 24 })).toEqual(24);
+        });
+        it('should handle left battery only', () => {
+            expect(getBatteryLevel({ battery_life: 76, battery_life_2: null })).toEqual(76);
+        });
+        it('should handle dual batteries', () => {
+            expect(getBatteryLevel({ battery_life: '92', battery_life_2: 84 })).toEqual(84);
+            expect(getBatteryLevel({ battery_life: '92', battery_life_2: 100 })).toEqual(92);
+        });
+    });
+    describe('cleanSnapshotUuid', () => {
+        it('should return the original uuid if it is already clean', () => {
+            expect(cleanSnapshotUuid('c2a0a397-3538-422d-bb4e-51837a56b870')).toBe('c2a0a397-3538-422d-bb4e-51837a56b870');
+        });
+        it('should return remove anything after :', () => {
+            expect(cleanSnapshotUuid('c2a0a397-3538-422d-bb4e-51837a56b870:122429140')).toBe('c2a0a397-3538-422d-bb4e-51837a56b870');
+        });
+        it('should handle falsy values', () => {
+            expect(cleanSnapshotUuid(undefined)).toBe(undefined);
+            expect(cleanSnapshotUuid(null)).toBe(null);
+        });
+    });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ring-client-api",
-  "version": "14.0.0-beta.0",
+  "version": "14.0.0-beta.1",
   "description": "Unofficial API for Ring doorbells, cameras, security alarm system and smart lighting",
   "main": "lib/index.js",
   "type": "module",
@@ -23,26 +23,26 @@
     "colors": "1.4.0",
     "debug": "^4.4.0",
     "json-bigint": "^1.0.0",
-    "rxjs": "^7.8.1",
+    "rxjs": "^7.8.2",
     "socket.io-client": "^2.5.0",
     "systeminformation": "^5.25.11",
-    "undici": "^7.2.1",
-    "uuid": "^11.0.5",
-    "werift": "0.21.6",
-    "ws": "^8.18.0"
+    "undici": "^7.8.0",
+    "uuid": "^11.1.0",
+    "werift": "0.22.1",
+    "ws": "^8.18.1"
   },
   "devDependencies": {
     "@types/debug": "4.1.12",
     "@types/json-bigint": "^1.0.4",
-    "@types/node": "22.10.5",
+    "@types/node": "22.14.1",
     "@types/socket.io-client": "1.4.36",
     "@types/uuid": "10.0.0",
-    "@types/ws": "^8.5.13",
+    "@types/ws": "^8.18.1",
     "eslint-config-shared": "*",
-    "msw": "^2.7.0",
+    "msw": "^2.7.5",
     "tsconfig": "*",
-    "typescript": "5.7.3",
-    "vitest": "^2.1.8"
+    "typescript": "5.8.3",
+    "vitest": "^3.1.1"
   },
   "engines": {
     "node": "^18 || ^20 || ^22"