feat(framework): server testing utils, transaction storage simplify, pathfinding tests (#384)
## Server Testing Utils - Add TestServer, TestClient, MockRoom for unit testing - Export testing utilities from @esengine/server/testing ## Transaction Storage (BREAKING) - Simplify RedisStorage/MongoStorage to factory pattern only - Remove DI client injection option - Add lazy connection and Symbol.asyncDispose support - Add 161 unit tests with full coverage ## Pathfinding Tests - Add 150 unit tests covering all components - BinaryHeap, Heuristics, AStarPathfinder, GridMap, NavMesh, PathSmoother ## Docs - Update storage.md for new factory pattern API
This commit is contained in:
YHH
GitHub
@@ -0,0 +1,445 @@
|
||||
/**
|
||||
* @zh TransactionContext 单元测试
|
||||
* @en TransactionContext unit tests
|
||||
*/
|
||||
|
||||
import { describe, it, expect, beforeEach, vi } from 'vitest'
|
||||
import { TransactionContext, createTransactionContext } from '../../src/core/TransactionContext.js'
|
||||
import { MemoryStorage } from '../../src/storage/MemoryStorage.js'
|
||||
import type { ITransactionOperation, ITransactionContext, OperationResult } from '../../src/core/types.js'
|
||||
|
||||
// ============================================================================
|
||||
// Mock Operations | 模拟操作
|
||||
// ============================================================================
|
||||
|
||||
class SuccessOperation implements ITransactionOperation<{ value: number }, { doubled: number }> {
|
||||
readonly name: string
|
||||
readonly data: { value: number }
|
||||
|
||||
private _compensated = false
|
||||
|
||||
constructor(name: string, value: number) {
|
||||
this.name = name
|
||||
this.data = { value }
|
||||
}
|
||||
|
||||
async validate(_ctx: ITransactionContext): Promise<boolean> {
|
||||
return this.data.value > 0
|
||||
}
|
||||
|
||||
async execute(_ctx: ITransactionContext): Promise<OperationResult<{ doubled: number }>> {
|
||||
return { success: true, data: { doubled: this.data.value * 2 } }
|
||||
}
|
||||
|
||||
async compensate(_ctx: ITransactionContext): Promise<void> {
|
||||
this._compensated = true
|
||||
}
|
||||
|
||||
get compensated(): boolean {
|
||||
return this._compensated
|
||||
}
|
||||
}
|
||||
|
||||
class FailOperation implements ITransactionOperation {
|
||||
readonly name = 'fail'
|
||||
readonly data = {}
|
||||
|
||||
async validate(_ctx: ITransactionContext): Promise<boolean> {
|
||||
return true
|
||||
}
|
||||
|
||||
async execute(_ctx: ITransactionContext): Promise<OperationResult> {
|
||||
return { success: false, error: 'Intentional failure', errorCode: 'FAIL' }
|
||||
}
|
||||
|
||||
async compensate(_ctx: ITransactionContext): Promise<void> {
|
||||
// No-op
|
||||
}
|
||||
}
|
||||
|
||||
class ValidationFailOperation implements ITransactionOperation {
|
||||
readonly name = 'validation-fail'
|
||||
readonly data = {}
|
||||
|
||||
async validate(_ctx: ITransactionContext): Promise<boolean> {
|
||||
return false
|
||||
}
|
||||
|
||||
async execute(_ctx: ITransactionContext): Promise<OperationResult> {
|
||||
return { success: true }
|
||||
}
|
||||
|
||||
async compensate(_ctx: ITransactionContext): Promise<void> {
|
||||
// No-op
|
||||
}
|
||||
}
|
||||
|
||||
class SlowOperation implements ITransactionOperation {
|
||||
readonly name = 'slow'
|
||||
readonly data: { delay: number }
|
||||
|
||||
constructor(delay: number) {
|
||||
this.data = { delay }
|
||||
}
|
||||
|
||||
async validate(_ctx: ITransactionContext): Promise<boolean> {
|
||||
return true
|
||||
}
|
||||
|
||||
async execute(_ctx: ITransactionContext): Promise<OperationResult> {
|
||||
await new Promise((resolve) => setTimeout(resolve, this.data.delay))
|
||||
return { success: true }
|
||||
}
|
||||
|
||||
async compensate(_ctx: ITransactionContext): Promise<void> {
|
||||
// No-op
|
||||
}
|
||||
}
|
||||
|
||||
class ContextDataOperation implements ITransactionOperation {
|
||||
readonly name = 'context-data'
|
||||
readonly data = {}
|
||||
|
||||
async validate(_ctx: ITransactionContext): Promise<boolean> {
|
||||
return true
|
||||
}
|
||||
|
||||
async execute(ctx: ITransactionContext): Promise<OperationResult> {
|
||||
ctx.set('testKey', 'testValue')
|
||||
ctx.set('numberKey', 42)
|
||||
return { success: true, data: { stored: true } }
|
||||
}
|
||||
|
||||
async compensate(_ctx: ITransactionContext): Promise<void> {
|
||||
// No-op
|
||||
}
|
||||
}
|
||||
|
||||
// ============================================================================
|
||||
// Test Suite | 测试套件
|
||||
// ============================================================================
|
||||
|
||||
describe('TransactionContext', () => {
|
||||
let storage: MemoryStorage
|
||||
|
||||
beforeEach(() => {
|
||||
storage = new MemoryStorage()
|
||||
})
|
||||
|
||||
// ========================================================================
|
||||
// 构造器测试 | Constructor Tests
|
||||
// ========================================================================
|
||||
|
||||
describe('Constructor', () => {
|
||||
it('should create with default options', () => {
|
||||
const ctx = new TransactionContext()
|
||||
expect(ctx.id).toMatch(/^tx_/)
|
||||
expect(ctx.state).toBe('pending')
|
||||
expect(ctx.timeout).toBe(30000)
|
||||
expect(ctx.operations).toHaveLength(0)
|
||||
expect(ctx.storage).toBeNull()
|
||||
})
|
||||
|
||||
it('should create with custom options', () => {
|
||||
const ctx = new TransactionContext({
|
||||
timeout: 10000,
|
||||
storage,
|
||||
metadata: { userId: 'user-1' },
|
||||
distributed: true,
|
||||
})
|
||||
|
||||
expect(ctx.timeout).toBe(10000)
|
||||
expect(ctx.storage).toBe(storage)
|
||||
expect(ctx.metadata.userId).toBe('user-1')
|
||||
})
|
||||
|
||||
it('should use createTransactionContext factory', () => {
|
||||
const ctx = createTransactionContext({ timeout: 5000 })
|
||||
expect(ctx).toBeDefined()
|
||||
expect(ctx.timeout).toBe(5000)
|
||||
})
|
||||
})
|
||||
|
||||
// ========================================================================
|
||||
// 添加操作测试 | Add Operation Tests
|
||||
// ========================================================================
|
||||
|
||||
describe('addOperation()', () => {
|
||||
it('should add operations', () => {
|
||||
const ctx = new TransactionContext()
|
||||
const op1 = new SuccessOperation('op1', 10)
|
||||
const op2 = new SuccessOperation('op2', 20)
|
||||
|
||||
ctx.addOperation(op1).addOperation(op2)
|
||||
|
||||
expect(ctx.operations).toHaveLength(2)
|
||||
expect(ctx.operations[0]).toBe(op1)
|
||||
expect(ctx.operations[1]).toBe(op2)
|
||||
})
|
||||
|
||||
it('should support method chaining', () => {
|
||||
const ctx = new TransactionContext()
|
||||
const result = ctx
|
||||
.addOperation(new SuccessOperation('op1', 10))
|
||||
.addOperation(new SuccessOperation('op2', 20))
|
||||
|
||||
expect(result).toBe(ctx)
|
||||
})
|
||||
|
||||
it('should throw when adding to non-pending transaction', async () => {
|
||||
const ctx = new TransactionContext()
|
||||
ctx.addOperation(new SuccessOperation('op1', 10))
|
||||
await ctx.execute()
|
||||
|
||||
expect(() => ctx.addOperation(new SuccessOperation('op2', 20))).toThrow(
|
||||
'Cannot add operation to transaction in state'
|
||||
)
|
||||
})
|
||||
})
|
||||
|
||||
// ========================================================================
|
||||
// 执行测试 | Execute Tests
|
||||
// ========================================================================
|
||||
|
||||
describe('execute()', () => {
|
||||
it('should execute all operations successfully', async () => {
|
||||
const ctx = new TransactionContext()
|
||||
ctx.addOperation(new SuccessOperation('op1', 10))
|
||||
ctx.addOperation(new SuccessOperation('op2', 20))
|
||||
|
||||
const result = await ctx.execute()
|
||||
|
||||
expect(result.success).toBe(true)
|
||||
expect(result.transactionId).toBe(ctx.id)
|
||||
expect(result.results).toHaveLength(2)
|
||||
expect(result.duration).toBeGreaterThanOrEqual(0)
|
||||
expect(ctx.state).toBe('committed')
|
||||
})
|
||||
|
||||
it('should return combined result data', async () => {
|
||||
const ctx = new TransactionContext()
|
||||
ctx.addOperation(new SuccessOperation('op1', 10))
|
||||
|
||||
const result = await ctx.execute<{ doubled: number }>()
|
||||
|
||||
expect(result.success).toBe(true)
|
||||
expect(result.data?.doubled).toBe(20)
|
||||
})
|
||||
|
||||
it('should fail if already executed', async () => {
|
||||
const ctx = new TransactionContext()
|
||||
ctx.addOperation(new SuccessOperation('op1', 10))
|
||||
|
||||
await ctx.execute()
|
||||
const result = await ctx.execute()
|
||||
|
||||
expect(result.success).toBe(false)
|
||||
expect(result.error).toContain('already in state')
|
||||
})
|
||||
|
||||
it('should fail on validation error', async () => {
|
||||
const ctx = new TransactionContext()
|
||||
ctx.addOperation(new ValidationFailOperation())
|
||||
|
||||
const result = await ctx.execute()
|
||||
|
||||
expect(result.success).toBe(false)
|
||||
expect(result.error).toContain('Validation failed')
|
||||
expect(ctx.state).toBe('rolledback')
|
||||
})
|
||||
|
||||
it('should fail and rollback on operation failure', async () => {
|
||||
const ctx = new TransactionContext()
|
||||
const op1 = new SuccessOperation('op1', 10)
|
||||
const op2 = new FailOperation()
|
||||
|
||||
ctx.addOperation(op1).addOperation(op2)
|
||||
|
||||
const result = await ctx.execute()
|
||||
|
||||
expect(result.success).toBe(false)
|
||||
expect(result.error).toBe('Intentional failure')
|
||||
expect(ctx.state).toBe('rolledback')
|
||||
expect(op1.compensated).toBe(true)
|
||||
})
|
||||
|
||||
it('should timeout on slow operations', async () => {
|
||||
const ctx = new TransactionContext({ timeout: 50 })
|
||||
// Add two operations - timeout is checked between operations
|
||||
ctx.addOperation(new SlowOperation(100))
|
||||
ctx.addOperation(new SuccessOperation('second', 1))
|
||||
|
||||
const result = await ctx.execute()
|
||||
|
||||
expect(result.success).toBe(false)
|
||||
expect(result.error).toContain('timed out')
|
||||
expect(ctx.state).toBe('rolledback')
|
||||
})
|
||||
|
||||
it('should save transaction log with storage', async () => {
|
||||
const ctx = new TransactionContext({ storage })
|
||||
ctx.addOperation(new SuccessOperation('op1', 10))
|
||||
|
||||
await ctx.execute()
|
||||
|
||||
const log = await storage.getTransaction(ctx.id)
|
||||
expect(log).not.toBeNull()
|
||||
expect(log?.state).toBe('committed')
|
||||
expect(log?.operations).toHaveLength(1)
|
||||
expect(log?.operations[0].state).toBe('executed')
|
||||
})
|
||||
|
||||
it('should update operation states on failure', async () => {
|
||||
const ctx = new TransactionContext({ storage })
|
||||
ctx.addOperation(new SuccessOperation('op1', 10))
|
||||
ctx.addOperation(new FailOperation())
|
||||
|
||||
await ctx.execute()
|
||||
|
||||
const log = await storage.getTransaction(ctx.id)
|
||||
expect(log?.state).toBe('rolledback')
|
||||
expect(log?.operations[0].state).toBe('compensated')
|
||||
})
|
||||
})
|
||||
|
||||
// ========================================================================
|
||||
// 回滚测试 | Rollback Tests
|
||||
// ========================================================================
|
||||
|
||||
describe('rollback()', () => {
|
||||
it('should rollback pending transaction', async () => {
|
||||
const ctx = new TransactionContext()
|
||||
const op1 = new SuccessOperation('op1', 10)
|
||||
ctx.addOperation(op1)
|
||||
|
||||
await ctx.rollback()
|
||||
|
||||
expect(ctx.state).toBe('rolledback')
|
||||
})
|
||||
|
||||
it('should not rollback already committed transaction', async () => {
|
||||
const ctx = new TransactionContext()
|
||||
ctx.addOperation(new SuccessOperation('op1', 10))
|
||||
|
||||
await ctx.execute()
|
||||
expect(ctx.state).toBe('committed')
|
||||
|
||||
await ctx.rollback()
|
||||
expect(ctx.state).toBe('committed')
|
||||
})
|
||||
|
||||
it('should not rollback already rolledback transaction', async () => {
|
||||
const ctx = new TransactionContext()
|
||||
ctx.addOperation(new FailOperation())
|
||||
|
||||
await ctx.execute()
|
||||
expect(ctx.state).toBe('rolledback')
|
||||
|
||||
await ctx.rollback()
|
||||
expect(ctx.state).toBe('rolledback')
|
||||
})
|
||||
})
|
||||
|
||||
// ========================================================================
|
||||
// 上下文数据测试 | Context Data Tests
|
||||
// ========================================================================
|
||||
|
||||
describe('Context Data', () => {
|
||||
it('should get and set context data', () => {
|
||||
const ctx = new TransactionContext()
|
||||
|
||||
ctx.set('key1', 'value1')
|
||||
ctx.set('key2', { nested: true })
|
||||
|
||||
expect(ctx.get<string>('key1')).toBe('value1')
|
||||
expect(ctx.get<{ nested: boolean }>('key2')).toEqual({ nested: true })
|
||||
})
|
||||
|
||||
it('should return undefined for non-existent key', () => {
|
||||
const ctx = new TransactionContext()
|
||||
expect(ctx.get('nonexistent')).toBeUndefined()
|
||||
})
|
||||
|
||||
it('should allow operations to share context data', async () => {
|
||||
const ctx = new TransactionContext()
|
||||
ctx.addOperation(new ContextDataOperation())
|
||||
|
||||
await ctx.execute()
|
||||
|
||||
expect(ctx.get<string>('testKey')).toBe('testValue')
|
||||
expect(ctx.get<number>('numberKey')).toBe(42)
|
||||
})
|
||||
})
|
||||
|
||||
// ========================================================================
|
||||
// 边界情况测试 | Edge Cases
|
||||
// ========================================================================
|
||||
|
||||
describe('Edge Cases', () => {
|
||||
it('should handle empty operations list', async () => {
|
||||
const ctx = new TransactionContext()
|
||||
const result = await ctx.execute()
|
||||
|
||||
expect(result.success).toBe(true)
|
||||
expect(result.results).toHaveLength(0)
|
||||
expect(ctx.state).toBe('committed')
|
||||
})
|
||||
|
||||
it('should handle single operation', async () => {
|
||||
const ctx = new TransactionContext()
|
||||
ctx.addOperation(new SuccessOperation('single', 5))
|
||||
|
||||
const result = await ctx.execute()
|
||||
|
||||
expect(result.success).toBe(true)
|
||||
expect(result.results).toHaveLength(1)
|
||||
})
|
||||
|
||||
it('should handle operation throwing exception', async () => {
|
||||
const ctx = new TransactionContext()
|
||||
const throwOp: ITransactionOperation = {
|
||||
name: 'throw',
|
||||
data: {},
|
||||
validate: async () => true,
|
||||
execute: async () => {
|
||||
throw new Error('Unexpected error')
|
||||
},
|
||||
compensate: async () => {},
|
||||
}
|
||||
|
||||
ctx.addOperation(throwOp)
|
||||
const result = await ctx.execute()
|
||||
|
||||
expect(result.success).toBe(false)
|
||||
expect(result.error).toBe('Unexpected error')
|
||||
})
|
||||
|
||||
it('should handle compensate throwing exception', async () => {
|
||||
const consoleSpy = vi.spyOn(console, 'error').mockImplementation(() => {})
|
||||
|
||||
const ctx = new TransactionContext({ storage })
|
||||
const badCompensateOp: ITransactionOperation = {
|
||||
name: 'bad-compensate',
|
||||
data: {},
|
||||
validate: async () => true,
|
||||
execute: async () => ({ success: true }),
|
||||
compensate: async () => {
|
||||
throw new Error('Compensation error')
|
||||
},
|
||||
}
|
||||
const failOp = new FailOperation()
|
||||
|
||||
ctx.addOperation(badCompensateOp).addOperation(failOp)
|
||||
const result = await ctx.execute()
|
||||
|
||||
expect(result.success).toBe(false)
|
||||
|
||||
// Check that operation state was updated with error
|
||||
const log = await storage.getTransaction(ctx.id)
|
||||
expect(log?.operations[0].state).toBe('failed')
|
||||
expect(log?.operations[0].error).toContain('Compensation error')
|
||||
|
||||
consoleSpy.mockRestore()
|
||||
})
|
||||
})
|
||||
})
|
||||
@@ -0,0 +1,358 @@
|
||||
/**
|
||||
* @zh TransactionManager 单元测试
|
||||
* @en TransactionManager unit tests
|
||||
*/
|
||||
|
||||
import { describe, it, expect, beforeEach } from 'vitest'
|
||||
import { TransactionManager, createTransactionManager } from '../../src/core/TransactionManager.js'
|
||||
import { MemoryStorage } from '../../src/storage/MemoryStorage.js'
|
||||
import type { ITransactionOperation, ITransactionContext, OperationResult } from '../../src/core/types.js'
|
||||
|
||||
// ============================================================================
|
||||
// Mock Operation | 模拟操作
|
||||
// ============================================================================
|
||||
|
||||
class MockOperation implements ITransactionOperation<{ value: number }, { result: number }> {
|
||||
readonly name = 'mock'
|
||||
readonly data: { value: number }
|
||||
|
||||
private _executed = false
|
||||
|
||||
constructor(value: number) {
|
||||
this.data = { value }
|
||||
}
|
||||
|
||||
async validate(_ctx: ITransactionContext): Promise<boolean> {
|
||||
return this.data.value > 0
|
||||
}
|
||||
|
||||
async execute(_ctx: ITransactionContext): Promise<OperationResult<{ result: number }>> {
|
||||
this._executed = true
|
||||
return { success: true, data: { result: this.data.value * 2 } }
|
||||
}
|
||||
|
||||
async compensate(_ctx: ITransactionContext): Promise<void> {
|
||||
this._executed = false
|
||||
}
|
||||
|
||||
get executed(): boolean {
|
||||
return this._executed
|
||||
}
|
||||
}
|
||||
|
||||
class FailingOperation implements ITransactionOperation<{ shouldFail: boolean }> {
|
||||
readonly name = 'failing'
|
||||
readonly data: { shouldFail: boolean }
|
||||
|
||||
constructor(shouldFail: boolean) {
|
||||
this.data = { shouldFail }
|
||||
}
|
||||
|
||||
async validate(_ctx: ITransactionContext): Promise<boolean> {
|
||||
return true
|
||||
}
|
||||
|
||||
async execute(_ctx: ITransactionContext): Promise<OperationResult> {
|
||||
if (this.data.shouldFail) {
|
||||
return { success: false, error: 'Intentional failure' }
|
||||
}
|
||||
return { success: true }
|
||||
}
|
||||
|
||||
async compensate(_ctx: ITransactionContext): Promise<void> {
|
||||
// No-op
|
||||
}
|
||||
}
|
||||
|
||||
// ============================================================================
|
||||
// Test Suite | 测试套件
|
||||
// ============================================================================
|
||||
|
||||
describe('TransactionManager', () => {
|
||||
let manager: TransactionManager
|
||||
let storage: MemoryStorage
|
||||
|
||||
beforeEach(() => {
|
||||
storage = new MemoryStorage()
|
||||
manager = new TransactionManager({
|
||||
storage,
|
||||
defaultTimeout: 5000,
|
||||
serverId: 'test-server',
|
||||
})
|
||||
})
|
||||
|
||||
// ========================================================================
|
||||
// 构造器测试 | Constructor Tests
|
||||
// ========================================================================
|
||||
|
||||
describe('Constructor', () => {
|
||||
it('should create with default config', () => {
|
||||
const defaultManager = new TransactionManager()
|
||||
expect(defaultManager.storage).toBeNull()
|
||||
expect(defaultManager.activeCount).toBe(0)
|
||||
expect(defaultManager.serverId).toMatch(/^server_/)
|
||||
})
|
||||
|
||||
it('should use provided config', () => {
|
||||
expect(manager.storage).toBe(storage)
|
||||
expect(manager.serverId).toBe('test-server')
|
||||
})
|
||||
|
||||
it('should use createTransactionManager factory', () => {
|
||||
const factoryManager = createTransactionManager({ serverId: 'factory-server' })
|
||||
expect(factoryManager).toBeInstanceOf(TransactionManager)
|
||||
expect(factoryManager.serverId).toBe('factory-server')
|
||||
})
|
||||
})
|
||||
|
||||
// ========================================================================
|
||||
// 事务创建测试 | Transaction Creation Tests
|
||||
// ========================================================================
|
||||
|
||||
describe('begin()', () => {
|
||||
it('should create new transaction context', () => {
|
||||
const tx = manager.begin()
|
||||
expect(tx.id).toMatch(/^tx_/)
|
||||
expect(tx.state).toBe('pending')
|
||||
})
|
||||
|
||||
it('should track active transactions', () => {
|
||||
expect(manager.activeCount).toBe(0)
|
||||
|
||||
const tx1 = manager.begin()
|
||||
expect(manager.activeCount).toBe(1)
|
||||
|
||||
const tx2 = manager.begin()
|
||||
expect(manager.activeCount).toBe(2)
|
||||
|
||||
expect(manager.getTransaction(tx1.id)).toBe(tx1)
|
||||
expect(manager.getTransaction(tx2.id)).toBe(tx2)
|
||||
})
|
||||
|
||||
it('should use custom timeout', () => {
|
||||
const tx = manager.begin({ timeout: 10000 })
|
||||
expect(tx.timeout).toBe(10000)
|
||||
})
|
||||
|
||||
it('should include serverId in metadata', () => {
|
||||
const tx = manager.begin()
|
||||
expect(tx.metadata.serverId).toBe('test-server')
|
||||
})
|
||||
|
||||
it('should merge custom metadata', () => {
|
||||
const tx = manager.begin({
|
||||
metadata: { userId: 'user-1', action: 'purchase' },
|
||||
})
|
||||
expect(tx.metadata.serverId).toBe('test-server')
|
||||
expect(tx.metadata.userId).toBe('user-1')
|
||||
expect(tx.metadata.action).toBe('purchase')
|
||||
})
|
||||
})
|
||||
|
||||
// ========================================================================
|
||||
// run() 便捷方法测试 | run() Convenience Method Tests
|
||||
// ========================================================================
|
||||
|
||||
describe('run()', () => {
|
||||
it('should execute transaction with builder', async () => {
|
||||
const result = await manager.run((ctx) => {
|
||||
ctx.addOperation(new MockOperation(10))
|
||||
})
|
||||
|
||||
expect(result.success).toBe(true)
|
||||
expect(result.transactionId).toMatch(/^tx_/)
|
||||
expect(result.duration).toBeGreaterThanOrEqual(0)
|
||||
})
|
||||
|
||||
it('should support async builder', async () => {
|
||||
const result = await manager.run(async (ctx) => {
|
||||
await Promise.resolve()
|
||||
ctx.addOperation(new MockOperation(5))
|
||||
})
|
||||
|
||||
expect(result.success).toBe(true)
|
||||
})
|
||||
|
||||
it('should clean up active transaction after run', async () => {
|
||||
expect(manager.activeCount).toBe(0)
|
||||
|
||||
await manager.run((ctx) => {
|
||||
ctx.addOperation(new MockOperation(10))
|
||||
expect(manager.activeCount).toBe(1)
|
||||
})
|
||||
|
||||
expect(manager.activeCount).toBe(0)
|
||||
})
|
||||
|
||||
it('should clean up even on failure', async () => {
|
||||
await manager.run((ctx) => {
|
||||
ctx.addOperation(new FailingOperation(true))
|
||||
})
|
||||
|
||||
expect(manager.activeCount).toBe(0)
|
||||
})
|
||||
|
||||
it('should return typed result data', async () => {
|
||||
const result = await manager.run<{ result: number }>((ctx) => {
|
||||
ctx.addOperation(new MockOperation(10))
|
||||
})
|
||||
|
||||
expect(result.success).toBe(true)
|
||||
expect(result.data?.result).toBe(20)
|
||||
})
|
||||
})
|
||||
|
||||
// ========================================================================
|
||||
// 分布式锁测试 | Distributed Lock Tests
|
||||
// ========================================================================
|
||||
|
||||
describe('Distributed Lock', () => {
|
||||
it('should acquire and release lock', async () => {
|
||||
const token = await manager.acquireLock('resource-1', 5000)
|
||||
expect(token).not.toBeNull()
|
||||
|
||||
const released = await manager.releaseLock('resource-1', token!)
|
||||
expect(released).toBe(true)
|
||||
})
|
||||
|
||||
it('should return null without storage', async () => {
|
||||
const noStorageManager = new TransactionManager()
|
||||
|
||||
const token = await noStorageManager.acquireLock('key', 5000)
|
||||
expect(token).toBeNull()
|
||||
|
||||
const released = await noStorageManager.releaseLock('key', 'token')
|
||||
expect(released).toBe(false)
|
||||
})
|
||||
|
||||
it('should execute withLock successfully', async () => {
|
||||
let executed = false
|
||||
|
||||
await manager.withLock('resource-1', async () => {
|
||||
executed = true
|
||||
return 'result'
|
||||
})
|
||||
|
||||
expect(executed).toBe(true)
|
||||
})
|
||||
|
||||
it('should throw if lock acquisition fails', async () => {
|
||||
// First acquire the lock
|
||||
await storage.acquireLock('resource-1', 5000)
|
||||
|
||||
// Try to acquire with withLock - should fail
|
||||
await expect(
|
||||
manager.withLock('resource-1', async () => {
|
||||
return 'should not reach'
|
||||
})
|
||||
).rejects.toThrow('Failed to acquire lock')
|
||||
})
|
||||
|
||||
it('should release lock after withLock completes', async () => {
|
||||
await manager.withLock('resource-1', async () => {
|
||||
return 'done'
|
||||
})
|
||||
|
||||
// Should be able to acquire again
|
||||
const token = await manager.acquireLock('resource-1', 5000)
|
||||
expect(token).not.toBeNull()
|
||||
})
|
||||
|
||||
it('should release lock even if function throws', async () => {
|
||||
try {
|
||||
await manager.withLock('resource-1', async () => {
|
||||
throw new Error('Test error')
|
||||
})
|
||||
} catch {
|
||||
// Expected
|
||||
}
|
||||
|
||||
// Should be able to acquire again
|
||||
const token = await manager.acquireLock('resource-1', 5000)
|
||||
expect(token).not.toBeNull()
|
||||
})
|
||||
})
|
||||
|
||||
// ========================================================================
|
||||
// 事务恢复测试 | Transaction Recovery Tests
|
||||
// ========================================================================
|
||||
|
||||
describe('recover()', () => {
|
||||
it('should return 0 without storage', async () => {
|
||||
const noStorageManager = new TransactionManager()
|
||||
const count = await noStorageManager.recover()
|
||||
expect(count).toBe(0)
|
||||
})
|
||||
|
||||
it('should recover pending transactions', async () => {
|
||||
// Save a pending transaction directly to storage
|
||||
await storage.saveTransaction({
|
||||
id: 'tx-pending',
|
||||
state: 'executing',
|
||||
createdAt: Date.now(),
|
||||
updatedAt: Date.now(),
|
||||
timeout: 5000,
|
||||
operations: [
|
||||
{ name: 'op1', state: 'executed' },
|
||||
],
|
||||
metadata: { serverId: 'test-server' },
|
||||
})
|
||||
|
||||
const count = await manager.recover()
|
||||
expect(count).toBe(1)
|
||||
|
||||
// Check that transaction state was updated
|
||||
const recovered = await storage.getTransaction('tx-pending')
|
||||
expect(recovered?.state).toBe('rolledback')
|
||||
})
|
||||
})
|
||||
|
||||
// ========================================================================
|
||||
// 清理测试 | Cleanup Tests
|
||||
// ========================================================================
|
||||
|
||||
describe('cleanup()', () => {
|
||||
it('should return 0 without storage', async () => {
|
||||
const noStorageManager = new TransactionManager()
|
||||
const count = await noStorageManager.cleanup()
|
||||
expect(count).toBe(0)
|
||||
})
|
||||
|
||||
it('should clean old completed transactions from pending list', async () => {
|
||||
const oldTimestamp = Date.now() - 48 * 60 * 60 * 1000 // 48 hours ago
|
||||
|
||||
// Note: cleanup() uses getPendingTransactions() which only returns pending/executing state
|
||||
// This test verifies the cleanup logic for transactions that are in pending state
|
||||
// but have been marked committed/rolledback (edge case during recovery)
|
||||
await storage.saveTransaction({
|
||||
id: 'tx-old-pending',
|
||||
state: 'pending', // This will be returned by getPendingTransactions
|
||||
createdAt: oldTimestamp,
|
||||
updatedAt: oldTimestamp,
|
||||
timeout: 5000,
|
||||
operations: [],
|
||||
})
|
||||
|
||||
// The current implementation doesn't clean pending transactions
|
||||
// This is a limitation - cleanup only works for committed/rolledback states
|
||||
// but getPendingTransactions doesn't return those
|
||||
const count = await manager.cleanup()
|
||||
expect(count).toBe(0) // Nothing cleaned because state is 'pending', not 'committed'
|
||||
})
|
||||
})
|
||||
|
||||
// ========================================================================
|
||||
// getTransaction 测试 | getTransaction Tests
|
||||
// ========================================================================
|
||||
|
||||
describe('getTransaction()', () => {
|
||||
it('should return active transaction', () => {
|
||||
const tx = manager.begin()
|
||||
expect(manager.getTransaction(tx.id)).toBe(tx)
|
||||
})
|
||||
|
||||
it('should return undefined for non-existent transaction', () => {
|
||||
expect(manager.getTransaction('non-existent')).toBeUndefined()
|
||||
})
|
||||
})
|
||||
})
|
||||
@@ -0,0 +1,574 @@
|
||||
/**
|
||||
* @zh SagaOrchestrator 单元测试
|
||||
* @en SagaOrchestrator unit tests
|
||||
*/
|
||||
|
||||
import { describe, it, expect, beforeEach, vi } from 'vitest'
|
||||
import {
|
||||
SagaOrchestrator,
|
||||
createSagaOrchestrator,
|
||||
type SagaStep,
|
||||
type SagaLog,
|
||||
} from '../../src/distributed/SagaOrchestrator.js'
|
||||
import { MemoryStorage } from '../../src/storage/MemoryStorage.js'
|
||||
|
||||
// ============================================================================
|
||||
// Test Suite | 测试套件
|
||||
// ============================================================================
|
||||
|
||||
describe('SagaOrchestrator', () => {
|
||||
let storage: MemoryStorage
|
||||
let orchestrator: SagaOrchestrator
|
||||
|
||||
beforeEach(() => {
|
||||
storage = new MemoryStorage()
|
||||
orchestrator = new SagaOrchestrator({
|
||||
storage,
|
||||
timeout: 5000,
|
||||
serverId: 'test-server',
|
||||
})
|
||||
})
|
||||
|
||||
// ========================================================================
|
||||
// 构造器测试 | Constructor Tests
|
||||
// ========================================================================
|
||||
|
||||
describe('Constructor', () => {
|
||||
it('should create with default config', () => {
|
||||
const defaultOrchestrator = new SagaOrchestrator()
|
||||
expect(defaultOrchestrator).toBeDefined()
|
||||
})
|
||||
|
||||
it('should create with custom config', () => {
|
||||
const customOrchestrator = new SagaOrchestrator({
|
||||
storage,
|
||||
timeout: 10000,
|
||||
serverId: 'custom-server',
|
||||
})
|
||||
expect(customOrchestrator).toBeDefined()
|
||||
})
|
||||
|
||||
it('should use createSagaOrchestrator factory', () => {
|
||||
const factoryOrchestrator = createSagaOrchestrator({ serverId: 'factory-server' })
|
||||
expect(factoryOrchestrator).toBeInstanceOf(SagaOrchestrator)
|
||||
})
|
||||
})
|
||||
|
||||
// ========================================================================
|
||||
// 成功执行测试 | Successful Execution Tests
|
||||
// ========================================================================
|
||||
|
||||
describe('execute() - success', () => {
|
||||
it('should execute single step saga', async () => {
|
||||
const executeLog: string[] = []
|
||||
|
||||
const steps: SagaStep<{ value: number }>[] = [
|
||||
{
|
||||
name: 'step1',
|
||||
execute: async (data) => {
|
||||
executeLog.push(`execute:${data.value}`)
|
||||
return { success: true }
|
||||
},
|
||||
compensate: async (data) => {
|
||||
executeLog.push(`compensate:${data.value}`)
|
||||
},
|
||||
data: { value: 1 },
|
||||
},
|
||||
]
|
||||
|
||||
const result = await orchestrator.execute(steps)
|
||||
|
||||
expect(result.success).toBe(true)
|
||||
expect(result.sagaId).toMatch(/^saga_/)
|
||||
expect(result.completedSteps).toEqual(['step1'])
|
||||
expect(result.duration).toBeGreaterThanOrEqual(0)
|
||||
expect(executeLog).toEqual(['execute:1'])
|
||||
})
|
||||
|
||||
it('should execute multi-step saga', async () => {
|
||||
const executeLog: string[] = []
|
||||
|
||||
const steps: SagaStep<{ name: string }>[] = [
|
||||
{
|
||||
name: 'step1',
|
||||
execute: async (data) => {
|
||||
executeLog.push(`execute:${data.name}`)
|
||||
return { success: true }
|
||||
},
|
||||
compensate: async (data) => {
|
||||
executeLog.push(`compensate:${data.name}`)
|
||||
},
|
||||
data: { name: 'A' },
|
||||
},
|
||||
{
|
||||
name: 'step2',
|
||||
execute: async (data) => {
|
||||
executeLog.push(`execute:${data.name}`)
|
||||
return { success: true }
|
||||
},
|
||||
compensate: async (data) => {
|
||||
executeLog.push(`compensate:${data.name}`)
|
||||
},
|
||||
data: { name: 'B' },
|
||||
},
|
||||
{
|
||||
name: 'step3',
|
||||
execute: async (data) => {
|
||||
executeLog.push(`execute:${data.name}`)
|
||||
return { success: true }
|
||||
},
|
||||
compensate: async (data) => {
|
||||
executeLog.push(`compensate:${data.name}`)
|
||||
},
|
||||
data: { name: 'C' },
|
||||
},
|
||||
]
|
||||
|
||||
const result = await orchestrator.execute(steps)
|
||||
|
||||
expect(result.success).toBe(true)
|
||||
expect(result.completedSteps).toEqual(['step1', 'step2', 'step3'])
|
||||
expect(executeLog).toEqual(['execute:A', 'execute:B', 'execute:C'])
|
||||
})
|
||||
|
||||
it('should save saga log on success', async () => {
|
||||
const steps: SagaStep<{}>[] = [
|
||||
{
|
||||
name: 'step1',
|
||||
execute: async () => ({ success: true }),
|
||||
compensate: async () => {},
|
||||
data: {},
|
||||
},
|
||||
]
|
||||
|
||||
const result = await orchestrator.execute(steps)
|
||||
|
||||
const log = await orchestrator.getSagaLog(result.sagaId)
|
||||
expect(log).not.toBeNull()
|
||||
expect(log?.state).toBe('completed')
|
||||
expect(log?.steps[0].state).toBe('completed')
|
||||
})
|
||||
})
|
||||
|
||||
// ========================================================================
|
||||
// 失败和补偿测试 | Failure and Compensation Tests
|
||||
// ========================================================================
|
||||
|
||||
describe('execute() - failure and compensation', () => {
|
||||
it('should compensate on step failure', async () => {
|
||||
const executeLog: string[] = []
|
||||
|
||||
const steps: SagaStep<{ name: string }>[] = [
|
||||
{
|
||||
name: 'step1',
|
||||
execute: async (data) => {
|
||||
executeLog.push(`execute:${data.name}`)
|
||||
return { success: true }
|
||||
},
|
||||
compensate: async (data) => {
|
||||
executeLog.push(`compensate:${data.name}`)
|
||||
},
|
||||
data: { name: 'A' },
|
||||
},
|
||||
{
|
||||
name: 'step2',
|
||||
execute: async (data) => {
|
||||
executeLog.push(`execute:${data.name}`)
|
||||
return { success: true }
|
||||
},
|
||||
compensate: async (data) => {
|
||||
executeLog.push(`compensate:${data.name}`)
|
||||
},
|
||||
data: { name: 'B' },
|
||||
},
|
||||
{
|
||||
name: 'step3',
|
||||
execute: async () => {
|
||||
return { success: false, error: 'Step 3 failed' }
|
||||
},
|
||||
compensate: async () => {},
|
||||
data: { name: 'C' },
|
||||
},
|
||||
]
|
||||
|
||||
const result = await orchestrator.execute(steps)
|
||||
|
||||
expect(result.success).toBe(false)
|
||||
expect(result.failedStep).toBe('step3')
|
||||
expect(result.error).toBe('Step 3 failed')
|
||||
expect(result.completedSteps).toEqual(['step1', 'step2'])
|
||||
|
||||
// Compensation should be in reverse order
|
||||
expect(executeLog).toEqual([
|
||||
'execute:A',
|
||||
'execute:B',
|
||||
'compensate:B',
|
||||
'compensate:A',
|
||||
])
|
||||
})
|
||||
|
||||
it('should save saga log on failure', async () => {
|
||||
const steps: SagaStep<{}>[] = [
|
||||
{
|
||||
name: 'step1',
|
||||
execute: async () => ({ success: true }),
|
||||
compensate: async () => {},
|
||||
data: {},
|
||||
},
|
||||
{
|
||||
name: 'step2',
|
||||
execute: async () => ({ success: false, error: 'Failed' }),
|
||||
compensate: async () => {},
|
||||
data: {},
|
||||
},
|
||||
]
|
||||
|
||||
const result = await orchestrator.execute(steps)
|
||||
|
||||
const log = await orchestrator.getSagaLog(result.sagaId)
|
||||
expect(log?.state).toBe('compensated')
|
||||
expect(log?.steps[0].state).toBe('compensated')
|
||||
expect(log?.steps[1].state).toBe('failed')
|
||||
})
|
||||
|
||||
it('should handle compensation error', async () => {
|
||||
const consoleSpy = vi.spyOn(console, 'error').mockImplementation(() => {})
|
||||
|
||||
const steps: SagaStep<{}>[] = [
|
||||
{
|
||||
name: 'step1',
|
||||
execute: async () => ({ success: true }),
|
||||
compensate: async () => {
|
||||
throw new Error('Compensation failed')
|
||||
},
|
||||
data: {},
|
||||
},
|
||||
{
|
||||
name: 'step2',
|
||||
execute: async () => ({ success: false, error: 'Failed' }),
|
||||
compensate: async () => {},
|
||||
data: {},
|
||||
},
|
||||
]
|
||||
|
||||
const result = await orchestrator.execute(steps)
|
||||
|
||||
expect(result.success).toBe(false)
|
||||
|
||||
const log = await orchestrator.getSagaLog(result.sagaId)
|
||||
expect(log?.steps[0].state).toBe('failed')
|
||||
expect(log?.steps[0].error).toContain('Compensation failed')
|
||||
|
||||
consoleSpy.mockRestore()
|
||||
})
|
||||
})
|
||||
|
||||
// ========================================================================
|
||||
// 超时测试 | Timeout Tests
|
||||
// ========================================================================
|
||||
|
||||
describe('timeout', () => {
|
||||
it('should timeout on slow saga', async () => {
|
||||
const fastOrchestrator = new SagaOrchestrator({
|
||||
storage,
|
||||
timeout: 50, // 50ms timeout
|
||||
})
|
||||
|
||||
// Timeout is checked between steps, so we need 2 steps
|
||||
const steps: SagaStep<{}>[] = [
|
||||
{
|
||||
name: 'slow-step',
|
||||
execute: async () => {
|
||||
await new Promise((resolve) => setTimeout(resolve, 100))
|
||||
return { success: true }
|
||||
},
|
||||
compensate: async () => {},
|
||||
data: {},
|
||||
},
|
||||
{
|
||||
name: 'second-step',
|
||||
execute: async () => {
|
||||
return { success: true }
|
||||
},
|
||||
compensate: async () => {},
|
||||
data: {},
|
||||
},
|
||||
]
|
||||
|
||||
const result = await fastOrchestrator.execute(steps)
|
||||
|
||||
expect(result.success).toBe(false)
|
||||
expect(result.error).toContain('timed out')
|
||||
})
|
||||
})
|
||||
|
||||
// ========================================================================
|
||||
// 分布式服务器测试 | Distributed Server Tests
|
||||
// ========================================================================
|
||||
|
||||
describe('distributed servers', () => {
|
||||
it('should track serverId for each step', async () => {
|
||||
const steps: SagaStep<{}>[] = [
|
||||
{
|
||||
name: 'step1',
|
||||
serverId: 'server-1',
|
||||
execute: async () => ({ success: true }),
|
||||
compensate: async () => {},
|
||||
data: {},
|
||||
},
|
||||
{
|
||||
name: 'step2',
|
||||
serverId: 'server-2',
|
||||
execute: async () => ({ success: true }),
|
||||
compensate: async () => {},
|
||||
data: {},
|
||||
},
|
||||
]
|
||||
|
||||
const result = await orchestrator.execute(steps)
|
||||
|
||||
const log = await orchestrator.getSagaLog(result.sagaId)
|
||||
expect(log?.steps[0].serverId).toBe('server-1')
|
||||
expect(log?.steps[1].serverId).toBe('server-2')
|
||||
})
|
||||
|
||||
it('should include orchestrator serverId in metadata', async () => {
|
||||
const steps: SagaStep<{}>[] = [
|
||||
{
|
||||
name: 'step1',
|
||||
execute: async () => ({ success: true }),
|
||||
compensate: async () => {},
|
||||
data: {},
|
||||
},
|
||||
]
|
||||
|
||||
const result = await orchestrator.execute(steps)
|
||||
|
||||
const log = await orchestrator.getSagaLog(result.sagaId)
|
||||
expect(log?.metadata?.orchestratorServerId).toBe('test-server')
|
||||
})
|
||||
})
|
||||
|
||||
// ========================================================================
|
||||
// getSagaLog 测试 | getSagaLog Tests
|
||||
// ========================================================================
|
||||
|
||||
describe('getSagaLog()', () => {
|
||||
it('should return saga log by id', async () => {
|
||||
const steps: SagaStep<{}>[] = [
|
||||
{
|
||||
name: 'step1',
|
||||
execute: async () => ({ success: true }),
|
||||
compensate: async () => {},
|
||||
data: {},
|
||||
},
|
||||
]
|
||||
|
||||
const result = await orchestrator.execute(steps)
|
||||
const log = await orchestrator.getSagaLog(result.sagaId)
|
||||
|
||||
expect(log).not.toBeNull()
|
||||
expect(log?.id).toBe(result.sagaId)
|
||||
})
|
||||
|
||||
it('should return null for non-existent saga', async () => {
|
||||
const log = await orchestrator.getSagaLog('non-existent')
|
||||
expect(log).toBeNull()
|
||||
})
|
||||
|
||||
it('should return null without storage', async () => {
|
||||
const noStorageOrchestrator = new SagaOrchestrator()
|
||||
const log = await noStorageOrchestrator.getSagaLog('any-id')
|
||||
expect(log).toBeNull()
|
||||
})
|
||||
})
|
||||
|
||||
// ========================================================================
|
||||
// 恢复测试 | Recovery Tests
|
||||
// ========================================================================
|
||||
|
||||
describe('recover()', () => {
|
||||
it('should return 0 without storage', async () => {
|
||||
const noStorageOrchestrator = new SagaOrchestrator()
|
||||
const count = await noStorageOrchestrator.recover()
|
||||
expect(count).toBe(0)
|
||||
})
|
||||
|
||||
it('should return 0 when no pending sagas', async () => {
|
||||
const count = await orchestrator.recover()
|
||||
expect(count).toBe(0)
|
||||
})
|
||||
})
|
||||
|
||||
// ========================================================================
|
||||
// 边界情况测试 | Edge Cases
|
||||
// ========================================================================
|
||||
|
||||
describe('Edge Cases', () => {
|
||||
it('should handle empty steps', async () => {
|
||||
const result = await orchestrator.execute([])
|
||||
|
||||
expect(result.success).toBe(true)
|
||||
expect(result.completedSteps).toEqual([])
|
||||
})
|
||||
|
||||
it('should handle execute throwing exception', async () => {
|
||||
const steps: SagaStep<{}>[] = [
|
||||
{
|
||||
name: 'throwing-step',
|
||||
execute: async () => {
|
||||
throw new Error('Unexpected error')
|
||||
},
|
||||
compensate: async () => {},
|
||||
data: {},
|
||||
},
|
||||
]
|
||||
|
||||
const result = await orchestrator.execute(steps)
|
||||
|
||||
expect(result.success).toBe(false)
|
||||
expect(result.error).toBe('Unexpected error')
|
||||
})
|
||||
|
||||
it('should work without storage', async () => {
|
||||
const noStorageOrchestrator = new SagaOrchestrator()
|
||||
|
||||
const steps: SagaStep<{}>[] = [
|
||||
{
|
||||
name: 'step1',
|
||||
execute: async () => ({ success: true }),
|
||||
compensate: async () => {},
|
||||
data: {},
|
||||
},
|
||||
]
|
||||
|
||||
const result = await noStorageOrchestrator.execute(steps)
|
||||
|
||||
expect(result.success).toBe(true)
|
||||
})
|
||||
|
||||
it('should track step timing', async () => {
|
||||
const steps: SagaStep<{}>[] = [
|
||||
{
|
||||
name: 'step1',
|
||||
execute: async () => {
|
||||
await new Promise((resolve) => setTimeout(resolve, 50))
|
||||
return { success: true }
|
||||
},
|
||||
compensate: async () => {},
|
||||
data: {},
|
||||
},
|
||||
]
|
||||
|
||||
const result = await orchestrator.execute(steps)
|
||||
|
||||
const log = await orchestrator.getSagaLog(result.sagaId)
|
||||
expect(log?.steps[0].startedAt).toBeGreaterThan(0)
|
||||
expect(log?.steps[0].completedAt).toBeGreaterThan(log?.steps[0].startedAt!)
|
||||
})
|
||||
})
|
||||
|
||||
// ========================================================================
|
||||
// 实际场景测试 | Real World Scenario Tests
|
||||
// ========================================================================
|
||||
|
||||
describe('Real World Scenarios', () => {
|
||||
it('should handle distributed purchase flow', async () => {
|
||||
const inventory: Map<string, number> = new Map()
|
||||
const wallet: Map<string, number> = new Map()
|
||||
|
||||
inventory.set('item-1', 10)
|
||||
wallet.set('player-1', 1000)
|
||||
|
||||
const steps: SagaStep<{ playerId: string; itemId: string; price: number }>[] = [
|
||||
{
|
||||
name: 'deduct_currency',
|
||||
serverId: 'wallet-server',
|
||||
execute: async (data) => {
|
||||
const balance = wallet.get(data.playerId) ?? 0
|
||||
if (balance < data.price) {
|
||||
return { success: false, error: 'Insufficient balance' }
|
||||
}
|
||||
wallet.set(data.playerId, balance - data.price)
|
||||
return { success: true }
|
||||
},
|
||||
compensate: async (data) => {
|
||||
const balance = wallet.get(data.playerId) ?? 0
|
||||
wallet.set(data.playerId, balance + data.price)
|
||||
},
|
||||
data: { playerId: 'player-1', itemId: 'item-1', price: 100 },
|
||||
},
|
||||
{
|
||||
name: 'reserve_item',
|
||||
serverId: 'inventory-server',
|
||||
execute: async (data) => {
|
||||
const stock = inventory.get(data.itemId) ?? 0
|
||||
if (stock < 1) {
|
||||
return { success: false, error: 'Out of stock' }
|
||||
}
|
||||
inventory.set(data.itemId, stock - 1)
|
||||
return { success: true }
|
||||
},
|
||||
compensate: async (data) => {
|
||||
const stock = inventory.get(data.itemId) ?? 0
|
||||
inventory.set(data.itemId, stock + 1)
|
||||
},
|
||||
data: { playerId: 'player-1', itemId: 'item-1', price: 100 },
|
||||
},
|
||||
]
|
||||
|
||||
const result = await orchestrator.execute(steps)
|
||||
|
||||
expect(result.success).toBe(true)
|
||||
expect(wallet.get('player-1')).toBe(900)
|
||||
expect(inventory.get('item-1')).toBe(9)
|
||||
})
|
||||
|
||||
it('should rollback distributed purchase on inventory failure', async () => {
|
||||
const wallet: Map<string, number> = new Map()
|
||||
const inventory: Map<string, number> = new Map()
|
||||
|
||||
wallet.set('player-1', 1000)
|
||||
inventory.set('item-1', 0) // Out of stock
|
||||
|
||||
const steps: SagaStep<{ playerId: string; itemId: string; price: number }>[] = [
|
||||
{
|
||||
name: 'deduct_currency',
|
||||
execute: async (data) => {
|
||||
const balance = wallet.get(data.playerId) ?? 0
|
||||
wallet.set(data.playerId, balance - data.price)
|
||||
return { success: true }
|
||||
},
|
||||
compensate: async (data) => {
|
||||
const balance = wallet.get(data.playerId) ?? 0
|
||||
wallet.set(data.playerId, balance + data.price)
|
||||
},
|
||||
data: { playerId: 'player-1', itemId: 'item-1', price: 100 },
|
||||
},
|
||||
{
|
||||
name: 'reserve_item',
|
||||
execute: async (data) => {
|
||||
const stock = inventory.get(data.itemId) ?? 0
|
||||
if (stock < 1) {
|
||||
return { success: false, error: 'Out of stock' }
|
||||
}
|
||||
inventory.set(data.itemId, stock - 1)
|
||||
return { success: true }
|
||||
},
|
||||
compensate: async (data) => {
|
||||
const stock = inventory.get(data.itemId) ?? 0
|
||||
inventory.set(data.itemId, stock + 1)
|
||||
},
|
||||
data: { playerId: 'player-1', itemId: 'item-1', price: 100 },
|
||||
},
|
||||
]
|
||||
|
||||
const result = await orchestrator.execute(steps)
|
||||
|
||||
expect(result.success).toBe(false)
|
||||
expect(result.error).toBe('Out of stock')
|
||||
expect(wallet.get('player-1')).toBe(1000) // Restored
|
||||
expect(inventory.get('item-1')).toBe(0) // Unchanged
|
||||
})
|
||||
})
|
||||
})
|
||||
@@ -0,0 +1,480 @@
|
||||
/**
|
||||
* @zh CurrencyOperation 单元测试
|
||||
* @en CurrencyOperation unit tests
|
||||
*/
|
||||
|
||||
import { describe, it, expect, beforeEach } from 'vitest'
|
||||
import { CurrencyOperation, createCurrencyOperation, type ICurrencyProvider } from '../../src/operations/CurrencyOperation.js'
|
||||
import { TransactionContext } from '../../src/core/TransactionContext.js'
|
||||
import { MemoryStorage } from '../../src/storage/MemoryStorage.js'
|
||||
import type { ITransactionContext } from '../../src/core/types.js'
|
||||
|
||||
// ============================================================================
|
||||
// Mock Provider | 模拟数据提供者
|
||||
// ============================================================================
|
||||
|
||||
class MockCurrencyProvider implements ICurrencyProvider {
|
||||
private _balances: Map<string, Map<string, number>> = new Map()
|
||||
|
||||
setInitialBalance(playerId: string, currency: string, amount: number): void {
|
||||
if (!this._balances.has(playerId)) {
|
||||
this._balances.set(playerId, new Map())
|
||||
}
|
||||
this._balances.get(playerId)!.set(currency, amount)
|
||||
}
|
||||
|
||||
async getBalance(playerId: string, currency: string): Promise<number> {
|
||||
return this._balances.get(playerId)?.get(currency) ?? 0
|
||||
}
|
||||
|
||||
async setBalance(playerId: string, currency: string, amount: number): Promise<void> {
|
||||
if (!this._balances.has(playerId)) {
|
||||
this._balances.set(playerId, new Map())
|
||||
}
|
||||
this._balances.get(playerId)!.set(currency, amount)
|
||||
}
|
||||
}
|
||||
|
||||
// ============================================================================
|
||||
// Test Suite | 测试套件
|
||||
// ============================================================================
|
||||
|
||||
describe('CurrencyOperation', () => {
|
||||
let storage: MemoryStorage
|
||||
let ctx: ITransactionContext
|
||||
|
||||
beforeEach(() => {
|
||||
storage = new MemoryStorage()
|
||||
ctx = new TransactionContext({ storage })
|
||||
})
|
||||
|
||||
// ========================================================================
|
||||
// 构造器测试 | Constructor Tests
|
||||
// ========================================================================
|
||||
|
||||
describe('Constructor', () => {
|
||||
it('should create with data', () => {
|
||||
const op = new CurrencyOperation({
|
||||
type: 'add',
|
||||
playerId: 'player-1',
|
||||
currency: 'gold',
|
||||
amount: 100,
|
||||
})
|
||||
|
||||
expect(op.name).toBe('currency')
|
||||
expect(op.data.type).toBe('add')
|
||||
expect(op.data.playerId).toBe('player-1')
|
||||
expect(op.data.currency).toBe('gold')
|
||||
expect(op.data.amount).toBe(100)
|
||||
})
|
||||
|
||||
it('should use createCurrencyOperation factory', () => {
|
||||
const op = createCurrencyOperation({
|
||||
type: 'deduct',
|
||||
playerId: 'player-2',
|
||||
currency: 'diamond',
|
||||
amount: 50,
|
||||
})
|
||||
|
||||
expect(op).toBeInstanceOf(CurrencyOperation)
|
||||
expect(op.data.type).toBe('deduct')
|
||||
})
|
||||
})
|
||||
|
||||
// ========================================================================
|
||||
// 验证测试 | Validation Tests
|
||||
// ========================================================================
|
||||
|
||||
describe('validate()', () => {
|
||||
it('should fail validation with zero amount', async () => {
|
||||
const op = new CurrencyOperation({
|
||||
type: 'add',
|
||||
playerId: 'player-1',
|
||||
currency: 'gold',
|
||||
amount: 0,
|
||||
})
|
||||
|
||||
const isValid = await op.validate(ctx)
|
||||
expect(isValid).toBe(false)
|
||||
})
|
||||
|
||||
it('should fail validation with negative amount', async () => {
|
||||
const op = new CurrencyOperation({
|
||||
type: 'add',
|
||||
playerId: 'player-1',
|
||||
currency: 'gold',
|
||||
amount: -10,
|
||||
})
|
||||
|
||||
const isValid = await op.validate(ctx)
|
||||
expect(isValid).toBe(false)
|
||||
})
|
||||
|
||||
it('should pass validation for add with positive amount', async () => {
|
||||
const op = new CurrencyOperation({
|
||||
type: 'add',
|
||||
playerId: 'player-1',
|
||||
currency: 'gold',
|
||||
amount: 100,
|
||||
})
|
||||
|
||||
const isValid = await op.validate(ctx)
|
||||
expect(isValid).toBe(true)
|
||||
})
|
||||
|
||||
it('should fail validation for deduct with insufficient balance', async () => {
|
||||
await storage.set('player:player-1:currency:gold', 50)
|
||||
|
||||
const op = new CurrencyOperation({
|
||||
type: 'deduct',
|
||||
playerId: 'player-1',
|
||||
currency: 'gold',
|
||||
amount: 100,
|
||||
})
|
||||
|
||||
const isValid = await op.validate(ctx)
|
||||
expect(isValid).toBe(false)
|
||||
})
|
||||
|
||||
it('should pass validation for deduct with sufficient balance', async () => {
|
||||
await storage.set('player:player-1:currency:gold', 150)
|
||||
|
||||
const op = new CurrencyOperation({
|
||||
type: 'deduct',
|
||||
playerId: 'player-1',
|
||||
currency: 'gold',
|
||||
amount: 100,
|
||||
})
|
||||
|
||||
const isValid = await op.validate(ctx)
|
||||
expect(isValid).toBe(true)
|
||||
})
|
||||
|
||||
it('should use provider for validation', async () => {
|
||||
const provider = new MockCurrencyProvider()
|
||||
provider.setInitialBalance('player-1', 'gold', 200)
|
||||
|
||||
const op = new CurrencyOperation({
|
||||
type: 'deduct',
|
||||
playerId: 'player-1',
|
||||
currency: 'gold',
|
||||
amount: 150,
|
||||
}).setProvider(provider)
|
||||
|
||||
const isValid = await op.validate(ctx)
|
||||
expect(isValid).toBe(true)
|
||||
})
|
||||
})
|
||||
|
||||
// ========================================================================
|
||||
// 执行测试 - 增加货币 | Execute Tests - Add Currency
|
||||
// ========================================================================
|
||||
|
||||
describe('execute() - add', () => {
|
||||
it('should add currency to empty balance', async () => {
|
||||
const op = new CurrencyOperation({
|
||||
type: 'add',
|
||||
playerId: 'player-1',
|
||||
currency: 'gold',
|
||||
amount: 100,
|
||||
})
|
||||
|
||||
const result = await op.execute(ctx)
|
||||
|
||||
expect(result.success).toBe(true)
|
||||
expect(result.data?.beforeBalance).toBe(0)
|
||||
expect(result.data?.afterBalance).toBe(100)
|
||||
|
||||
const balance = await storage.get<number>('player:player-1:currency:gold')
|
||||
expect(balance).toBe(100)
|
||||
})
|
||||
|
||||
it('should add currency to existing balance', async () => {
|
||||
await storage.set('player:player-1:currency:gold', 50)
|
||||
|
||||
const op = new CurrencyOperation({
|
||||
type: 'add',
|
||||
playerId: 'player-1',
|
||||
currency: 'gold',
|
||||
amount: 100,
|
||||
})
|
||||
|
||||
const result = await op.execute(ctx)
|
||||
|
||||
expect(result.success).toBe(true)
|
||||
expect(result.data?.beforeBalance).toBe(50)
|
||||
expect(result.data?.afterBalance).toBe(150)
|
||||
})
|
||||
|
||||
it('should store context data for verification', async () => {
|
||||
const op = new CurrencyOperation({
|
||||
type: 'add',
|
||||
playerId: 'player-1',
|
||||
currency: 'gold',
|
||||
amount: 100,
|
||||
})
|
||||
|
||||
await op.execute(ctx)
|
||||
|
||||
expect(ctx.get('currency:player-1:gold:before')).toBe(0)
|
||||
expect(ctx.get('currency:player-1:gold:after')).toBe(100)
|
||||
})
|
||||
})
|
||||
|
||||
// ========================================================================
|
||||
// 执行测试 - 扣除货币 | Execute Tests - Deduct Currency
|
||||
// ========================================================================
|
||||
|
||||
describe('execute() - deduct', () => {
|
||||
it('should deduct currency from balance', async () => {
|
||||
await storage.set('player:player-1:currency:gold', 200)
|
||||
|
||||
const op = new CurrencyOperation({
|
||||
type: 'deduct',
|
||||
playerId: 'player-1',
|
||||
currency: 'gold',
|
||||
amount: 75,
|
||||
})
|
||||
|
||||
const result = await op.execute(ctx)
|
||||
|
||||
expect(result.success).toBe(true)
|
||||
expect(result.data?.beforeBalance).toBe(200)
|
||||
expect(result.data?.afterBalance).toBe(125)
|
||||
|
||||
const balance = await storage.get<number>('player:player-1:currency:gold')
|
||||
expect(balance).toBe(125)
|
||||
})
|
||||
|
||||
it('should fail deduct with insufficient balance', async () => {
|
||||
await storage.set('player:player-1:currency:gold', 50)
|
||||
|
||||
const op = new CurrencyOperation({
|
||||
type: 'deduct',
|
||||
playerId: 'player-1',
|
||||
currency: 'gold',
|
||||
amount: 100,
|
||||
})
|
||||
|
||||
const result = await op.execute(ctx)
|
||||
|
||||
expect(result.success).toBe(false)
|
||||
expect(result.error).toBe('Insufficient balance')
|
||||
expect(result.errorCode).toBe('INSUFFICIENT_BALANCE')
|
||||
})
|
||||
|
||||
it('should deduct exact balance', async () => {
|
||||
await storage.set('player:player-1:currency:gold', 100)
|
||||
|
||||
const op = new CurrencyOperation({
|
||||
type: 'deduct',
|
||||
playerId: 'player-1',
|
||||
currency: 'gold',
|
||||
amount: 100,
|
||||
})
|
||||
|
||||
const result = await op.execute(ctx)
|
||||
|
||||
expect(result.success).toBe(true)
|
||||
expect(result.data?.afterBalance).toBe(0)
|
||||
})
|
||||
})
|
||||
|
||||
// ========================================================================
|
||||
// 补偿测试 | Compensate Tests
|
||||
// ========================================================================
|
||||
|
||||
describe('compensate()', () => {
|
||||
it('should restore balance after add', async () => {
|
||||
const op = new CurrencyOperation({
|
||||
type: 'add',
|
||||
playerId: 'player-1',
|
||||
currency: 'gold',
|
||||
amount: 100,
|
||||
})
|
||||
|
||||
await op.execute(ctx)
|
||||
expect(await storage.get('player:player-1:currency:gold')).toBe(100)
|
||||
|
||||
await op.compensate(ctx)
|
||||
expect(await storage.get('player:player-1:currency:gold')).toBe(0)
|
||||
})
|
||||
|
||||
it('should restore balance after deduct', async () => {
|
||||
await storage.set('player:player-1:currency:gold', 200)
|
||||
|
||||
const op = new CurrencyOperation({
|
||||
type: 'deduct',
|
||||
playerId: 'player-1',
|
||||
currency: 'gold',
|
||||
amount: 75,
|
||||
})
|
||||
|
||||
await op.execute(ctx)
|
||||
expect(await storage.get('player:player-1:currency:gold')).toBe(125)
|
||||
|
||||
await op.compensate(ctx)
|
||||
expect(await storage.get('player:player-1:currency:gold')).toBe(200)
|
||||
})
|
||||
})
|
||||
|
||||
// ========================================================================
|
||||
// Provider 测试 | Provider Tests
|
||||
// ========================================================================
|
||||
|
||||
describe('Provider', () => {
|
||||
it('should use provider for operations', async () => {
|
||||
const provider = new MockCurrencyProvider()
|
||||
provider.setInitialBalance('player-1', 'gold', 1000)
|
||||
|
||||
const op = new CurrencyOperation({
|
||||
type: 'deduct',
|
||||
playerId: 'player-1',
|
||||
currency: 'gold',
|
||||
amount: 300,
|
||||
}).setProvider(provider)
|
||||
|
||||
const result = await op.execute(ctx)
|
||||
|
||||
expect(result.success).toBe(true)
|
||||
expect(result.data?.beforeBalance).toBe(1000)
|
||||
expect(result.data?.afterBalance).toBe(700)
|
||||
|
||||
const newBalance = await provider.getBalance('player-1', 'gold')
|
||||
expect(newBalance).toBe(700)
|
||||
})
|
||||
|
||||
it('should compensate using provider', async () => {
|
||||
const provider = new MockCurrencyProvider()
|
||||
provider.setInitialBalance('player-1', 'gold', 500)
|
||||
|
||||
const op = new CurrencyOperation({
|
||||
type: 'add',
|
||||
playerId: 'player-1',
|
||||
currency: 'gold',
|
||||
amount: 200,
|
||||
}).setProvider(provider)
|
||||
|
||||
await op.execute(ctx)
|
||||
expect(await provider.getBalance('player-1', 'gold')).toBe(700)
|
||||
|
||||
await op.compensate(ctx)
|
||||
expect(await provider.getBalance('player-1', 'gold')).toBe(500)
|
||||
})
|
||||
|
||||
it('should support method chaining with setProvider', () => {
|
||||
const provider = new MockCurrencyProvider()
|
||||
const op = new CurrencyOperation({
|
||||
type: 'add',
|
||||
playerId: 'player-1',
|
||||
currency: 'gold',
|
||||
amount: 100,
|
||||
})
|
||||
|
||||
const result = op.setProvider(provider)
|
||||
expect(result).toBe(op)
|
||||
})
|
||||
})
|
||||
|
||||
// ========================================================================
|
||||
// 多货币类型测试 | Multiple Currency Types Tests
|
||||
// ========================================================================
|
||||
|
||||
describe('Multiple Currency Types', () => {
|
||||
it('should handle different currency types independently', async () => {
|
||||
await storage.set('player:player-1:currency:gold', 1000)
|
||||
await storage.set('player:player-1:currency:diamond', 50)
|
||||
|
||||
const goldOp = new CurrencyOperation({
|
||||
type: 'deduct',
|
||||
playerId: 'player-1',
|
||||
currency: 'gold',
|
||||
amount: 500,
|
||||
})
|
||||
|
||||
const diamondOp = new CurrencyOperation({
|
||||
type: 'add',
|
||||
playerId: 'player-1',
|
||||
currency: 'diamond',
|
||||
amount: 10,
|
||||
})
|
||||
|
||||
await goldOp.execute(ctx)
|
||||
await diamondOp.execute(ctx)
|
||||
|
||||
expect(await storage.get('player:player-1:currency:gold')).toBe(500)
|
||||
expect(await storage.get('player:player-1:currency:diamond')).toBe(60)
|
||||
})
|
||||
|
||||
it('should handle multiple players independently', async () => {
|
||||
await storage.set('player:player-1:currency:gold', 1000)
|
||||
await storage.set('player:player-2:currency:gold', 500)
|
||||
|
||||
const op1 = new CurrencyOperation({
|
||||
type: 'deduct',
|
||||
playerId: 'player-1',
|
||||
currency: 'gold',
|
||||
amount: 300,
|
||||
})
|
||||
|
||||
const op2 = new CurrencyOperation({
|
||||
type: 'add',
|
||||
playerId: 'player-2',
|
||||
currency: 'gold',
|
||||
amount: 300,
|
||||
})
|
||||
|
||||
await op1.execute(ctx)
|
||||
await op2.execute(ctx)
|
||||
|
||||
expect(await storage.get('player:player-1:currency:gold')).toBe(700)
|
||||
expect(await storage.get('player:player-2:currency:gold')).toBe(800)
|
||||
})
|
||||
})
|
||||
|
||||
// ========================================================================
|
||||
// 边界情况测试 | Edge Cases
|
||||
// ========================================================================
|
||||
|
||||
describe('Edge Cases', () => {
|
||||
it('should handle zero balance for new player', async () => {
|
||||
const op = new CurrencyOperation({
|
||||
type: 'add',
|
||||
playerId: 'new-player',
|
||||
currency: 'gold',
|
||||
amount: 100,
|
||||
})
|
||||
|
||||
const result = await op.execute(ctx)
|
||||
expect(result.data?.beforeBalance).toBe(0)
|
||||
})
|
||||
|
||||
it('should handle context without storage', async () => {
|
||||
const noStorageCtx = new TransactionContext()
|
||||
|
||||
const op = new CurrencyOperation({
|
||||
type: 'add',
|
||||
playerId: 'player-1',
|
||||
currency: 'gold',
|
||||
amount: 100,
|
||||
})
|
||||
|
||||
const result = await op.execute(noStorageCtx)
|
||||
expect(result.success).toBe(true)
|
||||
expect(result.data?.beforeBalance).toBe(0)
|
||||
expect(result.data?.afterBalance).toBe(100)
|
||||
})
|
||||
|
||||
it('should include reason in data', () => {
|
||||
const op = new CurrencyOperation({
|
||||
type: 'deduct',
|
||||
playerId: 'player-1',
|
||||
currency: 'gold',
|
||||
amount: 100,
|
||||
reason: 'purchase_item',
|
||||
})
|
||||
|
||||
expect(op.data.reason).toBe('purchase_item')
|
||||
})
|
||||
})
|
||||
})
|
||||
@@ -0,0 +1,624 @@
|
||||
/**
|
||||
* @zh InventoryOperation 单元测试
|
||||
* @en InventoryOperation unit tests
|
||||
*/
|
||||
|
||||
import { describe, it, expect, beforeEach } from 'vitest'
|
||||
import {
|
||||
InventoryOperation,
|
||||
createInventoryOperation,
|
||||
type IInventoryProvider,
|
||||
type ItemData,
|
||||
} from '../../src/operations/InventoryOperation.js'
|
||||
import { TransactionContext } from '../../src/core/TransactionContext.js'
|
||||
import { MemoryStorage } from '../../src/storage/MemoryStorage.js'
|
||||
import type { ITransactionContext } from '../../src/core/types.js'
|
||||
|
||||
// ============================================================================
|
||||
// Mock Provider | 模拟数据提供者
|
||||
// ============================================================================
|
||||
|
||||
class MockInventoryProvider implements IInventoryProvider {
|
||||
private _inventory: Map<string, Map<string, ItemData>> = new Map()
|
||||
private _capacity: Map<string, number> = new Map()
|
||||
|
||||
addItem(playerId: string, itemId: string, item: ItemData): void {
|
||||
if (!this._inventory.has(playerId)) {
|
||||
this._inventory.set(playerId, new Map())
|
||||
}
|
||||
this._inventory.get(playerId)!.set(itemId, item)
|
||||
}
|
||||
|
||||
setCapacity(playerId: string, capacity: number): void {
|
||||
this._capacity.set(playerId, capacity)
|
||||
}
|
||||
|
||||
async getItem(playerId: string, itemId: string): Promise<ItemData | null> {
|
||||
return this._inventory.get(playerId)?.get(itemId) ?? null
|
||||
}
|
||||
|
||||
async setItem(playerId: string, itemId: string, item: ItemData | null): Promise<void> {
|
||||
if (!this._inventory.has(playerId)) {
|
||||
this._inventory.set(playerId, new Map())
|
||||
}
|
||||
if (item) {
|
||||
this._inventory.get(playerId)!.set(itemId, item)
|
||||
} else {
|
||||
this._inventory.get(playerId)!.delete(itemId)
|
||||
}
|
||||
}
|
||||
|
||||
async hasCapacity(playerId: string, count: number): Promise<boolean> {
|
||||
const capacity = this._capacity.get(playerId)
|
||||
if (capacity === undefined) return true
|
||||
const currentCount = this._inventory.get(playerId)?.size ?? 0
|
||||
return currentCount + count <= capacity
|
||||
}
|
||||
}
|
||||
|
||||
// ============================================================================
|
||||
// Test Suite | 测试套件
|
||||
// ============================================================================
|
||||
|
||||
describe('InventoryOperation', () => {
|
||||
let storage: MemoryStorage
|
||||
let ctx: ITransactionContext
|
||||
|
||||
beforeEach(() => {
|
||||
storage = new MemoryStorage()
|
||||
ctx = new TransactionContext({ storage })
|
||||
})
|
||||
|
||||
// ========================================================================
|
||||
// 构造器测试 | Constructor Tests
|
||||
// ========================================================================
|
||||
|
||||
describe('Constructor', () => {
|
||||
it('should create with data', () => {
|
||||
const op = new InventoryOperation({
|
||||
type: 'add',
|
||||
playerId: 'player-1',
|
||||
itemId: 'sword-001',
|
||||
quantity: 1,
|
||||
})
|
||||
|
||||
expect(op.name).toBe('inventory')
|
||||
expect(op.data.type).toBe('add')
|
||||
expect(op.data.playerId).toBe('player-1')
|
||||
expect(op.data.itemId).toBe('sword-001')
|
||||
expect(op.data.quantity).toBe(1)
|
||||
})
|
||||
|
||||
it('should use createInventoryOperation factory', () => {
|
||||
const op = createInventoryOperation({
|
||||
type: 'remove',
|
||||
playerId: 'player-2',
|
||||
itemId: 'potion-hp',
|
||||
quantity: 5,
|
||||
})
|
||||
|
||||
expect(op).toBeInstanceOf(InventoryOperation)
|
||||
expect(op.data.type).toBe('remove')
|
||||
})
|
||||
})
|
||||
|
||||
// ========================================================================
|
||||
// 验证测试 | Validation Tests
|
||||
// ========================================================================
|
||||
|
||||
describe('validate()', () => {
|
||||
it('should fail validation with zero quantity', async () => {
|
||||
const op = new InventoryOperation({
|
||||
type: 'add',
|
||||
playerId: 'player-1',
|
||||
itemId: 'sword',
|
||||
quantity: 0,
|
||||
})
|
||||
|
||||
const isValid = await op.validate(ctx)
|
||||
expect(isValid).toBe(false)
|
||||
})
|
||||
|
||||
it('should fail validation with negative quantity', async () => {
|
||||
const op = new InventoryOperation({
|
||||
type: 'add',
|
||||
playerId: 'player-1',
|
||||
itemId: 'sword',
|
||||
quantity: -1,
|
||||
})
|
||||
|
||||
const isValid = await op.validate(ctx)
|
||||
expect(isValid).toBe(false)
|
||||
})
|
||||
|
||||
it('should pass validation for add with positive quantity', async () => {
|
||||
const op = new InventoryOperation({
|
||||
type: 'add',
|
||||
playerId: 'player-1',
|
||||
itemId: 'sword',
|
||||
quantity: 1,
|
||||
})
|
||||
|
||||
const isValid = await op.validate(ctx)
|
||||
expect(isValid).toBe(true)
|
||||
})
|
||||
|
||||
it('should fail validation for remove with insufficient quantity', async () => {
|
||||
await storage.set('player:player-1:inventory:sword', {
|
||||
itemId: 'sword',
|
||||
quantity: 2,
|
||||
})
|
||||
|
||||
const op = new InventoryOperation({
|
||||
type: 'remove',
|
||||
playerId: 'player-1',
|
||||
itemId: 'sword',
|
||||
quantity: 5,
|
||||
})
|
||||
|
||||
const isValid = await op.validate(ctx)
|
||||
expect(isValid).toBe(false)
|
||||
})
|
||||
|
||||
it('should fail validation for remove with non-existent item', async () => {
|
||||
const op = new InventoryOperation({
|
||||
type: 'remove',
|
||||
playerId: 'player-1',
|
||||
itemId: 'nonexistent',
|
||||
quantity: 1,
|
||||
})
|
||||
|
||||
const isValid = await op.validate(ctx)
|
||||
expect(isValid).toBe(false)
|
||||
})
|
||||
|
||||
it('should pass validation for remove with sufficient quantity', async () => {
|
||||
await storage.set('player:player-1:inventory:sword', {
|
||||
itemId: 'sword',
|
||||
quantity: 10,
|
||||
})
|
||||
|
||||
const op = new InventoryOperation({
|
||||
type: 'remove',
|
||||
playerId: 'player-1',
|
||||
itemId: 'sword',
|
||||
quantity: 5,
|
||||
})
|
||||
|
||||
const isValid = await op.validate(ctx)
|
||||
expect(isValid).toBe(true)
|
||||
})
|
||||
|
||||
it('should check capacity with provider', async () => {
|
||||
const provider = new MockInventoryProvider()
|
||||
provider.setCapacity('player-1', 1)
|
||||
provider.addItem('player-1', 'existing', { itemId: 'existing', quantity: 1 })
|
||||
|
||||
const op = new InventoryOperation({
|
||||
type: 'add',
|
||||
playerId: 'player-1',
|
||||
itemId: 'new-item',
|
||||
quantity: 1,
|
||||
}).setProvider(provider)
|
||||
|
||||
const isValid = await op.validate(ctx)
|
||||
expect(isValid).toBe(false)
|
||||
})
|
||||
})
|
||||
|
||||
// ========================================================================
|
||||
// 执行测试 - 添加物品 | Execute Tests - Add Item
|
||||
// ========================================================================
|
||||
|
||||
describe('execute() - add', () => {
|
||||
it('should add new item to empty inventory', async () => {
|
||||
const op = new InventoryOperation({
|
||||
type: 'add',
|
||||
playerId: 'player-1',
|
||||
itemId: 'sword',
|
||||
quantity: 1,
|
||||
})
|
||||
|
||||
const result = await op.execute(ctx)
|
||||
|
||||
expect(result.success).toBe(true)
|
||||
expect(result.data?.beforeItem).toBeUndefined()
|
||||
expect(result.data?.afterItem).toEqual({
|
||||
itemId: 'sword',
|
||||
quantity: 1,
|
||||
properties: undefined,
|
||||
})
|
||||
|
||||
const item = await storage.get<ItemData>('player:player-1:inventory:sword')
|
||||
expect(item?.quantity).toBe(1)
|
||||
})
|
||||
|
||||
it('should stack items when adding to existing', async () => {
|
||||
await storage.set('player:player-1:inventory:potion', {
|
||||
itemId: 'potion',
|
||||
quantity: 5,
|
||||
})
|
||||
|
||||
const op = new InventoryOperation({
|
||||
type: 'add',
|
||||
playerId: 'player-1',
|
||||
itemId: 'potion',
|
||||
quantity: 3,
|
||||
})
|
||||
|
||||
const result = await op.execute(ctx)
|
||||
|
||||
expect(result.success).toBe(true)
|
||||
expect(result.data?.beforeItem?.quantity).toBe(5)
|
||||
expect(result.data?.afterItem?.quantity).toBe(8)
|
||||
})
|
||||
|
||||
it('should add item with properties', async () => {
|
||||
const op = new InventoryOperation({
|
||||
type: 'add',
|
||||
playerId: 'player-1',
|
||||
itemId: 'enchanted-sword',
|
||||
quantity: 1,
|
||||
properties: { damage: 100, enchant: 'fire' },
|
||||
})
|
||||
|
||||
const result = await op.execute(ctx)
|
||||
|
||||
expect(result.success).toBe(true)
|
||||
expect(result.data?.afterItem?.properties).toEqual({
|
||||
damage: 100,
|
||||
enchant: 'fire',
|
||||
})
|
||||
})
|
||||
|
||||
it('should store context data', async () => {
|
||||
const op = new InventoryOperation({
|
||||
type: 'add',
|
||||
playerId: 'player-1',
|
||||
itemId: 'sword',
|
||||
quantity: 1,
|
||||
})
|
||||
|
||||
await op.execute(ctx)
|
||||
|
||||
expect(ctx.get('inventory:player-1:sword:before')).toBeNull()
|
||||
expect(ctx.get('inventory:player-1:sword:after')).toEqual({
|
||||
itemId: 'sword',
|
||||
quantity: 1,
|
||||
properties: undefined,
|
||||
})
|
||||
})
|
||||
})
|
||||
|
||||
// ========================================================================
|
||||
// 执行测试 - 移除物品 | Execute Tests - Remove Item
|
||||
// ========================================================================
|
||||
|
||||
describe('execute() - remove', () => {
|
||||
it('should remove partial quantity', async () => {
|
||||
await storage.set('player:player-1:inventory:potion', {
|
||||
itemId: 'potion',
|
||||
quantity: 10,
|
||||
})
|
||||
|
||||
const op = new InventoryOperation({
|
||||
type: 'remove',
|
||||
playerId: 'player-1',
|
||||
itemId: 'potion',
|
||||
quantity: 3,
|
||||
})
|
||||
|
||||
const result = await op.execute(ctx)
|
||||
|
||||
expect(result.success).toBe(true)
|
||||
expect(result.data?.beforeItem?.quantity).toBe(10)
|
||||
expect(result.data?.afterItem?.quantity).toBe(7)
|
||||
|
||||
const item = await storage.get<ItemData>('player:player-1:inventory:potion')
|
||||
expect(item?.quantity).toBe(7)
|
||||
})
|
||||
|
||||
it('should delete item when removing all quantity', async () => {
|
||||
await storage.set('player:player-1:inventory:sword', {
|
||||
itemId: 'sword',
|
||||
quantity: 1,
|
||||
})
|
||||
|
||||
const op = new InventoryOperation({
|
||||
type: 'remove',
|
||||
playerId: 'player-1',
|
||||
itemId: 'sword',
|
||||
quantity: 1,
|
||||
})
|
||||
|
||||
const result = await op.execute(ctx)
|
||||
|
||||
expect(result.success).toBe(true)
|
||||
expect(result.data?.afterItem).toBeUndefined()
|
||||
|
||||
const item = await storage.get('player:player-1:inventory:sword')
|
||||
expect(item).toBeNull()
|
||||
})
|
||||
|
||||
it('should fail when item not found', async () => {
|
||||
const op = new InventoryOperation({
|
||||
type: 'remove',
|
||||
playerId: 'player-1',
|
||||
itemId: 'nonexistent',
|
||||
quantity: 1,
|
||||
})
|
||||
|
||||
const result = await op.execute(ctx)
|
||||
|
||||
expect(result.success).toBe(false)
|
||||
expect(result.error).toBe('Insufficient item quantity')
|
||||
expect(result.errorCode).toBe('INSUFFICIENT_ITEM')
|
||||
})
|
||||
|
||||
it('should fail when quantity insufficient', async () => {
|
||||
await storage.set('player:player-1:inventory:potion', {
|
||||
itemId: 'potion',
|
||||
quantity: 2,
|
||||
})
|
||||
|
||||
const op = new InventoryOperation({
|
||||
type: 'remove',
|
||||
playerId: 'player-1',
|
||||
itemId: 'potion',
|
||||
quantity: 5,
|
||||
})
|
||||
|
||||
const result = await op.execute(ctx)
|
||||
|
||||
expect(result.success).toBe(false)
|
||||
expect(result.errorCode).toBe('INSUFFICIENT_ITEM')
|
||||
})
|
||||
})
|
||||
|
||||
// ========================================================================
|
||||
// 执行测试 - 更新物品 | Execute Tests - Update Item
|
||||
// ========================================================================
|
||||
|
||||
describe('execute() - update', () => {
|
||||
it('should update item properties', async () => {
|
||||
await storage.set('player:player-1:inventory:sword', {
|
||||
itemId: 'sword',
|
||||
quantity: 1,
|
||||
properties: { damage: 10 },
|
||||
})
|
||||
|
||||
const op = new InventoryOperation({
|
||||
type: 'update',
|
||||
playerId: 'player-1',
|
||||
itemId: 'sword',
|
||||
quantity: 0, // keep existing
|
||||
properties: { damage: 20, enchant: 'ice' },
|
||||
})
|
||||
|
||||
const result = await op.execute(ctx)
|
||||
|
||||
expect(result.success).toBe(true)
|
||||
expect(result.data?.afterItem?.properties).toEqual({
|
||||
damage: 20,
|
||||
enchant: 'ice',
|
||||
})
|
||||
expect(result.data?.afterItem?.quantity).toBe(1)
|
||||
})
|
||||
|
||||
it('should update item quantity', async () => {
|
||||
await storage.set('player:player-1:inventory:potion', {
|
||||
itemId: 'potion',
|
||||
quantity: 5,
|
||||
})
|
||||
|
||||
const op = new InventoryOperation({
|
||||
type: 'update',
|
||||
playerId: 'player-1',
|
||||
itemId: 'potion',
|
||||
quantity: 10,
|
||||
})
|
||||
|
||||
const result = await op.execute(ctx)
|
||||
|
||||
expect(result.success).toBe(true)
|
||||
expect(result.data?.afterItem?.quantity).toBe(10)
|
||||
})
|
||||
|
||||
it('should fail when updating non-existent item', async () => {
|
||||
const op = new InventoryOperation({
|
||||
type: 'update',
|
||||
playerId: 'player-1',
|
||||
itemId: 'nonexistent',
|
||||
quantity: 1,
|
||||
})
|
||||
|
||||
const result = await op.execute(ctx)
|
||||
|
||||
expect(result.success).toBe(false)
|
||||
expect(result.error).toBe('Item not found')
|
||||
expect(result.errorCode).toBe('ITEM_NOT_FOUND')
|
||||
})
|
||||
})
|
||||
|
||||
// ========================================================================
|
||||
// 补偿测试 | Compensate Tests
|
||||
// ========================================================================
|
||||
|
||||
describe('compensate()', () => {
|
||||
it('should restore state after add', async () => {
|
||||
const op = new InventoryOperation({
|
||||
type: 'add',
|
||||
playerId: 'player-1',
|
||||
itemId: 'sword',
|
||||
quantity: 1,
|
||||
})
|
||||
|
||||
await op.execute(ctx)
|
||||
expect(await storage.get('player:player-1:inventory:sword')).not.toBeNull()
|
||||
|
||||
await op.compensate(ctx)
|
||||
expect(await storage.get('player:player-1:inventory:sword')).toBeNull()
|
||||
})
|
||||
|
||||
it('should restore state after remove', async () => {
|
||||
await storage.set('player:player-1:inventory:potion', {
|
||||
itemId: 'potion',
|
||||
quantity: 5,
|
||||
})
|
||||
|
||||
const op = new InventoryOperation({
|
||||
type: 'remove',
|
||||
playerId: 'player-1',
|
||||
itemId: 'potion',
|
||||
quantity: 3,
|
||||
})
|
||||
|
||||
await op.execute(ctx)
|
||||
const afterRemove = await storage.get<ItemData>('player:player-1:inventory:potion')
|
||||
expect(afterRemove?.quantity).toBe(2)
|
||||
|
||||
await op.compensate(ctx)
|
||||
const afterCompensate = await storage.get<ItemData>('player:player-1:inventory:potion')
|
||||
expect(afterCompensate?.quantity).toBe(5)
|
||||
})
|
||||
|
||||
it('should restore deleted item after remove all', async () => {
|
||||
await storage.set('player:player-1:inventory:sword', {
|
||||
itemId: 'sword',
|
||||
quantity: 1,
|
||||
})
|
||||
|
||||
const op = new InventoryOperation({
|
||||
type: 'remove',
|
||||
playerId: 'player-1',
|
||||
itemId: 'sword',
|
||||
quantity: 1,
|
||||
})
|
||||
|
||||
await op.execute(ctx)
|
||||
expect(await storage.get('player:player-1:inventory:sword')).toBeNull()
|
||||
|
||||
await op.compensate(ctx)
|
||||
const restored = await storage.get<ItemData>('player:player-1:inventory:sword')
|
||||
expect(restored?.quantity).toBe(1)
|
||||
})
|
||||
|
||||
it('should restore state after update', async () => {
|
||||
await storage.set('player:player-1:inventory:sword', {
|
||||
itemId: 'sword',
|
||||
quantity: 1,
|
||||
properties: { damage: 10 },
|
||||
})
|
||||
|
||||
const op = new InventoryOperation({
|
||||
type: 'update',
|
||||
playerId: 'player-1',
|
||||
itemId: 'sword',
|
||||
quantity: 0,
|
||||
properties: { damage: 50 },
|
||||
})
|
||||
|
||||
await op.execute(ctx)
|
||||
await op.compensate(ctx)
|
||||
|
||||
const restored = await storage.get<ItemData>('player:player-1:inventory:sword')
|
||||
expect(restored?.properties).toEqual({ damage: 10 })
|
||||
})
|
||||
})
|
||||
|
||||
// ========================================================================
|
||||
// Provider 测试 | Provider Tests
|
||||
// ========================================================================
|
||||
|
||||
describe('Provider', () => {
|
||||
it('should use provider for operations', async () => {
|
||||
const provider = new MockInventoryProvider()
|
||||
provider.addItem('player-1', 'sword', { itemId: 'sword', quantity: 1 })
|
||||
|
||||
const op = new InventoryOperation({
|
||||
type: 'add',
|
||||
playerId: 'player-1',
|
||||
itemId: 'sword',
|
||||
quantity: 2,
|
||||
}).setProvider(provider)
|
||||
|
||||
const result = await op.execute(ctx)
|
||||
|
||||
expect(result.success).toBe(true)
|
||||
expect(result.data?.afterItem?.quantity).toBe(3)
|
||||
|
||||
const item = await provider.getItem('player-1', 'sword')
|
||||
expect(item?.quantity).toBe(3)
|
||||
})
|
||||
|
||||
it('should compensate using provider', async () => {
|
||||
const provider = new MockInventoryProvider()
|
||||
provider.addItem('player-1', 'potion', { itemId: 'potion', quantity: 10 })
|
||||
|
||||
const op = new InventoryOperation({
|
||||
type: 'remove',
|
||||
playerId: 'player-1',
|
||||
itemId: 'potion',
|
||||
quantity: 3,
|
||||
}).setProvider(provider)
|
||||
|
||||
await op.execute(ctx)
|
||||
expect((await provider.getItem('player-1', 'potion'))?.quantity).toBe(7)
|
||||
|
||||
await op.compensate(ctx)
|
||||
expect((await provider.getItem('player-1', 'potion'))?.quantity).toBe(10)
|
||||
})
|
||||
})
|
||||
|
||||
// ========================================================================
|
||||
// 边界情况测试 | Edge Cases
|
||||
// ========================================================================
|
||||
|
||||
describe('Edge Cases', () => {
|
||||
it('should handle context without storage', async () => {
|
||||
const noStorageCtx = new TransactionContext()
|
||||
|
||||
const op = new InventoryOperation({
|
||||
type: 'add',
|
||||
playerId: 'player-1',
|
||||
itemId: 'sword',
|
||||
quantity: 1,
|
||||
})
|
||||
|
||||
const result = await op.execute(noStorageCtx)
|
||||
expect(result.success).toBe(true)
|
||||
})
|
||||
|
||||
it('should include reason in data', () => {
|
||||
const op = new InventoryOperation({
|
||||
type: 'add',
|
||||
playerId: 'player-1',
|
||||
itemId: 'reward-sword',
|
||||
quantity: 1,
|
||||
reason: 'quest_reward',
|
||||
})
|
||||
|
||||
expect(op.data.reason).toBe('quest_reward')
|
||||
})
|
||||
|
||||
it('should preserve item properties when stacking', async () => {
|
||||
await storage.set('player:player-1:inventory:potion', {
|
||||
itemId: 'potion',
|
||||
quantity: 5,
|
||||
properties: { quality: 'rare' },
|
||||
})
|
||||
|
||||
const op = new InventoryOperation({
|
||||
type: 'add',
|
||||
playerId: 'player-1',
|
||||
itemId: 'potion',
|
||||
quantity: 3,
|
||||
})
|
||||
|
||||
const result = await op.execute(ctx)
|
||||
|
||||
expect(result.data?.afterItem?.properties).toEqual({ quality: 'rare' })
|
||||
expect(result.data?.afterItem?.quantity).toBe(8)
|
||||
})
|
||||
})
|
||||
})
|
||||
@@ -0,0 +1,524 @@
|
||||
/**
|
||||
* @zh TradeOperation 单元测试
|
||||
* @en TradeOperation unit tests
|
||||
*/
|
||||
|
||||
import { describe, it, expect, beforeEach } from 'vitest'
|
||||
import { TradeOperation, createTradeOperation, type ITradeProvider } from '../../src/operations/TradeOperation.js'
|
||||
import { TransactionContext } from '../../src/core/TransactionContext.js'
|
||||
import { MemoryStorage } from '../../src/storage/MemoryStorage.js'
|
||||
import type { ITransactionContext } from '../../src/core/types.js'
|
||||
import type { ICurrencyProvider } from '../../src/operations/CurrencyOperation.js'
|
||||
import type { IInventoryProvider, ItemData } from '../../src/operations/InventoryOperation.js'
|
||||
|
||||
// ============================================================================
|
||||
// Mock Providers | 模拟数据提供者
|
||||
// ============================================================================
|
||||
|
||||
class MockCurrencyProvider implements ICurrencyProvider {
|
||||
private _balances: Map<string, Map<string, number>> = new Map()
|
||||
|
||||
initBalance(playerId: string, currency: string, amount: number): void {
|
||||
if (!this._balances.has(playerId)) {
|
||||
this._balances.set(playerId, new Map())
|
||||
}
|
||||
this._balances.get(playerId)!.set(currency, amount)
|
||||
}
|
||||
|
||||
async getBalance(playerId: string, currency: string): Promise<number> {
|
||||
return this._balances.get(playerId)?.get(currency) ?? 0
|
||||
}
|
||||
|
||||
async setBalance(playerId: string, currency: string, amount: number): Promise<void> {
|
||||
if (!this._balances.has(playerId)) {
|
||||
this._balances.set(playerId, new Map())
|
||||
}
|
||||
this._balances.get(playerId)!.set(currency, amount)
|
||||
}
|
||||
}
|
||||
|
||||
class MockInventoryProvider implements IInventoryProvider {
|
||||
private _inventory: Map<string, Map<string, ItemData>> = new Map()
|
||||
|
||||
addItem(playerId: string, itemId: string, item: ItemData): void {
|
||||
if (!this._inventory.has(playerId)) {
|
||||
this._inventory.set(playerId, new Map())
|
||||
}
|
||||
this._inventory.get(playerId)!.set(itemId, item)
|
||||
}
|
||||
|
||||
async getItem(playerId: string, itemId: string): Promise<ItemData | null> {
|
||||
return this._inventory.get(playerId)?.get(itemId) ?? null
|
||||
}
|
||||
|
||||
async setItem(playerId: string, itemId: string, item: ItemData | null): Promise<void> {
|
||||
if (!this._inventory.has(playerId)) {
|
||||
this._inventory.set(playerId, new Map())
|
||||
}
|
||||
if (item) {
|
||||
this._inventory.get(playerId)!.set(itemId, item)
|
||||
} else {
|
||||
this._inventory.get(playerId)!.delete(itemId)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// ============================================================================
|
||||
// Test Suite | 测试套件
|
||||
// ============================================================================
|
||||
|
||||
describe('TradeOperation', () => {
|
||||
let storage: MemoryStorage
|
||||
let ctx: ITransactionContext
|
||||
|
||||
beforeEach(() => {
|
||||
storage = new MemoryStorage()
|
||||
ctx = new TransactionContext({ storage })
|
||||
})
|
||||
|
||||
// ========================================================================
|
||||
// 构造器测试 | Constructor Tests
|
||||
// ========================================================================
|
||||
|
||||
describe('Constructor', () => {
|
||||
it('should create with data', () => {
|
||||
const op = new TradeOperation({
|
||||
tradeId: 'trade-001',
|
||||
partyA: {
|
||||
playerId: 'player-1',
|
||||
items: [{ itemId: 'sword', quantity: 1 }],
|
||||
},
|
||||
partyB: {
|
||||
playerId: 'player-2',
|
||||
currencies: [{ currency: 'gold', amount: 1000 }],
|
||||
},
|
||||
})
|
||||
|
||||
expect(op.name).toBe('trade')
|
||||
expect(op.data.tradeId).toBe('trade-001')
|
||||
expect(op.data.partyA.playerId).toBe('player-1')
|
||||
expect(op.data.partyB.playerId).toBe('player-2')
|
||||
})
|
||||
|
||||
it('should use createTradeOperation factory', () => {
|
||||
const op = createTradeOperation({
|
||||
tradeId: 'trade-002',
|
||||
partyA: { playerId: 'player-1' },
|
||||
partyB: { playerId: 'player-2' },
|
||||
})
|
||||
|
||||
expect(op).toBeInstanceOf(TradeOperation)
|
||||
})
|
||||
})
|
||||
|
||||
// ========================================================================
|
||||
// 验证测试 | Validation Tests
|
||||
// ========================================================================
|
||||
|
||||
describe('validate()', () => {
|
||||
it('should validate item trade', async () => {
|
||||
// Player 1 has sword, Player 2 has gold
|
||||
await storage.set('player:player-1:inventory:sword', {
|
||||
itemId: 'sword',
|
||||
quantity: 1,
|
||||
})
|
||||
await storage.set('player:player-2:currency:gold', 1000)
|
||||
|
||||
const op = new TradeOperation({
|
||||
tradeId: 'trade-001',
|
||||
partyA: {
|
||||
playerId: 'player-1',
|
||||
items: [{ itemId: 'sword', quantity: 1 }],
|
||||
},
|
||||
partyB: {
|
||||
playerId: 'player-2',
|
||||
currencies: [{ currency: 'gold', amount: 1000 }],
|
||||
},
|
||||
})
|
||||
|
||||
const isValid = await op.validate(ctx)
|
||||
expect(isValid).toBe(true)
|
||||
})
|
||||
|
||||
it('should fail validation when party A lacks items', async () => {
|
||||
await storage.set('player:player-2:currency:gold', 1000)
|
||||
|
||||
const op = new TradeOperation({
|
||||
tradeId: 'trade-001',
|
||||
partyA: {
|
||||
playerId: 'player-1',
|
||||
items: [{ itemId: 'sword', quantity: 1 }],
|
||||
},
|
||||
partyB: {
|
||||
playerId: 'player-2',
|
||||
currencies: [{ currency: 'gold', amount: 1000 }],
|
||||
},
|
||||
})
|
||||
|
||||
const isValid = await op.validate(ctx)
|
||||
expect(isValid).toBe(false)
|
||||
})
|
||||
|
||||
it('should fail validation when party B lacks currency', async () => {
|
||||
await storage.set('player:player-1:inventory:sword', {
|
||||
itemId: 'sword',
|
||||
quantity: 1,
|
||||
})
|
||||
await storage.set('player:player-2:currency:gold', 500) // Not enough
|
||||
|
||||
const op = new TradeOperation({
|
||||
tradeId: 'trade-001',
|
||||
partyA: {
|
||||
playerId: 'player-1',
|
||||
items: [{ itemId: 'sword', quantity: 1 }],
|
||||
},
|
||||
partyB: {
|
||||
playerId: 'player-2',
|
||||
currencies: [{ currency: 'gold', amount: 1000 }],
|
||||
},
|
||||
})
|
||||
|
||||
const isValid = await op.validate(ctx)
|
||||
expect(isValid).toBe(false)
|
||||
})
|
||||
})
|
||||
|
||||
// ========================================================================
|
||||
// 执行测试 - 物品换货币 | Execute Tests - Item for Currency
|
||||
// ========================================================================
|
||||
|
||||
describe('execute() - item for currency', () => {
|
||||
it('should trade item for currency', async () => {
|
||||
await storage.set('player:player-1:inventory:sword', {
|
||||
itemId: 'sword',
|
||||
quantity: 1,
|
||||
})
|
||||
await storage.set('player:player-2:currency:gold', 1000)
|
||||
|
||||
const op = new TradeOperation({
|
||||
tradeId: 'trade-001',
|
||||
partyA: {
|
||||
playerId: 'player-1',
|
||||
items: [{ itemId: 'sword', quantity: 1 }],
|
||||
},
|
||||
partyB: {
|
||||
playerId: 'player-2',
|
||||
currencies: [{ currency: 'gold', amount: 1000 }],
|
||||
},
|
||||
})
|
||||
|
||||
const result = await op.execute(ctx)
|
||||
|
||||
expect(result.success).toBe(true)
|
||||
expect(result.data?.tradeId).toBe('trade-001')
|
||||
expect(result.data?.completed).toBe(true)
|
||||
|
||||
// Player 1: no sword, got gold
|
||||
expect(await storage.get('player:player-1:inventory:sword')).toBeNull()
|
||||
expect(await storage.get('player:player-1:currency:gold')).toBe(1000)
|
||||
|
||||
// Player 2: got sword, no gold
|
||||
const p2Sword = await storage.get<ItemData>('player:player-2:inventory:sword')
|
||||
expect(p2Sword?.quantity).toBe(1)
|
||||
expect(await storage.get('player:player-2:currency:gold')).toBe(0)
|
||||
})
|
||||
})
|
||||
|
||||
// ========================================================================
|
||||
// 执行测试 - 物品换物品 | Execute Tests - Item for Item
|
||||
// ========================================================================
|
||||
|
||||
describe('execute() - item for item', () => {
|
||||
it('should trade items between players', async () => {
|
||||
await storage.set('player:player-1:inventory:sword', {
|
||||
itemId: 'sword',
|
||||
quantity: 1,
|
||||
})
|
||||
await storage.set('player:player-2:inventory:shield', {
|
||||
itemId: 'shield',
|
||||
quantity: 1,
|
||||
})
|
||||
|
||||
const op = new TradeOperation({
|
||||
tradeId: 'trade-002',
|
||||
partyA: {
|
||||
playerId: 'player-1',
|
||||
items: [{ itemId: 'sword', quantity: 1 }],
|
||||
},
|
||||
partyB: {
|
||||
playerId: 'player-2',
|
||||
items: [{ itemId: 'shield', quantity: 1 }],
|
||||
},
|
||||
})
|
||||
|
||||
const result = await op.execute(ctx)
|
||||
|
||||
expect(result.success).toBe(true)
|
||||
|
||||
// Player 1: got shield, no sword
|
||||
expect(await storage.get('player:player-1:inventory:sword')).toBeNull()
|
||||
const p1Shield = await storage.get<ItemData>('player:player-1:inventory:shield')
|
||||
expect(p1Shield?.quantity).toBe(1)
|
||||
|
||||
// Player 2: got sword, no shield
|
||||
expect(await storage.get('player:player-2:inventory:shield')).toBeNull()
|
||||
const p2Sword = await storage.get<ItemData>('player:player-2:inventory:sword')
|
||||
expect(p2Sword?.quantity).toBe(1)
|
||||
})
|
||||
})
|
||||
|
||||
// ========================================================================
|
||||
// 执行测试 - 货币换货币 | Execute Tests - Currency for Currency
|
||||
// ========================================================================
|
||||
|
||||
describe('execute() - currency for currency', () => {
|
||||
it('should trade currencies between players', async () => {
|
||||
await storage.set('player:player-1:currency:gold', 1000)
|
||||
await storage.set('player:player-2:currency:diamond', 100)
|
||||
|
||||
const op = new TradeOperation({
|
||||
tradeId: 'trade-003',
|
||||
partyA: {
|
||||
playerId: 'player-1',
|
||||
currencies: [{ currency: 'gold', amount: 1000 }],
|
||||
},
|
||||
partyB: {
|
||||
playerId: 'player-2',
|
||||
currencies: [{ currency: 'diamond', amount: 100 }],
|
||||
},
|
||||
})
|
||||
|
||||
const result = await op.execute(ctx)
|
||||
|
||||
expect(result.success).toBe(true)
|
||||
|
||||
// Player 1: no gold, got diamonds
|
||||
expect(await storage.get('player:player-1:currency:gold')).toBe(0)
|
||||
expect(await storage.get('player:player-1:currency:diamond')).toBe(100)
|
||||
|
||||
// Player 2: got gold, no diamonds
|
||||
expect(await storage.get('player:player-2:currency:gold')).toBe(1000)
|
||||
expect(await storage.get('player:player-2:currency:diamond')).toBe(0)
|
||||
})
|
||||
})
|
||||
|
||||
// ========================================================================
|
||||
// 执行测试 - 复杂交易 | Execute Tests - Complex Trade
|
||||
// ========================================================================
|
||||
|
||||
describe('execute() - complex trade', () => {
|
||||
it('should handle multiple items and currencies', async () => {
|
||||
// Setup
|
||||
await storage.set('player:player-1:inventory:sword', { itemId: 'sword', quantity: 2 })
|
||||
await storage.set('player:player-1:inventory:potion', { itemId: 'potion', quantity: 10 })
|
||||
await storage.set('player:player-2:currency:gold', 5000)
|
||||
await storage.set('player:player-2:currency:diamond', 50)
|
||||
|
||||
const op = new TradeOperation({
|
||||
tradeId: 'trade-004',
|
||||
partyA: {
|
||||
playerId: 'player-1',
|
||||
items: [
|
||||
{ itemId: 'sword', quantity: 1 },
|
||||
{ itemId: 'potion', quantity: 5 },
|
||||
],
|
||||
},
|
||||
partyB: {
|
||||
playerId: 'player-2',
|
||||
currencies: [
|
||||
{ currency: 'gold', amount: 2000 },
|
||||
{ currency: 'diamond', amount: 20 },
|
||||
],
|
||||
},
|
||||
})
|
||||
|
||||
const result = await op.execute(ctx)
|
||||
|
||||
expect(result.success).toBe(true)
|
||||
|
||||
// Player 1
|
||||
const p1Sword = await storage.get<ItemData>('player:player-1:inventory:sword')
|
||||
expect(p1Sword?.quantity).toBe(1) // Had 2, gave 1
|
||||
const p1Potion = await storage.get<ItemData>('player:player-1:inventory:potion')
|
||||
expect(p1Potion?.quantity).toBe(5) // Had 10, gave 5
|
||||
expect(await storage.get('player:player-1:currency:gold')).toBe(2000)
|
||||
expect(await storage.get('player:player-1:currency:diamond')).toBe(20)
|
||||
|
||||
// Player 2
|
||||
const p2Sword = await storage.get<ItemData>('player:player-2:inventory:sword')
|
||||
expect(p2Sword?.quantity).toBe(1)
|
||||
const p2Potion = await storage.get<ItemData>('player:player-2:inventory:potion')
|
||||
expect(p2Potion?.quantity).toBe(5)
|
||||
expect(await storage.get('player:player-2:currency:gold')).toBe(3000) // Had 5000, gave 2000
|
||||
expect(await storage.get('player:player-2:currency:diamond')).toBe(30) // Had 50, gave 20
|
||||
})
|
||||
})
|
||||
|
||||
// ========================================================================
|
||||
// 失败和补偿测试 | Failure and Compensation Tests
|
||||
// ========================================================================
|
||||
|
||||
describe('failure and compensation', () => {
|
||||
it('should rollback on partial failure', async () => {
|
||||
// Player 1 has sword, Player 2 does NOT have enough gold
|
||||
await storage.set('player:player-1:inventory:sword', {
|
||||
itemId: 'sword',
|
||||
quantity: 1,
|
||||
})
|
||||
await storage.set('player:player-2:currency:gold', 500) // Not enough
|
||||
|
||||
const op = new TradeOperation({
|
||||
tradeId: 'trade-fail',
|
||||
partyA: {
|
||||
playerId: 'player-1',
|
||||
items: [{ itemId: 'sword', quantity: 1 }],
|
||||
},
|
||||
partyB: {
|
||||
playerId: 'player-2',
|
||||
currencies: [{ currency: 'gold', amount: 1000 }],
|
||||
},
|
||||
})
|
||||
|
||||
const result = await op.execute(ctx)
|
||||
|
||||
expect(result.success).toBe(false)
|
||||
expect(result.errorCode).toBe('TRADE_FAILED')
|
||||
|
||||
// Everything should be restored
|
||||
const p1Sword = await storage.get<ItemData>('player:player-1:inventory:sword')
|
||||
expect(p1Sword?.quantity).toBe(1) // Restored
|
||||
expect(await storage.get('player:player-2:inventory:sword')).toBeNull()
|
||||
})
|
||||
|
||||
it('should compensate after successful execute', async () => {
|
||||
await storage.set('player:player-1:inventory:sword', {
|
||||
itemId: 'sword',
|
||||
quantity: 1,
|
||||
})
|
||||
await storage.set('player:player-2:currency:gold', 1000)
|
||||
|
||||
const op = new TradeOperation({
|
||||
tradeId: 'trade-compensate',
|
||||
partyA: {
|
||||
playerId: 'player-1',
|
||||
items: [{ itemId: 'sword', quantity: 1 }],
|
||||
},
|
||||
partyB: {
|
||||
playerId: 'player-2',
|
||||
currencies: [{ currency: 'gold', amount: 1000 }],
|
||||
},
|
||||
})
|
||||
|
||||
await op.execute(ctx)
|
||||
|
||||
// Verify trade happened
|
||||
expect(await storage.get('player:player-1:inventory:sword')).toBeNull()
|
||||
expect(await storage.get('player:player-1:currency:gold')).toBe(1000)
|
||||
|
||||
// Compensate
|
||||
await op.compensate(ctx)
|
||||
|
||||
// Everything should be restored
|
||||
const p1Sword = await storage.get<ItemData>('player:player-1:inventory:sword')
|
||||
expect(p1Sword?.quantity).toBe(1)
|
||||
expect(await storage.get('player:player-1:currency:gold')).toBe(0)
|
||||
expect(await storage.get('player:player-2:inventory:sword')).toBeNull()
|
||||
expect(await storage.get('player:player-2:currency:gold')).toBe(1000)
|
||||
})
|
||||
})
|
||||
|
||||
// ========================================================================
|
||||
// Provider 测试 | Provider Tests
|
||||
// ========================================================================
|
||||
|
||||
describe('Provider', () => {
|
||||
it('should use providers for trade', async () => {
|
||||
const currencyProvider = new MockCurrencyProvider()
|
||||
const inventoryProvider = new MockInventoryProvider()
|
||||
|
||||
currencyProvider.initBalance('player-1', 'gold', 0)
|
||||
currencyProvider.initBalance('player-2', 'gold', 1000)
|
||||
inventoryProvider.addItem('player-1', 'sword', { itemId: 'sword', quantity: 1 })
|
||||
|
||||
const provider: ITradeProvider = {
|
||||
currencyProvider,
|
||||
inventoryProvider,
|
||||
}
|
||||
|
||||
const op = new TradeOperation({
|
||||
tradeId: 'trade-provider',
|
||||
partyA: {
|
||||
playerId: 'player-1',
|
||||
items: [{ itemId: 'sword', quantity: 1 }],
|
||||
},
|
||||
partyB: {
|
||||
playerId: 'player-2',
|
||||
currencies: [{ currency: 'gold', amount: 1000 }],
|
||||
},
|
||||
}).setProvider(provider)
|
||||
|
||||
const result = await op.execute(ctx)
|
||||
|
||||
expect(result.success).toBe(true)
|
||||
|
||||
// Verify using providers
|
||||
expect(await inventoryProvider.getItem('player-1', 'sword')).toBeNull()
|
||||
expect(await currencyProvider.getBalance('player-1', 'gold')).toBe(1000)
|
||||
expect((await inventoryProvider.getItem('player-2', 'sword'))?.quantity).toBe(1)
|
||||
expect(await currencyProvider.getBalance('player-2', 'gold')).toBe(0)
|
||||
})
|
||||
})
|
||||
|
||||
// ========================================================================
|
||||
// 边界情况测试 | Edge Cases
|
||||
// ========================================================================
|
||||
|
||||
describe('Edge Cases', () => {
|
||||
it('should handle empty trade', async () => {
|
||||
const op = new TradeOperation({
|
||||
tradeId: 'trade-empty',
|
||||
partyA: { playerId: 'player-1' },
|
||||
partyB: { playerId: 'player-2' },
|
||||
})
|
||||
|
||||
const result = await op.execute(ctx)
|
||||
|
||||
expect(result.success).toBe(true)
|
||||
expect(result.data?.completed).toBe(true)
|
||||
})
|
||||
|
||||
it('should handle one-sided gift', async () => {
|
||||
await storage.set('player:player-1:inventory:gift', {
|
||||
itemId: 'gift',
|
||||
quantity: 1,
|
||||
})
|
||||
|
||||
const op = new TradeOperation({
|
||||
tradeId: 'trade-gift',
|
||||
partyA: {
|
||||
playerId: 'player-1',
|
||||
items: [{ itemId: 'gift', quantity: 1 }],
|
||||
},
|
||||
partyB: { playerId: 'player-2' }, // Gives nothing
|
||||
})
|
||||
|
||||
const result = await op.execute(ctx)
|
||||
|
||||
expect(result.success).toBe(true)
|
||||
expect(await storage.get('player:player-1:inventory:gift')).toBeNull()
|
||||
const p2Gift = await storage.get<ItemData>('player:player-2:inventory:gift')
|
||||
expect(p2Gift?.quantity).toBe(1)
|
||||
})
|
||||
|
||||
it('should include reason in data', () => {
|
||||
const op = new TradeOperation({
|
||||
tradeId: 'trade-reason',
|
||||
partyA: { playerId: 'player-1' },
|
||||
partyB: { playerId: 'player-2' },
|
||||
reason: 'player_trade',
|
||||
})
|
||||
|
||||
expect(op.data.reason).toBe('player_trade')
|
||||
})
|
||||
})
|
||||
})
|
||||
@@ -0,0 +1,254 @@
|
||||
/**
|
||||
* @zh MemoryStorage 单元测试
|
||||
* @en MemoryStorage unit tests
|
||||
*/
|
||||
|
||||
import { describe, it, expect, beforeEach } from 'vitest'
|
||||
import { MemoryStorage } from '../../src/storage/MemoryStorage.js'
|
||||
import type { TransactionLog } from '../../src/core/types.js'
|
||||
|
||||
describe('MemoryStorage', () => {
|
||||
let storage: MemoryStorage
|
||||
|
||||
beforeEach(() => {
|
||||
storage = new MemoryStorage()
|
||||
})
|
||||
|
||||
// ========================================================================
|
||||
// 分布式锁测试 | Distributed Lock Tests
|
||||
// ========================================================================
|
||||
|
||||
describe('Distributed Lock', () => {
|
||||
it('should acquire lock successfully', async () => {
|
||||
const token = await storage.acquireLock('test-key', 5000)
|
||||
expect(token).not.toBeNull()
|
||||
expect(typeof token).toBe('string')
|
||||
})
|
||||
|
||||
it('should fail to acquire same lock twice', async () => {
|
||||
const token1 = await storage.acquireLock('test-key', 5000)
|
||||
const token2 = await storage.acquireLock('test-key', 5000)
|
||||
|
||||
expect(token1).not.toBeNull()
|
||||
expect(token2).toBeNull()
|
||||
})
|
||||
|
||||
it('should release lock with correct token', async () => {
|
||||
const token = await storage.acquireLock('test-key', 5000)
|
||||
expect(token).not.toBeNull()
|
||||
|
||||
const released = await storage.releaseLock('test-key', token!)
|
||||
expect(released).toBe(true)
|
||||
})
|
||||
|
||||
it('should fail to release lock with wrong token', async () => {
|
||||
const token = await storage.acquireLock('test-key', 5000)
|
||||
expect(token).not.toBeNull()
|
||||
|
||||
const released = await storage.releaseLock('test-key', 'wrong-token')
|
||||
expect(released).toBe(false)
|
||||
})
|
||||
|
||||
it('should allow re-acquiring after release', async () => {
|
||||
const token1 = await storage.acquireLock('test-key', 5000)
|
||||
await storage.releaseLock('test-key', token1!)
|
||||
|
||||
const token2 = await storage.acquireLock('test-key', 5000)
|
||||
expect(token2).not.toBeNull()
|
||||
})
|
||||
|
||||
it('should expire lock after TTL', async () => {
|
||||
await storage.acquireLock('test-key', 50) // 50ms TTL
|
||||
|
||||
// 等待锁过期
|
||||
await new Promise((resolve) => setTimeout(resolve, 100))
|
||||
|
||||
const token2 = await storage.acquireLock('test-key', 5000)
|
||||
expect(token2).not.toBeNull()
|
||||
})
|
||||
})
|
||||
|
||||
// ========================================================================
|
||||
// 事务日志测试 | Transaction Log Tests
|
||||
// ========================================================================
|
||||
|
||||
describe('Transaction Log', () => {
|
||||
const createMockLog = (id: string): TransactionLog => ({
|
||||
id,
|
||||
state: 'pending',
|
||||
operations: [],
|
||||
createdAt: Date.now(),
|
||||
updatedAt: Date.now(),
|
||||
})
|
||||
|
||||
it('should save and retrieve transaction', async () => {
|
||||
const log = createMockLog('tx-1')
|
||||
await storage.saveTransaction(log)
|
||||
|
||||
const retrieved = await storage.getTransaction('tx-1')
|
||||
expect(retrieved).not.toBeNull()
|
||||
expect(retrieved!.id).toBe('tx-1')
|
||||
})
|
||||
|
||||
it('should return null for non-existent transaction', async () => {
|
||||
const retrieved = await storage.getTransaction('non-existent')
|
||||
expect(retrieved).toBeNull()
|
||||
})
|
||||
|
||||
it('should update transaction state', async () => {
|
||||
const log = createMockLog('tx-1')
|
||||
await storage.saveTransaction(log)
|
||||
|
||||
await storage.updateTransactionState('tx-1', 'committed')
|
||||
|
||||
const retrieved = await storage.getTransaction('tx-1')
|
||||
expect(retrieved!.state).toBe('committed')
|
||||
})
|
||||
|
||||
it('should update operation state', async () => {
|
||||
const log: TransactionLog = {
|
||||
...createMockLog('tx-1'),
|
||||
operations: [
|
||||
{ name: 'op1', state: 'pending' },
|
||||
{ name: 'op2', state: 'pending' },
|
||||
],
|
||||
}
|
||||
await storage.saveTransaction(log)
|
||||
|
||||
await storage.updateOperationState('tx-1', 0, 'completed')
|
||||
await storage.updateOperationState('tx-1', 1, 'failed', 'Some error')
|
||||
|
||||
const retrieved = await storage.getTransaction('tx-1')
|
||||
expect(retrieved!.operations[0].state).toBe('completed')
|
||||
expect(retrieved!.operations[1].state).toBe('failed')
|
||||
expect(retrieved!.operations[1].error).toBe('Some error')
|
||||
})
|
||||
|
||||
it('should delete transaction', async () => {
|
||||
const log = createMockLog('tx-1')
|
||||
await storage.saveTransaction(log)
|
||||
|
||||
await storage.deleteTransaction('tx-1')
|
||||
|
||||
const retrieved = await storage.getTransaction('tx-1')
|
||||
expect(retrieved).toBeNull()
|
||||
})
|
||||
|
||||
it('should get pending transactions', async () => {
|
||||
await storage.saveTransaction({ ...createMockLog('tx-1'), state: 'pending' })
|
||||
await storage.saveTransaction({ ...createMockLog('tx-2'), state: 'executing' })
|
||||
await storage.saveTransaction({ ...createMockLog('tx-3'), state: 'committed' })
|
||||
|
||||
const pending = await storage.getPendingTransactions()
|
||||
expect(pending.length).toBe(2) // pending and executing
|
||||
expect(pending.map((p) => p.id).sort()).toEqual(['tx-1', 'tx-2'])
|
||||
})
|
||||
|
||||
it('should filter pending transactions by serverId', async () => {
|
||||
await storage.saveTransaction({
|
||||
...createMockLog('tx-1'),
|
||||
state: 'pending',
|
||||
metadata: { serverId: 'server-1' },
|
||||
})
|
||||
await storage.saveTransaction({
|
||||
...createMockLog('tx-2'),
|
||||
state: 'pending',
|
||||
metadata: { serverId: 'server-2' },
|
||||
})
|
||||
|
||||
const pending = await storage.getPendingTransactions('server-1')
|
||||
expect(pending.length).toBe(1)
|
||||
expect(pending[0].id).toBe('tx-1')
|
||||
})
|
||||
})
|
||||
|
||||
// ========================================================================
|
||||
// 数据操作测试 | Data Operations Tests
|
||||
// ========================================================================
|
||||
|
||||
describe('Data Operations', () => {
|
||||
it('should set and get data', async () => {
|
||||
await storage.set('key1', { value: 123 })
|
||||
|
||||
const data = await storage.get<{ value: number }>('key1')
|
||||
expect(data).toEqual({ value: 123 })
|
||||
})
|
||||
|
||||
it('should return null for non-existent key', async () => {
|
||||
const data = await storage.get('non-existent')
|
||||
expect(data).toBeNull()
|
||||
})
|
||||
|
||||
it('should delete data', async () => {
|
||||
await storage.set('key1', { value: 123 })
|
||||
const deleted = await storage.delete('key1')
|
||||
|
||||
expect(deleted).toBe(true)
|
||||
expect(await storage.get('key1')).toBeNull()
|
||||
})
|
||||
|
||||
it('should return false when deleting non-existent key', async () => {
|
||||
const deleted = await storage.delete('non-existent')
|
||||
expect(deleted).toBe(false)
|
||||
})
|
||||
|
||||
it('should expire data after TTL', async () => {
|
||||
await storage.set('key1', { value: 123 }, 50) // 50ms TTL
|
||||
|
||||
// 数据应该存在
|
||||
expect(await storage.get('key1')).toEqual({ value: 123 })
|
||||
|
||||
// 等待过期
|
||||
await new Promise((resolve) => setTimeout(resolve, 100))
|
||||
|
||||
expect(await storage.get('key1')).toBeNull()
|
||||
})
|
||||
|
||||
it('should overwrite existing data', async () => {
|
||||
await storage.set('key1', { value: 1 })
|
||||
await storage.set('key1', { value: 2 })
|
||||
|
||||
const data = await storage.get<{ value: number }>('key1')
|
||||
expect(data).toEqual({ value: 2 })
|
||||
})
|
||||
})
|
||||
|
||||
// ========================================================================
|
||||
// 辅助方法测试 | Helper Methods Tests
|
||||
// ========================================================================
|
||||
|
||||
describe('Helper Methods', () => {
|
||||
it('should clear all data', async () => {
|
||||
await storage.set('key1', 'value1')
|
||||
await storage.set('key2', 'value2')
|
||||
await storage.saveTransaction({
|
||||
id: 'tx-1',
|
||||
state: 'pending',
|
||||
operations: [],
|
||||
createdAt: Date.now(),
|
||||
updatedAt: Date.now(),
|
||||
})
|
||||
|
||||
storage.clear()
|
||||
|
||||
expect(await storage.get('key1')).toBeNull()
|
||||
expect(await storage.get('key2')).toBeNull()
|
||||
expect(await storage.getTransaction('tx-1')).toBeNull()
|
||||
expect(storage.transactionCount).toBe(0)
|
||||
})
|
||||
|
||||
it('should track transaction count', async () => {
|
||||
expect(storage.transactionCount).toBe(0)
|
||||
|
||||
await storage.saveTransaction({
|
||||
id: 'tx-1',
|
||||
state: 'pending',
|
||||
operations: [],
|
||||
createdAt: Date.now(),
|
||||
updatedAt: Date.now(),
|
||||
})
|
||||
|
||||
expect(storage.transactionCount).toBe(1)
|
||||
})
|
||||
})
|
||||
})
|
||||
Reference in New Issue
Block a user