@webex/test-users 3.0.0-beta.2 → 3.0.0-beta.200

package/src/index.js

@@ -24,7 +24,7 @@ function fixToken(token) {
   }
 
   if (token.refresh_token_expires_in && !token.refresh_token_expires) {
-  /* eslint camelcase: [0] */
+    /* eslint camelcase: [0] */
     token.refresh_token_expires = now + token.refresh_token_expires_in * 1000;
   }
 
@@ -61,14 +61,14 @@ function getClientCredentials({clientId, clientSecret, idbrokerUrl}) {
       grant_type: 'client_credentials',
       scope: 'Identity:SCIM webexsquare:get_conversation',
       client_id: clientId,
-      client_secret: clientSecret
+      client_secret: clientSecret,
     },
     headers: {
       // Note: we can't request's auth hash here because this endpoint expects
       // us to send the auth header *without including "Basic "* before the
       // token string
-      authorization: btoa(`${clientId}:${clientSecret}`)
-    }
+      authorization: btoa(`${clientId}:${clientSecret}`),
+    },
   })
     .then((res) => {
       const token = fixToken(res.body);
@@ -93,13 +93,12 @@ function getClientCredentials({clientId, clientSecret, idbrokerUrl}) {
  * @returns {Promise<HttpResponseObject>}
  */
 function requestWithAuth(options) {
-  return getClientCredentials(options.body)
-    .then((authorization) => {
-      options.headers = options.headers || {};
-      options.headers.authorization = authorization;
+  return getClientCredentials(options.body).then((authorization) => {
+    options.headers = options.headers || {};
+    options.headers.authorization = authorization;
 
-      return request(options);
-    });
+    return request(options);
+  });
 }
 
 /**
@@ -132,20 +131,20 @@ function requestWithAuth(options) {
  */
 
 /**
-  * @typedef {Object} TestUserObject
-  * @property {string} password
-  * @property {string} emailAddress
-  * @property {string} displayName
-  * @property {string} id
-  * @property {string} userName
-  * @property {string} email
-  * @property {string} name
-  * @property {string} givenName
-  * @property {string} type
-  * @property {Array.<string>} entitlements
-  * @property {string} orgId
-  * @property {AccessTokenObject} token
-  */
+ * @typedef {Object} TestUserObject
+ * @property {string} password
+ * @property {string} emailAddress
+ * @property {string} displayName
+ * @property {string} id
+ * @property {string} userName
+ * @property {string} email
+ * @property {string} name
+ * @property {string} givenName
+ * @property {string} type
+ * @property {Array.<string>} entitlements
+ * @property {string} orgId
+ * @property {AccessTokenObject} token
+ */
 
 /**
  * Creates a test user
@@ -156,7 +155,10 @@ export function createTestUser(options = {}) {
   const clientId = options.clientId || process.env.WEBEX_CLIENT_ID;
   const clientSecret = options.clientSecret || process.env.WEBEX_CLIENT_SECRET;
   const idbrokerUrl = options.idbrokerUrl || process.env.IDBROKER_BASE_URL;
-  const cigServiceUrl = options.cigServiceUrl || process.env.WEBEX_TEST_USERS_CI_GATEWAY_SERVICE_URL || process.env.WEBEX_TEST_USERS_CONVERSATION_SERVICE_URL;
+  const cigServiceUrl =
+    options.cigServiceUrl ||
+    process.env.WEBEX_TEST_USERS_CI_GATEWAY_SERVICE_URL ||
+    process.env.WEBEX_TEST_USERS_CONVERSATION_SERVICE_URL;
 
   if (!clientId) {
     throw new Error('options.clientId or process.env.WEBEX_CLIENT_ID must be defined');
@@ -171,7 +173,9 @@ export function createTestUser(options = {}) {
   }
 
   if (!cigServiceUrl) {
-    throw new Error('options.cigServiceUrl or process.env.WEBEX_TEST_USERS_CI_GATEWAY_SERVICE_URL must be defined');
+    throw new Error(
+      'options.cigServiceUrl or process.env.WEBEX_TEST_USERS_CI_GATEWAY_SERVICE_URL must be defined'
+    );
   }
 
   const body = {
@@ -185,7 +189,8 @@ export function createTestUser(options = {}) {
       'squaredCallInitiation',
       'squaredRoomModeration',
       'squaredInviter',
-      'webExSquared'
+      'webExSquared',
+      'basicMessage',
     ],
     idbrokerUrl,
     machineType: options.machineType,
@@ -194,20 +199,21 @@ export function createTestUser(options = {}) {
     password: options.password || `${uuid.v4()}zAY1*`,
     roles: options.roles || [],
     scopes: options.scope || process.env.WEBEX_SCOPE,
-    type: options.type
+    type: options.type,
   };
 
   return requestWithAuth({
     method: 'POST',
     uri: `${cigServiceUrl}${BASE_PATH_SECURE}`,
     json: true,
-    body
-  })
-    .then((res) => Object.assign({
-      password: body.password,
-      emailAddress: res.body.user.email,
-      displayName: res.body.user.name
-    }, res.body.user, {token: fixToken(res.body.token)}));
+    body,
+  }).then((res) => ({
+    password: body.password,
+    emailAddress: res.body.user.email,
+    displayName: res.body.user.name,
+    ...res.body.user,
+    token: fixToken(res.body.token),
+  }));
 }
 
 /**
@@ -224,7 +230,10 @@ export function createTestUser(options = {}) {
 export function loginTestUser(options) {
   const clientId = options.clientId || process.env.WEBEX_CLIENT_ID;
   const clientSecret = options.clientSecret || process.env.WEBEX_CLIENT_SECRET;
-  const cigServiceUrl = options.cigServiceUrl || process.env.WEBEX_TEST_USERS_CI_GATEWAY_SERVICE_URL || process.env.WEBEX_TEST_USERS_CONVERSATION_SERVICE_URL;
+  const cigServiceUrl =
+    options.cigServiceUrl ||
+    process.env.WEBEX_TEST_USERS_CI_GATEWAY_SERVICE_URL ||
+    process.env.WEBEX_TEST_USERS_CONVERSATION_SERVICE_URL;
 
   if (!clientId) {
     throw new Error('options.clientId or process.env.WEBEX_CLIENT_ID must be defined');
@@ -235,7 +244,9 @@ export function loginTestUser(options) {
   }
 
   if (!cigServiceUrl) {
-    throw new Error('options.cigServiceUrl or process.env.WEBEX_TEST_USERS_CI_GATEWAY_SERVICE_URL must be defined');
+    throw new Error(
+      'options.cigServiceUrl or process.env.WEBEX_TEST_USERS_CI_GATEWAY_SERVICE_URL must be defined'
+    );
   }
 
   return request({
@@ -244,10 +255,9 @@ export function loginTestUser(options) {
     json: true,
     body: _.defaultsDeep(options, {
       clientId,
-      clientSecret
-    })
-  })
-    .then((res) => fixToken(res.body));
+      clientSecret,
+    }),
+  }).then((res) => fixToken(res.body));
 }
 
 /**
@@ -261,10 +271,15 @@ export function loginTestUser(options) {
  * @returns {Promise}
  */
 export function removeTestUser(options = {}) {
-  const cigServiceUrl = options.cigServiceUrl || process.env.WEBEX_TEST_USERS_CI_GATEWAY_SERVICE_URL || process.env.WEBEX_TEST_USERS_CONVERSATION_SERVICE_URL;
+  const cigServiceUrl =
+    options.cigServiceUrl ||
+    process.env.WEBEX_TEST_USERS_CI_GATEWAY_SERVICE_URL ||
+    process.env.WEBEX_TEST_USERS_CONVERSATION_SERVICE_URL;
 
   if (!cigServiceUrl) {
-    throw new Error('options.cigServiceUrl or process.env.WEBEX_TEST_USERS_CI_GATEWAY_SERVICE_URL must be defined');
+    throw new Error(
+      'options.cigServiceUrl or process.env.WEBEX_TEST_USERS_CI_GATEWAY_SERVICE_URL must be defined'
+    );
   }
 
   if (!options.id) {
@@ -272,12 +287,11 @@ export function removeTestUser(options = {}) {
   }
 
   if (!options.token) {
-    return loginTestUser(options)
-      .then((token) => {
-        options.token = token;
+    return loginTestUser(options).then((token) => {
+      options.token = token;
 
-        return removeTestUser(options);
-      });
+      return removeTestUser(options);
+    });
   }
 
   assert(options.token.authorization, 'options.token.authorization must be defined');
@@ -286,20 +300,20 @@ export function removeTestUser(options = {}) {
     method: 'POST',
     json: true,
     headers: {
-      authorization: options.token.authorization
+      authorization: options.token.authorization,
     },
     body: {
       /* eslint-disable camelcase */
       user_id: options.id,
       refresh_token: options.token.refresh_token,
-      user_type: options.userType || 'PERSON'
+      user_type: options.userType || 'PERSON',
       /* eslint-enable camelcase */
     },
-    uri: `${cigServiceUrl}${BASE_PATH}/delete`
+    uri: `${cigServiceUrl}${BASE_PATH}/delete`,
   });
 }
 
 export {
   default as createWhistlerTestUser,
-  removeTestUser as removeWhistlerTestUser
+  removeTestUser as removeWhistlerTestUser,
 } from './whistler';

package/src/whistler.js

@@ -1,5 +1,7 @@
 import btoa from 'btoa';
 import {request} from '@webex/http-core';
+import randomName from 'node-random-name';
+import uuid from 'uuid';
 
 /**
  * Fetches credentials/access_token to talk to the whistler endpoint
@@ -20,47 +22,50 @@ const getClientCredentials = ({
   orgId,
   idbrokerUrl,
   machineAccount,
-  machinePassword
-}) => request({
-  method: 'POST',
-  uri: `${idbrokerUrl}/idb/token/${orgId}/v2/actions/GetBearerToken/invoke`,
-  json: true,
-  body: {
-    uid: machineAccount,
-    password: machinePassword
-  }
-})
-  .then((res) => request({
+  machinePassword,
+}) =>
+  request({
     method: 'POST',
-    uri: `${idbrokerUrl}/idb/oauth2/v1/access_token`,
+    uri: `${idbrokerUrl}/idb/token/${orgId}/v2/actions/GetBearerToken/invoke`,
     json: true,
-    form: {
-      assertion: res.body.BearerToken,
-      grant_type: 'urn:ietf:params:oauth:grant-type:saml2-bearer',
-      scope: 'webexsquare:get_conversation webexsquare:admin',
-      self_contained_token: true,
-      client_id: clientId,
-      client_secret: clientSecret
+    body: {
+      uid: machineAccount,
+      password: machinePassword,
     },
-    headers: {
-      // Note: we can't request's auth hash here because this endpoint expects
-      // us to send the auth header *without including "Basic "* before the
-      // token string
-      // authorization: `Basic + ${btoa(`${clientId}:${clientSecret}`)}`
-      authorization: btoa(`${clientId}:${clientSecret}`)
-    }
-  }))
-  .then((res) => `${res.body.token_type} ${res.body.access_token}`);
+  })
+    .then((res) =>
+      request({
+        method: 'POST',
+        uri: `${idbrokerUrl}/idb/oauth2/v1/access_token`,
+        json: true,
+        form: {
+          assertion: res.body.BearerToken,
+          grant_type: 'urn:ietf:params:oauth:grant-type:saml2-bearer',
+          scope: 'webexsquare:get_conversation webexsquare:admin',
+          self_contained_token: true,
+          client_id: clientId,
+          client_secret: clientSecret,
+        },
+        headers: {
+          // Note: we can't request's auth hash here because this endpoint expects
+          // us to send the auth header *without including "Basic "* before the
+          // token string
+          // authorization: `Basic + ${btoa(`${clientId}:${clientSecret}`)}`
+          authorization: btoa(`${clientId}:${clientSecret}`),
+        },
+      })
+    )
+    .then((res) => `${res.body.token_type} ${res.body.access_token}`);
 
 /**
-  * @typedef {Object} TestUserObject
-  * @property {string} password
-  * @property {string} emailAddress
-  * @property {string} displayName
-  * @property {string} token
-  * @property {string} reservationUrl
-  * @property {object} responseMetaData - whistler given properties
-  */
+ * @typedef {Object} TestUserObject
+ * @property {string} password
+ * @property {string} emailAddress
+ * @property {string} displayName
+ * @property {string} token
+ * @property {string} reservationUrl
+ * @property {object} responseMetaData - whistler given properties
+ */
 
 /**
  * @typedef {Object} CreateUserOptions
@@ -82,8 +87,10 @@ const getClientCredentials = ({
 export default function createTestUser(options = {}) {
   const clientId = options.clientId || process.env.WEBEX_CLIENT_ID;
   const clientSecret = options.clientSecret || process.env.WEBEX_CLIENT_SECRET;
-  const machineAccount = options.machineAccount || process.env.WHISTLER_MACHINE_ACCOUNT;
-  const machinePassword = options.machinePassword || process.env.WHISTLER_MACHINE_PASSWORD;
+  const machineAccount =
+    options.machineAccount || process.env.WHISTLER_MACHINE_ACCOUNT || randomName();
+  const machinePassword =
+    options.machinePassword || process.env.WHISTLER_MACHINE_PASSWORD || `${uuid.v4()}zAY1*`;
   const idbrokerUrl = options.idbrokerUrl || process.env.IDBROKER_BASE_URL;
   const orgId = options.orgId || process.env.WHISTLER_TEST_ORG_ID;
   const whistlerServiceUrl = options.whistlerServiceUrl || process.env.WHISTLER_API_SERVICE_URL;
@@ -98,11 +105,15 @@ export default function createTestUser(options = {}) {
   }
 
   if (!machineAccount) {
-    throw new Error('options.machineAccount or process.env.WHISTLER_MACHINE_ACCOUNT must be defined');
+    throw new Error(
+      'options.machineAccount or process.env.WHISTLER_MACHINE_ACCOUNT must be defined'
+    );
   }
 
   if (!machinePassword) {
-    throw new Error('options.machinePassword or process.env.WHISTLER_MACHINE_PASSWORD must be defined');
+    throw new Error(
+      'options.machinePassword or process.env.WHISTLER_MACHINE_PASSWORD must be defined'
+    );
   }
   if (!idbrokerUrl) {
     throw new Error('options.idbrokerUrl or process.env.IDBROKER_BASE_URL must be defined');
@@ -113,7 +124,9 @@ export default function createTestUser(options = {}) {
   }
 
   if (!whistlerServiceUrl) {
-    throw new Error('options.whistlerServiceUrl or process.env.WHISTLER_API_SERVICE_URL must be defined');
+    throw new Error(
+      'options.whistlerServiceUrl or process.env.WHISTLER_API_SERVICE_URL must be defined'
+    );
   }
 
   // For reservation groups and user scopes
@@ -124,27 +137,30 @@ export default function createTestUser(options = {}) {
     machineAccount,
     machinePassword,
     idbrokerUrl,
-    orgId
+    orgId,
   })
-    .then((authorization) => request({
-      method: 'GET',
-      uri: `${whistlerServiceUrl}/reservations/testUser`,
-      qs: {
-        reservationGroup,
-        userScopes,
-        isAccessTokenRequired: true
-      },
-      headers: {
-        authorization
-      }
-    }))
-    .then((res) => Object.assign({
+    .then((authorization) =>
+      request({
+        method: 'GET',
+        uri: `${whistlerServiceUrl}/reservations/testUser`,
+        qs: {
+          reservationGroup,
+          userScopes,
+          isAccessTokenRequired: true,
+        },
+        headers: {
+          authorization,
+        },
+      })
+    )
+    .then((res) => ({
       password: res.body.responseMetaData.ciPassword,
       emailAddress: res.body.responseMetaData.name,
       displayName: res.body.responseMetaData.webExUserName,
       token: res.body.responseMetaData.ciAccessToken,
-      reservationUrl: res.body.reservationUrl
-    }, res.body.responseMetaData));
+      reservationUrl: res.body.reservationUrl,
+      ...res.body.responseMetaData,
+    }));
 }
 
 /**
@@ -156,8 +172,8 @@ export function removeTestUser(options = {}) {
   return request({
     method: 'DELETE',
     headers: {
-      authorization: `Bearer ${options.token}`
+      authorization: `Bearer ${options.token}`,
     },
-    uri: options.reservationUrl
+    uri: options.reservationUrl,
   });
 }

package/test/integration/spec/index.js

@@ -1,4 +1,3 @@
-
 import chai from 'chai';
 import chaiAsPromised from 'chai-as-promised';
 import uuid from 'uuid';
@@ -15,7 +14,10 @@ assert.hasAccessToken = (user) => {
   assert.isDefined(user.token.expires_in, 'user.token.expires_in is defined');
   assert.isDefined(user.token.token_type, 'user.token.token_type is defined');
   assert.isDefined(user.token.refresh_token, 'user.token.refresh_token is defined');
-  assert.isDefined(user.token.refresh_token_expires_in, 'user.token.refresh_token_expires_in is defined');
+  assert.isDefined(
+    user.token.refresh_token_expires_in,
+    'user.token.refresh_token_expires_in is defined'
+  );
   assert.isDefined(user.token.expires, 'user.token.expires is defined');
   assert.isDefined(user.token.refresh_token_expires, 'user.token.refresh_token_expires is defined');
 };
@@ -28,7 +30,10 @@ assert.hasAuthorizationCode = (user) => {
 assert.hasRefreshToken = (user) => {
   assert.isDefined(user.token, 'user.token is defined');
   assert.isDefined(user.token.refresh_token, 'user.token.refresh_token is defined');
-  assert.isDefined(user.token.refresh_token_expires_in, 'user.token.refresh_token_expires_in is defined');
+  assert.isDefined(
+    user.token.refresh_token_expires_in,
+    'user.token.refresh_token_expires_in is defined'
+  );
   assert.isDefined(user.token.refresh_token_expires, 'user.token.refresh_token_expires is defined');
 };
 
@@ -50,7 +55,7 @@ nodeOnly(describe)('test-users', () => {
     return {
       id: user.id,
       email: user.emailAddress || user.email,
-      password: user.password
+      password: user.password,
     };
   }
 
@@ -59,51 +64,53 @@ nodeOnly(describe)('test-users', () => {
 
     return request({
       method: 'POST',
-      uri: `${process.env.IDBROKER_BASE_URL || 'https://idbroker.webex.com'}/idb/oauth2/v1/access_token`,
+      uri: `${
+        process.env.IDBROKER_BASE_URL || 'https://idbroker.webex.com'
+      }/idb/oauth2/v1/access_token`,
       form: {
         /* eslint-disable camelcase */
         grant_type: 'refresh_token',
         redirect_uri: process.env.WEBEX_REDIRECT_URI,
-        refresh_token: user.token.refresh_token
+        refresh_token: user.token.refresh_token,
         /* eslint-enable */
       },
       auth: {
         user: process.env.WEBEX_CLIENT_ID,
-        pass: process.env.WEBEX_CLIENT_SECRET
-      }
+        pass: process.env.WEBEX_CLIENT_SECRET,
+      },
     });
   }
 
   describe('createTestUser()', () => {
-    it('creates a test user', () => createTestUser()
-      .then((u) => {
+    it('creates a test user', () =>
+      createTestUser().then((u) => {
         assert.isTestUser(u);
         assert.hasAccessToken(u);
       }));
 
-    it('creates a test user with a custom email address', () => createTestUser({emailAddress})
-      .then((u) => {
+    it('creates a test user with a custom email address', () =>
+      createTestUser({emailAddress}).then((u) => {
         assert.isTestUser(u);
         assert.hasAccessToken(u);
         assert.equal(u.email, emailAddress);
       }));
 
-    it('creates a test user with a custom password', () => createTestUser({password})
-      .then((u) => {
+    it('creates a test user with a custom password', () =>
+      createTestUser({password}).then((u) => {
         assert.isTestUser(u);
         assert.hasAccessToken(u);
         assert.equal(u.password, password);
       }));
 
-    it('creates a test user with a custom display name', () => createTestUser({displayName})
-      .then((u) => {
+    it('creates a test user with a custom display name', () =>
+      createTestUser({displayName}).then((u) => {
         assert.isTestUser(u);
         assert.hasAccessToken(u);
         assert.equal(u.displayName, displayName);
       }));
 
-    it('creates a test user with a usable refresh token', () => createTestUser({})
-      .then(async (u) => {
+    it('creates a test user with a usable refresh token', () =>
+      createTestUser({}).then(async (u) => {
         assert.isTestUser(u);
         assert.hasAccessToken(u);
 
@@ -112,8 +119,8 @@ nodeOnly(describe)('test-users', () => {
         assert.equal(res.statusCode, 200);
       }));
 
-    it('creates a test user but returns an authorization code', () => createTestUser({authCodeOnly: true})
-      .then((u) => {
+    it('creates a test user but returns an authorization code', () =>
+      createTestUser({authCodeOnly: true}).then((u) => {
         assert.isTestUser(u);
         assert.hasAuthorizationCode(u);
       }));
@@ -121,70 +128,75 @@ nodeOnly(describe)('test-users', () => {
     it('creates a test user in another org', async () => {
       const u = await createTestUser({
         orgId: 'kmsFederation',
-        entitlements: ['webExSquared']
+        entitlements: ['webExSquared'],
       });
 
       assert.isTestUser(u);
       assert.hasAccessToken(u);
     });
 
-    it('creates a machine type test user', () => createTestUser({
-      machineType: 'LYRA_SPACE',
-      type: 'MACHINE'
-    }).then((u) => {
-      assert.isTestUser(u);
-      assert.equal(u.type, 'MACHINE', 'type is MACHINE');
-      assert.equal(u.machineType, 'LYRA_SPACE', 'machineType is LYRA_SPACE');
-    }));
+    it('creates a machine type test user', () =>
+      createTestUser({
+        machineType: 'LYRA_SPACE',
+        type: 'MACHINE',
+      }).then((u) => {
+        assert.isTestUser(u);
+        assert.equal(u.type, 'MACHINE', 'type is MACHINE');
+        assert.equal(u.machineType, 'LYRA_SPACE', 'machineType is LYRA_SPACE');
+      }));
   });
 
   describe('loginTestUser()', () => {
-    it('retrieves credentials for the specified user', () => createTestUser()
-      .then(prune)
-      .then(loginTestUser)
-      .then((token) => {
-        assert.hasAccessToken({token});
-      }));
-
-    it('retrieves credentials with a useable refresh token', () => createTestUser()
-      .then(prune)
-      .then(loginTestUser)
-      .then(async (token) => {
-        assert.hasAccessToken({token});
-        assert.hasRefreshToken({token});
-
-        const res = await refresh({token});
-
-        assert.equal(res.statusCode, 200);
-      }));
+    it('retrieves credentials for the specified user', () =>
+      createTestUser()
+        .then(prune)
+        .then(loginTestUser)
+        .then((token) => {
+          assert.hasAccessToken({token});
+        }));
+
+    it('retrieves credentials with a useable refresh token', () =>
+      createTestUser()
+        .then(prune)
+        .then(loginTestUser)
+        .then(async (token) => {
+          assert.hasAccessToken({token});
+          assert.hasRefreshToken({token});
+
+          const res = await refresh({token});
+
+          assert.equal(res.statusCode, 200);
+        }));
   });
 
   describe('removeTestUser()', () => {
-    it('removes the specified test user', () => createTestUser()
-      .then(async (u) => {
+    it('removes the specified test user', () =>
+      createTestUser().then(async (u) => {
         const res = await removeTestUser(u);
 
         assert.equal(res.statusCode, 204);
       }));
 
-    it('removes a test user if no access token is available', () => createTestUser()
-      .then(prune)
-      .then(async (u) => {
-        const res = await removeTestUser(u);
+    it('removes a test user if no access token is available', () =>
+      createTestUser()
+        .then(prune)
+        .then(async (u) => {
+          const res = await removeTestUser(u);
 
-        assert.equal(res.statusCode, 204);
-      }));
+          assert.equal(res.statusCode, 204);
+        }));
 
-    it('removes a test user with an access token set to undefined', () => createTestUser()
-      .then((user) => {
-        user.token = undefined;
+    it('removes a test user with an access token set to undefined', () =>
+      createTestUser()
+        .then((user) => {
+          user.token = undefined;
 
-        return user;
-      })
-      .then(async (u) => {
-        const res = await removeTestUser(u);
+          return user;
+        })
+        .then(async (u) => {
+          const res = await removeTestUser(u);
 
-        assert.equal(res.statusCode, 204);
-      }));
+          assert.equal(res.statusCode, 204);
+        }));
   });
 });