@malloydata/db-publisher 0.0.314 → 0.0.316

package/dist/{publisher_connection.spec.js → publisher_connection.unit.spec.js}

@@ -5,62 +5,34 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  */
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
 Object.defineProperty(exports, "__esModule", { value: true });
-const malloy = __importStar(require("@malloydata/malloy"));
 const test_1 = require("@malloydata/malloy/test");
 const publisher_connection_1 = require("./publisher_connection");
-const url_1 = require("url");
-const util = __importStar(require("util"));
-const fs = __importStar(require("fs"));
 const client_1 = require("./client");
-// mocks client code for testing
+// mocks client code for testing - only for unit tests
 jest.mock('./client', () => {
     const mockConnectionsApi = {
         getConnection: jest.fn(),
-        getTest: jest.fn(),
+        getTable: jest.fn(),
         getTablesource: jest.fn(),
         getSqlsource: jest.fn(),
         getQuerydata: jest.fn(),
         getTemporarytable: jest.fn(),
+        postSqlsource: jest.fn(),
+        postQuerydata: jest.fn(),
+        postTemporarytable: jest.fn(),
+    };
+    const mockConnectionsTestApi = {
+        testConnectionConfiguration: jest.fn(),
     };
     return {
         Configuration: jest.fn().mockImplementation(() => ({
             basePath: 'http://test.com/api/v0',
         })),
         ConnectionsApi: jest.fn().mockImplementation(() => mockConnectionsApi),
+        ConnectionsTestApi: jest
+            .fn()
+            .mockImplementation(() => mockConnectionsTestApi),
     };
 });
 const [describe] = (0, test_1.describeIfDatabaseAvailable)(['publisher']);
