@malloydata/malloy-tests 0.0.220-dev241203204946 → 0.0.220-dev241204170603

package/mysql/mysql_start.sh

@@ -5,11 +5,13 @@ rm -rf .tmp
 mkdir .tmp
 
 # run docker
-SCRIPTDIR=$(dirname $0)
-docker run -p 3306:3306 -d -v $SCRIPTDIR/../data/mysql:/init_data --name mysql-malloy -e MYSQL_ALLOW_EMPTY_PASSWORD=yes -d mysql:8.4.2
+SCRIPTDIR=$(cd $(dirname $0); pwd)
+DATADIR=$(dirname $SCRIPTDIR)/data/mysql
+docker run -p 3306:3306 -d -v $DATADIR:/init_data --name mysql-malloy -e MYSQL_ALLOW_EMPTY_PASSWORD=yes -d mysql:8.4.2
 
 # wait for server to start
 counter=0
+echo -n Starting Docker ...
 while ! docker logs mysql-malloy 2>&1 | grep -q "mysqld: ready for connections"
 do
   sleep 10
@@ -23,9 +25,12 @@ do
     exit 1
     break
   fi
+  echo -n ...
 done
 
 # load the test data.
+echo
+echo Loading Test Data
 docker exec mysql-malloy cp /init_data/malloytest.mysql.gz /tmp
 docker exec mysql-malloy gunzip /tmp/malloytest.mysql.gz
 docker exec mysql-malloy mysql -P3306 -h127.0.0.1 -uroot -e 'drop database if exists malloytest; create database malloytest; use malloytest; source /tmp/malloytest.mysql;'

package/mysql/mysql_stop.sh

@@ -4,4 +4,4 @@
 rm -rf .tmp
 
 # stop container
-docker rm -f mysql-malloy
+docker rm -f mysql-malloy

package/package.json

@@ -21,13 +21,13 @@
   },
   "dependencies": {
     "@jest/globals": "^29.4.3",
-    "@malloydata/db-bigquery": "^0.0.220-dev241203204946",
-    "@malloydata/db-duckdb": "^0.0.220-dev241203204946",
-    "@malloydata/db-postgres": "^0.0.220-dev241203204946",
-    "@malloydata/db-snowflake": "^0.0.220-dev241203204946",
-    "@malloydata/db-trino": "^0.0.220-dev241203204946",
-    "@malloydata/malloy": "^0.0.220-dev241203204946",
-    "@malloydata/render": "^0.0.220-dev241203204946",
+    "@malloydata/db-bigquery": "^0.0.220-dev241204170603",
+    "@malloydata/db-duckdb": "^0.0.220-dev241204170603",
+    "@malloydata/db-postgres": "^0.0.220-dev241204170603",
+    "@malloydata/db-snowflake": "^0.0.220-dev241204170603",
+    "@malloydata/db-trino": "^0.0.220-dev241204170603",
+    "@malloydata/malloy": "^0.0.220-dev241204170603",
+    "@malloydata/render": "^0.0.220-dev241204170603",
     "events": "^3.3.0",
     "jsdom": "^22.1.0",
     "luxon": "^2.4.0",
@@ -37,5 +37,5 @@
     "@types/jsdom": "^21.1.1",
     "@types/luxon": "^2.4.0"
   },
-  "version": "0.0.220-dev241203204946"
+  "version": "0.0.220-dev241204170603"
 }

package/src/databases/all/compound-atomic.spec.ts

