@datalayer/core 0.0.10 → 0.0.11

package/lib/__tests__/shared/cleanup-shared.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Shared cleanup logic for both setup and teardown
+ */
+export declare function performCleanup(phase: 'setup' | 'teardown'): Promise<void>;

package/lib/__tests__/shared/cleanup-shared.js

@@ -0,0 +1,228 @@
+/*
+ * Copyright (c) 2023-2025 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+import { snapshots, runtimes } from '../../api/runtimes';
+import { users, items } from '../../api/spacer';
+import { testConfig } from './test-config';
+/**
+ * Shared cleanup logic for both setup and teardown
+ */
+export async function performCleanup(phase) {
+    const phaseLabel = phase === 'setup' ? 'PRE-TEST' : 'POST-TEST';
+    console.log('='.repeat(60));
+    console.log(`${phaseLabel} CLEANUP: Starting ${phase === 'setup' ? 'pre' : 'post'}-test cleanup...`);
+    console.log('='.repeat(60));
+    // Check if we have a token
+    if (!testConfig.hasToken()) {
+        console.log('WARNING: No Datalayer API token configured - skipping cleanup');
+        return;
+    }
+    const DATALAYER_TOKEN = testConfig.getToken();
+    const RUNTIMES_BASE_URL = testConfig.getBaseUrl('RUNTIMES');
+    const SPACER_BASE_URL = testConfig.getBaseUrl('SPACER');
+    // Clean up runtimes
+    await cleanupRuntimes(DATALAYER_TOKEN, RUNTIMES_BASE_URL, phaseLabel);
+    // Clean up test snapshots
+    await cleanupTestSnapshots(DATALAYER_TOKEN, RUNTIMES_BASE_URL, phaseLabel);
+    // Clean up ALL spacer items (notebooks, lexicals, etc.)
+    await cleanupSpacerItems(DATALAYER_TOKEN, SPACER_BASE_URL, phaseLabel);
+    // Final verification (only for teardown)
+    if (phase === 'teardown') {
+        await verifyFinalState(DATALAYER_TOKEN, RUNTIMES_BASE_URL, SPACER_BASE_URL);
+    }
+    console.log('='.repeat(60));
+    console.log(`${phaseLabel} CLEANUP: ${phase === 'setup' ? 'Pre' : 'Post'}-test cleanup completed`);
+    console.log('='.repeat(60));
+}
+async function cleanupRuntimes(token, baseUrl, phaseLabel) {
+    try {
+        console.log(`Cleaning up ${phaseLabel === 'PRE-TEST' ? 'existing' : 'test'} runtimes...`);
+        const runtimesResponse = await runtimes.listRuntimes(token, baseUrl);
+        if (!runtimesResponse.runtimes || runtimesResponse.runtimes.length === 0) {
+            console.log('✓ No runtimes to clean up');
+            return;
+        }
+        console.log(`Found ${runtimesResponse.runtimes.length} runtime(s) to clean up`);
+        let removedCount = 0;
+        let failedCount = 0;
+        for (const runtime of runtimesResponse.runtimes) {
+            try {
+                await runtimes.deleteRuntime(token, runtime.pod_name, baseUrl);
+                console.log(`  ✓ Removed runtime: ${runtime.pod_name}`);
+                removedCount++;
+            }
+            catch (error) {
+                console.log(`  ✗ Failed to remove runtime ${runtime.pod_name}: ${error.message}`);
+                failedCount++;
+            }
+        }
+        if (removedCount > 0 || failedCount > 0) {
+            console.log(`Runtime cleanup summary: ${removedCount} removed, ${failedCount} failed`);
+        }
+    }
+    catch (error) {
+        console.error('Error cleaning up runtimes:', error.message);
+    }
+}
+async function cleanupTestSnapshots(token, baseUrl, phaseLabel) {
+    try {
+        console.log(`Cleaning up ALL snapshots${phaseLabel === 'POST-TEST' ? ' created during tests' : ''}...`);
+        const snapshotsResponse = await snapshots.listSnapshots(token, baseUrl);
+        if (!snapshotsResponse.snapshots ||
+            snapshotsResponse.snapshots.length === 0) {
+            console.log('✓ No snapshots found');
+            return;
+        }
+        // Filter out already deleted snapshots
+        const allSnapshots = snapshotsResponse.snapshots.filter(s => s.status !== 'deleted');
+        if (allSnapshots.length === 0) {
+            const deletedCount = snapshotsResponse.snapshots.filter(s => s.status === 'deleted').length;
+            if (deletedCount > 0) {
+                console.log(`Found ${deletedCount} already deleted snapshot(s), skipping`);
+            }
+            console.log('✓ No active snapshots to clean up');
+            return;
+        }
+        console.log(`Found ${allSnapshots.length} active snapshot(s) to clean up`);
+        let removedCount = 0;
+        let skippedCount = 0;
+        let failedCount = 0;
+        for (const snapshot of allSnapshots) {
+            try {
+                console.log(`  Attempting to delete: ${snapshot.name} (uid: ${snapshot.uid}, status: ${snapshot.status})`);
+                await snapshots.deleteSnapshot(token, snapshot.uid, baseUrl);
+                console.log(`  ✓ Removed snapshot: ${snapshot.name}`);
+                removedCount++;
+            }
+            catch (error) {
+                if (error.message?.includes('404') ||
+                    error.message?.includes('not found')) {
+                    console.log(`  - Already removed: ${snapshot.name}`);
+                    skippedCount++;
+                }
+                else {
+                    console.log(`  ✗ Failed to remove snapshot ${snapshot.name}: ${error.message}`);
+                    failedCount++;
+                }
+            }
+        }
+        if (removedCount > 0 || skippedCount > 0 || failedCount > 0) {
+            console.log(`Snapshot cleanup summary: ${removedCount} removed, ${skippedCount} skipped, ${failedCount} failed`);
+            // Verify snapshots are actually deleted
+            console.log('Verifying snapshot deletion...');
+            const verifyResponse = await snapshots.listSnapshots(token, baseUrl);
+            const remainingCount = verifyResponse.snapshots?.length || 0;
+            console.log(`  Remaining snapshots after cleanup: ${remainingCount}`);
+            if (remainingCount > 0 && verifyResponse.snapshots) {
+                console.log('  Still present:');
+                for (const snap of verifyResponse.snapshots.slice(0, 5)) {
+                    console.log(`    - ${snap.name} (uid: ${snap.uid}, status: ${snap.status})`);
+                }
+                if (verifyResponse.snapshots.length > 5) {
+                    console.log(`    ... and ${verifyResponse.snapshots.length - 5} more`);
+                }
+            }
+        }
+    }
+    catch (error) {
+        console.error('Error cleaning up snapshots:', error.message);
+    }
+}
+async function cleanupSpacerItems(token, baseUrl, phaseLabel) {
+    try {
+        console.log(`Cleaning up ALL spacer items${phaseLabel === 'POST-TEST' ? ' (complete cleanup)' : ''}...`);
+        // Get user spaces
+        const spacesResponse = await users.getMySpaces(token, baseUrl);
+        if (!spacesResponse.spaces || spacesResponse.spaces.length === 0) {
+            console.log('✓ No spaces found');
+            return;
+        }
+        console.log(`Found ${spacesResponse.spaces.length} space(s)`);
+        let totalRemovedCount = 0;
+        let totalFailedCount = 0;
+        // Go through each space and clean up test items
+        for (const space of spacesResponse.spaces) {
+            try {
+                const itemsResponse = await items.getSpaceItems(token, space.uid, baseUrl);
+                if (!itemsResponse.items || itemsResponse.items.length === 0) {
+                    continue;
+                }
+                const spaceName = space.name || space.name_t || 'Unknown Space';
+                console.log(`  Space "${spaceName}": Found ${itemsResponse.items.length} item(s) to clean up`);
+                for (const item of itemsResponse.items) {
+                    try {
+                        // API returns uid field but TypeScript interface doesn't include it
+                        await items.deleteItem(token, item.uid, baseUrl);
+                        console.log(`    ✓ Removed item: ${item.name || item.name_t}`);
+                        totalRemovedCount++;
+                    }
+                    catch (error) {
+                        console.log(`    ✗ Failed to remove item ${item.name || item.name_t}: ${error.message}`);
+                        totalFailedCount++;
+                    }
+                }
+            }
+            catch (error) {
+                const spaceName = space.name || space.name_t || 'Unknown Space';
+                console.log(`  Error processing space ${spaceName}: ${error.message}`);
+            }
+        }
+        if (totalRemovedCount > 0 || totalFailedCount > 0) {
+            console.log(`Spacer items cleanup summary: ${totalRemovedCount} removed, ${totalFailedCount} failed`);
+        }
+        else {
+            console.log('✓ No spacer items to clean up');
+        }
+    }
+    catch (error) {
+        console.error('Error cleaning up spacer items:', error.message);
+    }
+}
+async function verifyFinalState(token, runtimesBaseUrl, spacerBaseUrl) {
+    try {
+        const finalRuntimes = await runtimes.listRuntimes(token, runtimesBaseUrl);
+        const finalSnapshots = await snapshots.listSnapshots(token, runtimesBaseUrl);
+        const remainingRuntimes = finalRuntimes.runtimes?.length || 0;
+        const remainingSnapshots = (finalSnapshots.snapshots || []).filter(s => s.status !== 'deleted').length;
+        // Count spacer test items
+        let remainingTestItems = 0;
+        try {
+            const spacesResponse = await users.getMySpaces(token, spacerBaseUrl);
+            if (spacesResponse.spaces) {
+                for (const space of spacesResponse.spaces) {
+                    try {
+                        const itemsResponse = await items.getSpaceItems(token, space.uid, spacerBaseUrl);
+                        if (itemsResponse.items) {
+                            remainingTestItems += itemsResponse.items.length;
+                        }
+                    }
+                    catch (error) {
+                        // Ignore errors for individual spaces
+                    }
+                }
+            }
+        }
+        catch (error) {
+            // Ignore errors
+        }
+        console.log('-'.repeat(60));
+        console.log('Final state after all tests:');
+        console.log(`  - Remaining runtimes: ${remainingRuntimes}`);
+        console.log(`  - Remaining active snapshots: ${remainingSnapshots}`);
+        console.log(`  - Total snapshots: ${finalSnapshots.snapshots?.length || 0}`);
+        console.log(`  - Remaining spacer items: ${remainingTestItems}`);
+        if (remainingRuntimes > 0) {
+            console.log(`\nNOTE: ${remainingRuntimes} runtime(s) still active. These may require manual cleanup.`);
+        }
+        if (remainingSnapshots > 0) {
+            console.log(`\nNOTE: ${remainingSnapshots} snapshot(s) still active. These may require manual cleanup.`);
+        }
+        if (remainingTestItems > 0) {
+            console.log(`\nNOTE: ${remainingTestItems} spacer item(s) still active. These may require manual cleanup.`);
+        }
+    }
+    catch (error) {
+        console.error('Error during final verification:', error.message);
+    }
+}

