@etus/bhono-app 0.1.1

package/templates/base/src/server/__tests__/mocks/r2.ts

@@ -0,0 +1,397 @@
+// src/server/__tests__/mocks/r2.ts
+import { vi } from 'vitest'
+
+/**
+ * Stored R2 object data
+ */
+interface StoredR2Object {
+  key: string
+  body: ArrayBuffer
+  httpMetadata?: R2HTTPMetadata
+  customMetadata?: Record<string, string>
+  uploaded: Date
+}
+
+/**
+ * Mock R2 Object interface
+ */
+export interface MockR2Object {
+  key: string
+  version: string
+  size: number
+  etag: string
+  httpEtag: string
+  checksums: R2Checksums
+  uploaded: Date
+  httpMetadata?: R2HTTPMetadata
+  customMetadata?: Record<string, string>
+  range?: R2Range
+  storageClass: string
+  body: ReadableStream
+  bodyUsed: boolean
+  arrayBuffer: () => Promise<ArrayBuffer>
+  text: () => Promise<string>
+  json: <T>() => Promise<T>
+  blob: () => Promise<Blob>
+  writeHttpMetadata: (headers: Headers) => void
+}
+
+/**
+ * Mock R2 Object Body (for get operations)
+ */
+export interface MockR2ObjectBody extends MockR2Object {
+  body: ReadableStream
+  bodyUsed: boolean
+}
+
+/**
+ * Mock R2 Objects list response
+ */
+export interface MockR2Objects {
+  objects: MockR2Object[]
+  truncated: boolean
+  cursor?: string
+  delimitedPrefixes: string[]
+}
+
+/**
+ * Mock R2 Bucket interface
+ */
+export interface MockR2Bucket {
+  head: ReturnType<typeof vi.fn>
+  get: ReturnType<typeof vi.fn>
+  put: ReturnType<typeof vi.fn>
+  delete: ReturnType<typeof vi.fn>
+  list: ReturnType<typeof vi.fn>
+  createMultipartUpload: ReturnType<typeof vi.fn>
+  resumeMultipartUpload: ReturnType<typeof vi.fn>
+  _store: Map<string, StoredR2Object>
+}
+
+/**
+ * Generate a simple etag from content
+ */
+function generateEtag(content: ArrayBuffer): string {
+  // Simple hash for testing purposes
+  const view = new Uint8Array(content)
+  let hash = 0
+  for (let i = 0; i < view.length; i++) {
+    hash = ((hash << 5) - hash + view[i]) | 0
+  }
+  return `"${Math.abs(hash).toString(16)}"`
+}
+
+/**
+ * Create a mock R2Object from stored data
+ */
+function createMockR2Object(stored: StoredR2Object, includeBody = false): MockR2Object {
+  const etag = generateEtag(stored.body)
+  let bodyUsed = false
+
+  const obj: MockR2Object = {
+    key: stored.key,
+    version: crypto.randomUUID(),
+    size: stored.body.byteLength,
+    etag,
+    httpEtag: etag,
+    checksums: {
+      toJSON: () => ({}),
+    } as R2Checksums,
+    uploaded: stored.uploaded,
+    httpMetadata: stored.httpMetadata,
+    customMetadata: stored.customMetadata,
+    storageClass: 'Standard',
+    body: new ReadableStream({
+      start(controller) {
+        if (includeBody) {
+          controller.enqueue(new Uint8Array(stored.body))
+        }
+        controller.close()
+      },
+    }),
+    bodyUsed,
+    arrayBuffer: async () => {
+      if (bodyUsed) throw new Error('Body already used')
+      bodyUsed = true
+      return stored.body
+    },
+    text: async () => {
+      if (bodyUsed) throw new Error('Body already used')
+      bodyUsed = true
+      return new TextDecoder().decode(stored.body)
+    },
+    json: async <T>() => {
+      if (bodyUsed) throw new Error('Body already used')
+      bodyUsed = true
+      return JSON.parse(new TextDecoder().decode(stored.body)) as T
+    },
+    blob: async () => {
+      if (bodyUsed) throw new Error('Body already used')
+      bodyUsed = true
+      return new Blob([stored.body], { type: stored.httpMetadata?.contentType })
+    },
+    writeHttpMetadata: (headers: Headers) => {
+      if (stored.httpMetadata?.contentType) {
+        headers.set('content-type', stored.httpMetadata.contentType)
+      }
+      if (stored.httpMetadata?.contentDisposition) {
+        headers.set('content-disposition', stored.httpMetadata.contentDisposition)
+      }
+      if (stored.httpMetadata?.contentEncoding) {
+        headers.set('content-encoding', stored.httpMetadata.contentEncoding)
+      }
+      if (stored.httpMetadata?.contentLanguage) {
+        headers.set('content-language', stored.httpMetadata.contentLanguage)
+      }
+      if (stored.httpMetadata?.cacheControl) {
+        headers.set('cache-control', stored.httpMetadata.cacheControl)
+      }
+      if (stored.httpMetadata?.cacheExpiry) {
+        headers.set('expires', stored.httpMetadata.cacheExpiry.toUTCString())
+      }
+    },
+  }
+
+  return obj
+}
+
+/**
+ * Convert various input types to ArrayBuffer
+ */
+async function toArrayBuffer(
+  body: ArrayBuffer | ArrayBufferView | string | Blob | ReadableStream | null
+): Promise<ArrayBuffer> {
+  if (body === null) {
+    return new ArrayBuffer(0)
+  }
+
+  if (body instanceof ArrayBuffer) {
+    return body
+  }
+
+  if (ArrayBuffer.isView(body)) {
+    return body.buffer.slice(body.byteOffset, body.byteOffset + body.byteLength)
+  }
+
+  if (typeof body === 'string') {
+    return new TextEncoder().encode(body).buffer
+  }
+
+  if (body instanceof Blob) {
+    return body.arrayBuffer()
+  }
+
+  if (body instanceof ReadableStream) {
+    const reader = body.getReader()
+    const chunks: Uint8Array[] = []
+    let done = false
+    while (!done) {
+      const result = await reader.read()
+      done = result.done
+      if (result.value) {
+        chunks.push(result.value)
+      }
+    }
+    const totalLength = chunks.reduce((acc, chunk) => acc + chunk.length, 0)
+    const combined = new Uint8Array(totalLength)
+    let offset = 0
+    for (const chunk of chunks) {
+      combined.set(chunk, offset)
+      offset += chunk.length
+    }
+    return combined.buffer
+  }
+
+  throw new Error('Unsupported body type')
+}
+
+/**
+ * Creates a mock R2 bucket with in-memory Map store
+ */
+export function createMockR2(): MockR2Bucket {
+  const store = new Map<string, StoredR2Object>()
+
+  const bucket: MockR2Bucket = {
+    _store: store,
+
+    head: vi.fn(async (key: string): Promise<MockR2Object | null> => {
+      const stored = store.get(key)
+      if (!stored) return null
+      return createMockR2Object(stored, false)
+    }),
+
+    get: vi.fn(
+      async (
+        key: string,
+        options?: R2GetOptions
+      ): Promise<MockR2ObjectBody | MockR2Object | null> => {
+        const stored = store.get(key)
+        if (!stored) return null
+
+        // Handle conditional requests
+        if (options?.onlyIf) {
+          const etag = generateEtag(stored.body)
+          const cond = options.onlyIf
+
+          if (cond.etagMatches && cond.etagMatches !== etag) {
+            return createMockR2Object(stored, false) as MockR2Object
+          }
+          if (cond.etagDoesNotMatch && cond.etagDoesNotMatch === etag) {
+            return createMockR2Object(stored, false) as MockR2Object
+          }
+        }
+
+        return createMockR2Object(stored, true) as MockR2ObjectBody
+      }
+    ),
+
+    put: vi.fn(
+      async (
+        key: string,
+        value: ArrayBuffer | ArrayBufferView | string | Blob | ReadableStream | null,
+        options?: R2PutOptions
+      ): Promise<MockR2Object> => {
+        const body = await toArrayBuffer(value)
+
+        const stored: StoredR2Object = {
+          key,
+          body,
+          httpMetadata: options?.httpMetadata,
+          customMetadata: options?.customMetadata,
+          uploaded: new Date(),
+        }
+
+        store.set(key, stored)
+        return createMockR2Object(stored, false)
+      }
+    ),
+
+    delete: vi.fn(async (keys: string | string[]): Promise<void> => {
+      const keyArray = Array.isArray(keys) ? keys : [keys]
+      for (const key of keyArray) {
+        store.delete(key)
+      }
+    }),
+
+    list: vi.fn(async (options?: R2ListOptions): Promise<MockR2Objects> => {
+      const prefix = options?.prefix ?? ''
+      const limit = options?.limit ?? 1000
+      const delimiter = options?.delimiter
+
+      const objects: MockR2Object[] = []
+      const delimitedPrefixes = new Set<string>()
+
+      for (const [key, stored] of store.entries()) {
+        if (!key.startsWith(prefix)) continue
+
+        if (delimiter) {
+          const remainder = key.slice(prefix.length)
+          const delimiterIndex = remainder.indexOf(delimiter)
+          if (delimiterIndex !== -1) {
+            delimitedPrefixes.add(prefix + remainder.slice(0, delimiterIndex + 1))
+            continue
+          }
+        }
+
+        objects.push(createMockR2Object(stored, false))
+
+        if (objects.length >= limit) {
+          break
+        }
+      }
+
+      // Sort by key
+      objects.sort((a, b) => a.key.localeCompare(b.key))
+
+      return {
+        objects,
+        truncated: objects.length >= limit,
+        delimitedPrefixes: [...delimitedPrefixes].sort(),
+      }
+    }),
+
+    createMultipartUpload: vi.fn(async (key: string, options?: R2MultipartOptions) => {
+      // Basic multipart upload mock - not fully implemented
+      return {
+        key,
+        uploadId: crypto.randomUUID(),
+        uploadPart: vi.fn(),
+        abort: vi.fn(),
+        complete: vi.fn(),
+      }
+    }),
+
+    resumeMultipartUpload: vi.fn(async (key: string, uploadId: string) => {
+      return {
+        key,
+        uploadId,
+        uploadPart: vi.fn(),
+        abort: vi.fn(),
+        complete: vi.fn(),
+      }
+    }),
+  }
+
+  return bucket
+}
+
+/**
+ * Seeds mock R2 with data
+ * @param r2 The mock R2 bucket
+ * @param data Object mapping keys to values
+ */
+export async function seedMockR2(
+  r2: MockR2Bucket,
+  data: Record<
+    string,
+    | string
+    | ArrayBuffer
+    | {
+        body: string | ArrayBuffer
+        httpMetadata?: R2HTTPMetadata
+        customMetadata?: Record<string, string>
+      }
+  >
+): Promise<void> {
+  for (const [key, entry] of Object.entries(data)) {
+    if (typeof entry === 'string') {
+      r2._store.set(key, {
+        key,
+        body: new TextEncoder().encode(entry).buffer,
+        uploaded: new Date(),
+      })
+    } else if (entry instanceof ArrayBuffer) {
+      r2._store.set(key, {
+        key,
+        body: entry,
+        uploaded: new Date(),
+      })
+    } else {
+      const body =
+        typeof entry.body === 'string' ? new TextEncoder().encode(entry.body).buffer : entry.body
+
+      r2._store.set(key, {
+        key,
+        body,
+        httpMetadata: entry.httpMetadata,
+        customMetadata: entry.customMetadata,
+        uploaded: new Date(),
+      })
+    }
+  }
+}
+
+/**
+ * Clears all data from the mock R2
+ * @param r2 The mock R2 bucket
+ */
+export function clearMockR2(r2: MockR2Bucket): void {
+  r2._store.clear()
+}
+
+/**
+ * Creates a mock R2 that conforms to the Cloudflare R2Bucket type
+ */
+export function createMockR2AsR2Bucket(): R2Bucket {
+  return createMockR2() as unknown as R2Bucket
+}

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

