Add multi-top-up and repeated exhaustion session coverage tests

Author: brendanjryan

src/tempo/server/Session.coverage.test.ts

@@ -20,7 +20,7 @@ import * as Store from '../../Store.js'
 import * as ChannelStore from '../session/ChannelStore.js'
 import { signVoucher } from '../session/Voucher.js'
 import { sessionManager } from '../client/SessionManager.js'
-import { session } from './Session.js'
+import { charge, session } from './Session.js'
 
 const isLocalnet = nodeEnv === 'localnet'
 const payer = accounts[2]
@@ -720,6 +720,133 @@ describe.runIf(isLocalnet)('session coverage gaps', () => {
     })
   })
 
+  describe('PR7: multi top-up continuity', () => {
+    test('open -> topUp -> topUp -> voucher/charge -> close', async () => {
+      const { channelId, serializedTransaction } = await createSignedOpenTransaction(4_000_000n)
+      const server = createServer()
+
+      const openReceipt = await server.verify({
+        credential: {
+          challenge: makeChallenge({ id: 'open-multi-topup', channelId }),
+          payload: {
+            action: 'open' as const,
+            type: 'transaction' as const,
+            channelId,
+            transaction: serializedTransaction,
+            cumulativeAmount: '1000000',
+            signature: await signVoucherFor(payer, channelId, 1_000_000n),
+          },
+        },
+        request: makeRequest(),
+      })
+      expect(openReceipt.status).toBe('success')
+
+      await charge(store, channelId, 1_000_000n)
+      await expect(charge(store, channelId, 1_000_000n)).rejects.toThrow('requested')
+
+      const topUp1Amount = 2_000_000n
+      const { serializedTransaction: topUp1 } = await signTopUpChannel({
+        escrow: escrowContract,
+        payer,
+        channelId,
+        token: currency,
+        amount: topUp1Amount,
+      })
+
+      const topUp1Receipt = await server.verify({
+        credential: {
+          challenge: makeChallenge({ id: 'topup-1', channelId }),
+          payload: {
+            action: 'topUp' as const,
+            type: 'transaction' as const,
+            channelId,
+            transaction: topUp1,
+            additionalDeposit: topUp1Amount.toString(),
+          },
+        },
+        request: makeRequest(),
+      })
+      expect(topUp1Receipt.status).toBe('success')
+      expect((await store.getChannel(channelId))?.deposit).toBe(6_000_000n)
+
+      const voucher1 = await server.verify({
+        credential: {
+          challenge: makeChallenge({ id: 'voucher-after-topup-1', channelId }),
+          payload: {
+            action: 'voucher' as const,
+            channelId,
+            cumulativeAmount: '3000000',
+            signature: await signVoucherFor(payer, channelId, 3_000_000n),
+          },
+        },
+        request: makeRequest(),
+      })
+      expect(voucher1.acceptedCumulative).toBe('3000000')
+
+      await charge(store, channelId, 2_000_000n)
+      await expect(charge(store, channelId, 1_000_000n)).rejects.toThrow('requested')
+
+      const topUp2Amount = 2_000_000n
+      const { serializedTransaction: topUp2 } = await signTopUpChannel({
+        escrow: escrowContract,
+        payer,
+        channelId,
+        token: currency,
+        amount: topUp2Amount,
+      })
+
+      const topUp2Receipt = await server.verify({
+        credential: {
+          challenge: makeChallenge({ id: 'topup-2', channelId }),
+          payload: {
+            action: 'topUp' as const,
+            type: 'transaction' as const,
+            channelId,
+            transaction: topUp2,
+            additionalDeposit: topUp2Amount.toString(),
+          },
+        },
+        request: makeRequest(),
+      })
+      expect(topUp2Receipt.status).toBe('success')
+      expect((await store.getChannel(channelId))?.deposit).toBe(8_000_000n)
+
+      const voucher2 = await server.verify({
+        credential: {
+          challenge: makeChallenge({ id: 'voucher-after-topup-2', channelId }),
+          payload: {
+            action: 'voucher' as const,
+            channelId,
+            cumulativeAmount: '5000000',
+            signature: await signVoucherFor(payer, channelId, 5_000_000n),
+          },
+        },
+        request: makeRequest(),
+      })
+      expect(voucher2.acceptedCumulative).toBe('5000000')
+
+      await charge(store, channelId, 2_000_000n)
+
+      const closeReceipt = await server.verify({
+        credential: {
+          challenge: makeChallenge({ id: 'close-multi-topup', channelId }),
+          payload: {
+            action: 'close' as const,
+            channelId,
+            cumulativeAmount: '5000000',
+            signature: await signVoucherFor(payer, channelId, 5_000_000n),
+          },
+        },
+        request: makeRequest(),
+      })
+      expect(closeReceipt.status).toBe('success')
+
+      const finalized = await store.getChannel(channelId)
+      expect(finalized?.spent).toBe(5_000_000n)
+      expect(finalized?.finalized).toBe(true)
+    })
+  })
+
   describe('PR7: e2e streaming loop', () => {
     test('open -> stream -> need-voucher -> resume -> close', async () => {
       const backingStore = Store.memory()
@@ -798,5 +925,79 @@ describe.runIf(isLocalnet)('session coverage gaps', () => {
       const persisted = await ChannelStore.fromStore(backingStore).getChannel(channelId!)
       expect(persisted?.finalized).toBe(true)
     })
+
+    test('handles repeated exhaustion/resume cycles within one stream', async () => {
+      const backingStore = Store.memory()
+      const routeHandler = Mppx_server.create({
+        methods: [
+          tempo_server.session({
+            store: backingStore,
+            getClient: () => client,
+            account: recipient,
+            currency,
+            escrowContract,
+            chainId: chain.id,
+            sse: true,
+          }),
+        ],
+        realm: 'api.example.com',
+        secretKey: 'secret',
+      }).session({ amount: '1', decimals: 6, unitType: 'token' })
+
+      let voucherPosts = 0
+      const fetch = async (input: RequestInfo | URL, init?: RequestInit) => {
+        const request = new Request(input, init)
+        let action: 'open' | 'topUp' | 'voucher' | 'close' | undefined
+
+        if (request.method === 'POST' && request.headers.has('Authorization')) {
+          try {
+            const credential = Credential.fromRequest<any>(request)
+            action = credential.payload?.action
+            if (action === 'voucher') voucherPosts++
+          } catch {}
+        }
+
+        const result = await routeHandler(request)
+        if (result.status === 402) return result.challenge
+
+        if (action === 'voucher') {
+          return new Response(null, { status: 200 })
+        }
+
+        if (request.headers.get('Accept')?.includes('text/event-stream')) {
+          return result.withReceipt(async function* (stream) {
+            await stream.charge()
+            yield 'chunk-1'
+            await stream.charge()
+            yield 'chunk-2'
+            await stream.charge()
+            yield 'chunk-3'
+            await stream.charge()
+            yield 'chunk-4'
+          })
+        }
+
+        return result.withReceipt(new Response('ok'))
+      }
+
+      const manager = sessionManager({
+        account: payer,
+        client,
+        escrowContract,
+        fetch,
+        maxDeposit: '4',
+      })
+
+      const chunks: string[] = []
+      const stream = await manager.sse('https://api.example.com/stream')
+      for await (const chunk of stream) chunks.push(chunk)
+
+      expect(chunks).toEqual(['chunk-1', 'chunk-2', 'chunk-3', 'chunk-4'])
+      expect(voucherPosts).toBeGreaterThanOrEqual(2)
+
+      const closeReceipt = await manager.close()
+      expect(closeReceipt?.status).toBe('success')
+      expect(closeReceipt?.spent).toBe('4000000')
+    })
   })
 })