378 lines
24 KiB
JavaScript
378 lines
24 KiB
JavaScript
const { test } = require('node:test');
|
|
const assert = require('node:assert/strict');
|
|
const fs = require('node:fs'), path = require('node:path'), vm = require('node:vm');
|
|
const base = path.resolve(__dirname, '..');
|
|
function apiFixture(handler, saved) {
|
|
const storage = new Map(saved ? [['juzi.taobao.session.v1', saved]] : []);
|
|
const app = { globalData: { profile: null, photos: null, payload: null } };
|
|
const calls = [], module = { exports: {} }; let authCalls = 0;
|
|
vm.runInNewContext(fs.readFileSync(path.join(base, 'utils/api.js'), 'utf8'), {
|
|
module, Promise, Date, Math, setTimeout: (fn) => setTimeout(fn, 0), getApp: () => app,
|
|
my: { authorize(opts) { authCalls++; opts.success({}); },
|
|
setStorageSync({ key, data }) { storage.set(key, data); },
|
|
getStorageSync({ key }) { return { data: storage.get(key) }; },
|
|
removeStorageSync({ key }) { storage.delete(key); } },
|
|
require(name) {
|
|
if (name === '../config') return { transport: 'cloud', assetBase: 'https://assets.example/' };
|
|
if (name === './transport') return { request(route, body, token) {
|
|
calls.push({ route, body: JSON.parse(JSON.stringify(body)), token });
|
|
return Promise.resolve().then(() => handler(route.replace('/api/taobao/', ''), body, token));
|
|
} };
|
|
throw Error('unexpected dependency ' + name);
|
|
}
|
|
});
|
|
return { api: module.exports, app, calls, storage, authCalls: () => authCalls };
|
|
}
|
|
function sessions(route) {
|
|
if (route === 'challenge') return { ok: true, challenge: 'one-use' };
|
|
if (route === 'guest-session') return { ok: true, token: 'guest-token', user: { id: 'guest-a', kind: 'taobao_guest' } };
|
|
if (route === 'session' || route === 'me') return { ok: true, token: 'account-token', user: { id: 'account-a', kind: 'taobao' } };
|
|
if (route === 'logout') return { ok: true };
|
|
throw Error('unexpected route ' + route);
|
|
}
|
|
function page(file, api, extra = {}, dependencies = {}) {
|
|
let definition; const timers = [], nav = [], toasts = [], storage = [];
|
|
const context = { Page(value) { definition = value; }, console, Promise, Date,
|
|
setTimeout(fn) { timers.push(fn); return timers.length; }, clearTimeout(id) { timers[id - 1] = null; },
|
|
my: { navigateTo: v => nav.push(v), redirectTo: v => nav.push(v),
|
|
showToast: v => toasts.push(v), setStorageSync: v => storage.push(v), getStorageSync: () => ({}) },
|
|
getApp: () => ({ globalData: {} }),
|
|
require(name) {
|
|
if (/utils\/api(?:\.js)?$/.test(name)) return api;
|
|
if (Object.hasOwn(dependencies, name)) return dependencies[name];
|
|
return require(path.resolve(path.dirname(path.join(base, file)), name));
|
|
}, ...extra };
|
|
vm.runInNewContext(fs.readFileSync(path.join(base, file), 'utf8'), context);
|
|
const p = Object.assign({}, definition, { data: JSON.parse(JSON.stringify(definition.data)), setData(patch, cb) {
|
|
for (const [key, value] of Object.entries(patch)) {
|
|
const parts = key.replace(/\[(\d+)\]/g, '.$1').split('.'); let target = this.data;
|
|
for (const part of parts.slice(0, -1)) target = target[part]; target[parts.at(-1)] = value;
|
|
}
|
|
if (cb) cb();
|
|
} });
|
|
return { p, timers, nav, toasts, storage, context };
|
|
}
|
|
const flush = () => new Promise(resolve => setImmediate(resolve));
|
|
|
|
test('guest requires consent, skips account authorization, never persists, and cold start clears the experience', async () => {
|
|
const f = apiFixture(sessions, { token: 'old-account', user: { id: 'old' } });
|
|
await assert.rejects(f.api.loginGuest(false), /同意/);
|
|
await f.api.loginGuest(true);
|
|
assert.equal(f.authCalls(), 0); assert.equal(f.api.isGuest(), true); assert.equal(f.api.isSignedIn(), false);
|
|
assert.equal(f.storage.size, 0);
|
|
f.app.globalData.profile = { age: 30 }; f.app.globalData.photos = ['face']; f.app.globalData.payload = { result: {} };
|
|
assert.equal((await f.api.restore()).kind, 'taobao_guest');
|
|
assert.equal(f.calls.some(v => v.route.endsWith('/me')), false, 'product round trip keeps guest in memory');
|
|
f.api.resetForLaunch();
|
|
assert.equal(f.api.hasSession(), false); assert.equal(f.app.globalData.payload, null);
|
|
assert.equal(await f.api.restore(), null); assert.equal(f.storage.size, 0);
|
|
});
|
|
|
|
test('explicit guest entry retires cached account verification before guest network work and ignores every late /me outcome', async t => {
|
|
for (const timing of ['before', 'challenge-pending', 'guest-session-pending', 'after']) {
|
|
for (const outcome of ['success', '401']) await t.test(timing + ' / ' + outcome, async () => {
|
|
let finishMe, finishChallenge, finishGuest;
|
|
const f = apiFixture(route => {
|
|
if (route === 'me') return new Promise(resolve => { finishMe = resolve; });
|
|
if (route === 'challenge') return new Promise(resolve => { finishChallenge = resolve; });
|
|
if (route === 'guest-session') return new Promise(resolve => { finishGuest = resolve; });
|
|
throw Error('unexpected route ' + route);
|
|
}, { token: 'old-formal-token', user: { id: 'old-account', kind: 'taobao' } });
|
|
f.app.globalData.profile = { real_age: 30 }; f.app.globalData.photos = ['old-private-photo']; f.app.globalData.payload = { old: true };
|
|
const checking = f.api.restore().then(value => ({ value }), error => ({ error }));
|
|
await flush();
|
|
const respondMe = () => finishMe(outcome === 'success'
|
|
? { ok: true, user: { id: 'old-account', kind: 'taobao' } }
|
|
: { ok: false, http_status: 401, message: 'old account expired' });
|
|
if (timing === 'before') {
|
|
respondMe();
|
|
const checked = await checking;
|
|
if (outcome === 'success') assert.equal(checked.value.id, 'old-account');
|
|
else assert.equal(checked.error.status, 401);
|
|
}
|
|
const entering = f.api.loginGuest(true);
|
|
// These guarantees apply synchronously on the user's confirmed choice,
|
|
// even while a previous account check or the new challenge is pending.
|
|
assert.equal(f.api.user(), null); assert.equal(f.api.hasSession(), false); assert.equal(f.api.isSignedIn(), false);
|
|
assert.equal(f.storage.size, 0); assert.equal(f.app.globalData.profile, null);
|
|
assert.equal(f.app.globalData.photos, null); assert.equal(f.app.globalData.payload, null); assert.equal(f.authCalls(), 0);
|
|
await flush();
|
|
if (timing === 'challenge-pending') {
|
|
respondMe(); const checked = await checking; assert.equal(checked.error.canceled, true);
|
|
assert.equal(f.api.hasSession(), false);
|
|
}
|
|
finishChallenge({ ok: true, challenge: 'guest-only-challenge' }); await flush();
|
|
if (timing === 'guest-session-pending') {
|
|
respondMe(); const checked = await checking; assert.equal(checked.error.canceled, true);
|
|
assert.equal(f.api.hasSession(), false);
|
|
}
|
|
finishGuest({ ok: true, token: 'new-guest-token', user: { id: 'new-guest', kind: 'taobao_guest' } });
|
|
await entering;
|
|
if (timing === 'after') {
|
|
respondMe(); const checked = await checking; assert.equal(checked.error.canceled, true);
|
|
}
|
|
assert.equal(f.api.user().id, 'new-guest'); assert.equal(f.api.isGuest(), true); assert.equal(f.api.isSignedIn(), false);
|
|
assert.equal(f.storage.size, 0); assert.equal(f.authCalls(), 0);
|
|
assert.equal((await f.api.restore()).id, 'new-guest');
|
|
assert.equal(f.calls.filter(call => call.route.endsWith('/me')).length, 1, 'guest restore never rechecks the old formal account');
|
|
assert.equal(f.calls.find(call => call.route.endsWith('/me')).token, 'old-formal-token');
|
|
const guestCalls = f.calls.filter(call => /\/(challenge|guest-session)$/.test(call.route));
|
|
assert.equal(guestCalls.length, 2); assert(guestCalls.every(call => call.token === ''), 'neither guest handshake request inherits a formal Bearer');
|
|
});
|
|
}
|
|
});
|
|
|
|
test('a rejected guest consent leaves account restore intact, while failed confirmed guest entry cannot resurrect that account', async t => {
|
|
await t.test('consent is checked before clearing the existing account', async () => {
|
|
let finishMe;
|
|
const f = apiFixture(route => route === 'me' ? new Promise(resolve => { finishMe = resolve; }) : sessions(route),
|
|
{ token: 'saved-formal-token', user: { id: 'old-account', kind: 'taobao' } });
|
|
const restoring = f.api.restore(); await flush();
|
|
await assert.rejects(f.api.loginGuest(false), /同意/); assert.equal(f.storage.size, 1);
|
|
finishMe({ ok: true, user: { id: 'old-account', kind: 'taobao' } }); await restoring;
|
|
assert.equal(f.api.isSignedIn(), true); assert.equal(f.calls.length, 1); assert.equal(f.authCalls(), 0);
|
|
});
|
|
for (const outcome of ['success', '401']) await t.test('guest failure then old /me ' + outcome, async () => {
|
|
let finishMe;
|
|
const f = apiFixture(route => {
|
|
if (route === 'me') return new Promise(resolve => { finishMe = resolve; });
|
|
if (route === 'guest-session') return { ok: false, http_status: 503, message: 'guest temporarily unavailable' };
|
|
return sessions(route);
|
|
}, { token: 'saved-formal-token', user: { id: 'old-account', kind: 'taobao' } });
|
|
const checking = f.api.restore().then(value => ({ value }), error => ({ error })); await flush();
|
|
await assert.rejects(f.api.loginGuest(true), /guest temporarily unavailable/);
|
|
finishMe(outcome === 'success' ? { ok: true, user: { id: 'old-account', kind: 'taobao' } }
|
|
: { ok: false, http_status: 401, message: 'old account expired' });
|
|
assert.equal((await checking).error.canceled, true);
|
|
assert.equal(f.api.user(), null); assert.equal(f.api.hasSession(), false); assert.equal(f.storage.size, 0);
|
|
assert.equal(await f.api.restore(), null); assert.equal(f.authCalls(), 0);
|
|
assert(f.calls.filter(call => /\/(challenge|guest-session)$/.test(call.route)).every(call => call.token === ''));
|
|
});
|
|
});
|
|
|
|
test('restored account is not signed in before server verification; expiry clears cached identity and report', async () => {
|
|
let resolveMe;
|
|
const f = apiFixture(route => route === 'me' ? new Promise(r => { resolveMe = r; }) : sessions(route),
|
|
{ token: 'saved-token', user: { id: 'stale', kind: 'taobao' } });
|
|
const restore = f.api.restore();
|
|
assert.equal(f.api.user(), null); assert.equal(f.api.isSignedIn(), false);
|
|
await flush(); resolveMe({ ok: false, http_status: 401, message: '登录已过期' });
|
|
await assert.rejects(restore, /过期/);
|
|
assert.equal(f.storage.size, 0); assert.equal(f.api.user(), null); assert.equal(f.app.globalData.photos, null);
|
|
});
|
|
|
|
test('network failure during restore does not present an unverified cached account as logged in', async () => {
|
|
const f = apiFixture(() => { throw Error('offline'); }, { token: 'saved', user: { id: 'cached' } });
|
|
await assert.rejects(f.api.restore(), /offline/);
|
|
assert.equal(f.api.isSignedIn(), false); assert.equal(f.api.user(), null);
|
|
assert.equal(f.storage.size, 1, 'network outage does not revoke the saved account');
|
|
});
|
|
|
|
test('ending guest experience immediately clears all local content even if revocation cannot connect', async () => {
|
|
const f = apiFixture(route => route === 'logout' ? new Promise(() => {}) : sessions(route));
|
|
await f.api.loginGuest(true); f.app.globalData.photos = ['private']; f.app.globalData.payload = { private: true };
|
|
await f.api.endGuest();
|
|
assert.equal(f.api.user(), null); assert.equal(f.app.globalData.photos, null); assert.equal(f.app.globalData.payload, null);
|
|
});
|
|
|
|
test('identity change rejects delayed old-account responses and clears transient report data', async () => {
|
|
let resolveOld;
|
|
const f = apiFixture(route => route === 'slow' ? new Promise(r => { resolveOld = r; }) : sessions(route));
|
|
await f.api.login(true); f.app.globalData.payload = { account: 'a' };
|
|
const oldRequest = f.api.request('slow'); await flush();
|
|
await f.api.loginGuest(true); resolveOld({ ok: true, secret: 'old-account-report' });
|
|
await assert.rejects(oldRequest, err => err.canceled === true);
|
|
assert.equal(f.app.globalData.payload, null); assert.equal(f.api.isGuest(), true);
|
|
});
|
|
|
|
test('guest profile stays in memory and guest history does not request account history', () => {
|
|
const api = { user: () => ({ id: 'guest-a', kind: 'taobao_guest' }), assetUrl: p => p, request() { throw Error('must not request history'); } };
|
|
let reads = 0; const app = { globalData: {} };
|
|
const profile = page('pages/profile/profile.js', api, { getApp: () => app,
|
|
my: { getStorageSync() { reads++; return {}; }, setStorageSync() { throw Error('guest profile must not persist'); }, navigateTo() {} } });
|
|
profile.p.onLoad(); assert.equal(reads, 0);
|
|
profile.p.setData({ birth: '1996-01', age: 30, genderText: '女', regionText: '北京' }); profile.p.onStartCamera();
|
|
assert.equal(app.globalData.profile.real_age, 30);
|
|
const history = page('pages/history/history.js', api); history.p.onShow(); history.p.load();
|
|
assert.equal(history.p.data.guest, true); assert.equal(history.p.data.items.length, 0);
|
|
assert.match(history.p.data.identityNote, /不保存/);
|
|
});
|
|
|
|
test('login agreement gates both entry modes and guest entry uses guest-session flow', async () => {
|
|
let guestCalls = 0;
|
|
const p = page('pages/login/login.js', { assetUrl: v => v, restore: async () => null,
|
|
loginGuest: async () => { guestCalls++; }, login: async () => { throw Error('wrong entry'); } });
|
|
p.p.onLoad({ switch: '1' }); p.p.onShow(); p.p.onGuest(); assert.equal(guestCalls, 0);
|
|
p.p.onToggleAgree(); p.p.onGuest(); p.p.onGuest(); await flush();
|
|
assert.equal(guestCalls, 1); assert.equal(p.nav[0].url, '/pages/splash/splash');
|
|
});
|
|
|
|
test('synchronous guest startup failures release the button and permit a deliberate retry', async () => {
|
|
let calls = 0;
|
|
const p = page('pages/login/login.js', {assetUrl:v=>v, loginGuest() { if (++calls === 1) throw Error('游客连接失败'); return Promise.resolve(); }});
|
|
p.p.onLoad({switch:'1'}); p.p.onShow(); p.p.onToggleAgree();
|
|
p.p.onGuest(); assert.equal(p.p.data.busy,true); await flush();
|
|
assert.equal(p.p.data.busy,false); assert.match(p.p.data.message,/游客连接失败/);
|
|
p.p.onGuest(); await flush(); assert.equal(calls,2); assert.equal(p.nav.length,1);
|
|
});
|
|
|
|
test('guest entry does not wait for cached-account restore or let its late success redirect the page', async () => {
|
|
let finishRestore, finishGuest, restores = 0, guests = 0;
|
|
const p = page('pages/login/login.js', { assetUrl: v => v,
|
|
restore() { restores++; return new Promise(resolve => { finishRestore = resolve; }); },
|
|
loginGuest() { guests++; return new Promise(resolve => { finishGuest = resolve; }); },
|
|
login() { throw Error('guest must not request account login'); } });
|
|
p.p.onLoad(); p.p.onShow(); assert.equal(p.p.data.checking, true);
|
|
p.p.onToggleAgree(); p.p.onGuest(); p.p.onGuest();
|
|
assert.equal(guests, 1); assert.equal(p.p.data.checking, false); assert.equal(p.p.data.busy, true);
|
|
p.p.onShow(); assert.equal(restores, 1, 'foregrounding must not replace an intentional guest entry');
|
|
finishRestore({ id: 'old-account', kind: 'taobao' }); await flush();
|
|
assert.equal(p.nav.length, 0); assert.match(p.p.data.message, /正在开始游客体验/);
|
|
finishGuest({ id: 'guest-a', kind: 'taobao_guest' }); await flush();
|
|
assert.equal(p.nav.length, 1); assert.equal(p.nav[0].url, '/pages/splash/splash'); assert.equal(p.p.data.busy, false);
|
|
const markup = fs.readFileSync(path.join(base, 'pages/login/login.axml'), 'utf8');
|
|
assert.match(markup, /disabled="{{busy}}"[^>]*onTap="onGuest"/);
|
|
});
|
|
|
|
test('late restore errors cannot overwrite a failed guest entry or send the visitor to account authorization', async () => {
|
|
let failRestore;
|
|
const p = page('pages/login/login.js', { assetUrl: v => v,
|
|
restore: () => new Promise((resolve, reject) => { failRestore = reject; }),
|
|
loginGuest: async () => { throw Error('游客连接暂不可用，请重试'); },
|
|
login() { throw Error('must not authorize a visitor'); } });
|
|
p.p.onLoad(); p.p.onShow(); p.p.onToggleAgree(); p.p.onGuest(); await flush();
|
|
assert.equal(p.p.data.busy, false); assert.match(p.p.data.message, /游客连接暂不可用/);
|
|
failRestore(Object.assign(Error('old account expired'), { status: 401 })); await flush();
|
|
assert.match(p.p.data.message, /游客连接暂不可用/); assert.equal(p.nav.length, 0); assert.equal(p.p.data.checking, false);
|
|
});
|
|
|
|
test('all recommendation tiers open the one confirmed item, block repeat taps and keep report state on return', () => {
|
|
for (const tier of [1, 2, 3]) {
|
|
const opened = []; const user = { id: 'guest-a', kind: 'taobao_guest' };
|
|
const api = { assetUrl: v => v, user: () => user };
|
|
const r = page('pages/report/report.js', api, { my: { tb: { openDetail: v => opened.push(v) }, showToast() {} } });
|
|
r.p.ownerId = user.id; r.p.alive = true;
|
|
r.p.setData({ product: { tier }, frontPhoto: 'private-front', cards: [{ index: 1 }], guest: true });
|
|
r.p.onMore(); r.p.onMore(); assert.equal(opened.length, 1); assert.equal(opened[0].itemId, '1090510453077');
|
|
r.p.onHide(); r.p.onShow();
|
|
assert.equal(r.p.data.cards[0].index, 1); assert.equal(r.p.data.frontPhoto, 'private-front'); assert.equal(r.p.data.guest, true);
|
|
r.p.onMore(); assert.equal(opened.length, 2, 'return enables a fresh deliberate tap'); r.p.onUnload();
|
|
}
|
|
});
|
|
|
|
test('product API absence and failed navigation give feedback and allow retry', () => {
|
|
const api = { assetUrl: v => v, user: () => ({ id: 'a' }) };
|
|
const absent = page('pages/report/report.js', api); absent.p.setData({ product: { tier: 1 } }); absent.p.onMore();
|
|
assert.match(absent.toasts[0].content, /手机淘宝/);
|
|
let navCalls = 0; const toasts = [];
|
|
const failed = page('pages/report/report.js', api, { my: { tb: { openDetail(opts) { navCalls++; opts.fail({}); } }, showToast: v => toasts.push(v) } });
|
|
failed.p.setData({ product: { tier: 2 } }); failed.p.onMore(); failed.p.onMore();
|
|
assert.equal(navCalls, 2); assert.match(toasts[0].content, /无法打开/);
|
|
});
|
|
|
|
test('report ownership guard also clears a guest report after switching identity', () => {
|
|
const api = { assetUrl: v => v, user: () => ({ id: 'new-owner', kind: 'taobao' }) };
|
|
const r = page('pages/report/report.js', api); r.p.ownerId = 'guest-old';
|
|
r.p.photos = ['private']; r.p.payload = { private: true }; r.p.setData({ frontPhoto: 'private', cards: [{}] });
|
|
r.p.onShow(); assert.equal(r.p.data.frontPhoto, ''); assert.equal(r.p.photos.length, 0); assert.equal(r.p.payload, null);
|
|
assert.equal(r.nav[0].url, '/pages/login/login');
|
|
});
|
|
|
|
test('lost submission response reuses request_id/photo refs, and resuming a known job never resubmits analysis', async () => {
|
|
let submissions = 0, failFirst = true; const bodies = [];
|
|
const f = apiFixture((route, body) => {
|
|
if (route === 'photo') return { ok: true };
|
|
if (route === 'skin-analyze') { submissions++; bodies.push(JSON.parse(JSON.stringify(body))); if (failFirst) { failFirst = false; throw Error('response lost'); } return { ok: true, job: 'original-job' }; }
|
|
if (route === 'analysis') return { ok: true, status: 'complete', payload: { ok: true, result: {} } };
|
|
return sessions(route);
|
|
});
|
|
await f.api.loginGuest(true); const attempt = f.api.createAnalysisAttempt();
|
|
await assert.rejects(f.api.analyze(['data:image/jpeg;base64,YQ==', 'data:image/jpeg;base64,Yg==', 'data:image/jpeg;base64,Yw=='], { real_age: 30 }, {}, attempt), /response lost/);
|
|
await f.api.resumeAnalysis(attempt, {});
|
|
assert.equal(submissions, 2); assert.deepEqual(bodies[0], bodies[1]);
|
|
assert.equal(f.calls.filter(c => c.route.endsWith('/photo')).length, 3, 'stable refs are not reuploaded');
|
|
await f.api.resumeAnalysis(attempt, {}); assert.equal(submissions, 2);
|
|
await f.api.login(true); await assert.rejects(f.api.resumeAnalysis(attempt, {}), err => err.canceled === true);
|
|
});
|
|
|
|
test('cold launch route is the standalone login page', () => {
|
|
const project = JSON.parse(fs.readFileSync(path.join(base, 'app.json'), 'utf8'));
|
|
assert.equal(project.pages[0], 'pages/login/login');
|
|
assert.equal(project.pages.length, 6);
|
|
const build = JSON.parse(fs.readFileSync(path.join(base, 'mini.project.json'), 'utf8'));
|
|
for (const route of ['pages/mvp/mvp', 'pages/camtest/camtest', 'pages/camnative/camnative']) {
|
|
assert(!project.pages.includes(route));
|
|
const directory = route.slice(0, route.lastIndexOf('/')) + '/**';
|
|
assert(build.exclude.includes(directory)); assert(build.uploadExclude.includes(directory));
|
|
}
|
|
});
|
|
|
|
test('login has no diagnostic entry even if an old development flag is enabled', () => {
|
|
for (const [environment, cameraDebug] of [['development', false], ['development', true], ['production', true]]) {
|
|
const p = page('pages/login/login.js', { assetUrl: v => v }, {}, { '../../config': { environment, cameraDebug } });
|
|
assert.equal(p.p.onCameraTest, undefined);
|
|
assert.equal(p.nav.length, 0);
|
|
const markup = fs.readFileSync(path.join(base, 'pages/login/login.axml'), 'utf8');
|
|
assert.doesNotMatch(markup, /showCameraTest|onCameraTest|相机测试/);
|
|
}
|
|
});
|
|
|
|
test('foreground account revalidation gates business requests and clears a mismatched host identity', async () => {
|
|
let resolveMe, reportRequests = 0;
|
|
const f = apiFixture(route => {
|
|
if (route === 'me') return new Promise(resolve => { resolveMe = resolve; });
|
|
if (route === 'reports') { reportRequests++; return { ok: true, items: [] }; }
|
|
return sessions(route);
|
|
});
|
|
await f.api.login(true); f.app.globalData.photos = ['private'];
|
|
f.api.suspendSession();
|
|
const pending = f.api.request('reports'); await flush();
|
|
assert.equal(f.api.isSignedIn(), false); assert.equal(reportRequests, 0);
|
|
resolveMe({ ok: false, http_status: 401, message: '当前淘宝账号已变化' });
|
|
await assert.rejects(pending, /变化/);
|
|
assert.equal(f.api.user(), null); assert.equal(f.app.globalData.photos, null); assert.equal(reportRequests, 0);
|
|
});
|
|
|
|
test('a verification response from before host backgrounding cannot restore old identity', async () => {
|
|
const pending = [];
|
|
const f = apiFixture(route => route === 'me' ? new Promise(resolve => pending.push(resolve)) : sessions(route));
|
|
await f.api.login(true);
|
|
const oldCheck = f.api.restore(); await flush();
|
|
f.api.suspendSession(); const currentCheck = f.api.restore(); await flush();
|
|
pending[1]({ ok: true, user: { id: 'account-a', kind: 'taobao' } }); await currentCheck;
|
|
pending[0]({ ok: true, user: { id: 'stale-account', kind: 'taobao' } });
|
|
await assert.rejects(oldCheck, err => err.canceled === true);
|
|
assert.equal(f.api.user().id, 'account-a');
|
|
});
|
|
|
|
test('signed report stays hidden on revalidation network error and retry restores its unchanged tab/photo state', async () => {
|
|
let offline = true; const opens = [];
|
|
const user = { id: 'account-a', kind: 'taobao' };
|
|
const api = { assetUrl: v => v, user: () => user, restore: async () => { if (offline) throw Error('offline'); return user; } };
|
|
const r = page('pages/report/report.js', api, { my: { tb: { openDetail: opts => opens.push(opts) }, showToast() {} } });
|
|
r.p.ownerId = user.id; r.p.alive = true;
|
|
r.p.setData({ cards: [{ index: 1 }], frontPhoto: 'private-photo', product: { tier: 1 } });
|
|
const check = r.p.onShow(); assert.equal(r.p.data.identityChecking, true);
|
|
r.p.onMore(); assert.equal(opens.length, 0);
|
|
await check;
|
|
assert.match(r.p.data.identityError, /无法确认/); assert.equal(r.p.data.frontPhoto, 'private-photo');
|
|
assert.equal(r.p.data.cards[0].index, 1);
|
|
offline = false; await r.p.onRetryIdentity();
|
|
assert.equal(r.p.data.identityError, ''); assert.equal(r.p.data.identityChecking, false);
|
|
assert.equal(r.p.data.frontPhoto, 'private-photo'); assert.equal(r.p.data.cards[0].index, 1);
|
|
r.p.onMore(); assert.equal(opens.length, 1); r.p.onUnload();
|
|
});
|
|
|
|
test('profile 401 clears private fields and history never loads before current account verification', async () => {
|
|
const user = { id: 'account-a', kind: 'taobao' };
|
|
let requests = 0;
|
|
const api = { assetUrl: v => v, user: () => user,
|
|
restore: async () => { const err = Error('account changed'); err.status = 401; throw err; },
|
|
request() { requests++; return Promise.resolve({ ok: true, items: [] }); } };
|
|
const p = page('pages/profile/profile.js', api); p.p.ownerId = user.id;
|
|
p.p.setData({ birth: '1996-01', birthText: '1996年1月', genderText: '女', regionText: '北京' });
|
|
await p.p.onShow(); assert.equal(p.p.data.birth, ''); assert.equal(p.nav[0].url, '/pages/login/login');
|
|
const h = page('pages/history/history.js', api); await h.p.onShow();
|
|
assert.equal(requests, 0); assert.equal(h.nav[0].url, '/pages/login/login');
|
|
});
|