@quillsql/admin 1.6.1 → 1.6.2

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

@@ -0,0 +1,454 @@
+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 ConnectSchema from '../ConnectSchema';
+import { useAdmin } from '../../../AdminProvider';
+import { defaultTheme } from '../../../Admin';
+// Add these mocks before the describe block
+class MockResizeObserver {
+    observe() { }
+    unobserve() { }
+    disconnect() { }
+}
+global.ResizeObserver = MockResizeObserver;
+// Mock window.HTMLElement.prototype.scrollIntoView
+window.HTMLElement.prototype.scrollIntoView = jest.fn();
+// Mock the hooks
+jest.mock('../../../AdminProvider');
+jest.mock('@quillsql/react');
+jest.mock('../../../hooks/useDatabaseSchema', () => ({
+    useDatabaseSchema: () => ({
+        schema: [
+            {
+                tableName: 'users',
+                displayName: 'Users',
+                columns: [
+                    {
+                        columnName: 'id',
+                        displayName: 'ID',
+                        fieldType: 'number',
+                        dataTypeId: 1,
+                        field: 'id',
+                    },
+                    {
+                        columnName: 'tenant_id',
+                        displayName: 'Tenant ID',
+                        fieldType: 'number',
+                        dataTypeId: 1,
+                        field: 'tenant_id',
+                    },
+                    {
+                        columnName: 'tenant_name',
+                        displayName: 'Tenant Name',
+                        fieldType: 'text',
+                        dataTypeId: 2,
+                        field: 'tenant_name',
+                    },
+                ],
+            },
+        ],
+        isLoading: false,
+    }),
+}));
+// avoid error thrown by jspdf
+jest.mock('jspdf', () => ({
+    __esModule: true,
+    default: jest.fn(() => ({
+        text: jest.fn(),
+        save: jest.fn(),
+    })),
+}));
+describe('ConnectSchema', () => {
+    const mockOnTenantCreation = jest.fn();
+    const mockGetToken = jest.fn();
+    const mockQuillFetchWithToken = jest.fn();
+    const mockState = {
+        queryEndpoint: 'http://test-endpoint',
+        loading: true,
+        publicKey: 'test-key',
+        queryHeaders: {},
+        activeSavedQueryReportId: '',
+        withCredentials: false,
+        client: {
+            ownerTenantFields: ['tenant_id', 'tenant_name'],
+        },
+        clients: [],
+        organization: null,
+        organizations: [],
+        organizationId: null,
+        activeQuery: '',
+        activeEditItem: undefined,
+        tables: [],
+        schema: [],
+        databaseSchema: undefined,
+        activeComponent: 'Dashboards',
+        dashboards: [],
+        selectedDashboard: null,
+        reportId: null,
+        report: null,
+        theme: defaultTheme,
+        organizationIdSet: false,
+        dateFilter: {},
+        domainName: '',
+        databaseTypeMismatch: { show: false, backendDatabaseType: '' },
+        selectedTenantField: undefined,
+        selectedTenantValues: undefined,
+        selectedDashboardTenantIds: undefined,
+        mappableDashboardTenantIds: undefined,
+        mappableDashboardTenantIdsLoading: false,
+        currentTenantIdentity: undefined,
+    };
+    const defaultProps = {
+        containerStyle: {},
+        header1Style: {},
+        header2Style: {},
+        databaseSchema: [
+            {
+                tableName: 'users',
+                displayName: 'Users',
+                columns: [
+                    {
+                        columnName: 'id',
+                        displayName: 'ID',
+                        fieldType: 'number',
+                        dataTypeId: 1,
+                        field: 'id',
+                    },
+                    {
+                        columnName: 'tenant_id',
+                        displayName: 'Tenant ID',
+                        fieldType: 'number',
+                        dataTypeId: 1,
+                        field: 'tenant_id',
+                    },
+                    {
+                        columnName: 'tenant_name',
+                        displayName: 'Tenant Name',
+                        fieldType: 'text',
+                        dataTypeId: 2,
+                        field: 'tenant_name',
+                    },
+                ],
+            },
+        ],
+        connection: {
+            type: 'PostgreSQL',
+            user: 'testuser',
+            password: 'testpass',
+            host: 'localhost',
+            databaseName: 'testdb',
+            port: '5432',
+        },
+        tenantInit: {
+            ownerTenant: undefined,
+        },
+        onTenantCreation: mockOnTenantCreation,
+        onValidateEditTenant: jest.fn().mockImplementation(async () => {
+            const response = {
+                queries: {
+                    queryResults: [
+                        {
+                            fields: [
+                                { name: 'tenant_id', dataTypeID: 23 }, // 23 is integer type
+                                { name: 'tenant_name', dataTypeID: 25 }, // 25 is text type
+                            ],
+                            rows: [
+                                {
+                                    tenant_id: 1,
+                                    tenant_name: 'Tenant 1',
+                                    quill_flag: 'tenant_1',
+                                    quill_label: 'Tenant 1',
+                                },
+                                {
+                                    tenant_id: 2,
+                                    tenant_name: 'Tenant 2',
+                                    quill_flag: 'tenant_2',
+                                    quill_label: 'Tenant 2',
+                                },
+                            ],
+                        },
+                    ],
+                },
+                data: {
+                    tenant: {
+                        tenantField: 'tenant_id',
+                    },
+                },
+            };
+            const tenantFieldDataType = response.queries.queryResults[0]?.fields?.find((field) => field.name === response.data.tenant.tenantField)?.dataTypeID;
+            const isNumber = [20, 21, 23, 700, 701, 1700].includes(tenantFieldDataType);
+            return response.queries.queryResults[0]?.rows?.map((row) => ({
+                id: isNumber ? Number(row.tenant_id) : row.tenant_id,
+                label: row.quill_label,
+                flag: row.quill_flag,
+            }));
+        }),
+        initialError: undefined,
+        clientId: 'test-client-id',
+        selectedSchemas: ['public'],
+        state: mockState,
+        label: 'Create Tenant',
+        returnToConnectDatabase: jest.fn().mockImplementation(() => { }),
+    };
+    beforeEach(() => {
+        // Reset all mocks before each test
+        jest.clearAllMocks();
+        // Setup default mock implementations
+        useAdmin.mockReturnValue({
+            state: {
+                queryEndpoint: 'http://test-endpoint',
+                client: {
+                    ownerTenantFields: ['tenant_id', 'tenant_name'],
+                },
+                // ... other state properties
+            },
+            getToken: mockGetToken,
+            quillFetchWithToken: mockQuillFetchWithToken,
+        });
+    });
+    it('renders the component with initial state', async () => {
+        await act(async () => {
+            render(_jsx(ConnectSchema, { ...defaultProps }));
+        });
+        // Check for main elements
+        expect(screen.getByText('Create Tenant')).toBeInTheDocument();
+        expect(screen.getByText('How do you represent your customers in your database?')).toBeInTheDocument();
+    });
+    it('handles tenant creation with row-level tenant', async () => {
+        // Mock successful tenant validation response
+        mockQuillFetchWithToken.mockResolvedValueOnce({
+            data: {
+                tenant: {
+                    tenantField: 'tenant_id',
+                    tenantNameField: 'tenant_name',
+                    scope: 'row',
+                },
+            },
+            queries: {
+                queryResults: [
+                    {
+                        fields: [
+                            { name: 'tenant_id', dataTypeID: 23 }, // 23 is integer type
+                            { name: 'tenant_name', dataTypeID: 25 }, // 25 is text type
+                        ],
+                        rows: [
+                            {
+                                tenant_id: 1,
+                                tenant_name: 'Tenant 1',
+                                quill_flag: 'tenant_1',
+                                quill_label: 'Tenant 1',
+                            },
+                            {
+                                tenant_id: 2,
+                                tenant_name: 'Tenant 2',
+                                quill_flag: 'tenant_2',
+                                quill_label: 'Tenant 2',
+                            },
+                        ],
+                    },
+                ],
+            },
+        });
+        // Mock successful tenant creation response
+        mockQuillFetchWithToken.mockResolvedValueOnce({
+            data: {
+                tenant: {
+                    id: 'test-tenant-id',
+                    name: 'Test Tenant',
+                    tenantField: 'tenant_id',
+                    tenantNameField: 'tenant_name',
+                    scope: 'row',
+                },
+            },
+            queries: {
+                queryResults: [
+                    {
+                        rows: [
+                            {
+                                tenant_id: 1,
+                                tenant_name: 'Tenant 1',
+                                quill_flag: 'tenant_1',
+                                quill_label: 'Tenant 1',
+                            },
+                            {
+                                tenant_id: 2,
+                                tenant_name: 'Tenant 2',
+                                quill_flag: 'tenant_2',
+                                quill_label: 'Tenant 2',
+                            },
+                        ],
+                    },
+                ],
+            },
+        });
+        await act(async () => {
+            render(_jsx(ConnectSchema, { ...defaultProps }));
+        });
+        // Fill in tenant name
+        await act(async () => {
+            const inputs = screen.getAllByRole('textbox');
+            const nameInput = inputs[0];
+            if (!nameInput)
+                throw new Error('Name input not found');
+            fireEvent.change(nameInput, {
+                target: { value: 'Test Tenant' },
+            });
+        });
+        // Fill in tenant field (foreign key)
+        await act(async () => {
+            const tenantFieldInput = screen
+                .getByTestId('quill-input-tenant-field')
+                .querySelector('input');
+            fireEvent.change(tenantFieldInput, {
+                target: { value: 'tenant_id' },
+            });
+        });
+        // Select tenant table
+        await act(async () => {
+            const tableSelect = screen
+                .getByTestId('quill-select-tenant-table')
+                .querySelector('button');
+            fireEvent.click(tableSelect);
+        });
+        await act(async () => {
+            fireEvent.click(screen.getByText('users'));
+        });
+        // Select tenant 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 () => {
+            fireEvent.click(screen.getByText(/tenant_id/i));
+        });
+        // Select tenant 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 () => {
+            fireEvent.click(screen.getByText(/tenant_name/i));
+        });
+        // Select tenant flag field
+        await act(async () => {
+            const flagFieldSelect = screen
+                .getByTestId('quill-select-tenant-flag-field')
+                .querySelector('button');
+            expect(flagFieldSelect).not.toBeDisabled();
+            fireEvent.click(flagFieldSelect);
+        });
+        await act(async () => {
+            fireEvent.click(screen.getAllByText(/tenant_id/i)[1]);
+        });
+        // 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();
+        });
+        // Select default tenant ID
+        await act(async () => {
+            const defaultTenantSelect = screen
+                .getByTestId('quill-select-default-tenant-id-field')
+                .querySelector('button');
+            fireEvent.click(defaultTenantSelect);
+        });
+        await act(async () => {
+            fireEvent.click(screen.getByText('Tenant 1'));
+        });
+        // Click Looks Good button
+        await act(async () => {
+            const looksGoodButton = screen.getByText('Looks Good');
+            fireEvent.click(looksGoodButton);
+        });
+        // Wait for the tenant creation to complete
+        await waitFor(() => {
+            expect(mockOnTenantCreation).toHaveBeenCalledWith(expect.objectContaining({
+                ownerTenant: expect.objectContaining({
+                    name: 'Test Tenant',
+                    tenantField: 'tenant_id',
+                    tenantNameField: 'tenant_name',
+                    scope: 'row',
+                }),
+            }));
+        });
+    });
+    it('handles tenant creation with database-level tenant', async () => {
+        // Mock successful tenant creation
+        mockQuillFetchWithToken.mockResolvedValueOnce({
+            data: {
+                tenant: {
+                    id: 'test-tenant-id',
+                    name: 'Test Tenant',
+                    scope: 'database',
+                },
+            },
+        });
+        await act(async () => {
+            render(_jsx(ConnectSchema, { ...defaultProps }));
+        });
+        // Fill in tenant name
+        await act(async () => {
+            const inputs = screen.getAllByRole('textbox');
+            const nameInput = inputs[0];
+            if (!nameInput)
+                throw new Error('Name input not found');
+            fireEvent.change(nameInput, {
+                target: { value: 'Test Tenant' },
+            });
+        });
+        // Select database-level scope
+        await act(async () => {
+            fireEvent.click(screen.getByText(/Database level/i));
+        });
+        // Fill in tags list
+        await act(async () => {
+            const tenantFlagsInput = screen
+                .getByTestId('quill-input-tenant-flags')
+                .querySelector('input');
+            fireEvent.change(tenantFlagsInput, {
+                target: { value: 'tag1, tag2' },
+            });
+        });
+        // Select default tenant flag
+        await act(async () => {
+            const defaultTenantFlagSelect = screen
+                .getByTestId('quill-select-default-tenant-flag')
+                .querySelector('button');
+            fireEvent.click(defaultTenantFlagSelect);
+        });
+        await act(async () => {
+            fireEvent.click(screen.getByText('tag1'));
+        });
+        // 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 the tenant creation to complete
+        await waitFor(() => {
+            expect(mockOnTenantCreation).toHaveBeenCalledWith(expect.objectContaining({
+                ownerTenant: expect.objectContaining({
+                    name: 'Test Tenant',
+                    scope: 'database',
+                }),
+            }));
+        });
+    });
+});

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

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

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

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