@malloydata/malloy-tests 0.0.68-dev230808000650 → 0.0.68

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

@@ -24,240 +24,7 @@
 
 import {RuntimeList, allDatabases} from '../../runtimes';
 import {databasesFromEnvironmentOr} from '../../util';
-import * as malloy from '@malloydata/malloy';
-
-export const orderBySharedTests = (
-  runtimes: RuntimeList,
-  _splitFunction?: (column: string, splitChar: string) => string
-) => {
-  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);
-    });
-  });
-};
+import {orderBySharedTests} from '../shared/orderby';
 
 const runtimes = new RuntimeList(databasesFromEnvironmentOr(allDatabases));
 

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

@@ -24,93 +24,7 @@
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 import {RuntimeList, allDatabases} from '../../runtimes';
 import {databasesFromEnvironmentOr} from '../../util';
-
-export const problemsSharedTests = (
-  runtimes: RuntimeList,
-  _splitFunction?: (column: string, splitChar: string) => string
-) => {
-  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',
-            },
-          ],
-        });
-      });
-    });
-  });
-};
+import {problemsSharedTests} from '../shared/problems';
 
 const runtimes = new RuntimeList(databasesFromEnvironmentOr(allDatabases));
 

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

@@ -26,77 +26,7 @@
 
 import {RuntimeList, allDatabases} from '../../runtimes';
 import {databasesFromEnvironmentOr} from '../../util';
-
-// No prebuilt shared model, each test is complete.  Makes debugging easier.
-
-export const sqlExpressionsSharedTests = (
-  runtimes: RuntimeList,
-  _splitFunction?: (column: string, splitChar: string) => string
-) => {
-  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);
-    });
-  });
-};
+import {sqlExpressionsSharedTests} from '../shared/sql_expressions';
 
 const runtimes = new RuntimeList(databasesFromEnvironmentOr(allDatabases));