@etus/bhono-app 0.1.1

package/templates/base/src/server/__tests__/fixtures.ts

@@ -0,0 +1,461 @@
+// src/server/__tests__/fixtures.ts
+import type { User, Account, SessionData } from '../types'
+import type { Role } from '../auth/roles'
+
+/**
+ * Counter for generating unique IDs
+ */
+let idCounter = 0
+
+/**
+ * Generate a unique test ID
+ */
+function generateTestId(): string {
+  idCounter++
+  return `test-${idCounter}-${Date.now()}`
+}
+
+/**
+ * Reset the ID counter (call in beforeEach if needed)
+ */
+export function resetIdCounter(): void {
+  idCounter = 0
+}
+
+// ============================================================================
+// USER FIXTURES
+// ============================================================================
+
+/**
+ * Base user fixture with sensible defaults
+ */
+export interface UserFixtureOptions {
+  id?: string
+  email?: string
+  name?: string
+  avatarUrl?: string | null
+  status?: 'active' | 'inactive'
+  providerIds?: string[]
+  isSuperAdmin?: boolean
+  createdAt?: string
+  updatedAt?: string
+  deletedAt?: string | null
+}
+
+/**
+ * Creates a standard user fixture
+ */
+export function createUserFixture(options: UserFixtureOptions = {}): User {
+  const id = options.id ?? generateTestId()
+  return {
+    id,
+    email: options.email ?? `user-${id}@example.com`,
+    name: options.name ?? `Test User ${id}`,
+    avatarUrl: options.avatarUrl ?? null,
+    status: options.status ?? 'active',
+    providerIds: options.providerIds ?? ['google'],
+    isSuperAdmin: options.isSuperAdmin ?? false,
+    createdAt: options.createdAt ?? new Date().toISOString(),
+    updatedAt: options.updatedAt ?? new Date().toISOString(),
+    deletedAt: options.deletedAt ?? null,
+  }
+}
+
+/**
+ * Creates an admin user fixture (account-level admin, not super admin)
+ */
+export function createAdminFixture(options: UserFixtureOptions = {}): User {
+  return createUserFixture({
+    name: options.name ?? 'Admin User',
+    ...options,
+  })
+}
+
+/**
+ * Creates a super admin user fixture
+ */
+export function createSuperAdminFixture(options: UserFixtureOptions = {}): User {
+  return createUserFixture({
+    name: options.name ?? 'Super Admin',
+    isSuperAdmin: true,
+    ...options,
+  })
+}
+
+/**
+ * Creates a deleted (soft-deleted) user fixture
+ */
+export function createDeletedUserFixture(options: UserFixtureOptions = {}): User {
+  return createUserFixture({
+    status: 'inactive',
+    deletedAt: options.deletedAt ?? new Date().toISOString(),
+    ...options,
+  })
+}
+
+/**
+ * Creates an inactive user fixture
+ */
+export function createInactiveUserFixture(options: UserFixtureOptions = {}): User {
+  return createUserFixture({
+    status: 'inactive',
+    ...options,
+  })
+}
+
+// ============================================================================
+// ACCOUNT FIXTURES
+// ============================================================================
+
+/**
+ * Account fixture options
+ */
+export interface AccountFixtureOptions {
+  id?: string
+  name?: string
+  description?: string | null
+  domain?: string | null
+  createdAt?: string
+  updatedAt?: string
+  deletedAt?: string | null
+}
+
+/**
+ * Creates a standard account fixture
+ */
+export function createAccountFixture(options: AccountFixtureOptions = {}): Account {
+  const id = options.id ?? generateTestId()
+  return {
+    id,
+    name: options.name ?? `Test Account ${id}`,
+    description: options.description ?? 'A test account for unit tests',
+    domain: options.domain ?? null,
+    createdAt: options.createdAt ?? new Date().toISOString(),
+    updatedAt: options.updatedAt ?? new Date().toISOString(),
+    deletedAt: options.deletedAt ?? null,
+  }
+}
+
+/**
+ * Creates a deleted (soft-deleted) account fixture
+ */
+export function createDeletedAccountFixture(options: AccountFixtureOptions = {}): Account {
+  return createAccountFixture({
+    deletedAt: options.deletedAt ?? new Date().toISOString(),
+    ...options,
+  })
+}
+
+/**
+ * Creates an account with a domain
+ */
+export function createAccountWithDomainFixture(
+  domain: string,
+  options: AccountFixtureOptions = {}
+): Account {
+  return createAccountFixture({
+    domain,
+    ...options,
+  })
+}
+
+// ============================================================================
+// USER-ACCOUNT RELATIONSHIP FIXTURES
+// ============================================================================
+
+/**
+ * User-Account relationship fixture options
+ */
+export interface UserAccountFixtureOptions {
+  userId: string
+  accountId: string
+  role?: Role
+}
+
+/**
+ * Creates a user-account relationship
+ */
+export function createUserAccountFixture(options: UserAccountFixtureOptions): {
+  userId: string
+  accountId: string
+  role: Role
+} {
+  return {
+    userId: options.userId,
+    accountId: options.accountId,
+    role: options.role ?? 'VIEWER',
+  }
+}
+
+// ============================================================================
+// SESSION FIXTURES
+// ============================================================================
+
+/**
+ * Session fixture options
+ */
+export interface SessionFixtureOptions {
+  userId?: string
+  email?: string
+  name?: string
+  avatarUrl?: string | null
+  isSuperAdmin?: boolean
+  fingerprint?: {
+    ip?: string
+    userAgent?: string
+  }
+}
+
+/**
+ * Creates a session data fixture
+ */
+export function createSessionFixture(options: SessionFixtureOptions = {}): SessionData {
+  const userId = options.userId ?? generateTestId()
+  return {
+    userId,
+    email: options.email ?? `session-user-${userId}@example.com`,
+    name: options.name ?? `Session User ${userId}`,
+    avatarUrl: options.avatarUrl ?? null,
+    isSuperAdmin: options.isSuperAdmin ?? false,
+    fingerprint: options.fingerprint ?? {
+      ip: '127.0.0.1',
+      userAgent: 'TestAgent/1.0',
+    },
+  }
+}
+
+/**
+ * Creates a super admin session fixture
+ */
+export function createSuperAdminSessionFixture(options: SessionFixtureOptions = {}): SessionData {
+  return createSessionFixture({
+    name: options.name ?? 'Super Admin Session',
+    isSuperAdmin: true,
+    ...options,
+  })
+}
+
+/**
+ * Creates a session token
+ */
+export function createSessionToken(): string {
+  // Generate a realistic-looking session token
+  const bytes = new Uint8Array(32)
+  for (let i = 0; i < 32; i++) {
+    bytes[i] = Math.floor(Math.random() * 256)
+  }
+  return btoa(String.fromCharCode(...bytes))
+    .replaceAll('+', '-')
+    .replaceAll('/', '_')
+    .replaceAll('=', '')
+}
+
+// ============================================================================
+// REQUEST BODY FIXTURES
+// ============================================================================
+
+/**
+ * Valid create user request body
+ */
+export const validCreateUserBody = {
+  email: 'newuser@example.com',
+  name: 'New User',
+  password: 'SecurePassword123!',
+}
+
+/**
+ * Invalid email request body
+ */
+export const invalidEmailBody = {
+  email: 'not-an-email',
+  name: 'New User',
+  password: 'SecurePassword123!',
+}
+
+/**
+ * Invalid password request body (too short)
+ */
+export const invalidPasswordBody = {
+  email: 'newuser@example.com',
+  name: 'New User',
+  password: '123',
+}
+
+/**
+ * Missing required fields body
+ */
+export const missingFieldsBody = {
+  email: 'newuser@example.com',
+}
+
+/**
+ * Valid login request body
+ */
+export const validLoginBody = {
+  email: 'user@example.com',
+  password: 'SecurePassword123!',
+}
+
+/**
+ * Valid account creation body
+ */
+export const validCreateAccountBody = {
+  name: 'New Account',
+  description: 'A new test account',
+}
+
+/**
+ * Valid account update body
+ */
+export const validUpdateAccountBody = {
+  name: 'Updated Account Name',
+  description: 'Updated description',
+}
+
+/**
+ * Valid user update body
+ */
+export const validUpdateUserBody = {
+  name: 'Updated User Name',
+  status: 'active' as const,
+}
+
+/**
+ * Valid invitation body
+ */
+export const validInvitationBody = {
+  email: 'invited@example.com',
+  role: 'VIEWER' as Role,
+}
+
+// ============================================================================
+// DATABASE RECORD FIXTURES (for mocking D1 responses)
+// ============================================================================
+
+/**
+ * Creates a user database record (matching D1 schema)
+ */
+export function createUserRecord(options: UserFixtureOptions = {}): Record<string, unknown> {
+  const user = createUserFixture(options)
+  return {
+    id: user.id,
+    google_id: `google-${user.id}`,
+    email: user.email,
+    name: user.name,
+    avatar_url: user.avatarUrl,
+    status: user.status,
+    provider_ids: JSON.stringify(user.providerIds),
+    is_super_admin: user.isSuperAdmin ? 1 : 0,
+    created_at: user.createdAt,
+    updated_at: user.updatedAt,
+    deleted_at: user.deletedAt,
+    created_by_id: null,
+    updated_by_id: null,
+    deleted_by_id: null,
+  }
+}
+
+/**
+ * Creates an account database record (matching D1 schema)
+ */
+export function createAccountRecord(options: AccountFixtureOptions = {}): Record<string, unknown> {
+  const account = createAccountFixture(options)
+  return {
+    id: account.id,
+    name: account.name,
+    description: account.description,
+    domain: account.domain,
+    created_at: account.createdAt,
+    updated_at: account.updatedAt,
+    deleted_at: account.deletedAt,
+  }
+}
+
+/**
+ * Creates a user-account database record (matching D1 schema)
+ */
+export function createUserAccountRecord(
+  options: UserAccountFixtureOptions
+): Record<string, unknown> {
+  const ua = createUserAccountFixture(options)
+  return {
+    user_id: ua.userId,
+    account_id: ua.accountId,
+    role: ua.role,
+  }
+}
+
+// ============================================================================
+// BULK FIXTURE CREATORS
+// ============================================================================
+
+/**
+ * Creates multiple user fixtures
+ */
+export function createMultipleUsers(count: number, options: UserFixtureOptions = {}): User[] {
+  return Array.from({ length: count }, (_, i) =>
+    createUserFixture({
+      ...options,
+      name: options.name ? `${options.name} ${i + 1}` : undefined,
+    })
+  )
+}
+
+/**
+ * Creates multiple account fixtures
+ */
+export function createMultipleAccounts(
+  count: number,
+  options: AccountFixtureOptions = {}
+): Account[] {
+  return Array.from({ length: count }, (_, i) =>
+    createAccountFixture({
+      ...options,
+      name: options.name ? `${options.name} ${i + 1}` : undefined,
+    })
+  )
+}
+
+// ============================================================================
+// FIXTURE PRESETS
+// ============================================================================
+
+/**
+ * Preset: A complete test scenario with users, accounts, and relationships
+ */
+export interface TestScenario {
+  superAdmin: User
+  admin: User
+  regularUser: User
+  viewerUser: User
+  deletedUser: User
+  account1: Account
+  account2: Account
+  deletedAccount: Account
+}
+
+/**
+ * Creates a complete test scenario with all common entities
+ */
+export function createTestScenario(): TestScenario {
+  const superAdmin = createSuperAdminFixture({ id: 'super-admin-1' })
+  const admin = createAdminFixture({ id: 'admin-1' })
+  const regularUser = createUserFixture({ id: 'user-1' })
+  const viewerUser = createUserFixture({ id: 'viewer-1', name: 'Viewer User' })
+  const deletedUser = createDeletedUserFixture({ id: 'deleted-user-1' })
+
+  const account1 = createAccountFixture({ id: 'account-1', name: 'Primary Account' })
+  const account2 = createAccountFixture({ id: 'account-2', name: 'Secondary Account' })
+  const deletedAccount = createDeletedAccountFixture({ id: 'deleted-account-1' })
+
+  return {
+    superAdmin,
+    admin,
+    regularUser,
+    viewerUser,
+    deletedUser,
+    account1,
+    account2,
+    deletedAccount,
+  }
+}

