@quillsql/admin 1.7.1 → 1.7.3

package/dist/esm/forms/client_onboard/__tests__/ConnectDatabase.test.js

@@ -1,566 +0,0 @@
-import { jsx as _jsx } from "react/jsx-runtime";
-import { act } from 'react';
-import { render, screen, fireEvent, waitFor } from '@testing-library/react';
-import '@testing-library/jest-dom';
-import ConnectDatabase from '../ConnectDatabase';
-import { useAdmin } from '../../../hooks/useAdmin';
-// Mock the hooks
-jest.mock('../../../AdminProvider');
-jest.mock('@quillsql/react');
-// Mock the API calls
-jest.mock('../../../api/ConnectionClient', () => ({
-    testConnectionString: jest.fn(),
-    getTableColumnsBySchema: jest.fn(),
-    setSchemaNames: jest.fn(),
-}));
-// avoid error thrown by jspdf
-jest.mock('jspdf', () => ({
-    __esModule: true,
-    default: jest.fn(() => ({
-        text: jest.fn(),
-        save: jest.fn(),
-    })),
-}));
-// Add before describe('ConnectDatabase')
-class MockResizeObserver {
-    observe() { }
-    unobserve() { }
-    disconnect() { }
-}
-global.ResizeObserver = MockResizeObserver;
-describe('ConnectDatabase', () => {
-    const mockSetEnvironmentDetails = jest.fn().mockImplementation(() => { });
-    const mockState = {
-        queryEndpoint: 'http://test-endpoint',
-    };
-    const defaultProps = {
-        environmentDetails: {
-            connection: {
-                type: 'PostgreSQL',
-                user: '',
-                password: '',
-                host: '',
-                databaseName: '',
-                port: '',
-                connectionString: '',
-            },
-            client: {
-                clientId: '',
-                schemaNames: [],
-            },
-        },
-        setEnvironmentDetails: mockSetEnvironmentDetails,
-        fetchSchemasLoading: false,
-    };
-    beforeEach(() => {
-        // Reset all mocks before each test
-        jest.clearAllMocks();
-        // Setup default mock implementations
-        useAdmin.mockReturnValue({ state: mockState });
-    });
-    // Database Type Selection Tests
-    describe('Database Type Selection', () => {
-        it('renders all database type options', async () => {
-            await act(async () => {
-                render(_jsx(ConnectDatabase, { ...defaultProps }));
-            });
-            // Check if all database types are rendered
-            expect(screen.getByText('PostgreSQL')).toBeInTheDocument();
-            expect(screen.getByText('MySQL')).toBeInTheDocument();
-            expect(screen.getByText('BigQuery')).toBeInTheDocument();
-            expect(screen.getByText('SQL Server')).toBeInTheDocument();
-            expect(screen.getByText('ClickHouse')).toBeInTheDocument();
-            expect(screen.getByText('Snowflake')).toBeInTheDocument();
-        });
-        it('switches database type correctly', async () => {
-            await act(async () => {
-                render(_jsx(ConnectDatabase, { ...defaultProps }));
-            });
-            // Test PostgreSQL (default)
-            expect(screen.getByText('Host')).toBeInTheDocument();
-            expect(screen.getByText('Database Name')).toBeInTheDocument();
-            expect(screen.getByText('User')).toBeInTheDocument();
-            expect(screen.getByText('Password')).toBeInTheDocument();
-            expect(screen.getByText('Port')).toBeInTheDocument();
-            // Test MySQL
-            await act(async () => {
-                fireEvent.click(screen.getByText('MySQL'));
-            });
-            expect(screen.getByText('Host')).toBeInTheDocument();
-            expect(screen.getByText('Database Name')).toBeInTheDocument();
-            expect(screen.getByText('User')).toBeInTheDocument();
-            expect(screen.getByText('Password')).toBeInTheDocument();
-            expect(screen.getByText('Port')).toBeInTheDocument();
-            // Test SQL Server
-            await act(async () => {
-                fireEvent.click(screen.getByText('SQL Server'));
-            });
-            expect(screen.getByText('Host')).toBeInTheDocument();
-            expect(screen.getByText('Database Name')).toBeInTheDocument();
-            expect(screen.getByText('User')).toBeInTheDocument();
-            expect(screen.getByText('Password')).toBeInTheDocument();
-            expect(screen.getByText('Port')).toBeInTheDocument();
-            // Test ClickHouse
-            await act(async () => {
-                fireEvent.click(screen.getByText('ClickHouse'));
-            });
-            expect(screen.getByText('Host')).toBeInTheDocument();
-            expect(screen.getByText('User')).toBeInTheDocument();
-            expect(screen.getByText('Password')).toBeInTheDocument();
-            expect(screen.getByText('Port')).toBeInTheDocument();
-            // Test Snowflake
-            await act(async () => {
-                fireEvent.click(screen.getByText('Snowflake'));
-            });
-            expect(screen.getByText('Host')).toBeInTheDocument();
-            expect(screen.getByText('Database Name')).toBeInTheDocument();
-            expect(screen.getByText('User')).toBeInTheDocument();
-            expect(screen.getByText('Password')).toBeInTheDocument();
-            expect(screen.getByText('Warehouse')).toBeInTheDocument();
-            // Test BigQuery
-            await act(async () => {
-                fireEvent.click(screen.getByText('BigQuery'));
-            });
-            expect(screen.getByText('Service Account Json')).toBeInTheDocument();
-            expect(screen.getByText('Upload JSON')).toBeInTheDocument();
-        });
-    });
-    // Connection Method Tests
-    describe('Connection Methods', () => {
-        it('switches between credential tabs for PostgreSQL', async () => {
-            await act(async () => {
-                render(_jsx(ConnectDatabase, { ...defaultProps }));
-            });
-            // Initially should show Database Credentials
-            expect(screen.getByText('Database Credentials')).toBeInTheDocument();
-            // 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();
-        });
-        it('switches between credential tabs for MySQL', async () => {
-            await act(async () => {
-                render(_jsx(ConnectDatabase, { ...defaultProps }));
-            });
-            // Switch to MySQL
-            await act(async () => {
-                fireEvent.click(screen.getByText('MySQL'));
-            });
-            // Initially should show Database Credentials
-            expect(screen.getByText('Database Credentials')).toBeInTheDocument();
-            // 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();
-        });
-    });
-    // Connection Information Tests
-    describe('Connection Information', () => {
-        it('handles PostgreSQL credential input', async () => {
-            await act(async () => {
-                render(_jsx(ConnectDatabase, { ...defaultProps }));
-            });
-            // Verify Connect button is disabled
-            expect(screen.getByTestId('quill-connect-button').querySelector('button')
-                .className).toContain('quill-button-disabled');
-            // Fill in PostgreSQL credentials
-            await act(async () => {
-                fireEvent.change(screen.getByTestId('quill-input-host').querySelector('input'), { target: { value: 'localhost' } });
-            });
-            // Verify Connect button is disabled
-            expect(screen.getByTestId('quill-connect-button').querySelector('button')
-                .className).toContain('quill-button-disabled');
-            await act(async () => {
-                fireEvent.change(screen
-                    .getByTestId('quill-input-databaseName')
-                    .querySelector('input'), { target: { value: 'testdb' } });
-            });
-            // Verify Connect button is disabled
-            expect(screen.getByTestId('quill-connect-button').querySelector('button')
-                .className).toContain('quill-button-disabled');
-            await act(async () => {
-                fireEvent.change(screen.getByTestId('quill-input-user').querySelector('input'), { target: { value: 'testuser' } });
-            });
-            // Verify Connect button is disabled
-            expect(screen.getByTestId('quill-connect-button').querySelector('button')
-                .className).toContain('quill-button-disabled');
-            await act(async () => {
-                fireEvent.change(screen.getByTestId('quill-input-password').querySelector('input'), { target: { value: 'testpass' } });
-            });
-            // Verify Connect button is disabled
-            expect(screen.getByTestId('quill-connect-button').querySelector('button')
-                .className).toContain('quill-button-disabled');
-            await act(async () => {
-                fireEvent.change(screen.getByTestId('quill-input-port').querySelector('input'), { target: { value: '5432' } });
-            });
-            // Verify Connect button is enabled
-            expect(screen.getByTestId('quill-connect-button').querySelector('button')
-                .className).not.toContain('quill-button-disabled');
-        });
-        it('handles PostgreSQL credential input in connection string mode', async () => {
-            await act(async () => {
-                render(_jsx(ConnectDatabase, { ...defaultProps }));
-            });
-            // Switch to Connection String tab
-            await act(async () => {
-                fireEvent.click(screen.getByTestId('quill-tab-Connection String'));
-            });
-            // 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: 'postgresql://testuser:testpass@localhost:5432/testdb',
-                    },
-                });
-            });
-            // Verify Connect button is enabled
-            expect(screen.getByTestId('quill-connect-button').querySelector('button')
-                .className).not.toContain('quill-button-disabled');
-        });
-        it('handles MySQL credential input', async () => {
-            await act(async () => {
-                render(_jsx(ConnectDatabase, { ...defaultProps }));
-            });
-            // Switch to MySQL
-            await act(async () => {
-                fireEvent.click(screen.getByText('MySQL'));
-            });
-            // Verify Connect button is disabled initially
-            expect(screen.getByTestId('quill-connect-button').querySelector('button')
-                .className).toContain('quill-button-disabled');
-            // Fill in MySQL credentials
-            await act(async () => {
-                fireEvent.change(screen.getByTestId('quill-input-host').querySelector('input'), { target: { value: 'localhost' } });
-            });
-            await act(async () => {
-                fireEvent.change(screen
-                    .getByTestId('quill-input-databaseName')
-                    .querySelector('input'), { target: { value: 'testdb' } });
-            });
-            await act(async () => {
-                fireEvent.change(screen.getByTestId('quill-input-user').querySelector('input'), { target: { value: 'testuser' } });
-            });
-            await act(async () => {
-                fireEvent.change(screen.getByTestId('quill-input-password').querySelector('input'), { target: { value: 'testpass' } });
-            });
-            await act(async () => {
-                fireEvent.change(screen.getByTestId('quill-input-port').querySelector('input'), { target: { value: '3306' } });
-            });
-            // Verify Connect button is enabled
-            expect(screen.getByTestId('quill-connect-button').querySelector('button')
-                .className).not.toContain('quill-button-disabled');
-        });
-        it('handles SQL Server credential input', async () => {
-            await act(async () => {
-                render(_jsx(ConnectDatabase, { ...defaultProps }));
-            });
-            // Switch to SQL Server
-            await act(async () => {
-                fireEvent.click(screen.getByText('SQL Server'));
-            });
-            // Verify Connect button is disabled initially
-            expect(screen.getByTestId('quill-connect-button').querySelector('button')
-                .className).toContain('quill-button-disabled');
-            // Fill in SQL Server credentials
-            await act(async () => {
-                fireEvent.change(screen.getByTestId('quill-input-host').querySelector('input'), { target: { value: 'localhost' } });
-            });
-            await act(async () => {
-                fireEvent.change(screen
-                    .getByTestId('quill-input-databaseName')
-                    .querySelector('input'), { target: { value: 'testdb' } });
-            });
-            await act(async () => {
-                fireEvent.change(screen.getByTestId('quill-input-user').querySelector('input'), { target: { value: 'testuser' } });
-            });
-            await act(async () => {
-                fireEvent.change(screen.getByTestId('quill-input-password').querySelector('input'), { target: { value: 'testpass' } });
-            });
-            await act(async () => {
-                fireEvent.change(screen.getByTestId('quill-input-port').querySelector('input'), { target: { value: '1433' } });
-            });
-            // Verify Connect button is enabled
-            expect(screen.getByTestId('quill-connect-button').querySelector('button')
-                .className).not.toContain('quill-button-disabled');
-        });
-        it('handles ClickHouse credential input', async () => {
-            await act(async () => {
-                render(_jsx(ConnectDatabase, { ...defaultProps }));
-            });
-            // Switch to ClickHouse
-            await act(async () => {
-                fireEvent.click(screen.getByText('ClickHouse'));
-            });
-            // Verify Connect button is disabled initially
-            expect(screen.getByTestId('quill-connect-button').querySelector('button')
-                .className).toContain('quill-button-disabled');
-            // Fill in ClickHouse credentials
-            await act(async () => {
-                fireEvent.change(screen.getByTestId('quill-input-host').querySelector('input'), { target: { value: 'localhost' } });
-            });
-            await act(async () => {
-                fireEvent.change(screen.getByTestId('quill-input-user').querySelector('input'), { target: { value: 'testuser' } });
-            });
-            await act(async () => {
-                fireEvent.change(screen.getByTestId('quill-input-password').querySelector('input'), { target: { value: 'testpass' } });
-            });
-            await act(async () => {
-                fireEvent.change(screen.getByTestId('quill-input-port').querySelector('input'), { target: { value: '9000' } });
-            });
-            // Verify Connect button is enabled
-            expect(screen.getByTestId('quill-connect-button').querySelector('button')
-                .className).not.toContain('quill-button-disabled');
-        });
-        it('handles Snowflake credential input', async () => {
-            await act(async () => {
-                render(_jsx(ConnectDatabase, { ...defaultProps }));
-            });
-            // Switch to Snowflake
-            await act(async () => {
-                fireEvent.click(screen.getByText('Snowflake'));
-            });
-            // Verify Connect button is disabled initially
-            expect(screen.getByTestId('quill-connect-button').querySelector('button')
-                .className).toContain('quill-button-disabled');
-            // Fill in Snowflake credentials
-            await act(async () => {
-                fireEvent.change(screen.getByTestId('quill-input-host').querySelector('input'), { target: { value: 'account.snowflakecomputing.com' } });
-            });
-            await act(async () => {
-                fireEvent.change(screen
-                    .getByTestId('quill-input-databaseName')
-                    .querySelector('input'), { target: { value: 'testdb' } });
-            });
-            await act(async () => {
-                fireEvent.change(screen.getByTestId('quill-input-user').querySelector('input'), { target: { value: 'testuser' } });
-            });
-            await act(async () => {
-                fireEvent.change(screen.getByTestId('quill-input-password').querySelector('input'), { target: { value: 'testpass' } });
-            });
-            await act(async () => {
-                fireEvent.change(screen.getByTestId('quill-input-warehouse').querySelector('input'), { target: { value: 'testwarehouse' } });
-            });
-            // Verify Connect button is enabled
-            expect(screen.getByTestId('quill-connect-button').querySelector('button')
-                .className).not.toContain('quill-button-disabled');
-        });
-        it('handles BigQuery JSON file upload', async () => {
-            // Mock FileReader
-            const mockFileReader = {
-                readAsText: jest.fn(),
-                onload: jest.fn(),
-                result: '',
-            };
-            global.FileReader = jest.fn(() => mockFileReader);
-            global.FileReader.EMPTY = 0;
-            global.FileReader.LOADING = 1;
-            global.FileReader.DONE = 2;
-            await act(async () => {
-                render(_jsx(ConnectDatabase, { ...defaultProps }));
-            });
-            // Switch to BigQuery
-            await act(async () => {
-                fireEvent.click(screen.getByText('BigQuery'));
-            });
-            // Create a mock JSON file
-            const mockJsonContent = JSON.stringify({
-                type: 'service_account',
-                project_id: 'test-project',
-                private_key_id: 'test-key-id',
-                private_key: 'test-private-key',
-            });
-            const mockFile = new File([mockJsonContent], 'test-credentials.json', {
-                type: 'application/json',
-            });
-            // Simulate file upload through the hidden input
-            await act(async () => {
-                fireEvent.change(screen.getByTitle('Upload JSON'), {
-                    target: { files: [mockFile] },
-                });
-            });
-            // Simulate FileReader completing the read
-            await act(async () => {
-                mockFileReader.result = mockJsonContent;
-                mockFileReader.onload({ target: mockFileReader });
-            });
-            // Verify file name is displayed
-            expect(screen.getByText('test-credentials.json')).toBeInTheDocument();
-            // Verify Connect button is enabled
-            expect(screen.getByTestId('quill-connect-button').querySelector('button')
-                .className).not.toContain('quill-button-disabled');
-        });
-    });
-    // Connection Testing Tests
-    describe('Connection Testing', () => {
-        it('handles successful connection test and schema selection', async () => {
-            const mockTestConnection = 
-            // eslint-disable-next-line @typescript-eslint/no-var-requires
-            require('../../../api/ConnectionClient').testConnectionString;
-            const mockSetSchemaNames = 
-            // eslint-disable-next-line @typescript-eslint/no-var-requires
-            require('../../../api/ConnectionClient').setSchemaNames;
-            const mockGetTableColumns = 
-            // eslint-disable-next-line @typescript-eslint/no-var-requires
-            require('../../../api/ConnectionClient').getTableColumnsBySchema;
-            // Mock successful connection test
-            mockTestConnection.mockResolvedValueOnce({
-                success: true,
-                clientId: 'test-client-id',
-                schemas: ['schema1', 'schema2'],
-            });
-            // Mock successful schema selection
-            mockSetSchemaNames.mockResolvedValueOnce({ success: true });
-            mockGetTableColumns.mockResolvedValueOnce({
-                success: true,
-                columnsByTable: [
-                    {
-                        tableName: 'test_table',
-                        columns: [
-                            { name: 'id', type: 'integer' },
-                            { name: 'name', type: 'text' },
-                        ],
-                    },
-                ],
-            });
-            await act(async () => {
-                render(_jsx(ConnectDatabase, { ...defaultProps }));
-            });
-            // Fill in the form
-            await act(async () => {
-                fireEvent.change(screen.getByTestId('quill-input-host').querySelector('input'), { target: { value: 'localhost' } });
-            });
-            await act(async () => {
-                fireEvent.change(screen
-                    .getByTestId('quill-input-databaseName')
-                    .querySelector('input'), { target: { value: 'testdb' } });
-            });
-            await act(async () => {
-                fireEvent.change(screen.getByTestId('quill-input-user').querySelector('input'), { target: { value: 'testuser' } });
-            });
-            await act(async () => {
-                fireEvent.change(screen.getByTestId('quill-input-password').querySelector('input'), { target: { value: 'testpass' } });
-            });
-            await act(async () => {
-                fireEvent.change(screen.getByTestId('quill-input-port').querySelector('input'), { target: { value: '5432' } });
-            });
-            // Click connect
-            await act(async () => {
-                fireEvent.click(screen.getByText('Connect'));
-            });
-            // Wait for the schema selection modal to appear
-            await waitFor(() => {
-                expect(screen.getByText('Connection Successful')).toBeInTheDocument();
-            });
-            // Click the select button to open the dropdown
-            await act(async () => {
-                const selectButton = screen.getByText('Select');
-                fireEvent.click(selectButton);
-            });
-            // Wait for the dropdown to appear and select schema1
-            await waitFor(() => {
-                expect(screen.getByText('schema1')).toBeInTheDocument();
-            });
-            // Click the schema1 option
-            await act(async () => {
-                const schema1Option = screen.getByText('schema1');
-                fireEvent.click(schema1Option);
-            });
-            // Wait for the selection to be applied
-            await waitFor(() => {
-                expect(screen.getByText('schema1')).toBeInTheDocument();
-            });
-            // 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');
-            });
-            // Click the Looks Good button
-            await act(async () => {
-                const looksGoodButton = screen
-                    .getByTestId('quill-looks-good-button')
-                    .querySelector('button');
-                fireEvent.click(looksGoodButton);
-            });
-            // Verify that setEnvironmentDetails was called with correct data
-            await waitFor(() => {
-                expect(mockSetEnvironmentDetails).toHaveBeenCalledWith({
-                    type: 'PostgreSQL',
-                    host: 'localhost',
-                    databaseName: 'testdb',
-                    user: 'testuser',
-                    password: 'testpass',
-                    port: '5432',
-                    connectionString: 'postgres://testuser:testpass@localhost:5432/testdb',
-                }, [
-                    {
-                        tableName: 'test_table',
-                        columns: [
-                            { name: 'id', type: 'integer' },
-                            { name: 'name', type: 'text' },
-                        ],
-                    },
-                ], ['schema1'], 'test-client-id');
-            });
-        });
-        it('handles connection test failure', async () => {
-            const mockTestConnection = 
-            // eslint-disable-next-line @typescript-eslint/no-var-requires
-            require('../../../api/ConnectionClient').testConnectionString;
-            mockTestConnection.mockResolvedValueOnce({
-                success: false,
-                error: 'Connection failed',
-            });
-            await act(async () => {
-                render(_jsx(ConnectDatabase, { ...defaultProps }));
-            });
-            // Fill in the form
-            await act(async () => {
-                fireEvent.change(screen.getByTestId('quill-input-host').querySelector('input'), { target: { value: 'localhost' } });
-            });
-            await act(async () => {
-                fireEvent.change(screen
-                    .getByTestId('quill-input-databaseName')
-                    .querySelector('input'), { target: { value: 'testdb' } });
-            });
-            await act(async () => {
-                fireEvent.change(screen.getByTestId('quill-input-user').querySelector('input'), { target: { value: 'testuser' } });
-            });
-            await act(async () => {
-                fireEvent.change(screen.getByTestId('quill-input-password').querySelector('input'), { target: { value: 'testpass' } });
-            });
-            await act(async () => {
-                fireEvent.change(screen.getByTestId('quill-input-port').querySelector('input'), { target: { value: '5432' } });
-            });
-            // Click connect
-            await act(async () => {
-                fireEvent.click(screen.getByText('Connect'));
-            });
-            // Wait for the error message to appear
-            await waitFor(() => {
-                expect(screen.getByText('Connection failed')).toBeInTheDocument();
-            });
-        });
-    });
-    // IP Allowlist Tests
-    describe('IP Allowlist', () => {
-        it('displays IP allowlist information', async () => {
-            await act(async () => {
-                render(_jsx(ConnectDatabase, { ...defaultProps }));
-            });
-            // Check for IP allowlist section
-            expect(screen.getByText('IP Allowlist')).toBeInTheDocument();
-            expect(screen.getByText('34.133.137.225')).toBeInTheDocument();
-        });
-    });
-});

package/dist/esm/forms/client_onboard/__tests__/ConnectSchema.test.d.ts

@@ -1,2 +0,0 @@
-import '@testing-library/jest-dom';
-//# sourceMappingURL=ConnectSchema.test.d.ts.map

package/dist/esm/forms/client_onboard/__tests__/ConnectSchema.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"ConnectSchema.test.d.ts","sourceRoot":"","sources":["../../../../../src/forms/client_onboard/__tests__/ConnectSchema.test.tsx"],"names":[],"mappings":"AAEA,OAAO,2BAA2B,CAAC"}