@datalayer/core 0.0.9 → 0.0.11

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

@@ -0,0 +1,376 @@
+/*
+ * Copyright (c) 2023-2025 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+import { describe, it, expect, beforeAll, afterAll } from 'vitest';
+import { DatalayerSDK } from '..';
+import { Runtime } from '../models/Runtime';
+import { Snapshot } from '../models/Snapshot';
+import { Notebook } from '../models/Notebook';
+import { Lexical } from '../models/Lexical';
+import { testConfig } from '../../../__tests__/shared/test-config';
+import { DEFAULT_SERVICE_URLS } from '../../../api/constants';
+import { performCleanup } from '../../../__tests__/shared/cleanup-shared';
+/**
+ * SDK Models Integration Tests
+ *
+ * Tests model state management, lazy loading, and relationships
+ * using the SDK client and model classes.
+ */
+describe('SDK Models Integration Tests', () => {
+    let sdk;
+    let testSpace = null;
+    let testNotebook = null;
+    let testLexical = null;
+    let testRuntime = null;
+    let testSnapshot = null;
+    beforeAll(async () => {
+        if (!testConfig.hasToken()) {
+            return;
+        }
+        await performCleanup('setup');
+        sdk = new DatalayerSDK({
+            token: testConfig.getToken(),
+            iamRunUrl: DEFAULT_SERVICE_URLS.IAM,
+            runtimesRunUrl: DEFAULT_SERVICE_URLS.RUNTIMES,
+            spacerRunUrl: DEFAULT_SERVICE_URLS.SPACER,
+        });
+    });
+    afterAll(async () => {
+        if (!testConfig.hasToken()) {
+            return;
+        }
+        await performCleanup('teardown');
+    }, 30000);
+    describe.skipIf(!testConfig.hasToken())('Model state management', () => {
+        it('should mark models as deleted after deletion', async () => {
+            console.log('Testing model deletion state...');
+            // Get a space to work with
+            const spaces = await sdk.getMySpaces();
+            expect(spaces.length).toBeGreaterThan(0);
+            testSpace = spaces[0];
+            // Create a notebook
+            const notebook = await sdk.createNotebook({
+                spaceId: testSpace.uid,
+                notebookType: 'jupyter',
+                name: 'model-test-notebook-' + Date.now(),
+                description: 'Test notebook for model tests',
+            });
+            expect(notebook).toBeInstanceOf(Notebook);
+            // Delete it
+            await notebook.delete();
+            // Verify it's marked as deleted
+            expect(notebook.isDeleted).toBe(true);
+            // Verify methods throw errors
+            try {
+                await notebook.getName();
+                expect(true).toBe(false); // Should not reach here
+            }
+            catch (error) {
+                expect(error.message).toContain('deleted');
+                console.log('Deleted model correctly throws error');
+            }
+        });
+        it('should handle lazy loading of model properties', async () => {
+            if (!testSpace) {
+                throw new Error('Test dependency failed: testSpace should be available from previous test');
+            }
+            console.log('Testing lazy loading...');
+            // Create a notebook with minimal data
+            testNotebook = await sdk.createNotebook({
+                spaceId: testSpace.uid,
+                notebookType: 'jupyter',
+                name: 'lazy-load-test-' + Date.now(),
+                description: 'Test description',
+            });
+            // First call should fetch from API
+            const name1 = await testNotebook.getName();
+            expect(name1).toBeDefined();
+            // Second call should use cached value (faster)
+            const start = Date.now();
+            const name2 = await testNotebook.getName();
+            const elapsed = Date.now() - start;
+            expect(name2).toBe(name1);
+            expect(elapsed).toBeLessThan(10); // Should be instant
+            console.log(`Lazy loading working - cached access in ${elapsed}ms`);
+        });
+        it('should refresh data when explicitly requested', async () => {
+            // Ensure we have a space to work with
+            if (!testSpace) {
+                const spaces = await sdk.getMySpaces();
+                expect(spaces.length).toBeGreaterThan(0);
+                testSpace = spaces[0];
+            }
+            // Create a notebook if we don't have one
+            if (!testNotebook) {
+                testNotebook = await sdk.createNotebook({
+                    spaceId: testSpace.uid,
+                    notebookType: 'jupyter',
+                    name: 'refresh-test-' + Date.now(),
+                    description: 'Test description',
+                });
+            }
+            console.log('Testing data refresh...');
+            // Get initial name
+            const originalName = await testNotebook.getName();
+            expect(originalName).toBeDefined();
+            // Test that we can fetch fresh data
+            const content = await testNotebook.getContent();
+            expect(content).toBeDefined();
+            // Verify the model is working properly
+            const uid = testNotebook.uid;
+            expect(uid).toBeDefined();
+            console.log(`Model data access verified - name: ${originalName}, uid: ${uid}`);
+        });
+    });
+    describe.skipIf(!testConfig.hasToken())('Model relationships', () => {
+        it('should handle Space → Notebook relationship', async () => {
+            // Ensure we have a space
+            if (!testSpace) {
+                const spaces = await sdk.getMySpaces();
+                expect(spaces.length).toBeGreaterThan(0);
+                testSpace = spaces[0];
+            }
+            // Ensure we have a notebook
+            if (!testNotebook) {
+                testNotebook = await sdk.createNotebook({
+                    spaceId: testSpace.uid,
+                    notebookType: 'jupyter',
+                    name: 'relationship-test-' + Date.now(),
+                    description: 'Test notebook for relationships',
+                });
+            }
+            console.log('Testing Space → Notebook relationship...');
+            // Get items from space
+            const items = await testSpace.getItems();
+            expect(Array.isArray(items)).toBe(true);
+            console.log(`Space has ${items.length} items`);
+            console.log('Looking for notebook with id:', testNotebook.id);
+            console.log('Items in space:', items.map(item => ({
+                id: item.id,
+                uid: item.uid,
+                type: item.type || item.type,
+                name: item.name,
+            })));
+            // Our test notebook should be in the items
+            // Note: Space items may not have a 'type' property
+            const foundNotebook = items.find(item => item.id === testNotebook.id ||
+                item.uid === testNotebook.uid);
+            expect(foundNotebook).toBeDefined();
+            console.log(`Found notebook ${testNotebook.id} in space items`);
+            console.log(`Space contains ${items.length} items`);
+        });
+        it('should handle Space → Lexical relationship', async () => {
+            // Ensure we have a space
+            if (!testSpace) {
+                const spaces = await sdk.getMySpaces();
+                expect(spaces.length).toBeGreaterThan(0);
+                testSpace = spaces[0];
+            }
+            console.log('Testing Space → Lexical relationship...');
+            // Create a lexical document
+            testLexical = await sdk.createLexical({
+                spaceId: testSpace.uid,
+                name: 'relationship-test-lexical-' + Date.now(),
+                documentType: 'document',
+                description: 'Test lexical document for relationships',
+            });
+            expect(testLexical).toBeInstanceOf(Lexical);
+            // Verify it appears in space items
+            const items = await testSpace.getItems();
+            const foundLexical = items.find(item => item.id === testLexical.id || item.uid === testLexical.uid);
+            expect(foundLexical).toBeDefined();
+            console.log(`Created lexical ${testLexical.id} in space`);
+        });
+    });
+    describe.skipIf(!testConfig.hasToken() || testConfig.shouldSkipExpensive())('Runtime → Snapshot relationship', () => {
+        it('should handle Runtime → Snapshot creation', async () => {
+            console.log('Testing Runtime → Snapshot relationship...');
+            // Create a runtime
+            testRuntime = await sdk.createRuntime({
+                environment_name: 'python-cpu-env',
+                type: 'notebook',
+                given_name: 'model-test-runtime',
+                credits_limit: 10,
+            });
+            expect(testRuntime).toBeInstanceOf(Runtime);
+            console.log(`Created runtime: ${testRuntime.podName}`);
+            // Create a snapshot from the runtime
+            testSnapshot = await testRuntime.createSnapshot('model-test-snapshot', 'Test snapshot from model test');
+            expect(testSnapshot).toBeInstanceOf(Snapshot);
+            // Snapshots don't have a podName property
+            // Instead, check that the snapshot was created successfully
+            expect(testSnapshot.uid).toBeDefined();
+            expect(testSnapshot.name).toBe('model-test-snapshot');
+            console.log(`Created snapshot ${testSnapshot.uid} from runtime`);
+        });
+        it('should list runtime snapshots', async () => {
+            if (!testRuntime || !testSnapshot) {
+                throw new Error('Test dependency failed: testRuntime and testSnapshot should be available from previous test');
+            }
+            console.log('Testing runtime snapshot listing...');
+            // List all snapshots
+            const snapshots = await sdk.listSnapshots();
+            // Find our test snapshot
+            const found = snapshots.find(s => s.uid === testSnapshot.uid);
+            expect(found).toBeDefined();
+            console.log(`Found ${snapshots.length} snapshots total`);
+        });
+    });
+    describe.skipIf(!testConfig.hasToken())('Model serialization', () => {
+        it('should serialize Space model to JSON', async () => {
+            if (!testSpace) {
+                throw new Error('Test dependency failed: testSpace should be available from previous test');
+            }
+            console.log('Testing Space serialization...');
+            const json = await testSpace.toJSON();
+            expect(json).toBeDefined();
+            expect(json.id || json.uid).toBeDefined();
+            // JSON should include fetched properties
+            if (testSpace.name) {
+                expect(json.name).toBe(testSpace.name);
+            }
+            console.log('Space serialized successfully');
+        });
+        it('should serialize Notebook model to JSON', async () => {
+            // Always create a fresh notebook for this test to avoid state issues
+            // Ensure we have a space first
+            if (!testSpace) {
+                const spaces = await sdk.getMySpaces();
+                expect(spaces.length).toBeGreaterThan(0);
+                testSpace = spaces[0];
+            }
+            const freshNotebook = await sdk.createNotebook({
+                spaceId: testSpace.uid,
+                notebookType: 'jupyter',
+                name: 'serialization-test-' + Date.now(),
+                description: 'Test notebook for serialization',
+            });
+            console.log('Testing Notebook serialization...');
+            console.log('Notebook created with id:', freshNotebook.id);
+            const json = await freshNotebook.toJSON();
+            expect(json).toBeDefined();
+            expect(json.id).toBe(freshNotebook.id);
+            // Log the JSON to see what fields are present
+            console.log('Notebook JSON:', JSON.stringify(json, null, 2));
+            // The notebook should have its basic properties
+            // The name might be in name, name_t, or notebook_name_s
+            const name = json.name || json.name_t || json.notebook_name_s;
+            expect(name).toBeDefined();
+            expect(json.id).toBeDefined();
+            expect(json.uid).toBeDefined();
+            console.log('Notebook serialized successfully');
+        });
+        it.skipIf(testConfig.shouldSkipExpensive())('should serialize Runtime model to JSON', async () => {
+            if (!testRuntime) {
+                throw new Error('Test dependency failed: testRuntime should be available from previous test');
+            }
+            console.log('Testing Runtime serialization...');
+            const json = await testRuntime.toJSON();
+            expect(json).toBeDefined();
+            expect(json.pod_name).toBe(testRuntime.podName);
+            expect(json.environment_name).toBe(testRuntime.environmentName);
+            console.log('Runtime serialized successfully');
+        });
+        it.skipIf(testConfig.shouldSkipExpensive())('should serialize Snapshot model to JSON', async () => {
+            if (!testSnapshot) {
+                throw new Error('Test dependency failed: testSnapshot should be available from previous test');
+            }
+            console.log('Testing Snapshot serialization...');
+            const json = await testSnapshot.toJSON();
+            expect(json).toBeDefined();
+            expect(json.uid).toBe(testSnapshot.uid);
+            console.log('Snapshot serialized successfully');
+        });
+    });
+    describe.skipIf(!testConfig.hasToken())('Model error handling', () => {
+        it('should handle API errors gracefully in models', async () => {
+            console.log('Testing model error handling...');
+            // Create a fake notebook with invalid ID
+            const fakeNotebook = new Notebook({ id: 'invalid-id', space_id: 'invalid-space' }, sdk);
+            try {
+                await fakeNotebook.getName();
+                expect(true).toBe(false); // Should not reach here
+            }
+            catch (error) {
+                expect(error).toBeDefined();
+                console.log('Model correctly propagates API errors');
+            }
+        });
+        it('should validate model operations', async () => {
+            if (!testNotebook) {
+                throw new Error('Test dependency failed: testNotebook should be available from previous test');
+            }
+            console.log('Testing model validation...');
+            try {
+                // Try to update with invalid data
+                await testNotebook.update({});
+                // This might succeed with empty update, which is okay
+                console.log('Empty update handled');
+            }
+            catch (error) {
+                console.log('Invalid update rejected');
+            }
+        });
+        it('should handle concurrent model operations', async () => {
+            if (!testNotebook) {
+                throw new Error('Test dependency failed: testNotebook should be available from previous test');
+            }
+            console.log('Testing concurrent model operations...');
+            // Make multiple concurrent requests
+            const promises = [
+                testNotebook.getName(),
+                testNotebook.getContent(),
+                testNotebook.getUpdatedAt(),
+            ];
+            const results = await Promise.all(promises);
+            expect(results[0]).toBeDefined(); // name
+            expect(results[1]).toBeDefined(); // content
+            expect(results[2]).toBeInstanceOf(Date); // updatedAt
+            console.log('Concurrent operations completed successfully');
+        });
+    });
+    describe.skipIf(!testConfig.hasToken())('Model lifecycle', () => {
+        it('should support full model lifecycle', async () => {
+            // Ensure we have a space
+            if (!testSpace) {
+                const spaces = await sdk.getMySpaces();
+                expect(spaces.length).toBeGreaterThan(0);
+                testSpace = spaces[0];
+            }
+            console.log('Testing full model lifecycle...');
+            // 1. Create
+            const notebook = await sdk.createNotebook({
+                spaceId: testSpace.uid,
+                notebookType: 'jupyter',
+                name: 'lifecycle-test-' + Date.now(),
+                description: 'Lifecycle test notebook',
+            });
+            expect(notebook).toBeInstanceOf(Notebook);
+            console.log('1. Created notebook');
+            // 2. Read
+            const retrieved = await sdk.getNotebook(notebook.uid);
+            expect(retrieved.id).toBe(notebook.id);
+            console.log('2. Retrieved notebook');
+            // 3. Use methods to access properties
+            const name = await notebook.getName();
+            expect(name).toBeDefined();
+            const content = await notebook.getContent();
+            expect(content).toBeDefined();
+            console.log('3. Used notebook methods');
+            // 4. Delete
+            await notebook.delete();
+            expect(notebook.isDeleted).toBe(true);
+            console.log('4. Deleted notebook');
+            // 5. Verify deletion
+            try {
+                await notebook.getName();
+                expect(true).toBe(false);
+            }
+            catch (error) {
+                expect(error.message).toContain('deleted');
+                console.log('5. Verified deletion state');
+            }
+        });
+    });
+});

