@stellaris/vite-plugin-tencent-oss/test/plugin.test.js

Upload the production files bundled in the project to Tencent CSS, except for html

// 简单的测试框架实现
const describe = (name, fn) => {
  console.log(`\n📝 ${name}`);
  fn();
};

const it = async (name, fn) => {
  try {
    await fn();
    console.log(`  ✅ ${name}`);
  } catch (error) {
    console.log(`  ❌ ${name}`);
    console.log(`     ${error.message}`);
  }
};

const expect = (actual) => ({
  toBe: (expected) => {
    if (actual !== expected) {
      throw new Error(`Expected ${expected}, but got ${actual}`);
    }
  },
  toEqual: (expected) => {
    if (JSON.stringify(actual) !== JSON.stringify(expected)) {
      throw new Error(
        `Expected ${JSON.stringify(expected)}, but got ${JSON.stringify(
          actual
        )}`
      );
    }
  },
  toBeDefined: () => {
    if (actual === undefined) {
      throw new Error(`Expected value to be defined, but got undefined`);
    }
  },
  toBeUndefined: () => {
    if (actual !== undefined) {
      throw new Error(`Expected value to be undefined, but got ${actual}`);
    }
  },
  toThrow: (expectedMessage) => {
    try {
      actual();
      throw new Error(`Expected function to throw, but it didn't`);
    } catch (error) {
      if (expectedMessage && !error.message.includes(expectedMessage)) {
        throw new Error(
          `Expected error message to contain "${expectedMessage}", but got "${error.message}"`
        );
      }
    }
  },
  rejects: {
    toThrow: async (expectedMessage) => {
      try {
        await actual;
        throw new Error(`Expected promise to reject, but it resolved`);
      } catch (error) {
        if (expectedMessage && !error.message.includes(expectedMessage)) {
          throw new Error(
            `Expected error message to contain "${expectedMessage}", but got "${error.message}"`
          );
        }
      }
    },
  },
});

const beforeEach = (fn) => {
  // 简单实现，在每个测试前运行
  fn();
};
import path from "path";
import { fileURLToPath } from "url";
import vitePluginTencentOss from "../index.js";

const __filename = fileURLToPath(import.meta.url);
const __dirname = path.dirname(__filename);

describe("vitePluginTencentOss", () => {
  let mockConfig;

  beforeEach(() => {
    mockConfig = {
      base: "https://static.example.com/app/",
      build: {
        outDir: "dist",
        ssrManifest: false,
        ssr: false,
      },
    };
  });

  it("应该返回正确的插件配置", () => {
    const options = {
      secretId: "test-id",
      secretKey: "test-key",
      bucket: "test-bucket",
      region: "ap-beijing",
      enabled: true,
    };

    const plugin = vitePluginTencentOss(options);

    expect(plugin).toBeDefined();
    expect(plugin.name).toBe("vite-plugin-tencent-oss");
    expect(plugin.enforce).toBe("post");
    expect(plugin.apply).toBe("build");
    expect(typeof plugin.configResolved).toBe("function");
    expect(typeof plugin.closeBundle).toBe("function");
  });

  it("当 enabled 为 false 时应该返回 undefined", () => {
    const options = {
      secretId: "test-id",
      secretKey: "test-key",
      bucket: "test-bucket",
      region: "ap-beijing",
      enabled: false,
    };

    const plugin = vitePluginTencentOss(options);
    expect(plugin).toBeUndefined();
  });

  it("缺少必要参数时应该抛出错误", async () => {
    const options = {
      secretId: "test-id",
      // 缺少 secretKey
      bucket: "test-bucket",
      region: "ap-beijing",
      enabled: true,
    };

    const plugin = vitePluginTencentOss(options);
    plugin.configResolved(mockConfig);

    await expect(plugin.closeBundle()).rejects.toThrow("关键参数缺失");
  });

  it("应该正确处理 configResolved", () => {
    const options = {
      secretId: "test-id",
      secretKey: "test-key",
      bucket: "test-bucket",
      region: "ap-beijing",
      enabled: true,
    };

    const plugin = vitePluginTencentOss(options);
    plugin.configResolved(mockConfig);

    // 这里我们无法直接测试内部状态，但可以确保没有抛出错误
    expect(plugin.configResolved).toBeDefined();
  });
});

describe("separateFilesByGlobs", () => {
  // 我们需要从 index.js 中导出这个函数来测试
  // 暂时跳过，在改进错误处理时会处理
});

describe("路径处理测试", () => {
  it("应该正确处理 URL 路径", () => {
    const baseUrl = "https://static.example.com/app/";
    const url = new URL(baseUrl);

    expect(url.pathname).toBe("/app/");
    expect(url.origin).toBe("https://static.example.com");
  });

  it("应该正确处理文件路径", () => {
    const outDirPath = "/project/dist";
    const fileFullPath = "/project/dist/assets/index.123.js";
    const filePath = fileFullPath.split(outDirPath)[1];

    expect(filePath).toBe("/assets/index.123.js");
  });

  it("应该正确构建 OSS 路径", () => {
    const ossBasePath = "/app/";
    const filePath = "/assets/index.123.js";
    const ossFilePath = ossBasePath.replace(/\/$/, "") + filePath;

    expect(ossFilePath).toBe("/app/assets/index.123.js");
  });
});