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

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

@@ -24,7 +24,7 @@
 
 import {RuntimeList, allDatabases} from '../../runtimes';
 import '../../util/db-jest-matchers';
-import {databasesFromEnvironmentOr, mkSqlEqWith, testIf} from '../../util';
+import {databasesFromEnvironmentOr, mkSqlEqWith, onlyIf} from '../../util';
 import {fail} from 'assert';
 
 const runtimes = new RuntimeList(databasesFromEnvironmentOr(allDatabases));
@@ -119,13 +119,16 @@ describe.each(runtimes.runtimeList)('%s', (databaseName, runtime) => {
   });
 
   // filtered turtle expressions
-  testIf(runtime.supportsNesting)('model: filtered turtle', async () => {
-    await expect(`
+  test(
+    'model: filtered turtle',
+    onlyIf(runtime.supportsNesting, async () => {
+      await expect(`
       run: aircraft->{
         nest: b is by_manufacturer + { where: aircraft_models.manufacturer ?~'B%'}
       }
     `).malloyResultMatches(expressionModel, {'b.manufacturer': 'BEECH'});
-  });
+    })
+  );
 
   // having.
   it('model: simple having', async () => {
@@ -139,8 +142,10 @@ describe.each(runtimes.runtimeList)('%s', (databaseName, runtime) => {
     `).malloyResultMatches(expressionModel, {aircraft_count: 91});
   });
 
-  testIf(runtime.supportsNesting)('model: having in a nest', async () => {
-    await expect(`
+  test(
+    'model: having in a nest',
+    onlyIf(runtime.supportsNesting, async () => {
+      await expect(`
       run: aircraft->{
         top: 10
         order_by: 1
@@ -155,10 +160,13 @@ describe.each(runtimes.runtimeList)('%s', (databaseName, runtime) => {
         }
       }
     `).malloyResultMatches(expressionModel, {'by_state.state': 'VA'});
-  });
+    })
+  );
 
-  testIf(runtime.supportsNesting)('model: turtle having on main', async () => {
-    await expect(`
+  test(
+    'model: turtle having on main',
+    onlyIf(runtime.supportsNesting, async () => {
+      await expect(`
       run: aircraft->{
         order_by: 2 asc
         having: aircraft_count ? >500
@@ -178,14 +186,15 @@ describe.each(runtimes.runtimeList)('%s', (databaseName, runtime) => {
         }
       }
     `).malloyResultMatches(expressionModel, {
-      'by_state.by_city.city': 'ALBUQUERQUE',
-    });
-  });
+        'by_state.by_city.city': 'ALBUQUERQUE',
+      });
+    })
+  );
 
   // bigquery doesn't like to partition by floats,