@@ -0,0 +1,509 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+import {RuntimeList, allDatabases} from '../../runtimes';
+import {databasesFromEnvironmentOr} from '../../util';
+import '../../util/db-jest-matchers';
+import {
+  RecordLiteralNode,
+  ArrayLiteralNode,
+  ArrayTypeDef,
+  FieldDef,
+  Expr,
+} from '@malloydata/malloy';
+
+const runtimes = new RuntimeList(databasesFromEnvironmentOr(allDatabases));
+
+/*
+ * Tests for the composite atomic data types "record", "array of values",
+ * and "array of records". Each starts with a test that the dialect functions
+ * for literals work, and then bases the rest of the tests on literals,
+ * so fix that one first if the tests are failing.
+ */
+
+describe.each(runtimes.runtimeList)(
+  'compound atomic datatypes %s',
+  (conName, runtime) => {
+    const supportsNestedArrays = runtime.dialect.nestedArrays;
+    const quote = runtime.dialect.sqlMaybeQuoteIdentifier;
+    function literalNum(num: Number): Expr {
+      const literal = num.toString();
+      return {node: 'numberLiteral', literal, sql: literal};
+    }
+    const empty = `${conName}.sql("SELECT 0 as z")`;
+    function arraySelectVal(...val: Number[]): string {
+      const literal: ArrayLiteralNode = {
+        node: 'arrayLiteral',
+        typeDef: {
+          type: 'array',
+          name: 'evens',
+          join: 'many',
+          elementTypeDef: {type: 'number'},
+          fields: [],
+          dialect: runtime.dialect.name,
+        },
+        kids: {values: val.map(v => literalNum(v))},
+      };
+      return runtime.dialect.sqlLiteralArray(literal);
+    }
+    function recordLiteral(fromObj: Record<string, number>): RecordLiteralNode {
+      const kids: Record<string, Expr> = {};
+      const fields: FieldDef[] = Object.keys(fromObj).map(name => {
+        kids[name] = literalNum(fromObj[name]);
+        return {
+          type: 'number',
+          name,
+        };
+      });
+      const literal: RecordLiteralNode = {
+        node: 'recordLiteral',
+        typeDef: {
+          type: 'record',
+          name: 'evens',
+          join: 'one',
+          dialect: runtime.dialect.name,
+          fields,
+        },
+        kids,
+      };
+      literal.sql = runtime.dialect.sqlLiteralRecord(literal);
+      return literal;
+    }
+
+    function recordSelectVal(fromObj: Record<string, number>): string {
+      return runtime.dialect.sqlLiteralRecord(recordLiteral(fromObj));
+    }
+    const canReadCompoundSchema = runtime.dialect.compoundObjectInSchema;
+
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    const ab = recordSelectVal({a: 0, b: 1});
+
+    const malloySizes = 'sizes is {s is 0, m is 1, l is 2, xl is 3}';
+    const sizesObj = {s: 0, m: 1, l: 2, xl: 3};
+    const sizesSQL = recordSelectVal(sizesObj);
+    // Keeping the pipeline simpler makes debugging easier, so don't add
+    // and extra stage unless you have to
+    const sizes = canReadCompoundSchema
+      ? `${conName}.sql(""" SELECT ${sizesSQL} AS ${quote('sizes')} """)`
+      : `${conName}.sql('SELECT 0 AS O') -> { select: ${malloySizes}}`;
+    const evensObj = [2, 4, 6, 8];
+    const evensSQL = arraySelectVal(...evensObj);
+    const evens = `${conName}.sql("""
+      SELECT ${evensSQL} AS ${quote('evens')}
+    """)`;
+
+    describe('simple arrays', () => {
+      test('array literal dialect function', async () => {
+        await expect(`
+          run: ${evens}`).malloyResultMatches(runtime, {
+          evens: evensObj,
+        });
+      });
+      test('select array', async () => {
+        await expect(`
+          # test.verbose
+          run: ${evens}->{select: nn is evens}
+          `).malloyResultMatches(runtime, {nn: evensObj});
+      });
+      test.when(canReadCompoundSchema)(
+        'schema read allows array-un-nest on each',
+        async () => {
+          await expect(`
+          run: ${evens}->{ select: n is evens.each }
+        `).malloyResultMatches(
+            runtime,
+            evensObj.map(n => ({n}))
+          );
+        }
+      );
+      test('array can be passed to !function', async () => {
+        // Used as a standin for "unknown function user might call"
+        const nameOfArrayLenFunction = {
+          'duckdb': 'LEN',
+          'standardsql': 'ARRAY_LENGTH',
+          'postgres': 'JSONB_ARRAY_LENGTH',
+          'presto': 'CARDINALITY',
+          'trino': 'CARDINALITY',
+          'mysql': 'JSON_LENGTH',
+          'snowflake': 'ARRAY_SIZE',
+        };
+        const dialect = runtime.dialect.name;
+        const missing = `Dialect '${dialect}' missing array length function in nameOfArrayLenFunction`;
+        const fn = nameOfArrayLenFunction[dialect] ?? missing;
+        expect(fn).not.toEqual(missing);
+        await expect(
+          `run: ${evens}->{ select: nby2 is ${fn}!number(evens); } `
+        ).malloyResultMatches(runtime, {nby2: evensObj.length});
+      });
+      test('array.each in source', async () => {
+        await expect(`
+          run: ${empty}
+          extend { dimension: d4 is [1,2,3,4] }
+          -> { select: die_roll is d4.each }
+        `).malloyResultMatches(runtime, [
+          {die_roll: 1},
+          {die_roll: 2},
+          {die_roll: 3},
+          {die_roll: 4},
+        ]);
+      });
+      test('array.each in extend block', async () => {
+        await expect(`
+          run: ${empty} -> {
+            extend: { dimension: d4 is [1,2,3,4] }
+            select: die_roll is d4.each
+          }
+        `).malloyResultMatches(runtime, [
+          {die_roll: 1},
+          {die_roll: 2},
+          {die_roll: 3},
+          {die_roll: 4},
+        ]);
+      });
+      test.skip('cross join arrays', async () => {
+        await expect(`
+          run: ${empty} extend {
+            dimension: d1 is [1,2,3,4]
+            join_cross: d2 is [1,2,3,4]
+          } -> {
+            group_by: roll is d1.each + d2.each
+            aggregate: rolls is count()
+          }
+        `).malloyResultMatches(runtime, [
+          {roll: 2, rolls: 1},
+          {roll: 3, rolls: 2},
+          {roll: 4, rolls: 3},
+          {roll: 5, rolls: 4},
+          {roll: 6, rolls: 3},
+          {roll: 7, rolls: 2},
+          {roll: 8, rolls: 1},
+        ]);
+      });
+      // can't use special chars in column names in bq
+      test.when(conName !== 'bigquery')(
+        'array stored field with special chars in name',
+        async () => {
+          const special_chars = ["'", '"', '.', '`'];
+          for (const c of special_chars) {
+            const qname = '`_\\' + c + '_`';
+            const malloySrc = `
+            # test.verbose
+            run: ${empty}
+            ->{ select: ${qname} is [1]}
+            -> { select: num is ${qname}.each }`;
+            await expect(malloySrc).malloyResultMatches(runtime, {});
+            const result = await runtime.loadQuery(malloySrc).run();
+            const ok =
+              result.data.path(0, 'num').value === 1
+                ? 'ok'
+                : `Array containing ${c} character is not ok`;
+            expect(ok).toEqual('ok');
+          }
+        }
+      );
+      test.when(supportsNestedArrays)('bare array of array', async () => {
+        await expect(`
+          run: ${empty} -> { select: aoa is [[1,2]] }
+        `).malloyResultMatches(runtime, {aoa: [[1, 2]]});
+      });
+      test.when(supportsNestedArrays)('each.each array of array', async () => {
+        await expect(`
+          run: ${empty} extend { dimension: aoa is [[1,2]] } -> { select: aoa.each.each }
+        `).malloyResultMatches(runtime, [{each: 1}, {each: 2}]);
+      });
+    });
+    describe('record', () => {
+      function rec_eq(as?: string): Record<string, Number> {
+        const name = as ?? 'sizes';
+        return {
+          [`${name}/s`]: 0,
+          [`${name}/m`]: 1,
+          [`${name}/l`]: 2,
+          [`${name}/xl`]: 3,
+        };
+      }
+      test('record literal object', async () => {
+        await expect(`
+          run: ${conName}.sql("select 0 as o")
+          -> { select: ${malloySizes}}
+        `).malloyResultMatches(runtime, rec_eq());
+      });
+      // can't use special chars in column names in bq
+      test.when(conName !== 'bigquery')(
+        'special character in record property name',
+        async () => {
+          const special_chars = ["'", '"', '.', '`'];
+          for (const c of special_chars) {
+            const qname = '_\\' + c + '_';
+            const name = '_' + c + '_';
+            const malloySrc = `run: ${empty} -> { select: \`${qname}\` is 'ok' }`;
+            // no malloyResultMatches because it treats a special in an expect key
+            const query = runtime.loadQuery(malloySrc);
+            const result = await query.run();
+            const p =
+              result.data.path(0, name).value === 'ok'
+                ? 'ok'
+                : `Name containing the ${c} character was not ok`;
+            expect(p).toEqual('ok');
+          }
+        }
+      );
+      // can't use special chars in column names in bq
+      test.when(conName !== 'bigquery')(
+        'record stored in field with special chars in name',
+        async () => {
+          const special_chars = ["'", '"', '.', '`'];
+          for (const c of special_chars) {
+            const qname = '`_\\' + c + '_`';
+            const malloySrc = `
+            run: ${empty}
+            ->{ select: ${qname} is {rnum is 1}}
+            -> { select: num is ${qname}.rnum }`;
+            const result = await runtime.loadQuery(malloySrc).run();
+            const ok =
+              result.data.path(0, 'num').value === 1
+                ? 'ok'
+                : `Array containing ${c} character is not ok`;
+            expect(ok).toEqual('ok');
+          }
+        }
+      );
+      test.when(canReadCompoundSchema)(
+        'can read schema of record object',
+        async () => {
+          await expect(`run: ${conName}.sql("""
+          SELECT ${sizesSQL} AS ${quote('sizes')}
+        """)`).malloyResultMatches(runtime, rec_eq());
+        }
+      );
+      test('simple record.property access', async () => {
+        await expect(`
+          run: ${sizes} -> { select: small is sizes.s }`).malloyResultMatches(
+          runtime,
+          {small: 0}
+        );
+      });
+      test('nested data looks like a record', async () => {
+        await expect(`
+          run: ${conName}.sql('SELECT 1 as ${quote('o')}') -> {
+            group_by: row is 'one_row'
+            nest: sizes is {
+              aggregate:
+                s is sum(o) - 1,
+                m is sum(o),
+                x is sum(o) + 1,
+                xl is sum(o) + 2
+            }
+          } -> { select: small is sizes.s }`).malloyResultMatches(runtime, {
+          small: 0,
+        });
+      });
+      test('record can be selected', async () => {
+        await expect(
+          `
+          run: ${sizes} -> { select: sizes }`
+        ).malloyResultMatches(runtime, rec_eq());
+      });
+      test('record literal can be selected', async () => {
+        await expect(`
+          run: ${sizes} -> { select: record is sizes }
+        `).malloyResultMatches(runtime, rec_eq('record'));
+      });
+      test('select record literal from a source', async () => {
+        await expect(`
+          run: ${empty} -> {
+            extend: { dimension: ${malloySizes} }
+            select: sizes
+          }
+        `).malloyResultMatches(runtime, rec_eq());
+      });
+      test('computed record.property from a source', async () => {
+        await expect(`
+          run: ${empty}
+            extend { dimension: record is {s is 0, m is 1, l is 2, xl is 3} }
+            -> { select: small is record.s }
+        `).malloyResultMatches(runtime, {small: 0});
+      });
+      test('record.property from an extend block', async () => {
+        await expect(`
+          run: ${empty} -> {
+            extend: { dimension: record is {s is 0, m is 1, l is 2, xl is 3} }
+            select: small is record.s
+          }
+        `).malloyResultMatches(runtime, {small: 0});
+      });
+      test('simple each on array property inside record', async () => {
+        await expect(`
+          run: ${empty} -> { select: nums is { odds is [1,3], evens is [2,4]} }
+          -> { select: odd is nums.odds.value }
+        `).malloyResultMatches(runtime, [{odd: 1}, {odd: 3}]);
+      });
+      test('each on array property inside record from source', async () => {
+        await expect(`
+          run: ${empty} extend { dimension: nums is { odds is [1,3], evens is [2,4]} }
+          -> { select: odd is nums.odds.each }
+        `).malloyResultMatches(runtime, [{odd: 1}, {odd: 3}]);
+      });
+      const abc = "rec is {a is 'a', bc is {b is 'b', c is 'c'}}";
+      test('record with a record property', async () => {
+        await expect(`
+          run: ${empty} -> { select: ${abc} }
+          -> { select: rec.a, rec.bc.b, rec.bc.c }
+        `).malloyResultMatches(runtime, {a: 'a', b: 'b', c: 'c'});
+      });
+      test('record in source with a record property', async () => {
+        await expect(`
+          run: ${empty} extend { dimension: ${abc} }
+          -> { select: rec.a, rec.bc.b, rec.bc.c }
+        `).malloyResultMatches(runtime, {a: 'a', b: 'b', c: 'c'});
+      });
+      test('record dref in source with a record property', async () => {
+        await expect(`
+          run: ${empty} extend { dimension: ${abc} }
+          -> { select: b is pick rec.bc.b when true else 'b' }
+        `).malloyResultMatches(runtime, {b: 'b'});
+      });
+      test.todo('array or record where first entries are null');
+    });
+    describe('repeated record', () => {
+      const abType: ArrayTypeDef = {
+        type: 'array',
+        dialect: runtime.dialect.name,
+        join: 'many',
+        elementTypeDef: {type: 'record_element'},
+        fields: [
+          {name: 'a', type: 'number'},
+          {name: 'b', type: 'number'},
+        ],
+        name: '',
+      };
+      const values = [
+        recordLiteral({a: 10, b: 11}),
+        recordLiteral({a: 20, b: 21}),
+      ];
+
+      const ab = runtime.dialect.sqlLiteralArray({
+        node: 'arrayLiteral',
+        typeDef: abType,
+        kids: {values},
+      });
+      const ab_eq = [
+        {a: 10, b: 11},
+        {a: 20, b: 21},
+      ];
+      const abMalloy = '[{a is 10, b is 11}, {a is 20, b is 21}]';
+      function selectAB(n: string) {
+        return `SELECT ${ab} AS ${quote(n)}`;
+      }
+
+      test('repeated record from nest', async () => {
+        await expect(`
+            run: ${conName}.sql("""
+              SELECT
+                10 as ${quote('a')},
+                11 as ${quote('b')}
+              UNION ALL SELECT 20 , 21
+            """) -> { nest: ab is { select: a, b } }
+                 -> { select: ab.a, ab.b ; order_by: a}
+        `).malloyResultMatches(runtime, ab_eq);
+      });
+      test('select repeated record from literal dialect functions', async () => {
+        await expect(`
+          run: ${conName}.sql(""" ${selectAB('ab')} """)
+        `).malloyResultMatches(runtime, {ab: ab_eq});
+      });
+      test('repeat record from malloy literal', async () => {
+        await expect(`
+          run: ${empty}
+          -> { select: ab is ${abMalloy} }
+        `).malloyResultMatches(runtime, {ab: ab_eq});
+      });
+      test('repeated record can be selected and renamed', async () => {
+        const src = `
+          run: ${conName}.sql("""
+            ${selectAB('sqlAB')}
+          """) -> { select: ab is sqlAB }
+      `;
+        await expect(src).malloyResultMatches(runtime, {ab: ab_eq});
+      });
+      test('select repeated record passed down pipeline', async () => {
+        await expect(`
+          run: ${empty}
+          -> { select: pipeAb is ${abMalloy} }
+          -> { select: ab is pipeAb }
+        `).malloyResultMatches(runtime, {ab: ab_eq});
+      });
+      test('deref repeat record passed down pipeline', async () => {
+        await expect(`
+          run: ${empty}
+          -> { select: pipeAb is ${abMalloy} }
+          -> { select: pipeAb.a, pipeAb.b }
+        `).malloyResultMatches(runtime, ab_eq);
+      });
+      test('select array of records from source', async () => {
+        await expect(`
+          run: ${empty}
+          extend { dimension: abSrc is ${abMalloy} }
+          -> { select: ab is abSrc }
+        `).malloyResultMatches(runtime, {ab: ab_eq});
+      });
+      test('deref array of records from source', async () => {
+        await expect(`
+          run: ${empty}
+          extend { dimension: ab is ${abMalloy} }
+          -> { select: ab.a, ab.b }
+        `).malloyResultMatches(runtime, ab_eq);
+      });
+      test('repeated record in source wth record property', async () => {
+        await expect(`
+          run: ${empty} extend { dimension: rec is [ {bc is  {b is 'b'}} ] }
+          -> { select: rec.bc.b }
+        `).malloyResultMatches(runtime, {b: 'b'});
+      });
+      test('piped repeated record containing an array', async () => {
+        await expect(`
+          run: ${empty} -> {
+            select: rrec is [
+              { val is 1, names is ['uno', 'one'] },
+              { val is 2, names is ['due', 'two'] }
+            ]
+          } -> {
+            select: val is rrec.val, name is rrec.names.each
+            order_by: val desc, name asc
+          }
+        `).malloyResultMatches(runtime, [
+          {val: 2, name: 'due'},
+          {val: 2, name: 'two'},
+          {val: 1, name: 'one'},
+          {val: 1, name: 'uno'},
+        ]);
+      });
+      test('source repeated record containing an array', async () => {
+        await expect(`
+          run: ${empty} extend {
+            dimension: rrec is [
+              { val is 1, names is ['uno', 'one'] },
+              { val is 2, names is ['due', 'two'] }
+            ]
+          } -> {
+            select: val is rrec.val, name is rrec.names.each
+            order_by: val desc, name asc
+          }
+        `).malloyResultMatches(runtime, [
+          {val: 2, name: 'due'},
+          {val: 2, name: 'two'},
+          {val: 1, name: 'one'},
+          {val: 1, name: 'uno'},
+        ]);
+      });
+    });
+  }
+);
+
+afterAll(async () => {
+  await runtimes.closeAll();
+});

