@malloydata/malloy-tests 0.0.195-dev241001233244 → 0.0.195-dev241003204819

package/package.json

@@ -21,13 +21,14 @@
   },
   "dependencies": {
     "@jest/globals": "^29.4.3",
-    "@malloydata/db-bigquery": "^0.0.195-dev241001233244",
-    "@malloydata/db-duckdb": "^0.0.195-dev241001233244",
-    "@malloydata/db-postgres": "^0.0.195-dev241001233244",
-    "@malloydata/db-snowflake": "^0.0.195-dev241001233244",
-    "@malloydata/db-trino": "^0.0.195-dev241001233244",
-    "@malloydata/malloy": "^0.0.195-dev241001233244",
-    "@malloydata/render": "^0.0.195-dev241001233244",
+    "@malloydata/db-bigquery": "^0.0.195-dev241003204819",
+    "@malloydata/db-duckdb": "^0.0.195-dev241003204819",
+    "@malloydata/db-postgres": "^0.0.195-dev241003204819",
+    "@malloydata/db-snowflake": "^0.0.195-dev241003204819",
+    "@malloydata/db-trino": "^0.0.195-dev241003204819",
+    "@malloydata/malloy": "^0.0.195-dev241003204819",
+    "@malloydata/render": "^0.0.195-dev241003204819",
+    "events": "^3.3.0",
     "jsdom": "^22.1.0",
     "luxon": "^2.4.0",
     "madge": "^6.0.0"
@@ -36,5 +37,5 @@
     "@types/jsdom": "^21.1.1",
     "@types/luxon": "^2.4.0"
   },
-  "version": "0.0.195-dev241001233244"
+  "version": "0.0.195-dev241003204819"
 }

package/src/databases/bigquery/malloy_query.spec.ts

@@ -52,12 +52,7 @@ async function runQuery(model: malloy.ModelMaterializer, query: string) {
 }
 
 async function bqCompile(sql: string): Promise<boolean> {
-  try {
-    await bq.executeSQLRaw(`WITH test AS(\n${sql}) SELECT 1 as one`);
-  } catch (e) {
-    malloy.Malloy.log.error(`SQL: didn't compile\n=============\n${sql}`);
-    throw e;
-  }
+  await bq.executeSQLRaw(`WITH test AS(\n${sql}) SELECT 1 as one`);
   return true;
 }
 

package/src/events.spec.ts

