344 lines
10 KiB
Plaintext
344 lines
10 KiB
Plaintext
# 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
|
|
}
|