package/src/databases/duckdb/materialization.spec.ts

@@ -2,7 +2,7 @@
  * Copyright (c) Meta Platforms, Inc. and affiliates.
  *
  * This source code is licensed under the MIT license found in the
- *  LICENSE file in the root directory of this source tree.
+ * LICENSE file in the root directory of this source tree.
  */
 
 import {RuntimeList} from '../../runtimes';

package/src/databases/duckdb/reference-id.spec.ts

@@ -2,7 +2,7 @@
  * Copyright (c) Meta Platforms, Inc. and affiliates.
  *
  * This source code is licensed under the MIT license found in the
- *  LICENSE file in the root directory of this source tree.
+ * LICENSE file in the root directory of this source tree.
  */
 
 import {RuntimeList} from '../../runtimes';

package/src/databases/presto-trino/presto-trino.spec.ts

@@ -2,7 +2,7 @@
  * Copyright (c) Meta Platforms, Inc. and affiliates.
  *
  * This source code is licensed under the MIT license found in the
- *  LICENSE file in the root directory of this source tree.
+ * LICENSE file in the root directory of this source tree.
  */
 
 /* eslint-disable no-console */
@@ -22,6 +22,18 @@ describe.each(runtimes.runtimeList)(
       throw new Error("Couldn't build runtime");
     }
 
