Merge remote-tracking branch 'origin/next' into feat/noindex-domains

tests/Feature/Api/ApplicationBuildSecretsSettingApiTest.php

@@ -0,0 +1,257 @@
+<?php
+
+use App\Models\Application;
+use App\Models\Environment;
+use App\Models\GithubApp;
+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 Illuminate\Support\Facades\Http;
+use Illuminate\Support\Facades\Storage;
+
+uses(RefreshDatabase::class);
+
+beforeEach(function () {
+    Storage::fake('ssh-keys');
+    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]);
+
+    $this->bearerToken = $this->user->createToken('build-secrets-api-test', ['*'])->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]);
+    $this->application = Application::factory()->create([
+        'environment_id' => $this->environment->id,
+        'destination_id' => $this->destination->id,
+        'destination_type' => $this->destination->getMorphClass(),
+    ]);
+});
+
+function buildSecretsApiHeaders(string $bearerToken): array
+{
+    return [
+        'Authorization' => 'Bearer '.$bearerToken,
+        'Content-Type' => 'application/json',
+    ];
+}
+
+function buildSecretsGithubPrivateKey(): string
+{
+    $key = openssl_pkey_new([
+        'private_key_bits' => 2048,
+        'private_key_type' => OPENSSL_KEYTYPE_RSA,
+    ]);
+
+    openssl_pkey_export($key, $privateKey);
+
+    return $privateKey;
+}
+
+describe('PATCH /api/v1/applications/{uuid} use_build_secrets', function () {
+    test('updates the application setting', function () {
+        expect($this->application->settings->use_build_secrets)->toBeFalse();
+
+        $this->withHeaders(buildSecretsApiHeaders($this->bearerToken))
+            ->patchJson("/api/v1/applications/{$this->application->uuid}", [
+                'use_build_secrets' => true,
+            ])
+            ->assertOk();
+
+        expect($this->application->fresh()->settings->use_build_secrets)->toBeTrue();
+
+        $this->withHeaders(buildSecretsApiHeaders($this->bearerToken))
+            ->patchJson("/api/v1/applications/{$this->application->uuid}", [
+                'use_build_secrets' => false,
+            ])
+            ->assertOk();
+
+        expect($this->application->fresh()->settings->use_build_secrets)->toBeFalse();
+    });
+
+    test('rejects non boolean values', function () {
+        $this->withHeaders(buildSecretsApiHeaders($this->bearerToken))
+            ->patchJson("/api/v1/applications/{$this->application->uuid}", [
+                'use_build_secrets' => 'not-a-boolean',
+            ])
+            ->assertUnprocessable()
+            ->assertJsonValidationErrors('use_build_secrets');
+    });
+
+    test('does not change the setting when omitted', function () {
+        $this->application->settings->update(['use_build_secrets' => true]);
+
+        $this->withHeaders(buildSecretsApiHeaders($this->bearerToken))
+            ->patchJson("/api/v1/applications/{$this->application->uuid}", [
+                'name' => 'updated-name',
+            ])
+            ->assertOk();
+
+        expect($this->application->fresh()->settings->use_build_secrets)->toBeTrue();
+    });
+});
+
+describe('POST /api/v1/applications/public use_build_secrets', function () {
+    test('creates an application with the requested build secrets setting', function (bool $useBuildSecrets) {
+        $response = $this->withHeaders(buildSecretsApiHeaders($this->bearerToken))
+            ->postJson('/api/v1/applications/public', [
+                'project_uuid' => $this->project->uuid,
+                'environment_uuid' => $this->environment->uuid,
+                'server_uuid' => $this->server->uuid,
+                'git_repository' => 'https://gitlab.com/coolify/build-secrets-test',
+                'git_branch' => 'main',
+                'build_pack' => 'nixpacks',
+                'ports_exposes' => '3000',
+                'use_build_secrets' => $useBuildSecrets,
+                'autogenerate_domain' => false,
+            ])
+            ->assertCreated();
+
+        $application = Application::where('uuid', $response->json('uuid'))->firstOrFail();
+
+        expect($application->settings->use_build_secrets)->toBe($useBuildSecrets);
+    })->with([
+        'enabled' => true,
+        'disabled' => false,
+    ]);
+
+    test('rejects non boolean values', function () {
+        $this->withHeaders(buildSecretsApiHeaders($this->bearerToken))
+            ->postJson('/api/v1/applications/public', [
+                'project_uuid' => $this->project->uuid,
+                'environment_uuid' => $this->environment->uuid,
+                'server_uuid' => $this->server->uuid,
+                'git_repository' => 'https://gitlab.com/coolify/build-secrets-test',
+                'git_branch' => 'main',
+                'build_pack' => 'nixpacks',
+                'ports_exposes' => '3000',
+                'use_build_secrets' => 'not-a-boolean',
+                'autogenerate_domain' => false,
+            ])
+            ->assertUnprocessable()
+            ->assertJsonValidationErrors('use_build_secrets');
+    });
+});
+
+describe('other application creation endpoints use_build_secrets', function () {
+    test('creates a Dockerfile application with build secrets enabled', function () {
+        $response = $this->withHeaders(buildSecretsApiHeaders($this->bearerToken))
+            ->postJson('/api/v1/applications/dockerfile', [
+                'project_uuid' => $this->project->uuid,
+                'environment_uuid' => $this->environment->uuid,
+                'server_uuid' => $this->server->uuid,
+                'dockerfile' => base64_encode("FROM nginx:alpine\nEXPOSE 80"),
+                'use_build_secrets' => true,
+                'autogenerate_domain' => false,
+            ])
+            ->assertCreated();
+
+        $application = Application::where('uuid', $response->json('uuid'))->firstOrFail();
+
+        expect($application->settings->use_build_secrets)->toBeTrue();
+    });
+
+    test('creates a Docker image application with build secrets enabled', function () {
+        $response = $this->withHeaders(buildSecretsApiHeaders($this->bearerToken))
+            ->postJson('/api/v1/applications/dockerimage', [
+                'project_uuid' => $this->project->uuid,
+                'environment_uuid' => $this->environment->uuid,
+                'server_uuid' => $this->server->uuid,
+                'docker_registry_image_name' => 'nginx',
+                'docker_registry_image_tag' => 'alpine',
+                'ports_exposes' => '80',
+                'use_build_secrets' => true,
+                'autogenerate_domain' => false,
+            ])
+            ->assertCreated();
+
+        $application = Application::where('uuid', $response->json('uuid'))->firstOrFail();
+
+        expect($application->settings->use_build_secrets)->toBeTrue();
+    });
+
+    test('creates a private deploy key application with build secrets enabled', function () {
+        $privateKey = PrivateKey::factory()->create(['team_id' => $this->team->id]);
+
+        $response = $this->withHeaders(buildSecretsApiHeaders($this->bearerToken))
+            ->postJson('/api/v1/applications/private-deploy-key', [
+                'project_uuid' => $this->project->uuid,
+                'environment_uuid' => $this->environment->uuid,
+                'server_uuid' => $this->server->uuid,
+                'private_key_uuid' => $privateKey->uuid,
+                'git_repository' => 'git@gitlab.com:coolify/build-secrets-test.git',
+                'git_branch' => 'main',
+                'build_pack' => 'nixpacks',
+                'ports_exposes' => '3000',
+                'use_build_secrets' => true,
+                'autogenerate_domain' => false,
+            ])
+            ->assertCreated();
+
+        $application = Application::where('uuid', $response->json('uuid'))->firstOrFail();
+
+        expect($application->settings->use_build_secrets)->toBeTrue();
+    });
+
+    test('creates a private GitHub App application with build secrets enabled', function () {
+        $privateKey = PrivateKey::create([
+            'name' => 'GitHub App Key',
+            'private_key' => buildSecretsGithubPrivateKey(),
+            'team_id' => $this->team->id,
+        ]);
+        $githubApp = GithubApp::create([
+            'name' => 'Build Secrets GitHub App',
+            'api_url' => 'https://api.github.com',
+            'html_url' => 'https://github.com',
+            'app_id' => 12345,
+            'installation_id' => 67890,
+            'client_id' => 'build-secrets-client-id',
+            'client_secret' => 'build-secrets-client-secret',
+            'webhook_secret' => 'build-secrets-webhook-secret',
+            'private_key_id' => $privateKey->id,
+            'team_id' => $this->team->id,
+            'is_system_wide' => false,
+            'is_public' => false,
+        ]);
+
+        Http::fake([
+            'https://api.github.com/zen' => Http::response('Keep it logically awesome.', 200, [
+                'Date' => now()->toRfc7231String(),
+            ]),
+            'https://api.github.com/app/installations/67890/access_tokens' => Http::response([
+                'token' => 'github-installation-token',
+            ], 201),
+            'https://api.github.com/repos/coolify/build-secrets-test' => Http::response([
+                'id' => 123456,
+            ]),
+        ]);
+
+        $response = $this->withHeaders(buildSecretsApiHeaders($this->bearerToken))
+            ->postJson('/api/v1/applications/private-github-app', [
+                'project_uuid' => $this->project->uuid,
+                'environment_uuid' => $this->environment->uuid,
+                'server_uuid' => $this->server->uuid,
+                'github_app_uuid' => $githubApp->uuid,
+                'git_repository' => 'coolify/build-secrets-test',
+                'git_branch' => 'main',
+                'build_pack' => 'nixpacks',
+                'ports_exposes' => '3000',
+                'use_build_secrets' => true,
+                'autogenerate_domain' => false,
+            ])
+            ->assertCreated();
+
+        $application = Application::where('uuid', $response->json('uuid'))->firstOrFail();
+
+        expect($application->settings->use_build_secrets)->toBeTrue();
+    });
+});

