@malloydata/malloy-tests 0.0.127-dev240307031210 → 0.0.127-dev240309202055

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

@@ -25,7 +25,7 @@
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 
 import {RuntimeList, allDatabases} from '../../runtimes';
-import {databasesFromEnvironmentOr, testIf} from '../../util';
+import {databasesFromEnvironmentOr, onlyIf} from '../../util';
 import '../../util/db-jest-matchers';
 
 const runtimes = new RuntimeList(databasesFromEnvironmentOr(allDatabases));
@@ -526,9 +526,9 @@ runtimes.runtimeMap.forEach((runtime, databaseName) => {
     });
   });
 
-  testIf(runtime.supportsNesting)(
-    `number as null- ${databaseName}`,
-    async () => {
+  test(
+    `number as null 2 - ${databaseName}`,
+    onlyIf(runtime.supportsNesting, async () => {
       // a cross join produces a Many to Many result.
       // symmetric aggregate are needed on both sides of the join
       // Check the row count and that sums on each side work properly.
@@ -541,7 +541,7 @@ runtimes.runtimeMap.forEach((runtime, databaseName) => {
           }
         }
       `).malloyResultMatches(runtime, {'ugly.foo': null});
-    }
+    })
   );
 
   // average should only include non-null values in the denominator
@@ -586,9 +586,9 @@ runtimes.runtimeMap.forEach((runtime, databaseName) => {
       }`).malloyResultMatches(runtime, {births_per_100k: 9742});
   });
 
-  testIf(runtime.supportsNesting)(
+  test(
     `ungrouped top level with nested  - ${databaseName}`,
-    async () => {
+    onlyIf(runtime.supportsNesting, async () => {
       await expect(`
       run: ${databaseName}.table('malloytest.state_facts') extend {
         measure: total_births is births.sum()
@@ -602,7 +602,7 @@ runtimes.runtimeMap.forEach((runtime, databaseName) => {
         }
         limit: 1000
       }`).malloyResultMatches(runtime, {births_per_100k: 9742});
-    }
+    })
   );
 
   it(`ungrouped - eliminate rows  - ${databaseName}`, async () => {
@@ -620,9 +620,9 @@ runtimes.runtimeMap.forEach((runtime, databaseName) => {
     ]);
   });
 
-  testIf(runtime.supportsNesting)(
+  test(
     `ungrouped nested with no grouping above - ${databaseName}`,
-    async () => {
+    onlyIf(runtime.supportsNesting, async () => {
       await expect(`
         run: ${databaseName}.table('malloytest.state_facts') extend {
           measure: total_births is births.sum()
@@ -634,12 +634,12 @@ runtimes.runtimeMap.forEach((runtime, databaseName) => {
             aggregate: births_per_100k
           }
         }`).malloyResultMatches(runtime, {'by_name.births_per_100k': 66703});
-    }
+    })
   );
 
-  testIf(runtime.supportsNesting)(
+  test(
     `ungrouped - partial grouping - ${databaseName}`,
-    async () => {
+    onlyIf(runtime.supportsNesting, async () => {
       await expect(`
         run: ${databaseName}.table('malloytest.airports') extend {
           measure: c is count()
@@ -668,12 +668,12 @@ runtimes.runtimeMap.forEach((runtime, databaseName) => {
         'fac_type.all_of_this_type': 1782,
         'fac_type.all_top': 2421,
       });
-    }
+    })
   );
 
-  testIf(runtime.supportsNesting)(
+  test(
     `ungrouped - all nested - ${databaseName}`,
-    async () => {
+    onlyIf(runtime.supportsNesting, async () => {
       await expect(`
         run: ${databaseName}.table('malloytest.airports') extend {
           measure: c is count()
@@ -697,12 +697,12 @@ runtimes.runtimeMap.forEach((runtime, databaseName) => {
         'fac_type.all_': 1845,
         'fac_type.all_major': 1819,
       });
-    }
+    })
   );
 
-  testIf(runtime.supportsNesting)(
+  test(
     `ungrouped nested  - ${databaseName}`,
-    async () => {
+    onlyIf(runtime.supportsNesting, async () => {
       await expect(`
         run: ${databaseName}.table('malloytest.state_facts') extend {
           measure: total_births is births.sum()
@@ -715,12 +715,12 @@ runtimes.runtimeMap.forEach((runtime, databaseName) => {
           }
         }
       `).malloyResultMatches(runtime, {'by_state.births_per_100k': 36593});
-    }
+    })
   );
 
-  testIf(runtime.supportsNesting)(
+  test(
     `ungrouped nested expression  - ${databaseName}`,
-    async () => {
+    onlyIf(runtime.supportsNesting, async () => {
       await expect(`
         run: ${databaseName}.table('malloytest.state_facts') extend {
           measure: total_births is births.sum()
@@ -733,12 +733,12 @@ runtimes.runtimeMap.forEach((runtime, databaseName) => {
           }
         }
       `).malloyResultMatches(runtime, {'by_state.births_per_100k': 36593});
-    }
+    })
   );
 
-  testIf(runtime.supportsNesting)(
+  test(
     `ungrouped nested group by float  - ${databaseName}`,
-    async () => {
+    onlyIf(runtime.supportsNesting, async () => {
       await expect(`
         run: ${databaseName}.table('malloytest.state_facts') extend {
           measure: total_births is births.sum()
@@ -751,7 +751,7 @@ runtimes.runtimeMap.forEach((runtime, databaseName) => {
           }
         }
       `).malloyResultMatches(runtime, {'by_state.ug': 62742230});
-    }
+    })
   );
 
   it(`run simple sql - ${databaseName}`, async () => {
@@ -818,9 +818,9 @@ SELECT row_to_json(finalStage) as row FROM __stage0 AS finalStage`);
     });
   });
 
-  testIf(runtime.supportsNesting)(
+  test(
     `all with parameters - nest  - ${databaseName}`,
-    async () => {
+    onlyIf(runtime.supportsNesting, async () => {
       await expect(`
         run: ${databaseName}.table('malloytest.state_facts') extend {
           measure: total_births is births.sum()
@@ -840,26 +840,31 @@ SELECT row_to_json(finalStage) as row FROM __stage0 AS finalStage`);
         'by_stuff.all_births': 119809719,
         'by_stuff.all_name': 61091215,
       });
-    }
+    })
   );
 
-  testIf(runtime.supportsNesting)(
+  test(
     `single value to udf - ${databaseName}`,
-    async () => {
-      await expect(`
+    onlyIf(
+      runtime.supportsNesting && runtime.dialect.supportsPipelinesInViews,
+      async () => {
+        await expect(`
         run: ${databaseName}.table('malloytest.state_facts') extend {
           view: fun is {
             aggregate: t is count()
           } -> { select: t1 is t+1 }
         } -> { nest: fun }
       `).malloyResultMatches(runtime, {'fun.t1': 52});
-    }
+      }
+    )
   );
 
-  testIf(runtime.supportsNesting)(
+  test(
     `Multi value to udf - ${databaseName}`,
-    async () => {
-      await expect(`
+    onlyIf(
+      runtime.supportsNesting && runtime.dialect.supportsPipelinesInViews,
+      async () => {
+        await expect(`
         run: ${databaseName}.table('malloytest.state_facts') extend {
           view: fun is {
             group_by: one is 1
@@ -869,13 +874,16 @@ SELECT row_to_json(finalStage) as row FROM __stage0 AS finalStage`);
           nest: fun
         }
       `).malloyResultMatches(runtime, {'fun.t1': 52});
-    }
+      }
+    )
   );
 
-  testIf(runtime.supportsNesting)(
+  test(
     `Multi value to udf group by - ${databaseName}`,
-    async () => {
-      await expect(`
+    onlyIf(
+      runtime.supportsNesting && runtime.dialect.supportsPipelinesInViews,
+      async () => {
+        await expect(`
         run: ${databaseName}.table('malloytest.state_facts') extend {
           view: fun is {
             group_by: one is 1
@@ -885,7 +893,8 @@ SELECT row_to_json(finalStage) as row FROM __stage0 AS finalStage`);
           nest: fun
         }
       `).malloyResultMatches(runtime, {'fun.t1': 52});
-    }
+      }
+    )
   );
 
   const sql1234 = `${databaseName}.sql('SELECT 1 as ${q`a`}, 2 as ${q`b`} UNION ALL SELECT 3, 4')`;
@@ -978,11 +987,13 @@ SELECT row_to_json(finalStage) as row FROM __stage0 AS finalStage`);
       `).malloyResultMatches(runtime, {x: 30});
   });
 
-  testIf(runtime.supportsNesting)(
+  test(
     `array unnest - ${databaseName}`,
-    async () => {
-      const splitFN = getSplitFunction(databaseName);
-      await expect(`
+    onlyIf(
+      runtime.supportsNesting && runtime.dialect.supportsArraysInData,
+      async () => {
+        const splitFN = getSplitFunction(databaseName);
+        await expect(`
       run: ${databaseName}.sql("""
         SELECT
           ${q`city`},
@@ -994,15 +1005,18 @@ SELECT row_to_json(finalStage) as row FROM __stage0 AS finalStage`);
         aggregate: c is count()
       }
       `).malloyResultMatches(runtime, {c: 145});
-    }
+      }
+    )
   );
 
   // make sure we can count the total number of elements when fanning out.
-  testIf(runtime.supportsNesting)(
+  test(
     `array unnest x 2 - ${databaseName}`,
-    async () => {
-      const splitFN = getSplitFunction(databaseName);
-      await expect(`
+    onlyIf(
+      runtime.supportsNesting && runtime.dialect.supportsArraysInData,
+      async () => {
+        const splitFN = getSplitFunction(databaseName);
+        await expect(`
       run: ${databaseName}.sql("""
         SELECT
           ${q`city`},
@@ -1016,13 +1030,16 @@ SELECT row_to_json(finalStage) as row FROM __stage0 AS finalStage`);
           c is words.count()
           a is abreak.count()
       }`).malloyResultMatches(runtime, {b: 3552, c: 4586, a: 6601});
-    }
+      }
+    )
   );
 
-  testIf(runtime.supportsNesting)(`nest null - ${databaseName}`, async () => {
-    const result = await runtime
-      .loadQuery(
-        `
+  test(
+    `nest null - ${databaseName}`,
+    onlyIf(runtime.supportsNesting, async () => {
+      const result = await runtime
+        .loadQuery(
+          `
         run: ${databaseName}.table('malloytest.airports') -> {
           where: faa_region = null
           group_by: faa_region
@@ -1040,18 +1057,19 @@ SELECT row_to_json(finalStage) as row FROM __stage0 AS finalStage`);
           }
         }
       `
-      )
-      .run();
+        )
+        .run();
 
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    const d: any = result.data.toObject();
-    expect(d[0]['by_state']).not.toBe(null);
-    expect(d[0]['by_state1']).not.toBe(null);
-  });
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      const d: any = result.data.toObject();
+      expect(d[0]['by_state']).not.toBe(null);
+      expect(d[0]['by_state1']).not.toBe(null);
+    })
+  );
 
-  testIf(runtime.supportsNesting)(
+  test(
     `number as null- ${databaseName}`,
-    async () => {
+    onlyIf(runtime.supportsNesting, async () => {
       const result = await runtime
         .loadQuery(
           `
@@ -1068,7 +1086,7 @@ SELECT row_to_json(finalStage) as row FROM __stage0 AS finalStage`);
         )
         .run();
       expect(result.data.path(0, 'ugly', 0, 'foo').value).toBe(null);
-    }
+    })
   );
 
   it(`removes surpuflous order_by - solo aggregates - ${databaseName}`, async () => {
@@ -1155,21 +1173,23 @@ SELECT row_to_json(finalStage) as row FROM __stage0 AS finalStage`);
     const back = '\\';
     test('backslash quote', async () => {
       await expect(`
-        run: ${databaseName}.sql('SELECT 1') -> {
+        run: ${databaseName}.sql('SELECT 1 as one') -> {
           select: tick is '${back}${tick}'
         }
       `).malloyResultMatches(runtime, {tick});
     });
     test('backslash backslash', async () => {
       await expect(`
-        run: ${databaseName}.sql("SELECT 1") -> {
+        run: ${databaseName}.sql("SELECT 1 as one") -> {
           select: back is '${back}${back}'
         }
       `).malloyResultMatches(runtime, {back});
     });
 
-    testIf(runtime.supportsNesting)('spaces in names', async () => {
-      await expect(`
+    test(
+      'spaces in names',
+      onlyIf(runtime.supportsNesting, async () => {
+        await expect(`
         source: \`space race\` is ${databaseName}.table('malloytest.state_facts') extend {
           join_one: \`j space\` is ${databaseName}.table('malloytest.state_facts') on \`j space\`.state=state
           view: \`q u e r y\` is {
@@ -1188,6 +1208,7 @@ SELECT row_to_json(finalStage) as row FROM __stage0 AS finalStage`);
         }
         run: \`space race\` -> \`q u e r y\`
       `).malloyResultMatches(runtime, {'c o u n t': 24});
-    });
+      })
+    );
   });
 });

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

@@ -23,7 +23,7 @@
  */
 
 import {RuntimeList, allDatabases} from '../../runtimes';
-import {databasesFromEnvironmentOr, testIf} from '../../util';
+import {databasesFromEnvironmentOr, onlyIf} from '../../util';
 import '../../util/db-jest-matchers';
 
 const runtimes = new RuntimeList(databasesFromEnvironmentOr(allDatabases));
@@ -87,9 +87,9 @@ describe.each(runtimes.runtimeList)('%s', (databaseName, runtime) => {
     `).malloyResultMatches(orderByModel, {});
   });
 
-  testIf(runtime.supportsNesting)(
+  test(
     `reserved words are quoted in turtles - ${databaseName}`,
-    async () => {
+    onlyIf(runtime.supportsNesting, async () => {
       await expect(`
       run: models->{
         nest: withx is {
@@ -102,7 +102,7 @@ describe.each(runtimes.runtimeList)('%s', (databaseName, runtime) => {
           fetch is withx.fetch
       }
     `).malloyResultMatches(orderByModel, {});
-    }
+    })
   );
 
   it.skip('reserved words in structure definitions', async () => {
@@ -142,9 +142,9 @@ describe.each(runtimes.runtimeList)('%s', (databaseName, runtime) => {
     `).malloyResultMatches(orderByModel, {model_count: 102});
   });
 
-  testIf(runtime.supportsNesting)(
+  test(
     `modeled having complex - ${databaseName}`,
-    async () => {
+    onlyIf(runtime.supportsNesting, async () => {
       await expect(`
         source: popular_names is models->{
           having: model_count > 100
@@ -161,7 +161,7 @@ describe.each(runtimes.runtimeList)('%s', (databaseName, runtime) => {
           select: manufacturer, model_count
         }
       `).malloyResultMatches(orderByModel, {model_count: 102});
-    }
+    })
   );
 
   it(`turtle references joined element - ${databaseName}`, async () => {

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

@@ -27,18 +27,18 @@ import '../../util/db-jest-matchers';
 import {
   databasesFromEnvironmentOr,
   mkSqlEqWith,
+  onlyIf,
   runQuery,
-  testIf,
 } from '../../util';
 import {DateTime as LuxonDateTime} from 'luxon';
 
 const runtimes = new RuntimeList(databasesFromEnvironmentOr(allDatabases));
 
-const timeSQL =
-  "SELECT DATE '2021-02-24' as t_date, TIMESTAMP '2021-02-24 03:05:06' as t_timestamp";
-
 // MTOY todo look at this list for timezone problems, I know there are some
 describe.each(runtimes.runtimeList)('%s date and time', (dbName, runtime) => {
+  const q = runtime.getQuoter();
+
+  const timeSQL = `SELECT DATE '2021-02-24' as ${q`t_date`}, TIMESTAMP '2021-02-24 03:05:06' as ${q`t_timestamp`} `;
   const sqlEq = mkSqlEqWith(runtime, dbName, {sql: timeSQL});
 
   describe('interval measurement', () => {
@@ -489,10 +489,10 @@ describe.each(runtimes.runtimeList)('%s date and time', (dbName, runtime) => {
       ).toBe('America/Los_Angeles');
     });
 
-    // TODO don't need to run this on all connections, so testIf not needed
-    testIf(runtime.supportsNesting)(
+    // TODO don't need to run this on all connections, so onlyIf not needed
+    test(
       'timezone set in view inside source',
-      async () => {
+      onlyIf(runtime.supportsNesting, async () => {
         expect(
           (
             await runQuery(
@@ -515,13 +515,13 @@ describe.each(runtimes.runtimeList)('%s date and time', (dbName, runtime) => {
             {name: 'la_query', queryTimezone: 'America/Los_Angeles'},
           ],
         });
-      }
+      })
     );
 
-    // TODO don't need to run this on all connections, so testIf not needed
-    testIf(runtime.supportsNesting)(
+    // TODO don't need to run this on all connections, so onlyIf not needed
+    test(
       'timezone set in query using source',
-      async () => {
+      onlyIf(runtime.supportsNesting, async () => {
         expect(
           (
             await runQuery(
@@ -539,37 +539,40 @@ describe.each(runtimes.runtimeList)('%s date and time', (dbName, runtime) => {
             )
           ).resultExplore.queryTimezone
         ).toBe('America/Los_Angeles');
-      }
+      })
     );
 
-    testIf(runtime.supportsNesting)('multiple timezones', async () => {
-      const theQuery = await runQuery(
-        runtime,
-        `run: ${dbName}.sql('SELECT 1') extend {
-          timezone: 'America/New_York'
-          dimension: ny_time is @2021-02-24 03:05:06
-          view: la_query is {
-            timezone: 'America/Los_Angeles'
-            select: la_time is @2021-02-24 03:05:06
-          }
-          view: mex_query is {
-            timezone: 'America/Mexico_City'
-            select: mex_time is @2021-02-24 03:05:06
-          }
-        } -> {
-         group_by: ny_time
-         nest: la_query, mex_query
-        }`
-      );
-      expect(theQuery.resultExplore.structDef).toMatchObject({
-        queryTimezone: 'America/New_York',
-        fields: [
-          {},
-          {name: 'la_query', queryTimezone: 'America/Los_Angeles'},
-          {name: 'mex_query', queryTimezone: 'America/Mexico_City'},
-        ],
-      });
-    });
+    test(
+      'multiple timezones',
+      onlyIf(runtime.supportsNesting, async () => {
+        const theQuery = await runQuery(
+          runtime,
+          `run: ${dbName}.sql('SELECT 1') extend {
+            timezone: 'America/New_York'
+            dimension: ny_time is @2021-02-24 03:05:06
+            view: la_query is {
+              timezone: 'America/Los_Angeles'
+              select: la_time is @2021-02-24 03:05:06
+            }
+            view: mex_query is {
+              timezone: 'America/Mexico_City'
+              select: mex_time is @2021-02-24 03:05:06
+            }
+          } -> {
+          group_by: ny_time
+          nest: la_query, mex_query
+          }`
+        );
+        expect(theQuery.resultExplore.structDef).toMatchObject({
+          queryTimezone: 'America/New_York',
+          fields: [
+            {},
+            {name: 'la_query', queryTimezone: 'America/Los_Angeles'},
+            {name: 'mex_query', queryTimezone: 'America/Mexico_City'},
+          ],
+        });
+      })
+    );
   });
 });
 
@@ -651,6 +654,7 @@ describe.each(runtimes.runtimeList)('%s: tz literals', (dbName, runtime) => {
 });
 
 describe.each(runtimes.runtimeList)('%s: query tz', (dbName, runtime) => {
+  const q = runtime.getQuoter();
   test('literal timestamps', async () => {
     const query = runtime.loadQuery(
       `
@@ -705,7 +709,7 @@ describe.each(runtimes.runtimeList)('%s: query tz', (dbName, runtime) => {
 
   test('cast date to timestamp', async () => {
     await expect(
-      `run: ${dbName}.sql(" SELECT DATE '2020-02-20'  AS mex_20") -> {
+      `run: ${dbName}.sql(""" SELECT DATE '2020-02-20'  AS ${q`mex_20`} """) -> {
         timezone: '${zone}'
         select: mex_ts is mex_20::timestamp
       }`

package/src/databases/bigquery-postgres/multi_connection.spec.ts

@@ -29,16 +29,14 @@ import {EmptyURLReader} from '@malloydata/malloy';
 import {BigQueryTestConnection, PostgresTestConnection} from '../../runtimes';
 import {describeIfDatabaseAvailable} from '../../util';
 
-const res = describeIfDatabaseAvailable(['bigquery', 'postgres']);
-let [describe] = res;
-const [, databases] = res;
+const [, databases] = describeIfDatabaseAvailable(['bigquery', 'postgres']);
 
 // *** NOTE ***
 // this is a special case (for now): a test that REQUIRES two databases - bigquery AND postgres
-describe =
+const describe =
   databases.filter(d => ['postgres', 'bigquery'].includes(d)).length >= 2
-    ? describe
-    : describe.skip;
+    ? globalThis.describe
+    : globalThis.describe.skip;
 
 describe('Multi-connection', () => {
   const bqConnection = new BigQueryTestConnection(

package/src/databases/bigquery-postgres/streaming.spec.ts

@@ -48,6 +48,9 @@ const [describe, databases] = describeIfDatabaseAvailable([
 ]);
 
 describe('Streaming tests', () => {
+  if (!databases.length) {
+    it.skip('skipped', () => {});
+  }
   const runtimes = new RuntimeList(databases);
 
   afterAll(async () => {

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

@@ -29,7 +29,7 @@ import {describeIfDatabaseAvailable} from '../../util';
 // TODO identify which tests need to run on wasm and move them into their own file
 const runtimes = ['duckdb', 'duckdb_wasm'];
 
-const [_describe, databases] = describeIfDatabaseAvailable(runtimes);
+const [describe, databases] = describeIfDatabaseAvailable(runtimes);
 const allDucks = new RuntimeList(databases);
 
 describe.each(allDucks.runtimeList)('duckdb:%s', (dbName, runtime) => {

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

@@ -90,6 +90,9 @@ function modelText(databaseName: string) {
 }
 
 describe('Streaming tests', () => {
+  if (!databases.length) {
+    it.skip('skipped', () => {});
+  }
   const runtimes = new RuntimeList(databases);
 
   afterAll(async () => {