package/lib/__tests__/shared/test-config.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Test configuration object with proper fallbacks
+ */
+export declare const testConfig: {
+    /**
+     * Check if we have a token available
+     */
+    hasToken(): boolean;
+    /**
+     * Get the Datalayer API token for testing
+     * Priority order:
+     * 1. DATALAYER_TEST_TOKEN environment variable
+     * 2. DATALAYER_API_TOKEN environment variable
+     * 3. VITE_DATALAYER_API_TOKEN environment variable
+     * 4. Throw error if not found
+     */
+    getToken(): string;
+    /**
+     * Get the base URL for testing
+     * Uses DEFAULT_SERVICE_URLS or can be overridden via environment
+     */
+    getBaseUrl(service?: "IAM" | "RUNTIMES" | "SPACER"): string;
+    /**
+     * Check if expensive tests should be skipped
+     * Default is false (run expensive tests) unless explicitly set to 'true'
+     */
+    shouldSkipExpensive(): boolean;
+    /**
+     * Get test environment names for runtime creation
+     */
+    getTestEnvironments(): {
+        python: string;
+        ai: string;
+    };
+    /**
+     * Check if debug output is enabled
+     */
+    isDebugEnabled(): boolean;
+    /**
+     * Get custom timeout for API calls (in milliseconds)
+     */
+    getTimeout(): number;
+};
+/**
+ * Helper function to skip tests if no token is available
+ */
+export declare const skipIfNoToken: () => boolean;
+/**
+ * Log debug information if debug is enabled
+ */
+export declare const debugLog: (...args: any[]) => void;

