@mimik/local 1.6.0 → 4.4.2

package/lib/tasks.js

@@ -3,16 +3,23 @@ const fs = require('fs');
 const json = require('comment-json');
 const path = require('path');
 const Promise = require('bluebird');
-const rp = require('request-promise');
 const uuid = require('uuid');
 const _ = require('lodash');
 
-const { getTargets } = require('./commonExt');
+const { rp } = require('./rp-axios-wrapper');
+const { getAllTargets } = require('./commonExt');
 const {
   sumoLogFile,
   s3LogFile,
+  kinesisLogFile,
+  locationFile,
+  keyFile,
   packageFile,
   customerConfigFile,
+  testStartFile,
+  exampleStartFile,
+  exampleTestStartFile,
+  startFile,
   mSTConfigFile,
   mITConfigFile,
   mIDConfigFile,
@@ -21,8 +28,12 @@ const {
   swaggerExt,
   APIProvider,
   correlationId,
+  LITERAL,
   DEFAULT_SUMOLOG,
   DEFAULT_S3LOG,
+  DEFAULT_KINESISLOG,
+  DEFAULT_KEY,
+  DEFAULT_LOCATION,
   DEFAULT_MST,
   DEFAULT_MIT,
   DEFAULT_MID,
@@ -30,29 +41,111 @@ const {
   DUMMY_MIT,
   DUMMY_MID,
   AWS_S3,
+  AWS_KINESIS,
   SUMOLOGIC,
   ALL,
+  NONE,
+  ALL_MODES,
+  SWAGGER_SEP,
+  SYSTEM_NAME,
+  IT_REGISTRY,
+  TOKEN_SERVICE,
+  IDENTITY_SERVICE,
+  TEST,
 } = require('./common');
 const {
   exitError,
+  setDomainName,
   baseUrl,
   retrieve,
 } = require('./helpers');
 
+const getStartParams = (confType) => {
+  let regType = 'Local configuration setup ';
+  let startConfig;
+
+  process.stdout.write(regType);
+  if (confType === TEST) {
+    const test = 'for ' + TEST.info + ' ';
+
+    process.stdout.write(test);
+    regType += test;
+    startConfig = retrieve(regType, testStartFile, { sourceFilename: exampleStartFile, sourceFilenameSupp: exampleTestStartFile });
+  }
+  else {
+    startConfig = retrieve(regType, startFile, { sourceFilename: exampleStartFile });
+  }
+  return {
+    regType,
+    startConfig,
+  };
+};
+
+const init = (regType, standAlone) => {
+  const pack = retrieve(regType, packageFile);
+  const sumoLog = retrieve(regType, sumoLogFile, { default: DEFAULT_SUMOLOG });
+  const s3Log = retrieve(regType, s3LogFile, { default: DEFAULT_S3LOG });
+  const kinesisLog = retrieve(regType, kinesisLogFile, { default: DEFAULT_KINESISLOG });
+  const locationProvider = retrieve(regType, locationFile, { default: DEFAULT_LOCATION });
+  const key = retrieve(regType, keyFile, { default: DEFAULT_KEY });
+
+  console.log('- server type is ' + pack.mimik.type.info);
+  const config = {
+    regType,
+    pack,
+    sumoLog,
+    s3Log,
+    kinesisLog,
+    locationProvider,
+    key,
+  };
+
+  if (pack.mimik.type !== TOKEN_SERVICE && pack.mimik.type !== IT_REGISTRY) config.customer = retrieve(regType, customerConfigFile); // we don't need customer for mST or mIT
+  if (standAlone === 'yes') {
+    config.mST = DUMMY_MST;
+    console.log('- using ' + 'dummy mSTConfig'.warn);
+    config.mIT = DUMMY_MIT;
+    console.log('- using ' + 'dummy mITConfig'.warn);
+    config.mID = DUMMY_MID;
+    console.log('- using ' + 'dummy mIDConfig'.warn);
+  }
+  else {
+    config.mST = retrieve(regType, mSTConfigFile, { default: DEFAULT_MST });
+    config.mIT = retrieve(regType, mITConfigFile, { default: DEFAULT_MIT });
+    config.mID = retrieve(regType, mIDConfigFile, { default: DEFAULT_MID });
+  }
+  config.mSTBaseUrl = baseUrl(TOKEN_SERVICE, regType, config.mST);
+  config.MITBaseUrl = baseUrl(IT_REGISTRY, regType, config.mIT);
+  if (config.mST.domainName === 'localhost') {
+    console.log('- in ' + `${TOKEN_SERVICE} localhost, updating ${TOKEN_SERVICE} is true`.warn);
+    config.mST.update = true;
+  }
+  return config;
+};
+
 const startSetup = (config, origStart) => {
   const start = _.clone(origStart);
   const { regType } = config;
-  const { type } = config.pack;
+  const { type } = config.pack.mimik;
   // basic check
   if (start.standAlone === 'yes') {
     if (start.NODE_ENV !== 'local') exitError(regType, Error('standAlone is only for local environment'));
-    if (type === 'mST') exitError(regType, Error(`standAlone does not apply to ${type}`));
+    if (type === TOKEN_SERVICE) exitError(regType, Error(`standAlone does not apply to ${type}`));
   }
   // references
-  start.MIT_URL = baseUrl('mIT', regType, config.mIT);
-  start.MST_URL = baseUrl('mST', regType, config.mST);
+  start.MIT_URL = baseUrl(IT_REGISTRY, regType, config.mIT);
+  start.MST_URL = baseUrl(TOKEN_SERVICE, regType, config.mST);
   // logs
-  if (!start.LOG_MODE || start.LOG_MODE === SUMOLOGIC || start.LOG_MODE === ALL) {
+  let logMode = null;
+
+  if (start.LOG_MODE) {
+    logMode = _.split(_.trim(start.LOG_MODE), /\s*,\s*/);
+    if (logMode.length === 0) exitError(regType, 'Invalid LOG_MODE: cannot be an empty array');
+    if (_.difference(logMode, ALL_MODES).length !== 0) exitError(regType, `Invalid items in LOG_MODE: ${logMode}`);
+    if (logMode.includes(NONE) && logMode.length !== 1) throw new Error(`Cannot have multiple modes when ${NONE} is selected`);
+    if (logMode.includes(ALL)) logMode = [SUMOLOGIC, AWS_S3]; // legacy support
+  }
+  if (!logMode || logMode.includes(SUMOLOGIC)) {
     let sumoLog = config.sumoLog[type];
 
     if (!sumoLog) {
@@ -63,7 +156,7 @@ const startSetup = (config, origStart) => {
     start.SUMO_LOGIC_ENDPOINT = start.SUMO_LOGIC_ENDPOINT || sumoLog.url;
     start.SUMO_LOGIC_COLLECTOR_CODE = start.SUMO_LOGIC_COLLECTOR_CODE || sumoLog.code;
   }
-  if (start.LOG_MODE === AWS_S3 || start.LOG_MODE === ALL) {
+  if (logMode && logMode.includes(AWS_S3)) {
     const { s3Log } = config;
 
     start.S3_AWS_ACCESS_KEY_ID = start.S3_AWS_ACCESS_KEY_ID || s3Log.accessKeyId;
@@ -74,20 +167,32 @@ const startSetup = (config, origStart) => {
     start.S3_AWS_TIMEOUT = start.S3_AWS_TIMEOUT || s3Log.timeout;
     start.S3_AWS_MAX_SIZE = start.S3_AWS_MAX_SIZE || s3Log.maxSize;
   }
+  if (logMode && logMode.includes(AWS_KINESIS)) {
+    const { kinesisLog } = config;
+
+    start.KINESIS_AWS_ACCESS_KEY_ID = start.KINESIS_AWS_ACCESS_KEY_ID || kinesisLog.accessKeyId;
+    start.KINESIS_AWS_REGION = start.KINESIS_AWS_REGION || kinesisLog.region;
+    start.KINESIS_AWS_SECRET_ACCESS_KEY = start.KINESIS_AWS_SECRET_ACCESS_KEY || kinesisLog.secretAccessKey;
+    start.KINESIS_AWS_STREAM_NAME_INFO = start.KINESIS_AWS_STREAM_NAME_INFO || kinesisLog.streamNameInfo;
+    start.KINESIS_AWS_STREAM_NAME_ERROR = start.KINESIS_AWS_STREAM_NAME_ERROR || kinesisLog.streamNameError;
+    start.KINESIS_AWS_STREAM_NAME_OTHER = start.KINESIS_AWS_STREAM_NAME_OTHER || kinesisLog.streamNameOther;
+  }
   // server basics
   start.SERVER_TYPE = type;
   start.SERVER_ID = start.SERVER_ID || uuid.v4();
+  // passphrase to be shared to all the servers
+  if (config.mST.passphrase) start.PASSPHRASE = config.mST.passphrase;
   // oauth issuer full address
-  start.OAUTH_ISSUER = `${baseUrl('mST', regType, config.mST)}/oauth/token`;
+  start.OAUTH_ISSUER = `${baseUrl(TOKEN_SERVICE, regType, config.mST, LITERAL)}/oauth/token`;
   // setting admin
-  start.ADMIN_EXTERNAL_ID = `admin_${config.customer ? config.customer.name : 'System'}_${start.NODE_ENV}_${type}`;
+  start.ADMIN_EXTERNAL_ID = `admin_${config.customer ? config.customer.name : SYSTEM_NAME}_${start.NODE_ENV}_${type}`;
   // setting up dummy variables which will be updating by mST seeding
   start.OAUTH_CLIENT_ID = '--noId--';
   start.OAUTH_CLIENT_SECRET = '--noSecret--';
   start.OAUTH_CLIENT_ACCESS_KEY = '--noKey--';
   start.OAUTH_CLIENT_AUDIENCE = '--noAudience--';
   // specific to mST
-  if (type === 'mST') {
+  if (type === TOKEN_SERVICE) {
     // use the port from config
     start.SERVER_PORT = config.mST.port;
     // setting admin
@@ -96,27 +201,35 @@ const startSetup = (config, origStart) => {
     // default audience
     start.MIT_AUDIENCE = '--noAudience--';
     start.MST_AUDIENCE = '--noAudience--';
+    // setting public address for platform independence
+    start.SERVER_PUBLIC_DOMAIN_NAME = setDomainName(type, regType, config.mST.domainName, config.mST.port, LITERAL);
+    start.SERVER_PUBLIC_PROTOCOL = config.mST.protocol;
   }
   // specific to mID
-  if (type === 'mID') {
+  if (type === IDENTITY_SERVICE) {
     start.SERVER_PORT = config.mID.port;
     // setting url
-    start.MID_URL = baseUrl('mID', regType, config.mID);
+    start.MID_URL = baseUrl(IDENTITY_SERVICE, regType, config.mID);
   }
-  if (type === 'mIT') {
+  if (type === IT_REGISTRY) {
     start.SERVER_PORT = config.mIT.port;
   }
   // specific to servers that need to handle user token and mID
-  if (start.oauthImplicitNeeded === 'yes' || type === 'mID') {
+  if (start.oauthImplicitNeeded === 'yes' || type === IDENTITY_SERVICE) {
     delete start.oauthImplicitNeeded;
     start.OAUTH_IMPLICIT_AUDIENCE = config.mID.implicit.audience;
     start.OAUTH_IMPLICIT_KEY = config.mID.implicit.key;
-    start.OAUTH_IMPLICIT_ISSUER = `${baseUrl('mID', regType, config.mID)}/oauth/token`;
+    start.OAUTH_IMPLICIT_ISSUER = `${baseUrl(IDENTITY_SERVICE, regType, config.mID, LITERAL)}/oauth/token`;
   }
   // specific to servers than need to interact with mID
   if (start.mIDNeeded === 'yes') {
     delete start.mIDNeeded;
-    start.MID_URL = baseUrl('mID', regType, config.mID);
+    start.MID_URL = baseUrl(IDENTITY_SERVICE, regType, config.mID);
+  }
+  if (start.locationNeeded === 'yes' && config.locationProvider.url) {
+    delete start.locationNeeded;
+    start.LOCATION_PROVIDER = config.locationProvider.url;
+    if (config.locationProvider.key) start.LOCATION_PROVIDER_KEY = config.locationProvider.key;
   }
 
   return start;
@@ -129,16 +242,17 @@ const startSetup = (config, origStart) => {
  * @function getAPI
  * @category async
  * @param {PATH<string>} directory - Directory to store the API file.
- * @param {string} name - Name of the API to retrieve. The name is made of a `(customer)`_`(API name)`.
+ * @param {string} account - Account of the API API to retrieve.
+ * @param {string} type - Type of microservice associated with the API to retrieve.
  * @param {SEMVER<string>} version - Version fo the API to retrieve.
+ * @param {string} apiKey - key to access private API.
  * @return {Promise}.
  * @fulfil {object} The API file itself.
  * @throws {Promise} An error containing the reason of the failure.
  *
  * The directory will be created if it does not exist.
  */
-const getAPI = (directory, name, version) => {
-  const params = name.split('_');
+const getAPI = (directory, account, type, version, apiKey) => {
   const fileExists = (fname) => {
     try { fs.statSync(fname); }
     catch (err) { return false; }
@@ -153,7 +267,7 @@ const getAPI = (directory, name, version) => {
       return Promise.reject(err);
     }
   }
-  const filename = path.join(directory, `${name}_${version}_${swaggerExt}`);
+  const filename = path.join(directory, `${account}${SWAGGER_SEP}${type}${SWAGGER_SEP}${version}${SWAGGER_SEP}${swaggerExt}`);
 
   if (fileExists(filename)) {
     let result;
@@ -163,53 +277,96 @@ const getAPI = (directory, name, version) => {
     catch (errRead) { return Promise.reject(errRead); }
     return Promise.resolve(result);
   }
-  const url = `${APIProvider}/${params[0]}/${params[1]}/${version}`;
+  const url = `${APIProvider}/${account}/${type}/${version}`;
 
   process.stdout.write(' at (' + `${url}`.info + '): ');
-  return rp({
+  const options = {
     method: 'GET',
     url,
-    json: true,
-  }).catch((err) => {
-    console.log(ERR_CHECK.error);
-    throw err;
-  }).then((result) => {
-    try { fs.writeFileSync(filename, json.stringify(result, null, 2)); }
-    catch (err) {
+  };
+
+  if (apiKey) options.headers = { Authorization: apiKey };
+  return rp(options)
+    .catch((err) => {
       console.log(ERR_CHECK.error);
       throw err;
-    }
-    console.log(SUCCESS_CHECK.success);
-    return result;
-  });
+    })
+    .then((result) => {
+      try { fs.writeFileSync(filename, json.stringify(result, null, 2)); }
+      catch (err) {
+        console.log(ERR_CHECK.error);
+        throw err;
+      }
+      console.log(SUCCESS_CHECK.success);
+      return result;
+    });
+};
+
+const gettingSystemCustomer = (authorization, mSTbaseUrl) => {
+  process.stdout.write('- getting customer (' + SYSTEM_NAME.info + '): ');
+  return rp({
+    method: 'GET',
+    headers: { authorization, 'x-correlation-id': correlationId },
+    url: `${mSTbaseUrl}/customers/${SYSTEM_NAME}`,
+  })
+    .then((responseGET) => {
+      console.log(SUCCESS_CHECK.success);
+      return responseGET.data;
+    })
+    .catch((err) => {
+      console.log(ERR_CHECK.error);
+      throw err;
+    });
 };
 
 const settingUpCustomer = (customer, authorization, mSTbaseUrl, update) => {
   process.stdout.write('- setting up customer (' + `${customer.name}`.info + '): ');
+
+  let isNewCustomer;
+
   return rp({
-    method: 'POST',
+    method: 'GET',
     headers: { authorization, 'x-correlation-id': correlationId },
-    url: `${mSTbaseUrl}/customers`,
-    json: customer,
+    url: `${mSTbaseUrl}/customers/${customer.name}`,
   })
-    .then(() => console.log(SUCCESS_CHECK.success))
     .catch((err) => {
-      if (err.statusCode !== 409) {
+      if (err.statusCode !== 404) {
         console.log(ERR_CHECK.error);
         throw err;
       }
+
+      isNewCustomer = true;
+      console.log('creating new customer'.info);
+      return rp({
+        method: 'POST',
+        headers: { authorization, 'x-correlation-id': correlationId },
+        url: `${mSTbaseUrl}/customers`,
+        data: customer,
+      })
+        .catch((error) => {
+          console.log(ERR_CHECK.error);
+          throw error;
+        });
+    })
+    .then((response) => {
+      if (isNewCustomer) return response.data;
+
       if (!update) {
-        console.log('already setup and update is false in mSTConfig.json, not updating'.warn);
-        return null;
+        console.log('already setup and update is false in mSTConfig.json, not updating'.info);
+        return response.data;
       }
-      process.stdout.write('already setup, updating: '.warn);
+
+      console.log('already setup and update is true in mSTConfig.json, updating'.info);
       return rp({
         method: 'PUT',
         headers: { authorization, 'x-correlation-id': correlationId },
         url: `${mSTbaseUrl}/customers/${customer.name}`,
-        json: customer,
+        data: customer,
       })
-        .then(() => console.log(SUCCESS_CHECK.success))
+        .then((responsePUT) => {
+          console.log(SUCCESS_CHECK.success);
+          return responsePUT.data;
+        })
         .catch((errPUT) => {
           console.log(ERR_CHECK.error);
           throw errPUT;
@@ -223,7 +380,7 @@ const settingUpServer = (serverType, serverId, customer, authorization, mSTbaseU
     method: 'POST',
     url: `${mSTbaseUrl}/clients`,
     headers: { authorization, 'x-correlation-id': correlationId },
-    json: {
+    data: {
       externalId: serverId,
       type: serverType,
       customerName: customer.name,
@@ -262,49 +419,18 @@ const settingUpDummyServer = (serverType, serverId, customer, origStart) => {
 
   updatedStart.OAUTH_GENERIC_KEY = 'a-secret-key-for-generic';
   updatedStart.OAUTH_GENERIC_AUDIENCE = `http://dummy-${serverType}-generic-audience`;
-  getTargets(serverType, customer.config).forEach((target) => {
-    updatedStart[`${target.toUpperCase()}_URL`] = `http://dummy-${target}/dummy`;
-    updatedStart[`${target.toUpperCase()}_AUDIENCE`] = `http://dummy-${target}-audience`;
-  });
-  console.log(SUCCESS_CHECK.success);
-  return updatedStart;
-};
-
-const init = (regType, standAlone) => {
-  const pack = retrieve(regType, packageFile);
-  const sumoLog = retrieve(regType, sumoLogFile, { default: DEFAULT_SUMOLOG });
-  const s3Log = retrieve(regType, s3LogFile, { default: DEFAULT_S3LOG });
-
-  console.log('- server type is ' + pack.type.info);
-  const config = {
-    regType,
-    pack,
-    sumoLog,
-    s3Log,
-  };
-  if (pack.type !== 'mST') config.customer = retrieve(regType, customerConfigFile); // we don't need customer for mST
-
-
-  if (standAlone === 'yes') {
-    config.mST = DUMMY_MST;
-    console.log('- using ' + 'dummy mSTConfig'.warn);
-    config.mIT = DUMMY_MIT;
-    console.log('- using ' + 'dummy mITConfig'.warn);
-    config.mID = DUMMY_MID;
-    console.log('- using ' + 'dummy mIDConfig'.warn);
+  if (!customer) { // mIT case
+    updatedStart[`${serverType.toUpperCase()}_URL`] = `http://dummy-${serverType}/dummy`;
+    updatedStart[`${serverType.toUpperCase()}_AUDIENCE`] = `http://dummy-${serverType}-audience`;
   }
   else {
-    config.mST = retrieve(regType, mSTConfigFile, { default: DEFAULT_MST });
-    config.mIT = retrieve(regType, mITConfigFile, { default: DEFAULT_MIT });
-    config.mID = retrieve(regType, mIDConfigFile, { default: DEFAULT_MID });
-  }
-  config.mSTBaseUrl = baseUrl('mST', regType, config.mST);
-  config.MITBaseUrl = baseUrl('mIT', regType, config.mIT);
-  if (config.mST.domainName === 'localhost') {
-    console.log('- in ' + 'mST localhost, updating mST is true'.warn);
-    config.mST.update = true;
+    getAllTargets(serverType, customer.config).forEach((target) => {
+      updatedStart[`${target.type.toUpperCase()}_URL`] = `http://dummy-${target.type}/dummy`;
+      updatedStart[`${target.type.toUpperCase()}_AUDIENCE`] = `http://dummy-${target.type}-audience`;
+    });
   }
-  return config;
+  console.log(SUCCESS_CHECK.success);
+  return updatedStart;
 };
 
 const settingUpAdminClient = (serverType, adminExternalId, customer, authorization, mSTbaseUrl) => {
@@ -313,14 +439,14 @@ const settingUpAdminClient = (serverType, adminExternalId, customer, authorizati
     method: 'POST',
     url: `${mSTbaseUrl}/clients`,
     headers: { authorization, 'x-correlation-id': correlationId },
-    json: {
+    data: {
       externalId: adminExternalId,
       type: 'admin',
       customerName: customer.name,
     },
   }).then((resultPOST) => {
     console.log(SUCCESS_CHECK.success);
-    return resultPOST.data;
+    return resultPOST;
   }).catch((err) => {
     if (err.statusCode !== 409) {
       console.log(ERR_CHECK.error);
@@ -330,7 +456,6 @@ const settingUpAdminClient = (serverType, adminExternalId, customer, authorizati
       method: 'GET',
       url: `${mSTbaseUrl}/clients/${adminExternalId}`,
       headers: { authorization, 'x-correlation-id': correlationId },
-      json: true,
     }).catch((errGET) => {
       console.log(ERR_CHECK.error);
       throw errGET;
@@ -340,21 +465,25 @@ const settingUpAdminClient = (serverType, adminExternalId, customer, authorizati
         throw new Error(`customer name conflict, admin cannot use externalId: ${adminExternalId}`);
       }
       console.log('already setup'.warn);
-      return resultGET.data;
+      return resultGET;
     });
   });
 };
 
-const getAdminToken = (serverType, admin, mSTbaseUrl) => {
-  process.stdout.write('- getting admin token for ' + serverType.info + ': ');
+const getAdminToken = (audienceType, admin, mSTbaseUrl) => {
+  process.stdout.write('- getting admin token for ' + audienceType.type.info + ': ');
+  if (!audienceType.audience) {
+    console.log(ERR_CHECK.error);
+    return Promise.reject(new Error(`no audience for ${audienceType.type}`));
+  }
   return rp({
     method: 'POST',
     headers: { 'x-correlation-id': correlationId },
     url: `${mSTbaseUrl}/oauth/token`,
-    json: {
+    data: {
       client_id: admin.id,
       client_secret: admin.secret,
-      audience: `${mSTbaseUrl}/clients/Generic-${serverType}`,
+      audience: `${audienceType.audience.split('Generic-')[0]}Generic-${audienceType.type}`,
       grant_type: 'client_credentials',
     },
   }).catch((err) => {
@@ -367,12 +496,14 @@ const getAdminToken = (serverType, admin, mSTbaseUrl) => {
 };
 
 module.exports = {
+  getStartParams,
+  init,
   startSetup,
   getAPI,
+  gettingSystemCustomer,
   settingUpCustomer,
   settingUpServer,
   settingUpDummyServer,
-  init,
   settingUpAdminClient,
   getAdminToken,
 };

package/manual-test/getAPI.js

@@ -1,3 +1,3 @@
 const start = require('../index');
 
-return start.getAPI('./testing', 'mimik_mDS', '1.1.1')
+return start.getAPI('./testing', 'mimik', 'mDS', '1.1.1')

package/manual-test/retrieve.js

@@ -1,5 +1,7 @@
-const start = require('../index');
+const { retrieve }= require('../lib/helpers');
 
-console.log(start.retrieve('test', 'orig.json', 'source.json'));
+// console.log(retrieve('test', 'test.json', { sourceFilename: './start-example.json', sourceFilenameSupp: 'startTest-example.json' } ));
 
-// console.log(start.retrieve('test', 'alt.json', 'source.json', 'orig.json'));
+// console.log(retrieve('test', 'test.json'));
+// console.log(retrieve('test', 'test.json', { sourceFilename: './nonexistent.json', sourceFilenameSupp: 'startTest-example.json' }));
+console.log(retrieve('test', 'test.json', { sourceFilename: './start-example.json' } ));

package/manual-test/start-example.json

@@ -0,0 +1,46 @@
+{
+    // "SERVER_ID": "mST-12345",
+    // "DEBUG": "swagger-tools:middleware.*",
+    // -- logs
+    "LOG_LEVEL": "info",
+    "CONSOLE_LEVEL": "debug",
+    "NO_STACK": "yes",
+    // "LOG_MODE": "all",
+    // "LOG_MODE": "awsS3",
+    "LOG_MODE": "sumologic",
+    // -- providers
+    // "LOCATION_PROVIDER": "http://ip-api.com/json",
+    // "LOCATION_PROVIDER_KEY": "---a key---",
+    // "CLOUD_PROVIDER": "AWS",
+    // -- server public address
+    // "SERVER_PUBLIC_DOMAIN_NAME": "mst.mimik360.com",
+    // "SERVER_PUBLIC_PROTOCOL": "https:",
+    // -- database
+    "DATABASE_NAME": "tokens",
+    "MONGO_MAX_POOL_SIZE": 60,
+    // "MONGO_REPLICAT_SET": "test",
+    // "DATABASE_IP": "localhost:27018,localhost:27019,localhost:27020",
+    // -- specific parameters
+    "OAUTH_ACCESS_TOKEN_EXPIRE": "24h",
+    "OAUTH_REFRESH_TOKEN_EXPIRE": "30d",
+    // "PASSPHRASE": "This is a passphrase",
+    // "MST_STANDALONE_SET": "off"
+    // "SUB_MST_SET": "off"
+    // information retriveved from super mST client registration
+    // "OAUTH_SUB_CLIENT_ID": "a sub client id",
+    // "OAUTH_SUB_CLIENT_SECRET": "a sub client secret",
+    // "OAUTH_SUB_CLIENT_ACCESS_KEY": "a sub client access key",
+    // "OAUTH_SUB_CLIENT_AUDIENCE": "a sub client audience",
+    // "OAUTH_SUB_ISSUER": "sub client token issuer",
+    // "OAUTH_SUB_GENERIC_KEY": "a sub client generic key",
+    // "OAUTH_SUB_GENERIC_AUDIENCE": "a sub client geneic audience",
+    // "SUPER_MST_AUDIENCE": "the super mST audience ",
+    // "SUB_MST_AUDIENCE": "the sub mST audience",
+    // information to be provided
+    // "SUPER_MST_URL": "url of super mST",
+    // -- security
+    // "SERVER_SECURITY_SET": "off",
+    // -- environment
+    // "REGISTRATION_RETRY": 200000,
+    "NODE_ENV": "local"
+}

package/manual-test/startTest-example.json

@@ -0,0 +1,8 @@
+{
+    "CONSOLE_LEVEL": "info",
+    "NO_STACK": "no",
+    "LOG_MODE": "all",
+    // Required by @mimik/test-helper if USE_MOCK_PROFILES is "no":
+    // "MST_TOKEN": "mST-token",
+    "USE_MOCK_PROFILES": "yes"
+}

package/manual-test/test.json

@@ -0,0 +1,46 @@
+{
+  // "SERVER_ID": "mST-12345",
+  // "DEBUG": "swagger-tools:middleware.*",
+  // -- logs
+  "LOG_LEVEL": "info",
+  "CONSOLE_LEVEL": "debug",
+  "NO_STACK": "yes",
+  // "LOG_MODE": "all",
+  // "LOG_MODE": "awsS3",
+  "LOG_MODE": "sumologic",
+  // -- providers
+  // "LOCATION_PROVIDER": "http://ip-api.com/json",
+  // "LOCATION_PROVIDER_KEY": "---a key---",
+  // "CLOUD_PROVIDER": "AWS",
+  // -- server public address
+  // "SERVER_PUBLIC_DOMAIN_NAME": "mst.mimik360.com",
+  // "SERVER_PUBLIC_PROTOCOL": "https:",
+  // -- database
+  "DATABASE_NAME": "tokens",
+  "MONGO_MAX_POOL_SIZE": 60,
+  // "MONGO_REPLICAT_SET": "test",
+  // "DATABASE_IP": "localhost:27018,localhost:27019,localhost:27020",
+  // -- specific parameters
+  "OAUTH_ACCESS_TOKEN_EXPIRE": "24h",
+  "OAUTH_REFRESH_TOKEN_EXPIRE": "30d",
+  // "PASSPHRASE": "This is a passphrase",
+  // "MST_STANDALONE_SET": "off"
+  // "SUB_MST_SET": "off"
+  // information retriveved from super mST client registration
+  // "OAUTH_SUB_CLIENT_ID": "a sub client id",
+  // "OAUTH_SUB_CLIENT_SECRET": "a sub client secret",
+  // "OAUTH_SUB_CLIENT_ACCESS_KEY": "a sub client access key",
+  // "OAUTH_SUB_CLIENT_AUDIENCE": "a sub client audience",
+  // "OAUTH_SUB_ISSUER": "sub client token issuer",
+  // "OAUTH_SUB_GENERIC_KEY": "a sub client generic key",
+  // "OAUTH_SUB_GENERIC_AUDIENCE": "a sub client geneic audience",
+  // "SUPER_MST_AUDIENCE": "the super mST audience ",
+  // "SUB_MST_AUDIENCE": "the sub mST audience",
+  // information to be provided
+  // "SUPER_MST_URL": "url of super mST",
+  // -- security
+  // "SERVER_SECURITY_SET": "off",
+  // -- environment
+  // "REGISTRATION_RETRY": 200000,
+  "NODE_ENV": "local"
+}