@malloydata/malloy 0.0.190 → 0.0.191-dev240925232958

package/dist/lang/test/expressions.spec.js

@@ -67,11 +67,11 @@ describe('expressions', () => {
         });
         test('typecheck addition lhs', () => {
             const wrong = (0, test_translator_1.expr) `${'"string"'} + 1`;
-            expect(wrong).translationToFailWith("The '+' operator requires a number, not a 'string'");
+            expect(wrong).toLog((0, test_translator_1.errorMessage)("The '+' operator requires a number, not a 'string'"));
         });
         test('typecheck addition rhs', () => {
             const wrong = (0, test_translator_1.expr) `1 + ${'"string"'}`;
-            expect(wrong).translationToFailWith("The '+' operator requires a number, not a 'string'");
+            expect(wrong).toLog((0, test_translator_1.errorMessage)("The '+' operator requires a number, not a 'string'"));
         });
         test('subtraction', () => {
             expect('42 - 7').compilesTo('{42 - 7}');
@@ -134,16 +134,16 @@ describe('expressions', () => {
             expect('ai ?? 7').compilesTo('{ai coalesce 7}');
         });
         test('coalesce type mismatch', () => {
-            expect(new test_translator_1.BetaExpression('ai ?? @2003')).translationToFailWith('Mismatched types for coalesce (number, date)');
+            expect(new test_translator_1.BetaExpression('ai ?? @2003')).toLog((0, test_translator_1.errorMessage)('Mismatched types for coalesce (number, date)'));
         });
         test('disallow date OP number', () => {
-            expect(new test_translator_1.BetaExpression('@2001 = 7')).translationToFailWith('Cannot compare a date to a number');
+            expect(new test_translator_1.BetaExpression('@2001 = 7')).toLog((0, test_translator_1.errorMessage)('Cannot compare a date to a number'));
         });
         test('disallow date OP timestamp', () => {
-            expect(new test_translator_1.BetaExpression('ad = ats')).translationToFailWith('Cannot compare a date to a timestamp');
+            expect(new test_translator_1.BetaExpression('ad = ats')).toLog((0, test_translator_1.errorMessage)('Cannot compare a date to a timestamp'));
         });
         test('disallow interval from date to timestamp', () => {
-            expect(new test_translator_1.BetaExpression('days(ad to ats)')).translationToFailWith('Cannot measure from date to timestamp');
+            expect(new test_translator_1.BetaExpression('days(ad to ats)')).toLog((0, test_translator_1.errorMessage)('Cannot measure from date to timestamp'));
         });
         test('compare to truncation uses straight comparison', () => {
             expect('ad = ad.quarter').compilesTo('{ad = {timeTrunc-quarter ad}}');
@@ -165,7 +165,7 @@ describe('expressions', () => {
         });
         const noOffset = ['second', 'minute', 'hour'];
         test.each(noOffset.map(x => [x]))('disallow date delta %s', unit => {
-            expect(new test_translator_1.BetaExpression(`ad + 10 ${unit}s`)).translationToFailWith(`Cannot offset date by ${unit}`);
+            expect(new test_translator_1.BetaExpression(`ad + 10 ${unit}s`)).toLog((0, test_translator_1.errorMessage)(`Cannot offset date by ${unit}`));
         });
         test('apply with parens', () => {
             expect((0, test_translator_1.expr) `ai ? (> 1 & < 100)`).toTranslate();
@@ -173,35 +173,35 @@ describe('expressions', () => {
         describe('sql friendly warnings', () => {
             test('is null with warning', () => {
                 const warnSrc = (0, test_translator_1.expr) `ai is null`;
-                expect(warnSrc).toTranslateWithWarnings("Use '= NULL' to check for NULL instead of 'IS NULL'");
+                expect(warnSrc).toLog((0, test_translator_1.warningMessage)("Use '= NULL' to check for NULL instead of 'IS NULL'"));
                 expect(warnSrc).compilesTo('{is-null ai}');
                 const warning = warnSrc.translator.problems()[0];
                 expect(warning.replacement).toEqual('ai = null');
             });
             test('is not null with warning', () => {
                 const warnSrc = (0, test_translator_1.expr) `ai is not null`;
-                expect(warnSrc).toTranslateWithWarnings("Use '!= NULL' to check for NULL instead of 'IS NOT NULL'");
+                expect(warnSrc).toLog((0, test_translator_1.warningMessage)("Use '!= NULL' to check for NULL instead of 'IS NOT NULL'"));
                 expect(warnSrc).compilesTo('{is-not-null ai}');
                 const warning = warnSrc.translator.problems()[0];
                 expect(warning.replacement).toEqual('ai != null');
             });
             test('like with warning', () => {
                 const warnSrc = (0, test_translator_1.expr) `astr like 'a'`;
-                expect(warnSrc).toTranslateWithWarnings("Use Malloy operator '~' instead of 'LIKE'");
+                expect(warnSrc).toLog((0, test_translator_1.warningMessage)("Use Malloy operator '~' instead of 'LIKE'"));
                 expect(warnSrc).compilesTo('{astr like "a"}');
                 const warning = warnSrc.translator.problems()[0];
                 expect(warning.replacement).toEqual("astr ~ 'a'");
             });
             test('NOT LIKE with warning', () => {
                 const warnSrc = (0, test_translator_1.expr) `astr not like 'a'`;
-                expect(warnSrc).toTranslateWithWarnings("Use Malloy operator '!~' instead of 'NOT LIKE'");
+                expect(warnSrc).toLog((0, test_translator_1.warningMessage)("Use Malloy operator '!~' instead of 'NOT LIKE'"));
                 expect(warnSrc).compilesTo('{astr !like "a"}');
                 const warning = warnSrc.translator.problems()[0];
                 expect(warning.replacement).toEqual("astr !~ 'a'");
             });
             test('is is-null in a model', () => {
                 const isNullSrc = (0, test_translator_1.model) `source: xa is a extend { dimension: x1 is astr is null }`;
-                expect(isNullSrc).toTranslateWithWarnings("Use '= NULL' to check for NULL instead of 'IS NULL'");
+                expect(isNullSrc).toLog((0, test_translator_1.warningMessage)("Use '= NULL' to check for NULL instead of 'IS NULL'"));
             });
             test('is not-null in a model', () => {
                 const isNullSrc = (0, test_translator_1.model) `source: xa is a extend { dimension: x1 is not null }`;
@@ -209,7 +209,7 @@ describe('expressions', () => {
             });
             test('is not-null is in a model', () => {
                 const isNullSrc = (0, test_translator_1.model) `source: xa is a extend { dimension: x1 is not null is null }`;
-                expect(isNullSrc).toTranslateWithWarnings("Use '= NULL' to check for NULL instead of 'IS NULL'");
+                expect(isNullSrc).toLog((0, test_translator_1.warningMessage)("Use '= NULL' to check for NULL instead of 'IS NULL'"));
                 const warning = isNullSrc.translator.problems()[0];
                 expect(warning.replacement).toEqual('null = null');
             });
@@ -225,7 +225,7 @@ describe('expressions', () => {
             });
             test('not null::number', () => {
                 const notNull = (0, test_translator_1.expr) `not null::number`;
-                expect(notNull).translationToFailWith("'not' Can't use type number");
+                expect(notNull).toLog((0, test_translator_1.errorMessage)("'not' Can't use type number"));
             });
             test('(not null)::number', () => {
                 const notNull = (0, test_translator_1.expr) `(not null)::number`;
@@ -246,7 +246,7 @@ describe('expressions', () => {
     });
     test('correctly flags filtered scalar', () => {
         const e = new test_translator_1.BetaExpression('ai { where: true }');
-        expect(e).translationToFailWith('Filtered expression requires an aggregate computation');
+        expect(e).toLog((0, test_translator_1.errorMessage)('Filtered expression requires an aggregate computation'));
     });
     test('correctly flags filtered analytic', () => {
         expect((0, test_translator_1.markSource) `
@@ -254,7 +254,7 @@ describe('expressions', () => {
           group_by: ai
           calculate: l is lag(ai) { where: true }
         }
-      `).translationToFailWith('Filtered expression requires an aggregate computation');
+      `).toLog((0, test_translator_1.errorMessage)('Filtered expression requires an aggregate computation'));
     });
     describe('expr props', () => {
         test('aggregate order by not allowed without experiments enabled', () => {
@@ -263,7 +263,7 @@ describe('expressions', () => {
             group_by: ai
             aggregate: x1 is string_agg(astr) { order_by: ai }
           }
-        `).translationToFailWith('Enable experiment `aggregate_order_by` to use `order_by` with an aggregate function');
+        `).toLog((0, test_translator_1.errorMessage)('Enable experiment `aggregate_order_by` to use `order_by` with an aggregate function'));
         });
         test('aggregate limit not allowed without experiments enabled', () => {
             expect((0, test_translator_1.markSource) `
@@ -271,7 +271,7 @@ describe('expressions', () => {
             group_by: ai
             aggregate: x3 is string_agg(astr) { limit: 10 }
           }
-        `).translationToFailWith("Experimental flag 'aggregate_limit' required to enable this feature");
+        `).toLog((0, test_translator_1.error)('experiment-not-enabled', { experimentId: 'aggregate_limit' }));
         });
         test('aggregate order_by not allowed with different experiment enabled', () => {
             expect((0, test_translator_1.markSource) `
@@ -280,7 +280,7 @@ describe('expressions', () => {
             group_by: ai
             aggregate: x1 is string_agg(astr) { order_by: ai }
           }
-        `).translationToFailWith('Enable experiment `aggregate_order_by` to use `order_by` with an aggregate function');
+        `).toLog((0, test_translator_1.errorMessage)('Enable experiment `aggregate_order_by` to use `order_by` with an aggregate function'));
         });
         test('aggregate limit not allowed with different experiment enabled', () => {
             expect((0, test_translator_1.markSource) `
@@ -289,18 +289,18 @@ describe('expressions', () => {
             group_by: ai
             group_by: x3 is string_agg(astr) { limit: 10 }
           }
-        `).translationToFailWith("Experimental flag 'aggregate_limit' required to enable this feature");
+        `).toLog((0, test_translator_1.error)('experiment-not-enabled', { experimentId: 'aggregate_limit' }));
         });
         test('props not allowed on most expressions', () => {
             expect((0, test_translator_1.markSource) `
-          ##! experimental { aggregate_order_by aggregate_limit }
-          run: a -> {
-            group_by: x1 is 1 { order_by: ai }
-            group_by: x2 is 1 { partition_by: ai }
-            group_by: x3 is 1 { limit: 10 }
-            group_by: x4 is 1 { where: ai }
-          }
-        `).translationToFailWith('`order_by` is not supported for this kind of expression', '`partition_by` is not supported for this kind of expression', '`limit` is not supported for this kind of expression', 'Filtered expression requires an aggregate computation');
+        ##! experimental { aggregate_order_by aggregate_limit }
+        run: a -> {
+          group_by: x1 is 1 { order_by: ai }
+          group_by: x2 is 1 { partition_by: ai }
+          group_by: x3 is 1 { limit: 10 }
+          group_by: x4 is 1 { where: ai }
+        }
+      `).toLog((0, test_translator_1.errorMessage)('`order_by` is not supported for this kind of expression'), (0, test_translator_1.errorMessage)('`partition_by` is not supported for this kind of expression'), (0, test_translator_1.errorMessage)('`limit` is not supported for this kind of expression'), (0, test_translator_1.errorMessage)('Filtered expression requires an aggregate computation'));
         });
         test('analytics can take parititon_by and order_by', () => {
             expect((0, test_translator_1.markSource) `
@@ -327,7 +327,7 @@ describe('expressions', () => {
           calculate: x is lag(ai) { partition_by: ac }
           calculate: y is lag(ai) { partition_by: x }
         }
-      `).translationToFailWith('Partition expression must be scalar or aggregate', 'Partition expression must be scalar or aggregate');
+      `).toLog((0, test_translator_1.errorMessage)('Partition expression must be scalar or aggregate'), (0, test_translator_1.errorMessage)('Partition expression must be scalar or aggregate'));
         });
         test('analytics order_by requires expression', () => {
             expect((0, test_translator_1.markSource) `
@@ -336,7 +336,7 @@ describe('expressions', () => {
           group_by: ai
           calculate: x is lag(ai) { order_by: asc }
         }
-      `).translationToFailWith('analytic `order_by` must specify an aggregate expression or output field reference');
+      `).toLog((0, test_translator_1.errorMessage)('analytic `order_by` must specify an aggregate expression or output field reference'));
         });
         test('string_agg_distinct order by cannot specify expression', () => {
             expect((0, test_translator_1.markSource) `
@@ -345,7 +345,7 @@ describe('expressions', () => {
           group_by: ai
           aggregate: x is string_agg_distinct(astr) { order_by: ai }
         }
-      `).translationToFailWith('`order_by` must be only `asc` or `desc` with no expression');
+      `).toLog((0, test_translator_1.errorMessage)('`order_by` must be only `asc` or `desc` with no expression'));
         });
         test('string_agg_distinct order by can be just direction', () => {
             expect((0, test_translator_1.markSource) `
@@ -396,7 +396,7 @@ describe('expressions', () => {
             order_by: sum(ai)
           }
         }
-      `).translationToFailWith('aggregate `order_by` must be scalar');
+      `).toLog((0, test_translator_1.errorMessage)('aggregate `order_by` must be scalar'));
         });
         test('aggregate order by cannot be analytic', () => {
             expect((0, test_translator_1.markSource) `
@@ -406,7 +406,7 @@ describe('expressions', () => {
             order_by: rank()
           }
         }
-      `).translationToFailWith('aggregate `order_by` must be scalar');
+      `).toLog((0, test_translator_1.errorMessage)('aggregate `order_by` must be scalar'));
         });
         test('analytic order by can be an aggregate', () => {
             expect((0, test_translator_1.markSource) `
@@ -439,7 +439,7 @@ describe('expressions', () => {
             order_by: ai
           }
         }
-      `).translationToFailWith('analytic `order_by` must be an aggregate or an output field reference');
+      `).toLog((0, test_translator_1.errorMessage)('analytic `order_by` must be an aggregate or an output field reference'));
         });
         test('can specify multiple wheres', () => {
             expect((0, test_translator_1.markSource) `
@@ -472,6 +472,7 @@ describe('expressions', () => {
         rename: nested is astruct
         rename: inline is aninline
         dimension: field is column * 2
+        dimension: field_and_one_field is column + one.column
         dimension: many_field is many.column * 2
         dimension: many_one_field is many.column + one.column
         join_one: one is a extend {
@@ -513,7 +514,7 @@ describe('expressions', () => {
             expect(modelX `one.column.min()`).toTranslate();
         });
         test('one.min(one.column)', () => {
-            expect(modelX `one.min(one.column)`).translationToFailWith('Symmetric aggregate function `min` must be written as `min(expression)` or `path.to.field.min()`');
+            expect(modelX `one.min(one.column)`).toLog((0, test_translator_1.errorMessage)('Symmetric aggregate function `min` must be written as `min(expression)` or `path.to.field.min()`'));
         });
         test('min(one.column)', () => {
             expect(modelX `min(one.column)`).toTranslate();
@@ -522,7 +523,7 @@ describe('expressions', () => {
             expect(modelX `min(many.column)`).toTranslate();
         });
         test('min()', () => {
-            expect(modelX `min()`).translationToFailWith('Symmetric aggregate function `min` must be written as `min(expression)` or `path.to.field.min()`');
+            expect(modelX `min()`).toLog((0, test_translator_1.errorMessage)('Symmetric aggregate function `min` must be written as `min(expression)` or `path.to.field.min()`'));
         });
         test('source.min(column)', () => {
             expect(modelX `source.min(column)`).toTranslate();
@@ -534,7 +535,7 @@ describe('expressions', () => {
             expect(modelX `max(many.column)`).toTranslate();
         });
         test('max()', () => {
-            expect(modelX `max()`).translationToFailWith('Symmetric aggregate function `max` must be written as `max(expression)` or `path.to.field.max()`');
+            expect(modelX `max()`).toLog((0, test_translator_1.errorMessage)('Symmetric aggregate function `max` must be written as `max(expression)` or `path.to.field.max()`'));
         });
         test('source.max(many.column)', () => {
             expect(modelX `source.max(many.column)`).toTranslate();
@@ -555,7 +556,7 @@ describe('expressions', () => {
             expect(modelX `many.count()`).toTranslate();
         });
         test('sum()', () => {
-            expect(modelX `sum()`).translationToFailWith('Asymmetric aggregate function `sum` must be written as `path.to.field.sum()`, `path.to.join.sum(expression)`, or `sum(expression)`');
+            expect(modelX `sum()`).toLog((0, test_translator_1.errorMessage)('Asymmetric aggregate function `sum` must be written as `path.to.field.sum()`, `path.to.join.sum(expression)`, or `sum(expression)`'));
         });
         test('sum(column)', () => {
             expect(modelX `sum(column)`).toTranslate();
@@ -570,10 +571,10 @@ describe('expressions', () => {
             expect(modelX `source.sum(column)`).toTranslate();
         });
         test('sum(many.column)', () => {
-            expect(modelX `sum(many.column)`).translationToFailWith('Join path is required for this calculation; use `many.column.sum()`');
+            expect(modelX `sum(many.column)`).toLog((0, test_translator_1.errorMessage)('Join path is required for this calculation; use `many.column.sum()`'));
         });
         test('source.sum(many.column)', () => {
-            expect(modelX `source.sum(many.column)`).translationToFailWith('Cannot compute `sum` across `join_many` relationship `many`; use `many.column.sum()`');
+            expect(modelX `source.sum(many.column)`).toLog((0, test_translator_1.errorMessage)('Cannot compute `sum` across `join_many` relationship `many`; use `many.column.sum()`'));
         });
         test('many.column.sum()', () => {
             expect(modelX `many.column.sum()`).toTranslate();
@@ -582,7 +583,7 @@ describe('expressions', () => {
             expect(modelX `many.sum(many.column)`).toTranslate();
         });
         test('sum(one.column)', () => {
-            expect(modelX `sum(one.column)`).toTranslateWithWarnings('Join path is required for this calculation; use `one.column.sum()` or `source.sum(one.column)` to get a result weighted with respect to `source`');
+            expect(modelX `sum(one.column)`).toLog((0, test_translator_1.warningMessage)('Join path is required for this calculation; use `one.column.sum()` or `source.sum(one.column)` to get a result weighted with respect to `source`'));
         });
         test('sum(many.constant)', () => {
             expect(modelX `sum(many.constant)`).toTranslate();
@@ -591,13 +592,13 @@ describe('expressions', () => {
             expect(modelX `source.sum(many.constant)`).toTranslate();
         });
         test('sum(nested.column)', () => {
-            expect(modelX `sum(nested.column)`).translationToFailWith('Join path is required for this calculation; use `nested.column.sum()`');
+            expect(modelX `sum(nested.column)`).toLog((0, test_translator_1.errorMessage)('Join path is required for this calculation; use `nested.column.sum()`'));
         });
         test('nested.column.sum()', () => {
             expect(modelX `nested.column.sum()`).toTranslate();
         });
         test('source.sum(nested.column)', () => {
-            expect(modelX `source.sum(nested.column)`).translationToFailWith('Cannot compute `sum` across repeated relationship `nested`; use `nested.column.sum()`');
+            expect(modelX `source.sum(nested.column)`).toLog((0, test_translator_1.errorMessage)('Cannot compute `sum` across repeated relationship `nested`; use `nested.column.sum()`'));
         });
         test('can aggregate field defined with no join usage', () => {
             expect((0, test_translator_1.markSource) `
@@ -612,7 +613,7 @@ describe('expressions', () => {
       `).toTranslate();
         });
         test('sum(inline.column)', () => {
-            expect(modelX `sum(inline.column)`).toTranslateWithWarnings('Join path is required for this calculation; use `inline.column.sum()` or `source.sum(inline.column)` to get a result weighted with respect to `source`');
+            expect(modelX `sum(inline.column)`).toLog((0, test_translator_1.warningMessage)('Join path is required for this calculation; use `inline.column.sum()` or `source.sum(inline.column)` to get a result weighted with respect to `source`'));
         });
         test('inline.column.sum()', () => {
             expect(modelX `inline.column.sum()`).toTranslate();
@@ -621,10 +622,10 @@ describe('expressions', () => {
             expect(modelX `source.sum(inline.column)`).toTranslate();
         });
         test('sum(many.field)', () => {
-            expect(modelX `sum(many.field)`).translationToFailWith('Join path is required for this calculation; use `many.field.sum()`');
+            expect(modelX `sum(many.field)`).toLog((0, test_translator_1.errorMessage)('Join path is required for this calculation; use `many.field.sum()`'));
         });
         test('source.sum(many.field)', () => {
-            expect(modelX `source.sum(many.field)`).translationToFailWith('Cannot compute `sum` across `join_many` relationship `many`; use `many.field.sum()`');
+            expect(modelX `source.sum(many.field)`).toLog((0, test_translator_1.errorMessage)('Cannot compute `sum` across `join_many` relationship `many`; use `many.field.sum()`'));
         });
         test('many.field.sum()', () => {
             expect(modelX `many.field.sum()`).toTranslate();
@@ -633,10 +634,10 @@ describe('expressions', () => {
             expect(modelX `many.sum(many.field)`).toTranslate();
         });
         test('sum(many.field + many.field)', () => {
-            expect(modelX `sum(many.field + many.field)`).translationToFailWith('Join path is required for this calculation; use `many.sum(many.field + many.field)`');
+            expect(modelX `sum(many.field + many.field)`).toLog((0, test_translator_1.errorMessage)('Join path is required for this calculation; use `many.sum(many.field + many.field)`'));
         });
         test('source.sum(many.field + many.field)', () => {
-            expect(modelX `source.sum(many.field + many.field)`).translationToFailWith('Cannot compute `sum` across `join_many` relationship `many`; use `many.sum(many.field + many.field)`');
+            expect(modelX `source.sum(many.field + many.field)`).toLog((0, test_translator_1.errorMessage)('Cannot compute `sum` across `join_many` relationship `many`; use `many.sum(many.field + many.field)`'));
         });
         test('many.field + many.field.sum()', () => {
             expect(modelX `many.field + many.field.sum()`).toTranslate();
@@ -645,10 +646,10 @@ describe('expressions', () => {
             expect(modelX `many.sum(many.field + many.field)`).toTranslate();
         });
         test('sum(many_field)', () => {
-            expect(modelX `sum(many_field)`).translationToFailWith('Join path is required for this calculation; use `many_field.sum()`');
+            expect(modelX `sum(many_field)`).toLog((0, test_translator_1.errorMessage)('Join path is required for this calculation; use `many_field.sum()`'));
         });
         test('source.sum(many_field)', () => {
-            expect(modelX `source.sum(many_field)`).translationToFailWith('Cannot compute `sum` across `join_many` relationship `many`; use `many_field.sum()`');
+            expect(modelX `source.sum(many_field)`).toLog((0, test_translator_1.errorMessage)('Cannot compute `sum` across `join_many` relationship `many`; use `many_field.sum()`'));
         });
         test('many_field.sum()', () => {
             expect(modelX `many_field.sum()`).toTranslate();
@@ -657,10 +658,10 @@ describe('expressions', () => {
             expect(modelX `many.sum(many_field)`).toTranslate();
         });
         test('sum(one.many_field)', () => {
-            expect(modelX `sum(one.many_field)`).translationToFailWith('Join path is required for this calculation; use `one.many_field.sum()`');
+            expect(modelX `sum(one.many_field)`).toLog((0, test_translator_1.errorMessage)('Join path is required for this calculation; use `one.many_field.sum()`'));
         });
         test('source.sum(one.many_field)', () => {
-            expect(modelX `source.sum(one.many_field)`).translationToFailWith('Cannot compute `sum` across `join_many` relationship `many`; use `one.many_field.sum()`');
+            expect(modelX `source.sum(one.many_field)`).toLog((0, test_translator_1.errorMessage)('Cannot compute `sum` across `join_many` relationship `many`; use `one.many_field.sum()`'));
         });
         test('one.many_field.sum()', () => {
             expect(modelX `one.many_field.sum()`).toTranslate();
@@ -669,28 +670,31 @@ describe('expressions', () => {
             expect(modelX `one.many.sum(one.many_field)`).toTranslate();
         });
         test('sum(many.field + one.field)', () => {
-            expect(modelX `sum(many.field + one.field)`).translationToFailWith('Aggregated dimensional expression contains multiple join paths; rewrite, for example `sum(first_join.field + second_join.field)` as `first_join.field.sum() + second_join.field.sum()`');
+            expect(modelX `sum(many.field + one.field)`).toLog((0, test_translator_1.errorMessage)('Aggregated dimensional expression contains multiple join paths; rewrite, for example `sum(first_join.field + second_join.field)` as `first_join.field.sum() + second_join.field.sum()`'));
         });
         test('source.sum(many.field + one.field)', () => {
-            expect(modelX `source.sum(many.field + one.field)`).translationToFailWith('Aggregated dimensional expression contains multiple join paths; rewrite, for example `sum(first_join.field + second_join.field)` as `first_join.field.sum() + second_join.field.sum()`');
+            expect(modelX `source.sum(many.field + one.field)`).toLog((0, test_translator_1.errorMessage)('Aggregated dimensional expression contains multiple join paths; rewrite, for example `sum(first_join.field + second_join.field)` as `first_join.field.sum() + second_join.field.sum()`'));
         });
         test('many.sum(many.field + one.field)', () => {
             expect(modelX `many.sum(many.field + one.field)`).toTranslate();
         });
+        test('many_one_field.sum()', () => {
+            expect(modelX `many_one_field.sum()`).toLog((0, test_translator_1.errorMessage)('Aggregated dimensional expression contains multiple join paths; rewrite, for example `sum(first_join.field + second_join.field)` as `first_join.field.sum() + second_join.field.sum()`'));
+        });
         test('sum(many_one_field)', () => {
-            expect(modelX `sum(many_one_field)`).translationToFailWith('Aggregated dimensional expression contains multiple join paths; rewrite, for example `sum(first_join.field + second_join.field)` as `first_join.field.sum() + second_join.field.sum()`');
+            expect(modelX `sum(many_one_field)`).toLog((0, test_translator_1.errorMessage)('Aggregated dimensional expression contains multiple join paths; rewrite, for example `sum(first_join.field + second_join.field)` as `first_join.field.sum() + second_join.field.sum()`'));
         });
         test('source.sum(many_one_field)', () => {
-            expect(modelX `source.sum(many_one_field)`).translationToFailWith('Aggregated dimensional expression contains multiple join paths; rewrite, for example `sum(first_join.field + second_join.field)` as `first_join.field.sum() + second_join.field.sum()`');
+            expect(modelX `source.sum(many_one_field)`).toLog((0, test_translator_1.errorMessage)('Aggregated dimensional expression contains multiple join paths; rewrite, for example `sum(first_join.field + second_join.field)` as `first_join.field.sum() + second_join.field.sum()`'));
         });
         test('many.sum(many_one_field)', () => {
             expect(modelX `many.sum(many_one_field)`).toTranslate();
         });
         test('sum(many.one.field)', () => {
-            expect(modelX `sum(many.one.field)`).translationToFailWith('Join path is required for this calculation; use `many.one.field.sum()` or `many.sum(many.one.field)` to get a result weighted with respect to `many`');
+            expect(modelX `sum(many.one.field)`).toLog((0, test_translator_1.errorMessage)('Join path is required for this calculation; use `many.one.field.sum()` or `many.sum(many.one.field)` to get a result weighted with respect to `many`'));
         });
         test('sum(many.one.one.field)', () => {
-            expect(modelX `sum(many.one.one.field)`).translationToFailWith('Join path is required for this calculation; use `many.one.one.field.sum()` or `many.sum(many.one.one.field)` to get a result weighted with respect to `many`');
+            expect(modelX `sum(many.one.one.field)`).toLog((0, test_translator_1.errorMessage)('Join path is required for this calculation; use `many.one.one.field.sum()` or `many.sum(many.one.one.field)` to get a result weighted with respect to `many`'));
         });
         test('many.avg(field)', () => {
             expect(modelX `many.avg(field)`).toTranslate();
@@ -699,7 +703,7 @@ describe('expressions', () => {
             expect(modelX `one.avg(field)`).toTranslate();
         });
         test('cross.avg(field)', () => {
-            expect(modelX `cross.avg(field)`).translationToFailWith('Cannot compute `avg` across `join_cross` relationship `cross`; use `field.avg()`');
+            expect(modelX `cross.avg(field)`).toLog((0, test_translator_1.errorMessage)('Cannot compute `avg` across `join_cross` relationship `cross`; use `field.avg()`'));
         });
         test('cross.avg(cross.field)', () => {
             expect(modelX `cross.avg(cross.field)`).toTranslate();
@@ -714,7 +718,7 @@ describe('expressions', () => {
             expect(modelX `source.sum(one.column)`).toTranslate();
         });
         test('sum(one.column + one.column)', () => {
-            expect(modelX `sum(one.column + one.column)`).toTranslateWithWarnings('Join path is required for this calculation; use `one.sum(one.column + one.column)` or `source.sum(one.column + one.column)` to get a result weighted with respect to `source`');
+            expect(modelX `sum(one.column + one.column)`).toLog((0, test_translator_1.warningMessage)('Join path is required for this calculation; use `one.sum(one.column + one.column)` or `source.sum(one.column + one.column)` to get a result weighted with respect to `source`'));
         });
         test('one.sum(one.column + one.column)', () => {
             expect(modelX `one.sum(one.column + one.column)`).toTranslate();
@@ -728,7 +732,7 @@ describe('expressions', () => {
       run: a -> {
         group_by: output is 1
         calculate: bar is lag(sum(output))
-      }`).translationToFailWith("'output' is not defined");
+      }`).toLog((0, test_translator_1.errorMessage)("'output' is not defined"));
         });
     });
     describe('pick statements', () => {
@@ -784,11 +788,11 @@ describe('expressions', () => {
       `).toTranslate();
         });
         test('n-ary without else', () => {
-            expect(`
+            return expect(`
         source: na is a extend { dimension: d is
           pick 7 when true and true
         }
-      `).translationToFailWith("pick incomplete, missing 'else'");
+      `).toLog((0, test_translator_1.error)('pick-missing-else'));
         });
         test('n-ary with mismatch when clauses', () => {
             expect((0, test_translator_1.markSource) `
@@ -797,7 +801,10 @@ describe('expressions', () => {
           pick '7' when true or true
           else 7
         }
-      `).translationToFailWith("pick type 'string', expected 'number'");
+      `).toLog((0, test_translator_1.error)('pick-type-does-not-match', {
+                pickType: 'string',
+                returnType: 'number',
+            }));
         });
         test('n-ary with mismatched else clause', () => {
             expect((0, test_translator_1.markSource) `
@@ -805,28 +812,40 @@ describe('expressions', () => {
           pick 7 when true and true
           else '7'
         }
-      `).translationToFailWith("else type 'string', expected 'number'");
+      `).toLog((0, test_translator_1.error)('pick-else-type-does-not-match', {
+                elseType: 'string',
+                returnType: 'number',
+            }));
         });
         test('applied else mismatch', () => {
             expect((0, test_translator_1.markSource) `
         source: na is a extend { dimension: d is
           7 ? pick 7 when 7 else 'not seven'
         }
-      `).translationToFailWith("else type 'string', expected 'number'");
+      `).toLog((0, test_translator_1.error)('pick-else-type-does-not-match', {
+                elseType: 'string',
+                returnType: 'number',
+            }));
         });
         test('applied default mismatch', () => {
             expect((0, test_translator_1.markSource) `
         source: na is a extend { dimension: d is
           7 ? pick 'seven' when 7
         }
-      `).translationToFailWith("pick default type 'number', expected 'string'");
+      `).toLog((0, test_translator_1.error)('pick-default-type-does-not-match', {
+                defaultType: 'number',
+                returnType: 'string',
+            }));
         });
         test('applied when mismatch', () => {
             expect((0, test_translator_1.markSource) `
         source: na is a extend { dimension: d is
           7 ? pick 'seven' when 7 pick 6 when 6
         }
-      `).translationToFailWith("pick type 'number', expected 'string'");
+      `).toLog((0, test_translator_1.error)('pick-type-does-not-match', {
+                pickType: 'number',
+                returnType: 'string',
+            }));
         });
     });
     test('paren and applied div', () => {
@@ -854,12 +873,12 @@ describe('sql native fields in schema', () => {
     test('flag unsupported equality', () => {
         // because we don't know if the two unsupported types are comparable
         const uModel = new test_translator_1.TestTranslator('run: ab->{ where: aun = b.aun  select: * }');
-        expect(uModel).translationToFailWith("Unsupported SQL native type 'undefined' not allowed in expression");
+        expect(uModel).toLog((0, test_translator_1.error)('sql-native-not-allowed-in-expression', { rawType: undefined }));
     });
     test('flag unsupported compare', () => {
         // because we don't know if the two unsupported types are comparable
         const uModel = new test_translator_1.TestTranslator('run: ab->{ where: aun > b.aun  select: * }');
-        expect(uModel).translationToFailWith("Unsupported SQL native type 'undefined' not allowed in expression");
+        expect(uModel).toLog((0, test_translator_1.error)('sql-native-not-allowed-in-expression', { rawType: undefined }));
     });
     test('allow unsupported equality when raw types match', () => {
         const uModel = new test_translator_1.TestTranslator('run: ab->{ where: aweird = b.aweird  select: * }');
@@ -867,7 +886,7 @@ describe('sql native fields in schema', () => {
     });
     test('flag not applied to unsupported', () => {
         const uModel = new test_translator_1.TestTranslator('source: x is a extend { dimension: notUn is not aun }');
-        expect(uModel).translationToFailWith("'not' Can't be used with unsupported SQL native type 'undefined'");
+        expect(uModel).toLog((0, test_translator_1.error)('sql-native-not-allowed-in-expression', { rawType: undefined }));
     });
     test('allow unsupported to be cast', () => {
         const uModel = new test_translator_1.TestTranslator('source: x is a extend { dimension: notUn is aun::string }');
@@ -891,14 +910,14 @@ describe('sql native fields in schema', () => {
         run: a -> {
           group_by: x is sql_number("\${asdfasdf} * 2")
         }
-      `).translationToFailWith("Invalid interpolation: 'asdfasdf' is not defined");
+      `).toLog((0, test_translator_1.errorMessage)("Invalid interpolation: 'asdfasdf' is not defined"));
         });
         test('error when using sql_ function without experiment', () => {
             expect(`
         run: a -> {
           group_by: x is sql_number("\${asdfasdf} * 2")
         }
-      `).translationToFailWith('Cannot use sql_function `sql_number`; use `sql_functions` experiment to enable this behavior');
+      `).toLog((0, test_translator_1.errorMessage)('Cannot use sql_function `sql_number`; use `sql_functions` experiment to enable this behavior'));
         });
     });
     describe('cast', () => {
@@ -920,7 +939,7 @@ describe('sql native fields in schema', () => {
             expect((0, test_translator_1.expr) `astr:::number + 1`).toTranslate();
         });
         test('sql cast illegal type name', () => {
-            expect((0, test_translator_1.expr) `astr::"stuff 'n' things"`).translationToFailWith("Cast type `stuff 'n' things` is invalid for standardsql dialect");
+            expect((0, test_translator_1.expr) `astr::"stuff 'n' things"`).toLog((0, test_translator_1.errorMessage)("Cast type `stuff 'n' things` is invalid for standardsql dialect"));
         });
     });
 });

package/dist/lang/test/imports.spec.js

@@ -110,7 +110,7 @@ source: botProjQSrc is botProjQ
             },
         });
         docParse.translate();
-        expect(docParse).translationToFailWith(new RegExp((0, escapeRegExp_1.default)(reportedError)));
+        expect(docParse).toLog((0, test_translator_1.errorMessage)(new RegExp((0, escapeRegExp_1.default)(reportedError))));
     });
     test('chained imports', () => {
         const docParse = new test_translator_1.TestTranslator('import "child"');
@@ -156,7 +156,7 @@ source: botProjQSrc is botProjQ
           }`,
             },
         });
-        expect(docParse).translationToFailWith("Cannot redefine 'astr'");
+        expect(docParse).toLog((0, test_translator_1.errorMessage)("Cannot redefine 'astr'"));
     });
     test('source references expanded when not exported', () => {
         const srcFiles = {
@@ -221,7 +221,7 @@ source: botProjQSrc is botProjQ
                 'internal://test/langtests/child': 'source: aa is a',
             },
         });
-        expect(doc.translator).translationToFailWith("Cannot find 'bb', not imported");
+        expect(doc.translator).toLog((0, test_translator_1.errorMessage)("Cannot find 'bb', not imported"));
     });
     test('selective renamed import of source, not found', () => {
         const doc = (0, test_translator_1.model) `import { cc is ${'bb'} } from "child"`;
@@ -233,7 +233,7 @@ source: botProjQSrc is botProjQ
                 'internal://test/langtests/child': 'source: aa is a',
             },
         });
-        expect(doc.translator).translationToFailWith("Cannot find 'bb', not imported");
+        expect(doc.translator).toLog((0, test_translator_1.errorMessage)("Cannot find 'bb', not imported"));
     });
     test('selective import of source, no-redefinition', () => {
         const doc = (0, test_translator_1.model) `
@@ -247,7 +247,7 @@ source: botProjQSrc is botProjQ
                 'internal://test/langtests/child': 'source: bb is a',
             },
         });
-        expect(doc.translator).translationToFailWith("Cannot redefine 'cc'");
+        expect(doc.translator).toLog((0, test_translator_1.errorMessage)("Cannot redefine 'cc'"));
     });
 });
 //# sourceMappingURL=imports.spec.js.map