@datalayer/core 0.0.12 → 0.0.13

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

@@ -1,276 +0,0 @@
-/*
- * 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

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

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

@@ -1,361 +0,0 @@
-/*
- * 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 { Space } from '../models/Space';
-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 Spacer Integration Tests
- *
- * Tests workspace, notebook, and lexical document lifecycle
- * using the SDK client and model classes.
- */
-describe('SDK Spacer Integration Tests', () => {
-    let sdk;
-    let testSpace = null;
-    let createdNotebook = null;
-    let createdLexical = 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())('Space management', () => {
-        it('should get user spaces', async () => {
-            console.log('Getting user spaces...');
-            const spaces = await sdk.getMySpaces();
-            expect(spaces).toBeDefined();
-            expect(Array.isArray(spaces)).toBe(true);
-            expect(spaces.length).toBeGreaterThan(0);
-            const firstSpace = spaces[0];
-            expect(firstSpace).toBeInstanceOf(Space);
-            expect(firstSpace.id || firstSpace.uid).toBeDefined();
-            testSpace = firstSpace;
-            console.log(`Found ${spaces.length} space(s)`);
-            const spaceName = await firstSpace.getName();
-            console.log(`Using space: ${spaceName || firstSpace.id || firstSpace.uid}`);
-        });
-        it('should test space model methods', async () => {
-            if (!testSpace) {
-                throw new Error('Test dependency failed: testSpace should be available from previous test');
-            }
-            console.log('Testing space model methods...');
-            // Test getName method (lazy loading)
-            const name = await testSpace.getName();
-            expect(name).toBeDefined();
-            console.log(`Space name: ${name}`);
-            // Test getDescription method
-            const description = await testSpace.getDescription();
-            console.log(`Space description: ${description || 'None'}`);
-            // Test getUpdatedAt method
-            const updatedAt = await testSpace.getUpdatedAt();
-            if (updatedAt) {
-                expect(updatedAt).toBeInstanceOf(Date);
-                console.log(`Space updated at: ${updatedAt.toISOString()}`);
-            }
-            else {
-                console.log('Space has no update timestamp');
-            }
-            // Test getItems method
-            const items = await testSpace.getItems();
-            expect(Array.isArray(items)).toBe(true);
-            console.log(`Space has ${items.length} item(s)`);
-            // Test toJSON method
-            const json = await testSpace.toJSON();
-            expect(json).toBeDefined();
-            expect(json.id || json.uid).toBeDefined();
-            // Test toString
-            const str = testSpace.toString();
-            expect(str).toContain('Space');
-            console.log(`Space string: ${str}`);
-        });
-        // Space creation is not implemented - removed this test
-    });
-    describe.skipIf(!testConfig.hasToken())('Notebook lifecycle', () => {
-        it('should create a notebook', async () => {
-            if (!testSpace) {
-                throw new Error('Test dependency failed: testSpace should be available from previous test');
-            }
-            console.log('Creating notebook...');
-            const notebook = await sdk.createNotebook({
-                spaceId: testSpace.uid,
-                notebookType: 'jupyter',
-                name: 'sdk-test-notebook-' + Date.now(),
-                description: 'Test notebook from SDK',
-            });
-            expect(notebook).toBeInstanceOf(Notebook);
-            expect(notebook.id).toBeDefined();
-            expect(notebook.spaceId).toBe(testSpace.uid);
-            createdNotebook = notebook;
-            console.log(`Created notebook: ${notebook.id}`);
-            console.log(`  Name: ${await notebook.getName()}`);
-            console.log(`  Space: ${notebook.spaceId}`);
-        });
-        it('should get notebook details', async () => {
-            if (!createdNotebook) {
-                throw new Error('Test dependency failed: notebook should be created in previous test');
-            }
-            console.log('Getting notebook details...');
-            const notebook = await sdk.getNotebook(createdNotebook.uid);
-            expect(notebook).toBeInstanceOf(Notebook);
-            expect(notebook.id).toBe(createdNotebook.id);
-            expect(notebook.spaceId).toBe(createdNotebook.spaceId);
-            console.log(`Retrieved notebook: ${notebook.id}`);
-            const notebookName = await notebook.getName();
-            console.log(`  Name: ${notebookName}`);
-        });
-        it('should update notebook', async () => {
-            if (!createdNotebook) {
-                throw new Error('Test dependency failed: notebook should be created in previous test');
-            }
-            console.log('Updating notebook...');
-            const updatedNotebook = await sdk.updateNotebook(createdNotebook, {
-                name: 'sdk-test-notebook-updated',
-                description: 'Updated description from SDK test',
-            });
-            expect(updatedNotebook).toBeInstanceOf(Notebook);
-            expect(updatedNotebook.id).toBe(createdNotebook.id);
-            console.log(`Updated notebook: ${updatedNotebook.id}`);
-            const updatedNotebookName = await updatedNotebook.getName();
-            console.log(`  New name: ${updatedNotebookName}`);
-        });
-        it('should test notebook model methods', async () => {
-            if (!createdNotebook) {
-                throw new Error('Test dependency failed: notebook should be created in previous test');
-            }
-            console.log('Testing notebook model methods...');
-            // Check the raw data structure (debugging removed)
-            const rawData = await createdNotebook.toJSON();
-            expect(rawData).toBeDefined();
-            // Test getName method (lazy loading)
-            const name = await createdNotebook.getName();
-            expect(name).toBeDefined();
-            console.log(`Notebook name: ${name}`);
-            // Test getContent method
-            const content = await createdNotebook.getContent();
-            console.log(`Notebook has content: ${content !== null}`);
-            // Test getKernelSpec method
-            const kernelSpec = await createdNotebook.getKernelSpec();
-            console.log(`Kernel spec: ${kernelSpec ? JSON.stringify(kernelSpec).substring(0, 50) : 'None'}`);
-            // Test getUpdatedAt method
-            const updatedAt = await createdNotebook.getUpdatedAt();
-            expect(updatedAt).toBeInstanceOf(Date);
-            console.log(`Notebook updated at: ${updatedAt.toISOString()}`);
-            // Skip the update test as the notebook was already updated in the previous test
-            // The API doesn't like rapid successive updates
-            console.log('Skipping model update test (notebook already updated)');
-            // Test toJSON method
-            const json = await createdNotebook.toJSON();
-            expect(json).toBeDefined();
-            expect(json.id).toBe(createdNotebook.id);
-            // Test toString
-            const str = createdNotebook.toString();
-            expect(str).toContain('Notebook');
-            expect(str).toContain(createdNotebook.id);
-            console.log(`Notebook string: ${str}`);
-        });
-        it('should delete notebook', async () => {
-            if (!createdNotebook) {
-                throw new Error('Test dependency failed: notebook should be created in previous test');
-            }
-            console.log('Deleting notebook...');
-            await createdNotebook.delete();
-            console.log(`Notebook deleted successfully`);
-            // Verify deletion
-            expect(createdNotebook.isDeleted).toBe(true);
-            try {
-                await createdNotebook.getName();
-                expect(true).toBe(false); // Should not reach here
-            }
-            catch (error) {
-                expect(error.message).toContain('deleted');
-                console.log('Notebook correctly marked as deleted');
-            }
-        });
-    });
-    describe.skipIf(!testConfig.hasToken())('Lexical document lifecycle', () => {
-        it('should create a lexical document', async () => {
-            if (!testSpace) {
-                throw new Error('Test dependency failed: testSpace should be available from previous test');
-            }
-            console.log('Creating lexical document...');
-            const lexical = await sdk.createLexical({
-                spaceId: testSpace.uid,
-                name: 'sdk-test-lexical-' + Date.now(),
-                description: 'Test lexical from SDK',
-                documentType: 'document',
-            });
-            expect(lexical).toBeInstanceOf(Lexical);
-            expect(lexical.id).toBeDefined();
-            expect(lexical.spaceId).toBe(testSpace.uid);
-            createdLexical = lexical;
-            console.log(`Created lexical: ${lexical.id}`);
-            const lexicalName = await lexical.getName();
-            console.log(`  Name: ${lexicalName}`);
-        });
-        it('should get lexical details', async () => {
-            if (!createdLexical) {
-                throw new Error('Test dependency failed: lexical should be created in previous test');
-            }
-            console.log('Getting lexical details...');
-            const lexical = await sdk.getLexical(createdLexical.uid);
-            expect(lexical).toBeInstanceOf(Lexical);
-            expect(lexical.id).toBe(createdLexical.id);
-            expect(lexical.spaceId).toBe(createdLexical.spaceId);
-            console.log(`Retrieved lexical: ${lexical.id}`);
-            const retrievedLexicalName = await lexical.getName();
-            console.log(`  Name: ${retrievedLexicalName}`);
-        });
-        it('should update lexical', async () => {
-            if (!createdLexical) {
-                throw new Error('Test dependency failed: lexical should be created in previous test');
-            }
-            console.log('Updating lexical...');
-            const updatedLexical = await sdk.updateLexical(createdLexical, {
-                name: 'sdk-test-lexical-updated',
-                description: 'Updated description from SDK test',
-            });
-            expect(updatedLexical).toBeInstanceOf(Lexical);
-            expect(updatedLexical.id).toBe(createdLexical.id);
-            console.log(`Updated lexical: ${updatedLexical.id}`);
-            const updatedLexicalName = await updatedLexical.getName();
-            console.log(`  New name: ${updatedLexicalName}`);
-        });
-        it('should test lexical model methods', async () => {
-            if (!createdLexical) {
-                throw new Error('Test dependency failed: lexical should be created in previous test');
-            }
-            console.log('Testing lexical model methods...');
-            // Check the raw data structure (debugging removed)
-            const rawData = await createdLexical.toJSON();
-            expect(rawData).toBeDefined();
-            // Test getName method (lazy loading)
-            const name = await createdLexical.getName();
-            expect(name).toBeDefined();
-            console.log(`Lexical name: ${name}`);
-            // Test getContent method
-            const content = await createdLexical.getContent();
-            console.log(`Lexical has content: ${content !== null}`);
-            // Test getUpdatedAt method
-            const updatedAt = await createdLexical.getUpdatedAt();
-            expect(updatedAt).toBeInstanceOf(Date);
-            console.log(`Lexical updated at: ${updatedAt.toISOString()}`);
-            // Skip the update test as the lexical was already updated in the previous test
-            // The API doesn't like rapid successive updates
-            console.log('Skipping model update test (lexical already updated)');
-            // Test toJSON method
-            const json = await createdLexical.toJSON();
-            expect(json).toBeDefined();
-            expect(json.id).toBe(createdLexical.id);
-            // Test toString
-            const str = createdLexical.toString();
-            expect(str).toContain('Lexical');
-            expect(str).toContain(createdLexical.id);
-            console.log(`Lexical string: ${str}`);
-        });
-        it('should delete lexical document', async () => {
-            if (!createdLexical) {
-                throw new Error('Test dependency failed: lexical should be created in previous test');
-            }
-            console.log('Deleting lexical...');
-            await createdLexical.delete();
-            console.log(`Lexical deleted successfully`);
-            // Verify deletion
-            expect(createdLexical.isDeleted).toBe(true);
-            try {
-                await createdLexical.getName();
-                expect(true).toBe(false); // Should not reach here
-            }
-            catch (error) {
-                expect(error.message).toContain('deleted');
-                console.log('Lexical correctly marked as deleted');
-            }
-        });
-    });
-    describe.skipIf(!testConfig.hasToken())('Space items management', () => {
-        it('should get space items', async () => {
-            if (!testSpace) {
-                throw new Error('Test dependency failed: testSpace should be available from previous test');
-            }
-            console.log('Getting space items...');
-            const response = await sdk.getSpaceItems(testSpace.uid);
-            expect(response).toBeDefined();
-            expect(response.items).toBeDefined();
-            expect(Array.isArray(response.items)).toBe(true);
-            console.log(`Space has ${response.items.length} item(s)`);
-            if (response.items.length > 0) {
-                const firstItem = response.items[0];
-                console.log(`First item: ${firstItem.name} (${firstItem.type})`);
-            }
-        });
-        it('should delete space item', async () => {
-            // Note: We don't actually delete items here as they might be important
-            // This just tests the method exists and can be called
-            console.log('Testing space item deletion (dry run)...');
-            // We would normally create a test item and delete it
-            // For now, just verify the method exists
-            expect(sdk.deleteSpaceItem).toBeDefined();
-            console.log('Space item deletion method verified');
-        });
-    });
-    describe.skipIf(!testConfig.hasToken())('Error handling', () => {
-        it('should handle non-existent notebook gracefully', async () => {
-            console.log('Testing non-existent notebook...');
-            try {
-                await sdk.getNotebook('non-existent-notebook-id');
-                expect(true).toBe(false); // Should not reach here
-            }
-            catch (error) {
-                expect(error).toBeDefined();
-                console.log('Non-existent notebook error handled correctly');
-            }
-        });
-        it('should handle non-existent lexical gracefully', async () => {
-            console.log('Testing non-existent lexical...');
-            try {
-                await sdk.getLexical('non-existent-lexical-id');
-                expect(true).toBe(false); // Should not reach here
-            }
-            catch (error) {
-                expect(error).toBeDefined();
-                console.log('Non-existent lexical error handled correctly');
-            }
-        });
-        it('should validate notebook creation parameters', async () => {
-            console.log('Testing invalid notebook creation...');
-            try {
-                // Missing required fields
-                await sdk.createNotebook({
-                    spaceId: '', // Invalid empty spaceId
-                    notebookType: 'jupyter',
-                    name: 'test',
-                    description: 'test description',
-                });
-                expect(true).toBe(false); // Should not reach here
-            }
-            catch (error) {
-                expect(error).toBeDefined();
-                console.log('Invalid notebook parameters rejected');
-            }
-        });
-    });
-});