unreal-engine-mcp-server 0.4.7 → 0.5.0

package/tests/test-graphql.mjs

@@ -0,0 +1,322 @@
+#!/usr/bin/env node
+/**
+ * GraphQL API Test Suite
+ *
+ * Tests the GraphQL server functionality
+ */
+
+import { createServer } from 'http';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { GraphQLServer } from '../dist/graphql/server.js';
+import { UnrealBridge } from '../dist/unreal-bridge.js';
+import { AutomationBridge } from '../dist/automation/index.js';
+
+// Test automation bridge for verifying GraphQL integration
+class TestAutomationBridge {
+  constructor() {
+    this.handlers = new Map();
+    this.connected = false;
+  }
+
+  on(event, handler) {
+    this.handlers.set(event, handler);
+  }
+
+  off(event, handler) {
+    const existing = this.handlers.get(event);
+    if (!existing) return;
+    if (!handler || existing === handler) {
+      this.handlers.delete(event);
+    }
+  }
+
+  isConnected() {
+    return this.connected;
+  }
+
+  start() {
+    // Simulate connection
+    setTimeout(() => {
+      this.connected = true;
+      const handler = this.handlers.get('connected');
+      if (handler) {
+        handler({ metadata: {}, port: 8090, protocol: 'mcp-automation' });
+      }
+    }, 100);
+  }
+
+  stop() {
+    // Cleanup
+  }
+
+  sendAutomationRequest(action, params, options) {
+    // Return test data based on action
+    switch (action) {
+      case 'list_assets':
+        return Promise.resolve({
+          success: true,
+          result: {
+            assets: [
+              { name: 'Material1', path: '/Game/Materials/Mat1', class: 'Material' },
+              { name: 'Material2', path: '/Game/Materials/Mat2', class: 'Material' }
+            ],
+            totalCount: 2
+          }
+        });
+
+      case 'list_actors':
+        return Promise.resolve({
+          success: true,
+          result: {
+            actors: [
+              { name: 'Cube', class: 'StaticMeshActor', location: { x: 0, y: 0, z: 100 } },
+              { name: 'Sphere', class: 'StaticMeshActor', location: { x: 100, y: 0, z: 100 } }
+            ]
+          }
+        });
+
+      case 'get_blueprint':
+        return Promise.resolve({
+          success: true,
+          result: {
+            name: 'BP_Test',
+            path: '/Game/Blueprints/BP_Test',
+            parentClass: 'Actor',
+            variables: [{ name: 'Health', type: 'Float', defaultValue: 100 }],
+            functions: [{ name: 'TakeDamage', inputs: [{ name: 'Damage', type: 'Float' }] }],
+            events: [{ name: 'BeginPlay', type: 'Event' }],
+            components: []
+          }
+        });
+
+      case 'list_blueprints':
+        return Promise.resolve({
+          success: true,
+          result: {
+            blueprints: [
+              { name: 'BP_Player', path: '/Game/Blueprints/BP_Player', parentClass: 'Character' },
+              { name: 'BP_Enemy', path: '/Game/Blueprints/BP_Enemy', parentClass: 'Character' }
+            ],
+            totalCount: 2
+          }
+        });
+
+      case 'search':
+        return Promise.resolve({
+          success: true,
+          result: {
+            results: [
+              { name: 'Material1', path: '/Game/Materials/Mat1', class: 'Material' },
+              { name: 'Cube', class: 'StaticMeshActor' }
+            ]
+          }
+        });
+
+      default:
+        return Promise.resolve({ success: true, result: {} });
+    }
+  }
+}
+
+const log = {
+  info: (...args) => console.log('[INFO]', ...args),
+  warn: (...args) => console.warn('[WARN]', ...args),
+  error: (...args) => console.error('[ERROR]', ...args),
+  debug: (...args) => console.debug('[DEBUG]', ...args)
+};
+
+async function testGraphQLServer() {
+  log.info('Starting GraphQL server test...');
+
+  const bridge = new UnrealBridge();
+  const testAutomationBridge = new TestAutomationBridge();
+  bridge.setAutomationBridge(testAutomationBridge);
+
+  const graphQLServer = new GraphQLServer(bridge, testAutomationBridge, {
+    enabled: true,
+    port: 4000,
+    host: '127.0.0.1'
+  });
+
+  try {
+    await graphQLServer.start();
+    log.info('✅ GraphQL server started successfully');
+
+    // Give the server a moment to start
+    await new Promise(resolve => setTimeout(resolve, 500));
+
+    log.info('GraphQL server is running at http://127.0.0.1:4000/graphql');
+    log.info('You can test it with: curl -X POST -H "Content-Type: application/json" -d \'{"query": "{ assets { edges { node { name path } } } }"\' http://127.0.0.1:4000/graphql');
+
+    // Run tests
+    await runGraphQLTests();
+
+    // Keep server running for manual testing
+    log.info('\nGraphQL server is still running. Press Ctrl+C to stop.');
+  } catch (error) {
+    log.error('Failed to start GraphQL server:', error);
+    process.exit(1);
+  }
+}
+
+async function runGraphQLTests() {
+  log.info('\n=== Running GraphQL Tests ===\n');
+
+  const tests = [
+    {
+      name: 'List Assets',
+      query: `
+        {
+          assets {
+            edges {
+              node {
+                name
+                path
+                class
+              }
+            }
+            totalCount
+          }
+        }
+      `
+    },
+    {
+      name: 'List Actors',
+      query: `
+        {
+          actors {
+            edges {
+              node {
+                name
+                class
+                location {
+                  x
+                  y
+                  z
+                }
+              }
+            }
+          }
+        }
+      `
+    },
+    {
+      name: 'Get Blueprint',
+      query: `
+        {
+          blueprint(path: "/Game/Blueprints/BP_Test") {
+            name
+            path
+            parentClass
+            variables {
+              name
+              type
+              defaultValue
+            }
+            functions {
+              name
+              inputs {
+                name
+                type
+              }
+            }
+            events {
+              name
+              type
+            }
+          }
+        }
+      `
+    },
+    {
+      name: 'List Blueprints',
+      query: `
+        {
+          blueprints {
+            edges {
+              node {
+                name
+                path
+                parentClass
+              }
+            }
+            totalCount
+          }
+        }
+      `
+    },
+    {
+      name: 'Search',
+      query: `
+        {
+          search(query: "Material", type: ASSETS) {
+            ... on Asset {
+              name
+              path
+              class
+            }
+          }
+        }
+      `
+    }
+  ];
+
+  let passed = 0;
+  let failed = 0;
+
+  for (const test of tests) {
+    try {
+      log.info(`Testing: ${test.name}`);
+
+      const response = await fetch('http://127.0.0.1:4000/graphql', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ query: test.query })
+      });
+
+      const result = await response.json();
+
+      if (result.errors) {
+        log.error(`  ❌ ${test.name} - GraphQL Errors:`, JSON.stringify(result.errors));
+        failed++;
+      } else if (result.data) {
+        log.info(`  ✅ ${test.name} - Success`);
+        passed++;
+      } else {
+        log.error(`  ❌ ${test.name} - No data returned`);
+        failed++;
+      }
+    } catch (error) {
+      log.error(`  ❌ ${test.name} - Error:`, error.message);
+      failed++;
+    }
+  }
+
+  log.info('\n=== Test Results ===');
+  log.info(`Passed: ${passed}/${tests.length}`);
+  log.info(`Failed: ${failed}/${tests.length}`);
+
+  return { passed, failed, total: tests.length };
+}
+
+// Handle graceful shutdown
+process.on('SIGINT', () => {
+  log.info('\nShutting down...');
+  process.exit(0);
+});
+
+const thisFilePath = fileURLToPath(import.meta.url);
+const isMainModule = (() => {
+  const argvPath = process.argv[1];
+  if (!argvPath) return false;
+  const resolvedArgvPath = path.resolve(argvPath);
+  return thisFilePath === resolvedArgvPath;
+})();
+
+if (isMainModule) {
+  testGraphQLServer().catch(error => {
+    log.error('Test failed:', error);
+    process.exit(1);
+  });
+}

