QLHazyCoder
1027 lines
36 KiB
JavaScript
1027 lines
36 KiB
JavaScript
const test = require('node:test');
|
||
const assert = require('node:assert/strict');
|
||
const fs = require('node:fs');
|
||
|
||
test('background imports message router module', () => {
|
||
const source = fs.readFileSync('background.js', 'utf8');
|
||
assert.match(source, /background\/message-router\.js/);
|
||
});
|
||
|
||
test('background defaults enable free phone reuse switches', () => {
|
||
const source = fs.readFileSync('background.js', 'utf8');
|
||
const defaultsStart = source.indexOf('const PERSISTED_SETTING_DEFAULTS = {');
|
||
const defaultsEnd = source.indexOf('const PERSISTED_SETTING_KEYS = Object.keys(PERSISTED_SETTING_DEFAULTS);');
|
||
const defaultsBlock = source.slice(defaultsStart, defaultsEnd);
|
||
|
||
assert.match(defaultsBlock, /freePhoneReuseEnabled:\s*true/);
|
||
assert.match(defaultsBlock, /freePhoneReuseAutoEnabled:\s*true/);
|
||
assert.match(defaultsBlock, /phoneSmsReuseEnabled:\s*DEFAULT_HERO_SMS_REUSE_ENABLED/);
|
||
});
|
||
|
||
test('background free reusable phone setter does not depend on module-scoped phone flow constants', () => {
|
||
const source = fs.readFileSync('background.js', 'utf8');
|
||
const setterStart = source.indexOf('async function setFreeReusablePhoneActivation');
|
||
const setterEnd = source.indexOf('// ============================================================\n// Tab Registry', setterStart);
|
||
const setterBlock = source.slice(setterStart, setterEnd);
|
||
|
||
assert.ok(setterStart >= 0, 'expected setFreeReusablePhoneActivation to exist');
|
||
assert.doesNotMatch(setterBlock, /DEFAULT_PHONE_NUMBER_MAX_USES/);
|
||
assert.match(setterBlock, /maxUses:\s*Math\.max\(1,\s*Math\.floor\(Number\(record\.maxUses\)\s*\|\|\s*3\)\)/);
|
||
});
|
||
|
||
test('background free reusable phone setter can recover local HeroSMS activation id by phone number', () => {
|
||
const source = fs.readFileSync('background.js', 'utf8');
|
||
const setterStart = source.indexOf('async function setFreeReusablePhoneActivation');
|
||
const setterEnd = source.indexOf('// ============================================================\n// Tab Registry', setterStart);
|
||
const setterBlock = source.slice(setterStart, setterEnd);
|
||
|
||
assert.match(source, /function findLocalHeroSmsActivationForPhone\(/);
|
||
assert.match(source, /state\.currentPhoneActivation/);
|
||
assert.match(source, /state\.reusablePhoneActivation/);
|
||
assert.match(source, /state\.signupPhoneActivation/);
|
||
assert.match(source, /state\.signupPhoneCompletedActivation/);
|
||
assert.match(source, /state\.phonePreferredActivation/);
|
||
assert.match(source, /state\.phoneReusableActivationPool/);
|
||
assert.match(setterBlock, /findLocalHeroSmsActivationForPhone\(state,\s*phoneNumber\)/);
|
||
assert.match(setterBlock, /activationId = String\(\s*record\.activationId[\s\S]*localActivation\?\.activationId/);
|
||
assert.match(setterBlock, /manualOnly:\s*!activationId/);
|
||
});
|
||
|
||
test('background blocks free reusable phone mutations while phone signup owns the identity', () => {
|
||
const source = fs.readFileSync('background.js', 'utf8');
|
||
const clearStart = source.indexOf('async function clearFreeReusablePhoneActivation');
|
||
const setterStart = source.indexOf('async function setFreeReusablePhoneActivation');
|
||
const setterEnd = source.indexOf('// ============================================================\n// Tab Registry', setterStart);
|
||
const clearBlock = source.slice(clearStart, setterStart);
|
||
const setterBlock = source.slice(setterStart, setterEnd);
|
||
|
||
assert.match(source, /function isPhoneSignupIdentityStateForReuse\(/);
|
||
assert.match(source, /function hasSignupPhoneActivationState\(/);
|
||
assert.match(clearBlock, /isPhoneSignupIdentityStateForReuse\(state\)/);
|
||
assert.match(setterBlock, /isPhoneSignupIdentityStateForReuse\(state\)/);
|
||
});
|
||
|
||
test('background HeroSMS phone prefix inference covers built-in major countries', () => {
|
||
const source = fs.readFileSync('background.js', 'utf8');
|
||
const supportedStart = source.indexOf('const HERO_SMS_SUPPORTED_COUNTRY_IDS = [');
|
||
const prefixStart = source.indexOf('const HERO_SMS_COUNTRY_BY_PHONE_PREFIX = Object.freeze([');
|
||
const prefixEnd = source.indexOf(']);', prefixStart);
|
||
const supportedBlock = source.slice(supportedStart, source.indexOf('];', supportedStart));
|
||
const prefixBlock = source.slice(prefixStart, prefixEnd);
|
||
|
||
assert.match(supportedBlock, /\[6,\s*52,\s*187,\s*16,\s*151,\s*43,\s*73,\s*10/);
|
||
[
|
||
['84', 10, 'Vietnam'],
|
||
['66', 52, 'Thailand'],
|
||
['62', 6, 'Indonesia'],
|
||
['44', 16, 'United Kingdom'],
|
||
['81', 151, 'Japan'],
|
||
['49', 43, 'Germany'],
|
||
['33', 73, 'France'],
|
||
['1', 187, 'USA'],
|
||
].forEach(([prefix, id, label]) => {
|
||
assert.match(prefixBlock, new RegExp(`prefix:\\s*'${prefix}'[\\s\\S]*id:\\s*${id}[\\s\\S]*label:\\s*'${label}'`));
|
||
});
|
||
});
|
||
|
||
test('message router module exposes a factory', () => {
|
||
const source = fs.readFileSync('background/message-router.js', 'utf8');
|
||
const globalScope = {};
|
||
|
||
const api = new Function('self', `${source}; return self.MultiPageBackgroundMessageRouter;`)(globalScope);
|
||
|
||
assert.equal(typeof api?.createMessageRouter, 'function');
|
||
});
|
||
|
||
test('SAVE_SETTING broadcasts free phone reuse setting updates for realtime sidepanel sync', async () => {
|
||
const source = fs.readFileSync('background/message-router.js', 'utf8');
|
||
const globalScope = { console };
|
||
const api = new Function('self', `${source}; return self.MultiPageBackgroundMessageRouter;`)(globalScope);
|
||
const broadcasts = [];
|
||
let state = {
|
||
freePhoneReuseEnabled: false,
|
||
freePhoneReuseAutoEnabled: false,
|
||
plusModeEnabled: false,
|
||
plusPaymentMethod: 'paypal',
|
||
};
|
||
|
||
const router = api.createMessageRouter({
|
||
addLog: async () => {},
|
||
buildLuckmailSessionSettingsPayload: () => ({}),
|
||
buildPersistentSettingsPayload: (input = {}) => {
|
||
const updates = {};
|
||
if (Object.prototype.hasOwnProperty.call(input, 'freePhoneReuseEnabled')) {
|
||
updates.freePhoneReuseEnabled = Boolean(input.freePhoneReuseEnabled);
|
||
}
|
||
if (Object.prototype.hasOwnProperty.call(input, 'freePhoneReuseAutoEnabled')) {
|
||
updates.freePhoneReuseAutoEnabled = Boolean(input.freePhoneReuseAutoEnabled);
|
||
}
|
||
return updates;
|
||
},
|
||
broadcastDataUpdate: (payload) => broadcasts.push(payload),
|
||
getState: async () => ({ ...state }),
|
||
setPersistentSettings: async (updates) => ({ ...updates }),
|
||
setState: async (updates) => {
|
||
state = { ...state, ...updates };
|
||
},
|
||
});
|
||
|
||
const response = await router.handleMessage({
|
||
type: 'SAVE_SETTING',
|
||
payload: {
|
||
freePhoneReuseEnabled: true,
|
||
freePhoneReuseAutoEnabled: true,
|
||
},
|
||
});
|
||
|
||
assert.equal(response.ok, true);
|
||
assert.equal(state.freePhoneReuseEnabled, true);
|
||
assert.equal(state.freePhoneReuseAutoEnabled, true);
|
||
assert.ok(
|
||
broadcasts.some((payload) => (
|
||
payload.freePhoneReuseEnabled === true
|
||
&& payload.freePhoneReuseAutoEnabled === true
|
||
)),
|
||
'expected SAVE_SETTING to broadcast free reuse switch updates'
|
||
);
|
||
});
|
||
|
||
test('SAVE_SETTING preserves phone reuse preferences while phone signup is selected', async () => {
|
||
const source = fs.readFileSync('background/message-router.js', 'utf8');
|
||
const globalScope = { console };
|
||
const api = new Function('self', `${source}; return self.MultiPageBackgroundMessageRouter;`)(globalScope);
|
||
const persistedPayloads = [];
|
||
let state = {
|
||
signupMethod: 'phone',
|
||
phoneVerificationEnabled: true,
|
||
plusModeEnabled: false,
|
||
phoneSmsReuseEnabled: true,
|
||
heroSmsReuseEnabled: true,
|
||
freePhoneReuseEnabled: true,
|
||
freePhoneReuseAutoEnabled: true,
|
||
phonePreferredActivation: {
|
||
provider: 'hero-sms',
|
||
activationId: 'stored',
|
||
phoneNumber: '66950001111',
|
||
},
|
||
};
|
||
|
||
const router = api.createMessageRouter({
|
||
addLog: async () => {},
|
||
buildLuckmailSessionSettingsPayload: () => ({}),
|
||
buildPersistentSettingsPayload: (input = {}) => ({
|
||
signupMethod: String(input.signupMethod || state.signupMethod),
|
||
phoneSmsReuseEnabled: Boolean(input.phoneSmsReuseEnabled),
|
||
heroSmsReuseEnabled: Boolean(input.heroSmsReuseEnabled),
|
||
freePhoneReuseEnabled: Boolean(input.freePhoneReuseEnabled),
|
||
freePhoneReuseAutoEnabled: Boolean(input.freePhoneReuseAutoEnabled),
|
||
phonePreferredActivation: input.phonePreferredActivation ?? null,
|
||
}),
|
||
broadcastDataUpdate: () => {},
|
||
getState: async () => ({ ...state }),
|
||
setPersistentSettings: async (updates) => {
|
||
persistedPayloads.push({ ...updates });
|
||
return { ...updates };
|
||
},
|
||
setState: async (updates) => {
|
||
state = { ...state, ...updates };
|
||
},
|
||
});
|
||
|
||
const response = await router.handleMessage({
|
||
type: 'SAVE_SETTING',
|
||
payload: {
|
||
signupMethod: 'phone',
|
||
phoneSmsReuseEnabled: false,
|
||
heroSmsReuseEnabled: false,
|
||
freePhoneReuseEnabled: false,
|
||
freePhoneReuseAutoEnabled: false,
|
||
phonePreferredActivation: null,
|
||
},
|
||
});
|
||
|
||
assert.equal(response.ok, true);
|
||
assert.equal(state.phoneSmsReuseEnabled, true);
|
||
assert.equal(state.heroSmsReuseEnabled, true);
|
||
assert.equal(state.freePhoneReuseEnabled, true);
|
||
assert.equal(state.freePhoneReuseAutoEnabled, true);
|
||
assert.deepStrictEqual(state.phonePreferredActivation, {
|
||
provider: 'hero-sms',
|
||
activationId: 'stored',
|
||
phoneNumber: '66950001111',
|
||
});
|
||
assert.equal(persistedPayloads[0].phoneSmsReuseEnabled, true);
|
||
assert.equal(persistedPayloads[0].freePhoneReuseEnabled, true);
|
||
});
|
||
|
||
test('SAVE_SETTING allows phone reuse preferences after switching back to email signup', async () => {
|
||
const source = fs.readFileSync('background/message-router.js', 'utf8');
|
||
const globalScope = { console };
|
||
const api = new Function('self', `${source}; return self.MultiPageBackgroundMessageRouter;`)(globalScope);
|
||
let state = {
|
||
signupMethod: 'phone',
|
||
phoneVerificationEnabled: true,
|
||
plusModeEnabled: false,
|
||
phoneSmsReuseEnabled: true,
|
||
heroSmsReuseEnabled: true,
|
||
freePhoneReuseEnabled: true,
|
||
freePhoneReuseAutoEnabled: true,
|
||
};
|
||
|
||
const router = api.createMessageRouter({
|
||
addLog: async () => {},
|
||
buildLuckmailSessionSettingsPayload: () => ({}),
|
||
buildPersistentSettingsPayload: (input = {}) => ({
|
||
signupMethod: String(input.signupMethod || state.signupMethod),
|
||
phoneSmsReuseEnabled: Boolean(input.phoneSmsReuseEnabled),
|
||
heroSmsReuseEnabled: Boolean(input.heroSmsReuseEnabled),
|
||
freePhoneReuseEnabled: Boolean(input.freePhoneReuseEnabled),
|
||
freePhoneReuseAutoEnabled: Boolean(input.freePhoneReuseAutoEnabled),
|
||
}),
|
||
broadcastDataUpdate: () => {},
|
||
getState: async () => ({ ...state }),
|
||
setPersistentSettings: async (updates) => ({ ...updates }),
|
||
setState: async (updates) => {
|
||
state = { ...state, ...updates };
|
||
},
|
||
});
|
||
|
||
const response = await router.handleMessage({
|
||
type: 'SAVE_SETTING',
|
||
payload: {
|
||
signupMethod: 'email',
|
||
phoneSmsReuseEnabled: false,
|
||
heroSmsReuseEnabled: false,
|
||
freePhoneReuseEnabled: false,
|
||
freePhoneReuseAutoEnabled: false,
|
||
},
|
||
});
|
||
|
||
assert.equal(response.ok, true);
|
||
assert.equal(state.signupMethod, 'email');
|
||
assert.equal(state.phoneSmsReuseEnabled, false);
|
||
assert.equal(state.heroSmsReuseEnabled, false);
|
||
assert.equal(state.freePhoneReuseEnabled, false);
|
||
assert.equal(state.freePhoneReuseAutoEnabled, false);
|
||
});
|
||
|
||
test('SAVE_SETTING broadcasts operation delay setting without background success log', async () => {
|
||
const source = fs.readFileSync('background/message-router.js', 'utf8');
|
||
const globalScope = { console };
|
||
const api = new Function('self', `${source}; return self.MultiPageBackgroundMessageRouter;`)(globalScope);
|
||
const broadcasts = [];
|
||
const logs = [];
|
||
let state = { operationDelayEnabled: true, plusModeEnabled: false, plusPaymentMethod: 'paypal' };
|
||
|
||
const router = api.createMessageRouter({
|
||
addLog: async (message, level = 'info') => logs.push({ message, level }),
|
||
buildLuckmailSessionSettingsPayload: () => ({}),
|
||
buildPersistentSettingsPayload: (input = {}) => Object.prototype.hasOwnProperty.call(input, 'operationDelayEnabled')
|
||
? { operationDelayEnabled: true }
|
||
: {},
|
||
broadcastDataUpdate: (payload) => broadcasts.push(payload),
|
||
getState: async () => ({ ...state }),
|
||
setPersistentSettings: async (updates) => ({ ...updates }),
|
||
setState: async (updates) => { state = { ...state, ...updates }; },
|
||
});
|
||
|
||
const response = await router.handleMessage({
|
||
type: 'SAVE_SETTING',
|
||
source: 'sidepanel',
|
||
payload: { operationDelayEnabled: false },
|
||
});
|
||
|
||
assert.equal(response.ok, true);
|
||
assert.equal(state.operationDelayEnabled, true);
|
||
assert.deepStrictEqual(broadcasts.at(-1), { operationDelayEnabled: true });
|
||
assert.equal(logs.length, 0);
|
||
});
|
||
|
||
test('SAVE_SETTING rebuilds Plus node statuses when the account access strategy changes', async () => {
|
||
const source = fs.readFileSync('background/message-router.js', 'utf8');
|
||
const globalScope = { console };
|
||
const api = new Function('self', `${source}; return self.MultiPageBackgroundMessageRouter;`)(globalScope);
|
||
const broadcasts = [];
|
||
let state = {
|
||
plusModeEnabled: true,
|
||
plusPaymentMethod: 'paypal',
|
||
plusAccountAccessStrategy: 'oauth',
|
||
oauthUrl: 'https://oauth.example/current',
|
||
localhostUrl: 'http://localhost:38080/callback',
|
||
oauthFlowDeadlineAt: Date.now() + 60000,
|
||
oauthFlowDeadlineSourceUrl: 'https://oauth.example/current',
|
||
cpaOAuthState: 'cpa-state',
|
||
cpaManagementOrigin: 'https://cpa.example.com',
|
||
sub2apiSessionId: 'sub-session',
|
||
sub2apiOAuthState: 'sub-oauth-state',
|
||
sub2apiGroupId: 'group-id',
|
||
sub2apiGroupIds: ['group-id'],
|
||
sub2apiDraftName: 'draft-name',
|
||
sub2apiProxyId: 'proxy-id',
|
||
codex2apiSessionId: 'codex-session',
|
||
codex2apiOAuthState: 'codex-oauth-state',
|
||
plusManualConfirmationPending: true,
|
||
plusManualConfirmationRequestId: 'gopay-req',
|
||
plusManualConfirmationStep: 9,
|
||
plusManualConfirmationMethod: 'gopay',
|
||
plusManualConfirmationTitle: 'GoPay 订阅确认',
|
||
plusManualConfirmationMessage: '完成后继续 OAuth 登录。',
|
||
currentNodeId: 'confirm-oauth',
|
||
nodeStatuses: {
|
||
'open-chatgpt': 'completed',
|
||
'plus-checkout-create': 'completed',
|
||
'plus-checkout-billing': 'completed',
|
||
'paypal-approve': 'completed',
|
||
'plus-checkout-return': 'completed',
|
||
'oauth-login': 'completed',
|
||
'fetch-login-code': 'completed',
|
||
'post-login-phone-verification': 'completed',
|
||
'confirm-oauth': 'running',
|
||
'platform-verify': 'pending',
|
||
},
|
||
};
|
||
|
||
const router = api.createMessageRouter({
|
||
addLog: async () => {},
|
||
buildLuckmailSessionSettingsPayload: () => ({}),
|
||
buildPersistentSettingsPayload: (input = {}) => Object.prototype.hasOwnProperty.call(input, 'plusAccountAccessStrategy')
|
||
? { plusAccountAccessStrategy: input.plusAccountAccessStrategy }
|
||
: {},
|
||
broadcastDataUpdate: (payload) => broadcasts.push(payload),
|
||
getNodeIdsForState: (nextState = {}) => (
|
||
String(nextState.plusAccountAccessStrategy || '').trim() === 'sub2api_codex_session'
|
||
? [
|
||
'open-chatgpt',
|
||
'plus-checkout-create',
|
||
'plus-checkout-billing',
|
||
'paypal-approve',
|
||
'plus-checkout-return',
|
||
'sub2api-session-import',
|
||
]
|
||
: [
|
||
'open-chatgpt',
|
||
'plus-checkout-create',
|
||
'plus-checkout-billing',
|
||
'paypal-approve',
|
||
'plus-checkout-return',
|
||
'oauth-login',
|
||
'fetch-login-code',
|
||
'post-login-phone-verification',
|
||
'confirm-oauth',
|
||
'platform-verify',
|
||
]
|
||
),
|
||
getState: async () => ({ ...state }),
|
||
getStepIdsForState: () => [],
|
||
setPersistentSettings: async (updates) => ({ ...updates }),
|
||
setState: async (updates) => {
|
||
state = { ...state, ...updates };
|
||
},
|
||
});
|
||
|
||
const response = await router.handleMessage({
|
||
type: 'SAVE_SETTING',
|
||
payload: {
|
||
plusAccountAccessStrategy: 'sub2api_codex_session',
|
||
},
|
||
});
|
||
|
||
assert.equal(response.ok, true);
|
||
assert.equal(state.plusAccountAccessStrategy, 'sub2api_codex_session');
|
||
assert.equal(state.currentNodeId, '');
|
||
assert.equal(state.oauthUrl, null);
|
||
assert.equal(state.localhostUrl, null);
|
||
assert.equal(state.oauthFlowDeadlineAt, null);
|
||
assert.equal(state.oauthFlowDeadlineSourceUrl, null);
|
||
assert.equal(state.cpaOAuthState, null);
|
||
assert.equal(state.cpaManagementOrigin, null);
|
||
assert.equal(state.sub2apiSessionId, null);
|
||
assert.equal(state.sub2apiOAuthState, null);
|
||
assert.equal(state.sub2apiGroupId, null);
|
||
assert.deepStrictEqual(state.sub2apiGroupIds, []);
|
||
assert.equal(state.sub2apiDraftName, null);
|
||
assert.equal(state.sub2apiProxyId, null);
|
||
assert.equal(state.codex2apiSessionId, null);
|
||
assert.equal(state.codex2apiOAuthState, null);
|
||
assert.equal(state.plusManualConfirmationPending, false);
|
||
assert.equal(state.plusManualConfirmationRequestId, '');
|
||
assert.equal(state.plusManualConfirmationStep, 0);
|
||
assert.equal(state.plusManualConfirmationMethod, '');
|
||
assert.equal(state.plusManualConfirmationTitle, '');
|
||
assert.equal(state.plusManualConfirmationMessage, '');
|
||
assert.deepStrictEqual(state.nodeStatuses, {
|
||
'open-chatgpt': 'pending',
|
||
'plus-checkout-create': 'pending',
|
||
'plus-checkout-billing': 'pending',
|
||
'paypal-approve': 'pending',
|
||
'plus-checkout-return': 'pending',
|
||
'sub2api-session-import': 'pending',
|
||
});
|
||
assert.equal(Object.prototype.hasOwnProperty.call(state.nodeStatuses, 'oauth-login'), false);
|
||
assert.equal(Object.prototype.hasOwnProperty.call(state.nodeStatuses, 'platform-verify'), false);
|
||
assert.deepStrictEqual(broadcasts.at(-1), {
|
||
plusAccountAccessStrategy: 'sub2api_codex_session',
|
||
oauthUrl: null,
|
||
localhostUrl: null,
|
||
oauthFlowDeadlineAt: null,
|
||
oauthFlowDeadlineSourceUrl: null,
|
||
cpaOAuthState: null,
|
||
cpaManagementOrigin: null,
|
||
sub2apiSessionId: null,
|
||
sub2apiOAuthState: null,
|
||
sub2apiGroupId: null,
|
||
sub2apiGroupIds: [],
|
||
sub2apiDraftName: null,
|
||
sub2apiProxyId: null,
|
||
codex2apiSessionId: null,
|
||
codex2apiOAuthState: null,
|
||
plusManualConfirmationPending: false,
|
||
plusManualConfirmationRequestId: '',
|
||
plusManualConfirmationStep: 0,
|
||
plusManualConfirmationMethod: '',
|
||
plusManualConfirmationTitle: '',
|
||
plusManualConfirmationMessage: '',
|
||
nodeStatuses: {
|
||
'open-chatgpt': 'pending',
|
||
'plus-checkout-create': 'pending',
|
||
'plus-checkout-billing': 'pending',
|
||
'paypal-approve': 'pending',
|
||
'plus-checkout-return': 'pending',
|
||
'sub2api-session-import': 'pending',
|
||
},
|
||
currentNodeId: '',
|
||
});
|
||
});
|
||
|
||
test('SAVE_SETTING rebuilds Plus node statuses when panel mode forces the effective strategy back to OAuth', async () => {
|
||
const source = fs.readFileSync('background/message-router.js', 'utf8');
|
||
const globalScope = { console };
|
||
const api = new Function('self', `${source}; return self.MultiPageBackgroundMessageRouter;`)(globalScope);
|
||
const broadcasts = [];
|
||
let state = {
|
||
targetId: 'sub2api',
|
||
plusModeEnabled: true,
|
||
plusPaymentMethod: 'paypal',
|
||
plusAccountAccessStrategy: 'sub2api_codex_session',
|
||
oauthUrl: 'https://oauth.example/current',
|
||
localhostUrl: 'http://localhost:38080/callback',
|
||
sub2apiSessionId: 'sub-session',
|
||
plusManualConfirmationPending: true,
|
||
plusManualConfirmationRequestId: 'gopay-req',
|
||
plusManualConfirmationStep: 9,
|
||
plusManualConfirmationMethod: 'gopay',
|
||
plusManualConfirmationTitle: 'GoPay 订阅确认',
|
||
plusManualConfirmationMessage: '完成后继续导入当前 ChatGPT 会话到 SUB2API。',
|
||
currentNodeId: 'sub2api-session-import',
|
||
nodeStatuses: {
|
||
'open-chatgpt': 'completed',
|
||
'plus-checkout-create': 'completed',
|
||
'plus-checkout-billing': 'completed',
|
||
'paypal-approve': 'completed',
|
||
'plus-checkout-return': 'completed',
|
||
'sub2api-session-import': 'running',
|
||
},
|
||
};
|
||
|
||
const router = api.createMessageRouter({
|
||
addLog: async () => {},
|
||
buildLuckmailSessionSettingsPayload: () => ({}),
|
||
buildPersistentSettingsPayload: (input = {}) => Object.prototype.hasOwnProperty.call(input, 'targetId')
|
||
? { targetId: input.targetId }
|
||
: {},
|
||
broadcastDataUpdate: (payload) => broadcasts.push(payload),
|
||
getNodeIdsForState: (nextState = {}) => (
|
||
String(nextState.targetId || '').trim() === 'sub2api'
|
||
&& String(nextState.plusAccountAccessStrategy || '').trim() === 'sub2api_codex_session'
|
||
? [
|
||
'open-chatgpt',
|
||
'plus-checkout-create',
|
||
'plus-checkout-billing',
|
||
'paypal-approve',
|
||
'plus-checkout-return',
|
||
'sub2api-session-import',
|
||
]
|
||
: [
|
||
'open-chatgpt',
|
||
'plus-checkout-create',
|
||
'plus-checkout-billing',
|
||
'paypal-approve',
|
||
'plus-checkout-return',
|
||
'oauth-login',
|
||
'fetch-login-code',
|
||
'post-login-phone-verification',
|
||
'confirm-oauth',
|
||
'platform-verify',
|
||
]
|
||
),
|
||
getState: async () => ({ ...state }),
|
||
getStepIdsForState: () => [],
|
||
setPersistentSettings: async (updates) => ({ ...updates }),
|
||
setState: async (updates) => {
|
||
state = { ...state, ...updates };
|
||
},
|
||
});
|
||
|
||
const response = await router.handleMessage({
|
||
type: 'SAVE_SETTING',
|
||
payload: {
|
||
targetId: 'cpa',
|
||
},
|
||
});
|
||
|
||
assert.equal(response.ok, true);
|
||
assert.equal(state.targetId, 'cpa');
|
||
assert.equal(state.plusAccountAccessStrategy, 'sub2api_codex_session');
|
||
assert.equal(state.currentNodeId, '');
|
||
assert.equal(state.oauthUrl, null);
|
||
assert.equal(state.localhostUrl, null);
|
||
assert.equal(state.sub2apiSessionId, null);
|
||
assert.equal(state.plusManualConfirmationPending, false);
|
||
assert.equal(state.plusManualConfirmationMessage, '');
|
||
assert.deepStrictEqual(state.nodeStatuses, {
|
||
'open-chatgpt': 'pending',
|
||
'plus-checkout-create': 'pending',
|
||
'plus-checkout-billing': 'pending',
|
||
'paypal-approve': 'pending',
|
||
'plus-checkout-return': 'pending',
|
||
'oauth-login': 'pending',
|
||
'fetch-login-code': 'pending',
|
||
'post-login-phone-verification': 'pending',
|
||
'confirm-oauth': 'pending',
|
||
'platform-verify': 'pending',
|
||
});
|
||
assert.equal(Object.prototype.hasOwnProperty.call(state.nodeStatuses, 'sub2api-session-import'), false);
|
||
assert.deepStrictEqual(broadcasts.at(-1), {
|
||
targetId: 'cpa',
|
||
signupMethod: 'email',
|
||
oauthUrl: null,
|
||
localhostUrl: null,
|
||
oauthFlowDeadlineAt: null,
|
||
oauthFlowDeadlineSourceUrl: null,
|
||
cpaOAuthState: null,
|
||
cpaManagementOrigin: null,
|
||
sub2apiSessionId: null,
|
||
sub2apiOAuthState: null,
|
||
sub2apiGroupId: null,
|
||
sub2apiGroupIds: [],
|
||
sub2apiDraftName: null,
|
||
sub2apiProxyId: null,
|
||
codex2apiSessionId: null,
|
||
codex2apiOAuthState: null,
|
||
plusManualConfirmationPending: false,
|
||
plusManualConfirmationRequestId: '',
|
||
plusManualConfirmationStep: 0,
|
||
plusManualConfirmationMethod: '',
|
||
plusManualConfirmationTitle: '',
|
||
plusManualConfirmationMessage: '',
|
||
nodeStatuses: {
|
||
'open-chatgpt': 'pending',
|
||
'plus-checkout-create': 'pending',
|
||
'plus-checkout-billing': 'pending',
|
||
'paypal-approve': 'pending',
|
||
'plus-checkout-return': 'pending',
|
||
'oauth-login': 'pending',
|
||
'fetch-login-code': 'pending',
|
||
'post-login-phone-verification': 'pending',
|
||
'confirm-oauth': 'pending',
|
||
'platform-verify': 'pending',
|
||
},
|
||
currentNodeId: '',
|
||
});
|
||
});
|
||
|
||
test('SAVE_SETTING mirrors activeFlowId into flowId when switching to kiro flow', async () => {
|
||
const source = fs.readFileSync('background/message-router.js', 'utf8');
|
||
const globalScope = { console };
|
||
const api = new Function('self', `${source}; return self.MultiPageBackgroundMessageRouter;`)(globalScope);
|
||
const broadcasts = [];
|
||
let state = { activeFlowId: 'openai', flowId: 'openai', targetId: 'cpa', plusModeEnabled: false, plusPaymentMethod: 'paypal' };
|
||
|
||
const router = api.createMessageRouter({
|
||
addLog: async () => {},
|
||
buildLuckmailSessionSettingsPayload: () => ({}),
|
||
buildPersistentSettingsPayload: (input = {}) => Object.prototype.hasOwnProperty.call(input, 'activeFlowId')
|
||
? { activeFlowId: input.activeFlowId }
|
||
: {},
|
||
broadcastDataUpdate: (payload) => broadcasts.push(payload),
|
||
getState: async () => ({ ...state }),
|
||
setPersistentSettings: async (updates) => ({ ...updates }),
|
||
setState: async (updates) => { state = { ...state, ...updates }; },
|
||
});
|
||
|
||
const response = await router.handleMessage({
|
||
type: 'SAVE_SETTING',
|
||
source: 'sidepanel',
|
||
payload: { activeFlowId: 'kiro' },
|
||
});
|
||
|
||
assert.equal(response.ok, true);
|
||
assert.equal(state.activeFlowId, 'kiro');
|
||
assert.equal(state.flowId, 'kiro');
|
||
assert.deepStrictEqual(broadcasts.at(-1), {
|
||
activeFlowId: 'kiro',
|
||
flowId: 'kiro',
|
||
signupMethod: 'email',
|
||
});
|
||
});
|
||
|
||
test('CLEAR_GROK_SSO_COOKIES delegates canonical runtime cleanup to background', async () => {
|
||
const source = fs.readFileSync('background/message-router.js', 'utf8');
|
||
const globalScope = { console };
|
||
const api = new Function('self', `${source}; return self.MultiPageBackgroundMessageRouter;`)(globalScope);
|
||
let called = false;
|
||
const router = api.createMessageRouter({
|
||
clearGrokSsoCookies: async () => {
|
||
called = true;
|
||
return {
|
||
ok: true,
|
||
state: {
|
||
grokSsoCookie: '',
|
||
grokSsoCookies: [],
|
||
runtimeState: {
|
||
flowState: {
|
||
grok: {
|
||
sso: {
|
||
currentCookie: '',
|
||
cookies: [],
|
||
extractedAt: 0,
|
||
},
|
||
},
|
||
},
|
||
},
|
||
},
|
||
};
|
||
},
|
||
});
|
||
|
||
const response = await router.handleMessage({
|
||
type: 'CLEAR_GROK_SSO_COOKIES',
|
||
source: 'sidepanel',
|
||
payload: {},
|
||
});
|
||
|
||
assert.equal(called, true);
|
||
assert.equal(response.ok, true);
|
||
assert.deepStrictEqual(response.state.grokSsoCookies, []);
|
||
assert.equal(response.state.runtimeState.flowState.grok.sso.currentCookie, '');
|
||
});
|
||
|
||
test('SAVE_SETTING syncs canonical kiro settingsState back into session state', async () => {
|
||
const source = fs.readFileSync('background/message-router.js', 'utf8');
|
||
const globalScope = { console };
|
||
const api = new Function('self', `${source}; return self.MultiPageBackgroundMessageRouter;`)(globalScope);
|
||
const canonicalSettingsState = {
|
||
schemaVersion: 4,
|
||
activeFlowId: 'kiro',
|
||
services: {
|
||
account: { customPassword: '' },
|
||
email: { provider: 'duck' },
|
||
proxy: { enabled: false, provider: '711proxy', mode: 'account' },
|
||
},
|
||
flows: {
|
||
openai: {
|
||
integrationTargetId: 'cpa',
|
||
integrationTargets: {
|
||
cpa: { vpsUrl: '', vpsPassword: '', localCpaStep9Mode: 'submit' },
|
||
sub2api: {
|
||
sub2apiUrl: '',
|
||
sub2apiEmail: '',
|
||
sub2apiPassword: '',
|
||
sub2apiGroupName: 'codex',
|
||
sub2apiGroupNames: ['codex', 'openai-plus'],
|
||
sub2apiAccountPriority: 1,
|
||
sub2apiDefaultProxyName: '',
|
||
},
|
||
codex2api: { codex2apiUrl: '', codex2apiAdminKey: '' },
|
||
},
|
||
signup: {
|
||
signupMethod: 'email',
|
||
phoneVerificationEnabled: false,
|
||
phoneSignupReloginAfterBindEmailEnabled: false,
|
||
},
|
||
plus: {
|
||
plusModeEnabled: false,
|
||
plusPaymentMethod: 'paypal',
|
||
},
|
||
autoRun: {
|
||
stepExecutionRange: { enabled: false, fromStep: 1, toStep: 11 },
|
||
},
|
||
},
|
||
kiro: {
|
||
targetId: 'kiro-rs',
|
||
targets: {
|
||
'kiro-rs': {
|
||
baseUrl: 'https://kiro.example.com/admin',
|
||
apiKey: 'live-key',
|
||
},
|
||
},
|
||
autoRun: {
|
||
stepExecutionRange: { enabled: false, fromStep: 1, toStep: 9 },
|
||
},
|
||
},
|
||
},
|
||
};
|
||
let state = {
|
||
activeFlowId: 'kiro',
|
||
flowId: 'kiro',
|
||
targetId: 'kiro-rs',
|
||
kiroRsUrl: 'https://kiro.example.com/admin',
|
||
kiroRsKey: '',
|
||
settingsSchemaVersion: 4,
|
||
settingsState: {
|
||
...canonicalSettingsState,
|
||
flows: {
|
||
...canonicalSettingsState.flows,
|
||
kiro: {
|
||
...canonicalSettingsState.flows.kiro,
|
||
targets: {
|
||
'kiro-rs': {
|
||
baseUrl: 'https://kiro.example.com/admin',
|
||
apiKey: '',
|
||
},
|
||
},
|
||
},
|
||
},
|
||
},
|
||
plusModeEnabled: false,
|
||
plusPaymentMethod: 'paypal',
|
||
};
|
||
|
||
const router = api.createMessageRouter({
|
||
addLog: async () => {},
|
||
buildLuckmailSessionSettingsPayload: () => ({}),
|
||
buildPersistentSettingsPayload: (input = {}) => ({
|
||
activeFlowId: String(input.activeFlowId || 'kiro'),
|
||
kiroRsKey: String(input.kiroRsKey || ''),
|
||
}),
|
||
broadcastDataUpdate: () => {},
|
||
getState: async () => ({ ...state }),
|
||
setPersistentSettings: async () => ({
|
||
activeFlowId: 'kiro',
|
||
flowId: 'kiro',
|
||
targetId: 'kiro-rs',
|
||
kiroRsUrl: 'https://kiro.example.com/admin',
|
||
kiroRsKey: 'live-key',
|
||
settingsSchemaVersion: 4,
|
||
settingsState: canonicalSettingsState,
|
||
}),
|
||
setState: async (updates) => {
|
||
state = { ...state, ...updates };
|
||
},
|
||
});
|
||
|
||
const response = await router.handleMessage({
|
||
type: 'SAVE_SETTING',
|
||
payload: {
|
||
activeFlowId: 'kiro',
|
||
kiroRsKey: 'live-key',
|
||
},
|
||
});
|
||
|
||
assert.equal(response.ok, true);
|
||
assert.equal(state.kiroRsKey, 'live-key');
|
||
assert.equal(state.settingsState.flows.kiro.targets['kiro-rs'].apiKey, 'live-key');
|
||
});
|
||
|
||
test('CHECK_KIRO_RS_CONNECTION prefers current sidepanel payload over stale saved kiro.rs config', async () => {
|
||
const source = fs.readFileSync('background/message-router.js', 'utf8');
|
||
const globalScope = { console };
|
||
const api = new Function('self', `${source}; return self.MultiPageBackgroundMessageRouter;`)(globalScope);
|
||
const calls = [];
|
||
const router = api.createMessageRouter({
|
||
getState: async () => ({
|
||
activeFlowId: 'kiro',
|
||
flowId: 'kiro',
|
||
targetId: 'kiro-rs',
|
||
kiroRsUrl: 'https://old.example.com/admin',
|
||
kiroRsKey: 'old-key',
|
||
settingsState: {
|
||
flows: {
|
||
kiro: {
|
||
targetId: 'kiro-rs',
|
||
targets: {
|
||
'kiro-rs': {
|
||
baseUrl: 'https://old.example.com/admin',
|
||
apiKey: 'old-key',
|
||
},
|
||
},
|
||
},
|
||
},
|
||
},
|
||
}),
|
||
testKiroRsConnection: async (baseUrl, apiKey) => {
|
||
calls.push({ baseUrl, apiKey });
|
||
return {
|
||
ok: false,
|
||
status: 401,
|
||
message: 'kiro.rs API Key 被拒绝（HTTP 401：Invalid or missing admin API key）',
|
||
};
|
||
},
|
||
});
|
||
|
||
const response = await router.handleMessage({
|
||
type: 'CHECK_KIRO_RS_CONNECTION',
|
||
payload: {
|
||
activeFlowId: 'kiro',
|
||
targetId: 'kiro-rs',
|
||
baseUrl: ' https://new.example.com/admin/ ',
|
||
apiKey: ' new-key ',
|
||
},
|
||
});
|
||
|
||
assert.equal(response.ok, false);
|
||
assert.equal(response.status, 401);
|
||
assert.equal(response.message, 'kiro.rs API Key 被拒绝（HTTP 401：Invalid or missing admin API key）');
|
||
assert.deepStrictEqual(calls, [
|
||
{
|
||
baseUrl: 'https://new.example.com/admin/',
|
||
apiKey: ' new-key ',
|
||
},
|
||
]);
|
||
});
|
||
|
||
test('AUTO_RUN applies current flow selection from payload before starting loop', async () => {
|
||
const source = fs.readFileSync('background/message-router.js', 'utf8');
|
||
const globalScope = { console };
|
||
const api = new Function('self', `${source}; return self.MultiPageBackgroundMessageRouter;`)(globalScope);
|
||
const calls = [];
|
||
const validations = [];
|
||
let state = {
|
||
activeFlowId: 'openai',
|
||
flowId: 'openai',
|
||
targetId: 'cpa',
|
||
plusModeEnabled: false,
|
||
plusPaymentMethod: 'paypal',
|
||
};
|
||
|
||
const router = api.createMessageRouter({
|
||
clearStopRequest: () => {},
|
||
getPendingAutoRunTimerPlan: () => null,
|
||
getState: async () => ({ ...state }),
|
||
normalizeRunCount: (value) => Number(value) || 1,
|
||
setState: async (updates) => {
|
||
calls.push({ type: 'setState', updates: { ...updates } });
|
||
state = { ...state, ...updates };
|
||
},
|
||
startAutoRunLoop: (totalRuns, options) => {
|
||
calls.push({ type: 'startAutoRunLoop', totalRuns, options });
|
||
},
|
||
validateAutoRunStart: (validationState, options = {}) => {
|
||
validations.push({
|
||
activeFlowId: validationState?.activeFlowId,
|
||
flowId: validationState?.flowId,
|
||
targetId: validationState?.targetId,
|
||
optionActiveFlowId: options?.activeFlowId,
|
||
});
|
||
return { ok: true, errors: [] };
|
||
},
|
||
});
|
||
|
||
const response = await router.handleMessage({
|
||
type: 'AUTO_RUN',
|
||
payload: {
|
||
totalRuns: 1,
|
||
activeFlowId: 'kiro',
|
||
targetId: 'kiro-rs',
|
||
},
|
||
});
|
||
|
||
assert.equal(response.ok, true);
|
||
assert.equal(state.activeFlowId, 'kiro');
|
||
assert.equal(state.flowId, 'kiro');
|
||
assert.equal(state.targetId, 'kiro-rs');
|
||
assert.deepStrictEqual(calls, [
|
||
{
|
||
type: 'setState',
|
||
updates: {
|
||
activeFlowId: 'kiro',
|
||
flowId: 'kiro',
|
||
targetId: 'kiro-rs',
|
||
},
|
||
},
|
||
{
|
||
type: 'setState',
|
||
updates: {
|
||
autoRunSkipFailures: false,
|
||
},
|
||
},
|
||
{
|
||
type: 'startAutoRunLoop',
|
||
totalRuns: 1,
|
||
options: {
|
||
autoRunSkipFailures: false,
|
||
mode: 'restart',
|
||
},
|
||
},
|
||
]);
|
||
assert.deepStrictEqual(validations, [
|
||
{
|
||
activeFlowId: 'kiro',
|
||
flowId: 'kiro',
|
||
targetId: 'kiro-rs',
|
||
optionActiveFlowId: 'kiro',
|
||
},
|
||
]);
|
||
});
|
||
|
||
test('SAVE_SETTING re-resolves signup method when panel mode changes', async () => {
|
||
const source = fs.readFileSync('background/message-router.js', 'utf8');
|
||
const globalScope = { console };
|
||
const api = new Function('self', `${source}; return self.MultiPageBackgroundMessageRouter;`)(globalScope);
|
||
let state = {
|
||
signupMethod: 'phone',
|
||
phoneVerificationEnabled: true,
|
||
plusModeEnabled: false,
|
||
targetId: 'sub2api',
|
||
};
|
||
|
||
const router = api.createMessageRouter({
|
||
addLog: async () => {},
|
||
buildLuckmailSessionSettingsPayload: () => ({}),
|
||
buildPersistentSettingsPayload: (input = {}) => Object.prototype.hasOwnProperty.call(input, 'targetId')
|
||
? { targetId: input.targetId }
|
||
: {},
|
||
broadcastDataUpdate: () => {},
|
||
getState: async () => ({ ...state }),
|
||
resolveSignupMethod: (nextState = {}) => nextState.targetId === 'cpa' ? 'email' : 'phone',
|
||
setPersistentSettings: async (updates) => ({ ...updates }),
|
||
setState: async (updates) => {
|
||
state = { ...state, ...updates };
|
||
},
|
||
});
|
||
|
||
const response = await router.handleMessage({
|
||
type: 'SAVE_SETTING',
|
||
payload: { targetId: 'cpa' },
|
||
});
|
||
|
||
assert.equal(response.ok, true);
|
||
assert.equal(state.targetId, 'cpa');
|
||
assert.equal(state.signupMethod, 'email');
|
||
});
|
||
|
||
test('SAVE_SETTING applies shared mode-switch normalization before persisting incompatible capability flags', async () => {
|
||
const source = fs.readFileSync('background/message-router.js', 'utf8');
|
||
const globalScope = { console };
|
||
const api = new Function('self', `${source}; return self.MultiPageBackgroundMessageRouter;`)(globalScope);
|
||
const persistedPayloads = [];
|
||
let state = {
|
||
activeFlowId: 'site-a',
|
||
signupMethod: 'email',
|
||
phoneVerificationEnabled: false,
|
||
plusModeEnabled: false,
|
||
targetId: 'cpa',
|
||
};
|
||
|
||
const router = api.createMessageRouter({
|
||
addLog: async () => {},
|
||
buildLuckmailSessionSettingsPayload: () => ({}),
|
||
buildPersistentSettingsPayload: (input = {}) => ({
|
||
plusModeEnabled: Boolean(input.plusModeEnabled),
|
||
phoneVerificationEnabled: Boolean(input.phoneVerificationEnabled),
|
||
signupMethod: String(input.signupMethod || 'email'),
|
||
}),
|
||
broadcastDataUpdate: () => {},
|
||
getState: async () => ({ ...state }),
|
||
resolveSignupMethod: (nextState = {}) => (
|
||
Boolean(nextState.phoneVerificationEnabled) && Boolean(nextState.plusModeEnabled) ? 'phone' : 'email'
|
||
),
|
||
setPersistentSettings: async (updates) => {
|
||
persistedPayloads.push({ ...updates });
|
||
return { ...updates };
|
||
},
|
||
setState: async (updates) => {
|
||
state = { ...state, ...updates };
|
||
},
|
||
validateModeSwitch: () => ({
|
||
ok: false,
|
||
errors: [{ code: 'plus_mode_unsupported', message: '当前 flow 不支持 Plus 模式。' }],
|
||
normalizedUpdates: {
|
||
plusModeEnabled: false,
|
||
phoneVerificationEnabled: false,
|
||
signupMethod: 'email',
|
||
},
|
||
}),
|
||
});
|
||
|
||
const response = await router.handleMessage({
|
||
type: 'SAVE_SETTING',
|
||
payload: {
|
||
plusModeEnabled: true,
|
||
phoneVerificationEnabled: true,
|
||
signupMethod: 'phone',
|
||
},
|
||
});
|
||
|
||
assert.equal(response.ok, true);
|
||
assert.equal(state.plusModeEnabled, false);
|
||
assert.equal(state.phoneVerificationEnabled, false);
|
||
assert.equal(state.signupMethod, 'email');
|
||
assert.deepEqual(persistedPayloads[0], {
|
||
plusModeEnabled: false,
|
||
phoneVerificationEnabled: false,
|
||
signupMethod: 'email',
|
||
});
|
||
assert.equal(response.modeValidation?.errors?.[0]?.code, 'plus_mode_unsupported');
|
||
});
|