@stacksjs/bun-router 0.0.14 → 0.0.15

package/src/testing/model-binding-testing.ts

@@ -0,0 +1,645 @@
+import type { EnhancedRequest } from '../types'
+import type { ModelBindingTestOptions } from './types'
+import { mock } from 'bun:test'
+import { createMockRequest } from './test-request'
+
+/**
+ * Generic mock model base class for type annotations
+ */
+export class GenericMockModel {
+  public id: any
+  public attributes: Record<string, any>
+
+  constructor(data: Record<string, any> = {}) {
+    this.id = data.id
+    this.attributes = data
+  }
+
+  static modelName: string = 'GenericMockModel'
+
+  static async find(_id: any): Promise<GenericMockModel | null> {
+    return null
+  }
+
+  static async findOrFail(_id: any): Promise<GenericMockModel> {
+    throw new Error('Not implemented')
+  }
+
+  static async where(_conditions: Record<string, any>): Promise<GenericMockModel[]> {
+    return []
+  }
+
+  static async create(_data: Record<string, any>): Promise<GenericMockModel> {
+    throw new Error('Not implemented')
+  }
+
+  async save(): Promise<GenericMockModel> {
+    return this
+  }
+
+  async delete(): Promise<void> {
+    // Mock deletion
+  }
+
+  toJSON(): Record<string, any> {
+    return { id: this.id, ...this.attributes }
+  }
+}
+
+/**
+ * Mock User class for type annotations
+ */
+export class MockUserClass {
+  public id: number
+  public email: string
+  public name: string
+
+  constructor(data: { id: number, email?: string, name?: string } = { id: 1 }) {
+    this.id = data.id
+    this.email = data.email || 'test@example.com'
+    this.name = data.name || 'Test User'
+  }
+
+  static async find(_id: any): Promise<MockUserClass | null> {
+    return null
+  }
+
+  static async findOrFail(_id: any): Promise<MockUserClass> {
+    throw new Error('Not implemented')
+  }
+
+  toJSON(): Record<string, any> {
+    return { id: this.id, email: this.email, name: this.name }
+  }
+}
+
+/**
+ * Mock Post class for type annotations
+ */
+export class MockPostClass {
+  public id: number
+  public title: string
+  public content: string
+  public userId: number
+
+  constructor(data: { id: number, title?: string, content?: string, userId?: number } = { id: 1 }) {
+    this.id = data.id
+    this.title = data.title || 'Test Post'
+    this.content = data.content || 'Test content'
+    this.userId = data.userId || 1
+  }
+
+  static async find(_id: any): Promise<MockPostClass | null> {
+    return null
+  }
+
+  static async findOrFail(_id: any): Promise<MockPostClass> {
+    throw new Error('Not implemented')
+  }
+
+  async belongsTo(_userId: number): Promise<boolean> {
+    return false
+  }
+
+  toJSON(): Record<string, any> {
+    return { id: this.id, title: this.title, content: this.content, userId: this.userId }
+  }
+}
+
+/**
+ * Model binding testing utilities
+ */
+export class ModelBindingTester {
+  private request: EnhancedRequest
+  private options: ModelBindingTestOptions
+
+  constructor(options: ModelBindingTestOptions = {}) {
+    this.options = options
+    this.request = createMockRequest()
+  }
+
+  /**
+   * Set the request for testing
+   */
+  withRequest(request: EnhancedRequest): ModelBindingTester {
+    this.request = request
+    return this
+  }
+
+  /**
+   * Set route parameters
+   */
+  withParams(params: Record<string, string>): ModelBindingTester {
+    this.request.params = { ...this.request.params, ...params }
+    return this
+  }
+
+  /**
+   * Set the model class to test
+   */
+  withModel(modelClass: any): ModelBindingTester {
+    this.options.modelClass = modelClass
+    return this
+  }
+
+  /**
+   * Set the route key for model binding
+   */
+  withRouteKey(routeKey: string): ModelBindingTester {
+    this.options.routeKey = routeKey
+    return this
+  }
+
+  /**
+   * Set constraints for model binding
+   */
+  withConstraints(constraints: Record<string, any>): ModelBindingTester {
+    this.options.constraints = constraints
+    return this
+  }
+
+  /**
+   * Set a custom resolver function
+   */
+  withResolver(resolver: (value: string) => Promise<any>): ModelBindingTester {
+    this.options.customResolver = resolver
+    return this
+  }
+
+  /**
+   * Test model resolution
+   */
+  async testResolution(paramValue: string): Promise<any> {
+    if (this.options.customResolver) {
+      return await this.options.customResolver(paramValue)
+    }
+
+    // Mock default resolution behavior
+    if (this.options.modelClass) {
+      return new (this.options.modelClass as any)({ id: paramValue })
+    }
+
+    return { id: paramValue }
+  }
+
+  /**
+   * Test model not found scenario
+   */
+  async testNotFound(paramValue: string): Promise<void> {
+    try {
+      await this.testResolution(paramValue)
+      throw new Error('Expected model not found error')
+    }
+    catch (error) {
+      if (error instanceof Error && error.message !== 'Model not found') {
+        throw error
+      }
+    }
+  }
+
+  /**
+   * Get the configured request
+   */
+  getRequest(): EnhancedRequest {
+    return this.request
+  }
+}
+
+/**
+ * Mock model factories
+ */
+export const modelMocks = {
+  /**
+   * Create a mock model class
+   */
+  createModel: (name: string, attributes: Record<string, any> = {}): typeof GenericMockModel => {
+    return class MockModel {
+      public id: any
+      public attributes: Record<string, any>
+
+      constructor(data: Record<string, any> = {}) {
+        this.id = data.id
+        this.attributes = { ...attributes, ...data }
+      }
+
+      static modelName: string = name
+
+      static async find(id: any): Promise<MockModel | null> {
+        if (id === 'not-found')
+          return null
+        return new MockModel({ id, ...attributes })
+      }
+
+      static async findOrFail(id: any): Promise<MockModel> {
+        const model = await this.find(id)
+        if (!model)
+          throw new Error('Model not found')
+        return model
+      }
+
+      static async where(conditions: Record<string, any>): Promise<MockModel[]> {
+        return [new MockModel({ id: 1, ...attributes, ...conditions })]
+      }
+
+      static async create(data: Record<string, any>): Promise<MockModel> {
+        return new MockModel({ id: Date.now(), ...data })
+      }
+
+      async save(): Promise<MockModel> {
+        return this
+      }
+
+      async delete(): Promise<void> {
+        // Mock deletion
+      }
+
+      toJSON(): Record<string, any> {
+        return { id: this.id, ...this.attributes }
+      }
+    } as typeof GenericMockModel
+  },
+
+  /**
+   * Create a User model mock
+   */
+  User: (class MockUser {
+    public id: number
+    public email: string
+    public name: string
+
+    constructor(data: { id: number, email?: string, name?: string } = { id: 1 }) {
+      this.id = data.id
+      this.email = data.email || 'test@example.com'
+      this.name = data.name || 'Test User'
+    }
+
+    static async find(id: any): Promise<MockUser | null> {
+      if (id === 'not-found')
+        return null
+      return new MockUser({ id: Number.parseInt(id) })
+    }
+
+    static async findOrFail(id: any): Promise<MockUser> {
+      const user = await this.find(id)
+      if (!user)
+        throw new Error('User not found')
+      return user
+    }
+
+    toJSON(): Record<string, any> {
+      return { id: this.id, email: this.email, name: this.name }
+    }
+  }) as typeof MockUserClass,
+
+  /**
+   * Create a Post model mock
+   */
+  Post: (class MockPost {
+    public id: number
+    public title: string
+    public content: string
+    public userId: number
+
+    constructor(data: { id: number, title?: string, content?: string, userId?: number } = { id: 1 }) {
+      this.id = data.id
+      this.title = data.title || 'Test Post'
+      this.content = data.content || 'Test content'
+      this.userId = data.userId || 1
+    }
+
+    static async find(id: any): Promise<MockPost | null> {
+      if (id === 'not-found')
+        return null
+      return new MockPost({ id: Number.parseInt(id) })
+    }
+
+    static async findOrFail(id: any): Promise<MockPost> {
+      const post = await this.find(id)
+      if (!post)
+        throw new Error('Post not found')
+      return post
+    }
+
+    async belongsTo(userId: number): Promise<boolean> {
+      return this.userId === userId
+    }
+
+    toJSON(): Record<string, any> {
+      return { id: this.id, title: this.title, content: this.content, userId: this.userId }
+    }
+  }) as typeof MockPostClass,
+}
+
+/** Model constraint function type */
+export type ModelConstraintFn = (_model: any, _request: EnhancedRequest) => Promise<boolean>
+
+/** Simple model constraint function type (no request) */
+export type SimpleModelConstraintFn = (_model: any) => Promise<boolean>
+
+/**
+ * Model binding constraint helpers
+ */
+export const constraintHelpers: {
+  belongsTo: (userIdField?: string) => ModelConstraintFn
+  belongsToUser: () => ModelConstraintFn
+  published: () => SimpleModelConstraintFn
+  visible: () => SimpleModelConstraintFn
+  custom: (constraintFn: ModelConstraintFn) => ModelConstraintFn
+  combine: (...constraints: ModelConstraintFn[]) => ModelConstraintFn
+} = {
+  /**
+   * Create a belongsTo constraint
+   */
+  belongsTo: (userIdField: string = 'userId'): ModelConstraintFn => {
+    const fn = async (model: any, request: EnhancedRequest): Promise<boolean> => {
+      if (!request.user)
+        return false
+      return model[userIdField] === request.user.id
+    }
+    return mock(fn)
+  },
+
+  /**
+   * Create a belongsToUser constraint
+   */
+  belongsToUser: (): ModelConstraintFn => {
+    const fn = async (model: any, request: EnhancedRequest): Promise<boolean> => {
+      if (!request.user)
+        return false
+      return model.userId === request.user.id
+    }
+    return mock(fn)
+  },
+
+  /**
+   * Create a published constraint
+   */
+  published: (): SimpleModelConstraintFn => {
+    const fn = async (model: any): Promise<boolean> => {
+      return model.published === true || model.status === 'published'
+    }
+    return mock(fn)
+  },
+
+  /**
+   * Create a visible constraint
+   */
+  visible: (): SimpleModelConstraintFn => {
+    const fn = async (model: any): Promise<boolean> => {
+      return model.visible !== false && model.hidden !== true
+    }
+    return mock(fn)
+  },
+
+  /**
+   * Create a custom constraint
+   */
+  custom: (constraintFn: ModelConstraintFn): ModelConstraintFn => {
+    return mock(constraintFn)
+  },
+
+  /**
+   * Combine multiple constraints with AND logic
+   */
+  combine: (...constraints: ModelConstraintFn[]): ModelConstraintFn => {
+    const fn = async (model: any, request: EnhancedRequest): Promise<boolean> => {
+      for (const constraint of constraints) {
+        if (!(await constraint(model, request))) {
+          return false
+        }
+      }
+      return true
+    }
+    return mock(fn)
+  },
+}
+
+/**
+ * Model resolver factory for testing
+ */
+export class ModelResolverTester {
+  private resolvers: Map<string, (value: string) => Promise<any>> = new Map()
+
+  /**
+   * Register a model resolver
+   */
+  register(key: string, resolver: (value: string) => Promise<any>): ModelResolverTester {
+    this.resolvers.set(key, mock(resolver))
+    return this
+  }
+
+  /**
+   * Register a model class resolver
+   */
+  registerModel(key: string, modelClass: any): ModelResolverTester {
+    const resolver = mock(async (value: string) => {
+      if (modelClass.find) {
+        const model = await modelClass.find(value)
+        if (!model)
+          throw new Error(`${modelClass.name || 'Model'} not found`)
+        return model
+      }
+      return new (modelClass as any)({ id: value })
+    })
+
+    this.resolvers.set(key, resolver)
+    return this
+  }
+
+  /**
+   * Test model resolution
+   */
+  async resolve(key: string, value: string): Promise<any> {
+    const resolver = this.resolvers.get(key)
+    if (!resolver) {
+      throw new Error(`No resolver registered for key: ${key}`)
+    }
+    return await resolver(value)
+  }
+
+  /**
+   * Test all registered resolvers
+   */
+  async testAll(testValue: string = '1'): Promise<Record<string, any>> {
+    const results: Record<string, any> = {}
+
+    for (const [key, resolver] of this.resolvers) {
+      try {
+        results[key] = await resolver(testValue)
+      }
+      catch (error) {
+        results[key] = { error: error instanceof Error ? error.message : 'Unknown error' }
+      }
+    }
+
+    return results
+  }
+
+  /**
+   * Get all registered resolver keys
+   */
+  getKeys(): string[] {
+    return Array.from(this.resolvers.keys())
+  }
+
+  /**
+   * Clear all resolvers
+   */
+  clear(): ModelResolverTester {
+    this.resolvers.clear()
+    return this
+  }
+}
+
+/** Route handler function type */
+export type RouteHandlerFn = (_request: EnhancedRequest) => Promise<Response>
+
+/** Binding middleware function type */
+export type BindingMiddlewareFn = (request: EnhancedRequest, next: () => Promise<Response>) => Promise<Response>
+
+/**
+ * Route model binding test helpers
+ */
+export const routeModelHelpers: {
+  testRoute: (path: string, params: Record<string, string>, modelBindings: Record<string, any>) => Promise<EnhancedRequest>
+  createHandler: (expectedModels: string[]) => RouteHandlerFn
+  testBindingMiddleware: (bindings: Record<string, any>) => BindingMiddlewareFn
+} = {
+  /**
+   * Test route with model binding
+   */
+  testRoute: async (
+    path: string,
+    params: Record<string, string>,
+    modelBindings: Record<string, any>,
+  ): Promise<EnhancedRequest> => {
+    const request = createMockRequest('GET', path)
+    request.params = params
+
+    // Simulate model binding resolution
+    for (const [key, model] of Object.entries(modelBindings)) {
+      request.context = request.context || {}
+      request.context[key] = model
+    }
+
+    return request
+  },
+
+  /**
+   * Create a route handler that expects model binding
+   */
+  createHandler: (expectedModels: string[]): RouteHandlerFn => {
+    const fn = async (request: EnhancedRequest): Promise<Response> => {
+      const context = request.context || {}
+
+      for (const modelKey of expectedModels) {
+        if (!context[modelKey]) {
+          return new Response(`Model ${modelKey} not found`, { status: 404 })
+        }
+      }
+
+      return new Response(JSON.stringify({
+        params: request.params,
+        models: Object.fromEntries(
+          expectedModels.map(key => [key, context[key]]),
+        ),
+      }), {
+        headers: { 'Content-Type': 'application/json' },
+      })
+    }
+    return mock(fn)
+  },
+
+  /**
+   * Test model binding middleware
+   */
+  testBindingMiddleware: (bindings: Record<string, any>): BindingMiddlewareFn => {
+    const fn = async (request: EnhancedRequest, next: () => Promise<Response>): Promise<Response> => {
+      request.context = request.context || {}
+
+      for (const [key, resolver] of Object.entries(bindings)) {
+        const paramValue = request.params[key]
+        if (paramValue) {
+          try {
+            if (typeof resolver === 'function') {
+              request.context[key] = await resolver(paramValue)
+            }
+            else {
+              request.context[key] = resolver
+            }
+          }
+          catch (error) {
+            console.error(`Error resolving model ${key}:`, error)
+            return new Response(`${key} not found`, { status: 404 })
+          }
+        }
+      }
+
+      return await next()
+    }
+    return mock(fn)
+  },
+}
+
+/**
+ * Factory functions
+ */
+export function createModelBindingTester(options?: ModelBindingTestOptions): ModelBindingTester {
+  return new ModelBindingTester(options)
+}
+
+export function createModelResolverTester(): ModelResolverTester {
+  return new ModelResolverTester()
+}
+
+/** User scope constraint function */
+export type UserScopeConstraint = (_model: any, _user: any) => Promise<boolean>
+
+/** Default user scope constraint */
+const defaultUserScopeConstraint: UserScopeConstraint = async (m, u) => m.userId === u.id
+
+/**
+ * Test utilities for scoped model binding
+ */
+export const scopedBindingHelpers: {
+  testUserScoped: (model: any, user: any, constraint?: UserScopeConstraint) => Promise<boolean>
+  testRoleAccess: (model: any, user: any, requiredRoles: string[]) => Promise<boolean>
+  testPermissionAccess: (model: any, user: any, requiredPermissions: string[]) => Promise<boolean>
+} = {
+  /**
+   * Test user-scoped model binding
+   */
+  testUserScoped: async (
+    model: any,
+    user: any,
+    constraint: UserScopeConstraint = defaultUserScopeConstraint,
+  ): Promise<boolean> => {
+    return await constraint(model, user)
+  },
+
+  /**
+   * Test role-based model access
+   */
+  testRoleAccess: async (
+    model: any,
+    user: any,
+    requiredRoles: string[],
+  ): Promise<boolean> => {
+    if (!user.roles)
+      return false
+    return requiredRoles.some(role => user.roles.includes(role))
+  },
+
+  /**
+   * Test permission-based model access
+   */
+  testPermissionAccess: async (
+    model: any,
+    user: any,
+    requiredPermissions: string[],
+  ): Promise<boolean> => {
+    if (!user.permissions)
+      return false
+    return requiredPermissions.every(permission => user.permissions.includes(permission))
+  },
+}