package/tests/test-inspect.mjs

@@ -0,0 +1,72 @@
+#!/usr/bin/env node
+/**
+ * Condensed Inspect Test Suite (15 cases) — safe for real Editor runs.
+ * Tools used: control_actor (bootstrap), inspect
+ */
+
+import { runToolTests } from './test-runner.mjs';
+
+const testCases = [
+  // 1. Bootstrap: spawn a mesh actor for inspection (using control_actor instead of execute_python)
+  { scenario: 'Bootstrap - spawn InspectActor', toolName: 'control_actor', arguments: { action: 'spawn', classPath: '/Engine/BasicShapes/Cube', actorName: 'Inspect_A', location: { x: 0, y: 0, z: 200 } }, expected: 'success - bootstrap created' },
+  // 2. Inspect actor by name
+  { scenario: 'Inspect actor by name', toolName: 'inspect', arguments: { action: 'inspect_object', name: 'Inspect_A' }, expected: 'success - object inspected' },
+  // 3. Get a property from the actor
+  { scenario: 'Get actor location property', toolName: 'inspect', arguments: { action: 'get_property', name: 'Inspect_A', propertyPath: 'ActorLocation' }, expected: 'success - property retrieved' },
+  // 4. Set a property on the actor
+  { scenario: 'Set actor hidden property', toolName: 'inspect', arguments: { action: 'set_property', name: 'Inspect_A', propertyPath: 'bHidden', value: true }, expected: 'success - property set' },
+  // 5. Inspect component list
+  { scenario: 'Get components on actor', toolName: 'inspect', arguments: { action: 'get_components', name: 'Inspect_A' }, expected: 'success - components returned' },
+  // 6. Get component property
+  { scenario: 'Get static mesh component mesh', toolName: 'inspect', arguments: { action: 'get_component_property', name: 'Inspect_A', componentName: 'StaticMeshComponent', propertyPath: 'StaticMesh' }, expected: 'success - component property retrieved' },
+  // 7. Set component mobility
+  { scenario: 'Set component mobility', toolName: 'inspect', arguments: { action: 'set_component_property', name: 'Inspect_A', componentName: 'StaticMeshComponent', propertyPath: 'Mobility', value: 'Movable' }, expected: 'success - component property set' },
+  // 8. Query actor metadata (best-effort)
+  { scenario: 'Get actor metadata', toolName: 'inspect', arguments: { action: 'get_metadata', name: 'Inspect_A' }, expected: 'success - metadata returned' },
+  // 9. Add a tag to the actor
+  { scenario: 'Add tag to actor', toolName: 'inspect', arguments: { action: 'add_tag', name: 'Inspect_A', tag: 'InspectTC' }, expected: 'success - tag added' },
+  // 10. Find actors by tag
+  { scenario: 'Find actors by tag', toolName: 'inspect', arguments: { action: 'find_by_tag', tag: 'InspectTC' }, expected: 'success - actors found' },
+  // 11. Save actor state (best-effort)
+  { scenario: 'Save actor snapshot', toolName: 'inspect', arguments: { action: 'create_snapshot', name: 'Inspect_A', snapshotName: 'Inspect_A_Snap' }, expected: 'success - snapshot created' },
+  // 12. Restore actor state
+  { scenario: 'Restore actor snapshot', toolName: 'inspect', arguments: { action: 'restore_snapshot', name: 'Inspect_A', snapshotName: 'Inspect_A_Snap' }, expected: 'success - snapshot restored' },
+  // 13. Export actor to JSON
+  { scenario: 'Export actor', toolName: 'inspect', arguments: { action: 'export', name: 'Inspect_A', format: 'JSON', outputPath: './tests/reports/inspect_actor_export.json' }, expected: 'success - actor exported' },
+  // 14. Delete test actor via inspect
+  { scenario: 'Delete actor', toolName: 'inspect', arguments: { action: 'delete_object', name: 'Inspect_A' }, expected: 'success - actor deleted' },
+  // 15. Verify deletion with a simple list
+  { scenario: 'Verify actor deleted', toolName: 'inspect', arguments: { action: 'list_objects', filter: 'Inspect_A' }, expected: 'success - deleted or not found' },
+  // Additional
+  { scenario: 'List objects', toolName: 'inspect', arguments: { action: 'list_objects', filter: 'Inspect_' }, expected: 'success or handled' },
+  { scenario: 'Find by class', toolName: 'inspect', arguments: { action: 'find_by_class', className: 'StaticMeshActor' }, expected: 'success or handled' },
+  { scenario: 'Get bounding box', toolName: 'inspect', arguments: { action: 'get_bounding_box', name: 'Inspect_A' }, expected: 'error|ACTOR_NOT_FOUND' },
+  { scenario: 'Inspect blueprint class (best-effort)', toolName: 'inspect', arguments: { action: 'inspect_class', classPath: '/Game/Blueprints/BP_Auto' }, expected: 'success or handled' },
+  { scenario: 'Verify delete again', toolName: 'inspect', arguments: { action: 'delete_object', name: 'Inspect_A' }, expected: 'error|NOT_FOUND' },
+  {
+    scenario: "Error: Invalid object path",
+    toolName: "inspect",
+    arguments: { action: "inspect_object", objectPath: "/Invalid/Path" },
+    expected: "not_found"
+  },
+  {
+    scenario: "Edge: Set invalid property",
+    toolName: "inspect",
+    arguments: { action: "set_property", objectPath: "/Valid", propertyName: "InvalidProp", value: 1 },
+    expected: "error|unknown_property|OBJECT_NOT_FOUND"
+  },
+  {
+    scenario: "Border: Empty tag add",
+    toolName: "inspect",
+    arguments: { action: "add_tag", objectPath: "/Valid", tag: "" },
+    expected: "success|handled"
+  },
+  {
+    scenario: "Error: Find invalid class",
+    toolName: "inspect",
+    arguments: { action: "find_by_class", className: "InvalidClass" },
+    expected: "no_results|success"
+  }
+];
+
+await runToolTests('Inspect', testCases);

