@datalayer/core 0.0.9 → 0.0.11

package/lib/api/spacer/__tests__/lexicals.unit.test.js

@@ -0,0 +1,323 @@
+/*
+ * Copyright (c) 2023-2025 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { lexicals } from '..';
+import * as DatalayerApi from '../../DatalayerApi';
+import { API_BASE_PATHS, DEFAULT_SERVICE_URLS } from '../../constants';
+import { MOCK_JWT_TOKEN } from '../../../__tests__/shared/test-constants';
+// Mock the DatalayerApi module
+vi.mock('../../DatalayerApi', () => ({
+    requestDatalayerAPI: vi.fn(),
+}));
+describe('Spacer Lexicals Unit Tests', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+    describe('create', () => {
+        const mockCreateResponse = {
+            success: true,
+            message: 'Document created successfully',
+            document: {
+                id: 'lexical-123',
+                uid: 'uid-lexical-123',
+                name: 'Test Document',
+                content: {},
+                space_id: 'space-456',
+                owner_id: 'user-789',
+                created_at: '2024-01-01T00:00:00Z',
+            },
+        };
+        it('should successfully create a lexical document with FormData', async () => {
+            console.log('Testing lexical document creation with FormData...');
+            const mockedRequest = vi.mocked(DatalayerApi.requestDatalayerAPI);
+            mockedRequest.mockResolvedValue(mockCreateResponse);
+            const lexicalData = {
+                spaceId: 'space-456',
+                documentType: 'lexical',
+                name: 'Test Document',
+                description: 'A test document',
+            };
+            const result = await lexicals.createLexical(MOCK_JWT_TOKEN, lexicalData, DEFAULT_SERVICE_URLS.SPACER);
+            expect(mockedRequest).toHaveBeenCalledTimes(1);
+            // Check that FormData was passed as the body
+            const callArgs = mockedRequest.mock.calls[0][0];
+            expect(callArgs.url).toBe(`${DEFAULT_SERVICE_URLS.SPACER}${API_BASE_PATHS.SPACER}/lexicals`);
+            expect(callArgs.method).toBe('POST');
+            expect(callArgs.token).toBe(MOCK_JWT_TOKEN);
+            expect(callArgs.body).toBeInstanceOf(FormData);
+            expect(result).toEqual(mockCreateResponse);
+            expect(result.success).toBe(true);
+            expect(result.document.name).toBe('Test Document');
+            console.log('Document created successfully');
+        });
+        it('should handle FormData with file attachment', async () => {
+            console.log('Testing lexical document creation with file...');
+            const mockedRequest = vi.mocked(DatalayerApi.requestDatalayerAPI);
+            mockedRequest.mockResolvedValue(mockCreateResponse);
+            const file = new File(['test content'], 'test.txt', {
+                type: 'text/plain',
+            });
+            const lexicalData = {
+                spaceId: 'space-456',
+                documentType: 'lexical',
+                name: 'Test Document',
+                description: 'A test document with file',
+                file,
+            };
+            await lexicals.createLexical(MOCK_JWT_TOKEN, lexicalData, DEFAULT_SERVICE_URLS.SPACER);
+            const callArgs = mockedRequest.mock.calls[0][0];
+            expect(callArgs.url).toBe(`${DEFAULT_SERVICE_URLS.SPACER}${API_BASE_PATHS.SPACER}/lexicals`);
+            expect(callArgs.method).toBe('POST');
+            expect(callArgs.token).toBe(MOCK_JWT_TOKEN);
+            expect(callArgs.body).toBeInstanceOf(FormData);
+            console.log('Document with file created successfully');
+        });
+        it('should handle different document types', async () => {
+            console.log('Testing lexical document with different type...');
+            const mockedRequest = vi.mocked(DatalayerApi.requestDatalayerAPI);
+            mockedRequest.mockResolvedValue(mockCreateResponse);
+            const lexicalData = {
+                spaceId: 'space-456',
+                documentType: 'markdown',
+                name: 'Markdown Document',
+                description: 'A markdown document',
+            };
+            await lexicals.createLexical(MOCK_JWT_TOKEN, lexicalData, DEFAULT_SERVICE_URLS.SPACER);
+            const callArgs = mockedRequest.mock.calls[0][0];
+            expect(callArgs.url).toBe(`${DEFAULT_SERVICE_URLS.SPACER}${API_BASE_PATHS.SPACER}/lexicals`);
+            expect(callArgs.method).toBe('POST');
+            expect(callArgs.token).toBe(MOCK_JWT_TOKEN);
+            expect(callArgs.body).toBeInstanceOf(FormData);
+            console.log('Document with different type created successfully');
+        });
+        it('should handle API errors during creation', async () => {
+            console.log('Testing lexical document creation with API error...');
+            const mockedRequest = vi.mocked(DatalayerApi.requestDatalayerAPI);
+            mockedRequest.mockRejectedValue(new Error('API Error'));
+            const lexicalData = {
+                spaceId: 'space-456',
+                documentType: 'lexical',
+                name: 'Test Document',
+                description: 'A test document',
+            };
+            await expect(lexicals.createLexical(MOCK_JWT_TOKEN, lexicalData, DEFAULT_SERVICE_URLS.SPACER)).rejects.toThrow('API Error');
+            console.log('API error handled correctly');
+        });
+        it('should use custom base URL when provided', async () => {
+            console.log('Testing lexical document creation with custom base URL...');
+            const customUrl = 'https://custom.spacer.api';
+            const mockedRequest = vi.mocked(DatalayerApi.requestDatalayerAPI);
+            mockedRequest.mockResolvedValue(mockCreateResponse);
+            const lexicalData = {
+                spaceId: 'space-456',
+                documentType: 'lexical',
+                name: 'Test Document',
+                description: 'A test document',
+            };
+            await lexicals.createLexical(MOCK_JWT_TOKEN, lexicalData, customUrl);
+            const callArgs = mockedRequest.mock.calls[0][0];
+            expect(callArgs.url).toBe(`${customUrl}${API_BASE_PATHS.SPACER}/lexicals`);
+            expect(callArgs.method).toBe('POST');
+            expect(callArgs.token).toBe(MOCK_JWT_TOKEN);
+            expect(callArgs.body).toBeInstanceOf(FormData);
+            console.log('Custom base URL used correctly');
+        });
+        it('should handle server validation errors', async () => {
+            console.log('Testing lexical document creation with validation error...');
+            const validationErrorResponse = {
+                success: false,
+                message: 'Validation failed',
+                errors: ['Invalid space ID', 'Document type not supported'],
+            };
+            const mockedRequest = vi.mocked(DatalayerApi.requestDatalayerAPI);
+            mockedRequest.mockResolvedValue(validationErrorResponse);
+            const lexicalData = {
+                spaceId: 'invalid-space',
+                documentType: 'unknown',
+                name: 'Test Document',
+                description: 'A test document',
+            };
+            const result = await lexicals.createLexical(MOCK_JWT_TOKEN, lexicalData, DEFAULT_SERVICE_URLS.SPACER);
+            expect(result).toEqual(validationErrorResponse);
+            expect(result.success).toBe(false);
+            expect(result.message).toBe('Validation failed');
+            console.log('Validation error handled correctly');
+        });
+    });
+    describe('get', () => {
+        const mockGetResponse = {
+            success: true,
+            message: 'Document retrieved successfully',
+            document: {
+                id: 'lexical-123',
+                uid: 'uid-lexical-123',
+                name: 'Test Document',
+                content: {
+                    root: {
+                        type: 'root',
+                        children: [
+                            {
+                                type: 'paragraph',
+                                children: [{ type: 'text', text: 'Test content' }],
+                            },
+                        ],
+                    },
+                },
+                space_id: 'space-456',
+                owner_id: 'user-789',
+                created_at: '2024-01-01T00:00:00Z',
+                updated_at: '2024-01-02T00:00:00Z',
+            },
+        };
+        it('should successfully get a lexical document by ID', async () => {
+            console.log('Testing get lexical document by ID...');
+            const mockedRequest = vi.mocked(DatalayerApi.requestDatalayerAPI);
+            mockedRequest.mockResolvedValue(mockGetResponse);
+            const result = await lexicals.getLexical(MOCK_JWT_TOKEN, 'lexical-123', DEFAULT_SERVICE_URLS.SPACER);
+            expect(mockedRequest).toHaveBeenCalledTimes(1);
+            expect(mockedRequest).toHaveBeenCalledWith({
+                url: `${DEFAULT_SERVICE_URLS.SPACER}${API_BASE_PATHS.SPACER}/lexicals/lexical-123`,
+                method: 'GET',
+                token: MOCK_JWT_TOKEN,
+            });
+            expect(result).toEqual(mockGetResponse);
+            expect(result.success).toBe(true);
+            expect(result.document?.id).toBe('lexical-123');
+            console.log('Document retrieved successfully');
+        });
+        it('should handle document not found (404)', async () => {
+            console.log('Testing get document with 404...');
+            const notFoundResponse = {
+                success: false,
+                message: 'Document not found',
+            };
+            const mockedRequest = vi.mocked(DatalayerApi.requestDatalayerAPI);
+            mockedRequest.mockResolvedValue(notFoundResponse);
+            const result = await lexicals.getLexical(MOCK_JWT_TOKEN, 'nonexistent-document', DEFAULT_SERVICE_URLS.SPACER);
+            expect(result).toEqual(notFoundResponse);
+            expect(result.success).toBe(false);
+            expect(result.document).toBeUndefined();
+            console.log('404 response handled correctly');
+        });
+        it('should handle API errors during get', async () => {
+            console.log('Testing get document with API error...');
+            const mockedRequest = vi.mocked(DatalayerApi.requestDatalayerAPI);
+            mockedRequest.mockRejectedValue(new Error('Network error'));
+            await expect(lexicals.getLexical(MOCK_JWT_TOKEN, 'lexical-123', DEFAULT_SERVICE_URLS.SPACER)).rejects.toThrow('Network error');
+            console.log('API error handled correctly');
+        });
+        it('should use custom base URL when provided', async () => {
+            console.log('Testing get document with custom base URL...');
+            const customUrl = 'https://custom.spacer.api';
+            const mockedRequest = vi.mocked(DatalayerApi.requestDatalayerAPI);
+            mockedRequest.mockResolvedValue(mockGetResponse);
+            await lexicals.getLexical(MOCK_JWT_TOKEN, 'lexical-123', customUrl);
+            expect(mockedRequest).toHaveBeenCalledWith({
+                url: `${customUrl}${API_BASE_PATHS.SPACER}/lexicals/lexical-123`,
+                method: 'GET',
+                token: MOCK_JWT_TOKEN,
+            });
+            console.log('Custom base URL used correctly');
+        });
+    });
+    describe('update', () => {
+        const mockUpdateResponse = {
+            success: true,
+            message: 'Document updated successfully',
+            document: {
+                id: 'lexical-123',
+                uid: 'uid-lexical-123',
+                name: 'Updated Document',
+                content: {},
+                space_id: 'space-456',
+                owner_id: 'user-789',
+                created_at: '2024-01-01T00:00:00Z',
+                updated_at: '2024-01-03T00:00:00Z',
+            },
+        };
+        it('should successfully update a document name', async () => {
+            console.log('Testing update document name...');
+            const mockedRequest = vi.mocked(DatalayerApi.requestDatalayerAPI);
+            mockedRequest.mockResolvedValue(mockUpdateResponse);
+            const updateData = {
+                name: 'Updated Document',
+            };
+            const result = await lexicals.updateLexical(MOCK_JWT_TOKEN, 'lexical-123', updateData, DEFAULT_SERVICE_URLS.SPACER);
+            expect(mockedRequest).toHaveBeenCalledTimes(1);
+            expect(mockedRequest).toHaveBeenCalledWith({
+                url: `${DEFAULT_SERVICE_URLS.SPACER}${API_BASE_PATHS.SPACER}/lexicals/lexical-123`,
+                method: 'PUT',
+                token: MOCK_JWT_TOKEN,
+                body: updateData,
+            });
+            expect(result).toEqual(mockUpdateResponse);
+            expect(result.success).toBe(true);
+            expect(result.document.name).toBe('Updated Document');
+            console.log('Document name updated successfully');
+        });
+        it('should successfully update a document description', async () => {
+            console.log('Testing update document description...');
+            const mockedRequest = vi.mocked(DatalayerApi.requestDatalayerAPI);
+            mockedRequest.mockResolvedValue(mockUpdateResponse);
+            const updateData = {
+                description: 'Updated description',
+            };
+            const result = await lexicals.updateLexical(MOCK_JWT_TOKEN, 'lexical-123', updateData, DEFAULT_SERVICE_URLS.SPACER);
+            expect(mockedRequest).toHaveBeenCalledWith({
+                url: `${DEFAULT_SERVICE_URLS.SPACER}${API_BASE_PATHS.SPACER}/lexicals/lexical-123`,
+                method: 'PUT',
+                token: MOCK_JWT_TOKEN,
+                body: updateData,
+            });
+            expect(result.success).toBe(true);
+            console.log('Document description updated successfully');
+        });
+        it('should successfully update both name and description', async () => {
+            console.log('Testing update document name and description...');
+            const mockedRequest = vi.mocked(DatalayerApi.requestDatalayerAPI);
+            mockedRequest.mockResolvedValue(mockUpdateResponse);
+            const updateData = {
+                name: 'Updated Document',
+                description: 'Updated description',
+            };
+            const result = await lexicals.updateLexical(MOCK_JWT_TOKEN, 'lexical-123', updateData, DEFAULT_SERVICE_URLS.SPACER);
+            expect(mockedRequest).toHaveBeenCalledWith({
+                url: `${DEFAULT_SERVICE_URLS.SPACER}${API_BASE_PATHS.SPACER}/lexicals/lexical-123`,
+                method: 'PUT',
+                token: MOCK_JWT_TOKEN,
+                body: updateData,
+            });
+            expect(result.success).toBe(true);
+            console.log('Document name and description updated successfully');
+        });
+        it('should handle API errors during update', async () => {
+            console.log('Testing update document with API error...');
+            const mockedRequest = vi.mocked(DatalayerApi.requestDatalayerAPI);
+            mockedRequest.mockRejectedValue(new Error('Update failed'));
+            const updateData = {
+                name: 'Updated Document',
+            };
+            await expect(lexicals.updateLexical(MOCK_JWT_TOKEN, 'lexical-123', updateData, DEFAULT_SERVICE_URLS.SPACER)).rejects.toThrow('Update failed');
+            console.log('API error handled correctly');
+        });
+        it('should use custom base URL when provided', async () => {
+            console.log('Testing update document with custom base URL...');
+            const customUrl = 'https://custom.spacer.api';
+            const mockedRequest = vi.mocked(DatalayerApi.requestDatalayerAPI);
+            mockedRequest.mockResolvedValue(mockUpdateResponse);
+            const updateData = {
+                name: 'Updated Document',
+            };
+            await lexicals.updateLexical(MOCK_JWT_TOKEN, 'lexical-123', updateData, customUrl);
+            expect(mockedRequest).toHaveBeenCalledWith({
+                url: `${customUrl}${API_BASE_PATHS.SPACER}/lexicals/lexical-123`,
+                method: 'PUT',
+                token: MOCK_JWT_TOKEN,
+                body: updateData,
+            });
+            console.log('Custom base URL used correctly');
+        });
+    });
+});

package/lib/api/spacer/__tests__/notebooks.unit.test.d.ts

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

package/lib/api/spacer/__tests__/notebooks.unit.test.js

@@ -0,0 +1,224 @@
+/*
+ * Copyright (c) 2023-2025 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { notebooks } from '..';
+import * as DatalayerApi from '../../DatalayerApi';
+import { API_BASE_PATHS, DEFAULT_SERVICE_URLS } from '../../constants';
+import { MOCK_JWT_TOKEN } from '../../../__tests__/shared/test-constants';
+// Mock the DatalayerApi module
+vi.mock('../../DatalayerApi', () => ({
+    requestDatalayerAPI: vi.fn(),
+}));
+describe('Spacer Notebooks Unit Tests', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+    describe('create', () => {
+        const mockCreateResponse = {
+            success: true,
+            message: 'Notebook created successfully',
+            notebook: {
+                id: 'notebook-123',
+                uid: 'uid-notebook-123',
+                name: 'Test Notebook',
+                path: '/notebooks/test-notebook',
+                space_id: 'space-456',
+                owner_id: 'user-789',
+                created_at: '2024-01-01T00:00:00Z',
+            },
+        };
+        it('should successfully create a notebook with FormData', async () => {
+            console.log('Testing notebook creation with FormData...');
+            const mockedRequest = vi.mocked(DatalayerApi.requestDatalayerAPI);
+            mockedRequest.mockResolvedValue(mockCreateResponse);
+            const notebookData = {
+                spaceId: 'space-456',
+                notebookType: 'jupyter',
+                name: 'Test Notebook',
+                description: 'A test notebook',
+            };
+            const result = await notebooks.createNotebook(MOCK_JWT_TOKEN, notebookData, DEFAULT_SERVICE_URLS.SPACER);
+            expect(mockedRequest).toHaveBeenCalledTimes(1);
+            // Check that FormData was passed as the body
+            const callArgs = mockedRequest.mock.calls[0][0];
+            expect(callArgs.url).toBe(`${DEFAULT_SERVICE_URLS.SPACER}${API_BASE_PATHS.SPACER}/notebooks`);
+            expect(callArgs.method).toBe('POST');
+            expect(callArgs.token).toBe(MOCK_JWT_TOKEN);
+            expect(callArgs.body).toBeInstanceOf(FormData);
+            expect(result).toEqual(mockCreateResponse);
+            expect(result.success).toBe(true);
+            expect(result.notebook.name).toBe('Test Notebook');
+            console.log('Notebook created successfully');
+        });
+        it('should handle FormData with file attachment', async () => {
+            console.log('Testing notebook creation with file...');
+            const mockedRequest = vi.mocked(DatalayerApi.requestDatalayerAPI);
+            mockedRequest.mockResolvedValue(mockCreateResponse);
+            const file = new File(['notebook content'], 'test.ipynb', {
+                type: 'application/json',
+            });
+            const notebookData = {
+                spaceId: 'space-456',
+                notebookType: 'jupyter',
+                name: 'Test Notebook',
+                description: 'A test notebook',
+                file,
+            };
+            await notebooks.createNotebook(MOCK_JWT_TOKEN, notebookData, DEFAULT_SERVICE_URLS.SPACER);
+            const callArgs = mockedRequest.mock.calls[0][0];
+            expect(callArgs.url).toBe(`${DEFAULT_SERVICE_URLS.SPACER}${API_BASE_PATHS.SPACER}/notebooks`);
+            expect(callArgs.method).toBe('POST');
+            expect(callArgs.token).toBe(MOCK_JWT_TOKEN);
+            expect(callArgs.body).toBeInstanceOf(FormData);
+            console.log('Notebook with file created successfully');
+        });
+        it('should handle API errors during creation', async () => {
+            console.log('Testing notebook creation with API error...');
+            const mockedRequest = vi.mocked(DatalayerApi.requestDatalayerAPI);
+            mockedRequest.mockRejectedValue(new Error('API Error'));
+            const formData = new FormData();
+            formData.append('spaceId', 'space-456');
+            formData.append('notebookType', 'jupyter');
+            formData.append('name', 'Test Notebook');
+            formData.append('description', 'A test notebook');
+            await expect(notebooks.createNotebook(MOCK_JWT_TOKEN, formData, DEFAULT_SERVICE_URLS.SPACER)).rejects.toThrow('API Error');
+            console.log('API error handled correctly');
+        });
+    });
+    describe('get', () => {
+        const mockGetResponse = {
+            success: true,
+            message: 'Notebook retrieved successfully',
+            notebook: {
+                id: 'notebook-123',
+                uid: 'uid-notebook-123',
+                name: 'Test Notebook',
+                path: '/notebooks/test-notebook',
+                space_id: 'space-456',
+                owner_id: 'user-789',
+                created_at: '2024-01-01T00:00:00Z',
+                updated_at: '2024-01-02T00:00:00Z',
+            },
+        };
+        it('should successfully get a notebook by ID', async () => {
+            console.log('Testing get notebook by ID...');
+            const mockedRequest = vi.mocked(DatalayerApi.requestDatalayerAPI);
+            mockedRequest.mockResolvedValue(mockGetResponse);
+            const result = await notebooks.getNotebook(MOCK_JWT_TOKEN, 'notebook-123', DEFAULT_SERVICE_URLS.SPACER);
+            expect(mockedRequest).toHaveBeenCalledTimes(1);
+            expect(mockedRequest).toHaveBeenCalledWith({
+                url: `${DEFAULT_SERVICE_URLS.SPACER}${API_BASE_PATHS.SPACER}/notebooks/notebook-123`,
+                method: 'GET',
+                token: MOCK_JWT_TOKEN,
+            });
+            expect(result).toEqual(mockGetResponse);
+            expect(result.success).toBe(true);
+            expect(result.notebook?.id).toBe('notebook-123');
+            console.log('Notebook retrieved successfully');
+        });
+        it('should handle notebook not found (404)', async () => {
+            console.log('Testing get notebook with 404...');
+            const notFoundResponse = {
+                success: false,
+                message: 'Notebook not found',
+            };
+            const mockedRequest = vi.mocked(DatalayerApi.requestDatalayerAPI);
+            mockedRequest.mockResolvedValue(notFoundResponse);
+            const result = await notebooks.getNotebook(MOCK_JWT_TOKEN, 'nonexistent-notebook', DEFAULT_SERVICE_URLS.SPACER);
+            expect(result).toEqual(notFoundResponse);
+            expect(result.success).toBe(false);
+            expect(result.notebook).toBeUndefined();
+            console.log('404 response handled correctly');
+        });
+        it('should handle API errors during get', async () => {
+            console.log('Testing get notebook with API error...');
+            const mockedRequest = vi.mocked(DatalayerApi.requestDatalayerAPI);
+            mockedRequest.mockRejectedValue(new Error('Network error'));
+            await expect(notebooks.getNotebook(MOCK_JWT_TOKEN, 'notebook-123', DEFAULT_SERVICE_URLS.SPACER)).rejects.toThrow('Network error');
+            console.log('API error handled correctly');
+        });
+    });
+    describe('update', () => {
+        const mockUpdateResponse = {
+            success: true,
+            message: 'Notebook updated successfully',
+            notebook: {
+                id: 'notebook-123',
+                uid: 'uid-notebook-123',
+                name: 'Updated Notebook',
+                path: '/notebooks/updated-notebook',
+                space_id: 'space-456',
+                owner_id: 'user-789',
+                created_at: '2024-01-01T00:00:00Z',
+                updated_at: '2024-01-03T00:00:00Z',
+            },
+        };
+        it('should successfully update a notebook name', async () => {
+            console.log('Testing update notebook name...');
+            const mockedRequest = vi.mocked(DatalayerApi.requestDatalayerAPI);
+            mockedRequest.mockResolvedValue(mockUpdateResponse);
+            const updateData = {
+                name: 'Updated Notebook',
+            };
+            const result = await notebooks.updateNotebook(MOCK_JWT_TOKEN, 'notebook-123', updateData, DEFAULT_SERVICE_URLS.SPACER);
+            expect(mockedRequest).toHaveBeenCalledTimes(1);
+            expect(mockedRequest).toHaveBeenCalledWith({
+                url: `${DEFAULT_SERVICE_URLS.SPACER}${API_BASE_PATHS.SPACER}/notebooks/notebook-123`,
+                method: 'PUT',
+                token: MOCK_JWT_TOKEN,
+                body: updateData,
+            });
+            expect(result).toEqual(mockUpdateResponse);
+            expect(result.success).toBe(true);
+            expect(result.notebook.name).toBe('Updated Notebook');
+            console.log('Notebook name updated successfully');
+        });
+        it('should successfully update a notebook description', async () => {
+            console.log('Testing update notebook description...');
+            const mockedRequest = vi.mocked(DatalayerApi.requestDatalayerAPI);
+            mockedRequest.mockResolvedValue(mockUpdateResponse);
+            const updateData = {
+                description: 'Updated description',
+            };
+            const result = await notebooks.updateNotebook(MOCK_JWT_TOKEN, 'notebook-123', updateData, DEFAULT_SERVICE_URLS.SPACER);
+            expect(mockedRequest).toHaveBeenCalledWith({
+                url: `${DEFAULT_SERVICE_URLS.SPACER}${API_BASE_PATHS.SPACER}/notebooks/notebook-123`,
+                method: 'PUT',
+                token: MOCK_JWT_TOKEN,
+                body: updateData,
+            });
+            expect(result.success).toBe(true);
+            console.log('Notebook description updated successfully');
+        });
+        it('should successfully update both name and description', async () => {
+            console.log('Testing update notebook name and description...');
+            const mockedRequest = vi.mocked(DatalayerApi.requestDatalayerAPI);
+            mockedRequest.mockResolvedValue(mockUpdateResponse);
+            const updateData = {
+                name: 'Updated Notebook',
+                description: 'Updated description',
+            };
+            const result = await notebooks.updateNotebook(MOCK_JWT_TOKEN, 'notebook-123', updateData, DEFAULT_SERVICE_URLS.SPACER);
+            expect(mockedRequest).toHaveBeenCalledWith({
+                url: `${DEFAULT_SERVICE_URLS.SPACER}${API_BASE_PATHS.SPACER}/notebooks/notebook-123`,
+                method: 'PUT',
+                token: MOCK_JWT_TOKEN,
+                body: updateData,
+            });
+            expect(result.success).toBe(true);
+            console.log('Notebook name and description updated successfully');
+        });
+        it('should handle API errors during update', async () => {
+            console.log('Testing update notebook with API error...');
+            const mockedRequest = vi.mocked(DatalayerApi.requestDatalayerAPI);
+            mockedRequest.mockRejectedValue(new Error('Update failed'));
+            const updateData = {
+                name: 'Updated Notebook',
+            };
+            await expect(notebooks.updateNotebook(MOCK_JWT_TOKEN, 'notebook-123', updateData, DEFAULT_SERVICE_URLS.SPACER)).rejects.toThrow('Update failed');
+            console.log('API error handled correctly');
+        });
+    });
+});

package/lib/api/spacer/__tests__/users.unit.test.d.ts

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