feat: manually mirror opencoze's code from bytedance

Change-Id: I09a73aadda978ad9511264a756b2ce51f5761adf

frontend/packages/arch/bot-http/__tests__/axios.test.ts

@@ -0,0 +1,249 @@
+/*
+ * Copyright 2025 coze-dev Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+ 
+import MockAdapter from 'axios-mock-adapter';
+import { AxiosError, isAxiosError } from 'axios';
+import { redirect } from '@coze-arch/web-context';
+
+import { emitAPIErrorEvent } from '../src/eventbus';
+import { axiosInstance } from '../src/axios'; // your import path
+import { ApiError, reportHttpError, ReportEventNames } from '../src/api-error';
+
+// This sets the mock adapter on the default instance
+const mock = new MockAdapter(axiosInstance);
+
+vi.mock('@coze-arch/logger', () => ({
+  logger: {
+    info: vi.fn(),
+    persist: {
+      error: vi.fn(),
+    },
+  },
+}));
+
+vi.mock('../src/eventbus', () => ({
+  emitAPIErrorEvent: vi.fn(),
+  APIErrorEvent: {
+    UNAUTHORIZED: 'unauthorized',
+    COUNTRY_RESTRICTED: 'countryRestricted',
+    COZE_TOKEN_INSUFFICIENT: 'cozeTokenInsufficient',
+  },
+}));
+vi.mock('../src/api-error', async () => {
+  const actual = (await vi.importActual('../src/api-error')) as any;
+
+  return {
+    ...actual,
+    reportHttpError: vi.fn(),
+  };
+});
+
+vi.mock('@coze-arch/web-context', () => ({
+  redirect: vi.fn(),
+}));
+
+describe('axiosInstance', () => {
+  beforeEach(() => {
+    mock.reset();
+    vi.clearAllMocks();
+  });
+  it('should fetch users', async () => {
+    // Mock any GET request to /users
+    // arguments for reply are (status, data, headers)
+    mock.onGet('/users').reply(200, {
+      code: 0,
+      data: { users: [{ id: 1, name: 'John Smith' }] },
+    });
+
+    const response = await axiosInstance.get('/users');
+
+    expect(response.status).toBe(200);
+    expect(response.data.data.users[0].id).toBe(1);
+  });
+
+  it('should throw api errors if code not equal to zero', async () => {
+    mock.onGet('/users').reply(200, {
+      code: 1,
+      msg: 'fake error',
+    });
+
+    await expect(() => axiosInstance.get('/users')).rejects.toThrowError(
+      ApiError,
+    );
+    expect(reportHttpError).toBeCalledWith(
+      ReportEventNames.ApiError,
+      expect.any(ApiError),
+    );
+  });
+
+  it('should emit special events when not login', async () => {
+    mock.onGet('/users').reply(200, {
+      // 700012006 => not login
+      code: 700012006,
+      msg: 'fake error',
+    });
+
+    await expect(axiosInstance.get('/users')).rejects.toThrow(ApiError);
+    expect(emitAPIErrorEvent).toBeCalledWith(
+      'unauthorized',
+      expect.any(ApiError),
+    );
+    expect(reportHttpError).toBeCalledWith(
+      ReportEventNames.ApiError,
+      expect.any(ApiError),
+    );
+
+    mock.onGet('/users2').reply(200, {
+      // 700012015 => COUNTRY_RESTRICTED
+      code: 700012015,
+      msg: 'fake error',
+    });
+
+    await expect(() => axiosInstance.get('/users2')).rejects.toThrowError(
+      ApiError,
+    );
+    expect(emitAPIErrorEvent).toBeCalledWith(
+      'countryRestricted',
+      expect.any(ApiError),
+    );
+    expect(reportHttpError).toBeCalledWith(
+      ReportEventNames.ApiError,
+      expect.any(ApiError),
+    );
+
+    mock.onGet('/users4').reply(200, {
+      // 702082020 => COZE_TOKEN_INSUFFICIENT
+      code: 702082020,
+      msg: 'fake error',
+    });
+
+    await expect(axiosInstance.get('/users4')).rejects.toThrow(ApiError);
+    expect(emitAPIErrorEvent).toBeCalledWith(
+      'cozeTokenInsufficient',
+      expect.any(ApiError),
+    );
+    expect(reportHttpError).toBeCalledWith(
+      ReportEventNames.ApiError,
+      expect.any(ApiError),
+    );
+
+    mock.onGet('/users5').reply(200, {
+      // 702095072 => COZE_TOKEN_INSUFFICIENT
+      code: 702095072,
+      msg: 'fake error',
+    });
+
+    await expect(axiosInstance.get('/users5')).rejects.toThrow(ApiError);
+    expect(emitAPIErrorEvent).toBeCalledWith(
+      'cozeTokenInsufficient',
+      expect.any(ApiError),
+    );
+    expect(reportHttpError).toBeCalledWith(
+      ReportEventNames.ApiError,
+      expect.any(ApiError),
+    );
+  });
+
+  it('should logger error when network error', async () => {
+    mock.onGet('/users3').networkError();
+    try {
+      await expect(() => axiosInstance.get('/users3')).rejects.toThrow(Error);
+    } catch (error) {
+      expect(isAxiosError(error)).toBe(true);
+      expect(reportHttpError).toBeCalledWith(
+        ReportEventNames.NetworkError,
+        expect.any(AxiosError),
+      );
+    }
+  });
+
+  it('should handle unauthorized response', async () => {
+    mock.onGet('/users').reply(401, {
+      code: 401,
+      data: {
+        redirect_uri: '/login',
+      },
+      message: 'Unauthorized',
+    });
+
+    await expect(() => axiosInstance.get('/users')).rejects.toThrowError(Error);
+    expect(reportHttpError).toBeCalledWith(
+      ReportEventNames.NetworkError,
+      expect.any(Error),
+    );
+
+    expect(redirect).toBeCalledWith('/login');
+  });
+
+  it('should set content-type header for post request', async () => {
+    mock.onPost('/api/mock').reply(200, {
+      code: 0,
+      data: {},
+    });
+    const response = await axiosInstance.post('/api/mock');
+    expect(response.config.headers['Content-Type']).toBe('application/json');
+    expect(response.config.data).toBe(JSON.stringify({}));
+  });
+  it('should set content-type header for get request', async () => {
+    mock.onGet('/api/mock').reply(200, {
+      code: 0,
+      data: {},
+    });
+    const response = await axiosInstance.request({
+      url: '/api/mock',
+      method: 'GET',
+    });
+    expect(response.config.headers['Content-Type']).toBe('application/json');
+  });
+  it("won't override exist data", async () => {
+    mock.onPost('/api/mock').reply(200, {
+      code: 0,
+      data: {},
+    });
+    const response = await axiosInstance.post('/api/mock', { data: '1' });
+    expect(response.config.headers['Content-Type']).toBe('application/json');
+    expect(response.config.data).toBe(JSON.stringify({ data: '1' }));
+  });
+  it("won't override exist content-type header", async () => {
+    mock.onPost('/api/mock').reply(200, {
+      code: 0,
+      data: {},
+    });
+    const response = await axiosInstance.post('/api/mock', undefined, {
+      headers: {
+        'Content-Type': 'text/plain',
+      },
+    });
+    expect(response.config.headers['Content-Type']).toBe('text/plain');
+  });
+  it('should set handle object header', async () => {
+    mock.onPost('/api/mock').reply(200, {
+      code: 0,
+      data: {},
+    });
+
+    axiosInstance.interceptors.request.use(config => {
+      // @ts-expect-error just for test
+      config.headers = { 'Content-Type': 'application/json' };
+      return config;
+    });
+    const response = await axiosInstance.request({
+      url: '/api/mock',
+      method: 'POST',
+    });
+    expect(response.config.headers['Content-Type']).toBe('application/json');
+  });
+});