@datalayer/core 0.0.12 → 0.0.13

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

@@ -1,79 +0,0 @@
-/*
- * 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/__tests__/utils.test.d.ts

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

package/lib/__tests__/utils.test.js

@@ -1,59 +0,0 @@
-/*
- * Copyright (c) 2023-2025 Datalayer, Inc.
- * Distributed under the terms of the Modified BSD License.
- */
-import { describe, it, expect } from 'vitest';
-import { formatString, addNumbers, isDefined, delay } from '../utils';
-describe('utils', () => {
-    describe('formatString', () => {
-        it('should trim and lowercase strings', () => {
-            expect(formatString('  HELLO WORLD  ')).toBe('hello world');
-        });
-        it('should handle empty strings', () => {
-            expect(formatString('')).toBe('');
-        });
-        it('should handle already formatted strings', () => {
-            expect(formatString('hello')).toBe('hello');
-        });
-    });
-    describe('addNumbers', () => {
-        it('should add positive numbers', () => {
-            expect(addNumbers(2, 3)).toBe(5);
-        });
-        it('should add negative numbers', () => {
-            expect(addNumbers(-2, -3)).toBe(-5);
-        });
-        it('should add zero', () => {
-            expect(addNumbers(5, 0)).toBe(5);
-        });
-        it('should handle decimals', () => {
-            expect(addNumbers(1.5, 2.5)).toBe(4);
-        });
-    });
-    describe('isDefined', () => {
-        it('should return true for defined values', () => {
-            expect(isDefined('hello')).toBe(true);
-            expect(isDefined(0)).toBe(true);
-            expect(isDefined(false)).toBe(true);
-            expect(isDefined([])).toBe(true);
-        });
-        it('should return false for undefined', () => {
-            expect(isDefined(undefined)).toBe(false);
-        });
-        it('should return false for null', () => {
-            expect(isDefined(null)).toBe(false);
-        });
-    });
-    describe('delay', () => {
-        it('should resolve after specified time', async () => {
-            const start = Date.now();
-            await delay(100);
-            const end = Date.now();
-            expect(end - start).toBeGreaterThanOrEqual(90); // Allow some tolerance
-        });
-        it('should return a Promise', () => {
-            const result = delay(1);
-            expect(result).toBeInstanceOf(Promise);
-        });
-    });
-});

package/lib/api/__tests__/iam.authentication.integration.test.d.ts

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

package/lib/api/__tests__/iam.authentication.integration.test.js

