@gravito/satellite-invoice 0.1.4 → 0.2.0

package/tests/Application/Contexts/InvoiceAuditContext.test.ts

@@ -0,0 +1,198 @@
+import { beforeEach, describe, expect, it } from 'bun:test'
+import { InvoiceAuditContext } from '../../../src/Application/Contexts/InvoiceAuditContext'
+import { DefaultInvoiceTracker } from '../../../src/Application/Roles/InvoiceTrackerRole'
+import type { IInvoiceRepository } from '../../../src/Domain/Contracts/IInvoiceRepository'
+import { Invoice } from '../../../src/Domain/Entities/Invoice'
+import { InvoiceNotFoundError } from '../../../src/Domain/Errors/InvoiceError'
+import { InvoiceNumber } from '../../../src/Domain/ValueObjects/InvoiceNumber'
+
+// Mock Repository
+class MockRepository implements IInvoiceRepository {
+  private invoices: Map<string, Invoice> = new Map()
+
+  async save(invoice: Invoice): Promise<void> {
+    this.invoices.set(invoice.id, invoice)
+  }
+
+  async findById(id: string): Promise<Invoice | null> {
+    return this.invoices.get(id) || null
+  }
+
+  async findByOrderId(orderId: string): Promise<Invoice | null> {
+    for (const invoice of this.invoices.values()) {
+      if (invoice.orderId === orderId) {
+        return invoice
+      }
+    }
+    return null
+  }
+
+  async findAll(): Promise<Invoice[]> {
+    return Array.from(this.invoices.values())
+  }
+
+  async findByInvoiceNumber(invoiceNumber: string): Promise<Invoice | null> {
+    for (const invoice of this.invoices.values()) {
+      if (invoice.invoiceNumber === invoiceNumber) {
+        return invoice
+      }
+    }
+    return null
+  }
+
+  async findByStatus(status: string): Promise<Invoice[]> {
+    return Array.from(this.invoices.values()).filter((inv) => inv.status === status)
+  }
+
+  async findByDateRange(startDate: Date, endDate: Date): Promise<Invoice[]> {
+    return Array.from(this.invoices.values()).filter(
+      (inv) => inv.createdAt >= startDate && inv.createdAt <= endDate
+    )
+  }
+}
+
+describe('InvoiceAuditContext', () => {
+  let context: InvoiceAuditContext
+  let repository: MockRepository
+  let tracker: DefaultInvoiceTracker
+
+  beforeEach(async () => {
+    repository = new MockRepository()
+    tracker = new DefaultInvoiceTracker()
+    context = new InvoiceAuditContext(repository, tracker)
+  })
+
+  it('應該查詢發票狀態', async () => {
+    const invoice = Invoice.create(
+      {
+        orderId: 'order-123',
+        invoiceNumber: 'GX-12345678',
+        amount: 1000,
+        tax: 50,
+        status: 'ISSUED',
+      },
+      'inv-123'
+    )
+    await repository.save(invoice)
+    tracker.trackInvoice(invoice)
+
+    const result = await context.queryStatus({ invoiceId: 'inv-123' })
+
+    expect(result.id).toBe('inv-123')
+    expect(result.invoiceNumber).toBe('GX-12345678')
+    expect(result.orderId).toBe('order-123')
+    expect(result.status).toBe('ISSUED')
+    expect(result.amount).toBe(1000)
+    expect(result.createdAt).toBeInstanceOf(Date)
+  })
+
+  it('應該在發票不存在時拋出錯誤', async () => {
+    try {
+      await context.queryStatus({ invoiceId: 'non-existent' })
+      expect(true).toBe(false) // 應該拋出錯誤
+    } catch (error) {
+      expect(error).toBeInstanceOf(InvoiceNotFoundError)
+    }
+  })
+
+  it('應該取得審計追蹤', async () => {
+    const invoice = Invoice.create(
+      {
+        orderId: 'order-123',
+        invoiceNumber: 'GX-12345678',
+        amount: 1000,
+        tax: 50,
+        status: 'ISSUED',
+      },
+      'inv-123'
+    )
+    await repository.save(invoice)
+    tracker.trackInvoice(invoice)
+
+    tracker.recordAuditLog({
+      invoiceId: 'inv-123',
+      action: 'CREATED',
+      timestamp: new Date(),
+      details: { amount: 1000 },
+    })
+
+    const result = await context.getAuditTrail({ invoiceId: 'inv-123' })
+
+    expect(result.invoiceId).toBe('inv-123')
+    expect(result.logs.length).toBe(1)
+    expect((result.logs[0] as any).action).toBe('CREATED')
+  })
+
+  it('應該在發票不存在時取得審計追蹤時拋出錯誤', async () => {
+    try {
+      await context.getAuditTrail({ invoiceId: 'non-existent' })
+      expect(true).toBe(false) // 應該拋出錯誤
+    } catch (error) {
+      expect(error).toBeInstanceOf(InvoiceNotFoundError)
+    }
+  })
+
+  it('應該生成期間報告', async () => {
+    // 建立多張發票
+    for (let i = 0; i < 3; i++) {
+      const invoice = Invoice.create({
+        orderId: `order-${i}`,
+        invoiceNumber: InvoiceNumber.generate().value,
+        amount: 1000 * (i + 1),
+        tax: 50 * (i + 1),
+        status: 'ISSUED',
+      })
+      await repository.save(invoice)
+      tracker.trackInvoice(invoice)
+    }
+
+    const now = new Date()
+    const startDate = new Date(now.getTime() - 24 * 60 * 60 * 1000)
+    const endDate = new Date(now.getTime() + 24 * 60 * 60 * 1000)
+
+    const report = await context.generateReport({ startDate, endDate })
+
+    expect(report.period.startDate).toEqual(startDate)
+    expect(report.period.endDate).toEqual(endDate)
+    expect(report.summary.total).toBe(3)
+    expect(report.summary.issued).toBe(3)
+    expect(report.summary.cancelled).toBe(0)
+    expect(report.summary.returned).toBe(0)
+    expect(report.summary.totalAmount).toBe(6000) // 1000 + 2000 + 3000
+    expect(report.invoices.length).toBe(3)
+  })
+
+  it('應該在空期間返回空報告', async () => {
+    const startDate = new Date('2020-01-01')
+    const endDate = new Date('2020-12-31')
+
+    const report = await context.generateReport({ startDate, endDate })
+
+    expect(report.summary.total).toBe(0)
+    expect(report.invoices.length).toBe(0)
+  })
+
+  it('應該在報告中包含正確的發票詳情', async () => {
+    const invoice = Invoice.create({
+      orderId: 'order-123',
+      invoiceNumber: 'GX-12345678',
+      amount: 5000,
+      tax: 250,
+      status: 'ISSUED',
+    })
+    await repository.save(invoice)
+    tracker.trackInvoice(invoice)
+
+    const now = new Date()
+    const startDate = new Date(now.getTime() - 24 * 60 * 60 * 1000)
+    const endDate = new Date(now.getTime() + 24 * 60 * 60 * 1000)
+
+    const report = await context.generateReport({ startDate, endDate })
+
+    expect(report.invoices[0].id).toBe(invoice.id)
+    expect(report.invoices[0].number).toBe('GX-12345678')
+    expect(report.invoices[0].orderId).toBe('order-123')
+    expect(report.invoices[0].amount).toBe(5000)
+    expect(report.invoices[0].status).toBe('ISSUED')
+  })
+})

