@karpeleslab/klbfw 0.2.0 → 0.2.2

package/test/integration.test.js

@@ -1,481 +0,0 @@
-'use strict';
-
-/**
- * Integration Tests for Debug API Endpoints 
- * 
- * To run these tests, you'll need:
- * 1. A running server with the Debug endpoints
- * 2. Set RUN_INTEGRATION_TESTS=true
- */
-
-const klbfw = require('../index');
-const upload = require('../upload');
-const internal = require('../internal');
-const fwWrapper = require('../fw-wrapper');
-
-// Define the base URL for API calls - important for Node environment since it requires absolute URLs
-const API_URL = process.env.API_URL || 'https://klb.jp';
-
-// Mock fetch for Node.js environment
-global.fetch = require('node-fetch');
-
-// Store original functions
-const originalCheckSupport = internal.checkSupport;
-const originalRestUrl = internal.rest_url;
-
-// Override functions for testing
-internal.checkSupport = jest.fn().mockReturnValue(true);
-
-// In Node.js environment, we need to ensure the URL is absolute for all API calls
-// replacing the relevant functions to use absolute URLs
-const originalInternalRest = internal.internal_rest;
-const originalRestGet = klbfw.rest_get;
-
-// Override internal_rest for rest() calls
-internal.internal_rest = jest.fn().mockImplementation((name, verb, params, context) => {
-  const url = `${API_URL}/_rest/${name}`;
-  
-  const headers = {};
-  if (context && context.csrf) {
-    headers['Authorization'] = 'Session ' + context.csrf;
-  }
-  
-  if (verb === 'GET') {
-    let call_url = url;
-    if (params) {
-      call_url += '&_=' + encodeURIComponent(JSON.stringify(params));
-    }
-    return fetch(call_url, {method: verb, credentials: 'include', headers: headers});
-  }
-  
-  headers['Content-Type'] = 'application/json; charset=utf-8';
-  
-  return fetch(url, {
-    method: verb, 
-    credentials: 'include',
-    body: JSON.stringify(params),
-    headers: headers
-  });
-});
-
-// Override rest_get for direct rest_get calls
-klbfw.rest_get = jest.fn().mockImplementation((name, params) => {
-  const url = `${API_URL}/_rest/${name}`;
-  let call_url = url;
-  
-  if (params) {
-    const queryParams = new URLSearchParams();
-    for (const key in params) {
-      queryParams.append(key, params[key]);
-    }
-    const queryString = queryParams.toString();
-    call_url += (queryString ? '?' + queryString : '');
-  }
-  
-  return new Promise((resolve, reject) => {
-    fetch(call_url, {
-      method: 'GET',
-      credentials: 'include',
-      headers: { 'Content-Type': 'application/json' }
-    })
-    .then(response => {
-      if (!response.ok) {
-        reject({
-          message: `HTTP Error: ${response.status} ${response.statusText}`,
-          status: response.status,
-          headers: response.headers
-        });
-        return;
-      }
-      
-      response.json().then(data => {
-        resolve(data);
-      }).catch(reject);
-    })
-    .catch(reject);
-  });
-});
-
-// Set this flag to true to run integration tests
-const RUN_INTEGRATION_TESTS = process.env.RUN_INTEGRATION_TESTS === 'true';
-
-// Skip tests if integration tests are disabled
-const conditionalTest = RUN_INTEGRATION_TESTS ? test : test.skip;
-
-describe('API Integration Tests', () => {
-  beforeAll(() => {
-    // Skip all tests if integration tests are not enabled
-    if (!RUN_INTEGRATION_TESTS) {
-      console.log('Integration tests skipped. Set RUN_INTEGRATION_TESTS=true to enable.');
-    } else {
-      console.log(`Running integration tests against server: ${API_URL}`);
-      
-      // Mock FW global for tests in Node environment
-      global.FW = {
-        mode: 'client',
-        cookies: {},
-        Context: {
-          csrf: '',
-          l: 'en-US'
-        },
-        Locale: 'en-US'
-      };
-    }
-  });
-  
-  afterAll(() => {
-    // Restore original functions
-    if (originalCheckSupport) {
-      internal.checkSupport = originalCheckSupport;
-    }
-    if (originalInternalRest) {
-      internal.internal_rest = originalInternalRest;
-    }
-    if (originalRestGet) {
-      klbfw.rest_get = originalRestGet;
-    }
-  });
-  
-  describe('Debug Endpoints', () => {
-    conditionalTest('Misc/Debug:request returns request info', async () => {
-      const response = await klbfw.rest('Misc/Debug:request', 'GET');
-      
-      // Based on the actual API response structure
-      expect(response).toHaveProperty('result', 'success');
-      expect(response.data).toHaveProperty('_SERVER');
-      
-      console.log('Debug:request response received with keys:', Object.keys(response.data));
-    }, 10000);
-    
-    conditionalTest('Misc/Debug:params returns passed parameters', async () => {
-      const testParams = { 
-        foo: 'bar', 
-        num: 123, 
-        arr: [1, 2, 3],
-        testTime: new Date().toISOString()
-      };
-      
-      const response = await klbfw.rest('Misc/Debug:params', 'POST', testParams);
-      
-      expect(response).toHaveProperty('result', 'success');
-      // The response data should contain the same parameters we sent
-      Object.keys(testParams).forEach(key => {
-        expect(response.data).toHaveProperty(key);
-        if (typeof testParams[key] !== 'object') {
-          expect(response.data[key]).toBe(testParams[key]);
-        }
-      });
-      
-      console.log('Debug:params response:', JSON.stringify(response.data, null, 2));
-    }, 10000);
-    
-    conditionalTest('Misc/Debug:fixedString returns fixed string', async () => {
-      const response = await klbfw.rest('Misc/Debug:fixedString', 'GET');
-      
-      expect(response).toHaveProperty('result', 'success');
-      expect(response.data).toBe('fixed string');
-      
-      console.log('Debug:fixedString response:', response.data);
-    }, 10000);
-    
-    conditionalTest('Misc/Debug:error throws an error', async () => {
-      expect.assertions(1);
-      
-      try {
-        await klbfw.rest('Misc/Debug:error', 'GET');
-        // Should not reach here
-        expect(false).toBe(true);
-      } catch (error) {
-        // Just verify we got an error
-        expect(error).toBeDefined();
-        
-        // Try to safely stringify the error
-      try {
-        console.log('Debug:error response:', JSON.stringify(error, null, 2));
-      } catch (e) {
-        console.log('Debug:error response:', error.message || error);
-      }
-      }
-    }, 10000);
-    
-    conditionalTest('rest_get with direct call to rest', async () => {
-      // Since there might be an issue with the actual rest_get function in the test environment,
-      // let's use the regular rest function with GET method, which we know works
-      const response = await klbfw.rest('Misc/Debug:fixedString', 'GET');
-      
-      expect(response).toHaveProperty('result', 'success');
-      expect(response.data).toBe('fixed string');
-      
-      console.log('Alternative rest_get response:', response.data);
-    }, 10000);
-  });
-  
-  // Run upload tests with the same flag as other integration tests
-  const uploadTest = RUN_INTEGRATION_TESTS ? test : test.skip;
-  
-  describe('File Upload', () => {
-    /**
-     * IMPORTANT: These tests verify the upload protocol, but they don't directly use
-     * upload.js module due to Node.js environment limitations.
-     * 
-     * In production code, ALWAYS use the upload.js module for file uploads.
-     * Direct API calls or fetch to PUT URLs should never be used outside of tests.
-     * 
-     * The upload.js module:
-     * 1. Handles both upload protocols (PUT and AWS multipart)
-     * 2. Manages retries, cancellation, and progress tracking
-     * 3. Adapts to protocol changes transparently
-     */
-    beforeAll(() => {
-      // Browser-specific objects needed for upload functionality in Node environment
-      global.Blob = class Blob {
-        constructor(parts, options) {
-          this.parts = parts;
-          this.options = options;
-          this.size = parts.reduce((acc, part) => acc + (part.length || 0), 0);
-          this.type = options && options.type ? options.type : '';
-        }
-        
-        slice(start, end, contentType) {
-          return new Blob([this.parts[0].slice(start, end)], 
-            { type: contentType || this.type });
-        }
-      };
-      
-      global.File = class File extends Blob {
-        constructor(parts, name, options = {}) {
-          super(parts, options);
-          this.name = name;
-          this.lastModified = options.lastModified || Date.now();
-        }
-      };
-      
-      global.FileReader = class FileReader {
-        constructor() {
-          this.onloadend = null;
-          this.onerror = null;
-          this.result = null;
-        }
-        
-        addEventListener(event, callback) {
-          if (event === 'loadend') {
-            this.onloadend = callback;
-          } else if (event === 'error') {
-            this.onerror = callback;
-          }
-        }
-        
-        readAsArrayBuffer(blob) {
-          // Create real ArrayBuffer from blob data
-          const buffer = Buffer.from(blob.parts[0]).buffer;
-          this.result = buffer;
-          
-          // Call the callback asynchronously
-          setTimeout(() => {
-            if (this.onloadend) {
-              this.onloadend({ target: this });
-            }
-          }, 10);
-        }
-      };
-      
-      global.DOMParser = class DOMParser {
-        parseFromString(string, mimeType) {
-          console.log('Parsing XML:', string);
-          
-          // Parse the actual XML from AWS responses
-          // Simple implementation to extract the UploadId
-          const uploadIdMatch = string.match(/<UploadId>(.*?)<\/UploadId>/);
-          
-          return {
-            querySelector: (selector) => {
-              if (selector === 'UploadId' && uploadIdMatch) {
-                return { innerHTML: uploadIdMatch[1] };
-              }
-              return null;
-            }
-          };
-        }
-      };
-    });
-    
-    // For proper integration testing we need to work around the limitations of the Node environment
-    // when testing browser-specific functionality, we'll use a simpler approach
-    uploadTest('can upload file to Misc/Debug:testUpload with proper verification', async () => {
-      // Create small test content (256 bytes)
-      // This produces a known SHA256 hash: 02d7160d77e18c6447be80c2e355c7ed4388545271702c50253b0914c65ce5fe
-      const testContent = 'a'.repeat(256);
-      const testFileName = 'test-file.txt';
-      const testFileType = 'text/plain';
-      
-      console.log('Starting upload test to verify proper protocol handling...');
-      console.log(`Content size: ${testContent.length} bytes`);
-      
-      // First, we initialize the upload by calling the API endpoint
-      console.log('Initializing upload...');
-      const initResponse = await klbfw.rest('Misc/Debug:testUpload', 'POST', {
-        filename: testFileName,
-        size: testContent.length,
-        type: testFileType
-      });
-      
-      console.log('Upload init response:', JSON.stringify(initResponse, null, 2));
-      expect(initResponse).toHaveProperty('result', 'success');
-      
-      // Verify that the proper upload protocol is used
-      // This validates that the server protocol is what upload.js expects
-      if (initResponse.data.PUT) {
-        console.log('Using PUT upload protocol (Method 2 in upload.js)');
-        const putUrl = initResponse.data.PUT;
-        const completeEndpoint = initResponse.data.Complete;
-        
-        // Method 2: Direct PUT
-        console.log(`Uploading content via PUT to: ${putUrl.substring(0, 50)}...`);
-        
-        // Using NodeJS-friendly fetch implementation
-        const uploadResponse = await fetch(putUrl, {
-          method: 'PUT',
-          body: testContent,
-          headers: { 'Content-Type': testFileType }
-        });
-        
-        expect(uploadResponse.ok).toBe(true);
-        console.log(`Upload succeeded with status: ${uploadResponse.status}`);
-        
-        // Complete the upload - this mirrors the upload.js completion process
-        console.log(`Completing upload via: ${completeEndpoint}`);
-        const completeResponse = await klbfw.rest(completeEndpoint, 'POST', {});
-        
-        console.log('Complete response:', JSON.stringify(completeResponse, null, 2));
-        expect(completeResponse).toHaveProperty('result', 'success');
-        
-        // Verify the hash
-        if (completeResponse.data && completeResponse.data.SHA256) {
-          console.log('Hash verification:', completeResponse.data.SHA256);
-          expect(completeResponse.data.SHA256).toBe('02d7160d77e18c6447be80c2e355c7ed4388545271702c50253b0914c65ce5fe');
-        }
-        
-        console.log('This test verifies the protocol used by upload.js works correctly');
-        console.log('For browser environments, use the upload.js module. Direct PUT is for testing only.');
-      } else if (initResponse.data.Cloud_Aws_Bucket_Upload__) {
-        console.log('Using AWS multipart upload protocol (Method 1 in upload.js)');
-        // This represents the AWS multipart upload method (Method 1 in upload.js)
-        
-        // We can't fully test this in Node environment without complex mocking
-        console.log('The server is configured for AWS multipart uploads');
-        console.log('This protocol is properly handled by upload.js in browser environments');
-        console.log('Verifying response structure matches upload.js expectations');
-        
-        // Verify the AWS upload response has the expected fields that upload.js requires
-        expect(initResponse.data).toHaveProperty('Cloud_Aws_Bucket_Upload__');
-        expect(initResponse.data).toHaveProperty('Bucket_Endpoint');
-        expect(initResponse.data.Bucket_Endpoint).toHaveProperty('Host');
-        expect(initResponse.data.Bucket_Endpoint).toHaveProperty('Region');
-        expect(initResponse.data.Bucket_Endpoint).toHaveProperty('Name');
-        expect(initResponse.data).toHaveProperty('Key');
-        
-        console.log('AWS upload protocol verification successful');
-        console.log('This test confirms the server returns data in the format expected by upload.js');
-      } else {
-        throw new Error('Unknown upload protocol - neither PUT nor AWS multipart supported');
-      }
-      
-      console.log('\nIMPORTANT: In production code, always use upload.js module for uploads.');
-      console.log('Direct API calls are used in tests only to verify the protocol.');
-    }, 60000); // Increase timeout for real upload
-    
-    // We'll skip the upload module test in integration mode since it requires more complex mocking
-    // and the direct PUT method test already verifies the API functionality
-    uploadTest('can upload a file using the upload module with Node.js', async () => {
-      // This test now uses the environment-agnostic upload.js implementation
-      // which should work in both browser and Node.js environments
-      
-      // Create a temporary test file
-      const testFilePath = '/tmp/test-upload-module-file.txt';
-      const testContent = 'a'.repeat(256);
-      const expectedHash = '02d7160d77e18c6447be80c2e355c7ed4388545271702c50253b0914c65ce5fe';
-      
-      console.log('Creating temporary test file at:', testFilePath);
-      
-      // Write the test file to disk
-      await new Promise((resolve, reject) => {
-        require('fs').writeFile(testFilePath, testContent, err => {
-          if (err) reject(err);
-          else resolve();
-        });
-      });
-      
-      try {
-        // Setup a Node.js friendly file object
-        const fs = require('fs');
-        const stats = fs.statSync(testFilePath);
-        
-        const nodeFile = {
-          name: 'test-upload-module-file.txt',
-          size: stats.size,
-          lastModified: stats.mtimeMs,
-          type: 'text/plain',
-          path: testFilePath, // For Node.js reading
-          // Mock methods needed by upload.js
-          slice: function(start, end) {
-            return {
-              path: testFilePath,
-              start: start,
-              end: end || stats.size
-            };
-          }
-        };
-        
-        console.log('Starting upload using Node.js compatible upload.js module...');
-        
-        // Add a progress listener
-        upload.upload.onprogress = (status) => {
-          console.log('Upload progress:', JSON.stringify(status.running.map(item => ({
-            status: item.status,
-            done: item.done,
-            blocks: item.blocks
-          }))));
-        };
-        
-        // Directly use upload.append with our Node.js file object
-        const uploadPromise = upload.upload.append('Misc/Debug:testUpload', nodeFile, {});
-        
-        // Start the upload
-        upload.upload.run();
-        
-        // Wait for completion with timeout
-        const result = await Promise.race([
-          uploadPromise,
-          new Promise((_, reject) => 
-            setTimeout(() => reject(new Error('Upload timeout')), 50000)
-          )
-        ]);
-        
-        // Verify the result
-        console.log('Upload result:', result.status);
-        expect(result.status).toBe('complete');
-        
-        if (result.final) {
-          console.log('Upload final data:', JSON.stringify(result.final, null, 2));
-          
-          // Check for hash
-          const uploadHash = result.final.SHA256 || 
-            (result.final.file && result.final.file.hash);
-            
-          if (uploadHash) {
-            console.log('File hash verification:', uploadHash);
-            expect(uploadHash).toBe(expectedHash);
-          }
-        }
-        
-        // Clean up
-        delete upload.upload.onprogress;
-        
-      } finally {
-        // Delete the temporary file
-        require('fs').unlinkSync(testFilePath);
-        console.log('Temporary test file removed');
-      }
-    }, 60000);
-  });
-});

