@quillsql/admin 1.6.1 → 1.6.3

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

@@ -0,0 +1,566 @@
+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 '../../../AdminProvider';
+// 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

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

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

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