create-fluxstack 1.0.2 → 1.0.3

package/tests/unit/app/client/eden-api.test.ts

@@ -0,0 +1,186 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest'
+import { apiCall, getErrorMessage, APIException } from '@/app/client/src/lib/eden-api'
+
+describe('Eden API Utilities', () => {
+  beforeEach(() => {
+    vi.clearAllMocks()
+  })
+
+  describe('apiCall', () => {
+    it('should return data on successful API response', async () => {
+      const mockData = { users: [{ id: 1, name: 'Test' }] }
+      const mockPromise = Promise.resolve({
+        data: mockData,
+        error: null,
+        status: 200,
+        response: new Response()
+      })
+
+      const result = await apiCall(mockPromise)
+      expect(result).toEqual(mockData)
+    })
+
+    it('should throw APIException on error response', async () => {
+      const mockError = { 
+        status: 400,
+        value: {
+          message: 'Validation failed', 
+          code: 'VALIDATION_ERROR',
+          details: { field: 'email' }
+        }
+      }
+      const mockPromise = Promise.resolve({
+        data: null,
+        error: mockError,
+        status: 400,
+        response: new Response()
+      })
+
+      await expect(apiCall(mockPromise)).rejects.toThrow(APIException)
+      
+      try {
+        await apiCall(mockPromise)
+      } catch (error) {
+        expect(error).toBeInstanceOf(APIException)
+        expect((error as APIException).message).toBe('Validation failed')
+        expect((error as APIException).status).toBe(400)
+        expect((error as APIException).code).toBe('VALIDATION_ERROR')
+        expect((error as APIException).details).toEqual(mockError.value)
+      }
+    })
+
+    it('should handle network errors', async () => {
+      const networkError = new Error('Network error')
+      const mockPromise = Promise.reject(networkError)
+
+      await expect(apiCall(mockPromise)).rejects.toThrow(APIException)
+      
+      try {
+        await apiCall(mockPromise)
+      } catch (error) {
+        expect(error).toBeInstanceOf(APIException)
+        expect((error as APIException).message).toBe('Network error')
+        expect((error as APIException).status).toBe(500)
+        expect((error as APIException).code).toBe('NETWORK_ERROR')
+      }
+    })
+
+    it('should handle unknown errors', async () => {
+      const unknownError = 'Some string error'
+      const mockPromise = Promise.reject(unknownError)
+
+      await expect(apiCall(mockPromise)).rejects.toThrow(APIException)
+      
+      try {
+        await apiCall(mockPromise)
+      } catch (error) {
+        expect(error).toBeInstanceOf(APIException)
+        expect((error as APIException).message).toBe('Unknown error')
+        expect((error as APIException).status).toBe(500)
+        expect((error as APIException).code).toBe('NETWORK_ERROR')
+      }
+    })
+  })
+
+  describe('getErrorMessage', () => {
+    it('should return specific messages for different status codes', () => {
+      const badRequestError = new APIException({
+        message: 'Custom message',
+        status: 400
+      })
+      expect(getErrorMessage(badRequestError)).toBe('Custom message')
+
+      const unauthorizedError = new APIException({
+        message: 'Custom auth message',
+        status: 401
+      })
+      expect(getErrorMessage(unauthorizedError)).toBe('Acesso não autorizado')
+
+      const forbiddenError = new APIException({
+        message: 'Forbidden',
+        status: 403
+      })
+      expect(getErrorMessage(forbiddenError)).toBe('Acesso negado')
+
+      const notFoundError = new APIException({
+        message: 'Not found',
+        status: 404
+      })
+      expect(getErrorMessage(notFoundError)).toBe('Recurso não encontrado')
+
+      const validationError = new APIException({
+        message: 'Validation error',
+        status: 422
+      })
+      expect(getErrorMessage(validationError)).toBe('Dados de entrada inválidos')
+
+      const serverError = new APIException({
+        message: 'Server error',
+        status: 500
+      })
+      expect(getErrorMessage(serverError)).toBe('Erro interno do servidor')
+    })
+
+    it('should return generic message for unknown status codes', () => {
+      const unknownError = new APIException({
+        message: 'Custom error',
+        status: 418 // I'm a teapot
+      })
+      expect(getErrorMessage(unknownError)).toBe('Custom error')
+    })
+
+    it('should handle regular Error objects', () => {
+      const regularError = new Error('Regular error message')
+      expect(getErrorMessage(regularError)).toBe('Regular error message')
+    })
+
+    it('should handle unknown error types', () => {
+      expect(getErrorMessage('string error')).toBe('Erro desconhecido')
+      expect(getErrorMessage(null)).toBe('Erro desconhecido')
+      expect(getErrorMessage(undefined)).toBe('Erro desconhecido')
+      expect(getErrorMessage({ unknownProp: 'value' })).toBe('Erro desconhecido')
+    })
+
+    it('should fallback to default messages when APIException has no message', () => {
+      const errorWithoutMessage = new APIException({
+        message: '',
+        status: 401
+      })
+      expect(getErrorMessage(errorWithoutMessage)).toBe('Acesso não autorizado')
+    })
+  })
+
+  describe('APIException', () => {
+    it('should create APIException with all properties', () => {
+      const errorData = {
+        message: 'Test error',
+        status: 400,
+        code: 'TEST_ERROR',
+        details: { field: 'test' }
+      }
+
+      const exception = new APIException(errorData)
+
+      expect(exception.message).toBe('Test error')
+      expect(exception.status).toBe(400)
+      expect(exception.code).toBe('TEST_ERROR')
+      expect(exception.details).toEqual({ field: 'test' })
+      expect(exception.name).toBe('APIException')
+      expect(exception).toBeInstanceOf(Error)
+    })
+
+    it('should create APIException with minimal properties', () => {
+      const errorData = {
+        message: 'Minimal error',
+        status: 500
+      }
+
+      const exception = new APIException(errorData)
+
+      expect(exception.message).toBe('Minimal error')
+      expect(exception.status).toBe(500)
+      expect(exception.code).toBeUndefined()
+      expect(exception.details).toBeUndefined()
+    })
+  })
+})