+    test.when(databaseName === 'presto')('presto explain parser', async () => {
+      const abrec = 'CAST(ROW(0,1) AS ROW(a DOUBLE,b DOUBLE))';
+      await expect(`
+        run: ${databaseName}.sql("""
+          SELECT
+            ${abrec} as "abrec",
+            ARRAY['c', 'd'] as str_array,
+            array[1,2,3] as int_array,
+            ARRAY[${abrec}] as array_of_abrec
+        """)
+      `).malloyResultMatches(runtime, {});
+    });
     it(`runs an sql query - ${databaseName}`, async () => {
       await expect(
         `run: ${databaseName}.sql("SELECT 1 as n") -> { select: n }`

package/src/events.spec.ts

@@ -2,7 +2,7 @@
  * Copyright (c) Meta Platforms, Inc. and affiliates.
  *
  * This source code is licensed under the MIT license found in the
- *  LICENSE file in the root directory of this source tree.
+ * LICENSE file in the root directory of this source tree.
  */
 
 import {runtimeFor} from './runtimes';

package/src/util/db-jest-matchers.ts

@@ -203,7 +203,7 @@ expect.extend({
           const actuallyGot = got instanceof Date ? got.getTime() : got;
           if (typeof mustBe === 'number' && typeof actuallyGot !== 'number') {
             fails.push(`${expected} Got: Non Numeric '${pGot}'`);
-          } else if (actuallyGot !== mustBe) {
+          } else if (!objectsMatch(actuallyGot, mustBe)) {
             fails.push(`${expected} Got: ${pGot}`);
           }
         } catch (e) {
@@ -332,8 +332,8 @@ function humanReadable(thing: unknown): string {
 
 // b is "expected"
 // a is "actual"
-// If expected is an object, all of the keys should also
-// match, buy the expected is allowed to have other keys that are not matched
+// If expected is an object, all of the keys should also match,
+// but the expected is allowed to have other keys that are not matched
 function objectsMatch(a: unknown, b: unknown): boolean {
   if (
     typeof b === 'string' ||