@etus/bhono-app 0.1.1

package/templates/base/tests/integration/fixtures/accounts.ts

@@ -0,0 +1,136 @@
+/**
+ * Account Fixtures for Integration Tests
+ *
+ * Provides factory functions for creating accounts and user-account
+ * relationships in the test database.
+ */
+
+import { getSqlite } from '../setup'
+
+// ============================================================================
+// TYPES
+// ============================================================================
+
+export type Role = 'ADMIN' | 'MANAGER' | 'EDITOR' | 'AUTHOR' | 'VIEWER' | 'BILLING' | 'ANALYTICS'
+
+export interface CreateAccountOptions {
+  id?: string
+  name?: string
+  description?: string | null
+  domain?: string | null
+  deletedAt?: string | null
+}
+
+export interface CreatedAccount {
+  id: string
+  name: string
+  description: string | null
+  domain: string | null
+  deletedAt: string | null
+}
+
+// ============================================================================
+// HELPER FUNCTIONS
+// ============================================================================
+
+let accountCounter = 0
+
+function generateAccountDefaults(): { id: string; name: string } {
+  accountCounter++
+  return {
+    id: crypto.randomUUID(),
+    name: `Test Account ${accountCounter}`,
+  }
+}
+
+// ============================================================================
+// FIXTURE FACTORIES
+// ============================================================================
+
+/**
+ * Create an account in the database with defaults
+ */
+export async function createAccount(options: CreateAccountOptions = {}): Promise<CreatedAccount> {
+  const db = getSqlite()
+  const defaults = generateAccountDefaults()
+
+  const account: CreatedAccount = {
+    id: options.id ?? defaults.id,
+    name: options.name ?? defaults.name,
+    description: options.description ?? null,
+    domain: options.domain ?? null,
+    deletedAt: options.deletedAt ?? null,
+  }
+
+  db.prepare(`
+    INSERT INTO accounts (id, name, description, domain, deleted_at)
+    VALUES (?, ?, ?, ?, ?)
+  `).run(
+    account.id,
+    account.name,
+    account.description,
+    account.domain,
+    account.deletedAt
+  )
+
+  return account
+}
+
+/**
+ * Create a soft-deleted account
+ */
+export async function createDeletedAccount(options: CreateAccountOptions = {}): Promise<CreatedAccount> {
+  const deletedAt = options.deletedAt ?? new Date().toISOString()
+  return createAccount({
+    ...options,
+    deletedAt,
+  })
+}
+
+/**
+ * Add a user to an account with a specific role
+ */
+export async function addUserToAccount(
+  userId: string,
+  accountId: string,
+  role: Role
+): Promise<{ userId: string; accountId: string; role: Role }> {
+  const db = getSqlite()
+
+  db.prepare(`
+    INSERT INTO user_accounts (user_id, account_id, role)
+    VALUES (?, ?, ?)
+  `).run(userId, accountId, role)
+
+  return { userId, accountId, role }
+}
+
+/**
+ * Get all accounts for a user
+ */
+export async function getUserAccounts(userId: string): Promise<{ accountId: string; role: Role }[]> {
+  const db = getSqlite()
+  const rows = db.prepare(`
+    SELECT account_id, role FROM user_accounts WHERE user_id = ?
+  `).all(userId) as { account_id: string; role: Role }[]
+
+  return rows.map((row) => ({
+    accountId: row.account_id,
+    role: row.role,
+  }))
+}
+
+/**
+ * Get all users for an account
+ */
+export async function getAccountUsers(accountId: string): Promise<{ userId: string; role: Role }[]> {
+  const db = getSqlite()
+  const rows = db.prepare(`
+    SELECT user_id, role FROM user_accounts WHERE account_id = ?
+  `).all(accountId) as { user_id: string; role: Role }[]
+
+  return rows.map((row) => ({
+    userId: row.user_id,
+    role: row.role,
+  }))
+}

package/templates/base/tests/integration/fixtures/index.ts