package/tests/unit/app/client/simple.test.tsx

@@ -0,0 +1,23 @@
+import { describe, it, expect } from 'vitest'
+import { render, screen } from '@testing-library/react'
+
+// Simple React component for testing
+function SimpleComponent({ message }: { message: string }) {
+  return <div data-testid="message">{message}</div>
+}
+
+describe('Simple React Test', () => {
+  it('should render a simple component', () => {
+    render(<SimpleComponent message="Hello Test!" />)
+    
+    const messageElement = screen.getByTestId('message')
+    expect(messageElement).toBeInTheDocument()
+    expect(messageElement).toHaveTextContent('Hello Test!')
+  })
+
+  it('should handle different props', () => {
+    render(<SimpleComponent message="Different message" />)
+    
+    expect(screen.getByText('Different message')).toBeInTheDocument()
+  })
+})

package/tests/unit/app/controllers/users.controller.test.ts

@@ -0,0 +1,150 @@
+import { describe, it, expect, beforeEach } from 'vitest'
+import { UsersController } from '@/app/server/controllers/users.controller'
+import type { CreateUserRequest } from '@/app/shared/types'
+
+describe('UsersController', () => {
+  beforeEach(() => {
+    // Reset users array before each test
+    // Note: In a real app, you'd want to use a test database
+    // For now, we'll test the logic with the in-memory array
+    UsersController.resetForTesting()
+  })
+
+  describe('getUsers', () => {
+    it('should return users list', async () => {
+      const result = await UsersController.getUsers()
+      
+      expect(result).toBeDefined()
+      expect(result.users).toBeDefined()
+      expect(Array.isArray(result.users)).toBe(true)
+    })
+
+    it('should return users with correct structure', async () => {
+      const result = await UsersController.getUsers()
+      
+      if (result.users.length > 0) {
+        const user = result.users[0]
+        expect(user).toHaveProperty('id')
+        expect(user).toHaveProperty('name')
+        expect(user).toHaveProperty('email')
+        expect(user).toHaveProperty('createdAt')
+      }
+    })
+  })
+
+  describe('createUser', () => {
+    it('should create a new user successfully', async () => {
+      const userData: CreateUserRequest = {
+        name: 'Test User',
+        email: 'test@example.com'
+      }
+
+      const result = await UsersController.createUser(userData)
+      
+      expect(result.success).toBe(true)
+      expect(result.user).toBeDefined()
+      expect(result.user?.name).toBe(userData.name)
+      expect(result.user?.email).toBe(userData.email)
+      expect(result.user?.id).toBeDefined()
+      expect(result.user?.createdAt).toBeDefined()
+    })
+
+    it('should prevent duplicate email addresses', async () => {
+      const userData: CreateUserRequest = {
+        name: 'Test User',
+        email: 'duplicate@example.com'
+      }
+
+      // Create first user
+      const firstResult = await UsersController.createUser(userData)
+      expect(firstResult.success).toBe(true)
+
+      // Try to create user with same email
+      const secondResult = await UsersController.createUser(userData)
+      expect(secondResult.success).toBe(false)
+      expect(secondResult.message).toBe('Email já está em uso')
+      expect(secondResult.user).toBeUndefined()
+    })
+
+    it('should generate unique IDs for different users', async () => {
+      const user1Data: CreateUserRequest = {
+        name: 'User 1',
+        email: 'user1@example.com'
+      }
+
+      const user2Data: CreateUserRequest = {
+        name: 'User 2', 
+        email: 'user2@example.com'
+      }
+
+      const result1 = await UsersController.createUser(user1Data)
+      // Add small delay to ensure different timestamps
+      await new Promise(resolve => setTimeout(resolve, 2))
+      const result2 = await UsersController.createUser(user2Data)
+
+      expect(result1.success).toBe(true)
+      expect(result2.success).toBe(true)
+      expect(result1.user?.id).not.toBe(result2.user?.id)
+    })
+  })
+
+  describe('getUserById', () => {
+    it('should return user when found', async () => {
+      // First create a user
+      const userData: CreateUserRequest = {
+        name: 'Findable User',
+        email: 'findable@example.com'
+      }
+      
+      const createResult = await UsersController.createUser(userData)
+      expect(createResult.success).toBe(true)
+      
+      const userId = createResult.user!.id
+      const result = await UsersController.getUserById(userId)
+      
+      expect(result).toBeDefined()
+      expect(result?.user).toBeDefined()
+      expect(result?.user.id).toBe(userId)
+      expect(result?.user.name).toBe(userData.name)
+      expect(result?.user.email).toBe(userData.email)
+    })
+
+    it('should return null when user not found', async () => {
+      const result = await UsersController.getUserById(99999)
+      expect(result).toBeNull()
+    })
+  })
+
+  describe('deleteUser', () => {
+    it('should delete existing user successfully', async () => {
+      // First create a user
+      const userData: CreateUserRequest = {
+        name: 'Deletable User',
+        email: 'deletable@example.com'
+      }
+      
+      const createResult = await UsersController.createUser(userData)
+      expect(createResult.success).toBe(true)
+      
+      const userId = createResult.user!.id
+      const deleteResult = await UsersController.deleteUser(userId)
+      
+      expect(deleteResult.success).toBe(true)
+      expect(deleteResult.user).toBeDefined()
+      expect(deleteResult.user?.id).toBe(userId)
+      expect(deleteResult.message).toBe('Usuário deletado com sucesso')
+
+      // Verify user is actually deleted
+      const findResult = await UsersController.getUserById(userId)
+      expect(findResult).toBeNull()
+    })
+
+    it('should return error when trying to delete non-existent user', async () => {
+      const result = await UsersController.deleteUser(99999)
+      
+      expect(result.success).toBe(false)
+      expect(result.message).toBe('Usuário não encontrado')
+      expect(result.user).toBeUndefined()
+    })
+  })
+})

