@malloydata/malloy-tests 0.0.69-dev230808200646 → 0.0.69

package/src/databases/all/orderby.spec.ts

@@ -24,12 +24,235 @@
 
 import {RuntimeList, allDatabases} from '../../runtimes';
 import {databasesFromEnvironmentOr} from '../../util';
-import {orderBySharedTests} from '../shared/orderby';
+import '../../util/db-jest-matchers';
+import * as malloy from '@malloydata/malloy';
 
 const runtimes = new RuntimeList(databasesFromEnvironmentOr(allDatabases));
 
-/*
- * This test file reuses common tests definitions.
- * For actual test development please go to: test/src/databases/shared/orderby.spec.ts
- */
-orderBySharedTests(runtimes);
+afterAll(async () => {
+  await runtimes.closeAll();
+});
+
+async function validateCompilation(
+  databaseName: string,
+  sql: string
+): Promise<boolean> {
+  try {
+    const runtime = runtimes.runtimeMap.get(databaseName);
+    if (runtime === undefined) {
+      throw new Error(`Unknown database ${databaseName}`);
+    }
+    await (
+      await runtime.connections.lookupConnection(databaseName)
+    ).runSQL(`WITH test AS(\n${sql}) SELECT '[{"foo":1}]' as results`);
+  } catch (e) {
+    console.log(`SQL: didn't compile\n=============\n${sql}`);
+    throw e;
+  }
+  return true;
+}
+
+const expressionModels = new Map<string, malloy.ModelMaterializer>();
+runtimes.runtimeMap.forEach((runtime, databaseName) =>
+  expressionModels.set(
+    databaseName,
+    runtime.loadModel(`
+    source: models is table('malloytest.aircraft_models'){
+      measure: model_count is count()
+    }
+  `)
+  )
+);
+
+expressionModels.forEach((orderByModel, databaseName) => {
+  it(`boolean type - ${databaseName}`, async () => {
+    const result = await orderByModel
+      .loadQuery(
+        `
+        query: models-> {
+          group_by: big is seats >=20
+          aggregate: model_count is count()
+        }
+        `
+      )
+      .run();
+    expect(result.data.row(0).cell('big').value).toBe(false);
+    expect(result.data.row(0).cell('model_count').value).toBe(58451);
+  });
+
+  it(`boolean in pipeline - ${databaseName}`, async () => {
+    const result = await orderByModel
+      .loadQuery(
+        `
+        query: models->{
+          group_by:
+            manufacturer,
+            big is seats >=21
+          aggregate: model_count is count()
+        }->{
+          group_by: big
+          aggregate: model_count is model_count.sum()
+        }
+        `
+      )
+      .run();
+    expect(result.data.row(0).cell('big').value).toBe(false);
+    expect(result.data.row(0).cell('model_count').value).toBe(58500);
+  });
+
+  it(`filtered measures in model are aggregates #352 - ${databaseName}`, async () => {
+    const result = await orderByModel
+      .loadQuery(
+        `
+        query: models->{
+          aggregate: j_names is model_count {where: manufacturer ~ 'J%'}
+        }
+        -> {
+          group_by: j_names
+        }
+        `
+      )
+      .run();
+    expect(result.data.row(0).cell('j_names').value).toBe(1358);
+  });
+
+  it(`reserved words are quoted - ${databaseName}`, async () => {
+    const sql = await orderByModel
+      .loadQuery(
+        `
+      query: models->{
+        aggregate: fetch is count()
+      }->{
+        group_by: fetch
+      }
+      `
+      )
+      .getSQL();
+    await validateCompilation(databaseName, sql);
+  });
+
+  it(`reserved words are quoted in turtles - ${databaseName}`, async () => {
+    const sql = await orderByModel
+      .loadQuery(
+        `
+      query: models->{
+        nest: withx is {
+          group_by: select is UPPER(manufacturer)
+          aggregate: fetch is count()
+        }
+      } -> {
+        project:
+          withxz is lower(withx.select)
+          fetch is withx.fetch
+      }
+      `
+      )
+      .getSQL();
+    await validateCompilation(databaseName, sql);
+  });
+
+  it.skip('reserved words in structure definitions', async () => {
+    const sql = await orderByModel
+      .loadQuery(
+        `
+      query: models->{
+        nest: withx is {
+          group_by: is select is UPPER(manufacturer)
+          aggregate: fetch is count()
+        }
+      } -> {
+        project: withxis lower(withx.select)
+        project: fetch is with.fetch
+      }
+      `
+      )
+      .getSQL();
+    await validateCompilation(databaseName, sql);
+  });
+
+  it(`aggregate and scalar conditions - ${databaseName}`, async () => {
+    const sql = await orderByModel
+      .loadQuery(
+        `
+      query: models->{
+        aggregate: model_count is count(){? manufacturer ? ~'A%' }
+      }
+      `
+      )
+      .getSQL();
+    await validateCompilation(databaseName, sql);
+  });
+
+  // I'm not sure I have the syntax right here...
+  it(`modeled having simple - ${databaseName}`, async () => {
+    const result = await orderByModel
+      .loadQuery(
+        `
+        source: popular_names is from(models->{
+          having: model_count > 100
+          group_by: manufacturer
+          aggregate: model_count
+        })
+
+        query: popular_names->{
+          order_by: 2
+          project: manufacturer, model_count
+        }
+        `
+      )
+      .run();
+    expect(result.data.row(0).cell('model_count').value).toBe(102);
+  });
+
+  it(`modeled having complex - ${databaseName}`, async () => {
+    const result = await orderByModel
+      .loadQuery(
+        `
+        source: popular_names is from(models->{
+          having: model_count > 100
+          group_by: manufacturer
+          aggregate: model_count
+          nest: l is {
+            top: 5
+            group_by: manufacturer
+            aggregate: model_count
+          }
+        })
+
+        query: popular_names->{
+         order_by: 2
+         project: manufacturer, model_count
+        }
+        `
+      )
+      .run();
+    expect(result.data.row(0).cell('model_count').value).toBe(102);
+  });
+
+  it(`turtle references joined element - ${databaseName}`, async () => {
+    const sql = await orderByModel
+      .loadQuery(
+        `
+    source: a is table('malloytest.aircraft'){
+      primary_key: tail_num
+      measure: aircraft_count is count(*)
+    }
+
+    source: f is table('malloytest.flights'){
+      primary_key: id2
+      join_one: a with tail_num
+
+      measure: flight_count is count()
+      query: foo is {
+        group_by: carrier
+        aggregate: flight_count
+        aggregate: a.aircraft_count
+      }
+    }
+    query: f->foo
+  `
+      )
+      .getSQL();
+    await validateCompilation(databaseName, sql);
+  });
+});