@@ -0,0 +1,123 @@
+/*
+ * 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 {runtimeFor} from './runtimes';
+import './util/db-jest-matchers';
+
+const runtime = runtimeFor('duckdb');
+
+const envDatabases = (
+  process.env['MALLOY_DATABASES'] ||
+  process.env['MALLOY_DATABASE'] ||
+  'duckdb'
+).split(',');
+
+let describe = globalThis.describe;
+if (!envDatabases.includes('duckdb')) {
+  describe = describe.skip;
+  describe.skip = describe;
+}
+
+describe('emits events', () => {
+  describe('for parameters', () => {
+    test('argument compiled event is emitted', async () => {
+      await expect(`
+        ##! experimental.parameters
+        source: s(x::string) is duckdb.table('malloytest.state_facts') extend {
+          where: x = 'CA'
+        }
+        run: s(x is "foo") -> { select: * }
+      `).toEmitDuringCompile(runtime, {
+        id: 'source-argument-compiled',
+        data: {name: 'x'},
+      });
+    });
+    test('parameterized source compiled event is emitted when source is used', async () => {
+      await expect(`
+        ##! experimental.parameters
+        source: s(x::string) is duckdb.table('malloytest.state_facts') extend {
+          where: x = 'CA'
+        }
+        run: s(x is "foo") -> { select: * }
+      `).toEmitDuringCompile(runtime, {
+        id: 'parameterized-source-compiled',
+        data: {parameters: {x: {type: 'string'}}},
+      });
+    });
+    test('parameterized source compiled event is not emitted when source is not used', async () => {
+      await expect(`
+        ##! experimental.parameters
+        source: a(used::string) is duckdb.table('malloytest.state_facts') extend {
+          where: used = 'CA'
+        }
+        source: b(unused::string) is duckdb.table('malloytest.state_facts') extend {
+          where: unused = 'CA'
+        }
+        run: a(used is "foo") -> { select: * }
+      `).toEmitDuringCompile(runtime, {
+        id: 'parameterized-source-compiled',
+        data: {parameters: {used: {type: 'string'}}},
+      });
+    });
+    test('parameterized source compiled event is emitted when join is used', async () => {
+      await expect(`
+        ##! experimental.parameters
+        source: s0(x::string) is duckdb.table('malloytest.state_facts') extend {
+          where: x = 'CA'
+        }
+        source: s1 is duckdb.table('malloytest.state_facts') extend {
+          join_one: s0(x is "foo") on 1 = 1
+        }
+        run: s1 -> { select: s0.state }
+      `).toEmitDuringCompile(runtime, {
+        id: 'parameterized-source-compiled',
+        data: {parameters: {x: {type: 'string'}}},
+      });
+    });
+  });
+  describe('for joins', () => {
+    test('join usage is emitted', async () => {
+      await expect(`
+        ##! experimental.parameters
+        source: s0(x::string) is duckdb.table('malloytest.state_facts') extend {
+          where: x = 'CA'
+        }
+        source: s1 is duckdb.table('malloytest.state_facts') extend {
+          join_one: s0(x is "foo") on 1 = 1
+          join_one: s0_copy is s0(x is "bar") on 1 = 1
+        }
+        run: s1 -> {
+          select: s0_copy.state
+          select: foo is s0_copy.state // only should be emitted once
+        }
+      `).toEmitDuringCompile(runtime, {
+        id: 'join-used',
+        data: {name: 's0_copy'},
+      });
+    });
+  });
+  describe('for errors', () => {
+    test('translator errors are emitted', async () => {
+      await expect(`
+        source: s1 is duckdb.table('malloytest.state_facts') extend {
+          dimension: foo is pick "foo" when 1 = 1 else 2
+        }
+        run: s1 -> { select: foo }
+      `).toEmitDuringTranslation(runtime, {
+        id: 'translation-error',
+        data: {
+          code: 'pick-else-type-does-not-match',
+          data: {
+            elseType: 'number',
+            returnType: 'string',
+          },
+          message: 'else type `number` does not match return type `string`',
+        },
+      });
+    });
+  });
+});

package/src/runtimes.ts

@@ -38,6 +38,7 @@ import {PooledPostgresConnection} from '@malloydata/db-postgres';
 import {TrinoConnection, TrinoExecutor} from '@malloydata/db-trino';
 import {SnowflakeExecutor} from '@malloydata/db-snowflake/src/snowflake_executor';
 import {PrestoConnection} from '@malloydata/db-trino/src/trino_connection';
+import {EventEmitter} from 'events';
 
 export class SnowflakeTestConnection extends SnowflakeConnection {
   public async runSQL(
@@ -193,7 +194,7 @@ export function runtimeFor(dbName: string): SingleConnectionRuntime {
 }
 
 export function testRuntimeFor(connection: Connection) {
-  return new SingleConnectionRuntime(files, connection);
+  return new SingleConnectionRuntime(files, connection, new EventEmitter());
 }
 
 /**

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

@@ -31,12 +31,19 @@ import {
   LogMessage,
   SingleConnectionRuntime,
 } from '@malloydata/malloy';
+import EventEmitter from 'events';
 import {inspect} from 'util';
 
 type ExpectedResultRow = Record<string, unknown>;
 type ExpectedResult = ExpectedResultRow | ExpectedResultRow[];
 type Runner = Runtime | ModelMaterializer;
 
+interface ExpectedEvent {
+  id: string;
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  data: any;
+}
+
 declare global {
   // eslint-disable-next-line @typescript-eslint/no-namespace
   namespace jest {
@@ -72,6 +79,14 @@ declare global {
         runtime: Runner,
         matchVals: ExpectedResult
       ): Promise<R>;
+      toEmitDuringCompile(
+        runtime: Runtime,
+        ...events: ExpectedEvent[]
+      ): Promise<R>;
+      toEmitDuringTranslation(
+        runtime: Runtime,
+        ...events: ExpectedEvent[]
+      ): Promise<R>;
     }
   }
 }
@@ -130,6 +145,7 @@ expect.extend({
 
     const queryTags = (await query.getPreparedQuery()).tagParse().tag;
     const queryTestTag = queryTags.tag('test');
+
     let result: Result;
     try {
       result = await query.run();
@@ -217,8 +233,82 @@ expect.extend({
       message: () => 'All rows matched expected results',
     };
   },
+  async toEmitDuringCompile(
+    querySrc: string,
+    runtime: Runtime,
+    ...expectedEvents: ExpectedEvent[]
+  ) {
+    return toEmit(this, querySrc, 'compile', runtime, ...expectedEvents);
+  },
+  async toEmitDuringTranslation(
+    querySrc: string,
+    runtime: Runtime,
+    ...expectedEvents: ExpectedEvent[]
+  ) {
+    return toEmit(this, querySrc, 'translate', runtime, ...expectedEvents);
+  },
 });
 
+async function toEmit(
+  context: jest.MatcherContext,
+  querySrc: string,
+  when: 'compile' | 'translate',
+  runtime: Runtime,
+  ...expectedEvents: ExpectedEvent[]
+) {
+  const eventStream = runtime.eventStream;
+  if (eventStream === undefined) {
+    return {
+      pass: false,
+      message: () => 'No event stream found',
+    };
+  }
+  if (!(eventStream instanceof EventEmitter)) {
+    return {
+      pass: false,
+      message: () => 'Event stream is not an EventEmitter',
+    };
+  }
+  const gotEvents: ExpectedEvent[] = [];
+  const eventIdsWeCareAbout = new Set(expectedEvents.map(e => e.id));
+  for (const id of eventIdsWeCareAbout) {
+    eventStream.on(id, data => {
+      gotEvents.push({id, data});
+    });
+  }
+  const model = runtime.loadModel(querySrc, {
+    noThrowOnError: when === 'translate',
+  });
+  if (when === 'compile') {
+    const query = model.loadFinalQuery();
+    await query.getPreparedResult();
+  } else {
+    await model.getModel();
+  }
+
+  let matching = gotEvents.length === expectedEvents.length;
+  if (matching) {
+    for (let i = 0; i < expectedEvents.length; i++) {
+      const got = gotEvents[i];
+      const want = expectedEvents[i];
+      matching &&= objectsMatch(got, want);
+    }
+  }
+
+  if (!matching) {
+    return {
+      pass: false,
+      message: () =>
+        `Expected events ${context.utils.diff(expectedEvents, gotEvents)}`,
+    };
+  }
+
+  return {
+    pass: true,
+    message: () => 'All rows matched expected results',
+  };
+}
+
 function errorLogToString(src: string, msgs: LogMessage[]) {
   let lovely = '';
   let lineNo = 0;
@@ -240,3 +330,44 @@ function errorLogToString(src: string, msgs: LogMessage[]) {
 function humanReadable(thing: unknown): string {
   return inspect(thing, {breakLength: 72, depth: Infinity});
 }
+
+// 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
+function objectsMatch(a: unknown, b: unknown): boolean {
+  if (
+    typeof b === 'string' ||
+    typeof b === 'number' ||
+    typeof b === 'boolean' ||
+    typeof b === 'bigint' ||
+    b === undefined ||
+    b === null
+  ) {
+    return b === a;
+  } else if (Array.isArray(b)) {
+    if (Array.isArray(a)) {
+      return a.length === b.length && a.every((v, i) => objectsMatch(v, b[i]));
+    }
+    return false;
+  } else {
+    if (
+      typeof a === 'string' ||
+      typeof a === 'number' ||
+      typeof a === 'boolean' ||
+      typeof a === 'bigint' ||
+      a === undefined ||
+      a === null
+    ) {
+      return false;
+    }
+    if (Array.isArray(a)) return false;
+    const keys = Object.keys(b);
+    for (const key of keys) {
+      if (!objectsMatch(a[key], b[key])) {
+        return false;
+      }
+    }
+    return true;
+  }
+}