# Run all tests
npm run test

# Run tests in watch mode
npm run test:watch

# Run specific test file
npm run test -- test/unit/utils/buildWhereClause.test.ts

# Run D1 tests
npm run test:d1

packages/@websideproject/nuxt-auto-api/
├── test/
│   ├── fixtures/          # Test apps for E2E
│   │   ├── basic/         # Basic CRUD test app
│   │   └── auth/          # With authentication
│   ├── unit/              # Unit tests
│   │   ├── utils/         # Utility function tests
│   │   └── middleware/    # Middleware tests
│   ├── integration/       # Integration tests
│   ├── e2e/               # End-to-end tests
│   └── helpers/           # Test utilities
│       ├── setup.ts       # SQLite setup
│       ├── setup-d1.ts    # D1 setup
│       ├── factories.ts   # Data factories
│       └── mocks.ts       # Mock utilities

// test/unit/utils/buildWhereClause.test.ts
import { describe, it, expect } from 'vitest'
import { sqliteTable, integer, text } from 'drizzle-orm/sqlite-core'
import { buildWhereClause } from '../../../src/runtime/server/utils/buildWhereClause'

const testTable = sqliteTable('test', {
  id: integer('id').primaryKey(),
  name: text('name'),
  age: integer('age')
})

describe('buildWhereClause', () => {
  it('should build simple equality filter', () => {
    const filter = { name: 'John' }
    const result = buildWhereClause(filter, testTable)

    expect(result).toBeDefined()
  })

  it('should handle $gt operator', () => {
    const filter = { age: { $gt: 18 } }
    const result = buildWhereClause(filter, testTable)

    expect(result).toBeDefined()
  })
})

// test/unit/middleware/authz.test.ts
import { describe, it, expect } from 'vitest'
import { createAuthorizationMiddleware } from '../../../src/runtime/server/middleware/authz'
import { createMockContext, createMockUser } from '../../helpers/mocks'

describe('Authorization Middleware', () => {
  it('should allow request with valid permissions', async () => {
    const config = {
      permissions: {
        read: ['user', 'admin']
      }
    }

    const middleware = createAuthorizationMiddleware(config)
    const context = createMockContext({
      user: createMockUser('user'),
      permissions: ['read'],
      operation: 'list'
    })

    await expect(middleware(context)).resolves.not.toThrow()
  })
})

// test/integration/crud.test.ts
import { describe, it, expect, beforeEach, afterEach } from 'vitest'
import { setupTestDatabase, seedDatabase, cleanDatabase } from '../helpers/setup'
import * as baseSchema from '../../playground/server/database/schema'

describe('CRUD Operations Integration', () => {
  let db: any
  let sqlite: any
  let testData: any

  beforeEach(async () => {
    const setup = await setupTestDatabase(baseSchema)
    db = setup.db
    sqlite = setup.sqlite
    testData = await seedDatabase(db, baseSchema)
  })

  afterEach(async () => {
    await cleanDatabase(db, baseSchema)
    sqlite.close()
  })

  it('should return all posts', async () => {
    const context = createMockContext({
      db,
      schema: baseSchema,
      resource: 'posts',
      operation: 'list',
      query: {}
    })

    const result = await listHandler(context)

    expect(result.data).toBeArray()
    expect(result.data.length).toBeGreaterThan(0)
  })
})

// test/e2e/full-flow.test.ts
import { describe, it, expect, beforeAll } from 'vitest'
import { setup, $fetch } from '@nuxt/test-utils/e2e'
import { fileURLToPath } from 'node:url'

