@malloydata/malloy-tests 0.0.127-dev240306172007 → 0.0.127-dev240308180053

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 () => {

package/src/render/render.spec.ts

@@ -23,7 +23,7 @@
 
 import {ModelMaterializer} from '@malloydata/malloy';
 import {RuntimeList, runtimeFor} from '../runtimes';
-import {describeIfDatabaseAvailable} from '../util';
+import {describeIfDatabaseAvailable, onlyIf} from '../util';
 import {HTMLView} from '@malloydata/render';
 import {JSDOM} from 'jsdom';
 
@@ -66,130 +66,172 @@ describe('rendering results', () => {
     await runtimes.closeAll();
   });
 
-  test('can render table', async () => {
-    const runtime = runtimes.runtimeMap.get('bigquery');
-    expect(runtime).toBeDefined();
-    if (runtime) {
-      const src = `
+  test(
+    'can render table',
+    onlyIf(databases.includes('bigquery'), async () => {
+      const runtime = runtimes.runtimeMap.get('bigquery');
+      expect(runtime).toBeDefined();
+      if (runtime) {
+        const src = `
         run: bigquery.table('malloy-data.faa.flights') -> {
           group_by: carrier
           aggregate: flight_count is count()
         }
       `;
-      const result = await runtime.loadQuery(src).run();
-      const document = new JSDOM().window.document;
-      await new HTMLView(document).render(result, {
-        dataStyles: {},
-      });
-    }
-  });
-
-  test('can render unsupported bigquery geo types', async () => {
-    await runUnsupportedRenderTest(
-      'bigquery',
-      runtimes,
-      "ST_GEOGFROMTEXT('LINESTRING(1 2, 3 4)')",
-      'LINESTRING(1 2, 3 4)'
-    );
-  });
-
-  test('can render unsupported bigquery ip types', async () => {
-    await runUnsupportedRenderTest(
-      'bigquery',
-      runtimes,
-      "NET.IP_FROM_STRING('192.168.1.1')",
-      '{"type":"Buffer","data":[192,168,1,1]}'
-    );
-  });
-
-  test('can render unsupported bigquery interval types', async () => {
-    await runUnsupportedRenderTest(
-      'bigquery',
-      runtimes,
-      'INTERVAL 1 YEAR',
-      '1-0 0 0:0:0'
-    );
-  });
-
-  test('can render unsupported bigquery time types', async () => {
-    await runUnsupportedRenderTest(
-      'bigquery',
-      runtimes,
-      'TIME(10, 10, 1)',
-      '10:10:01'
-    );
-  });
-
-  test('can render unsupported postgres interval types', async () => {
-    await runUnsupportedRenderTest(
-      'postgres',
-      runtimes,
-      'make_interval(days => 12)',
-      '12 days'
-    );
-  });
-
-  test('can render unsupported postgres uuid types', async () => {
-    await runUnsupportedRenderTest(
-      'postgres',
-      runtimes,
-      "CAST('a0eebc99-9c0b-4ef8-bb6d-6bb9bd380a11' AS UUID)",
-      'a0eebc99-9c0b-4ef8-bb6d-6bb9bd380a11'
-    );
-  });
-
-  test('can render unsupported postgres inet types', async () => {
-    await runUnsupportedRenderTest(
-      'postgres',
-      runtimes,
-      "'192.168.1.1'::inet",
-      '192.168.1.1'
-    );
-  });
-
-  test('can render unsupported postgres macaddr types', async () => {
-    await runUnsupportedRenderTest(
-      'postgres',
-      runtimes,
-      "'00:04:E2:36:95:C0'::macaddr",
-      '00:04:e2:36:95:c0'
-    );
-  });
-
-  test('can render supported postgres types', async () => {
-    await runUnsupportedRenderTest('postgres', runtimes, '12345', '12,345');
-  });
-
-  test('can render supported duckdb types', async () => {
-    await runUnsupportedRenderTest('duckdb', runtimes, '12345', '12,345');
-  });
-
-  test('can render unsupported duckdb blob types', async () => {
-    await runUnsupportedRenderTest(
-      'duckdb',
-      runtimes,
-      "'\\xAA'::BLOB",
-      '{"type":"Buffer","data":[170]}'
-    );
-  });
-
-  test('can render unsupported duckdb uuid types', async () => {
-    await runUnsupportedRenderTest(
-      'duckdb',
-      runtimes,
-      "'a0eebc99-9c0b-4ef8-bb6d-6bb9bd380a11'::UUID",
-      'a0eebc99-9c0b-4ef8-bb6d-6bb9bd380a11'
-    );
-  });
-
-  test('can render null unsupported types', async () => {
-    await runUnsupportedRenderTest(
-      'bigquery',
-      runtimes,
-      'CAST(NULL AS GEOGRAPHY)',
-      '<span class="value-null">∅</span>'
-    );
-  });
+        const result = await runtime.loadQuery(src).run();
+        const document = new JSDOM().window.document;
+        await new HTMLView(document).render(result, {
+          dataStyles: {},
+        });
+      }
+    })
+  );
+
+  test(
+    'can render unsupported bigquery geo types',
+    onlyIf(databases.includes('bigquery'), async () => {
+      await runUnsupportedRenderTest(
+        'bigquery',
+        runtimes,
+        "ST_GEOGFROMTEXT('LINESTRING(1 2, 3 4)')",
+        'LINESTRING(1 2, 3 4)'
+      );
+    })
+  );
+
+  test(
+    'can render unsupported bigquery ip types',
+    onlyIf(databases.includes('bigquery'), async () => {
+      await runUnsupportedRenderTest(
+        'bigquery',
+        runtimes,
+        "NET.IP_FROM_STRING('192.168.1.1')",
+        '{"type":"Buffer","data":[192,168,1,1]}'
+      );
+    })
+  );
+
+  test(
+    'can render unsupported bigquery interval types',
+    onlyIf(databases.includes('bigquery'), async () => {
+      await runUnsupportedRenderTest(
+        'bigquery',
+        runtimes,
+        'INTERVAL 1 YEAR',
+        '1-0 0 0:0:0'
+      );
+    })
+  );
+
+  test(
+    'can render unsupported bigquery time types',
+    onlyIf(databases.includes('bigquery'), async () => {
+      await runUnsupportedRenderTest(
+        'bigquery',
+        runtimes,
+        'TIME(10, 10, 1)',
+        '10:10:01'
+      );
+    })
+  );
+
+  test(
+    'can render unsupported postgres interval types',
+    onlyIf(databases.includes('postgres'), async () => {
+      await runUnsupportedRenderTest(
+        'postgres',
+        runtimes,
+        'make_interval(days => 12)',
+        '12 days'
+      );
+    })
+  );
+
+  test(
+    'can render unsupported postgres uuid types',
+    onlyIf(databases.includes('postgres'), async () => {
+      await runUnsupportedRenderTest(
+        'postgres',
+        runtimes,
+        "CAST('a0eebc99-9c0b-4ef8-bb6d-6bb9bd380a11' AS UUID)",
+        'a0eebc99-9c0b-4ef8-bb6d-6bb9bd380a11'
+      );
+    })
+  );
+
+  test(
+    'can render unsupported postgres inet types',
+    onlyIf(databases.includes('postgres'), async () => {
+      await runUnsupportedRenderTest(
+        'postgres',
+        runtimes,
+        "'192.168.1.1'::inet",
+        '192.168.1.1'
+      );
+    })
+  );
+
+  test(
+    'can render unsupported postgres macaddr types',
+    onlyIf(databases.includes('postgres'), async () => {
+      await runUnsupportedRenderTest(
+        'postgres',
+        runtimes,
+        "'00:04:E2:36:95:C0'::macaddr",
+        '00:04:e2:36:95:c0'
+      );
+    })
+  );
+
+  test(
+    'can render supported postgres types',
+    onlyIf(databases.includes('postgres'), async () => {
+      await runUnsupportedRenderTest('postgres', runtimes, '12345', '12,345');
+    })
+  );
+
+  test(
+    'can render supported duckdb types',
+    onlyIf(databases.includes('duckdb'), async () => {
+      await runUnsupportedRenderTest('duckdb', runtimes, '12345', '12,345');
+    })
+  );
+
+  test(
+    'can render unsupported duckdb blob types',
+    onlyIf(databases.includes('duckdb'), async () => {
+      await runUnsupportedRenderTest(
+        'duckdb',
+        runtimes,
+        "'\\xAA'::BLOB",
+        '{"type":"Buffer","data":[170]}'
+      );
+    })
+  );
+
+  test(
+    'can render unsupported duckdb uuid types',
+    onlyIf(databases.includes('duckdb'), async () => {
+      await runUnsupportedRenderTest(
+        'duckdb',
+        runtimes,
+        "'a0eebc99-9c0b-4ef8-bb6d-6bb9bd380a11'::UUID",
+        'a0eebc99-9c0b-4ef8-bb6d-6bb9bd380a11'
+      );
+    })
+  );
+
+  test(
+    'can render null unsupported types',
+    onlyIf(databases.includes('bigquery'), async () => {
+      await runUnsupportedRenderTest(
+        'bigquery',
+        runtimes,
+        'CAST(NULL AS GEOGRAPHY)',
+        '<span class="value-null">∅</span>'
+      );
+    })
+  );
 
   describe('html renderer', () => {
     describe('complex query with tags', () => {

package/src/util/index.ts

@@ -84,6 +84,19 @@ export function databasesFromEnvironmentOr(
     : defaultDatabases;
 }
 
+const describeSkip: jest.Describe = Object.assign(
+  (
+    name: number | string | Function | jest.FunctionLike,
+    fn: jest.EmptyFunction
+  ) => describe.skip(name, fn),
+  {
+    skip: describe.skip,
+    // eslint-disable-next-line no-restricted-properties
+    only: describe.only,
+    each: (() => () => it.skip('skipped', () => {})) as unknown as jest.Each,
+  }
+);
+
 // confirms that one or more of the databases being tested overlaps with the databases a test suite can accept.
 // if there is overlap, return a tuple of jest.describe and the dialects to be tested
 // if there is no overlap, return a tuple if jest.describe.skip and the dialects to be tested
@@ -93,7 +106,7 @@ export function describeIfDatabaseAvailable(
   const currentDatabases = databasesFromEnvironmentOr(acceptableDatabases);
   const overlap = acceptableDatabases.filter(d => currentDatabases.includes(d));
 
-  return overlap.length > 0 ? [describe, overlap] : [describe.skip, overlap];
+  return overlap.length > 0 ? [describe, overlap] : [describeSkip, overlap];
 }
 
 interface InitValues {
@@ -206,6 +219,13 @@ export async function runQuery(runtime: Runtime, querySrc: string) {
   return result;
 }
 
-export const testIf = (condition: boolean) => {
-  return condition ? test : test.skip;
-};
+export function onlyIf(
+  cond: boolean,
+  condTest: jest.ProvidesCallback
+): jest.ProvidesCallback {
+  if (cond) {
+    return condTest;
+  } else {
+    return () => {};
+  }
+}