Update flare-ui/src/app/components/test/test.component.ts

flare-ui/src/app/components/test/test.component.ts

@@ -10,11 +10,12 @@ import { MatListModule } from '@angular/material/list';
 import { MatChipsModule } from '@angular/material/chips';
 import { MatCardModule } from '@angular/material/card';
 import { ApiService } from '../../services/api.service';
+import { AuthService } from '../../services/auth.service';
 import { HttpClient } from '@angular/common/http';
 
 interface TestResult {
   name: string;
-  status: 'PASS' | 'FAIL' | 'RUNNING' | 'SKIPPED';
+  status: 'PASS' | 'FAIL' | 'RUNNING' | 'SKIP';
   duration_ms?: number;
   error?: string;
   details?: string;
@@ -48,13 +49,14 @@ interface TestCase {
     MatExpansionModule,
     MatListModule,
     MatChipsModule,
-    MatCardModule  // ADD THIS
+    MatCardModule
   ],
   templateUrl: './test.component.html',
   styleUrls: ['./test.component.scss']
 })
 export class TestComponent implements OnInit {
   private apiService = inject(ApiService);
+  private authService = inject(AuthService);
   private http = inject(HttpClient);
 
   running = false;
@@ -66,28 +68,28 @@ export class TestComponent implements OnInit {
       name: 'auth',
       displayName: 'Authentication Tests',
       tests: [],
-      selected: false,
+      selected: true,
       expanded: false
     },
     {
       name: 'api',
       displayName: 'API Endpoint Tests',
       tests: [],
-      selected: false,
+      selected: true,
       expanded: false
     },
     {
       name: 'validation',
       displayName: 'Validation Tests',
       tests: [],
-      selected: false,
+      selected: true,
       expanded: false
     },
     {
       name: 'integration',
       displayName: 'Integration Tests',
       tests: [],
-      selected: false,
+      selected: true,
       expanded: false
     }
   ];
