@malloydata/malloy-tests 0.0.135 → 0.0.136-dev240326234246

package/dist/runtimes.js

@@ -0,0 +1,180 @@
+"use strict";
+/*
+ * Copyright 2023 Google LLC
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files
+ * (the "Software"), to deal in the Software without restriction,
+ * including without limitation the rights to use, copy, modify, merge,
+ * publish, distribute, sublicense, and/or sell copies of the Software,
+ * and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RuntimeList = exports.allDatabases = exports.testRuntimeFor = exports.runtimeFor = exports.rows = exports.DuckDBWASMTestConnection = exports.DuckDBTestConnection = exports.PostgresTestConnection = exports.BigQueryTestConnection = exports.SnowflakeTestConnection = void 0;
+const malloy_1 = require("@malloydata/malloy");
+const db_bigquery_1 = require("@malloydata/db-bigquery");
+const db_duckdb_1 = require("@malloydata/db-duckdb");
+const wasm_1 = require("@malloydata/db-duckdb/wasm");
+const db_snowflake_1 = require("@malloydata/db-snowflake");
+const db_postgres_1 = require("@malloydata/db-postgres");
+const db_trino_1 = require("@malloydata/db-trino");
+const snowflake_executor_1 = require("@malloydata/db-snowflake/src/snowflake_executor");
+class SnowflakeTestConnection extends db_snowflake_1.SnowflakeConnection {
+    async runSQL(sqlCommand, options) {
+        try {
+            return await super.runSQL(sqlCommand, options);
+        }
+        catch (e) {
+            // eslint-disable-next-line no-console
+            console.log(`Error in SQL:\n ${sqlCommand}`);
+            throw e;
+        }
+    }
+}
+exports.SnowflakeTestConnection = SnowflakeTestConnection;
+class BigQueryTestConnection extends db_bigquery_1.BigQueryConnection {
+    // we probably need a better way to do this.
+    async runSQL(sqlCommand, options) {
+        try {
+            return await super.runSQL(sqlCommand, options);
+        }
+        catch (e) {
+            // eslint-disable-next-line no-console
+            console.log(`Error in SQL:\n ${sqlCommand}`);
+            throw e;
+        }
+    }
+}
+exports.BigQueryTestConnection = BigQueryTestConnection;
+class PostgresTestConnection extends db_postgres_1.PooledPostgresConnection {
+    // we probably need a better way to do this.
+    async runSQL(sqlCommand, options) {
+        try {
+            return await super.runSQL(sqlCommand, options);
+        }
+        catch (e) {
+            // eslint-disable-next-line no-console
+            console.log(`Error in SQL:\n ${sqlCommand}`);
+            throw e;
+        }
+    }
+}
+exports.PostgresTestConnection = PostgresTestConnection;
+class DuckDBTestConnection extends db_duckdb_1.DuckDBConnection {
+    // we probably need a better way to do this.
+    async runSQL(sqlCommand, options) {
+        try {
+            return await super.runSQL(sqlCommand, options);
+        }
+        catch (e) {
+            // eslint-disable-next-line no-console
+            console.log(`Error in SQL:\n ${sqlCommand}`);
+            throw e;
+        }
+    }
+}
+exports.DuckDBTestConnection = DuckDBTestConnection;
+class DuckDBWASMTestConnection extends wasm_1.DuckDBWASMConnection {
+    // we probably need a better way to do this.
+    async runSQL(sqlCommand, options) {
+        try {
+            return await super.runSQL(sqlCommand, options);
+        }
+        catch (e) {
+            // eslint-disable-next-line no-console
+            console.log(`Error in SQL:\n ${sqlCommand}`);
+            throw e;
+        }
+    }
+}
+exports.DuckDBWASMTestConnection = DuckDBWASMTestConnection;
+const files = new malloy_1.EmptyURLReader();
+function rows(qr) {
+    return qr.data.value;
+}
+exports.rows = rows;
+function runtimeFor(dbName) {
+    let connection;
+    try {
+        switch (dbName) {
+            case 'bigquery':
+                connection = new BigQueryTestConnection(dbName, {}, { projectId: 'malloy-data' });
+                break;
+            case 'postgres':
+                connection = new PostgresTestConnection(dbName);
+                break;
+            case 'duckdb':
+                connection = new DuckDBTestConnection(dbName, 'test/data/duckdb/duckdb_test.db');
+                break;
+            case 'duckdb_wasm':
+                connection = new DuckDBWASMTestConnection(dbName, 'test/data/duckdb/duckdb_test.db');
+                break;
+            case 'motherduck':
+                connection = new DuckDBTestConnection(dbName, 'md:my_db');
+                break;
+            case 'snowflake':
+                {
+                    const connOptions = snowflake_executor_1.SnowflakeExecutor.getConnectionOptionsFromEnv();
+                    connection = new SnowflakeTestConnection(dbName, { connOptions });
+                }
+                break;
+            case 'trino':
+                connection = new db_trino_1.TrinoConnection(dbName, {}, db_trino_1.TrinoExecutor.getConnectionOptionsFromEnv());
+                break;
+            default:
+                throw new Error(`Unknown runtime "${dbName}`);
+        }
+        return testRuntimeFor(connection);
+    }
+    catch (error) {
+        throw new Error(`Failed to create connection \`${dbName}\`: ${error.message}`);
+    }
+}
+exports.runtimeFor = runtimeFor;
+function testRuntimeFor(connection) {
+    return new malloy_1.SingleConnectionRuntime(files, connection);
+}
+exports.testRuntimeFor = testRuntimeFor;
+exports.allDatabases = [
+    'postgres',
+    'bigquery',
+    'duckdb',
+    'duckdb_wasm',
+    'snowflake',
+];
+class RuntimeList {
+    constructor(...args) {
+        this.runtimeMap = new Map();
+        this.runtimeList = [];
+        const databases = args.length > 0 && args[0] !== undefined ? args[0] : exports.allDatabases;
+        for (const database of databases) {
+            const rt = database instanceof malloy_1.SingleConnectionRuntime
+                ? database
+                : runtimeFor(database);
+            this.runtimeMap.set(rt.connection.name, rt);
+            this.runtimeList.push([rt.connection.name, rt]);
+        }
+    }
+    async closeAll() {
+        for (const [_key, runtime] of this.runtimeMap) {
+            await runtime.connection.close();
+        }
+        // Unfortunate hack to avoid slow to die background threads tripping
+        // up jest
+        await new Promise(resolve => setTimeout(resolve, 10000));
+    }
+}
+exports.RuntimeList = RuntimeList;
+//# sourceMappingURL=runtimes.js.map

package/dist/runtimes.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtimes.js","sourceRoot":"","sources":["../src/runtimes.ts"],"names":[],"mappings":"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"}

package/dist/tags.spec.d.ts

@@ -0,0 +1,8 @@
+import { TagDict } from '@malloydata/malloy';
+declare global {
+    namespace jest {
+        interface Matchers<R> {
+            tagsAre(t: TagDict): R;
+        }
+    }
+}

package/dist/tags.spec.js

@@ -0,0 +1,490 @@
+"use strict";
+/*
+ * Copyright 2023 Google LLC
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files
+ * (the "Software"), to deal in the Software without restriction,
+ * including without limitation the rights to use, copy, modify, merge,
+ * publish, distribute, sublicense, and/or sell copies of the Software,
+ * and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const malloy_1 = require("@malloydata/malloy");
+const runtimes_1 = require("./runtimes");
+expect.extend({
+    tagsAre(src, result) {
+        if (typeof src === 'string') {
+            const { tag, log } = malloy_1.Tag.fromTagline(src, undefined);
+            const errs = log.map(e => e.message);
+            if (log.length > 0) {
+                return {
+                    pass: false,
+                    message: () => `${src}: Tag Parsing Error(s)\n${errs.join('\n')}`,
+                };
+            }
+            src = tag;
+        }
+        const got = src.properties;
+        if (this.equals(got, result)) {
+            return {
+                pass: true,
+                message: () => 'Parse returned expected object',
+            };
+        }
+        const expected = this.utils.printExpected(result);
+        const received = this.utils.printReceived(got);
+        return {
+            pass: false,
+            message: () => `Expected: ${expected}\nReceived: ${received}`,
+        };
+    },
+});
+const runtime = (0, runtimes_1.runtimeFor)('duckdb');
+describe('tagParse to Tag', () => {
+    const tagTests = [
+        ['just_name', { just_name: {} }],
+        ['name=bare_string', { name: { eq: 'bare_string' } }],
+        ['name="quoted_string"', { name: { eq: 'quoted_string' } }],
+        ['name {prop1}', { name: { properties: { prop1: {} } } }],
+        [
+            'name {prop1 prop2=value}',
+            {
+                name: {
+                    properties: {
+                        prop1: {},
+                        prop2: { eq: 'value' },
+                    },
+                },
+            },
+        ],
+        ['name.prop', { name: { properties: { prop: {} } } }],
+        ['name.prop=value', { name: { properties: { prop: { eq: 'value' } } } }],
+        [
+            'name.prop.sub=value',
+            { name: { properties: { prop: { properties: { sub: { eq: 'value' } } } } } },
+        ],
+        [
+            'name{first3=[a, b, c]}',
+            { name: { properties: { first3: { eq: [{ eq: 'a' }, { eq: 'b' }, { eq: 'c' }] } } } },
+        ],
+        ['name{first1=[a,]}', { name: { properties: { first1: { eq: [{ eq: 'a' }] } } } }],
+        [
+            'name{first=[a {A}]}',
+            { name: { properties: { first: { eq: [{ eq: 'a', properties: { A: {} } }] } } } },
+        ],
+        [
+            'name{first=[{A}]}',
+            { name: { properties: { first: { eq: [{ properties: { A: {} } }] } } } },
+        ],
+        ['name=value {prop}', { name: { eq: 'value', properties: { prop: {} } } }],
+        [
+            'name.prop={prop2}',
+            { name: { properties: { prop: { properties: { prop2: {} } } } } },
+        ],
+        ['no yes -no', { yes: {} }],
+        // TODO interesting behavior that removing a non-existant element, or the last element,
+        // does not remove the `properties`.
+        ['x -x.y', { x: { properties: {} } }],
+        ['x={y} -x.y', { x: { properties: {} } }],
+        ['x={y z} -x.y', { x: { properties: { z: {} } } }],
+        ['x={y z} x {-y}', { x: { properties: { z: {} } } }],
+        ['x=1 x {xx=11}', { x: { eq: '1', properties: { xx: { eq: '11' } } } }],
+        ['x.y=xx x=1 {...}', { x: { eq: '1', properties: { y: { eq: 'xx' } } } }],
+        ['a {b c} a=1', { a: { eq: '1' } }],
+        ['a=1 a=...{b}', { a: { eq: '1', properties: { b: {} } } }],
+        [
+            'a=red { shade=dark } color=$(a) shade=$(a.shade)',
+            {
+                a: { eq: 'red', properties: { shade: { eq: 'dark' } } },
+                color: { eq: 'red', properties: { shade: { eq: 'dark' } } },
+                shade: { eq: 'dark' },
+            },
+        ],
+        ['x=.01', { x: { eq: '.01' } }],
+        ['x=-7', { x: { eq: '-7' } }],
+        ['x=7', { x: { eq: '7' } }],
+        ['x=7.0', { x: { eq: '7.0' } }],
+        ['x=.7', { x: { eq: '.7' } }],
+        ['x=.7e2', { x: { eq: '.7e2' } }],
+        ['x=7E2', { x: { eq: '7E2' } }],
+        ['`spacey name`=Zaphod', { 'spacey name': { eq: 'Zaphod' } }],
+        [
+            'image { alt=hello { field=department } }',
+            {
+                image: {
+                    properties: {
+                        alt: { eq: 'hello', properties: { field: { eq: 'department' } } },
+                    },
+                },
+            },
+        ],
+        [
+            'image image.alt=hello image.alt.field=department',
+            {
+                image: {
+                    properties: {
+                        alt: { eq: 'hello', properties: { field: { eq: 'department' } } },
+                    },
+                },
+            },
+        ],
+    ];
+    test.each(tagTests)('tag %s', (expression, expected) => {
+        expect(expression).tagsAre(expected);
+    });
+    test.skip('unskip to debug just one of the expressions', () => {
+        const x = ['x x.y', { x: { properties: { y: {} } } }];
+        expect(x[0]).tagsAre(x[1]);
+    });
+    test('inherits can be over-ridden', () => {
+        const loc1 = {
+            url: 'inherit-test',
+            range: { start: { line: 1, character: 0 }, end: { line: 1, character: 0 } },
+        };
+        const loc2 = {
+            url: 'inherit-test',
+            range: { start: { line: 2, character: 0 }, end: { line: 2, character: 0 } },
+        };
+        const nestedTags = malloy_1.Tag.annotationToTag({
+            inherits: { notes: [{ text: '## from=inherits\n', at: loc1 }] },
+            notes: [{ text: '## from=notes\n', at: loc2 }],
+        });
+        const fromVal = nestedTags.tag.text('from');
+        expect(fromVal).toEqual('notes');
+    });
+});
+describe('Tag access', () => {
+    test('just text', () => {
+        const strToParse = 'a=b';
+        const getTags = malloy_1.Tag.fromTagline(strToParse, undefined);
+        expect(getTags.log).toEqual([]);
+        const a = getTags.tag.tag('a');
+        expect(a).toBeDefined();
+        expect(a === null || a === void 0 ? void 0 : a.text()).toEqual('b');
+    });
+    test('tag path', () => {
+        const strToParse = 'a.b.c.d.e=f';
+        const tagParse = malloy_1.Tag.fromTagline(strToParse, undefined);
+        expect(tagParse.log).toEqual([]);
+        const abcde = tagParse.tag.tag('a', 'b', 'c', 'd', 'e');
+        expect(abcde).toBeDefined();
+        expect(abcde === null || abcde === void 0 ? void 0 : abcde.text()).toEqual('f');
+    });
+    test('just array', () => {
+        const strToParse = 'a=[b]';
+        const getTags = malloy_1.Tag.fromTagline(strToParse, undefined);
+        expect(getTags.log).toEqual([]);
+        const a = getTags.tag.tag('a');
+        const aval = a === null || a === void 0 ? void 0 : a.array();
+        expect(aval).toBeDefined();
+        if (aval) {
+            expect(aval.length).toEqual(1);
+            expect(aval[0].text()).toEqual('b');
+        }
+    });
+    test('array as text', () => {
+        const strToParse = 'a=[b]';
+        const getTags = malloy_1.Tag.fromTagline(strToParse, undefined);
+        expect(getTags.log).toEqual([]);
+        const a = getTags.tag.tag('a');
+        expect(a).toBeDefined();
+        expect(a === null || a === void 0 ? void 0 : a.text()).toBeUndefined();
+    });
+    test('text as array', () => {
+        const strToParse = 'a=b';
+        const getTags = malloy_1.Tag.fromTagline(strToParse, undefined);
+        expect(getTags.log).toEqual([]);
+        const a = getTags.tag.tag('a');
+        expect(a).toBeDefined();
+        expect(a === null || a === void 0 ? void 0 : a.array()).toBeUndefined();
+    });
+    test('just numeric', () => {
+        const strToParse = 'a=7';
+        const getTags = malloy_1.Tag.fromTagline(strToParse, undefined);
+        expect(getTags.log).toEqual([]);
+        const a = getTags.tag.tag('a');
+        expect(a).toBeDefined();
+        const n = a === null || a === void 0 ? void 0 : a.numeric();
+        expect(typeof n).toBe('number');
+        expect(n).toEqual(7);
+    });
+    test('text as numeric', () => {
+        const strToParse = 'a=seven';
+        const getTags = malloy_1.Tag.fromTagline(strToParse, undefined);
+        expect(getTags.log).toEqual([]);
+        const a = getTags.tag.tag('a');
+        expect(a).toBeDefined();
+        const n = a === null || a === void 0 ? void 0 : a.numeric();
+        expect(n).toBeUndefined();
+    });
+    test('array as numeric', () => {
+        const strToParse = 'a=[seven]';
+        const getTags = malloy_1.Tag.fromTagline(strToParse, undefined);
+        expect(getTags.log).toEqual([]);
+        const a = getTags.tag.tag('a');
+        expect(a).toBeDefined();
+        const n = a === null || a === void 0 ? void 0 : a.numeric();
+        expect(n).toBeUndefined();
+    });
+    test('full text array', () => {
+        const strToParse = 'a=[b,c]';
+        const getTags = malloy_1.Tag.fromTagline(strToParse, undefined);
+        expect(getTags.log).toEqual([]);
+        const a = getTags.tag.tag('a');
+        expect(a).toBeDefined();
+        const ais = a === null || a === void 0 ? void 0 : a.textArray();
+        expect(ais).toEqual(['b', 'c']);
+    });
+    test('filtered text array', () => {
+        const strToParse = 'a=[b,c,{d}]';
+        const getTags = malloy_1.Tag.fromTagline(strToParse, undefined);
+        expect(getTags.log).toEqual([]);
+        const a = getTags.tag.tag('a');
+        expect(a).toBeDefined();
+        const ais = a === null || a === void 0 ? void 0 : a.textArray();
+        expect(ais).toEqual(['b', 'c']);
+    });
+    test('full numeric array', () => {
+        const strToParse = 'a=[1,2]';
+        const getTags = malloy_1.Tag.fromTagline(strToParse, undefined);
+        expect(getTags.log).toEqual([]);
+        const a = getTags.tag.tag('a');
+        expect(a).toBeDefined();
+        const ais = a === null || a === void 0 ? void 0 : a.numericArray();
+        expect(ais).toEqual([1, 2]);
+    });
+    test('filtered numeric array', () => {
+        const strToParse = 'a=[1,2,three]';
+        const getTags = malloy_1.Tag.fromTagline(strToParse, undefined);
+        expect(getTags.log).toEqual([]);
+        const a = getTags.tag.tag('a');
+        expect(a).toBeDefined();
+        const ais = a === null || a === void 0 ? void 0 : a.numericArray();
+        expect(ais).toEqual([1, 2]);
+    });
+    test('has', () => {
+        const strToParse = 'a b.d';
+        const getTags = malloy_1.Tag.fromTagline(strToParse, undefined);
+        expect(getTags.log).toEqual([]);
+        expect(getTags.tag.has('a')).toBeTruthy();
+        expect(getTags.tag.has('b', 'd')).toBeTruthy();
+        expect(getTags.tag.has('c')).toBeFalsy();
+    });
+});
+describe('## top level', () => {
+    test('top level tags are available in the model def', async () => {
+        const model = await runtime
+            .loadModel(`
+        ## propertyTag
+        ##" Doc String
+      `)
+            .getModel();
+        const modelTagLine = model.tagParse().tag;
+        expect(modelTagLine.has('propertyTag')).toBeTruthy();
+        expect(model.getTaglines(/^##"/)).toEqual(['##" Doc String\n']);
+    });
+});
+describe('tags in results', () => {
+    test('nameless query', async () => {
+        const loaded = runtime.loadQuery(`
+        ## modelDef=ok
+        source: one is duckdb.sql("SELECT 1 as one")
+        # b4query
+        run: # afterQuery import=$(modelDef)
+          one -> { select: * }`);
+        const qTag = { b4query: {}, afterQuery: {}, import: { eq: 'ok' } };
+        const query = await loaded.getPreparedQuery();
+        expect(query).toBeDefined();
+        expect(query.tagParse().tag).tagsAre(qTag);
+        const result = await loaded.run();
+        expect(result.tagParse().tag).tagsAre(qTag);
+    });
+    const wantTag = { BQ: {}, AQ: {}, Bis: {}, Ais: {}, import: { eq: 'ok' } };
+    test('named query', async () => {
+        const loaded = runtime.loadQuery(`
+        ## modelDef=ok
+        source: one is duckdb.sql("SELECT 1 as one")
+        # BQ
+        query: # AQ
+          # import=$(modelDef)
+          theName
+          # Bis
+          is
+          # Ais
+          one -> { select: * }
+        run: theName
+      `);
+        const query = await loaded.getPreparedQuery();
+        expect(query).toBeDefined();
+        expect(query.tagParse().tag).tagsAre(wantTag);
+        const result = await loaded.run();
+        expect(result.tagParse().tag).tagsAre(wantTag);
+    });
+    test('turtle query', async () => {
+        const loaded = runtime.loadQuery(`
+        ## modelDef=ok
+        source: one is duckdb.sql("SELECT 1 as one") extend {
+          # BQ import=$(modelDef)
+          view: # AQ
+            in_one
+            # Bis
+            is
+            # Ais
+            { select: one }
+        }
+        run: one -> in_one
+      `);
+        const query = await loaded.getPreparedQuery();
+        expect(query).toBeDefined();
+        expect(query.tagParse().tag).tagsAre(wantTag);
+        const result = await loaded.run();
+        expect(result.tagParse().tag).tagsAre(wantTag);
+    });
+    test('field ref has tag', async () => {
+        const loaded = runtime.loadQuery(`run: duckdb.sql("select 1 as num") extend {
+        dimension: # sourceNote
+          one is num
+        } -> {
+          select: # queryNote
+          one
+      }`);
+        const result = await loaded.run();
+        const shape = result.resultExplore;
+        const one = shape.getFieldByName('one');
+        expect(one).toBeDefined();
+        const tp = one.tagParse();
+        expect(tp.log).toEqual([]);
+        expect(tp.tag).tagsAre({ sourceNote: {}, queryNote: {} });
+    });
+    test('atomic field model scope tag', async () => {
+        const loaded = runtime.loadQuery(`
+          ## modelDef=ok
+          source: one is duckdb.sql("SELECT 1 as one")
+          run: one -> {
+            select:
+              # note1 import=$(modelDef)
+              one
+          }`);
+        const result = await loaded.run();
+        const shape = result.resultExplore;
+        const one = shape.getFieldByName('one');
+        expect(one).toBeDefined();
+        const tp = one.tagParse();
+        expect(tp.log).toEqual([]);
+        expect(tp.tag).tagsAre({ note1: {}, import: { eq: 'ok' } });
+    });
+    test('nested query has tag', async () => {
+        const loaded = runtime.loadQuery(`
+          ## modelDef=ok
+          source: one is duckdb.sql("SELECT 1 as one")
+          source: malloy_one is one extend {
+            view: in_one is {
+              select: one
+            }
+            view: one_and_one is {
+              group_by: one
+              # note1
+              nest:
+                # note2 import=$(modelDef)
+                in_one
+            }
+          }
+          run: malloy_one -> one_and_one`);
+        const result = await loaded.run();
+        const shape = result.resultExplore;
+        const one = shape.getFieldByName('in_one');
+        expect(one).toBeDefined();
+        expect(one.tagParse().tag).tagsAre({
+            note1: {},
+            note2: {},
+            import: { eq: 'ok' },
+        });
+    });
+    test('render usage test case', async () => {
+        const loaded = runtime.loadQuery(`
+        source: ages is duckdb.sql('SELECT 1 as one') extend {
+          # name
+          dimension: name is 'John'
+          view: height
+          # barchart
+          is {
+            select: heightd is 10
+          }
+
+          view: age
+          # barchart
+          is {
+            select: aged is 20
+          }
+
+        }
+        run: ages -> {
+          group_by: name
+          nest: height
+          nest: age
+        }
+        `);
+        const result = await loaded.run();
+        const shape = result.resultExplore;
+        const height = shape.getFieldByName('height');
+        const age = shape.getFieldByName('age');
+        const name = shape.getFieldByName('name');
+        expect(height.tagParse().tag).tagsAre({ barchart: {} });
+        expect(age.tagParse().tag).tagsAre({ barchart: {} });
+        expect(name.tagParse().tag).tagsAre({ name: {} });
+    });
+    test('User defined scopes nest properly', async () => {
+        const loaded = runtime.loadQuery(`
+          ## scope=model
+          run: duckdb.sql("SELECT 1 as one") -> {
+            select:
+              # valueFrom=$(scope)
+              one
+          }`);
+        const result = await loaded.run();
+        const shape = result.resultExplore;
+        const field = shape.getFieldByName('one');
+        expect(field).toBeDefined();
+        let tp = field.tagParse().tag;
+        expect(tp).tagsAre({ valueFrom: { eq: 'model' } });
+        const sessionScope = malloy_1.Tag.fromTagline('# scope=session', undefined).tag;
+        tp = field.tagParse({ scopes: [sessionScope] }).tag;
+        expect(tp).tagsAre({ valueFrom: { eq: 'session' } });
+        const globalScope = malloy_1.Tag.fromTagline('# scope=global', undefined).tag;
+        tp = field.tagParse({ scopes: [globalScope, sessionScope] }).tag;
+        expect(tp).tagsAre({ valueFrom: { eq: 'global' } });
+    });
+    test('inherited model tags override', async () => {
+        const model = runtime.loadModel('## from=cell1\nsource: one is duckdb.sql("select 1")');
+        const model2 = model.extendModel('## from=cell2');
+        const query = model2.loadQuery('run: one -> {select: `1`}');
+        const result = await query.run();
+        const modelTags = result.modelTag;
+        expect(modelTags.text('from')).toEqual('cell2');
+    });
+    test('property access on existing tag (which does not yet have properties)', () => {
+        const parsePlot = malloy_1.Tag.fromTagline('# plot', undefined);
+        const parsed = malloy_1.Tag.fromTagline('# plot.x=2', parsePlot.tag);
+        const allTags = parsed.tag;
+        const plotTag = allTags.tag('plot');
+        const xTag = plotTag.tag('x');
+        const x = xTag.numeric();
+        expect(parsed.tag.numeric('plot', 'x')).toEqual(2);
+        expect(plotTag.numeric('x')).toEqual(2);
+        expect(x).toEqual(2);
+    });
+});
+//# sourceMappingURL=tags.spec.js.map