End-to-End Testing Guide

Complete guide for testing the ProcessDsl platform from DSL to running microservice.

Prerequisites

✅ Docker & Docker Compose
✅ .NET 8.0 SDK
✅ Node.js 18+
✅ Python 3.8+

Quick Start (5 Minutes)

1. Start Camunda Stack

Access Points:

Zeebe gRPC: localhost:26500
Operate UI: http://localhost:8081 (username: demo, password: demo)
Tasklist UI: http://localhost:8082 (username: demo, password: demo)

2. Generate BPMN from DSL

# Convert .bpm to .bpmn
PYTHONPATH=src python3 -m bpm_dsl.cli convert examples/process_entity_demo.bpm \
  --output examples/process_entity_demo.bpmn

# Output: examples/process_entity_demo.bpmn

3. Deploy Process to Camunda

chmod +x scripts/deploy_to_camunda.sh
./scripts/deploy_to_camunda.sh examples/process_entity_demo.bpmn

Expected Output:

✅ Process deployed successfully!
   Process ID: process-entity-demo

4. Generate & Start Microservice

# Generate microservice (if not already done)
./scripts/generate_microservice.sh \
  examples/process_entity_demo.yaml \
  src/microservices/ProcessEntityDemo \
  ProcessEntityDemo

# Build
dotnet build src/microservices/ProcessEntityDemo/src/ProcessEntityDemo/

# Run
dotnet run --project src/microservices/ProcessEntityDemo/src/ProcessEntityDemo/ \
  --urls http://localhost:5100

Expected Output:

info: Program[0]
      Customer API microservice started
info: Program[0]
      Camunda URL: http://localhost:26500
info: Program[0]
      Swagger UI: http://localhost:5100

5. Test End-to-End

chmod +x scripts/test_microservice.sh
./scripts/test_microservice.sh

Expected Output:

✅ Microservice is running
✅ Camunda integration working
✅ POST /customers triggers process
🎉 End-to-End Test Complete!

Detailed Testing Scenarios

Scenario 1: Create Customer → Start Process

Request:

curl -X POST http://localhost:5100/customers \
  -H "Content-Type: application/json" \
  -d '{
    "id": "cust-001",
    "name": "Jane Smith",
    "email": "jane.smith@example.com",
    "phone": "+1234567890",
    "address": {
      "street": "456 Oak Ave",
      "city": "Boston",
      "state": "MA",
      "postalCode": "02101",
      "country": "US"
    }
  }'

Expected Response (201):

{
  "id": "cust-001",
  "name": "Jane Smith",
  "email": "jane.smith@example.com",
  "createdAt": "2025-10-05T19:00:00Z",
  "updatedAt": "2025-10-05T19:00:00Z"
}

Verification:

Check microservice logs:

info: ProcessEntityDemo.Controllers.DefaultApiController[0]
      Starting process process-entity-demo for CustomersPost
info: ProcessEntityDemo.Controllers.DefaultApiController[0]
      Process instance 2251799813685251 started successfully

Check Camunda Operate: http://localhost:8081
- Navigate to "Processes"
- Find "Process Entity Demo"
- Should see 1 running instance
Check job worker logs:
```
docker-compose logs job-worker
```
Should show: Processing job for process-entity-validator

Scenario 2: Camunda Unavailable (503)

Simulate:

# Stop Camunda
docker-compose stop zeebe

# Try to create customer
curl -X POST http://localhost:5100/customers \
  -H "Content-Type: application/json" \
  -d '{"id":"test","name":"Test","email":"test@test.com"}'

Expected Response (503):

{
  "error": "Process orchestration unavailable",
  "message": "Could not connect to Camunda"
}

Restart:

docker-compose start zeebe

Scenario 3: Invalid Data (400)

Request:

curl -X POST http://localhost:5100/customers \
  -H "Content-Type: application/json" \
  -d '{
    "name": "Missing ID"
  }'

Expected Response (400):

