create-fluxstack 1.0.13 → 1.0.15

package/tests/setup.ts

@@ -1,29 +0,0 @@
-import '@testing-library/jest-dom'
-import { beforeAll, afterAll, afterEach } from 'vitest'
-import { cleanup } from '@testing-library/react'
-import { act } from 'react'
-
-// Fix React.act for React 19
-global.React = { act }
-
-// Cleanup after each test case (e.g. clearing jsdom)
-afterEach(() => {
-  cleanup()
-})
-
-// Global test setup
-beforeAll(() => {
-  // Setup global test environment
-  console.log('🧪 Setting up test environment...')
-})
-
-afterAll(() => {
-  // Cleanup global test environment
-  console.log('🧹 Cleaning up test environment...')
-})
-
-// Mock environment variables for tests
-process.env.NODE_ENV = 'test'
-process.env.PORT = '3001'
-process.env.FRONTEND_PORT = '5174'
-process.env.BACKEND_PORT = '3002'

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

@@ -1,56 +0,0 @@
-import { describe, it, expect } from 'vitest'
-import { render, screen } from '@testing-library/react'
-import { getErrorMessage, APIException } from '@/app/client/src/lib/eden-api'
-
-// Simple component test without full App complexity
-function SimpleHeader({ title }: { title: string }) {
-  return (
-    <header>
-      <div>{title}</div>
-    </header>
-  )
-}
-
-describe('Simple App Components', () => {
-  describe('Header Component', () => {
-    it('should render header with title', () => {
-      render(<SimpleHeader title="🔥 FluxStack v1.4.0" />)
-      
-      expect(screen.getByText('🔥 FluxStack v1.4.0')).toBeInTheDocument()
-    })
-  })
-
-  describe('Error Handling Utilities', () => {
-    it('should handle API exceptions correctly', () => {
-      const apiError = new APIException({
-        message: 'Test error',
-        status: 400,
-        code: 'TEST_ERROR'
-      })
-
-      const message = getErrorMessage(apiError)
-      expect(message).toBe('Test error')
-    })
-
-    it('should handle different status codes', () => {
-      const unauthorizedError = new APIException({
-        message: 'Unauthorized',
-        status: 401
-      })
-
-      const message = getErrorMessage(unauthorizedError)
-      expect(message).toBe('Acesso não autorizado')
-    })
-
-    it('should handle regular errors', () => {
-      const regularError = new Error('Regular error')
-      const message = getErrorMessage(regularError)
-      expect(message).toBe('Regular error')
-    })
-
-    it('should handle unknown errors', () => {
-      const message = getErrorMessage('string error')
-      expect(message).toBe('Erro desconhecido')
-    })
-  })
-})

package/tests/unit/app/client/App.test.tsx.skip

