@opensaas/stack-cli 0.1.1 → 0.1.2

package/src/commands/init.test.ts

@@ -1,308 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest'
-import { initCommand } from './init.js'
-import * as fs from 'fs'
-import * as path from 'path'
-import * as os from 'os'
-
-// Mock prompts module
-vi.mock('prompts', () => ({
-  default: vi.fn(),
-}))
-
-// Mock ora module
-vi.mock('ora', () => ({
-  default: vi.fn(() => ({
-    start: vi.fn().mockReturnThis(),
-    succeed: vi.fn().mockReturnThis(),
-    fail: vi.fn().mockReturnThis(),
-    text: '',
-  })),
-}))
-
-// Mock chalk module
-vi.mock('chalk', () => ({
-  default: {
-    bold: {
-      cyan: vi.fn((str) => str),
-      green: vi.fn((str) => str),
-    },
-    cyan: vi.fn((str) => str),
-    gray: vi.fn((str) => str),
-    red: vi.fn((str) => str),
-    yellow: vi.fn((str) => str),
-    green: vi.fn((str) => str),
-  },
-}))
-
-describe('Init Command', () => {
-  let tempDir: string
-  let originalCwd: string
-  let originalExit: typeof process.exit
-  let exitCode: number | undefined
-
-  beforeEach(() => {
-    // Create temp directory for testing
-    tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'init-test-'))
-    originalCwd = process.cwd()
-    process.chdir(tempDir)
-
-    // Mock process.exit
-    originalExit = process.exit
-    exitCode = undefined
-    process.exit = vi.fn((code?: number) => {
-      exitCode = code
-      throw new Error(`process.exit(${code})`)
-    }) as never
-  })
-
-  afterEach(() => {
-    // Restore
-    process.chdir(originalCwd)
-    process.exit = originalExit
-
-    // Clean up
-    if (fs.existsSync(tempDir)) {
-      fs.rmSync(tempDir, { recursive: true, force: true })
-    }
-  })
-
-  describe('initCommand', () => {
-    it('should create project structure with provided name', async () => {
-      const projectName = 'test-project'
-
-      try {
-        await initCommand(projectName)
-      } catch {
-        // Expected to throw due to mocked process.exit
-      }
-
-      const projectPath = path.join(tempDir, projectName)
-      expect(fs.existsSync(projectPath)).toBe(true)
-      expect(fs.existsSync(path.join(projectPath, 'app'))).toBe(true)
-      expect(fs.existsSync(path.join(projectPath, 'lib'))).toBe(true)
-      expect(fs.existsSync(path.join(projectPath, 'prisma'))).toBe(true)
-    })
-
-    it('should create package.json with correct content', async () => {
-      const projectName = 'test-project'
-
-      try {
-        await initCommand(projectName)
-      } catch {
-        // Expected to throw due to mocked process.exit
-      }
-
-      const projectPath = path.join(tempDir, projectName)
-      const packageJson = JSON.parse(
-        fs.readFileSync(path.join(projectPath, 'package.json'), 'utf-8'),
-      )
-
-      expect(packageJson.name).toBe(projectName)
-      expect(packageJson.scripts.generate).toBe('opensaas generate')
-      expect(packageJson.scripts['db:push']).toBe('prisma db push')
-      expect(packageJson.dependencies['@opensaas/stack-core']).toBeDefined()
-    })
-
-    it('should create tsconfig.json', async () => {
-      const projectName = 'test-project'
-
-      try {
-        await initCommand(projectName)
-      } catch {
-        // Expected to throw
-      }
-
-      const projectPath = path.join(tempDir, projectName)
-      const tsConfig = JSON.parse(fs.readFileSync(path.join(projectPath, 'tsconfig.json'), 'utf-8'))
-
-      expect(tsConfig.compilerOptions.target).toBe('ES2022')
-      expect(tsConfig.compilerOptions.moduleResolution).toBe('bundler')
-    })
-
-    it('should create opensaas.config.ts with User list', async () => {
-      const projectName = 'test-project'
-
-      try {
-        await initCommand(projectName)
-      } catch {
-        // Expected to throw
-      }
-
-      const projectPath = path.join(tempDir, projectName)
-      const config = fs.readFileSync(path.join(projectPath, 'opensaas.config.ts'), 'utf-8')
-
-      expect(config).toContain('config({')
-      expect(config).toContain('lists: {')
-      expect(config).toContain('User: list({')
-      expect(config).toContain('name: text(')
-      expect(config).toContain('email: text(')
-      expect(config).toContain('password: password(')
-    })
-
-    it('should create .env file', async () => {
-      const projectName = 'test-project'
-
-      try {
-        await initCommand(projectName)
-      } catch {
-        // Expected to throw
-      }
-
-      const projectPath = path.join(tempDir, projectName)
-      const env = fs.readFileSync(path.join(projectPath, '.env'), 'utf-8')
-
-      expect(env).toContain('DATABASE_URL')
-      expect(env).toContain('file:./dev.db')
-    })
-
-    it('should create .gitignore file', async () => {
-      const projectName = 'test-project'
-
-      try {
-        await initCommand(projectName)
-      } catch {
-        // Expected to throw
-      }
-
-      const projectPath = path.join(tempDir, projectName)
-      const gitignore = fs.readFileSync(path.join(projectPath, '.gitignore'), 'utf-8')
-
-      expect(gitignore).toContain('node_modules')
-      expect(gitignore).toContain('.opensaas')
-      expect(gitignore).toContain('prisma/dev.db')
-    })
-
-    it('should create lib/context.ts', async () => {
-      const projectName = 'test-project'
-
-      try {
-        await initCommand(projectName)
-      } catch {
-        // Expected to throw
-      }
-
-      const projectPath = path.join(tempDir, projectName)
-      const context = fs.readFileSync(path.join(projectPath, 'lib', 'context.ts'), 'utf-8')
-
-      expect(context).toContain('import { PrismaClient }')
-      expect(context).toContain('export async function getContext(')
-    })
-
-    it('should create app/page.tsx', async () => {
-      const projectName = 'test-project'
-
-      try {
-        await initCommand(projectName)
-      } catch {
-        // Expected to throw
-      }
-
-      const projectPath = path.join(tempDir, projectName)
-      const page = fs.readFileSync(path.join(projectPath, 'app', 'page.tsx'), 'utf-8')
-
-      expect(page).toContain('export default function Home(')
-      expect(page).toContain('Welcome to OpenSaas')
-    })
-
-    it('should create app/layout.tsx', async () => {
-      const projectName = 'test-project'
-
-      try {
-        await initCommand(projectName)
-      } catch {
-        // Expected to throw
-      }
-
-      const projectPath = path.join(tempDir, projectName)
-      const layout = fs.readFileSync(path.join(projectPath, 'app', 'layout.tsx'), 'utf-8')
-
-      expect(layout).toContain('export default function RootLayout(')
-      expect(layout).toContain('export const metadata')
-    })
-
-    it('should create README.md', async () => {
-      const projectName = 'test-project'
-
-      try {
-        await initCommand(projectName)
-      } catch {
-        // Expected to throw
-      }
-
-      const projectPath = path.join(tempDir, projectName)
-      const readme = fs.readFileSync(path.join(projectPath, 'README.md'), 'utf-8')
-
-      expect(readme).toContain(`# ${projectName}`)
-      expect(readme).toContain('Getting Started')
-      expect(readme).toContain('npm run generate')
-    })
-
-    it('should create next.config.js', async () => {
-      const projectName = 'test-project'
-
-      try {
-        await initCommand(projectName)
-      } catch {
-        // Expected to throw
-      }
-
-      const projectPath = path.join(tempDir, projectName)
-      const nextConfig = fs.readFileSync(path.join(projectPath, 'next.config.js'), 'utf-8')
-
-      expect(nextConfig).toContain('serverComponentsExternalPackages')
-      expect(nextConfig).toContain('@opensaas/stack-core')
-    })
-
-    it('should fail if directory already exists', async () => {
-      const projectName = 'test-project'
-
-      // Create directory first
-      fs.mkdirSync(path.join(tempDir, projectName))
-
-      try {
-        await initCommand(projectName)
-      } catch {
-        // Expected to throw
-      }
-
-      expect(exitCode).toBe(1)
-    })
-
-    it('should validate project name format', async () => {
-      const prompts = await import('prompts')
-
-      // Test with a valid name that should succeed
-      const validName = 'test-project-valid'
-
-      vi.mocked(prompts.default).mockResolvedValue({
-        name: validName,
-      })
-
-      try {
-        await initCommand(undefined)
-      } catch {
-        // Expected to throw due to mocked process.exit
-      }
-
-      // Project should be created with valid name
-      expect(fs.existsSync(path.join(tempDir, validName))).toBe(true)
-    })
-
-    it('should verify cleanup behavior exists', () => {
-      // This test verifies the cleanup logic is present in the code
-      // Full end-to-end testing of cleanup is difficult in ESM environment
-      // The actual cleanup logic in init.ts catches errors and removes the directory
-
-      const projectName = 'test-project-cleanup'
-      const projectPath = path.join(tempDir, projectName)
-
-      // Create a test directory
-      fs.mkdirSync(projectPath)
-      expect(fs.existsSync(projectPath)).toBe(true)
-
-      // Verify cleanup can work
-      fs.rmSync(projectPath, { recursive: true, force: true })
-      expect(fs.existsSync(projectPath)).toBe(false)
-    })
-  })
-})