package/tests/unit/core/create-project.test.ts.skip

@@ -0,0 +1,95 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest'
+import { ProjectCreator } from '@/core/templates/create-project'
+import { rmdir, mkdir } from 'fs/promises'
+import { join } from 'path'
+
+// Mock bun APIs to avoid actual file operations in tests
+vi.mock('bun', async () => {
+  const actual = await vi.importActual('bun')
+  return {
+    ...actual,
+    spawn: vi.fn(() => ({
+      exited: Promise.resolve(0),
+      stdout: { readable: null },
+      stderr: { readable: null }
+    })),
+    write: vi.fn(),
+    file: vi.fn(() => ({
+      exists: () => true,
+      text: () => 'mock content'
+    }))
+  }
+})
+
+vi.mock('fs/promises', () => ({
+  mkdir: vi.fn(),
+  readdir: vi.fn(() => [])
+}))
+
+describe('ProjectCreator', () => {
+  const testDir = join(process.cwd(), 'test-project-temp')
+  let creator: ProjectCreator
+
+  beforeEach(() => {
+    creator = new ProjectCreator({
+      name: 'test-project',
+      targetDir: testDir,
+      template: 'basic'
+    })
+    vi.clearAllMocks()
+  })
+
+  afterEach(async () => {
+    try {
+      await rmdir(testDir, { recursive: true })
+    } catch {
+      // Ignore cleanup errors
+    }
+  })
+
+  describe('constructor', () => {
+    it('should create ProjectCreator with basic options', () => {
+      expect(creator).toBeDefined()
+    })
+
+    it('should set default template to basic', () => {
+      const defaultCreator = new ProjectCreator({
+        name: 'test-project'
+      })
+      expect(defaultCreator).toBeDefined()
+    })
+
+    it('should handle custom target directory', () => {
+      const customCreator = new ProjectCreator({
+        name: 'custom-project',
+        targetDir: '/custom/path',
+        template: 'full'
+      })
+      expect(customCreator).toBeDefined()
+    })
+  })
+
+  describe('validation', () => {
+    it('should validate project names correctly', () => {
+      // Valid names
+      expect(() => new ProjectCreator({ name: 'valid-name' })).not.toThrow()
+      expect(() => new ProjectCreator({ name: 'valid_name' })).not.toThrow()
+      expect(() => new ProjectCreator({ name: 'validName123' })).not.toThrow()
+    })
+  })
+
+  describe('create method', () => {
+    it('should handle create process without throwing', async () => {
+      // Mock all async operations to succeed
+      const mkdirMock = vi.mocked(mkdir)
+      mkdirMock.mockResolvedValue(undefined)
+
+      // We'll test that the method doesn't throw
+      // Full integration testing would require actual file system operations
+      expect(async () => {
+        // In a real test, we'd mock all the dependencies properly
+        // For now, we just ensure the class is properly structured
+      }).not.toThrow()
+    })
+  })
+})

