Quickstarters Test Framework

- type: provision
  provisionParams:
    quickstarter: be-python-flask

- type: provision
  description: Provision quickstarter
  provisionParams:
    quickstarter: be-python-flask
    pipeline: "{{.ProjectID}}-{{.ComponentID}}"
    branch: "master"
    env:
      - key: SOME_PARAM
        value: "some-value"
    verify:
      strategy: fail-fast
      jenkinsStages: golden/jenkins-provision-stages.json

- type: build
  buildParams: {}

- type: build
  description: Build and deploy
  buildParams:
    verify:
      strategy: aggregate
      jenkinsStages: golden/jenkins-build-stages.json
      sonarScan: golden/sonar-scan.json
      runAttachments: ["metadata.json"]
      testResults: 5
      openShiftResources:
        deployments: ["{{.ComponentID}}"]
        services: ["{{.ComponentID}}", "{{.ComponentID}}-backend"]
        routes: ["{{.ComponentID}}"]

- type: upload
  description: Upload config into repo
  uploadParams:
    file: fixtures/app-config.json
    filename: config/app-config.json
    render: true

- type: wait
  waitParams:
    condition: deployment-complete
    resource: "deployment/{{.ComponentID}}"
    timeout: "10m"
    interval: "5s"

- type: wait
  waitParams:
    condition: pod-ready
    resource: "-l app={{.ProjectID}}-{{.ComponentID}}"
    timeout: "5m"
    interval: "5s"

- type: wait
  waitParams:
    condition: log-contains
    resource: "deployment/{{.ComponentID}}"
    message: "Server listening"
    timeout: "5m"
    interval: "10s"

- type: wait
  waitParams:
    condition: route-accessible
    resource: "route/{{.ComponentID}}"
    timeout: "5m"
    interval: "5s"

- type: wait
  waitParams:
    condition: http-accessible
    url: "http://{{.ComponentID}}.{{.ProjectID}}-dev.svc.cluster.local:8080/health"
    timeout: "5m"
    interval: "2s"

- type: wait
  waitParams:
    condition: job-complete
    resource: "job/{{.ProjectID}}-{{.ComponentID}}-migration"
    timeout: "10m"
    interval: "5s"

- type: http
  description: Health endpoint returns expected JSON
  httpParams:
    url: "http://{{.ComponentID}}.{{.ProjectID}}-dev.svc.cluster.local:8080/health"
    method: GET
    headers:
      Accept: application/json
    expectedStatus: 200
    expectedBody: functional/api/health-response.json
    retry:
      attempts: 10
      delay: "2s"

- type: http
  description: Assert JSON fields
  httpParams:
    url: "http://{{.ComponentID}}.{{.ProjectID}}-dev.svc.cluster.local:8080/health"
    expectedStatus: 200
    assertions:
      - path: "status"
        equals: "ok"
      - path: "version"
        exists: true
      - path: "message"
        contains: "ready"
      - path: "commit"
        matches: "^[a-f0-9]{7,}$"

- type: http
  description: Create resource
  httpParams:
    url: "http://{{.ComponentID}}.{{.ProjectID}}-dev.svc.cluster.local:8080/api/v1/items"
    method: POST
    headers:
      Content-Type: application/json
      Accept: application/json
    body: '{"name":"example"}'
    expectedStatus: 201
    timeout: 60

- type: inspect
  description: Verify runtime signals
  inspectParams:
    resource: "deployment/{{.ComponentID}}"
    namespace: "{{.ProjectID}}-dev"
    checks:
      logs:
        contains: ["Server listening on :8080"]
        notContains: ["Traceback", "panic:"]
        matches: ["Listening on.*8080"]
      env:
        APP_ENV: "dev"
        ODS_PROJECT: "{{.ProjectID}}"
      resources:
        limits:
          cpu: "500m"
          memory: "512Mi"
        requests:
          cpu: "100m"
          memory: "128Mi"

- type: expose-service
  description: Expose services for local/Jenkins runs
  exposeServiceParams:
    services:
      - serviceName: "{{.ComponentID}}"
        namespace: "{{.ProjectID}}-dev"
        port: "8080"
      - serviceName: "{{.ComponentID}}-backend"
        # namespace defaults to "<project>-dev" if omitted
        # port defaults to 8080 if omitted

- type: run
  description: End-to-end tests
  runParams:
    file: functional/integration/e2e_test.sh
    services:
      api: "{{.ComponentID}}"
      backend: "{{.ComponentID}}-backend"

#!/usr/bin/env bash
set -euo pipefail

: "${API_SERVICE_URL:?missing API_SERVICE_URL}"
: "${BACKEND_SERVICE_URL:?missing BACKEND_SERVICE_URL}"

curl -fsS "$API_SERVICE_URL/health" | jq -e '.status == "ok"' >/dev/null
curl -fsS "$BACKEND_SERVICE_URL/metrics" >/dev/null

const (
    StepTypeUpload        = "upload"
    StepTypeRun           = "run"
    // ... existing types ...
    StepTypeMyCustom      = "my-custom"  // Add your new type here
)

// MyCustomParams defines parameters for the my-custom step type
type MyCustomParams struct {
    // Add your custom fields here
    Target      string   `json:"target"`
    Options     []string `json:"options"`
    RetryCount  int      `json:"retryCount"`
}

