@friggframework/devtools 2.0.0-next.4 → 2.0.0-next.41

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

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

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

@@ -0,0 +1,118 @@
+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')
+    })
+  })
+})