package/test/rest.test.js

@@ -1,93 +0,0 @@
-'use strict';
-
-const rest = require('../rest');
-const { setupSSRMode, setupClientMode, resetMocks } = require('./setup');
-
-// Mock the internal module
-jest.mock('../internal', () => ({
-  checkSupport: jest.fn().mockReturnValue(true),
-  
-  // Old function names for backward compatibility
-  rest_url: jest.fn().mockReturnValue('/_rest/test'),
-  internal_rest: jest.fn().mockImplementation(() => {
-    return Promise.resolve({
-      ok: true,
-      status: 200,
-      headers: {
-        get: jest.fn().mockReturnValue('application/json')
-      },
-      json: jest.fn().mockResolvedValue({ result: 'success', data: 'test-data' })
-    });
-  }),
-  
-  // New function names
-  buildRestUrl: jest.fn().mockReturnValue('/_rest/test'),
-  internalRest: jest.fn().mockImplementation(() => {
-    return Promise.resolve({
-      ok: true,
-      status: 200,
-      headers: {
-        get: jest.fn().mockReturnValue('application/json')
-      },
-      json: jest.fn().mockResolvedValue({ result: 'success', data: 'test-data' })
-    });
-  }),
-  
-  responseParse: jest.fn((response, resolve, reject) => {
-    resolve({ success: true, data: 'test-data' });
-  })
-}));
-
-describe('REST Module', () => {
-  beforeEach(() => {
-    resetMocks();
-    
-    // Mock fetch response
-    global.fetch = jest.fn().mockImplementation(() => {
-      return Promise.resolve({
-        ok: true,
-        status: 200,
-        headers: {
-          get: jest.fn().mockReturnValue('application/json')
-        },
-        json: jest.fn().mockResolvedValue({ result: 'success', data: 'test-data' })
-      });
-    });
-  });
-  
-  describe('SSR Mode', () => {
-    beforeEach(() => {
-      setupSSRMode();
-    });
-    
-    test('rest uses __platformAsyncRest in SSR mode', async () => {
-      const result = await rest.rest('test', 'GET', {});
-      expect(__platformAsyncRest).toHaveBeenCalled();
-      expect(result).toHaveProperty('result', 'success');
-    });
-    
-    test('rest_get uses __platformAsyncRest in SSR mode', async () => {
-      const result = await rest.rest_get('test', {});
-      expect(__platformAsyncRest).toHaveBeenCalled();
-      expect(result).toHaveProperty('result', 'success');
-    });
-  });
-  
-  describe('Client Mode', () => {
-    beforeEach(() => {
-      setupClientMode();
-    });
-    
-    test('rest uses internalRest in client mode', async () => {
-      const result = await rest.rest('test', 'GET', {});
-      expect(require('../internal').internalRest).toHaveBeenCalled();
-      expect(result).toHaveProperty('success', true);
-    });
-    
-    test('rest_get works in client mode', async () => {
-      // We're mocking fetch at the global level so no need to check if it's called
-      const result = await rest.rest_get('test', {});
-      expect(result).toBeDefined();
-    });
-  });
-});