test: move test files into lib

Author: mhuynh5757

karma.conf.ts

@@ -14,8 +14,7 @@ if (fs.existsSync(__dirname + '/config.yaml')) {
   process.env.AUTH_TOKEN = process.env.AUTH_TOKEN || creds.auth_token;
 }
 
-const testFiles = process.env.INTEGRATION_TEST_FILES ?
-  process.env.INTEGRATION_TEST_FILES.split(',') : ['tests/integration/**/*.ts'];
+const testFiles = ["lib/tests/**/*.ts"];
 
 console.log('Test Files:', testFiles);
 
@@ -102,13 +101,12 @@ module.exports = function(config: any) {
         'lib/**/*',
         ...testFiles,
       ],
-      tsconfig: './tsconfig-karma.json',
+      tsconfig: './tsconfig.json',
     },
     logLevel: process.env.E2E_LOGLEVEL || config.LOG_DEBUG,
     port: 9876,
     preprocessors: {
       'lib/**/*.ts': 'karma-typescript',
-      'tests/integration/**/*.ts': 'karma-typescript',
     },
     reporters: ['spec', 'karma-typescript', 'junit'],
     singleRun: true,

lib/tests/lib/token.js

@@ -0,0 +1,32 @@
+const Twilio = require('twilio');
+const env = require('../env.js');
+
+function generateAccessToken(identity, ttl, appSid) {
+  const accessToken = new Twilio.jwt.AccessToken(env.accountSid,
+    env.apiKeySid,
+    env.apiKeySecret,
+    { ttl: ttl || 300, identity });
+
+  accessToken.addGrant(new Twilio.jwt.AccessToken.VoiceGrant({
+    incomingAllow: true,
+    outgoingApplicationSid: appSid || env.appSid,
+  }));
+
+  return accessToken.toJwt();
+}
+
+function generateCapabilityToken() {
+  const outgoingScope = new Twilio.jwt.ClientCapability.OutgoingClientScope({
+    applicationSid: env.appSid
+  });
+
+  const token = new Twilio.jwt.ClientCapability({
+    accountSid: env.accountSid,
+    authToken: env.authToken,
+  });
+
+  token.addScope(outgoingScope);
+  return token.toJwt();
+}
+
+module.exports = { generateAccessToken, generateCapabilityToken };

lib/tests/unit/device.ts