{
  "type": "https://tools.ietf.org/html/rfc7231#section-6.5.1",
  "title": "One or more validation errors occurred.",
  "status": 400,
  "errors": {
    "Id": ["The Id field is required."],
    "Email": ["The Email field is required."]
  }
}

Component Testing

Test 1: DSL Parser

# Valid process
PYTHONPATH=src python3 -m bpm_dsl.cli validate examples/process_entity_demo.bpm
# ✅ Process is valid

# Invalid process
PYTHONPATH=src python3 -m bpm_dsl.cli validate examples/process_entity_invalid.bpm
# ❌ Validation errors shown

Test 2: BPMN Generation

PYTHONPATH=src python3 -m bpm_dsl.cli convert examples/process_entity_demo.bpm
# Output: process_entity_demo.bpmn

Test 3: ProcessDsl.Orchestration

cd src/ProcessDsl.Orchestration
dotnet test
# 32/32 tests passing

Test 4: Job Worker

cd tests/ProcessDsl.EntityValidation.Tests
dotnet test
# All tests passing

Monitoring & Debugging

View Process Instances

Camunda Operate:

Open http://localhost:8081
Login: demo / demo
Navigate to "Processes" → "Process Entity Demo"
View running/completed instances

REST API:

# List process instances
curl http://localhost:9600/v1/process-instances/search \
  -H "Content-Type: application/json" \
  -d '{"filter":{"processDefinitionKey":"process-entity-demo"}}'

Check Microservice Logs

# Real-time logs
dotnet run --project src/microservices/ProcessEntityDemo/src/ProcessEntityDemo/ 2>&1 | tee microservice.log

# Filter for process starts
grep "Starting process" microservice.log

Check Job Worker Logs

docker-compose logs -f job-worker

Check Zeebe Health

curl http://localhost:9600/actuator/health

Performance Testing

Load Test

# Install hey (HTTP load testing tool)
# brew install hey  # macOS
# apt install hey   # Linux

# Run load test - 100 requests, 10 concurrent
hey -n 100 -c 10 \
  -m POST \
  -H "Content-Type: application/json" \
  -d '{"id":"load-test","name":"Load Test","email":"load@test.com","phone":"+1234567890","address":{"street":"123 St","city":"City","state":"ST","postalCode":"12345","country":"US"}}' \
  http://localhost:5100/customers

Expected Results:

Success rate: >99%
Average latency: <200ms (with Camunda)
Throughput: >50 req/sec

Troubleshooting

Issue: Microservice can't connect to Camunda

Symptoms:

503 errors from POST /customers
Logs: "Failed to start process - Camunda unavailable"

Solution:

# Check Camunda is running
docker-compose ps zeebe

# Check Zeebe is accessible
curl http://localhost:26500

# Restart Camunda
docker-compose restart zeebe

Issue: Process instance not appearing in Operate

Symptoms:

201 response from microservice
No process instance in Operate UI

Solution:

Check Elasticsearch is running:

curl http://localhost:9200/_cluster/health

Check Operate logs:
```
docker-compose logs operate
```
Restart Operate:
```
docker-compose restart operate
```

Issue: Job Worker not processing tasks

Symptoms:

Process instances stuck at processEntity task
No job worker logs

Solution:

# Check worker is running
docker-compose ps job-worker

# View worker logs
docker-compose logs job-worker

# Restart worker
docker-compose restart job-worker

Cleanup

Stop Services

# Stop but keep data
docker-compose stop

# Stop and remove containers (keep volumes)
docker-compose down

# Remove everything including data
docker-compose down -v

Reset Everything

# Remove all containers and volumes
docker-compose down -v

