xiaoshu-app/projects/xiaoshu-mobile/src/app/core/api.service.spec.ts

import { provideHttpClient } from '@angular/common/http';
import { HttpTestingController, provideHttpClientTesting } from '@angular/common/http/testing';
import { fakeAsync, TestBed, tick } from '@angular/core/testing';
import { Router } from '@angular/router';
import { API_CONFIG } from './app.constants';
import { ApiError, ApiService } from './api.service';
import { SessionService } from './session.service';

describe('ApiService', () => {
  let api: ApiService;
  let http: HttpTestingController;
  let sessionToken = '';
  let sessionLogout: jasmine.Spy;
  let routerNavigate: jasmine.Spy;

  beforeEach(() => {
    sessionToken = '';
    sessionLogout = jasmine.createSpy('logout');
    routerNavigate = jasmine.createSpy('navigate').and.returnValue(Promise.resolve(true));
    TestBed.configureTestingModule({ providers: [
      provideHttpClient(),
      provideHttpClientTesting(),
      { provide: SessionService, useValue: { token: () => sessionToken, user: () => ({ objectId: 'member-42', userId: 42 }), logout: sessionLogout } },
      { provide: Router, useValue: { url: '/pages/his/his?date=2026-09-02', navigate: routerNavigate } },
    ] });
    api = TestBed.inject(ApiService);
    http = TestBed.inject(HttpTestingController);
  });

  afterEach(() => http.verify());

  it('routes migrated actions through the cloud gateway and parses JSON result strings', () => {
    let actual: unknown;
    api.get('node_list', { cpage: 1 }).subscribe((response) => actual = response.result);
    const request = http.expectOne(API_CONFIG.cloudFunctionUrl);
    expect(request.request.method).toBe('POST');
    expect(request.request.headers.get('X-Parse-Application-Id')).toBe(API_CONFIG.parseAppId);
    expect(request.request.body).toEqual({ params: { action: 'node_list', cpage: 1 } });
    request.flush({ retcode: 0, result: '[{"ID":1}]' });
    expect(actual).toEqual([{ ID: 1 }]);
  });

  it('treats lesson courses as a read and does not trigger appointment refresh loops', () => {
    sessionToken = 'r:session-token';
    let changes = 0;
    api.dataChanges$.subscribe(() => changes++);
    api.get('app_lesson_courses', { orderId: 901 }).subscribe();
    const request = http.expectOne(API_CONFIG.cloudFunctionUrl);
    expect(request.request.body.params.action).toBe('app_lesson_courses');
    request.flush({ retcode: 0, result: { items: [] } });
    expect(changes).toBe(0);
  });

  it('coalesces concurrent overview reads but fetches fresh data after completion', () => {
    sessionToken = 'r:session-token';
    const first: unknown[] = [];
    api.post('app_account_overview', { uid: 42 }).subscribe((value) => first.push(value.result));
    api.post('app_account_overview', { uid: 42 }).subscribe((value) => first.push(value.result));
    const shared = http.expectOne(API_CONFIG.cloudFunctionUrl);
    expect(shared.request.body).toEqual({ token: 'r:session-token', params: { action: 'app_account_overview', uid: 42 } });
    shared.flush({ retcode: 0, result: { profile: { userId: 42 } } });
    expect(first.length).toBe(2);

    api.post('app_account_overview', { uid: 42 }).subscribe((value) => first.push(value.result));
    const next = http.expectOne(API_CONFIG.cloudFunctionUrl);
    next.flush({ retcode: 0, result: { profile: { userId: 42, version: 2 } } });
    expect(first.length).toBe(3);

    api.post('app_account_overview', { uid: 42, refresh: true }).subscribe();
    const refreshed = http.expectOne(API_CONFIG.cloudFunctionUrl);
    expect(refreshed.request.body).toEqual({ token: 'r:session-token', params: { action: 'app_account_overview', uid: 42, refresh: true } });
    refreshed.flush({ retcode: 0, result: { profile: { userId: 42 } } });
  });

  it('routes not-yet-implemented actions through the cloud gateway for an explicit migration error', () => {
    api.get('order_list', { cpage: 2 }).subscribe();
    const request = http.expectOne(API_CONFIG.cloudFunctionUrl);
    expect(request.request.method).toBe('POST');
    expect(request.request.body).toEqual({ params: { action: 'order_list', cpage: 2 } });
    request.flush({ retcode: 0, result: [] });
  });

  it('retries transient gateway failures before surfacing a friendly error', fakeAsync(() => {
    let actual: unknown;
    api.get('order_list', { cpage: 1 }).subscribe({ error: (error) => actual = error });

    http.expectOne(API_CONFIG.cloudFunctionUrl)
      .flush('Bad Gateway', { status: 502, statusText: 'Bad Gateway' });
    tick(400);

    http.expectOne(API_CONFIG.cloudFunctionUrl)
      .flush('Bad Gateway', { status: 502, statusText: 'Bad Gateway' });
    tick(800);

    http.expectOne(API_CONFIG.cloudFunctionUrl)
      .flush('Bad Gateway', { status: 502, statusText: 'Bad Gateway' });

    expect(actual instanceof ApiError).toBeTrue();
    expect((actual as ApiError).message).toBe('请求暂未完成，请检查网络后重试；已填写内容会保留。');
  }));

  it('nests reserved id parameters inside params', () => {
    api.get('node_get', { id: 81 }).subscribe();
    const request = http.expectOne(API_CONFIG.cloudFunctionUrl);
    expect(request.request.body).toEqual({ params: { action: 'node_get', id: 81 } });
    request.flush({ retcode: 0, result: { id: 81 } });
  });

  it('routes public content details and hit increments through the cloud gateway', () => {
    api.get('content_get', { id: 931 }).subscribe();
    const detail = http.expectOne(API_CONFIG.cloudFunctionUrl);
    expect(detail.request.body).toEqual({ params: { action: 'content_get', id: 931 } });
    detail.flush({ retcode: 0, result: [{ GeneralID: 931, Title: '文章' }] });

    api.post('content_uphis', { id: 931 }).subscribe();
    const hits = http.expectOne(API_CONFIG.cloudFunctionUrl);
    expect(hits.request.body).toEqual({ params: { action: 'content_uphis', id: 931 } });
    hits.flush({ retcode: 0, result: { hits: 2 } });
  });

  it('passes Parse sessions to private-capable content actions and never falls back to the old gateway', () => {
    sessionToken = 'r:session-token';
    api.get('content_get', { id: 931 }).subscribe();
    const cloud = http.expectOne(API_CONFIG.cloudFunctionUrl);
    expect(cloud.request.body).toEqual({ token: 'r:session-token', params: { action: 'content_get', id: 931 } });
    cloud.flush({ retcode: 0, result: [{ GeneralID: 931 }] });

    sessionToken = 'legacy-session';
    api.get('content_get', { id: 931 }).subscribe();
    const migratedDetail = http.expectOne(API_CONFIG.cloudFunctionUrl);
    expect(migratedDetail.request.body).toEqual({ params: { action: 'content_get', id: 931 } });
    migratedDetail.flush({ retcode: 0, result: [{ GeneralID: 931 }] });

    api.post('content_uphis', { id: 931 }).subscribe();
    const migratedHits = http.expectOne(API_CONFIG.cloudFunctionUrl);
    expect(migratedHits.request.body).toEqual({ params: { action: 'content_uphis', id: 931 } });
    migratedHits.flush({ retcode: 0, result: null });
  });

  it('routes private addon and blocked product queries through the cloud gateway', () => {
    api.get('content_list', { modelId: 56, myfield2: 'UserId=42' }).subscribe();
    api.get('product_list', { cpage: 1 }).subscribe();
    const [content, products] = http.match(API_CONFIG.cloudFunctionUrl);
    expect(content.request.body).toEqual({ params: { action: 'content_list', modelId: 56, myfield2: 'UserId=42' } });
    expect(products.request.body).toEqual({ params: { action: 'product_list', cpage: 1 } });
    content.flush({ retcode: 0, result: [] });
    products.flush({ retcode: 0, result: [] });
  });

  it('routes supported private addon content with a Parse session', () => {
    sessionToken = 'r:session-token';
    api.get('content_list', { modelId: 56, myfield2: 'UserId=42|dqrq=20260818' }).subscribe();
    const request = http.expectOne(API_CONFIG.cloudFunctionUrl);
    expect(request.request.body).toEqual({ token: 'r:session-token', params: { action: 'content_list', modelId: 56, myfield2: 'UserId=42|dqrq=20260818' } });
    request.flush({ retcode: 0, result: [] });
  });

  it('routes verified learning detail reads with a Parse session', () => {
    sessionToken = 'r:session-token';
    api.get('e_record_detail', { id: 931 }).subscribe();
    const request = http.expectOne(API_CONFIG.cloudFunctionUrl);
    expect(request.request.body).toEqual({ token: 'r:session-token', params: { action: 'e_record_detail', id: 931 } });
    request.flush({ retcode: 0, result: [{ GeneralID: 149, detail: [{ Title: 'beautiful' }] }] });
  });

  it('routes course word progress reads with a Parse session', () => {
    sessionToken = 'r:session-token';
    api.get('e_ck_list', { uid: 58, nids: '40,41' }).subscribe();
    const request = http.expectOne(API_CONFIG.cloudFunctionUrl);
    expect(request.request.body).toEqual({ token: 'r:session-token', params: { action: 'e_ck_list', uid: 58, nids: '40,41' } });
    request.flush({ retcode: 0, result: [{ GeneralID: 2505, w_learned: 7 }] });
  });

  it('routes team member, team statistics, and coach student reads with a Parse session', () => {
    sessionToken = 'r:session-token';
    api.get('user_list', { puid: 58, cpage: 1 }).subscribe();
    api.get('user_dept', { uid: 58 }).subscribe();
    api.get('e_user_list', { cpage: 1 }).subscribe();
    const [members, statistics, students] = http.match(API_CONFIG.cloudFunctionUrl);
    expect(members.request.body).toEqual({ token: 'r:session-token', params: { action: 'user_list', puid: 58, cpage: 1 } });
    expect(statistics.request.body).toEqual({ token: 'r:session-token', params: { action: 'user_dept', uid: 58 } });
    expect(students.request.body).toEqual({ token: 'r:session-token', params: { action: 'e_user_list', cpage: 1 } });
    members.flush({ retcode: 0, result: [] });
    statistics.flush({ retcode: 0, result: { childs: 0, v0: 0 } });
    students.flush({ retcode: 0, result: [] });
  });

  it('routes typed virtual-currency history reads with a Parse session', () => {
    sessionToken = 'r:session-token';
    api.get('user_point_list', { uid: 58, stype: 3, cpage: 1 }).subscribe();
    const request = http.expectOne(API_CONFIG.cloudFunctionUrl);
    expect(request.request.body).toEqual({ token: 'r:session-token', params: { action: 'user_point_list', uid: 58, stype: 3, cpage: 1 } });
    request.flush({ retcode: 0, result: [{ ExpHisID: 1, score: 2 }] });
  });

  it('routes legacy model-based feedback submissions with a Parse session', () => {
    sessionToken = 'r:session-token';
    const model = JSON.stringify({ UserID: 58, Title: '小树 反馈的意见', TContent: '请假一天', Cateid: 22 });
    api.post('guestbook_add', { model }).subscribe();
    const request = http.expectOne(API_CONFIG.cloudFunctionUrl);
    expect(request.request.body).toEqual({ token: 'r:session-token', params: { action: 'guestbook_add', model } });
    request.flush({ retcode: 0, result: { GID: 1, TContent: '请假一天' } });
  });

  it('routes legacy mu profile updates with a Parse session', () => {
    sessionToken = 'r:session-token';
    const mu = JSON.stringify({ honeyName: '小树', Email: 'tree@example.test' });
    api.post('user_update', { uid: 58, mu, inviCode: '' }).subscribe();
    const request = http.expectOne(API_CONFIG.cloudFunctionUrl);
    expect(request.request.body).toEqual({ token: 'r:session-token', params: { action: 'user_update', uid: 58, mu, inviCode: '' } });
    request.flush({ retcode: 0, result: { userId: 58, honeyName: '小树' } });
  });

  it('routes learning word state writes with a Parse session', () => {
    sessionToken = 'r:session-token';
    api.post('e_add_words', { uid: 58, wordsId: '2505,2503', kcid: 16, ifnew: 1 }).subscribe();
    const request = http.expectOne(API_CONFIG.cloudFunctionUrl);
    expect(request.request.body).toEqual({ token: 'r:session-token', params: { requestKey: jasmine.any(String), action: 'e_add_words', uid: 58, wordsId: '2505,2503', kcid: 16, ifnew: 1 } });
    request.flush({ retcode: 0, result: { affected: 2, newWordState: 1 } });
  });

  it('routes study record upserts with a Parse session', () => {
    sessionToken = 'r:session-token';
    api.post('stu_record_update_v2', { orderId: 918, uid: 23, addon: '{"xxqs":[]}' }).subscribe();
    const request = http.expectOne(API_CONFIG.cloudFunctionUrl);
    expect(request.request.body).toEqual({ token: 'r:session-token', params: { requestKey: jasmine.any(String), action: 'stu_record_update_v2', orderId: 918, uid: 23, addon: '{"xxqs":[]}' } });
    request.flush({ retcode: 0, result: { GeneralID: 123456, created: true } });
  });

  it('routes scheduled study record creation with a Parse session', () => {
    sessionToken = 'r:session-token';
    api.post('content_add_zt', { content: '{"ModelID":56}', addon: '{"UserID":23,"xxqs":"[]"}' }).subscribe();
    const request = http.expectOne(API_CONFIG.cloudFunctionUrl);
    expect(request.request.body).toEqual({ token: 'r:session-token', params: { requestKey: jasmine.any(String), action: 'content_add_zt', content: '{"ModelID":56}', addon: '{"UserID":23,"xxqs":"[]"}' } });
    request.flush({ retcode: 0, result: '123456' });
  });

  it('routes normalized content updates with a Parse session', () => {
    sessionToken = 'r:session-token';
    api.post('content_update', { content: '{"GeneralID":123456}', addon: '{"learned":2}' }).subscribe();
    const request = http.expectOne(API_CONFIG.cloudFunctionUrl);
    expect(request.request.body).toEqual({ token: 'r:session-token', params: { requestKey: jasmine.any(String), action: 'content_update', content: '{"GeneralID":123456}', addon: '{"learned":2}' } });
    request.flush({ retcode: 0, result: '123456' });
  });

  it('routes normalized content creation with a Parse session', () => {
    sessionToken = 'r:session-token';
    api.post('content_add', { content: '{"ModelID":61,"nodeId":389}', addon: '{"UserID":23,"df":8}' }).subscribe();
    const request = http.expectOne(API_CONFIG.cloudFunctionUrl);
    expect(request.request.body).toEqual({ token: 'r:session-token', params: { requestKey: jasmine.any(String), action: 'content_add', content: '{"ModelID":61,"nodeId":389}', addon: '{"UserID":23,"df":8}' } });
    request.flush({ retcode: 0, result: '123456' });
  });

  it('routes appointment statistics with a Parse session', () => {
    sessionToken = 'r:session-token';
    api.post('e_order_tongji', { uid: 23 }).subscribe();
    const request = http.expectOne(API_CONFIG.cloudFunctionUrl);
    expect(request.request.body).toEqual({ token: 'r:session-token', params: { action: 'e_order_tongji', uid: 23 } });
    request.flush({ retcode: 0, result: { t30: '1', t_shichang: '0.5', t_total: '1' } });
  });

  it('routes complete appointment transitions with a Parse session', () => {
    sessionToken = 'r:session-token';
    api.post('e_order_update_v2', { uid: 23, status: 11, content: '{"GeneralID":918}' }).subscribe();
    const request = http.expectOne(API_CONFIG.cloudFunctionUrl);
    expect(request.request.body).toEqual({ token: 'r:session-token', params: { action: 'e_order_update_v2', uid: 23, status: 11, content: '{"GeneralID":918}' } });
    request.flush({ retcode: 0, result: { GeneralID: '918', status: 11, reviewCount: 15, periodDeducted: true } });
  });

  it('routes learning detail reads to cloud even when a stale legacy token remains locally', () => {
    sessionToken = 'legacy-session';
    api.get('e_words_list', { uid: 58 }).subscribe();
    const request = http.expectOne(API_CONFIG.cloudFunctionUrl);
    expect(request.request.body).toEqual({ params: { action: 'e_words_list', uid: 58 } });
    request.flush({ retcode: 0, result: [] });
  });

  it('routes public vocabulary addon content without a session', () => {
    api.get('content_list', { modelId: 52, nid: 327 }).subscribe();
    const request = http.expectOne(API_CONFIG.cloudFunctionUrl);
    expect(request.request.body).toEqual({ params: { action: 'content_list', modelId: 52, nid: 327 } });
    request.flush({ retcode: 0, result: [] });
  });

  it('requires a Parse session for user-specific unit progress', () => {
    sessionToken = 'r:session-token';
    api.get('node_list', { pid: 16, ifunit: 1, userId: 58 }).subscribe();
    const request = http.expectOne(API_CONFIG.cloudFunctionUrl);
    expect(request.request.body).toEqual({ token: 'r:session-token', params: { action: 'node_list', pid: 16, ifunit: 1, userId: 58 } });
    request.flush({ retcode: 0, result: [{ NodeID: 40, total: 20, yx_word: 5, process: 25 }] });
  });

  it('turns retcode -1 responses into ApiError', () => {
    let actual: unknown;
    api.post('user_login_passwd', {}).subscribe({ error: (error) => actual = error });
    http.expectOne(API_CONFIG.cloudFunctionUrl).flush({ retcode: -1, retmsg: '账号或密码错误', result: null }, { status: 401, statusText: 'Unauthorized' });
    expect(actual instanceof ApiError).toBeTrue();
    expect((actual as ApiError).message).toBe('账号或密码错误');
  });

  it('clears an expired Parse session and returns to login after an authenticated 401', fakeAsync(() => {
    sessionToken = 'r:expired-session';
    let actual: unknown;
    api.post('app_learning_overview', { uid: 42 }).subscribe({ error: (error) => actual = error });
    http.expectOne(API_CONFIG.cloudFunctionUrl).flush(
      { retmsg: '会话已失效' },
      { status: 401, statusText: 'Unauthorized' },
    );
    tick();

    expect(actual instanceof ApiError).toBeTrue();
    expect(sessionLogout).toHaveBeenCalledTimes(1);
    expect(routerNavigate).toHaveBeenCalledOnceWith(
      ['/pages/member/wxauth'],
      {
        queryParams: { returnUrl: '/pages/his/his?date=2026-09-02', expired: 1 },
        replaceUrl: true,
      },
    );
  }));

  it('returns to login when a protected request has no usable session left', fakeAsync(() => {
    let actual: unknown;
    api.post('e_get_21list', { uid: 42 }).subscribe({ error: (error) => actual = error });
    http.expectOne(API_CONFIG.cloudFunctionUrl).flush(
      { retmsg: '需要登录' },
      { status: 401, statusText: 'Unauthorized' },
    );
    tick();

    expect(actual instanceof ApiError).toBeTrue();
    expect(sessionLogout).toHaveBeenCalledTimes(1);
    expect(routerNavigate).toHaveBeenCalledTimes(1);
  }));

  it('keeps a successful password login on the cloud response', () => {
    let actual: unknown;
    api.post('user_login_passwd', { name: 'tree', passwd: 'password' }).subscribe((response) => actual = response.result);
    http.expectOne(API_CONFIG.cloudFunctionUrl).flush({ retcode: 0, result: { userId: 42, sessionToken: 'r:token' } });
    expect(actual).toEqual({ userId: 42, sessionToken: 'r:token' });
  });

  it('routes account availability checks and classic registration to the cloud', () => {
    api.post('user_info_name', { uname: '13800138000' }).subscribe({ error: () => undefined });
    const lookup = http.expectOne(API_CONFIG.cloudFunctionUrl);
    expect(lookup.request.body).toEqual({ params: { action: 'user_info_name', uname: '13800138000' } });
    lookup.flush({ retcode: -1, retmsg: '用户不存在', result: null }, { status: 404, statusText: 'Not Found' });

    api.post('user_register', { name: '13800138000', passwd: 'Ab1234', code: '' }).subscribe();
    const register = http.expectOne(API_CONFIG.cloudFunctionUrl);
    expect(register.request.body).toEqual({ params: { action: 'user_register', name: '13800138000', passwd: 'Ab1234', code: '' } });
    register.flush({ retcode: 0, result: { userId: 42, sessionToken: 'r:token' } });
  });
});

