@datalayer/core 0.0.12 → 0.0.14

package/lib/api/__tests__/spacer.integration.test.js

@@ -1,519 +0,0 @@
-/*
- * Copyright (c) 2023-2025 Datalayer, Inc.
- * Distributed under the terms of the Modified BSD License.
- */
-import { describe, it, expect, beforeAll, afterAll, test } from 'vitest';
-import { users, notebooks, lexicals, items } from '../spacer';
-import { testConfig, debugLog, skipIfNoToken, } from '../../__tests__/shared/test-config';
-import { performCleanup } from '../../__tests__/shared/cleanup-shared';
-let DATALAYER_TOKEN;
-let BASE_URL;
-// Skip all tests if no token is available
-const skipTests = skipIfNoToken();
-beforeAll(async () => {
-    if (skipTests) {
-        console.log('WARNING: Skipping Spacer Lifecycle integration tests: No Datalayer API token configured');
-        console.log('         Set DATALAYER_API_TOKEN env var or DATALAYER_TEST_TOKEN in .env.test');
-        return;
-    }
-    // Get token and base URL from test config
-    DATALAYER_TOKEN = testConfig.getToken();
-    BASE_URL = testConfig.getBaseUrl('SPACER');
-    debugLog('Test configuration loaded');
-    debugLog('Base URL:', BASE_URL);
-    debugLog('Token available:', !!DATALAYER_TOKEN);
-    // Pre-test cleanup
-    await performCleanup('setup');
-});
-afterAll(async () => {
-    if (skipTests) {
-        return;
-    }
-    // Post-test cleanup
-    await performCleanup('teardown');
-});
-describe.skipIf(skipTests)('Spacer Complete Lifecycle Integration Tests', () => {
-    // Complete lifecycle test for spacer resources
-    describe.sequential('complete spacer resource lifecycle', () => {
-        let testSpaceId;
-        let createdNotebookId;
-        let createdLexicalId;
-        let createdItemIds = [];
-        const testNamePrefix = `test-${Date.now()}`;
-        // No cleanup needed - handled by global setup/teardown
-        test('1. should get user spaces to find a valid space ID', async () => {
-            console.log('Getting user spaces...');
-            const response = await users.getMySpaces(DATALAYER_TOKEN, BASE_URL);
-            expect(response).toBeDefined();
-            expect(response).toHaveProperty('success');
-            expect(response.success).toBe(true);
-            expect(response).toHaveProperty('spaces');
-            expect(Array.isArray(response.spaces)).toBe(true);
-            console.log(`Found ${response.spaces.length} space(s) for user`);
-            if (response.spaces.length > 0) {
-                const firstSpace = response.spaces[0];
-                testSpaceId = firstSpace.uid || firstSpace.id;
-                const spaceName = firstSpace.name || firstSpace.name_t;
-                console.log(`Using space ID: ${testSpaceId} (${spaceName})`);
-                // Verify space structure - check for either old or new field names
-                expect(firstSpace).toHaveProperty('uid');
-                expect(firstSpace).toSatisfy((space) => space.name !== undefined || space.name_t !== undefined);
-            }
-            else {
-                console.log('WARNING: No spaces found - some tests may fail');
-                // Use a placeholder space ID
-                testSpaceId = 'test-space-id';
-            }
-        });
-        test('2. should create a notebook', async () => {
-            if (!testSpaceId) {
-                console.log('No space ID available, skipping notebook creation');
-                return;
-            }
-            // Add initial delay to spread out load when running with other tests
-            await new Promise(resolve => setTimeout(resolve, 1000));
-            console.log('Creating notebook...');
-            const notebookContent = {
-                cells: [
-                    {
-                        cell_type: 'markdown',
-                        metadata: {},
-                        source: [
-                            '# Test Notebook\n',
-                            'This is a test notebook created by integration tests',
-                        ],
-                    },
-                    {
-                        cell_type: 'code',
-                        metadata: {},
-                        source: ['print("Hello from integration test")'],
-                        outputs: [],
-                    },
-                ],
-                metadata: {
-                    kernelspec: {
-                        display_name: 'Python 3',
-                        language: 'python',
-                        name: 'python3',
-                    },
-                },
-                nbformat: 4,
-                nbformat_minor: 4,
-            };
-            const file = new Blob([JSON.stringify(notebookContent)], {
-                type: 'application/json',
-            });
-            try {
-                const response = await notebooks.createNotebook(DATALAYER_TOKEN, {
-                    spaceId: testSpaceId,
-                    notebookType: 'jupyter',
-                    name: `${testNamePrefix}-notebook`,
-                    description: 'Integration test notebook',
-                    file: file,
-                }, BASE_URL);
-                console.log('Notebook response:', JSON.stringify(response, null, 2));
-                if (response.success) {
-                    expect(response).toHaveProperty('notebook');
-                    expect(response.notebook).toHaveProperty('id');
-                    createdNotebookId = response.notebook.uid;
-                    console.log(`Created notebook with UID: ${createdNotebookId}`);
-                    createdItemIds.push(createdNotebookId);
-                }
-                else {
-                    console.log('Notebook creation failed:', response.message);
-                }
-            }
-            catch (error) {
-                console.error('Error creating notebook:', error.message);
-            }
-        });
-        test('3. should create a lexical document', async () => {
-            if (!testSpaceId) {
-                console.log('No space ID available, skipping lexical creation');
-                return;
-            }
-            // Add delay to spread out load when running with other tests
-            await new Promise(resolve => setTimeout(resolve, 2000)); // Stagger more than notebook creation
-            console.log('Creating lexical document...');
-            const lexicalContent = {
-                root: {
-                    type: 'root',
-                    format: '',
-                    indent: 0,
-                    version: 1,
-                    children: [
-                        {
-                            type: 'paragraph',
-                            format: '',
-                            indent: 0,
-                            version: 1,
-                            children: [
-                                {
-                                    type: 'text',
-                                    format: 0,
-                                    style: '',
-                                    mode: 'normal',
-                                    text: 'Test lexical document from integration test',
-                                    version: 1,
-                                    detail: 0,
-                                },
-                            ],
-                        },
-                    ],
-                },
-            };
-            const file = new Blob([JSON.stringify(lexicalContent)], {
-                type: 'application/json',
-            });
-            try {
-                const response = await lexicals.createLexical(DATALAYER_TOKEN, {
-                    spaceId: testSpaceId,
-                    documentType: 'lexical',
-                    name: `${testNamePrefix}-lexical`,
-                    description: 'Integration test lexical document',
-                    file: file,
-                }, BASE_URL);
-                console.log('Lexical response:', JSON.stringify(response, null, 2));
-                if (response.success) {
-                    expect(response).toHaveProperty('document');
-                    expect(response.document).toHaveProperty('id');
-                    createdLexicalId = response.document.uid;
-                    console.log(`Created lexical with UID: ${createdLexicalId}`);
-                    createdItemIds.push(createdLexicalId);
-                }
-                else {
-                    console.log('Lexical creation failed:', response.message);
-                }
-            }
-            catch (error) {
-                console.error('Error creating lexical:', error.message);
-            }
-        });
-        test('4. should list all items in the space', async () => {
-            if (!testSpaceId) {
-                console.log('No space ID available, skipping list items');
-                return;
-            }
-            console.log('Listing items in space...');
-            const response = await items.getSpaceItems(DATALAYER_TOKEN, testSpaceId, BASE_URL);
-            console.log('Items response:', JSON.stringify(response, null, 2));
-            expect(response).toBeDefined();
-            expect(response).toHaveProperty('success');
-            expect(response).toHaveProperty('items');
-            if (response.success && Array.isArray(response.items)) {
-                console.log(`Found ${response.items.length} items in space`);
-                // Find our created items
-                const foundNotebook = createdNotebookId
-                    ? response.items.find((item) => item.id === createdNotebookId)
-                    : null;
-                const foundLexical = createdLexicalId
-                    ? response.items.find((item) => item.id === createdLexicalId)
-                    : null;
-                if (foundNotebook) {
-                    console.log('✓ Found created notebook in items list');
-                    console.log('Notebook object:', JSON.stringify(foundNotebook, null, 2));
-                    // Handle both name formats that might be returned
-                    const notebookName = foundNotebook.name || foundNotebook.name_t || '';
-                    if (notebookName) {
-                        expect(notebookName).toContain(testNamePrefix);
-                    }
-                    else {
-                        console.log('Warning: Notebook found but has no name field');
-                    }
-                }
-                if (foundLexical) {
-                    console.log('✓ Found created lexical in items list');
-                    console.log('Lexical object:', JSON.stringify(foundLexical, null, 2));
-                    // Handle both name formats that might be returned
-                    const lexicalName = foundLexical.name || foundLexical.name_t || '';
-                    if (lexicalName) {
-                        expect(lexicalName).toContain(testNamePrefix);
-                    }
-                    else {
-                        console.log('Warning: Lexical found but has no name field');
-                    }
-                }
-            }
-        });
-        test('5. should get notebook details', async () => {
-            if (!createdNotebookId) {
-                console.log('No notebook was created, skipping get test');
-                return;
-            }
-            console.log('Getting notebook details...');
-            try {
-                // Add a small delay to allow server processing
-                await new Promise(resolve => setTimeout(resolve, 1000));
-                const response = await notebooks.getNotebook(DATALAYER_TOKEN, createdNotebookId, BASE_URL);
-                console.log('Get notebook response:', JSON.stringify(response, null, 2));
-                expect(response).toBeDefined();
-                expect(response).toHaveProperty('success');
-                if (response.success) {
-                    expect(response).toHaveProperty('notebook');
-                    expect(response.notebook?.uid).toBe(createdNotebookId);
-                    console.log('✓ Retrieved notebook details successfully');
-                }
-            }
-            catch (error) {
-                console.log('Expected error getting notebook:', error.message);
-                // The notebook might not be immediately available after creation
-                // This is acceptable for this test scenario
-            }
-        });
-        test('6. should get lexical details', async () => {
-            if (!createdLexicalId) {
-                console.log('No lexical was created, skipping get test');
-                return;
-            }
-            console.log('Getting lexical details...');
-            try {
-                // Add a small delay to allow server processing
-                await new Promise(resolve => setTimeout(resolve, 1000));
-                const response = await lexicals.getLexical(DATALAYER_TOKEN, createdLexicalId, BASE_URL);
-                console.log('Get lexical response:', JSON.stringify(response, null, 2));
-                expect(response).toBeDefined();
-                expect(response).toHaveProperty('success');
-                if (response.success) {
-                    expect(response).toHaveProperty('document');
-                    expect(response.document?.uid).toBe(createdLexicalId);
-                    console.log('✓ Retrieved lexical details successfully');
-                }
-            }
-            catch (error) {
-                console.log('Expected error getting lexical:', error.message);
-                // The lexical might not be immediately available after creation
-                // This is acceptable for this test scenario
-            }
-        });
-        test('7. should update notebook', async () => {
-            if (!createdNotebookId) {
-                console.log('No notebook was created, skipping update test');
-                return;
-            }
-            console.log('Updating notebook...');
-            const updateData = {
-                name: `${testNamePrefix}-notebook-updated`,
-                description: 'Updated integration test notebook',
-            };
-            try {
-                // Add delay to allow server processing and avoid resource contention
-                await new Promise(resolve => setTimeout(resolve, 5000)); // 5 second delay for bulk test runs
-                const response = await notebooks.updateNotebook(DATALAYER_TOKEN, createdNotebookId, updateData, BASE_URL);
-                console.log('Update notebook response:', JSON.stringify(response, null, 2));
-                expect(response).toBeDefined();
-                expect(response).toHaveProperty('success');
-                if (response.success) {
-                    expect(response).toHaveProperty('notebook');
-                    expect(response.notebook.uid).toBe(createdNotebookId);
-                    const nameObj = response.notebook.name_t || response.notebook.name || {};
-                    const notebookName = nameObj && typeof nameObj === 'object' && nameObj.set
-                        ? nameObj.set
-                        : typeof nameObj === 'string'
-                            ? nameObj
-                            : '';
-                    expect(notebookName).toContain('updated');
-                    console.log('✓ Updated notebook successfully');
-                }
-            }
-            catch (error) {
-                console.log('Error updating notebook:', error.message);
-                throw error; // Let the test fail
-            }
-        });
-        test('8. should update lexical', async () => {
-            if (!createdLexicalId) {
-                console.log('No lexical was created, skipping update test');
-                return;
-            }
-            console.log('Updating lexical...');
-            const updateData = {
-                name: `${testNamePrefix}-lexical-updated`,
-                description: 'Updated integration test lexical',
-            };
-            try {
-                // Add delay to allow server processing and avoid resource contention
-                await new Promise(resolve => setTimeout(resolve, 5000)); // 5 second delay for bulk test runs
-                const response = await lexicals.updateLexical(DATALAYER_TOKEN, createdLexicalId, updateData, BASE_URL);
-                console.log('Update lexical response:', JSON.stringify(response, null, 2));
-                expect(response).toBeDefined();
-                expect(response).toHaveProperty('success');
-                if (response.success) {
-                    expect(response).toHaveProperty('document');
-                    expect(response.document.uid).toBe(createdLexicalId);
-                    const nameObj = response.document.name_t || response.document.name || {};
-                    const lexicalName = nameObj && typeof nameObj === 'object' && nameObj.set
-                        ? nameObj.set
-                        : typeof nameObj === 'string'
-                            ? nameObj
-                            : '';
-                    expect(lexicalName).toContain('updated');
-                    console.log('✓ Updated lexical successfully');
-                }
-            }
-            catch (error) {
-                console.log('Error updating lexical:', error.message);
-                throw error; // Let the test fail
-            }
-        });
-        test('9. should verify updates by getting items again', async () => {
-            if (!createdNotebookId && !createdLexicalId) {
-                console.log('No items were created, skipping verification');
-                return;
-            }
-            console.log('Verifying updates...');
-            // Get notebook to verify update
-            if (createdNotebookId) {
-                const notebookResponse = await notebooks.getNotebook(DATALAYER_TOKEN, createdNotebookId, BASE_URL);
-                if (notebookResponse.success && notebookResponse.notebook) {
-                    const notebookName = notebookResponse.notebook.name ||
-                        notebookResponse.notebook.name_t ||
-                        '';
-                    expect(notebookName).toContain('updated');
-                    console.log('✓ Notebook update verified');
-                }
-            }
-            // Get lexical to verify update
-            if (createdLexicalId) {
-                const lexicalResponse = await lexicals.getLexical(DATALAYER_TOKEN, createdLexicalId, BASE_URL);
-                if (lexicalResponse.success && lexicalResponse.document) {
-                    const lexicalName = lexicalResponse.document.name ||
-                        lexicalResponse.document.name_t ||
-                        '';
-                    expect(lexicalName).toContain('updated');
-                    console.log('✓ Lexical update verified');
-                }
-            }
-        });
-        test('10. should delete notebook', async () => {
-            if (!createdNotebookId) {
-                console.log('No notebook was created, skipping delete test');
-                return;
-            }
-            console.log('Deleting notebook...');
-            try {
-                await items.deleteItem(DATALAYER_TOKEN, createdNotebookId, BASE_URL);
-                console.log('Notebook deletion request sent');
-                // Verify deletion
-                const getResponse = await notebooks.getNotebook(DATALAYER_TOKEN, createdNotebookId, BASE_URL);
-                if (!getResponse.success) {
-                    console.log('✓ Notebook properly deleted');
-                }
-                else {
-                    console.log('WARNING: Notebook still exists after deletion');
-                }
-                // Remove from cleanup list
-                createdNotebookId = undefined;
-                createdItemIds = createdItemIds.filter(id => id !== createdNotebookId);
-            }
-            catch (error) {
-                console.log('Expected deletion error:', error.message);
-            }
-        });
-        test('11. should delete lexical', async () => {
-            if (!createdLexicalId) {
-                console.log('No lexical was created, skipping delete test');
-                return;
-            }
-            console.log('Deleting lexical...');
-            try {
-                await items.deleteItem(DATALAYER_TOKEN, createdLexicalId, BASE_URL);
-                console.log('Lexical deletion request sent');
-                // Verify deletion
-                const getResponse = await lexicals.getLexical(DATALAYER_TOKEN, createdLexicalId, BASE_URL);
-                if (!getResponse.success) {
-                    console.log('✓ Lexical properly deleted');
-                }
-                else {
-                    console.log('WARNING: Lexical still exists after deletion');
-                }
-                // Remove from cleanup list
-                createdLexicalId = undefined;
-                createdItemIds = createdItemIds.filter(id => id !== createdLexicalId);
-            }
-            catch (error) {
-                console.log('Expected deletion error:', error.message);
-            }
-        });
-        test('12. should verify all items are deleted', async () => {
-            if (!testSpaceId) {
-                console.log('No space ID available, skipping final verification');
-                return;
-            }
-            console.log('Final verification...');
-            const response = await items.getSpaceItems(DATALAYER_TOKEN, testSpaceId, BASE_URL);
-            if (response.success && Array.isArray(response.items)) {
-                const remainingTestItems = response.items.filter((item) => item.name?.includes(testNamePrefix));
-                expect(remainingTestItems.length).toBe(0);
-                if (remainingTestItems.length === 0) {
-                    console.log('✓ All test items successfully deleted');
-                }
-                else {
-                    console.log(`WARNING: ${remainingTestItems.length} test items still exist`);
-                }
-            }
-            console.log('Complete spacer lifecycle test finished successfully!');
-        });
-    });
-    // Basic smoke tests that always run
-    describe('smoke tests', () => {
-        it('should successfully get user spaces', async () => {
-            console.log('Testing get user spaces endpoint...');
-            const response = await users.getMySpaces(DATALAYER_TOKEN, BASE_URL);
-            console.log(`Found ${response.spaces.length} space(s)`);
-            expect(response).toBeDefined();
-            expect(response).toHaveProperty('success');
-            expect(response.success).toBe(true);
-            expect(response).toHaveProperty('spaces');
-            expect(Array.isArray(response.spaces)).toBe(true);
-            if (response.spaces.length > 0) {
-                const firstSpace = response.spaces[0];
-                const spaceName = firstSpace.name || firstSpace.name_t;
-                console.log('First space:', spaceName);
-                expect(firstSpace).toHaveProperty('uid');
-                expect(firstSpace).toSatisfy((space) => space.name !== undefined || space.name_t !== undefined);
-            }
-        });
-        it('should handle non-existent notebook gracefully', async () => {
-            console.log('Testing get with non-existent notebook ID...');
-            try {
-                const response = await notebooks.getNotebook(DATALAYER_TOKEN, 'non-existent-notebook-id-123456789', BASE_URL);
-                console.log('404 response:', JSON.stringify(response, null, 2));
-                expect(response).toBeDefined();
-                expect(response).toHaveProperty('success');
-                expect(response).toHaveProperty('message');
-                if (!response.success) {
-                    expect(response.notebook).toBeUndefined();
-                    console.log('Expected 404 message:', response.message);
-                }
-            }
-            catch (error) {
-                console.log('Expected error for non-existent notebook:', error.message);
-                expect(error).toBeDefined();
-                // API may return either "not found" or "Network Error" for non-existent resources
-                expect(error.message.toLowerCase().includes('not found') ||
-                    error.message.includes('Network Error')).toBeTruthy();
-            }
-        });
-        it('should handle non-existent lexical gracefully', async () => {
-            console.log('Testing get with non-existent lexical ID...');
-            try {
-                const response = await lexicals.getLexical(DATALAYER_TOKEN, 'non-existent-lexical-id-123456789', BASE_URL);
-                console.log('404 response:', JSON.stringify(response, null, 2));
-                expect(response).toBeDefined();
-                expect(response).toHaveProperty('success');
-                expect(response).toHaveProperty('message');
-                if (!response.success) {
-                    expect(response.document).toBeUndefined();
-                    console.log('Expected 404 message:', response.message);
-                }
-            }
-            catch (error) {
-                console.log('Expected error for non-existent lexical:', error.message);
-                expect(error).toBeDefined();
-                // API may return either "not found" or "Network Error" for non-existent resources
-                expect(error.message.toLowerCase().includes('not found') ||
-                    error.message.includes('Network Error')).toBeTruthy();
-            }
-        });
-    });
-});