package/tests/Application/Contexts/InvoiceCancellationContext.test.ts

@@ -0,0 +1,232 @@
+import { beforeEach, describe, expect, it } from 'bun:test'
+import { InvoiceCancellationContext } from '../../../src/Application/Contexts/InvoiceCancellationContext'
+import { DefaultInvoiceCanceller } from '../../../src/Application/Roles/InvoiceCancellerRole'
+import type { IInvoiceRepository } from '../../../src/Domain/Contracts/IInvoiceRepository'
+import { Invoice } from '../../../src/Domain/Entities/Invoice'
+import {
+  InvalidCancellationError,
+  InvoiceNotFoundError,
+} from '../../../src/Domain/Errors/InvoiceError'
+import { InvoiceNumber } from '../../../src/Domain/ValueObjects/InvoiceNumber'
+
+// Mock Repository
+class MockRepository implements IInvoiceRepository {
+  private invoices: Map<string, Invoice> = new Map()
+
+  async save(invoice: Invoice): Promise<void> {
+    this.invoices.set(invoice.id, invoice)
+  }
+
+  async findById(id: string): Promise<Invoice | null> {
+    return this.invoices.get(id) || null
+  }
+
+  async findByOrderId(orderId: string): Promise<Invoice | null> {
+    for (const invoice of this.invoices.values()) {
+      if (invoice.orderId === orderId) {
+        return invoice
+      }
+    }
+    return null
+  }
+
+  async findAll(): Promise<Invoice[]> {
+    return Array.from(this.invoices.values())
+  }
+
+  async findByInvoiceNumber(invoiceNumber: string): Promise<Invoice | null> {
+    for (const invoice of this.invoices.values()) {
+      if (invoice.invoiceNumber === invoiceNumber) {
+        return invoice
+      }
+    }
+    return null
+  }
+
+  async findByStatus(status: string): Promise<Invoice[]> {
+    return Array.from(this.invoices.values()).filter((inv) => inv.status === status)
+  }
+
+  async findByDateRange(startDate: Date, endDate: Date): Promise<Invoice[]> {
+    return Array.from(this.invoices.values()).filter(
+      (inv) => inv.createdAt >= startDate && inv.createdAt <= endDate
+    )
+  }
+}
+
+describe('InvoiceCancellationContext', () => {
+  let context: InvoiceCancellationContext
+  let repository: MockRepository
+  let canceller: DefaultInvoiceCanceller
+
+  beforeEach(async () => {
+    repository = new MockRepository()
+    canceller = new DefaultInvoiceCanceller()
+    context = new InvoiceCancellationContext(repository, canceller)
+  })
+
+  it('應該成功取消已發行的發票', async () => {
+    // 先建立一張發票
+    const invoice = Invoice.create(
+      {
+        orderId: 'order-123',
+        invoiceNumber: 'GX-12345678',
+        amount: 1000,
+        tax: 50,
+        status: 'ISSUED',
+      },
+      'inv-123'
+    )
+    await repository.save(invoice)
+
+    // 取消發票
+    const result = await context.orchestrate({
+      invoiceId: 'inv-123',
+      reason: 'CUSTOMER_REQUEST',
+      notes: 'Customer changed their mind',
+    })
+
+    expect(result.id).toBe('inv-123')
+    expect(result.invoiceNumber).toBe('GX-12345678')
+    expect(result.previousStatus).toBe('ISSUED')
+    expect(result.newStatus).toBe('CANCELLED')
+    expect(result.cancelledAt).toBeInstanceOf(Date)
+  })
+
+  it('應該支援各種取消原因', async () => {
+    const reasons = [
+      'CUSTOMER_REQUEST',
+      'PAYMENT_FAILED',
+      'ORDER_CANCELLED',
+      'DUPLICATE',
+      'OTHER',
+    ] as const
+
+    for (const reason of reasons) {
+      const invoice = Invoice.create({
+        orderId: `order-${reason}`,
+        invoiceNumber: InvoiceNumber.generate().value,
+        amount: 1000,
+        tax: 50,
+        status: 'ISSUED',
+      })
+      await repository.save(invoice)
+
+      const result = await context.orchestrate({
+        invoiceId: invoice.id,
+        reason,
+      })
+
+      expect(result.previousStatus).toBe('ISSUED')
+      expect(result.newStatus).toBe('CANCELLED')
+    }
+  })
+
+  it('應該在發票不存在時拋出錯誤', async () => {
+    try {
+      await context.orchestrate({
+        invoiceId: 'non-existent',
+        reason: 'CUSTOMER_REQUEST',
+      })
+      expect(true).toBe(false) // 應該拋出錯誤
+    } catch (error) {
+      expect(error).toBeInstanceOf(InvoiceNotFoundError)
+    }
+  })
+
+  it('應該拒絕取消已取消的發票', async () => {
+    // 先建立並取消一張發票
+    const invoice = Invoice.create(
+      {
+        orderId: 'order-123',
+        invoiceNumber: 'GX-12345678',
+        amount: 1000,
+        tax: 50,
+        status: 'ISSUED',
+      },
+      'inv-123'
+    )
+    const cancelledInvoice = invoice.cancel()
+    await repository.save(cancelledInvoice)
+
+    // 嘗試再次取消
+    try {
+      await context.orchestrate({
+        invoiceId: 'inv-123',
+        reason: 'CUSTOMER_REQUEST',
+      })
+      expect(true).toBe(false) // 應該拋出錯誤
+    } catch (error) {
+      expect(error).toBeInstanceOf(InvalidCancellationError)
+    }
+  })
+
+  it('應該記錄取消的 notes', async () => {
+    const invoice = Invoice.create(
+      {
+        orderId: 'order-123',
+        invoiceNumber: 'GX-12345678',
+        amount: 1000,
+        tax: 50,
+        status: 'ISSUED',
+      },
+      'inv-123'
+    )
+    await repository.save(invoice)
+
+    const result = await context.orchestrate({
+      invoiceId: 'inv-123',
+      reason: 'CUSTOMER_REQUEST',
+      notes: 'Special handling requested',
+    })
+
+    expect(result.id).toBe('inv-123')
+    // 驗證記錄已保存
+    const record = (canceller as any).getCancellationRecord('inv-123')
+    expect(record.notes).toBe('Special handling requested')
+  })
+
+  it('應該更新 Repository 中的發票狀態', async () => {
+    const invoice = Invoice.create(
+      {
+        orderId: 'order-123',
+        invoiceNumber: 'GX-12345678',
+        amount: 1000,
+        tax: 50,
+        status: 'ISSUED',
+      },
+      'inv-123'
+    )
+    await repository.save(invoice)
+
+    await context.orchestrate({
+      invoiceId: 'inv-123',
+      reason: 'CUSTOMER_REQUEST',
+    })
+
+    // 驗證已保存的發票狀態已更新
+    const updated = await repository.findById('inv-123')
+    expect(updated?.status).toBe('CANCELLED')
+  })
+
+  it('應該能取消沒有 notes 的發票', async () => {
+    const invoice = Invoice.create(
+      {
+        orderId: 'order-123',
+        invoiceNumber: 'GX-12345678',
+        amount: 1000,
+        tax: 50,
+        status: 'ISSUED',
+      },
+      'inv-123'
+    )
+    await repository.save(invoice)
+
+    const result = await context.orchestrate({
+      invoiceId: 'inv-123',
+      reason: 'CUSTOMER_REQUEST',
+    })
+
+    expect(result.newStatus).toBe('CANCELLED')
+  })
+})

