@khanacademy/wonder-blocks-testing 0.0.2

package/dist/index.js

@@ -0,0 +1,566 @@
+module.exports =
+/******/ (function(modules) { // webpackBootstrap
+/******/ 	// The module cache
+/******/ 	var installedModules = {};
+/******/
+/******/ 	// The require function
+/******/ 	function __webpack_require__(moduleId) {
+/******/
+/******/ 		// Check if module is in cache
+/******/ 		if(installedModules[moduleId]) {
+/******/ 			return installedModules[moduleId].exports;
+/******/ 		}
+/******/ 		// Create a new module (and put it into the cache)
+/******/ 		var module = installedModules[moduleId] = {
+/******/ 			i: moduleId,
+/******/ 			l: false,
+/******/ 			exports: {}
+/******/ 		};
+/******/
+/******/ 		// Execute the module function
+/******/ 		modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
+/******/
+/******/ 		// Flag the module as loaded
+/******/ 		module.l = true;
+/******/
+/******/ 		// Return the exports of the module
+/******/ 		return module.exports;
+/******/ 	}
+/******/
+/******/
+/******/ 	// expose the modules object (__webpack_modules__)
+/******/ 	__webpack_require__.m = modules;
+/******/
+/******/ 	// expose the module cache
+/******/ 	__webpack_require__.c = installedModules;
+/******/
+/******/ 	// define getter function for harmony exports
+/******/ 	__webpack_require__.d = function(exports, name, getter) {
+/******/ 		if(!__webpack_require__.o(exports, name)) {
+/******/ 			Object.defineProperty(exports, name, { enumerable: true, get: getter });
+/******/ 		}
+/******/ 	};
+/******/
+/******/ 	// define __esModule on exports
+/******/ 	__webpack_require__.r = function(exports) {
+/******/ 		if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
+/******/ 			Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+/******/ 		}
+/******/ 		Object.defineProperty(exports, '__esModule', { value: true });
+/******/ 	};
+/******/
+/******/ 	// create a fake namespace object
+/******/ 	// mode & 1: value is a module id, require it
+/******/ 	// mode & 2: merge all properties of value into the ns
+/******/ 	// mode & 4: return value when already ns object
+/******/ 	// mode & 8|1: behave like require
+/******/ 	__webpack_require__.t = function(value, mode) {
+/******/ 		if(mode & 1) value = __webpack_require__(value);
+/******/ 		if(mode & 8) return value;
+/******/ 		if((mode & 4) && typeof value === 'object' && value && value.__esModule) return value;
+/******/ 		var ns = Object.create(null);
+/******/ 		__webpack_require__.r(ns);
+/******/ 		Object.defineProperty(ns, 'default', { enumerable: true, value: value });
+/******/ 		if(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key));
+/******/ 		return ns;
+/******/ 	};
+/******/
+/******/ 	// getDefaultExport function for compatibility with non-harmony modules
+/******/ 	__webpack_require__.n = function(module) {
+/******/ 		var getter = module && module.__esModule ?
+/******/ 			function getDefault() { return module['default']; } :
+/******/ 			function getModuleExports() { return module; };
+/******/ 		__webpack_require__.d(getter, 'a', getter);
+/******/ 		return getter;
+/******/ 	};
+/******/
+/******/ 	// Object.prototype.hasOwnProperty.call
+/******/ 	__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };
+/******/
+/******/ 	// __webpack_public_path__
+/******/ 	__webpack_require__.p = "";
+/******/
+/******/
+/******/ 	// Load entry module and return exports
+/******/ 	return __webpack_require__(__webpack_require__.s = 12);
+/******/ })
+/************************************************************************/
+/******/ ([
+/* 0 */
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "b", function() { return setup; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return getConfiguration; });
+let _configuration = null;
+/**
+ * Setup the fixture framework.
+ */
+
+const setup = configuration => {
+  _configuration = configuration;
+};
+/**
+ * Get the framework configuration.
+ *
+ * @returns {Configuration} The configuration as provided via setup().
+ * @throws {Error} If the configuration has not been set.
+ */
+
+const getConfiguration = () => {
+  if (_configuration == null) {
+    throw new Error("Not configured");
+  }
+
+  return _configuration;
+};
+
+/***/ }),
+/* 1 */
+/***/ (function(module, exports) {
+
+module.exports = require("react");
+
+/***/ }),
+/* 2 */
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony import */ var _storybook_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(3);
+/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "storybook", function() { return _storybook_js__WEBPACK_IMPORTED_MODULE_0__["a"]; });
+
+
+
+/***/ }),
+/* 3 */
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return getAdapter; });
+/* harmony import */ var react__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(1);
+/* harmony import */ var react__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(react__WEBPACK_IMPORTED_MODULE_0__);
+/* harmony import */ var _storybook_addon_actions__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(6);
+/* harmony import */ var _storybook_addon_actions__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(_storybook_addon_actions__WEBPACK_IMPORTED_MODULE_1__);
+/* harmony import */ var _adapter_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(7);
+
+
+
+
+/**
+ * Get a fixture framework adapter for Storybook support.
+ */
+const getAdapter = (MountingComponent = null) => new _adapter_js__WEBPACK_IMPORTED_MODULE_2__[/* Adapter */ "a"]("storybook", ({
+  title,
+  description: groupDescription
+}, adapterOptions, declaredFixtures) => {
+  const templateMap = new WeakMap();
+
+  const log = (message, ...args) => Object(_storybook_addon_actions__WEBPACK_IMPORTED_MODULE_1__["action"])(message).apply(void 0, args);
+
+  const exports = declaredFixtures.reduce((acc, {
+    description,
+    getProps,
+    component: Component
+  }, i) => {
+    const storyName = `${i + 1} ${description}`;
+    const exportName = storyName // Make word boundaries start with an upper case letter.
+    .replace(/\b\w/g, c => c.toUpperCase()) // Remove all non-alphanumeric characters.
+    .replace(/[^\w]+/g, "") // Remove all underscores.
+    .replace(/[_]+/g, ""); // We create a “template” of how args map to rendering
+    // for each type of component as the component here could
+    // be the component under test, or wrapped in a wrapper
+    // component. We don't use decorators for the wrapper
+    // because we may not be in a storybook context and it
+    // keeps the framework API simpler this way.
+
+    let Template = templateMap.get(Component);
+
+    if (Template == null) {
+      // The MountingComponent is a bit different than just a
+      // Storybook decorator. It's a React component that
+      // takes over rendering the component in the fixture
+      // with the given args, allowing for greater
+      // customization in a platform-agnostic manner (i.e.
+      // not just story format).
+      Template = MountingComponent ? args => /*#__PURE__*/react__WEBPACK_IMPORTED_MODULE_0__["createElement"](MountingComponent, {
+        component: Component,
+        props: args,
+        log: log
+      }) : args => /*#__PURE__*/react__WEBPACK_IMPORTED_MODULE_0__["createElement"](Component, args);
+      templateMap.set(Component, Template);
+    } // Each story that shares that component then reuses that
+    // template.
+
+
+    acc[exportName] = Template.bind({});
+    acc[exportName].args = getProps({
+      log
+    }); // Adding a story name here means that we don't have to
+    // care about naming the exports correctly, if we don't
+    // want (useful if we need to autogenerate or manually
+    // expose ESM exports).
+
+    acc[exportName].storyName = storyName;
+    return acc;
+  }, {
+    default: {
+      title,
+      // TODO(somewhatabstract): Use groupDescription
+      // Possibly via a decorator?
+      ...adapterOptions
+    }
+  });
+  return Object.freeze(exports);
+});
+
+/***/ }),
+/* 4 */
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return fixtures; });
+/* harmony import */ var react__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(1);
+/* harmony import */ var react__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(react__WEBPACK_IMPORTED_MODULE_0__);
+/* harmony import */ var _setup_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(0);
+/* harmony import */ var _combine_options_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(9);
+
+
+
+
+/**
+ * Describe a group of fixtures for a given component.
+ *
+ * Only one `fixtures` call should be used per fixture file as it returns
+ * the exports for that file.
+ *
+ * @param {FixtureOptions<TProps>} options Options describing the
+ * fixture group.
+ * @param {FixtureFn<TProps> => void} fn A function that provides a `fixture`
+ * function for defining fixtures.
+ * @returns {Exports} The object to be exported as `module.exports`.
+ *
+ * TODO(somewhatabstract): Determine a way around this requirement so we
+ * can support named exports and default exports via the adapters in a
+ * deterministic way. Currently this is imposed on us because of how
+ * storybook, the popular framework, uses both default and named exports for
+ * its interface.
+ */
+const fixtures = (options, fn) => {
+  var _additionalAdapterOpt;
+
+  const {
+    adapter,
+    defaultAdapterOptions
+  } = Object(_setup_js__WEBPACK_IMPORTED_MODULE_1__[/* getConfiguration */ "a"])();
+  const {
+    title,
+    component,
+    description: groupDescription,
+    defaultWrapper,
+    additionalAdapterOptions
+  } = options; // 1. Create a new adapter group.
+
+  const group = adapter.declareGroup({
+    title: title || component.displayName || component.name || "Component",
+    description: groupDescription
+  }); // 2. Invoke fn with a function that can add a new fixture.
+
+  const addFixture = (description, props, wrapper = null) => {
+    var _ref;
+
+    group.declareFixture({
+      description,
+      getProps: options => typeof props === "function" ? props(options) : props,
+      component: (_ref = wrapper != null ? wrapper : defaultWrapper) != null ? _ref : component
+    });
+  };
+
+  fn(addFixture); // 3. Combine the adapter options from the fixture group with the
+  //    defaults from our setup.
+
+  const groupAdapterOverrides = (_additionalAdapterOpt = additionalAdapterOptions == null ? void 0 : additionalAdapterOptions[adapter.name]) != null ? _additionalAdapterOpt : {};
+  const combinedAdapterOptions = Object(_combine_options_js__WEBPACK_IMPORTED_MODULE_2__[/* combineOptions */ "a"])(defaultAdapterOptions, groupAdapterOverrides); // 4. Call close on the group and return the result.
+
+  return group.closeGroup(combinedAdapterOptions);
+};
+
+/***/ }),
+/* 5 */
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return isolateModules; });
+// Opt this file out of coverage because it's super hard to test.
+
+/* istanbul ignore file */
+
+/**
+ * Isolate imports within a given action using jest.isolateModules.
+ *
+ * This is a helper for the `jest.isolateModules` API, allowing
+ * code to avoid the clunky closure syntax in their tests.
+ *
+ * @param {() => T} action The action that contains the isolated module imports.
+ * We do it this way so that any `require` calls are relative to the calling
+ * code and not this function. Note that we don't support promises here to
+ * discourage dynamic `import` use, which doesn't play well with standard
+ * jest yet.
+ */
+const isolateModules = action => {
+  if (typeof jest === "undefined") {
+    throw new Error(`jest is not available in global scope`);
+  }
+
+  let result = undefined;
+  jest.isolateModules(() => {
+    result = action();
+  }); // We know that we'll have a result of the appropriate type at this point.
+  // We could use a promise to make everything happy, but this doesn't need
+  // to be async, so why bother.
+  // $FlowIgnore[incompatible-return]
+
+  return result;
+};
+
+/***/ }),
+/* 6 */
+/***/ (function(module, exports) {
+
+module.exports = require("@storybook/addon-actions");
+
+/***/ }),
+/* 7 */
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return Adapter; });
+/* harmony import */ var _adapter_group_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(8);
+
+
+/**
+ * Class for implementing a custom adapter.
+ */
+class Adapter {
+  /**
+   * @param {string} name The name of the adapter.
+   * @param {CloseGroupFn<any, Options, Exports>} closeGroupFn The function
+   * an adapter group should call when the group is closed. This is invoked
+   * by an adapter group when it is closed. This function is where an
+   * adapter implements the logic to generate the actual fixtures for the
+   * adapter's target framework.
+   */
+  constructor(name, closeGroupFn) {
+    if (typeof name !== "string") {
+      throw new TypeError("name must be a string");
+    }
+
+    if (name.trim() === "") {
+      throw new Error("name must be a non-empty string");
+    }
+
+    if (typeof closeGroupFn !== "function") {
+      throw new TypeError("closeGroupFn must be a function");
+    }
+
+    this._name = name;
+    this._closeGroupFn = closeGroupFn;
+  }
+  /**
+   * The name of the adapter.
+   */
+
+
+  get name() {
+    return this._name;
+  }
+  /**
+   * Declare a new fixture group.
+   *
+   * @param {AdapterGroupOptions} options The options describing the fixture
+   * group.
+   * @returns {AdapterGroupInterface} The new fixture group.
+   */
+
+
+  declareGroup(options) {
+    return new _adapter_group_js__WEBPACK_IMPORTED_MODULE_0__[/* AdapterGroup */ "a"](this._closeGroupFn, options);
+  }
+
+}
+
+/***/ }),
+/* 8 */
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return AdapterGroup; });
+/**
+ * Simple adapter group implementation.
+ */
+class AdapterGroup {
+  /**
+   * Create an adapter group.
+   *
+   * @param {CloseGroupFn<TProps, Options, Exports>} closeGroupFn A function
+   * to invoke when the group is closed.
+   * @param {AdapterGroupOptions} options The options for the group.
+   */
+  constructor(closeGroupFn, _options) {
+    this.closeGroup = (adapterOptions = null) => {
+      if (this._closeGroupFn == null) {
+        throw new Error("Group already closed");
+      }
+
+      try {
+        return this._closeGroupFn(this._options, adapterOptions, this._fixtures);
+      } finally {
+        this._closeGroupFn = null;
+      }
+    };
+
+    this.declareFixture = options => {
+      if (typeof options !== "object" || options === null) {
+        throw new TypeError("options must be an object");
+      }
+
+      if (this._closeGroupFn == null) {
+        throw new Error("Cannot declare fixtures after closing the group");
+      }
+
+      this._fixtures.push(options);
+    };
+
+    if (typeof closeGroupFn !== "function") {
+      throw new TypeError("closeGroupFn must be a function");
+    }
+
+    if (typeof _options !== "object" || _options === null) {
+      throw new TypeError("options must be an object");
+    }
+
+    this._closeGroupFn = closeGroupFn;
+    this._options = _options;
+    this._fixtures = [];
+  }
+  /**
+   * Close the group.
+   *
+   * This declares that no more fixtures are to be added to the group,
+   * and will call the parent adapter with the declared fixtures so that they
+   * can be adapted for the target fixture framework, such as Storybook.
+   */
+
+
+}
+
+/***/ }),
+/* 9 */
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return combineOptions; });
+/* harmony import */ var _combine_top_level_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(10);
+
+/**
+ * Combine one or more objects into a single object.
+ *
+ * Objects later in the argument list take precedence over those that are
+ * earlier. Object and array values at the root level are merged.
+ */
+
+const combineOptions = (...toBeCombined) => {
+  const combined = toBeCombined.filter(Boolean).reduce((acc, cur) => {
+    for (const key of Object.keys(cur)) {
+      // We always call combine, even if acc[key] is undefined
+      // because we need to make sure we clone values.
+      acc[key] = Object(_combine_top_level_js__WEBPACK_IMPORTED_MODULE_0__[/* combineTopLevel */ "a"])(acc[key], cur[key]);
+    }
+
+    return acc;
+  }, {}); // We know that we are creating a compatible return type.
+  // $FlowIgnore[incompatible-return]
+
+  return combined;
+};
+
+/***/ }),
+/* 10 */
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return combineTopLevel; });
+/* harmony import */ var _khanacademy_wonder_stuff_core__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(11);
+/* harmony import */ var _khanacademy_wonder_stuff_core__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_khanacademy_wonder_stuff_core__WEBPACK_IMPORTED_MODULE_0__);
+
+/**
+ * Combine two values.
+ *
+ * This method clones val2 before using any of its properties to try to ensure
+ * the combined object is not linked back to the original.
+ *
+ * If the values are objects, it will merge them at the top level. Properties
+ * themselves are not merged; val2 properties will overwrite val1 where there
+ * are conflicts
+ *
+ * If the values are arrays, it will concatenate and dedupe them.
+ * NOTE: duplicates in either val1 or val2 will also be deduped.
+ *
+ * If the values are any other type, or val2 has a different type to val1, val2
+ * will be returned.
+ */
+
+const combineTopLevel = (val1, val2) => {
+  const obj2Clone = Object(_khanacademy_wonder_stuff_core__WEBPACK_IMPORTED_MODULE_0__["clone"])(val2); // Only merge if they're both arrays or both objects.
+  // If not, we will just return val2.
+
+  if (val1 !== null && val2 !== null && typeof val1 === "object" && typeof val2 === "object") {
+    const val1IsArray = Array.isArray(val1);
+    const val2IsArray = Array.isArray(val2);
+
+    if (val1IsArray && val2IsArray) {
+      return Array.from(new Set([].concat(val1, obj2Clone)));
+    } else if (!val1IsArray && !val2IsArray) {
+      return { ...val1,
+        ...obj2Clone
+      };
+    }
+  }
+
+  return obj2Clone;
+};
+
+/***/ }),
+/* 11 */
+/***/ (function(module, exports) {
+
+module.exports = require("@khanacademy/wonder-stuff-core");
+
+/***/ }),
+/* 12 */
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony import */ var _fixtures_adapters_adapters_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(2);
+/* harmony reexport (module object) */ __webpack_require__.d(__webpack_exports__, "adapters", function() { return _fixtures_adapters_adapters_js__WEBPACK_IMPORTED_MODULE_0__; });
+/* harmony import */ var _fixtures_fixtures_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(4);
+/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "fixtures", function() { return _fixtures_fixtures_js__WEBPACK_IMPORTED_MODULE_1__["a"]; });
+
+/* harmony import */ var _fixtures_setup_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(0);
+/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "setupFixtures", function() { return _fixtures_setup_js__WEBPACK_IMPORTED_MODULE_2__["b"]; });
+
+/* harmony import */ var _jest_isolate_modules_js__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(5);
+/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "isolateModules", function() { return _jest_isolate_modules_js__WEBPACK_IMPORTED_MODULE_3__["a"]; });
+
+// Fixtures framework
+
+
+
+ // Jest
+// TODO(somewhatabstract): To be moved to wonder stuff
+
+
+
+/***/ })
+/******/ ]);