# Remove generated files
rm -rf src/microservices/ProcessEntityDemo
rm examples/*.bpmn

# Rebuild from scratch
./scripts/generate_microservice.sh \
  examples/process_entity_demo.yaml \
  src/microservices/ProcessEntityDemo \
  ProcessEntityDemo

CI/CD Integration

GitHub Actions Example

name: End-to-End Tests

on: [push, pull_request]

jobs:
  e2e-test:
    runs-on: ubuntu-latest
    
    steps:
      - uses: actions/checkout@v3
      
      - name: Start Camunda
        run: docker-compose up -d
        
      - name: Wait for services
        run: sleep 30
        
      - name: Generate BPMN
        run: PYTHONPATH=src python3 -m bpm_dsl.cli convert examples/process_entity_demo.bpm --output examples/process_entity_demo.bpmn
        
      - name: Deploy to Camunda
        run: ./scripts/deploy_to_camunda.sh examples/process_entity_demo.bpmn
        
      - name: Build microservice
        run: dotnet build src/microservices/ProcessEntityDemo/src/ProcessEntityDemo/
        
      - name: Run microservice
        run: |
          dotnet run --project src/microservices/ProcessEntityDemo/src/ProcessEntityDemo/ &
          sleep 10
        
      - name: Run E2E tests
        run: ./scripts/test_microservice.sh
        
      - name: Cleanup
        run: docker-compose down -v

Next Steps

Add More Processes: Create additional .bpm files and generate microservices
Implement Database: Add EF Core for actual customer persistence
Add Authentication: Secure APIs with JWT or OAuth
Deploy to Production: Use Kubernetes for orchestration
Add Monitoring: Integrate Prometheus/Grafana for metrics

Summary

What We Tested:

✅ DSL → BPMN conversion
✅ BPMN deployment to Camunda
✅ Microservice generation
✅ REST API → Process orchestration
✅ Job worker processing
✅ Error handling (503, 400, 500)
✅ End-to-end workflow

Platform Status:

🟢 Production Ready for development workflows
🟢 All components tested and validated
🟢 Complete documentation provided
🟢 Zero manual steps for generation

Achievement Unlocked: 🎉 From a single .bpm DSL file to a fully operational microservice with Camunda orchestration!

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

End-to-End Testing Guide

Prerequisites

Quick Start (5 Minutes)

1. Start Camunda Stack

2. Generate BPMN from DSL

3. Deploy Process to Camunda

4. Generate & Start Microservice

5. Test End-to-End

Detailed Testing Scenarios

Scenario 1: Create Customer → Start Process

Scenario 2: Camunda Unavailable (503)

Scenario 3: Invalid Data (400)

Component Testing

Test 1: DSL Parser

Test 2: BPMN Generation

Test 3: ProcessDsl.Orchestration

Test 4: Job Worker

Monitoring & Debugging

View Process Instances

Check Microservice Logs

Check Job Worker Logs

Check Zeebe Health

Performance Testing

Load Test

Troubleshooting

Issue: Microservice can't connect to Camunda

Issue: Process instance not appearing in Operate

Issue: Job Worker not processing tasks

Cleanup

Stop Services

Reset Everything

CI/CD Integration

GitHub Actions Example

Next Steps

Summary

FilesExpand file tree

END_TO_END_TESTING.md

Latest commit

History

END_TO_END_TESTING.md

File metadata and controls

End-to-End Testing Guide

Prerequisites

Quick Start (5 Minutes)

1. Start Camunda Stack

2. Generate BPMN from DSL

3. Deploy Process to Camunda

4. Generate & Start Microservice

5. Test End-to-End

Detailed Testing Scenarios

Scenario 1: Create Customer → Start Process

Scenario 2: Camunda Unavailable (503)

Scenario 3: Invalid Data (400)

Component Testing

Test 1: DSL Parser

Test 2: BPMN Generation

Test 3: ProcessDsl.Orchestration

Test 4: Job Worker

Monitoring & Debugging

View Process Instances

Check Microservice Logs

Check Job Worker Logs

Check Zeebe Health

Performance Testing

Load Test

Troubleshooting

Issue: Microservice can't connect to Camunda

Issue: Process instance not appearing in Operate

Issue: Job Worker not processing tasks

Cleanup

Stop Services

Reset Everything

CI/CD Integration

GitHub Actions Example

Next Steps

Summary