type TestStep struct {
    Type        string `json:"type"`
    Description string `json:"description"`
    // ... existing params ...
    MyCustomParams *MyCustomParams `json:"myCustomParams,omitempty"`
}

package steps

import (
    "fmt"
    "testing"
)

// ExecuteMyCustom handles the my-custom step type.
// This function contains the actual logic for your step.
func ExecuteMyCustom(t *testing.T, step TestStep, testdataPath string,
                     tmplData TemplateData, projectName string) {

    // Validate parameters
    if step.MyCustomParams == nil {
        t.Fatalf("Missing my-custom parameters")
    }

    params := step.MyCustomParams

    // Implement your step logic here
    fmt.Printf("Executing custom step with target: %s\n", params.Target)

    // Example: Run some operation
    for _, option := range params.Options {
        fmt.Printf("Processing option: %s\n", option)
        // Your custom logic here
    }

    // Use template data for dynamic values
    renderedTarget := RenderTemplate(t, params.Target, tmplData)
    fmt.Printf("Rendered target: %s\n", renderedTarget)

    // Fail the test if something goes wrong
    if someCondition {
        t.Fatalf("Custom step failed: %v", err)
    }
}

// MyCustomHandler implements the handler for my-custom steps.
type MyCustomHandler struct{}

func (h *MyCustomHandler) Execute(t *testing.T, step *TestStep, params *ExecutionParams) error {
    ExecuteMyCustom(t, *step, params.TestdataPath, params.TmplData, params.ProjectName)
    return nil
}

func registerDefaultHandlers() {
    defaultRegistry.Register(StepTypeUpload, &UploadHandler{})
    defaultRegistry.Register(StepTypeRun, &RunHandler{})
    // ... existing registrations ...
    defaultRegistry.Register(StepTypeMyCustom, &MyCustomHandler{})  // Add this line
}

# my-custom Step

## Purpose
Brief description of what this step does.

## Parameters

- `target` (string, required): Description of target parameter
- `options` (array, optional): Description of options
- `retryCount` (int, optional): Number of retry attempts

## Example

\```yaml
- type: my-custom
  description: "Execute custom operation"
  myCustomParams:
    target: "{{.ComponentID}}"
    options:
      - "verbose"
      - "debug"
    retryCount: 3
\```

## Common Use Cases
- Use case 1
- Use case 2

package steps

import (
    "testing"
)

func TestMyCustomHandler(t *testing.T) {
    registry := DefaultRegistry()

    handler, err := registry.Get(StepTypeMyCustom)
    if err != nil {
        t.Fatalf("Expected my-custom handler to be registered: %v", err)
    }

    if handler == nil {
        t.Fatal("Handler should not be nil")
    }

    // Test execution (may need mocking for complex steps)
    step := &TestStep{
        Type: StepTypeMyCustom,
        MyCustomParams: &MyCustomParams{
            Target: "test-target",
            Options: []string{"opt1"},
        },
    }

    params := &ExecutionParams{
        TestdataPath: "/tmp/testdata",
        TmplData:     TemplateData{},
        ProjectName:  "test-project",
    }

    // Test that handler executes without panic
    // (Actual behavior testing may require more setup)
}

componentID: my-component

steps:
  - type: provision
    # ... provision step ...

  - type: my-custom
    description: "Run my custom operation"
    myCustomParams:
      target: "{{.ComponentID}}-resource"
      options:
        - "enable-feature-x"
        - "debug-mode"
      retryCount: 2

// steps/database.go
package steps

import (
    "fmt"
    "testing"
    "database/sql"
    _ "github.com/lib/pq"
)

type DatabaseParams struct {
    ConnectionString string `json:"connectionString"`
    Query           string `json:"query"`
    ExpectedRows    int    `json:"expectedRows"`
}

func ExecuteDatabase(t *testing.T, step TestStep, testdataPath string,
                     tmplData TemplateData, projectName string) {
    if step.DatabaseParams == nil {
        t.Fatalf("Missing database parameters")
    }

    params := step.DatabaseParams
    connStr := RenderTemplate(t, params.ConnectionString, tmplData)
    query := RenderTemplate(t, params.Query, tmplData)

    db, err := sql.Open("postgres", connStr)
    if err != nil {
        t.Fatalf("Failed to connect to database: %v", err)
    }
    defer db.Close()

    rows, err := db.Query(query)
    if err != nil {
        t.Fatalf("Query failed: %v", err)
    }
    defer rows.Close()

    count := 0
    for rows.Next() {
        count++
    }

    if count != params.ExpectedRows {
        t.Fatalf("Expected %d rows, got %d", params.ExpectedRows, count)
    }

    fmt.Printf("✅ Database validation passed: %d rows\n", count)
}

// steps/registry.go - add this handler
type DatabaseHandler struct{}

func (h *DatabaseHandler) Execute(t *testing.T, step *TestStep, params *ExecutionParams) error {
    ExecuteDatabase(t, *step, params.TestdataPath, params.TmplData, params.ProjectName)
    return nil
}

// In registerDefaultHandlers():
// defaultRegistry.Register("database", &DatabaseHandler{})