describe('teaching request reliability',()=>{
 let api:ApiService,http:HttpTestingController;
 beforeEach(()=>{TestBed.configureTestingModule({providers:[provideHttpClient(),provideHttpClientTesting(),{provide:SessionService,useValue:{token:()=> 'r:teacher',user:()=>({userId:88}),logout:()=>{}}}]});api=TestBed.inject(ApiService);http=TestBed.inject(HttpTestingController);});
 afterEach(()=>http.verify());
 for(const action of ['e_order_complete_feedback','vote_add','unit_record_update','e_get_21list_tj'])it(action+' carries the current session',()=>{api.post(action,{uid:1761}).subscribe();const req=http.expectOne(API_CONFIG.cloudFunctionUrl);expect(req.request.body.token).toBe('r:teacher');req.flush({retcode:0,result:{}});});
 it('does not automatically retry a write and retains its request key for manual retry',fakeAsync(()=>{const body={uid:1761,wordsId:'7',save:1};api.post('e_add_words',body).subscribe({error:()=>{}});const first=http.expectOne(API_CONFIG.cloudFunctionUrl),key=first.request.body.params.requestKey;expect(key).toBeTruthy();first.flush('',{status:503,statusText:'Unavailable'});tick(2000);http.expectNone(API_CONFIG.cloudFunctionUrl);api.post('e_add_words',body).subscribe();const retry=http.expectOne(API_CONFIG.cloudFunctionUrl);expect(retry.request.body.params.requestKey).toBe(key);retry.flush({retcode:0,result:{}});}));
 it('fetches a fresh learning summary after a successful teaching write',()=>{const results:Array<{records:Array<{id:number}>}>=[];api.post<{records:Array<{id:number}>}>('app_learning_overview',{uid:1761}).subscribe(({result})=>results.push(result));http.expectOne(API_CONFIG.cloudFunctionUrl).flush({retcode:0,result:{records:[]}});api.post('e_order_complete_feedback',{orderId:7}).subscribe();http.expectOne(API_CONFIG.cloudFunctionUrl).flush({retcode:0,result:{}});api.post<{records:Array<{id:number}>}>('app_learning_overview',{uid:1761}).subscribe(({result})=>results.push(result));http.expectOne(API_CONFIG.cloudFunctionUrl).flush({retcode:0,result:{records:[{id:1}]}});expect(results).toEqual([{records:[]},{records:[{id:1}]}]);});
 it('times out completion without retrying and keeps the idempotency key for a manual retry',fakeAsync(()=>{
  const body={orderId:901,expectedUpdatedAt:'2026-10-11T00:00:00Z',feedback:{contentSummary:'Unit 1'}};let message='';
  api.post('app_lesson_complete',body).subscribe({error:e=>message=e.message});
  const first=http.expectOne(API_CONFIG.cloudFunctionUrl),key=first.request.body.params.requestKey;
  tick(20_001);expect(message).toContain('请求暂未完成');expect(first.cancelled).toBeTrue();http.expectNone(API_CONFIG.cloudFunctionUrl);
  api.post('app_lesson_complete',body).subscribe();const retry=http.expectOne(API_CONFIG.cloudFunctionUrl);
  expect(retry.request.body.params.requestKey).toBe(key);retry.flush({retcode:0,result:{status:30}});
 }));

});