tests/Feature/Api/ApplicationSettingsApiTest.php

@@ -0,0 +1,183 @@
+<?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\Facades\Queue;
+
+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]);
+
+    $this->bearerToken = $this->user->createToken('application-settings-api-test', ['*'])->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]);
+    $this->application = Application::factory()->create([
+        'environment_id' => $this->environment->id,
+        'destination_id' => $this->destination->id,
+        'destination_type' => $this->destination->getMorphClass(),
+    ]);
+});
+
+function applicationSettingsApiHeaders(string $bearerToken): array
+{
+    return [
+        'Authorization' => 'Bearer '.$bearerToken,
+        'Content-Type' => 'application/json',
+    ];
+}
+
+function recommendedApplicationSettingsPayload(): array
+{
+    return [
+        'is_git_submodules_enabled' => false,
+        'is_git_lfs_enabled' => false,
+        'is_git_shallow_clone_enabled' => false,
+        'disable_build_cache' => true,
+        'inject_build_args_to_dockerfile' => false,
+        'include_source_commit_in_build' => true,
+        'is_env_sorting_enabled' => true,
+        'is_pr_deployments_public_enabled' => true,
+        'stop_grace_period' => 45,
+        'docker_images_to_keep' => 7,
+        'is_gzip_enabled' => false,
+        'is_stripprefix_enabled' => false,
+        'is_raw_compose_deployment_enabled' => true,
+    ];
+}
+
+test('GET /api/v1/applications/{uuid} includes settings without internal metadata', function () {
+    $this->application->settings->update(recommendedApplicationSettingsPayload());
+
+    $this->withHeaders(applicationSettingsApiHeaders($this->bearerToken))
+        ->getJson("/api/v1/applications/{$this->application->uuid}")
+        ->assertOk()
+        ->assertJsonPath('settings.disable_build_cache', true)
+        ->assertJsonPath('settings.stop_grace_period', 45)
+        ->assertJsonMissingPath('settings.id')
+        ->assertJsonMissingPath('settings.application_id')
+        ->assertJsonMissingPath('settings.created_at')
+        ->assertJsonMissingPath('settings.updated_at');
+});
+
+test('PATCH /api/v1/applications/{uuid} updates application settings', function () {
+    $this->application->update(['build_pack' => 'dockercompose']);
+
+    $this->withHeaders(applicationSettingsApiHeaders($this->bearerToken))
+        ->patchJson("/api/v1/applications/{$this->application->uuid}", recommendedApplicationSettingsPayload())
+        ->assertOk();
+
+    $settings = $this->application->fresh()->settings;
+
+    foreach (recommendedApplicationSettingsPayload() as $field => $value) {
+        expect($settings->{$field})->toBe($value);
+    }
+});
+
+test('application creation accepts application settings', function () {
+    Queue::fake();
+
+    $response = $this->withHeaders(applicationSettingsApiHeaders($this->bearerToken))
+        ->postJson('/api/v1/applications/public', array_merge([
+            'project_uuid' => $this->project->uuid,
+            'environment_uuid' => $this->environment->uuid,
+            'server_uuid' => $this->server->uuid,
+            'git_repository' => 'https://gitlab.com/coolify/application-settings-test',
+            'git_branch' => 'main',
+            'build_pack' => 'dockercompose',
+            'autogenerate_domain' => false,
+        ], recommendedApplicationSettingsPayload()))
+        ->assertCreated();
+
+    $settings = Application::where('uuid', $response->json('uuid'))->firstOrFail()->settings;
+
+    foreach (recommendedApplicationSettingsPayload() as $field => $value) {
+        expect($settings->{$field})->toBe($value);
+    }
+});
+
+test('proxy settings regenerate managed labels', function () {
+    $this->application->settings->update([
+        'is_container_label_readonly_enabled' => true,
+        'is_gzip_enabled' => true,
+        'is_stripprefix_enabled' => true,
+    ]);
+    $this->application->update(['custom_labels' => base64_encode('sentinel-label=true')]);
+
+    $this->withHeaders(applicationSettingsApiHeaders($this->bearerToken))
+        ->patchJson("/api/v1/applications/{$this->application->uuid}", [
+            'is_gzip_enabled' => false,
+            'is_stripprefix_enabled' => false,
+        ])
+        ->assertOk();
+
+    expect(base64_decode($this->application->fresh()->custom_labels))->not->toContain('sentinel-label=true');
+});
+
+test('rejects invalid boolean application settings', function () {
+    $this->withHeaders(applicationSettingsApiHeaders($this->bearerToken))
+        ->patchJson("/api/v1/applications/{$this->application->uuid}", [
+            'disable_build_cache' => 'not-a-boolean',
+        ])
+        ->assertUnprocessable()
+        ->assertJsonValidationErrors('disable_build_cache');
+});
+
+test('validates stop grace period bounds', function (int $stopGracePeriod) {
+    $this->withHeaders(applicationSettingsApiHeaders($this->bearerToken))
+        ->patchJson("/api/v1/applications/{$this->application->uuid}", [
+            'stop_grace_period' => $stopGracePeriod,
+        ])
+        ->assertUnprocessable()
+        ->assertJsonValidationErrors('stop_grace_period');
+})->with([
+    'below minimum' => 0,
+    'above maximum' => 3601,
+]);
+
+test('validates Docker image retention bounds', function (int $dockerImagesToKeep) {
+    $this->withHeaders(applicationSettingsApiHeaders($this->bearerToken))
+        ->patchJson("/api/v1/applications/{$this->application->uuid}", [
+            'docker_images_to_keep' => $dockerImagesToKeep,
+        ])
+        ->assertUnprocessable()
+        ->assertJsonValidationErrors('docker_images_to_keep');
+})->with([
+    'below minimum' => -1,
+    'above maximum' => 101,
+]);
+
+test('stop grace period can be reset to null', function () {
+    $this->application->settings->update(['stop_grace_period' => 45]);
+
+    $this->withHeaders(applicationSettingsApiHeaders($this->bearerToken))
+        ->patchJson("/api/v1/applications/{$this->application->uuid}", [
+            'stop_grace_period' => null,
+        ])
+        ->assertOk();
+
+    expect($this->application->fresh()->settings->stop_grace_period)->toBeNull();
+});
+
+test('raw compose deployment can only be enabled for Docker Compose applications', function () {
+    $this->withHeaders(applicationSettingsApiHeaders($this->bearerToken))
+        ->patchJson("/api/v1/applications/{$this->application->uuid}", [
+            'is_raw_compose_deployment_enabled' => true,
+        ])
+        ->assertUnprocessable()
+        ->assertJsonValidationErrors('is_raw_compose_deployment_enabled');
+});

