现在有的接口对接测试完成

2026-07-25 19:19:36 +08:00
parent 8870136d1b
commit 817d85e117
59 changed files with 26623 additions and 1576 deletions
@@ -25,10 +25,12 @@ test('API client exposes latest document-defined PC operations', () => {
    'clientId', 'tenantId', 'tokenKey', 'getToken', 'setToken', 'clearToken', 'buildApiUrl',
    'register', 'login', 'loginBySms', 'sendSmsCode',
    'currentProfile', 'updateProfile', 'changePassword', 'resetPassword', 'changePhone',
-    'deactivateAccount', 'logout', 'uploadFile', 'initResumableUpload', 'uploadResumableChunk',
-    'completeResumableUpload', 'createFileReference', 'deleteFileReference',
-    'captchaRequirement', 'captchaChallenge', 'captchaVerify',
+    'deactivateAccount', 'logout', 'initResumableUpload', 'uploadResumableChunk',
+    'completeResumableUpload',
+    'captchaRequirement', 'captchaChallenge', 'captchaVerify', 'captchaChallengeUrl', 'captchaVerifyUrl',
    'regionChildren', 'regionPath', 'regionSearch', 'regionDetail',
+    'genealogyQuota',
+    'notifications', 'unreadNotificationCount', 'markNotificationRead', 'markAllNotificationsRead',
    'feeds', 'feedsPage', 'feedDetail', 'createFeed', 'updateFeed', 'deleteFeed',
    'likeFeed', 'unlikeFeed', 'feedComments', 'feedCommentsPage', 'createFeedComment',
    'feedCommentReplies', 'feedCommentRepliesPage', 'deleteFeedComment',
@@ -36,7 +38,12 @@ test('API client exposes latest document-defined PC operations', () => {
    'previewGenerationPoems', 'saveGenerationPoems',
    'lineagePersons', 'lineagePersonsPage', 'lineagePersonOptions', 'lineageTree',
    'createLineagePerson', 'lineagePersonDetail', 'updateLineagePerson', 'disableLineagePerson',
-    'createLineageChild', 'createLineageParent', 'createLineageSibling', 'createLineageSpouse'
+    'createLineageChild', 'createLineageParent', 'createLineageSibling', 'createLineageSpouse',
+    'growthRecords', 'createGrowthRecord', 'growthRecordDetail', 'updateGrowthRecord', 'deleteGrowthRecord',
+    'relativeRecords', 'createRelativeRecord', 'relativeRecordDetail', 'updateRelativeRecord', 'deleteRelativeRecord',
+    'memos', 'createMemo', 'memoDetail', 'updateMemo', 'deleteMemo', 'deleteMeritRecord',
+    'deleteArticle', 'deleteAlbum', 'deleteAlbumPhoto', 'deleteVideo', 'deleteCeremony', 'deleteCeremonyGift',
+    'replaceCeremonyInvitees', 'ceremonyInvitations', 'respondCeremonyInvitation', 'myCeremonyInvitations'
  ].sort();

  assert.deepEqual(Object.keys(client).sort(), allowed);
@@ -66,34 +73,80 @@ test('password login stores only the returned token', async () => {
  assert.equal(client.getToken(), 'access-token');
 });

-test('sending an SMS code uses the latest documented request fields', async () => {
+test('sending an SMS code uses the PC operation path and documented request body', async () => {
  const client = GenealogyApi.createClient({
    baseUrl: 'https://api.example.test',
    tokenStore: { getItem() { return null; }, setItem() {}, removeItem() {} },
    axiosInstance: {
      request(config) {
-        assert.equal(config.url, '/genealogy/pc/auth/sms/code');
+        assert.equal(config.url, '/genealogy/pc/auth/sms/sms-login/code');
        assert.deepEqual(config.data, {
          grantType: 'sms',
          tenantId: '000000',
-          clientId: 'ced7e5f0498645c6ec642dcf450b036f',
          phone: '13800000000',
-          sceneCode: 'PC_SMS_LOGIN',
          validToken: 'captcha-ticket'
        });
+        assert.equal(config.headers.clientid, 'ced7e5f0498645c6ec642dcf450b036f');
        return Promise.resolve({ data: { code: 200, data: null } });
      }
    }
  });

-  await client.sendSmsCode({
+  await client.sendSmsCode('sms-login', {
    phone: '13800000000',
-    sceneCode: 'PC_SMS_LOGIN',
    validToken: 'captcha-ticket'
  });
 });

-test('password reset adds the documented grant, tenant and client fields', async () => {
+test('PC verification operations keep operationCode in the path and clientid out of query and body', async () => {
+  const calls = [];
+  const client = GenealogyApi.createClient({
+    baseUrl: 'https://api.example.test',
+    tokenStore: { getItem() { return null; }, setItem() {}, removeItem() {} },
+    axiosInstance: {
+      request(config) {
+        calls.push(config);
+        return Promise.resolve({ data: { code: 200, data: { required: false } } });
+      }
+    }
+  });
+  const challenge = { tenantId: '000000', subject: '13800000000' };
+  const verification = {
+    tenantId: '000000',
+    subject: '13800000000',
+    challengeId: 'challenge-1',
+    providerCode: 'tianai',
+    captchaType: 'SLIDER',
+    payload: { track: { left: 120, top: 0, trackList: [] } }
+  };
+
+  await client.captchaRequirement('sms-login', { subject: '13800000000' });
+  await client.captchaChallenge('sms-login', challenge);
+  await client.captchaVerify('sms-login', verification);
+
+  assert.deepEqual(calls.map((config) => [config.method, config.url, config.params, config.data]), [
+    ['get', '/genealogy/pc/auth/verification/sms-login/require', {
+      tenantId: '000000',
+      subject: '13800000000'
+    }, undefined],
+    ['post', '/genealogy/pc/auth/verification/sms-login/challenge', undefined, challenge],
+    ['post', '/genealogy/pc/auth/verification/sms-login/verify', undefined, verification]
+  ]);
+  calls.forEach((config) => {
+    assert.equal(config.headers.clientid, 'ced7e5f0498645c6ec642dcf450b036f');
+    assert.equal(config.headers.Authorization, undefined);
+  });
+  assert.equal(
+    client.captchaChallengeUrl('sms-login'),
+    'https://api.example.test/genealogy/pc/auth/verification/sms-login/challenge'
+  );
+  assert.equal(
+    client.captchaVerifyUrl('sms-login'),
+    'https://api.example.test/genealogy/pc/auth/verification/sms-login/verify'
+  );
+});
+
+test('password reset adds the documented grant and tenant fields without body clientId', async () => {
  const client = GenealogyApi.createClient({
    baseUrl: 'https://api.example.test',
    tokenStore: { getItem() { return null; }, setItem() {}, removeItem() {} },
@@ -105,7 +158,6 @@ test('password reset adds the documented grant, tenant and client fields', async
        assert.deepEqual(config.data, {
          grantType: 'password',
          tenantId: '000000',
-          clientId: 'ced7e5f0498645c6ec642dcf450b036f',
          phone: '13800000000',
          smsCode: '123456',
          newPassword: 'password-md5'
@@ -151,7 +203,6 @@ test('registration and SMS login use the PC auth endpoints with SMS fields', asy
      grantType: 'password',
      registerSource: 'PC',
      tenantId: '000000',
-      clientId: 'ced7e5f0498645c6ec642dcf450b036f',
      phone: '13800000000',
      smsCode: '123456',
      nickName: '小李',
@@ -160,14 +211,17 @@ test('registration and SMS login use the PC auth endpoints with SMS fields', asy
    ['post', '/genealogy/pc/auth/login/sms', {
      grantType: 'sms',
      tenantId: '000000',
-      clientId: 'ced7e5f0498645c6ec642dcf450b036f',
      phone: '13800000000',
      smsCode: '123456'
    }]
  ]);
+  calls.forEach((config) => {
+    assert.equal(config.headers.clientid, 'ced7e5f0498645c6ec642dcf450b036f');
+    assert.equal('clientId' in config.data, false);
+  });
 });

-test('phone change and account deactivation retain their PC request shapes', async () => {
+test('phone change and account deactivation retain PC bodies without clientId', async () => {
  let stored = 'access-token';
  const calls = [];
  const client = GenealogyApi.createClient({
@@ -191,14 +245,16 @@ test('phone change and account deactivation retain their PC request shapes', asy
  assert.deepEqual(calls.map((config) => [config.method, config.url, config.data]), [
    ['put', '/genealogy/pc/auth/phone', {
      phone: '13900000000',
-      smsCode: '123456',
-      clientId: 'ced7e5f0498645c6ec642dcf450b036f'
+      smsCode: '123456'
    }],
    ['post', '/genealogy/pc/auth/account/deactivate', {
-      smsCode: '654321',
-      clientId: 'ced7e5f0498645c6ec642dcf450b036f'
+      smsCode: '654321'
    }]
  ]);
+  calls.forEach((config) => {
+    assert.equal(config.headers.clientid, 'ced7e5f0498645c6ec642dcf450b036f');
+    assert.equal('clientId' in config.data, false);
+  });
  assert.equal(stored, '');
 });

@@ -233,7 +289,7 @@ test('region methods use PC paths and retain the logged-in authorization header'
  ]);
 });

-test('remaining PC file methods use the documented paths, request forms and login header', async () => {
+test('current PC file methods use the three documented resumable paths and request forms', async () => {
  const calls = [];
  const client = GenealogyApi.createClient({
    baseUrl: 'https://api.example.test',
@@ -268,19 +324,6 @@ test('remaining PC file methods use the documented paths, request forms and logi
    fileMd5: 'file-md5',
    fileSize: 8388608
  });
-  await client.createFileReference({
-    bizType: 'family_feed',
-    bizTable: 'gen_family_feed',
-    bizId: '900013001',
-    bizField: 'media_oss_ids',
-    ossId: '2060000000000000000'
-  });
-  await client.deleteFileReference({
-    bizTable: 'gen_family_feed',
-    bizId: '900013001',
-    bizField: 'media_oss_ids'
-  });
-
  assert.deepEqual(calls.map((config) => [
    config.method,
    config.url,
@@ -289,13 +332,7 @@ test('remaining PC file methods use the documented paths, request forms and logi
  ]), [
    ['post', '/genealogy/pc/files/resumable/init', undefined, 'Bearer access-token'],
    ['post', '/genealogy/pc/files/resumable/chunk', undefined, 'Bearer access-token'],
-    ['post', '/genealogy/pc/files/resumable/complete', undefined, 'Bearer access-token'],
-    ['post', '/genealogy/pc/files/reference', undefined, 'Bearer access-token'],
-    ['delete', '/genealogy/pc/files/reference', {
-      bizTable: 'gen_family_feed',
-      bizId: '900013001',
-      bizField: 'media_oss_ids'
-    }, 'Bearer access-token']
+    ['post', '/genealogy/pc/files/resumable/complete', undefined, 'Bearer access-token']
  ]);
  assert.deepEqual(calls[0].data, {
    fileName: 'video.mp4',
@@ -316,12 +353,55 @@ test('remaining PC file methods use the documented paths, request forms and logi
    fileMd5: 'file-md5',
    fileSize: 8388608
  });
-  assert.deepEqual(calls[3].data, {
-    bizType: 'family_feed',
-    bizTable: 'gen_family_feed',
-    bizId: '900013001',
-    bizField: 'media_oss_ids',
-    ossId: '2060000000000000000'
+});
+
+test('genealogy quota uses the current PC path without manufacturing a genealogy ID', async () => {
+  const client = GenealogyApi.createClient({
+    baseUrl: 'https://api.example.test',
+    tokenStore: { getItem() { return 'access-token'; }, setItem() {}, removeItem() {} },
+    axiosInstance: {
+      request(config) {
+        assert.equal(config.method, 'get');
+        assert.equal(config.url, '/genealogy/pc/genealogies/quota');
+        assert.equal(config.params, undefined);
+        assert.equal(config.data, undefined);
+        assert.equal(config.headers.Authorization, 'Bearer access-token');
+        assert.equal(config.headers.clientid, 'ced7e5f0498645c6ec642dcf450b036f');
+        return Promise.resolve({ data: { code: 200, data: { canCreate: true, canJoin: true } } });
+      }
+    }
+  });
+
+  await client.genealogyQuota();
+});
+
+test('notification methods use the current PC list, unread and read paths', async () => {
+  const calls = [];
+  const client = GenealogyApi.createClient({
+    baseUrl: 'https://api.example.test',
+    tokenStore: { getItem() { return 'access-token'; }, setItem() {}, removeItem() {} },
+    axiosInstance: {
+      request(config) {
+        calls.push(config);
+        return Promise.resolve({ data: { code: 200, data: [] } });
+      }
+    }
+  });
+
+  await client.notifications({ readStatus: '0' });
+  await client.unreadNotificationCount();
+  await client.markNotificationRead('2060000000000000001');
+  await client.markAllNotificationsRead();
+
+  assert.deepEqual(calls.map((config) => [config.method, config.url, config.params, config.data]), [
+    ['get', '/genealogy/pc/notifications', { readStatus: '0' }, undefined],
+    ['get', '/genealogy/pc/notifications/unread-count', undefined, undefined],
+    ['post', '/genealogy/pc/notifications/2060000000000000001/read', undefined, undefined],
+    ['post', '/genealogy/pc/notifications/read-all', undefined, undefined]
+  ]);
+  calls.forEach((config) => {
+    assert.equal(config.headers.Authorization, 'Bearer access-token');
+    assert.equal(config.headers.clientid, 'ced7e5f0498645c6ec642dcf450b036f');
  });
 });

@@ -474,3 +554,186 @@ test('lineage person methods use the Apifox PC paths, query and LineagePersonBod
    ['post', '/genealogy/pc/genealogies/2060000000000000001/lineage/persons/2060000000000000002/spouses', undefined, person, 'Bearer access-token', 'ced7e5f0498645c6ec642dcf450b036f']
  ]);
 });
+
+test('growth record methods use the Apifox PC paths and GrowthRecordBody', async () => {
+  const calls = [];
+  const client = GenealogyApi.createClient({
+    baseUrl: 'https://api.example.test',
+    tokenStore: { getItem() { return 'access-token'; }, setItem() {}, removeItem() {} },
+    axiosInstance: {
+      request(config) {
+        calls.push(config);
+        return Promise.resolve({ data: { code: 200, data: {} } });
+      }
+    }
+  });
+  const genealogyId = '2060000000000000001';
+  const recordId = '2060000000000000002';
+  const record = {
+    lineagePersonId: '2060000000000000003',
+    recordType: 'birth',
+    recordTitle: '出生记录',
+    recordContent: '平安出生',
+    recordDate: '2026-07-24',
+    remindTime: '2026-07-24T09:00:00+08:00',
+    mediaOssIds: '101,102',
+    sortOrder: 1,
+    status: 'enabled'
+  };
+
+  await client.growthRecords(genealogyId);
+  await client.createGrowthRecord(genealogyId, record);
+  await client.growthRecordDetail(genealogyId, recordId);
+  await client.updateGrowthRecord(genealogyId, recordId, record);
+  await client.deleteGrowthRecord(genealogyId, recordId);
+
+  assert.deepEqual(calls.map((config) => [
+    config.method,
+    config.url,
+    config.params,
+    config.data,
+    config.headers.Authorization,
+    config.headers.clientid
+  ]), [
+    ['get', '/genealogy/pc/genealogies/2060000000000000001/growth-records', undefined, undefined, 'Bearer access-token', 'ced7e5f0498645c6ec642dcf450b036f'],
+    ['post', '/genealogy/pc/genealogies/2060000000000000001/growth-records', undefined, record, 'Bearer access-token', 'ced7e5f0498645c6ec642dcf450b036f'],
+    ['get', '/genealogy/pc/genealogies/2060000000000000001/growth-records/2060000000000000002', undefined, undefined, 'Bearer access-token', 'ced7e5f0498645c6ec642dcf450b036f'],
+    ['put', '/genealogy/pc/genealogies/2060000000000000001/growth-records/2060000000000000002', undefined, record, 'Bearer access-token', 'ced7e5f0498645c6ec642dcf450b036f'],
+    ['delete', '/genealogy/pc/genealogies/2060000000000000001/growth-records/2060000000000000002', undefined, undefined, 'Bearer access-token', 'ced7e5f0498645c6ec642dcf450b036f']
+  ]);
+});
+
+test('relative record methods use the Apifox PC paths and RelativeRecordBody', async () => {
+  const calls = [];
+  const client = GenealogyApi.createClient({
+    baseUrl: 'https://api.example.test',
+    tokenStore: { getItem() { return 'access-token'; }, setItem() {}, removeItem() {} },
+    axiosInstance: { request(config) { calls.push(config); return Promise.resolve({ data: { code: 200, data: {} } }); } }
+  });
+  const genealogyId = '2060000000000000001';
+  const relativeId = '2060000000000000002';
+  const record = { relativeName: '王叔', relationName: '长辈', eventName: '寿宴', eventTime: '2026-07-24T09:00:00+08:00', giftAmount: 500, recordContent: '出席', mediaOssIds: '101', sortOrder: 1, status: 'enabled' };
+
+  await client.relativeRecords(genealogyId);
+  await client.createRelativeRecord(genealogyId, record);
+  await client.relativeRecordDetail(genealogyId, relativeId);
+  await client.updateRelativeRecord(genealogyId, relativeId, record);
+  await client.deleteRelativeRecord(genealogyId, relativeId);
+
+  assert.deepEqual(calls.map((config) => [config.method, config.url, config.data]), [
+    ['get', '/genealogy/pc/genealogies/2060000000000000001/relative-records', undefined],
+    ['post', '/genealogy/pc/genealogies/2060000000000000001/relative-records', record],
+    ['get', '/genealogy/pc/genealogies/2060000000000000001/relative-records/2060000000000000002', undefined],
+    ['put', '/genealogy/pc/genealogies/2060000000000000001/relative-records/2060000000000000002', record],
+    ['delete', '/genealogy/pc/genealogies/2060000000000000001/relative-records/2060000000000000002', undefined]
+  ]);
+});
+
+test('memo methods use the Apifox PC paths and documented request fields', async () => {
+  const calls = [];
+  const client = GenealogyApi.createClient({
+    baseUrl: 'https://api.example.test',
+    tokenStore: { getItem() { return 'access-token'; }, setItem() {}, removeItem() {} },
+    axiosInstance: { request(config) { calls.push(config); return Promise.resolve({ data: { code: 200, data: {} } }); } }
+  });
+  const genealogyId = '2060000000000000001';
+  const memoId = '2060000000000000002';
+  const memo = {
+    memoTitle: '祭祖提醒',
+    memoContent: '准备供品',
+    remindTime: '2026-07-24T09:00:00+08:00',
+    completed: '0',
+    mediaOssIds: '101,102',
+    sortOrder: 1,
+    status: 'enabled'
+  };
+
+  await client.memos(genealogyId);
+  await client.createMemo(genealogyId, memo);
+  await client.memoDetail(genealogyId, memoId);
+  await client.updateMemo(genealogyId, memoId, memo);
+  await client.deleteMemo(genealogyId, memoId);
+
+  assert.deepEqual(calls.map((config) => [config.method, config.url, config.data]), [
+    ['get', '/genealogy/pc/genealogies/2060000000000000001/memos', undefined],
+    ['post', '/genealogy/pc/genealogies/2060000000000000001/memos', memo],
+    ['get', '/genealogy/pc/genealogies/2060000000000000001/memos/2060000000000000002', undefined],
+    ['put', '/genealogy/pc/genealogies/2060000000000000001/memos/2060000000000000002', memo],
+    ['delete', '/genealogy/pc/genealogies/2060000000000000001/memos/2060000000000000002', undefined]
+  ]);
+});
+
+test('merit record deletion uses the only documented PC merit operation', async () => {
+  const client = GenealogyApi.createClient({
+    baseUrl: 'https://api.example.test',
+    tokenStore: { getItem() { return 'access-token'; }, setItem() {}, removeItem() {} },
+    axiosInstance: {
+      request(config) {
+        assert.equal(config.method, 'delete');
+        assert.equal(config.url, '/genealogy/pc/genealogies/2060000000000000001/merit-records/2060000000000000002');
+        assert.equal(config.headers.Authorization, 'Bearer access-token');
+        assert.equal(config.headers.clientid, 'ced7e5f0498645c6ec642dcf450b036f');
+        return Promise.resolve({ data: { code: 200, data: null } });
+      }
+    }
+  });
+
+  await client.deleteMeritRecord('2060000000000000001', '2060000000000000002');
+});
+
+test('remaining document-defined deletion operations use PC paths only', async () => {
+  const calls = [];
+  const client = GenealogyApi.createClient({
+    baseUrl: 'https://api.example.test',
+    tokenStore: { getItem() { return 'access-token'; }, setItem() {}, removeItem() {} },
+    axiosInstance: { request(config) { calls.push(config); return Promise.resolve({ data: { code: 200, data: null } }); } }
+  });
+  const genealogyId = '2060000000000000001';
+
+  await client.deleteArticle(genealogyId, '2060000000000000002');
+  await client.deleteAlbum(genealogyId, '2060000000000000003');
+  await client.deleteAlbumPhoto(genealogyId, '2060000000000000003', '2060000000000000004');
+  await client.deleteVideo(genealogyId, '2060000000000000005');
+  await client.deleteCeremony(genealogyId, '2060000000000000006');
+  await client.deleteCeremonyGift(genealogyId, '2060000000000000006', '2060000000000000007');
+
+  assert.deepEqual(calls.map((config) => [config.method, config.url, config.data, config.headers.clientid]), [
+    ['delete', '/genealogy/pc/genealogies/2060000000000000001/articles/2060000000000000002', undefined, 'ced7e5f0498645c6ec642dcf450b036f'],
+    ['delete', '/genealogy/pc/genealogies/2060000000000000001/albums/2060000000000000003', undefined, 'ced7e5f0498645c6ec642dcf450b036f'],
+    ['delete', '/genealogy/pc/genealogies/2060000000000000001/albums/2060000000000000003/photos/2060000000000000004', undefined, 'ced7e5f0498645c6ec642dcf450b036f'],
+    ['delete', '/genealogy/pc/genealogies/2060000000000000001/videos/2060000000000000005', undefined, 'ced7e5f0498645c6ec642dcf450b036f'],
+    ['delete', '/genealogy/pc/genealogies/2060000000000000001/ceremonies/2060000000000000006', undefined, 'ced7e5f0498645c6ec642dcf450b036f'],
+    ['delete', '/genealogy/pc/genealogies/2060000000000000001/ceremonies/2060000000000000006/gifts/2060000000000000007', undefined, 'ced7e5f0498645c6ec642dcf450b036f']
+  ]);
+});
+
+test('ceremony invitation methods use the current PC invitation contracts', async () => {
+  const calls = [];
+  const client = GenealogyApi.createClient({
+    baseUrl: 'https://api.example.test',
+    tokenStore: { getItem() { return 'access-token'; }, setItem() {}, removeItem() {} },
+    axiosInstance: { request(config) { calls.push(config); return Promise.resolve({ data: { code: 200, data: [] } }); } }
+  });
+  const genealogyId = '2060000000000000001';
+  const ceremonyId = '2060000000000000002';
+
+  await client.replaceCeremonyInvitees(genealogyId, ceremonyId, { inviteeUserIds: ['900000001', '900000002'] });
+  await client.ceremonyInvitations(genealogyId, ceremonyId);
+  await client.respondCeremonyInvitation(genealogyId, ceremonyId, { inviteStatus: 'ACCEPTED' });
+  await client.myCeremonyInvitations();
+
+  assert.deepEqual(calls.map((config) => [config.method, config.url, config.data]), [
+    ['put', '/genealogy/pc/genealogies/2060000000000000001/ceremonies/2060000000000000002/invitees', {
+      inviteeUserIds: ['900000001', '900000002']
+    }],
+    ['get', '/genealogy/pc/genealogies/2060000000000000001/ceremonies/2060000000000000002/invitations', undefined],
+    ['put', '/genealogy/pc/genealogies/2060000000000000001/ceremonies/2060000000000000002/invitations/me', {
+      inviteStatus: 'ACCEPTED'
+    }],
+    ['get', '/genealogy/pc/genealogies/ceremony-invitations/mine', undefined]
+  ]);
+  calls.forEach((config) => {
+    assert.equal(config.headers.Authorization, 'Bearer access-token');
+    assert.equal(config.headers.clientid, 'ced7e5f0498645c6ec642dcf450b036f');
+  });
+});