@@ -1,247 +0,0 @@
-/*
- * Copyright (c) 2023-2025 Datalayer, Inc.
- * Distributed under the terms of the Modified BSD License.
- */
-import { describe, it, expect, beforeAll } from 'vitest';
-import { authentication } from '../iam';
-import { testConfig, debugLog, skipIfNoToken, } from '../../__tests__/shared/test-config';
-let DATALAYER_TOKEN;
-let SESSION_TOKEN;
-let BASE_URL;
-// Skip all tests if no token is available
-const skipTests = skipIfNoToken();
-beforeAll(async () => {
-    if (skipTests) {
-        console.log('WARNING: Skipping IAM integration tests: No Datalayer API token configured');
-        console.log('         Set DATALAYER_API_TOKEN env var or DATALAYER_TEST_TOKEN in .env.test');
-        return;
-    }
-    // Get token and base URL from test config
-    DATALAYER_TOKEN = testConfig.getToken();
-    BASE_URL = testConfig.getBaseUrl('IAM');
-    debugLog('Test configuration loaded');
-    debugLog('Base URL:', BASE_URL);
-    debugLog('Token available:', !!DATALAYER_TOKEN);
-    // Login to get a session token for testing
-    try {
-        const loginResponse = await authentication.login({
-            token: DATALAYER_TOKEN,
-        }, BASE_URL);
-        SESSION_TOKEN = loginResponse.token;
-        debugLog('Got session token for testing');
-    }
-    catch (error) {
-        console.error('Failed to get session token:', error);
-        // Fall back to using the DATALAYER_TOKEN
-        SESSION_TOKEN = DATALAYER_TOKEN;
-    }
-});
-describe.skipIf(skipTests)('IAM Authentication Integration Tests', () => {
-    describe('login', () => {
-        it('should successfully login with valid token (expecting 201 status)', async () => {
-            console.log('Testing login with valid token (expecting 201 Created)...');
-            // The API should return 201 Created for successful login
-            const response = await authentication.login({
-                token: DATALAYER_TOKEN,
-            }, BASE_URL);
-            console.log('Login response:', JSON.stringify(response, null, 2));
-            // Verify response structure for successful login (201 status)
-            expect(response).toBeDefined();
-            expect(response.success).toBe(true);
-            expect(response.message).toBeDefined();
-            // The message should indicate login success
-            expect(response.message.toLowerCase()).toContain('success');
-            expect(response.token).toBeDefined();
-            expect(typeof response.token).toBe('string');
-            expect(response.user).toBeDefined();
-            expect(response.user.id).toBeDefined();
-            expect(response.user.uid).toBeDefined();
-            expect(response.user.email_s).toBeDefined();
-            expect(response.user.handle_s).toBeDefined();
-            console.log('Token login successful (201 Created expected)');
-            console.log('Success:', response.success);
-            console.log('Message:', response.message);
-            console.log('User ID:', response.user.id);
-            console.log('User UID:', response.user.uid);
-            console.log('User handle:', response.user.handle_s);
-            console.log('User email:', response.user.email_s);
-        });
-        it('should successfully login with valid token using default URL', async () => {
-            console.log('Testing login with valid token using default URL...');
-            const response = await authentication.login({
-                token: DATALAYER_TOKEN,
-            });
-            console.log('Login response with default URL:', JSON.stringify(response, null, 2));
-            // Verify response structure
-            expect(response).toBeDefined();
-            expect(response.success).toBe(true);
-            expect(response.message).toBeDefined();
-            expect(response.token).toBeDefined();
-            expect(typeof response.token).toBe('string');
-            expect(response.user).toBeDefined();
-            expect(response.user.id).toBeDefined();
-            expect(response.user.uid).toBeDefined();
-            expect(response.user.email_s).toBeDefined();
-            expect(response.user.handle_s).toBeDefined();
-            console.log('Token login successful with default URL');
-            console.log('Success:', response.success);
-            console.log('Message:', response.message);
-            console.log('User ID:', response.user.id);
-            console.log('User UID:', response.user.uid);
-            console.log('User handle:', response.user.handle_s);
-            console.log('User email:', response.user.email_s);
-        });
-        it('should fail when providing invalid token (expecting 401 status)', async () => {
-            console.log('Testing login with invalid token (expecting 401 Unauthorized)...');
-            const invalidToken = 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiJpbnZhbGlkIiwiaWF0IjoxNTE2MjM5MDIyfQ.invalid_signature_here';
-            try {
-                const response = await authentication.login({
-                    token: invalidToken,
-                }, BASE_URL);
-                console.log('Response for invalid token:', JSON.stringify(response, null, 2));
-                // If we get a response without error, check if it indicates failure
-                if (response.success === false) {
-                    console.log('Login failed as expected (success: false)');
-                    expect(response.success).toBe(false);
-                    expect(response.message).toBeDefined();
-                    expect(response.message.toLowerCase()).toContain('fail');
-                    console.log('   Error message:', response.message);
-                }
-                else {
-                    // If success is true for invalid token, that's unexpected
-                    throw new Error('Expected API to reject invalid token with 401');
-                }
-            }
-            catch (error) {
-                // The API should throw with 401 Unauthorized for invalid credentials
-                console.log('API correctly rejected invalid token with error:', error.message);
-                expect(error).toBeDefined();
-                expect(error.message).toBeDefined();
-                // Check for expected error patterns (401 or server error)
-                const isExpectedError = error.message.includes('401') ||
-                    error.message.includes('Unauthorized') ||
-                    error.message.includes('Invalid') ||
-                    error.message.includes('Login failed') ||
-                    error.message.includes('Server Error') ||
-                    error.message.includes('500');
-                expect(isExpectedError).toBe(true);
-                // Log the actual status for debugging
-                if (error.response?.status === 401) {
-                    console.log('Correctly received 401 Unauthorized status');
-                }
-                else if (error.response?.status === 500) {
-                    console.log('Received 500 Server Error (token might have invalid format)');
-                }
-            }
-        });
-    });
-    describe('proxyAuth', () => {
-        it('should successfully validate authentication with valid token', async () => {
-            console.log('Testing /proxy-auth endpoint with valid token...');
-            try {
-                await authentication.proxyAuth(SESSION_TOKEN, BASE_URL);
-                console.log('Successfully validated authentication through proxy');
-            }
-            catch (error) {
-                console.log('Proxy auth validation result:', error.message);
-                // The endpoint might not exist yet or might require specific proxy setup
-                // We'll accept either success or specific error responses
-                expect(error.message.includes('404') || // Endpoint might not exist
-                    error.message.includes('401') || // Unauthorized
-                    error.message.includes('403') || // Forbidden
-                    error.message.includes('proxy')).toBe(true);
-            }
-        });
-        it('should fail with 401 when using invalid token', async () => {
-            console.log('Testing /proxy-auth endpoint with invalid token...');
-            const invalidToken = 'invalid.token.here';
-            try {
-                await authentication.proxyAuth(invalidToken, BASE_URL);
-                // If we reach here, the endpoint accepted invalid token (shouldn't happen)
-                throw new Error('Expected proxy auth to reject invalid token');
-            }
-            catch (error) {
-                console.log('Proxy auth correctly rejected invalid token:', error.message);
-                expect(error).toBeDefined();
-                // Should get 401 Unauthorized or similar error
-                expect(error.message.includes('401') ||
-                    error.message.includes('Unauthorized') ||
-                    error.message.includes('Invalid') ||
-                    error.message.includes('404')).toBe(true);
-            }
-        });
-        it('should require token parameter', async () => {
-            console.log('Testing /proxy-auth endpoint without token...');
-            try {
-                // @ts-expect-error Testing missing required parameter
-                await authentication.proxyAuth();
-                throw new Error('Expected function to throw for missing token');
-            }
-            catch (error) {
-                console.log('Correctly rejected request without token:', error.message);
-                expect(error.message).toBe('Authentication token is required');
-            }
-        });
-    });
-    describe('logout', () => {
-        // NOTE: The logout endpoint appears to return 405 Method Not Allowed
-        // This might indicate the endpoint doesn't exist or uses a different HTTP method
-        // Commenting out these tests until we can verify the correct API specification
-        it.skip('should successfully logout with valid token', async () => {
-            console.log('Testing logout with valid token...');
-            // First login to get a fresh token
-            const loginResponse = await authentication.login({
-                token: DATALAYER_TOKEN,
-            });
-            expect(loginResponse.success).toBe(true);
-            const sessionToken = loginResponse.token;
-            console.log('Login successful, got session token');
-            // Now test logout with the session token
-            await expect(authentication.logout(sessionToken, BASE_URL)).resolves.toBeUndefined();
-            console.log('Logout successful');
-        });
-        it.skip('should successfully logout using default URL', async () => {
-            console.log('Testing logout with valid token using default URL...');
-            // First login to get a fresh token
-            const loginResponse = await authentication.login({
-                token: DATALAYER_TOKEN,
-            });
-            expect(loginResponse.success).toBe(true);
-            const sessionToken = loginResponse.token;
-            console.log('Login successful with default URL, got session token');
-            // Now test logout with the session token using default URL
-            await expect(authentication.logout(sessionToken)).resolves.toBeUndefined();
-            console.log('Logout successful with default URL');
-        });
-        it('should handle logout with invalid token', async () => {
-            console.log('Testing logout with invalid token...');
-            const invalidToken = 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiJpbnZhbGlkIiwiaWF0IjoxNTE2MjM5MDIyfQ.invalid_signature_here';
-            try {
-                await authentication.logout(invalidToken, BASE_URL);
-                console.log('Logout completed without error (unexpected)');
-            }
-            catch (error) {
-                console.log('Logout failed:', error.message);
-                expect(error).toBeDefined();
-                expect(error.message).toBeDefined();
-                // Should get a server error for invalid token
-                expect(error.message).toContain('Server Error');
-            }
-        });
-        it('should verify logout accepts token as required parameter', () => {
-            // This is a compile-time test to ensure the method signature is correct
-            // The token parameter should be required
-            const mockToken = 'test-token';
-            // This should compile without errors
-            expect(() => {
-                // Test with token only (using default URL)
-                const promise1 = authentication.logout(mockToken);
-                promise1.catch(() => { }); // Ignore the actual API call
-                // Test with both token and URL
-                const promise2 = authentication.logout(mockToken, BASE_URL);
-                promise2.catch(() => { }); // Ignore the actual API call
-            }).not.toThrow();
-            console.log('Logout method signature verified: token is required, baseUrl is optional');
-        });
-    });
-});