@@ -0,0 +1,281 @@
+// src/server/__tests__/setup.ts
+import { vi, beforeEach, afterEach } from 'vitest'
+import type { Env } from '../env'
+import type { SessionData } from '../types'
+import { createMockD1, createMockD1AsD1Database, type MockD1Database } from './mocks/db'
+import {
+  createMockKV,
+  createMockKVAsKVNamespace,
+  seedMockKV,
+  type MockKVNamespace,
+} from './mocks/kv'
+import { createMockR2, createMockR2AsR2Bucket, type MockR2Bucket } from './mocks/r2'
+
+// Re-export mocks for convenience
+export * from './mocks/db'
+export * from './mocks/kv'
+export * from './mocks/r2'
+
+/**
+ * Default environment configuration for tests
+ */
+export const DEFAULT_TEST_ENV = {
+  ENVIRONMENT: 'test',
+  APP_URL: 'http://localhost:8787',
+  JWT_SECRET: 'test-jwt-secret-key-for-testing-only',
+  JWT_EXPIRY_MINUTES: '15',
+  GOOGLE_CLIENT_ID: 'test-google-client-id',
+  GOOGLE_CLIENT_SECRET: 'test-google-client-secret',
+  GOOGLE_REDIRECT_URI: 'http://localhost:8787/api/auth/google/callback',
+  REFRESH_TOKEN_EXPIRY_DAYS: '30',
+  SENDGRID_API_KEY: 'test-sendgrid-api-key',
+  SENDGRID_FROM_EMAIL: 'test@example.com',
+  R2_PUBLIC_URL: 'https://r2-test.example.com',
+  CORS_ORIGINS: 'http://localhost:3000,http://localhost:5173',
+} as const
+
+/**
+ * Mock environment with typed mocks
+ */
+export interface MockEnv extends Env {
+  DB: D1Database & { _mock: MockD1Database }
+  SESSIONS: KVNamespace & { _mock: MockKVNamespace }
+  R2_BUCKET: R2Bucket & { _mock: MockR2Bucket }
+}
+
+/**
+ * Creates a complete mock environment for testing
+ * @param overrides Partial env values to override defaults
+ */
+export function createMockEnv(overrides?: Partial<Env>): MockEnv {
+  const mockDb = createMockD1()
+  const mockKv = createMockKV()
+  const mockR2 = createMockR2()
+
+  // Create typed DB with internal mock reference
+  const db = createMockD1AsD1Database() as D1Database & { _mock: MockD1Database }
+  ;(db as any)._mock = mockDb
+  // Copy mock methods to the D1Database interface
+  Object.assign(db, mockDb)
+
+  // Create typed KV with internal mock reference
+  const kv = createMockKVAsKVNamespace() as KVNamespace & { _mock: MockKVNamespace }
+  ;(kv as any)._mock = mockKv
+  // Copy mock methods to the KVNamespace interface
+  Object.assign(kv, mockKv)
+
+  // Create typed R2 with internal mock reference
+  const r2 = createMockR2AsR2Bucket() as R2Bucket & { _mock: MockR2Bucket }
+  ;(r2 as any)._mock = mockR2
+  // Copy mock methods to the R2Bucket interface
+  Object.assign(r2, mockR2)
+
+  // Create mock ASSETS fetcher
+  const assets: Fetcher = {
+    fetch: vi.fn(async (input: RequestInfo, init?: RequestInit) => {
+      return new Response('Not Found', { status: 404 })
+    }),
+    connect: vi.fn(),
+  } as unknown as Fetcher
+
+  return {
+    DB: db,
+    SESSIONS: kv,
+    ASSETS: assets,
+    R2_BUCKET: r2,
+    ...DEFAULT_TEST_ENV,
+    ...overrides,
+  } as MockEnv
+}
+
+/**
+ * Creates authentication headers with session cookie
+ * @param sessionToken The session token/ID
+ * @param accountId Optional account ID header
+ */
+export function createAuthHeaders(sessionToken: string, accountId?: string): Headers {
+  const headers = new Headers()
+  headers.set('Cookie', `sid=${sessionToken}`)
+
+  if (accountId) {
+    headers.set('X-Account-ID', accountId)
+  }
+
+  return headers
+}
+
+/**
+ * Creates a mock session in KV storage
+ * @param kv The mock KV namespace
+ * @param token The session token
+ * @param userId The user ID
+ * @param sessionData Additional session data
+ * @param ttlSeconds Optional TTL in seconds (default: 86400 = 24 hours)
+ */
+export async function createMockSession(
+  kv: MockKVNamespace | KVNamespace,
+  token: string,
+  userId: string,
+  sessionData: Partial<Omit<SessionData, 'userId'>> = {},
+  ttlSeconds = 86400
+): Promise<void> {
+  const data: SessionData = {
+    userId,
+    email: sessionData.email ?? `user-${userId}@example.com`,
+    name: sessionData.name ?? `User ${userId}`,
+    avatarUrl: sessionData.avatarUrl ?? null,
+    isSuperAdmin: sessionData.isSuperAdmin ?? false,
+    fingerprint: sessionData.fingerprint ?? {
+      ip: '127.0.0.1',
+      userAgent: 'TestAgent/1.0',
+    },
+  }
+
+  const key = `sid:${token}`
+  await kv.put(key, JSON.stringify(data), { expirationTtl: ttlSeconds })
+}
+
+/**
+ * Creates an expired session in KV storage (for testing expiration)
+ * @param kv The mock KV namespace
+ * @param token The session token
+ * @param userId The user ID
+ * @param sessionData Additional session data
+ */
+export async function createExpiredSession(
+  kv: MockKVNamespace | KVNamespace,
+  token: string,
+  userId: string,
+  sessionData: Partial<Omit<SessionData, 'userId'>> = {}
+): Promise<void> {
+  const data: SessionData = {
+    userId,
+    email: sessionData.email ?? `user-${userId}@example.com`,
+    name: sessionData.name ?? `User ${userId}`,
+    avatarUrl: sessionData.avatarUrl ?? null,
+    isSuperAdmin: sessionData.isSuperAdmin ?? false,
+    fingerprint: sessionData.fingerprint ?? {
+      ip: '127.0.0.1',
+      userAgent: 'TestAgent/1.0',
+    },
+  }
+
+  const key = `sid:${token}`
+
+  // For MockKVNamespace, we can directly set with past expiration
+  if ('_store' in kv) {
+    const mockKv = kv as MockKVNamespace
+    mockKv._store.set(key, {
+      value: JSON.stringify(data),
+      expirationTtl: 1, // 1 second TTL
+      storedAt: Date.now() - 2000, // Stored 2 seconds ago (already expired)
+    })
+  } else {
+    // For real KV in integration tests, use a very short TTL
+    await kv.put(key, JSON.stringify(data), { expirationTtl: 1 })
+  }
+}
+
+/**
+ * Global test setup - call in beforeEach
+ */
+export function setupTestEnvironment(): void {
+  vi.clearAllMocks()
+}
+
+/**
+ * Global test teardown - call in afterEach
+ */
+export function teardownTestEnvironment(): void {
+  vi.restoreAllMocks()
+}
+
+/**
+ * Setup hooks for test files
+ * Import and call this in your test file to automatically setup/teardown
+ */
+export function registerTestLifecycle(): void {
+  beforeEach(() => {
+    setupTestEnvironment()
+  })
+
+  afterEach(() => {
+    teardownTestEnvironment()
+  })
+}
+
+/**
+ * Create a mock Request object for testing handlers
+ * @param method HTTP method
+ * @param url URL string or path
+ * @param options Request options
+ */
+export function createMockRequest(
+  method: string,
+  url: string,
+  options?: {
+    body?: unknown
+    headers?: Headers | Record<string, string>
+    sessionToken?: string
+    accountId?: string
+  }
+): Request {
+  const fullUrl = url.startsWith('http') ? url : `http://localhost:8787${url}`
+
+  const headers = new Headers()
+
+  // Add custom headers
+  if (options?.headers) {
+    if (options.headers instanceof Headers) {
+      options.headers.forEach((value, key) => {
+        headers.set(key, value)
+      })
+    } else {
+      for (const [key, value] of Object.entries(options.headers)) {
+        headers.set(key, value)
+      }
+    }
+  }
+
+  // Add session cookie
+  if (options?.sessionToken) {
+    headers.set('Cookie', `sid=${options.sessionToken}`)
+  }
+
+  // Add account ID header
+  if (options?.accountId) {
+    headers.set('X-Account-ID', options.accountId)
+  }
+
+  // Set content type for JSON body
+  if (options?.body && !headers.has('Content-Type')) {
+    headers.set('Content-Type', 'application/json')
+  }
+
+  const init: RequestInit = {
+    method,
+    headers,
+  }
+
+  if (options?.body) {
+    init.body = JSON.stringify(options.body)
+  }
+
+  return new Request(fullUrl, init)
+}
+
+/**
+ * Helper to extract JSON from Response
+ * @param response Response object
+ */
+export async function getResponseJson<T = unknown>(response: Response): Promise<T> {
+  return response.json() as Promise<T>
+}
+
+/**
+ * Helper to check if response is successful
+ * @param response Response object
+ */
+export function isSuccessResponse(response: Response): boolean {
+  return response.ok && response.status >= 200 && response.status < 300
+}