Fix trace generation for landscapes with one class

Author: malte-hansen

src/backend/generation.ts

@@ -594,6 +594,9 @@ export function generateFakeTrace(apps: Array<FakeApp>, params: TraceGenerationP
             visitedClasses.delete(head[0]);
             classStack[classStack.length - 1][1].children.push(head[1]);
             previousClass = classStack[classStack.length - 1][0];
+          } else {
+            // Cannot reduce stack further, break out of the loop
+            break;
           }
           continue;
         }
@@ -616,6 +619,9 @@ export function generateFakeTrace(apps: Array<FakeApp>, params: TraceGenerationP
           visitedClasses.delete(head[0]);
           classStack[classStack.length - 1][1].children.push(head[1]);
           previousClass = classStack[classStack.length - 1][0];
+        } else {
+          // Cannot reduce stack further, break out of the loop
+          break;
         }
         continue;
       }

tests/backend/integration/trace-generation.test.ts

@@ -2,7 +2,7 @@ import { readFileSync } from 'fs';
 import { join } from 'path';
 import { beforeEach, describe, expect, it } from 'vitest';
 import { CommunicationStyle, generateFakeTrace, TraceGenerationParameters } from '../../../src/backend/generation';
-import { FakeApp } from '../../../src/backend/shared/types';
+import { FakeApp, FakeClass, FakePackage } from '../../../src/backend/shared/types';
 import { reconstructParentReferences } from '../../../src/backend/utils/landscape.utils';
 
 describe('Trace Generation Integration', () => {
@@ -469,4 +469,112 @@ describe('Trace Generation Integration', () => {
       expect(names1).not.toEqual(names2);
     });
   });
+
+  describe('Single Class Landscape', () => {
+    it('should handle single class with multiple methods without hanging', () => {
+      // Create a simple landscape with one class and two methods
+      const rootPackage: FakePackage = {
+        name: 'org',
+        classes: [],
+        subpackages: [],
+      };
+
+      const appPackage: FakePackage = {
+        name: 'testapp',
+        classes: [],
+        subpackages: [],
+        parent: rootPackage,
+      };
+
+      rootPackage.subpackages.push(appPackage);
+
+      const testClass: FakeClass = {
+        identifier: 'TestClass',
+        methods: ['method1', 'method2'],
+        parent: appPackage,
+        parentAppName: 'test-app',
+      };
+
+      appPackage.classes.push(testClass);
+
+      const testApp: FakeApp = {
+        name: 'test-app',
+        rootPackages: [rootPackage],
+        entryPoint: testClass,
+        classes: [testClass],
+        packages: [rootPackage, appPackage],
+        methods: ['method1', 'method2'],
+      };
+
+      const params: TraceGenerationParameters = {
+        duration: 1000,
+        callCount: 5,
+        maxConnectionDepth: 3,
+        communicationStyle: CommunicationStyle.TRUE_RANDOM,
+        allowCyclicCalls: false,
+        seed: 12345,
+      };
+
+      // This should complete without hanging
+      const trace = generateFakeTrace([testApp], params);
+
+      // Verify trace was generated
+      expect(trace).toBeDefined();
+      expect(trace.length).toBe(1);
+      expect(trace[0].name).toContain('TestClass');
+    });
+
+    it('should handle single class with allowCyclicCalls enabled', () => {
+      const rootPackage: FakePackage = {
+        name: 'org',
+        classes: [],
+        subpackages: [],
+      };
+
+      const appPackage: FakePackage = {
+        name: 'testapp',
+        classes: [],
+        subpackages: [],
+        parent: rootPackage,
+      };
+
+      rootPackage.subpackages.push(appPackage);
+
+      const testClass: FakeClass = {
+        identifier: 'TestClass',
+        methods: ['method1', 'method2'],
+        parent: appPackage,
+        parentAppName: 'test-app',
+      };
+
+      appPackage.classes.push(testClass);
+
+      const testApp: FakeApp = {
+        name: 'test-app',
+        rootPackages: [rootPackage],
+        entryPoint: testClass,
+        classes: [testClass],
+        packages: [rootPackage, appPackage],
+        methods: ['method1', 'method2'],
+      };
+
+      const params: TraceGenerationParameters = {
+        duration: 1000,
+        callCount: 5,
+        maxConnectionDepth: 3,
+        communicationStyle: CommunicationStyle.TRUE_RANDOM,
+        allowCyclicCalls: true,
+        seed: 54321,
+      };
+
+      const trace = generateFakeTrace([testApp], params);
+
+      function countSpans(spans: any[]): number {
+        return spans.length + spans.reduce((sum, span) => sum + countSpans(span.children), 0);
+      }
+
+      // With cyclic calls enabled, should generate the requested number of spans
+      expect(countSpans(trace)).toBe(6); // 1 root + 5 calls
+    });
+  });
 });

tests/frontend/LandscapeEditorDragDrop.test.tsx

@@ -2,7 +2,7 @@
  * @vitest-environment jsdom
  */
 import { describe, expect, it } from 'vitest';
-import { CleanedLandscape, CleanedPackage, CleanedClass } from '../../src/backend/shared/types';
+import { CleanedClass, CleanedLandscape, CleanedPackage } from '../../src/backend/shared/types';
 
 describe('LandscapeEditor - Drag and Drop Move Functions', () => {
   const createMockApp = (name: string, rootPackages?: CleanedPackage[], classes?: CleanedClass[]): CleanedLandscape => {