test(utils): add unit tests for utility functions

Add comprehensive unit tests for the utils module to ensure
proper functionality and prevent regressions.

新增对 utils 模块的全面单元测试，以确保功能正常并防止回归问题。

Change-Id: Ia91ad346ad2036bcc6a3dd81c9b055c7810e5443
Signed-off-by: OhYee <oyohyee@oyohyee.com>

Author: OhYee

tests/unittests/utils.test.ts

@@ -0,0 +1,158 @@
+import { Config } from '../../src/utils/config';
+import {
+  AgentRunError,
+  HTTPError,
+  ResourceNotExistError,
+  ResourceAlreadyExistError,
+  ClientError,
+} from '../../src/utils/exception';
+import * as model from '../../src/utils/model';
+import { mixin } from '../../src/utils/mixin';
+import {
+  updateObjectProperties,
+  listAllResourcesFunction,
+  ResourceBase,
+} from '../../src/utils/resource';
+import { DataAPI, ResourceType } from '../../src/utils/data-api';
+
+describe('utils - config', () => {
+  test('config defaults and data/control/devs endpoints and accountId error', () => {
+    // ensure we don't rely on external environment variables for accountId test
+    const cfg = new Config({ regionId: 'cn-test', accountId: 'explicit' });
+    expect(cfg.regionId).toBe('cn-test');
+    expect(cfg.timeout).toBe(600000);
+    expect(cfg.readTimeout).toBe(100000000);
+    // controlEndpoint default builds from region
+    expect(cfg.controlEndpoint).toContain('agentrun.cn-test.aliyuncs.com');
+
+    // when accountId explicitly set to empty string, getter should throw
+    const cfgNoAccount = new Config({ regionId: 'cn-test', accountId: '' });
+    expect(() => cfgNoAccount.accountId).toThrow();
+  });
+
+  test('withConfigs merge and headers merging', () => {
+    // avoid asserting on accessKey values because CI/dev environment may set env vars
+    const a = new Config({ accessKeyId: 'a', headers: { a: '1' } });
+    const b = new Config({ accessKeySecret: 's', headers: { b: '2' } });
+    const merged = Config.withConfigs(a, b);
+    expect(merged.headers).toMatchObject({ a: '1', b: '2' });
+  });
+});
+
+describe('utils - exception', () => {
+  test('HTTPError toResourceError branches', () => {
+    const e404 = new HTTPError(404, 'not');
+    const r = e404.toResourceError('foo', 'id');
+    expect(r).toBeInstanceOf(ResourceNotExistError);
+
+    const e409 = new HTTPError(409, 'conflict');
+    const r2 = e409.toResourceError('foo');
+    expect(r2).toBeInstanceOf(ResourceAlreadyExistError);
+
+    const e400 = new HTTPError(400, 'already exists somewhere');
+    const r3 = e400.toResourceError('x');
+    expect(r3).toBeInstanceOf(ResourceAlreadyExistError);
+
+    const eOther = new HTTPError(418, "I'm a teapot");
+    const r4 = eOther.toResourceError('x');
+    expect(r4).toBe(eOther);
+  });
+});
+
+describe('utils - model functions', () => {
+  test('case conversion and removeUndefined and fromInnerObject', () => {
+    expect(model.toSnakeCase('helloWorld')).toBe('hello_world');
+    expect(model.toCamelCase('hello_world')).toBe('helloWorld');
+
+    const nested = { aValue: 1, inner: { nestedValue: 2 }, arr: [{ subVal: 3 }] };
+    const snake = model.toSnakeCaseKeys(nested as any);
+    expect(Object.keys(snake)).toContain('a_value');
+    expect((snake as any).inner).toBeDefined();
+
+    const camel = model.toCamelCaseKeys({ a_value: 1, inner: { nested_value: 2 }, arr: [{ sub_val: 3 }] } as any);
+    expect(Object.keys(camel)).toContain('aValue');
+
+    expect(model.removeUndefined({ a: 1, b: undefined })).toEqual({ a: 1 });
+
+    // isFinalStatus true for READY and true for undefined
+    expect(model.isFinalStatus('READY')).toBe(true);
+    expect(model.isFinalStatus(undefined)).toBe(true);
+
+    // fromInnerObject merges extra
+    const obj = { x: 1 };
+    const merged = model.fromInnerObject(obj, { y: 2 });
+    expect((merged as any).y).toBe(2);
+  });
+});
+
+describe('utils - mixin', () => {
+  test('mixin copies prototype and static properties', () => {
+    class A {
+      static staticA = 1;
+      protoA() { return 'a'; }
+    }
+
+    class B { }
+
+    const Mixed = mixin(A as any, B as any) as any;
+    // static prop copied
+    expect(Mixed.staticA).toBe(1);
+    // prototype method available
+    const inst = new Mixed();
+    expect(typeof inst.protoA).toBe('function');
+  });
+});
+
+describe('utils - resource helpers', () => {
+  test('updateObjectProperties only copies data fields', () => {
+    const target: any = {};
+    const src: any = { a: 1, b: () => 2, _c: 3 };
+    updateObjectProperties(target, src);
+    expect(target.a).toBe(1);
+    expect(target.b).toBeUndefined();
+    expect(target._c).toBeUndefined();
+  });
+
+  test('listAllResourcesFunction paginates and dedups', async () => {
+    // listAllResourcesFunction uses a pageSize of 50 internally.
+    // To exercise pagination we return 50 items on first call and a small last page on second.
+    const firstPage = Array.from({ length: 50 }, (_, i) => ({ uniqIdCallback: () => `${i + 1}` }));
+    const secondPage = [{ uniqIdCallback: () => '50' }, { uniqIdCallback: () => '51' }];
+    const pages = [firstPage, secondPage];
+    let called = 0;
+    const list = async (params?: any) => {
+      return pages[called++] || [];
+    };
+
+    const all = listAllResourcesFunction(list as any);
+    const res = await all({});
+    // expect unique ids from 1..51 -> 51 results
+    expect(res.length).toBe(51);
+  });
+});
+
+describe('utils - data-api small surface', () => {
+  test('withPath merges queries and arrays', () => {
+    const cfg = new Config({ token: 't', accountId: 'acct' });
+    const d = new DataAPI('name', ResourceType.Runtime, cfg, 'ns');
+    const url = d.withPath('/some/path', { a: [1, 2], b: 'x' });
+    expect(url).toContain('a=1');
+    expect(url).toContain('a=2');
+    expect(url).toContain('b=x');
+  });
+
+  test('prepareRequest handles body types and sets token header', async () => {
+    const cfg = new Config({ token: 'tok', accountId: 'acct' });
+    const d = new DataAPI('name', ResourceType.Runtime, cfg, 'ns') as any;
+
+    const r1 = await d.prepareRequest('POST', 'https://example.com/x', { a: 1 }, { H: 'v' });
+    expect(r1.body).toBeDefined();
+    expect(r1.headers['Agentrun-Access-Token']).toBe('tok');
+
+    const r2 = await d.prepareRequest('PUT', 'https://example.com/x', Buffer.from('hi'), {});
+    expect(Buffer.isBuffer(r2.body)).toBe(true);
+
+    const r3 = await d.prepareRequest('PATCH', 'https://example.com/x', 'rawtext', {});
+    expect(r3.body).toBe('rawtext');
+  });
+});