-  testIf(runtime.supportsNesting)(
+  test(
     'model: having float group by partition',
-    async () => {
+    onlyIf(runtime.supportsNesting, async () => {
       await expect(`${modelText(databaseName)}
         run: aircraft_models->{
           order_by: 1
@@ -198,7 +207,7 @@ describe.each(runtimes.runtimeList)('%s', (databaseName, runtime) => {
             aggregate: aircraft_model_count
           }
       }`).malloyResultMatches(runtime, {aircraft_model_count: 448});
-    }
+    })
   );
 
   it('model: aggregate functions distinct min max', async () => {
@@ -232,9 +241,9 @@ describe.each(runtimes.runtimeList)('%s', (databaseName, runtime) => {
 
   // TODO not sure why this test needs to be skipped on postgres, feels like an oversight
   // NOTE: unless underlying type is stored as a timestamp snowflake does not support extraction
-  testIf(!['postgres', 'snowflake'].includes(databaseName))(
+  test(
     'model: dates named',
-    async () => {
+    onlyIf(!['postgres', 'snowflake'].includes(databaseName), async () => {
       await expect(`
       run: ${databaseName}.table('malloytest.alltypes')->{
         group_by:
@@ -261,7 +270,7 @@ describe.each(runtimes.runtimeList)('%s', (databaseName, runtime) => {
         t_timestamp_month: new Date('2020-03-01'),
         t_timestamp_year: new Date('2020-01-01'),
       });
-    }
+    })
   );
 
   it('named query metadata undefined', async () => {
@@ -316,21 +325,24 @@ describe.each(runtimes.runtimeList)('%s', (databaseName, runtime) => {
     `).malloyResultMatches(expressionModel, {a: 312});
   });
 
-  testIf(!['postgres', 'snowflake'].includes(runtime.connection.name))(
+  test(
     'sql safe cast',
-    async () => {
-      await expect(`
+    onlyIf(
+      !['postgres', 'snowflake'].includes(runtime.connection.name),
+      async () => {
+        await expect(`
       run: ${databaseName}.sql('SELECT 1') -> { select:
         bad_date is '123':::date
         bad_number is 'abc':::number
         good_number is "312":::"integer"
       }
     `).malloyResultMatches(expressionModel, {
-        bad_date: null,
-        bad_number: null,
-        good_number: 312,
-      });
-    }
+          bad_date: null,
+          bad_number: null,
+          good_number: 312,
+        });
+      }
+    )
   );
 
   it('many_field.sum() has correct locality', async () => {
@@ -540,9 +552,9 @@ describe.each(runtimes.runtimeList)('%s', (databaseName, runtime) => {
     });
   });
 
-  testIf(runtime.supportsNesting)(
+  test(
     'query with aliasname used twice',
-    async () => {
+    onlyIf(runtime.supportsNesting, async () => {
       await expect(`
         run: aircraft->{
           group_by: first is substr(city,1,1)
@@ -562,7 +574,7 @@ describe.each(runtimes.runtimeList)('%s', (databaseName, runtime) => {
             order_by: 2 desc, 1
         }
       `).malloyResultMatches(expressionModel, {first_three: 'SAB'});
-    }
+    })
   );
 
   it('joined filtered sources', async () => {

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

@@ -24,7 +24,7 @@
 /* eslint-disable no-console */
 
 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));
@@ -194,9 +194,9 @@ describe('join expression tests', () => {
     `).malloyResultMatches(joinModel, {f_sum2: 60462});
     });
 
-    testIf(runtime.supportsNesting)(
+    test(
       `model: unnest is left join - ${database}`,
-      async () => {
+      onlyIf(runtime.supportsNesting, async () => {
         await expect(`
           // produce a table with 4 rows that has a nested element
           query: a_states is ${database}.table('malloytest.state_facts')-> {
@@ -220,7 +220,7 @@ describe('join expression tests', () => {
             limit: 5
           }
         `).malloyResultMatches(joinModel, [{}, {}, {}, {}, {}]);
-      }
+      })
     );
 
     // not sure how to solve this one yet, just check for > 4 rows

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)(
+  test(
     `number as null- ${databaseName}`,
-    async () => {
+    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,12 +840,12 @@ 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 () => {
+    onlyIf(runtime.supportsNesting, async () => {
       await expect(`
         run: ${databaseName}.table('malloytest.state_facts') extend {
           view: fun is {
@@ -853,12 +853,12 @@ SELECT row_to_json(finalStage) as row FROM __stage0 AS finalStage`);
           } -> { select: t1 is t+1 }
         } -> { nest: fun }
       `).malloyResultMatches(runtime, {'fun.t1': 52});
-    }
+    })
   );
 
-  testIf(runtime.supportsNesting)(
+  test(
     `Multi value to udf - ${databaseName}`,
-    async () => {
+    onlyIf(runtime.supportsNesting, async () => {
       await expect(`
         run: ${databaseName}.table('malloytest.state_facts') extend {
           view: fun is {
@@ -869,12 +869,12 @@ 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 () => {
+    onlyIf(runtime.supportsNesting, async () => {
       await expect(`
         run: ${databaseName}.table('malloytest.state_facts') extend {
           view: fun is {
@@ -885,7 +885,7 @@ 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,9 +978,9 @@ SELECT row_to_json(finalStage) as row FROM __stage0 AS finalStage`);
       `).malloyResultMatches(runtime, {x: 30});
   });
 
-  testIf(runtime.supportsNesting)(
+  test(
     `array unnest - ${databaseName}`,
-    async () => {
+    onlyIf(runtime.supportsNesting, async () => {
       const splitFN = getSplitFunction(databaseName);
       await expect(`
       run: ${databaseName}.sql("""
@@ -994,13 +994,13 @@ 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 () => {
+    onlyIf(runtime.supportsNesting, async () => {
       const splitFN = getSplitFunction(databaseName);
       await expect(`
       run: ${databaseName}.sql("""
@@ -1016,13 +1016,15 @@ 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 +1042,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 +1071,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 () => {
@@ -1168,8 +1171,10 @@ SELECT row_to_json(finalStage) as row FROM __stage0 AS finalStage`);
       `).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 +1193,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,8 +27,8 @@ import '../../util/db-jest-matchers';
 import {
   databasesFromEnvironmentOr,
   mkSqlEqWith,
+  onlyIf,
   runQuery,
-  testIf,
 } from '../../util';
 import {DateTime as LuxonDateTime} from 'luxon';
 
@@ -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'},
+          ],
+        });
+      })
+    );
   });
 });