package/lib/api/iam/__tests__/authentication.unit.test.d.ts

@@ -1 +0,0 @@
-export {};

package/lib/api/iam/__tests__/authentication.unit.test.js

@@ -1,63 +0,0 @@
-/*
- * Copyright (c) 2023-2025 Datalayer, Inc.
- * Distributed under the terms of the Modified BSD License.
- */
-import { describe, it, expect } from 'vitest';
-import { authentication } from '..';
-describe('IAM Authentication Unit Tests', () => {
-    describe('login parameter validation', () => {
-        const mockBaseUrl = 'https://example.com';
-        it('should fail when providing both token and credentials', async () => {
-            console.log('Testing invalid login with both token and credentials...');
-            await expect(authentication.login({
-                token: 'some-token',
-                handle: 'user@example.com',
-                password: 'password123',
-            }, mockBaseUrl)).rejects.toThrow('Cannot provide both credentials (handle/password) and token');
-            console.log('Correctly rejected login with both authentication methods');
-        });
-        it('should fail when providing neither token nor credentials', async () => {
-            console.log('Testing invalid login with no authentication...');
-            await expect(authentication.login({}, mockBaseUrl)).rejects.toThrow('Must provide either credentials (handle+password) or token');
-            console.log('Correctly rejected login with no authentication');
-        });
-        it('should fail when providing handle without password', async () => {
-            console.log('Testing invalid login with handle but no password...');
-            await expect(authentication.login({
-                handle: 'user@example.com',
-            }, mockBaseUrl)).rejects.toThrow('Both handle and password are required for credential-based authentication');
-            console.log('Correctly rejected login with incomplete credentials');
-        });
-        it('should fail when providing password without handle', async () => {
-            console.log('Testing invalid login with password but no handle...');
-            await expect(authentication.login({
-                password: 'password123',
-            }, mockBaseUrl)).rejects.toThrow('Both handle and password are required for credential-based authentication');
-            console.log('Correctly rejected login with incomplete credentials');
-        });
-    });
-    describe('logout parameter validation', () => {
-        it('should require a token for logout', async () => {
-            console.log('Testing logout without token...');
-            // TypeScript should prevent this at compile time, but let's test runtime behavior
-            // @ts-expect-error Testing missing required parameter
-            await expect(authentication.logout()).rejects.toThrow();
-            console.log('Correctly rejected logout without token');
-        });
-        it('should accept logout with only token (using default URL)', async () => {
-            console.log('Testing logout with token only (default URL)...');
-            // This should not throw a validation error (though it may fail with API)
-            // The method signature allows this since baseUrl has a default
-            const mockToken = 'mock-token';
-            // We can't test the actual API call in a unit test, but we can verify
-            // the method accepts this signature
-            expect(() => {
-                // This should not throw a compile-time or immediate runtime error
-                const promise = authentication.logout(mockToken);
-                // Cancel the promise to avoid actual API call in unit test
-                promise.catch(() => { }); // Ignore the error
-            }).not.toThrow();
-            console.log('Logout accepts token with default URL');
-        });
-    });
-});

