Update tests for video-token-server

Author: Tim Mendoza

package-lock.json

@@ -22,6 +22,7 @@
     "@oclif/plugin-help": "^2",
     "@twilio-labs/serverless-api": "^4.0.1",
     "@twilio/cli-core": "^5.8.0",
+    "lodash": "^4.17.20",
     "moment": "^2.24.0",
     "nanoid": "^3.1.12"
   },

package.json

@@ -61,8 +61,9 @@ module.exports.handler = async (context, event, callback) => {
   try {
     await client.video.rooms.create({ uniqueName: room_name, type: ROOM_TYPE });
   } catch (e) {
+    // Ignore 53113 error (room already exists). See: https://www.twilio.com/docs/api/errors/53113
     if (e.code !== 53113) {
-      response.setStatusCode(401);
+      response.setStatusCode(500);
       response.setBody({
         error: {
           message: 'error creating room',

src/video-token-server.js

@@ -1,21 +1,31 @@
 const { handler } = require('../src/video-token-server');
 const jwt = require('jsonwebtoken');
+const { set } = require('lodash');
 
 const callback = jest.fn();
 
+const mockCreateFunction = jest.fn();
+
+const mockTwilioClient = set({}, 'video.rooms.create', mockCreateFunction);
+
 const mockContext = {
   ACCOUNT_SID: 'AC1234',
   TWILIO_API_KEY_SID: 'SK1234',
   TWILIO_API_KEY_SECRET: 'api_secret',
   API_PASSCODE: '123456',
   API_PASSCODE_EXPIRY: '10',
   DOMAIN_NAME: 'video-app-1234-5678-dev.twil.io',
+  ROOM_TYPE: 'group',
+  getTwilioClient: () => mockTwilioClient,
 };
 
 describe('the video-token-server', () => {
-  it('should return an "unauthorized" error when the passcode is incorrect', () => {
+  beforeEach(() => {
     Date.now = () => 5;
+    mockCreateFunction.mockImplementation(() => Promise.resolve());
+  });
 
+  it('should return an "unauthorized" error when the passcode is incorrect', () => {
     handler(mockContext, { passcode: '9876543210', user_identity: 'test identity' }, callback);
 
     expect(callback).toHaveBeenCalledWith(null, {
@@ -49,8 +59,6 @@ describe('the video-token-server', () => {
   });
 
   it('should return a "missing user_identity" error when the "user_identity" parameter is not supplied', () => {
-    Date.now = () => 5;
-
     handler(mockContext, { passcode: '12345612345678' }, callback);
 
     expect(callback).toHaveBeenCalledWith(null, {
@@ -65,13 +73,11 @@ describe('the video-token-server', () => {
     });
   });
 
-  it('should return a token when no room_name is supplied', () => {
-    Date.now = () => 5;
-
-    handler(mockContext, { passcode: '12345612345678', user_identity: 'test identity' }, callback);
+  it('should return a token when no room_name is supplied', async () => {
+    await handler(mockContext, { passcode: '12345612345678', user_identity: 'test identity' }, callback);
 
     expect(callback).toHaveBeenCalledWith(null, {
-      body: { token: expect.any(String) },
+      body: { token: expect.any(String), room_type: 'group' },
       headers: { 'Content-Type': 'application/json' },
       statusCode: 200,
     });
@@ -89,47 +95,101 @@ describe('the video-token-server', () => {
     });
   });
 
-  it('should return a valid token when passcode, room_name, and user_identity parameters are supplied', () => {
-    Date.now = () => 5;
-    handler(mockContext, { passcode: '12345612345678', room_name: 'test-room', user_identity: 'test-user' }, callback);
+  describe('when passcode, room_name, and user_identity parameters are supplied', () => {
+    it('should return a valid token', async () => {
+      await handler(
+        mockContext,
+        { passcode: '12345612345678', room_name: 'test-room', user_identity: 'test-user' },
+        callback
+      );
 
-    expect(callback).toHaveBeenCalledWith(null, {
-      body: { token: expect.any(String) },
-      headers: { 'Content-Type': 'application/json' },
-      statusCode: 200,
-    });
+      expect(callback).toHaveBeenCalledWith(null, {
+        body: { token: expect.any(String), room_type: 'group' },
+        headers: { 'Content-Type': 'application/json' },
+        statusCode: 200,
+      });
 
-    expect(jwt.verify(callback.mock.calls[0][1].body.token, 'api_secret')).toEqual({
-      exp: 14400,
-      grants: {
-        identity: 'test-user',
-        video: {
-          room: 'test-room',
+      expect(jwt.verify(callback.mock.calls[0][1].body.token, 'api_secret')).toEqual({
+        exp: 14400,
+        grants: {
+          identity: 'test-user',
+          video: {
+            room: 'test-room',
+          },
         },
-      },
-      iat: 0,
-      iss: 'SK1234',
-      jti: 'SK1234-0',
-      sub: 'AC1234',
+        iat: 0,
+        iss: 'SK1234',
+        jti: 'SK1234-0',
+        sub: 'AC1234',
+      });
     });
-  });
 
-  describe('when using an old form URL "video-app-XXXX-dev.twil.io', () => {
-    it('should return a valid token when passcode, room_name, and user_identity parameters are supplied', () => {
-      Date.now = () => 5;
-      handler(
+    it('should return a valid token when passcode when using an old form URL "video-app-XXXX-dev.twil.io', async () => {
+      await handler(
         { ...mockContext, DOMAIN_NAME: 'video-app-1234-dev.twil.io' },
         { passcode: '1234561234', room_name: 'test-room', user_identity: 'test-user' },
         callback
       );
 
       expect(callback).toHaveBeenCalledWith(null, {
-        body: { token: expect.any(String) },
+        body: { token: expect.any(String), room_type: 'group' },
         headers: { 'Content-Type': 'application/json' },
         statusCode: 200,
       });
 
       expect(jwt.verify(callback.mock.calls[0][1].body.token, 'api_secret')).toBeTruthy();
     });
+
+    it('should create a new room and return a valid token when passcode', async () => {
+      await handler(
+        mockContext,
+        { passcode: '12345612345678', room_name: 'test-room', user_identity: 'test-user' },
+        callback
+      );
+
+      expect(mockCreateFunction).toHaveBeenCalledWith({ type: 'group', uniqueName: 'test-room' });
+      expect(callback).toHaveBeenCalledWith(null, {
+        body: { token: expect.any(String), room_type: 'group' },
+        headers: { 'Content-Type': 'application/json' },
+        statusCode: 200,
+      });
+    });
+
+    it('should return a valid token when passcode when the room already exists', async () => {
+      mockCreateFunction.mockImplementation(() => Promise.reject({ code: 53113 }));
+
+      await handler(
+        mockContext,
+        { passcode: '12345612345678', room_name: 'test-room', user_identity: 'test-user' },
+        callback
+      );
+
+      expect(callback).toHaveBeenCalledWith(null, {
+        body: { token: expect.any(String), room_type: 'group' },
+        headers: { 'Content-Type': 'application/json' },
+        statusCode: 200,
+      });
+    });
+
+    it('should return an error when there is a problem creating the room', async () => {
+      mockCreateFunction.mockImplementationOnce(() => Promise.reject({ code: 12345 }));
+
+      await handler(
+        mockContext,
+        { passcode: '12345612345678', room_name: 'test-room', user_identity: 'test-user' },
+        callback
+      );
+
+      expect(callback).toHaveBeenCalledWith(null, {
+        body: {
+          error: {
+            explanation: 'Something went wrong when creating a room.',
+            message: 'error creating room',
+          },
+        },
+        headers: { 'Content-Type': 'application/json' },
+        statusCode: 500,
+      });
+    });
   });
 });