package/lib/sdk/client/__tests__/sdk.runtimes.integration.test.d.ts

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

package/lib/sdk/client/__tests__/sdk.runtimes.integration.test.js

@@ -0,0 +1,276 @@
+/*
+ * Copyright (c) 2023-2025 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+import { describe, it, expect, beforeAll, afterAll } from 'vitest';
+import { DatalayerSDK } from '..';
+import { Runtime } from '../models/Runtime';
+import { Snapshot } from '../models/Snapshot';
+import { testConfig } from '../../../__tests__/shared/test-config';
+import { DEFAULT_SERVICE_URLS } from '../../../api/constants';
+import { performCleanup } from '../../../__tests__/shared/cleanup-shared';
+/**
+ * SDK Runtimes Integration Tests
+ *
+ * Tests runtime and snapshot lifecycle management
+ * using the SDK client and model classes.
+ */
+describe('SDK Runtimes Integration Tests', () => {
+    let sdk;
+    let createdRuntime = null;
+    let createdSnapshot = null;
+    beforeAll(async () => {
+        if (!testConfig.hasToken()) {
+            return;
+        }
+        await performCleanup('setup');
+        sdk = new DatalayerSDK({
+            token: testConfig.getToken(),
+            iamRunUrl: DEFAULT_SERVICE_URLS.IAM,
+            runtimesRunUrl: DEFAULT_SERVICE_URLS.RUNTIMES,
+            spacerRunUrl: DEFAULT_SERVICE_URLS.SPACER,
+        });
+    });
+    afterAll(async () => {
+        if (!testConfig.hasToken()) {
+            return;
+        }
+        await performCleanup('teardown');
+    }, 30000);
+    describe.skipIf(!testConfig.hasToken())('Environment management', () => {
+        it('should list available environments', async () => {
+            console.log('Testing list environments...');
+            const environments = await sdk.listEnvironments();
+            expect(environments).toBeDefined();
+            expect(Array.isArray(environments)).toBe(true);
+            expect(environments.length).toBeGreaterThan(0);
+            const firstEnv = environments[0];
+            expect(firstEnv.name).toBeDefined();
+            expect(firstEnv.title).toBeDefined();
+            expect(firstEnv.language).toBeDefined();
+            console.log(`Found ${environments.length} environment(s)`);
+            console.log(`First environment: ${firstEnv.title} (${firstEnv.name})`);
+            console.log(`  Language: ${firstEnv.language}`);
+            console.log(`  Resources: CPU ${firstEnv.resources?.cpu}, Memory ${firstEnv.resources?.memory}`);
+        });
+    });
+    describe.skipIf(!testConfig.hasToken() || testConfig.shouldSkipExpensive())('Runtime lifecycle', () => {
+        it('should create a runtime', async () => {
+            console.log('Creating runtime...');
+            const runtime = await sdk.createRuntime({
+                environment_name: 'python-cpu-env',
+                type: 'notebook',
+                given_name: 'sdk-test-runtime',
+                credits_limit: 10,
+            });
+            expect(runtime).toBeInstanceOf(Runtime);
+            expect(runtime.podName).toBeDefined();
+            expect(runtime.environmentName).toBe('python-cpu-env');
+            expect(runtime.givenName).toContain('sdk-test-runtime');
+            createdRuntime = runtime;
+            console.log(`Created runtime: ${runtime.podName}`);
+            console.log(`  Given name: ${runtime.givenName}`);
+            console.log(`  Environment: ${runtime.environmentName}`);
+        });
+        it('should list runtimes and find created runtime', async () => {
+            if (!createdRuntime) {
+                throw new Error('Test dependency failed: createdRuntime should be available from previous test');
+            }
+            console.log('Listing runtimes...');
+            const runtimes = await sdk.listRuntimes();
+            expect(Array.isArray(runtimes)).toBe(true);
+            const found = runtimes.find(r => r.podName === createdRuntime.podName);
+            expect(found).toBeDefined();
+            expect(found).toBeInstanceOf(Runtime);
+            console.log(`Found ${runtimes.length} runtime(s)`);
+            console.log(`Created runtime found in list: ${found.podName}`);
+        });
+        it('should get runtime details', async () => {
+            if (!createdRuntime) {
+                throw new Error('Test dependency failed: createdRuntime should be available from previous test');
+            }
+            console.log('Getting runtime details...');
+            const runtime = await sdk.getRuntime(createdRuntime.podName);
+            expect(runtime).toBeInstanceOf(Runtime);
+            expect(runtime.podName).toBe(createdRuntime.podName);
+            expect(runtime.environmentName).toBe(createdRuntime.environmentName);
+            console.log(`Retrieved runtime: ${runtime.podName}`);
+            console.log(`  State: ${await runtime.getState()}`);
+            console.log(`  Running: ${await runtime.isRunning()}`);
+        });
+        it('should test runtime model methods', async () => {
+            if (!createdRuntime) {
+                throw new Error('Test dependency failed: createdRuntime should be available from previous test');
+            }
+            console.log('Testing runtime model methods...');
+            // Test state checking methods
+            const state = await createdRuntime.getState();
+            expect(state).toBeDefined();
+            console.log(`Runtime state: ${state}`);
+            const isRunning = await createdRuntime.isRunning();
+            expect(typeof isRunning).toBe('boolean');
+            console.log(`Is running: ${isRunning}`);
+            const hasError = await createdRuntime.hasError();
+            expect(typeof hasError).toBe('boolean');
+            console.log(`Has error: ${hasError}`);
+            // Test JSON export
+            const json = await createdRuntime.toJSON();
+            expect(json).toBeDefined();
+            expect(json.pod_name).toBe(createdRuntime.podName);
+            // Test toString
+            const str = createdRuntime.toString();
+            expect(str).toContain('Runtime');
+            expect(str).toContain(createdRuntime.podName);
+            console.log(`Runtime string: ${str}`);
+        });
+    });
+    describe.skipIf(!testConfig.hasToken() || testConfig.shouldSkipExpensive())('Snapshot lifecycle', () => {
+        it('should create a snapshot from runtime', async () => {
+            if (!createdRuntime) {
+                throw new Error('Test dependency failed: createdRuntime should be available from previous test');
+            }
+            console.log('Creating snapshot from runtime...');
+            const snapshot = await createdRuntime.createSnapshot('sdk-test-snapshot', 'Test snapshot from SDK');
+            expect(snapshot).toBeInstanceOf(Snapshot);
+            expect(snapshot.uid).toBeDefined();
+            expect(snapshot.name).toContain('sdk-test-snapshot');
+            createdSnapshot = snapshot;
+            console.log(`Created snapshot: ${snapshot.uid}`);
+            console.log(`  Name: ${snapshot.name}`);
+            console.log(`  Description: ${snapshot.description}`);
+        });
+        it('should list snapshots and find created snapshot', async () => {
+            if (!createdSnapshot) {
+                throw new Error('Test dependency failed: createdSnapshot should be available from previous test');
+            }
+            console.log('Listing snapshots...');
+            const snapshots = await sdk.listSnapshots();
+            expect(Array.isArray(snapshots)).toBe(true);
+            const found = snapshots.find(s => s.uid === createdSnapshot.uid);
+            expect(found).toBeDefined();
+            expect(found).toBeInstanceOf(Snapshot);
+            console.log(`Found ${snapshots.length} snapshot(s)`);
+            console.log(`Created snapshot found in list: ${found.uid}`);
+        });
+        it('should get snapshot details', async () => {
+            if (!createdSnapshot) {
+                throw new Error('Test dependency failed: createdSnapshot should be available from previous test');
+            }
+            console.log('Getting snapshot details...');
+            const snapshot = await sdk.getSnapshot(createdSnapshot.uid);
+            expect(snapshot).toBeInstanceOf(Snapshot);
+            expect(snapshot.uid).toBe(createdSnapshot.uid);
+            expect(snapshot.environment).toBe(createdSnapshot.environment);
+            console.log(`Retrieved snapshot: ${snapshot.uid}`);
+            const status = await snapshot.getStatus();
+            console.log(`  Status: ${status}`);
+            const size = await snapshot.getSize();
+            console.log(`  Size: ${size} bytes`);
+        });
+        it('should test snapshot model methods', async () => {
+            if (!createdSnapshot) {
+                throw new Error('Test dependency failed: createdSnapshot should be available from previous test');
+            }
+            console.log('Testing snapshot model methods...');
+            // Test status method
+            const status = await createdSnapshot.getStatus();
+            expect(status).toBeDefined();
+            console.log(`Snapshot status: ${status}`);
+            // Test size method
+            const size = await createdSnapshot.getSize();
+            expect(typeof size).toBe('number');
+            console.log(`Snapshot size: ${size} bytes`);
+            // Test metadata method
+            const metadata = await createdSnapshot.getLatestMetadata();
+            expect(metadata).toBeDefined();
+            console.log(`Metadata keys: ${Object.keys(metadata).join(', ')}`);
+            // Test JSON export
+            const json = await createdSnapshot.toJSON();
+            expect(json).toBeDefined();
+            expect(json.uid).toBe(createdSnapshot.uid);
+            // Test toString
+            const str = createdSnapshot.toString();
+            expect(str).toContain('Snapshot');
+            expect(str).toContain(createdSnapshot.uid);
+            console.log(`Snapshot string: ${str}`);
+        });
+        it('should delete snapshot', async () => {
+            if (!createdSnapshot) {
+                throw new Error('Test dependency failed: createdSnapshot should be available from previous test');
+            }
+            console.log('Deleting snapshot...');
+            const snapshotUid = createdSnapshot.uid; // Get uid before deletion
+            await sdk.deleteSnapshot(createdSnapshot);
+            console.log(`Snapshot ${snapshotUid} deleted`);
+            // Verify deletion
+            try {
+                await createdSnapshot.getStatus();
+                expect(true).toBe(false); // Should not reach here
+            }
+            catch (error) {
+                expect(error.message).toContain('deleted');
+                console.log('Snapshot correctly marked as deleted');
+            }
+            createdSnapshot = null; // Clear reference as it's deleted
+        });
+    });
+    describe.skipIf(!testConfig.hasToken() || testConfig.shouldSkipExpensive())('Runtime deletion', () => {
+        it('should delete runtime', async () => {
+            if (!createdRuntime) {
+                throw new Error('Test dependency failed: createdRuntime should be available from previous test');
+            }
+            console.log('Deleting runtime...');
+            const podName = createdRuntime.podName; // Get podName before deletion
+            await sdk.deleteRuntime(createdRuntime);
+            console.log(`Runtime ${podName} deleted`);
+            // Verify deletion
+            try {
+                await createdRuntime.getState();
+                expect(true).toBe(false); // Should not reach here
+            }
+            catch (error) {
+                expect(error.message).toContain('deleted');
+                console.log('Runtime correctly marked as deleted');
+            }
+            createdRuntime = null; // Clear reference as it's deleted
+        });
+    });
+    describe.skipIf(!testConfig.hasToken())('Error handling', () => {
+        it('should handle non-existent runtime gracefully', async () => {
+            console.log('Testing non-existent runtime...');
+            try {
+                await sdk.getRuntime('non-existent-pod-name');
+                expect(true).toBe(false); // Should not reach here
+            }
+            catch (error) {
+                expect(error).toBeDefined();
+                console.log('Non-existent runtime error handled correctly');
+            }
+        });
+        it('should handle non-existent snapshot gracefully', async () => {
+            console.log('Testing non-existent snapshot...');
+            try {
+                await sdk.getSnapshot('non-existent-snapshot-uid');
+                expect(true).toBe(false); // Should not reach here
+            }
+            catch (error) {
+                expect(error).toBeDefined();
+                console.log('Non-existent snapshot error handled correctly');
+            }
+        });
+        it('should validate runtime creation parameters', async () => {
+            console.log('Testing invalid runtime creation...');
+            try {
+                await sdk.createRuntime({
+                    environment_name: '', // Invalid
+                    type: 'notebook',
+                });
+                expect(true).toBe(false); // Should not reach here
+            }
+            catch (error) {
+                expect(error).toBeDefined();
+                console.log('Invalid runtime parameters rejected');
+            }
+        });
+    });
+});

package/lib/sdk/client/__tests__/sdk.spacer.integration.test.d.ts

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