package/lib/api/iam/__tests__/healthz.unit.test.d.ts

@@ -1 +0,0 @@
-export {};

package/lib/api/iam/__tests__/healthz.unit.test.js

@@ -1,60 +0,0 @@
-/*
- * Copyright (c) 2023-2025 Datalayer, Inc.
- * Distributed under the terms of the Modified BSD License.
- */
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { ping } from '../healthz';
-import { requestDatalayerAPI } from '../../DatalayerApi';
-// Mock the DatalayerAPI module
-vi.mock('../../DatalayerApi');
-describe('IAM Healthz Unit Tests', () => {
-    beforeEach(() => {
-        vi.clearAllMocks();
-    });
-    describe('ping', () => {
-        it('should return health status on successful health check', async () => {
-            const mockResponse = {
-                success: true,
-                message: 'datalayer_iam is up and running.',
-                status: { status: 'OK' },
-                version: '1.0.7',
-            };
-            vi.mocked(requestDatalayerAPI).mockResolvedValueOnce(mockResponse);
-            const result = await ping();
-            expect(result).toEqual(mockResponse);
-            expect(requestDatalayerAPI).toHaveBeenCalledWith({
-                url: 'https://prod1.datalayer.run/api/iam/v1/ping',
-                method: 'GET',
-            });
-        });
-        it('should use custom base URL when provided', async () => {
-            const mockResponse = {
-                success: true,
-                message: 'Service is healthy',
-                status: { status: 'OK' },
-                version: '2.0.0',
-            };
-            const customUrl = 'https://custom.example.com';
-            vi.mocked(requestDatalayerAPI).mockResolvedValueOnce(mockResponse);
-            const result = await ping(customUrl);
-            expect(result).toEqual(mockResponse);
-            expect(requestDatalayerAPI).toHaveBeenCalledWith({
-                url: `${customUrl}/api/iam/v1/ping`,
-                method: 'GET',
-            });
-        });
-        it('should throw error with status code on failure', async () => {
-            const mockError = {
-                response: { status: 500 },
-                message: 'Internal Server Error',
-            };
-            vi.mocked(requestDatalayerAPI).mockRejectedValueOnce(mockError);
-            await expect(ping()).rejects.toThrow('Health check failed: Service unhealthy (status 500) - Internal Server Error');
-        });
-        it('should throw generic error on network failure', async () => {
-            const mockError = new Error('Network error');
-            vi.mocked(requestDatalayerAPI).mockRejectedValueOnce(mockError);
-            await expect(ping()).rejects.toThrow('Health check failed: Network error');
-        });
-    });
-});

package/lib/api/iam/__tests__/profile.unit.test.d.ts

@@ -1 +0,0 @@
-export {};