package/tests/Application/Contexts/InvoiceIssuanceContext.test.ts

@@ -0,0 +1,180 @@
+import { beforeEach, describe, expect, it } from 'bun:test'
+import { InvoiceIssuanceContext } from '../../../src/Application/Contexts/InvoiceIssuanceContext'
+import { DefaultInvoiceIssuer } from '../../../src/Application/Roles/InvoiceIssuerRole'
+import type { IInvoiceRepository } from '../../../src/Domain/Contracts/IInvoiceRepository'
+import { DuplicateInvoiceError, InvoiceError } from '../../../src/Domain/Errors/InvoiceError'
+
+// Mock Repository
+class MockRepository implements IInvoiceRepository {
+  private invoices: Map<string, any> = new Map()
+
+  async save(invoice: any): Promise<void> {
+    this.invoices.set(invoice.id, invoice)
+  }
+
+  async findById(id: string): Promise<any> {
+    return this.invoices.get(id) || null
+  }
+
+  async findByOrderId(orderId: string): Promise<any> {
+    for (const invoice of this.invoices.values()) {
+      if (invoice.orderId === orderId) {
+        return invoice
+      }
+    }
+    return null
+  }
+
+  async findAll(): Promise<any[]> {
+    return Array.from(this.invoices.values())
+  }
+
+  async findByInvoiceNumber(invoiceNumber: string): Promise<any> {
+    for (const invoice of this.invoices.values()) {
+      if (invoice.invoiceNumber === invoiceNumber) {
+        return invoice
+      }
+    }
+    return null
+  }
+
+  async findByStatus(status: string): Promise<any[]> {
+    return Array.from(this.invoices.values()).filter((inv) => inv.status === status)
+  }
+
+  async findByDateRange(startDate: Date, endDate: Date): Promise<any[]> {
+    return Array.from(this.invoices.values()).filter(
+      (inv) => inv.createdAt >= startDate && inv.createdAt <= endDate
+    )
+  }
+}
+
+describe('InvoiceIssuanceContext', () => {
+  let context: InvoiceIssuanceContext
+  let repository: MockRepository
+  let issuer: DefaultInvoiceIssuer
+
+  beforeEach(() => {
+    repository = new MockRepository()
+    issuer = new DefaultInvoiceIssuer()
+    context = new InvoiceIssuanceContext(repository, issuer)
+  })
+
+  it('應該成功開立發票', async () => {
+    const result = await context.orchestrate({
+      orderId: 'order-123',
+      amount: 1000,
+      currency: 'TWD',
+    })
+
+    expect(result.id).toBeDefined()
+    expect(result.invoiceNumber).toMatch(/^GX-\d{8}$/)
+    expect(result.orderId).toBe('order-123')
+    expect(result.amount).toBe(1000)
+    expect(result.currency).toBe('TWD')
+    expect(result.status).toBe('ISSUED')
+  })
+
+  it('應該使用預設幣別 TWD', async () => {
+    const result = await context.orchestrate({
+      orderId: 'order-123',
+      amount: 1000,
+    })
+
+    expect(result.currency).toBe('TWD')
+  })
+
+  it('應該帶著買方和運送商識別碼開立發票', async () => {
+    const result = await context.orchestrate({
+      orderId: 'order-123',
+      amount: 1000,
+      buyerIdentifier: 'buyer-123',
+      carrierId: 'carrier-456',
+    })
+
+    expect(result.id).toBeDefined()
+    // 驗證保存的發票包含這些資訊
+    const saved = await repository.findById(result.id)
+    expect(saved).toBeDefined()
+  })
+
+  it('應該計算正確的稅額', async () => {
+    const result = await context.orchestrate({
+      orderId: 'order-123',
+      amount: 1000,
+    })
+
+    // 驗證金額
+    expect(result.amount).toBe(1000)
+    // 稅額應該是 50 (5% of 1000)
+    const saved = await repository.findById(result.id)
+    expect(saved.tax).toBe(50)
+  })
+
+  it('應該拒絕重複的訂單 ID', async () => {
+    // 第一次開票成功
+    await context.orchestrate({
+      orderId: 'order-123',
+      amount: 1000,
+    })
+
+    // 第二次應該失敗
+    try {
+      await context.orchestrate({
+        orderId: 'order-123',
+        amount: 1000,
+      })
+      expect(true).toBe(false) // 應該拋出錯誤
+    } catch (error) {
+      expect(error).toBeInstanceOf(DuplicateInvoiceError)
+    }
+  })
+
+  it('應該在無效的訂單時拋出錯誤', async () => {
+    try {
+      await context.orchestrate({
+        orderId: '',
+        amount: 1000,
+      })
+      expect(true).toBe(false) // 應該拋出錯誤
+    } catch (error) {
+      expect(error).toBeInstanceOf(InvoiceError)
+    }
+  })
+
+  it('應該保存發票到 Repository', async () => {
+    const result = await context.orchestrate({
+      orderId: 'order-123',
+      amount: 1000,
+    })
+
+    const saved = await repository.findById(result.id)
+    expect(saved).toBeDefined()
+    expect(saved.orderId).toBe('order-123')
+  })
+
+  it('應該能透過 orderId 查詢已開立的發票', async () => {
+    const result = await context.orchestrate({
+      orderId: 'order-123',
+      amount: 1000,
+    })
+
+    const saved = await repository.findByOrderId('order-123')
+    expect(saved).toBeDefined()
+    expect(saved.id).toBe(result.id)
+  })
+
+  it('應該生成不同的發票號碼', async () => {
+    const result1 = await context.orchestrate({
+      orderId: 'order-1',
+      amount: 1000,
+    })
+
+    const result2 = await context.orchestrate({
+      orderId: 'order-2',
+      amount: 1000,
+    })
+
+    expect(result1.invoiceNumber).not.toBe(result2.invoiceNumber)
+  })
+})