package/src/databases/all/problems.spec.ts

@@ -24,12 +24,88 @@
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 import {RuntimeList, allDatabases} from '../../runtimes';
 import {databasesFromEnvironmentOr} from '../../util';
-import {problemsSharedTests} from '../shared/problems';
+import '../../util/db-jest-matchers';
 
 const runtimes = new RuntimeList(databasesFromEnvironmentOr(allDatabases));
 
-/*
- * This test file reuses common tests definitions.
- * For actual test development please go to: test/src/databases/shared/problems.spec.ts
- */
-problemsSharedTests(runtimes);
+afterAll(async () => {
+  await runtimes.closeAll();
+});
+
+async function getError<T>(fn: () => Promise<T>) {
+  try {
+    await fn();
+  } catch (error) {
+    return error;
+  }
+}
+
+runtimes.runtimeMap.forEach((runtime, databaseName) => {
+  describe('warnings', () => {
+    // Today we don't show errors after the first model entry with an error,
+    // so this can't work yet.
+    it.skip(`can appear after errors - ${databaseName}`, async () => {
+      const source = `
+        source: foo is table('asdfds');
+        source: bar is table('malloytest.state_facts') {
+          dimension: a is LENGTH('foo')
+        }
+      `;
+      const error = await getError(() => runtime.getModel(source));
+      expect(error).not.toBeUndefined();
+      expect(error).toMatchObject({
+        problems: [
+          {
+            severity: 'error',
+          },
+          {
+            message:
+              "Case insensitivity for function names is deprecated, use 'length' instead",
+            severity: 'warn',
+          },
+        ],
+      });
+    });
+
+    it(`can appear before errors - ${databaseName}`, async () => {
+      const source = `
+        source: bar is table('malloytest.state_facts') {
+          dimension: a is LENGTH('foo')
+        }
+        source: foo is table('asdfds');
+      `;
+      const error = await getError(() => runtime.getModel(source));
+      expect(error).not.toBeUndefined();
+      expect(error).toMatchObject({
+        problems: [
+          {
+            message:
+              "Case insensitivity for function names is deprecated, use 'length' instead",
+            severity: 'warn',
+          },
+          {
+            severity: 'error',
+          },
+        ],
+      });
+    });
+
+    it(`can appear alone - ${databaseName}`, async () => {
+      const source = `
+        source: bar is table('malloytest.state_facts') {
+          dimension: a is LENGTH('foo')
+        }
+      `;
+      const model = await runtime.getModel(source);
+      expect(model).toMatchObject({
+        problems: [
+          {
+            message:
+              "Case insensitivity for function names is deprecated, use 'length' instead",
+            severity: 'warn',
+          },
+        ],
+      });
+    });
+  });
+});