@@ -0,0 +1,232 @@
+/**
+ * Integration Test Fixtures
+ *
+ * Re-exports all fixture factories and provides composite scenario builders
+ * for creating complex test setups.
+ */
+
+// Re-export all fixture factories
+export * from './users'
+export * from './accounts'
+export * from './invitations'
+
+// Import for internal use
+import { createUser, createSuperAdmin, createUserSession, type CreatedUser } from './users'
+import { createAccount, addUserToAccount, type CreatedAccount, type Role } from './accounts'
+
+// ============================================================================
+// TYPES
+// ============================================================================
+
+export interface TestScenarioOptions {
+  userName?: string
+  userEmail?: string
+  isSuperAdmin?: boolean
+  accountName?: string
+  role?: Role
+}
+
+export interface TestScenarioResult {
+  user: CreatedUser
+  account: CreatedAccount
+  sessionId: string
+  headers: Record<string, string>
+}
+
+export interface MultiUserScenarioResult {
+  account: CreatedAccount
+  admin: {
+    user: CreatedUser
+    sessionId: string
+    headers: Record<string, string>
+  }
+  manager: {
+    user: CreatedUser
+    sessionId: string
+    headers: Record<string, string>
+  }
+  viewer: {
+    user: CreatedUser
+    sessionId: string
+    headers: Record<string, string>
+  }
+}
+
+export interface MultiTenantScenarioResult {
+  user: CreatedUser
+  sessionId: string
+  headers: Record<string, string>
+  accounts: {
+    withAccess: { account: CreatedAccount; role: Role }[]
+    withoutAccess: CreatedAccount[]
+  }
+}
+
+// ============================================================================
+// COMPOSITE SCENARIO BUILDERS
+// ============================================================================
+
+/**
+ * Create a complete test scenario with user, account, membership, and session
+ *
+ * This is the most common setup for integration tests - a user who is
+ * a member of an account and has an active session.
+ */
+export async function createTestScenario(
+  options: TestScenarioOptions = {}
+): Promise<TestScenarioResult> {
+  // Create user
+  const user = options.isSuperAdmin
+    ? await createSuperAdmin({
+        name: options.userName,
+        email: options.userEmail,
+      })
+    : await createUser({
+        name: options.userName,
+        email: options.userEmail,
+      })
+
+  // Create account
+  const account = await createAccount({
+    name: options.accountName,
+  })
+
+  // Add user to account
+  await addUserToAccount(user.id, account.id, options.role ?? 'ADMIN')
+
+  // Create session
+  const { sessionId, headers } = await createUserSession(user.id, {
+    email: user.email,
+    name: user.name,
+    isSuperAdmin: user.isSuperAdmin,
+  })
+
+  return {
+    user,
+    account,
+    sessionId,
+    headers,
+  }
+}
+
+/**
+ * Create a multi-user scenario with admin, manager, and viewer in one account
+ *
+ * Useful for testing role-based access control across different permission levels.
+ */
+export async function createMultiUserScenario(): Promise<MultiUserScenarioResult> {
+  // Create account
+  const account = await createAccount({
+    name: 'Multi-User Test Account',
+  })
+
+  // Create admin user
+  const adminUser = await createUser({
+    name: 'Admin User',
+    email: 'admin@example.com',
+  })
+  await addUserToAccount(adminUser.id, account.id, 'ADMIN')
+  const adminSession = await createUserSession(adminUser.id, {
+    email: adminUser.email,
+    name: adminUser.name,
+  })
+
+  // Create manager user
+  const managerUser = await createUser({
+    name: 'Manager User',
+    email: 'manager@example.com',
+  })
+  await addUserToAccount(managerUser.id, account.id, 'MANAGER')
+  const managerSession = await createUserSession(managerUser.id, {
+    email: managerUser.email,
+    name: managerUser.name,
+  })
+
+  // Create viewer user
+  const viewerUser = await createUser({
+    name: 'Viewer User',
+    email: 'viewer@example.com',
+  })
+  await addUserToAccount(viewerUser.id, account.id, 'VIEWER')
+  const viewerSession = await createUserSession(viewerUser.id, {
+    email: viewerUser.email,
+    name: viewerUser.name,
+  })
+
+  return {
+    account,
+    admin: {
+      user: adminUser,
+      sessionId: adminSession.sessionId,
+      headers: adminSession.headers,
+    },
+    manager: {
+      user: managerUser,
+      sessionId: managerSession.sessionId,
+      headers: managerSession.headers,
+    },
+    viewer: {
+      user: viewerUser,
+      sessionId: viewerSession.sessionId,
+      headers: viewerSession.headers,
+    },
+  }
+}
+
+/**
+ * Create a multi-tenant scenario with a user who has access to some accounts but not others
+ *
+ * Useful for testing tenant isolation and cross-account access control.
+ */
+export async function createMultiTenantScenario(): Promise<MultiTenantScenarioResult> {
+  // Create user
+  const user = await createUser({
+    name: 'Multi-Tenant User',
+    email: 'multitenant@example.com',
+  })
+
+  // Create accounts with access (different roles)
+  const accountWithAdminAccess = await createAccount({
+    name: 'Account With Admin Access',
+  })
+  await addUserToAccount(user.id, accountWithAdminAccess.id, 'ADMIN')
+
+  const accountWithManagerAccess = await createAccount({
+    name: 'Account With Manager Access',
+  })
+  await addUserToAccount(user.id, accountWithManagerAccess.id, 'MANAGER')
+
+  const accountWithViewerAccess = await createAccount({
+    name: 'Account With Viewer Access',
+  })
+  await addUserToAccount(user.id, accountWithViewerAccess.id, 'VIEWER')
+
+  // Create accounts without access
+  const accountWithoutAccess1 = await createAccount({
+    name: 'Account Without Access 1',
+  })
+
+  const accountWithoutAccess2 = await createAccount({
+    name: 'Account Without Access 2',
+  })
+
+  // Create session
+  const { sessionId, headers } = await createUserSession(user.id, {
+    email: user.email,
+    name: user.name,
+  })
+
+  return {
+    user,
+    sessionId,
+    headers,
+    accounts: {
+      withAccess: [
+        { account: accountWithAdminAccess, role: 'ADMIN' as Role },
+        { account: accountWithManagerAccess, role: 'MANAGER' as Role },
+        { account: accountWithViewerAccess, role: 'VIEWER' as Role },
+      ],
+      withoutAccess: [accountWithoutAccess1, accountWithoutAccess2],
+    },
+  }
+}

