@friggframework/devtools 2.0.0--canary.517.35ee143.0 → 2.0.0--canary.524.06156322a.0

package/management-ui/src/test/utils/test-utils.jsx

@@ -1,134 +0,0 @@
-import React from 'react'
-import { render } from '@testing-library/react'
-import { BrowserRouter } from 'react-router-dom'
-import { vi } from 'vitest'
-import { ThemeProvider } from '../../components/theme-provider'
-
-// Mock providers for testing
-const MockSocketProvider = ({ children }) => children
-const MockFriggProvider = ({ children, initialUser, initialRepositories, initialCurrentRepository }) => {
-  // Create a minimal mock context
-  const mockContext = {
-    user: initialUser,
-    repositories: initialRepositories || [],
-    currentRepository: initialCurrentRepository,
-    isLoading: false,
-    loading: false,
-    error: null,
-    status: 'running',
-    integrations: [],
-    envVariables: {},
-    users: [],
-    connections: [],
-    currentUser: initialUser,
-    switchRepository: vi.fn().mockResolvedValue(),
-    fetchRepositories: vi.fn().mockResolvedValue([]),
-    startFrigg: vi.fn().mockResolvedValue(),
-    stopFrigg: vi.fn().mockResolvedValue(),
-    restartFrigg: vi.fn().mockResolvedValue(),
-    installIntegration: vi.fn().mockResolvedValue(),
-    createUser: vi.fn().mockResolvedValue(),
-    refreshData: vi.fn().mockResolvedValue(),
-  }
-  
-  return (
-    <div data-testid="mock-frigg-provider" data-context={JSON.stringify(mockContext)}>
-      {children}
-    </div>
-  )
-}
-
-// Custom render function that includes all providers
-export function renderWithProviders(ui, options = {}) {
-  const {
-    initialEntries = ['/'],
-    user = null,
-    repositories = [],
-    currentRepository = null,
-    ...renderOptions
-  } = options
-
-  function Wrapper({ children }) {
-    return (
-      <BrowserRouter>
-        <ThemeProvider defaultTheme="light">
-          <MockSocketProvider>
-            <MockFriggProvider 
-              initialUser={user}
-              initialRepositories={repositories}
-              initialCurrentRepository={currentRepository}
-            >
-              {children}
-            </MockFriggProvider>
-          </MockSocketProvider>
-        </ThemeProvider>
-      </BrowserRouter>
-    )
-  }
-
-  return render(ui, { wrapper: Wrapper, ...renderOptions })
-}
-
-// Mock data factories
-export const createMockRepository = (overrides = {}) => ({
-  name: 'test-repo',
-  path: '/test/path',
-  framework: 'React',
-  hasBackend: true,
-  version: '1.0.0',
-  detectionReasons: ['frigg dependencies'],
-  ...overrides
-})
-
-export const createMockUser = (overrides = {}) => ({
-  id: '1',
-  email: 'test@example.com',
-  name: 'Test User',
-  createdAt: '2023-01-01T00:00:00Z',
-  ...overrides
-})
-
-export const createMockIntegration = (overrides = {}) => ({
-  name: 'test-integration',
-  version: '1.0.0',
-  installed: true,
-  configured: true,
-  status: 'active',
-  ...overrides
-})
-
-export const createMockConnection = (overrides = {}) => ({
-  id: '1',
-  type: 'slack',
-  name: 'Test Connection',
-  status: 'active',
-  lastUsed: '2023-01-01T00:00:00Z',
-  config: {},
-  ...overrides
-})
-
-// Common test scenarios
-export const mockApiSuccess = (endpoint, data) => {
-  return {
-    endpoint,
-    response: {
-      data: { data }
-    }
-  }
-}
-
-export const mockApiError = (endpoint, error = 'Test error') => {
-  return {
-    endpoint,
-    error: new Error(error)
-  }
-}
-
-// Async utilities
-export const waitForLoading = () => new Promise(resolve => setTimeout(resolve, 0))
-
-export const waitForAnimation = () => new Promise(resolve => setTimeout(resolve, 100))
-
-// Re-export everything from testing library
-export * from '@testing-library/react'
-export { default as userEvent } from '@testing-library/user-event'

package/management-ui/src/utils/repository.js