@@ -68,10 +40,12 @@ describe('db:Publisher', () => {
     describe('unit', () => {
         describe('create', () => {
             let mockConnectionsApi;
+            let mockConnectionsTestApi;
             let _mockConfiguration;
             beforeEach(() => {
                 // Get fresh instances of the mocks
                 mockConnectionsApi = new client_1.ConnectionsApi(new client_1.Configuration());
+                mockConnectionsTestApi = new client_1.ConnectionsTestApi(new client_1.Configuration());
                 _mockConfiguration = new client_1.Configuration();
             });
             afterEach(() => {
@@ -86,7 +60,13 @@ describe('db:Publisher', () => {
                 };
                 const mockConnectionResponse = {
                     data: {
+                        name: 'test-connection',
+                        type: 'bigquery',
                         attributes: mockConnectionAttributes,
+                        bigqueryConnection: {
+                            defaultProjectId: 'test-project',
+                            billingProjectId: 'test-project',
+                        },
                     },
                     status: 200,
                     statusText: 'OK',
@@ -94,14 +74,17 @@ describe('db:Publisher', () => {
                     config: {},
                 };
                 const mockTestResponse = {
-                    data: undefined,
+                    data: {
+                        status: 'ok',
+                        errorMessage: '',
+                    },
                     status: 200,
                     statusText: 'OK',
                     headers: {},
                     config: {},
                 };
                 mockConnectionsApi.getConnection.mockResolvedValueOnce(mockConnectionResponse);
-                mockConnectionsApi.getTest.mockResolvedValueOnce(mockTestResponse);
+                mockConnectionsTestApi.testConnectionConfiguration.mockResolvedValueOnce(mockTestResponse);
                 const connection = await publisher_connection_1.PublisherConnection.create('test-connection', {
                     connectionUri: 'http://test.com/api/v0/projects/test-project/connections/test-connection',
                     accessToken: 'test-token',
@@ -140,7 +123,13 @@ describe('db:Publisher', () => {
                 };
                 const mockConnectionResponse = {
                     data: {
+                        name: 'test-connection',
+                        type: 'bigquery',
                         attributes: mockConnectionAttributes,
+                        bigqueryConnection: {
+                            defaultProjectId: 'test-project',
+                            billingProjectId: 'test-project',
+                        },
                     },
                     status: 200,
                     statusText: 'OK',
@@ -148,14 +137,17 @@ describe('db:Publisher', () => {
                     config: {},
                 };
                 const mockTestResponse = {
-                    data: undefined,
+                    data: {
+                        status: 'ok',
+                        errorMessage: '',
+                    },
                     status: 200,
                     statusText: 'OK',
                     headers: {},
                     config: {},
                 };
                 mockConnectionsApi.getConnection.mockResolvedValueOnce(mockConnectionResponse);
-                mockConnectionsApi.getTest.mockResolvedValueOnce(mockTestResponse);
+                mockConnectionsTestApi.testConnectionConfiguration.mockResolvedValueOnce(mockTestResponse);
                 const connection = await publisher_connection_1.PublisherConnection.create('test-connection', {
                     connectionUri: 'http://test.com/api/v0/projects/test-project/connections/test-connection',
                 });
@@ -177,17 +169,6 @@ describe('db:Publisher', () => {
                 jest.clearAllMocks();
             });
             it('should fetch table schema successfully', async () => {
-                const mockTableSchema = {
-                    type: 'table',
-                    name: 'test_table',
-                    tablePath: 'test_path',
-                    connection: 'test-connection',
-                    dialect: 'bigquery',
-                    fields: [
-                        { name: 'id', type: 'number' },
-                        { name: 'name', type: 'string' },
-                    ],
-                };
                 const mockConnectionResponse = {
                     data: {
                         attributes: {
@@ -204,7 +185,11 @@ describe('db:Publisher', () => {
                 };
                 const mockTableResponse = {
                     data: {
-                        source: JSON.stringify(mockTableSchema),
+                        resource: 'test_path',
+                        columns: [
+                            { name: 'id', type: 'number' },
+                            { name: 'name', type: 'string' },
+                        ],
                     },
                     status: 200,
                     statusText: 'OK',
@@ -212,24 +197,69 @@ describe('db:Publisher', () => {
                     config: {},
                 };
                 mockConnectionsApi.getConnection.mockResolvedValueOnce(mockConnectionResponse);
-                mockConnectionsApi.getTablesource.mockResolvedValueOnce(mockTableResponse);
+                mockConnectionsApi.getTable.mockResolvedValueOnce(mockTableResponse);
                 const connection = await publisher_connection_1.PublisherConnection.create('test-connection', {
                     connectionUri: 'http://test.com/api/v0/projects/test-project/connections/test-connection',
                     accessToken: 'test-token',
                 });
                 const schema = await connection.fetchTableSchema('test_key', 'test_path');
-                expect(schema).toEqual(mockTableSchema);
-                expect(mockConnectionsApi.getTablesource).toHaveBeenCalledWith('test-project', 'test-connection', 'test_key', 'test_path', {
+                expect(schema).toEqual({
+                    type: 'table',
+                    name: 'test_key',
+                    tablePath: 'test_path',
+                    connection: 'test-connection',
+                    dialect: 'bigquery',
+                    fields: [
+                        { name: 'id', type: 'number' },
+                        { name: 'name', type: 'string' },
+                    ],
+                });
+                expect(mockConnectionsApi.getTable).toHaveBeenCalledWith('test-project', 'test-connection', 'test_path', 'test_path', {
                     headers: {
                         Authorization: 'Bearer test-token',
                     },
                 });
             });
             it('should handle API errors', async () => {
-                await setupAndTestApiError(mockConnectionsApi, 'getTablesource', connection => connection.fetchTableSchema('test_key', 'test_path'));
+                await setupAndTestApiError(mockConnectionsApi, 'getTable', connection => connection.fetchTableSchema('test_key', 'test_path'));
             });
             it('should handle invalid JSON response', async () => {
-                await setupAndTestInvalidJsonResponse(mockConnectionsApi, 'getTablesource', connection => connection.fetchTableSchema('test_key', 'test_path'));
+                const mockConnectionResponse = {
+                    data: {
+                        attributes: {
+                            dialectName: 'bigquery',
+                            isPool: false,
+                            canPersist: true,
+                            canStream: true,
+                        },
+                    },
+                    status: 200,
+                    statusText: 'OK',
+                    headers: {},
+                    config: {},
+                };
+                const mockInvalidResponse = {
+                    data: { resource: 'invalid json', columns: null },
+                    status: 200,
+                    statusText: 'OK',
+                    headers: {},
+                    config: {},
+                };
+                mockConnectionsApi.getConnection.mockResolvedValueOnce(mockConnectionResponse);
+                mockConnectionsApi.getTable.mockResolvedValueOnce(mockInvalidResponse);
+                const connection = await publisher_connection_1.PublisherConnection.create('test-connection', {
+                    connectionUri: 'http://test.com/api/v0/projects/test-project/connections/test-connection',
+                    accessToken: 'test-token',
+                });
+                const schema = await connection.fetchTableSchema('test_key', 'test_path');
+                expect(schema).toEqual({
+                    type: 'table',
+                    name: 'test_key',
+                    tablePath: 'test_path',
+                    connection: 'test-connection',
+                    dialect: 'bigquery',
+                    fields: [],
+                });
             });
         });
         describe('fetchSelectSchema', () => {
@@ -279,7 +309,7 @@ describe('db:Publisher', () => {
                     config: {},
                 };
                 mockConnectionsApi.getConnection.mockResolvedValueOnce(mockConnectionResponse);
-                mockConnectionsApi.getSqlsource.mockResolvedValueOnce(mockSqlResponse);
+                mockConnectionsApi.postSqlsource.mockResolvedValueOnce(mockSqlResponse);
                 const connection = await publisher_connection_1.PublisherConnection.create('test-connection', {
                     connectionUri: 'http://test.com/api/v0/projects/test-project/connections/test-connection',
                     accessToken: 'test-token',
@@ -289,20 +319,22 @@ describe('db:Publisher', () => {
                     connection: 'test-connection',
                 });
                 expect(schema).toEqual(mockSqlSchema);
-                expect(mockConnectionsApi.getSqlsource).toHaveBeenCalledWith('test-project', 'test-connection', 'SELECT * FROM test_table', {
+                expect(mockConnectionsApi.postSqlsource).toHaveBeenCalledWith('test-project', 'test-connection', {
+                    sqlStatement: 'SELECT * FROM test_table',
+                }, {
                     headers: {
                         Authorization: 'Bearer test-token',
                     },
                 });
             });
             it('should handle API errors', async () => {
-                await setupAndTestApiError(mockConnectionsApi, 'getSqlsource', connection => connection.fetchSelectSchema({
+                await setupAndTestApiError(mockConnectionsApi, 'postSqlsource', connection => connection.fetchSelectSchema({
                     selectStr: 'SELECT * FROM test_table',
                     connection: 'test-connection',
                 }));
             });
             it('should handle invalid JSON response', async () => {
-                await setupAndTestInvalidJsonResponse(mockConnectionsApi, 'getSqlsource', connection => connection.fetchSelectSchema({
+                await setupAndTestInvalidJsonResponse(mockConnectionsApi, 'postSqlsource', connection => connection.fetchSelectSchema({
                     selectStr: 'SELECT * FROM test_table',
                     connection: 'test-connection',
                 }));
@@ -351,14 +383,14 @@ describe('db:Publisher', () => {
                     config: {},
                 };
                 mockConnectionsApi.getConnection.mockResolvedValueOnce(mockConnectionResponse);
-                mockConnectionsApi.getQuerydata.mockResolvedValueOnce(mockQueryResponse);
+                mockConnectionsApi.postQuerydata.mockResolvedValueOnce(mockQueryResponse);
                 const connection = await publisher_connection_1.PublisherConnection.create('test-connection', {
                     connectionUri: 'http://test.com/api/v0/projects/test-project/connections/test-connection',
                     accessToken: 'test-token',
                 });
                 const result = await connection.runSQL('SELECT * FROM test_table');
                 expect(result).toEqual(mockQueryData);
-                expect(mockConnectionsApi.getQuerydata).toHaveBeenCalledWith('test-project', 'test-connection', 'SELECT * FROM test_table', '{}', {
+                expect(mockConnectionsApi.postQuerydata).toHaveBeenCalledWith('test-project', 'test-connection', { sqlStatement: 'SELECT * FROM test_table' }, JSON.stringify({}), {
                     headers: {
                         Authorization: 'Bearer test-token',
                     },
@@ -396,7 +428,7 @@ describe('db:Publisher', () => {
                     config: {},
                 };
                 mockConnectionsApi.getConnection.mockResolvedValueOnce(mockConnectionResponse);
-                mockConnectionsApi.getQuerydata.mockResolvedValueOnce(mockQueryResponse);
+                mockConnectionsApi.postQuerydata.mockResolvedValueOnce(mockQueryResponse);
                 const connection = await publisher_connection_1.PublisherConnection.create('test-connection', {
                     connectionUri: 'http://test.com/api/v0/projects/test-project/connections/test-connection',
                     accessToken: 'test-token',
@@ -407,17 +439,17 @@ describe('db:Publisher', () => {
                 };
                 const result = await connection.runSQL('SELECT * FROM test_table', options);
                 expect(result).toEqual(mockQueryData);
-                expect(mockConnectionsApi.getQuerydata).toHaveBeenCalledWith('test-project', 'test-connection', 'SELECT * FROM test_table', JSON.stringify(options), {
+                expect(mockConnectionsApi.postQuerydata).toHaveBeenCalledWith('test-project', 'test-connection', { sqlStatement: 'SELECT * FROM test_table' }, JSON.stringify(options), {
                     headers: {
                         Authorization: 'Bearer test-token',
                     },
                 });
             });
             it('should handle API errors', async () => {
-                await setupAndTestApiError(mockConnectionsApi, 'getQuerydata', connection => connection.runSQL('SELECT * FROM test_table'));
+                await setupAndTestApiError(mockConnectionsApi, 'postQuerydata', connection => connection.runSQL('SELECT * FROM test_table'));
             });
             it('should handle invalid JSON response', async () => {
-                await setupAndTestInvalidJsonResponse(mockConnectionsApi, 'getQuerydata', connection => connection.runSQL('SELECT * FROM test_table'), { data: 'invalid json' });
+                await setupAndTestInvalidJsonResponse(mockConnectionsApi, 'postQuerydata', connection => connection.runSQL('SELECT * FROM test_table'), { data: 'invalid json' });
             });
         });
         describe('runSQLStream', () => {
@@ -463,7 +495,7 @@ describe('db:Publisher', () => {
                     config: {},
                 };
                 mockConnectionsApi.getConnection.mockResolvedValueOnce(mockConnectionResponse);
-                mockConnectionsApi.getQuerydata.mockResolvedValueOnce(mockQueryResponse);
+                mockConnectionsApi.postQuerydata.mockResolvedValueOnce(mockQueryResponse);
                 const connection = await publisher_connection_1.PublisherConnection.create('test-connection', {
                     connectionUri: 'http://test.com/api/v0/projects/test-project/connections/test-connection',
                     accessToken: 'test-token',
@@ -474,7 +506,7 @@ describe('db:Publisher', () => {
                     results.push(row);
                 }
                 expect(results).toEqual(mockQueryData.rows);
-                expect(mockConnectionsApi.getQuerydata).toHaveBeenCalledWith('test-project', 'test-connection', 'SELECT * FROM test_table', '{}', {
+                expect(mockConnectionsApi.postQuerydata).toHaveBeenCalledWith('test-project', 'test-connection', { sqlStatement: 'SELECT * FROM test_table' }, '{}', {
                     headers: {
                         Authorization: 'Bearer test-token',
                     },
@@ -512,7 +544,7 @@ describe('db:Publisher', () => {
                     config: {},
                 };
                 mockConnectionsApi.getConnection.mockResolvedValueOnce(mockConnectionResponse);
-                mockConnectionsApi.getQuerydata.mockResolvedValueOnce(mockQueryResponse);
+                mockConnectionsApi.postQuerydata.mockResolvedValueOnce(mockQueryResponse);
                 const connection = await publisher_connection_1.PublisherConnection.create('test-connection', {
                     connectionUri: 'http://test.com/api/v0/projects/test-project/connections/test-connection',
                     accessToken: 'test-token',
@@ -527,14 +559,14 @@ describe('db:Publisher', () => {
                     results.push(row);
                 }
                 expect(results).toEqual(mockQueryData.rows);
-                expect(mockConnectionsApi.getQuerydata).toHaveBeenCalledWith('test-project', 'test-connection', 'SELECT * FROM test_table', JSON.stringify(options), {
+                expect(mockConnectionsApi.postQuerydata).toHaveBeenCalledWith('test-project', 'test-connection', { sqlStatement: 'SELECT * FROM test_table' }, JSON.stringify(options), {
                     headers: {
                         Authorization: 'Bearer test-token',
                     },
                 });
             });
             it('should handle API errors', async () => {
-                await setupAndTestApiError(mockConnectionsApi, 'getQuerydata', async (connection) => {
+                await setupAndTestApiError(mockConnectionsApi, 'postQuerydata', async (connection) => {
                     const stream = connection.runSQLStream('SELECT * FROM test_table');
                     const results = [];
                     for await (const row of stream) {
@@ -543,7 +575,7 @@ describe('db:Publisher', () => {
                 });
             });
             it('should handle invalid JSON response', async () => {
-                await setupAndTestInvalidJsonResponse(mockConnectionsApi, 'getQuerydata', async (connection) => {
+                await setupAndTestInvalidJsonResponse(mockConnectionsApi, 'postQuerydata', async (connection) => {
                     const stream = connection.runSQLStream('SELECT * FROM test_table');
                     const results = [];
                     for await (const row of stream) {
@@ -588,29 +620,31 @@ describe('db:Publisher', () => {
                     config: {},
                 };
                 mockConnectionsApi.getConnection.mockResolvedValueOnce(mockConnectionResponse);
-                mockConnectionsApi.getTemporarytable.mockResolvedValueOnce(mockTableResponse);
+                mockConnectionsApi.postTemporarytable.mockResolvedValueOnce(mockTableResponse);
                 const connection = await publisher_connection_1.PublisherConnection.create('test-connection', {
                     connectionUri: 'http://test.com/api/v0/projects/test-project/connections/test-connection',
                     accessToken: 'test-token',
                 });
                 const tableName = await connection.manifestTemporaryTable('SELECT * FROM test_table');
                 expect(tableName).toBe('temp_table_123');
-                expect(mockConnectionsApi.getTemporarytable).toHaveBeenCalledWith('test-project', 'test-connection', 'SELECT * FROM test_table', {
+                expect(mockConnectionsApi.postTemporarytable).toHaveBeenCalledWith('test-project', 'test-connection', { sqlStatement: 'SELECT * FROM test_table' }, {
                     headers: {
                         Authorization: 'Bearer test-token',
                     },
                 });
             });
             it('should handle API errors', async () => {
-                await setupAndTestApiError(mockConnectionsApi, 'getTemporarytable', connection => connection.manifestTemporaryTable('SELECT * FROM test_table'));
+                await setupAndTestApiError(mockConnectionsApi, 'postTemporarytable', connection => connection.manifestTemporaryTable('SELECT * FROM test_table'));
             });
         });
         describe('test', () => {
             let mockConnectionsApi;
+            let mockConnectionsTestApi;
             let _mockConfiguration;
             beforeEach(() => {
                 // Get fresh instances of the mocks
                 mockConnectionsApi = new client_1.ConnectionsApi(new client_1.Configuration());
+                mockConnectionsTestApi = new client_1.ConnectionsTestApi(new client_1.Configuration());
                 _mockConfiguration = new client_1.Configuration();
             });
             afterEach(() => {
@@ -619,12 +653,18 @@ describe('db:Publisher', () => {
             it('should test connection successfully', async () => {
                 const mockConnectionResponse = {
                     data: {
+                        name: 'test-connection',
+                        type: 'bigquery',
                         attributes: {
                             dialectName: 'bigquery',
                             isPool: false,
                             canPersist: true,
                             canStream: true,
                         },
+                        bigqueryConnection: {
+                            defaultProjectId: 'test-project',
+                            billingProjectId: 'test-project',
+                        },
                     },
                     status: 200,
                     statusText: 'OK',
@@ -632,120 +672,119 @@ describe('db:Publisher', () => {
                     config: {},
                 };
                 const mockTestResponse = {
-                    data: undefined,
+                    data: {
+                        status: 'ok',
+                        errorMessage: '',
+                    },
                     status: 200,
                     statusText: 'OK',
                     headers: {},
                     config: {},
                 };
                 mockConnectionsApi.getConnection.mockResolvedValueOnce(mockConnectionResponse);
-                mockConnectionsApi.getTest.mockResolvedValueOnce(mockTestResponse);
+                mockConnectionsTestApi.testConnectionConfiguration.mockResolvedValueOnce(mockTestResponse);
                 const connection = await publisher_connection_1.PublisherConnection.create('test-connection', {
                     connectionUri: 'http://test.com/api/v0/projects/test-project/connections/test-connection',
                     accessToken: 'test-token',
                 });
                 await expect(connection.test()).resolves.not.toThrow();
-                expect(mockConnectionsApi.getTest).toHaveBeenCalledWith('test-project', 'test-connection', {
+                expect(mockConnectionsTestApi.testConnectionConfiguration).toHaveBeenCalledWith({
+                    name: 'test-connection',
+                    type: 'bigquery',
+                    attributes: {
+                        dialectName: 'bigquery',
+                        isPool: false,
+                        canPersist: true,
+                        canStream: true,
+                    },
+                    bigqueryConnection: {
+                        defaultProjectId: 'test-project',
+                        billingProjectId: 'test-project',
+                    },
+                }, {
                     headers: {
                         Authorization: 'Bearer test-token',
                     },
                 });
             });
         });
-    });
-    describe.skip('integration', () => {
-        let conn;
-        let runtime;
-        beforeEach(async () => {
-            conn = await publisher_connection_1.PublisherConnection.create('bigquery', 
-            //{
-            //connectionUri: 'http://localhost:4000/api/v0/projects/malloy-samples/connections/bigquery',
-            //}
-            {
-                connectionUri: 'http://demo.data.pathways.localhost:8000/api/v0/projects/malloy-samples/connections/bigquery',
-                accessToken: 'xyz',
-            });
-            const files = {
-                readURL: async (url) => {
-                    const filePath = (0, url_1.fileURLToPath)(url);
-                    return await util.promisify(fs.readFile)(filePath, 'utf8');
-                },
-            };
-            runtime = new malloy.Runtime({
-                urlReader: files,
-                connection: conn,
+        describe('estimateQueryCost', () => {
+            let mockConnectionsApi;
+            let _mockConfiguration;
+            beforeEach(() => {
+                // Get fresh instances of the mocks
+                mockConnectionsApi = new client_1.ConnectionsApi(new client_1.Configuration());
+                _mockConfiguration = new client_1.Configuration();
+            });
+            it('should return empty object for query cost estimation', async () => {
+                const mockConnectionAttributes = {
+                    dialectName: 'bigquery',
+                    isPool: false,
+                    canPersist: true,
+                    canStream: true,
+                };
+                const mockConnectionResponse = {
+                    data: {
+                        name: 'test-connection',
+                        type: 'bigquery',
+                        attributes: mockConnectionAttributes,
+                        bigqueryConnection: {
+                            defaultProjectId: 'test-project',
+                            billingProjectId: 'test-project',
+                        },
+                    },
+                    status: 200,
+                    statusText: 'OK',
+                    headers: {},
+                    config: {},
+                };
+                mockConnectionsApi.getConnection.mockResolvedValueOnce(mockConnectionResponse);
+                const connection = await publisher_connection_1.PublisherConnection.create('test-connection', {
+                    connectionUri: 'http://test.com/api/v0/projects/test-project/connections/test-connection',
+                    accessToken: 'test-token',
+                });
+                const cost = await connection.estimateQueryCost('SELECT * FROM test_table');
+                expect(cost).toEqual({});
             });
         });
-        afterEach(async () => {
-            await conn.close();
-        });
-        it('tests the connection', async () => {
-            await conn.test();
-        });
-        it('correctly identifies the dialect', () => {
-            expect(conn.dialectName).toBe('standardsql');
-        });
-        it('correctly identifies the connection as a pooled connection', () => {
-            expect(conn.isPool()).toBe(false);
-        });
-        it('correctly identifies the connection as a streaming connection', () => {
-            expect(conn.canStream()).toBe(true);
-        });
-        it('correctly identifies the connection as a persistSQLResults connection', () => {
-            expect(conn.canPersist()).toBe(true);
-        });
-        it('fetches the table schema', async () => {
-            const schema = await conn.fetchTableSchema('bigquery', 'bigquery-public-data.hacker_news.full');
-            expect(schema.type).toBe('table');
-            expect(schema.dialect).toBe('standardsql');
-            expect(schema.tablePath).toBe('bigquery-public-data.hacker_news.full');
-            expect(schema.fields.length).toBe(14);
-            expect(schema.fields[0].name).toBe('title');
-            expect(schema.fields[0].type).toBe('string');
-        });
-        it('fetches the sql source schema', async () => {
-            const schema = await conn.fetchSelectSchema({
-                connection: 'bigquery',
-                selectStr: 'SELECT * FROM bigquery-public-data.hacker_news.full',
-            });
-            expect(schema.type).toBe('sql_select');
-            expect(schema.dialect).toBe('standardsql');
-            expect(schema.fields.length).toBe(14);
-            expect(schema.fields[0].name).toBe('title');
-            expect(schema.fields[0].type).toBe('string');
-        });
-        it('runs a SQL query', async () => {
-            const res = await conn.runSQL('SELECT 1 as T');
-            expect(res.rows[0]['T']).toBe(1);
-        });
-        it('runs a Malloy query', async () => {
-            var _a;
-            const sql = await runtime
-                .loadModel("source: stories is bigquery.table('bigquery-public-data.hacker_news.full')")
-                .loadQuery('run:  stories -> { aggregate: cnt is count() group_by: `by` order_by: cnt desc limit: 10 }')
-                .getSQL();
-            const res = await conn.runSQL(sql);
-            expect(res.totalRows).toBe(10);
-            let total = 0;
-            for (const row of res.rows) {
-                total += +((_a = row['cnt']) !== null && _a !== void 0 ? _a : 0);
-            }
-            expect(total).toBe(1836679);
-        });
-        it('runs a Malloy query on an sql source', async () => {
-            const sql = await runtime
-                .loadModel("source: stories is bigquery.sql('SELECT * FROM bigquery-public-data.hacker_news.full')")
-                .loadQuery('run:  stories -> { aggregate: cnt is count() group_by: `by` order_by: cnt desc limit: 20 }')
-                .getSQL();
-            const res = await conn.runSQL(sql);
-            expect(res.totalRows).toBe(20);
-            expect(res.rows[0]['cnt']).toBe(1346912);
-        });
-        it('get temporary table name', async () => {
-            const sql = 'SELECT 1 as T';
-            const tempTableName = await conn.manifestTemporaryTable(sql);
-            expect(tempTableName).toBeDefined();
-            expect(tempTableName.startsWith('lofty-complex-452701')).toBe(true);
+        describe('close', () => {
+            let mockConnectionsApi;
+            let _mockConfiguration;
+            beforeEach(() => {
+                // Get fresh instances of the mocks
+                mockConnectionsApi = new client_1.ConnectionsApi(new client_1.Configuration());
+                _mockConfiguration = new client_1.Configuration();
+            });
+            it('should close connection successfully', async () => {
+                const mockConnectionAttributes = {
+                    dialectName: 'bigquery',
+                    isPool: false,
+                    canPersist: true,
+                    canStream: true,
+                };
+                const mockConnectionResponse = {
+                    data: {
+                        name: 'test-connection',
+                        type: 'bigquery',
+                        attributes: mockConnectionAttributes,
+                        bigqueryConnection: {
+                            defaultProjectId: 'test-project',
+                            billingProjectId: 'test-project',
+                        },
+                    },
+                    status: 200,
+                    statusText: 'OK',
+                    headers: {},
+                    config: {},
+                };
+                mockConnectionsApi.getConnection.mockResolvedValueOnce(mockConnectionResponse);
+                const connection = await publisher_connection_1.PublisherConnection.create('test-connection', {
+                    connectionUri: 'http://test.com/api/v0/projects/test-project/connections/test-connection',
+                    accessToken: 'test-token',
+                });
+                // close() should not throw and should return void
+                await expect(connection.close()).resolves.toBeUndefined();
+            });
         });
     });
 });
@@ -813,4 +852,4 @@ async function setupAndTestInvalidJsonResponse(mockConnectionsApi, apiMethod, op
     });
     await testErrorHandling(connection, () => operation(connection));
 }
-//# sourceMappingURL=publisher_connection.spec.js.map
+//# sourceMappingURL=publisher_connection.unit.spec.js.map