Login flow working

tests/bonob_client.ts

@@ -5,7 +5,7 @@ import sonos, { bonobService } from "../src/sonos";
 import server from "../src/server";
 
 import logger from "../src/logger";
-import { InMemoryMusicService } from "builders";
+import { InMemoryMusicService } from "./in_memory_music_service";
 
 const WEB_ADDRESS = "http://localhost:1234"
 

tests/builders.ts

@@ -1,6 +1,5 @@
 import { SonosDevice } from "@svrooij/sonos/lib";
 import { v4 as uuid } from "uuid";
-import { MusicService, Credentials } from "../src/music_service";
 
 import { Service, Device } from "../src/sonos";
 
@@ -55,23 +54,3 @@ export function getAppLinkMessage() {
     callbackPath: "",
   };
 }
-
-export class InMemoryMusicService implements MusicService {
-  users: Record<string, string> = {};
-
-  login({ username, password }: Credentials) {
-    return username != undefined && password != undefined && this.users[username] == password;
-  }
-
-  hasUser(credentials: Credentials) {
-    this.users[credentials.username] = credentials.password;
-  }
-
-  hasNoUsers() {
-    this.users = {};
-  }
-
-  clear() {
-    this.users = {};
-  }
-}

tests/in_memory_music_service.ts

@@ -0,0 +1,35 @@
+import {
+  MusicService,
+  Credentials,
+  AuthSuccess,
+  AuthFailure,
+} from "../src/music_service";
+
+
+export class InMemoryMusicService implements MusicService {
+  users: Record<string, string> = {};
+
+  login({ username, password }: Credentials): AuthSuccess | AuthFailure {
+    if (
+      username != undefined &&
+      password != undefined &&
+      this.users[username] == password
+    ) {
+      return { authToken: "token123", userId: username, nickname: username };
+    } else {
+      return { message: `Invalid user:${username}` };
+    }
+  }
+
+  hasUser(credentials: Credentials) {
+    this.users[credentials.username] = credentials.password;
+  }
+
+  hasNoUsers() {
+    this.users = {};
+  }
+
+  clear() {
+    this.users = {};
+  }
+}

tests/index.test.ts

@@ -2,7 +2,8 @@ import request from "supertest";
 import makeServer from "../src/server";
 import { SONOS_DISABLED, Sonos, Device } from "../src/sonos";
 