package/lib/__tests__/shared/test-config.js

@@ -0,0 +1,110 @@
+/*
+ * Copyright (c) 2023-2025 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+import * as dotenv from 'dotenv';
+import * as path from 'path';
+import { DEFAULT_SERVICE_URLS } from '../../api/constants';
+/**
+ * Load test environment configuration
+ * Loads from .env.test file and falls back to environment variables
+ */
+const loadTestConfig = () => {
+    // Load .env.test file from project root
+    const testEnvPath = path.resolve(process.cwd(), '.env.test');
+    dotenv.config({ path: testEnvPath });
+    // Also load regular .env as fallback
+    dotenv.config();
+};
+// Load config immediately when module is imported
+loadTestConfig();
+/**
+ * Test configuration object with proper fallbacks
+ */
+export const testConfig = {
+    /**
+     * Check if we have a token available
+     */
+    hasToken() {
+        return !!(process.env.DATALAYER_TEST_TOKEN ||
+            process.env.DATALAYER_API_TOKEN ||
+            process.env.VITE_DATALAYER_API_TOKEN);
+    },
+    /**
+     * Get the Datalayer API token for testing
+     * Priority order:
+     * 1. DATALAYER_TEST_TOKEN environment variable
+     * 2. DATALAYER_API_TOKEN environment variable
+     * 3. VITE_DATALAYER_API_TOKEN environment variable
+     * 4. Throw error if not found
+     */
+    getToken() {
+        const token = process.env.DATALAYER_TEST_TOKEN ||
+            process.env.DATALAYER_API_TOKEN ||
+            process.env.VITE_DATALAYER_API_TOKEN;
+        if (!token) {
+            throw new Error('No Datalayer API token found. Please set DATALAYER_TEST_TOKEN, DATALAYER_API_TOKEN, or VITE_DATALAYER_API_TOKEN environment variable');
+        }
+        return token;
+    },
+    /**
+     * Get the base URL for testing
+     * Uses DEFAULT_SERVICE_URLS or can be overridden via environment
+     */
+    getBaseUrl(service = 'IAM') {
+        const envBaseUrl = process.env.DATALAYER_TEST_BASE_URL;
+        if (envBaseUrl) {
+            return envBaseUrl;
+        }
+        return DEFAULT_SERVICE_URLS[service];
+    },
+    /**
+     * Check if expensive tests should be skipped
+     * Default is false (run expensive tests) unless explicitly set to 'true'
+     */
+    shouldSkipExpensive() {
+        return process.env.DATALAYER_TEST_SKIP_EXPENSIVE === 'true';
+    },
+    /**
+     * Get test environment names for runtime creation
+     */
+    getTestEnvironments() {
+        return {
+            python: process.env.DATALAYER_TEST_PYTHON_ENV || 'python-cpu-env',
+            ai: process.env.DATALAYER_TEST_AI_ENV || 'ai-env',
+        };
+    },
+    /**
+     * Check if debug output is enabled
+     */
+    isDebugEnabled() {
+        return process.env.DATALAYER_TEST_DEBUG === 'true';
+    },
+    /**
+     * Get custom timeout for API calls (in milliseconds)
+     */
+    getTimeout() {
+        const timeout = process.env.DATALAYER_TEST_TIMEOUT;
+        return timeout ? parseInt(timeout, 10) : 60000; // Default 60 seconds
+    },
+};
+/**
+ * Helper function to skip tests if no token is available
+ */
+export const skipIfNoToken = () => {
+    try {
+        testConfig.getToken();
+        return false;
+    }
+    catch {
+        return true;
+    }
+};
+/**
+ * Log debug information if debug is enabled
+ */
+export const debugLog = (...args) => {
+    if (testConfig.isDebugEnabled()) {
+        console.log('[DEBUG]', ...args);
+    }
+};