package/templates/base/src/server/__tests__/mocks/__tests__/db.test.ts

@@ -0,0 +1,239 @@
+// src/server/__tests__/mocks/__tests__/db.test.ts
+import { describe, it, expect, beforeEach, vi } from 'vitest'
+import {
+  createMockD1,
+  setMockQueryResult,
+  setMockDefaultResult,
+  clearMockQueryResults,
+  type MockD1Database,
+} from '../db'
+
+describe('MockD1Database', () => {
+  let db: MockD1Database
+
+  beforeEach(() => {
+    db = createMockD1()
+    vi.clearAllMocks()
+  })
+
+  describe('createMockD1', () => {
+    it('creates a mock database with all required methods', () => {
+      expect(db.prepare).toBeDefined()
+      expect(db.batch).toBeDefined()
+      expect(db.exec).toBeDefined()
+      expect(db.dump).toBeDefined()
+      expect(db._queryResults).toBeInstanceOf(Map)
+    })
+
+    it('prepare returns a mock prepared statement', () => {
+      const stmt = db.prepare('SELECT * FROM users')
+      expect(stmt).toBeDefined()
+      expect(stmt.bind).toBeDefined()
+      expect(stmt.first).toBeDefined()
+      expect(stmt.all).toBeDefined()
+      expect(stmt.run).toBeDefined()
+      expect(stmt.raw).toBeDefined()
+    })
+  })
+
+  describe('PreparedStatement.bind', () => {
+    it('returns the statement for chaining', () => {
+      const stmt = db.prepare('SELECT * FROM users WHERE id = ?')
+      const bound = stmt.bind('user-1')
+      expect(bound).toBe(stmt)
+    })
+
+    it('accepts multiple parameters', () => {
+      const stmt = db.prepare('SELECT * FROM users WHERE id = ? AND status = ?')
+      const bound = stmt.bind('user-1', 'active')
+      expect(bound).toBe(stmt)
+    })
+  })
+
+  describe('PreparedStatement.first', () => {
+    it('returns null when no results are set', async () => {
+      const stmt = db.prepare('SELECT * FROM users WHERE id = ?')
+      const result = await stmt.bind('user-1').first()
+      expect(result).toBeNull()
+    })
+
+    it('returns the first row when results are set', async () => {
+      const user = { id: 'user-1', name: 'Test User' }
+      setMockQueryResult(db, ['user-1'], [user])
+
+      const stmt = db.prepare('SELECT * FROM users WHERE id = ?')
+      const result = await stmt.bind('user-1').first()
+      expect(result).toEqual(user)
+    })
+
+    it('returns a single column value when column name is provided', async () => {
+      const user = { id: 'user-1', name: 'Test User' }
+      setMockQueryResult(db, ['user-1'], [user])
+
+      const stmt = db.prepare('SELECT * FROM users WHERE id = ?')
+      const result = await stmt.bind('user-1').first('name')
+      expect(result).toBe('Test User')
+    })
+
+    it('returns null for non-existent column', async () => {
+      const user = { id: 'user-1', name: 'Test User' }
+      setMockQueryResult(db, ['user-1'], [user])
+
+      const stmt = db.prepare('SELECT * FROM users WHERE id = ?')
+      const result = await stmt.bind('user-1').first('nonexistent')
+      expect(result).toBeNull()
+    })
+  })
+
+  describe('PreparedStatement.all', () => {
+    it('returns empty results when no results are set', async () => {
+      const stmt = db.prepare('SELECT * FROM users')
+      const result = await stmt.all()
+      expect(result.results).toEqual([])
+      expect(result.success).toBe(true)
+    })
+
+    it('returns all rows when results are set', async () => {
+      const users = [
+        { id: 'user-1', name: 'User 1' },
+        { id: 'user-2', name: 'User 2' },
+      ]
+      setMockDefaultResult(db, users)
+
+      const stmt = db.prepare('SELECT * FROM users')
+      const result = await stmt.all()
+      expect(result.results).toEqual(users)
+      expect(result.success).toBe(true)
+      expect(result.meta).toBeDefined()
+    })
+
+    it('wraps single object result in array', async () => {
+      const user = { id: 'user-1', name: 'User 1' }
+      setMockDefaultResult(db, user)
+
+      const stmt = db.prepare('SELECT * FROM users')
+      const result = await stmt.all()
+      expect(result.results).toEqual([user])
+    })
+  })
+
+  describe('PreparedStatement.run', () => {
+    it('returns success result for mutations', async () => {
+      const stmt = db.prepare('INSERT INTO users (id, name) VALUES (?, ?)')
+      const result = await stmt.bind('user-1', 'Test User').run()
+
+      expect(result.success).toBe(true)
+      expect(result.meta.changes).toBe(1)
+      expect(result.meta.changed_db).toBe(true)
+    })
+  })
+
+  describe('PreparedStatement.raw', () => {
+    it('returns array of arrays instead of objects', async () => {
+      const users = [
+        { id: 'user-1', name: 'User 1' },
+        { id: 'user-2', name: 'User 2' },
+      ]
+      setMockDefaultResult(db, users)
+
+      const stmt = db.prepare('SELECT id, name FROM users')
+      const result = await stmt.raw()
+
+      expect(result).toEqual([
+        ['user-1', 'User 1'],
+        ['user-2', 'User 2'],
+      ])
+    })
+  })
+
+  describe('setMockQueryResult', () => {
+    it('sets results for specific bound values', async () => {
+      const user1 = { id: 'user-1', name: 'User 1' }
+      const user2 = { id: 'user-2', name: 'User 2' }
+
+      setMockQueryResult(db, ['user-1'], [user1])
+      setMockQueryResult(db, ['user-2'], [user2])
+
+      const stmt1 = db.prepare('SELECT * FROM users WHERE id = ?')
+      const result1 = await stmt1.bind('user-1').first()
+      expect(result1).toEqual(user1)
+
+      const stmt2 = db.prepare('SELECT * FROM users WHERE id = ?')
+      const result2 = await stmt2.bind('user-2').first()
+      expect(result2).toEqual(user2)
+    })
+  })
+
+  describe('setMockDefaultResult', () => {
+    it('sets default result for unmatched queries', async () => {
+      const defaultUsers = [{ id: 'default', name: 'Default User' }]
+      setMockDefaultResult(db, defaultUsers)
+
+      const stmt = db.prepare('SELECT * FROM users')
+      const result = await stmt.all()
+      expect(result.results).toEqual(defaultUsers)
+    })
+  })
+
+  describe('clearMockQueryResults', () => {
+    it('clears all query results and default', async () => {
+      setMockQueryResult(db, ['user-1'], [{ id: 'user-1' }])
+      setMockDefaultResult(db, [{ id: 'default' }])
+
+      clearMockQueryResults(db)
+
+      expect(db._queryResults.size).toBe(0)
+      expect(db._defaultResult).toBeNull()
+    })
+  })
+
+  describe('batch', () => {
+    it('executes multiple statements and returns results', async () => {
+      setMockDefaultResult(db, [{ id: 'user-1' }])
+
+      const stmt1 = db.prepare('SELECT * FROM users')
+      const stmt2 = db.prepare('SELECT * FROM accounts')
+
+      const results = await db.batch([stmt1, stmt2])
+
+      expect(results).toHaveLength(2)
+      expect(results[0].results).toEqual([{ id: 'user-1' }])
+      expect(results[1].results).toEqual([{ id: 'user-1' }])
+    })
+  })
+
+  describe('exec', () => {
+    it('executes raw SQL and returns count', async () => {
+      const result = await db.exec('CREATE TABLE test (id TEXT)')
+      expect(result.count).toBe(1)
+      expect(result.duration).toBe(0)
+    })
+  })
+
+  describe('dump', () => {
+    it('returns an empty ArrayBuffer', async () => {
+      const result = await db.dump()
+      expect(result).toBeInstanceOf(ArrayBuffer)
+      expect(result.byteLength).toBe(0)
+    })
+  })
+
+  describe('vi.fn() tracking', () => {
+    it('tracks prepare calls', () => {
+      db.prepare('SELECT * FROM users')
+      db.prepare('SELECT * FROM accounts')
+
+      expect(db.prepare).toHaveBeenCalledTimes(2)
+      expect(db.prepare).toHaveBeenCalledWith('SELECT * FROM users')
+      expect(db.prepare).toHaveBeenCalledWith('SELECT * FROM accounts')
+    })
+
+    it('tracks statement method calls', async () => {
+      const stmt = db.prepare('SELECT * FROM users WHERE id = ?')
+      await stmt.bind('user-1').first()
+
+      expect(stmt.bind).toHaveBeenCalledWith('user-1')
+      expect(stmt.first).toHaveBeenCalled()
+    })
+  })
+})