zhangkun
1231 lines
37 KiB
JavaScript
1231 lines
37 KiB
JavaScript
const test = require('node:test');
|
|
const assert = require('node:assert/strict');
|
|
const fs = require('node:fs');
|
|
|
|
const source = fs.readFileSync('background/phone-verification-flow.js', 'utf8');
|
|
const globalScope = {};
|
|
const api = new Function('self', `${source}; return self.MultiPageBackgroundPhoneVerification;`)(globalScope);
|
|
|
|
function buildHeroSmsPricesPayload({ country = '52', service = 'dr', cost = 0.08, count = 25370, physicalCount = 14528 } = {}) {
|
|
return JSON.stringify({
|
|
[country]: {
|
|
[service]: {
|
|
cost,
|
|
count,
|
|
physicalCount,
|
|
},
|
|
},
|
|
});
|
|
}
|
|
|
|
function buildHeroSmsStatusV2Payload({ smsCode = '', smsText = '', callCode = '' } = {}) {
|
|
return JSON.stringify({
|
|
verificationType: 2,
|
|
sms: {
|
|
dateTime: '2026-02-18T16:11:33+00:00',
|
|
code: smsCode,
|
|
text: smsText,
|
|
},
|
|
call: {
|
|
code: callCode,
|
|
},
|
|
});
|
|
}
|
|
|
|
test('phone verification helper requests HeroSMS numbers with manual maxPrice and fixed OpenAI/Thailand parameters', async () => {
|
|
const requests = [];
|
|
const helpers = api.createPhoneVerificationHelpers({
|
|
addLog: async () => {},
|
|
ensureStep8SignupPageReady: async () => {},
|
|
fetchImpl: async (url) => {
|
|
const parsedUrl = new URL(url);
|
|
requests.push(parsedUrl);
|
|
return {
|
|
ok: true,
|
|
text: async () => 'ACCESS_NUMBER:123456:66959916439',
|
|
};
|
|
},
|
|
getState: async () => ({ heroSmsApiKey: 'demo-key', heroSmsMaxPrice: '0.08' }),
|
|
sendToContentScriptResilient: async () => ({}),
|
|
setState: async () => {},
|
|
sleepWithStop: async () => {},
|
|
throwIfStopped: () => {},
|
|
});
|
|
|
|
const activation = await helpers.requestPhoneActivation({
|
|
heroSmsApiKey: 'demo-key',
|
|
heroSmsMaxPrice: '0.08',
|
|
});
|
|
|
|
assert.deepStrictEqual(activation, {
|
|
activationId: '123456',
|
|
phoneNumber: '66959916439',
|
|
provider: 'hero-sms',
|
|
serviceCode: 'dr',
|
|
countryId: 52,
|
|
successfulUses: 0,
|
|
maxUses: 3,
|
|
});
|
|
assert.equal(requests.length, 1);
|
|
assert.equal(requests[0].searchParams.get('action'), 'getNumber');
|
|
assert.equal(requests[0].searchParams.get('service'), 'dr');
|
|
assert.equal(requests[0].searchParams.get('country'), '52');
|
|
assert.equal(requests[0].searchParams.get('api_key'), 'demo-key');
|
|
assert.equal(requests[0].searchParams.get('maxPrice'), '0.08');
|
|
assert.equal(requests[0].searchParams.get('fixedPrice'), 'true');
|
|
});
|
|
|
|
test('phone verification helper requires manual HeroSMS maxPrice', async () => {
|
|
const helpers = api.createPhoneVerificationHelpers({
|
|
addLog: async () => {},
|
|
ensureStep8SignupPageReady: async () => {},
|
|
fetchImpl: async () => {
|
|
throw new Error('should not request HeroSMS without maxPrice');
|
|
},
|
|
getState: async () => ({ heroSmsApiKey: 'demo-key', heroSmsMaxPrice: '' }),
|
|
sendToContentScriptResilient: async () => ({}),
|
|
setState: async () => {},
|
|
sleepWithStop: async () => {},
|
|
throwIfStopped: () => {},
|
|
});
|
|
|
|
await assert.rejects(
|
|
() => helpers.requestPhoneActivation({ heroSmsApiKey: 'demo-key', heroSmsMaxPrice: '' }),
|
|
/HeroSMS maxPrice is missing/i
|
|
);
|
|
});
|
|
|
|
test('phone verification helper still clears existing activation when maxPrice is missing', async () => {
|
|
const requests = [];
|
|
let currentState = {
|
|
heroSmsApiKey: 'demo-key',
|
|
heroSmsMaxPrice: '',
|
|
currentPhoneActivation: {
|
|
activationId: '123456',
|
|
phoneNumber: '66959916439',
|
|
successfulUses: 0,
|
|
maxUses: 3,
|
|
},
|
|
reusablePhoneActivation: null,
|
|
pendingPhoneActivationConfirmation: null,
|
|
};
|
|
const helpers = api.createPhoneVerificationHelpers({
|
|
addLog: async () => {},
|
|
ensureStep8SignupPageReady: async () => {},
|
|
fetchImpl: async (url) => {
|
|
const parsedUrl = new URL(url);
|
|
requests.push(parsedUrl);
|
|
return {
|
|
ok: true,
|
|
text: async () => 'ACCESS_CANCEL',
|
|
};
|
|
},
|
|
getState: async () => currentState,
|
|
sendToContentScriptResilient: async () => ({}),
|
|
setState: async (updates) => {
|
|
currentState = { ...currentState, ...updates };
|
|
},
|
|
sleepWithStop: async () => {},
|
|
throwIfStopped: () => {},
|
|
});
|
|
|
|
await assert.rejects(
|
|
() => helpers.completePhoneVerificationFlow(1, { addPhonePage: true }),
|
|
/HeroSMS maxPrice is missing/i
|
|
);
|
|
|
|
assert.equal(requests.length, 1);
|
|
assert.equal(requests[0].searchParams.get('action'), 'setStatus');
|
|
assert.equal(requests[0].searchParams.get('id'), '123456');
|
|
assert.equal(requests[0].searchParams.get('status'), '8');
|
|
assert.equal(requests[0].searchParams.has('maxPrice'), false);
|
|
assert.equal(currentState.currentPhoneActivation, null);
|
|
});
|
|
|
|
test('phone verification helper retries with HeroSMS getNumberV2 when getNumber reports NO_NUMBERS', async () => {
|
|
const requests = [];
|
|
const helpers = api.createPhoneVerificationHelpers({
|
|
addLog: async () => {},
|
|
ensureStep8SignupPageReady: async () => {},
|
|
fetchImpl: async (url) => {
|
|
const parsedUrl = new URL(url);
|
|
requests.push(parsedUrl);
|
|
const action = parsedUrl.searchParams.get('action');
|
|
if (action === 'getNumber') {
|
|
return {
|
|
ok: true,
|
|
text: async () => 'NO_NUMBERS',
|
|
};
|
|
}
|
|
if (action === 'getNumberV2') {
|
|
return {
|
|
ok: true,
|
|
text: async () => JSON.stringify({
|
|
activationId: '654321',
|
|
phoneNumber: '447911123456',
|
|
}),
|
|
};
|
|
}
|
|
throw new Error(`Unexpected HeroSMS action: ${action}`);
|
|
},
|
|
getState: async () => ({ heroSmsApiKey: 'demo-key', heroSmsMaxPrice: '0.08', heroSmsCountryId: 16 }),
|
|
sendToContentScriptResilient: async () => ({}),
|
|
setState: async () => {},
|
|
sleepWithStop: async () => {},
|
|
throwIfStopped: () => {},
|
|
});
|
|
|
|
const activation = await helpers.requestPhoneActivation({
|
|
heroSmsApiKey: 'demo-key',
|
|
heroSmsMaxPrice: '0.08',
|
|
heroSmsCountryId: 16,
|
|
});
|
|
|
|
assert.deepStrictEqual(activation, {
|
|
activationId: '654321',
|
|
phoneNumber: '447911123456',
|
|
provider: 'hero-sms',
|
|
serviceCode: 'dr',
|
|
countryId: 16,
|
|
successfulUses: 0,
|
|
maxUses: 3,
|
|
statusAction: 'getStatusV2',
|
|
});
|
|
assert.equal(requests.length, 2);
|
|
assert.equal(requests[0].searchParams.get('action'), 'getNumber');
|
|
assert.equal(requests[0].searchParams.get('country'), '16');
|
|
assert.equal(requests[0].searchParams.get('maxPrice'), '0.08');
|
|
assert.equal(requests[0].searchParams.get('fixedPrice'), 'true');
|
|
assert.equal(requests[1].searchParams.get('action'), 'getNumberV2');
|
|
assert.equal(requests[1].searchParams.get('country'), '16');
|
|
assert.equal(requests[1].searchParams.get('maxPrice'), '0.08');
|
|
assert.equal(requests[1].searchParams.get('fixedPrice'), 'true');
|
|
});
|
|
|
|
test('phone verification helper uses HeroSMS getStatusV2 after acquiring a number via getNumberV2', async () => {
|
|
const requests = [];
|
|
const stateUpdates = [];
|
|
let currentState = {
|
|
heroSmsApiKey: 'demo-key',
|
|
heroSmsMaxPrice: '0.08',
|
|
heroSmsCountryId: 16,
|
|
heroSmsCountryLabel: 'United Kingdom',
|
|
verificationResendCount: 0,
|
|
currentPhoneActivation: null,
|
|
reusablePhoneActivation: null,
|
|
};
|
|
let statusPollCount = 0;
|
|
|
|
const helpers = api.createPhoneVerificationHelpers({
|
|
addLog: async () => {},
|
|
ensureStep8SignupPageReady: async () => {},
|
|
fetchImpl: async (url) => {
|
|
const parsedUrl = new URL(url);
|
|
requests.push(parsedUrl);
|
|
const action = parsedUrl.searchParams.get('action');
|
|
if (action === 'getNumber') {
|
|
return {
|
|
ok: true,
|
|
text: async () => 'NO_NUMBERS',
|
|
};
|
|
}
|
|
if (action === 'getNumberV2') {
|
|
return {
|
|
ok: true,
|
|
text: async () => JSON.stringify({
|
|
activationId: '654321',
|
|
phoneNumber: '447911123456',
|
|
}),
|
|
};
|
|
}
|
|
if (action === 'getStatusV2') {
|
|
statusPollCount += 1;
|
|
return {
|
|
ok: true,
|
|
text: async () => (
|
|
statusPollCount === 1
|
|
? buildHeroSmsStatusV2Payload()
|
|
: buildHeroSmsStatusV2Payload({ smsCode: '112233', smsText: 'Your code is 112233' })
|
|
),
|
|
};
|
|
}
|
|
if (action === 'setStatus') {
|
|
return {
|
|
ok: true,
|
|
text: async () => 'ACCESS_ACTIVATION',
|
|
};
|
|
}
|
|
throw new Error(`Unexpected HeroSMS action: ${action}`);
|
|
},
|
|
getOAuthFlowStepTimeoutMs: async (defaultTimeoutMs) => defaultTimeoutMs,
|
|
getState: async () => ({ ...currentState }),
|
|
sendToContentScriptResilient: async (_source, message) => {
|
|
if (message.type === 'SUBMIT_PHONE_NUMBER') {
|
|
return {
|
|
phoneVerificationPage: true,
|
|
url: 'https://auth.openai.com/phone-verification',
|
|
};
|
|
}
|
|
if (message.type === 'SUBMIT_PHONE_VERIFICATION_CODE') {
|
|
return {
|
|
success: true,
|
|
consentReady: true,
|
|
url: 'https://auth.openai.com/authorize',
|
|
};
|
|
}
|
|
throw new Error(`Unexpected content-script message: ${message.type}`);
|
|
},
|
|
setState: async (updates) => {
|
|
stateUpdates.push(updates);
|
|
currentState = { ...currentState, ...updates };
|
|
},
|
|
sleepWithStop: async () => {},
|
|
throwIfStopped: () => {},
|
|
});
|
|
|
|
const result = await helpers.completePhoneVerificationFlow(1, {
|
|
addPhonePage: true,
|
|
phoneVerificationPage: false,
|
|
url: 'https://auth.openai.com/add-phone',
|
|
});
|
|
|
|
assert.deepStrictEqual(result, {
|
|
success: true,
|
|
consentReady: true,
|
|
url: 'https://auth.openai.com/authorize',
|
|
});
|
|
assert.deepStrictEqual(stateUpdates, [
|
|
{
|
|
currentPhoneActivation: {
|
|
activationId: '654321',
|
|
phoneNumber: '447911123456',
|
|
provider: 'hero-sms',
|
|
serviceCode: 'dr',
|
|
countryId: 16,
|
|
successfulUses: 0,
|
|
maxUses: 3,
|
|
statusAction: 'getStatusV2',
|
|
},
|
|
},
|
|
{
|
|
reusablePhoneActivation: {
|
|
activationId: '654321',
|
|
phoneNumber: '447911123456',
|
|
provider: 'hero-sms',
|
|
serviceCode: 'dr',
|
|
countryId: 16,
|
|
successfulUses: 0,
|
|
maxUses: 3,
|
|
statusAction: 'getStatusV2',
|
|
},
|
|
},
|
|
{
|
|
pendingPhoneActivationConfirmation: {
|
|
activationId: '654321',
|
|
phoneNumber: '447911123456',
|
|
provider: 'hero-sms',
|
|
serviceCode: 'dr',
|
|
countryId: 16,
|
|
successfulUses: 0,
|
|
maxUses: 3,
|
|
statusAction: 'getStatusV2',
|
|
},
|
|
},
|
|
{
|
|
currentPhoneActivation: null,
|
|
},
|
|
]);
|
|
const actions = requests.map((url) => url.searchParams.get('action'));
|
|
assert.deepStrictEqual(actions, [
|
|
'getNumber',
|
|
'getNumberV2',
|
|
'getStatusV2',
|
|
'getStatusV2',
|
|
'setStatus',
|
|
]);
|
|
});
|
|
|
|
test('phone verification helper keeps the user-provided maxPrice and surfaces HeroSMS price errors', async () => {
|
|
const helpers = api.createPhoneVerificationHelpers({
|
|
addLog: async () => {},
|
|
ensureStep8SignupPageReady: async () => {},
|
|
fetchImpl: async (url) => {
|
|
const parsedUrl = new URL(url);
|
|
const action = parsedUrl.searchParams.get('action');
|
|
if (action === 'getNumber') {
|
|
return {
|
|
ok: false,
|
|
text: async () => 'WRONG_MAX_PRICE:0.09',
|
|
};
|
|
}
|
|
throw new Error(`Unexpected HeroSMS action: ${action}`);
|
|
},
|
|
getState: async () => ({ heroSmsApiKey: 'demo-key', heroSmsMaxPrice: '0.08' }),
|
|
sendToContentScriptResilient: async () => ({}),
|
|
setState: async () => {},
|
|
sleepWithStop: async () => {},
|
|
throwIfStopped: () => {},
|
|
});
|
|
|
|
await assert.rejects(
|
|
() => helpers.requestPhoneActivation({ heroSmsApiKey: 'demo-key', heroSmsMaxPrice: '0.08' }),
|
|
/WRONG_MAX_PRICE:0.09/
|
|
);
|
|
});
|
|
|
|
test('phone verification helper completes add-phone flow, clears current activation, and stores reusable number state', async () => {
|
|
const requests = [];
|
|
const stateUpdates = [];
|
|
let currentState = {
|
|
heroSmsApiKey: 'demo-key',
|
|
heroSmsMaxPrice: '0.08',
|
|
verificationResendCount: 1,
|
|
currentPhoneActivation: null,
|
|
reusablePhoneActivation: null,
|
|
};
|
|
|
|
const helpers = api.createPhoneVerificationHelpers({
|
|
addLog: async () => {},
|
|
ensureStep8SignupPageReady: async () => {},
|
|
fetchImpl: async (url) => {
|
|
const parsedUrl = new URL(url);
|
|
requests.push(parsedUrl);
|
|
const action = parsedUrl.searchParams.get('action');
|
|
if (action === 'getNumber') {
|
|
return {
|
|
ok: true,
|
|
text: async () => 'ACCESS_NUMBER:123456:66959916439',
|
|
};
|
|
}
|
|
if (action === 'getStatus') {
|
|
return {
|
|
ok: true,
|
|
text: async () => 'STATUS_OK:654321',
|
|
};
|
|
}
|
|
if (action === 'setStatus') {
|
|
return {
|
|
ok: true,
|
|
text: async () => 'ACCESS_ACTIVATION',
|
|
};
|
|
}
|
|
throw new Error(`Unexpected HeroSMS action: ${action}`);
|
|
},
|
|
getOAuthFlowStepTimeoutMs: async (defaultTimeoutMs) => defaultTimeoutMs,
|
|
getState: async () => ({ ...currentState }),
|
|
sendToContentScriptResilient: async (_source, message) => {
|
|
if (message.type === 'SUBMIT_PHONE_NUMBER') {
|
|
return {
|
|
phoneVerificationPage: true,
|
|
url: 'https://auth.openai.com/phone-verification',
|
|
};
|
|
}
|
|
if (message.type === 'SUBMIT_PHONE_VERIFICATION_CODE') {
|
|
return {
|
|
success: true,
|
|
consentReady: true,
|
|
url: 'https://auth.openai.com/authorize',
|
|
};
|
|
}
|
|
throw new Error(`Unexpected content-script message: ${message.type}`);
|
|
},
|
|
setState: async (updates) => {
|
|
stateUpdates.push(updates);
|
|
currentState = { ...currentState, ...updates };
|
|
},
|
|
sleepWithStop: async () => {},
|
|
throwIfStopped: () => {},
|
|
});
|
|
|
|
const result = await helpers.completePhoneVerificationFlow(1, {
|
|
addPhonePage: true,
|
|
phoneVerificationPage: false,
|
|
url: 'https://auth.openai.com/add-phone',
|
|
});
|
|
|
|
assert.deepStrictEqual(result, {
|
|
success: true,
|
|
consentReady: true,
|
|
url: 'https://auth.openai.com/authorize',
|
|
});
|
|
assert.deepStrictEqual(stateUpdates, [
|
|
{
|
|
currentPhoneActivation: {
|
|
activationId: '123456',
|
|
phoneNumber: '66959916439',
|
|
provider: 'hero-sms',
|
|
serviceCode: 'dr',
|
|
countryId: 52,
|
|
successfulUses: 0,
|
|
maxUses: 3,
|
|
},
|
|
},
|
|
{
|
|
reusablePhoneActivation: {
|
|
activationId: '123456',
|
|
phoneNumber: '66959916439',
|
|
provider: 'hero-sms',
|
|
serviceCode: 'dr',
|
|
countryId: 52,
|
|
successfulUses: 0,
|
|
maxUses: 3,
|
|
},
|
|
},
|
|
{
|
|
pendingPhoneActivationConfirmation: {
|
|
activationId: '123456',
|
|
phoneNumber: '66959916439',
|
|
provider: 'hero-sms',
|
|
serviceCode: 'dr',
|
|
countryId: 52,
|
|
successfulUses: 0,
|
|
maxUses: 3,
|
|
},
|
|
},
|
|
{
|
|
currentPhoneActivation: null,
|
|
},
|
|
]);
|
|
|
|
const actions = requests.map((url) => url.searchParams.get('action'));
|
|
assert.deepStrictEqual(actions, ['getNumber', 'getStatus', 'setStatus']);
|
|
});
|
|
|
|
test('phone verification helper still succeeds when HeroSMS setStatus(3) fails after a successful submit', async () => {
|
|
const requests = [];
|
|
let currentState = {
|
|
heroSmsApiKey: 'demo-key',
|
|
heroSmsMaxPrice: '0.08',
|
|
verificationResendCount: 1,
|
|
currentPhoneActivation: null,
|
|
reusablePhoneActivation: null,
|
|
};
|
|
|
|
const helpers = api.createPhoneVerificationHelpers({
|
|
addLog: async () => {},
|
|
ensureStep8SignupPageReady: async () => {},
|
|
fetchImpl: async (url) => {
|
|
const parsedUrl = new URL(url);
|
|
requests.push(parsedUrl);
|
|
const action = parsedUrl.searchParams.get('action');
|
|
if (action === 'getNumber') {
|
|
return {
|
|
ok: true,
|
|
text: async () => 'ACCESS_NUMBER:123456:66959916439',
|
|
};
|
|
}
|
|
if (action === 'getStatus') {
|
|
return {
|
|
ok: true,
|
|
text: async () => 'STATUS_OK:654321',
|
|
};
|
|
}
|
|
if (action === 'setStatus') {
|
|
return {
|
|
ok: false,
|
|
text: async () => 'TEMPORARY_ERROR',
|
|
};
|
|
}
|
|
throw new Error(`Unexpected HeroSMS action: ${action}`);
|
|
},
|
|
getOAuthFlowStepTimeoutMs: async (defaultTimeoutMs) => defaultTimeoutMs,
|
|
getState: async () => ({ ...currentState }),
|
|
sendToContentScriptResilient: async (_source, message) => {
|
|
if (message.type === 'SUBMIT_PHONE_NUMBER') {
|
|
return {
|
|
phoneVerificationPage: true,
|
|
url: 'https://auth.openai.com/phone-verification',
|
|
};
|
|
}
|
|
if (message.type === 'SUBMIT_PHONE_VERIFICATION_CODE') {
|
|
return {
|
|
success: true,
|
|
consentReady: true,
|
|
url: 'https://auth.openai.com/authorize',
|
|
};
|
|
}
|
|
throw new Error(`Unexpected content-script message: ${message.type}`);
|
|
},
|
|
setState: async (updates) => {
|
|
currentState = { ...currentState, ...updates };
|
|
},
|
|
sleepWithStop: async () => {},
|
|
throwIfStopped: () => {},
|
|
});
|
|
|
|
const result = await helpers.completePhoneVerificationFlow(1, {
|
|
addPhonePage: true,
|
|
phoneVerificationPage: false,
|
|
url: 'https://auth.openai.com/add-phone',
|
|
});
|
|
|
|
assert.deepStrictEqual(result, {
|
|
success: true,
|
|
consentReady: true,
|
|
url: 'https://auth.openai.com/authorize',
|
|
});
|
|
assert.deepStrictEqual(currentState.currentPhoneActivation, null);
|
|
assert.deepStrictEqual(currentState.reusablePhoneActivation, null);
|
|
assert.deepStrictEqual(currentState.pendingPhoneActivationConfirmation, null);
|
|
const actions = requests.map((url) => url.searchParams.get('action'));
|
|
assert.deepStrictEqual(actions, ['getNumber', 'getStatus', 'setStatus']);
|
|
});
|
|
|
|
test('phone verification helper uses the configured HeroSMS country for both number acquisition and add-phone submission', async () => {
|
|
const requests = [];
|
|
const submittedPayloads = [];
|
|
let currentState = {
|
|
heroSmsApiKey: 'demo-key',
|
|
heroSmsMaxPrice: '0.08',
|
|
heroSmsCountryId: 16,
|
|
heroSmsCountryLabel: 'United Kingdom',
|
|
verificationResendCount: 0,
|
|
currentPhoneActivation: null,
|
|
reusablePhoneActivation: null,
|
|
};
|
|
|
|
const helpers = api.createPhoneVerificationHelpers({
|
|
addLog: async () => {},
|
|
ensureStep8SignupPageReady: async () => {},
|
|
fetchImpl: async (url) => {
|
|
const parsedUrl = new URL(url);
|
|
requests.push(parsedUrl);
|
|
const action = parsedUrl.searchParams.get('action');
|
|
if (action === 'getNumber') {
|
|
return {
|
|
ok: true,
|
|
text: async () => 'ACCESS_NUMBER:654321:447911123456',
|
|
};
|
|
}
|
|
if (action === 'getStatus') {
|
|
return {
|
|
ok: true,
|
|
text: async () => 'STATUS_OK:112233',
|
|
};
|
|
}
|
|
if (action === 'setStatus') {
|
|
return {
|
|
ok: true,
|
|
text: async () => 'ACCESS_ACTIVATION',
|
|
};
|
|
}
|
|
throw new Error(`Unexpected HeroSMS action: ${action}`);
|
|
},
|
|
getOAuthFlowStepTimeoutMs: async (defaultTimeoutMs) => defaultTimeoutMs,
|
|
getState: async () => ({ ...currentState }),
|
|
sendToContentScriptResilient: async (_source, message) => {
|
|
if (message.type === 'SUBMIT_PHONE_NUMBER') {
|
|
submittedPayloads.push(message.payload);
|
|
return {
|
|
phoneVerificationPage: true,
|
|
url: 'https://auth.openai.com/phone-verification',
|
|
};
|
|
}
|
|
if (message.type === 'SUBMIT_PHONE_VERIFICATION_CODE') {
|
|
return {
|
|
success: true,
|
|
consentReady: true,
|
|
url: 'https://auth.openai.com/authorize',
|
|
};
|
|
}
|
|
throw new Error(`Unexpected content-script message: ${message.type}`);
|
|
},
|
|
setState: async (updates) => {
|
|
currentState = { ...currentState, ...updates };
|
|
},
|
|
sleepWithStop: async () => {},
|
|
throwIfStopped: () => {},
|
|
});
|
|
|
|
const result = await helpers.completePhoneVerificationFlow(1, {
|
|
addPhonePage: true,
|
|
phoneVerificationPage: false,
|
|
url: 'https://auth.openai.com/add-phone',
|
|
});
|
|
|
|
assert.deepStrictEqual(result, {
|
|
success: true,
|
|
consentReady: true,
|
|
url: 'https://auth.openai.com/authorize',
|
|
});
|
|
assert.equal(requests[0].searchParams.get('action'), 'getNumber');
|
|
assert.equal(requests[0].searchParams.get('country'), '16');
|
|
assert.equal(requests[0].searchParams.get('maxPrice'), '0.08');
|
|
assert.equal(requests[0].searchParams.get('fixedPrice'), 'true');
|
|
assert.deepStrictEqual(submittedPayloads, [{
|
|
phoneNumber: '447911123456',
|
|
countryId: 16,
|
|
countryLabel: 'United Kingdom',
|
|
}]);
|
|
});
|
|
|
|
test('phone verification helper throws a step-7 restart error after 60 seconds plus one resend window without SMS', async () => {
|
|
const requests = [];
|
|
const messages = [];
|
|
const stateUpdates = [];
|
|
let currentState = {
|
|
heroSmsApiKey: 'demo-key',
|
|
heroSmsMaxPrice: '0.08',
|
|
verificationResendCount: 0,
|
|
currentPhoneActivation: null,
|
|
reusablePhoneActivation: null,
|
|
};
|
|
const statusCallsById = {};
|
|
const realDateNow = Date.now;
|
|
let fakeNow = 0;
|
|
Date.now = () => fakeNow;
|
|
|
|
try {
|
|
const helpers = api.createPhoneVerificationHelpers({
|
|
addLog: async () => {},
|
|
ensureStep8SignupPageReady: async () => {},
|
|
fetchImpl: async (url) => {
|
|
const parsedUrl = new URL(url);
|
|
requests.push(parsedUrl);
|
|
const action = parsedUrl.searchParams.get('action');
|
|
const id = parsedUrl.searchParams.get('id');
|
|
|
|
if (action === 'getNumber') {
|
|
return {
|
|
ok: true,
|
|
text: async () => 'ACCESS_NUMBER:123456:66959916439',
|
|
};
|
|
}
|
|
|
|
if (action === 'getStatus') {
|
|
statusCallsById[id] = (statusCallsById[id] || 0) + 1;
|
|
return {
|
|
ok: true,
|
|
text: async () => 'STATUS_WAIT_CODE',
|
|
};
|
|
}
|
|
|
|
if (action === 'setStatus') {
|
|
return {
|
|
ok: true,
|
|
text: async () => 'ACCESS_ACTIVATION',
|
|
};
|
|
}
|
|
|
|
throw new Error(`Unexpected HeroSMS action: ${action}`);
|
|
},
|
|
getOAuthFlowStepTimeoutMs: async (defaultTimeoutMs) => defaultTimeoutMs,
|
|
getState: async () => ({ ...currentState }),
|
|
sendToContentScriptResilient: async (_source, message) => {
|
|
messages.push(message.type);
|
|
if (message.type === 'SUBMIT_PHONE_NUMBER') {
|
|
return {
|
|
phoneVerificationPage: true,
|
|
url: 'https://auth.openai.com/phone-verification',
|
|
};
|
|
}
|
|
if (message.type === 'RESEND_PHONE_VERIFICATION_CODE') {
|
|
return {
|
|
resent: true,
|
|
url: 'https://auth.openai.com/phone-verification',
|
|
};
|
|
}
|
|
throw new Error(`Unexpected content-script message: ${message.type}`);
|
|
},
|
|
setState: async (updates) => {
|
|
stateUpdates.push(updates);
|
|
currentState = { ...currentState, ...updates };
|
|
},
|
|
sleepWithStop: async () => {
|
|
fakeNow += 61000;
|
|
},
|
|
throwIfStopped: () => {},
|
|
});
|
|
|
|
await assert.rejects(
|
|
helpers.completePhoneVerificationFlow(1, {
|
|
addPhonePage: true,
|
|
phoneVerificationPage: false,
|
|
url: 'https://auth.openai.com/add-phone',
|
|
}),
|
|
/Restart step 7 with a new number/i
|
|
);
|
|
assert.ok(statusCallsById['123456'] >= 2, 'first number should be polled twice before being replaced');
|
|
assert.deepStrictEqual(messages, [
|
|
'SUBMIT_PHONE_NUMBER',
|
|
'RESEND_PHONE_VERIFICATION_CODE',
|
|
]);
|
|
|
|
const actions = requests.map((url) => `${url.searchParams.get('action')}:${url.searchParams.get('id') || ''}`);
|
|
assert.deepStrictEqual(actions, [
|
|
'getNumber:',
|
|
'getStatus:123456',
|
|
'setStatus:123456',
|
|
'getStatus:123456',
|
|
'setStatus:123456',
|
|
]);
|
|
assert.equal(currentState.currentPhoneActivation, null);
|
|
assert.equal(
|
|
stateUpdates.some((updates) => Number(updates.currentPhoneActivation?.successfulUses) > 0),
|
|
false,
|
|
'60 seconds without SMS should not increment reuse count'
|
|
);
|
|
} finally {
|
|
Date.now = realDateNow;
|
|
}
|
|
});
|
|
|
|
test('phone verification helper replaces the number when code submission returns to add-phone', async () => {
|
|
const requests = [];
|
|
const messages = [];
|
|
let currentState = {
|
|
heroSmsApiKey: 'demo-key',
|
|
heroSmsMaxPrice: '0.08',
|
|
verificationResendCount: 1,
|
|
currentPhoneActivation: null,
|
|
reusablePhoneActivation: null,
|
|
};
|
|
|
|
const numbers = [
|
|
{ activationId: '111111', phoneNumber: '66950000001' },
|
|
{ activationId: '222222', phoneNumber: '66950000002' },
|
|
];
|
|
let numberIndex = 0;
|
|
let submitCodeCount = 0;
|
|
|
|
const helpers = api.createPhoneVerificationHelpers({
|
|
addLog: async () => {},
|
|
ensureStep8SignupPageReady: async () => {},
|
|
fetchImpl: async (url) => {
|
|
const parsedUrl = new URL(url);
|
|
requests.push(parsedUrl);
|
|
const action = parsedUrl.searchParams.get('action');
|
|
const id = parsedUrl.searchParams.get('id');
|
|
|
|
if (action === 'getNumber') {
|
|
const nextNumber = numbers[numberIndex];
|
|
numberIndex += 1;
|
|
return {
|
|
ok: true,
|
|
text: async () => `ACCESS_NUMBER:${nextNumber.activationId}:${nextNumber.phoneNumber}`,
|
|
};
|
|
}
|
|
if (action === 'getStatus') {
|
|
return {
|
|
ok: true,
|
|
text: async () => 'STATUS_OK:654321',
|
|
};
|
|
}
|
|
if (action === 'setStatus') {
|
|
return {
|
|
ok: true,
|
|
text: async () => `STATUS_UPDATED:${id}`,
|
|
};
|
|
}
|
|
throw new Error(`Unexpected HeroSMS action: ${action}`);
|
|
},
|
|
getOAuthFlowStepTimeoutMs: async (defaultTimeoutMs) => defaultTimeoutMs,
|
|
getState: async () => ({ ...currentState }),
|
|
sendToContentScriptResilient: async (_source, message) => {
|
|
messages.push(message.type);
|
|
if (message.type === 'SUBMIT_PHONE_NUMBER') {
|
|
return {
|
|
phoneVerificationPage: true,
|
|
url: 'https://auth.openai.com/phone-verification',
|
|
};
|
|
}
|
|
if (message.type === 'SUBMIT_PHONE_VERIFICATION_CODE') {
|
|
submitCodeCount += 1;
|
|
return submitCodeCount === 1
|
|
? {
|
|
returnedToAddPhone: true,
|
|
url: 'https://auth.openai.com/add-phone',
|
|
}
|
|
: {
|
|
success: true,
|
|
consentReady: true,
|
|
url: 'https://auth.openai.com/authorize',
|
|
};
|
|
}
|
|
if (message.type === 'RESEND_PHONE_VERIFICATION_CODE') {
|
|
return {
|
|
resent: true,
|
|
url: 'https://auth.openai.com/phone-verification',
|
|
};
|
|
}
|
|
throw new Error(`Unexpected content-script message: ${message.type}`);
|
|
},
|
|
setState: async (updates) => {
|
|
currentState = { ...currentState, ...updates };
|
|
},
|
|
sleepWithStop: async () => {},
|
|
throwIfStopped: () => {},
|
|
});
|
|
|
|
const result = await helpers.completePhoneVerificationFlow(1, {
|
|
addPhonePage: true,
|
|
phoneVerificationPage: false,
|
|
url: 'https://auth.openai.com/add-phone',
|
|
});
|
|
|
|
assert.deepStrictEqual(result, {
|
|
success: true,
|
|
consentReady: true,
|
|
url: 'https://auth.openai.com/authorize',
|
|
});
|
|
assert.deepStrictEqual(messages, [
|
|
'SUBMIT_PHONE_NUMBER',
|
|
'SUBMIT_PHONE_VERIFICATION_CODE',
|
|
'SUBMIT_PHONE_NUMBER',
|
|
'SUBMIT_PHONE_VERIFICATION_CODE',
|
|
]);
|
|
|
|
const actions = requests.map((url) => `${url.searchParams.get('action')}:${url.searchParams.get('id') || ''}`);
|
|
assert.deepStrictEqual(actions, [
|
|
'getNumber:',
|
|
'getStatus:111111',
|
|
'setStatus:111111',
|
|
'getNumber:',
|
|
'getStatus:222222',
|
|
'setStatus:222222',
|
|
]);
|
|
assert.deepStrictEqual(currentState.currentPhoneActivation, null);
|
|
assert.deepStrictEqual(currentState.reusablePhoneActivation, {
|
|
activationId: '222222',
|
|
phoneNumber: '66950000002',
|
|
provider: 'hero-sms',
|
|
serviceCode: 'dr',
|
|
countryId: 52,
|
|
successfulUses: 0,
|
|
maxUses: 3,
|
|
});
|
|
assert.deepStrictEqual(currentState.pendingPhoneActivationConfirmation, {
|
|
activationId: '222222',
|
|
phoneNumber: '66950000002',
|
|
provider: 'hero-sms',
|
|
serviceCode: 'dr',
|
|
countryId: 52,
|
|
successfulUses: 0,
|
|
maxUses: 3,
|
|
});
|
|
});
|
|
|
|
test('phone verification helper defers maxUses accounting for reused activations until the full flow succeeds', async () => {
|
|
const requests = [];
|
|
let currentState = {
|
|
heroSmsApiKey: 'demo-key',
|
|
heroSmsMaxPrice: '0.08',
|
|
verificationResendCount: 0,
|
|
currentPhoneActivation: null,
|
|
reusablePhoneActivation: {
|
|
activationId: '123456',
|
|
phoneNumber: '66959916439',
|
|
provider: 'hero-sms',
|
|
serviceCode: 'dr',
|
|
countryId: 52,
|
|
successfulUses: 2,
|
|
maxUses: 3,
|
|
},
|
|
};
|
|
|
|
const helpers = api.createPhoneVerificationHelpers({
|
|
addLog: async () => {},
|
|
ensureStep8SignupPageReady: async () => {},
|
|
fetchImpl: async (url) => {
|
|
const parsedUrl = new URL(url);
|
|
requests.push(parsedUrl);
|
|
const action = parsedUrl.searchParams.get('action');
|
|
if (action === 'reactivate') {
|
|
return {
|
|
ok: true,
|
|
text: async () => JSON.stringify({
|
|
activationId: '222333',
|
|
phoneNumber: '66959916439',
|
|
}),
|
|
};
|
|
}
|
|
if (action === 'getStatus') {
|
|
return {
|
|
ok: true,
|
|
text: async () => 'STATUS_OK:654321',
|
|
};
|
|
}
|
|
if (action === 'setStatus') {
|
|
return {
|
|
ok: true,
|
|
text: async () => 'ACCESS_ACTIVATION',
|
|
};
|
|
}
|
|
throw new Error(`Unexpected HeroSMS action: ${action}`);
|
|
},
|
|
getOAuthFlowStepTimeoutMs: async (defaultTimeoutMs) => defaultTimeoutMs,
|
|
getState: async () => ({ ...currentState }),
|
|
sendToContentScriptResilient: async (_source, message) => {
|
|
if (message.type === 'SUBMIT_PHONE_NUMBER') {
|
|
return {
|
|
phoneVerificationPage: true,
|
|
url: 'https://auth.openai.com/phone-verification',
|
|
};
|
|
}
|
|
if (message.type === 'SUBMIT_PHONE_VERIFICATION_CODE') {
|
|
return {
|
|
success: true,
|
|
consentReady: true,
|
|
url: 'https://auth.openai.com/authorize',
|
|
};
|
|
}
|
|
throw new Error(`Unexpected content-script message: ${message.type}`);
|
|
},
|
|
setState: async (updates) => {
|
|
currentState = { ...currentState, ...updates };
|
|
},
|
|
sleepWithStop: async () => {},
|
|
throwIfStopped: () => {},
|
|
});
|
|
|
|
const result = await helpers.completePhoneVerificationFlow(1, {
|
|
addPhonePage: true,
|
|
phoneVerificationPage: false,
|
|
url: 'https://auth.openai.com/add-phone',
|
|
});
|
|
|
|
assert.deepStrictEqual(result, {
|
|
success: true,
|
|
consentReady: true,
|
|
url: 'https://auth.openai.com/authorize',
|
|
});
|
|
assert.equal(requests[0].searchParams.get('action'), 'reactivate');
|
|
assert.equal(requests[0].searchParams.get('id'), '123456');
|
|
assert.deepStrictEqual(currentState.reusablePhoneActivation, {
|
|
activationId: '222333',
|
|
phoneNumber: '66959916439',
|
|
provider: 'hero-sms',
|
|
serviceCode: 'dr',
|
|
countryId: 52,
|
|
successfulUses: 2,
|
|
maxUses: 3,
|
|
});
|
|
assert.deepStrictEqual(currentState.pendingPhoneActivationConfirmation, {
|
|
activationId: '222333',
|
|
phoneNumber: '66959916439',
|
|
provider: 'hero-sms',
|
|
serviceCode: 'dr',
|
|
countryId: 52,
|
|
successfulUses: 2,
|
|
maxUses: 3,
|
|
});
|
|
});
|
|
|
|
test('phone verification helper defers maxUses accounting for reused V2 activations until the full flow succeeds', async () => {
|
|
const requests = [];
|
|
let currentState = {
|
|
heroSmsApiKey: 'demo-key',
|
|
heroSmsMaxPrice: '0.08',
|
|
heroSmsCountryId: 16,
|
|
heroSmsCountryLabel: 'United Kingdom',
|
|
verificationResendCount: 0,
|
|
currentPhoneActivation: null,
|
|
reusablePhoneActivation: {
|
|
activationId: '123456',
|
|
phoneNumber: '447911123456',
|
|
provider: 'hero-sms',
|
|
serviceCode: 'dr',
|
|
countryId: 16,
|
|
successfulUses: 2,
|
|
maxUses: 3,
|
|
statusAction: 'getStatusV2',
|
|
},
|
|
};
|
|
|
|
const helpers = api.createPhoneVerificationHelpers({
|
|
addLog: async () => {},
|
|
ensureStep8SignupPageReady: async () => {},
|
|
fetchImpl: async (url) => {
|
|
const parsedUrl = new URL(url);
|
|
requests.push(parsedUrl);
|
|
const action = parsedUrl.searchParams.get('action');
|
|
if (action === 'reactivate') {
|
|
return {
|
|
ok: true,
|
|
text: async () => JSON.stringify({
|
|
activationId: '222333',
|
|
phoneNumber: '447911123456',
|
|
}),
|
|
};
|
|
}
|
|
if (action === 'getStatusV2') {
|
|
return {
|
|
ok: true,
|
|
text: async () => buildHeroSmsStatusV2Payload({ smsCode: '654321', smsText: 'Your code is 654321' }),
|
|
};
|
|
}
|
|
if (action === 'setStatus') {
|
|
return {
|
|
ok: true,
|
|
text: async () => 'ACCESS_ACTIVATION',
|
|
};
|
|
}
|
|
throw new Error(`Unexpected HeroSMS action: ${action}`);
|
|
},
|
|
getOAuthFlowStepTimeoutMs: async (defaultTimeoutMs) => defaultTimeoutMs,
|
|
getState: async () => ({ ...currentState }),
|
|
sendToContentScriptResilient: async (_source, message) => {
|
|
if (message.type === 'SUBMIT_PHONE_NUMBER') {
|
|
return {
|
|
phoneVerificationPage: true,
|
|
url: 'https://auth.openai.com/phone-verification',
|
|
};
|
|
}
|
|
if (message.type === 'SUBMIT_PHONE_VERIFICATION_CODE') {
|
|
return {
|
|
success: true,
|
|
consentReady: true,
|
|
url: 'https://auth.openai.com/authorize',
|
|
};
|
|
}
|
|
throw new Error(`Unexpected content-script message: ${message.type}`);
|
|
},
|
|
setState: async (updates) => {
|
|
currentState = { ...currentState, ...updates };
|
|
},
|
|
sleepWithStop: async () => {},
|
|
throwIfStopped: () => {},
|
|
});
|
|
|
|
const result = await helpers.completePhoneVerificationFlow(1, {
|
|
addPhonePage: true,
|
|
phoneVerificationPage: false,
|
|
url: 'https://auth.openai.com/add-phone',
|
|
});
|
|
|
|
assert.deepStrictEqual(result, {
|
|
success: true,
|
|
consentReady: true,
|
|
url: 'https://auth.openai.com/authorize',
|
|
});
|
|
const actions = requests.map((url) => url.searchParams.get('action'));
|
|
assert.deepStrictEqual(actions, ['reactivate', 'getStatusV2', 'setStatus']);
|
|
assert.deepStrictEqual(currentState.reusablePhoneActivation, {
|
|
activationId: '222333',
|
|
phoneNumber: '447911123456',
|
|
provider: 'hero-sms',
|
|
serviceCode: 'dr',
|
|
countryId: 16,
|
|
successfulUses: 2,
|
|
maxUses: 3,
|
|
statusAction: 'getStatusV2',
|
|
});
|
|
assert.deepStrictEqual(currentState.pendingPhoneActivationConfirmation, {
|
|
activationId: '222333',
|
|
phoneNumber: '447911123456',
|
|
provider: 'hero-sms',
|
|
serviceCode: 'dr',
|
|
countryId: 16,
|
|
successfulUses: 2,
|
|
maxUses: 3,
|
|
statusAction: 'getStatusV2',
|
|
});
|
|
});
|
|
|
|
test('phone verification helper finalizes pending phone activation confirmation after the full flow succeeds', async () => {
|
|
let currentState = {
|
|
reusablePhoneActivation: {
|
|
activationId: '123456',
|
|
phoneNumber: '66959916439',
|
|
provider: 'hero-sms',
|
|
serviceCode: 'dr',
|
|
countryId: 52,
|
|
successfulUses: 0,
|
|
maxUses: 3,
|
|
},
|
|
pendingPhoneActivationConfirmation: {
|
|
activationId: '123456',
|
|
phoneNumber: '66959916439',
|
|
provider: 'hero-sms',
|
|
serviceCode: 'dr',
|
|
countryId: 52,
|
|
successfulUses: 0,
|
|
maxUses: 3,
|
|
},
|
|
};
|
|
|
|
const helpers = api.createPhoneVerificationHelpers({
|
|
addLog: async () => {},
|
|
getState: async () => ({ ...currentState }),
|
|
sendToContentScriptResilient: async () => ({}),
|
|
setState: async (updates) => {
|
|
currentState = { ...currentState, ...updates };
|
|
},
|
|
sleepWithStop: async () => {},
|
|
throwIfStopped: () => {},
|
|
});
|
|
|
|
const committedActivation = await helpers.finalizePendingPhoneActivationConfirmation();
|
|
|
|
assert.deepStrictEqual(committedActivation, {
|
|
activationId: '123456',
|
|
phoneNumber: '66959916439',
|
|
provider: 'hero-sms',
|
|
serviceCode: 'dr',
|
|
countryId: 52,
|
|
successfulUses: 1,
|
|
maxUses: 3,
|
|
});
|
|
assert.deepStrictEqual(currentState.reusablePhoneActivation, {
|
|
activationId: '123456',
|
|
phoneNumber: '66959916439',
|
|
provider: 'hero-sms',
|
|
serviceCode: 'dr',
|
|
countryId: 52,
|
|
successfulUses: 1,
|
|
maxUses: 3,
|
|
});
|
|
assert.equal(currentState.pendingPhoneActivationConfirmation, null);
|
|
});
|
|
|
|
test('phone verification helper clears reusable activation when final success exhausts maxUses', async () => {
|
|
let currentState = {
|
|
reusablePhoneActivation: {
|
|
activationId: '222333',
|
|
phoneNumber: '447911123456',
|
|
provider: 'hero-sms',
|
|
serviceCode: 'dr',
|
|
countryId: 16,
|
|
successfulUses: 2,
|
|
maxUses: 3,
|
|
statusAction: 'getStatusV2',
|
|
},
|
|
pendingPhoneActivationConfirmation: {
|
|
activationId: '222333',
|
|
phoneNumber: '447911123456',
|
|
provider: 'hero-sms',
|
|
serviceCode: 'dr',
|
|
countryId: 16,
|
|
successfulUses: 2,
|
|
maxUses: 3,
|
|
statusAction: 'getStatusV2',
|
|
},
|
|
};
|
|
|
|
const helpers = api.createPhoneVerificationHelpers({
|
|
addLog: async () => {},
|
|
getState: async () => ({ ...currentState }),
|
|
sendToContentScriptResilient: async () => ({}),
|
|
setState: async (updates) => {
|
|
currentState = { ...currentState, ...updates };
|
|
},
|
|
sleepWithStop: async () => {},
|
|
throwIfStopped: () => {},
|
|
});
|
|
|
|
const committedActivation = await helpers.finalizePendingPhoneActivationConfirmation();
|
|
|
|
assert.deepStrictEqual(committedActivation, {
|
|
activationId: '222333',
|
|
phoneNumber: '447911123456',
|
|
provider: 'hero-sms',
|
|
serviceCode: 'dr',
|
|
countryId: 16,
|
|
successfulUses: 3,
|
|
maxUses: 3,
|
|
statusAction: 'getStatusV2',
|
|
});
|
|
assert.equal(currentState.reusablePhoneActivation, null);
|
|
assert.equal(currentState.pendingPhoneActivationConfirmation, null);
|
|
});
|