prepare 6.3.1 release

.circleci/config.yml

@@ -41,6 +41,9 @@ jobs:
         default: false
       docker-image:
         type: string
+      run-contract-tests:
+        type: boolean
+        default: true
     docker:
       - image: <<parameters.docker-image>>
     steps:
@@ -56,6 +59,14 @@ jobs:
           condition: <<parameters.run-lint>>
           steps:
             - run: npm run lint
+      - when:
+          condition: <<parameters.run-contract-tests>>
+          steps:
+            - run:
+                command: npm run contract-test-service
+                background: true
+            - run: mkdir -p reports/junit
+            - run: TEST_HARNESS_PARAMS="-junit reports/junit/contract-test-results.xml -skip-from contract-tests/testharness-suppressions.txt" npm run contract-test-harness
       - run:
           name: dependency audit
           command: ./scripts/better-audit.sh

.gitignore

@@ -1,7 +1,7 @@
 package-lock.json
 /docs/build/
 /local/
-/node_modules/
+**/node_modules/
 junit.xml
 npm-debug.log
 test-types.js

configuration.js

@@ -31,7 +31,7 @@ module.exports = (function () {
   const typesForPropertiesWithNoDefault = {
     // Add a value here if we add a configuration property whose type cannot be determined by looking
     // in baseDefaults (for instance, the default is null but if the value isn't null it should be a
-    // string). The allowable values are 'boolean', 'string', 'number', 'object', 'function', or
+    // string). The allowable values are 'boolean', 'string', 'number', 'object', 'function', 'array' or
     // 'factory' (the last one means it can be either a function or an object).
     bigSegments: 'object',
     eventProcessor: 'object',
@@ -48,6 +48,42 @@ module.exports = (function () {
     wrapperVersion: 'string',
   };
 
+  /**
+   * Expression to validate characters that are allowed in tag keys and values.
+   */
+  const allowedTagCharacters = /^(\w|\.|-)+$/;
+
+  /**
+   * Verify that a value meets the requirements for a tag value.
+   * @param {Object} config
+   * @param {string} tagValue
+   */
+  function validateTagValue(name, config, tagValue) {
+    if (typeof tagValue !== 'string' || !tagValue.match(allowedTagCharacters)) {
+      config.logger.warn(messages.invalidTagValue(name));
+      return undefined;
+    }
+    return tagValue;
+  }
+
+  const optionsWithValidatorsOrConversions = {
+    // Add a value here if we add a configuration property which requires custom validation
+    // and/or type conversion.
+    // The validator should log a message for any validation issues encountered.
+    // The validator should return undefined, or the validated value.
+
+    application: (name, config, value) => {
+      const validated = {};
+      if (value.id) {
+        validated.id = validateTagValue(`${name}.id`, config, value.id);
+      }
+      if (value.version) {
+        validated.version = validateTagValue(`${name}.version`, config, value.version);
+      }
+      return validated;
+    },
+  };
+
   /* eslint-disable camelcase */
   const deprecatedOptions = {};
   /* eslint-enable camelcase */
@@ -102,8 +138,16 @@ module.exports = (function () {
       if (value !== null && value !== undefined) {
         const defaultValue = defaultConfig[name];
         const typeDesc = typesForPropertiesWithNoDefault[name];
-        if (defaultValue === undefined && typeDesc === undefined) {
+        const validator = optionsWithValidatorsOrConversions[name];
+        if (defaultValue === undefined && typeDesc === undefined && validator === undefined) {
           config.logger.warn(messages.unknownOption(name));
+        } else if (validator !== undefined) {
+          const validated = validator(name, config, config[name]);
+          if (validated !== undefined) {
+            config[name] = validated;
+          } else {
+            delete config[name];
+          }
         } else {
           const expectedType = typeDesc || typeDescForValue(defaultValue);
           const actualType = typeDescForValue(value);
@@ -156,8 +200,29 @@ module.exports = (function () {
     return config;
   }
 
+  /**
+   * Get tags for the specified configuration.
+   *
+   * If any additional tags are added to the configuration, then the tags from
+   * this method should be extended with those.
+   * @param {Object} config The already valiated configuration.
+   * @returns {Object} The tag configuration.
+   */
+  function getTags(config) {
+    const tags = {};
+    if (config.application && config.application.id !== undefined && config.application.id !== null) {
+      tags['application-id'] = [config.application.id];
+    }
+    if (config.application && config.application.version !== undefined && config.application.id !== null) {
+      tags['application-version'] = [config.application.version];
+    }
+
+    return tags;
+  }
+
   return {
-    validate: validate,
-    defaults: defaults,
+    validate,
+    defaults,
+    getTags,
   };
 })();

contract-tests/README.md

@@ -0,0 +1,7 @@
+# SDK contract test service
+
+This directory contains an implementation of the cross-platform SDK testing protocol defined by https://github.com/launchdarkly/sdk-test-harness. See that project's `README` for details of this protocol, and the kinds of SDK capabilities that are relevant to the contract tests. This code should not need to be updated unless the SDK has added or removed such capabilities.
+
+To run these tests locally, run `npm run contract-tests` from the SDK project root directory. This will start the test service, download the correct version of the test harness tool, and run the tests.
+
+Or, to test against an in-progress local version of the test harness, run `npm run contract-test-service` from the SDK project root directory; then, in the root directory of the `sdk-test-harness` project, build the test harness and run it from the command line.

contract-tests/index.js

@@ -0,0 +1,108 @@
+const express = require('express');
+const bodyParser = require('body-parser');
+
+const { Log } = require('./log');
+const { newSdkClientEntity, badCommandError } = require('./sdkClientEntity');
+
+const app = express();
+let server = null;
+
+const port = 8000;
+
+let clientCounter = 0;
+const clients = {};
+
+const mainLog = Log('service');
+
+app.use(bodyParser.json());
+
+app.get('/', (req, res) => {
+  res.header('Content-Type', 'application/json');
+  res.json({
+    capabilities: [
+      'server-side',
+      'all-flags-client-side-only',
+      'all-flags-details-only-for-tracked-flags',
+      'all-flags-with-reasons',
+      'tags',
+    ],
+  });
+});
+
+app.delete('/', (req, res) => {
+  mainLog.info('Test service has told us to exit');
+  res.status(204);
+  res.send();
+
+  // Defer the following actions till after the response has been sent
+  setTimeout(() => {
+    server.close(() => process.exit());
+    // We force-quit with process.exit because, even after closing the server, there could be some
+    // scheduled tasks lingering if an SDK instance didn't get cleaned up properly, and we don't want
+    // that to prevent us from quitting.
+  }, 1);
+});
+
+app.post('/', async (req, res) => {
+  const options = req.body;
+
+  clientCounter += 1;
+  const clientId = clientCounter.toString();
+  const resourceUrl = `/clients/${clientId}`;
+
+  try {
+    const client = await newSdkClientEntity(options);
+    clients[clientId] = client;
+
+    res.status(201);
+    res.set('Location', resourceUrl);
+  } catch (e) {
+    res.status(500);
+    const message = e.message || JSON.stringify(e);
+    mainLog.error('Error creating client: ' + message);
+    res.write(message);
+  }
+  res.send();
+});
+
+app.post('/clients/:id', async (req, res) => {
+  const client = clients[req.params.id];
+  if (!client) {
+    res.status(404);
+  } else {
+    try {
+      const respValue = await client.doCommand(req.body);
+      if (respValue) {
+        res.status(200);
+        res.write(JSON.stringify(respValue));
+      } else {
+        res.status(204);
+      }
+    } catch (e) {
+      const isBadRequest = e === badCommandError;
+      res.status(isBadRequest ? 400 : 500);
+      res.write(e.message || JSON.stringify(e));
+      if (!isBadRequest && e.stack) {
+        console.log(e.stack);
+      }
+    }
+  }
+  res.send();
+});
+
+app.delete('/clients/:id', async (req, res) => {
+  const client = clients[req.params.id];
+  if (!client) {
+    res.status(404);
+    res.send();
+  } else {
+    client.close();
+    delete clients[req.params.id];
+    res.status(204);
+    res.send();
+  }
+});
+
+server = app.listen(port, () => {
+  console.log('Listening on port %d', port);
+});

contract-tests/log.js

@@ -0,0 +1,23 @@
+const ld = require('launchdarkly-node-server-sdk');
+
+function Log(tag) {
+  function doLog(level, message) {
+    console.log(new Date().toISOString() + ` [${tag}] ${level}: ${message}`);
+  }
+  return {
+    info: message => doLog('info', message),
+    error: message => doLog('error', message),
+  };
+}
+
+function sdkLogger(tag) {
+  return ld.basicLogger({
+    level: 'debug',
+    destination: line => {
+      console.log(new Date().toISOString() + ` [${tag}.sdk] ${line}`);
+    },
+  });
+}
+
+module.exports.Log = Log;
+module.exports.sdkLogger = sdkLogger;

contract-tests/package.json

@@ -0,0 +1,15 @@
+{
+  "name": "node-server-sdk-contract-tests",
+  "version": "0.0.0",
+  "main": "index.js",
+  "scripts": {
+    "start": "node index.js"
+  },
+  "author": "",
+  "license": "Apache-2.0",
+  "dependencies": {
+    "body-parser": "^1.19.0",
+    "express": "^4.17.1",
+    "launchdarkly-node-server-sdk": "file:.."
+  }
+}