package/tests/test-landscape.mjs

@@ -0,0 +1,60 @@
+#!/usr/bin/env node
+/**
+ * Condensed Environment Building Test Suite (15 cases)
+ * Tool: build_environment
+ */
+
+import { runToolTests } from './test-runner.mjs';
+
+const testCases = [
+  { scenario: 'Create small landscape', toolName: 'build_environment', arguments: { action: 'create_landscape', name: 'TC_Landscape', sizeX: 4, sizeY: 4 }, expected: 'success - landscape created' },
+  { scenario: 'Sculpt landscape - smooth', toolName: 'build_environment', arguments: { action: 'sculpt', name: 'TC_Landscape', tool: 'Smooth' }, expected: 'success or LOAD_FAILED' },
+  { scenario: 'Flatten small area', toolName: 'build_environment', arguments: { action: 'sculpt', name: 'TC_Landscape', tool: 'Flatten' }, expected: 'success or LOAD_FAILED' },
+  { scenario: 'Add foliage type (trees)', toolName: 'build_environment', arguments: { action: 'add_foliage', foliageType: 'TC_Tree', meshPath: '/Engine/BasicShapes/Cube.Cube', density: 0.1 }, expected: 'success - foliage added' },
+  { scenario: 'Paint a small foliage patch', toolName: 'build_environment', arguments: { action: 'paint_foliage', foliageType: 'TC_Tree', position: { x: 0, y: 0, z: 0 }, brushSize: 100, strength: 0.5 }, expected: 'success - foliage painted' },
+  { scenario: 'Create procedural terrain', toolName: 'build_environment', arguments: { action: 'create_procedural_terrain', name: 'TC_ProcTerrain', location: { x: 500, y: 0, z: 0 }, subdivisions: 8 }, expected: 'success - procedural terrain created' },
+  { scenario: 'Create procedural foliage (small)', toolName: 'build_environment', arguments: { action: 'create_procedural_foliage', bounds: { location: { x: 0, y: 0, z: 0 }, size: { x: 1000, y: 1000, z: 100 } }, seed: 42 }, expected: 'success - procedural foliage created' },
+  { scenario: 'Add grass foliage', toolName: 'build_environment', arguments: { action: 'add_foliage', meshPath: '/Engine/BasicShapes/Cube.Cube', density: 0.5 }, expected: 'success - grass added' },
+  { scenario: 'Generate small LODs (best-effort)', toolName: 'build_environment', arguments: { action: 'generate_lods', assetPath: '/Game/Meshes/SM_Test', lodCount: 2 }, expected: 'success or ASSET_NOT_FOUND' },
+  { scenario: 'Bake lightmap for a small area (preview)', toolName: 'build_environment', arguments: { action: 'bake_lightmap', quality: 'Preview' }, expected: 'success - lightmap bake requested' },
+  { scenario: 'Create landscape grass type', toolName: 'build_environment', arguments: { action: 'create_landscape_grass_type', name: 'TC_Grass', meshPath: '/Engine/BasicShapes/Cube.Cube' }, expected: 'success - grass type created' },
+  { scenario: 'Add foliage instances', toolName: 'build_environment', arguments: { action: 'add_foliage', foliageType: 'TC_Tree', locations: [{ x: 0, y: 0, z: 0 }] }, expected: 'success - instances added' },
+  { scenario: 'Export environment snapshot', toolName: 'build_environment', arguments: { action: 'export_snapshot', path: './tests/reports/env_snapshot.json' }, expected: 'success - snapshot exported' },
+  { scenario: 'Import environment snapshot', toolName: 'build_environment', arguments: { action: 'import_snapshot', path: './tests/reports/env_snapshot.json' }, expected: 'success - import handled' },
+  { scenario: 'Cleanup landscape artifacts', toolName: 'build_environment', arguments: { action: 'delete', names: ['TC_Landscape', 'TC_ProcTerrain'] }, expected: 'success or DELETE_PARTIAL' },
+  // Additional
+  // Real-World Scenario: Terrain Sculpting
+  { scenario: 'Sculpting - Create Landscape', toolName: 'build_environment', arguments: { action: 'create_landscape', name: 'TC_Sculpt_Landscape', sizeX: 8, sizeY: 8 }, expected: 'success' },
+  { scenario: 'Sculpting - Apply Noise', toolName: 'build_environment', arguments: { action: 'sculpt', name: 'TC_Sculpt_Landscape', tool: 'Noise', strength: 0.2 }, expected: 'success or LOAD_FAILED' },
+  { scenario: 'Sculpting - Assign Material', toolName: 'build_environment', arguments: { action: 'set_landscape_material', name: 'TC_Sculpt_Landscape', materialPath: '/Engine/EngineMaterials/WorldGridMaterial.WorldGridMaterial' }, expected: 'success or LOAD_FAILED' },
+
+  // Cleanup
+  { scenario: 'Cleanup - Delete Sculpt Landscape', toolName: 'build_environment', arguments: { action: 'delete', names: ['TC_Sculpt_Landscape'] }, expected: 'success or DELETE_PARTIAL' },
+
+  {
+    scenario: "Error: Invalid sculpt tool",
+    toolName: "build_environment",
+    arguments: { action: "sculpt", tool: "InvalidTool" },
+    expected: "error"
+  },
+  {
+    scenario: "Edge: Landscape size 0",
+    toolName: "build_environment",
+    arguments: { action: "create_landscape", sizeX: 0, sizeY: 0 },
+    expected: "error|validation|required"
+  },
+  {
+    scenario: "Border: Zero density foliage",
+    toolName: "build_environment",
+    arguments: { action: "add_foliage", meshPath: "/Game/Valid", density: 0 },
+    expected: "success|no_instances|LOAD_FAILED|ASSET_NOT_FOUND|INVALID_ARGUMENT"
+  },
+  {
+    scenario: "Edge: Empty foliage types",
+    toolName: "build_environment",
+    arguments: { action: "create_procedural_foliage", foliageTypes: [] },
+    expected: "success|no_op"
+  }
+];
+
+await runToolTests('Environment Building', testCases);