tests/Feature/ApplicationNoindexDomainsTest.php

@@ -3,7 +3,11 @@
 use App\Livewire\Project\Application\General;
 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;
@@ -81,9 +85,26 @@ describe('Application noindex domains', function () {
     });
 
     test('the Livewire toggle persists the flag', function () {
+        InstanceSettings::unguarded(function () {
+            InstanceSettings::updateOrCreate(['id' => 0], []);
+        });
+        $privateKey = PrivateKey::factory()->create(['team_id' => $this->team->id]);
+        $server = Server::factory()->create([
+            'team_id' => $this->team->id,
+            'private_key_id' => $privateKey->id,
+        ]);
+        $destination = StandaloneDocker::where('server_id', $server->id)->first()
+            ?? StandaloneDocker::factory()->create(['server_id' => $server->id]);
+
         $application = Application::factory()->create([
             'environment_id' => $this->environment->id,
+            'destination_id' => $destination->id,
+            'destination_type' => StandaloneDocker::class,
             'fqdn' => 'https://prod.example.com,https://staging.example.com',
+            'static_image' => 'nginx:alpine',
+            'base_directory' => '/',
+            'is_http_basic_auth_enabled' => false,
+            'redirect' => 'no',
         ]);
 
         Livewire::test(General::class, ['application' => $application])

tests/Feature/ApplicationSourceCrossTeamTest.php

@@ -11,6 +11,7 @@ use App\Models\Server;
 use App\Models\Team;
 use App\Models\User;
 use Illuminate\Foundation\Testing\RefreshDatabase;
+use Illuminate\Support\Facades\Http;
 use Livewire\Features\SupportLockedProperties\CannotUpdateLockedPropertyException;
 use Livewire\Livewire;
 use Visus\Cuid2\Cuid2;
@@ -117,6 +118,48 @@ test('changeSource rejects an arbitrary class as source_type', function () {
     expect($this->applicationA->source_type)->not->toBe(Server::class);
 });
 
+test('changeSource dispatches configuration changed for an owned source', function () {
+    Http::fake([
+        'https://api.github.com/repos/*' => Http::response(['id' => 123]),
+    ]);
+    $source = GithubApp::create([
+        'name' => 'own-github-app',
+        'team_id' => $this->teamA->id,
+        'api_url' => 'https://api.github.com',
+        'html_url' => 'https://github.com',
+        'is_public' => true,
+    ]);
+    $this->applicationA->update(['git_repository' => 'coollabsio/coolify']);
+
+    Livewire::test(Source::class, ['application' => $this->applicationA->fresh()])
+        ->call('changeSource', $source->id, GithubApp::class)
+        ->assertDispatched('configurationChanged');
+});
+
+test('changeSource dispatches configuration changed when repository metadata lookup fails after persistence', function () {
+    Http::fake([
+        'https://api.github.com/repos/*' => Http::response(
+            ['message' => 'Unavailable'],
+            503,
+            ['X-RateLimit-Reset' => now()->addMinute()->timestamp],
+        ),
+    ]);
+    $source = GithubApp::create([
+        'name' => 'own-unavailable-github-app',
+        'team_id' => $this->teamA->id,
+        'api_url' => 'https://api.github.com',
+        'html_url' => 'https://github.com',
+        'is_public' => true,
+    ]);
+    $this->applicationA->update(['git_repository' => 'coollabsio/coolify']);
+
+    Livewire::test(Source::class, ['application' => $this->applicationA->fresh()])
+        ->call('changeSource', $source->id, GithubApp::class)
+        ->assertDispatched('configurationChanged');
+
+    expect($this->applicationA->refresh()->source_id)->toBe($source->id);
+});
+
 test('privateKeyId is locked so submit() cannot persist a client-supplied foreign id', function () {
     // Without #[Locked], an attacker could POST {"updates": {"privateKeyId": <foreign_id>},
     // "calls": [{"method": "submit"}]} and have syncData(true) write the foreign id through

tests/Feature/Livewire/Project/Application/AdvancedStopGracePeriodTest.php

@@ -16,6 +16,8 @@ uses(RefreshDatabase::class);
 function createApplicationForAdvancedStopGracePeriodTest(): Application
 {
     $team = Team::factory()->create();
+    $team->members()->attach(auth()->id(), ['role' => 'owner']);
+    session(['currentTeam' => $team]);
     $server = Server::factory()->create(['team_id' => $team->id]);
     $project = Project::factory()->create(['team_id' => $team->id]);
     $environment = Environment::factory()->create(['project_id' => $project->id]);
@@ -43,7 +45,8 @@ it('saves a valid stop grace period', function () {
         ->set('stopGracePeriod', '300')
         ->call('saveStopGracePeriod')
         ->assertHasNoErrors()
-        ->assertDispatched('success');
+        ->assertDispatched('success')
+        ->assertDispatched('configurationChanged');
 
     expect($application->settings()->first()->stop_grace_period)->toBe(300);
 });

tests/Feature/Livewire/Project/Application/ConfigurationChangeRefreshEventsTest.php

@@ -0,0 +1,44 @@
+<?php
+
+use App\Livewire\Project\Shared\EnvironmentVariable\All as EnvironmentVariableAll;
+use App\Livewire\Project\Shared\HealthChecks;
+use App\Models\Application;
+use App\Models\Environment;
+use App\Models\InstanceSettings;
+use App\Models\Project;
+use App\Models\Team;
+use App\Models\User;
+use Illuminate\Foundation\Testing\RefreshDatabase;
+use Livewire\Livewire;
+
+uses(RefreshDatabase::class);
+
+beforeEach(function () {
+    InstanceSettings::unguarded(function () {
+        InstanceSettings::updateOrCreate(['id' => 0], []);
+    });
+    $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]);
+
+    $project = Project::factory()->create(['team_id' => $this->team->id]);
+    $environment = Environment::factory()->create(['project_id' => $project->id]);
+    $this->application = Application::factory()->create(['environment_id' => $environment->id])->refresh();
+});
+
+it('refreshes configuration changes after health check saves', function (string $method) {
+    Livewire::test(HealthChecks::class, ['resource' => $this->application])
+        ->call($method)
+        ->assertHasNoErrors()
+        ->assertDispatched('configurationChanged');
+})->with(['instantSave', 'submit', 'toggleHealthcheck']);
+
+it('refreshes configuration changes after environment variable settings are saved', function () {
+    Livewire::test(EnvironmentVariableAll::class, ['resource' => $this->application])
+        ->set('use_build_secrets', true)
+        ->call('instantSave')
+        ->assertHasNoErrors()
+        ->assertDispatched('configurationChanged');
+});

tests/Feature/Livewire/Project/Application/SwarmConfigurationChangedTest.php

@@ -0,0 +1,36 @@
+<?php
+
+use App\Livewire\Project\Application\Swarm;
+use App\Models\Application;
+use App\Models\Environment;
+use App\Models\Project;
+use App\Models\Server;
+use App\Models\Team;
+use App\Models\User;
+use Illuminate\Foundation\Testing\RefreshDatabase;
+use Livewire\Livewire;
+
+uses(RefreshDatabase::class);
+
+it('dispatches configuration changed when Swarm settings are saved', function (string $method) {
+    $team = Team::factory()->create();
+    $user = User::factory()->create();
+    $team->members()->attach($user->id, ['role' => 'owner']);
+    $server = Server::factory()->create(['team_id' => $team->id]);
+    $project = Project::factory()->create(['team_id' => $team->id]);
+    $environment = Environment::factory()->create(['project_id' => $project->id]);
+    $application = Application::factory()->create([
+        'environment_id' => $environment->id,
+        'destination_id' => $server->standaloneDockers()->firstOrFail()->id,
+        'destination_type' => $server->standaloneDockers()->firstOrFail()->getMorphClass(),
+        'swarm_replicas' => 1,
+    ]);
+
+    $this->actingAs($user);
+
+    Livewire::test(Swarm::class, ['application' => $application])
+        ->set('isSwarmOnlyWorkerNodes', false)
+        ->call($method)
+        ->assertHasNoErrors()
+        ->assertDispatched('configurationChanged');
+})->with(['instantSave', 'submit']);

tests/Feature/Livewire/RailpackLivewireUiTest.php

@@ -118,4 +118,24 @@ uZx9iFkCELtxrh31QJ68AAAAEXNhaWxANzZmZjY2ZDJlMmRkAQIDBA==
             ->assertSee('nixpacks.toml')
             ->assertDontSee('railpack.json');
     });
+
+    test('saving general settings refreshes configuration changes when label reset is disabled', 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',
+        ]);
+        $application->settings->update(['is_container_label_readonly_enabled' => false]);
+
+        Livewire::test(General::class, ['application' => $application->refresh()])
+            ->set('isPreserveRepositoryEnabled', true)
+            ->call('instantSave')
+            ->assertHasNoErrors()
+            ->assertDispatched('configurationChanged');
+    });
 });