@datalayer/core 0.0.10 → 0.0.12

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

@@ -0,0 +1,252 @@
+/*
+ * Copyright (c) 2023-2025 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+import { describe, it, expect, beforeAll } from 'vitest';
+import { authentication, profile } 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 profile 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 profile tests
+    try {
+        const loginResponse = await authentication.login({
+            token: DATALAYER_TOKEN,
+        });
+        SESSION_TOKEN = loginResponse.token;
+        debugLog('Successfully logged in, got session token');
+    }
+    catch (error) {
+        console.error('Failed to login for profile tests:', error);
+        throw error;
+    }
+});
+describe.skipIf(skipTests)('IAM Profile Integration Tests', () => {
+    describe('me', () => {
+        it('should successfully get current user profile with token', async () => {
+            console.log('Testing /me endpoint with session token...');
+            const response = await profile.me(SESSION_TOKEN, BASE_URL);
+            console.log('Profile response:', JSON.stringify(response, null, 2));
+            // Verify response structure
+            expect(response).toBeDefined();
+            expect(response.success).toBe(true);
+            expect(response.message).toBeDefined();
+            expect(typeof response.message).toBe('string');
+            // Verify me object structure
+            expect(response.me).toBeDefined();
+            expect(response.me.id).toBeDefined();
+            expect(typeof response.me.id).toBe('string');
+            expect(response.me.uid).toBeDefined();
+            expect(typeof response.me.uid).toBe('string');
+            expect(response.me.handle).toBeDefined();
+            expect(typeof response.me.handle).toBe('string');
+            expect(response.me.email).toBeDefined();
+            expect(typeof response.me.email).toBe('string');
+            expect(response.me.firstName).toBeDefined();
+            expect(typeof response.me.firstName).toBe('string');
+            expect(response.me.lastName).toBeDefined();
+            expect(typeof response.me.lastName).toBe('string');
+            expect(response.me.avatarUrl).toBeDefined();
+            expect(typeof response.me.avatarUrl).toBe('string');
+            expect(response.me.roles).toBeDefined();
+            expect(Array.isArray(response.me.roles)).toBe(true);
+            console.log('Successfully retrieved user profile');
+            console.log('ID:', response.me.id);
+            console.log('UID:', response.me.uid);
+            console.log('Email:', response.me.email);
+            console.log('Handle:', response.me.handle);
+            console.log('Name:', response.me.firstName, response.me.lastName);
+            console.log('Roles:', response.me.roles.join(', '));
+        });
+        it('should successfully get current user profile using default URL', async () => {
+            console.log('Testing /me endpoint with default URL...');
+            const response = await profile.me(SESSION_TOKEN);
+            console.log('Profile 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.me).toBeDefined();
+            expect(response.me.uid).toBeDefined();
+            expect(response.me.handle).toBeDefined();
+            expect(response.me.email).toBeDefined();
+            expect(Array.isArray(response.me.roles)).toBe(true);
+            console.log('Successfully retrieved user profile with default URL');
+            console.log('UID:', response.me.uid);
+            console.log('Handle:', response.me.handle);
+        });
+        it('should fail when using invalid token', async () => {
+            console.log('Testing /me endpoint with invalid token...');
+            const invalidToken = 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiJpbnZhbGlkIiwiaWF0IjoxNTE2MjM5MDIyfQ.invalid_signature_here';
+            try {
+                await profile.me(invalidToken, BASE_URL);
+                // If we get here, the API accepted an invalid token (shouldn't happen)
+                throw new Error('Expected API to reject invalid token');
+            }
+            catch (error) {
+                console.log('API correctly rejected invalid token:', error.message);
+                expect(error).toBeDefined();
+                expect(error.message).toBeDefined();
+                // The error message should indicate server error or authentication failure
+                expect(error.message.includes('401') ||
+                    error.message.includes('Unauthorized') ||
+                    error.message.includes('Invalid') ||
+                    error.message.includes('credentials') ||
+                    error.message.includes('Server Error') ||
+                    error.message.includes('500')).toBe(true);
+            }
+        });
+        it('should fail when no token is provided', async () => {
+            console.log('Testing /me endpoint without token...');
+            try {
+                // @ts-expect-error Testing missing required parameter
+                await profile.me();
+                // Should not reach here
+                throw new Error('Expected function to throw for missing token');
+            }
+            catch (error) {
+                console.log('Correctly rejected request without token:', error.message);
+                expect(error).toBeDefined();
+                expect(error.message).toBe('Authentication token is required');
+            }
+        });
+        it('should fail when empty token is provided', async () => {
+            console.log('Testing /me endpoint with empty token...');
+            try {
+                await profile.me('', BASE_URL);
+                // Should not reach here
+                throw new Error('Expected function to throw for empty token');
+            }
+            catch (error) {
+                console.log('Correctly rejected request with empty token:', error.message);
+                expect(error).toBeDefined();
+                expect(error.message).toBe('Authentication token is required');
+            }
+        });
+    });
+    describe('whoami', () => {
+        it('should successfully get current user identity with token', async () => {
+            console.log('Testing /whoami endpoint with session token...');
+            const response = await profile.whoami(SESSION_TOKEN, BASE_URL);
+            console.log('WhoAmI response:', JSON.stringify(response, null, 2));
+            // Verify response structure
+            expect(response).toBeDefined();
+            expect(response.success).toBe(true);
+            expect(response.message).toBeDefined();
+            expect(typeof response.message).toBe('string');
+            // Verify profile object structure
+            expect(response.profile).toBeDefined();
+            expect(response.profile.id).toBeDefined();
+            expect(typeof response.profile.id).toBe('string');
+            expect(response.profile.uid).toBeDefined();
+            expect(typeof response.profile.uid).toBe('string');
+            expect(response.profile.handle_s).toBeDefined();
+            expect(typeof response.profile.handle_s).toBe('string');
+            expect(response.profile.email_s).toBeDefined();
+            expect(typeof response.profile.email_s).toBe('string');
+            expect(response.profile.first_name_t).toBeDefined();
+            expect(typeof response.profile.first_name_t).toBe('string');
+            expect(response.profile.last_name_t).toBeDefined();
+            expect(typeof response.profile.last_name_t).toBe('string');
+            expect(response.profile.type_s).toBeDefined();
+            expect(typeof response.profile.type_s).toBe('string');
+            expect(response.profile.origin_s).toBeDefined();
+            expect(typeof response.profile.origin_s).toBe('string');
+            expect(response.profile.creation_ts_dt).toBeDefined();
+            expect(typeof response.profile.creation_ts_dt).toBe('string');
+            expect(response.profile.last_update_ts_dt).toBeDefined();
+            expect(typeof response.profile.last_update_ts_dt).toBe('string');
+            expect(response.profile.join_ts_dt).toBeDefined();
+            expect(typeof response.profile.join_ts_dt).toBe('string');
+            // join_request_ts_dt can be null
+            if (response.profile.join_request_ts_dt !== null) {
+                expect(typeof response.profile.join_request_ts_dt).toBe('string');
+            }
+            console.log('Successfully retrieved user identity');
+            console.log('ID:', response.profile.id);
+            console.log('UID:', response.profile.uid);
+            console.log('Email:', response.profile.email_s);
+            console.log('Handle:', response.profile.handle_s);
+            console.log('Name:', response.profile.first_name_t, response.profile.last_name_t);
+            console.log('Type:', response.profile.type_s);
+        });
+        it('should successfully get current user identity using default URL', async () => {
+            console.log('Testing /whoami endpoint with default URL...');
+            const response = await profile.whoami(SESSION_TOKEN);
+            console.log('WhoAmI 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.profile).toBeDefined();
+            expect(response.profile.uid).toBeDefined();
+            expect(response.profile.handle_s).toBeDefined();
+            expect(response.profile.email_s).toBeDefined();
+            console.log('Successfully retrieved user identity with default URL');
+            console.log('UID:', response.profile.uid);
+            console.log('Handle:', response.profile.handle_s);
+        });
+        it('should fail whoami when using invalid token', async () => {
+            console.log('Testing /whoami endpoint with invalid token...');
+            const invalidToken = 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiJpbnZhbGlkIiwiaWF0IjoxNTE2MjM5MDIyfQ.invalid_signature_here';
+            try {
+                await profile.whoami(invalidToken, BASE_URL);
+                // If we get here, the API accepted an invalid token (shouldn't happen)
+                throw new Error('Expected API to reject invalid token');
+            }
+            catch (error) {
+                console.log('API correctly rejected invalid token:', error.message);
+                expect(error).toBeDefined();
+                expect(error.message).toBeDefined();
+                // The error message should indicate server error or authentication failure
+                expect(error.message.includes('401') ||
+                    error.message.includes('Unauthorized') ||
+                    error.message.includes('Invalid') ||
+                    error.message.includes('credentials') ||
+                    error.message.includes('Server Error') ||
+                    error.message.includes('500')).toBe(true);
+            }
+        });
+        it('should fail whoami when no token is provided', async () => {
+            console.log('Testing /whoami endpoint without token...');
+            try {
+                // @ts-expect-error Testing missing required parameter
+                await profile.whoami();
+                // Should not reach here
+                throw new Error('Expected function to throw for missing token');
+            }
+            catch (error) {
+                console.log('Correctly rejected request without token:', error.message);
+                expect(error).toBeDefined();
+                expect(error.message).toBe('Authentication token is required');
+            }
+        });
+        it('should fail whoami when empty token is provided', async () => {
+            console.log('Testing /whoami endpoint with empty token...');
+            try {
+                await profile.whoami('', BASE_URL);
+                // Should not reach here
+                throw new Error('Expected function to throw for empty token');
+            }
+            catch (error) {
+                console.log('Correctly rejected request with empty token:', error.message);
+                expect(error).toBeDefined();
+                expect(error.message).toBe('Authentication token is required');
+            }
+        });
+    });
+});

package/lib/api/__tests__/runtimes.environments.integration.test.d.ts

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

package/lib/api/__tests__/runtimes.environments.integration.test.js

@@ -0,0 +1,122 @@
+/*
+ * Copyright (c) 2023-2025 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+import { describe, it, expect, beforeAll } from 'vitest';
+import { environments } from '../runtimes';
+import { testConfig, debugLog, skipIfNoToken, } from '../../__tests__/shared/test-config';
+let DATALAYER_TOKEN;
+let BASE_URL;
+// Skip all tests if no token is available
+const skipTests = skipIfNoToken();
+beforeAll(async () => {
+    if (skipTests) {
+        console.log('WARNING: Skipping Runtimes Environments 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('RUNTIMES');
+    debugLog('Test configuration loaded');
+    debugLog('Base URL:', BASE_URL);
+    debugLog('Token available:', !!DATALAYER_TOKEN);
+});
+describe.skipIf(skipTests)('Runtimes Environments Integration Tests', () => {
+    describe('list', () => {
+        it('should successfully list available environments', async () => {
+            console.log('Testing list environments endpoint...');
+            const response = await environments.listEnvironments(DATALAYER_TOKEN, BASE_URL);
+            console.log('Environments response:', JSON.stringify(response, null, 2));
+            // Verify the response structure
+            expect(response).toBeDefined();
+            expect(response).toHaveProperty('success');
+            expect(response.success).toBe(true);
+            expect(response).toHaveProperty('message');
+            expect(response).toHaveProperty('environments');
+            expect(Array.isArray(response.environments)).toBe(true);
+            // Check that we have at least some environments
+            console.log(`Found ${response.environments.length} available environments`);
+            // If we have environments, check the structure of the first one
+            if (response.environments.length > 0) {
+                const firstEnv = response.environments[0];
+                console.log('First environment:', firstEnv.title);
+                // Verify environment structure
+                expect(firstEnv).toHaveProperty('title');
+                expect(firstEnv).toHaveProperty('description');
+                expect(firstEnv).toHaveProperty('dockerImage');
+                expect(firstEnv).toHaveProperty('language');
+                expect(firstEnv).toHaveProperty('burning_rate');
+                expect(typeof firstEnv.burning_rate).toBe('number');
+            }
+        });
+        it('should work with default URL if not specified', async () => {
+            console.log('Testing list environments with default URL...');
+            // Call without specifying URL to use default
+            const response = await environments.listEnvironments(DATALAYER_TOKEN);
+            console.log('Default URL environments response:', JSON.stringify(response, null, 2));
+            // Should still get valid response
+            expect(response).toBeDefined();
+            expect(response.success).toBe(true);
+            expect(response).toHaveProperty('environments');
+            expect(Array.isArray(response.environments)).toBe(true);
+        });
+        it('should include environment resource information', async () => {
+            console.log('Testing environment resource information...');
+            const response = await environments.listEnvironments(DATALAYER_TOKEN, BASE_URL);
+            // Check if any environment has resource information
+            const envWithResources = response.environments.find(env => env.resources || env.resourcesRanges);
+            if (envWithResources) {
+                console.log('Found environment with resources:', envWithResources.title);
+                if (envWithResources.resources) {
+                    console.log('Resources:', envWithResources.resources);
+                    expect(envWithResources.resources).toHaveProperty('cpu');
+                    expect(envWithResources.resources).toHaveProperty('memory');
+                }
+                if (envWithResources.resourcesRanges) {
+                    console.log('Resource ranges:', envWithResources.resourcesRanges);
+                }
+            }
+            else {
+                console.log('No environments with explicit resource information found');
+            }
+        });
+        it('should include environment snippets if available', async () => {
+            console.log('Testing environment snippets...');
+            const response = await environments.listEnvironments(DATALAYER_TOKEN, BASE_URL);
+            // Check if any environment has snippets
+            const envWithSnippets = response.environments.find(env => env.snippets && env.snippets.length > 0);
+            if (envWithSnippets) {
+                console.log('Found environment with snippets:', envWithSnippets.title);
+                console.log('Number of snippets:', envWithSnippets.snippets?.length);
+                const firstSnippet = envWithSnippets.snippets[0];
+                expect(firstSnippet).toHaveProperty('title');
+                // Description might be optional
+                if (firstSnippet.description) {
+                    expect(firstSnippet).toHaveProperty('description');
+                }
+                expect(firstSnippet).toHaveProperty('code');
+            }
+            else {
+                console.log('No environments with snippets found');
+            }
+        });
+    });
+    describe('error handling', () => {
+        it('should handle invalid token gracefully', async () => {
+            console.log('Testing with invalid token...');
+            const invalidToken = 'invalid-token-123';
+            try {
+                await environments.listEnvironments(invalidToken, BASE_URL);
+                // If we get here, the API accepted the invalid token (shouldn't happen)
+                console.log('WARNING: API accepted invalid token');
+            }
+            catch (error) {
+                console.log('Error with invalid token:', error.message);
+                // We expect an error with invalid token
+                expect(error).toBeDefined();
+                expect(error.message).toBeDefined();
+            }
+        });
+    });
+});

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

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

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

@@ -0,0 +1,50 @@
+/*
+ * Copyright (c) 2023-2025 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+import { describe, it, expect } from 'vitest';
+import { healthz } from '../runtimes';
+import { testConfig, skipIfNoToken } from '../../__tests__/shared/test-config';
+/**
+ * Integration tests for Runtimes health check API
+ * These tests run against the actual Datalayer Runtimes API
+ */
+describe('Runtimes Healthz Integration Tests', () => {
+    describe.skipIf(skipIfNoToken())('ping endpoint', () => {
+        it('should successfully ping the Runtimes service', async () => {
+            console.log('Testing health check ping endpoint for Runtimes...');
+            const response = await healthz.ping(testConfig.getBaseUrl('RUNTIMES'));
+            // Log response for debugging
+            console.log('Ping response:', JSON.stringify(response, null, 2));
+            // Verify response structure
+            expect(response).toBeDefined();
+            expect(response.success).toBe(true);
+            expect(response.message).toBeDefined();
+            // Log success
+            console.log('Runtimes health check successful');
+            console.log('Success:', response.success);
+            console.log('Message:', response.message);
+            if (response.status) {
+                console.log('Status:', response.status.status);
+            }
+            if (response.version) {
+                console.log('Version:', response.version);
+            }
+        });
+        it('should work with default URL if not specified', async () => {
+            console.log('Testing health check with default URL...');
+            // Use default URL (should use production)
+            const response = await healthz.ping();
+            expect(response).toBeDefined();
+            expect(response.success).toBe(true);
+            expect(response.message).toBeDefined();
+            console.log('Successfully pinged Runtimes service with default URL');
+        });
+        it('should fail with invalid URL', async () => {
+            console.log('Testing health check with invalid URL...');
+            const invalidUrl = 'https://invalid.datalayer.run';
+            await expect(healthz.ping(invalidUrl)).rejects.toThrow('Health check failed');
+            console.log('Correctly failed with invalid URL');
+        });
+    });
+});

package/lib/api/__tests__/runtimes.integration.test.d.ts

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