jiapu/tests/upload-pages.test.js

const assert = require('assert');
const UploadPages = require('../public/js/upload-pages.js');

async function run() {
  assert.deepStrictEqual(UploadPages.normalizeUploadResult({
    ossId: 2060001,
    fileName: 'cover.jpg',
    url: 'https://cdn.example.test/cover.jpg'
  }), {
    ossId: '2060001',
    fileName: 'cover.jpg',
    url: 'https://cdn.example.test/cover.jpg'
  });

  assert.deepStrictEqual(UploadPages.normalizeUploadResult({
    id: 2060002,
    originalName: 'old.png',
    fileUrl: '/old.png'
  }), {
    ossId: '2060002',
    fileName: 'old.png',
    url: '/old.png'
  });

  assert.strictEqual(UploadPages.mergeOssIds('', '2060001', false), '2060001');
  assert.strictEqual(UploadPages.mergeOssIds('2060001', '2060002', true), '2060001,2060002');
  assert.strictEqual(UploadPages.mergeOssIds('2060001', '2060001', true), '2060001');
  assert.strictEqual(UploadPages.buildUploadStatus('cover.jpg', '2060001'), 'cover.jpg 上传完成，OSS ID：2060001');

  assert.strictEqual(UploadPages.getUploadMode(4194304), 'single');
  assert.strictEqual(UploadPages.getUploadMode(4194305), 'resumable');
  assert.deepStrictEqual(UploadPages.buildResumableInitBody({
    name: 'avatar.jpg',
    size: 5242880,
    type: 'image/jpeg'
  }, 'file-md5', 4194304, {
    bizType: 'avatar',
    usageScene: 'profile_avatar'
  }), {
    fileName: 'avatar.jpg',
    fileSize: 5242880,
    fileMd5: 'file-md5',
    contentType: 'image/jpeg',
    chunkSize: 4194304,
    totalChunks: 2,
    bizType: 'avatar',
    usageScene: 'profile_avatar'
  });

  const calls = [];
  const file = {
    name: 'avatar.jpg',
    size: 8,
    type: 'image/jpeg',
    slice(start, end) {
      return { start, end, size: end - start };
    }
  };
  const api = {
    initResumableUpload(body) {
      calls.push({ type: 'init', body });
      return Promise.resolve({ uploadId: 'upload-1' });
    },
    uploadChunk(body) {
      calls.push({ type: 'chunk', body });
      return Promise.resolve();
    },
    completeResumableUpload(body) {
      calls.push({ type: 'complete', body });
      return Promise.resolve({ ossId: 2060001 });
    }
  };
  const result = await UploadPages.uploadResumable(api, file, {
    chunkSize: 4,
    bizType: 'avatar',
    usageScene: 'profile_avatar',
    hashBlob(blob) {
      return Promise.resolve(blob === file ? 'file-md5' : `chunk-${blob.start}`);
    }
  });

  assert.deepStrictEqual(result, { ossId: 2060001 });
  assert.deepStrictEqual(calls, [
    {
      type: 'init',
      body: {
        fileName: 'avatar.jpg',
        fileSize: 8,
        fileMd5: 'file-md5',
        contentType: 'image/jpeg',
        chunkSize: 4,
        totalChunks: 2,
        bizType: 'avatar',
        usageScene: 'profile_avatar'
      }
    },
    {
      type: 'chunk',
      body: {
        uploadId: 'upload-1',
        chunkIndex: 0,
        chunkMd5: 'chunk-0',
        file: { start: 0, end: 4, size: 4 }
      }
    },
    {
      type: 'chunk',
      body: {
        uploadId: 'upload-1',
        chunkIndex: 1,
        chunkMd5: 'chunk-4',
        file: { start: 4, end: 8, size: 4 }
      }
    },
    {
      type: 'complete',
      body: {
        uploadId: 'upload-1',
        fileMd5: 'file-md5',
        fileSize: 8
      }
    }
  ]);

  let singleUploadCalled = false;
  const singleResult = await UploadPages.uploadFileForPage({
    uploadFile(value) {
      singleUploadCalled = value.size === 4;
      return Promise.resolve({ ossId: 2060002 });
    }
  }, { size: 4 }, {
    mode: 'auto',
    chunkSize: 4
  });

  assert.strictEqual(singleUploadCalled, true);
  assert.deepStrictEqual(singleResult, { ossId: 2060002 });

  console.log('upload-pages tests passed');
}

run().catch((error) => {
  console.error(error);
  process.exitCode = 1;
});