@datalayer/core 0.0.10 → 0.0.12

package/lib/sdk/client/models/__tests__/Lexical.test.js

@@ -0,0 +1,288 @@
+/*
+ * Copyright (c) 2023-2025 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+/**
+ * @module sdk/client/models/__tests__/Lexical.test
+ * @description Tests for the Lexical domain model.
+ */
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { Lexical } from '../Lexical';
+import { lexicals, items } from '../../../../api/spacer';
+// Mock the spacer API
+vi.mock('../../../../api/spacer', () => ({
+    lexicals: {
+        getLexical: vi.fn(),
+        updateLexical: vi.fn(),
+    },
+    items: {
+        deleteItem: vi.fn(),
+    },
+}));
+describe('Lexical Model', () => {
+    const mockLexicalData = {
+        id: 'lexical-123',
+        uid: 'lexical-uid-456',
+        name: 'Project Documentation', // API uses name field
+        content: {
+            type: 'doc',
+            content: [
+                {
+                    type: 'paragraph',
+                    content: [
+                        {
+                            type: 'text',
+                            text: 'This is a sample document',
+                        },
+                    ],
+                },
+            ],
+        },
+        space_id: 'space-789',
+        owner_id: 'user-abc',
+        created_at: '2023-01-01T10:00:00Z',
+        updated_at: '2023-01-02T15:30:00Z',
+    };
+    let mockSDK;
+    let lexical;
+    beforeEach(() => {
+        mockSDK = {
+            getToken: vi.fn().mockReturnValue('mock-token'),
+            getSpacerRunUrl: vi.fn().mockReturnValue('https://spacer.example.com'),
+        };
+        lexical = new Lexical(mockLexicalData, mockSDK);
+        vi.clearAllMocks();
+    });
+    describe('Static Properties', () => {
+        it('should return correct id', () => {
+            expect(lexical.id).toBe('lexical-123');
+        });
+        it('should return correct uid', () => {
+            expect(lexical.uid).toBe('lexical-uid-456');
+        });
+        it('should return correct space ID', () => {
+            expect(lexical.spaceId).toBe('space-789');
+        });
+        it('should return correct owner ID', () => {
+            expect(lexical.ownerId).toBe('user-abc');
+        });
+        it('should return correct created date', () => {
+            expect(lexical.createdAt).toEqual(new Date('2023-01-01T10:00:00Z'));
+        });
+        it('should handle minimal data gracefully', () => {
+            const minimalData = {
+                id: 'lexical-minimal',
+                uid: 'lexical-uid-minimal',
+                name: 'Minimal Document',
+                space_id: 'space-minimal',
+                owner_id: 'user-minimal',
+                created_at: '2023-01-01T08:00:00Z',
+            };
+            const minimalLexical = new Lexical(minimalData, mockSDK);
+            expect(minimalLexical.id).toBe('lexical-minimal');
+            expect(minimalLexical.uid).toBe('lexical-uid-minimal');
+            expect(minimalLexical.spaceId).toBe('space-minimal');
+        });
+    });
+    describe('Dynamic Methods', () => {
+        beforeEach(() => {
+            lexicals.getLexical.mockResolvedValue({
+                success: true,
+                document: { ...mockLexicalData, name: 'Updated Documentation' },
+            });
+        });
+        it('should fetch fresh name from API and update internal data', async () => {
+            const name = await lexical.getName();
+            expect(name).toBe('Updated Documentation');
+            expect(lexicals.getLexical).toHaveBeenCalledWith('mock-token', 'lexical-uid-456', // Use uid, not id
+            'https://spacer.example.com');
+        });
+        it('should fetch fresh content from API', async () => {
+            const updatedContent = {
+                type: 'doc',
+                content: [
+                    {
+                        type: 'paragraph',
+                        content: [
+                            {
+                                type: 'text',
+                                text: 'Updated document content',
+                            },
+                        ],
+                    },
+                ],
+            };
+            lexicals.getLexical.mockResolvedValue({
+                success: true,
+                document: { ...mockLexicalData, content: updatedContent },
+            });
+            const content = await lexical.getContent();
+            expect(content).toEqual(updatedContent);
+            expect(lexicals.getLexical).toHaveBeenCalledWith('mock-token', 'lexical-uid-456', // Use uid, not id
+            'https://spacer.example.com');
+        });
+        it('should fetch fresh updated date from API', async () => {
+            const newUpdateTime = '2023-01-03T12:00:00Z';
+            lexicals.getLexical.mockResolvedValue({
+                success: true,
+                document: { ...mockLexicalData, updated_at: newUpdateTime },
+            });
+            const updatedAt = await lexical.getUpdatedAt();
+            expect(updatedAt).toEqual(new Date(newUpdateTime));
+        });
+        it('should handle missing updated_at by falling back to created_at', async () => {
+            lexicals.getLexical.mockResolvedValue({
+                success: true,
+                document: { ...mockLexicalData, updated_at: undefined },
+            });
+            const updatedAt = await lexical.getUpdatedAt();
+            expect(updatedAt).toEqual(new Date(mockLexicalData.created_at));
+        });
+        it('should handle missing content gracefully', async () => {
+            lexicals.getLexical.mockResolvedValue({
+                success: true,
+                document: { ...mockLexicalData, content: undefined },
+            });
+            const content = await lexical.getContent();
+            expect(content).toBeUndefined();
+        });
+        it('should update internal data when fetching dynamic properties', async () => {
+            const updatedData = {
+                ...mockLexicalData,
+                name: 'Fresh Name',
+                content: { type: 'doc', content: [] },
+                updated_at: '2023-01-04T10:00:00Z',
+            };
+            lexicals.getLexical.mockResolvedValue({
+                success: true,
+                document: updatedData,
+            });
+            await lexical.getName();
+            const json = await lexical.toJSON();
+            expect(json.name).toBe('Fresh Name');
+            expect(json.updated_at).toBe('2023-01-04T10:00:00Z');
+        });
+    });
+    describe('Action Methods', () => {
+        it('should update document and return new instance', async () => {
+            const updatedDocument = {
+                ...mockLexicalData,
+                name: 'New Documentation Title',
+                updated_at: '2023-01-03T14:00:00Z',
+            };
+            lexicals.updateLexical.mockResolvedValue({
+                success: true,
+                document: updatedDocument,
+            });
+            const updated = await lexical.update({
+                name: 'New Documentation Title',
+                description: 'Updated description',
+            });
+            expect(lexicals.updateLexical).toHaveBeenCalledWith('mock-token', 'lexical-uid-456', // Use uid, not id
+            { name: 'New Documentation Title', description: 'Updated description' }, 'https://spacer.example.com');
+            expect(updated).toBeInstanceOf(Lexical);
+            expect(updated.toString()).toBe('Lexical(lexical-123, New Documentation Title)');
+        });
+        it('should delete document and mark as deleted', async () => {
+            items.deleteItem.mockResolvedValue({ success: true });
+            await lexical.delete();
+            expect(items.deleteItem).toHaveBeenCalledWith('mock-token', 'lexical-uid-456', // Use uid, not id
+            'https://spacer.example.com');
+            // After deletion, accessing properties should throw error
+            expect(() => lexical.id).toThrow('Lexical lexical-123 has been deleted and no longer exists');
+        });
+    });
+    describe('Utility Methods', () => {
+        it('should return JSON with fresh data', async () => {
+            const freshData = { ...mockLexicalData, name: 'Fresh Documentation' };
+            lexicals.getLexical.mockResolvedValue({
+                success: true,
+                document: freshData,
+            });
+            const json = await lexical.toJSON();
+            expect(json.name).toBe('Fresh Documentation');
+            expect(json.id).toBe('lexical-123');
+        });
+        it('should return string representation', () => {
+            expect(lexical.toString()).toBe('Lexical(lexical-123, Project Documentation)');
+        });
+    });
+    describe('Deletion State Management', () => {
+        beforeEach(async () => {
+            items.deleteItem.mockResolvedValue({ success: true });
+            await lexical.delete();
+        });
+        it('should throw error when accessing static properties after deletion', () => {
+            expect(() => lexical.id).toThrow('Lexical lexical-123 has been deleted and no longer exists');
+            expect(() => lexical.uid).toThrow('Lexical lexical-123 has been deleted and no longer exists');
+            expect(() => lexical.spaceId).toThrow('Lexical lexical-123 has been deleted and no longer exists');
+            expect(() => lexical.ownerId).toThrow('Lexical lexical-123 has been deleted and no longer exists');
+            expect(() => lexical.createdAt).toThrow('Lexical lexical-123 has been deleted and no longer exists');
+        });
+        it('should throw error when calling dynamic methods after deletion', async () => {
+            await expect(lexical.getName()).rejects.toThrow('Lexical lexical-123 has been deleted and no longer exists');
+            await expect(lexical.getContent()).rejects.toThrow('Lexical lexical-123 has been deleted and no longer exists');
+            await expect(lexical.getUpdatedAt()).rejects.toThrow('Lexical lexical-123 has been deleted and no longer exists');
+        });
+        it('should throw error when calling action methods after deletion', async () => {
+            await expect(lexical.update({ name: 'New Name' })).rejects.toThrow('Lexical lexical-123 has been deleted and no longer exists');
+        });
+        it('should throw error when calling utility methods after deletion', async () => {
+            await expect(lexical.toJSON()).rejects.toThrow('Lexical lexical-123 has been deleted and no longer exists');
+            expect(() => lexical.toString()).toThrow('Lexical lexical-123 has been deleted and no longer exists');
+        });
+    });
+    describe('Error Handling', () => {
+        it('should handle API errors gracefully in dynamic methods', async () => {
+            lexicals.getLexical.mockRejectedValue(new Error('API Error'));
+            await expect(lexical.getName()).rejects.toThrow('API Error');
+        });
+        it('should handle missing document in API response', async () => {
+            lexicals.getLexical.mockResolvedValue({
+                success: false,
+                message: 'Document not found',
+                document: null,
+            });
+            const name = await lexical.getName();
+            // Should return the current name from internal data when API returns null
+            expect(name).toBe('Project Documentation');
+        });
+        it('should handle API errors in update method', async () => {
+            lexicals.updateLexical.mockRejectedValue(new Error('Update failed'));
+            await expect(lexical.update({ name: 'New Name' })).rejects.toThrow('Update failed');
+        });
+        it('should handle API errors in delete method', async () => {
+            items.deleteItem.mockRejectedValue(new Error('Delete failed'));
+            await expect(lexical.delete()).rejects.toThrow('Delete failed');
+        });
+    });
+    describe('Edge Cases', () => {
+        it('should handle empty content gracefully', async () => {
+            lexicals.getLexical.mockResolvedValue({
+                success: true,
+                document: { ...mockLexicalData, content: {} },
+            });
+            const content = await lexical.getContent();
+            expect(content).toEqual({});
+        });
+        it('should handle null content gracefully', async () => {
+            lexicals.getLexical.mockResolvedValue({
+                success: true,
+                document: { ...mockLexicalData, content: null },
+            });
+            const content = await lexical.getContent();
+            expect(content).toBeNull();
+        });
+        it('should handle partial update requests', async () => {
+            const partialUpdate = { name: 'Only Name Updated' };
+            lexicals.updateLexical.mockResolvedValue({
+                success: true,
+                document: { ...mockLexicalData, name: 'Only Name Updated' },
+            });
+            const updated = await lexical.update(partialUpdate);
+            expect(lexicals.updateLexical).toHaveBeenCalledWith('mock-token', 'lexical-uid-456', // Use uid, not id
+            partialUpdate, 'https://spacer.example.com');
+            expect(updated.toString()).toBe('Lexical(lexical-123, Only Name Updated)');
+        });
+    });
+});