package/dist/index.js.flow

@@ -0,0 +1,2 @@
+// @flow
+export * from "../src/index.js";

package/docs.md

@@ -0,0 +1 @@
+`wonder-blocks-testing` provides a utilities to support testing React components

package/package.json

@@ -0,0 +1,28 @@
+{
+    "name": "@khanacademy/wonder-blocks-testing",
+    "version": "0.0.2",
+    "design": "v1",
+    "publishConfig": {
+        "access": "public"
+    },
+    "description": "",
+    "main": "dist/index.js",
+    "module": "dist/es/index.js",
+    "source": "src/index.js",
+    "scripts": {
+        "test": "echo \"Error: no test specified\" && exit 1"
+    },
+    "dependencies": {
+        "@khanacademy/wonder-stuff-core": "^0.1.2",
+        "@babel/runtime": "^7.16.3"
+    },
+    "peerDependencies": {
+        "@storybook/addon-actions": "^6.4.8",
+        "react": "16.14.0"
+    },
+    "devDependencies": {
+        "wb-dev-build-settings": "^0.2.0"
+    },
+    "author": "",
+    "license": "MIT"
+}

package/src/fixtures/__tests__/combine-options.test.js

@@ -0,0 +1,65 @@
+// @flow
+import * as CombineTopLevelModule from "../combine-top-level.js";
+
+import {combineOptions} from "../combine-options.js";
+
+jest.mock("../combine-top-level.js");
+
+describe("#combineOptions", () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+    });
+
+    it("should call combine once per property per object", () => {
+        // Arrange
+        const toBeCombined = [
+            {a: "test1", b: "test1"},
+            {b: "test2"},
+            {a: "test3", c: "test3"},
+        ];
+        const combineSpy = jest.spyOn(CombineTopLevelModule, "combineTopLevel");
+
+        // Act
+        combineOptions(...toBeCombined);
+
+        // Assert
+        expect(combineSpy).toHaveBeenCalledTimes(5);
+    });
+
+    it("should ignore falsy args", () => {
+        // Arrange
+        const toBeCombined = [null, {a: "test"}, {b: "test"}, 0, undefined];
+        const combineSpy = jest.spyOn(CombineTopLevelModule, "combineTopLevel");
+
+        // Act
+        combineOptions(...toBeCombined);
+
+        // Assert
+        expect(combineSpy).toHaveBeenCalledTimes(2);
+    });
+
+    it("should return the combined object", () => {
+        // Arrange
+        const toBeCombined = [
+            {a: "test1", b: "test1"},
+            {b: "test2"},
+            {a: "test3", c: "test3"},
+        ];
+        jest.spyOn(CombineTopLevelModule, "combineTopLevel").mockImplementation(
+            // Just for testing, we know the values are strings, so let's
+            // combine them with concatenation so we see the order of
+            // combination in the result.
+            (v1, v2) => `${v1 === undefined ? "" : v1}${v2}`,
+        );
+
+        // Act
+        const result = combineOptions(...toBeCombined);
+
+        // Assert
+        expect(result).toEqual({
+            a: "test1test3",
+            b: "test1test2",
+            c: "test3",
+        });
+    });
+});