334 lines
14 KiB
TypeScript
334 lines
14 KiB
TypeScript
import {
|
|
applyGooglePlayPurchase,
|
|
GOOGLE_PLAY_ACKNOWLEDGED_STATE,
|
|
type GooglePlayPurchaseApi,
|
|
type GooglePlayPurchaseStore,
|
|
type StoredGooglePlayPurchase,
|
|
type VerifiedGooglePlayPurchaseRecord,
|
|
} from './google-play-apply.ts'
|
|
import { GooglePlayVerificationError, sha256Hex, type NormalizedGooglePlayPurchase } from './google-play.ts'
|
|
import {
|
|
classifyGooglePlayPersistenceError,
|
|
createSupabaseGooglePlayPurchaseStore,
|
|
GooglePlayPurchasePersistenceError,
|
|
} from './google-play-purchase-store.ts'
|
|
|
|
function assert(condition: boolean, message: string): asserts condition {
|
|
if (!condition) throw new Error(message)
|
|
}
|
|
|
|
const USER_ID = '11111111-2222-3333-4444-555555555555'
|
|
const PRODUCT_ID = 'd3ro_voice_pro_monthly'
|
|
const TOKEN = 'purchase-token-0001'
|
|
const PENDING_ACK = 'ACKNOWLEDGEMENT_STATE_PENDING'
|
|
|
|
function purchase(overrides: Partial<NormalizedGooglePlayPurchase> = {}): NormalizedGooglePlayPurchase {
|
|
return {
|
|
platform: 'google_play',
|
|
productId: PRODUCT_ID,
|
|
tier: 'pro',
|
|
storeTransactionId: 'GPA.1234-5678-9012-34567',
|
|
purchaseState: 'purchased',
|
|
purchaseAt: '2029-12-01T00:00:00Z',
|
|
expiresAt: '2030-01-01T00:00:00Z',
|
|
autoRenewing: true,
|
|
acknowledged: false,
|
|
entitled: true,
|
|
verification: {
|
|
subscriptionState: 'SUBSCRIPTION_STATE_ACTIVE',
|
|
acknowledgementState: PENDING_ACK,
|
|
lineItems: [{ productId: PRODUCT_ID, expiryTime: '2030-01-01T00:00:00Z' }],
|
|
},
|
|
linkedPurchaseToken: null,
|
|
...overrides,
|
|
}
|
|
}
|
|
|
|
class FakePlayApi implements GooglePlayPurchaseApi {
|
|
verifyCalls = 0
|
|
acknowledged: Array<{ productId: string; purchaseToken: string }> = []
|
|
failAcknowledge = false
|
|
ownsLookup: ((token: string) => Promise<boolean>) | null = null
|
|
constructor(private readonly log: string[], private readonly result: NormalizedGooglePlayPurchase) {}
|
|
verify(
|
|
_userId: string,
|
|
_productId: string,
|
|
_purchaseToken: string,
|
|
ownsExpiredPurchaseToken: (token: string) => Promise<boolean>,
|
|
): Promise<NormalizedGooglePlayPurchase> {
|
|
this.verifyCalls += 1
|
|
this.ownsLookup = ownsExpiredPurchaseToken
|
|
this.log.push('verify')
|
|
return Promise.resolve(this.result)
|
|
}
|
|
acknowledge(productId: string, purchaseToken: string): Promise<void> {
|
|
this.log.push('acknowledge')
|
|
if (this.failAcknowledge) {
|
|
return Promise.reject(new GooglePlayVerificationError('google_play_acknowledgement_failed', 502))
|
|
}
|
|
this.acknowledged.push({ productId, purchaseToken })
|
|
return Promise.resolve()
|
|
}
|
|
}
|
|
|
|
class FakeStore implements GooglePlayPurchaseStore {
|
|
applied: VerifiedGooglePlayPurchaseRecord[] = []
|
|
marked: Array<{ userId: string; purchaseToken: string }> = []
|
|
ownsQueries: Array<{ userId: string; purchaseToken: string }> = []
|
|
reject: GooglePlayPurchasePersistenceError | null = null
|
|
result: StoredGooglePlayPurchase = { applied: true, purchase_id: 'p-1', acknowledged: false }
|
|
constructor(private readonly log: string[]) {}
|
|
ownsPurchaseToken(userId: string, purchaseToken: string): Promise<boolean> {
|
|
this.ownsQueries.push({ userId, purchaseToken })
|
|
return Promise.resolve(true)
|
|
}
|
|
applyVerified(record: VerifiedGooglePlayPurchaseRecord): Promise<StoredGooglePlayPurchase> {
|
|
this.log.push('apply')
|
|
if (this.reject) return Promise.reject(this.reject)
|
|
this.applied.push(record)
|
|
return Promise.resolve(this.result)
|
|
}
|
|
markAcknowledged(userId: string, purchaseToken: string): Promise<void> {
|
|
this.log.push('mark')
|
|
this.marked.push({ userId, purchaseToken })
|
|
return Promise.resolve()
|
|
}
|
|
}
|
|
|
|
function setup(verified: NormalizedGooglePlayPurchase = purchase()) {
|
|
const log: string[] = []
|
|
const playApi = new FakePlayApi(log, verified)
|
|
const store = new FakeStore(log)
|
|
return { log, playApi, store }
|
|
}
|
|
|
|
const input = { userId: USER_ID, productId: PRODUCT_ID, purchaseToken: TOKEN }
|
|
|
|
Deno.test('purchase rejected by the database is never acknowledged with Google', async () => {
|
|
for (const code of ['active_subscription_other_provider', 'purchase_owned_by_other_user'] as const) {
|
|
const { log, playApi, store } = setup()
|
|
store.reject = new GooglePlayPurchasePersistenceError(code)
|
|
let caught: unknown = null
|
|
try {
|
|
await applyGooglePlayPurchase({ playApi, store }, input)
|
|
} catch (error) {
|
|
caught = error
|
|
}
|
|
assert(caught instanceof GooglePlayPurchasePersistenceError && caught.code === code, `${code} must propagate`)
|
|
assert(playApi.acknowledged.length === 0, `${code}: rejected purchase must stay unacknowledged`)
|
|
assert(store.marked.length === 0, `${code}: rejected purchase must not be marked acknowledged`)
|
|
assert(log.join(',') === 'verify,apply', `${code}: unexpected call order ${log.join(',')}`)
|
|
}
|
|
})
|
|
|
|
Deno.test('accepted purchase is persisted unacknowledged, then acknowledged, then marked', async () => {
|
|
const { log, playApi, store } = setup()
|
|
const result = await applyGooglePlayPurchase({ playApi, store }, input)
|
|
|
|
assert(log.join(',') === 'verify,apply,acknowledge,mark', `unexpected call order ${log.join(',')}`)
|
|
assert(store.applied.length === 1, 'purchase must be persisted once')
|
|
const persisted = store.applied[0]
|
|
assert(persisted.userId === USER_ID && persisted.purchaseToken === TOKEN, 'persisted identity must match')
|
|
assert(persisted.purchase.acknowledged === false, 'persistence must record acknowledged=false before Google ack')
|
|
assert(
|
|
persisted.purchase.verification.acknowledgementState === GOOGLE_PLAY_ACKNOWLEDGED_STATE,
|
|
'entitled receipt must be stored in its canonical post-acknowledgement form',
|
|
)
|
|
assert(
|
|
playApi.acknowledged.length === 1
|
|
&& playApi.acknowledged[0].productId === PRODUCT_ID
|
|
&& playApi.acknowledged[0].purchaseToken === TOKEN,
|
|
'Google must be acknowledged for the verified product and token',
|
|
)
|
|
assert(store.marked.length === 1 && store.marked[0].userId === USER_ID, 'acknowledgement must be recorded')
|
|
assert(result.acknowledgedNow, 'result must report the acknowledgement')
|
|
assert(result.purchase.acknowledged, 'returned purchase must be acknowledged')
|
|
assert(
|
|
result.stored !== null && result.stored.acknowledged === true && result.stored.purchase_id === 'p-1',
|
|
'returned stored row must reflect the acknowledgement',
|
|
)
|
|
})
|
|
|
|
Deno.test('duplicate and stale persistence results are still acknowledged', async () => {
|
|
const results: StoredGooglePlayPurchase[] = [
|
|
{ applied: false, duplicate: true, purchase_id: 'p-1', acknowledged: false },
|
|
{ applied: false, duplicate: false, reason: 'stale_provider_event', purchase_id: 'p-1', acknowledged: false },
|
|
]
|
|
for (const stored of results) {
|
|
const { playApi, store } = setup()
|
|
store.result = stored
|
|
await applyGooglePlayPurchase({ playApi, store }, input)
|
|
assert(playApi.acknowledged.length === 1, 'stored purchase must be acknowledged to avoid auto-refund')
|
|
assert(store.marked.length === 1, 'acknowledgement must be recorded')
|
|
}
|
|
})
|
|
|
|
Deno.test('failed Google acknowledgement leaves the stored purchase unacknowledged and propagates', async () => {
|
|
const { log, playApi, store } = setup()
|
|
playApi.failAcknowledge = true
|
|
let caught: unknown = null
|
|
try {
|
|
await applyGooglePlayPurchase({ playApi, store }, input)
|
|
} catch (error) {
|
|
caught = error
|
|
}
|
|
assert(
|
|
caught instanceof GooglePlayVerificationError && caught.code === 'google_play_acknowledgement_failed'
|
|
&& caught.status === 502,
|
|
'acknowledgement failure must propagate as 502',
|
|
)
|
|
assert(store.applied.length === 1 && store.applied[0].purchase.acknowledged === false, 'row stays acknowledged=false')
|
|
assert(store.marked.length === 0, 'failed acknowledgement must not be recorded')
|
|
assert(log.join(',') === 'verify,apply,acknowledge', `unexpected call order ${log.join(',')}`)
|
|
})
|
|
|
|
Deno.test('already acknowledged purchase is persisted as acknowledged without another Google call', async () => {
|
|
const { playApi, store } = setup(purchase({
|
|
acknowledged: true,
|
|
verification: {
|
|
subscriptionState: 'SUBSCRIPTION_STATE_ACTIVE',
|
|
acknowledgementState: GOOGLE_PLAY_ACKNOWLEDGED_STATE,
|
|
},
|
|
}))
|
|
const result = await applyGooglePlayPurchase({ playApi, store }, input)
|
|
assert(store.applied[0].purchase.acknowledged === true, 'acknowledged purchase must persist acknowledged=true')
|
|
assert(playApi.acknowledged.length === 0 && store.marked.length === 0, 'no second acknowledgement')
|
|
assert(!result.acknowledgedNow && result.purchase.acknowledged, 'result must stay acknowledged')
|
|
})
|
|
|
|
Deno.test('non-entitled purchase is persisted verbatim and never acknowledged', async () => {
|
|
const { playApi, store } = setup(purchase({ entitled: false, purchaseState: 'pending' }))
|
|
const result = await applyGooglePlayPurchase({ playApi, store }, input)
|
|
assert(
|
|
store.applied[0].purchase.verification.acknowledgementState === PENDING_ACK,
|
|
'non-entitled receipt must keep Google acknowledgement state',
|
|
)
|
|
assert(playApi.acknowledged.length === 0 && store.marked.length === 0, 'non-entitled purchase must not be acknowledged')
|
|
assert(!result.purchase.acknowledged, 'result must stay unacknowledged')
|
|
})
|
|
|
|
Deno.test('preverified purchase skips Google verification but keeps the persist-then-acknowledge order', async () => {
|
|
const { log, playApi, store } = setup()
|
|
await applyGooglePlayPurchase({ playApi, store }, { ...input, preverified: purchase() })
|
|
assert(playApi.verifyCalls === 0, 'preverified purchase must not be verified again')
|
|
assert(log.join(',') === 'apply,acknowledge,mark', `unexpected call order ${log.join(',')}`)
|
|
})
|
|
|
|
Deno.test('expired-token ownership lookup is scoped to the purchasing user', async () => {
|
|
const { playApi, store } = setup()
|
|
await applyGooglePlayPurchase({ playApi, store }, input)
|
|
assert(playApi.ownsLookup !== null, 'verify must receive an ownership lookup')
|
|
assert(await playApi.ownsLookup('expired-token-0001'), 'lookup must delegate to the store')
|
|
assert(
|
|
store.ownsQueries.length === 1
|
|
&& store.ownsQueries[0].userId === USER_ID
|
|
&& store.ownsQueries[0].purchaseToken === 'expired-token-0001',
|
|
'lookup must be scoped to the purchasing user',
|
|
)
|
|
})
|
|
|
|
Deno.test('database exception messages map to stable persistence codes', () => {
|
|
assert(
|
|
classifyGooglePlayPersistenceError('purchase_owned_by_other_user') === 'purchase_owned_by_other_user',
|
|
'owner conflict must map',
|
|
)
|
|
assert(
|
|
classifyGooglePlayPersistenceError('linked_purchase_owned_by_other_user') === 'purchase_owned_by_other_user',
|
|
'linked owner conflict keeps its historical mapping',
|
|
)
|
|
assert(
|
|
classifyGooglePlayPersistenceError('active_subscription_other_provider') === 'active_subscription_other_provider',
|
|
'provider conflict must map',
|
|
)
|
|
assert(
|
|
classifyGooglePlayPersistenceError('provider_event_payload_mismatch') === 'purchase_persistence_failed',
|
|
'other failures must map to the generic code',
|
|
)
|
|
})
|
|
|
|
interface RecordedCall {
|
|
kind: 'rpc' | 'update'
|
|
name: string
|
|
args: Record<string, unknown>
|
|
filters: Array<[string, string, unknown]>
|
|
}
|
|
|
|
function fakeSupabaseClient(calls: RecordedCall[], rpcError: { message: string } | null = null) {
|
|
const client = {
|
|
rpc(name: string, args: Record<string, unknown>) {
|
|
calls.push({ kind: 'rpc', name, args, filters: [] })
|
|
return Promise.resolve(rpcError
|
|
? { data: null, error: rpcError }
|
|
: { data: { applied: true, purchase_id: 'p-1', acknowledged: false }, error: null })
|
|
},
|
|
from(table: string) {
|
|
return {
|
|
update(values: Record<string, unknown>) {
|
|
const call: RecordedCall = { kind: 'update', name: table, args: values, filters: [] }
|
|
calls.push(call)
|
|
const chain = {
|
|
eq(column: string, value: unknown) {
|
|
call.filters.push(['eq', column, value])
|
|
return chain
|
|
},
|
|
is(column: string, value: unknown) {
|
|
call.filters.push(['is', column, value])
|
|
return Promise.resolve({ error: null })
|
|
},
|
|
}
|
|
return chain
|
|
},
|
|
}
|
|
},
|
|
}
|
|
return client as unknown as Parameters<typeof createSupabaseGooglePlayPurchaseStore>[0]
|
|
}
|
|
|
|
Deno.test('Supabase store maps the RPC with hashed tokens and records acknowledgement by direct update', async () => {
|
|
const calls: RecordedCall[] = []
|
|
const store = createSupabaseGooglePlayPurchaseStore(fakeSupabaseClient(calls))
|
|
const record = {
|
|
userId: USER_ID,
|
|
purchaseToken: TOKEN,
|
|
purchase: purchase({ linkedPurchaseToken: 'linked-token-0001' }),
|
|
}
|
|
const stored = await store.applyVerified(record)
|
|
await store.markAcknowledged(USER_ID, TOKEN)
|
|
|
|
const tokenHash = await sha256Hex(TOKEN)
|
|
const [rpc, update] = calls
|
|
assert(rpc.kind === 'rpc' && rpc.name === 'apply_verified_google_play_purchase', 'must call the purchase RPC')
|
|
assert(rpc.args.p_token_hash === tokenHash, 'token must be hashed')
|
|
assert(rpc.args.p_linked_token_hash === await sha256Hex('linked-token-0001'), 'linked token must be hashed')
|
|
assert(rpc.args.p_purchase_token === TOKEN && rpc.args.p_user_id === USER_ID, 'identity must be mapped')
|
|
assert(rpc.args.p_acknowledged === false, 'acknowledged flag must be forwarded')
|
|
assert(stored !== null && stored.purchase_id === 'p-1', 'RPC row must be returned')
|
|
assert(calls.filter((call) => call.kind === 'rpc').length === 1, 'acknowledgement must not re-enter the RPC')
|
|
assert(update.kind === 'update' && update.name === 'iap_purchases', 'acknowledgement must update iap_purchases')
|
|
assert(typeof update.args.acknowledged_at === 'string', 'acknowledged_at must be set')
|
|
assert(
|
|
JSON.stringify(update.filters) === JSON.stringify([
|
|
['eq', 'platform', 'google_play'],
|
|
['eq', 'user_id', USER_ID],
|
|
['eq', 'token_hash', tokenHash],
|
|
['is', 'acknowledged_at', null],
|
|
]),
|
|
`unexpected update filters ${JSON.stringify(update.filters)}`,
|
|
)
|
|
})
|
|
|
|
Deno.test('Supabase store turns RPC rejections into persistence errors', async () => {
|
|
const store = createSupabaseGooglePlayPurchaseStore(
|
|
fakeSupabaseClient([], { message: 'active_subscription_other_provider' }),
|
|
)
|
|
let caught: unknown = null
|
|
try {
|
|
await store.applyVerified({ userId: USER_ID, purchaseToken: TOKEN, purchase: purchase() })
|
|
} catch (error) {
|
|
caught = error
|
|
}
|
|
assert(
|
|
caught instanceof GooglePlayPurchasePersistenceError && caught.code === 'active_subscription_other_provider',
|
|
'RPC rejection must surface as a typed persistence error',
|
|
)
|
|
})
|