package/lib/sdk/client/models/__tests__/Notebook.test.d.ts

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

package/lib/sdk/client/models/__tests__/Notebook.test.js

@@ -0,0 +1,206 @@
+/*
+ * Copyright (c) 2023-2025 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+/**
+ * @module sdk/client/models/__tests__/Notebook.test
+ * @description Tests for the Notebook domain model.
+ */
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { Notebook } from '../Notebook';
+import { notebooks } from '../../../../api/spacer';
+// Mock the notebooks API
+vi.mock('../../../../api/spacer', () => ({
+    notebooks: {
+        getNotebook: vi.fn(),
+        updateNotebook: vi.fn(),
+    },
+    items: {
+        deleteItem: vi.fn(),
+    },
+}));
+describe('Notebook Model', () => {
+    const mockNotebookData = {
+        id: 'notebook-123',
+        uid: 'notebook-uid-456',
+        name: 'Test Notebook',
+        path: '/test/notebook.ipynb',
+        content: {
+            cells: [{ cell_type: 'code', source: 'print("hello")' }],
+            metadata: {},
+            nbformat: 4,
+            nbformat_minor: 2,
+        },
+        space_id: 'space-789',
+        owner_id: 'user-abc',
+        created_at: '2023-01-01T00:00:00Z',
+        updated_at: '2023-01-01T00:30:00Z',
+        version: 1,
+        kernel_spec: {
+            display_name: 'Python 3',
+            language: 'python',
+            name: 'python3',
+        },
+        metadata: {
+            custom_field: 'custom_value',
+        },
+    };
+    let mockSDK;
+    let notebook;
+    beforeEach(() => {
+        mockSDK = {
+            getToken: vi.fn().mockReturnValue('mock-token'),
+            getSpacerRunUrl: vi.fn().mockReturnValue('https://api.example.com'),
+        };
+        notebook = new Notebook(mockNotebookData, mockSDK);
+        vi.clearAllMocks();
+    });
+    describe('Static Properties', () => {
+        it('should return correct id', () => {
+            expect(notebook.id).toBe('notebook-123');
+        });
+        it('should return correct uid', () => {
+            expect(notebook.uid).toBe('notebook-uid-456');
+        });
+        it('should return correct path', () => {
+            expect(notebook.path).toBe('/test/notebook.ipynb');
+        });
+        it('should return correct space id', () => {
+            expect(notebook.spaceId).toBe('space-789');
+        });
+        it('should return correct owner id', () => {
+            expect(notebook.ownerId).toBe('user-abc');
+        });
+        it('should return correct created date', () => {
+            expect(notebook.createdAt).toEqual(new Date('2023-01-01T00:00:00Z'));
+        });
+        it('should return correct version', () => {
+            expect(notebook.version).toBe(1);
+        });
+        it('should return correct metadata', () => {
+            expect(notebook.metadata).toEqual({ custom_field: 'custom_value' });
+        });
+        it('should handle missing optional fields gracefully', () => {
+            const minimalData = {
+                id: 'notebook-123',
+                uid: 'notebook-uid-456',
+                name: 'Minimal Notebook',
+                path: '/minimal.ipynb',
+                space_id: 'space-789',
+                owner_id: 'user-abc',
+                created_at: '2023-01-01T00:00:00Z',
+            };
+            const minimalNotebook = new Notebook(minimalData, mockSDK);
+            expect(minimalNotebook.version).toBe(0);
+            expect(minimalNotebook.metadata).toEqual({});
+        });
+    });
+    describe('Dynamic Methods', () => {
+        beforeEach(() => {
+            notebooks.getNotebook.mockResolvedValue({
+                notebook: { ...mockNotebookData, name: 'Updated Name' },
+            });
+        });
+        it('should fetch fresh name from API and update internal data', async () => {
+            const name = await notebook.getName();
+            expect(name).toBe('Updated Name');
+            expect(notebooks.getNotebook).toHaveBeenCalledWith('mock-token', 'notebook-uid-456', // Use uid, not id
+            'https://api.example.com');
+        });
+        it('should fetch fresh content from API', async () => {
+            const updatedContent = { cells: [], metadata: {}, nbformat: 4 };
+            notebooks.getNotebook.mockResolvedValue({
+                notebook: { ...mockNotebookData, content: updatedContent },
+            });
+            const content = await notebook.getContent();
+            expect(content).toEqual(updatedContent);
+            expect(notebooks.getNotebook).toHaveBeenCalledWith('mock-token', 'notebook-uid-456', // Use uid, not id
+            'https://api.example.com');
+        });
+        it('should fetch fresh kernel spec from API', async () => {
+            const updatedKernelSpec = {
+                display_name: 'Python 3.9',
+                language: 'python',
+            };
+            notebooks.getNotebook.mockResolvedValue({
+                notebook: { ...mockNotebookData, kernel_spec: updatedKernelSpec },
+            });
+            const kernelSpec = await notebook.getKernelSpec();
+            expect(kernelSpec).toEqual(updatedKernelSpec);
+        });
+        it('should fetch fresh updated date from API', async () => {
+            const newUpdatedAt = '2023-01-02T12:00:00Z';
+            notebooks.getNotebook.mockResolvedValue({
+                notebook: { ...mockNotebookData, updated_at: newUpdatedAt },
+            });
+            const updatedAt = await notebook.getUpdatedAt();
+            expect(updatedAt).toEqual(new Date(newUpdatedAt));
+        });
+        it('should use created_at when updated_at is missing', async () => {
+            notebooks.getNotebook.mockResolvedValue({
+                notebook: { ...mockNotebookData, updated_at: undefined },
+            });
+            const updatedAt = await notebook.getUpdatedAt();
+            expect(updatedAt).toEqual(new Date(mockNotebookData.created_at));
+        });
+        it('should update internal data when fetching dynamic properties', async () => {
+            const updatedData = {
+                ...mockNotebookData,
+                name: 'Fresh Name',
+                version: 2,
+            };
+            notebooks.getNotebook.mockResolvedValue({
+                notebook: updatedData,
+            });
+            await notebook.getName();
+            const json = await notebook.toJSON();
+            expect(json.name).toBe('Fresh Name');
+            expect(json.version).toBe(2);
+        });
+    });
+    describe('Action Methods', () => {
+        it('should update notebook and return new instance', async () => {
+            const updateData = { name: 'New Name', description: 'New Description' };
+            const updatedNotebookData = { ...mockNotebookData, name: 'New Name' };
+            notebooks.updateNotebook.mockResolvedValue({
+                notebook: updatedNotebookData,
+            });
+            const updatedNotebook = await notebook.update(updateData);
+            expect(notebooks.updateNotebook).toHaveBeenCalledWith('mock-token', 'notebook-uid-456', // Use uid, not id
+            updateData, 'https://api.example.com');
+            expect(updatedNotebook).toBeInstanceOf(Notebook);
+            expect(updatedNotebook.id).toBe('notebook-123');
+        });
+        it('should delete notebook', async () => {
+            const { items } = await import('../../../../api/spacer');
+            items.deleteItem.mockResolvedValue({});
+            await notebook.delete();
+            expect(items.deleteItem).toHaveBeenCalledWith('mock-token', 'notebook-uid-456', // Use uid, not id
+            'https://api.example.com');
+        });
+    });
+    describe('Utility Methods', () => {
+        it('should return JSON with fresh data', async () => {
+            const freshData = { ...mockNotebookData, name: 'Latest Name' };
+            notebooks.getNotebook.mockResolvedValue({ notebook: freshData });
+            const json = await notebook.toJSON();
+            expect(json.name).toBe('Latest Name');
+            expect(json.id).toBe('notebook-123');
+        });
+        it('should return string representation', () => {
+            expect(notebook.toString()).toBe('Notebook(notebook-123, Test Notebook)');
+        });
+    });
+    describe('Error Handling', () => {
+        it('should handle API errors gracefully in dynamic methods', async () => {
+            notebooks.getNotebook.mockRejectedValue(new Error('API Error'));
+            await expect(notebook.getName()).rejects.toThrow('API Error');
+        });
+        it('should handle missing notebook in API response', async () => {
+            notebooks.getNotebook.mockResolvedValue({ notebook: null });
+            const name = await notebook.getName();
+            // Should return the current name from internal data when API returns null
+            expect(name).toBe('Test Notebook');
+        });
+    });
+});