@@ -1,237 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest'
-import { render, screen, fireEvent, waitFor } from '@testing-library/react'
-import userEvent from '@testing-library/user-event'
-import App from '@/app/client/src/App'
-
-// Mock the eden-api module properly for hoisting
-vi.mock('@/app/client/src/lib/eden-api', () => ({
-  api: {
-    health: {
-      get: vi.fn(() => Promise.resolve({
-        status: "🚀 Hot Reload ativo!",
-        timestamp: new Date().toISOString(),
-        uptime: "120s",
-        version: "1.4.0",
-        environment: "development"
-      }))
-    },
-    users: {
-      get: vi.fn(() => Promise.resolve({
-        users: [
-          { id: 1, name: 'Test User 1', email: 'test1@example.com', createdAt: '2024-01-01' },
-          { id: 2, name: 'Test User 2', email: 'test2@example.com', createdAt: '2024-01-02' }
-        ]
-      })),
-      post: vi.fn(() => Promise.resolve({
-        success: true,
-        user: { id: 3, name: 'New User', email: 'new@example.com', createdAt: '2024-01-03' }
-      }))
-    }
-  },
-  apiCall: vi.fn((promise) => promise),
-  getErrorMessage: vi.fn((error) => error?.message || 'Unknown error')
-}))
-
-describe('App Component', () => {
-  beforeEach(() => {
-    vi.clearAllMocks()
-  })
-
-  describe('Header and Navigation', () => {
-    it('should render header with logo and tabs', () => {
-      render(<App />)
-      
-      const logo = screen.getByText('🔥 FluxStack v1.4.0')
-      const overviewTab = screen.getByText('📋 Visão Geral')
-      const demoTab = screen.getByText('🚀 Demo')
-      const apiDocsTab = screen.getByText('📚 API Docs')
-      
-      expect(logo).toBeInTheDocument()
-      expect(overviewTab).toBeInTheDocument()
-      expect(demoTab).toBeInTheDocument()
-      expect(apiDocsTab).toBeInTheDocument()
-    })
-
-    it('should switch tabs correctly', async () => {
-      const user = userEvent.setup()
-      render(<App />)
-      
-      // Initially on overview tab
-      expect(screen.getByText('🔥 FluxStack - Hot Reload Ativo! ⚡')).toBeInTheDocument()
-      
-      // Click demo tab
-      await user.click(screen.getByText('🚀 Demo'))
-      expect(screen.getByText('🔥 Demo Interativo - Hot Reload Testando!')).toBeInTheDocument()
-      
-      // Click API docs tab
-      await user.click(screen.getByText('📚 API Docs'))
-      expect(screen.getByText('Documentação da API')).toBeInTheDocument()
-    })
-
-    it('should show API status indicator', () => {
-      render(<App />)
-      
-      const statusBadge = screen.getByText(/API (Online|Offline)/)
-      expect(statusBadge).toBeInTheDocument()
-    })
-  })
-
-  describe('Overview Tab', () => {
-    it('should render overview content with features', () => {
-      render(<App />)
-      
-      expect(screen.getByText('🔥 FluxStack - Hot Reload Ativo! ⚡')).toBeInTheDocument()
-      expect(screen.getByText('Framework full-stack TypeScript moderno com hot reload coordenado! 🚀')).toBeInTheDocument()
-      
-      // Check features
-      expect(screen.getByText('Elysia.js')).toBeInTheDocument()
-      expect(screen.getByText('React + Vite')).toBeInTheDocument()
-      expect(screen.getByText('Eden Treaty')).toBeInTheDocument()
-      expect(screen.getByText('Docker Ready')).toBeInTheDocument()
-    })
-
-    it('should render tech stack information', () => {
-      render(<App />)
-      
-      expect(screen.getByText('Stack Tecnológica')).toBeInTheDocument()
-      expect(screen.getByText('Backend')).toBeInTheDocument()
-      expect(screen.getByText('Frontend')).toBeInTheDocument()
-      expect(screen.getByText('Comunicação')).toBeInTheDocument()
-    })
-  })
-
-  describe('Demo Tab - User Management', () => {
-    it('should render user form in demo tab', async () => {
-      const user = userEvent.setup()
-      render(<App />)
-      
-      await user.click(screen.getByText('🚀 Demo'))
-      
-      expect(screen.getByLabelText('Nome')).toBeInTheDocument()
-      expect(screen.getByLabelText('Email')).toBeInTheDocument()
-      expect(screen.getByRole('button', { name: /adicionar/i })).toBeInTheDocument()
-    })
-
-    it('should handle user form submission', async () => {
-      const user = userEvent.setup()
-      render(<App />)
-      
-      await user.click(screen.getByText('🚀 Demo'))
-      
-      const nameInput = screen.getByLabelText('Nome')
-      const emailInput = screen.getByLabelText('Email')
-      const submitButton = screen.getByRole('button', { name: /adicionar/i })
-      
-      await user.type(nameInput, 'Test User')
-      await user.type(emailInput, 'test@example.com')
-      await user.click(submitButton)
-      
-      // Form should be cleared after submission
-      await waitFor(() => {
-        expect(nameInput).toHaveValue('')
-        expect(emailInput).toHaveValue('')
-      })
-    })
-
-    it('should display users list in demo tab', async () => {
-      const user = userEvent.setup()
-      render(<App />)
-      
-      await user.click(screen.getByText('🚀 Demo'))
-      
-      // Wait for users to load
-      await waitFor(() => {
-        expect(screen.getByText('Test User 1')).toBeInTheDocument()
-        expect(screen.getByText('test1@example.com')).toBeInTheDocument()
-        expect(screen.getByText('Test User 2')).toBeInTheDocument()
-        expect(screen.getByText('test2@example.com')).toBeInTheDocument()
-      })
-    })
-
-    it('should show stats cards in demo tab', async () => {
-      const user = userEvent.setup()
-      render(<App />)
-      
-      await user.click(screen.getByText('🚀 Demo'))
-      
-      expect(screen.getByText('Usuários')).toBeInTheDocument()
-      expect(screen.getByText('API Status')).toBeInTheDocument()
-      expect(screen.getByText('Eden Treaty')).toBeInTheDocument()
-    })
-
-    it('should not submit form with empty fields', async () => {
-      const user = userEvent.setup()
-      render(<App />)
-      
-      await user.click(screen.getByText('🚀 Demo'))
-      
-      const submitButton = screen.getByRole('button', { name: /adicionar/i })
-      expect(submitButton).toBeDisabled()
-    })
-  })
-
-  describe('API Docs Tab', () => {
-    it('should render API documentation content', async () => {
-      const user = userEvent.setup()
-      render(<App />)
-      
-      await user.click(screen.getByText('📚 API Docs'))
-      
-      expect(screen.getByText('Documentação da API')).toBeInTheDocument()
-      expect(screen.getByText('Documentação interativa gerada automaticamente com Swagger')).toBeInTheDocument()
-    })
-
-    it('should have swagger links in API docs tab', async () => {
-      const user = userEvent.setup()
-      render(<App />)
-      
-      await user.click(screen.getByText('📚 API Docs'))
-      
-      const swaggerLink = screen.getByText('🚀 Abrir em Nova Aba')
-      const jsonLink = screen.getByText('📋 Ver JSON')
-      
-      expect(swaggerLink.closest('a')).toHaveAttribute('href', '/swagger')
-      expect(jsonLink.closest('a')).toHaveAttribute('href', '/swagger/json')
-    })
-
-    it('should render Eden Treaty code examples', async () => {
-      const user = userEvent.setup()
-      render(<App />)
-      
-      await user.click(screen.getByText('📚 API Docs'))
-      
-      expect(screen.getByText('🔧 Como usar Eden Treaty')).toBeInTheDocument()
-      expect(screen.getByText('Configuração do Cliente:')).toBeInTheDocument()
-      expect(screen.getByText('Exemplos de Uso:')).toBeInTheDocument()
-    })
-  })
-
-  describe('API Integration', () => {
-    it('should check API status on mount', async () => {
-      const { api } = await import('@/app/client/src/lib/eden-api')
-      render(<App />)
-      
-      await waitFor(() => {
-        expect(api.health.get).toHaveBeenCalled()
-      })
-    })
-
-    it('should load users on mount', async () => {
-      const { api } = await import('@/app/client/src/lib/eden-api')
-      render(<App />)
-      
-      await waitFor(() => {
-        expect(api.users.get).toHaveBeenCalled()
-      })
-    })
-  })
-
-  describe('Toast Messages', () => {
-    it('should not show toast initially', () => {
-      render(<App />)
-      
-      const toast = screen.queryByRole('alert')
-      expect(toast).not.toBeInTheDocument()
-    })
-  })
-})

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

@@ -1,186 +0,0 @@
-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

@@ -1,23 +0,0 @@
-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

@@ -1,150 +0,0 @@
-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()
-    })
-  })
-})