@@ -119,7 +121,6 @@ export class TestComponent implements OnInit {
 
   ngOnInit() {
     this.initializeTests();
-    // Başlangıçta tüm kategoriler seçili mi kontrol et
     this.updateAllSelected();
   }
 
@@ -131,9 +132,35 @@ export class TestComponent implements OnInit {
     this.updateAllSelected();
   }
 
+  // Helper method to ensure authentication
+  private async ensureAuth(): Promise<boolean> {
+    try {
+      // Check if we already have a token
+      if (this.authService.getToken()) {
+        return true;
+      }
+
+      // Otherwise login
+      const response = await this.http.post('/api/login', {
+        username: 'admin',
+        password: 'admin'
+      }).toPromise() as any;
+
+      if (response?.token) {
+        this.authService.setToken(response.token);
+        this.authService.setUsername(response.username);
+        return true;
+      }
+      return false;
+    } catch {
+      return false;
+    }
+  }
+
   initializeTests() {
     // Authentication Tests
     this.addTest('auth', 'Login with valid credentials', async () => {
+      const start = Date.now();
       try {
         const response = await this.http.post('/api/login', {
           username: 'admin',
@@ -143,37 +170,39 @@ export class TestComponent implements OnInit {
         return {
           name: 'Login with valid credentials',
           status: response?.token ? 'PASS' : 'FAIL',
-          duration_ms: 120
+          duration_ms: Date.now() - start,
+          details: response?.token ? 'Successfully authenticated' : 'No token received'
         };
       } catch (error) {
         return {
           name: 'Login with valid credentials',
           status: 'FAIL',
           error: 'Login failed',
-          duration_ms: 120
+          duration_ms: Date.now() - start
         };
       }
     });
 
     this.addTest('auth', 'Login with invalid credentials', async () => {
+      const start = Date.now();
       try {
         await this.http.post('/api/login', {
           username: 'admin',
-          password: 'wrong'
+          password: 'wrong_password_12345'
         }).toPromise();
         
         return {
           name: 'Login with invalid credentials',
           status: 'FAIL',
           error: 'Expected 401 but got success',
-          duration_ms: 80
+          duration_ms: Date.now() - start
         };
       } catch (error: any) {
         return {
           name: 'Login with invalid credentials',
           status: error.status === 401 ? 'PASS' : 'FAIL',
-          duration_ms: 80,
-          details: 'Correctly rejected invalid credentials'
+          duration_ms: Date.now() - start,
+          details: error.status === 401 ? 'Correctly rejected invalid credentials' : `Unexpected status: ${error.status}`
         };
       }
     });
@@ -182,11 +211,21 @@ export class TestComponent implements OnInit {
     this.addTest('api', 'GET /api/environment', async () => {
       const start = Date.now();
       try {
+        if (!await this.ensureAuth()) {
+          return {
+            name: 'GET /api/environment',
+            status: 'SKIP',
+            error: 'Authentication failed',
+            duration_ms: Date.now() - start
+          };
+        }
+
         const response = await this.apiService.getEnvironment().toPromise();
         return {
           name: 'GET /api/environment',
           status: response?.work_mode ? 'PASS' : 'FAIL',
-          duration_ms: Date.now() - start
+          duration_ms: Date.now() - start,
+          details: response?.work_mode ? `Work mode: ${response.work_mode}` : 'No work mode returned'
         };
       } catch (error) {
         return {
@@ -201,12 +240,21 @@ export class TestComponent implements OnInit {
     this.addTest('api', 'GET /api/projects', async () => {
       const start = Date.now();
       try {
+        if (!await this.ensureAuth()) {
+          return {
+            name: 'GET /api/projects',
+            status: 'SKIP',
+            error: 'Authentication failed',
+            duration_ms: Date.now() - start
+          };
+        }
+
         const response = await this.apiService.getProjects().toPromise();
         return {
           name: 'GET /api/projects',
           status: Array.isArray(response) ? 'PASS' : 'FAIL',
           duration_ms: Date.now() - start,
-          details: `Retrieved ${response?.length || 0} projects`
+          details: Array.isArray(response) ? `Retrieved ${response.length} projects` : 'Invalid response format'
         };
       } catch (error) {
         return {
@@ -221,12 +269,21 @@ export class TestComponent implements OnInit {
     this.addTest('api', 'GET /api/apis', async () => {
       const start = Date.now();
       try {
+        if (!await this.ensureAuth()) {
+          return {
+            name: 'GET /api/apis',
+            status: 'SKIP',
+            error: 'Authentication failed',
+            duration_ms: Date.now() - start
+          };
+        }
+
         const response = await this.apiService.getAPIs().toPromise();
         return {
           name: 'GET /api/apis',
           status: Array.isArray(response) ? 'PASS' : 'FAIL',
           duration_ms: Date.now() - start,
-          details: `Retrieved ${response?.length || 0} APIs`
+          details: Array.isArray(response) ? `Retrieved ${response.length} APIs` : 'Invalid response format'
         };
       } catch (error) {
         return {
@@ -244,26 +301,54 @@ export class TestComponent implements OnInit {
       let projectId: number | undefined = undefined;
 
       try {
-        // Create project
+        if (!await this.ensureAuth()) {
+          return {
+            name: 'Create and delete project',
+            status: 'SKIP',
+            error: 'Authentication failed',
+            duration_ms: Date.now() - start
+          };
+        }
+
+        // Create test project
+        const testProjectName = `test_project_${Date.now()}`;
         const createResponse = await this.apiService.createProject({
-          name: `test_project_${Date.now()}`,
-          caption: 'Test Project'
+          name: testProjectName,
+          caption: 'Test Project for Integration Test',
+          icon: 'folder',
+          description: 'This is a test project'
         }).toPromise() as any;
 
         if (!createResponse?.id) {
-          throw new Error('Project creation failed');
+          throw new Error('Project creation failed - no ID returned');
         }
 
         projectId = createResponse.id;
 
+        // Verify project was created
+        const projects = await this.apiService.getProjects().toPromise() as any[];
+        const createdProject = projects.find(p => p.id === projectId);
+        
+        if (!createdProject) {
+          throw new Error('Created project not found in project list');
+        }
+
         // Delete project
-        await this.apiService.deleteProject(projectId!).toPromise();
+        await this.apiService.deleteProject(projectId).toPromise();
+
+        // Verify project was soft deleted
+        const projectsAfterDelete = await this.apiService.getProjects().toPromise() as any[];
+        const deletedProject = projectsAfterDelete.find(p => p.id === projectId);
+        
+        if (deletedProject) {
+          throw new Error('Project still visible after deletion');
+        }
 
         return {
           name: 'Create and delete project',
           status: 'PASS',
           duration_ms: Date.now() - start,
-          details: 'Project lifecycle test passed'
+          details: `Successfully created and deleted project: ${testProjectName}`
         };
       } catch (error: any) {
         // Try to clean up if project was created
@@ -284,23 +369,102 @@ export class TestComponent implements OnInit {
 
     this.addTest('integration', 'API used in intent cannot be deleted', async () => {
       const start = Date.now();
+      let testApiName: string | undefined;
+      let testProjectId: number | undefined;
+
       try {
-        // Try to delete an API that's used in intents
-        await this.apiService.deleteAPI('book_flight_api').toPromise();
-        
+        if (!await this.ensureAuth()) {
+          return {
+            name: 'API used in intent cannot be deleted',
+            status: 'SKIP',
+            error: 'Authentication failed',
+            duration_ms: Date.now() - start
+          };
+        }
+
+        // 1. Create test API
+        testApiName = `test_api_${Date.now()}`;
+        await this.apiService.createAPI({
+          name: testApiName,
+          url: 'https://test.example.com/api',
+          method: 'POST',
+          timeout_seconds: 10,
+          headers: { 'Content-Type': 'application/json' },
+          body_template: {}
+        }).toPromise();
+
+        // 2. Create test project with version that uses the API
+        const testProjectName = `test_project_${Date.now()}`;
+        const createProjectResponse = await this.apiService.createProject({
+          name: testProjectName,
+          caption: 'Test Project'
+        }).toPromise() as any;
+
+        testProjectId = createProjectResponse.id;
+
+        // 3. Update the version to add an intent that uses our API
+        const version = createProjectResponse.versions[0];
+        await this.apiService.updateVersion(testProjectId, version.id, {
+          caption: version.caption,
+          general_prompt: 'Test prompt',
+          llm: version.llm,
+          intents: [{
+            name: 'test-intent',
+            caption: 'Test Intent',
+            locale: 'tr-TR',
+            detection_prompt: 'Test detection',
+            examples: ['test example'],
+            parameters: [],
+            action: testApiName,  // This is where we use the API
+            fallback_timeout_prompt: 'Timeout',
+            fallback_error_prompt: 'Error'
+          }],
+          last_update_date: version.last_update_date
+        }).toPromise();
+
+        // 4. Try to delete the API - this should fail
+        try {
+          await this.apiService.deleteAPI(testApiName).toPromise();
+          
+          // If we reach here, deletion succeeded when it shouldn't have
+          return {
+            name: 'API used in intent cannot be deleted',
+            status: 'FAIL',
+            error: 'API was deleted even though it was in use',
+            duration_ms: Date.now() - start
+          };
+        } catch (deleteError: any) {
+          // Check if we got the expected error
+          const isExpectedError = deleteError.status === 400 && 
+                                 deleteError.error?.detail?.includes('API is used');
+          
+          return {
+            name: 'API used in intent cannot be deleted',
+            status: isExpectedError ? 'PASS' : 'FAIL',
+            duration_ms: Date.now() - start,
+            details: isExpectedError 
+              ? 'Correctly prevented deletion of API in use' 
+              : `Unexpected error: Status ${deleteError.status}, Detail: ${deleteError.error?.detail || deleteError.message}`
+          };
+        }
+      } catch (error: any) {
         return {
           name: 'API used in intent cannot be deleted',
           status: 'FAIL',
-          error: 'Expected error but API was deleted',
+          error: `Test setup failed: ${error.message}`,
           duration_ms: Date.now() - start
         };
-      } catch (error: any) {
-        return {
-          name: 'API used in intent cannot be deleted',
-          status: error.status === 400 ? 'PASS' : 'FAIL',
-          duration_ms: Date.now() - start,
-          details: 'Correctly prevented deletion of API in use'
-        };
+      } finally {
+        // Cleanup
+        try {
+          if (testProjectId) {
+            await this.apiService.deleteProject(testProjectId).toPromise();
+          }
+          if (testApiName) {
+            // Now we can delete the API since the project is gone
+            await this.apiService.deleteAPI(testApiName).toPromise();
+          }
+        } catch {}
       }
     });
 
@@ -308,17 +472,29 @@ export class TestComponent implements OnInit {
     this.addTest('validation', 'Regex validation - valid pattern', async () => {
       const start = Date.now();
       try {
-        const response = await this.apiService.validateRegex('^[A-Z]{3}$', 'ABC').toPromise();
+        if (!await this.ensureAuth()) {
+          return {
+            name: 'Regex validation - valid pattern',
+            status: 'SKIP',
+            error: 'Authentication failed',
+            duration_ms: Date.now() - start
+          };
+        }
+
+        const response = await this.apiService.validateRegex('^[A-Z]{3}$', 'ABC').toPromise() as any;
         return {
           name: 'Regex validation - valid pattern',
-          status: response.valid && response.matches ? 'PASS' : 'FAIL',
-          duration_ms: Date.now() - start
+          status: response?.valid && response?.matches ? 'PASS' : 'FAIL',
+          duration_ms: Date.now() - start,
+          details: response?.valid && response?.matches 
+            ? 'Pattern matched successfully' 
+            : 'Pattern did not match or validation failed'
         };
       } catch (error) {
         return {
           name: 'Regex validation - valid pattern',
           status: 'FAIL',
-          error: 'Validation failed',
+          error: 'Validation endpoint failed',
           duration_ms: Date.now() - start
         };
       }
@@ -327,14 +503,26 @@ export class TestComponent implements OnInit {
     this.addTest('validation', 'Regex validation - invalid pattern', async () => {
       const start = Date.now();
       try {
-        const response = await this.apiService.validateRegex('[invalid', 'test').toPromise();
+        if (!await this.ensureAuth()) {
+          return {
+            name: 'Regex validation - invalid pattern',
+            status: 'SKIP',
+            error: 'Authentication failed',
+            duration_ms: Date.now() - start
+          };
+        }
+
+        const response = await this.apiService.validateRegex('[invalid', 'test').toPromise() as any;
         return {
           name: 'Regex validation - invalid pattern',
-          status: !response.valid ? 'PASS' : 'FAIL',
+          status: !response?.valid ? 'PASS' : 'FAIL',
           duration_ms: Date.now() - start,
-          details: 'Correctly identified invalid regex'
+          details: !response?.valid 
+            ? 'Correctly identified invalid regex' 
+            : 'Failed to identify invalid regex'
         };
-      } catch (error) {
+      } catch (error: any) {
+        // Some errors are expected for invalid regex
         return {
           name: 'Regex validation - invalid pattern',
           status: 'PASS',
@@ -346,7 +534,8 @@ export class TestComponent implements OnInit {
 
     // Update test counts
     this.categories.forEach(cat => {
-      cat.displayName = `${cat.displayName} (${cat.tests.length} tests)`;
+      const originalName = cat.displayName.split(' (')[0];
+      cat.displayName = `${originalName} (${cat.tests.length} tests)`;
     });
   }