@quillsql/admin 1.7.0 → 1.7.2

package/dist/esm/public_components/__tests__/CreateEnvironment.test.js

@@ -1,719 +0,0 @@
-import { jsx as _jsx } from "react/jsx-runtime";
-import { act } from 'react';
-import { render, screen, fireEvent, waitFor, within, } from '@testing-library/react';
-import '@testing-library/jest-dom';
-import CreateEnvironment from '../CreateEnvironment';
-import { useAdmin } from '../../AdminProvider';
-import { quillFetch } from '../../utils/dataFetcher';
-import dotenv from 'dotenv';
-import path from 'path';
-import { defaultTheme } from '../../Admin';
-// Load environment variables from .env.local
-dotenv.config({ path: path.resolve(__dirname, '../../../.env.local') });
-// Mock necessary modules
-jest.mock('../../AdminProvider');
-jest.mock('@quillsql/react');
-// Mock sessionStorage
-const mockSessionStorage = {
-    getItem: jest.fn(),
-    setItem: jest.fn(),
-    removeItem: jest.fn(),
-    clear: jest.fn(),
-    length: 0,
-    key: jest.fn(),
-};
-Object.defineProperty(window, 'sessionStorage', {
-    value: mockSessionStorage,
-    writable: true,
-});
-// Mock SqlTextEditor
-jest.mock('../../components/SqlTextEditor', () => ({
-    __esModule: true,
-    default: ({ value, setValue }) => (_jsx("textarea", { "data-testid": "sql-editor", value: value, onChange: (e) => setValue(e.target.value) })),
-}));
-// Mock scrollIntoView
-window.HTMLElement.prototype.scrollIntoView = jest.fn();
-// avoid error thrown by jspdf
-jest.mock('jspdf', () => ({
-    __esModule: true,
-    default: jest.fn(() => ({
-        text: jest.fn(),
-        save: jest.fn(),
-    })),
-}));
-// Mock ResizeObserver
-global.ResizeObserver = class MockResizeObserver {
-    observe() { }
-    unobserve() { }
-    disconnect() { }
-};
-const testDatabases = [
-    {
-        databaseType: 'PostgreSQL',
-        databaseLabel: 'PostgreSQL',
-        databaseConnectionString: process.env.TEST_POSTGRES_CONNECTION_STRING,
-        databaseCredentials: null,
-        schemaName: 'public',
-        tenant: {
-            name: 'Test Tenant',
-            tenantField: 'customer_id',
-            tenantTable: 'public.customers',
-            idField: 'id',
-            nameField: 'name',
-            tagField: 'id',
-            defaultTenant: 'Acme',
-        },
-        virtualTableQuery: 'SELECT * FROM public.transactions;',
-    },
-    {
-        databaseType: 'PostgreSQL',
-        databaseLabel: 'PostgreSQL',
-        databaseConnectionString: null,
-        databaseCredentials: {
-            user: process.env.TEST_POSTGRES_USER,
-            password: process.env.TEST_POSTGRES_PASSWORD,
-            host: process.env.TEST_POSTGRES_HOST,
-            port: process.env.TEST_POSTGRES_PORT,
-            database: process.env.TEST_POSTGRES_DATABASE,
-        },
-        schemaName: 'public',
-        tenant: {
-            name: 'Test Tenant',
-            tenantField: 'customer_id',
-            tenantTable: 'public.customers',
-            idField: 'id',
-            nameField: 'name',
-            tagField: 'id',
-            defaultTenant: 'Acme',
-        },
-        virtualTableQuery: 'SELECT * FROM public.transactions;',
-    },
-    {
-        databaseType: 'MySQL',
-        databaseLabel: 'MySQL',
-        databaseConnectionString: null,
-        databaseCredentials: {
-            user: process.env.TEST_MYSQL_USER,
-            password: process.env.TEST_MYSQL_PASSWORD,
-            host: process.env.TEST_MYSQL_HOST,
-            port: process.env.TEST_MYSQL_PORT,
-            database: process.env.TEST_MYSQL_DATABASE,
-        },
-        schemaName: 'railway',
-        tenant: {
-            name: 'Test Tenant',
-            tenantField: 'customer_id',
-            tenantTable: 'railway.customers',
-            idField: 'id',
-            nameField: 'name',
-            tagField: 'id',
-            defaultTenant: 'Acme',
-        },
-        virtualTableQuery: 'SELECT * FROM railway.transactions;',
-    },
-    {
-        databaseType: 'MySQL',
-        databaseLabel: 'MySQL',
-        databaseConnectionString: process.env.TEST_MYSQL_CONNECTION_STRING,
-        databaseCredentials: {
-            user: null,
-            password: null,
-            host: null,
-            port: null,
-            database: null,
-        },
-        schemaName: 'railway',
-        tenant: {
-            name: 'Test Tenant',
-            tenantField: 'customer_id',
-            tenantTable: 'railway.customers',
-            idField: 'id',
-            nameField: 'name',
-            tagField: 'id',
-            defaultTenant: 'Acme',
-        },
-        virtualTableQuery: 'SELECT * FROM railway.transactions;',
-    },
-    {
-        databaseType: 'MSSQL',
-        databaseLabel: 'SQL Server',
-        databaseConnectionString: null,
-        databaseCredentials: {
-            user: process.env.TEST_MSSQL_USER,
-            password: process.env.TEST_MSSQL_PASSWORD,
-            host: process.env.TEST_MSSQL_HOST,
-            port: process.env.TEST_MSSQL_PORT,
-            database: process.env.TEST_MSSQL_DATABASE,
-        },
-        schemaName: 'dbo',
-        tenant: {
-            name: 'Test Tenant',
-            tenantField: 'customer_id',
-            tenantTable: 'dbo.customers',
-            idField: 'id',
-            nameField: 'name',
-            tagField: 'id',
-            defaultTenant: 'Acme',
-        },
-        virtualTableQuery: 'SELECT * FROM [dbo].[transactions];',
-    },
-    {
-        databaseType: 'ClickHouse',
-        databaseLabel: 'ClickHouse',
-        databaseConnectionString: null,
-        databaseCredentials: {
-            user: process.env.TEST_CLICKHOUSE_USER,
-            password: process.env.TEST_CLICKHOUSE_PASSWORD,
-            host: process.env.TEST_CLICKHOUSE_HOST,
-            port: process.env.TEST_CLICKHOUSE_PORT,
-            database: null,
-        },
-        schemaName: 'default',
-        tenant: {
-            name: 'Test Tenant',
-            tenantField: 'merchant_id',
-            tenantTable: 'default.merchants',
-            idField: 'id',
-            nameField: 'name',
-            tagField: 'id',
-            defaultTenant: 'Merchant A',
-        },
-        virtualTableQuery: 'SELECT * FROM "default"."transactions";',
-    },
-    {
-        databaseType: 'Snowflake',
-        databaseLabel: 'Snowflake',
-        databaseConnectionString: null,
-        databaseCredentials: {
-            user: process.env.TEST_SNOWFLAKE_USER,
-            password: process.env.TEST_SNOWFLAKE_PASSWORD,
-            host: process.env.TEST_SNOWFLAKE_HOST,
-            database: process.env.TEST_SNOWFLAKE_DATABASE,
-            warehouse: process.env.TEST_SNOWFLAKE_WAREHOUSE,
-            port: null,
-        },
-        schemaName: 'CSVS',
-        tenant: {
-            name: 'Test Tenant',
-            tenantField: 'COMPANY_ID',
-            tenantTable: 'CSVS.COMPANIES',
-            idField: 'ID',
-            nameField: 'NAME',
-            tagField: 'ID',
-            defaultTenant: 'Google',
-        },
-        virtualTableQuery: 'SELECT * FROM "CSVS"."CONTACTS";',
-    },
-    {
-        databaseType: 'BigQuery',
-        databaseLabel: 'BigQuery',
-        databaseConnectionString: null,
-        databaseCredentials: {
-            user: null,
-            password: null,
-            host: null,
-            port: null,
-            database: null,
-            warehouse: null,
-        },
-        jsonString: process.env.TEST_BIGQUERY_CONNECTION_JSON,
-        schemaName: 'transactions',
-        tenant: {
-            name: 'Test Tenant',
-            tenantField: 'customer_id',
-            tenantTable: 'transactions.customers',
-            idField: '_id_',
-            nameField: 'name',
-            tagField: '_id_',
-            defaultTenant: 'Acme',
-        },
-        virtualTableQuery: 'SELECT amount, customer_id FROM `transactions`.`transactions`;',
-    },
-    {
-        databaseType: 'Databricks',
-        databaseLabel: 'Databricks',
-        databaseConnectionString: null,
-        databaseCredentials: {
-            host: process.env.TEST_DATABRICKS_HOST,
-            path: process.env.TEST_DATABRICKS_PATH,
-            token: process.env.TEST_DATABRICKS_TOKEN,
-            database: null,
-            user: null,
-            password: null,
-            port: null,
-            warehouse: null,
-        },
-        jsonString: null,
-        schemaName: 'default',
-        tenant: {
-            name: 'Test Tenant',
-            tenantField: 'customer_id',
-            tenantTable: 'default.customers',
-            idField: 'id',
-            nameField: 'name',
-            tagField: 'id',
-            defaultTenant: 'John Doe',
-        },
-        virtualTableQuery: 'SELECT * FROM default.transactions;',
-    },
-];
-describe('CreateEnvironment', () => {
-    const mockOnOnboardComplete = jest.fn();
-    let mockState;
-    let mockSetClient;
-    let mockDispatch;
-    // let mockQuillFetch: jest.Mock;
-    let clientId;
-    beforeEach(() => {
-        mockSetClient = jest.fn();
-        mockDispatch = jest.fn();
-        // mockQuillFetch = jest.fn((args) => quillFetch(args));
-        mockState = {
-            queryEndpoint: 'http://localhost:8080/cloud',
-            clerkOrgId: 'test-domain',
-            theme: defaultTheme,
-        };
-        useAdmin.mockReturnValue({
-            state: mockState,
-            setClient: mockSetClient,
-            dispatch: mockDispatch,
-            getToken: () => 'test-token',
-            quillFetchWithToken: (args) => {
-                return quillFetch({ ...args, getToken: () => 'test-token' });
-            },
-        });
-    });
-    afterEach(async () => {
-        if (clientId) {
-            // wait for other stuff to finish
-            await new Promise((resolve) => setTimeout(resolve, 3000));
-            await quillFetch({
-                task: 'delete-client',
-                metadata: {
-                    clientId,
-                },
-                client: {
-                    queryEndpoint: 'http://localhost:8080/cloud',
-                    clientId,
-                    withCredentials: false,
-                },
-                getToken: async () => '',
-            });
-        }
-        jest.clearAllMocks();
-    });
-    it.each(testDatabases)('completes onboarding with $databaseType database', async (database) => {
-        expect(process.env.TEST_MODE).toBe('true');
-        render(_jsx(CreateEnvironment, { onOnboardComplete: mockOnOnboardComplete }));
-        expect(screen.getByText(database.databaseLabel)).toBeInTheDocument();
-        // 1. Connect database
-        // Check before states
-        let element = screen.getByTestId('quill-client-id');
-        let envSteps = JSON.parse(element.getAttribute('data-create-env-steps') || '{}');
-        // createEnvSteps
-        expect(envSteps.connectDB.open).toBe(true);
-        expect(envSteps.connectSchema.open).toBe(false);
-        expect(envSteps.createVirtualTables.open).toBe(false);
-        // state
-        const state = JSON.parse(element.getAttribute('data-state') || '{}');
-        expect(state.queryEndpoint).not.toBeNull();
-        // Start inputting details
-        // Switch to database type
-        await act(async () => {
-            fireEvent.click(screen.getByText(new RegExp(database.databaseLabel, 'i')));
-        });
-        if (database.databaseConnectionString) {
-            // Fill in connection string
-            // Click on Connection String tab
-            await act(async () => {
-                fireEvent.click(screen.getByTestId('quill-tab-Connection String'));
-            });
-            // Should now show Connection String input
-            expect(screen.getAllByText('Connection String')[0]).toBeInTheDocument();
-            // Verify Connect button is disabled initially
-            expect(screen.getByTestId('quill-connect-button').querySelector('button')
-                .className).toContain('quill-button-disabled');
-            // Enter connection string
-            await act(async () => {
-                fireEvent.change(screen
-                    .getByTestId('quill-input-connectionString')
-                    .querySelector('input'), {
-                    target: { value: database.databaseConnectionString },
-                });
-            });
-            // Verify Connect button is enabled
-            expect(screen.getByTestId('quill-connect-button').querySelector('button')
-                .className).not.toContain('quill-button-disabled');
-        }
-        else if (database.jsonString) {
-            // Mock file upload by directly setting the JSON string
-            await act(async () => {
-                const fileInput = screen.getByTestId('quill-input-fileInput');
-                const file = new File([database.jsonString], 'service-account.json', { type: 'application/json' });
-                Object.defineProperty(fileInput, 'files', {
-                    value: [file],
-                });
-                fireEvent.change(fileInput);
-            });
-            // Verify the file label was updated
-            await waitFor(() => {
-                expect(screen.getByTestId('quill-file-label')).toHaveTextContent('service-account.json');
-            });
-        }
-        else {
-            // Verify Connect button is disabled
-            expect(screen.getByTestId('quill-connect-button').querySelector('button')
-                .className).toContain('quill-button-disabled');
-            if (database.databaseCredentials?.database) {
-                await act(async () => {
-                    fireEvent.change(screen
-                        .getByTestId('quill-input-databaseName')
-                        .querySelector('input'), { target: { value: database.databaseCredentials.database } });
-                });
-            }
-            if (database.databaseCredentials?.host) {
-                await act(async () => {
-                    fireEvent.change(screen.getByTestId('quill-input-host').querySelector('input'), { target: { value: database.databaseCredentials.host } });
-                });
-            }
-            if (database.databaseCredentials?.user) {
-                await act(async () => {
-                    fireEvent.change(screen.getByTestId('quill-input-user').querySelector('input'), { target: { value: database.databaseCredentials.user } });
-                });
-            }
-            if (database.databaseCredentials?.password) {
-                await act(async () => {
-                    fireEvent.change(screen
-                        .getByTestId('quill-input-password')
-                        .querySelector('input'), { target: { value: database.databaseCredentials.password } });
-                });
-            }
-            if (database.databaseCredentials?.port) {
-                await act(async () => {
-                    fireEvent.change(screen.getByTestId('quill-input-port').querySelector('input'), { target: { value: database.databaseCredentials.port } });
-                });
-            }
-            if (database.databaseCredentials?.warehouse) {
-                await act(async () => {
-                    fireEvent.change(screen
-                        .getByTestId('quill-input-warehouse')
-                        .querySelector('input'), { target: { value: database.databaseCredentials.warehouse } });
-                });
-            }
-            if (database.databaseCredentials?.path) {
-                await act(async () => {
-                    fireEvent.change(screen.getByTestId('quill-input-path').querySelector('input'), { target: { value: database.databaseCredentials.path } });
-                });
-            }
-            if (database.databaseCredentials?.token) {
-                await act(async () => {
-                    fireEvent.change(screen.getByTestId('quill-input-token').querySelector('input'), { target: { value: database.databaseCredentials.token } });
-                });
-            }
-            // Verify Connect button is enabled
-            expect(screen.getByTestId('quill-connect-button').querySelector('button')
-                .className).not.toContain('quill-button-disabled');
-        }
-        // Click connect
-        await act(async () => {
-            fireEvent.click(screen.getByText('Connect'));
-        });
-        await waitFor(() => {
-            expect(screen.getByText('Connection Successful')).toBeInTheDocument();
-        }, { timeout: 5000 });
-        // Verify setEnvironmentDetails was called by checking state changes
-        element = screen.getByTestId('quill-client-id');
-        let newClient = JSON.parse(element.getAttribute('data-new-client') || '{}');
-        expect(typeof newClient.clientId).toBe('string');
-        expect(newClient.clientId.length).toBeGreaterThan(0);
-        await act(async () => {
-            mockState.client = newClient;
-        });
-        // Wait for the state update to be reflected
-        await waitFor(() => {
-            const element = screen.getByTestId('quill-client-id');
-            const currentState = JSON.parse(element.getAttribute('data-state') || '{}');
-            return currentState.client?.id === newClient.clientId;
-        }, { timeout: 5000 });
-        // Click the select button to open the dropdown
-        await act(async () => {
-            expect(screen.getByTestId('quill-schema-select')).toBeInTheDocument();
-            const selectButton = screen
-                .getByTestId('quill-schema-select')
-                .querySelector('button');
-            fireEvent.click(selectButton);
-        });
-        // Wait for the dropdown to appear and select schema
-        await waitFor(() => {
-            expect(screen.getByText(database.schemaName)).toBeInTheDocument();
-        }, { timeout: 5000 });
-        await act(async () => {
-            // Click the schema option
-            const schemaOption = screen.getByText(database.schemaName);
-            fireEvent.click(schemaOption);
-            const selectButton = screen
-                .getByTestId('quill-schema-select')
-                .querySelector('button');
-            fireEvent.click(selectButton);
-        });
-        // Wait for all updates to complete
-        await waitFor(() => {
-            expect(screen.getByText(database.schemaName)).toBeInTheDocument();
-        }, { timeout: 5000 });
-        // Wait for the button to be enabled and click it
-        await waitFor(() => {
-            const looksGoodButton = screen
-                .getByTestId('quill-looks-good-button')
-                .querySelector('button');
-            expect(looksGoodButton.className).not.toContain('quill-button-disabled');
-        }, { timeout: 5000 });
-        // Click the Looks Good button
-        await act(async () => {
-            const looksGoodButton = screen
-                .getByTestId('quill-looks-good-button')
-                .querySelector('button');
-            fireEvent.click(looksGoodButton);
-        });
-        await waitFor(() => {
-            expect(screen.getByText('How do you represent your customers in your database?')).toBeInTheDocument();
-        }, { timeout: 10000 });
-        const environmentDetails = JSON.parse(element.getAttribute('data-environment-details') || '{}');
-        element = screen.getByTestId('quill-client-id');
-        newClient = JSON.parse(element.getAttribute('data-new-client') || '{}');
-        // Verify database schema was set
-        expect(environmentDetails.databaseSchema).toBeInstanceOf(Array);
-        // Client should have databaseType, schemaNames (non empty array), and clerkOrgId
-        expect(newClient.schemaNames).toBeInstanceOf(Array);
-        expect(newClient.schemaNames.length).toBeGreaterThan(0);
-        expect(newClient.databaseType).toBe(database.databaseType);
-        // 2. Connect schema
-        // Check before states
-        element = screen.getByTestId('quill-client-id');
-        envSteps = JSON.parse(element.getAttribute('data-create-env-steps') || '{}');
-        // createEnvSteps
-        expect(envSteps.connectSchema.open).toBe(true);
-        expect(envSteps.createVirtualTables.open).toBe(false);
-        expect(envSteps.connectDB.open).toBe(false);
-        // databaseSchema
-        let databaseSchema = JSON.parse(element.getAttribute('data-database-schema') || '{}');
-        expect(databaseSchema).toBeInstanceOf(Array);
-        expect(databaseSchema.length).toBeGreaterThan(0);
-        await act(async () => {
-            mockState.databaseSchema = {
-                schema: databaseSchema,
-            };
-        });
-        // connection.type
-        let connection = JSON.parse(element.getAttribute('data-connection') || '{}');
-        expect(connection.type).toBe(database.databaseType);
-        // discard changes button hidden
-        expect(screen.queryByText(/Discard Changes/i)).toBeNull();
-        // Create a row level tenant
-        // Fill in tenant name
-        await act(async () => {
-            const tenantNameInput = screen
-                .getByTestId('quill-input-tenant-name')
-                .querySelector('input');
-            fireEvent.change(tenantNameInput, {
-                target: { value: database.tenant.name },
-            });
-        });
-        // Fill in tenant table
-        await act(async () => {
-            const tableSelect = screen
-                .getByTestId('quill-select-tenant-table')
-                .querySelector('button');
-            fireEvent.click(tableSelect);
-        });
-        await waitFor(() => {
-            expect(screen.getByText(database.tenant.tenantTable)).toBeInTheDocument();
-        }, { timeout: 5000 });
-        await act(async () => {
-            fireEvent.click(screen.getByText(database.tenant.tenantTable));
-        });
-        // Fill in id field
-        await act(async () => {
-            const idFieldSelect = screen
-                .getByTestId('quill-select-tenant-id-field')
-                .querySelector('button');
-            expect(idFieldSelect).not.toBeDisabled();
-            fireEvent.click(idFieldSelect);
-        });
-        await act(async () => {
-            const container = screen.getByTestId('quill-select-portal-id-field');
-            const targetElement = within(container).getByText(database.tenant.idField);
-            fireEvent.click(targetElement);
-        });
-        // Fill in name field
-        await act(async () => {
-            const nameFieldSelect = screen
-                .getByTestId('quill-select-tenant-name-field')
-                .querySelector('button');
-            expect(nameFieldSelect).not.toBeDisabled();
-            fireEvent.click(nameFieldSelect);
-        });
-        await act(async () => {
-            const container = screen.getByTestId('quill-select-portal-name-field');
-            const targetElement = within(container).getByText(database.tenant.nameField);
-            fireEvent.click(targetElement);
-        });
-        // Fill in tenant field (foreign key)
-        await act(async () => {
-            const tenantFieldInput = screen
-                .getByTestId('quill-input-tenant-field')
-                .querySelector('input');
-            fireEvent.change(tenantFieldInput, {
-                target: { value: database.tenant.tenantField },
-            });
-        });
-        // Fill in tag
-        await act(async () => {
-            const flagFieldSelect = screen
-                .getByTestId('quill-select-tenant-flag-field')
-                .querySelector('button');
-            expect(flagFieldSelect).not.toBeDisabled();
-            fireEvent.click(flagFieldSelect);
-        });
-        await act(async () => {
-            const container = screen.getByTestId('quill-select-portal-flag-field');
-            const targetElement = within(container).getByText(database.tenant.tagField);
-            fireEvent.click(targetElement);
-        });
-        // Press save changes (should be enabled now)
-        // Click Save Changes button
-        await act(async () => {
-            const saveButton = screen
-                .getByTestId('quill-save-changes-button')
-                .querySelector('button');
-            expect(saveButton.className).not.toContain('quill-button-disabled');
-            fireEvent.click(saveButton);
-        });
-        // Wait for tenant IDs modal to appear and select default tenant
-        await waitFor(() => {
-            expect(screen.getByText('Tenant IDs')).toBeInTheDocument();
-        }, { timeout: 5000 });
-        // Looks good button disabled until default tenant set
-        // Set default tenant id
-        // Select default tenant ID
-        await act(async () => {
-            const defaultTenantSelect = screen
-                .getByTestId('quill-select-default-tenant-id-field')
-                .querySelector('button');
-            fireEvent.click(defaultTenantSelect);
-        });
-        await waitFor(() => {
-            expect(screen.getByText(database.tenant.defaultTenant)).toBeInTheDocument();
-        }, { timeout: 5000 });
-        await act(async () => {
-            const button = screen.getByText(database.tenant.defaultTenant);
-            fireEvent.click(button);
-        });
-        // Click Looks Good button
-        await act(async () => {
-            const looksGoodButton = screen.getByText('Looks Good');
-            fireEvent.click(looksGoodButton);
-        });
-        // Press looks good
-        // handleEditTenant called with submit true
-        // onSubmitEditTenant called
-        await waitFor(() => {
-            expect(screen.getByText('Create a cleaned schema that makes it easier to write queries.')).toBeInTheDocument();
-        }, { timeout: 5000 });
-        // tenantInit should be set
-        element = screen.getByTestId('quill-client-id');
-        const tenantInit = JSON.parse(element.getAttribute('data-tenant-init') || '{}');
-        expect(tenantInit).toBeInstanceOf(Object);
-        const ownerTenant = tenantInit.ownerTenant;
-        expect(ownerTenant).toBeInstanceOf(Object);
-        expect(ownerTenant.name).toBe(database.tenant.name);
-        expect(ownerTenant.tenantField).toBe(database.tenant.tenantField);
-        expect(ownerTenant.tenantFlagField).toBe(database.tenant.tagField);
-        expect(ownerTenant.tenantIdField).toBe(database.tenant.idField);
-        expect(ownerTenant.tenantLabelField).toBe(database.tenant.nameField);
-        // client should have ownerTenantFields and allTenantTypes set with tenantInit
-        newClient = JSON.parse(element.getAttribute('data-new-client') || '{}');
-        expect(newClient.ownerTenantFields).toBeInstanceOf(Array);
-        expect(newClient.allTenantTypes).toBeInstanceOf(Array);
-        expect(newClient.ownerTenantFields.length).toBeGreaterThan(0);
-        expect(newClient.allTenantTypes.length).toBeGreaterThan(0);
-        expect(newClient.ownerTenantFields).toContain(database.tenant.tenantField);
-        // Check create-tenant task was called with success true
-        // 3. Create virtual tables
-        // Check before states
-        element = screen.getByTestId('quill-client-id');
-        envSteps = JSON.parse(element.getAttribute('data-create-env-steps') || '{}');
-        // createEnvSteps
-        expect(envSteps.createVirtualTables.open).toBe(true);
-        expect(envSteps.connectSchema.open).toBe(false);
-        expect(envSteps.connectDB.open).toBe(false);
-        // databaseSchema
-        databaseSchema = JSON.parse(element.getAttribute('data-database-schema') || '{}');
-        expect(databaseSchema).toBeInstanceOf(Array);
-        expect(databaseSchema.length).toBeGreaterThan(0);
-        // connection.type
-        connection = JSON.parse(element.getAttribute('data-connection') || '{}');
-        expect(connection.type).toBe(database.databaseType);
-        // sqlTables empty at start
-        let sqlTables = JSON.parse(element.getAttribute('data-sql-tables') || '{}');
-        expect(sqlTables).toBeInstanceOf(Array);
-        expect(sqlTables.length).toBe(0);
-        // client should have schemaNames and clientId set
-        newClient = JSON.parse(element.getAttribute('data-new-client') || '{}');
-        expect(newClient.schemaNames).toBeInstanceOf(Array);
-        expect(newClient.schemaNames.length).toBeGreaterThan(0);
-        expect(newClient.clientId.length).toBeGreaterThan(0);
-        // Looks good button hidden until virtual tables created
-        expect(screen.queryByText(/Looks Good/i)).toBeNull();
-        // fill in a query and run it
-        // Enter and execute a query
-        const query = database.virtualTableQuery;
-        const sqlEditor = screen.getByTestId('sql-editor');
-        fireEvent.change(sqlEditor, {
-            target: { value: query },
-        });
-        // Click Run query button
-        await act(async () => {
-            fireEvent.click(screen.getByText('Run query'));
-        });
-        // if there is tableData, show virtual tables button
-        await waitFor(() => {
-            expect(screen.getByText('Add Virtual Table')).toBeInTheDocument();
-        }, { timeout: 5000 });
-        // click add virtual tables button
-        await act(async () => {
-            fireEvent.click(screen
-                .getByTestId('add-virtual-table-button')
-                .querySelector('button'));
-        });
-        // Wait for the modal and confirm
-        await waitFor(() => {
-            expect(screen.getByText('Confirm')).toBeInTheDocument();
-        }, { timeout: 5000 });
-        await act(async () => {
-            fireEvent.click(screen.getByText('Confirm'));
-        });
-        // createVirtualTable called
-        // sqlTables updated
-        // Looks good button enabled
-        await waitFor(() => {
-            expect(screen.getByText('Looks good')).toBeInTheDocument();
-        }, { timeout: 5000 });
-        element = screen.getByTestId('quill-client-id');
-        sqlTables = JSON.parse(element.getAttribute('data-sql-tables') || '{}');
-        expect(sqlTables).toBeInstanceOf(Array);
-        expect(sqlTables.length).toBeGreaterThan(0);
-        // Press looks good
-        // Click Looks good button
-        fireEvent.click(screen.getByText('Looks good'));
-        // Verify onboarding completion
-        // Call completeOnboarding
-        // quillFetch called with task finish-onboarding
-        // Client is set to response.data.client
-        // onOnboardComplete function called
-        await waitFor(() => {
-            expect(mockOnOnboardComplete).toHaveBeenCalled();
-        }, { timeout: 5000 });
-        // for cleanup
-        clientId = screen.getByTestId('quill-client-id').textContent;
-    }, 30000);
-});