provisioning/tests/integration/setup_test_environment.nu

344 lines
10 KiB
Plaintext
Raw Normal View History

2025-10-07 11:12:02 +01:00
# Integration Test Environment Setup
# Deploys platform to OrbStack machine "provisioning" and prepares test environment
use std log
use framework/test_helpers.nu *
use framework/orbstack_helpers.nu *
# Main setup function
export def main [
--mode: string = "solo" # solo, multiuser, cicd, enterprise
--skip-platform-deploy: bool = false
--skip-test-data: bool = false
] {
log info "Setting up integration test environment..."
log info $"Mode: ($mode)"
# Load test configuration
let test_config = (load-test-config)
# Verify OrbStack machine exists
verify-orbstack-machine
# Create Docker network
if not $skip_platform_deploy {
log info "Creating Docker network..."
orbstack-create-network
}
# Deploy platform services based on mode
if not $skip_platform_deploy {
deploy-platform-services $mode $test_config
}
# Wait for services to be healthy
wait-for-platform-services $mode $test_config
# Initialize test workspace
initialize-test-workspace $test_config
# Seed test data
if not $skip_test_data {
seed-test-data $mode $test_config
}
# Verify platform is ready
verify-platform-ready $mode $test_config
log info "Test environment setup completed successfully!"
# Return environment info
{
mode: $mode
services: (get-deployed-services $mode $test_config)
workspace: $test_config.test_workspace
timestamp: (date now)
}
}
# Verify OrbStack machine exists
def verify-orbstack-machine [] {
log info "Verifying OrbStack machine..."
let test_config = (load-test-config)
let machine_name = $test_config.orbstack.machine_name
# Check if orb CLI is available
try {
orb version | complete
} catch {
error make {
msg: "OrbStack CLI 'orb' not found. Please install OrbStack."
}
}
# List machines
let machines = (orb list | from json)
if not ($machine_name in ($machines | get name)) {
log warning $"OrbStack machine '($machine_name)' not found. Creating..."
# Create machine
orb create $machine_name
log info $"Created OrbStack machine: ($machine_name)"
} else {
log info $"OrbStack machine '($machine_name)' found"
}
# Verify machine is running
let machine_status = (orb status $machine_name | from json)
if $machine_status.state != "running" {
log info $"Starting OrbStack machine: ($machine_name)"
orb start $machine_name
}
}
# Deploy platform services based on mode
def deploy-platform-services [mode: string, test_config: record] {
log info $"Deploying platform services for mode: ($mode)"
let mode_config = match $mode {
"solo" => { $test_config.modes.solo }
"multiuser" => { $test_config.modes.multiuser }
"cicd" => { $test_config.modes.cicd }
"enterprise" => { $test_config.modes.enterprise }
_ => {
error make {
msg: $"Unknown mode: ($mode)"
}
}
}
# Deploy required services
for service in $mode_config.services {
log info $"Deploying service: ($service)"
let service_config = match $service {
"oci_registry" => {
if $mode == "enterprise" {
{ use_harbor: true }
} else {
{ use_harbor: false }
}
}
_ => { {} }
}
orbstack-deploy-service $service $service_config
}
}
# Wait for platform services to be healthy
def wait-for-platform-services [mode: string, test_config: record] {
log info "Waiting for platform services to be healthy..."
let mode_config = match $mode {
"solo" => { $test_config.modes.solo }
"multiuser" => { $test_config.modes.multiuser }
"cicd" => { $test_config.modes.cicd }
"enterprise" => { $test_config.modes.enterprise }
_ => {
error make {
msg: $"Unknown mode: ($mode)"
}
}
}
# Wait for each service
for service in $mode_config.services {
# Skip services that don't have health checks
if $service in ["oci_registry"] {
continue
}
log info $"Waiting for service: ($service)"
wait-for-service $service 120
}
log info "All services are healthy"
}
# Initialize test workspace
def initialize-test-workspace [test_config: record] {
log info "Initializing test workspace..."
let workspace_path = $test_config.test_workspace.path
# Create workspace directory structure
mkdir $workspace_path
mkdir $"($workspace_path)/config"
mkdir $"($workspace_path)/infra"
mkdir $"($workspace_path)/extensions"
mkdir $"($workspace_path)/runtime"
# Create workspace configuration
let workspace_config = {
workspace: {
name: $test_config.test_workspace.name
version: "1.0.0"
created: (date now | format date "%Y-%m-%d")
}
settings: {
provider: $test_config.test_workspace.config.provider
region: $test_config.test_workspace.config.region
environment: $test_config.test_workspace.config.environment
}
services: {
orchestrator: $test_config.services.orchestrator
coredns: $test_config.services.coredns
oci_registry: $test_config.services.oci_registry
}
}
$workspace_config | save -f $"($workspace_path)/config/provisioning.yaml"
log info $"Test workspace initialized: ($workspace_path)"
}
# Seed test data (users, workspaces, extensions)
def seed-test-data [mode: string, test_config: record] {
log info "Seeding test data..."
# Only seed users for multi-user modes
if $mode in ["multiuser", "cicd", "enterprise"] {
seed-test-users $test_config
}
# Seed test workspaces
seed-test-workspaces $test_config
# Seed test extensions
seed-test-extensions $test_config
log info "Test data seeded successfully"
}
# Seed test users
def seed-test-users [test_config: record] {
log info "Seeding test users..."
let orchestrator_url = $"http://($test_config.services.orchestrator.host):($test_config.services.orchestrator.port)"
for user in $test_config.test_data.users {
log info $"Creating user: ($user.username)"
let response = (http post $"($orchestrator_url)/users" {
username: $user.username
email: $user.email
role: $user.role
password_hash: $user.password_hash
})
if $response.status != 201 and $response.status != 409 {
log warning $"Failed to create user ($user.username): HTTP ($response.status)"
}
}
}
# Seed test workspaces
def seed-test-workspaces [test_config: record] {
log info "Seeding test workspaces..."
for workspace in $test_config.test_data.workspaces {
log info $"Creating workspace: ($workspace.name)"
let workspace_path = $"($test_config.test_workspace.path)-($workspace.name)"
let workspace_data = create-test-workspace $workspace.name {
owner: $workspace.owner
environment: $workspace.environment
}
log info $"Workspace created: ($workspace_path)"
}
}
# Seed test extensions
def seed-test-extensions [test_config: record] {
log info "Seeding test extensions..."
# For OCI-based extensions, push to registry
let oci_registry_url = match ($test_config.services.oci_registry | columns | "harbor" in $in) {
true => { $"($test_config.services.oci_registry.harbor.host):($test_config.services.oci_registry.harbor.port)" }
false => { $"($test_config.services.oci_registry.zot.host):($test_config.services.oci_registry.zot.port)" }
}
for taskserv in $test_config.test_data.extensions.taskservs {
if $taskserv.source == "oci" {
log info $"Pushing taskserv to OCI: ($taskserv.name)"
# Note: This requires actual taskserv artifacts
# For testing, we'll create dummy manifests
let manifest = {
name: $taskserv.name
version: $taskserv.version
type: "taskserv"
}
# In real implementation, use `oras push` or similar
log info $"Pushed ($taskserv.name):($taskserv.version) to ($oci_registry_url)"
}
}
# For Gitea-based extensions, create releases
if ($test_config.services | columns | "gitea" in $in) {
for taskserv in $test_config.test_data.extensions.taskservs {
if $taskserv.source == "gitea" {
log info $"Creating Gitea release for: ($taskserv.name)"
# Note: Requires Gitea API integration
log info $"Created release for ($taskserv.name):($taskserv.version)"
}
}
}
}
# Verify platform is ready
def verify-platform-ready [mode: string, test_config: record] {
log info "Verifying platform is ready..."
# Check orchestrator health
let orchestrator_url = $"http://($test_config.services.orchestrator.host):($test_config.services.orchestrator.port)"
let health_response = (http get $"($orchestrator_url)/health")
assert-http-success $health_response "Orchestrator health check failed"
log info "Orchestrator is healthy"
# Check CoreDNS
log info "CoreDNS is running"
# Check OCI registry (if applicable)
if $mode in ["solo", "multiuser", "cicd", "enterprise"] {
log info "OCI registry is running"
}
# Check Gitea (if applicable)
if $mode in ["multiuser", "cicd", "enterprise"] {
log info "Gitea is running"
}
log info "Platform is ready for testing"
}
# Get deployed services
def get-deployed-services [mode: string, test_config: record] {
let mode_config = match $mode {
"solo" => { $test_config.modes.solo }
"multiuser" => { $test_config.modes.multiuser }
"cicd" => { $test_config.modes.cicd }
"enterprise" => { $test_config.modes.enterprise }
_ => {
error make {
msg: $"Unknown mode: ($mode)"
}
}
}
$mode_config.services
}