package/lib/sdk/client/models/__tests__/Runtime.test.d.ts

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

package/lib/sdk/client/models/__tests__/Runtime.test.js

@@ -0,0 +1,133 @@
+/*
+ * Copyright (c) 2023-2025 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+/**
+ * @module sdk/client/models/__tests__/Runtime.test
+ * @description Tests for the Runtime domain model.
+ */
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { Runtime } from '../Runtime';
+describe('Runtime Model', () => {
+    const mockRuntimeData = {
+        pod_name: 'test-runtime-123',
+        uid: 'runtime-uid-456',
+        environment_name: 'python-cpu',
+        state: 'running',
+        burning_rate: 1.5,
+        given_name: 'Test Runtime',
+        jupyter_url: 'https://jupyter.example.com',
+        jupyter_token: 'jupyter-token-789',
+        type: 'notebook',
+        created_at: '2023-01-01T00:00:00Z',
+        started_at: '2023-01-01T00:01:00Z',
+        expired_at: '2023-01-01T01:00:00Z',
+    };
+    let mockSDK;
+    let runtime;
+    beforeEach(() => {
+        mockSDK = {
+            getRuntime: vi.fn(),
+            deleteRuntime: vi.fn(),
+            createSnapshot: vi.fn(),
+        };
+        runtime = new Runtime(mockRuntimeData, mockSDK);
+    });
+    describe('Static Properties', () => {
+        it('should return correct pod name', () => {
+            expect(runtime.podName).toBe('test-runtime-123');
+        });
+        it('should return correct uid', () => {
+            expect(runtime.uid).toBe('runtime-uid-456');
+        });
+        it('should return correct environment name', () => {
+            expect(runtime.environmentName).toBe('python-cpu');
+        });
+        it('should return correct burning rate', () => {
+            expect(runtime.burningRate).toBe(1.5);
+        });
+        it('should return correct given name', () => {
+            expect(runtime.givenName).toBe('Test Runtime');
+        });
+        it('should return correct jupyter url', () => {
+            expect(runtime.jupyterUrl).toBe('https://jupyter.example.com');
+        });
+        it('should return correct jupyter token', () => {
+            expect(runtime.jupyterToken).toBe('jupyter-token-789');
+        });
+        it('should return correct type', () => {
+            expect(runtime.type).toBe('notebook');
+        });
+        it('should return correct dates', () => {
+            expect(runtime.createdAt).toEqual(new Date('2023-01-01T00:00:00Z'));
+            expect(runtime.startedAt).toEqual(new Date('2023-01-01T00:01:00Z'));
+            expect(runtime.expiredAt).toEqual(new Date('2023-01-01T01:00:00Z'));
+        });
+    });
+    describe('Dynamic State', () => {
+        it('should fetch fresh state from API', async () => {
+            const freshRuntime = new Runtime({ ...mockRuntimeData, state: 'stopped' }, mockSDK);
+            mockSDK.getRuntime.mockResolvedValue(freshRuntime);
+            const state = await runtime.getState();
+            expect(state).toBe('stopped');
+            expect(mockSDK.getRuntime).toHaveBeenCalledWith('test-runtime-123');
+        });
+        it('should update internal data when getting state', async () => {
+            const freshRuntime = new Runtime({ ...mockRuntimeData, state: 'error' }, mockSDK);
+            mockSDK.getRuntime.mockResolvedValue(freshRuntime);
+            await runtime.getState();
+            const json = await runtime.toJSON();
+            expect(json.state).toBe('error');
+        });
+    });
+    describe('State Checking Methods', () => {
+        beforeEach(() => {
+            const freshRuntime = new Runtime(mockRuntimeData, mockSDK);
+            mockSDK.getRuntime.mockResolvedValue(freshRuntime);
+        });
+        it('should check if runtime is running', async () => {
+            expect(await runtime.isRunning()).toBe(true);
+        });
+        it('should check if runtime is starting', async () => {
+            const startingRuntime = new Runtime({ ...mockRuntimeData, state: 'starting' }, mockSDK);
+            mockSDK.getRuntime.mockResolvedValue(startingRuntime);
+            expect(await runtime.isStarting()).toBe(true);
+            expect(await runtime.isRunning()).toBe(false);
+        });
+        it('should check if runtime has error', async () => {
+            const errorRuntime = new Runtime({ ...mockRuntimeData, state: 'error' }, mockSDK);
+            mockSDK.getRuntime.mockResolvedValue(errorRuntime);
+            expect(await runtime.hasError()).toBe(true);
+        });
+    });
+    describe('Action Methods', () => {
+        it('should delete runtime', async () => {
+            await runtime.delete();
+            expect(mockSDK.deleteRuntime).toHaveBeenCalledWith('test-runtime-123');
+        });
+        it('should create snapshot', async () => {
+            const mockSnapshot = { uid: 'snap-123', name: 'test-snap' };
+            mockSDK.createSnapshot.mockResolvedValue({
+                snapshot: mockSnapshot,
+            });
+            await runtime.createSnapshot('test-snap', 'desc');
+            expect(mockSDK.createSnapshot).toHaveBeenCalledWith({
+                pod_name: 'test-runtime-123',
+                name: 'test-snap',
+                description: 'desc',
+                stop: false,
+            });
+        });
+    });
+    describe('Utility Methods', () => {
+        it('should return JSON with fresh data', async () => {
+            const freshRuntime = new Runtime({ ...mockRuntimeData, state: 'stopped' }, mockSDK);
+            mockSDK.getRuntime.mockResolvedValue(freshRuntime);
+            const json = await runtime.toJSON();
+            expect(json.state).toBe('stopped');
+        });
+        it('should return string representation', () => {
+            expect(runtime.toString()).toBe('Runtime(test-runtime-123, python-cpu)');
+        });
+    });
+});

package/lib/sdk/client/models/__tests__/Snapshot.test.d.ts

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