package/lib/api/__tests__/iam.healthz.integration.test.d.ts

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

package/lib/api/__tests__/iam.healthz.integration.test.js

@@ -1,63 +0,0 @@
-/*
- * Copyright (c) 2023-2025 Datalayer, Inc.
- * Distributed under the terms of the Modified BSD License.
- */
-import { describe, it, expect, beforeAll } from 'vitest';
-import { healthz } from '../iam';
-import { testConfig, debugLog, skipIfNoToken, } from '../../__tests__/shared/test-config';
-let BASE_URL;
-// Skip all tests if no token is available
-const skipTests = skipIfNoToken();
-beforeAll(async () => {
-    if (skipTests) {
-        console.log('WARNING: Skipping IAM healthz integration tests: No Datalayer API token configured');
-        console.log('         Set DATALAYER_API_TOKEN env var or DATALAYER_TEST_TOKEN in .env.test');
-        return;
-    }
-    // Get base URL from test config
-    BASE_URL = testConfig.getBaseUrl('IAM');
-    debugLog('Test configuration loaded');
-    debugLog('Base URL:', BASE_URL);
-});
-describe.skipIf(skipTests)('IAM Healthz Integration Tests', () => {
-    describe('ping endpoint', () => {
-        it('should successfully ping the IAM service', async () => {
-            console.log('Testing health check ping endpoint...');
-            const response = await healthz.ping(BASE_URL);
-            console.log('Ping response:', JSON.stringify(response, null, 2));
-            // Verify the response structure matches actual API response
-            expect(response).toBeDefined();
-            expect(response.success).toBe(true);
-            expect(response.message).toBeDefined();
-            expect(response.message.toLowerCase()).toContain('running');
-            expect(response.status).toBeDefined();
-            expect(response.status.status).toBe('OK');
-            expect(response.version).toBeDefined();
-            expect(typeof response.version).toBe('string');
-            console.log('Health check successful');
-            console.log('Success:', response.success);
-            console.log('Message:', response.message);
-            console.log('Status:', response.status.status);
-            console.log('Version:', response.version);
-        });
-        it('should work with default URL if not specified', async () => {
-            console.log('Testing health check with default URL...');
-            // Call without specifying URL to use default
-            const response = await healthz.ping();
-            console.log('Default URL ping response:', JSON.stringify(response, null, 2));
-            // Should still get valid response
-            expect(response).toBeDefined();
-            expect(response.success).toBe(true);
-            expect(response.status).toBeDefined();
-            expect(response.status.status).toBe('OK');
-        });
-    });
-    describe('error handling', () => {
-        it('should handle malformed URLs gracefully', async () => {
-            console.log('Testing error handling with malformed URL...');
-            const malformedUrl = 'not-a-valid-url';
-            // ping should throw an error
-            await expect(healthz.ping(malformedUrl)).rejects.toThrow();
-        });
-    });
-});

package/lib/api/__tests__/iam.profile.integration.test.d.ts

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