-import { aDevice, aService, InMemoryMusicService } from './builders';
+import { aDevice, aService } from './builders';
+import { InMemoryMusicService } from "./in_memory_music_service";
 
 describe("index", () => {
   describe("when sonos integration is disabled", () => {

tests/link_codes.test.ts

@@ -0,0 +1,47 @@
+import { InMemoryLinkCodes } from "../src/link_codes"
+
+describe("InMemoryLinkCodes", () => {
+  const linkCodes = new InMemoryLinkCodes()
+
+  describe('minting', () => {
+    it('should be able to mint unique codes', () => {
+      const code1 = linkCodes.mint()
+      const code2 = linkCodes.mint()
+      const code3 = linkCodes.mint()
+
+      expect(code1).not.toEqual(code2);
+      expect(code1).not.toEqual(code3);
+    });
+  });
+
+  describe("associating a code with a user", () => {
+    describe('when token is valid', () => {
+      it('should associate the token', () => {
+        const linkCode = linkCodes.mint();
+        const association = { authToken: "token123", nickname: "bob", userId: "1" };
+
+        linkCodes.associate(linkCode, association);
+
+        expect(linkCodes.associationFor(linkCode)).toEqual(association);
+      }); 
+    });
+
+    describe('when token is valid', () => {
+      it('should throw an error', () => {
+        const invalidLinkCode = "invalidLinkCode";
+        const association = { authToken: "token123", nickname: "bob", userId: "1" };
+
+        expect(() => linkCodes.associate(invalidLinkCode, association)).toThrow(`Invalid linkCode ${invalidLinkCode}`)
+      }); 
+    });
+  });
+
+  describe('fetching an association for a linkCode', () => {
+    describe('when the token doesnt exist', () => {
+      it('should return undefined', () => {
+        const missingLinkCode = 'someLinkCodeThatDoesntExist';
+        expect(linkCodes.associationFor(missingLinkCode)).toBeUndefined()
+      });
+    })
+  });
+})

tests/scenarios.test.ts

@@ -4,7 +4,8 @@ import { Express } from "express";
 import request from "supertest";
 
 import { GetAppLinkResult } from "../src/smapi";
-import { InMemoryMusicService, getAppLinkMessage } from "./builders";
+import { getAppLinkMessage } from "./builders";
+import { InMemoryMusicService } from "./in_memory_music_service";
 import { InMemoryLinkCodes } from "../src/link_codes";
 import { Credentials } from "../src/music_service";
 import makeServer from "../src/server";
@@ -53,13 +54,14 @@ class SonosDriver {
               .post(this.stripServiceRoot(regUrl))
               .type("form")
               .send({ username, password, linkCode })
-              .expect(200)
               .then(response => ({
                 expectSuccess: () => {
-                  expect(response.text).toContain("ok")
+                  expect(response.status).toEqual(200);
+                  expect(response.text).toContain("Login Successful")
                 },
                 expectFailure: () => {
-                  expect(response.text).toContain("boo")
+                  expect(response.status).toEqual(403);
+                  expect(response.text).toContain("Login failed")
                 },
               }));
           },

tests/smapi.test.ts

@@ -1,27 +1,228 @@
+import crypto from "crypto";
 import request from "supertest";
+import { createClientAsync } from "soap";
 
-import { DOMParserImpl } from 'xmldom-ts';
-import * as xpath from 'xpath-ts';
+import { DOMParserImpl } from "xmldom-ts";
+import * as xpath from "xpath-ts";
 
+import { InMemoryLinkCodes, LinkCodes } from "../src/link_codes";
 import makeServer from "../src/server";
-import { SONOS_DISABLED, STRINGS_PATH } from "../src/sonos";
+import { bonobService, SONOS_DISABLED, STRINGS_PATH } from "../src/sonos";
 
-import { aService, InMemoryMusicService } from './builders';
+import { aService, getAppLinkMessage } from "./builders";
+import { InMemoryMusicService } from "./in_memory_music_service";
+import supersoap from "./supersoap";
 
 const parseXML = (value: string) => new DOMParserImpl().parseFromString(value);
-const select = xpath.useNamespaces({"sonos": "http://sonos.com/sonosapi"})
+const select = xpath.useNamespaces({ sonos: "http://sonos.com/sonosapi" });
 
-describe('strings.xml', () => {
-  const server = makeServer(SONOS_DISABLED, aService(), 'http://localhost:1234', new InMemoryMusicService());
+describe("service config", () => {
+  describe("strings.xml", () => {
+    const server = makeServer(
+      SONOS_DISABLED,
+      aService(),
+      "http://localhost:1234",
+      new InMemoryMusicService()
+    );
 
-  it("should return xml for the strings", async () => {
-    const res = await request(server).get(STRINGS_PATH).send();
+    it("should return xml for the strings", async () => {
+      const res = await request(server).get(STRINGS_PATH).send();
 
-    expect(res.status).toEqual(200);
+      expect(res.status).toEqual(200);
 
-    const xml = parseXML(res.text);
-    const x = select("//sonos:string[@stringId='AppLinkMessage']/text()", xml) as Node[]
-    expect(x.length).toEqual(1)
-    expect(x[0]!.nodeValue).toEqual("Linking sonos with bonob")
+      const xml = parseXML(res.text);
+      const x = select(
+        "//sonos:string[@stringId='AppLinkMessage']/text()",
+        xml
+      ) as Node[];
+      expect(x.length).toEqual(1);
+      expect(x[0]!.nodeValue).toEqual("Linking sonos with bonob");
+    });
   });
-});
+});
+
+describe("api", () => {
+  const rootUrl = "http://localhost:1234";
+  const service = bonobService("test-api", 133, rootUrl, "AppLink");
+  const musicService = new InMemoryMusicService();
+  const linkCodes = new InMemoryLinkCodes();
+
+  beforeEach(() => {
+    musicService.clear();
+    linkCodes.clear();
+  });
+
+  describe("pages", () => {
+    const server = makeServer(
+      SONOS_DISABLED,
+      service,
+      rootUrl,
+      musicService,
+      linkCodes
+    );
+
+    describe("/login", () => {
+      describe("when the credentials are valid", () => {
+        it("should return 200 ok and have associated linkCode with user", async () => {
+          const username = "jane";
+          const password = "password100";
+          const linkCode = linkCodes.mint();
+
+          musicService.hasUser({ username, password });
+
+          const res = await request(server)
+            .post("/login")
+            .type("form")
+            .send({ username, password, linkCode })
+            .expect(200);
+
+          expect(res.text).toContain("Login successful");
+
+          const association = linkCodes.associationFor(linkCode);
+          expect(association.nickname).toEqual(username);
+        });
+      });
+
+      describe("when credentials are invalid", () => {
+        it("should return 403 with message", async () => {
+          const username = "userDoesntExist";
+          const password = "password";
+          const linkCode = linkCodes.mint();
+
+          musicService.hasNoUsers();
+
+          const res = await request(server)
+            .post("/login")
+            .type("form")
+            .send({ username, password, linkCode })
+            .expect(403);
+
+          expect(res.text).toContain(`Login failed, Invalid user:${username}`);
+        });
+      });
+
+      describe("when linkCode is invalid", () => {
+        it("should return 400 with message", async () => {
+          const username = "jane";
+          const password = "password100";
+          const linkCode = "someLinkCodeThatDoesntExist";
+
+          musicService.hasUser({ username, password });
+
+          const res = await request(server)
+            .post("/login")
+            .type("form")
+            .send({ username, password, linkCode })
+            .expect(400);
+
+          expect(res.text).toContain("Invalid linkCode!");
+        });
+      });
+    });
+  });
+
+  describe("soap api", () => {
+    describe("getAppLink", () => {
+      const mockLinkCodes = {
+        mint: jest.fn(),
+      };
+      const server = makeServer(
+        SONOS_DISABLED,
+        service,
+        rootUrl,
+        musicService,
+        (mockLinkCodes as unknown) as LinkCodes
+      );
+
+      it("should do something", async () => {
+        const ws = await createClientAsync(`${service.uri}?wsdl`, {
+          endpoint: service.uri,
+          httpClient: supersoap(server, rootUrl),
+        });
+
+        const linkCode = "theLinkCode8899";
+
+        mockLinkCodes.mint.mockReturnValue(linkCode);
+
+        const result = await ws.getAppLinkAsync(getAppLinkMessage());
+
+        expect(result[0]).toEqual({
+          getAppLinkResult: {
+            authorizeAccount: {
+              appUrlStringId: "AppLinkMessage",
+              deviceLink: {
+                regUrl: `${rootUrl}/login?linkCode=${linkCode}`,
+                linkCode: linkCode,
+                showLinkCode: false,
+              },
+            },
+          },
+        });
+      });
+    });
+  });
+
+  describe("getDeviceAuthToken", () => {
+    const linkCodes = new InMemoryLinkCodes();
+    const server = makeServer(
+      SONOS_DISABLED,
+      service,
+      rootUrl,
+      musicService,
+      linkCodes
+    );
+
+    describe("when there is a linkCode association", () => {
+      it("should return a device auth token", async () => {
+        const linkCode = linkCodes.mint();
+        const association = { authToken: "at", userId: "uid", nickname: "nn" };
+        linkCodes.associate(linkCode, association);
+
+        const ws = await createClientAsync(`${service.uri}?wsdl`, {
+          endpoint: service.uri,
+          httpClient: supersoap(server, rootUrl),
+        });
+
+        const result = await ws.getDeviceAuthTokenAsync({ linkCode });
+
+        expect(result[0]).toEqual({
+          getDeviceAuthTokenResult: {
+            authToken: association.authToken,
+            privateKey: "v1",
+            userInfo: {
+              nickname: association.nickname,
+              userIdHashCode: crypto
+                .createHash("sha256")
+                .update(association.userId)
+                .digest("hex"),
+            },
+          },
+        });
+      });
+    });
+
+    describe("when there is no linkCode association", () => {
+      it("should return a device auth token", async () => {
+        const linkCode = "invalidLinkCode";
+
+        const ws = await createClientAsync(`${service.uri}?wsdl`, {
+          endpoint: service.uri,
+          httpClient: supersoap(server, rootUrl),
+        });
+
+        await ws
+          .getDeviceAuthTokenAsync({ linkCode })
+          .then(() => {
+            throw "Shouldnt get here";
+          })
+          .catch((e: any) => {
+            expect(e.root.Envelope.Body.Fault).toEqual({
+              faultcode: "Client.NOT_LINKED_RETRY",
+              faultstring: "Link Code not found retry...",
+              detail: { ExceptionInfo: "NOT_LINKED_RETRY", SonosError: "5" },
+            });
+          });
+      });
+    });
+  });
+});

tests/ws.test.ts

@@ -1,7 +1,8 @@
 import makeServer from "../src/server";
 import { SONOS_DISABLED, SOAP_PATH } from "../src/sonos";
 
-import { aService, InMemoryMusicService } from "./builders";
+import { aService } from "./builders";
+import { InMemoryMusicService } from "./in_memory_music_service";
 import supersoap from './supersoap';
 
 import { createClientAsync } from "soap";