This is page 47 of 48. Use http://codebase.md/czlonkowski/n8n-mcp?page={x} to view the full context.
# Directory Structure
```
├── _config.yml
├── .claude
│ └── agents
│ ├── code-reviewer.md
│ ├── context-manager.md
│ ├── debugger.md
│ ├── deployment-engineer.md
│ ├── mcp-backend-engineer.md
│ ├── n8n-mcp-tester.md
│ ├── technical-researcher.md
│ └── test-automator.md
├── .dockerignore
├── .env.docker
├── .env.example
├── .env.n8n.example
├── .env.test
├── .env.test.example
├── .github
│ ├── ABOUT.md
│ ├── BENCHMARK_THRESHOLDS.md
│ ├── FUNDING.yml
│ ├── gh-pages.yml
│ ├── secret_scanning.yml
│ └── workflows
│ ├── benchmark-pr.yml
│ ├── benchmark.yml
│ ├── docker-build-fast.yml
│ ├── docker-build-n8n.yml
│ ├── docker-build.yml
│ ├── release.yml
│ ├── test.yml
│ └── update-n8n-deps.yml
├── .gitignore
├── .npmignore
├── ATTRIBUTION.md
├── CHANGELOG.md
├── CLAUDE.md
├── codecov.yml
├── coverage.json
├── data
│ ├── .gitkeep
│ ├── nodes.db
│ ├── nodes.db-shm
│ ├── nodes.db-wal
│ └── templates.db
├── deploy
│ └── quick-deploy-n8n.sh
├── docker
│ ├── docker-entrypoint.sh
│ ├── n8n-mcp
│ ├── parse-config.js
│ └── README.md
├── docker-compose.buildkit.yml
├── docker-compose.extract.yml
├── docker-compose.n8n.yml
├── docker-compose.override.yml.example
├── docker-compose.test-n8n.yml
├── docker-compose.yml
├── Dockerfile
├── Dockerfile.railway
├── Dockerfile.test
├── docs
│ ├── AUTOMATED_RELEASES.md
│ ├── BENCHMARKS.md
│ ├── bugfix-onSessionCreated-event.md
│ ├── CHANGELOG.md
│ ├── CLAUDE_CODE_SETUP.md
│ ├── CLAUDE_INTERVIEW.md
│ ├── CODECOV_SETUP.md
│ ├── CODEX_SETUP.md
│ ├── CURSOR_SETUP.md
│ ├── DEPENDENCY_UPDATES.md
│ ├── DOCKER_README.md
│ ├── DOCKER_TROUBLESHOOTING.md
│ ├── FINAL_AI_VALIDATION_SPEC.md
│ ├── FLEXIBLE_INSTANCE_CONFIGURATION.md
│ ├── HTTP_DEPLOYMENT.md
│ ├── img
│ │ ├── cc_command.png
│ │ ├── cc_connected.png
│ │ ├── codex_connected.png
│ │ ├── cursor_tut.png
│ │ ├── Railway_api.png
│ │ ├── Railway_server_address.png
│ │ ├── vsc_ghcp_chat_agent_mode.png
│ │ ├── vsc_ghcp_chat_instruction_files.png
│ │ ├── vsc_ghcp_chat_thinking_tool.png
│ │ └── windsurf_tut.png
│ ├── INSTALLATION.md
│ ├── LIBRARY_USAGE.md
│ ├── local
│ │ ├── DEEP_DIVE_ANALYSIS_2025-10-02.md
│ │ ├── DEEP_DIVE_ANALYSIS_README.md
│ │ ├── Deep_dive_p1_p2.md
│ │ ├── integration-testing-plan.md
│ │ ├── integration-tests-phase1-summary.md
│ │ ├── N8N_AI_WORKFLOW_BUILDER_ANALYSIS.md
│ │ ├── P0_IMPLEMENTATION_PLAN.md
│ │ └── TEMPLATE_MINING_ANALYSIS.md
│ ├── MCP_ESSENTIALS_README.md
│ ├── MCP_QUICK_START_GUIDE.md
│ ├── MULTI_APP_INTEGRATION.md
│ ├── N8N_DEPLOYMENT.md
│ ├── RAILWAY_DEPLOYMENT.md
│ ├── README_CLAUDE_SETUP.md
│ ├── README.md
│ ├── tools-documentation-usage.md
│ ├── VS_CODE_PROJECT_SETUP.md
│ ├── WINDSURF_SETUP.md
│ └── workflow-diff-examples.md
├── examples
│ └── enhanced-documentation-demo.js
├── fetch_log.txt
├── IMPLEMENTATION_GUIDE.md
├── LICENSE
├── MEMORY_N8N_UPDATE.md
├── MEMORY_TEMPLATE_UPDATE.md
├── monitor_fetch.sh
├── MVP_DEPLOYMENT_PLAN.md
├── N8N_HTTP_STREAMABLE_SETUP.md
├── n8n-nodes.db
├── P0-R3-TEST-PLAN.md
├── package-lock.json
├── package.json
├── package.runtime.json
├── PRIVACY.md
├── railway.json
├── README.md
├── renovate.json
├── scripts
│ ├── analyze-optimization.sh
│ ├── audit-schema-coverage.ts
│ ├── build-optimized.sh
│ ├── compare-benchmarks.js
│ ├── demo-optimization.sh
│ ├── deploy-http.sh
│ ├── deploy-to-vm.sh
│ ├── export-webhook-workflows.ts
│ ├── extract-changelog.js
│ ├── extract-from-docker.js
│ ├── extract-nodes-docker.sh
│ ├── extract-nodes-simple.sh
│ ├── format-benchmark-results.js
│ ├── generate-benchmark-stub.js
│ ├── generate-detailed-reports.js
│ ├── generate-test-summary.js
│ ├── http-bridge.js
│ ├── mcp-http-client.js
│ ├── migrate-nodes-fts.ts
│ ├── migrate-tool-docs.ts
│ ├── n8n-docs-mcp.service
│ ├── nginx-n8n-mcp.conf
│ ├── prebuild-fts5.ts
│ ├── prepare-release.js
│ ├── publish-npm-quick.sh
│ ├── publish-npm.sh
│ ├── quick-test.ts
│ ├── run-benchmarks-ci.js
│ ├── sync-runtime-version.js
│ ├── test-ai-validation-debug.ts
│ ├── test-code-node-enhancements.ts
│ ├── test-code-node-fixes.ts
│ ├── test-docker-config.sh
│ ├── test-docker-fingerprint.ts
│ ├── test-docker-optimization.sh
│ ├── test-docker.sh
│ ├── test-empty-connection-validation.ts
│ ├── test-error-message-tracking.ts
│ ├── test-error-output-validation.ts
│ ├── test-error-validation.js
│ ├── test-essentials.ts
│ ├── test-expression-code-validation.ts
│ ├── test-expression-format-validation.js
│ ├── test-fts5-search.ts
│ ├── test-fuzzy-fix.ts
│ ├── test-fuzzy-simple.ts
│ ├── test-helpers-validation.ts
│ ├── test-http-search.ts
│ ├── test-http.sh
│ ├── test-jmespath-validation.ts
│ ├── test-multi-tenant-simple.ts
│ ├── test-multi-tenant.ts
│ ├── test-n8n-integration.sh
│ ├── test-node-info.js
│ ├── test-node-type-validation.ts
│ ├── test-nodes-base-prefix.ts
│ ├── test-operation-validation.ts
│ ├── test-optimized-docker.sh
│ ├── test-release-automation.js
│ ├── test-search-improvements.ts
│ ├── test-security.ts
│ ├── test-single-session.sh
│ ├── test-sqljs-triggers.ts
│ ├── test-telemetry-debug.ts
│ ├── test-telemetry-direct.ts
│ ├── test-telemetry-env.ts
│ ├── test-telemetry-integration.ts
│ ├── test-telemetry-no-select.ts
│ ├── test-telemetry-security.ts
│ ├── test-telemetry-simple.ts
│ ├── test-typeversion-validation.ts
│ ├── test-url-configuration.ts
│ ├── test-user-id-persistence.ts
│ ├── test-webhook-validation.ts
│ ├── test-workflow-insert.ts
│ ├── test-workflow-sanitizer.ts
│ ├── test-workflow-tracking-debug.ts
│ ├── update-and-publish-prep.sh
│ ├── update-n8n-deps.js
│ ├── update-readme-version.js
│ ├── vitest-benchmark-json-reporter.js
│ └── vitest-benchmark-reporter.ts
├── SECURITY.md
├── src
│ ├── config
│ │ └── n8n-api.ts
│ ├── data
│ │ └── canonical-ai-tool-examples.json
│ ├── database
│ │ ├── database-adapter.ts
│ │ ├── migrations
│ │ │ └── add-template-node-configs.sql
│ │ ├── node-repository.ts
│ │ ├── nodes.db
│ │ ├── schema-optimized.sql
│ │ └── schema.sql
│ ├── errors
│ │ └── validation-service-error.ts
│ ├── http-server-single-session.ts
│ ├── http-server.ts
│ ├── index.ts
│ ├── loaders
│ │ └── node-loader.ts
│ ├── mappers
│ │ └── docs-mapper.ts
│ ├── mcp
│ │ ├── handlers-n8n-manager.ts
│ │ ├── handlers-workflow-diff.ts
│ │ ├── index.ts
│ │ ├── server.ts
│ │ ├── stdio-wrapper.ts
│ │ ├── tool-docs
│ │ │ ├── configuration
│ │ │ │ ├── get-node-as-tool-info.ts
│ │ │ │ ├── get-node-documentation.ts
│ │ │ │ ├── get-node-essentials.ts
│ │ │ │ ├── get-node-info.ts
│ │ │ │ ├── get-property-dependencies.ts
│ │ │ │ ├── index.ts
│ │ │ │ └── search-node-properties.ts
│ │ │ ├── discovery
│ │ │ │ ├── get-database-statistics.ts
│ │ │ │ ├── index.ts
│ │ │ │ ├── list-ai-tools.ts
│ │ │ │ ├── list-nodes.ts
│ │ │ │ └── search-nodes.ts
│ │ │ ├── guides
│ │ │ │ ├── ai-agents-guide.ts
│ │ │ │ └── index.ts
│ │ │ ├── index.ts
│ │ │ ├── system
│ │ │ │ ├── index.ts
│ │ │ │ ├── n8n-diagnostic.ts
│ │ │ │ ├── n8n-health-check.ts
│ │ │ │ ├── n8n-list-available-tools.ts
│ │ │ │ └── tools-documentation.ts
│ │ │ ├── templates
│ │ │ │ ├── get-template.ts
│ │ │ │ ├── get-templates-for-task.ts
│ │ │ │ ├── index.ts
│ │ │ │ ├── list-node-templates.ts
│ │ │ │ ├── list-tasks.ts
│ │ │ │ ├── search-templates-by-metadata.ts
│ │ │ │ └── search-templates.ts
│ │ │ ├── types.ts
│ │ │ ├── validation
│ │ │ │ ├── index.ts
│ │ │ │ ├── validate-node-minimal.ts
│ │ │ │ ├── validate-node-operation.ts
│ │ │ │ ├── validate-workflow-connections.ts
│ │ │ │ ├── validate-workflow-expressions.ts
│ │ │ │ └── validate-workflow.ts
│ │ │ └── workflow_management
│ │ │ ├── index.ts
│ │ │ ├── n8n-autofix-workflow.ts
│ │ │ ├── n8n-create-workflow.ts
│ │ │ ├── n8n-delete-execution.ts
│ │ │ ├── n8n-delete-workflow.ts
│ │ │ ├── n8n-get-execution.ts
│ │ │ ├── n8n-get-workflow-details.ts
│ │ │ ├── n8n-get-workflow-minimal.ts
│ │ │ ├── n8n-get-workflow-structure.ts
│ │ │ ├── n8n-get-workflow.ts
│ │ │ ├── n8n-list-executions.ts
│ │ │ ├── n8n-list-workflows.ts
│ │ │ ├── n8n-trigger-webhook-workflow.ts
│ │ │ ├── n8n-update-full-workflow.ts
│ │ │ ├── n8n-update-partial-workflow.ts
│ │ │ └── n8n-validate-workflow.ts
│ │ ├── tools-documentation.ts
│ │ ├── tools-n8n-friendly.ts
│ │ ├── tools-n8n-manager.ts
│ │ ├── tools.ts
│ │ └── workflow-examples.ts
│ ├── mcp-engine.ts
│ ├── mcp-tools-engine.ts
│ ├── n8n
│ │ ├── MCPApi.credentials.ts
│ │ └── MCPNode.node.ts
│ ├── parsers
│ │ ├── node-parser.ts
│ │ ├── property-extractor.ts
│ │ └── simple-parser.ts
│ ├── scripts
│ │ ├── debug-http-search.ts
│ │ ├── extract-from-docker.ts
│ │ ├── fetch-templates-robust.ts
│ │ ├── fetch-templates.ts
│ │ ├── rebuild-database.ts
│ │ ├── rebuild-optimized.ts
│ │ ├── rebuild.ts
│ │ ├── sanitize-templates.ts
│ │ ├── seed-canonical-ai-examples.ts
│ │ ├── test-autofix-documentation.ts
│ │ ├── test-autofix-workflow.ts
│ │ ├── test-execution-filtering.ts
│ │ ├── test-node-suggestions.ts
│ │ ├── test-protocol-negotiation.ts
│ │ ├── test-summary.ts
│ │ ├── test-webhook-autofix.ts
│ │ ├── validate.ts
│ │ └── validation-summary.ts
│ ├── services
│ │ ├── ai-node-validator.ts
│ │ ├── ai-tool-validators.ts
│ │ ├── confidence-scorer.ts
│ │ ├── config-validator.ts
│ │ ├── enhanced-config-validator.ts
│ │ ├── example-generator.ts
│ │ ├── execution-processor.ts
│ │ ├── expression-format-validator.ts
│ │ ├── expression-validator.ts
│ │ ├── n8n-api-client.ts
│ │ ├── n8n-validation.ts
│ │ ├── node-documentation-service.ts
│ │ ├── node-similarity-service.ts
│ │ ├── node-specific-validators.ts
│ │ ├── operation-similarity-service.ts
│ │ ├── property-dependencies.ts
│ │ ├── property-filter.ts
│ │ ├── resource-similarity-service.ts
│ │ ├── sqlite-storage-service.ts
│ │ ├── task-templates.ts
│ │ ├── universal-expression-validator.ts
│ │ ├── workflow-auto-fixer.ts
│ │ ├── workflow-diff-engine.ts
│ │ └── workflow-validator.ts
│ ├── telemetry
│ │ ├── batch-processor.ts
│ │ ├── config-manager.ts
│ │ ├── early-error-logger.ts
│ │ ├── error-sanitization-utils.ts
│ │ ├── error-sanitizer.ts
│ │ ├── event-tracker.ts
│ │ ├── event-validator.ts
│ │ ├── index.ts
│ │ ├── performance-monitor.ts
│ │ ├── rate-limiter.ts
│ │ ├── startup-checkpoints.ts
│ │ ├── telemetry-error.ts
│ │ ├── telemetry-manager.ts
│ │ ├── telemetry-types.ts
│ │ └── workflow-sanitizer.ts
│ ├── templates
│ │ ├── batch-processor.ts
│ │ ├── metadata-generator.ts
│ │ ├── README.md
│ │ ├── template-fetcher.ts
│ │ ├── template-repository.ts
│ │ └── template-service.ts
│ ├── types
│ │ ├── index.ts
│ │ ├── instance-context.ts
│ │ ├── n8n-api.ts
│ │ ├── node-types.ts
│ │ ├── session-restoration.ts
│ │ └── workflow-diff.ts
│ └── utils
│ ├── auth.ts
│ ├── bridge.ts
│ ├── cache-utils.ts
│ ├── console-manager.ts
│ ├── documentation-fetcher.ts
│ ├── enhanced-documentation-fetcher.ts
│ ├── error-handler.ts
│ ├── example-generator.ts
│ ├── fixed-collection-validator.ts
│ ├── logger.ts
│ ├── mcp-client.ts
│ ├── n8n-errors.ts
│ ├── node-source-extractor.ts
│ ├── node-type-normalizer.ts
│ ├── node-type-utils.ts
│ ├── node-utils.ts
│ ├── npm-version-checker.ts
│ ├── protocol-version.ts
│ ├── simple-cache.ts
│ ├── ssrf-protection.ts
│ ├── template-node-resolver.ts
│ ├── template-sanitizer.ts
│ ├── url-detector.ts
│ ├── validation-schemas.ts
│ └── version.ts
├── supabase-telemetry-aggregation.sql
├── TELEMETRY_PRUNING_GUIDE.md
├── telemetry-pruning-analysis.md
├── test-output.txt
├── test-reinit-fix.sh
├── tests
│ ├── __snapshots__
│ │ └── .gitkeep
│ ├── auth.test.ts
│ ├── benchmarks
│ │ ├── database-queries.bench.ts
│ │ ├── index.ts
│ │ ├── mcp-tools.bench.ts
│ │ ├── mcp-tools.bench.ts.disabled
│ │ ├── mcp-tools.bench.ts.skip
│ │ ├── node-loading.bench.ts.disabled
│ │ ├── README.md
│ │ ├── search-operations.bench.ts.disabled
│ │ └── validation-performance.bench.ts.disabled
│ ├── bridge.test.ts
│ ├── comprehensive-extraction-test.js
│ ├── data
│ │ └── .gitkeep
│ ├── debug-slack-doc.js
│ ├── demo-enhanced-documentation.js
│ ├── docker-tests-README.md
│ ├── error-handler.test.ts
│ ├── examples
│ │ └── using-database-utils.test.ts
│ ├── extracted-nodes-db
│ │ ├── database-import.json
│ │ ├── extraction-report.json
│ │ ├── insert-nodes.sql
│ │ ├── n8n-nodes-base__Airtable.json
│ │ ├── n8n-nodes-base__Discord.json
│ │ ├── n8n-nodes-base__Function.json
│ │ ├── n8n-nodes-base__HttpRequest.json
│ │ ├── n8n-nodes-base__If.json
│ │ ├── n8n-nodes-base__Slack.json
│ │ ├── n8n-nodes-base__SplitInBatches.json
│ │ └── n8n-nodes-base__Webhook.json
│ ├── factories
│ │ ├── node-factory.ts
│ │ └── property-definition-factory.ts
│ ├── fixtures
│ │ ├── .gitkeep
│ │ ├── database
│ │ │ └── test-nodes.json
│ │ ├── factories
│ │ │ ├── node.factory.ts
│ │ │ └── parser-node.factory.ts
│ │ └── template-configs.ts
│ ├── helpers
│ │ └── env-helpers.ts
│ ├── http-server-auth.test.ts
│ ├── integration
│ │ ├── ai-validation
│ │ │ ├── ai-agent-validation.test.ts
│ │ │ ├── ai-tool-validation.test.ts
│ │ │ ├── chat-trigger-validation.test.ts
│ │ │ ├── e2e-validation.test.ts
│ │ │ ├── helpers.ts
│ │ │ ├── llm-chain-validation.test.ts
│ │ │ ├── README.md
│ │ │ └── TEST_REPORT.md
│ │ ├── ci
│ │ │ └── database-population.test.ts
│ │ ├── database
│ │ │ ├── connection-management.test.ts
│ │ │ ├── empty-database.test.ts
│ │ │ ├── fts5-search.test.ts
│ │ │ ├── node-fts5-search.test.ts
│ │ │ ├── node-repository.test.ts
│ │ │ ├── performance.test.ts
│ │ │ ├── template-node-configs.test.ts
│ │ │ ├── template-repository.test.ts
│ │ │ ├── test-utils.ts
│ │ │ └── transactions.test.ts
│ │ ├── database-integration.test.ts
│ │ ├── docker
│ │ │ ├── docker-config.test.ts
│ │ │ ├── docker-entrypoint.test.ts
│ │ │ └── test-helpers.ts
│ │ ├── flexible-instance-config.test.ts
│ │ ├── mcp
│ │ │ └── template-examples-e2e.test.ts
│ │ ├── mcp-protocol
│ │ │ ├── basic-connection.test.ts
│ │ │ ├── error-handling.test.ts
│ │ │ ├── performance.test.ts
│ │ │ ├── protocol-compliance.test.ts
│ │ │ ├── README.md
│ │ │ ├── session-management.test.ts
│ │ │ ├── test-helpers.ts
│ │ │ ├── tool-invocation.test.ts
│ │ │ └── workflow-error-validation.test.ts
│ │ ├── msw-setup.test.ts
│ │ ├── n8n-api
│ │ │ ├── executions
│ │ │ │ ├── delete-execution.test.ts
│ │ │ │ ├── get-execution.test.ts
│ │ │ │ ├── list-executions.test.ts
│ │ │ │ └── trigger-webhook.test.ts
│ │ │ ├── scripts
│ │ │ │ └── cleanup-orphans.ts
│ │ │ ├── system
│ │ │ │ ├── diagnostic.test.ts
│ │ │ │ ├── health-check.test.ts
│ │ │ │ └── list-tools.test.ts
│ │ │ ├── test-connection.ts
│ │ │ ├── types
│ │ │ │ └── mcp-responses.ts
│ │ │ ├── utils
│ │ │ │ ├── cleanup-helpers.ts
│ │ │ │ ├── credentials.ts
│ │ │ │ ├── factories.ts
│ │ │ │ ├── fixtures.ts
│ │ │ │ ├── mcp-context.ts
│ │ │ │ ├── n8n-client.ts
│ │ │ │ ├── node-repository.ts
│ │ │ │ ├── response-types.ts
│ │ │ │ ├── test-context.ts
│ │ │ │ └── webhook-workflows.ts
│ │ │ └── workflows
│ │ │ ├── autofix-workflow.test.ts
│ │ │ ├── create-workflow.test.ts
│ │ │ ├── delete-workflow.test.ts
│ │ │ ├── get-workflow-details.test.ts
│ │ │ ├── get-workflow-minimal.test.ts
│ │ │ ├── get-workflow-structure.test.ts
│ │ │ ├── get-workflow.test.ts
│ │ │ ├── list-workflows.test.ts
│ │ │ ├── smart-parameters.test.ts
│ │ │ ├── update-partial-workflow.test.ts
│ │ │ ├── update-workflow.test.ts
│ │ │ └── validate-workflow.test.ts
│ │ ├── security
│ │ │ ├── command-injection-prevention.test.ts
│ │ │ └── rate-limiting.test.ts
│ │ ├── session
│ │ │ └── test-onSessionCreated-event.ts
│ │ ├── session-lifecycle-retry.test.ts
│ │ ├── session-persistence.test.ts
│ │ ├── session-restoration-warmstart.test.ts
│ │ ├── setup
│ │ │ ├── integration-setup.ts
│ │ │ └── msw-test-server.ts
│ │ ├── telemetry
│ │ │ ├── docker-user-id-stability.test.ts
│ │ │ └── mcp-telemetry.test.ts
│ │ ├── templates
│ │ │ └── metadata-operations.test.ts
│ │ └── workflow-creation-node-type-format.test.ts
│ ├── logger.test.ts
│ ├── MOCKING_STRATEGY.md
│ ├── mocks
│ │ ├── n8n-api
│ │ │ ├── data
│ │ │ │ ├── credentials.ts
│ │ │ │ ├── executions.ts
│ │ │ │ └── workflows.ts
│ │ │ ├── handlers.ts
│ │ │ └── index.ts
│ │ └── README.md
│ ├── node-storage-export.json
│ ├── setup
│ │ ├── global-setup.ts
│ │ ├── msw-setup.ts
│ │ ├── TEST_ENV_DOCUMENTATION.md
│ │ └── test-env.ts
│ ├── test-database-extraction.js
│ ├── test-direct-extraction.js
│ ├── test-enhanced-documentation.js
│ ├── test-enhanced-integration.js
│ ├── test-mcp-extraction.js
│ ├── test-mcp-server-extraction.js
│ ├── test-mcp-tools-integration.js
│ ├── test-node-documentation-service.js
│ ├── test-node-list.js
│ ├── test-package-info.js
│ ├── test-parsing-operations.js
│ ├── test-slack-node-complete.js
│ ├── test-small-rebuild.js
│ ├── test-sqlite-search.js
│ ├── test-storage-system.js
│ ├── unit
│ │ ├── __mocks__
│ │ │ ├── n8n-nodes-base.test.ts
│ │ │ ├── n8n-nodes-base.ts
│ │ │ └── README.md
│ │ ├── database
│ │ │ ├── __mocks__
│ │ │ │ └── better-sqlite3.ts
│ │ │ ├── database-adapter-unit.test.ts
│ │ │ ├── node-repository-core.test.ts
│ │ │ ├── node-repository-operations.test.ts
│ │ │ ├── node-repository-outputs.test.ts
│ │ │ ├── README.md
│ │ │ └── template-repository-core.test.ts
│ │ ├── docker
│ │ │ ├── config-security.test.ts
│ │ │ ├── edge-cases.test.ts
│ │ │ ├── parse-config.test.ts
│ │ │ └── serve-command.test.ts
│ │ ├── errors
│ │ │ └── validation-service-error.test.ts
│ │ ├── examples
│ │ │ └── using-n8n-nodes-base-mock.test.ts
│ │ ├── flexible-instance-security-advanced.test.ts
│ │ ├── flexible-instance-security.test.ts
│ │ ├── http-server
│ │ │ └── multi-tenant-support.test.ts
│ │ ├── http-server-n8n-mode.test.ts
│ │ ├── http-server-n8n-reinit.test.ts
│ │ ├── http-server-session-management.test.ts
│ │ ├── loaders
│ │ │ └── node-loader.test.ts
│ │ ├── mappers
│ │ │ └── docs-mapper.test.ts
│ │ ├── mcp
│ │ │ ├── get-node-essentials-examples.test.ts
│ │ │ ├── handlers-n8n-manager-simple.test.ts
│ │ │ ├── handlers-n8n-manager.test.ts
│ │ │ ├── handlers-workflow-diff.test.ts
│ │ │ ├── lru-cache-behavior.test.ts
│ │ │ ├── multi-tenant-tool-listing.test.ts.disabled
│ │ │ ├── parameter-validation.test.ts
│ │ │ ├── search-nodes-examples.test.ts
│ │ │ ├── tools-documentation.test.ts
│ │ │ └── tools.test.ts
│ │ ├── monitoring
│ │ │ └── cache-metrics.test.ts
│ │ ├── MULTI_TENANT_TEST_COVERAGE.md
│ │ ├── multi-tenant-integration.test.ts
│ │ ├── parsers
│ │ │ ├── node-parser-outputs.test.ts
│ │ │ ├── node-parser.test.ts
│ │ │ ├── property-extractor.test.ts
│ │ │ └── simple-parser.test.ts
│ │ ├── scripts
│ │ │ └── fetch-templates-extraction.test.ts
│ │ ├── services
│ │ │ ├── ai-node-validator.test.ts
│ │ │ ├── ai-tool-validators.test.ts
│ │ │ ├── confidence-scorer.test.ts
│ │ │ ├── config-validator-basic.test.ts
│ │ │ ├── config-validator-edge-cases.test.ts
│ │ │ ├── config-validator-node-specific.test.ts
│ │ │ ├── config-validator-security.test.ts
│ │ │ ├── debug-validator.test.ts
│ │ │ ├── enhanced-config-validator-integration.test.ts
│ │ │ ├── enhanced-config-validator-operations.test.ts
│ │ │ ├── enhanced-config-validator.test.ts
│ │ │ ├── example-generator.test.ts
│ │ │ ├── execution-processor.test.ts
│ │ │ ├── expression-format-validator.test.ts
│ │ │ ├── expression-validator-edge-cases.test.ts
│ │ │ ├── expression-validator.test.ts
│ │ │ ├── fixed-collection-validation.test.ts
│ │ │ ├── loop-output-edge-cases.test.ts
│ │ │ ├── n8n-api-client.test.ts
│ │ │ ├── n8n-validation.test.ts
│ │ │ ├── node-similarity-service.test.ts
│ │ │ ├── node-specific-validators.test.ts
│ │ │ ├── operation-similarity-service-comprehensive.test.ts
│ │ │ ├── operation-similarity-service.test.ts
│ │ │ ├── property-dependencies.test.ts
│ │ │ ├── property-filter-edge-cases.test.ts
│ │ │ ├── property-filter.test.ts
│ │ │ ├── resource-similarity-service-comprehensive.test.ts
│ │ │ ├── resource-similarity-service.test.ts
│ │ │ ├── task-templates.test.ts
│ │ │ ├── template-service.test.ts
│ │ │ ├── universal-expression-validator.test.ts
│ │ │ ├── validation-fixes.test.ts
│ │ │ ├── workflow-auto-fixer.test.ts
│ │ │ ├── workflow-diff-engine.test.ts
│ │ │ ├── workflow-fixed-collection-validation.test.ts
│ │ │ ├── workflow-validator-comprehensive.test.ts
│ │ │ ├── workflow-validator-edge-cases.test.ts
│ │ │ ├── workflow-validator-error-outputs.test.ts
│ │ │ ├── workflow-validator-expression-format.test.ts
│ │ │ ├── workflow-validator-loops-simple.test.ts
│ │ │ ├── workflow-validator-loops.test.ts
│ │ │ ├── workflow-validator-mocks.test.ts
│ │ │ ├── workflow-validator-performance.test.ts
│ │ │ ├── workflow-validator-with-mocks.test.ts
│ │ │ └── workflow-validator.test.ts
│ │ ├── session-lifecycle-events.test.ts
│ │ ├── session-management-api.test.ts
│ │ ├── session-restoration-retry.test.ts
│ │ ├── session-restoration.test.ts
│ │ ├── telemetry
│ │ │ ├── batch-processor.test.ts
│ │ │ ├── config-manager.test.ts
│ │ │ ├── event-tracker.test.ts
│ │ │ ├── event-validator.test.ts
│ │ │ ├── rate-limiter.test.ts
│ │ │ ├── telemetry-error.test.ts
│ │ │ ├── telemetry-manager.test.ts
│ │ │ ├── v2.18.3-fixes-verification.test.ts
│ │ │ └── workflow-sanitizer.test.ts
│ │ ├── templates
│ │ │ ├── batch-processor.test.ts
│ │ │ ├── metadata-generator.test.ts
│ │ │ ├── template-repository-metadata.test.ts
│ │ │ └── template-repository-security.test.ts
│ │ ├── test-env-example.test.ts
│ │ ├── test-infrastructure.test.ts
│ │ ├── types
│ │ │ ├── instance-context-coverage.test.ts
│ │ │ └── instance-context-multi-tenant.test.ts
│ │ ├── utils
│ │ │ ├── auth-timing-safe.test.ts
│ │ │ ├── cache-utils.test.ts
│ │ │ ├── console-manager.test.ts
│ │ │ ├── database-utils.test.ts
│ │ │ ├── fixed-collection-validator.test.ts
│ │ │ ├── n8n-errors.test.ts
│ │ │ ├── node-type-normalizer.test.ts
│ │ │ ├── node-type-utils.test.ts
│ │ │ ├── node-utils.test.ts
│ │ │ ├── simple-cache-memory-leak-fix.test.ts
│ │ │ ├── ssrf-protection.test.ts
│ │ │ └── template-node-resolver.test.ts
│ │ └── validation-fixes.test.ts
│ └── utils
│ ├── assertions.ts
│ ├── builders
│ │ └── workflow.builder.ts
│ ├── data-generators.ts
│ ├── database-utils.ts
│ ├── README.md
│ └── test-helpers.ts
├── thumbnail.png
├── tsconfig.build.json
├── tsconfig.json
├── types
│ ├── mcp.d.ts
│ └── test-env.d.ts
├── verify-telemetry-fix.js
├── versioned-nodes.md
├── vitest.config.benchmark.ts
├── vitest.config.integration.ts
└── vitest.config.ts
```
# Files
--------------------------------------------------------------------------------
/test-output.txt:
--------------------------------------------------------------------------------
```
> [email protected] test
> vitest --reporter=verbose
RUN v3.2.4 /Users/romualdczlonkowski/Pliki/n8n-mcp/n8n-mcp
Coverage enabled with v8
✓ tests/unit/http-server/multi-tenant-support.test.ts > HTTP Server Multi-Tenant Support > extractMultiTenantHeaders Function > should extract all multi-tenant headers when present 2ms
✓ tests/unit/http-server/multi-tenant-support.test.ts > HTTP Server Multi-Tenant Support > extractMultiTenantHeaders Function > should handle missing headers gracefully 0ms
✓ tests/unit/http-server/multi-tenant-support.test.ts > HTTP Server Multi-Tenant Support > extractMultiTenantHeaders Function > should handle case-insensitive headers 0ms
✓ tests/unit/http-server/multi-tenant-support.test.ts > HTTP Server Multi-Tenant Support > extractMultiTenantHeaders Function > should handle array header values 0ms
✓ tests/unit/http-server/multi-tenant-support.test.ts > HTTP Server Multi-Tenant Support > extractMultiTenantHeaders Function > should handle non-string header values 0ms
✓ tests/unit/http-server/multi-tenant-support.test.ts > HTTP Server Multi-Tenant Support > Instance Context Creation and Validation > should create valid instance context from complete headers 0ms
✓ tests/unit/http-server/multi-tenant-support.test.ts > HTTP Server Multi-Tenant Support > Instance Context Creation and Validation > should create partial instance context when some headers missing 0ms
✓ tests/unit/http-server/multi-tenant-support.test.ts > HTTP Server Multi-Tenant Support > Instance Context Creation and Validation > should return undefined context when no relevant headers present 0ms
↓ tests/unit/http-server/multi-tenant-support.test.ts > HTTP Server Multi-Tenant Support > Instance Context Creation and Validation > should validate instance context before use
✓ tests/unit/http-server/multi-tenant-support.test.ts > HTTP Server Multi-Tenant Support > Instance Context Creation and Validation > should handle malformed URLs in headers 1ms
✓ tests/unit/http-server/multi-tenant-support.test.ts > HTTP Server Multi-Tenant Support > Instance Context Creation and Validation > should handle special characters in headers 0ms
↓ tests/unit/http-server/multi-tenant-support.test.ts > HTTP Server Multi-Tenant Support > Session ID Generation with Configuration Hash > should generate consistent session ID for same configuration
↓ tests/unit/http-server/multi-tenant-support.test.ts > HTTP Server Multi-Tenant Support > Session ID Generation with Configuration Hash > should generate different session ID for different configuration
↓ tests/unit/http-server/multi-tenant-support.test.ts > HTTP Server Multi-Tenant Support > Session ID Generation with Configuration Hash > should include UUID in session ID for uniqueness
↓ tests/unit/http-server/multi-tenant-support.test.ts > HTTP Server Multi-Tenant Support > Session ID Generation with Configuration Hash > should handle undefined configuration in hash generation
↓ tests/unit/http-server/multi-tenant-support.test.ts > HTTP Server Multi-Tenant Support > Security Logging with Sanitization > should sanitize sensitive information in logs
↓ tests/unit/http-server/multi-tenant-support.test.ts > HTTP Server Multi-Tenant Support > Security Logging with Sanitization > should log session creation events
↓ tests/unit/http-server/multi-tenant-support.test.ts > HTTP Server Multi-Tenant Support > Security Logging with Sanitization > should log context switching events
↓ tests/unit/http-server/multi-tenant-support.test.ts > HTTP Server Multi-Tenant Support > Security Logging with Sanitization > should log validation failures securely
↓ tests/unit/http-server/multi-tenant-support.test.ts > HTTP Server Multi-Tenant Support > Security Logging with Sanitization > should not log API keys or sensitive data in plain text
✓ tests/unit/http-server/multi-tenant-support.test.ts > HTTP Server Multi-Tenant Support > Context Switching and Session Management > should handle session creation for new instance context 1ms
✓ tests/unit/http-server/multi-tenant-support.test.ts > HTTP Server Multi-Tenant Support > Context Switching and Session Management > should handle session switching between different contexts 0ms
✓ tests/unit/http-server/multi-tenant-support.test.ts > HTTP Server Multi-Tenant Support > Context Switching and Session Management > should prevent race conditions in session management 0ms
✓ tests/unit/http-server/multi-tenant-support.test.ts > HTTP Server Multi-Tenant Support > Context Switching and Session Management > should handle session cleanup for inactive sessions 0ms
✓ tests/unit/http-server/multi-tenant-support.test.ts > HTTP Server Multi-Tenant Support > Context Switching and Session Management > should handle maximum session limit 0ms
↓ tests/unit/http-server/multi-tenant-support.test.ts > HTTP Server Multi-Tenant Support > Error Handling and Edge Cases > should handle invalid header types gracefully
✓ tests/unit/http-server/multi-tenant-support.test.ts > HTTP Server Multi-Tenant Support > Error Handling and Edge Cases > should handle missing or corrupt session data 0ms
↓ tests/unit/http-server/multi-tenant-support.test.ts > HTTP Server Multi-Tenant Support > Error Handling and Edge Cases > should handle context validation errors gracefully
✓ tests/unit/http-server/multi-tenant-support.test.ts > HTTP Server Multi-Tenant Support > Error Handling and Edge Cases > should handle memory pressure during session management 1ms
✓ tests/integration/n8n-api/workflows/update-partial-workflow.test.ts > Integration: handleUpdatePartialWorkflow > Node Operations > addNode > should add a new node to workflow 396ms
✓ tests/integration/n8n-api/workflows/update-partial-workflow.test.ts > Integration: handleUpdatePartialWorkflow > Node Operations > addNode > should return error for duplicate node name 180ms
✓ tests/integration/n8n-api/workflows/update-partial-workflow.test.ts > Integration: handleUpdatePartialWorkflow > Node Operations > removeNode > should remove node by name 255ms
✓ tests/integration/n8n-api/workflows/update-partial-workflow.test.ts > Integration: handleUpdatePartialWorkflow > Node Operations > removeNode > should return error for non-existent node 185ms
✓ tests/integration/n8n-api/workflows/update-partial-workflow.test.ts > Integration: handleUpdatePartialWorkflow > Node Operations > updateNode > should update node parameters 246ms
✓ tests/integration/n8n-api/workflows/update-partial-workflow.test.ts > Integration: handleUpdatePartialWorkflow > Node Operations > updateNode > should update nested parameters 245ms
✓ tests/integration/n8n-api/workflows/update-partial-workflow.test.ts > Integration: handleUpdatePartialWorkflow > Node Operations > moveNode > should move node to new position 250ms
✓ tests/integration/n8n-api/workflows/update-partial-workflow.test.ts > Integration: handleUpdatePartialWorkflow > Node Operations > enableNode / disableNode > should disable a node 244ms
✓ tests/integration/n8n-api/workflows/update-partial-workflow.test.ts > Integration: handleUpdatePartialWorkflow > Node Operations > enableNode / disableNode > should enable a disabled node 362ms
✓ tests/integration/n8n-api/workflows/update-partial-workflow.test.ts > Integration: handleUpdatePartialWorkflow > Connection Operations > addConnection > should add connection between nodes 243ms
✓ tests/integration/n8n-api/workflows/update-partial-workflow.test.ts > Integration: handleUpdatePartialWorkflow > Connection Operations > addConnection > should add connection with custom ports 245ms
✓ tests/integration/n8n-api/workflows/update-partial-workflow.test.ts > Integration: handleUpdatePartialWorkflow > Connection Operations > removeConnection > should remove connection between nodes 241ms
✓ tests/integration/n8n-api/workflows/update-partial-workflow.test.ts > Integration: handleUpdatePartialWorkflow > Connection Operations > removeConnection > should ignore error for non-existent connection with ignoreErrors flag 244ms
✓ tests/integration/n8n-api/workflows/update-partial-workflow.test.ts > Integration: handleUpdatePartialWorkflow > Connection Operations > replaceConnections > should replace all connections 253ms
✓ tests/integration/n8n-api/workflows/update-partial-workflow.test.ts > Integration: handleUpdatePartialWorkflow > Connection Operations > cleanStaleConnections > should remove stale connections in dry run mode 299ms
✓ tests/integration/n8n-api/workflows/update-partial-workflow.test.ts > Integration: handleUpdatePartialWorkflow > Metadata Operations > updateSettings > should update workflow settings 247ms
✓ tests/integration/n8n-api/workflows/update-partial-workflow.test.ts > Integration: handleUpdatePartialWorkflow > Metadata Operations > updateName > should update workflow name 242ms
✓ tests/integration/n8n-api/workflows/update-partial-workflow.test.ts > Integration: handleUpdatePartialWorkflow > Metadata Operations > addTag / removeTag > should add tag to workflow 254ms
✓ tests/integration/n8n-api/workflows/update-partial-workflow.test.ts > Integration: handleUpdatePartialWorkflow > Metadata Operations > addTag / removeTag > should remove tag from workflow 339ms
✓ tests/integration/n8n-api/workflows/update-partial-workflow.test.ts > Integration: handleUpdatePartialWorkflow > Advanced Scenarios > should apply multiple operations in sequence 243ms
✓ tests/integration/n8n-api/workflows/update-partial-workflow.test.ts > Integration: handleUpdatePartialWorkflow > Advanced Scenarios > should validate operations without applying (validateOnly mode) 232ms
✓ tests/integration/n8n-api/workflows/update-partial-workflow.test.ts > Integration: handleUpdatePartialWorkflow > Advanced Scenarios > should handle continueOnError mode with partial failures 240ms
✓ tests/integration/mcp-protocol/session-management.test.ts > MCP Session Management > Session Lifecycle > should establish a new session 188ms
✓ tests/integration/mcp-protocol/session-management.test.ts > MCP Session Management > Session Lifecycle > should handle session initialization with capabilities 158ms
✓ tests/integration/mcp-protocol/session-management.test.ts > MCP Session Management > Session Lifecycle > should handle clean session termination 171ms
✓ tests/integration/mcp-protocol/session-management.test.ts > MCP Session Management > Session Lifecycle > should handle abrupt disconnection 175ms
↓ tests/integration/mcp-protocol/session-management.test.ts > MCP Session Management > Multiple Sessions > should handle multiple concurrent sessions
↓ tests/integration/mcp-protocol/session-management.test.ts > MCP Session Management > Multiple Sessions > should isolate session state
✓ tests/integration/mcp-protocol/session-management.test.ts > MCP Session Management > Multiple Sessions > should handle sequential sessions without interference 317ms
✓ tests/integration/mcp-protocol/session-management.test.ts > MCP Session Management > Multiple Sessions > should handle single server with multiple sequential connections 187ms
✓ tests/integration/mcp-protocol/session-management.test.ts > MCP Session Management > Session Recovery > should not persist state between sessions 200ms
✓ tests/integration/mcp-protocol/session-management.test.ts > MCP Session Management > Session Recovery > should handle rapid session cycling 1193ms
✓ tests/integration/mcp-protocol/session-management.test.ts > MCP Session Management > Session Metadata > should track client information 123ms
✓ tests/integration/mcp-protocol/session-management.test.ts > MCP Session Management > Session Metadata > should handle different client versions 183ms
✓ tests/integration/mcp-protocol/session-management.test.ts > MCP Session Management > Session Limits > should handle many sequential sessions 1711ms
✓ tests/integration/mcp-protocol/session-management.test.ts > MCP Session Management > Session Limits > should handle session with heavy usage 245ms
✓ tests/integration/mcp-protocol/session-management.test.ts > MCP Session Management > Session Error Recovery > should handle errors without breaking session 132ms
✓ tests/integration/mcp-protocol/session-management.test.ts > MCP Session Management > Session Error Recovery > should handle multiple errors in sequence 125ms
✓ tests/integration/mcp-protocol/session-management.test.ts > MCP Session Management > Resource Cleanup > should properly close all resources on shutdown 373ms
✓ tests/integration/mcp-protocol/session-management.test.ts > MCP Session Management > Session Transport Events > should handle transport reconnection 297ms
✓ tests/unit/utils/cache-utils.test.ts > cache-utils > createCacheKey > should create consistent SHA-256 hash for same input 1ms
✓ tests/unit/utils/cache-utils.test.ts > cache-utils > createCacheKey > should produce different hashes for different inputs 0ms
✓ tests/unit/utils/cache-utils.test.ts > cache-utils > createCacheKey > should use memoization for repeated inputs 0ms
✓ tests/unit/utils/cache-utils.test.ts > cache-utils > createCacheKey > should limit memoization cache size 3ms
✓ tests/unit/utils/cache-utils.test.ts > cache-utils > getCacheConfig > should return default configuration when no env vars set 0ms
✓ tests/unit/utils/cache-utils.test.ts > cache-utils > getCacheConfig > should use environment variables when set 0ms
✓ tests/unit/utils/cache-utils.test.ts > cache-utils > getCacheConfig > should enforce minimum bounds 0ms
✓ tests/unit/utils/cache-utils.test.ts > cache-utils > getCacheConfig > should enforce maximum bounds 0ms
✓ tests/unit/utils/cache-utils.test.ts > cache-utils > getCacheConfig > should handle invalid values gracefully 0ms
✓ tests/unit/utils/cache-utils.test.ts > cache-utils > createInstanceCache > should create LRU cache with correct configuration 0ms
✓ tests/unit/utils/cache-utils.test.ts > cache-utils > createInstanceCache > should call dispose callback on eviction 1ms
✓ tests/unit/utils/cache-utils.test.ts > cache-utils > createInstanceCache > should update age on get 0ms
✓ tests/unit/utils/cache-utils.test.ts > cache-utils > CacheMutex > should prevent concurrent access to same key 0ms
✓ tests/unit/utils/cache-utils.test.ts > cache-utils > CacheMutex > should allow concurrent access to different keys 0ms
✓ tests/unit/utils/cache-utils.test.ts > cache-utils > CacheMutex > should check if key is locked 0ms
✓ tests/unit/utils/cache-utils.test.ts > cache-utils > CacheMutex > should clear all locks 0ms
✓ tests/unit/utils/cache-utils.test.ts > cache-utils > CacheMutex > should handle timeout for stuck locks 5002ms
✓ tests/unit/utils/cache-utils.test.ts > cache-utils > calculateBackoffDelay > should calculate exponential backoff correctly 0ms
✓ tests/unit/utils/cache-utils.test.ts > cache-utils > calculateBackoffDelay > should respect max delay 0ms
✓ tests/unit/utils/cache-utils.test.ts > cache-utils > calculateBackoffDelay > should add jitter 0ms
✓ tests/unit/utils/cache-utils.test.ts > cache-utils > withRetry > should succeed on first attempt 0ms
✓ tests/unit/utils/cache-utils.test.ts > cache-utils > withRetry > should retry on failure and eventually succeed 33ms
✓ tests/unit/utils/cache-utils.test.ts > cache-utils > withRetry > should throw after max attempts 34ms
✓ tests/unit/utils/cache-utils.test.ts > cache-utils > withRetry > should not retry non-retryable errors 0ms
✓ tests/unit/utils/cache-utils.test.ts > cache-utils > withRetry > should retry network errors 10ms
✓ tests/unit/utils/cache-utils.test.ts > cache-utils > withRetry > should retry 429 Too Many Requests 167ms
✓ tests/unit/utils/cache-utils.test.ts > cache-utils > cacheMetrics > should track cache operations 0ms
✓ tests/unit/utils/cache-utils.test.ts > cache-utils > cacheMetrics > should update cache size 0ms
✓ tests/unit/utils/cache-utils.test.ts > cache-utils > cacheMetrics > should reset metrics 0ms
✓ tests/unit/utils/cache-utils.test.ts > cache-utils > cacheMetrics > should format metrics for logging 0ms
✓ tests/unit/utils/cache-utils.test.ts > cache-utils > getCacheStatistics > should return formatted statistics 1ms
✓ tests/unit/utils/cache-utils.test.ts > cache-utils > getCacheStatistics > should calculate runtime 0ms
✓ tests/integration/n8n-api/workflows/list-workflows.test.ts > Integration: handleListWorkflows > No Filters > should list all workflows without filters 405ms
✓ tests/integration/n8n-api/workflows/list-workflows.test.ts > Integration: handleListWorkflows > Filter by Active Status > should filter workflows by active=true 240ms
✓ tests/integration/n8n-api/workflows/list-workflows.test.ts > Integration: handleListWorkflows > Filter by Active Status > should filter workflows by active=false 188ms
✓ tests/integration/n8n-api/workflows/list-workflows.test.ts > Integration: handleListWorkflows > Filter by Tags > should filter workflows by name instead of tags 175ms
✓ tests/integration/n8n-api/workflows/list-workflows.test.ts > Integration: handleListWorkflows > Pagination > should return first page with limit 421ms
✓ tests/integration/n8n-api/workflows/list-workflows.test.ts > Integration: handleListWorkflows > Pagination > should handle pagination with cursor 745ms
✓ tests/integration/n8n-api/workflows/list-workflows.test.ts > Integration: handleListWorkflows > Pagination > should handle last page (no more results) 182ms
✓ tests/integration/n8n-api/workflows/list-workflows.test.ts > Integration: handleListWorkflows > Limit Variations > should respect limit=1 193ms
✓ tests/integration/n8n-api/workflows/list-workflows.test.ts > Integration: handleListWorkflows > Limit Variations > should respect limit=50 108ms
✓ tests/integration/n8n-api/workflows/list-workflows.test.ts > Integration: handleListWorkflows > Limit Variations > should respect limit=100 (max) 124ms
✓ tests/integration/n8n-api/workflows/list-workflows.test.ts > Integration: handleListWorkflows > Exclude Pinned Data > should exclude pinned data when requested 176ms
✓ tests/integration/n8n-api/workflows/list-workflows.test.ts > Integration: handleListWorkflows > Empty Results > should return empty array when no workflows match filters 55ms
✓ tests/integration/n8n-api/workflows/list-workflows.test.ts > Integration: handleListWorkflows > Sort Order > should return workflows in consistent order 771ms
✓ tests/integration/n8n-api/workflows/autofix-workflow.test.ts > Integration: handleAutofixWorkflow > Preview Mode > should preview fixes without applying them (expression-format) 186ms
✓ tests/integration/n8n-api/workflows/autofix-workflow.test.ts > Integration: handleAutofixWorkflow > Preview Mode > should preview multiple fix types 197ms
✓ tests/integration/n8n-api/workflows/autofix-workflow.test.ts > Integration: handleAutofixWorkflow > Apply Mode > should apply expression-format fixes 180ms
✓ tests/integration/n8n-api/workflows/autofix-workflow.test.ts > Integration: handleAutofixWorkflow > Apply Mode > should apply webhook-missing-path fixes 370ms
✓ tests/integration/n8n-api/workflows/autofix-workflow.test.ts > Integration: handleAutofixWorkflow > Fix Type Filtering > should only apply specified fix types 176ms
✓ tests/integration/n8n-api/workflows/autofix-workflow.test.ts > Integration: handleAutofixWorkflow > Fix Type Filtering > should handle multiple fix types filter 181ms
✓ tests/integration/n8n-api/workflows/autofix-workflow.test.ts > Integration: handleAutofixWorkflow > Confidence Threshold > should filter fixes by high confidence threshold 176ms
✓ tests/integration/n8n-api/workflows/autofix-workflow.test.ts > Integration: handleAutofixWorkflow > Confidence Threshold > should include medium and high confidence with medium threshold 198ms
✓ tests/integration/n8n-api/workflows/autofix-workflow.test.ts > Integration: handleAutofixWorkflow > Confidence Threshold > should include all confidence levels with low threshold 191ms
✓ tests/integration/n8n-api/workflows/autofix-workflow.test.ts > Integration: handleAutofixWorkflow > Max Fixes Parameter > should limit fixes to maxFixes parameter 191ms
✓ tests/integration/n8n-api/workflows/autofix-workflow.test.ts > Integration: handleAutofixWorkflow > No Fixes Available > should handle workflow with no fixable issues 180ms
✓ tests/integration/n8n-api/workflows/autofix-workflow.test.ts > Integration: handleAutofixWorkflow > Error Handling > should handle non-existent workflow ID 64ms
✓ tests/integration/n8n-api/workflows/autofix-workflow.test.ts > Integration: handleAutofixWorkflow > Error Handling > should handle invalid fixTypes parameter 124ms
✓ tests/integration/n8n-api/workflows/autofix-workflow.test.ts > Integration: handleAutofixWorkflow > Error Handling > should handle invalid confidence threshold 114ms
✓ tests/integration/n8n-api/workflows/autofix-workflow.test.ts > Integration: handleAutofixWorkflow > Response Format > should return complete autofix response structure (preview) 177ms
✓ tests/integration/n8n-api/workflows/autofix-workflow.test.ts > Integration: handleAutofixWorkflow > Response Format > should return complete autofix response structure (apply) 303ms
✓ tests/unit/docker/config-security.test.ts > Config File Security Tests > Command injection prevention > should prevent basic command injection attempts 1757ms
✓ tests/unit/docker/config-security.test.ts > Config File Security Tests > Command injection prevention > should handle complex nested injection attempts 33ms
✓ tests/unit/docker/config-security.test.ts > Config File Security Tests > Command injection prevention > should handle Unicode and special characters safely 32ms
Warning: Ignoring dangerous variable: LD_PRELOAD
✓ tests/unit/docker/config-security.test.ts > Config File Security Tests > Shell metacharacter handling > should safely handle all shell metacharacters 38ms
✓ tests/unit/docker/config-security.test.ts > Config File Security Tests > Escaping edge cases > should handle consecutive single quotes 32ms
✓ tests/unit/docker/config-security.test.ts > Config File Security Tests > Escaping edge cases > should handle empty and whitespace-only values 32ms
✓ tests/unit/docker/config-security.test.ts > Config File Security Tests > Escaping edge cases > should handle very long values 32ms
✓ tests/unit/docker/config-security.test.ts > Config File Security Tests > Environment variable name security > should handle potentially dangerous key names 34ms
✓ tests/unit/docker/config-security.test.ts > Config File Security Tests > Real-world attack scenarios > should prevent path traversal attempts 32ms
✓ tests/unit/docker/config-security.test.ts > Config File Security Tests > Real-world attack scenarios > should handle polyglot payloads safely 33ms
✓ tests/unit/docker/config-security.test.ts > Config File Security Tests > Stress testing > should handle deeply nested malicious structures 32ms
✓ tests/unit/docker/config-security.test.ts > Config File Security Tests > Stress testing > should handle mixed attack vectors in single config 37ms
✓ tests/unit/docker/serve-command.test.ts > n8n-mcp serve Command > Command transformation > should detect "n8n-mcp serve" and set MCP_MODE=http 154ms
✓ tests/unit/docker/serve-command.test.ts > n8n-mcp serve Command > Command transformation > should preserve additional arguments after serve command 125ms
✓ tests/unit/docker/serve-command.test.ts > n8n-mcp serve Command > Command transformation > should not affect other commands 134ms
✓ tests/unit/docker/serve-command.test.ts > n8n-mcp serve Command > Integration with config loading > should load config before processing serve command 160ms
✓ tests/unit/docker/serve-command.test.ts > n8n-mcp serve Command > Command line variations > should handle serve command with equals sign notation 125ms
ERROR: AUTH_TOKEN or AUTH_TOKEN_FILE is required for HTTP mode
✓ tests/unit/docker/serve-command.test.ts > n8n-mcp serve Command > Command line variations > should handle quoted arguments correctly 119ms
✓ tests/unit/docker/serve-command.test.ts > n8n-mcp serve Command > Error handling > should handle serve command with missing AUTH_TOKEN in HTTP mode 121ms
✓ tests/unit/docker/serve-command.test.ts > n8n-mcp serve Command > Error handling > should succeed with AUTH_TOKEN provided 121ms
✓ tests/unit/docker/serve-command.test.ts > n8n-mcp serve Command > Backwards compatibility > should maintain compatibility with direct HTTP mode setting 131ms
✓ tests/unit/docker/serve-command.test.ts > n8n-mcp serve Command > Command construction > should properly construct the node command after transformation 125ms
✓ tests/unit/docker/parse-config.test.ts > parse-config.js > Basic functionality > should parse simple flat config 33ms
✓ tests/unit/docker/parse-config.test.ts > parse-config.js > Basic functionality > should handle nested objects by flattening with underscores 31ms
✓ tests/unit/docker/parse-config.test.ts > parse-config.js > Basic functionality > should convert boolean values to strings 33ms
✓ tests/unit/docker/parse-config.test.ts > parse-config.js > Basic functionality > should convert numbers to strings 32ms
✓ tests/unit/docker/parse-config.test.ts > parse-config.js > Environment variable precedence > should not export variables that are already set in environment 33ms
✓ tests/unit/docker/parse-config.test.ts > parse-config.js > Environment variable precedence > should respect nested environment variables 32ms
✓ tests/unit/docker/parse-config.test.ts > parse-config.js > Shell escaping and security > should escape single quotes properly 33ms
✓ tests/unit/docker/parse-config.test.ts > parse-config.js > Shell escaping and security > should handle command injection attempts safely 38ms
✓ tests/unit/docker/parse-config.test.ts > parse-config.js > Shell escaping and security > should handle special shell characters safely 31ms
✓ tests/unit/docker/parse-config.test.ts > parse-config.js > Edge cases and error handling > should exit silently if config file does not exist 29ms
✓ tests/unit/docker/parse-config.test.ts > parse-config.js > Edge cases and error handling > should exit silently on invalid JSON 30ms
✓ tests/unit/docker/parse-config.test.ts > parse-config.js > Edge cases and error handling > should handle empty config file 30ms
✓ tests/unit/docker/parse-config.test.ts > parse-config.js > Edge cases and error handling > should ignore arrays in config 32ms
✓ tests/unit/docker/parse-config.test.ts > parse-config.js > Edge cases and error handling > should ignore null values 32ms
✓ tests/unit/docker/parse-config.test.ts > parse-config.js > Edge cases and error handling > should handle deeply nested structures 33ms
✓ tests/unit/docker/parse-config.test.ts > parse-config.js > Edge cases and error handling > should handle empty strings 32ms
✓ tests/unit/docker/parse-config.test.ts > parse-config.js > Default behavior > should use /app/config.json as default path when no argument provided 29ms
✓ tests/unit/services/config-validator-edge-cases.test.ts > ConfigValidator - Edge Cases > Null and Undefined Handling > should handle null config gracefully 0ms
✓ tests/unit/services/config-validator-edge-cases.test.ts > ConfigValidator - Edge Cases > Null and Undefined Handling > should handle undefined config gracefully 0ms
✓ tests/unit/services/config-validator-edge-cases.test.ts > ConfigValidator - Edge Cases > Null and Undefined Handling > should handle null properties array gracefully 0ms
✓ tests/unit/services/config-validator-edge-cases.test.ts > ConfigValidator - Edge Cases > Null and Undefined Handling > should handle undefined properties array gracefully 0ms
✓ tests/unit/services/config-validator-edge-cases.test.ts > ConfigValidator - Edge Cases > Null and Undefined Handling > should handle properties with null values in config 0ms
✓ tests/unit/services/config-validator-edge-cases.test.ts > ConfigValidator - Edge Cases > Boundary Value Testing > should handle empty arrays 0ms
✓ tests/unit/services/config-validator-edge-cases.test.ts > ConfigValidator - Edge Cases > Boundary Value Testing > should handle very large property arrays 1ms
✓ tests/unit/services/config-validator-edge-cases.test.ts > ConfigValidator - Edge Cases > Boundary Value Testing > should handle deeply nested displayOptions 0ms
✓ tests/unit/services/config-validator-edge-cases.test.ts > ConfigValidator - Edge Cases > Boundary Value Testing > should handle extremely long string values 0ms
✓ tests/unit/services/config-validator-edge-cases.test.ts > ConfigValidator - Edge Cases > Invalid Data Type Handling > should handle NaN values 0ms
✓ tests/unit/services/config-validator-edge-cases.test.ts > ConfigValidator - Edge Cases > Invalid Data Type Handling > should handle Infinity values 0ms
✓ tests/unit/services/config-validator-edge-cases.test.ts > ConfigValidator - Edge Cases > Invalid Data Type Handling > should handle objects when expecting primitives 0ms
✓ tests/unit/services/config-validator-edge-cases.test.ts > ConfigValidator - Edge Cases > Invalid Data Type Handling > should handle circular references in config 0ms
✓ tests/unit/services/config-validator-edge-cases.test.ts > ConfigValidator - Edge Cases > Performance Boundaries > should validate large config objects within reasonable time 41ms
✓ tests/unit/services/config-validator-edge-cases.test.ts > ConfigValidator - Edge Cases > Special Characters and Encoding > should handle special characters in property values 0ms
✓ tests/unit/services/config-validator-edge-cases.test.ts > ConfigValidator - Edge Cases > Special Characters and Encoding > should handle unicode characters 0ms
✓ tests/unit/services/config-validator-edge-cases.test.ts > ConfigValidator - Edge Cases > Complex Validation Scenarios > should handle conflicting displayOptions conditions 0ms
✓ tests/unit/services/config-validator-edge-cases.test.ts > ConfigValidator - Edge Cases > Complex Validation Scenarios > should handle multiple validation profiles correctly 1ms
✓ tests/unit/services/config-validator-edge-cases.test.ts > ConfigValidator - Edge Cases > Error Recovery and Resilience > should continue validation after encountering errors 1ms
✓ tests/unit/services/config-validator-edge-cases.test.ts > ConfigValidator - Edge Cases > Error Recovery and Resilience > should handle malformed property definitions gracefully 0ms
✓ tests/unit/services/config-validator-edge-cases.test.ts > ConfigValidator - Edge Cases > validateBatch method implementation > should validate multiple configs in batch if method exists 0ms
✓ tests/unit/docker/edge-cases.test.ts > Docker Config Edge Cases > Data type edge cases > should handle JavaScript number edge cases 56ms
✓ tests/unit/docker/edge-cases.test.ts > Docker Config Edge Cases > Data type edge cases > should handle unusual but valid JSON structures 31ms
✓ tests/unit/docker/edge-cases.test.ts > Docker Config Edge Cases > Data type edge cases > should handle circular reference prevention in nested configs 31ms
✓ tests/unit/docker/edge-cases.test.ts > Docker Config Edge Cases > File system edge cases > should handle permission errors gracefully 31ms
✓ tests/unit/docker/edge-cases.test.ts > Docker Config Edge Cases > File system edge cases > should handle symlinks correctly 38ms
✓ tests/unit/docker/edge-cases.test.ts > Docker Config Edge Cases > File system edge cases > should handle very large config files 63ms
✓ tests/unit/docker/edge-cases.test.ts > Docker Config Edge Cases > JSON parsing edge cases > should handle various invalid JSON formats 356ms
✓ tests/unit/docker/edge-cases.test.ts > Docker Config Edge Cases > JSON parsing edge cases > should handle Unicode edge cases in JSON 31ms
✓ tests/unit/docker/edge-cases.test.ts > Docker Config Edge Cases > Environment variable edge cases > should handle environment variable name transformations 31ms
✓ tests/unit/docker/edge-cases.test.ts > Docker Config Edge Cases > Environment variable edge cases > should handle conflicting keys after transformation 32ms
✓ tests/unit/docker/edge-cases.test.ts > Docker Config Edge Cases > Performance edge cases > should handle extremely deep nesting efficiently 89ms
✓ tests/unit/docker/edge-cases.test.ts > Docker Config Edge Cases > Performance edge cases > should handle wide objects efficiently 43ms
✓ tests/unit/docker/edge-cases.test.ts > Docker Config Edge Cases > Mixed content edge cases > should handle mixed valid and invalid content 30ms
✓ tests/unit/docker/edge-cases.test.ts > Docker Config Edge Cases > Real-world configuration scenarios > should handle typical n8n-mcp configuration 33ms
✓ tests/unit/services/example-generator.test.ts > ExampleGenerator > getExamples > should return curated examples for HTTP Request node 1ms
✓ tests/unit/services/example-generator.test.ts > ExampleGenerator > getExamples > should return curated examples for Webhook node 0ms
✓ tests/unit/services/example-generator.test.ts > ExampleGenerator > getExamples > should return curated examples for Code node 0ms
✓ tests/unit/services/example-generator.test.ts > ExampleGenerator > getExamples > should generate basic examples for unconfigured nodes 0ms
✓ tests/unit/services/example-generator.test.ts > ExampleGenerator > getExamples > should use common property if no required fields exist 0ms
✓ tests/unit/services/example-generator.test.ts > ExampleGenerator > getExamples > should return empty minimal object if no essentials provided 0ms
✓ tests/unit/services/example-generator.test.ts > ExampleGenerator > special example nodes > should provide webhook processing example 0ms
✓ tests/unit/services/example-generator.test.ts > ExampleGenerator > special example nodes > should provide data transformation examples 0ms
✓ tests/unit/services/example-generator.test.ts > ExampleGenerator > special example nodes > should provide aggregation example 0ms
✓ tests/unit/services/example-generator.test.ts > ExampleGenerator > special example nodes > should provide JMESPath filtering example 0ms
✓ tests/unit/services/example-generator.test.ts > ExampleGenerator > special example nodes > should provide Python example 0ms
✓ tests/unit/services/example-generator.test.ts > ExampleGenerator > special example nodes > should provide AI tool example 0ms
✓ tests/unit/services/example-generator.test.ts > ExampleGenerator > special example nodes > should provide crypto usage example 0ms
✓ tests/unit/services/example-generator.test.ts > ExampleGenerator > special example nodes > should provide static data example 0ms
✓ tests/unit/services/example-generator.test.ts > ExampleGenerator > database node examples > should provide PostgreSQL examples 0ms
✓ tests/unit/services/example-generator.test.ts > ExampleGenerator > database node examples > should provide MongoDB examples 0ms
✓ tests/unit/services/example-generator.test.ts > ExampleGenerator > database node examples > should provide MySQL examples 0ms
✓ tests/unit/services/example-generator.test.ts > ExampleGenerator > communication node examples > should provide Slack examples 0ms
✓ tests/unit/services/example-generator.test.ts > ExampleGenerator > communication node examples > should provide Email examples 0ms
✓ tests/unit/services/example-generator.test.ts > ExampleGenerator > error handling patterns > should provide modern error handling patterns 0ms
✓ tests/unit/services/example-generator.test.ts > ExampleGenerator > error handling patterns > should provide API retry patterns 0ms
✓ tests/unit/services/example-generator.test.ts > ExampleGenerator > error handling patterns > should provide database error patterns 0ms
✓ tests/unit/services/example-generator.test.ts > ExampleGenerator > error handling patterns > should provide webhook error patterns 0ms
✓ tests/unit/services/example-generator.test.ts > ExampleGenerator > getTaskExample > should return minimal example for basic task 0ms
✓ tests/unit/services/example-generator.test.ts > ExampleGenerator > getTaskExample > should return common example for typical task 0ms
✓ tests/unit/services/example-generator.test.ts > ExampleGenerator > getTaskExample > should return advanced example for complex task 0ms
✓ tests/unit/services/example-generator.test.ts > ExampleGenerator > getTaskExample > should default to common example for unknown task 0ms
✓ tests/unit/services/example-generator.test.ts > ExampleGenerator > getTaskExample > should return undefined for unknown node type 0ms
✓ tests/unit/services/example-generator.test.ts > ExampleGenerator > default value generation > should generate appropriate defaults for different property types 0ms
✓ tests/unit/services/example-generator.test.ts > ExampleGenerator > default value generation > should use property defaults when available 0ms
✓ tests/unit/services/example-generator.test.ts > ExampleGenerator > default value generation > should generate context-aware string defaults 0ms
✓ tests/unit/services/example-generator.test.ts > ExampleGenerator > default value generation > should use placeholder as fallback for string defaults 0ms
✓ tests/unit/services/example-generator.test.ts > ExampleGenerator > edge cases > should handle empty essentials object 0ms
✓ tests/unit/services/example-generator.test.ts > ExampleGenerator > edge cases > should handle properties with missing options 0ms
✓ tests/unit/services/example-generator.test.ts > ExampleGenerator > edge cases > should handle collection and fixedCollection types 0ms
✓ tests/unit/mcp/tools-documentation.test.ts > tools-documentation > getToolDocumentation > essentials mode > should return essential documentation for existing tool 1ms
✓ tests/unit/mcp/tools-documentation.test.ts > tools-documentation > getToolDocumentation > essentials mode > should return error message for unknown tool 0ms
✓ tests/unit/mcp/tools-documentation.test.ts > tools-documentation > getToolDocumentation > essentials mode > should use essentials as default depth 0ms
✓ tests/unit/mcp/tools-documentation.test.ts > tools-documentation > getToolDocumentation > full mode > should return complete documentation for existing tool 0ms
✓ tests/unit/mcp/tools-documentation.test.ts > tools-documentation > getToolDocumentation > special documentation topics > should return JavaScript Code node guide for javascript_code_node_guide 0ms
✓ tests/unit/mcp/tools-documentation.test.ts > tools-documentation > getToolDocumentation > special documentation topics > should return Python Code node guide for python_code_node_guide 0ms
✓ tests/unit/mcp/tools-documentation.test.ts > tools-documentation > getToolDocumentation > special documentation topics > should return full JavaScript guide when requested 0ms
✓ tests/unit/mcp/tools-documentation.test.ts > tools-documentation > getToolDocumentation > special documentation topics > should return full Python guide when requested 0ms
✓ tests/unit/mcp/tools-documentation.test.ts > tools-documentation > getToolsOverview > essentials mode > should return essential overview with categories 1ms
✓ tests/unit/mcp/tools-documentation.test.ts > tools-documentation > getToolsOverview > essentials mode > should use essentials as default 0ms
✓ tests/unit/mcp/tools-documentation.test.ts > tools-documentation > getToolsOverview > full mode > should return complete overview with all tools 0ms
✓ tests/unit/mcp/tools-documentation.test.ts > tools-documentation > searchToolDocumentation > should find tools matching keyword in name 0ms
✓ tests/unit/mcp/tools-documentation.test.ts > tools-documentation > searchToolDocumentation > should find tools matching keyword in description 0ms
✓ tests/unit/mcp/tools-documentation.test.ts > tools-documentation > searchToolDocumentation > should be case insensitive 0ms
✓ tests/unit/mcp/tools-documentation.test.ts > tools-documentation > searchToolDocumentation > should return empty array for no matches 0ms
✓ tests/unit/mcp/tools-documentation.test.ts > tools-documentation > searchToolDocumentation > should search in both essentials and full descriptions 0ms
✓ tests/unit/mcp/tools-documentation.test.ts > tools-documentation > getToolsByCategory > should return tools for discovery category 0ms
✓ tests/unit/mcp/tools-documentation.test.ts > tools-documentation > getToolsByCategory > should return tools for validation category 0ms
✓ tests/unit/mcp/tools-documentation.test.ts > tools-documentation > getToolsByCategory > should return tools for configuration category 0ms
✓ tests/unit/mcp/tools-documentation.test.ts > tools-documentation > getToolsByCategory > should return empty array for unknown category 0ms
✓ tests/unit/mcp/tools-documentation.test.ts > tools-documentation > getAllCategories > should return all unique categories 0ms
✓ tests/unit/mcp/tools-documentation.test.ts > tools-documentation > getAllCategories > should not have duplicates 0ms
✓ tests/unit/mcp/tools-documentation.test.ts > tools-documentation > getAllCategories > should return non-empty array 0ms
✓ tests/unit/mcp/tools-documentation.test.ts > tools-documentation > Error Handling > should handle missing tool gracefully 0ms
✓ tests/unit/mcp/tools-documentation.test.ts > tools-documentation > Error Handling > should handle empty search query 0ms
✓ tests/unit/mcp/tools-documentation.test.ts > tools-documentation > Documentation Quality > should format parameters correctly in full mode 0ms
✓ tests/unit/mcp/tools-documentation.test.ts > tools-documentation > Documentation Quality > should include code blocks for examples 0ms
✓ tests/unit/mcp/tools-documentation.test.ts > tools-documentation > Documentation Quality > should have consistent section headers 0ms
✓ tests/unit/parsers/node-parser.test.ts > NodeParser > parse method > should parse correctly when node is programmatic 2ms
✓ tests/unit/parsers/node-parser.test.ts > NodeParser > parse method > should parse correctly when node is declarative 1ms
✓ tests/unit/parsers/node-parser.test.ts > NodeParser > parse method > should preserve type when package prefix is already included 1ms
✓ tests/unit/parsers/node-parser.test.ts > NodeParser > parse method > should set isTrigger flag when node is a trigger 1ms
✓ tests/unit/parsers/node-parser.test.ts > NodeParser > parse method > should set isWebhook flag when node is a webhook 1ms
✓ tests/unit/parsers/node-parser.test.ts > NodeParser > parse method > should set isAITool flag when node has AI capability 0ms
✓ tests/unit/parsers/node-parser.test.ts > NodeParser > parse method > should parse correctly when node uses VersionedNodeType class 1ms
✓ tests/unit/parsers/node-parser.test.ts > NodeParser > parse method > should parse correctly when node has nodeVersions property 1ms
✓ tests/unit/parsers/node-parser.test.ts > NodeParser > parse method > should use max version when version is an array 1ms
✓ tests/unit/parsers/node-parser.test.ts > NodeParser > parse method > should throw error when node is missing name property 0ms
✓ tests/unit/parsers/node-parser.test.ts > NodeParser > parse method > should use static description when instantiation fails 1ms
✓ tests/unit/parsers/node-parser.test.ts > NodeParser > parse method > should extract category when using different property names 1ms
✓ tests/unit/parsers/node-parser.test.ts > NodeParser > parse method > should set isTrigger flag when node has polling property 1ms
✓ tests/unit/parsers/node-parser.test.ts > NodeParser > parse method > should set isTrigger flag when node has eventTrigger property 1ms
✓ tests/unit/parsers/node-parser.test.ts > NodeParser > parse method > should set isTrigger flag when node name contains trigger 1ms
✓ tests/unit/parsers/node-parser.test.ts > NodeParser > parse method > should set isWebhook flag when node name contains webhook 1ms
✓ tests/unit/parsers/node-parser.test.ts > NodeParser > parse method > should parse correctly when node is an instance object 1ms
✓ tests/unit/parsers/node-parser.test.ts > NodeParser > parse method > should handle different package name formats 1ms
✓ tests/unit/parsers/node-parser.test.ts > NodeParser > version extraction > should extract version from baseDescription.defaultVersion 0ms
✓ tests/unit/parsers/node-parser.test.ts > NodeParser > version extraction > should extract version from nodeVersions keys 0ms
✓ tests/unit/parsers/node-parser.test.ts > NodeParser > version extraction > should extract version from instance nodeVersions 0ms
✓ tests/unit/parsers/node-parser.test.ts > NodeParser > version extraction > should handle version as number in description 1ms
✓ tests/unit/parsers/node-parser.test.ts > NodeParser > version extraction > should handle version as string in description 1ms
✓ tests/unit/parsers/node-parser.test.ts > NodeParser > version extraction > should default to version 1 when no version found 1ms
✓ tests/unit/parsers/node-parser.test.ts > NodeParser > versioned node detection > should detect versioned nodes with nodeVersions 0ms
✓ tests/unit/parsers/node-parser.test.ts > NodeParser > versioned node detection > should detect versioned nodes with defaultVersion 0ms
✓ tests/unit/parsers/node-parser.test.ts > NodeParser > versioned node detection > should detect versioned nodes with version array in instance 0ms
✓ tests/unit/parsers/node-parser.test.ts > NodeParser > versioned node detection > should not detect non-versioned nodes as versioned 1ms
✓ tests/unit/parsers/node-parser.test.ts > NodeParser > edge cases > should handle null/undefined description gracefully 0ms
✓ tests/unit/parsers/node-parser.test.ts > NodeParser > edge cases > should handle empty routing object for declarative nodes 1ms
✓ tests/unit/parsers/node-parser.test.ts > NodeParser > edge cases > should handle complex nested versioned structure 0ms
✓ tests/unit/services/config-validator-basic.test.ts > ConfigValidator - Basic Validation > validate > should validate required fields for Slack message post 1ms
✓ tests/unit/services/config-validator-basic.test.ts > ConfigValidator - Basic Validation > validate > should validate successfully with all required fields 0ms
✓ tests/unit/services/config-validator-basic.test.ts > ConfigValidator - Basic Validation > validate > should handle unknown node types gracefully 0ms
✓ tests/unit/services/config-validator-basic.test.ts > ConfigValidator - Basic Validation > validate > should validate property types 0ms
✓ tests/unit/services/config-validator-basic.test.ts > ConfigValidator - Basic Validation > validate > should validate option values 0ms
✓ tests/unit/services/config-validator-basic.test.ts > ConfigValidator - Basic Validation > validate > should check property visibility based on displayOptions 0ms
✓ tests/unit/services/config-validator-basic.test.ts > ConfigValidator - Basic Validation > validate > should handle empty properties array 0ms
✓ tests/unit/services/config-validator-basic.test.ts > ConfigValidator - Basic Validation > validate > should handle missing displayOptions gracefully 0ms
✓ tests/unit/services/config-validator-basic.test.ts > ConfigValidator - Basic Validation > validate > should validate options with array format 0ms
✓ tests/unit/services/config-validator-basic.test.ts > ConfigValidator - Basic Validation > edge cases and additional coverage > should handle null and undefined config values 0ms
✓ tests/unit/services/config-validator-basic.test.ts > ConfigValidator - Basic Validation > edge cases and additional coverage > should validate nested displayOptions conditions 0ms
✓ tests/unit/services/config-validator-basic.test.ts > ConfigValidator - Basic Validation > edge cases and additional coverage > should handle hide conditions in displayOptions 0ms
✓ tests/unit/services/config-validator-basic.test.ts > ConfigValidator - Basic Validation > edge cases and additional coverage > should handle internal properties that start with underscore 0ms
✓ tests/unit/services/config-validator-basic.test.ts > ConfigValidator - Basic Validation > edge cases and additional coverage > should warn about inefficient configured but hidden properties 0ms
✓ tests/unit/services/config-validator-basic.test.ts > ConfigValidator - Basic Validation > edge cases and additional coverage > should suggest commonly used properties 0ms
✓ tests/unit/mcp/lru-cache-behavior.test.ts > LRU Cache Behavior Tests > Cache Key Generation and Collision > should generate different cache keys for different contexts 2ms
✓ tests/unit/mcp/lru-cache-behavior.test.ts > LRU Cache Behavior Tests > Cache Key Generation and Collision > should generate same cache key for identical contexts 2ms
✓ tests/unit/mcp/lru-cache-behavior.test.ts > LRU Cache Behavior Tests > Cache Key Generation and Collision > should handle potential cache key collisions gracefully 2ms
✓ tests/unit/mcp/lru-cache-behavior.test.ts > LRU Cache Behavior Tests > LRU Eviction Behavior > should evict oldest entries when cache is full 42ms
✓ tests/unit/mcp/lru-cache-behavior.test.ts > LRU Cache Behavior Tests > LRU Eviction Behavior > should maintain LRU order during access 7ms
✓ tests/unit/mcp/lru-cache-behavior.test.ts > LRU Cache Behavior Tests > LRU Eviction Behavior > should handle rapid successive access patterns 6ms
✓ tests/unit/mcp/lru-cache-behavior.test.ts > LRU Cache Behavior Tests > TTL (Time To Live) Behavior > should respect TTL settings 8ms
✓ tests/unit/mcp/lru-cache-behavior.test.ts > LRU Cache Behavior Tests > TTL (Time To Live) Behavior > should update age on cache access (updateAgeOnGet) 6ms
✓ tests/unit/mcp/lru-cache-behavior.test.ts > LRU Cache Behavior Tests > Dispose Callback Security and Logging > should sanitize cache keys in dispose callback logs 66ms
✓ tests/unit/mcp/lru-cache-behavior.test.ts > LRU Cache Behavior Tests > Dispose Callback Security and Logging > should handle dispose callback with undefined client 49ms
✓ tests/unit/mcp/lru-cache-behavior.test.ts > LRU Cache Behavior Tests > Cache Memory Management > should maintain consistent cache size limits 95ms
✓ tests/unit/mcp/lru-cache-behavior.test.ts > LRU Cache Behavior Tests > Cache Memory Management > should handle edge case of single cache entry 90ms
✓ tests/unit/mcp/lru-cache-behavior.test.ts > LRU Cache Behavior Tests > Cache Configuration Validation > should use reasonable cache limits 45ms
✓ tests/unit/mcp/lru-cache-behavior.test.ts > LRU Cache Behavior Tests > Cache Interaction with Validation > should not cache when context validation fails 57ms
✓ tests/unit/mcp/lru-cache-behavior.test.ts > LRU Cache Behavior Tests > Cache Interaction with Validation > should handle cache when config creation fails 47ms
✓ tests/unit/mcp/lru-cache-behavior.test.ts > LRU Cache Behavior Tests > Complex Cache Scenarios > should handle mixed valid and invalid contexts 55ms
✓ tests/unit/mcp/lru-cache-behavior.test.ts > LRU Cache Behavior Tests > Complex Cache Scenarios > should handle concurrent access to same cache key 144ms
✓ tests/unit/validation-fixes.test.ts > Validation System Fixes > Issue #73: validate_node_minimal crashes without input validation > should handle empty config in validation schemas 19ms
✓ tests/unit/validation-fixes.test.ts > Validation System Fixes > Issue #73: validate_node_minimal crashes without input validation > should handle null config in validation schemas 21ms
✓ tests/unit/validation-fixes.test.ts > Validation System Fixes > Issue #73: validate_node_minimal crashes without input validation > should accept valid config object 20ms
✓ tests/unit/validation-fixes.test.ts > Validation System Fixes > Issue #58: validate_node_operation crashes on nested input > should handle invalid nodeType gracefully 21ms
✓ tests/unit/validation-fixes.test.ts > Validation System Fixes > Issue #58: validate_node_operation crashes on nested input > should handle null nodeType gracefully 19ms
✓ tests/unit/validation-fixes.test.ts > Validation System Fixes > Issue #58: validate_node_operation crashes on nested input > should handle non-string nodeType gracefully 21ms
✓ tests/unit/validation-fixes.test.ts > Validation System Fixes > Issue #58: validate_node_operation crashes on nested input > should handle valid nodeType properly 18ms
✓ tests/unit/validation-fixes.test.ts > Validation System Fixes > Issue #70: Profile settings not respected > should pass profile parameter to all validation phases 21ms
✓ tests/unit/validation-fixes.test.ts > Validation System Fixes > Issue #70: Profile settings not respected > should filter out sticky notes from validation 28ms
✓ tests/unit/validation-fixes.test.ts > Validation System Fixes > Issue #70: Profile settings not respected > should allow legitimate loops in cycle detection 22ms
✓ tests/unit/validation-fixes.test.ts > Validation System Fixes > Issue #68: Better error recovery suggestions > should provide recovery suggestions for invalid node types 21ms
✓ tests/unit/validation-fixes.test.ts > Validation System Fixes > Issue #68: Better error recovery suggestions > should provide recovery suggestions for connection errors 18ms
✓ tests/unit/validation-fixes.test.ts > Validation System Fixes > Issue #68: Better error recovery suggestions > should provide workflow for multiple errors 20ms
✓ tests/unit/validation-fixes.test.ts > Validation System Fixes > Enhanced Input Validation > should validate tool parameters with schemas 18ms
✓ tests/unit/validation-fixes.test.ts > Validation System Fixes > Enhanced Input Validation > should reject invalid parameters 19ms
✓ tests/unit/validation-fixes.test.ts > Validation System Fixes > Enhanced Input Validation > should format validation errors properly 18ms
✓ tests/unit/mcp/handlers-workflow-diff.test.ts > handlers-workflow-diff > handleUpdatePartialWorkflow > should apply diff operations successfully 27ms
✓ tests/unit/mcp/handlers-workflow-diff.test.ts > handlers-workflow-diff > handleUpdatePartialWorkflow > should handle validation-only mode 29ms
✓ tests/unit/mcp/handlers-workflow-diff.test.ts > handlers-workflow-diff > handleUpdatePartialWorkflow > should handle multiple operations 185ms
✓ tests/unit/mcp/handlers-workflow-diff.test.ts > handlers-workflow-diff > handleUpdatePartialWorkflow > should handle diff application failures 50ms
✓ tests/unit/mcp/handlers-workflow-diff.test.ts > handlers-workflow-diff > handleUpdatePartialWorkflow > should handle API not configured error 28ms
✓ tests/unit/mcp/handlers-workflow-diff.test.ts > handlers-workflow-diff > handleUpdatePartialWorkflow > should handle workflow not found error 29ms
✓ tests/unit/mcp/handlers-workflow-diff.test.ts > handlers-workflow-diff > handleUpdatePartialWorkflow > should handle API errors during update 28ms
✓ tests/unit/mcp/handlers-workflow-diff.test.ts > handlers-workflow-diff > handleUpdatePartialWorkflow > should handle input validation errors 32ms
✓ tests/unit/mcp/handlers-workflow-diff.test.ts > handlers-workflow-diff > handleUpdatePartialWorkflow > should handle complex operation types 29ms
✓ tests/unit/mcp/handlers-workflow-diff.test.ts > handlers-workflow-diff > handleUpdatePartialWorkflow > should handle debug logging when enabled 29ms
✓ tests/unit/mcp/handlers-workflow-diff.test.ts > handlers-workflow-diff > handleUpdatePartialWorkflow > should handle generic errors 30ms
✓ tests/unit/mcp/handlers-workflow-diff.test.ts > handlers-workflow-diff > handleUpdatePartialWorkflow > should handle authentication errors 26ms
✓ tests/unit/mcp/handlers-workflow-diff.test.ts > handlers-workflow-diff > handleUpdatePartialWorkflow > should handle rate limit errors 23ms
✓ tests/unit/mcp/handlers-workflow-diff.test.ts > handlers-workflow-diff > handleUpdatePartialWorkflow > should handle server errors 26ms
✓ tests/unit/mcp/handlers-workflow-diff.test.ts > handlers-workflow-diff > handleUpdatePartialWorkflow > should validate operation structure 24ms
✓ tests/unit/mcp/handlers-workflow-diff.test.ts > handlers-workflow-diff > handleUpdatePartialWorkflow > should handle empty operations array 23ms
✓ tests/unit/mcp/handlers-workflow-diff.test.ts > handlers-workflow-diff > handleUpdatePartialWorkflow > should handle partial diff application 27ms
✓ tests/unit/mappers/docs-mapper.test.ts > DocsMapper > fetchDocumentation > successful documentation fetch > should fetch documentation for httpRequest node 25ms
✓ tests/unit/mappers/docs-mapper.test.ts > DocsMapper > fetchDocumentation > successful documentation fetch > should apply known fixes for node types 28ms
✓ tests/unit/mappers/docs-mapper.test.ts > DocsMapper > fetchDocumentation > successful documentation fetch > should handle node types with package prefix 27ms
✓ tests/unit/mappers/docs-mapper.test.ts > DocsMapper > fetchDocumentation > successful documentation fetch > should try multiple paths until finding documentation 25ms
✓ tests/unit/mappers/docs-mapper.test.ts > DocsMapper > fetchDocumentation > successful documentation fetch > should check directory paths with index.md 28ms
✓ tests/unit/mappers/docs-mapper.test.ts > DocsMapper > fetchDocumentation > documentation not found > should return null when documentation is not found 27ms
✓ tests/unit/mappers/docs-mapper.test.ts > DocsMapper > fetchDocumentation > documentation not found > should return null for empty node type 27ms
✓ tests/unit/mappers/docs-mapper.test.ts > DocsMapper > fetchDocumentation > documentation not found > should handle invalid node type format 28ms
✓ tests/unit/mappers/docs-mapper.test.ts > DocsMapper > fetchDocumentation > path construction > should construct correct paths for core nodes 25ms
✓ tests/unit/mappers/docs-mapper.test.ts > DocsMapper > fetchDocumentation > path construction > should construct correct paths for app nodes 23ms
✓ tests/unit/mappers/docs-mapper.test.ts > DocsMapper > fetchDocumentation > path construction > should construct correct paths for trigger nodes 26ms
✓ tests/unit/mappers/docs-mapper.test.ts > DocsMapper > fetchDocumentation > path construction > should construct correct paths for langchain nodes 24ms
✓ tests/unit/mappers/docs-mapper.test.ts > DocsMapper > fetchDocumentation > error handling > should handle file system errors gracefully 24ms
✓ tests/unit/mappers/docs-mapper.test.ts > DocsMapper > fetchDocumentation > error handling > should handle non-Error exceptions 28ms
✓ tests/unit/mappers/docs-mapper.test.ts > DocsMapper > fetchDocumentation > KNOWN_FIXES mapping > should apply fix for httpRequest 28ms
✓ tests/unit/mappers/docs-mapper.test.ts > DocsMapper > fetchDocumentation > KNOWN_FIXES mapping > should apply fix for respondToWebhook 23ms
✓ tests/unit/mappers/docs-mapper.test.ts > DocsMapper > fetchDocumentation > KNOWN_FIXES mapping > should preserve casing for unknown nodes 27ms
✓ tests/unit/mappers/docs-mapper.test.ts > DocsMapper > fetchDocumentation > logging > should log search progress 24ms
✓ tests/unit/mappers/docs-mapper.test.ts > DocsMapper > fetchDocumentation > logging > should log when documentation is not found 26ms
✓ tests/unit/mappers/docs-mapper.test.ts > DocsMapper > fetchDocumentation > edge cases > should handle very long node names 26ms
✓ tests/unit/mappers/docs-mapper.test.ts > DocsMapper > fetchDocumentation > edge cases > should handle node names with special characters 29ms
✓ tests/unit/mappers/docs-mapper.test.ts > DocsMapper > fetchDocumentation > edge cases > should handle multiple dots in node type 27ms
✓ tests/unit/mappers/docs-mapper.test.ts > DocsMapper > enhanceLoopNodeDocumentation - SplitInBatches > should enhance SplitInBatches documentation with output guidance 25ms
✓ tests/unit/mappers/docs-mapper.test.ts > DocsMapper > enhanceLoopNodeDocumentation - SplitInBatches > should enhance SplitInBatches documentation when no "When to use" section exists 25ms
✓ tests/unit/mappers/docs-mapper.test.ts > DocsMapper > enhanceLoopNodeDocumentation - SplitInBatches > should handle splitInBatches in various node type formats 23ms
✓ tests/unit/mappers/docs-mapper.test.ts > DocsMapper > enhanceLoopNodeDocumentation - SplitInBatches > should provide specific guidance for correct connection patterns 27ms
✓ tests/unit/mappers/docs-mapper.test.ts > DocsMapper > enhanceLoopNodeDocumentation - SplitInBatches > should explain the common AI assistant mistake 27ms
✓ tests/unit/mappers/docs-mapper.test.ts > DocsMapper > enhanceLoopNodeDocumentation - SplitInBatches > should not enhance non-splitInBatches nodes with loop guidance 23ms
✓ tests/unit/mappers/docs-mapper.test.ts > DocsMapper > enhanceLoopNodeDocumentation - IF node > should enhance IF node documentation with output guidance 26ms
✓ tests/unit/mappers/docs-mapper.test.ts > DocsMapper > enhanceLoopNodeDocumentation - IF node > should handle IF node when no "Node parameters" section exists 23ms
✓ tests/unit/mappers/docs-mapper.test.ts > DocsMapper > enhanceLoopNodeDocumentation - IF node > should handle various IF node type formats 24ms
✓ tests/unit/mappers/docs-mapper.test.ts > DocsMapper > enhanceLoopNodeDocumentation - edge cases > should handle content without clear insertion points 25ms
✓ tests/unit/mappers/docs-mapper.test.ts > DocsMapper > enhanceLoopNodeDocumentation - edge cases > should handle empty content 27ms
✓ tests/unit/mappers/docs-mapper.test.ts > DocsMapper > enhanceLoopNodeDocumentation - edge cases > should handle content with multiple "When to use" sections 23ms
✓ tests/unit/mappers/docs-mapper.test.ts > DocsMapper > enhanceLoopNodeDocumentation - edge cases > should not double-enhance already enhanced content 25ms
✓ tests/unit/mappers/docs-mapper.test.ts > DocsMapper > enhanceLoopNodeDocumentation - edge cases > should handle very large content efficiently 26ms
✓ tests/unit/mappers/docs-mapper.test.ts > DocsMapper > DocsMapper instance > should use consistent docsPath across instances 23ms
✓ tests/unit/mappers/docs-mapper.test.ts > DocsMapper > DocsMapper instance > should maintain KNOWN_FIXES as readonly 24ms
✓ tests/unit/database/template-repository-core.test.ts > TemplateRepository - Core Functionality > FTS5 initialization > should initialize FTS5 when supported 24ms
✓ tests/unit/database/template-repository-core.test.ts > TemplateRepository - Core Functionality > FTS5 initialization > should skip FTS5 when not supported 26ms
✓ tests/unit/database/template-repository-core.test.ts > TemplateRepository - Core Functionality > saveTemplate > should save a template with proper JSON serialization 25ms
✓ tests/unit/database/template-repository-core.test.ts > TemplateRepository - Core Functionality > getTemplate > should retrieve a specific template by ID 24ms
✓ tests/unit/database/template-repository-core.test.ts > TemplateRepository - Core Functionality > getTemplate > should return null for non-existent template 27ms
✓ tests/unit/database/template-repository-core.test.ts > TemplateRepository - Core Functionality > searchTemplates > should use FTS5 search when available 25ms
✓ tests/unit/database/template-repository-core.test.ts > TemplateRepository - Core Functionality > searchTemplates > should fall back to LIKE search when FTS5 is not supported 25ms
✓ tests/unit/database/template-repository-core.test.ts > TemplateRepository - Core Functionality > getTemplatesByNodes > should find templates using specific node types 25ms
✓ tests/unit/database/template-repository-core.test.ts > TemplateRepository - Core Functionality > getTemplatesForTask > should return templates for known tasks 27ms
✓ tests/unit/database/template-repository-core.test.ts > TemplateRepository - Core Functionality > getTemplatesForTask > should return empty array for unknown task 28ms
✓ tests/unit/database/template-repository-core.test.ts > TemplateRepository - Core Functionality > template statistics > should get template count 24ms
✓ tests/unit/database/template-repository-core.test.ts > TemplateRepository - Core Functionality > template statistics > should get template statistics 27ms
✓ tests/unit/database/template-repository-core.test.ts > TemplateRepository - Core Functionality > pagination count methods > should get node templates count 28ms
✓ tests/unit/database/template-repository-core.test.ts > TemplateRepository - Core Functionality > pagination count methods > should get search count 31ms
✓ tests/unit/database/template-repository-core.test.ts > TemplateRepository - Core Functionality > pagination count methods > should get task templates count 25ms
✓ tests/unit/database/template-repository-core.test.ts > TemplateRepository - Core Functionality > pagination count methods > should handle pagination in getAllTemplates 26ms
✓ tests/unit/database/template-repository-core.test.ts > TemplateRepository - Core Functionality > pagination count methods > should handle pagination in getTemplatesByNodes 27ms
✓ tests/unit/database/template-repository-core.test.ts > TemplateRepository - Core Functionality > pagination count methods > should handle pagination in searchTemplates 22ms
✓ tests/unit/database/template-repository-core.test.ts > TemplateRepository - Core Functionality > pagination count methods > should handle pagination in getTemplatesForTask 27ms
✓ tests/unit/database/template-repository-core.test.ts > TemplateRepository - Core Functionality > maintenance operations > should clear all templates 27ms
✓ tests/unit/database/template-repository-core.test.ts > TemplateRepository - Core Functionality > maintenance operations > should rebuild FTS5 index when supported 26ms
✓ tests/unit/services/config-validator-node-specific.test.ts > ConfigValidator - Node-Specific Validation > HTTP Request node validation > should perform HTTP Request specific validation 29ms
✓ tests/unit/services/config-validator-node-specific.test.ts > ConfigValidator - Node-Specific Validation > HTTP Request node validation > should validate HTTP Request with authentication in API URLs 29ms
✓ tests/unit/services/config-validator-node-specific.test.ts > ConfigValidator - Node-Specific Validation > HTTP Request node validation > should validate JSON in HTTP Request body 27ms
✓ tests/unit/services/config-validator-node-specific.test.ts > ConfigValidator - Node-Specific Validation > HTTP Request node validation > should handle webhook-specific validation 28ms
✓ tests/unit/services/config-validator-node-specific.test.ts > ConfigValidator - Node-Specific Validation > Code node validation > should validate Code node configurations 28ms
✓ tests/unit/services/config-validator-node-specific.test.ts > ConfigValidator - Node-Specific Validation > Code node validation > should validate JavaScript syntax in Code node 25ms
✓ tests/unit/services/config-validator-node-specific.test.ts > ConfigValidator - Node-Specific Validation > Code node validation > should validate n8n-specific patterns in Code node 26ms
✓ tests/unit/services/config-validator-node-specific.test.ts > ConfigValidator - Node-Specific Validation > Code node validation > should handle empty code in Code node 29ms
✓ tests/unit/services/config-validator-node-specific.test.ts > ConfigValidator - Node-Specific Validation > Code node validation > should validate complex return patterns in Code node 29ms
✓ tests/unit/services/config-validator-node-specific.test.ts > ConfigValidator - Node-Specific Validation > Code node validation > should validate Code node with $helpers usage 24ms
✓ tests/unit/services/config-validator-node-specific.test.ts > ConfigValidator - Node-Specific Validation > Code node validation > should detect incorrect $helpers.getWorkflowStaticData usage 27ms
✓ tests/unit/services/config-validator-node-specific.test.ts > ConfigValidator - Node-Specific Validation > Code node validation > should validate console.log usage 25ms
✓ tests/unit/services/config-validator-node-specific.test.ts > ConfigValidator - Node-Specific Validation > Code node validation > should validate $json usage warning 24ms
✓ tests/unit/services/config-validator-node-specific.test.ts > ConfigValidator - Node-Specific Validation > Code node validation > should not warn about properties for Code nodes 28ms
✓ tests/unit/services/config-validator-node-specific.test.ts > ConfigValidator - Node-Specific Validation > Code node validation > should validate crypto module usage 27ms
✓ tests/unit/services/config-validator-node-specific.test.ts > ConfigValidator - Node-Specific Validation > Code node validation > should suggest error handling for complex code 27ms
✓ tests/unit/services/config-validator-node-specific.test.ts > ConfigValidator - Node-Specific Validation > Code node validation > should suggest error handling for non-trivial code 24ms
✓ tests/unit/services/config-validator-node-specific.test.ts > ConfigValidator - Node-Specific Validation > Code node validation > should validate async operations without await 27ms
✓ tests/unit/services/config-validator-node-specific.test.ts > ConfigValidator - Node-Specific Validation > Python Code node validation > should validate Python code syntax 27ms
✓ tests/unit/services/config-validator-node-specific.test.ts > ConfigValidator - Node-Specific Validation > Python Code node validation > should detect mixed indentation in Python code 23ms
✓ tests/unit/services/config-validator-node-specific.test.ts > ConfigValidator - Node-Specific Validation > Python Code node validation > should warn about incorrect n8n return patterns 27ms
✓ tests/unit/services/config-validator-node-specific.test.ts > ConfigValidator - Node-Specific Validation > Python Code node validation > should warn about using external libraries in Python code 28ms
✓ tests/unit/services/config-validator-node-specific.test.ts > ConfigValidator - Node-Specific Validation > Python Code node validation > should validate Python code with print statements 29ms
✓ tests/unit/services/config-validator-node-specific.test.ts > ConfigValidator - Node-Specific Validation > Database node validation > should validate database query security 23ms
✓ tests/unit/services/config-validator-node-specific.test.ts > ConfigValidator - Node-Specific Validation > Database node validation > should check for SQL injection vulnerabilities 26ms
✓ tests/unit/services/config-validator-node-specific.test.ts > ConfigValidator - Node-Specific Validation > Database node validation > should validate SQL SELECT * performance warning 25ms
✓ tests/unit/parsers/node-parser-outputs.test.ts > NodeParser - Output Extraction > extractOutputs method > should extract outputs array from base description 28ms
✓ tests/unit/parsers/node-parser-outputs.test.ts > NodeParser - Output Extraction > extractOutputs method > should extract outputNames array from base description 27ms
✓ tests/unit/parsers/node-parser-outputs.test.ts > NodeParser - Output Extraction > extractOutputs method > should extract both outputs and outputNames when both are present 25ms
✓ tests/unit/parsers/node-parser-outputs.test.ts > NodeParser - Output Extraction > extractOutputs method > should convert single output to array format 26ms
✓ tests/unit/parsers/node-parser-outputs.test.ts > NodeParser - Output Extraction > extractOutputs method > should convert single outputName to array format 26ms
✓ tests/unit/parsers/node-parser-outputs.test.ts > NodeParser - Output Extraction > extractOutputs method > should extract outputs from versioned node when not in base description 26ms
✓ tests/unit/parsers/node-parser-outputs.test.ts > NodeParser - Output Extraction > extractOutputs method > should handle node instantiation failure gracefully 28ms
✓ tests/unit/parsers/node-parser-outputs.test.ts > NodeParser - Output Extraction > extractOutputs method > should return empty result when no outputs found anywhere 26ms
✓ tests/unit/parsers/node-parser-outputs.test.ts > NodeParser - Output Extraction > extractOutputs method > should handle complex versioned node structure 27ms
✓ tests/unit/parsers/node-parser-outputs.test.ts > NodeParser - Output Extraction > extractOutputs method > should prefer base description outputs over versioned when both exist 25ms
✓ tests/unit/parsers/node-parser-outputs.test.ts > NodeParser - Output Extraction > extractOutputs method > should handle IF node with typical output structure 27ms
✓ tests/unit/parsers/node-parser-outputs.test.ts > NodeParser - Output Extraction > extractOutputs method > should handle SplitInBatches node with counterintuitive output structure 28ms
✓ tests/unit/parsers/node-parser-outputs.test.ts > NodeParser - Output Extraction > extractOutputs method > should handle Switch node with multiple outputs 28ms
✓ tests/unit/parsers/node-parser-outputs.test.ts > NodeParser - Output Extraction > extractOutputs method > should handle empty outputs array 26ms
✓ tests/unit/parsers/node-parser-outputs.test.ts > NodeParser - Output Extraction > extractOutputs method > should handle mismatched outputs and outputNames arrays 30ms
✓ tests/unit/parsers/node-parser-outputs.test.ts > NodeParser - Output Extraction > real-world node structures > should handle actual n8n SplitInBatches node structure 33ms
✓ tests/unit/parsers/node-parser-outputs.test.ts > NodeParser - Output Extraction > real-world node structures > should handle actual n8n IF node structure 32ms
✓ tests/unit/parsers/node-parser-outputs.test.ts > NodeParser - Output Extraction > real-world node structures > should handle single-output nodes like HTTP Request 33ms
✓ tests/unit/parsers/simple-parser.test.ts > SimpleParser > parse method > should parse a basic programmatic node 21ms
✓ tests/unit/parsers/simple-parser.test.ts > SimpleParser > parse method > should parse a declarative node 23ms
✓ tests/unit/parsers/simple-parser.test.ts > SimpleParser > parse method > should detect trigger nodes 21ms
✓ tests/unit/parsers/simple-parser.test.ts > SimpleParser > parse method > should detect webhook nodes 22ms
✓ tests/unit/parsers/simple-parser.test.ts > SimpleParser > parse method > should detect AI tool nodes 20ms
✓ tests/unit/parsers/simple-parser.test.ts > SimpleParser > parse method > should parse VersionedNodeType class 22ms
✓ tests/unit/parsers/simple-parser.test.ts > SimpleParser > parse method > should merge baseDescription with version-specific description 19ms
✓ tests/unit/parsers/simple-parser.test.ts > SimpleParser > parse method > should throw error for nodes without name 23ms
✓ tests/unit/parsers/simple-parser.test.ts > SimpleParser > parse method > should handle nodes that fail to instantiate 28ms
✓ tests/unit/parsers/simple-parser.test.ts > SimpleParser > parse method > should handle static description property 24ms
✓ tests/unit/parsers/simple-parser.test.ts > SimpleParser > parse method > should handle instance-based nodes 20ms
✓ tests/unit/parsers/simple-parser.test.ts > SimpleParser > parse method > should use displayName fallback to name if not provided 20ms
✓ tests/unit/parsers/simple-parser.test.ts > SimpleParser > parse method > should handle category extraction from different fields 21ms
✓ tests/unit/parsers/simple-parser.test.ts > SimpleParser > trigger detection > should detect triggers by group 20ms
✓ tests/unit/parsers/simple-parser.test.ts > SimpleParser > trigger detection > should detect polling triggers 19ms
✓ tests/unit/parsers/simple-parser.test.ts > SimpleParser > trigger detection > should detect trigger property 22ms
✓ tests/unit/parsers/simple-parser.test.ts > SimpleParser > trigger detection > should detect event triggers 21ms
✓ tests/unit/parsers/simple-parser.test.ts > SimpleParser > trigger detection > should detect triggers by name 21ms
✓ tests/unit/parsers/simple-parser.test.ts > SimpleParser > operations extraction > should extract declarative operations from routing.request 19ms
✓ tests/unit/parsers/simple-parser.test.ts > SimpleParser > operations extraction > should extract declarative operations from routing.operations 23ms
✓ tests/unit/parsers/simple-parser.test.ts > SimpleParser > operations extraction > should extract programmatic operations from resource property 20ms
✓ tests/unit/parsers/simple-parser.test.ts > SimpleParser > operations extraction > should extract programmatic operations with resource context 23ms
✓ tests/unit/parsers/simple-parser.test.ts > SimpleParser > operations extraction > should handle operations with multiple resource conditions 22ms
✓ tests/unit/parsers/simple-parser.test.ts > SimpleParser > operations extraction > should handle single resource condition as array 22ms
✓ tests/unit/parsers/simple-parser.test.ts > SimpleParser > version extraction > should extract version from baseDescription.defaultVersion 19ms
✓ tests/unit/parsers/simple-parser.test.ts > SimpleParser > version extraction > should extract version from description.version 19ms
✓ tests/unit/parsers/simple-parser.test.ts > SimpleParser > version extraction > should default to version 1 18ms
✓ tests/unit/parsers/simple-parser.test.ts > SimpleParser > versioned node detection > should detect nodes with baseDescription and nodeVersions 20ms
✓ tests/unit/parsers/simple-parser.test.ts > SimpleParser > versioned node detection > should detect nodes with version array 19ms
✓ tests/unit/parsers/simple-parser.test.ts > SimpleParser > versioned node detection > should detect nodes with defaultVersion 21ms
✓ tests/unit/parsers/simple-parser.test.ts > SimpleParser > versioned node detection > should handle instance-level version detection 20ms
✓ tests/unit/parsers/simple-parser.test.ts > SimpleParser > edge cases > should handle empty routing object 20ms
✓ tests/unit/parsers/simple-parser.test.ts > SimpleParser > edge cases > should handle missing properties array 18ms
✓ tests/unit/parsers/simple-parser.test.ts > SimpleParser > edge cases > should handle missing credentials 17ms
✓ tests/unit/parsers/simple-parser.test.ts > SimpleParser > edge cases > should handle nodes with baseDescription but no name in main description 18ms
✓ tests/unit/parsers/simple-parser.test.ts > SimpleParser > edge cases > should handle complex nested routing structures 17ms
✓ tests/unit/parsers/simple-parser.test.ts > SimpleParser > edge cases > should handle operations without displayName 20ms
✓ tests/unit/scripts/fetch-templates-extraction.test.ts > Template Configuration Extraction > extractNodeConfigs > should extract configs from valid workflow with multiple nodes 20ms
✓ tests/unit/scripts/fetch-templates-extraction.test.ts > Template Configuration Extraction > extractNodeConfigs > should return empty array for workflow with no nodes 19ms
✓ tests/unit/scripts/fetch-templates-extraction.test.ts > Template Configuration Extraction > extractNodeConfigs > should skip sticky note nodes 19ms
✓ tests/unit/scripts/fetch-templates-extraction.test.ts > Template Configuration Extraction > extractNodeConfigs > should skip nodes without parameters 19ms
✓ tests/unit/scripts/fetch-templates-extraction.test.ts > Template Configuration Extraction > extractNodeConfigs > should handle nodes with credentials 20ms
✓ tests/unit/scripts/fetch-templates-extraction.test.ts > Template Configuration Extraction > extractNodeConfigs > should use default complexity when metadata is missing 21ms
✓ tests/unit/scripts/fetch-templates-extraction.test.ts > Template Configuration Extraction > extractNodeConfigs > should handle malformed compressed data gracefully 21ms
✓ tests/unit/scripts/fetch-templates-extraction.test.ts > Template Configuration Extraction > extractNodeConfigs > should handle invalid JSON after decompression 20ms
✓ tests/unit/scripts/fetch-templates-extraction.test.ts > Template Configuration Extraction > extractNodeConfigs > should handle workflows with missing nodes array 19ms
✓ tests/unit/scripts/fetch-templates-extraction.test.ts > Template Configuration Extraction > detectExpressions > should detect n8n expression syntax with ={{...}} 22ms
✓ tests/unit/scripts/fetch-templates-extraction.test.ts > Template Configuration Extraction > detectExpressions > should detect $json references 34ms
✓ tests/unit/scripts/fetch-templates-extraction.test.ts > Template Configuration Extraction > detectExpressions > should detect $node references 27ms
✓ tests/unit/scripts/fetch-templates-extraction.test.ts > Template Configuration Extraction > detectExpressions > should return false for parameters without expressions 24ms
✓ tests/unit/scripts/fetch-templates-extraction.test.ts > Template Configuration Extraction > detectExpressions > should handle nested objects with expressions 24ms
✓ tests/unit/scripts/fetch-templates-extraction.test.ts > Template Configuration Extraction > detectExpressions > should return false for null parameters 21ms
✓ tests/unit/scripts/fetch-templates-extraction.test.ts > Template Configuration Extraction > detectExpressions > should return false for undefined parameters 21ms
✓ tests/unit/scripts/fetch-templates-extraction.test.ts > Template Configuration Extraction > detectExpressions > should return false for empty object 19ms
✓ tests/unit/scripts/fetch-templates-extraction.test.ts > Template Configuration Extraction > detectExpressions > should handle array parameters with expressions 19ms
✓ tests/unit/scripts/fetch-templates-extraction.test.ts > Template Configuration Extraction > detectExpressions > should detect multiple expression types in same params 18ms
✓ tests/unit/scripts/fetch-templates-extraction.test.ts > Template Configuration Extraction > Edge Cases > should handle very large workflows without crashing 21ms
✓ tests/unit/scripts/fetch-templates-extraction.test.ts > Template Configuration Extraction > Edge Cases > should handle special characters in node names and parameters 19ms
✓ tests/unit/scripts/fetch-templates-extraction.test.ts > Template Configuration Extraction > Edge Cases > should preserve parameter structure exactly as in workflow 21ms
✓ tests/unit/services/config-validator-security.test.ts > ConfigValidator - Security Validation > Credential security > should perform security checks for hardcoded credentials 33ms
✓ tests/unit/services/config-validator-security.test.ts > ConfigValidator - Security Validation > Credential security > should validate HTTP Request with authentication in API URLs 31ms
✓ tests/unit/services/config-validator-security.test.ts > ConfigValidator - Security Validation > Code execution security > should warn about security issues with eval/exec 32ms
✓ tests/unit/services/config-validator-security.test.ts > ConfigValidator - Security Validation > Code execution security > should detect infinite loops 30ms
✓ tests/unit/services/config-validator-security.test.ts > ConfigValidator - Security Validation > Database security > should validate database query security 26ms
✓ tests/unit/services/config-validator-security.test.ts > ConfigValidator - Security Validation > Database security > should check for SQL injection vulnerabilities 25ms
↓ tests/unit/services/config-validator-security.test.ts > ConfigValidator - Security Validation > Database security > should warn about DROP TABLE operations
↓ tests/unit/services/config-validator-security.test.ts > ConfigValidator - Security Validation > Database security > should warn about TRUNCATE operations
✓ tests/unit/services/config-validator-security.test.ts > ConfigValidator - Security Validation > Database security > should check for unescaped user input in queries 28ms
↓ tests/unit/services/config-validator-security.test.ts > ConfigValidator - Security Validation > Network security > should warn about HTTP (non-HTTPS) API calls
↓ tests/unit/services/config-validator-security.test.ts > ConfigValidator - Security Validation > Network security > should validate localhost/internal URLs
↓ tests/unit/services/config-validator-security.test.ts > ConfigValidator - Security Validation > Network security > should check for sensitive data in URLs
↓ tests/unit/services/config-validator-security.test.ts > ConfigValidator - Security Validation > File system security > should warn about dangerous file operations
↓ tests/unit/services/config-validator-security.test.ts > ConfigValidator - Security Validation > File system security > should check for path traversal vulnerabilities
✓ tests/unit/services/config-validator-security.test.ts > ConfigValidator - Security Validation > Crypto and sensitive operations > should validate crypto module usage 29ms
↓ tests/unit/services/config-validator-security.test.ts > ConfigValidator - Security Validation > Crypto and sensitive operations > should warn about weak crypto algorithms
↓ tests/unit/services/config-validator-security.test.ts > ConfigValidator - Security Validation > Crypto and sensitive operations > should check for environment variable access
✓ tests/unit/services/config-validator-security.test.ts > ConfigValidator - Security Validation > Python security > should warn about exec/eval in Python 24ms
↓ tests/unit/services/config-validator-security.test.ts > ConfigValidator - Security Validation > Python security > should check for subprocess/os.system usage
✓ tests/unit/examples/using-n8n-nodes-base-mock.test.ts > WorkflowService with n8n-nodes-base mock > getNodeDescription > should get webhook node description 19ms
✓ tests/unit/examples/using-n8n-nodes-base-mock.test.ts > WorkflowService with n8n-nodes-base mock > getNodeDescription > should get httpRequest node description 21ms
✓ tests/unit/examples/using-n8n-nodes-base-mock.test.ts > WorkflowService with n8n-nodes-base mock > executeNode > should execute httpRequest node with custom response 19ms
✓ tests/unit/examples/using-n8n-nodes-base-mock.test.ts > WorkflowService with n8n-nodes-base mock > executeNode > should execute slack node and track calls 22ms
✓ tests/unit/examples/using-n8n-nodes-base-mock.test.ts > WorkflowService with n8n-nodes-base mock > executeNode > should throw error for non-executable node 20ms
✓ tests/unit/examples/using-n8n-nodes-base-mock.test.ts > WorkflowService with n8n-nodes-base mock > validateSlackMessage > should validate slack message parameters 22ms
✓ tests/unit/examples/using-n8n-nodes-base-mock.test.ts > WorkflowService with n8n-nodes-base mock > validateSlackMessage > should throw error for missing parameters 20ms
✓ tests/unit/examples/using-n8n-nodes-base-mock.test.ts > WorkflowService with n8n-nodes-base mock > validateSlackMessage > should handle missing slack node 26ms
✓ tests/unit/examples/using-n8n-nodes-base-mock.test.ts > WorkflowService with n8n-nodes-base mock > complex workflow scenarios > should handle if node branching 21ms
✓ tests/unit/examples/using-n8n-nodes-base-mock.test.ts > WorkflowService with n8n-nodes-base mock > complex workflow scenarios > should handle merge node combining inputs 22ms
✓ tests/unit/parsers/property-extractor.test.ts > PropertyExtractor > extractProperties > should extract properties from programmatic node 22ms
✓ tests/unit/parsers/property-extractor.test.ts > PropertyExtractor > extractProperties > should extract properties from versioned node latest version 22ms
✓ tests/unit/parsers/property-extractor.test.ts > PropertyExtractor > extractProperties > should extract properties from instance with nodeVersions 20ms
✓ tests/unit/parsers/property-extractor.test.ts > PropertyExtractor > extractProperties > should normalize properties to consistent structure 22ms
✓ tests/unit/parsers/property-extractor.test.ts > PropertyExtractor > extractProperties > should handle nodes without properties 19ms
✓ tests/unit/parsers/property-extractor.test.ts > PropertyExtractor > extractProperties > should handle failed instantiation 23ms
✓ tests/unit/parsers/property-extractor.test.ts > PropertyExtractor > extractProperties > should extract from baseDescription when main description is missing 20ms
✓ tests/unit/parsers/property-extractor.test.ts > PropertyExtractor > extractProperties > should handle complex nested properties 25ms
✓ tests/unit/parsers/property-extractor.test.ts > PropertyExtractor > extractProperties > should handle non-function node classes 27ms
✓ tests/unit/parsers/property-extractor.test.ts > PropertyExtractor > extractOperations > should extract operations from declarative node routing 26ms
✓ tests/unit/parsers/property-extractor.test.ts > PropertyExtractor > extractOperations > should extract operations when node has programmatic properties 20ms
✓ tests/unit/parsers/property-extractor.test.ts > PropertyExtractor > extractOperations > should extract operations when routing.operations structure exists 21ms
✓ tests/unit/parsers/property-extractor.test.ts > PropertyExtractor > extractOperations > should handle operations when programmatic nodes have resource-based structure 20ms
✓ tests/unit/parsers/property-extractor.test.ts > PropertyExtractor > extractOperations > should return empty array when node has no operations 21ms
✓ tests/unit/parsers/property-extractor.test.ts > PropertyExtractor > extractOperations > should extract operations when node has version structure 20ms
✓ tests/unit/parsers/property-extractor.test.ts > PropertyExtractor > extractOperations > should handle extraction when property is named action instead of operation 22ms
✓ tests/unit/parsers/property-extractor.test.ts > PropertyExtractor > detectAIToolCapability > should detect AI capability when usableAsTool property is true 20ms
✓ tests/unit/parsers/property-extractor.test.ts > PropertyExtractor > detectAIToolCapability > should detect AI capability when actions contain usableAsTool 20ms
✓ tests/unit/parsers/property-extractor.test.ts > PropertyExtractor > detectAIToolCapability > should detect AI capability when versioned node has usableAsTool 22ms
✓ tests/unit/parsers/property-extractor.test.ts > PropertyExtractor > detectAIToolCapability > should detect AI capability when node name contains AI-related terms 24ms
✓ tests/unit/parsers/property-extractor.test.ts > PropertyExtractor > detectAIToolCapability > should return false when node is not AI-related 21ms
✓ tests/unit/parsers/property-extractor.test.ts > PropertyExtractor > detectAIToolCapability > should return false when node has no description 19ms
✓ tests/unit/parsers/property-extractor.test.ts > PropertyExtractor > extractCredentials > should extract credentials when node description contains them 21ms
✓ tests/unit/parsers/property-extractor.test.ts > PropertyExtractor > extractCredentials > should extract credentials when node has version structure 21ms
✓ tests/unit/parsers/property-extractor.test.ts > PropertyExtractor > extractCredentials > should return empty array when node has no credentials 22ms
✓ tests/unit/parsers/property-extractor.test.ts > PropertyExtractor > extractCredentials > should extract credentials when only baseDescription has them 20ms
✓ tests/unit/parsers/property-extractor.test.ts > PropertyExtractor > extractCredentials > should extract credentials when they are defined at instance level 27ms
✓ tests/unit/parsers/property-extractor.test.ts > PropertyExtractor > extractCredentials > should return empty array when instantiation fails 19ms
✓ tests/unit/parsers/property-extractor.test.ts > PropertyExtractor > edge cases > should handle extraction when properties are deeply nested 21ms
✓ tests/unit/parsers/property-extractor.test.ts > PropertyExtractor > edge cases > should not throw when node structure has circular references 19ms
✓ tests/unit/parsers/property-extractor.test.ts > PropertyExtractor > edge cases > should extract from all sources when multiple operation types exist 21ms
✓ tests/unit/mcp/handlers-n8n-manager.test.ts > handlers-n8n-manager > getN8nApiClient > should create new client when config is available 37ms
✓ tests/unit/mcp/handlers-n8n-manager.test.ts > handlers-n8n-manager > getN8nApiClient > should return null when config is not available 30ms
✓ tests/unit/mcp/handlers-n8n-manager.test.ts > handlers-n8n-manager > getN8nApiClient > should reuse existing client when config has not changed 28ms
✓ tests/unit/mcp/handlers-n8n-manager.test.ts > handlers-n8n-manager > getN8nApiClient > should create new client when config URL changes 28ms
✓ tests/unit/mcp/handlers-n8n-manager.test.ts > handlers-n8n-manager > handleCreateWorkflow > should create workflow successfully 36ms
✓ tests/unit/mcp/handlers-n8n-manager.test.ts > handlers-n8n-manager > handleCreateWorkflow > should handle validation errors 30ms
✓ tests/unit/mcp/handlers-n8n-manager.test.ts > handlers-n8n-manager > handleCreateWorkflow > should handle workflow structure validation failures 30ms
✓ tests/unit/mcp/handlers-n8n-manager.test.ts > handlers-n8n-manager > handleCreateWorkflow > should handle API errors 31ms
✓ tests/unit/mcp/handlers-n8n-manager.test.ts > handlers-n8n-manager > handleCreateWorkflow > should handle API not configured error 33ms
✓ tests/unit/mcp/handlers-n8n-manager.test.ts > handlers-n8n-manager > handleCreateWorkflow > SHORT form detection > should detect and reject nodes-base.* SHORT form 32ms
✓ tests/unit/mcp/handlers-n8n-manager.test.ts > handlers-n8n-manager > handleCreateWorkflow > SHORT form detection > should detect and reject nodes-langchain.* SHORT form 33ms
✓ tests/unit/mcp/handlers-n8n-manager.test.ts > handlers-n8n-manager > handleCreateWorkflow > SHORT form detection > should detect multiple SHORT form nodes 34ms
✓ tests/unit/mcp/handlers-n8n-manager.test.ts > handlers-n8n-manager > handleCreateWorkflow > SHORT form detection > should allow FULL form n8n-nodes-base.* without error 30ms
✓ tests/unit/mcp/handlers-n8n-manager.test.ts > handlers-n8n-manager > handleCreateWorkflow > SHORT form detection > should allow FULL form @n8n/n8n-nodes-langchain.* without error 32ms
✓ tests/unit/mcp/handlers-n8n-manager.test.ts > handlers-n8n-manager > handleCreateWorkflow > SHORT form detection > should detect SHORT form in mixed FULL/SHORT workflow 39ms
✓ tests/unit/mcp/handlers-n8n-manager.test.ts > handlers-n8n-manager > handleCreateWorkflow > SHORT form detection > should handle nodes with null type gracefully 41ms
✓ tests/unit/mcp/handlers-n8n-manager.test.ts > handlers-n8n-manager > handleCreateWorkflow > SHORT form detection > should handle nodes with undefined type gracefully 47ms
✓ tests/unit/mcp/handlers-n8n-manager.test.ts > handlers-n8n-manager > handleCreateWorkflow > SHORT form detection > should handle empty nodes array gracefully 40ms
✓ tests/unit/mcp/handlers-n8n-manager.test.ts > handlers-n8n-manager > handleCreateWorkflow > SHORT form detection > should handle nodes array with undefined nodes gracefully 40ms
✓ tests/unit/mcp/handlers-n8n-manager.test.ts > handlers-n8n-manager > handleCreateWorkflow > SHORT form detection > should provide correct index in error message for multiple nodes 42ms
✓ tests/unit/mcp/handlers-n8n-manager.test.ts > handlers-n8n-manager > handleGetWorkflow > should get workflow successfully 39ms
✓ tests/unit/mcp/handlers-n8n-manager.test.ts > handlers-n8n-manager > handleGetWorkflow > should handle not found error 44ms
✓ tests/unit/mcp/handlers-n8n-manager.test.ts > handlers-n8n-manager > handleGetWorkflow > should handle invalid input 38ms
✓ tests/unit/mcp/handlers-n8n-manager.test.ts > handlers-n8n-manager > handleGetWorkflowDetails > should get workflow details with execution stats 40ms
✓ tests/unit/mcp/handlers-n8n-manager.test.ts > handlers-n8n-manager > handleGetWorkflowDetails > should handle workflow with webhook trigger 40ms
✓ tests/unit/mcp/handlers-n8n-manager.test.ts > handlers-n8n-manager > handleDeleteWorkflow > should delete workflow successfully 40ms
✓ tests/unit/mcp/handlers-n8n-manager.test.ts > handlers-n8n-manager > handleDeleteWorkflow > should handle invalid input 41ms
✓ tests/unit/mcp/handlers-n8n-manager.test.ts > handlers-n8n-manager > handleDeleteWorkflow > should handle N8nApiError 38ms
✓ tests/unit/mcp/handlers-n8n-manager.test.ts > handlers-n8n-manager > handleDeleteWorkflow > should handle generic errors 40ms
✓ tests/unit/mcp/handlers-n8n-manager.test.ts > handlers-n8n-manager > handleDeleteWorkflow > should handle API not configured error 36ms
✓ tests/unit/mcp/handlers-n8n-manager.test.ts > handlers-n8n-manager > handleListWorkflows > should list workflows with minimal data 37ms
✓ tests/unit/mcp/handlers-n8n-manager.test.ts > handlers-n8n-manager > handleListWorkflows > should handle invalid input with ZodError 36ms
✓ tests/unit/mcp/handlers-n8n-manager.test.ts > handlers-n8n-manager > handleListWorkflows > should handle N8nApiError 36ms
✓ tests/unit/mcp/handlers-n8n-manager.test.ts > handlers-n8n-manager > handleListWorkflows > should handle generic errors 37ms
✓ tests/unit/mcp/handlers-n8n-manager.test.ts > handlers-n8n-manager > handleListWorkflows > should handle workflows without isArchived field gracefully 34ms
✓ tests/unit/mcp/handlers-n8n-manager.test.ts > handlers-n8n-manager > handleListWorkflows > should convert tags array to comma-separated string 39ms
✓ tests/unit/mcp/handlers-n8n-manager.test.ts > handlers-n8n-manager > handleListWorkflows > should handle empty tags array 36ms
✓ tests/unit/mcp/handlers-n8n-manager.test.ts > handlers-n8n-manager > handleValidateWorkflow > should validate workflow from n8n instance 38ms
✓ tests/unit/mcp/handlers-n8n-manager.test.ts > handlers-n8n-manager > handleHealthCheck > should check health successfully 37ms
✓ tests/unit/mcp/handlers-n8n-manager.test.ts > handlers-n8n-manager > handleHealthCheck > should handle API errors 36ms
✓ tests/unit/mcp/handlers-n8n-manager.test.ts > handlers-n8n-manager > handleDiagnostic > should provide diagnostic information 46ms
✓ tests/unit/mcp/handlers-n8n-manager.test.ts > handlers-n8n-manager > Error handling > should handle authentication errors 35ms
✓ tests/unit/mcp/handlers-n8n-manager.test.ts > handlers-n8n-manager > Error handling > should handle rate limit errors 38ms
✓ tests/unit/mcp/handlers-n8n-manager.test.ts > handlers-n8n-manager > Error handling > should handle generic errors 36ms
✓ tests/unit/mcp/handlers-n8n-manager.test.ts > handlers-n8n-manager > handleTriggerWebhookWorkflow > should trigger webhook successfully 35ms
✓ tests/unit/mcp/handlers-n8n-manager.test.ts > handlers-n8n-manager > handleTriggerWebhookWorkflow > should extract execution ID from webhook error response 38ms
✓ tests/unit/mcp/handlers-n8n-manager.test.ts > handlers-n8n-manager > handleTriggerWebhookWorkflow > should extract execution ID without workflow ID 39ms
✓ tests/unit/mcp/handlers-n8n-manager.test.ts > handlers-n8n-manager > handleTriggerWebhookWorkflow > should handle execution ID as "id" field 44ms
✓ tests/unit/mcp/handlers-n8n-manager.test.ts > handlers-n8n-manager > handleTriggerWebhookWorkflow > should provide generic guidance when no execution ID is available 39ms
✓ tests/unit/mcp/handlers-n8n-manager.test.ts > handlers-n8n-manager > handleTriggerWebhookWorkflow > should use standard error message for authentication errors 39ms
✓ tests/unit/mcp/handlers-n8n-manager.test.ts > handlers-n8n-manager > handleTriggerWebhookWorkflow > should use standard error message for validation errors 39ms
✓ tests/unit/mcp/handlers-n8n-manager.test.ts > handlers-n8n-manager > handleTriggerWebhookWorkflow > should handle invalid input with Zod validation error 41ms
✓ tests/unit/mcp/handlers-n8n-manager.test.ts > handlers-n8n-manager > handleTriggerWebhookWorkflow > should not include "contact support" in error messages 36ms
✓ tests/unit/mcp/handlers-n8n-manager.test.ts > handlers-n8n-manager > handleTriggerWebhookWorkflow > should always recommend preview mode in error messages 40ms
✓ tests/unit/loaders/node-loader.test.ts > N8nNodeLoader > loadAllNodes > should load nodes from all configured packages 41ms
✓ tests/unit/loaders/node-loader.test.ts > N8nNodeLoader > loadAllNodes > should handle missing packages gracefully 43ms
✓ tests/unit/loaders/node-loader.test.ts > N8nNodeLoader > loadAllNodes > should handle packages with no n8n config 34ms
✓ tests/unit/loaders/node-loader.test.ts > N8nNodeLoader > loadPackageNodes - array format > should load nodes with default export 30ms
✓ tests/unit/loaders/node-loader.test.ts > N8nNodeLoader > loadPackageNodes - array format > should load nodes with named export matching node name 36ms
✓ tests/unit/loaders/node-loader.test.ts > N8nNodeLoader > loadPackageNodes - array format > should load nodes with object values export 35ms
✓ tests/unit/loaders/node-loader.test.ts > N8nNodeLoader > loadPackageNodes - array format > should extract node name from complex paths 35ms
✓ tests/unit/loaders/node-loader.test.ts > N8nNodeLoader > loadPackageNodes - array format > should handle nodes that fail to load 34ms
✓ tests/unit/loaders/node-loader.test.ts > N8nNodeLoader > loadPackageNodes - array format > should warn when no valid export is found 30ms
✓ tests/unit/loaders/node-loader.test.ts > N8nNodeLoader > loadPackageNodes - object format > should load nodes from object format 35ms
✓ tests/unit/loaders/node-loader.test.ts > N8nNodeLoader > loadPackageNodes - object format > should handle different export patterns in object format 43ms
✓ tests/unit/loaders/node-loader.test.ts > N8nNodeLoader > loadPackageNodes - object format > should handle errors in object format 37ms
✓ tests/unit/loaders/node-loader.test.ts > N8nNodeLoader > edge cases > should handle empty nodes array 33ms
✓ tests/unit/loaders/node-loader.test.ts > N8nNodeLoader > edge cases > should handle empty nodes object 32ms
✓ tests/unit/loaders/node-loader.test.ts > N8nNodeLoader > edge cases > should handle package.json without n8n property 32ms
✓ tests/unit/loaders/node-loader.test.ts > N8nNodeLoader > edge cases > should handle malformed node paths 35ms
✓ tests/unit/loaders/node-loader.test.ts > N8nNodeLoader > edge cases > should handle circular references in exports 35ms
✓ tests/unit/loaders/node-loader.test.ts > N8nNodeLoader > edge cases > should handle very long file paths 36ms
✓ tests/unit/loaders/node-loader.test.ts > N8nNodeLoader > edge cases > should handle special characters in node names 35ms
✓ tests/unit/loaders/node-loader.test.ts > N8nNodeLoader > edge cases > should handle mixed array and object in nodes (invalid but defensive) 32ms
✓ tests/unit/loaders/node-loader.test.ts > N8nNodeLoader > console output verification > should log correct messages for successful loads 33ms
✓ tests/unit/loaders/node-loader.test.ts > N8nNodeLoader > console output verification > should log package loading progress 35ms
✓ tests/integration/database/connection-management.test.ts > Database Connection Management > In-Memory Database > should create and connect to in-memory database 24ms
✓ tests/integration/database/connection-management.test.ts > Database Connection Management > In-Memory Database > should execute queries on in-memory database 24ms
✓ tests/integration/database/connection-management.test.ts > Database Connection Management > In-Memory Database > should handle multiple connections to same in-memory database 23ms
✓ tests/integration/database/connection-management.test.ts > Database Connection Management > File-Based Database > should create and connect to file database 30ms
✓ tests/integration/database/connection-management.test.ts > Database Connection Management > File-Based Database > should enable WAL mode by default for file databases 28ms
✓ tests/integration/database/connection-management.test.ts > Database Connection Management > File-Based Database > should allow disabling WAL mode 29ms
✓ tests/integration/database/connection-management.test.ts > Database Connection Management > File-Based Database > should handle connection pooling simulation 37ms
✓ tests/integration/database/connection-management.test.ts > Database Connection Management > Connection Error Handling > should handle invalid file path gracefully 29ms
✓ tests/integration/database/connection-management.test.ts > Database Connection Management > Connection Error Handling > should handle database file corruption 55ms
✓ tests/integration/database/connection-management.test.ts > Database Connection Management > Connection Error Handling > should handle readonly database access 33ms
✓ tests/integration/database/connection-management.test.ts > Database Connection Management > Connection Lifecycle > should properly close database connections 31ms
✓ tests/integration/database/connection-management.test.ts > Database Connection Management > Connection Lifecycle > should handle multiple open/close cycles 29ms
✓ tests/integration/database/connection-management.test.ts > Database Connection Management > Connection Lifecycle > should handle connection timeout simulation 147ms
✓ tests/integration/database/connection-management.test.ts > Database Connection Management > Database Configuration > should apply optimal pragmas for performance 26ms
✓ tests/integration/database/connection-management.test.ts > Database Connection Management > Database Configuration > should have foreign key support enabled 27ms
✓ tests/unit/database/node-repository-outputs.test.ts > NodeRepository - Outputs Handling > saveNode with outputs > should save node with outputs and outputNames correctly 25ms
✓ tests/unit/database/node-repository-outputs.test.ts > NodeRepository - Outputs Handling > saveNode with outputs > should save node with only outputs (no outputNames) 22ms
✓ tests/unit/database/node-repository-outputs.test.ts > NodeRepository - Outputs Handling > saveNode with outputs > should save node with only outputNames (no outputs) 24ms
✓ tests/unit/database/node-repository-outputs.test.ts > NodeRepository - Outputs Handling > saveNode with outputs > should save node without outputs or outputNames 21ms
✓ tests/unit/database/node-repository-outputs.test.ts > NodeRepository - Outputs Handling > saveNode with outputs > should handle empty outputs and outputNames arrays 23ms
✓ tests/unit/database/node-repository-outputs.test.ts > NodeRepository - Outputs Handling > getNode with outputs > should retrieve node with outputs and outputNames correctly 23ms
✓ tests/unit/database/node-repository-outputs.test.ts > NodeRepository - Outputs Handling > getNode with outputs > should retrieve node with only outputs (null outputNames) 21ms
✓ tests/unit/database/node-repository-outputs.test.ts > NodeRepository - Outputs Handling > getNode with outputs > should retrieve node with only outputNames (null outputs) 23ms
✓ tests/unit/database/node-repository-outputs.test.ts > NodeRepository - Outputs Handling > getNode with outputs > should retrieve node without outputs or outputNames 22ms
✓ tests/unit/database/node-repository-outputs.test.ts > NodeRepository - Outputs Handling > getNode with outputs > should handle malformed JSON gracefully 23ms
✓ tests/unit/database/node-repository-outputs.test.ts > NodeRepository - Outputs Handling > getNode with outputs > should return null for non-existent node 21ms
✓ tests/unit/database/node-repository-outputs.test.ts > NodeRepository - Outputs Handling > getNode with outputs > should handle SplitInBatches counterintuitive output order correctly 24ms
✓ tests/unit/database/node-repository-outputs.test.ts > NodeRepository - Outputs Handling > parseNodeRow with outputs > should parse node row with outputs correctly using parseNodeRow 22ms
✓ tests/unit/database/node-repository-outputs.test.ts > NodeRepository - Outputs Handling > parseNodeRow with outputs > should handle empty string as null for outputs 23ms
✓ tests/unit/database/node-repository-outputs.test.ts > NodeRepository - Outputs Handling > complex output structures > should handle complex output objects with metadata 23ms
✓ tests/unit/database/database-adapter-unit.test.ts > Database Adapter - Unit Tests > DatabaseAdapter Interface > should define interface when adapter is created 23ms
✓ tests/unit/database/database-adapter-unit.test.ts > Database Adapter - Unit Tests > PreparedStatement Interface > should define interface when statement is prepared 22ms
✓ tests/unit/database/database-adapter-unit.test.ts > Database Adapter - Unit Tests > FTS5 Support Detection > should detect support when FTS5 module is available 23ms
✓ tests/unit/database/database-adapter-unit.test.ts > Database Adapter - Unit Tests > Transaction Handling > should handle commit and rollback when transaction is executed 22ms
✓ tests/unit/database/database-adapter-unit.test.ts > Database Adapter - Unit Tests > Pragma Handling > should return values when pragma commands are executed 22ms
✓ tests/unit/http-server-session-management.test.ts > HTTP Server Session Management > Session Creation and Limits > should allow creation of sessions up to MAX_SESSIONS limit 118ms
✓ tests/unit/http-server-session-management.test.ts > HTTP Server Session Management > Session Creation and Limits > should reject new sessions when MAX_SESSIONS limit is reached 33ms
✓ tests/unit/http-server-session-management.test.ts > HTTP Server Session Management > Session Creation and Limits > should validate canCreateSession method behavior 30ms
✓ tests/unit/http-server-session-management.test.ts > HTTP Server Session Management > Session Expiration and Cleanup > should clean up expired sessions 32ms
✓ tests/unit/http-server-session-management.test.ts > HTTP Server Session Management > Session Expiration and Cleanup > should start and stop session cleanup timer 72ms
✓ tests/unit/http-server-session-management.test.ts > HTTP Server Session Management > Session Expiration and Cleanup > should handle removeSession method correctly 31ms
✓ tests/unit/http-server-session-management.test.ts > HTTP Server Session Management > Session Expiration and Cleanup > should handle removeSession with transport close error gracefully 31ms
✓ tests/unit/http-server-session-management.test.ts > HTTP Server Session Management > Session Metadata Tracking > should track session metadata correctly 44ms
✓ tests/unit/http-server-session-management.test.ts > HTTP Server Session Management > Session Metadata Tracking > should get session metrics correctly 33ms
✓ tests/unit/http-server-session-management.test.ts > HTTP Server Session Management > Session Metadata Tracking > should get active session count correctly 31ms
✓ tests/unit/http-server-session-management.test.ts > HTTP Server Session Management > Security Features > Production Mode with Default Token > should throw error in production with default token 32ms
✓ tests/unit/http-server-session-management.test.ts > HTTP Server Session Management > Security Features > Production Mode with Default Token > should allow default token in development 31ms
✓ tests/unit/http-server-session-management.test.ts > HTTP Server Session Management > Security Features > Production Mode with Default Token > should allow default token when NODE_ENV is not set 36ms
✓ tests/unit/http-server-session-management.test.ts > HTTP Server Session Management > Security Features > Token Validation > should warn about short tokens 34ms
✓ tests/unit/http-server-session-management.test.ts > HTTP Server Session Management > Security Features > Token Validation > should validate minimum token length (32 characters) 36ms
✓ tests/unit/http-server-session-management.test.ts > HTTP Server Session Management > Security Features > Token Validation > should throw error when AUTH_TOKEN is empty 34ms
✓ tests/unit/http-server-session-management.test.ts > HTTP Server Session Management > Security Features > Token Validation > should throw error when AUTH_TOKEN is missing 33ms
✓ tests/unit/http-server-session-management.test.ts > HTTP Server Session Management > Security Features > Token Validation > should load token from AUTH_TOKEN_FILE 32ms
✓ tests/unit/http-server-session-management.test.ts > HTTP Server Session Management > Security Features > Security Info in Health Endpoint > should include security information in health endpoint 39ms
✓ tests/unit/http-server-session-management.test.ts > HTTP Server Session Management > Security Features > Security Info in Health Endpoint > should show default token warning in health endpoint 48ms
✓ tests/unit/http-server-session-management.test.ts > HTTP Server Session Management > Transport Management > should handle transport cleanup on close 51ms
✓ tests/unit/http-server-session-management.test.ts > HTTP Server Session Management > Transport Management > should handle multiple concurrent sessions 57ms
✓ tests/unit/http-server-session-management.test.ts > HTTP Server Session Management > Transport Management > should handle session-specific transport instances 59ms
✓ tests/unit/http-server-session-management.test.ts > HTTP Server Session Management > New Endpoints > DELETE /mcp Endpoint > should terminate session successfully 39ms
✓ tests/unit/http-server-session-management.test.ts > HTTP Server Session Management > New Endpoints > DELETE /mcp Endpoint > should return 400 when Mcp-Session-Id header is missing 36ms
✓ tests/unit/http-server-session-management.test.ts > HTTP Server Session Management > New Endpoints > DELETE /mcp Endpoint > should return 400 for invalid session ID format 39ms
✓ tests/unit/http-server-session-management.test.ts > HTTP Server Session Management > New Endpoints > DELETE /mcp Endpoint > should return 404 when session not found 34ms
✓ tests/unit/http-server-session-management.test.ts > HTTP Server Session Management > New Endpoints > DELETE /mcp Endpoint > should handle termination errors gracefully 33ms
✓ tests/unit/http-server-session-management.test.ts > HTTP Server Session Management > New Endpoints > Enhanced Health Endpoint > should include session statistics in health endpoint 34ms
✓ tests/unit/http-server-session-management.test.ts > HTTP Server Session Management > New Endpoints > Enhanced Health Endpoint > should show correct session usage format 38ms
✓ tests/unit/http-server-session-management.test.ts > HTTP Server Session Management > Session ID Validation > should validate UUID v4 format correctly 35ms
✓ tests/unit/http-server-session-management.test.ts > HTTP Server Session Management > Session ID Validation > should reject requests with invalid session ID format 38ms
✓ tests/unit/http-server-session-management.test.ts > HTTP Server Session Management > Session ID Validation > should reject requests with non-existent session ID 33ms
✓ tests/unit/http-server-session-management.test.ts > HTTP Server Session Management > Shutdown and Cleanup > should clean up all resources on shutdown 31ms
✓ tests/unit/http-server-session-management.test.ts > HTTP Server Session Management > Shutdown and Cleanup > should handle transport close errors during shutdown 34ms
✓ tests/unit/http-server-session-management.test.ts > HTTP Server Session Management > getSessionInfo Method > should return correct session info structure 33ms
✓ tests/unit/http-server-session-management.test.ts > HTTP Server Session Management > getSessionInfo Method > should show legacy SSE session when present 34ms
✓ tests/integration/database/template-repository.test.ts > TemplateRepository Integration Tests > saveTemplate > should save single template successfully 26ms
✓ tests/integration/database/template-repository.test.ts > TemplateRepository Integration Tests > saveTemplate > should update existing template 23ms
✓ tests/integration/database/template-repository.test.ts > TemplateRepository Integration Tests > saveTemplate > should handle templates with complex node types 25ms
✓ tests/integration/database/template-repository.test.ts > TemplateRepository Integration Tests > saveTemplate > should sanitize workflow data before saving 23ms
✓ tests/integration/database/template-repository.test.ts > TemplateRepository Integration Tests > getTemplate > should retrieve template by id 24ms
✓ tests/integration/database/template-repository.test.ts > TemplateRepository Integration Tests > getTemplate > should return null for non-existent template 22ms
✓ tests/integration/database/template-repository.test.ts > TemplateRepository Integration Tests > searchTemplates with FTS5 > should search templates by name 26ms
✓ tests/integration/database/template-repository.test.ts > TemplateRepository Integration Tests > searchTemplates with FTS5 > should search templates by description 24ms
✓ tests/integration/database/template-repository.test.ts > TemplateRepository Integration Tests > searchTemplates with FTS5 > should handle multiple search terms 51ms
✓ tests/integration/database/template-repository.test.ts > TemplateRepository Integration Tests > searchTemplates with FTS5 > should limit search results 29ms
✓ tests/integration/database/template-repository.test.ts > TemplateRepository Integration Tests > searchTemplates with FTS5 > should handle special characters in search 22ms
✓ tests/integration/database/template-repository.test.ts > TemplateRepository Integration Tests > searchTemplates with FTS5 > should support pagination in search results 27ms
✓ tests/integration/database/template-repository.test.ts > TemplateRepository Integration Tests > getTemplatesByNodeTypes > should find templates using specific node types 22ms
✓ tests/integration/database/template-repository.test.ts > TemplateRepository Integration Tests > getTemplatesByNodeTypes > should find templates using multiple node types 25ms
✓ tests/integration/database/template-repository.test.ts > TemplateRepository Integration Tests > getTemplatesByNodeTypes > should return empty array for non-existent node types 25ms
✓ tests/integration/database/template-repository.test.ts > TemplateRepository Integration Tests > getTemplatesByNodeTypes > should limit results 23ms
✓ tests/integration/database/template-repository.test.ts > TemplateRepository Integration Tests > getTemplatesByNodeTypes > should support pagination with offset 25ms
✓ tests/integration/database/template-repository.test.ts > TemplateRepository Integration Tests > getAllTemplates > should return empty array when no templates 26ms
✓ tests/integration/database/template-repository.test.ts > TemplateRepository Integration Tests > getAllTemplates > should return all templates with limit 47ms
✓ tests/integration/database/template-repository.test.ts > TemplateRepository Integration Tests > getAllTemplates > should support pagination with offset 28ms
✓ tests/integration/database/template-repository.test.ts > TemplateRepository Integration Tests > getAllTemplates > should support different sort orders 23ms
✓ tests/integration/database/template-repository.test.ts > TemplateRepository Integration Tests > getAllTemplates > should order templates by views and created_at descending 25ms
✓ tests/integration/database/template-repository.test.ts > TemplateRepository Integration Tests > getTemplate with detail > should return template with workflow data 23ms
↓ tests/integration/database/template-repository.test.ts > TemplateRepository Integration Tests > clearOldTemplates > should remove templates older than specified days
✓ tests/integration/database/template-repository.test.ts > TemplateRepository Integration Tests > Transaction handling > should rollback on error during bulk save 25ms
✓ tests/integration/database/template-repository.test.ts > TemplateRepository Integration Tests > FTS5 performance > should handle large dataset searches efficiently 105ms
✓ tests/integration/database/template-repository.test.ts > TemplateRepository Integration Tests > New pagination count methods > getNodeTemplatesCount > should return correct count for node type searches 28ms
✓ tests/integration/database/template-repository.test.ts > TemplateRepository Integration Tests > New pagination count methods > getNodeTemplatesCount > should return 0 for non-existent node types 23ms
✓ tests/integration/database/template-repository.test.ts > TemplateRepository Integration Tests > New pagination count methods > getSearchCount > should return correct count for search queries 27ms
✓ tests/integration/database/template-repository.test.ts > TemplateRepository Integration Tests > New pagination count methods > getTaskTemplatesCount > should return correct count for task-based searches 27ms
✓ tests/integration/database/template-repository.test.ts > TemplateRepository Integration Tests > New pagination count methods > getTemplateCount > should return total template count 24ms
✓ tests/integration/database/template-repository.test.ts > TemplateRepository Integration Tests > New pagination count methods > getTemplateCount > should return 0 for empty database 27ms
✓ tests/integration/database/template-repository.test.ts > TemplateRepository Integration Tests > New pagination count methods > getTemplatesForTask with pagination > should support pagination for task-based searches 26ms
✓ tests/integration/database/template-repository.test.ts > TemplateRepository Integration Tests > searchTemplatesByMetadata - Two-Phase Optimization > should use two-phase query pattern for performance 26ms
✓ tests/integration/database/template-repository.test.ts > TemplateRepository Integration Tests > searchTemplatesByMetadata - Two-Phase Optimization > should preserve exact ordering from Phase 1 23ms
✓ tests/integration/database/template-repository.test.ts > TemplateRepository Integration Tests > searchTemplatesByMetadata - Two-Phase Optimization > should handle empty results efficiently 24ms
✓ tests/integration/database/template-repository.test.ts > TemplateRepository Integration Tests > searchTemplatesByMetadata - Two-Phase Optimization > should validate IDs defensively 25ms
✓ tests/integration/database/fts5-search.test.ts > FTS5 Full-Text Search > FTS5 Availability > should have FTS5 extension available 24ms
✓ tests/integration/database/fts5-search.test.ts > FTS5 Full-Text Search > FTS5 Availability > should support FTS5 for template searches 21ms
✓ tests/integration/database/fts5-search.test.ts > FTS5 Full-Text Search > Template FTS5 Operations > should search templates by exact term 24ms
✓ tests/integration/database/fts5-search.test.ts > FTS5 Full-Text Search > Template FTS5 Operations > should search with partial term and prefix 21ms
✓ tests/integration/database/fts5-search.test.ts > FTS5 Full-Text Search > Template FTS5 Operations > should search across multiple columns 26ms
✓ tests/integration/database/fts5-search.test.ts > FTS5 Full-Text Search > Template FTS5 Operations > should handle phrase searches 25ms
✓ tests/integration/database/fts5-search.test.ts > FTS5 Full-Text Search > Template FTS5 Operations > should support NOT queries 22ms
✓ tests/integration/database/fts5-search.test.ts > FTS5 Full-Text Search > FTS5 Ranking and Scoring > should rank results by relevance using bm25 31ms
✓ tests/integration/database/fts5-search.test.ts > FTS5 Full-Text Search > FTS5 Ranking and Scoring > should use custom weights for columns 23ms
✓ tests/integration/database/fts5-search.test.ts > FTS5 Full-Text Search > FTS5 Advanced Features > should support snippet extraction 24ms
✓ tests/integration/database/fts5-search.test.ts > FTS5 Full-Text Search > FTS5 Advanced Features > should support highlight function 22ms
✓ tests/integration/database/fts5-search.test.ts > FTS5 Full-Text Search > FTS5 Triggers and Synchronization > should automatically sync FTS on insert 24ms
↓ tests/integration/database/fts5-search.test.ts > FTS5 Full-Text Search > FTS5 Triggers and Synchronization > should automatically sync FTS on update
✓ tests/integration/database/fts5-search.test.ts > FTS5 Full-Text Search > FTS5 Triggers and Synchronization > should automatically sync FTS on delete 22ms
✓ tests/integration/database/fts5-search.test.ts > FTS5 Full-Text Search > FTS5 Performance > should handle large dataset searches efficiently 30ms
✓ tests/integration/database/fts5-search.test.ts > FTS5 Full-Text Search > FTS5 Performance > should optimize rebuilding FTS index 24ms
✓ tests/integration/database/fts5-search.test.ts > FTS5 Full-Text Search > FTS5 Error Handling > should handle malformed queries gracefully 22ms
✓ tests/integration/database/fts5-search.test.ts > FTS5 Full-Text Search > FTS5 Error Handling > should handle special characters in search terms 23ms
✓ tests/integration/database/fts5-search.test.ts > FTS5 Full-Text Search > FTS5 Error Handling > should handle empty search terms 22ms
✓ tests/integration/database/transactions.test.ts > Database Transactions > Basic Transactions > should commit transaction successfully 22ms
✓ tests/integration/database/transactions.test.ts > Database Transactions > Basic Transactions > should rollback transaction on error 24ms
✓ tests/integration/database/transactions.test.ts > Database Transactions > Basic Transactions > should handle transaction helper function 25ms
✓ tests/integration/database/transactions.test.ts > Database Transactions > Nested Transactions (Savepoints) > should handle nested transactions with savepoints 22ms
✓ tests/integration/database/transactions.test.ts > Database Transactions > Nested Transactions (Savepoints) > should release savepoints properly 23ms
✓ tests/integration/database/transactions.test.ts > Database Transactions > Transaction Isolation > should handle IMMEDIATE transactions 140ms
✓ tests/integration/database/transactions.test.ts > Database Transactions > Transaction Isolation > should handle EXCLUSIVE transactions 137ms
✓ tests/integration/database/transactions.test.ts > Database Transactions > Transaction with Better-SQLite3 API > should use transaction() method for automatic handling 30ms
✓ tests/integration/database/transactions.test.ts > Database Transactions > Transaction with Better-SQLite3 API > should rollback transaction() on error 27ms
✓ tests/integration/database/transactions.test.ts > Database Transactions > Transaction with Better-SQLite3 API > should handle immediate transactions with transaction() 24ms
✓ tests/integration/database/transactions.test.ts > Database Transactions > Transaction with Better-SQLite3 API > should handle exclusive transactions with transaction() 22ms
✓ tests/integration/database/transactions.test.ts > Database Transactions > Transaction Performance > should show performance benefit of transactions for bulk inserts 26ms
✓ tests/integration/database/transactions.test.ts > Database Transactions > Transaction Error Scenarios > should handle constraint violations in transactions 22ms
✓ tests/integration/database/transactions.test.ts > Database Transactions > Transaction Error Scenarios > should handle deadlock scenarios 139ms
↓ tests/integration/docker/docker-entrypoint.test.ts > Docker Entrypoint Script > MCP Mode handling > should default to stdio mode when MCP_MODE is not set
↓ tests/integration/docker/docker-entrypoint.test.ts > Docker Entrypoint Script > MCP Mode handling > should respect MCP_MODE=http environment variable
↓ tests/integration/docker/docker-entrypoint.test.ts > Docker Entrypoint Script > n8n-mcp serve command > should transform "n8n-mcp serve" to HTTP mode
↓ tests/integration/docker/docker-entrypoint.test.ts > Docker Entrypoint Script > n8n-mcp serve command > should preserve arguments after "n8n-mcp serve"
↓ tests/integration/docker/docker-entrypoint.test.ts > Docker Entrypoint Script > Database path configuration > should use default database path when NODE_DB_PATH is not set
↓ tests/integration/docker/docker-entrypoint.test.ts > Docker Entrypoint Script > Database path configuration > should respect NODE_DB_PATH environment variable
↓ tests/integration/docker/docker-entrypoint.test.ts > Docker Entrypoint Script > Database path configuration > should validate NODE_DB_PATH format
↓ tests/integration/docker/docker-entrypoint.test.ts > Docker Entrypoint Script > Permission handling > should fix permissions when running as root
↓ tests/integration/docker/docker-entrypoint.test.ts > Docker Entrypoint Script > Permission handling > should switch to nodejs user when running as root
↓ tests/integration/docker/docker-entrypoint.test.ts > Docker Entrypoint Script > Permission handling > should demonstrate docker exec runs as root while main process runs as nodejs
↓ tests/integration/docker/docker-entrypoint.test.ts > Docker Entrypoint Script > Auth token validation > should require AUTH_TOKEN in HTTP mode
↓ tests/integration/docker/docker-entrypoint.test.ts > Docker Entrypoint Script > Auth token validation > should accept AUTH_TOKEN_FILE
↓ tests/integration/docker/docker-entrypoint.test.ts > Docker Entrypoint Script > Auth token validation > should validate AUTH_TOKEN_FILE exists
↓ tests/integration/docker/docker-entrypoint.test.ts > Docker Entrypoint Script > Signal handling and process management > should use exec to ensure proper signal propagation
↓ tests/integration/docker/docker-entrypoint.test.ts > Docker Entrypoint Script > Logging behavior > should suppress logs in stdio mode
↓ tests/integration/docker/docker-entrypoint.test.ts > Docker Entrypoint Script > Logging behavior > should show logs in HTTP mode
↓ tests/integration/docker/docker-entrypoint.test.ts > Docker Entrypoint Script > Config file integration > should load config before validation checks
↓ tests/integration/docker/docker-entrypoint.test.ts > Docker Entrypoint Script > Database initialization with file locking > should prevent race conditions during database initialization
× tests/integration/mcp-protocol/performance.test.ts > MCP Performance Tests > Response Time Benchmarks > should respond to simple queries quickly 3593ms
→ expected 10.319083329999994 to be less than 10
→ expected 11.152821670000048 to be less than 10
→ expected 10.546642500000017 to be less than 10
✓ tests/integration/mcp-protocol/performance.test.ts > MCP Performance Tests > Response Time Benchmarks > should handle list operations efficiently 168ms
✓ tests/integration/mcp-protocol/performance.test.ts > MCP Performance Tests > Response Time Benchmarks > should perform searches efficiently 241ms
✓ tests/integration/mcp-protocol/performance.test.ts > MCP Performance Tests > Response Time Benchmarks > should retrieve node info quickly 129ms
✓ tests/integration/mcp-protocol/performance.test.ts > MCP Performance Tests > Concurrent Request Performance > should handle concurrent requests efficiently 175ms
✓ tests/integration/mcp-protocol/performance.test.ts > MCP Performance Tests > Concurrent Request Performance > should handle mixed concurrent operations 268ms
✓ tests/integration/mcp-protocol/performance.test.ts > MCP Performance Tests > Large Data Performance > should handle large node lists efficiently 139ms
✓ tests/integration/mcp-protocol/performance.test.ts > MCP Performance Tests > Large Data Performance > should handle large workflow validation efficiently 172ms
✓ tests/integration/mcp-protocol/performance.test.ts > MCP Performance Tests > Memory Efficiency > should handle repeated operations without memory leaks 10435ms
✓ tests/integration/mcp-protocol/performance.test.ts > MCP Performance Tests > Memory Efficiency > should release memory after large operations 212ms
✓ tests/integration/mcp-protocol/performance.test.ts > MCP Performance Tests > Scalability Tests > should maintain performance with increasing load 190ms
✓ tests/integration/mcp-protocol/performance.test.ts > MCP Performance Tests > Scalability Tests > should handle burst traffic 408ms
✓ tests/integration/mcp-protocol/performance.test.ts > MCP Performance Tests > Critical Path Optimization > should optimize tool listing performance 372ms
✓ tests/integration/mcp-protocol/performance.test.ts > MCP Performance Tests > Critical Path Optimization > should optimize search performance 196ms
✓ tests/integration/mcp-protocol/performance.test.ts > MCP Performance Tests > Critical Path Optimization > should cache effectively for repeated queries 117ms
× tests/integration/mcp-protocol/performance.test.ts > MCP Performance Tests > Stress Tests > should handle sustained high load 15370ms
→ expected 98.23265575928114 to be greater than 100
→ expected 95.82978873918175 to be greater than 100
→ expected 96.67608784131137 to be greater than 100
× tests/integration/mcp-protocol/performance.test.ts > MCP Performance Tests > Stress Tests > should recover from performance degradation 2051ms
→ expected 10.093091499997536 to be less than 10
→ expected 14.27884989999875 to be less than 10
→ expected 10.580879200002528 to be less than 10
✓ tests/integration/templates/metadata-operations.test.ts > Template Metadata Operations - Integration Tests > Repository Metadata Operations > should update template metadata successfully 45ms
✓ tests/integration/templates/metadata-operations.test.ts > Template Metadata Operations - Integration Tests > Repository Metadata Operations > should batch update metadata for multiple templates 45ms
✓ tests/integration/templates/metadata-operations.test.ts > Template Metadata Operations - Integration Tests > Repository Metadata Operations > should search templates by category 44ms
✓ tests/integration/templates/metadata-operations.test.ts > Template Metadata Operations - Integration Tests > Repository Metadata Operations > should search templates by complexity 45ms
✓ tests/integration/templates/metadata-operations.test.ts > Template Metadata Operations - Integration Tests > Repository Metadata Operations > should search templates by setup time 44ms
✓ tests/integration/templates/metadata-operations.test.ts > Template Metadata Operations - Integration Tests > Repository Metadata Operations > should search templates by required service 43ms
✓ tests/integration/templates/metadata-operations.test.ts > Template Metadata Operations - Integration Tests > Repository Metadata Operations > should search templates by target audience 44ms
✓ tests/integration/templates/metadata-operations.test.ts > Template Metadata Operations - Integration Tests > Repository Metadata Operations > should handle combined filters correctly 42ms
✓ tests/integration/templates/metadata-operations.test.ts > Template Metadata Operations - Integration Tests > Repository Metadata Operations > should return correct counts for metadata searches 44ms
✓ tests/integration/templates/metadata-operations.test.ts > Template Metadata Operations - Integration Tests > Repository Metadata Operations > should get unique categories 45ms
✓ tests/integration/templates/metadata-operations.test.ts > Template Metadata Operations - Integration Tests > Repository Metadata Operations > should get unique target audiences 43ms
✓ tests/integration/templates/metadata-operations.test.ts > Template Metadata Operations - Integration Tests > Repository Metadata Operations > should get templates by category 44ms
✓ tests/integration/templates/metadata-operations.test.ts > Template Metadata Operations - Integration Tests > Repository Metadata Operations > should get templates by complexity 45ms
✓ tests/integration/templates/metadata-operations.test.ts > Template Metadata Operations - Integration Tests > Repository Metadata Operations > should get templates without metadata 42ms
✓ tests/integration/templates/metadata-operations.test.ts > Template Metadata Operations - Integration Tests > Repository Metadata Operations > should get outdated metadata templates 45ms
✓ tests/integration/templates/metadata-operations.test.ts > Template Metadata Operations - Integration Tests > Repository Metadata Operations > should get metadata statistics 43ms
✓ tests/integration/templates/metadata-operations.test.ts > Template Metadata Operations - Integration Tests > Service Layer Integration > should search templates with metadata through service 45ms
✓ tests/integration/templates/metadata-operations.test.ts > Template Metadata Operations - Integration Tests > Service Layer Integration > should handle pagination correctly in metadata search 44ms
✓ tests/integration/templates/metadata-operations.test.ts > Template Metadata Operations - Integration Tests > Service Layer Integration > should return templates with metadata information 45ms
✓ tests/integration/templates/metadata-operations.test.ts > Template Metadata Operations - Integration Tests > Security and Error Handling > should handle malicious input safely in metadata search 43ms
✓ tests/integration/templates/metadata-operations.test.ts > Template Metadata Operations - Integration Tests > Security and Error Handling > should handle invalid metadata gracefully 43ms
✓ tests/integration/templates/metadata-operations.test.ts > Template Metadata Operations - Integration Tests > Security and Error Handling > should handle empty search results gracefully 45ms
✓ tests/integration/templates/metadata-operations.test.ts > Template Metadata Operations - Integration Tests > Security and Error Handling > should handle edge case parameters 43ms
✓ tests/integration/templates/metadata-operations.test.ts > Template Metadata Operations - Integration Tests > Performance and Scalability > should handle large result sets efficiently 41ms
✓ tests/integration/templates/metadata-operations.test.ts > Template Metadata Operations - Integration Tests > Performance and Scalability > should handle concurrent metadata updates 47ms
✓ tests/unit/services/debug-validator.test.ts > Debug Validator Tests > should handle nodes at extreme positions - debug 22ms
✓ tests/unit/services/debug-validator.test.ts > Debug Validator Tests > should handle special characters in node names - debug 23ms
✓ tests/unit/services/debug-validator.test.ts > Debug Validator Tests > should handle non-array nodes - debug 20ms
✓ tests/integration/database/template-node-configs.test.ts > Template Node Configs Database Integration > Schema Validation > should create template_node_configs table 31ms
✓ tests/integration/database/template-node-configs.test.ts > Template Node Configs Database Integration > Schema Validation > should have all required columns 29ms
✓ tests/integration/database/template-node-configs.test.ts > Template Node Configs Database Integration > Schema Validation > should have correct column types and constraints 32ms
✓ tests/integration/database/template-node-configs.test.ts > Template Node Configs Database Integration > Schema Validation > should have complexity CHECK constraint 29ms
✓ tests/integration/database/template-node-configs.test.ts > Template Node Configs Database Integration > Schema Validation > should accept valid complexity values 30ms
✓ tests/integration/database/template-node-configs.test.ts > Template Node Configs Database Integration > Indexes > should create idx_config_node_type_rank index 29ms
✓ tests/integration/database/template-node-configs.test.ts > Template Node Configs Database Integration > Indexes > should create idx_config_complexity index 27ms
✓ tests/integration/database/template-node-configs.test.ts > Template Node Configs Database Integration > Indexes > should create idx_config_auth index 29ms
✓ tests/integration/database/template-node-configs.test.ts > Template Node Configs Database Integration > View: ranked_node_configs > should create ranked_node_configs view 27ms
✓ tests/integration/database/template-node-configs.test.ts > Template Node Configs Database Integration > View: ranked_node_configs > should return only top 5 ranked configs per node type 41ms
✓ tests/integration/database/template-node-configs.test.ts > Template Node Configs Database Integration > View: ranked_node_configs > should order by node_type and rank 27ms
✓ tests/integration/database/template-node-configs.test.ts > Template Node Configs Database Integration > Foreign Key Constraints > should allow inserting config with valid template_id 30ms
✓ tests/integration/database/template-node-configs.test.ts > Template Node Configs Database Integration > Foreign Key Constraints > should cascade delete configs when template is deleted 30ms
✓ tests/integration/database/template-node-configs.test.ts > Template Node Configs Database Integration > Data Operations > should insert and retrieve config with all fields 26ms
✓ tests/integration/database/template-node-configs.test.ts > Template Node Configs Database Integration > Data Operations > should handle nullable fields correctly 28ms
✓ tests/integration/database/template-node-configs.test.ts > Template Node Configs Database Integration > Data Operations > should update rank values 26ms
✓ tests/integration/database/template-node-configs.test.ts > Template Node Configs Database Integration > Data Operations > should delete configs with rank > 10 29ms
✓ tests/integration/database/template-node-configs.test.ts > Template Node Configs Database Integration > Query Performance > should query by node_type and rank efficiently 33ms
✓ tests/integration/database/template-node-configs.test.ts > Template Node Configs Database Integration > Query Performance > should filter by complexity efficiently 33ms
✓ tests/integration/database/template-node-configs.test.ts > Template Node Configs Database Integration > Migration Idempotency > should be safe to run migration multiple times 28ms
✓ tests/unit/mcp/parameter-validation.test.ts > Parameter Validation > validateToolParams > Basic Parameter Validation > should pass validation when all required parameters are provided 23ms
✓ tests/unit/mcp/parameter-validation.test.ts > Parameter Validation > validateToolParams > Basic Parameter Validation > should throw error when required parameter is missing 25ms
✓ tests/unit/mcp/parameter-validation.test.ts > Parameter Validation > validateToolParams > Basic Parameter Validation > should throw error when multiple required parameters are missing 24ms
✓ tests/unit/mcp/parameter-validation.test.ts > Parameter Validation > validateToolParams > Basic Parameter Validation > should throw error when required parameter is undefined 22ms
✓ tests/unit/mcp/parameter-validation.test.ts > Parameter Validation > validateToolParams > Basic Parameter Validation > should throw error when required parameter is null 24ms
✓ tests/unit/mcp/parameter-validation.test.ts > Parameter Validation > validateToolParams > Basic Parameter Validation > should pass when required parameter is empty string 21ms
✓ tests/unit/mcp/parameter-validation.test.ts > Parameter Validation > validateToolParams > Basic Parameter Validation > should pass when required parameter is zero 24ms
✓ tests/unit/mcp/parameter-validation.test.ts > Parameter Validation > validateToolParams > Basic Parameter Validation > should pass when required parameter is false 25ms
✓ tests/unit/mcp/parameter-validation.test.ts > Parameter Validation > validateToolParams > Edge Cases > should handle empty args object 23ms
✓ tests/unit/mcp/parameter-validation.test.ts > Parameter Validation > validateToolParams > Edge Cases > should handle null args 24ms
✓ tests/unit/mcp/parameter-validation.test.ts > Parameter Validation > validateToolParams > Edge Cases > should handle undefined args 24ms
✓ tests/unit/mcp/parameter-validation.test.ts > Parameter Validation > validateToolParams > Edge Cases > should pass when no required parameters are specified 22ms
✓ tests/unit/mcp/parameter-validation.test.ts > Parameter Validation > validateToolParams > Edge Cases > should handle special characters in parameter names 25ms
✓ tests/unit/mcp/parameter-validation.test.ts > Parameter Validation > Tool-Specific Parameter Validation > get_node_info > should require nodeType parameter 25ms
✓ tests/unit/mcp/parameter-validation.test.ts > Parameter Validation > Tool-Specific Parameter Validation > get_node_info > should succeed with valid nodeType 23ms
✓ tests/unit/mcp/parameter-validation.test.ts > Parameter Validation > Tool-Specific Parameter Validation > search_nodes > should require query parameter 25ms
✓ tests/unit/mcp/parameter-validation.test.ts > Parameter Validation > Tool-Specific Parameter Validation > search_nodes > should succeed with valid query 26ms
✓ tests/unit/mcp/parameter-validation.test.ts > Parameter Validation > Tool-Specific Parameter Validation > search_nodes > should handle optional limit parameter 23ms
✓ tests/unit/mcp/parameter-validation.test.ts > Parameter Validation > Tool-Specific Parameter Validation > search_nodes > should reject invalid limit value 26ms
✓ tests/unit/mcp/parameter-validation.test.ts > Parameter Validation > Tool-Specific Parameter Validation > validate_node_operation > should require nodeType and config parameters 25ms
✓ tests/unit/mcp/parameter-validation.test.ts > Parameter Validation > Tool-Specific Parameter Validation > validate_node_operation > should require nodeType parameter when config is provided 24ms
✓ tests/unit/mcp/parameter-validation.test.ts > Parameter Validation > Tool-Specific Parameter Validation > validate_node_operation > should require config parameter when nodeType is provided 26ms
✓ tests/unit/mcp/parameter-validation.test.ts > Parameter Validation > Tool-Specific Parameter Validation > validate_node_operation > should succeed with valid parameters 25ms
✓ tests/unit/mcp/parameter-validation.test.ts > Parameter Validation > Tool-Specific Parameter Validation > search_node_properties > should require nodeType and query parameters 24ms
✓ tests/unit/mcp/parameter-validation.test.ts > Parameter Validation > Tool-Specific Parameter Validation > search_node_properties > should succeed with valid parameters 26ms
✓ tests/unit/mcp/parameter-validation.test.ts > Parameter Validation > Tool-Specific Parameter Validation > search_node_properties > should handle optional maxResults parameter 26ms
✓ tests/unit/mcp/parameter-validation.test.ts > Parameter Validation > Tool-Specific Parameter Validation > list_node_templates > should require nodeTypes parameter 24ms
✓ tests/unit/mcp/parameter-validation.test.ts > Parameter Validation > Tool-Specific Parameter Validation > list_node_templates > should succeed with valid nodeTypes array 25ms
✓ tests/unit/mcp/parameter-validation.test.ts > Parameter Validation > Tool-Specific Parameter Validation > get_template > should require templateId parameter 27ms
✓ tests/unit/mcp/parameter-validation.test.ts > Parameter Validation > Tool-Specific Parameter Validation > get_template > should succeed with valid templateId 26ms
✓ tests/unit/mcp/parameter-validation.test.ts > Parameter Validation > Numeric Parameter Conversion > limit parameter conversion > should reject string limit values 24ms
✓ tests/unit/mcp/parameter-validation.test.ts > Parameter Validation > Numeric Parameter Conversion > limit parameter conversion > should reject invalid string limit values 27ms
✓ tests/unit/mcp/parameter-validation.test.ts > Parameter Validation > Numeric Parameter Conversion > limit parameter conversion > should use default when limit is undefined 27ms
✓ tests/unit/mcp/parameter-validation.test.ts > Parameter Validation > Numeric Parameter Conversion > limit parameter conversion > should reject zero as limit due to minimum constraint 25ms
✓ tests/unit/mcp/parameter-validation.test.ts > Parameter Validation > Numeric Parameter Conversion > maxResults parameter conversion > should convert string numbers to numbers 27ms
✓ tests/unit/mcp/parameter-validation.test.ts > Parameter Validation > Numeric Parameter Conversion > maxResults parameter conversion > should use default when maxResults is invalid 27ms
✓ tests/unit/mcp/parameter-validation.test.ts > Parameter Validation > Numeric Parameter Conversion > templateLimit parameter conversion > should reject string limit values 27ms
✓ tests/unit/mcp/parameter-validation.test.ts > Parameter Validation > Numeric Parameter Conversion > templateLimit parameter conversion > should reject invalid string limit values 24ms
✓ tests/unit/mcp/parameter-validation.test.ts > Parameter Validation > Numeric Parameter Conversion > templateId parameter handling > should pass through numeric templateId 27ms
✓ tests/unit/mcp/parameter-validation.test.ts > Parameter Validation > Numeric Parameter Conversion > templateId parameter handling > should convert string templateId to number 27ms
✓ tests/unit/mcp/parameter-validation.test.ts > Parameter Validation > Tools with No Required Parameters > should allow tools_documentation with no parameters 27ms
✓ tests/unit/mcp/parameter-validation.test.ts > Parameter Validation > Tools with No Required Parameters > should allow list_nodes with no parameters 25ms
✓ tests/unit/mcp/parameter-validation.test.ts > Parameter Validation > Tools with No Required Parameters > should allow list_ai_tools with no parameters 27ms
✓ tests/unit/mcp/parameter-validation.test.ts > Parameter Validation > Tools with No Required Parameters > should allow get_database_statistics with no parameters 28ms
✓ tests/unit/mcp/parameter-validation.test.ts > Parameter Validation > Tools with No Required Parameters > should allow list_tasks with no parameters 26ms
✓ tests/unit/mcp/parameter-validation.test.ts > Parameter Validation > Error Message Quality > should provide clear error messages with tool name 28ms
✓ tests/unit/mcp/parameter-validation.test.ts > Parameter Validation > Error Message Quality > should list all missing parameters 27ms
✓ tests/unit/mcp/parameter-validation.test.ts > Parameter Validation > Error Message Quality > should include helpful guidance 28ms
✓ tests/unit/mcp/parameter-validation.test.ts > Parameter Validation > MCP Error Response Handling > should convert validation errors to MCP error responses rather than throwing exceptions 26ms
✓ tests/unit/mcp/parameter-validation.test.ts > Parameter Validation > MCP Error Response Handling > should handle edge cases in parameter validation gracefully 28ms
✓ tests/unit/mcp/parameter-validation.test.ts > Parameter Validation > MCP Error Response Handling > should provide consistent error format across all tools 28ms
✓ tests/unit/mcp/parameter-validation.test.ts > Parameter Validation > MCP Error Response Handling > should validate n8n management tools parameters 27ms
✓ tests/unit/flexible-instance-security-advanced.test.ts > Advanced Security and Error Handling Tests > Advanced Input Sanitization > should handle SQL injection attempts in context fields 52ms
✓ tests/unit/flexible-instance-security-advanced.test.ts > Advanced Security and Error Handling Tests > Advanced Input Sanitization > should handle XSS attempts in context fields 54ms
✓ tests/unit/flexible-instance-security-advanced.test.ts > Advanced Security and Error Handling Tests > Advanced Input Sanitization > should handle extremely long input values 52ms
✓ tests/unit/flexible-instance-security-advanced.test.ts > Advanced Security and Error Handling Tests > Advanced Input Sanitization > should handle Unicode and special characters safely 55ms
✓ tests/unit/flexible-instance-security-advanced.test.ts > Advanced Security and Error Handling Tests > Advanced Input Sanitization > should handle null bytes and control characters 52ms
✓ tests/unit/flexible-instance-security-advanced.test.ts > Advanced Security and Error Handling Tests > Prototype Pollution Protection > should not be vulnerable to prototype pollution via __proto__ 53ms
✓ tests/unit/flexible-instance-security-advanced.test.ts > Advanced Security and Error Handling Tests > Prototype Pollution Protection > should not be vulnerable to prototype pollution via constructor 54ms
✓ tests/unit/flexible-instance-security-advanced.test.ts > Advanced Security and Error Handling Tests > Prototype Pollution Protection > should handle Object.create(null) safely 51ms
✓ tests/unit/flexible-instance-security-advanced.test.ts > Advanced Security and Error Handling Tests > Memory Exhaustion Protection > should handle deeply nested objects without stack overflow 51ms
✓ tests/unit/flexible-instance-security-advanced.test.ts > Advanced Security and Error Handling Tests > Memory Exhaustion Protection > should handle circular references in metadata 54ms
✓ tests/unit/flexible-instance-security-advanced.test.ts > Advanced Security and Error Handling Tests > Memory Exhaustion Protection > should handle massive arrays in metadata 51ms
✓ tests/unit/flexible-instance-security-advanced.test.ts > Advanced Security and Error Handling Tests > Cache Security and Isolation > should prevent cache key collisions through hash security 51ms
✓ tests/unit/flexible-instance-security-advanced.test.ts > Advanced Security and Error Handling Tests > Cache Security and Isolation > should not expose sensitive data in cache key logs 53ms
✓ tests/unit/flexible-instance-security-advanced.test.ts > Advanced Security and Error Handling Tests > Cache Security and Isolation > should handle hash collisions securely 51ms
✓ tests/unit/flexible-instance-security-advanced.test.ts > Advanced Security and Error Handling Tests > Error Message Security > should not expose sensitive data in validation error messages 55ms
✓ tests/unit/flexible-instance-security-advanced.test.ts > Advanced Security and Error Handling Tests > Error Message Security > should sanitize error details in API responses 52ms
✓ tests/unit/flexible-instance-security-advanced.test.ts > Advanced Security and Error Handling Tests > Resource Exhaustion Protection > should handle memory pressure gracefully 56ms
✓ tests/unit/flexible-instance-security-advanced.test.ts > Advanced Security and Error Handling Tests > Resource Exhaustion Protection > should handle high frequency validation requests 81ms
✓ tests/unit/flexible-instance-security-advanced.test.ts > Advanced Security and Error Handling Tests > Cryptographic Security > should use cryptographically secure hash function 51ms
✓ tests/unit/flexible-instance-security-advanced.test.ts > Advanced Security and Error Handling Tests > Cryptographic Security > should handle edge cases in hash input 54ms
✓ tests/unit/flexible-instance-security-advanced.test.ts > Advanced Security and Error Handling Tests > Injection Attack Prevention > should prevent command injection through context fields 51ms
✓ tests/unit/flexible-instance-security-advanced.test.ts > Advanced Security and Error Handling Tests > Injection Attack Prevention > should prevent path traversal attempts 51ms
✓ tests/unit/flexible-instance-security-advanced.test.ts > Advanced Security and Error Handling Tests > Injection Attack Prevention > should prevent LDAP injection attempts 53ms
✓ tests/unit/flexible-instance-security-advanced.test.ts > Advanced Security and Error Handling Tests > State Management Security > should maintain isolation between contexts 51ms
✓ tests/unit/flexible-instance-security-advanced.test.ts > Advanced Security and Error Handling Tests > State Management Security > should handle concurrent access securely 76ms
✓ tests/unit/mcp/handlers-n8n-manager-simple.test.ts > handlers-n8n-manager Simple Coverage Tests > Cache Key Generation > should generate deterministic SHA-256 hashes 57ms
✓ tests/unit/mcp/handlers-n8n-manager-simple.test.ts > handlers-n8n-manager Simple Coverage Tests > Cache Key Generation > should handle empty instanceId in cache key generation 55ms
✓ tests/unit/mcp/handlers-n8n-manager-simple.test.ts > handlers-n8n-manager Simple Coverage Tests > Cache Key Generation > should handle undefined values in cache key generation 56ms
✓ tests/unit/mcp/handlers-n8n-manager-simple.test.ts > handlers-n8n-manager Simple Coverage Tests > URL Sanitization > should sanitize URLs for logging 55ms
✓ tests/unit/mcp/handlers-n8n-manager-simple.test.ts > handlers-n8n-manager Simple Coverage Tests > URL Sanitization > should handle various URL formats in sanitization 58ms
✓ tests/unit/mcp/handlers-n8n-manager-simple.test.ts > handlers-n8n-manager Simple Coverage Tests > Cache Key Partial Logging > should create partial cache key for logging 55ms
✓ tests/unit/mcp/handlers-n8n-manager-simple.test.ts > handlers-n8n-manager Simple Coverage Tests > Cache Key Partial Logging > should handle various hash lengths for partial logging 58ms
✓ tests/unit/mcp/handlers-n8n-manager-simple.test.ts > handlers-n8n-manager Simple Coverage Tests > Error Message Handling > should handle different error types correctly 55ms
✓ tests/unit/mcp/handlers-n8n-manager-simple.test.ts > handlers-n8n-manager Simple Coverage Tests > Error Message Handling > should handle error objects without message property 57ms
✓ tests/unit/mcp/handlers-n8n-manager-simple.test.ts > handlers-n8n-manager Simple Coverage Tests > Configuration Fallbacks > should handle null config scenarios 55ms
✓ tests/unit/mcp/handlers-n8n-manager-simple.test.ts > handlers-n8n-manager Simple Coverage Tests > Configuration Fallbacks > should handle undefined config values 57ms
✓ tests/unit/mcp/handlers-n8n-manager-simple.test.ts > handlers-n8n-manager Simple Coverage Tests > Array and Object Handling > should handle undefined array lengths 54ms
✓ tests/unit/mcp/handlers-n8n-manager-simple.test.ts > handlers-n8n-manager Simple Coverage Tests > Array and Object Handling > should handle empty arrays 60ms
✓ tests/unit/mcp/handlers-n8n-manager-simple.test.ts > handlers-n8n-manager Simple Coverage Tests > Array and Object Handling > should handle arrays with elements 57ms
✓ tests/unit/mcp/handlers-n8n-manager-simple.test.ts > handlers-n8n-manager Simple Coverage Tests > Conditional Logic Coverage > should handle truthy cursor values 59ms
✓ tests/unit/mcp/handlers-n8n-manager-simple.test.ts > handlers-n8n-manager Simple Coverage Tests > Conditional Logic Coverage > should handle falsy cursor values 55ms
✓ tests/unit/mcp/handlers-n8n-manager-simple.test.ts > handlers-n8n-manager Simple Coverage Tests > String Manipulation > should handle environment variable filtering 60ms
✓ tests/unit/mcp/handlers-n8n-manager-simple.test.ts > handlers-n8n-manager Simple Coverage Tests > String Manipulation > should handle version string extraction 57ms
✓ tests/unit/mcp/handlers-n8n-manager-simple.test.ts > handlers-n8n-manager Simple Coverage Tests > String Manipulation > should handle missing dependencies 58ms
✓ tests/unit/mcp/get-node-essentials-examples.test.ts > get_node_essentials with includeExamples > includeExamples parameter > should not include examples when includeExamples is false 30ms
✓ tests/unit/mcp/get-node-essentials-examples.test.ts > get_node_essentials with includeExamples > includeExamples parameter > should not include examples when includeExamples is undefined 32ms
✓ tests/unit/mcp/get-node-essentials-examples.test.ts > get_node_essentials with includeExamples > includeExamples parameter > should include examples when includeExamples is true 31ms
✓ tests/unit/mcp/get-node-essentials-examples.test.ts > get_node_essentials with includeExamples > includeExamples parameter > should limit examples to top 3 per node 32ms
✓ tests/unit/mcp/get-node-essentials-examples.test.ts > get_node_essentials with includeExamples > example data structure with metadata > should return examples with full metadata structure 32ms
✓ tests/unit/mcp/get-node-essentials-examples.test.ts > get_node_essentials with includeExamples > example data structure with metadata > should include complexity in source metadata 32ms
✓ tests/unit/mcp/get-node-essentials-examples.test.ts > get_node_essentials with includeExamples > example data structure with metadata > should limit use cases to 2 items 32ms
✓ tests/unit/mcp/get-node-essentials-examples.test.ts > get_node_essentials with includeExamples > example data structure with metadata > should handle empty use_cases gracefully 32ms
✓ tests/unit/mcp/get-node-essentials-examples.test.ts > get_node_essentials with includeExamples > caching behavior with includeExamples > should use different cache keys for with/without examples 32ms
✓ tests/unit/mcp/get-node-essentials-examples.test.ts > get_node_essentials with includeExamples > caching behavior with includeExamples > should cache results separately for different includeExamples values 31ms
✓ tests/unit/mcp/get-node-essentials-examples.test.ts > get_node_essentials with includeExamples > backward compatibility > should maintain backward compatibility when includeExamples not specified 32ms
✓ tests/unit/mcp/get-node-essentials-examples.test.ts > get_node_essentials with includeExamples > backward compatibility > should return same core data regardless of includeExamples value 32ms
✓ tests/unit/mcp/get-node-essentials-examples.test.ts > get_node_essentials with includeExamples > error handling > should continue to work even if example fetch fails 31ms
✓ tests/unit/mcp/get-node-essentials-examples.test.ts > get_node_essentials with includeExamples > error handling > should handle malformed JSON in template configs gracefully 31ms
✓ tests/unit/mcp/get-node-essentials-examples.test.ts > get_node_essentials with includeExamples > performance > should complete in reasonable time with examples 32ms
✓ tests/unit/mcp/get-node-essentials-examples.test.ts > get_node_essentials with includeExamples > performance > should not add significant overhead when includeExamples is false 32ms
✓ tests/unit/http-server-n8n-mode.test.ts > HTTP Server n8n Mode > Protocol Version Endpoint (GET /mcp) > should return standard response when N8N_MODE is not set 45ms
✓ tests/unit/http-server-n8n-mode.test.ts > HTTP Server n8n Mode > Protocol Version Endpoint (GET /mcp) > should return protocol version when N8N_MODE=true 43ms
✓ tests/unit/http-server-n8n-mode.test.ts > HTTP Server n8n Mode > Session ID Header (POST /mcp) > should handle POST request when N8N_MODE is not set 45ms
✓ tests/unit/http-server-n8n-mode.test.ts > HTTP Server n8n Mode > Session ID Header (POST /mcp) > should handle POST request when N8N_MODE=true 43ms
✓ tests/unit/http-server-n8n-mode.test.ts > HTTP Server n8n Mode > Error Response Format > should use JSON-RPC error format for auth errors 44ms
✓ tests/unit/http-server-n8n-mode.test.ts > HTTP Server n8n Mode > Error Response Format > should handle invalid auth token 46ms
✓ tests/unit/http-server-n8n-mode.test.ts > HTTP Server n8n Mode > Error Response Format > should handle invalid auth header format 43ms
✓ tests/unit/http-server-n8n-mode.test.ts > HTTP Server n8n Mode > Normal Mode Behavior > should maintain standard behavior for health endpoint 43ms
✓ tests/unit/http-server-n8n-mode.test.ts > HTTP Server n8n Mode > Normal Mode Behavior > should maintain standard behavior for root endpoint 44ms
✓ tests/unit/http-server-n8n-mode.test.ts > HTTP Server n8n Mode > Edge Cases > should handle N8N_MODE with various values 45ms
✓ tests/unit/http-server-n8n-mode.test.ts > HTTP Server n8n Mode > Edge Cases > should handle OPTIONS requests for CORS 44ms
✓ tests/unit/http-server-n8n-mode.test.ts > HTTP Server n8n Mode > Edge Cases > should validate session info methods 47ms
✓ tests/unit/http-server-n8n-mode.test.ts > HTTP Server n8n Mode > 404 Handler > should handle 404 errors correctly 42ms
✓ tests/unit/http-server-n8n-mode.test.ts > HTTP Server n8n Mode > 404 Handler > should handle GET requests to non-existent paths 43ms
✓ tests/unit/http-server-n8n-mode.test.ts > HTTP Server n8n Mode > Security Features > should handle malformed authorization headers 111ms
✓ tests/unit/http-server-n8n-mode.test.ts > HTTP Server n8n Mode > Security Features > should verify server configuration methods exist 43ms
✓ tests/unit/http-server-n8n-mode.test.ts > HTTP Server n8n Mode > Security Features > should handle valid auth tokens properly 43ms
✓ tests/unit/http-server-n8n-mode.test.ts > HTTP Server n8n Mode > Security Features > should handle DELETE endpoint without session ID 43ms
✓ tests/unit/http-server-n8n-mode.test.ts > HTTP Server n8n Mode > Security Features > should provide proper error details for debugging 44ms
✓ tests/unit/http-server-n8n-mode.test.ts > HTTP Server n8n Mode > Express Middleware Configuration > should configure all necessary middleware 44ms
✓ tests/unit/http-server-n8n-mode.test.ts > HTTP Server n8n Mode > Express Middleware Configuration > should handle CORS preflight for different methods 100ms
✓ tests/unit/services/enhanced-config-validator-integration.test.ts > EnhancedConfigValidator - Integration Tests > similarity service integration > should initialize similarity services when initializeSimilarityServices is called 45ms
stderr | tests/unit/services/enhanced-config-validator-integration.test.ts > EnhancedConfigValidator - Integration Tests > similarity service integration > should handle similarity service errors gracefully
Resource similarity service error: Error: Service error
at Object.<anonymous> [90m(/Users/romualdczlonkowski/Pliki/n8n-mcp/n8n-mcp/[39mtests/unit/services/enhanced-config-validator-integration.test.ts:193:15[90m)[39m
at Object.mockCall [90m(file:///Users/romualdczlonkowski/Pliki/n8n-mcp/n8n-mcp/[39mnode_modules/[4m@vitest[24m/spy/dist/index.js:96:15[90m)[39m
at Object.spy [as findSimilarResources] [90m(file:///Users/romualdczlonkowski/Pliki/n8n-mcp/n8n-mcp/[39mnode_modules/[4mtinyspy[24m/dist/index.js:47:80[90m)[39m
at Function.validateResourceAndOperation [90m(/Users/romualdczlonkowski/Pliki/n8n-mcp/n8n-mcp/[39msrc/services/enhanced-config-validator.ts:732:56[90m)[39m
at Function.addOperationSpecificEnhancements [90m(/Users/romualdczlonkowski/Pliki/n8n-mcp/n8n-mcp/[39msrc/services/enhanced-config-validator.ts:260:10[90m)[39m
at Function.validateWithMode [90m(/Users/romualdczlonkowski/Pliki/n8n-mcp/n8n-mcp/[39msrc/services/enhanced-config-validator.ts:110:10[90m)[39m
at [90m/Users/romualdczlonkowski/Pliki/n8n-mcp/n8n-mcp/[39mtests/unit/services/enhanced-config-validator-integration.test.ts:196:46
at [90mfile:///Users/romualdczlonkowski/Pliki/n8n-mcp/n8n-mcp/[39mnode_modules/[4m@vitest[24m/runner/dist/chunk-hooks.js:155:11
at [90mfile:///Users/romualdczlonkowski/Pliki/n8n-mcp/n8n-mcp/[39mnode_modules/[4m@vitest[24m/runner/dist/chunk-hooks.js:752:26
at [90mfile:///Users/romualdczlonkowski/Pliki/n8n-mcp/n8n-mcp/[39mnode_modules/[4m@vitest[24m/runner/dist/chunk-hooks.js:1897:20
✓ tests/unit/services/enhanced-config-validator-integration.test.ts > EnhancedConfigValidator - Integration Tests > similarity service integration > should use resource similarity service for invalid resource errors 45ms
✓ tests/unit/services/enhanced-config-validator-integration.test.ts > EnhancedConfigValidator - Integration Tests > similarity service integration > should use operation similarity service for invalid operation errors 45ms
✓ tests/unit/services/enhanced-config-validator-integration.test.ts > EnhancedConfigValidator - Integration Tests > similarity service integration > should handle similarity service errors gracefully 50ms
✓ tests/unit/services/enhanced-config-validator-integration.test.ts > EnhancedConfigValidator - Integration Tests > similarity service integration > should not call similarity services for valid configurations 47ms
✓ tests/unit/services/enhanced-config-validator-integration.test.ts > EnhancedConfigValidator - Integration Tests > similarity service integration > should limit suggestion count when calling similarity services 45ms
✓ tests/unit/services/enhanced-config-validator-integration.test.ts > EnhancedConfigValidator - Integration Tests > error enhancement with suggestions > should enhance resource validation errors with suggestions 44ms
✓ tests/unit/services/enhanced-config-validator-integration.test.ts > EnhancedConfigValidator - Integration Tests > error enhancement with suggestions > should enhance operation validation errors with suggestions 45ms
✓ tests/unit/services/enhanced-config-validator-integration.test.ts > EnhancedConfigValidator - Integration Tests > error enhancement with suggestions > should not enhance errors when no good suggestions are available 55ms
✓ tests/unit/services/enhanced-config-validator-integration.test.ts > EnhancedConfigValidator - Integration Tests > error enhancement with suggestions > should provide multiple operation suggestions when resource is known 49ms
✓ tests/unit/services/enhanced-config-validator-integration.test.ts > EnhancedConfigValidator - Integration Tests > confidence thresholds and filtering > should only use high confidence resource suggestions 47ms
✓ tests/unit/services/enhanced-config-validator-integration.test.ts > EnhancedConfigValidator - Integration Tests > confidence thresholds and filtering > should only use high confidence operation suggestions 44ms
✓ tests/unit/services/enhanced-config-validator-integration.test.ts > EnhancedConfigValidator - Integration Tests > integration with existing validation logic > should work with minimal validation mode 45ms
✓ tests/unit/services/enhanced-config-validator-integration.test.ts > EnhancedConfigValidator - Integration Tests > integration with existing validation logic > should work with strict validation profile 44ms
✓ tests/unit/services/enhanced-config-validator-integration.test.ts > EnhancedConfigValidator - Integration Tests > integration with existing validation logic > should preserve original error properties when enhancing 44ms
✓ tests/integration/database/performance.test.ts > Database Performance Tests > Node Repository Performance > should handle bulk inserts efficiently 175ms
✓ tests/integration/database/performance.test.ts > Database Performance Tests > Node Repository Performance > should search nodes quickly with indexes 284ms
✓ tests/integration/database/performance.test.ts > Database Performance Tests > Node Repository Performance > should handle concurrent reads efficiently 59ms
✓ tests/integration/database/performance.test.ts > Database Performance Tests > Template Repository Performance with FTS5 > should perform FTS5 searches efficiently 1061ms
✓ tests/integration/database/performance.test.ts > Database Performance Tests > Template Repository Performance with FTS5 > should handle complex node type searches efficiently 548ms
✓ tests/integration/database/performance.test.ts > Database Performance Tests > Database Optimization > should benefit from proper indexing 319ms
✓ tests/integration/database/performance.test.ts > Database Performance Tests > Database Optimization > should handle VACUUM operation efficiently 62ms
✓ tests/integration/database/performance.test.ts > Database Performance Tests > Database Optimization > should maintain performance with WAL mode 66ms
✓ tests/integration/database/performance.test.ts > Database Performance Tests > Memory Usage > should handle large result sets without excessive memory 315ms
✓ tests/integration/database/performance.test.ts > Database Performance Tests > Concurrent Write Performance > should handle concurrent writes with transactions 57ms
✓ tests/integration/mcp-protocol/tool-invocation.test.ts > MCP Tool Invocation > Node Discovery Tools > list_nodes > should list nodes with default parameters 152ms
✓ tests/integration/mcp-protocol/tool-invocation.test.ts > MCP Tool Invocation > Node Discovery Tools > list_nodes > should filter nodes by category 116ms
✓ tests/integration/mcp-protocol/tool-invocation.test.ts > MCP Tool Invocation > Node Discovery Tools > list_nodes > should limit results 102ms
✓ tests/integration/mcp-protocol/tool-invocation.test.ts > MCP Tool Invocation > Node Discovery Tools > list_nodes > should filter by package 131ms
✓ tests/integration/mcp-protocol/tool-invocation.test.ts > MCP Tool Invocation > Node Discovery Tools > search_nodes > should search nodes by keyword 107ms
✓ tests/integration/mcp-protocol/tool-invocation.test.ts > MCP Tool Invocation > Node Discovery Tools > search_nodes > should support different search modes 113ms
✓ tests/integration/mcp-protocol/tool-invocation.test.ts > MCP Tool Invocation > Node Discovery Tools > search_nodes > should respect result limit 101ms
✓ tests/integration/mcp-protocol/tool-invocation.test.ts > MCP Tool Invocation > Node Discovery Tools > get_node_info > should get complete node information 109ms
✓ tests/integration/mcp-protocol/tool-invocation.test.ts > MCP Tool Invocation > Node Discovery Tools > get_node_info > should handle non-existent nodes 113ms
✓ tests/integration/mcp-protocol/tool-invocation.test.ts > MCP Tool Invocation > Node Discovery Tools > get_node_info > should handle invalid node type format 109ms
✓ tests/integration/mcp-protocol/tool-invocation.test.ts > MCP Tool Invocation > Node Discovery Tools > get_node_essentials > should return condensed node information 130ms
✓ tests/integration/mcp-protocol/tool-invocation.test.ts > MCP Tool Invocation > Validation Tools > validate_node_operation > should validate valid node configuration 108ms
✓ tests/integration/mcp-protocol/tool-invocation.test.ts > MCP Tool Invocation > Validation Tools > validate_node_operation > should detect missing required fields 109ms
✓ tests/integration/mcp-protocol/tool-invocation.test.ts > MCP Tool Invocation > Validation Tools > validate_node_operation > should support different validation profiles 116ms
✓ tests/integration/mcp-protocol/tool-invocation.test.ts > MCP Tool Invocation > Validation Tools > validate_workflow > should validate complete workflow 111ms
✓ tests/integration/mcp-protocol/tool-invocation.test.ts > MCP Tool Invocation > Validation Tools > validate_workflow > should detect connection errors 113ms
✓ tests/integration/mcp-protocol/tool-invocation.test.ts > MCP Tool Invocation > Validation Tools > validate_workflow > should validate expressions 110ms
✓ tests/integration/mcp-protocol/tool-invocation.test.ts > MCP Tool Invocation > Documentation Tools > tools_documentation > should get quick start guide 124ms
✓ tests/integration/mcp-protocol/tool-invocation.test.ts > MCP Tool Invocation > Documentation Tools > tools_documentation > should get specific tool documentation 103ms
✓ tests/integration/mcp-protocol/tool-invocation.test.ts > MCP Tool Invocation > Documentation Tools > tools_documentation > should get comprehensive documentation 113ms
✓ tests/integration/mcp-protocol/tool-invocation.test.ts > MCP Tool Invocation > Documentation Tools > tools_documentation > should handle invalid topics gracefully 151ms
✓ tests/integration/mcp-protocol/tool-invocation.test.ts > MCP Tool Invocation > AI Tools > list_ai_tools > should list AI-capable nodes 112ms
✓ tests/integration/mcp-protocol/tool-invocation.test.ts > MCP Tool Invocation > AI Tools > get_node_as_tool_info > should provide AI tool usage information 108ms
✓ tests/integration/mcp-protocol/tool-invocation.test.ts > MCP Tool Invocation > Task Templates > list_tasks > should list all available tasks 112ms
✓ tests/integration/mcp-protocol/tool-invocation.test.ts > MCP Tool Invocation > Task Templates > list_tasks > should filter by category 103ms
✓ tests/integration/mcp-protocol/tool-invocation.test.ts > MCP Tool Invocation > Complex Tool Interactions > should handle tool chaining 111ms
✓ tests/integration/mcp-protocol/tool-invocation.test.ts > MCP Tool Invocation > Complex Tool Interactions > should handle parallel tool calls 138ms
✓ tests/integration/mcp-protocol/tool-invocation.test.ts > MCP Tool Invocation > Complex Tool Interactions > should maintain consistency across related tools 111ms
× tests/integration/n8n-api/workflows/validate-workflow.test.ts > Integration: handleValidateWorkflow > Valid Workflow > should validate valid workflow with default profile (runtime) 104ms
→ No response from n8n server
→ No response from n8n server
→ No response from n8n server
× tests/integration/n8n-api/workflows/validate-workflow.test.ts > Integration: handleValidateWorkflow > Valid Workflow > should validate with strict profile 99ms
→ No response from n8n server
→ No response from n8n server
→ No response from n8n server
× tests/integration/n8n-api/workflows/validate-workflow.test.ts > Integration: handleValidateWorkflow > Valid Workflow > should validate with ai-friendly profile 100ms
→ No response from n8n server
→ No response from n8n server
→ No response from n8n server
× tests/integration/n8n-api/workflows/validate-workflow.test.ts > Integration: handleValidateWorkflow > Valid Workflow > should validate with minimal profile 104ms
→ No response from n8n server
→ No response from n8n server
→ No response from n8n server
× tests/integration/n8n-api/workflows/validate-workflow.test.ts > Integration: handleValidateWorkflow > Invalid Workflow Detection > should detect invalid node type 104ms
→ No response from n8n server
→ No response from n8n server
→ No response from n8n server
× tests/integration/n8n-api/workflows/validate-workflow.test.ts > Integration: handleValidateWorkflow > Invalid Workflow Detection > should detect missing required connections 113ms
→ No response from n8n server
→ No response from n8n server
→ No response from n8n server
× tests/integration/n8n-api/workflows/validate-workflow.test.ts > Integration: handleValidateWorkflow > Selective Validation > should validate nodes only (skip connections) 100ms
→ No response from n8n server
→ No response from n8n server
→ No response from n8n server
× tests/integration/n8n-api/workflows/validate-workflow.test.ts > Integration: handleValidateWorkflow > Selective Validation > should validate connections only (skip nodes) 100ms
→ No response from n8n server
→ No response from n8n server
→ No response from n8n server
× tests/integration/n8n-api/workflows/validate-workflow.test.ts > Integration: handleValidateWorkflow > Selective Validation > should validate expressions only 103ms
→ No response from n8n server
→ No response from n8n server
→ No response from n8n server
✓ tests/integration/n8n-api/workflows/validate-workflow.test.ts > Integration: handleValidateWorkflow > Error Handling > should handle non-existent workflow ID 35ms
× tests/integration/n8n-api/workflows/validate-workflow.test.ts > Integration: handleValidateWorkflow > Error Handling > should handle invalid profile parameter 101ms
→ No response from n8n server
→ No response from n8n server
→ No response from n8n server
× tests/integration/n8n-api/workflows/validate-workflow.test.ts > Integration: handleValidateWorkflow > Response Format > should return complete validation response structure 100ms
→ No response from n8n server
→ No response from n8n server
→ No response from n8n server
✓ tests/unit/services/task-templates.test.ts > TaskTemplates > getTaskTemplate > should return template for get_api_data task 44ms
✓ tests/unit/services/task-templates.test.ts > TaskTemplates > getTaskTemplate > should return template for webhook tasks 45ms
✓ tests/unit/services/task-templates.test.ts > TaskTemplates > getTaskTemplate > should return template for database tasks 44ms
✓ tests/unit/services/task-templates.test.ts > TaskTemplates > getTaskTemplate > should return undefined for unknown task 45ms
✓ tests/unit/services/task-templates.test.ts > TaskTemplates > getTaskTemplate > should have getTemplate alias working 44ms
✓ tests/unit/services/task-templates.test.ts > TaskTemplates > template structure > should have all required fields in templates 49ms
✓ tests/unit/services/task-templates.test.ts > TaskTemplates > template structure > should have proper user must provide structure 45ms
✓ tests/unit/services/task-templates.test.ts > TaskTemplates > template structure > should have optional enhancements where applicable 45ms
✓ tests/unit/services/task-templates.test.ts > TaskTemplates > template structure > should have notes for complex templates 45ms
✓ tests/unit/services/task-templates.test.ts > TaskTemplates > special templates > should have process_webhook_data template with detailed code 44ms
✓ tests/unit/services/task-templates.test.ts > TaskTemplates > special templates > should have AI agent workflow template 44ms
✓ tests/unit/services/task-templates.test.ts > TaskTemplates > special templates > should have error handling pattern templates 47ms
✓ tests/unit/services/task-templates.test.ts > TaskTemplates > special templates > should have AI tool templates 43ms
✓ tests/unit/services/task-templates.test.ts > TaskTemplates > getAllTasks > should return all task names 45ms
✓ tests/unit/services/task-templates.test.ts > TaskTemplates > getTasksForNode > should return tasks for HTTP Request node 44ms
✓ tests/unit/services/task-templates.test.ts > TaskTemplates > getTasksForNode > should return tasks for Code node 44ms
✓ tests/unit/services/task-templates.test.ts > TaskTemplates > getTasksForNode > should return tasks for Webhook node 46ms
✓ tests/unit/services/task-templates.test.ts > TaskTemplates > getTasksForNode > should return empty array for unknown node 47ms
✓ tests/unit/services/task-templates.test.ts > TaskTemplates > searchTasks > should find tasks by name 44ms
✓ tests/unit/services/task-templates.test.ts > TaskTemplates > searchTasks > should find tasks by description 46ms
✓ tests/unit/services/task-templates.test.ts > TaskTemplates > searchTasks > should find tasks by node type 45ms
✓ tests/unit/services/task-templates.test.ts > TaskTemplates > searchTasks > should be case insensitive 44ms
✓ tests/unit/services/task-templates.test.ts > TaskTemplates > searchTasks > should return empty array for no matches 44ms
✓ tests/unit/services/task-templates.test.ts > TaskTemplates > getTaskCategories > should return all task categories 44ms
✓ tests/unit/services/task-templates.test.ts > TaskTemplates > getTaskCategories > should have tasks assigned to categories 50ms
✓ tests/unit/services/task-templates.test.ts > TaskTemplates > getTaskCategories > should have tasks in multiple categories where appropriate 45ms
✓ tests/unit/services/task-templates.test.ts > TaskTemplates > error handling templates > should have proper retry configuration 44ms
✓ tests/unit/services/task-templates.test.ts > TaskTemplates > error handling templates > should have database transaction safety template 45ms
✓ tests/unit/services/task-templates.test.ts > TaskTemplates > error handling templates > should have AI rate limit handling 45ms
✓ tests/unit/services/task-templates.test.ts > TaskTemplates > code node templates > should have aggregate data template 44ms
✓ tests/unit/services/task-templates.test.ts > TaskTemplates > code node templates > should have batch processing template 47ms
✓ tests/unit/services/task-templates.test.ts > TaskTemplates > code node templates > should have error safe transform template 44ms
✓ tests/unit/services/task-templates.test.ts > TaskTemplates > code node templates > should have async processing template 44ms
✓ tests/unit/services/task-templates.test.ts > TaskTemplates > code node templates > should have Python data analysis template 44ms
✓ tests/unit/services/task-templates.test.ts > TaskTemplates > template configurations > should have proper error handling defaults 44ms
✓ tests/unit/services/task-templates.test.ts > TaskTemplates > template configurations > should have appropriate retry configurations 44ms
× tests/integration/n8n-api/workflows/update-workflow.test.ts > Integration: handleUpdateWorkflow > Full Workflow Replacement > should replace entire workflow with new nodes and connections 104ms
→ No response from n8n server
→ No response from n8n server
→ No response from n8n server
× tests/integration/n8n-api/workflows/update-workflow.test.ts > Integration: handleUpdateWorkflow > Update Nodes > should update workflow nodes while preserving other properties 100ms
→ No response from n8n server
→ No response from n8n server
→ No response from n8n server
× tests/integration/n8n-api/workflows/update-workflow.test.ts > Integration: handleUpdateWorkflow > Update Settings > should update workflow settings without affecting nodes 99ms
→ No response from n8n server
→ No response from n8n server
→ No response from n8n server
× tests/integration/n8n-api/workflows/update-workflow.test.ts > Integration: handleUpdateWorkflow > Validation Errors > should return error for invalid node types 103ms
→ No response from n8n server
→ No response from n8n server
→ No response from n8n server
✓ tests/integration/n8n-api/workflows/update-workflow.test.ts > Integration: handleUpdateWorkflow > Validation Errors > should return error for non-existent workflow ID 34ms
× tests/integration/n8n-api/workflows/update-workflow.test.ts > Integration: handleUpdateWorkflow > Update Name > should update workflow name without affecting structure 98ms
→ No response from n8n server
→ No response from n8n server
→ No response from n8n server
× tests/integration/n8n-api/workflows/update-workflow.test.ts > Integration: handleUpdateWorkflow > Multiple Properties > should update name and settings together 100ms
→ No response from n8n server
→ No response from n8n server
→ No response from n8n server
✓ tests/unit/services/expression-validator-edge-cases.test.ts > ExpressionValidator - Edge Cases > Null and Undefined Handling > should handle null expression gracefully 44ms
✓ tests/unit/services/expression-validator-edge-cases.test.ts > ExpressionValidator - Edge Cases > Null and Undefined Handling > should handle undefined expression gracefully 45ms
✓ tests/unit/services/expression-validator-edge-cases.test.ts > ExpressionValidator - Edge Cases > Null and Undefined Handling > should handle null context gracefully 46ms
✓ tests/unit/services/expression-validator-edge-cases.test.ts > ExpressionValidator - Edge Cases > Null and Undefined Handling > should handle undefined context gracefully 44ms
✓ tests/unit/services/expression-validator-edge-cases.test.ts > ExpressionValidator - Edge Cases > Boundary Value Testing > should handle empty string expression 44ms
✓ tests/unit/services/expression-validator-edge-cases.test.ts > ExpressionValidator - Edge Cases > Boundary Value Testing > should handle extremely long expressions 48ms
✓ tests/unit/services/expression-validator-edge-cases.test.ts > ExpressionValidator - Edge Cases > Boundary Value Testing > should handle deeply nested property access 44ms
✓ tests/unit/services/expression-validator-edge-cases.test.ts > ExpressionValidator - Edge Cases > Boundary Value Testing > should handle many different variables in one expression 45ms
✓ tests/unit/services/expression-validator-edge-cases.test.ts > ExpressionValidator - Edge Cases > Invalid Syntax Handling > should detect unclosed expressions 50ms
✓ tests/unit/services/expression-validator-edge-cases.test.ts > ExpressionValidator - Edge Cases > Invalid Syntax Handling > should detect nested expressions 47ms
✓ tests/unit/services/expression-validator-edge-cases.test.ts > ExpressionValidator - Edge Cases > Invalid Syntax Handling > should detect empty expressions 52ms
✓ tests/unit/services/expression-validator-edge-cases.test.ts > ExpressionValidator - Edge Cases > Invalid Syntax Handling > should handle malformed node references 58ms
✓ tests/unit/services/expression-validator-edge-cases.test.ts > ExpressionValidator - Edge Cases > Special Characters and Unicode > should handle special characters in node names 48ms
✓ tests/unit/services/expression-validator-edge-cases.test.ts > ExpressionValidator - Edge Cases > Special Characters and Unicode > should handle Unicode in property names 44ms
✓ tests/unit/services/expression-validator-edge-cases.test.ts > ExpressionValidator - Edge Cases > Context Validation > should warn about $input when no input data available 45ms
✓ tests/unit/services/expression-validator-edge-cases.test.ts > ExpressionValidator - Edge Cases > Context Validation > should handle references to non-existent nodes 45ms
✓ tests/unit/services/expression-validator-edge-cases.test.ts > ExpressionValidator - Edge Cases > Context Validation > should validate $items function references 45ms
✓ tests/unit/services/expression-validator-edge-cases.test.ts > ExpressionValidator - Edge Cases > Complex Expression Patterns > should handle JavaScript operations in expressions 44ms
✓ tests/unit/services/expression-validator-edge-cases.test.ts > ExpressionValidator - Edge Cases > Complex Expression Patterns > should handle array access patterns 47ms
✓ tests/unit/services/expression-validator-edge-cases.test.ts > ExpressionValidator - Edge Cases > validateNodeExpressions > should validate all expressions in node parameters 47ms
✓ tests/unit/services/expression-validator-edge-cases.test.ts > ExpressionValidator - Edge Cases > validateNodeExpressions > should handle null/undefined in parameters 48ms
✓ tests/unit/services/expression-validator-edge-cases.test.ts > ExpressionValidator - Edge Cases > validateNodeExpressions > should handle circular references in parameters 45ms
✓ tests/unit/services/expression-validator-edge-cases.test.ts > ExpressionValidator - Edge Cases > validateNodeExpressions > should aggregate errors from multiple expressions 47ms
✓ tests/unit/services/expression-validator-edge-cases.test.ts > ExpressionValidator - Edge Cases > Performance Edge Cases > should handle recursive parameter structures efficiently 45ms
✓ tests/unit/services/expression-validator-edge-cases.test.ts > ExpressionValidator - Edge Cases > Performance Edge Cases > should handle large arrays of expressions 56ms
✓ tests/unit/services/expression-validator-edge-cases.test.ts > ExpressionValidator - Edge Cases > Error Message Quality > should provide helpful error messages 43ms
✓ tests/integration/n8n-api/executions/trigger-webhook.test.ts > Integration: handleTriggerWebhookWorkflow > GET Method > should trigger GET webhook without data 196ms
✓ tests/integration/n8n-api/executions/trigger-webhook.test.ts > Integration: handleTriggerWebhookWorkflow > GET Method > should trigger GET webhook with query parameters 108ms
✓ tests/integration/n8n-api/executions/trigger-webhook.test.ts > Integration: handleTriggerWebhookWorkflow > GET Method > should trigger GET webhook with custom headers 102ms
✓ tests/integration/n8n-api/executions/trigger-webhook.test.ts > Integration: handleTriggerWebhookWorkflow > GET Method > should trigger GET webhook and wait for response 107ms
✓ tests/integration/n8n-api/executions/trigger-webhook.test.ts > Integration: handleTriggerWebhookWorkflow > POST Method > should trigger POST webhook with JSON data 103ms
✓ tests/integration/n8n-api/executions/trigger-webhook.test.ts > Integration: handleTriggerWebhookWorkflow > POST Method > should trigger POST webhook without data 101ms
✓ tests/integration/n8n-api/executions/trigger-webhook.test.ts > Integration: handleTriggerWebhookWorkflow > POST Method > should trigger POST webhook with custom headers 101ms
✓ tests/integration/n8n-api/executions/trigger-webhook.test.ts > Integration: handleTriggerWebhookWorkflow > POST Method > should trigger POST webhook without waiting for response 99ms
✓ tests/integration/n8n-api/executions/trigger-webhook.test.ts > Integration: handleTriggerWebhookWorkflow > PUT Method > should trigger PUT webhook with update data 111ms
✓ tests/integration/n8n-api/executions/trigger-webhook.test.ts > Integration: handleTriggerWebhookWorkflow > PUT Method > should trigger PUT webhook with custom headers 103ms
✓ tests/integration/n8n-api/executions/trigger-webhook.test.ts > Integration: handleTriggerWebhookWorkflow > PUT Method > should trigger PUT webhook without data 105ms
✓ tests/integration/n8n-api/executions/trigger-webhook.test.ts > Integration: handleTriggerWebhookWorkflow > DELETE Method > should trigger DELETE webhook with query parameters 104ms
✓ tests/integration/n8n-api/executions/trigger-webhook.test.ts > Integration: handleTriggerWebhookWorkflow > DELETE Method > should trigger DELETE webhook with custom headers 103ms
✓ tests/integration/n8n-api/executions/trigger-webhook.test.ts > Integration: handleTriggerWebhookWorkflow > DELETE Method > should trigger DELETE webhook without parameters 101ms
✓ tests/integration/n8n-api/executions/trigger-webhook.test.ts > Integration: handleTriggerWebhookWorkflow > Error Handling > should handle invalid webhook URL 38ms
✓ tests/integration/n8n-api/executions/trigger-webhook.test.ts > Integration: handleTriggerWebhookWorkflow > Error Handling > should handle malformed webhook URL 32ms
✓ tests/integration/n8n-api/executions/trigger-webhook.test.ts > Integration: handleTriggerWebhookWorkflow > Error Handling > should handle missing webhook URL 32ms
✓ tests/integration/n8n-api/executions/trigger-webhook.test.ts > Integration: handleTriggerWebhookWorkflow > Error Handling > should handle invalid HTTP method 29ms
✓ tests/integration/n8n-api/executions/trigger-webhook.test.ts > Integration: handleTriggerWebhookWorkflow > Default Method Behavior > should default to POST method when not specified 104ms
✓ tests/integration/n8n-api/executions/trigger-webhook.test.ts > Integration: handleTriggerWebhookWorkflow > Response Format > should return complete webhook response structure 103ms
✓ tests/unit/services/property-dependencies.test.ts > PropertyDependencies > analyze > should analyze simple property dependencies 46ms
✓ tests/unit/services/property-dependencies.test.ts > PropertyDependencies > analyze > should handle hide conditions 45ms
✓ tests/unit/services/property-dependencies.test.ts > PropertyDependencies > analyze > should handle multiple dependencies 45ms
✓ tests/unit/services/property-dependencies.test.ts > PropertyDependencies > analyze > should build dependency graph 46ms
✓ tests/unit/services/property-dependencies.test.ts > PropertyDependencies > analyze > should identify properties that enable others 46ms
✓ tests/unit/services/property-dependencies.test.ts > PropertyDependencies > analyze > should add notes for collection types 48ms
✓ tests/unit/services/property-dependencies.test.ts > PropertyDependencies > analyze > should generate helpful descriptions 44ms
✓ tests/unit/services/property-dependencies.test.ts > PropertyDependencies > analyze > should handle empty properties 46ms
✓ tests/unit/services/property-dependencies.test.ts > PropertyDependencies > suggestions > should suggest key properties to configure first 44ms
✓ tests/unit/services/property-dependencies.test.ts > PropertyDependencies > suggestions > should detect circular dependencies 45ms
✓ tests/unit/services/property-dependencies.test.ts > PropertyDependencies > suggestions > should note complex dependencies 44ms
✓ tests/unit/services/property-dependencies.test.ts > PropertyDependencies > getVisibilityImpact > should determine visible properties for POST method 50ms
✓ tests/unit/services/property-dependencies.test.ts > PropertyDependencies > getVisibilityImpact > should determine hidden properties for GET method 45ms
✓ tests/unit/services/property-dependencies.test.ts > PropertyDependencies > getVisibilityImpact > should provide reasons for visibility 46ms
✓ tests/unit/services/property-dependencies.test.ts > PropertyDependencies > getVisibilityImpact > should handle partial dependencies 44ms
✓ tests/unit/services/property-dependencies.test.ts > PropertyDependencies > getVisibilityImpact > should handle properties without display options 43ms
✓ tests/unit/services/property-dependencies.test.ts > PropertyDependencies > getVisibilityImpact > should handle empty configuration 45ms
✓ tests/unit/services/property-dependencies.test.ts > PropertyDependencies > getVisibilityImpact > should handle array values in conditions 45ms
✓ tests/unit/services/property-dependencies.test.ts > PropertyDependencies > edge cases > should handle properties with both show and hide conditions 48ms
✓ tests/unit/services/property-dependencies.test.ts > PropertyDependencies > edge cases > should handle non-array values in display conditions 44ms
✓ tests/unit/services/property-dependencies.test.ts > PropertyDependencies > edge cases > should handle deeply nested property references 45ms
× tests/integration/n8n-api/workflows/create-workflow.test.ts > Integration: handleCreateWorkflow > P0: Node Type Format Bug Fix > should create workflow with webhook node using FULL node type format 109ms
→ expected false to be true // Object.is equality
→ expected false to be true // Object.is equality
→ expected false to be true // Object.is equality
× tests/integration/n8n-api/workflows/create-workflow.test.ts > Integration: handleCreateWorkflow > P1: Base n8n Nodes > should create workflow with HTTP Request node 101ms
→ expected false to be true // Object.is equality
→ expected false to be true // Object.is equality
→ expected false to be true // Object.is equality
× tests/integration/n8n-api/workflows/create-workflow.test.ts > Integration: handleCreateWorkflow > P1: Base n8n Nodes > should create workflow with langchain agent node 105ms
→ expected false to be true // Object.is equality
→ expected false to be true // Object.is equality
→ expected false to be true // Object.is equality
× tests/integration/n8n-api/workflows/create-workflow.test.ts > Integration: handleCreateWorkflow > P1: Base n8n Nodes > should create complex multi-node workflow 105ms
→ expected false to be true // Object.is equality
→ expected false to be true // Object.is equality
→ expected false to be true // Object.is equality
× tests/integration/n8n-api/workflows/create-workflow.test.ts > Integration: handleCreateWorkflow > P2: Advanced Workflow Features > should create workflow with complex connections and branching 115ms
→ expected false to be true // Object.is equality
→ expected false to be true // Object.is equality
→ expected false to be true // Object.is equality
× tests/integration/n8n-api/workflows/create-workflow.test.ts > Integration: handleCreateWorkflow > P2: Advanced Workflow Features > should create workflow with custom settings 103ms
→ expected false to be true // Object.is equality
→ expected false to be true // Object.is equality
→ expected false to be true // Object.is equality
× tests/integration/n8n-api/workflows/create-workflow.test.ts > Integration: handleCreateWorkflow > P2: Advanced Workflow Features > should create workflow with n8n expressions 101ms
→ expected false to be true // Object.is equality
→ expected false to be true // Object.is equality
→ expected false to be true // Object.is equality
× tests/integration/n8n-api/workflows/create-workflow.test.ts > Integration: handleCreateWorkflow > P2: Advanced Workflow Features > should create workflow with error handling configuration 101ms
→ expected false to be true // Object.is equality
→ expected false to be true // Object.is equality
→ expected false to be true // Object.is equality
✓ tests/integration/n8n-api/workflows/create-workflow.test.ts > Integration: handleCreateWorkflow > Error Scenarios > should reject workflow with invalid node type (MCP validation) 34ms
✓ tests/integration/n8n-api/workflows/create-workflow.test.ts > Integration: handleCreateWorkflow > Error Scenarios > should reject workflow with missing required node parameters (MCP validation) 34ms
✓ tests/integration/n8n-api/workflows/create-workflow.test.ts > Integration: handleCreateWorkflow > Error Scenarios > should reject workflow with duplicate node names (MCP validation) 29ms
✓ tests/integration/n8n-api/workflows/create-workflow.test.ts > Integration: handleCreateWorkflow > Error Scenarios > should reject workflow with invalid connection references (MCP validation) 33ms
✓ tests/integration/n8n-api/workflows/create-workflow.test.ts > Integration: handleCreateWorkflow > Edge Cases > should reject single-node non-webhook workflow (MCP validation) 32ms
✓ tests/integration/n8n-api/workflows/create-workflow.test.ts > Integration: handleCreateWorkflow > Edge Cases > should reject single-node non-trigger workflow (MCP validation) 32ms
✓ tests/integration/n8n-api/workflows/create-workflow.test.ts > Integration: handleCreateWorkflow > Edge Cases > should reject single-node workflow without settings (MCP validation) 32ms
✓ tests/integration/database/node-repository.test.ts > NodeRepository Integration Tests > saveNode > should save single node successfully 31ms
✓ tests/integration/database/node-repository.test.ts > NodeRepository Integration Tests > saveNode > should update existing nodes 34ms
✓ tests/integration/database/node-repository.test.ts > NodeRepository Integration Tests > saveNode > should handle nodes with complex properties 34ms
✓ tests/integration/database/node-repository.test.ts > NodeRepository Integration Tests > saveNode > should handle very large nodes 34ms
✓ tests/integration/database/node-repository.test.ts > NodeRepository Integration Tests > getNode > should retrieve node by type 33ms
✓ tests/integration/database/node-repository.test.ts > NodeRepository Integration Tests > getNode > should return null for non-existent node 30ms
✓ tests/integration/database/node-repository.test.ts > NodeRepository Integration Tests > getNode > should handle special characters in node types 33ms
✓ tests/integration/database/node-repository.test.ts > NodeRepository Integration Tests > getAllNodes > should return empty array when no nodes 42ms
✓ tests/integration/database/node-repository.test.ts > NodeRepository Integration Tests > getAllNodes > should return all nodes with limit 47ms
✓ tests/integration/database/node-repository.test.ts > NodeRepository Integration Tests > getAllNodes > should return all nodes without limit 35ms
✓ tests/integration/database/node-repository.test.ts > NodeRepository Integration Tests > getAllNodes > should handle very large result sets efficiently 61ms
✓ tests/integration/database/node-repository.test.ts > NodeRepository Integration Tests > getNodesByPackage > should filter nodes by package 34ms
✓ tests/integration/database/node-repository.test.ts > NodeRepository Integration Tests > getNodesByPackage > should return empty array for non-existent package 31ms
✓ tests/integration/database/node-repository.test.ts > NodeRepository Integration Tests > getNodesByCategory > should filter nodes by category 33ms
✓ tests/integration/database/node-repository.test.ts > NodeRepository Integration Tests > searchNodes > should search by node type 32ms
✓ tests/integration/database/node-repository.test.ts > NodeRepository Integration Tests > searchNodes > should search by display name 32ms
✓ tests/integration/database/node-repository.test.ts > NodeRepository Integration Tests > searchNodes > should search by description 32ms
✓ tests/integration/database/node-repository.test.ts > NodeRepository Integration Tests > searchNodes > should handle OR mode (default) 31ms
✓ tests/integration/database/node-repository.test.ts > NodeRepository Integration Tests > searchNodes > should handle AND mode 33ms
✓ tests/integration/database/node-repository.test.ts > NodeRepository Integration Tests > searchNodes > should handle FUZZY mode 34ms
✓ tests/integration/database/node-repository.test.ts > NodeRepository Integration Tests > searchNodes > should handle case-insensitive search 34ms
✓ tests/integration/database/node-repository.test.ts > NodeRepository Integration Tests > searchNodes > should return empty array for no matches 33ms
✓ tests/integration/database/node-repository.test.ts > NodeRepository Integration Tests > searchNodes > should respect limit parameter 30ms
✓ tests/integration/database/node-repository.test.ts > NodeRepository Integration Tests > getAITools > should return only AI tool nodes 32ms
✓ tests/integration/database/node-repository.test.ts > NodeRepository Integration Tests > getNodeCount > should return correct node count 32ms
✓ tests/integration/database/node-repository.test.ts > NodeRepository Integration Tests > searchNodeProperties > should find properties by name 33ms
✓ tests/integration/database/node-repository.test.ts > NodeRepository Integration Tests > searchNodeProperties > should find nested properties 32ms
✓ tests/integration/database/node-repository.test.ts > NodeRepository Integration Tests > searchNodeProperties > should return empty array for non-existent node 30ms
✓ tests/integration/database/node-repository.test.ts > NodeRepository Integration Tests > Transaction handling > should handle errors gracefully 33ms
✓ tests/integration/database/node-repository.test.ts > NodeRepository Integration Tests > Transaction handling > should handle concurrent saves 33ms
✓ tests/integration/database/node-repository.test.ts > NodeRepository Integration Tests > Performance characteristics > should handle bulk operations efficiently 52ms
✓ tests/integration/mcp-protocol/error-handling.test.ts > MCP Error Handling > JSON-RPC Error Codes > should handle invalid request (parse error) 120ms
✓ tests/integration/mcp-protocol/error-handling.test.ts > MCP Error Handling > JSON-RPC Error Codes > should handle method not found 112ms
✓ tests/integration/mcp-protocol/error-handling.test.ts > MCP Error Handling > JSON-RPC Error Codes > should handle invalid params 108ms
✓ tests/integration/mcp-protocol/error-handling.test.ts > MCP Error Handling > JSON-RPC Error Codes > should handle internal errors gracefully 153ms
✓ tests/integration/mcp-protocol/error-handling.test.ts > MCP Error Handling > Tool-Specific Errors > Node Discovery Errors > should handle invalid category filter 107ms
✓ tests/integration/mcp-protocol/error-handling.test.ts > MCP Error Handling > Tool-Specific Errors > Node Discovery Errors > should handle invalid search mode 108ms
✓ tests/integration/mcp-protocol/error-handling.test.ts > MCP Error Handling > Tool-Specific Errors > Node Discovery Errors > should handle empty search query 119ms
✓ tests/integration/mcp-protocol/error-handling.test.ts > MCP Error Handling > Tool-Specific Errors > Node Discovery Errors > should handle non-existent node types 110ms
✓ tests/integration/mcp-protocol/error-handling.test.ts > MCP Error Handling > Tool-Specific Errors > Validation Errors > should handle invalid validation profile 109ms
✓ tests/integration/mcp-protocol/error-handling.test.ts > MCP Error Handling > Tool-Specific Errors > Validation Errors > should handle malformed workflow structure 111ms
✓ tests/integration/mcp-protocol/error-handling.test.ts > MCP Error Handling > Tool-Specific Errors > Validation Errors > should handle circular workflow references 109ms
✓ tests/integration/mcp-protocol/error-handling.test.ts > MCP Error Handling > Tool-Specific Errors > Documentation Errors > should handle non-existent documentation topics 110ms
✓ tests/integration/mcp-protocol/error-handling.test.ts > MCP Error Handling > Tool-Specific Errors > Documentation Errors > should handle invalid depth parameter 117ms
✓ tests/integration/mcp-protocol/error-handling.test.ts > MCP Error Handling > Large Payload Handling > should handle large node info requests 121ms
✓ tests/integration/mcp-protocol/error-handling.test.ts > MCP Error Handling > Large Payload Handling > should handle large workflow validation 120ms
✓ tests/integration/mcp-protocol/error-handling.test.ts > MCP Error Handling > Large Payload Handling > should handle many concurrent requests 124ms
✓ tests/integration/mcp-protocol/error-handling.test.ts > MCP Error Handling > Invalid JSON Handling > should handle invalid JSON in tool parameters 116ms
✓ tests/integration/mcp-protocol/error-handling.test.ts > MCP Error Handling > Invalid JSON Handling > should handle malformed workflow JSON 156ms
✓ tests/integration/mcp-protocol/error-handling.test.ts > MCP Error Handling > Timeout Scenarios > should handle rapid sequential requests 358ms
✓ tests/integration/mcp-protocol/error-handling.test.ts > MCP Error Handling > Timeout Scenarios > should handle long-running operations 111ms
✓ tests/integration/mcp-protocol/error-handling.test.ts > MCP Error Handling > Memory Pressure > should handle multiple large responses 111ms
✓ tests/integration/mcp-protocol/error-handling.test.ts > MCP Error Handling > Memory Pressure > should handle workflow with many nodes 110ms
✓ tests/integration/mcp-protocol/error-handling.test.ts > MCP Error Handling > Error Recovery > should continue working after errors 110ms
✓ tests/integration/mcp-protocol/error-handling.test.ts > MCP Error Handling > Error Recovery > should handle mixed success and failure 121ms
✓ tests/integration/mcp-protocol/error-handling.test.ts > MCP Error Handling > Edge Cases > should handle empty responses gracefully 106ms
✓ tests/integration/mcp-protocol/error-handling.test.ts > MCP Error Handling > Edge Cases > should handle special characters in parameters 107ms
✓ tests/integration/mcp-protocol/error-handling.test.ts > MCP Error Handling > Edge Cases > should handle unicode in parameters 108ms
✓ tests/integration/mcp-protocol/error-handling.test.ts > MCP Error Handling > Edge Cases > should handle null and undefined gracefully 133ms
✓ tests/integration/mcp-protocol/error-handling.test.ts > MCP Error Handling > Error Message Quality > should provide helpful error messages 111ms
✓ tests/integration/mcp-protocol/error-handling.test.ts > MCP Error Handling > Error Message Quality > should indicate missing required parameters 107ms
✓ tests/integration/mcp-protocol/error-handling.test.ts > MCP Error Handling > Error Message Quality > should provide context for validation errors 112ms
✓ tests/integration/mcp-protocol/workflow-error-validation.test.ts > MCP Workflow Error Output Validation Integration > validate_workflow tool - Error Output Configuration > should detect incorrect error output configuration via MCP 123ms
✓ tests/integration/mcp-protocol/workflow-error-validation.test.ts > MCP Workflow Error Output Validation Integration > validate_workflow tool - Error Output Configuration > should validate correct error output configuration via MCP 117ms
✓ tests/integration/mcp-protocol/workflow-error-validation.test.ts > MCP Workflow Error Output Validation Integration > validate_workflow tool - Error Output Configuration > should detect onError and connection mismatches via MCP 113ms
✓ tests/integration/mcp-protocol/workflow-error-validation.test.ts > MCP Workflow Error Output Validation Integration > validate_workflow tool - Error Output Configuration > should handle large workflows with complex error patterns via MCP 135ms
✓ tests/integration/mcp-protocol/workflow-error-validation.test.ts > MCP Workflow Error Output Validation Integration > validate_workflow tool - Error Output Configuration > should handle edge cases gracefully via MCP 109ms
✓ tests/integration/mcp-protocol/workflow-error-validation.test.ts > MCP Workflow Error Output Validation Integration > validate_workflow tool - Error Output Configuration > should validate with different validation profiles via MCP 109ms
✓ tests/integration/mcp-protocol/workflow-error-validation.test.ts > MCP Workflow Error Output Validation Integration > Error Message Format Consistency > should format error messages consistently across different scenarios 111ms
✓ tests/unit/__mocks__/n8n-nodes-base.test.ts > n8n-nodes-base mock > getNodeTypes > should return node types registry 32ms
✓ tests/unit/__mocks__/n8n-nodes-base.test.ts > n8n-nodes-base mock > getNodeTypes > should retrieve webhook node 30ms
✓ tests/unit/__mocks__/n8n-nodes-base.test.ts > n8n-nodes-base mock > getNodeTypes > should retrieve httpRequest node 33ms
✓ tests/unit/__mocks__/n8n-nodes-base.test.ts > n8n-nodes-base mock > getNodeTypes > should retrieve slack node 33ms
✓ tests/unit/__mocks__/n8n-nodes-base.test.ts > n8n-nodes-base mock > node execution > should execute webhook node 32ms
✓ tests/unit/__mocks__/n8n-nodes-base.test.ts > n8n-nodes-base mock > node execution > should execute httpRequest node 33ms
✓ tests/unit/__mocks__/n8n-nodes-base.test.ts > n8n-nodes-base mock > mockNodeBehavior > should override node execution behavior 30ms
✓ tests/unit/__mocks__/n8n-nodes-base.test.ts > n8n-nodes-base mock > mockNodeBehavior > should override node description 32ms
✓ tests/unit/__mocks__/n8n-nodes-base.test.ts > n8n-nodes-base mock > registerMockNode > should register custom node 32ms
✓ tests/unit/__mocks__/n8n-nodes-base.test.ts > n8n-nodes-base mock > conditional nodes > should execute if node with two outputs 32ms
✓ tests/unit/__mocks__/n8n-nodes-base.test.ts > n8n-nodes-base mock > conditional nodes > should execute switch node with multiple outputs 32ms
✓ tests/unit/services/enhanced-config-validator-operations.test.ts > EnhancedConfigValidator - Operation and Resource Validation > Invalid Operations > should detect invalid operation "listFiles" for Google Drive 36ms
✓ tests/unit/services/enhanced-config-validator-operations.test.ts > EnhancedConfigValidator - Operation and Resource Validation > Invalid Operations > should provide suggestions for typos in operations 31ms
✓ tests/unit/services/enhanced-config-validator-operations.test.ts > EnhancedConfigValidator - Operation and Resource Validation > Invalid Operations > should list valid operations for the resource 33ms
✓ tests/unit/services/enhanced-config-validator-operations.test.ts > EnhancedConfigValidator - Operation and Resource Validation > Invalid Resources > should detect plural resource "files" and suggest singular 34ms
✓ tests/unit/services/enhanced-config-validator-operations.test.ts > EnhancedConfigValidator - Operation and Resource Validation > Invalid Resources > should suggest similar resources for typos 33ms
✓ tests/unit/services/enhanced-config-validator-operations.test.ts > EnhancedConfigValidator - Operation and Resource Validation > Invalid Resources > should list valid resources when no match found 33ms
✓ tests/unit/services/enhanced-config-validator-operations.test.ts > EnhancedConfigValidator - Operation and Resource Validation > Combined Resource and Operation Validation > should validate both resource and operation together 31ms
✓ tests/unit/services/enhanced-config-validator-operations.test.ts > EnhancedConfigValidator - Operation and Resource Validation > Slack Node Validation > should suggest "send" instead of "sendMessage" 34ms
✓ tests/unit/services/enhanced-config-validator-operations.test.ts > EnhancedConfigValidator - Operation and Resource Validation > Slack Node Validation > should suggest singular "channel" instead of "channels" 34ms
✓ tests/unit/services/enhanced-config-validator-operations.test.ts > EnhancedConfigValidator - Operation and Resource Validation > Valid Configurations > should accept valid Google Drive configuration 36ms
✓ tests/unit/services/enhanced-config-validator-operations.test.ts > EnhancedConfigValidator - Operation and Resource Validation > Valid Configurations > should accept valid Slack configuration 37ms
✓ tests/integration/mcp/template-examples-e2e.test.ts > Template Examples E2E Integration > Querying Examples Directly > should fetch top 2 examples for webhook node 32ms
✓ tests/integration/mcp/template-examples-e2e.test.ts > Template Examples E2E Integration > Querying Examples Directly > should fetch top 3 examples with metadata for HTTP request node 38ms
✓ tests/integration/mcp/template-examples-e2e.test.ts > Template Examples E2E Integration > Example Data Structure Validation > should have valid JSON in parameters_json 37ms
✓ tests/integration/mcp/template-examples-e2e.test.ts > Template Examples E2E Integration > Example Data Structure Validation > should have valid JSON in use_cases 36ms
✓ tests/integration/mcp/template-examples-e2e.test.ts > Template Examples E2E Integration > Example Data Structure Validation > should have credentials_json when has_credentials is 1 35ms
✓ tests/integration/mcp/template-examples-e2e.test.ts > Template Examples E2E Integration > Ranked View Functionality > should return only top 5 ranked configs per node type from view 32ms
✓ tests/integration/mcp/template-examples-e2e.test.ts > Template Examples E2E Integration > Performance with Real-World Data Volume > should query specific node type examples quickly 42ms
✓ tests/integration/mcp/template-examples-e2e.test.ts > Template Examples E2E Integration > Performance with Real-World Data Volume > should filter by complexity efficiently 48ms
✓ tests/integration/mcp/template-examples-e2e.test.ts > Template Examples E2E Integration > Edge Cases > should handle node types with no configs 39ms
✓ tests/integration/mcp/template-examples-e2e.test.ts > Template Examples E2E Integration > Edge Cases > should handle very long parameters_json 63ms
✓ tests/integration/mcp/template-examples-e2e.test.ts > Template Examples E2E Integration > Edge Cases > should handle special characters in parameters 42ms
✓ tests/integration/mcp/template-examples-e2e.test.ts > Template Examples E2E Integration > Data Integrity > should maintain referential integrity with templates table 41ms
✓ tests/integration/mcp/template-examples-e2e.test.ts > Template Examples E2E Integration > Data Integrity > should cascade delete configs when template is deleted 42ms
✓ tests/unit/mcp/tools.test.ts > n8nDocumentationToolsFinal > Tool Structure Validation > should have all required properties for each tool 35ms
✓ tests/unit/mcp/tools.test.ts > n8nDocumentationToolsFinal > Tool Structure Validation > should have unique tool names 33ms
✓ tests/unit/mcp/tools.test.ts > n8nDocumentationToolsFinal > Tool Structure Validation > should have valid JSON Schema for all inputSchemas 39ms
✓ tests/unit/mcp/tools.test.ts > n8nDocumentationToolsFinal > Individual Tool Validation > tools_documentation > should exist 39ms
✓ tests/unit/mcp/tools.test.ts > n8nDocumentationToolsFinal > Individual Tool Validation > tools_documentation > should have correct schema 34ms
✓ tests/unit/mcp/tools.test.ts > n8nDocumentationToolsFinal > Individual Tool Validation > tools_documentation > should have helpful description 32ms
✓ tests/unit/mcp/tools.test.ts > n8nDocumentationToolsFinal > Individual Tool Validation > list_nodes > should exist 33ms
✓ tests/unit/mcp/tools.test.ts > n8nDocumentationToolsFinal > Individual Tool Validation > list_nodes > should have correct schema properties 30ms
✓ tests/unit/mcp/tools.test.ts > n8nDocumentationToolsFinal > Individual Tool Validation > list_nodes > should have correct defaults 33ms
✓ tests/unit/mcp/tools.test.ts > n8nDocumentationToolsFinal > Individual Tool Validation > list_nodes > should have proper enum values 32ms
✓ tests/unit/mcp/tools.test.ts > n8nDocumentationToolsFinal > Individual Tool Validation > get_node_info > should exist 32ms
✓ tests/unit/mcp/tools.test.ts > n8nDocumentationToolsFinal > Individual Tool Validation > get_node_info > should have nodeType as required parameter 32ms
✓ tests/unit/mcp/tools.test.ts > n8nDocumentationToolsFinal > Individual Tool Validation > get_node_info > should mention performance implications in description 31ms
✓ tests/unit/mcp/tools.test.ts > n8nDocumentationToolsFinal > Individual Tool Validation > search_nodes > should exist 33ms
✓ tests/unit/mcp/tools.test.ts > n8nDocumentationToolsFinal > Individual Tool Validation > search_nodes > should have query as required parameter 32ms
✓ tests/unit/mcp/tools.test.ts > n8nDocumentationToolsFinal > Individual Tool Validation > search_nodes > should have mode enum with correct values 38ms
✓ tests/unit/mcp/tools.test.ts > n8nDocumentationToolsFinal > Individual Tool Validation > search_nodes > should have limit with default value 38ms
✓ tests/unit/mcp/tools.test.ts > n8nDocumentationToolsFinal > Individual Tool Validation > validate_workflow > should exist 31ms
✓ tests/unit/mcp/tools.test.ts > n8nDocumentationToolsFinal > Individual Tool Validation > validate_workflow > should have workflow as required parameter 34ms
✓ tests/unit/mcp/tools.test.ts > n8nDocumentationToolsFinal > Individual Tool Validation > validate_workflow > should have options with correct validation settings 33ms
✓ tests/unit/mcp/tools.test.ts > n8nDocumentationToolsFinal > Individual Tool Validation > validate_workflow > should have correct profile enum values 32ms
✓ tests/unit/mcp/tools.test.ts > n8nDocumentationToolsFinal > Individual Tool Validation > get_templates_for_task > should exist 33ms
✓ tests/unit/mcp/tools.test.ts > n8nDocumentationToolsFinal > Individual Tool Validation > get_templates_for_task > should have task as required parameter 31ms
✓ tests/unit/mcp/tools.test.ts > n8nDocumentationToolsFinal > Individual Tool Validation > get_templates_for_task > should have correct task enum values 35ms
✓ tests/unit/mcp/tools.test.ts > n8nDocumentationToolsFinal > Tool Description Quality > should have concise descriptions that fit in one line 32ms
✓ tests/unit/mcp/tools.test.ts > n8nDocumentationToolsFinal > Tool Description Quality > should include examples or key information in descriptions 32ms
✓ tests/unit/mcp/tools.test.ts > n8nDocumentationToolsFinal > Schema Consistency > should use consistent parameter naming 31ms
✓ tests/unit/mcp/tools.test.ts > n8nDocumentationToolsFinal > Schema Consistency > should have consistent limit parameter defaults 30ms
✓ tests/unit/mcp/tools.test.ts > n8nDocumentationToolsFinal > Tool Categories Coverage > should have tools for all major categories 34ms
✓ tests/unit/mcp/tools.test.ts > n8nDocumentationToolsFinal > Parameter Validation > should have proper type definitions for all parameters 34ms
✓ tests/unit/mcp/tools.test.ts > n8nDocumentationToolsFinal > Parameter Validation > should mark required parameters correctly 32ms
✓ tests/unit/mcp/tools.test.ts > n8nDocumentationToolsFinal > Edge Cases > should handle tools with no parameters 32ms
✓ tests/unit/mcp/tools.test.ts > n8nDocumentationToolsFinal > Edge Cases > should have array parameters defined correctly 36ms
✓ tests/unit/mcp/tools.test.ts > n8nDocumentationToolsFinal > New Template Tools > list_templates > should exist and be properly defined 33ms
✓ tests/unit/mcp/tools.test.ts > n8nDocumentationToolsFinal > New Template Tools > list_templates > should have correct parameters 36ms
✓ tests/unit/mcp/tools.test.ts > n8nDocumentationToolsFinal > New Template Tools > list_templates > should have no required parameters 33ms
✓ tests/unit/mcp/tools.test.ts > n8nDocumentationToolsFinal > New Template Tools > get_template (enhanced) > should exist and support mode parameter 32ms
✓ tests/unit/mcp/tools.test.ts > n8nDocumentationToolsFinal > New Template Tools > get_template (enhanced) > should have mode parameter with correct values 32ms
✓ tests/unit/mcp/tools.test.ts > n8nDocumentationToolsFinal > New Template Tools > get_template (enhanced) > should require templateId parameter 29ms
✓ tests/unit/mcp/tools.test.ts > n8nDocumentationToolsFinal > New Template Tools > search_templates_by_metadata > should exist in the tools array 32ms
✓ tests/unit/mcp/tools.test.ts > n8nDocumentationToolsFinal > New Template Tools > search_templates_by_metadata > should have proper description 34ms
✓ tests/unit/mcp/tools.test.ts > n8nDocumentationToolsFinal > New Template Tools > search_templates_by_metadata > should have correct input schema structure 32ms
✓ tests/unit/mcp/tools.test.ts > n8nDocumentationToolsFinal > New Template Tools > search_templates_by_metadata > should have category parameter with proper schema 32ms
✓ tests/unit/mcp/tools.test.ts > n8nDocumentationToolsFinal > New Template Tools > search_templates_by_metadata > should have complexity parameter with enum values 29ms
✓ tests/unit/mcp/tools.test.ts > n8nDocumentationToolsFinal > New Template Tools > search_templates_by_metadata > should have time-based parameters with numeric constraints 32ms
✓ tests/unit/mcp/tools.test.ts > n8nDocumentationToolsFinal > New Template Tools > search_templates_by_metadata > should have service and audience parameters 33ms
✓ tests/unit/mcp/tools.test.ts > n8nDocumentationToolsFinal > New Template Tools > search_templates_by_metadata > should have pagination parameters 35ms
✓ tests/unit/mcp/tools.test.ts > n8nDocumentationToolsFinal > New Template Tools > search_templates_by_metadata > should include all expected properties 32ms
✓ tests/unit/mcp/tools.test.ts > n8nDocumentationToolsFinal > New Template Tools > search_templates_by_metadata > should have appropriate additionalProperties setting 29ms
✓ tests/unit/mcp/tools.test.ts > n8nDocumentationToolsFinal > New Template Tools > Enhanced pagination support > list_node_templates > should support limit parameter 32ms
✓ tests/unit/mcp/tools.test.ts > n8nDocumentationToolsFinal > New Template Tools > Enhanced pagination support > list_node_templates > should support offset parameter 32ms
✓ tests/unit/mcp/tools.test.ts > n8nDocumentationToolsFinal > New Template Tools > Enhanced pagination support > search_templates > should support limit parameter 34ms
✓ tests/unit/mcp/tools.test.ts > n8nDocumentationToolsFinal > New Template Tools > Enhanced pagination support > search_templates > should support offset parameter 33ms
✓ tests/unit/mcp/tools.test.ts > n8nDocumentationToolsFinal > New Template Tools > Enhanced pagination support > get_templates_for_task > should support limit parameter 38ms
✓ tests/unit/mcp/tools.test.ts > n8nDocumentationToolsFinal > New Template Tools > Enhanced pagination support > get_templates_for_task > should support offset parameter 41ms
✓ tests/unit/mcp/tools.test.ts > n8nDocumentationToolsFinal > New Template Tools > Enhanced pagination support > search_templates_by_metadata > should support limit parameter 32ms
✓ tests/unit/mcp/tools.test.ts > n8nDocumentationToolsFinal > New Template Tools > Enhanced pagination support > search_templates_by_metadata > should support offset parameter 32ms
✓ tests/unit/mcp/search-nodes-examples.test.ts > search_nodes with includeExamples > includeExamples parameter > should not include examples when includeExamples is false 37ms
✓ tests/unit/mcp/search-nodes-examples.test.ts > search_nodes with includeExamples > includeExamples parameter > should not include examples when includeExamples is undefined 35ms
✓ tests/unit/mcp/search-nodes-examples.test.ts > search_nodes with includeExamples > includeExamples parameter > should include examples when includeExamples is true 34ms
✓ tests/unit/mcp/search-nodes-examples.test.ts > search_nodes with includeExamples > includeExamples parameter > should handle nodes without examples gracefully 33ms
✓ tests/unit/mcp/search-nodes-examples.test.ts > search_nodes with includeExamples > includeExamples parameter > should limit examples to top 2 per node 32ms
✓ tests/unit/mcp/search-nodes-examples.test.ts > search_nodes with includeExamples > example data structure > should return examples with correct structure when present 34ms
✓ tests/unit/mcp/search-nodes-examples.test.ts > search_nodes with includeExamples > backward compatibility > should maintain backward compatibility when includeExamples not specified 34ms
✓ tests/unit/mcp/search-nodes-examples.test.ts > search_nodes with includeExamples > performance considerations > should not significantly impact performance when includeExamples is false 33ms
✓ tests/unit/mcp/search-nodes-examples.test.ts > search_nodes with includeExamples > error handling > should continue to work even if example fetch fails 34ms
✓ tests/unit/mcp/search-nodes-examples.test.ts > search_nodes with includeExamples > error handling > should handle malformed parameters_json gracefully 34ms
✓ tests/unit/mcp/search-nodes-examples.test.ts > searchNodesLIKE with includeExamples > should support includeExamples in LIKE search 35ms
✓ tests/unit/mcp/search-nodes-examples.test.ts > searchNodesLIKE with includeExamples > should not include examples when includeExamples is false 33ms
✓ tests/unit/mcp/search-nodes-examples.test.ts > searchNodesFTS with includeExamples > should support includeExamples in FTS search 34ms
✓ tests/unit/mcp/search-nodes-examples.test.ts > searchNodesFTS with includeExamples > should pass options to example fetching logic 34ms
✓ tests/unit/database/node-repository-operations.test.ts > NodeRepository - Operations and Resources > getNodeOperations > should extract operations from array format 34ms
✓ tests/unit/database/node-repository-operations.test.ts > NodeRepository - Operations and Resources > getNodeOperations > should extract operations from object format grouped by resource 34ms
✓ tests/unit/database/node-repository-operations.test.ts > NodeRepository - Operations and Resources > getNodeOperations > should extract operations from properties with operation field 33ms
✓ tests/unit/database/node-repository-operations.test.ts > NodeRepository - Operations and Resources > getNodeOperations > should filter operations by resource when specified 33ms
✓ tests/unit/database/node-repository-operations.test.ts > NodeRepository - Operations and Resources > getNodeOperations > should return empty array for non-existent node 32ms
✓ tests/unit/database/node-repository-operations.test.ts > NodeRepository - Operations and Resources > getNodeOperations > should handle nodes without operations 33ms
✓ tests/unit/database/node-repository-operations.test.ts > NodeRepository - Operations and Resources > getNodeOperations > should handle malformed operations JSON gracefully 30ms
✓ tests/unit/database/node-repository-operations.test.ts > NodeRepository - Operations and Resources > getNodeResources > should extract resources from properties 34ms
✓ tests/unit/database/node-repository-operations.test.ts > NodeRepository - Operations and Resources > getNodeResources > should return empty array for node without resources 33ms
✓ tests/unit/database/node-repository-operations.test.ts > NodeRepository - Operations and Resources > getNodeResources > should return empty array for non-existent node 33ms
✓ tests/unit/database/node-repository-operations.test.ts > NodeRepository - Operations and Resources > getNodeResources > should handle multiple resource properties 32ms
✓ tests/unit/database/node-repository-operations.test.ts > NodeRepository - Operations and Resources > getOperationsForResource > should return operations for specific resource 33ms
✓ tests/unit/database/node-repository-operations.test.ts > NodeRepository - Operations and Resources > getOperationsForResource > should handle array format for resource display options 30ms
✓ tests/unit/database/node-repository-operations.test.ts > NodeRepository - Operations and Resources > getOperationsForResource > should return empty array for non-existent node 33ms
✓ tests/unit/database/node-repository-operations.test.ts > NodeRepository - Operations and Resources > getOperationsForResource > should handle string format for single resource 33ms
✓ tests/unit/database/node-repository-operations.test.ts > NodeRepository - Operations and Resources > getAllOperations > should collect operations from all nodes 33ms
✓ tests/unit/database/node-repository-operations.test.ts > NodeRepository - Operations and Resources > getAllOperations > should handle empty node list 33ms
✓ tests/unit/database/node-repository-operations.test.ts > NodeRepository - Operations and Resources > getAllResources > should collect resources from all nodes 33ms
✓ tests/unit/database/node-repository-operations.test.ts > NodeRepository - Operations and Resources > getAllResources > should handle empty node list 32ms
✓ tests/unit/database/node-repository-operations.test.ts > NodeRepository - Operations and Resources > edge cases and error handling > should handle null or undefined properties gracefully 30ms
✓ tests/unit/database/node-repository-operations.test.ts > NodeRepository - Operations and Resources > edge cases and error handling > should handle complex nested operation properties 33ms
✓ tests/unit/database/node-repository-operations.test.ts > NodeRepository - Operations and Resources > edge cases and error handling > should handle operations with mixed data types 32ms
✓ tests/unit/database/node-repository-operations.test.ts > NodeRepository - Operations and Resources > edge cases and error handling > should handle very deeply nested properties 33ms
✓ tests/unit/services/execution-processor.test.ts > ExecutionProcessor - Preview Mode > should generate preview for empty execution 30ms
✓ tests/unit/services/execution-processor.test.ts > ExecutionProcessor - Preview Mode > should generate preview with accurate item counts 33ms
✓ tests/unit/services/execution-processor.test.ts > ExecutionProcessor - Preview Mode > should extract data structure from nodes 33ms
✓ tests/unit/services/execution-processor.test.ts > ExecutionProcessor - Preview Mode > should estimate data size 34ms
✓ tests/unit/services/execution-processor.test.ts > ExecutionProcessor - Preview Mode > should detect error status in nodes 34ms
✓ tests/unit/services/execution-processor.test.ts > ExecutionProcessor - Preview Mode > should recommend full mode for small datasets 33ms
✓ tests/unit/services/execution-processor.test.ts > ExecutionProcessor - Preview Mode > should recommend filtered mode for large datasets 31ms
✓ tests/unit/services/execution-processor.test.ts > ExecutionProcessor - Preview Mode > should recommend summary mode for moderate datasets 41ms
✓ tests/unit/services/execution-processor.test.ts > ExecutionProcessor - Filtering > should filter by node names 42ms
✓ tests/unit/services/execution-processor.test.ts > ExecutionProcessor - Filtering > should handle non-existent node names gracefully 36ms
✓ tests/unit/services/execution-processor.test.ts > ExecutionProcessor - Filtering > should limit items to 0 (structure only) 33ms
✓ tests/unit/services/execution-processor.test.ts > ExecutionProcessor - Filtering > should limit items to 2 (default) 33ms
✓ tests/unit/services/execution-processor.test.ts > ExecutionProcessor - Filtering > should limit items to custom value 30ms
✓ tests/unit/services/execution-processor.test.ts > ExecutionProcessor - Filtering > should not truncate when itemsLimit is -1 (unlimited) 33ms
✓ tests/unit/services/execution-processor.test.ts > ExecutionProcessor - Filtering > should not truncate when items are less than limit 33ms
✓ tests/unit/services/execution-processor.test.ts > ExecutionProcessor - Filtering > should include input data when requested 33ms
✓ tests/unit/services/execution-processor.test.ts > ExecutionProcessor - Filtering > should not include input data by default 34ms
✓ tests/unit/services/execution-processor.test.ts > ExecutionProcessor - Modes > should handle preview mode 32ms
✓ tests/unit/services/execution-processor.test.ts > ExecutionProcessor - Modes > should handle summary mode 30ms
✓ tests/unit/services/execution-processor.test.ts > ExecutionProcessor - Modes > should handle filtered mode 33ms
✓ tests/unit/services/execution-processor.test.ts > ExecutionProcessor - Modes > should handle full mode 33ms
✓ tests/unit/services/execution-processor.test.ts > ExecutionProcessor - Edge Cases > should handle execution with no data 33ms
✓ tests/unit/services/execution-processor.test.ts > ExecutionProcessor - Edge Cases > should handle execution with error 33ms
✓ tests/unit/services/execution-processor.test.ts > ExecutionProcessor - Edge Cases > should handle empty node data arrays 32ms
✓ tests/unit/services/execution-processor.test.ts > ExecutionProcessor - Edge Cases > should handle nested data structures 30ms
✓ tests/unit/services/execution-processor.test.ts > ExecutionProcessor - Edge Cases > should calculate duration correctly 33ms
✓ tests/unit/services/execution-processor.test.ts > ExecutionProcessor - Edge Cases > should handle execution without stop time 33ms
✓ tests/unit/services/execution-processor.test.ts > ExecutionProcessor - processExecution > should return original execution when no options provided 33ms
✓ tests/unit/services/execution-processor.test.ts > ExecutionProcessor - processExecution > should process when mode is specified 33ms
✓ tests/unit/services/execution-processor.test.ts > ExecutionProcessor - processExecution > should process when filtering options are provided 33ms
✓ tests/unit/services/execution-processor.test.ts > ExecutionProcessor - Summary Statistics > should calculate hasMoreData correctly 30ms
✓ tests/unit/services/execution-processor.test.ts > ExecutionProcessor - Summary Statistics > should set hasMoreData to false when all data is included 33ms
✓ tests/unit/services/execution-processor.test.ts > ExecutionProcessor - Summary Statistics > should count total items correctly across multiple nodes 33ms
✓ tests/unit/database/node-repository-core.test.ts > NodeRepository - Core Functionality > saveNode > should save a node with proper JSON serialization 35ms
✓ tests/unit/database/node-repository-core.test.ts > NodeRepository - Core Functionality > saveNode > should handle nodes without optional fields 31ms
✓ tests/unit/database/node-repository-core.test.ts > NodeRepository - Core Functionality > getNode > should retrieve and deserialize a node correctly 32ms
✓ tests/unit/database/node-repository-core.test.ts > NodeRepository - Core Functionality > getNode > should return null for non-existent nodes 33ms
✓ tests/unit/database/node-repository-core.test.ts > NodeRepository - Core Functionality > getNode > should handle invalid JSON gracefully 35ms
✓ tests/unit/database/node-repository-core.test.ts > NodeRepository - Core Functionality > getAITools > should retrieve all AI tools sorted by display name 34ms
✓ tests/unit/database/node-repository-core.test.ts > NodeRepository - Core Functionality > getAITools > should return empty array when no AI tools exist 33ms
✓ tests/unit/database/node-repository-core.test.ts > NodeRepository - Core Functionality > safeJsonParse > should parse valid JSON 34ms
✓ tests/unit/database/node-repository-core.test.ts > NodeRepository - Core Functionality > safeJsonParse > should return default value for invalid JSON 32ms
✓ tests/unit/database/node-repository-core.test.ts > NodeRepository - Core Functionality > safeJsonParse > should handle empty strings 34ms
✓ tests/unit/database/node-repository-core.test.ts > NodeRepository - Core Functionality > safeJsonParse > should handle null and undefined 33ms
✓ tests/unit/database/node-repository-core.test.ts > NodeRepository - Core Functionality > Edge Cases > should handle very large JSON properties 34ms
✓ tests/unit/database/node-repository-core.test.ts > NodeRepository - Core Functionality > Edge Cases > should handle boolean conversion for integer fields 34ms
✓ tests/unit/multi-tenant-integration.test.ts > Multi-Tenant Support Integration > InstanceContext Validation > Real-world URL patterns > should accept realistic n8n URL: https://app.n8n.cloud 47ms
✓ tests/unit/multi-tenant-integration.test.ts > Multi-Tenant Support Integration > InstanceContext Validation > Real-world URL patterns > should accept realistic n8n URL: https://tenant1.n8n.cloud 48ms
✓ tests/unit/multi-tenant-integration.test.ts > Multi-Tenant Support Integration > InstanceContext Validation > Real-world URL patterns > should accept realistic n8n URL: https://my-company.n8n.cloud 50ms
✓ tests/unit/multi-tenant-integration.test.ts > Multi-Tenant Support Integration > InstanceContext Validation > Real-world URL patterns > should accept realistic n8n URL: https://n8n.example.com 52ms
✓ tests/unit/multi-tenant-integration.test.ts > Multi-Tenant Support Integration > InstanceContext Validation > Real-world URL patterns > should accept realistic n8n URL: https://automation.company.com 46ms
✓ tests/unit/multi-tenant-integration.test.ts > Multi-Tenant Support Integration > InstanceContext Validation > Real-world URL patterns > should accept realistic n8n URL: http://localhost:5678 52ms
✓ tests/unit/multi-tenant-integration.test.ts > Multi-Tenant Support Integration > InstanceContext Validation > Real-world URL patterns > should accept realistic n8n URL: https://localhost:8443 46ms
✓ tests/unit/multi-tenant-integration.test.ts > Multi-Tenant Support Integration > InstanceContext Validation > Real-world URL patterns > should accept realistic n8n URL: http://127.0.0.1:5678 71ms
✓ tests/unit/multi-tenant-integration.test.ts > Multi-Tenant Support Integration > InstanceContext Validation > Real-world URL patterns > should accept realistic n8n URL: https://192.168.1.100:8080 56ms
✓ tests/unit/multi-tenant-integration.test.ts > Multi-Tenant Support Integration > InstanceContext Validation > Real-world URL patterns > should accept realistic n8n URL: https://10.0.0.1:3000 50ms
✓ tests/unit/multi-tenant-integration.test.ts > Multi-Tenant Support Integration > InstanceContext Validation > Real-world URL patterns > should accept realistic n8n URL: http://n8n.internal.company.com 46ms
✓ tests/unit/multi-tenant-integration.test.ts > Multi-Tenant Support Integration > InstanceContext Validation > Real-world URL patterns > should accept realistic n8n URL: https://workflow.enterprise.local 46ms
✓ tests/unit/multi-tenant-integration.test.ts > Multi-Tenant Support Integration > InstanceContext Validation > Security validation > should reject potentially malicious URL: javascript:alert("xss") 47ms
✓ tests/unit/multi-tenant-integration.test.ts > Multi-Tenant Support Integration > InstanceContext Validation > Security validation > should reject potentially malicious URL: vbscript:msgbox("xss") 52ms
✓ tests/unit/multi-tenant-integration.test.ts > Multi-Tenant Support Integration > InstanceContext Validation > Security validation > should reject potentially malicious URL: data:text/html,<script>alert("xss")</script> 48ms
✓ tests/unit/multi-tenant-integration.test.ts > Multi-Tenant Support Integration > InstanceContext Validation > Security validation > should reject potentially malicious URL: file:///etc/passwd 48ms
✓ tests/unit/multi-tenant-integration.test.ts > Multi-Tenant Support Integration > InstanceContext Validation > Security validation > should reject potentially malicious URL: ldap://attacker.com/cn=admin 47ms
✓ tests/unit/multi-tenant-integration.test.ts > Multi-Tenant Support Integration > InstanceContext Validation > Security validation > should reject potentially malicious URL: ftp://malicious.com 52ms
✓ tests/unit/multi-tenant-integration.test.ts > Multi-Tenant Support Integration > InstanceContext Validation > API key validation > should reject invalid API key: "" 47ms
✓ tests/unit/multi-tenant-integration.test.ts > Multi-Tenant Support Integration > InstanceContext Validation > API key validation > should reject invalid API key: "placeholder" 47ms
✓ tests/unit/multi-tenant-integration.test.ts > Multi-Tenant Support Integration > InstanceContext Validation > API key validation > should reject invalid API key: "YOUR_API_KEY" 47ms
✓ tests/unit/multi-tenant-integration.test.ts > Multi-Tenant Support Integration > InstanceContext Validation > API key validation > should reject invalid API key: "example" 50ms
✓ tests/unit/multi-tenant-integration.test.ts > Multi-Tenant Support Integration > InstanceContext Validation > API key validation > should reject invalid API key: "your_api_key_here" 57ms
✓ tests/unit/multi-tenant-integration.test.ts > Multi-Tenant Support Integration > InstanceContext Validation > API key validation > should accept valid API keys 53ms
✓ tests/unit/multi-tenant-integration.test.ts > Multi-Tenant Support Integration > InstanceContext Validation > Edge cases and error handling > should handle partial instance context 50ms
✓ tests/unit/multi-tenant-integration.test.ts > Multi-Tenant Support Integration > InstanceContext Validation > Edge cases and error handling > should handle completely empty context 48ms
✓ tests/unit/multi-tenant-integration.test.ts > Multi-Tenant Support Integration > InstanceContext Validation > Edge cases and error handling > should handle numerical values gracefully 49ms
✓ tests/unit/multi-tenant-integration.test.ts > Multi-Tenant Support Integration > InstanceContext Validation > Edge cases and error handling > should reject invalid numerical values 47ms
✓ tests/unit/multi-tenant-integration.test.ts > Multi-Tenant Support Integration > InstanceContext Validation > Edge cases and error handling > should reject invalid retry values 46ms
✓ tests/unit/multi-tenant-integration.test.ts > Multi-Tenant Support Integration > Environment Variable Handling > should handle ENABLE_MULTI_TENANT flag correctly 48ms
✓ tests/unit/multi-tenant-integration.test.ts > Multi-Tenant Support Integration > Environment Variable Handling > should handle N8N_API_URL and N8N_API_KEY environment variables 46ms
✓ tests/unit/multi-tenant-integration.test.ts > Multi-Tenant Support Integration > Header Processing Simulation > should process multi-tenant headers correctly 50ms
✓ tests/unit/multi-tenant-integration.test.ts > Multi-Tenant Support Integration > Header Processing Simulation > should handle missing headers gracefully 46ms
✓ tests/unit/multi-tenant-integration.test.ts > Multi-Tenant Support Integration > Header Processing Simulation > should handle malformed headers 47ms
✓ tests/unit/multi-tenant-integration.test.ts > Multi-Tenant Support Integration > Configuration Priority Logic > should implement correct priority logic for tool inclusion 47ms
✓ tests/unit/multi-tenant-integration.test.ts > Multi-Tenant Support Integration > Session Management Concepts > should generate consistent identifiers for same configuration 51ms
✓ tests/unit/multi-tenant-integration.test.ts > Multi-Tenant Support Integration > Session Management Concepts > should generate different identifiers for different configurations 48ms
✓ tests/unit/multi-tenant-integration.test.ts > Multi-Tenant Support Integration > Session Management Concepts > should handle session isolation concepts 47ms
✓ tests/unit/multi-tenant-integration.test.ts > Multi-Tenant Support Integration > Error Scenarios and Recovery > should handle validation errors gracefully 49ms
✓ tests/unit/multi-tenant-integration.test.ts > Multi-Tenant Support Integration > Error Scenarios and Recovery > should provide specific error messages 48ms
✓ tests/unit/services/enhanced-config-validator.test.ts > EnhancedConfigValidator > validateWithMode > should validate config with operation awareness 50ms
✓ tests/unit/services/enhanced-config-validator.test.ts > EnhancedConfigValidator > validateWithMode > should extract operation context from config 47ms
✓ tests/unit/services/enhanced-config-validator.test.ts > EnhancedConfigValidator > validateWithMode > should filter properties based on operation context 47ms
✓ tests/unit/services/enhanced-config-validator.test.ts > EnhancedConfigValidator > validateWithMode > should handle minimal validation mode 63ms
✓ tests/unit/services/enhanced-config-validator.test.ts > EnhancedConfigValidator > validation profiles > should apply strict profile with all checks 47ms
✓ tests/unit/services/enhanced-config-validator.test.ts > EnhancedConfigValidator > validation profiles > should apply runtime profile focusing on critical errors 50ms
✓ tests/unit/services/enhanced-config-validator.test.ts > EnhancedConfigValidator > enhanced validation features > should provide examples for common errors 47ms
✓ tests/unit/services/enhanced-config-validator.test.ts > EnhancedConfigValidator > enhanced validation features > should suggest next steps for incomplete configurations 47ms
✓ tests/unit/services/enhanced-config-validator.test.ts > EnhancedConfigValidator > deduplicateErrors > should remove duplicate errors for the same property and type 46ms
✓ tests/unit/services/enhanced-config-validator.test.ts > EnhancedConfigValidator > deduplicateErrors > should prefer errors with fix information over those without 46ms
✓ tests/unit/services/enhanced-config-validator.test.ts > EnhancedConfigValidator > deduplicateErrors > should handle empty error arrays 50ms
✓ tests/unit/services/enhanced-config-validator.test.ts > EnhancedConfigValidator > applyProfileFilters - strict profile > should add suggestions for error-free configurations in strict mode 47ms
✓ tests/unit/services/enhanced-config-validator.test.ts > EnhancedConfigValidator > applyProfileFilters - strict profile > should enforce error handling for external service nodes in strict mode 46ms
✓ tests/unit/services/enhanced-config-validator.test.ts > EnhancedConfigValidator > applyProfileFilters - strict profile > should keep all errors, warnings, and suggestions in strict mode 47ms
✓ tests/unit/services/enhanced-config-validator.test.ts > EnhancedConfigValidator > enforceErrorHandlingForProfile > should add error handling warning for external service nodes 51ms
✓ tests/unit/services/enhanced-config-validator.test.ts > EnhancedConfigValidator > enforceErrorHandlingForProfile > should not add warning for non-error-prone nodes 47ms
✓ tests/unit/services/enhanced-config-validator.test.ts > EnhancedConfigValidator > enforceErrorHandlingForProfile > should not match httpRequest due to case sensitivity bug 47ms
✓ tests/unit/services/enhanced-config-validator.test.ts > EnhancedConfigValidator > enforceErrorHandlingForProfile > should only enforce for strict profile 46ms
✓ tests/unit/services/enhanced-config-validator.test.ts > EnhancedConfigValidator > addErrorHandlingSuggestions > should add network error handling suggestions when URL errors exist 47ms
✓ tests/unit/services/enhanced-config-validator.test.ts > EnhancedConfigValidator > addErrorHandlingSuggestions > should add webhook-specific suggestions 56ms
✓ tests/unit/services/enhanced-config-validator.test.ts > EnhancedConfigValidator > addErrorHandlingSuggestions > should detect webhook from error messages 48ms
✓ tests/unit/services/enhanced-config-validator.test.ts > EnhancedConfigValidator > addErrorHandlingSuggestions > should not add duplicate suggestions 47ms
✓ tests/unit/services/enhanced-config-validator.test.ts > EnhancedConfigValidator > filterPropertiesByOperation - real implementation > should filter properties based on operation context matching 67ms
✓ tests/unit/services/enhanced-config-validator.test.ts > EnhancedConfigValidator > filterPropertiesByOperation - real implementation > should handle properties without displayOptions in operation mode 64ms
✓ tests/unit/services/enhanced-config-validator.test.ts > EnhancedConfigValidator > isPropertyRelevantToOperation > should handle action field in operation context 50ms
✓ tests/unit/services/enhanced-config-validator.test.ts > EnhancedConfigValidator > isPropertyRelevantToOperation > should return false when action does not match 46ms
✓ tests/unit/services/enhanced-config-validator.test.ts > EnhancedConfigValidator > isPropertyRelevantToOperation > should handle arrays in displayOptions 47ms
✓ tests/unit/services/enhanced-config-validator.test.ts > EnhancedConfigValidator > operation-specific enhancements > should enhance MongoDB validation 46ms
✓ tests/unit/services/enhanced-config-validator.test.ts > EnhancedConfigValidator > operation-specific enhancements > should enhance MySQL validation 47ms
✓ tests/unit/services/enhanced-config-validator.test.ts > EnhancedConfigValidator > operation-specific enhancements > should enhance Postgres validation 52ms
✓ tests/unit/services/enhanced-config-validator.test.ts > EnhancedConfigValidator > generateNextSteps > should generate steps for different error types 48ms
✓ tests/unit/services/enhanced-config-validator.test.ts > EnhancedConfigValidator > generateNextSteps > should suggest addressing warnings when no errors exist 47ms
✓ tests/unit/services/enhanced-config-validator.test.ts > EnhancedConfigValidator > minimal validation mode edge cases > should only validate visible required properties in minimal mode 47ms
✓ tests/unit/services/enhanced-config-validator.test.ts > EnhancedConfigValidator > complex operation contexts > should handle all operation context fields (resource, operation, action, mode) 50ms
✓ tests/unit/services/enhanced-config-validator.test.ts > EnhancedConfigValidator > complex operation contexts > should validate Google Sheets append operation with range warning 48ms
✓ tests/unit/services/enhanced-config-validator.test.ts > EnhancedConfigValidator > complex operation contexts > should enhance Slack message send validation 57ms
✓ tests/unit/services/enhanced-config-validator.test.ts > EnhancedConfigValidator > profile-specific edge cases > should filter internal warnings in ai-friendly profile 52ms
```