package/src/databases/all/sql_expressions.spec.ts

@@ -26,12 +26,71 @@
 
 import {RuntimeList, allDatabases} from '../../runtimes';
 import {databasesFromEnvironmentOr} from '../../util';
-import {sqlExpressionsSharedTests} from '../shared/sql_expressions';
+import '../../util/db-jest-matchers';
+// No prebuilt shared model, each test is complete.  Makes debugging easier.
 
 const runtimes = new RuntimeList(databasesFromEnvironmentOr(allDatabases));
 
-/*
- * This test file reuses common tests definitions.
- * For actual test development please go to: test/src/databases/shared/sql_expressions.spec.ts
- */
-sqlExpressionsSharedTests(runtimes);
+afterAll(async () => {
+  await runtimes.closeAll();
+});
+
+runtimes.runtimeMap.forEach((runtime, databaseName) => {
+  it(`sql expression with turducken - ${databaseName}`, async () => {
+    const result = await runtime
+      .loadQuery(
+        `
+        run: ${databaseName}.sql(
+          """SELECT * FROM (%{
+            ${databaseName}.table('malloytest.state_facts') -> {
+              aggregate: c is count()
+            }
+          }) AS state_facts """
+        ) -> {
+          project: *
+        }
+      `
+      )
+      .run();
+    expect(result.data.value[0]['c']).toBe(51);
+  });
+  it(`sql expression in second of two queries in same block, dependent on first query - ${databaseName}`, async () => {
+    const result = await runtime
+      .loadQuery(
+        `
+        query:
+          a is ${databaseName}.table('malloytest.state_facts') -> {
+            aggregate: c is count()
+          }
+          b is ${databaseName}.sql(
+            """SELECT * FROM (%{ -> a -> { project: * } }) AS state_facts """
+          ) -> {
+            project: *
+          }
+        run: b
+      `
+      )
+      .run();
+    expect(result.data.value[0]['c']).toBe(51);
+  });
+  it(`sql expression in other sql expression - ${databaseName}`, async () => {
+    const result = await runtime
+      .loadQuery(
+        `
+        run: ${databaseName}.sql("""
+          SELECT * from (%{
+            ${databaseName}.sql("""SELECT 1 as one""") -> { group_by: one }
+          }) as the_table
+        """) -> { group_by: one }
+      `
+      )
+      .run();
+    expect(result.data.value[0]['one']).toBe(1);
+  });
+  it(`run sql expression as query - ${databaseName}`, async () => {
+    const result = await runtime
+      .loadQuery(`run: ${databaseName}.sql("""SELECT 1 as one""")`)
+      .run();
+    expect(result.data.value[0]['one']).toBe(1);
+  });
+});