package/templates/base/tests/integration/fixtures/invitations.ts

@@ -0,0 +1,195 @@
+/**
+ * Invitation Fixtures for Integration Tests
+ *
+ * Provides factory functions for creating invitations in the test database
+ * with various states (pending, expired, accepted).
+ */
+
+import { getSqlite } from '../setup'
+import type { Role } from './accounts'
+
+// ============================================================================
+// TYPES
+// ============================================================================
+
+export interface CreateInvitationOptions {
+  id?: string
+  accountId: string
+  email?: string
+  role?: Role
+  token?: string
+  invitedById: string
+  expiresAt?: string
+  acceptedAt?: string | null
+}
+
+export interface CreatedInvitation {
+  id: string
+  accountId: string
+  email: string
+  role: Role
+  token: string
+  invitedById: string
+  expiresAt: string
+  acceptedAt: string | null
+}
+
+// ============================================================================
+// HELPER FUNCTIONS
+// ============================================================================
+
+let invitationCounter = 0
+
+function generateInvitationDefaults(): { id: string; email: string; token: string } {
+  invitationCounter++
+  return {
+    id: crypto.randomUUID(),
+    email: `invited${invitationCounter}@example.com`,
+    token: crypto.randomUUID(),
+  }
+}
+
+/**
+ * Get a date string for N days from now
+ */
+function daysFromNow(days: number): string {
+  const date = new Date()
+  date.setDate(date.getDate() + days)
+  return date.toISOString()
+}
+
+/**
+ * Get a date string for N days ago
+ */
+function daysAgo(days: number): string {
+  const date = new Date()
+  date.setDate(date.getDate() - days)
+  return date.toISOString()
+}
+
+// ============================================================================
+// FIXTURE FACTORIES
+// ============================================================================
+
+/**
+ * Create an invitation in the database with defaults
+ */
+export async function createInvitation(options: CreateInvitationOptions): Promise<CreatedInvitation> {
+  const db = getSqlite()
+  const defaults = generateInvitationDefaults()
+
+  const invitation: CreatedInvitation = {
+    id: options.id ?? defaults.id,
+    accountId: options.accountId,
+    email: options.email ?? defaults.email,
+    role: options.role ?? 'VIEWER',
+    token: options.token ?? defaults.token,
+    invitedById: options.invitedById,
+    expiresAt: options.expiresAt ?? daysFromNow(7), // Default: expires in 7 days
+    acceptedAt: options.acceptedAt ?? null,
+  }
+
+  db.prepare(`
+    INSERT INTO invitations (id, account_id, email, role, token, invited_by_id, expires_at, accepted_at)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+  `).run(
+    invitation.id,
+    invitation.accountId,
+    invitation.email,
+    invitation.role,
+    invitation.token,
+    invitation.invitedById,
+    invitation.expiresAt,
+    invitation.acceptedAt
+  )
+
+  return invitation
+}
+
+/**
+ * Create an expired invitation
+ */
+export async function createExpiredInvitation(
+  options: Omit<CreateInvitationOptions, 'expiresAt'>
+): Promise<CreatedInvitation> {
+  return createInvitation({
+    ...options,
+    expiresAt: daysAgo(1), // Expired 1 day ago
+  })
+}
+
+/**
+ * Create an accepted invitation
+ */
+export async function createAcceptedInvitation(
+  options: Omit<CreateInvitationOptions, 'acceptedAt'>
+): Promise<CreatedInvitation> {
+  return createInvitation({
+    ...options,
+    acceptedAt: new Date().toISOString(),
+  })
+}
+
+/**
+ * Get an invitation by token
+ */
+export async function getInvitationByToken(token: string): Promise<CreatedInvitation | null> {
+  const db = getSqlite()
+  const row = db.prepare(`
+    SELECT id, account_id, email, role, token, invited_by_id, expires_at, accepted_at
+    FROM invitations WHERE token = ?
+  `).get(token) as {
+    id: string
+    account_id: string
+    email: string
+    role: Role
+    token: string
+    invited_by_id: string
+    expires_at: string
+    accepted_at: string | null
+  } | undefined
+
+  if (!row) return null
+
+  return {
+    id: row.id,
+    accountId: row.account_id,
+    email: row.email,
+    role: row.role,
+    token: row.token,
+    invitedById: row.invited_by_id,
+    expiresAt: row.expires_at,
+    acceptedAt: row.accepted_at,
+  }
+}
+
+/**
+ * Get all invitations for an account
+ */
+export async function getAccountInvitations(accountId: string): Promise<CreatedInvitation[]> {
+  const db = getSqlite()
+  const rows = db.prepare(`
+    SELECT id, account_id, email, role, token, invited_by_id, expires_at, accepted_at
+    FROM invitations WHERE account_id = ?
+  `).all(accountId) as {
+    id: string
+    account_id: string
+    email: string
+    role: Role
+    token: string
+    invited_by_id: string
+    expires_at: string
+    accepted_at: string | null
+  }[]
+
+  return rows.map((row) => ({
+    id: row.id,
+    accountId: row.account_id,
+    email: row.email,
+    role: row.role,
+    token: row.token,
+    invitedById: row.invited_by_id,
+    expiresAt: row.expires_at,
+    acceptedAt: row.accepted_at,
+  }))
+}

