An open-source, self-hostable PaaS alternative to Vercel, Heroku & Netlify that lets you easily deploy static sites, databases, full-stack applications and 360+ one-click services on your own servers.
PHP coolifydatabasesdeploymentdockerdocker-composeinertiajslaravelmariadbmysqlnextjsnodejsphppostgresredisself-hostedself-hostingserverstatic-sitesveltesvelte5
test(railpack): add API, Livewire UI tests and e2e smoke script
Andras Bacsai22a2c05a1d4f
diff --git a/scripts/railpack-smoke.sh b/scripts/railpack-smoke.shnew file mode 100755index 0000000000..92e621c3be--- /dev/null+++ b/scripts/railpack-smoke.sh@@ -0,0 +1,322 @@+#!/usr/bin/env bash+#+# Railpack end-to-end deploy smoke test against the local dev stack.+#+# Walks a curated set of railpack-* example apps from+# DevelopmentRailpackExamplesSeeder, triggers a deploy via the Coolify API,+# waits for the deployment queue to finish, then exec()s into the resulting+# container and checks that COOLIFY_*, SOURCE_COMMIT, and any RAILPACK_*+# build inputs landed correctly. Optionally curls the FQDN.+#+# Requires:+# - Dev stack running: spin up (or docker compose -f docker-compose.dev.yml up -d)+# - Seeder run: php artisan db:seed --class=DevelopmentRailpackExamplesSeeder+# - Personal token: PersonalAccessTokenSeeder run (creates Bearer 'root')+# - jq, curl available on host+#+# Usage:+# scripts/railpack-smoke.sh # default subset+# scripts/railpack-smoke.sh --app railpack-laravel # single app+# scripts/railpack-smoke.sh --all # every seeded railpack-* app+# scripts/railpack-smoke.sh --timeout 900 # build wait per app, seconds+# scripts/railpack-smoke.sh --no-curl # skip FQDN curl+# scripts/railpack-smoke.sh --extra-env KEY=VALUE # build+runtime env (alias of --both-env)+# scripts/railpack-smoke.sh --build-env KEY=VALUE # buildtime-only env (must reach build, NOT runtime)+# scripts/railpack-smoke.sh --runtime-env KEY=VALUE # runtime-only env (must reach runtime, NOT build)+# scripts/railpack-smoke.sh --both-env KEY=VALUE # buildtime+runtime env+#+set -euo pipefail++API_BASE="${COOLIFY_API_BASE:-http://localhost:8000/api/v1}"+TOKEN="${COOLIFY_API_TOKEN:-root}"+TIMEOUT="${SMOKE_TIMEOUT:-600}"+DO_CURL=1+BUILD_ENVS=()+RUNTIME_ENVS=()+BOTH_ENVS=()+APPS=()++DEFAULT_APPS=(+ railpack-expressjs+ railpack-nestjs+ railpack-nextjs-ssr+ railpack-vite-static+ railpack-astro-static+ railpack-python-flask+ railpack-go-gin+ railpack-rust+ railpack-laravel+ railpack-bun+)++while (( $# > 0 )); do+ case "$1" in+ --app) APPS+=("$2"); shift 2 ;;+ --all) APPS=(__ALL__); shift ;;+ --timeout) TIMEOUT="$2"; shift 2 ;;+ --no-curl) DO_CURL=0; shift ;;+ --extra-env|--both-env) BOTH_ENVS+=("$2"); shift 2 ;;+ --build-env) BUILD_ENVS+=("$2"); shift 2 ;;+ --runtime-env) RUNTIME_ENVS+=("$2"); shift 2 ;;+ --base) API_BASE="$2"; shift 2 ;;+ --token) TOKEN="$2"; shift 2 ;;+ -h|--help) sed -n '2,30p' "$0"; exit 0 ;;+ *) echo "unknown arg: $1" >&2; exit 2 ;;+ esac+done++if ! command -v jq >/dev/null; then+ echo "jq required" >&2; exit 2+fi+if ! command -v docker >/dev/null; then+ echo "docker required" >&2; exit 2+fi++curl_api() {+ local method="$1"; shift+ local path="$1"; shift+ curl -fsS -X "$method" \+ -H "Authorization: Bearer ${TOKEN}" \+ -H "Content-Type: application/json" \+ "${API_BASE}${path}" \+ "$@"+}++if (( ${#APPS[@]} == 0 )); then+ APPS=("${DEFAULT_APPS[@]}")+fi++if [[ "${APPS[0]}" == "__ALL__" ]]; then+ mapfile -t APPS < <(curl_api GET /applications | jq -r '.[].uuid' | grep '^railpack-' || true)+fi++log() { printf '[%s] %s\n' "$(date +%H:%M:%S)" "$*"; }+fail() { printf '\033[31m[FAIL]\033[0m %s: %s\n' "$1" "$2"; FAILED+=("$1: $2"); }+pass() { printf '\033[32m[ OK ]\033[0m %s: %s\n' "$1" "$2"; }++upsert_env() {+ local app_uuid="$1" key="$2" value="$3" buildtime="$4" runtime="$5" existing+ existing=$(curl_api GET "/applications/${app_uuid}/envs" | jq -r --arg k "$key" '.[] | select(.key==$k) | .uuid' | head -1)+ local payload+ payload=$(jq -nc --arg k "$key" --arg v "$value" --argjson b "$buildtime" --argjson r "$runtime" \+ '{key:$k, value:$v, is_buildtime:$b, is_runtime:$r, is_preview:false}')+ if [[ -n "$existing" ]]; then+ curl_api PATCH "/applications/${app_uuid}/envs" --data "$payload" >/dev/null+ log " env ${key} updated (buildtime=${buildtime} runtime=${runtime})"+ else+ curl_api POST "/applications/${app_uuid}/envs" --data "$payload" >/dev/null+ log " env ${key} created (buildtime=${buildtime} runtime=${runtime})"+ fi+}++ensure_envs() {+ local app_uuid="$1" kv key value+ for kv in "${BUILD_ENVS[@]:-}"; do+ [[ -z "$kv" ]] && continue+ key="${kv%%=*}"; value="${kv#*=}"+ upsert_env "$app_uuid" "$key" "$value" true false+ done+ for kv in "${RUNTIME_ENVS[@]:-}"; do+ [[ -z "$kv" ]] && continue+ key="${kv%%=*}"; value="${kv#*=}"+ upsert_env "$app_uuid" "$key" "$value" false true+ done+ for kv in "${BOTH_ENVS[@]:-}"; do+ [[ -z "$kv" ]] && continue+ key="${kv%%=*}"; value="${kv#*=}"+ upsert_env "$app_uuid" "$key" "$value" true true+ done+}++trigger_deploy() {+ local app_uuid="$1"+ curl_api POST "/applications/${app_uuid}/start?force=true&instant_deploy=true" \+ | jq -r '.deployment_uuid // empty'+}++wait_for_deploy() {+ local dep_uuid="$1" deadline="$2" status+ while (( $(date +%s) < deadline )); do+ status=$(curl_api GET "/deployments/${dep_uuid}" | jq -r '.status // "unknown"')+ case "$status" in+ finished) echo finished; return 0 ;;+ failed|cancelled) echo "$status"; return 1 ;;+ queued|in_progress) sleep 5 ;;+ *) sleep 5 ;;+ esac+ done+ echo timeout; return 1+}++container_for_app() {+ local app_uuid="$1"+ docker ps --filter "name=^${app_uuid}-" --format '{{.Names}}' | head -1+}++assert_envs_present() {+ local container="$1" app_uuid="$2"+ local env_dump+ env_dump=$(docker exec "$container" env 2>/dev/null || true)++ local missing=()+ for required in COOLIFY_FQDN COOLIFY_URL COOLIFY_BRANCH COOLIFY_RESOURCE_UUID COOLIFY_CONTAINER_NAME SOURCE_COMMIT; do+ if ! grep -q "^${required}=" <<<"$env_dump"; then+ missing+=("$required")+ fi+ done++ local resource_uuid+ resource_uuid=$(grep '^COOLIFY_RESOURCE_UUID=' <<<"$env_dump" | cut -d= -f2- || true)+ if [[ "$resource_uuid" != "$app_uuid" ]]; then+ missing+=("COOLIFY_RESOURCE_UUID-mismatch(got=${resource_uuid})")+ fi++ if (( ${#missing[@]} == 0 )); then+ pass "$app_uuid" "runtime envs present (${resource_uuid})"+ return 0+ fi+ fail "$app_uuid" "missing/incorrect envs: ${missing[*]}"+ return 1+}++deploy_logs_text() {+ local dep_uuid="$1"+ curl_api GET "/deployments/${dep_uuid}" | jq -r '(.logs | fromjson? // []) | .[].output' 2>/dev/null+}++assert_runtime_only_envs() {+ local container="$1" app_uuid="$2"+ [[ ${#RUNTIME_ENVS[@]} -eq 0 ]] && return 0+ local env_dump key value actual+ env_dump=$(docker exec "$container" env 2>/dev/null || true)+ for kv in "${RUNTIME_ENVS[@]}"; do+ key="${kv%%=*}"; value="${kv#*=}"+ if ! grep -q "^${key}=" <<<"$env_dump"; then+ fail "$app_uuid" "runtime-only env ${key} missing at runtime"+ return 1+ fi+ actual=$(grep "^${key}=" <<<"$env_dump" | head -1 | cut -d= -f2-)+ if [[ "$actual" != "$value" ]]; then+ fail "$app_uuid" "runtime env ${key} value mismatch (got=${actual} want=${value})"+ return 1+ fi+ done+ pass "$app_uuid" "runtime-only envs present at runtime (${#RUNTIME_ENVS[@]} key(s))"+}++assert_build_only_envs() {+ local container="$1" app_uuid="$2" dep_uuid="$3"+ [[ ${#BUILD_ENVS[@]} -eq 0 ]] && return 0+ local env_dump logs key+ env_dump=$(docker exec "$container" env 2>/dev/null || true)+ logs=$(deploy_logs_text "$dep_uuid")++ for kv in "${BUILD_ENVS[@]}"; do+ key="${kv%%=*}"+ # Reach build: railpack passes buildtime envs as docker buildx --secret id=KEY+ if ! grep -q -- "--secret id=${key}" <<<"$logs"; then+ fail "$app_uuid" "build-only env ${key} not seen as --secret in deploy logs"+ return 1+ fi+ # Must NOT leak to runtime container+ if grep -q "^${key}=" <<<"$env_dump"; then+ fail "$app_uuid" "build-only env ${key} LEAKED to runtime container"+ return 1+ fi+ done+ pass "$app_uuid" "build-only envs in build secret + absent at runtime (${#BUILD_ENVS[@]} key(s))"+}++assert_both_envs() {+ local container="$1" app_uuid="$2" dep_uuid="$3"+ [[ ${#BOTH_ENVS[@]} -eq 0 ]] && return 0+ local env_dump logs key+ env_dump=$(docker exec "$container" env 2>/dev/null || true)+ logs=$(deploy_logs_text "$dep_uuid")+ for kv in "${BOTH_ENVS[@]}"; do+ key="${kv%%=*}"+ if [[ "$key" =~ ^RAILPACK_ ]]; then+ # RAILPACK_* are buildtime-only by railpack convention; skip runtime check+ grep -q -- "--secret id=${key}" <<<"$logs" \+ || { fail "$app_uuid" "${key} not seen in build secrets"; return 1; }+ continue+ fi+ grep -q "^${key}=" <<<"$env_dump" \+ || { fail "$app_uuid" "both-env ${key} missing at runtime"; return 1; }+ done+ pass "$app_uuid" "both-envs reached runtime (${#BOTH_ENVS[@]} key(s))"+}++assert_fqdn_responds() {+ local app_uuid="$1"+ local fqdn+ fqdn=$(curl_api GET "/applications/${app_uuid}" | jq -r '.fqdn // empty')+ [[ -z "$fqdn" ]] && return 0+ local code+ code=$(curl -ksSL -o /dev/null -w '%{http_code}' --max-time 10 "$fqdn" || echo "000")+ case "$code" in+ 2*|3*) pass "$app_uuid" "fqdn ${fqdn} -> ${code}" ;;+ *) fail "$app_uuid" "fqdn ${fqdn} -> ${code}" ;;+ esac+}++run_one() {+ local app_uuid="$1"+ log "==> ${app_uuid}"++ if ! curl_api GET "/applications/${app_uuid}" >/dev/null 2>&1; then+ fail "$app_uuid" "application not found via API (run seeder?)"+ return+ fi++ ensure_envs "$app_uuid"++ local dep+ dep=$(trigger_deploy "$app_uuid")+ if [[ -z "$dep" ]]; then+ fail "$app_uuid" "no deployment_uuid returned"+ return+ fi+ log " deploy queued: ${dep}"++ local deadline=$(( $(date +%s) + TIMEOUT ))+ local result+ result=$(wait_for_deploy "$dep" "$deadline") || {+ fail "$app_uuid" "deploy ${result}"+ return+ }+ pass "$app_uuid" "deploy ${result}"++ sleep 2+ local container+ container=$(container_for_app "$app_uuid")+ if [[ -z "$container" ]]; then+ fail "$app_uuid" "no running container matching name=^${app_uuid}-"+ return+ fi+ pass "$app_uuid" "container ${container} running"++ assert_envs_present "$container" "$app_uuid" || true+ assert_runtime_only_envs "$container" "$app_uuid" || true+ assert_build_only_envs "$container" "$app_uuid" "$dep" || true+ assert_both_envs "$container" "$app_uuid" "$dep" || true++ if (( DO_CURL )); then+ assert_fqdn_responds "$app_uuid" || true+ fi+}++FAILED=()+for app in "${APPS[@]}"; do+ run_one "$app"+done++echo+echo "=== summary ==="+if (( ${#FAILED[@]} == 0 )); then+ echo "all apps passed"+ exit 0+fi+printf '%s failure(s):\n' "${#FAILED[@]}"+printf ' - %s\n' "${FAILED[@]}"+exit 1diff --git a/tests/Feature/Api/RailpackApiTest.php b/tests/Feature/Api/RailpackApiTest.phpnew file mode 100644index 0000000000..c9dbced4b9--- /dev/null+++ b/tests/Feature/Api/RailpackApiTest.php@@ -0,0 +1,345 @@+<?php++use App\Models\Application;+use App\Models\Environment;+use App\Models\InstanceSettings;+use App\Models\Project;+use App\Models\Server;+use App\Models\StandaloneDocker;+use App\Models\Team;+use App\Models\User;+use Illuminate\Foundation\Testing\RefreshDatabase;+use Illuminate\Support\Str;++uses(RefreshDatabase::class);++beforeEach(function () {+ InstanceSettings::unguarded(fn () => InstanceSettings::firstOrCreate(['id' => 0]));++ $this->team = Team::factory()->create();+ $this->user = User::factory()->create();+ $this->team->members()->attach($this->user->id, ['role' => 'owner']);+ session(['currentTeam' => $this->team]);++ $plainTextToken = Str::random(40);+ $token = $this->user->tokens()->create([+ 'name' => 'railpack-api-test-'.Str::random(6),+ 'token' => hash('sha256', $plainTextToken),+ 'abilities' => ['*'],+ 'team_id' => $this->team->id,+ ]);+ $this->bearerToken = $token->getKey().'|'.$plainTextToken;++ $this->server = Server::factory()->create(['team_id' => $this->team->id]);+ $this->destination = StandaloneDocker::where('server_id', $this->server->id)->first();+ $this->project = Project::factory()->create(['team_id' => $this->team->id]);+ $this->environment = Environment::factory()->create(['project_id' => $this->project->id]);+});++function railpackApiHeaders(string $bearerToken): array+{+ return [+ 'Authorization' => 'Bearer '.$bearerToken,+ 'Content-Type' => 'application/json',+ ];+}++function makeRailpackApp(array $overrides = []): Application+{+ return Application::factory()->create(array_merge([+ 'environment_id' => test()->environment->id,+ 'destination_id' => test()->destination->id,+ 'destination_type' => test()->destination->getMorphClass(),+ 'build_pack' => 'railpack',+ ], $overrides));+}++describe('PATCH /api/v1/applications/{uuid} build_pack=railpack', function () {+ test('rejects unsupported build_pack at controller layer', function () {+ $app = makeRailpackApp();++ $response = $this->withHeaders(railpackApiHeaders($this->bearerToken))+ ->patchJson("/api/v1/applications/{$app->uuid}", [+ 'build_pack' => 'totally-bogus',+ ]);++ $response->assertStatus(422);+ });++ test('switching from dockerfile to railpack clears dockerfile fields', function () {+ $app = makeRailpackApp([+ 'build_pack' => 'dockerfile',+ 'dockerfile' => 'FROM node:20',+ 'dockerfile_location' => '/Dockerfile',+ 'dockerfile_target_build' => 'production',+ 'custom_healthcheck_found' => true,+ ]);++ $response = $this->withHeaders(railpackApiHeaders($this->bearerToken))+ ->patchJson("/api/v1/applications/{$app->uuid}", [+ 'build_pack' => 'railpack',+ ]);++ $response->assertOk();++ $app->refresh();+ expect($app->build_pack)->toBe('railpack');+ expect($app->dockerfile)->toBeNull();+ // NOTE: dockerfile_location is normalized to '/Dockerfile' by the model+ // mutator when set to null, so we cannot assert it becomes null here.+ expect($app->dockerfile_target_build)->toBeNull();+ expect((bool) $app->custom_healthcheck_found)->toBeFalse();+ });++ test('switching from dockercompose to railpack clears compose fields and SERVICE_* envs', function () {+ $app = makeRailpackApp([+ 'build_pack' => 'dockercompose',+ 'docker_compose_domains' => '{"app": "example.com"}',+ 'docker_compose_raw' => "version: '3'\nservices:\n app:\n image: nginx",+ ]);++ $app->environment_variables()->createMany([+ ['key' => 'SERVICE_FQDN_APP', 'value' => 'app.example.com', 'is_buildtime' => false, 'is_preview' => false],+ ['key' => 'SERVICE_URL_APP', 'value' => 'http://app.example.com', 'is_buildtime' => false, 'is_preview' => false],+ ['key' => 'REGULAR_VAR', 'value' => 'keep_me', 'is_buildtime' => false, 'is_preview' => false],+ ]);++ $response = $this->withHeaders(railpackApiHeaders($this->bearerToken))+ ->patchJson("/api/v1/applications/{$app->uuid}", [+ 'build_pack' => 'railpack',+ ]);++ $response->assertOk();++ $app->refresh();+ expect($app->build_pack)->toBe('railpack');+ expect($app->docker_compose_domains)->toBeNull();+ expect($app->docker_compose_raw)->toBeNull();+ expect($app->environment_variables()->where('key', 'SERVICE_FQDN_APP')->count())->toBe(0);+ expect($app->environment_variables()->where('key', 'SERVICE_URL_APP')->count())->toBe(0);+ expect($app->environment_variables()->where('key', 'REGULAR_VAR')->count())->toBe(1);+ });++ test('install/build/start commands persist for railpack apps', function () {+ $app = makeRailpackApp();++ $response = $this->withHeaders(railpackApiHeaders($this->bearerToken))+ ->patchJson("/api/v1/applications/{$app->uuid}", [+ 'install_command' => 'npm ci',+ 'build_command' => 'npm run build',+ 'start_command' => 'node server.js',+ ]);++ $response->assertOk();++ $app->refresh();+ expect($app->install_command)->toBe('npm ci');+ expect($app->build_command)->toBe('npm run build');+ expect($app->start_command)->toBe('node server.js');+ });+});++describe('POST /api/v1/applications/{uuid}/envs RAILPACK_* handling', function () {+ test('adding RAILPACK_NODE_VERSION via API surfaces in railpack_environment_variables only', function () {+ $app = makeRailpackApp();++ $response = $this->withHeaders(railpackApiHeaders($this->bearerToken))+ ->postJson("/api/v1/applications/{$app->uuid}/envs", [+ 'key' => 'RAILPACK_NODE_VERSION',+ 'value' => '20',+ 'is_buildtime' => true,+ 'is_runtime' => false,+ 'is_preview' => false,+ ]);++ $response->assertCreated();++ $app->refresh();+ expect($app->railpack_environment_variables)->toHaveCount(1);+ expect($app->railpack_environment_variables->first()->key)->toBe('RAILPACK_NODE_VERSION');+ expect($app->runtime_environment_variables->where('key', 'RAILPACK_NODE_VERSION'))->toHaveCount(0);+ });++ test('runtime envs added via API surface in runtime_environment_variables but not railpack_*', function () {+ $app = makeRailpackApp();++ $this->withHeaders(railpackApiHeaders($this->bearerToken))+ ->postJson("/api/v1/applications/{$app->uuid}/envs", [+ 'key' => 'APP_ENV',+ 'value' => 'production',+ 'is_runtime' => true,+ 'is_buildtime' => false,+ 'is_preview' => false,+ ])->assertCreated();++ $this->withHeaders(railpackApiHeaders($this->bearerToken))+ ->postJson("/api/v1/applications/{$app->uuid}/envs", [+ 'key' => 'NIXPACKS_NODE_VERSION',+ 'value' => '18',+ 'is_buildtime' => true,+ 'is_runtime' => false,+ 'is_preview' => false,+ ])->assertCreated();++ $app->refresh();+ $runtime = $app->runtime_environment_variables;+ expect($runtime->pluck('key')->all())->toBe(['APP_ENV']);+ expect($app->railpack_environment_variables)->toHaveCount(0);+ });++ test('preview RAILPACK_* envs surface in railpack_environment_variables_preview only', function () {+ $app = makeRailpackApp();++ $this->withHeaders(railpackApiHeaders($this->bearerToken))+ ->postJson("/api/v1/applications/{$app->uuid}/envs", [+ 'key' => 'RAILPACK_BUILD_CMD',+ 'value' => 'npm run build',+ 'is_buildtime' => true,+ 'is_runtime' => false,+ 'is_preview' => true,+ ])->assertCreated();++ $app->refresh();+ expect($app->railpack_environment_variables_preview)->toHaveCount(1);+ expect($app->railpack_environment_variables)->toHaveCount(0);+ });++ test('buildtime-only env has is_buildtime=true and is_runtime=false', function () {+ $app = makeRailpackApp();++ $this->withHeaders(railpackApiHeaders($this->bearerToken))+ ->postJson("/api/v1/applications/{$app->uuid}/envs", [+ 'key' => 'API_KEY',+ 'value' => 'sekret',+ 'is_buildtime' => true,+ 'is_runtime' => false,+ 'is_preview' => false,+ ])->assertCreated();++ $app->refresh();+ $env = $app->environment_variables()->where('key', 'API_KEY')->first();+ expect($env)->not->toBeNull();+ expect((bool) $env->is_buildtime)->toBeTrue();+ expect((bool) $env->is_runtime)->toBeFalse();+ // Buildtime-only non-RAILPACK_ var: visible to runtime relation (it's not a buildpack-control var)+ // but is_runtime flag is false; consumers gate runtime via is_runtime, not via the relation alone.+ expect($env->resourceable_id)->toBe($app->id);+ });++ test('runtime-only env has is_runtime=true and is_buildtime=false', function () {+ $app = makeRailpackApp();++ $this->withHeaders(railpackApiHeaders($this->bearerToken))+ ->postJson("/api/v1/applications/{$app->uuid}/envs", [+ 'key' => 'LOG_LEVEL',+ 'value' => 'debug',+ 'is_buildtime' => false,+ 'is_runtime' => true,+ 'is_preview' => false,+ ])->assertCreated();++ $app->refresh();+ $env = $app->environment_variables()->where('key', 'LOG_LEVEL')->first();+ expect((bool) $env->is_buildtime)->toBeFalse();+ expect((bool) $env->is_runtime)->toBeTrue();+ });++ test('railpack build variables collection includes only is_buildtime=true entries', function () {+ // Sanity check the underlying query used by the deploy job: railpack_build_variables()+ // pulls $application->environment_variables()->where('is_buildtime', true)->get()+ // (see ApplicationDeploymentJob::railpack_build_variables).+ $app = makeRailpackApp();++ $this->withHeaders(railpackApiHeaders($this->bearerToken))+ ->postJson("/api/v1/applications/{$app->uuid}/envs", [+ 'key' => 'BUILD_ARG',+ 'value' => 'in-build',+ 'is_buildtime' => true,+ 'is_runtime' => false,+ 'is_preview' => false,+ ])->assertCreated();++ $this->withHeaders(railpackApiHeaders($this->bearerToken))+ ->postJson("/api/v1/applications/{$app->uuid}/envs", [+ 'key' => 'RUNTIME_ARG',+ 'value' => 'in-runtime',+ 'is_buildtime' => false,+ 'is_runtime' => true,+ 'is_preview' => false,+ ])->assertCreated();++ $app->refresh();+ $buildtime = $app->environment_variables()->where('is_buildtime', true)->pluck('key')->all();+ expect($buildtime)->toContain('BUILD_ARG');+ expect($buildtime)->not->toContain('RUNTIME_ARG');+ });++ test('user-defined COOLIFY_FQDN takes precedence over auto-generated', function () {+ // Documents generate_coolify_env_variables() override behavior:+ // it skips generation when application->environment_variables already has the key.+ $app = makeRailpackApp();++ $this->withHeaders(railpackApiHeaders($this->bearerToken))+ ->postJson("/api/v1/applications/{$app->uuid}/envs", [+ 'key' => 'COOLIFY_FQDN',+ 'value' => 'overridden.example.com',+ 'is_buildtime' => true,+ 'is_runtime' => true,+ 'is_preview' => false,+ ])->assertCreated();++ $app->refresh();+ $env = $app->environment_variables()->where('key', 'COOLIFY_FQDN')->first();+ expect($env)->not->toBeNull();+ expect($env->value)->toBe('overridden.example.com');+ // Confirm the model relation used by override-skip logic finds it+ expect($app->environment_variables->where('key', 'COOLIFY_FQDN')->isEmpty())->toBeFalse();+ });++ test('is_literal flag persists on create', function () {+ $app = makeRailpackApp();++ $this->withHeaders(railpackApiHeaders($this->bearerToken))+ ->postJson("/api/v1/applications/{$app->uuid}/envs", [+ 'key' => 'RAILPACK_LITERAL_FLAG',+ 'value' => '$NOT_INTERPOLATED',+ 'is_buildtime' => true,+ 'is_runtime' => false,+ 'is_preview' => false,+ 'is_literal' => true,+ ])->assertCreated();++ $app->refresh();+ $env = $app->environment_variables()->where('key', 'RAILPACK_LITERAL_FLAG')->first();+ expect((bool) $env->is_literal)->toBeTrue();+ });++ test('PATCH env updates buildtime/runtime flags', function () {+ $app = makeRailpackApp();++ $this->withHeaders(railpackApiHeaders($this->bearerToken))+ ->postJson("/api/v1/applications/{$app->uuid}/envs", [+ 'key' => 'TOGGLE_VAR',+ 'value' => 'v1',+ 'is_buildtime' => true,+ 'is_runtime' => true,+ 'is_preview' => false,+ ])->assertCreated();++ $this->withHeaders(railpackApiHeaders($this->bearerToken))+ ->patchJson("/api/v1/applications/{$app->uuid}/envs", [+ 'key' => 'TOGGLE_VAR',+ 'value' => 'v2',+ 'is_buildtime' => false,+ 'is_runtime' => true,+ 'is_multiline' => false,+ 'is_shown_once' => false,+ ])->assertStatus(201);++ $app->refresh();+ $env = $app->environment_variables()->where('key', 'TOGGLE_VAR')->first();+ expect($env->value)->toBe('v2');+ expect((bool) $env->is_buildtime)->toBeFalse();+ expect((bool) $env->is_runtime)->toBeTrue();+ });+});diff --git a/tests/Feature/Livewire/RailpackLivewireUiTest.php b/tests/Feature/Livewire/RailpackLivewireUiTest.phpnew file mode 100644index 0000000000..b21037b116--- /dev/null+++ b/tests/Feature/Livewire/RailpackLivewireUiTest.php@@ -0,0 +1,121 @@+<?php++use App\Livewire\Project\Application\General;+use App\Livewire\Project\New\PublicGitRepository;+use App\Models\Application;+use App\Models\Environment;+use App\Models\InstanceSettings;+use App\Models\PrivateKey;+use App\Models\Project;+use App\Models\Server;+use App\Models\StandaloneDocker;+use App\Models\Team;+use App\Models\User;+use Illuminate\Foundation\Testing\RefreshDatabase;+use Livewire\Livewire;++uses(RefreshDatabase::class);++beforeEach(function () {+ $this->team = Team::factory()->create();+ $this->user = User::factory()->create();+ $this->team->members()->attach($this->user->id, ['role' => 'owner']);++ $this->actingAs($this->user);+ session(['currentTeam' => $this->team]);+ InstanceSettings::unguarded(function () {+ InstanceSettings::updateOrCreate(['id' => 0], []);+ });++ $this->project = Project::factory()->create(['team_id' => $this->team->id]);+ $this->environment = Environment::factory()->create(['project_id' => $this->project->id]);+});++describe('PublicGitRepository port handling for railpack', function () {+ test('switching to railpack resets port to 3000 when not static', function () {+ Livewire::test(PublicGitRepository::class, ['type' => 'public'])+ ->set('build_pack', 'dockerfile')+ ->assertSet('port', 3000)+ ->set('build_pack', 'railpack')+ ->assertSet('port', 3000);+ });++ test('switching to railpack preserves port when isStatic is true', function () {+ $component = Livewire::test(PublicGitRepository::class, ['type' => 'public'])+ ->set('isStatic', true)+ ->call('instantSave');++ // After instantSave with isStatic=true, port becomes 80+ $component->assertSet('port', 80);++ // Switching from nixpacks to railpack should NOT clobber port back to 3000+ $component->set('build_pack', 'railpack')+ ->assertSet('port', 80);+ });++ test('switching to static sets port to 80 and disables show_is_static', function () {+ Livewire::test(PublicGitRepository::class, ['type' => 'public'])+ ->set('build_pack', 'static')+ ->assertSet('port', 80)+ ->assertSet('isStatic', false)+ ->assertSet('show_is_static', false);+ });+});++describe('General view railpack helper text', function () {+ beforeEach(function () {+ $this->privateKey = PrivateKey::create([+ 'name' => 'Test Key',+ 'private_key' => '-----BEGIN OPENSSH PRIVATE KEY-----+b3BlbnNzaC1rZXktdjEAAAAABG5vbmUAAAAEbm9uZQAAAAAAAAABAAAAMwAAAAtzc2gtZW+QyNTUxOQAAACBbhpqHhqv6aI67Mj9abM3DVbmcfYhZAhC7ca4d9UCevAAAAJi/QySHv0Mk+hwAAAAtzc2gtZWQyNTUxOQAAACBbhpqHhqv6aI67Mj9abM3DVbmcfYhZAhC7ca4d9UCevA+AAAECBQw4jg1WRT2IGHMncCiZhURCts2s24HoDS0thHnnRKVuGmoeGq/pojrsyP1pszcNV+uZx9iFkCELtxrh31QJ68AAAAEXNhaWxANzZmZjY2ZDJlMmRkAQIDBA==+-----END OPENSSH PRIVATE KEY-----',+ 'team_id' => $this->team->id,+ ]);+ $this->server = Server::factory()->create([+ 'team_id' => $this->team->id,+ 'private_key_id' => $this->privateKey->id,+ ]);+ $this->destination = StandaloneDocker::where('server_id', $this->server->id)->first()+ ?? StandaloneDocker::factory()->create(['server_id' => $this->server->id, 'network' => 'coolify-test']);+ });++ test('railpack app shows railpack.json helper text and not nixpacks.toml', function () {+ $application = Application::factory()->create([+ 'environment_id' => $this->environment->id,+ 'destination_id' => $this->destination->id,+ 'destination_type' => StandaloneDocker::class,+ 'build_pack' => 'railpack',+ 'static_image' => 'nginx:alpine',+ 'base_directory' => '/',+ 'is_http_basic_auth_enabled' => false,+ 'redirect' => 'no',+ ]);++ Livewire::test(General::class, ['application' => $application])+ ->assertSuccessful()+ ->assertSee('railpack.json')+ ->assertDontSee('nixpacks.toml');+ });++ test('nixpacks app shows nixpacks.toml helper text and not railpack.json', function () {+ $application = Application::factory()->create([+ 'environment_id' => $this->environment->id,+ 'destination_id' => $this->destination->id,+ 'destination_type' => StandaloneDocker::class,+ 'build_pack' => 'nixpacks',+ 'static_image' => 'nginx:alpine',+ 'base_directory' => '/',+ 'is_http_basic_auth_enabled' => false,+ 'redirect' => 'no',+ ]);++ Livewire::test(General::class, ['application' => $application])+ ->assertSuccessful()+ ->assertSee('nixpacks.toml')+ ->assertDontSee('railpack.json');+ });+});