package/lib/__tests__/shared/test-constants.d.ts

@@ -0,0 +1,66 @@
+/**
+ * Test constants for API unit tests
+ */
+/**
+ * A valid mock JWT token for testing
+ * This token has the correct JWT structure (header.payload.signature) but is not cryptographically valid
+ *
+ * Decoded header: {"alg":"HS256","typ":"JWT"}
+ * Decoded payload: {"sub":"test-user","iss":"test-issuer","iat":1700000000,"exp":9999999999,"aud":"test-audience"}
+ *
+ * The token is constructed to:
+ * - Have three parts separated by dots
+ * - Have valid base64url encoded parts
+ * - Have proper JWT header with alg and typ
+ * - Have common JWT claims in payload
+ * - Have an expiration far in the future to avoid expiration errors
+ * - Be long enough to pass length validation (>100 chars)
+ */
+export declare const MOCK_JWT_TOKEN = "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiJ0ZXN0LXVzZXIiLCJpc3MiOiJ0ZXN0LWlzc3VlciIsImlhdCI6MTcwMDAwMDAwMCwiZXhwIjo5OTk5OTk5OTk5LCJhdWQiOiJ0ZXN0LWF1ZGllbmNlIn0.abcdefghijklmnopqrstuvwxyz012345678901234567890";
+/**
+ * An invalid token (not JWT format) for negative testing
+ */
+export declare const INVALID_TOKEN = "invalid-token";
+/**
+ * A malformed JWT token (only two parts instead of three)
+ */
+export declare const MALFORMED_JWT_TOKEN = "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiJ0ZXN0LXVzZXIifQ";
+/**
+ * A JWT token with an expired timestamp
+ * Decoded payload: {"sub":"test-user","exp":1000000000}
+ */
+export declare const EXPIRED_JWT_TOKEN = "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiJ0ZXN0LXVzZXIiLCJleHAiOjEwMDAwMDAwMDB9.abcdefghijklmnopqrstuvwxyz012345678901234567890";
+/**
+ * Mock API responses
+ */
+export declare const MOCK_ENVIRONMENTS_RESPONSE: {
+    success: boolean;
+    message: string;
+    environments: {
+        title: string;
+        description: string;
+        dockerImage: string;
+        language: string;
+        burning_rate: number;
+    }[];
+};
+export declare const MOCK_RUNTIME_RESPONSE: {
+    success: boolean;
+    message: string;
+    runtime: {
+        pod_name: string;
+        status: string;
+        environment: string;
+        created_at: string;
+    };
+};
+export declare const MOCK_SNAPSHOT_RESPONSE: {
+    success: boolean;
+    message: string;
+    snapshot: {
+        id: string;
+        name: string;
+        created_at: string;
+        size: number;
+    };
+};