@@ -1,98 +0,0 @@
-import crypto from 'crypto'
-
-/**
- * Validates if a repository path is valid
- * @param {string} path - Repository path to validate
- * @returns {boolean} - True if valid, false otherwise
- */
-export function validateRepositoryPath(path) {
-  if (!path || typeof path !== 'string') {
-    return false
-  }
-  
-  // Must be absolute path and have reasonable length
-  return path.startsWith('/') && path.length > 2
-}
-
-/**
- * Formats a repository name for display
- * @param {string} name - Raw repository name
- * @returns {string} - Formatted display name
- */
-export function formatRepositoryName(name) {
-  if (!name || typeof name !== 'string') {
-    return ''
-  }
-  
-  let formatted = name
-  
-  // Remove common prefixes and suffixes
-  formatted = formatted
-    .replace(/^frigg-(.+)-api$/, '$1-api') // frigg-slack-api -> slack-api
-    .replace(/-backend$/, '')
-    .replace(/^frontend-/, '')
-  
-  // Convert to title case
-  formatted = formatted
-    .split(/[-_]/)
-    .map(word => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase())
-    .join(' ')
-  
-  return formatted
-}
-
-/**
- * Parses raw repository info into standardized format
- * @param {object} rawRepo - Raw repository data
- * @returns {object} - Parsed repository info
- */
-export function parseRepositoryInfo(rawRepo) {
-  const {
-    name = '',
-    path = '',
-    framework = null,
-    hasBackend = false,
-    detectionReasons = []
-  } = rawRepo
-  
-  // Generate consistent ID based on path
-  const id = crypto
-    .createHash('sha256')
-    .update(path)
-    .digest('hex')
-    .substring(0, 16)
-  
-  return {
-    id,
-    name,
-    displayName: formatRepositoryName(name),
-    path,
-    framework,
-    hasBackend,
-    detectionReasons: Array.isArray(detectionReasons) ? detectionReasons : [],
-    status: 'unknown'
-  }
-}
-
-/**
- * Gets the current status of a repository
- * @param {object} repo - Repository info
- * @returns {Promise<string>} - Status: 'active', 'inactive', or 'error'
- */
-export async function getRepositoryStatus(repo) {
-  try {
-    if (!validateRepositoryPath(repo?.path) || !repo?.name) {
-      return 'error'
-    }
-    
-    // In a real implementation, this would check:
-    // - If development servers are running
-    // - If the repository is accessible
-    // - If there are any errors in logs
-    
-    // For now, return a mock status
-    return 'inactive'
-  } catch (error) {
-    return 'error'
-  }
-}

package/management-ui/src/utils/repository.test.js

@@ -1,118 +0,0 @@
-import { describe, it, expect } from 'vitest'
-import { 
-  validateRepositoryPath, 
-  formatRepositoryName, 
-  parseRepositoryInfo,
-  getRepositoryStatus 
-} from './repository'
-
-describe('Repository Utilities', () => {
-  describe('validateRepositoryPath', () => {
-    it('returns true for valid repository paths', () => {
-      expect(validateRepositoryPath('/valid/path/to/repo')).toBe(true)
-      expect(validateRepositoryPath('/Users/user/project')).toBe(true)
-    })
-
-    it('returns false for invalid repository paths', () => {
-      expect(validateRepositoryPath('')).toBe(false)
-      expect(validateRepositoryPath(null)).toBe(false)
-      expect(validateRepositoryPath(undefined)).toBe(false)
-      expect(validateRepositoryPath('relative/path')).toBe(false)
-    })
-
-    it('returns false for paths that are too short', () => {
-      expect(validateRepositoryPath('/')).toBe(false)
-      expect(validateRepositoryPath('/a')).toBe(false)
-    })
-  })
-
-  describe('formatRepositoryName', () => {
-    it('formats repository names correctly', () => {
-      expect(formatRepositoryName('my-awesome-app')).toBe('My Awesome App')
-      expect(formatRepositoryName('frigg-integration')).toBe('Frigg Integration')
-      expect(formatRepositoryName('test_repo')).toBe('Test Repo')
-    })
-
-    it('handles edge cases', () => {
-      expect(formatRepositoryName('')).toBe('')
-      expect(formatRepositoryName('single')).toBe('Single')
-      expect(formatRepositoryName('UPPERCASE')).toBe('Uppercase')
-    })
-
-    it('removes common prefixes and suffixes', () => {
-      expect(formatRepositoryName('frigg-slack-api')).toBe('Slack Api')
-      expect(formatRepositoryName('my-app-backend')).toBe('My App')
-      expect(formatRepositoryName('frontend-react-app')).toBe('React App')
-    })
-  })
-
-  describe('parseRepositoryInfo', () => {
-    it('parses complete repository information', () => {
-      const rawRepo = {
-        name: 'test-repo',
-        path: '/test/path',
-        framework: 'React',
-        hasBackend: true,
-        detectionReasons: ['frigg dependencies', 'config file']
-      }
-
-      const parsed = parseRepositoryInfo(rawRepo)
-
-      expect(parsed).toEqual({
-        id: expect.any(String),
-        name: 'test-repo',
-        displayName: 'Test Repo',
-        path: '/test/path',
-        framework: 'React',
-        hasBackend: true,
-        detectionReasons: ['frigg dependencies', 'config file'],
-        status: 'unknown'
-      })
-    })
-
-    it('handles minimal repository information', () => {
-      const rawRepo = {
-        name: 'minimal',
-        path: '/minimal/path'
-      }
-
-      const parsed = parseRepositoryInfo(rawRepo)
-
-      expect(parsed).toEqual({
-        id: expect.any(String),
-        name: 'minimal',
-        displayName: 'Minimal',
-        path: '/minimal/path',
-        framework: null,
-        hasBackend: false,
-        detectionReasons: [],
-        status: 'unknown'
-      })
-    })
-
-    it('generates consistent IDs for same repository', () => {
-      const repo = { name: 'test', path: '/test' }
-      const parsed1 = parseRepositoryInfo(repo)
-      const parsed2 = parseRepositoryInfo(repo)
-      
-      expect(parsed1.id).toBe(parsed2.id)
-    })
-  })
-
-  describe('getRepositoryStatus', () => {
-    it('returns active for running repositories', async () => {
-      const mockRepo = { name: 'test', path: '/test' }
-      const status = await getRepositoryStatus(mockRepo)
-      
-      // This would normally check if servers are running, etc.
-      expect(['active', 'inactive', 'error']).toContain(status)
-    })
-
-    it('handles repository status check errors', async () => {
-      const invalidRepo = { name: '', path: '' }
-      const status = await getRepositoryStatus(invalidRepo)
-      
-      expect(status).toBe('error')
-    })
-  })
-})