@malloydata/malloy-tests 0.0.95-dev231019211822 → 0.0.95

package/src/jestMatcher.spec.ts

@@ -0,0 +1,88 @@
+/* eslint-disable no-console */
+/*
+ * Copyright 2023 Google LLC
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files
+ * (the "Software"), to deal in the Software without restriction,
+ * including without limitation the rights to use, copy, modify, merge,
+ * publish, distribute, sublicense, and/or sell copies of the Software,
+ * and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+import {runtimeFor} from './runtimes';
+import './util/db-jest-matchers';
+
+const runtime = runtimeFor('duckdb');
+
+// uncomment out the skip if you want to play with the matchers
+describe.skip('malloyResultMatches', () => {
+  const sampleSource = `duckdb.sql("""
+          SELECT 42 as num, 'whynot' as reason
+          UNION ALL SELECT 49, 'because'""")`;
+  const model = runtime.loadModel(`source: sampleSource is ${sampleSource}`);
+  const runtimeOrModel = runtime || model;
+
+  test('simple', async () => {
+    await expect(`
+      run: ${sampleSource}
+    `).malloyResultMatches(runtime, {num: 42, reason: 'whynot'});
+  });
+
+  test('nested', async () => {
+    await expect(`
+        run: sampleSource -> {
+            nest: the_nest is {
+                select: nestNum is num, nestWhy is reasons
+            }
+        }
+    `).malloyResultMatches(model, {
+      'the_nest.nestNum': 42,
+      'theNest.nestWhy': 'whynot',
+    });
+  });
+
+  test('multiple rows', async () => {
+    await expect(`
+        run: ${sampleSource}
+    `).malloyResultMatches(runtime, [
+      {num: 42, reason: 'whynot'},
+      {num: 49, reason: 'because'},
+    ]);
+  });
+
+  test('malloyResultMatches with an error', async () => {
+    await expect(`
+        rug: ${sampleSource}
+    `).malloyResultMatches(runtime, [
+      {num: 42, reason: 'whynot'},
+      {num: 49, reason: 'because'},
+    ]);
+  });
+
+  test('wrong data', async () => {
+    await expect(`
+      run: ${sampleSource}
+    `).malloyResultMatches(runtime, {num: 24, reason: 'i said so'});
+  });
+
+  test('failing exactly one row', async () => {
+    await expect(`
+      run: ${sampleSource}
+    `).malloyResultMatches(runtimeOrModel, [{}]);
+  });
+});
+
+afterAll(async () => await runtime.connection.close());

package/src/render/render.spec.ts

@@ -71,7 +71,7 @@ describe('rendering results', () => {
     expect(runtime).toBeDefined();
     if (runtime) {
       const src = `
-        query: table('malloy-data.faa.flights') -> {
+        run: bigquery.table('malloy-data.faa.flights') -> {
           group_by: carrier
           aggregate: flight_count is count()
         }
@@ -216,7 +216,7 @@ describe('rendering results', () => {
         UNION ALL SELECT 'Miguel', 3, 35, 4.2, 31, 1
         UNION ALL SELECT 'Miguel', 4, 47, 4.3, 76, 0 """) extend {
 
-        query: by_name is {
+        view: by_name is {
           group_by: nm
           nest: height_by_age
             # line_chart
@@ -236,12 +236,10 @@ describe('rendering results', () => {
         }
       }
 
-      query: by_name is height -> by_name {
-      }
+      query: by_name is height -> by_name
 
       # transpose
-      query: by_name_transposed is height -> by_name {
-      }
+      query: by_name_transposed is height -> by_name
 
       source: names is duckdb.sql("""SELECT 'Pedro' as nm
       UNION ALL SELECT 'Sebastian'
@@ -291,7 +289,7 @@ describe('rendering results', () => {
             # hidden
             dimension: price is apptcost
 
-            query: by_name is {
+            view: by_name is {
               group_by: nm
               order_by: nm
               nest: height_by_age
@@ -320,7 +318,7 @@ describe('rendering results', () => {
             }
 
             # dashboard
-            query: by_name_db is by_name {}
+            view: by_name_db is by_name {}
           }
 
           query: by_name is height -> by_name {}
@@ -378,7 +376,7 @@ describe('rendering results', () => {
             # currency
             dimension: floc is loc
 
-            query: by_name is {
+            view: by_name is {
               group_by: nm
               # pivot  { dimensions=["dayito"] }
               nest: pivot_f is {
@@ -400,7 +398,7 @@ describe('rendering results', () => {
             }
           }
 
-          query: by_name is height -> by_name {}
+          query: by_name is height -> by_name
       `;
       const result = await (
         await duckdb.loadModel(src).loadQueryByName('by_name')
@@ -461,8 +459,8 @@ describe('rendering results', () => {
   describe('bar chart renderer', () => {
     test('date with timezone rendered correctly', async () => {
       const src = `
-        query: mex_query # bar_chart
-          is duckdb.sql('SELECT 1') -> {
+        query: mex_query is # bar_chart
+          duckdb.sql('SELECT 1') -> {
             timezone: 'America/Mexico_City'
             select: mex_time is @2021-02-24 03:05:06
           }

package/src/tags.spec.ts

@@ -129,12 +129,32 @@ describe('tagParse to Tag', () => {
     ['x=.7e2', {x: {eq: '.7e2'}}],
     ['x=7E2', {x: {eq: '7E2'}}],
     ['`spacey name`=Zaphod', {'spacey name': {eq: 'Zaphod'}}],
+    [
+      'image { alt=hello { field=department } }',
+      {
+        image: {
+          properties: {
+            alt: {eq: 'hello', properties: {field: {eq: 'department'}}},
+          },
+        },
+      },
+    ],
+    [
+      'image image.alt=hello image.alt.field=department',
+      {
+        image: {
+          properties: {
+            alt: {eq: 'hello', properties: {field: {eq: 'department'}}},
+          },
+        },
+      },
+    ],
   ];
   test.each(tagTests)('tag %s', (expression: string, expected: TagDict) => {
     expect(expression).tagsAre(expected);
   });
-  test('uncomment to debug just one of the expressions', () => {
-    const x: TagTestTuple = ['a=a b=$(a)', {a: {eq: 'a'}, b: {eq: 'a'}}];
+  test.skip('unskip to debug just one of the expressions', () => {
+    const x: TagTestTuple = ['x x.y', {x: {properties: {y: {}}}}];
     expect(x[0]).tagsAre(x[1]);
   });
 });

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

@@ -1,3 +1,4 @@
+/* eslint-disable no-console */
 /*
  * Copyright 2023 Google LLC
  *
@@ -22,29 +23,43 @@
  */
 
 import {
+  ModelMaterializer,
   QueryMaterializer,
   Result,
-  SingleConnectionRuntime,
+  Runtime,
+  MalloyError,
+  LogMessage,
 } from '@malloydata/malloy';
 