package/lib/__tests__/shared/test-constants.js

@@ -0,0 +1,79 @@
+/*
+ * Copyright (c) 2023-2025 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+/**
+ * Test constants for API unit tests
+ */
+/**
+ * A valid mock JWT token for testing
+ * This token has the correct JWT structure (header.payload.signature) but is not cryptographically valid
+ *
+ * Decoded header: {"alg":"HS256","typ":"JWT"}
+ * Decoded payload: {"sub":"test-user","iss":"test-issuer","iat":1700000000,"exp":9999999999,"aud":"test-audience"}
+ *
+ * The token is constructed to:
+ * - Have three parts separated by dots
+ * - Have valid base64url encoded parts
+ * - Have proper JWT header with alg and typ
+ * - Have common JWT claims in payload
+ * - Have an expiration far in the future to avoid expiration errors
+ * - Be long enough to pass length validation (>100 chars)
+ */
+export const MOCK_JWT_TOKEN = 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiJ0ZXN0LXVzZXIiLCJpc3MiOiJ0ZXN0LWlzc3VlciIsImlhdCI6MTcwMDAwMDAwMCwiZXhwIjo5OTk5OTk5OTk5LCJhdWQiOiJ0ZXN0LWF1ZGllbmNlIn0.abcdefghijklmnopqrstuvwxyz012345678901234567890';
+/**
+ * An invalid token (not JWT format) for negative testing
+ */
+export const INVALID_TOKEN = 'invalid-token';
+/**
+ * A malformed JWT token (only two parts instead of three)
+ */
+export const MALFORMED_JWT_TOKEN = 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiJ0ZXN0LXVzZXIifQ';
+/**
+ * A JWT token with an expired timestamp
+ * Decoded payload: {"sub":"test-user","exp":1000000000}
+ */
+export const EXPIRED_JWT_TOKEN = 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiJ0ZXN0LXVzZXIiLCJleHAiOjEwMDAwMDAwMDB9.abcdefghijklmnopqrstuvwxyz012345678901234567890';
+/**
+ * Mock API responses
+ */
+export const MOCK_ENVIRONMENTS_RESPONSE = {
+    success: true,
+    message: 'Environments retrieved successfully',
+    environments: [
+        {
+            title: 'Python Base',
+            description: 'Basic Python environment',
+            dockerImage: 'python:3.9',
+            language: 'python',
+            burning_rate: 1,
+        },
+        {
+            title: 'R Statistical',
+            description: 'R environment for statistical computing',
+            dockerImage: 'r-base:4.3',
+            language: 'r',
+            burning_rate: 2,
+        },
+    ],
+};
+export const MOCK_RUNTIME_RESPONSE = {
+    success: true,
+    message: 'Runtime retrieved successfully',
+    runtime: {
+        pod_name: 'test-runtime-pod',
+        status: 'running',
+        environment: 'python-base',
+        created_at: '2024-01-01T00:00:00Z',
+    },
+};
+export const MOCK_SNAPSHOT_RESPONSE = {
+    success: true,
+    message: 'Snapshot retrieved successfully',
+    snapshot: {
+        id: 'test-snapshot-123',
+        name: 'Test Snapshot',
+        created_at: '2024-01-01T00:00:00Z',
+        size: 1024000,
+    },
+};

package/lib/api/DatalayerApi.d.ts

@@ -56,7 +56,7 @@ export interface IRequestDatalayerAPIOptions {
      */
     method?: string;
     /**
-     * JSON-serializable object
+     * JSON-serializable object or FormData
      */
     body?: any;
     /**