@malloydata/malloy-tests 0.0.95-dev231019211822 → 0.0.95

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

@@ -23,9 +23,8 @@
  */
 
 import {RuntimeList, allDatabases} from '../../runtimes';
-import {databasesFromEnvironmentOr} from '../../util';
+import {databasesFromEnvironmentOr, testIf} from '../../util';
 import '../../util/db-jest-matchers';
-import * as malloy from '@malloydata/malloy';
 
 const runtimes = new RuntimeList(databasesFromEnvironmentOr(allDatabases));
 
@@ -33,109 +32,64 @@ 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'){
+describe.each(runtimes.runtimeList)('%s', (databaseName, runtime) => {
+  const orderByModel = runtime.loadModel(`
+    source: models is ${databaseName}.table('malloytest.aircraft_models') extend {
       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);
+    await expect(`
+      run: models-> {
+        group_by: big is seats >=20
+        aggregate: model_count is count()
+      }
+    `).malloyResultMatches(orderByModel, {
+      big: false,
+      model_count: 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);
+    await expect(`
+      run: models->{
+        group_by:
+          manufacturer,
+          big is seats >=21
+        aggregate: model_count is count()
+      }->{
+        group_by: big
+        aggregate: model_count is model_count.sum()
+      }
+    `).malloyResultMatches(orderByModel, {
+      big: false,
+      model_count: 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);
+    await expect(`
+      run: models->{
+        aggregate: j_names is model_count {where: manufacturer ~ 'J%'}
+      } -> {
+        group_by: j_names
+      }
+    `).malloyResultMatches(orderByModel, {j_names: 1358});
   });
 
   it(`reserved words are quoted - ${databaseName}`, async () => {
-    const sql = await orderByModel
-      .loadQuery(
-        `
-      query: models->{
+    await expect(`
+      run: models->{
         aggregate: fetch is count()
       }->{
         group_by: fetch
       }
-      `
-      )
-      .getSQL();
-    await validateCompilation(databaseName, sql);
+    `).malloyResultMatches(orderByModel, {});
   });
 
   it(`reserved words are quoted in turtles - ${databaseName}`, async () => {
-    const sql = await orderByModel
-      .loadQuery(
-        `
-      query: models->{
+    await expect(`
+      run: models->{
         nest: withx is {
           group_by: select is UPPER(manufacturer)
           aggregate: fetch is count()
@@ -145,17 +99,12 @@ expressionModels.forEach((orderByModel, databaseName) => {
           withxz is lower(withx.select)
           fetch is withx.fetch
       }
-      `
-      )
-      .getSQL();
-    await validateCompilation(databaseName, sql);
+    `).malloyResultMatches(orderByModel, {});
   });
 
   it.skip('reserved words in structure definitions', async () => {
-    const sql = await orderByModel
-      .loadQuery(
-        `
-      query: models->{
+    await expect(`
+      run: models->{
         nest: withx is {
           group_by: is select is UPPER(manufacturer)
           aggregate: fetch is count()
@@ -164,51 +113,37 @@ expressionModels.forEach((orderByModel, databaseName) => {
         select: withxis lower(withx.select)
         select: fetch is with.fetch
       }
-      `
-      )
-      .getSQL();
-    await validateCompilation(databaseName, sql);
+    `).malloyResultMatches(orderByModel, {});
   });
 
   it(`aggregate and scalar conditions - ${databaseName}`, async () => {
-    const sql = await orderByModel
-      .loadQuery(
-        `
-      query: models->{
-        aggregate: model_count is count(){? manufacturer ? ~'A%' }
+    await expect(`
+      run: models->{
+        aggregate: model_count is count(){ where: manufacturer ? ~'A%' }
       }
-      `
-      )
-      .getSQL();
-    await validateCompilation(databaseName, sql);
+    `).malloyResultMatches(orderByModel, {});
   });
 
   // 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
-          select: manufacturer, model_count
-        }
-        `
-      )
-      .run();
-    expect(result.data.row(0).cell('model_count').value).toBe(102);
+    await expect(`
+      source: popular_names is models->{
+        having: model_count > 100
+        group_by: manufacturer
+        aggregate: model_count
+      }
+      run: popular_names->{
+        order_by: 2
+        select: manufacturer, model_count
+      }
+    `).malloyResultMatches(orderByModel, {model_count: 102});
   });
 
-  it(`modeled having complex - ${databaseName}`, async () => {
-    const result = await orderByModel
-      .loadQuery(
-        `
-        source: popular_names is from(models->{
+  testIf(runtime.supportsNesting)(
+    `modeled having complex - ${databaseName}`,
+    async () => {
+      await expect(`
+        source: popular_names is models->{
           having: model_count > 100
           group_by: manufacturer
           aggregate: model_count
@@ -217,42 +152,33 @@ expressionModels.forEach((orderByModel, databaseName) => {
             group_by: manufacturer
             aggregate: model_count
           }
-        })
-
-        query: popular_names->{
-         order_by: 2
-         select: manufacturer, model_count
         }
-        `
-      )
-      .run();
-    expect(result.data.row(0).cell('model_count').value).toBe(102);
-  });
+        run: popular_names->{
+          order_by: 2
+          select: manufacturer, model_count
+        }
+      `).malloyResultMatches(orderByModel, {model_count: 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()
-    }
+    await expect(`
+      source: a is ${databaseName}.table('malloytest.aircraft') extend {
+        primary_key: tail_num
+        measure: aircraft_count is count()
+      }
 
-    source: f is table('malloytest.flights'){
-      primary_key: id2
-      join_one: a with tail_num
+      run: ${databaseName}.table('malloytest.flights') extend {
+        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);
+        measure: flight_count is count()
+        view: foo is {
+          group_by: carrier
+          aggregate: flight_count
+          aggregate: a.aircraft_count
+        }
+      } -> foo
+    `).malloyResultMatches(orderByModel, {});
   });
 });

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

@@ -37,60 +37,40 @@ afterAll(async () => {
 
 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 """
-        ) -> {
-          select: *
-        }
-      `
-      )
-      .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') -> {
+    await expect(`
+      run: ${databaseName}.sql(
+        """SELECT * FROM (%{
+          ${databaseName}.table('malloytest.state_facts') -> {
             aggregate: c is count()
           }
-          b is ${databaseName}.sql(
-            """SELECT * FROM (%{ -> a -> { select: * } }) AS state_facts """
-          ) -> {
-            select: *
-          }
-        run: b
-      `
-      )
-      .run();
-    expect(result.data.value[0]['c']).toBe(51);
+        }) AS state_facts """
+      ) -> { select: * }
+    `).malloyResultMatches(runtime, {c: 51});
+  });
+  it(`sql expression in second of two queries in same block, dependent on first query - ${databaseName}`, async () => {
+    await expect(`
+      query:
+        a is ${databaseName}.table('malloytest.state_facts') -> {
+          aggregate: c is count()
+        }
+        b is ${databaseName}.sql(
+          """SELECT * FROM (%{ a -> { select: * } }) AS state_facts """
+        ) -> { select: * }
+      run: b
+    `).malloyResultMatches(runtime, {c: 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);
+    await expect(`
+      run: ${databaseName}.sql("""
+        SELECT * from (%{
+          ${databaseName}.sql("""SELECT 1 as one""") -> { group_by: one }
+        }) as the_table
+      """) -> { group_by: one }
+    `).malloyResultMatches(runtime, {one: 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);
+    await expect(
+      `run: ${databaseName}.sql("""SELECT 1 as one""")`
+    ).malloyResultMatches(runtime, {one: 1});
   });
 });