package/templates/base/tests/integration/fixtures/users.ts

@@ -0,0 +1,144 @@
+/**
+ * User Fixtures for Integration Tests
+ *
+ * Provides factory functions for creating users in the test database
+ * with various states (active, inactive, super admin, deleted).
+ */
+
+import { getSqlite, createSession } from '../setup'
+
+// ============================================================================
+// TYPES
+// ============================================================================
+
+export interface CreateUserOptions {
+  id?: string
+  googleId?: string
+  email?: string
+  name?: string
+  avatarUrl?: string | null
+  status?: 'active' | 'inactive'
+  isSuperAdmin?: boolean
+  deletedAt?: string | null
+}
+
+export interface CreatedUser {
+  id: string
+  googleId: string
+  email: string
+  name: string
+  avatarUrl: string | null
+  status: 'active' | 'inactive'
+  isSuperAdmin: boolean
+  deletedAt: string | null
+}
+
+// ============================================================================
+// HELPER FUNCTIONS
+// ============================================================================
+
+let userCounter = 0
+
+function generateUserDefaults(): { id: string; googleId: string; email: string; name: string } {
+  userCounter++
+  const id = crypto.randomUUID()
+  return {
+    id,
+    googleId: `google_${id}`,
+    email: `testuser${userCounter}@example.com`,
+    name: `Test User ${userCounter}`,
+  }
+}
+
+// ============================================================================
+// FIXTURE FACTORIES
+// ============================================================================
+
+/**
+ * Create a user in the database with defaults
+ */
+export async function createUser(options: CreateUserOptions = {}): Promise<CreatedUser> {
+  const db = getSqlite()
+  const defaults = generateUserDefaults()
+
+  const user: CreatedUser = {
+    id: options.id ?? defaults.id,
+    googleId: options.googleId ?? defaults.googleId,
+    email: options.email ?? defaults.email,
+    name: options.name ?? defaults.name,
+    avatarUrl: options.avatarUrl ?? null,
+    status: options.status ?? 'active',
+    isSuperAdmin: options.isSuperAdmin ?? false,
+    deletedAt: options.deletedAt ?? null,
+  }
+
+  db.prepare(`
+    INSERT INTO users (id, google_id, email, name, avatar_url, status, is_super_admin, provider_ids, deleted_at)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+  `).run(
+    user.id,
+    user.googleId,
+    user.email,
+    user.name,
+    user.avatarUrl,
+    user.status,
+    user.isSuperAdmin ? 1 : 0,
+    JSON.stringify(['google']),
+    user.deletedAt
+  )
+
+  return user
+}
+
+/**
+ * Create a super admin user
+ */
+export async function createSuperAdmin(options: CreateUserOptions = {}): Promise<CreatedUser> {
+  return createUser({
+    ...options,
+    isSuperAdmin: true,
+    name: options.name ?? 'Super Admin User',
+  })
+}
+
+/**
+ * Create an inactive user
+ */
+export async function createInactiveUser(options: CreateUserOptions = {}): Promise<CreatedUser> {
+  return createUser({
+    ...options,
+    status: 'inactive',
+  })
+}
+
+/**
+ * Create a soft-deleted user
+ */
+export async function createDeletedUser(options: CreateUserOptions = {}): Promise<CreatedUser> {
+  const deletedAt = options.deletedAt ?? new Date().toISOString()
+  return createUser({
+    ...options,
+    deletedAt,
+  })
+}
+
+/**
+ * Create a session for a user and return session ID and headers
+ */
+export async function createUserSession(
+  userId: string,
+  sessionData?: {
+    email?: string
+    name?: string
+    avatarUrl?: string | null
+    isSuperAdmin?: boolean
+  }
+): Promise<{ sessionId: string; headers: Record<string, string> }> {
+  const { sessionId } = await createSession(userId, sessionData)
+  return {
+    sessionId,
+    headers: {
+      Cookie: `sid=${sessionId}`,
+    },
+  }
+}