@karpeleslab/klbfw 0.2.0 → 0.2.2

package/test/upload.test.js

@@ -1,689 +0,0 @@
-'use strict';
-
-const klbfw = require('../index');
-const upload = require('../upload');
-const { setupSSRMode, setupClientMode, resetMocks } = require('./setup');
-
-// Mock file for upload tests
-class MockFile {
-  constructor(name, size, type) {
-    this.name = name;
-    this.size = size;
-    this.type = type;
-    this.lastModified = Date.now();
-  }
-  
-  slice() {
-    return new Blob(['mock file content']);
-  }
-}
-
-// Mock FileReader
-global.FileReader = class FileReader {
-  constructor() {
-    this.result = new ArrayBuffer(10);
-    this.onloadend = null;
-  }
-  
-  addEventListener(event, callback) {
-    if (event === 'loadend') {
-      this.onloadend = callback;
-    }
-  }
-  
-  readAsArrayBuffer() {
-    // Simulate async file reading
-    setTimeout(() => {
-      if (this.onloadend) {
-        this.onloadend();
-      }
-    }, 0);
-  }
-};
-
-// Mock Blob
-global.Blob = class Blob {
-  constructor(content) {
-    this.content = content;
-    this.size = content.join('').length;
-    this.type = 'text/plain';
-  }
-};
-
-describe('Upload API', () => {
-  /**
-   * IMPORTANT: In production code, always use the upload.js module for 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
-   */
-  beforeEach(() => {
-    resetMocks();
-  });
-  
-  describe('Client Mode', () => {
-    beforeEach(() => {
-      setupClientMode();
-    });
-    
-    test('upload.append adds file to upload queue', async () => {
-      const mockFile = new MockFile('test.jpg', 12345, 'image/jpeg');
-      
-      // We need to mock DOMParser for the upload process
-      global.DOMParser = class DOMParser {
-        parseFromString() {
-          return {
-            querySelector: () => ({ innerHTML: 'test-upload-id' })
-          };
-        }
-      };
-      
-      // Add to queue
-      const uploadPromise = upload.upload.append('Misc/Debug:testUpload', mockFile, {});
-      
-      // Manually trigger run to process the upload
-      upload.upload.run();
-      
-      // Add timeout to test
-      const result = await uploadPromise;
-      
-      // Basic validation
-      expect(result).toBeDefined();
-      expect(result.file).toBe(mockFile);
-      expect(result.path).toBe('Misc/Debug:testUpload');
-    }, 10000);
-    
-    test('upload status functions work properly', () => {
-      // Add a file to the upload queue
-      const mockFile = new MockFile('test.jpg', 12345, 'image/jpeg');
-      upload.upload.append('Misc/Debug:testUpload', mockFile, {});
-      
-      // Get status
-      const status = upload.upload.getStatus();
-      expect(status).toHaveProperty('queue');
-      expect(status).toHaveProperty('running');
-      expect(status).toHaveProperty('failed');
-    });
-  });
-  
-  describe('Upload with Debug endpoint', () => {
-    beforeEach(() => {
-      setupClientMode();
-      
-      // Setup more realistic mocks for actual upload test
-      global.Blob = class Blob {
-        constructor(content) {
-          this.content = content;
-          this.size = content.join('').length;
-          this.type = 'text/plain';
-        }
-        
-        slice(start, end) {
-          // Return a slice of the content
-          return new Blob([this.content[0].slice(start, end)]);
-        }
-      };
-      
-      global.FileReader = class FileReader {
-        constructor() {
-          this.result = null;
-          this.onloadend = null;
-        }
-        
-        addEventListener(event, callback) {
-          if (event === 'loadend') {
-            this.onloadend = callback;
-          } else if (event === 'error') {
-            this.onerror = callback;
-          }
-        }
-        
-        readAsArrayBuffer(blob) {
-          // Create a mock ArrayBuffer from the blob content
-          const content = blob.content[0];
-          const buffer = new ArrayBuffer(content.length);
-          const view = new Uint8Array(buffer);
-          for (let i = 0; i < content.length; i++) {
-            view[i] = content.charCodeAt(i);
-          }
-          this.result = buffer;
-          
-          // Call the callback asynchronously
-          setTimeout(() => {
-            if (this.onloadend) {
-              this.onloadend();
-            }
-          }, 10);
-        }
-      };
-      
-      global.DOMParser = class DOMParser {
-        parseFromString(string) {
-          // For simple mock, just simulate extracting upload id
-          return {
-            querySelector: (selector) => {
-              if (selector === 'UploadId') {
-                return { innerHTML: 'test-upload-id-12345' };
-              }
-              return null;
-            }
-          };
-        }
-      };
-      
-      // Mock fetch to handle upload operations
-      global.fetch = jest.fn().mockImplementation((url, options) => {
-        if (url.includes('/upload')) {
-          // This is the PUT request to upload a file
-          return Promise.resolve({
-            ok: true,
-            status: 200,
-            statusText: 'OK',
-            headers: {
-              get: (header) => {
-                if (header === 'ETag') return '"test-etag-12345"';
-                return null;
-              }
-            }
-          });
-        } else if (url.includes('uploads=')) {
-          // This is the multipart upload initialization
-          return Promise.resolve({
-            ok: true,
-            status: 200,
-            statusText: 'OK',
-            text: () => Promise.resolve('<InitiateMultipartUploadResult><UploadId>test-upload-id-12345</UploadId></InitiateMultipartUploadResult>')
-          });
-        } else if (url.includes('uploadId=')) {
-          // This is the multipart upload completion
-          return Promise.resolve({
-            ok: true,
-            status: 200,
-            statusText: 'OK',
-            text: () => Promise.resolve('<CompleteMultipartUploadResult><ETag>"test-etag-final-12345"</ETag></CompleteMultipartUploadResult>')
-          });
-        }
-        
-        // For other API requests
-        return Promise.resolve({
-          ok: true,
-          status: 200,
-          statusText: 'OK',
-          headers: {
-            get: () => 'application/json'
-          },
-          json: () => Promise.resolve({
-            result: 'success',
-            data: {
-              // For upload initialization
-              PUT: 'https://example.com/upload',
-              Complete: 'Misc/Debug:testUpload',
-              Blocksize: 1024 * 1024, // 1MB blocks
-              // For AWS uploads
-              Cloud_Aws_Bucket_Upload__: 'test-upload-id',
-              Bucket_Endpoint: {
-                Host: 'example.s3.amazonaws.com',
-                Name: 'test-bucket',
-                Region: 'us-east-1'
-              },
-              Key: 'uploads/test-file.txt'
-            }
-          })
-        });
-      });
-    });
-    
-    test('upload can process a file with PUT method', async () => {
-      // Create test file content - 256 bytes of 'a'
-      // This produces a known SHA256 hash: 02d7160d77e18c6447be80c2e355c7ed4388545271702c50253b0914c65ce5fe
-      const testContent = 'a'.repeat(256);
-      
-      // Create a mock file for upload
-      const testFile = new MockFile('test-file.txt', testContent.length, 'text/plain');
-      
-      // Add mocks for file slice method
-      testFile.slice = (start, end) => {
-        return new Blob([testContent.slice(start, end)]);
-      };
-      
-      // Configure fetch mock to return a PUT URL for method 2
-      global.fetch = jest.fn().mockImplementation((url, options) => {
-        if (url.includes('Misc/Debug:testUpload')) {
-          // Initial upload request
-          return Promise.resolve({
-            ok: true,
-            status: 200,
-            headers: {
-              get: () => 'application/json'
-            },
-            json: () => Promise.resolve({
-              result: 'success',
-              data: {
-                PUT: 'https://example.com/upload',
-                Complete: 'Misc/Debug:testUpload',
-                Blocksize: testContent.length  // Single block for this test
-              }
-            })
-          });
-        } else if (url === 'https://example.com/upload') {
-          // The PUT request to upload the file
-          return Promise.resolve({
-            ok: true,
-            status: 200,
-            headers: {
-              get: () => null
-            }
-          });
-        } else if (url.includes('Misc/Debug:testUpload')) {
-          // Completion request
-          return Promise.resolve({
-            ok: true,
-            status: 200,
-            headers: {
-              get: () => 'application/json'
-            },
-            json: () => Promise.resolve({
-              result: 'success',
-              data: {
-                file: {
-                  name: 'test-file.txt',
-                  size: testContent.length,
-                  type: 'text/plain',
-                  hash: '02d7160d77e18c6447be80c2e355c7ed4388545271702c50253b0914c65ce5fe'  // SHA256 hash of 256 'a' characters
-                }
-              }
-            })
-          });
-        }
-        
-        return Promise.resolve({
-          ok: true,
-          status: 200,
-          headers: {
-            get: () => 'application/json'
-          },
-          json: () => Promise.resolve({
-            result: 'success',
-            data: {}
-          })
-        });
-      });
-      
-      // Add the file to the upload queue
-      const uploadPromise = upload.upload.append('Misc/Debug:testUpload', testFile, {});
-      
-      // Start the upload process
-      upload.upload.run();
-      
-      // Wait for the upload to complete
-      const result = await uploadPromise;
-      
-      // Verify the upload result
-      expect(result).toBeDefined();
-      expect(result.file).toBe(testFile);
-      expect(result.path).toBe('Misc/Debug:testUpload');
-      expect(result.status).toBe('complete');
-      
-      // Check if the file info includes hash
-      if (result.final && result.final.file) {
-        expect(result.final.file.hash).toBe('02d7160d77e18c6447be80c2e355c7ed4388545271702c50253b0914c65ce5fe');
-      }
-    }, 10000);
-    
-    test('upload can process a file with AWS multipart method', async () => {
-      // Create test file content - 256 bytes of 'a'
-      // This produces a known SHA256 hash: 02d7160d77e18c6447be80c2e355c7ed4388545271702c50253b0914c65ce5fe
-      const testContent = 'a'.repeat(256);
-      
-      // Create a mock file for upload
-      const testFile = new MockFile('test-file.txt', testContent.length, 'text/plain');
-      
-      // Add mocks for file slice method
-      testFile.slice = (start, end) => {
-        return new Blob([testContent.slice(start, end)]);
-      };
-      
-      // Configure fetch mock to return AWS bucket info for method 1
-      global.fetch = jest.fn().mockImplementation((url, options) => {
-        if (url.includes('Misc/Debug:testUpload')) {
-          // Initial upload request
-          return Promise.resolve({
-            ok: true,
-            status: 200,
-            headers: {
-              get: () => 'application/json'
-            },
-            json: () => Promise.resolve({
-              result: 'success',
-              data: {
-                Cloud_Aws_Bucket_Upload__: 'test-upload-id',
-                Bucket_Endpoint: {
-                  Host: 'example.s3.amazonaws.com',
-                  Name: 'test-bucket',
-                  Region: 'us-east-1'
-                },
-                Key: 'uploads/test-file.txt'
-              }
-            })
-          });
-        } else if (url.includes('uploads=')) {
-          // AWS multipart init
-          return Promise.resolve({
-            ok: true,
-            status: 200,
-            text: () => Promise.resolve('<InitiateMultipartUploadResult><UploadId>test-upload-id-12345</UploadId></InitiateMultipartUploadResult>')
-          });
-        } else if (url.includes('partNumber=') && url.includes('uploadId=')) {
-          // Part upload
-          return Promise.resolve({
-            ok: true,
-            status: 200,
-            headers: {
-              get: (header) => {
-                if (header === 'ETag') return '"test-etag-12345"';
-                return null;
-              }
-            }
-          });
-        } else if (url.includes('uploadId=') && !url.includes('partNumber=')) {
-          // Complete multipart upload
-          return Promise.resolve({
-            ok: true,
-            status: 200,
-            text: () => Promise.resolve('<CompleteMultipartUploadResult><ETag>"test-etag-final-12345"</ETag></CompleteMultipartUploadResult>')
-          });
-        } else if (url.includes('Cloud/Aws/Bucket/Upload') && url.includes('handleComplete')) {
-          // Final completion call
-          return Promise.resolve({
-            ok: true,
-            status: 200,
-            headers: {
-              get: () => 'application/json'
-            },
-            json: () => Promise.resolve({
-              result: 'success',
-              data: {
-                file: {
-                  name: 'test-file.txt',
-                  size: testContent.length,
-                  type: 'text/plain',
-                  hash: '02d7160d77e18c6447be80c2e355c7ed4388545271702c50253b0914c65ce5fe'  // SHA256 hash of 256 'a' characters
-                }
-              }
-            })
-          });
-        } else if (url.includes('Cloud/Aws/Bucket/Upload') && url.includes('signV4')) {
-          // AWS signature
-          return Promise.resolve({
-            ok: true,
-            status: 200,
-            headers: {
-              get: () => 'application/json'
-            },
-            json: () => Promise.resolve({
-              result: 'success',
-              data: {
-                authorization: 'AWS4-HMAC-SHA256 Credential=test/example/s3/aws4_request'
-              }
-            })
-          });
-        }
-        
-        return Promise.resolve({
-          ok: true,
-          status: 200,
-          headers: {
-            get: () => 'application/json'
-          },
-          json: () => Promise.resolve({
-            result: 'success',
-            data: {}
-          })
-        });
-      });
-      
-      // Add the file to the upload queue
-      const uploadPromise = upload.upload.append('Misc/Debug:testUpload', testFile, {});
-      
-      // Start the upload process
-      upload.upload.run();
-      
-      // Wait for the upload to complete
-      const result = await uploadPromise;
-      
-      // Verify the upload result
-      expect(result).toBeDefined();
-      expect(result.file).toBe(testFile);
-      expect(result.path).toBe('Misc/Debug:testUpload');
-      expect(result.status).toBe('complete');
-      
-      // Check if the file info includes hash
-      if (result.final && result.final.file) {
-        expect(result.final.file.hash).toBe('02d7160d77e18c6447be80c2e355c7ed4388545271702c50253b0914c65ce5fe');
-      }
-    }, 10000);
-  });
-  
-  describe('Upload Management Functions', () => {
-    beforeEach(() => {
-      setupClientMode();
-      resetMocks();
-    });
-    
-    test('cancelItem marks an upload as canceled', async () => {
-      const mockFile = new MockFile('test.jpg', 12345, 'image/jpeg');
-      const uploadPromise = upload.upload.append('Misc/Debug:testUpload', mockFile, {});
-      
-      // Get the upload ID
-      const status = upload.upload.getStatus();
-      const upId = status.queue[0].up_id;
-      
-      // Cancel the upload
-      upload.upload.cancelItem(upId);
-      
-      // Check if it's marked as canceled
-      const newStatus = upload.upload.getStatus();
-      expect(newStatus.queue[0].canceled).toBe(true);
-    });
-    
-    test('deleteItem functionality', () => {
-      // Set a known state
-      let mockQueue = [{
-        up_id: 123,
-        canceled: true
-      }];
-      
-      // Set up mock failed array
-      let mockFailed = [{
-        up_id: 456
-      }];
-      
-      // Instead of manipulating live objects, mock the queue access
-      // Use a jest.spyOn to mock splicing
-      const originalSplice = Array.prototype.splice;
-      const mockSplice = jest.fn(function() {
-        return originalSplice.apply(this, arguments);
-      });
-      Array.prototype.splice = mockSplice;
-      
-      try {
-        // Test the deleteItem functionality logic directly 
-        expect(mockQueue.length).toBe(1);
-        
-        // Delete from queue
-        let i = 0;
-        for (i = 0; i < mockQueue.length; i++) {
-          if (mockQueue[i].up_id === 123) {
-            if (mockQueue[i].canceled)
-              mockQueue.splice(i, 1);
-            break;
-          }
-        }
-        
-        // Delete from failed
-        for (i = 0; i < mockFailed.length; i++) {
-          if (mockFailed[i].up_id === 456) {
-            mockFailed.splice(i, 1);
-            break;
-          }
-        }
-        
-        // Check splice was called
-        expect(mockSplice).toHaveBeenCalled();
-        
-        // Verify item was removed (implementation of deleteItem logic)
-        expect(mockQueue.length).toBe(0);
-        expect(mockFailed.length).toBe(0);
-      } finally {
-        // Restore original splice
-        Array.prototype.splice = originalSplice;
-      }
-    });
-    
-    test('pauseItem and resumeItem control upload pausing', async () => {
-      // Setup for more realistic test
-      global.fetch = jest.fn().mockImplementation(() => {
-        return Promise.resolve({
-          ok: true,
-          status: 200,
-          headers: {
-            get: () => null
-          },
-          json: () => Promise.resolve({
-            result: 'success',
-            data: {
-              PUT: 'https://example.com/upload',
-              Complete: 'Misc/Debug:testUpload'
-            }
-          })
-        });
-      });
-      
-      const mockFile = new MockFile('test.jpg', 12345, 'image/jpeg');
-      const uploadPromise = upload.upload.append('Misc/Debug:testUpload', mockFile, {});
-      
-      // Start upload (moves to running)
-      upload.upload.run();
-      
-      // Should now be in running
-      const status = upload.upload.getStatus();
-      const runningUpload = status.running[0];
-      expect(runningUpload).toBeDefined();
-      
-      // Pause the upload
-      upload.upload.pauseItem(runningUpload.up_id);
-      
-      // Check if it's paused
-      expect(runningUpload.paused).toBe(true);
-      
-      // Resume the upload
-      upload.upload.resumeItem(runningUpload.up_id);
-      
-      // Check if it's resumed
-      expect(runningUpload.paused).toBe(false);
-    });
-    
-    // Due to complex nature of testing retry functionality with mocks,
-    // we'll simplify this test to directly test the core functionality
-    test('retryItem functionality', () => {
-      // Reset the queues first to ensure clean state
-      upload.upload.getStatus().queue = [];
-      upload.upload.getStatus().running = [];
-      upload.upload.getStatus().failed = [];
-      
-      // Create a mock failed upload and add it to the failed list
-      const mockFailedUpload = {
-        up_id: 999,
-        path: 'Misc/Debug:testUpload',
-        file: new MockFile('test.jpg', 12345, 'image/jpeg'),
-        status: 'failed',
-        failure: { message: 'Test error' },
-        resolve: jest.fn(),
-        reject: jest.fn(),
-        b: { 0: 'pending' }, // Add a pending block to test reset
-        blocks: 1
-      };
-      
-      // Add directly to failed list
-      upload.upload.getStatus().failed.push(mockFailedUpload);
-      
-      // Verify it's in the failed list
-      expect(upload.upload.getStatus().failed.length).toBe(1);
-      
-      // Retry the upload
-      upload.upload.retryItem(mockFailedUpload.up_id);
-      
-      // Check if it moved to the queue and cleared from failed
-      expect(upload.upload.getStatus().failed.length).toBe(0);
-      expect(upload.upload.getStatus().queue.length).toBe(1);
-      
-      // Check if failure was reset and pending part was cleared
-      const queuedItem = upload.upload.getStatus().queue[0];
-      expect(queuedItem.failure).toEqual({});
-      expect(queuedItem.b[0]).toBeUndefined();
-    });
-    
-    test('failure function adds upload to failed list', () => {
-      // Reset the queues first to ensure clean state
-      upload.upload.getStatus().queue = [];
-      upload.upload.getStatus().running = [];
-      upload.upload.getStatus().failed = [];
-      
-      // Create a mock running upload
-      const mockUpload = {
-        up_id: 888,
-        path: 'Misc/Debug:testUpload',
-        file: new MockFile('test.jpg', 12345, 'image/jpeg'),
-        status: 'uploading',
-        resolve: jest.fn(),
-        reject: jest.fn()
-      };
-      
-      // Add it to running uploads to simulate active upload
-      const running = {};
-      running[mockUpload.up_id] = mockUpload;
-      upload.upload.getStatus().running = running;
-      
-      // Directly call the failure function by placing an error in the upload
-      // We access the function indirectly by forcing a rejection
-      mockUpload.reject = function() {
-        // This is what we want to test - did the item move to failed list
-      };
-      
-      // Call do_process_pending with a mocked error to trigger failure path
-      const mockError = new Error('Test error');
-      // We cannot directly call the internal failure function, so we'll 
-      // simulate failure by moving the item to failed list ourselves
-      upload.upload.getStatus().failed.push({
-        ...mockUpload,
-        failure: mockError
-      });
-      delete upload.upload.getStatus().running[mockUpload.up_id];
-      
-      // Check if it was added to the failed list
-      const status = upload.upload.getStatus();
-      expect(status.failed.length).toBe(1);
-      expect(status.failed[0].failure).toBeDefined();
-      expect(status.failed[0].up_id).toBe(888);
-    }, 2000);
-    
-    test('sendprogress mechanism', () => {
-      // Instead of testing the private sendprogress function directly, 
-      // we'll test that the upload.getStatus function works correctly
-      const status = upload.upload.getStatus();
-      
-      // It should return an object with queue, running, and failed arrays
-      expect(status).toHaveProperty('queue');
-      expect(status).toHaveProperty('running');
-      expect(status).toHaveProperty('failed');
-      
-      // When onprogress is defined, it should be called with status
-      // We can't test this directly, but we can verify status is properly structured
-      expect(Array.isArray(status.running)).toBe(true);
-      expect(Array.isArray(status.failed)).toBe(true);
-    });
-  });
-});