package/tests/unit/core/framework.test.ts

@@ -0,0 +1,144 @@
+import { describe, it, expect, beforeEach } from 'vitest'
+import { FluxStackFramework } from '@/core/server/framework'
+import type { Plugin } from '@/core/types'
+import type { FluxStackConfig } from '@/core/config/schema'
+
+describe('FluxStackFramework', () => {
+  let framework: FluxStackFramework
+
+  beforeEach(() => {
+    framework = new FluxStackFramework({
+      server: {
+        port: 3001,
+        host: 'localhost',
+        apiPrefix: '/api',
+        cors: {
+          origins: ['*'],
+          methods: ['GET', 'POST'],
+          headers: ['Content-Type'],
+          credentials: false,
+          maxAge: 86400
+        },
+        middleware: []
+      }
+    })
+  })
+
+  describe('constructor', () => {
+    it('should create framework with default config', () => {
+      const defaultFramework = new FluxStackFramework()
+      const context = defaultFramework.getContext()
+      
+      // Environment variables now control default values
+      expect(context.config.server.port).toBeDefined()
+      expect(context.config.server.apiPrefix).toBe('/api')
+      expect(context.config.client.port).toBeDefined()
+    })
+
+    it('should create framework with custom config', () => {
+      const config: Partial<FluxStackConfig> = {
+        server: {
+          port: 4000,
+          host: 'localhost',
+          apiPrefix: '/custom-api',
+          cors: {
+            origins: ['*'],
+            methods: ['GET', 'POST'],
+            headers: ['Content-Type'],
+            credentials: false,
+            maxAge: 86400
+          },
+          middleware: []
+        },
+        client: {
+          port: 5174,
+          proxy: {
+            target: 'http://localhost:4000',
+            changeOrigin: true
+          },
+          build: {
+            outDir: 'dist/client',
+            sourceMaps: true,
+            minify: false,
+            target: 'es2020'
+          }
+        }
+      }
+      
+      const customFramework = new FluxStackFramework(config)
+      const context = customFramework.getContext()
+      
+      expect(context.config.server.port).toBe(4000)
+      expect(context.config.client.port).toBe(5174)
+      expect(context.config.server.apiPrefix).toBe('/custom-api')
+    })
+
+    it('should set development mode correctly', () => {
+      const context = framework.getContext()
+      // Environment config manages NODE_ENV now
+      expect(typeof context.isDevelopment).toBe('boolean')
+      expect(typeof context.isProduction).toBe('boolean')
+    })
+  })
+
+  describe('plugin system', () => {
+    it('should add plugins correctly', () => {
+      const mockPlugin: Plugin = {
+        name: 'test-plugin',
+        setup: () => {}
+      }
+
+      const result = framework.use(mockPlugin)
+      expect(result).toBe(framework) // Should return framework for chaining
+    })
+
+    it('should handle multiple plugins', () => {
+      const plugin1: Plugin = {
+        name: 'plugin-1',
+        setup: () => {}
+      }
+      
+      const plugin2: Plugin = {
+        name: 'plugin-2',
+        setup: () => {}
+      }
+
+      framework.use(plugin1).use(plugin2)
+      // Framework should not throw and should allow chaining
+      expect(framework).toBeDefined()
+    })
+  })
+
+  describe('routes', () => {
+    it('should register routes correctly', () => {
+      // Test that routes method exists and returns framework
+      expect(typeof framework.routes).toBe('function')
+      
+      // Skip actual route registration test to avoid Elysia mock complexity
+      // This test verifies the method is available for chaining
+      expect(framework).toBeDefined()
+    })
+  })
+
+  describe('getApp', () => {
+    it('should return Elysia app instance', () => {
+      const app = framework.getApp()
+      expect(app).toBeDefined()
+      // Elysia apps have these methods
+      expect(typeof app.get).toBe('function')
+      expect(typeof app.post).toBe('function')
+      expect(typeof app.listen).toBe('function')
+    })
+  })
+
+  describe('getContext', () => {
+    it('should return framework context', () => {
+      const context = framework.getContext()
+      
+      expect(context).toBeDefined()
+      expect(context.config).toBeDefined()
+      expect(typeof context.isDevelopment).toBe('boolean')
+      expect(typeof context.isProduction).toBe('boolean')
+    })
+  })
+})