+type ExpectedResultRow = Record<string, unknown>;
+type ExpectedResult = ExpectedResultRow | ExpectedResultRow[];
+type Runner = Runtime | ModelMaterializer;
+
 declare global {
   // eslint-disable-next-line @typescript-eslint/no-namespace
   namespace jest {
     interface Matchers<R> {
       isSqlEq(): R;
       /**
-       * Jest matcher for running a Malloy query, assumes you only care about
-       * columns in the first row.
+       * Jest matcher for running a Malloy query, checks that each row
+       * contains the values matching the template. If you only want to
+       * check the first row, use the first form. If you want to check
+       * multiple rows, use the second.
+       *
+       *     await expect('query').malloyResultMatches(runtime, {colName: colValue});
+       *     await expect('query').malloyResultMatches(runtime, [{colName: colValue}]);
        *
-       *     await expect(runtime).queryMatches('query', {colName: colValue});
+       *   * If "colName" has a dot in it, it is assumed to be a reference to a value in a nest
+       *   * If you use an array, the number of rows in the result must match the rows in the match
+       *   * The empty match {} accepts ANY data, but will errror if there is not a row
        *
-       * @param runtime Database connection runtime
        * @param querySrc Malloy source, last query in source will be run
-       * @param expected Key value pairs
+       * @param runtime Database connection runtime OR Model ( for the call to loadQuery )
+       * @param expected Key value pairs or array of key value pairs
        */
-      queryMatches(
-        querySrc: string,
-        matchVals: Record<string, unknown>
+      malloyResultMatches(
+        runtime: Runner,
+        matchVals: ExpectedResult
       ): Promise<R>;
     }
   }
@@ -73,56 +88,115 @@ expect.extend({
     };
   },
 
-  async queryMatches(
-    runtime: SingleConnectionRuntime,
+  async malloyResultMatches(
     querySrc: string,
-    expected: Record<string, unknown>
+    runtime: Runner,
+    shouldEqual: ExpectedResult
   ) {
-    if (!runtime.supportsNesting && querySrc.indexOf('nest:') >= 0) {
-      return {
-        pass: true,
-        message: () =>
-          'Test was skipped since connection does not support nesting.',
-      };
+    // TODO -- THIS IS NOT OK BUT I AM NOT FIXING IT NOW
+    if (querySrc.indexOf('nest:') >= 0) {
+      if (runtime instanceof Runtime) {
+        return {
+          pass: true,
+          message: () =>
+            'Test was skipped since connection does not support nesting.',
+        };
+      }
     }
 
     let query: QueryMaterializer;
     try {
       query = runtime.loadQuery(querySrc);
     } catch (e) {
-      return {pass: false, message: () => `loadQuery failed: ${e.message}`};
+      return {
+        pass: false,
+        message: () => `loadQuery failed: ${e.message}`,
+      };
     }
 
     let result: Result;
     try {
       result = await query.run();
     } catch (e) {
-      const failMsg =
-        `query.run failed: ${e.message}\n` + `SQL: ${await query.getSQL()}`;
+      let failMsg = `query.run failed: ${e.message}`;
+      if (e instanceof MalloyError) {
+        failMsg = `Error in query compilation\n${errorLogToString(
+          querySrc,
+          e.problems
+        )}`;
+      } else {
+        try {
+          failMsg += `\nSQL: ${await query.getSQL()}`;
+        } catch (e2) {
+          // we could not show the SQL for unknown reasons
+        }
+      }
       return {pass: false, message: () => failMsg};
     }
 
+    const allRows = Array.isArray(shouldEqual) ? shouldEqual : [shouldEqual];
+    let i = 0;
     const fails: string[] = [];
-    for (const [name, value] of Object.entries(expected)) {
-      try {
-        const got = result.data.path(0, name).value;
-        const mustBe = value instanceof Date ? value.getTime() : value;
-        const actuallyGot = got instanceof Date ? got.getTime() : got;
-        if (actuallyGot !== mustBe) {
-          fails.push(`Expected {${name}: ${value}} Got: ${got}`);
+    const gotRows = result.data.toObject().length;
+    if (Array.isArray(shouldEqual)) {
+      if (gotRows !== allRows.length) {
+        fails.push(`Expected result.rows=${allRows.length}  Got: ${gotRows}`);
+      }
+    }
+    for (const expected of allRows) {
+      for (const [name, value] of Object.entries(expected)) {
+        const pExpect = JSON.stringify(value);
+        const row = allRows.length > 1 ? `[${i}]` : '';
+        const expected = `Expected ${row}{${name}: ${pExpect}}`;
+        try {
+          const nestOne = name.split('.');
+          const resultPath = [i, nestOne[0]];
+          for (const child of nestOne.slice(1)) {
+            resultPath.push(0);
+            resultPath.push(child);
+          }
+          const got = result.data.path(...resultPath).value;
+          const pGot = JSON.stringify(got);
+          const mustBe = value instanceof Date ? value.getTime() : value;
+          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) {
+            fails.push(`${expected} Got: ${pGot}`);
+          }
+        } catch (e) {
+          fails.push(`${expected} Error: ${e.message}`);
         }
-      } catch (e) {
-        fails.push(`Expected {${name}: ${value}} Error: ${e.message}`);
       }
+      i += 1;
     }
     if (fails.length !== 0) {
-      const failMsg = `SQL: ${await query.getSQL()}\n${fails.join('\n')}`;
+      const fromSQL = '  ' + (await query.getSQL()).split('\n').join('\n  ');
+      const failMsg = `SQL Generated:\n${fromSQL}\n${fails.join('\n')}`;
       return {pass: false, message: () => failMsg};
     }
 
     return {
       pass: true,
-      message: () => `First row matched ${JSON.stringify(expected)}`,
+      message: () => 'All rows matched expected results',
     };
   },
 });
+
+function errorLogToString(src: string, msgs: LogMessage[]) {
+  let lovely = '';
+  let lineNo = 0;
+  for (const line of src.split('\n')) {
+    lovely += `    | ${line}\n`;
+    for (const entry of msgs) {
+      if (entry.at) {
+        if (entry.at.range.start.line === lineNo) {
+          const charFrom = entry.at.range.start.character;
+          lovely += `!!!!! ${' '.repeat(charFrom)}^ ${entry.message}\n`;
+        }
+      }
+    }
+    lineNo += 1;
+  }
+  return lovely;
+}

package/src/util/index.ts

@@ -83,7 +83,6 @@ export function describeIfDatabaseAvailable(
 interface InitValues {
   sql?: string;
   malloy?: string;
-  connection?: string;
 }
 
 function sqlSafe(str: string): string {
@@ -92,7 +91,12 @@ function sqlSafe(str: string): string {
     .replace(/\\/g, '{backslash}')
     .replace(/"/g, '{double-quote}');
 }
-export function mkSqlEqWith(runtime: Runtime, initV?: InitValues) {
+
+export function mkSqlEqWith(
+  runtime: Runtime,
+  cName: string,
+  initV?: InitValues
+) {
   // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
   return async function (
     expr: string,
@@ -101,12 +105,8 @@ export function mkSqlEqWith(runtime: Runtime, initV?: InitValues) {
     const qExpr = expr.replace(/'/g, '`');
     const sqlV = initV?.sql || 'SELECT 1 as one';
     const malloyV = initV?.malloy || '';
-    const select = initV?.connection
-      ? ` connection: "${initV.connection}" select`
-      : 'select';
     const sourceDef = `
-      sql: sqlData is {${select}: """${sqlV}""" }
-      source: basicTypes is from_sql(sqlData) ${malloyV}
+      source: basicTypes is ${cName}.sql("""${sqlV}""") ${malloyV}
     `;
     let query: string;
     if (typeof result === 'boolean') {
@@ -117,17 +117,19 @@ export function mkSqlEqWith(runtime: Runtime, initV?: InitValues) {
         : `${notEq} when ${varName}`;
       const elsePick = result ? notEq : "'='";
       query = `${sourceDef}
-          query: basicTypes
+          run: basicTypes
           -> {
-            declare: ${varName} is ${expr}
+            extend: {dimension: ${varName} is ${expr}}
             select: calc is pick ${whenPick} else ${elsePick}
           }`;
     } else if (typeof result === 'number') {
       query = `${sourceDef}
-          query: basicTypes
+          run: basicTypes
           -> {
-            declare: expect is ${result}
-            declare: got is ${expr}
+            extend: {
+              dimension: expect is ${result}
+              dimension: got is ${expr}
+            }
             select: calc is
               pick '=' when expect = got
               else concat('sqlEq failed', CHR(10), '    Expected: ${qExpr} == ${result}', CHR(10), '    Received: ', got::string)
@@ -137,7 +139,7 @@ export function mkSqlEqWith(runtime: Runtime, initV?: InitValues) {
       const resultNoBacks = result.replace(/\\/g, '\\\\');
       const qResult = `'${resultNoBacks.replace(/'/g, "\\'")}'`;
       query = `${sourceDef}
-          query: basicTypes
+          run: basicTypes
           -> {
             select: expect is ${qResult}
             select: got is ${expr}
@@ -151,7 +153,7 @@ export function mkSqlEqWith(runtime: Runtime, initV?: InitValues) {
     } else {
       const qResult = result.replace(/'/g, '`');
       query = `${sourceDef}
-          query: basicTypes
+          run: basicTypes
           -> {
             select: expect is ${result}
             select: got is ${expr}