describe('Full CRUD Flow E2E', async () => {
  await setup({
    rootDir: fileURLToPath(new URL('../fixtures/basic', import.meta.url))
  })

  it('should complete full user journey', async () => {
    // 1. List posts
    const listResponse = await $fetch('/api/posts')
    expect(listResponse.data).toBeArray()

    // 2. Create post
    const createResponse = await $fetch('/api/posts', {
      method: 'POST',
      headers: { 'Authorization': 'Bearer admin-token' },
      body: {
        title: 'E2E Test Post',
        content: 'Test content',
        userId: 1
      }
    })

    expect(createResponse.data).toBeDefined()
    const postId = createResponse.data.id

    // 3. Get created post
    const getResponse = await $fetch(`/api/posts/${postId}`)
    expect(getResponse.data.id).toBe(postId)

    // 4. Update post
    const updateResponse = await $fetch(`/api/posts/${postId}`, {
      method: 'PATCH',
      headers: { 'Authorization': 'Bearer admin-token' },
      body: { title: 'Updated E2E Post' }
    })

    expect(updateResponse.data.title).toBe('Updated E2E Post')

    // 5. Delete post
    const deleteResponse = await $fetch(`/api/posts/${postId}`, {
      method: 'DELETE',
      headers: { 'Authorization': 'Bearer admin-token' }
    })

    expect(deleteResponse.success).toBe(true)
  })
})

// vitest.config.d1.ts
import { defineWorkersConfig } from '@cloudflare/vitest-pool-workers/config'

export default defineWorkersConfig({
  test: {
    poolOptions: {
      workers: {
        miniflare: {
          d1Databases: {
            DB: 'test-db'
          }
        }
      }
    }
  }
})

// test/integration/crud-d1.test.ts
import { describe, it, expect, beforeEach } from 'vitest'
import { env } from 'cloudflare:test'
import { setupTestD1Database, seedD1Database } from '../helpers/setup-d1'
import * as baseSchema from '../../playground/server/database/schema'

describe('CRUD Operations with D1', () => {
  let db: any
  let d1: D1Database

  beforeEach(async () => {
    const setup = await setupTestD1Database(env.DB, baseSchema)
    db = setup.db
    d1 = setup.d1

    await seedD1Database(db, baseSchema)
  })

  it('should list posts from D1', async () => {
    const context = createMockContext({
      db,
      schema: baseSchema,
      resource: 'posts',
      operation: 'list'
    })

    const result = await listHandler(context)

    expect(result.data).toBeArray()
    expect(result.data.length).toBeGreaterThan(0)
  })
})

// test/helpers/setup.ts
import Database from 'better-sqlite3'
import { drizzle } from 'drizzle-orm/better-sqlite3'

export async function setupTestDatabase(schema: any) {
  const sqlite = new Database(':memory:')
  const db = drizzle(sqlite, { schema })
  return { db, sqlite }
}

export async function seedDatabase(db: any, schema: any) {
  const users = await db.insert(schema.users).values([
    { email: 'admin@test.com', name: 'Admin', role: 'admin' },
    { email: 'user@test.com', name: 'User', role: 'user' }
  ]).returning()

  const posts = await db.insert(schema.posts).values([
    { title: 'Post 1', content: 'Content 1', userId: users[0].id }
  ]).returning()

  return { users, posts }
}

export async function cleanDatabase(db: any, schema: any) {
  await db.delete(schema.posts)
  await db.delete(schema.users)
}

// test/helpers/mocks.ts
export function createMockContext(overrides = {}) {
  return {
    db: null,
    schema: {},
    user: null,
    permissions: [],
    params: {},
    query: {},
    validated: {},
    event: createMockH3Event(),
    resource: 'posts',
    operation: 'list',
    ...overrides
  }
}

export function createMockUser(role = 'user', overrides = {}) {
  return {
    id: 1,
    email: 'test@example.com',
    name: 'Test User',
    role,
    permissions: getRolePermissions(role),
    ...overrides
  }
}

// test/helpers/factories.ts
export const UserFactory = {
  build: (overrides = {}) => ({
    email: `test${Date.now()}@example.com`,
    name: 'Test User',
    role: 'user',
    ...overrides
  }),

  create: async (db, schema, overrides = {}) => {
    const [user] = await db.insert(schema.users)
      .values(UserFactory.build(overrides))
      .returning()
    return user
  }
}

npm run test -- --coverage