@malloydata/malloy-tests 0.0.95-dev231019211822 → 0.0.95

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

@@ -24,12 +24,13 @@
 /* eslint-disable no-console */
 
 import {RuntimeList, allDatabases} from '../../runtimes';
-import {databasesFromEnvironmentOr} from '../../util';
+import {databasesFromEnvironmentOr, testIf} from '../../util';
 import '../../util/db-jest-matchers';
 
 const runtimes = new RuntimeList(databasesFromEnvironmentOr(allDatabases));
-const joinModelText = `
-  source: aircraft_models is table('malloytest.aircraft_models') extend {
+function modelText(connectionName: string) {
+  return `
+  source: aircraft_models is ${connectionName}.table('malloytest.aircraft_models') extend {
     primary_key: aircraft_model_code
     measure: model_count is count()
     view: manufacturer_models is {
@@ -42,7 +43,7 @@ const joinModelText = `
     }
   }
 
-  source: aircraft is table('malloytest.aircraft') extend {
+  source: aircraft is ${connectionName}.table('malloytest.aircraft') extend {
     primary_key: tail_num
     measure: aircraft_count is count()
   }
@@ -52,11 +53,7 @@ const joinModelText = `
         with manufacturer
   }
 `;
-
-// const models = new Map<string, malloy.ModelMaterializer>();
-// runtimes.runtimeMap.forEach((runtime, key) => {
-//   models.set(key, runtime.loadModel(joinModelText));
-// });
+}
 
 afterAll(async () => {
   await runtimes.closeAll();
@@ -64,107 +61,79 @@ afterAll(async () => {
 
 describe('join expression tests', () => {
   runtimes.runtimeMap.forEach((runtime, database) => {
+    const joinModelText = modelText(database);
+    const joinModel = runtime.loadModel(joinModelText);
     it(`model source refine join - ${database}`, async () => {
-      const result = await runtime
-        .loadModel(joinModelText)
-        .loadQuery(
-          `
-      source: a2 is aircraft extend {
-        join_one: aircraft_models with aircraft_model_code
-      }
-
-      run: a2 -> {
-        aggregate:
-          aircraft_count
-          aircraft_models.model_count
-      }
-      `
-        )
-        .run();
-      expect(result.data.value[0]['model_count']).toBe(1416);
+      await expect(`
+        source: a2 is aircraft extend {
+          join_one: aircraft_models with aircraft_model_code
+        }
+        run: a2 -> {
+          aggregate:
+            aircraft_count
+            aircraft_models.model_count
+        }
+      `).malloyResultMatches(joinModel, {model_count: 1416});
     });
 
     it(`model source refine in query join - ${database}`, async () => {
-      const result = await runtime
-        .loadModel(joinModelText)
-        .loadQuery(
-          `
-      run: aircraft {
-        join_one: aircraft_models with aircraft_model_code
-      } -> {
-        aggregate:
-          aircraft_count
-          aircraft_models.model_count
-      }
-      `
-        )
-        .run();
-      expect(result.data.value[0]['model_count']).toBe(1416);
+      await expect(`
+        run: aircraft extend {
+          join_one: aircraft_models with aircraft_model_code
+        } -> {
+          aggregate:
+            aircraft_count
+            aircraft_models.model_count
+        }
+      `).malloyResultMatches(joinModel, {model_count: 1416});
     });
 
     it(`model: join fact table query - ${database}`, async () => {
-      const result = await runtime
-        .loadModel(joinModelText)
-        .loadQuery(
-          `
-      run: aircraft_models {
-        join_one: am_facts is
-          aircraft_models->{
-            group_by: m is manufacturer
-            aggregate: num_models is count()
-          } with manufacturer
-      } -> {
-        select:
-          manufacturer
-          am_facts.num_models
-        order_by: 2 desc
-        limit: 1
-      }
-    `
-        )
-        .run();
-      expect(result.data.value[0]['num_models']).toBe(1147);
+      await expect(`
+        run: aircraft_models extend {
+          join_one: am_facts is
+            aircraft_models->{
+              group_by: m is manufacturer
+              aggregate: num_models is count()
+            } with manufacturer
+        } -> {
+          select:
+            manufacturer
+            am_facts.num_models
+          order_by: 2 desc
+          limit: 1
+        }
+      `).malloyResultMatches(joinModel, {num_models: 1147});
     });
 
     it(`model: source based on query - ${database}`, async () => {
-      const result = await runtime
-        .loadModel(joinModelText)
-        .loadQuery(
-          `
-      run:
-          aircraft_models-> {
+      await expect(`
+        run: aircraft_models
+          -> {
             group_by: m is manufacturer
             aggregate: num_models is count()
+          } -> {
+            select:
+            m
+            num_models
+            order_by: 2 desc
+            limit: 1
           }
-      -> {
-        select:
-          m
-          num_models
-        order_by: 2 desc
-        limit: 1
-      }
-        `
-        )
-        .run();
-      expect(result.data.value[0]['num_models']).toBe(1147);
+      `).malloyResultMatches(joinModel, {num_models: 1147});
     });
 
     it(`model: funnel - merge two queries - ${database}`, async () => {
-      const result = await runtime
-        .loadModel(joinModelText)
-        .loadQuery(
-          `
-          run: aircraft_models->{
-            group_by: m is manufacturer
-            aggregate: num_models is count()
-            } extend {
+      await expect(`
+        run: aircraft_models->{
+          group_by: m is manufacturer
+          aggregate: num_models is count()
+          } extend {
             join_one: seats is
               aircraft_models->{
                 group_by: m is manufacturer
                 aggregate: total_seats is seats.sum()
               } with m
-          }
-          -> {
+          } -> {
             select:
               m
               num_models
@@ -172,83 +141,66 @@ describe('join expression tests', () => {
             order_by: 2 desc
             limit: 1
           }
-        `
-        )
-        .run();
-      expect(result.data.value[0]['num_models']).toBe(1147);
-      expect(result.data.value[0]['total_seats']).toBe(252771);
+      `).malloyResultMatches(joinModel, {
+        num_models: 1147,
+        total_seats: 252771,
+      });
     });
 
     it(`model: modeled funnel - ${database}`, async () => {
-      const result = await runtime
-        .loadModel(joinModelText)
-        .loadQuery(
-          `
-      source: foo is aircraft_models-> manufacturer_models extend {
-        join_one: seats is aircraft_models->manufacturer_seats with manufacturer
-      }
-      run: foo-> {
-        select:
-          manufacturer,
-          num_models,
-          seats.total_seats
-        order_by: 2 desc
-        limit: 1
-      }
-        `
-        )
-        .run();
-      expect(result.data.value[0]['num_models']).toBe(1147);
-      expect(result.data.value[0]['total_seats']).toBe(252771);
+      await expect(`
+        run: aircraft_models-> manufacturer_models extend {
+          join_one: seats is aircraft_models->manufacturer_seats with manufacturer
+        } -> {
+          select:
+            manufacturer,
+            num_models,
+            seats.total_seats
+          order_by: 2 desc
+          limit: 1
+        }
+      `).malloyResultMatches(joinModel, {
+        num_models: 1147,
+        total_seats: 252771,
+      });
     });
 
     it(`model: modeled funnel2 - ${database}`, async () => {
-      const result = await runtime
-        .loadModel(joinModelText)
-        .loadQuery(
-          `
-      run: funnel->{
-        select:
-         manufacturer
-          num_models
-          seats.total_seats
-        order_by: 2 desc
-        limit: 1
-      }
-        `
-        )
-        .run();
-      expect(result.data.value[0]['num_models']).toBe(1147);
-      expect(result.data.value[0]['total_seats']).toBe(252771);
+      await expect(`
+        run: funnel->{
+          select:
+          manufacturer
+            num_models
+            seats.total_seats
+          order_by: 2 desc
+          limit: 1
+        }
+      `).malloyResultMatches(joinModel, {
+        num_models: 1147,
+        total_seats: 252771,
+      });
     });
 
     it(`model: double_pipe - ${database}`, async () => {
-      const result = await runtime
-        .loadModel(joinModelText)
-        .loadQuery(
-          `
-      run: aircraft_models->{
-        group_by: manufacturer
-        aggregate: f is count()
-      }->{
-        aggregate: f_sum is f.sum()
-      }->{
-        select: f_sum2 is f_sum+1
-      }
-    `
-        )
-        .run();
-      expect(result.data.value[0]['f_sum2']).toBe(60462);
+      await expect(`
+        run: aircraft_models->{
+          group_by: manufacturer
+          aggregate: f is count()
+        }->{
+          aggregate: f_sum is f.sum()
+        }->{
+          select: f_sum2 is f_sum+1
+        }
+    `).malloyResultMatches(joinModel, {f_sum2: 60462});
     });
 
-    test(`model: unnest is left join - ${database}`, async () => {
-      const result = await runtime
-        .loadModel(joinModelText)
-        .loadQuery(
-          `
+    testIf(runtime.supportsNesting)(
+      `model: unnest is left join - ${database}`,
+      async () => {
+        await expect(`
           // produce a table with 4 rows that has a nested element
-          query: a_states is table('malloytest.state_facts')-> {
-            where: state ? ~ 'A%'
+          query: a_states is ${database}.table('malloytest.state_facts')-> {
+          where: state ? ~ 'A%'
             group_by: state
             nest: somthing is {group_by: state}
           }
@@ -256,7 +208,7 @@ describe('join expression tests', () => {
           // join the 4 rows and reference the
           //  nested column. should return all the rows.
           //  If the unnest is an inner join, we'll get back just 4 rows.
-          run: table('malloytest.state_facts') {
+          run: ${database}.table('malloytest.state_facts') extend {
             join_one: a_states is a_states with state
           }
           -> {
@@ -265,73 +217,55 @@ describe('join expression tests', () => {
             nest: a is  {
               group_by: a_states.somthing.state
             }
+            limit: 5
           }
-    `
-        )
-        .run();
-      // console.log(result.data.toObject());
-      expect(result.data.rowCount).toBeGreaterThan(4);
-    });
+        `).malloyResultMatches(joinModel, [{}, {}, {}, {}, {}]);
+      }
+    );
 
-    // not sure how to solve this one yet.
+    // not sure how to solve this one yet, just check for > 4 rows
     it(`All joins at the same level - ${database}`, async () => {
-      const result = await runtime
-        .loadQuery(
-          `
-        source: flights is table('malloytest.flights') extend {
-          join_one: aircraft is table('malloytest.aircraft')
+      await expect(`
+        source: flights is ${database}.table('malloytest.flights') extend {
+          join_one: aircraft is ${database}.table('malloytest.aircraft')
             on tail_num = aircraft.tail_num
-          join_one: aircraft_models is table('malloytest.aircraft_models')
+          join_one: aircraft_models is ${database}.table('malloytest.aircraft_models')
             on aircraft.aircraft_model_code = aircraft_models.aircraft_model_code
         }
 
         run: flights -> {
           group_by: aircraft_models.seats
           aggregate: flight_count is count()
+          limit: 5
         }
-        `
-        )
-        .run();
-      // console.log(result.data.toObject());
-      expect(result.data.rowCount).toBeGreaterThan(4);
+      `).malloyResultMatches(joinModel, [{}, {}, {}, {}, {}]);
     });
 
     it(`join issue440 - ${database}`, async () => {
-      const result = await runtime
-        .loadQuery(
-          `
-        source: aircraft_models is table('malloytest.aircraft_models')
+      await expect(`
+        source: aircraft_models is ${database}.table('malloytest.aircraft_models')
 
-        source: aircraft is table('malloytest.aircraft')
+        source: aircraft is ${database}.table('malloytest.aircraft')
 
-        source: flights is table('malloytest.flights') extend {
+        source: flights is ${database}.table('malloytest.flights') extend {
           join_one: aircraft on aircraft.tail_num = tail_num
           join_one: aircraft_models on aircraft_models.aircraft_model_code = aircraft.aircraft_model_code
         }
 
         run: flights-> {
           group_by: testingtwo is aircraft_models.model
+          limit: 5
         }
-      `
-        )
-        .run();
-      // console.log(result.data.toObject());
-      expect(result.data.rowCount).toBeGreaterThan(4);
+      `).malloyResultMatches(runtime, [{}, {}, {}, {}, {}]);
     });
 
     it(`join issue1092 - ${database}`, async () => {
-      const result = await runtime
-        .loadQuery(
-          `
-          run: table('malloytest.state_facts') -> {
-            join_one: sf is table('malloytest.state_facts') on sf.state = state
-            aggregate: x is sf.births.sum() { ? state = 'CA' }
-          }
-          `
-        )
-        .run();
-      // console.log(result.data.toObject());
-      expect(result.data.rowCount).toBe(1);
+      await expect(`
+        run: ${database}.table('malloytest.state_facts') -> {
+          extend: {join_one: sf is ${database}.table('malloytest.state_facts') on sf.state = state}
+          aggregate: x is sf.births.sum() { where:  state = 'CA' }
+        }
+      `).malloyResultMatches(runtime, [{}]);
     });
   });
 });