@@ -0,0 +1,230 @@
+import * as assert from 'assert';
+import Call from '../../twilio/call';
+import Device from '../../twilio/device';
+import { generateAccessToken } from '../lib/token';
+
+// (rrowland) The TwiML expected by these tests can be found in the README.md
+
+describe('Device', function() {
+  this.timeout(10000);
+
+  let device1: Device;
+  let device2: Device;
+  let identity1: string;
+  let identity2: string;
+  let token1: string;
+  let token2: string;
+
+  before(() => {
+    identity1 = 'id1-' + Date.now();
+    identity2 = 'id2-' + Date.now();
+    token1 = generateAccessToken(identity1);
+    token2 = generateAccessToken(identity2);
+    device1 = new Device(token1);
+    device2 = new Device(token2);
+
+    return Promise.all([
+      device1.register(),
+      device2.register(),
+    ]);
+  });
+
+  after(() => {
+    if (device1) {
+      device1.disconnectAll();
+      device1.destroy();
+    }
+
+    if (device2) {
+      device2.disconnectAll();
+      device2.destroy();
+    }
+  });
+
+  describe('tokenWillExpire event', () => {
+    const setupDevice = (tokenTtl: number, tokenRefreshMs: number) => {
+      const accessToken = generateAccessToken(`device-tokenWillExpire-${Date.now()}`, tokenTtl);
+      const device = new Device(accessToken, { tokenRefreshMs });
+      device.on(Device.EventName.Error, () => { /* no-op */ });
+      return device;
+    };
+
+    it('should emit a "tokenWillExpire" event', async () => {
+      const device = setupDevice(10, 1000);
+      await new Promise<void>(async (resolve, reject) => {
+        let failureTimeout: any = null;
+        device.on(Device.EventName.TokenWillExpire, () => {
+          if (failureTimeout) {
+            clearTimeout(failureTimeout);
+          }
+          resolve();
+        });
+        await device.register();
+        failureTimeout = setTimeout(reject, 9500);
+      });
+    });
+
+    it('should not emit a "tokenWillExpire" event early', async () => {
+      const device = setupDevice(10, 1000);
+      await new Promise<void>(async (resolve, reject) => {
+        let successTimeout: any = null;
+        device.on(Device.EventName.TokenWillExpire, () => {
+          if (successTimeout) {
+            clearTimeout(successTimeout);
+          }
+          reject();
+        });
+        await device.register();
+        // NOTE(csantos): Expected time before tokenWillExpire event is raised is about 9s
+        // for a ttl: 10s and tokenRefreshMS: 1000, meaning we should resolve the test at less than 9s.
+        // However, the ttl returned from signaling, which we use to calculate the timeout,
+        // sometimes returns 1s less from the original ttl we provided. So let's account for that.
+        // Instead of resolving the test before 9s, we should do it before 8s instead.
+        successTimeout = setTimeout(resolve, 7500);
+      });
+    });
+
+    it('should emit a "tokenWillExpire" event as soon as possible if the option is smaller than the ttl', async () => {
+      const device = setupDevice(5, 10000);
+
+      const eventPromises = Promise.all([
+        Device.EventName.TokenWillExpire,
+        Device.EventName.Registering,
+      ].map((eventName: string) => new Promise<number>(res => {
+        device.on(eventName, () => res(Date.now()));
+      })));
+
+      device.register();
+
+      const [expireTime, registeringTime] = await eventPromises;
+      const diff = Math.abs(expireTime - registeringTime);
+      // ttl returned from signaling, which we use to calculate the timeout,
+      // sometimes returns 1s less from the original ttl we provided. So let's account for that.
+      assert(diff < 2000, `event time occurred too late; diff: ${diff}`);
+    });
+  });
+
+  describe('device 1 calls device 2', () => {
+    let call1: Call;
+    let call2: Call;
+
+    before(() => new Promise<void>(async resolve => {
+      device2.once(Device.EventName.Incoming, (call: Call) => {
+        call2 = call;
+        resolve();
+      });
+      call1 = await (device1['connect'] as any)({
+        params: { To: identity2, Custom1: 'foo + bar', Custom2: undefined, Custom3: '我不吃蛋' }
+      });
+    }));
+
+    describe('and device 2 accepts', () => {
+      beforeEach(() => {
+        if (!call1 || !call2) {
+          throw new Error(`Calls weren't both open at beforeEach`);
+        }
+      });
+
+      it('should connect the call', (done) => {
+        call2.once('accept', () => done());
+        call2.accept();
+      });
+
+      it('should stay open 3 seconds', (done) => {
+        function fail() {
+          call1.removeListener('disconnect', fail);
+          call2.removeListener('disconnect', fail);
+          done(new Error('Expected the call to stay open for 3 seconds'));
+        }
+
+        call1.once('disconnect', fail);
+        call2.once('disconnect', fail);
+
+        setTimeout(() => {
+          call1.removeListener('disconnect', fail);
+          call2.removeListener('disconnect', fail);
+          done();
+        }, 3000);
+      });
+
+      it('should set callerInfo to null on both calls', () => {
+        assert.equal(call1!.callerInfo, null);
+        assert.equal(call2!.callerInfo, null);
+      });
+
+      it('should be using the PCMU codec for both calls', (done) => {
+        let codec1: string | null | undefined = null;
+
+        function setCodec(sample: any) {
+          if (codec1 === null) {
+            codec1 = sample.codecName;
+          } else {
+            if (codec1 === 'opus' || sample.codecName === 'opus') {
+              done(new Error('Codec is opus'));
+            } else {
+              done();
+            }
+          }
+        }
+
+        const monitor1: any = call1['_monitor'];
+        const monitor2: any = call2['_monitor'];
+        if (!monitor1 || !monitor2) {
+          done(new Error('Missing monitor'));
+        }
+        monitor1.once('sample', setCodec);
+        monitor2.once('sample', setCodec);
+      });
+
+      it('should update network priority to high if supported', () => {
+        if (!call2 || !call2['_mediaHandler'] || !call2['_mediaHandler']._sender) {
+          throw new Error('Expected sender to be present');
+        }
+        const sender = call2['_mediaHandler']._sender;
+        const params = sender.getParameters();
+        const encoding = params.encodings && params.encodings[0];
+
+        if (!params.priority && !encoding) {
+          // Not supported by browser.
+          return;
+        }
+
+        assert(params.priority === 'high'
+          || (encoding && encoding.priority === 'high')
+          || (encoding && encoding.networkPriority === 'high'));
+      });
+
+      it('should receive the correct custom parameters from the TwiML app', () => {
+        const comparator =
+          ([customParamKeyA]: string[], [customParamKeyB]: string[]) => {
+            return customParamKeyA.localeCompare(customParamKeyB);
+          };
+        assert.deepEqual(
+          Array.from(call2.customParameters.entries()).sort(comparator),
+          [
+            ['custom + param', '我不吃蛋'],
+            ['custom1', 'foo + bar'],
+            ['custom2', 'undefined'],
+            ['custom3', '我不吃蛋'],
+            ['duplicate', '123456'],
+            ['foobar', 'some + value'],
+          ],
+        );
+      });
+
+      it('should post metrics', (done) => {
+        const publisher = call1['_publisher'];
+        (publisher as any)['_request'] = { post: (params: any, err: Function) => {
+          if (/EndpointMetrics$/.test(params.url)) {
+            done();
+          }
+        }};
+      });
+
+      it('should hang up', (done) => {
+        call1.once('disconnect', () => done());
+        call2.disconnect();
+      });
+    });
+  });
+});

tsconfig-base.json

@@ -7,6 +7,7 @@
     "moduleResolution": "node",
     "noImplicitAny": true,
     "noImplicitThis": true,
+    "rootDir": "lib",
     "inlineSourceMap": true,
     "strictNullChecks": true
   },

tsconfig-esm.json

@@ -3,7 +3,6 @@
   "compilerOptions": {
     "target": "es6",
     "module": "ESNext",
-    "outDir": "esm",
-    "rootDir": "lib",
+    "outDir": "esm"
   }
 }

tsconfig-karma.json

@@ -4,6 +4,5 @@
     "target": "es5",
     "module": "commonjs",
     "outDir": "es5",
-    "rootDir": "lib",
   }
 }