tests/Feature/CoolifyDefaultEnvironmentVariablesTest.php
Rama main · réplica de lectura del repositorio original.
<?php
use App\Actions\Database\StartDragonfly;
use App\Actions\Database\StartPostgresql;
use App\Jobs\ApplicationDeploymentJob;
use App\Livewire\Project\Shared\EnvironmentVariable\All;
use App\Models\Application;
use App\Models\ApplicationDeploymentQueue;
use App\Models\Environment;
use App\Models\InstanceSettings;
use App\Models\Project;
use App\Models\Server;
use App\Models\Service;
use App\Models\ServiceApplication;
use App\Models\StandaloneDragonfly;
use App\Models\StandalonePostgresql;
use App\Models\Team;
use App\Models\User;
use Illuminate\Foundation\Testing\RefreshDatabase;
use Illuminate\Support\Facades\Bus;
use Livewire\Livewire;
uses(RefreshDatabase::class);
beforeEach(function () {
InstanceSettings::query()->firstOrCreate(['id' => 0]);
Bus::fake();
$this->team = Team::factory()->create();
$this->server = Server::factory()->create(['team_id' => $this->team->id]);
$this->destination = $this->server->standaloneDockers()->firstOrFail();
$project = Project::factory()->create(['team_id' => $this->team->id, 'name' => 'Shop $live']);
$this->environment = Environment::factory()->create(['project_id' => $project->id, 'name' => 'staging']);
});
function coolifyDefaultsPostgres(array $attributes = []): StandalonePostgresql
{
return StandalonePostgresql::forceCreate([
'uuid' => 'coolify-defaults-db',
'name' => 'Main database',
'image' => 'postgres:16-alpine',
'postgres_password' => 'password',
'environment_id' => test()->environment->id,
'destination_id' => test()->destination->id,
'destination_type' => test()->destination->getMorphClass(),
...$attributes,
]);
}
/**
* @return array<int, string>
*/
function coolifyDefaultsDatabaseEnvironment(object $action, $database): array
{
$action->database = $database->fresh();
return (new ReflectionMethod($action, 'generate_environment_variables'))->invoke($action);
}
/**
* @return array<int, string>
*/
function coolifyDefaultsApplicationEnv(Application $application, bool $forBuildTime = false, ?Server $deploymentServer = null): array
{
$reflection = new ReflectionClass(ApplicationDeploymentJob::class);
$job = $reflection->newInstanceWithoutConstructor();
$queue = Mockery::mock(ApplicationDeploymentQueue::class);
$queue->shouldReceive('addLogEntry')->andReturnNull();
$properties = [
'application' => $application->fresh(),
'application_deployment_queue' => $queue,
'build_pack' => 'nixpacks',
'mainServer' => $deploymentServer ?? $application->destination->server,
'pull_request_id' => 0,
'commit' => 'HEAD',
'branch' => 'main',
'container_name' => 'coolify-defaults-app',
'saved_outputs' => collect(),
];
foreach ($properties as $property => $value) {
$reflection->getProperty($property)->setValue($job, $value);
}
if ($forBuildTime) {
return collect($reflection->getMethod('generate_coolify_env_variables')->invoke($job, true))
->map(fn ($value, $key) => "{$key}={$value}")->values()->all();
}
return collect($reflection->getMethod('generate_runtime_environment_variables')->invoke($job))->all();
}
function coolifyDefaultsApplication(): Application
{
return Application::factory()->create([
'name' => 'My web app',
'environment_id' => test()->environment->id,
'destination_id' => test()->destination->id,
'destination_type' => test()->destination->getMorphClass(),
]);
}
function coolifyDefaultsService(string $environmentYaml = ''): Service
{
$service = Service::factory()->create([
'name' => 'blog',
'environment_id' => test()->environment->id,
'server_id' => test()->server->id,
'destination_id' => test()->destination->id,
'destination_type' => test()->destination->getMorphClass(),
'docker_compose_raw' => "services:\n app:\n image: nginx:latest\n{$environmentYaml}",
]);
ServiceApplication::create(['name' => 'app', 'service_id' => $service->id]);
return $service;
}
test('a database gets the same Coolify variables as other resources, with compose-safe values', function () {
$environment = coolifyDefaultsDatabaseEnvironment(new StartPostgresql, coolifyDefaultsPostgres());
expect($environment)
->toContain('COOLIFY_RESOURCE_UUID=coolify-defaults-db')
->toContain('COOLIFY_CONTAINER_NAME=coolify-defaults-db')
->toContain('COOLIFY_APP_NAME=Main database')
->toContain('COOLIFY_PROJECT_NAME=Shop $$live')
->toContain('COOLIFY_ENVIRONMENT_NAME=staging')
->toContain("COOLIFY_SERVER_IP={$this->server->ip}");
});
test('a Dragonfly database also gets the Coolify variables', function () {
$database = StandaloneDragonfly::forceCreate([
'uuid' => 'coolify-defaults-dragonfly',
'name' => 'Cache',
'image' => 'docker.dragonflydb.io/dragonflydb/dragonfly',
'dragonfly_password' => 'password',
'environment_id' => $this->environment->id,
'destination_id' => $this->destination->id,
'destination_type' => $this->destination->getMorphClass(),
]);
expect(coolifyDefaultsDatabaseEnvironment(new StartDragonfly, $database))
->toContain('COOLIFY_RESOURCE_UUID=coolify-defaults-dragonfly')
->toContain('COOLIFY_APP_NAME=Cache');
});
test('a database variable that the user defines wins over the Coolify variable', function () {
$database = coolifyDefaultsPostgres();
$database->runtime_environment_variables()->create(['key' => 'COOLIFY_APP_NAME', 'value' => 'custom']);
$appNames = collect(coolifyDefaultsDatabaseEnvironment(new StartPostgresql, $database))
->filter(fn ($variable) => str_starts_with($variable, 'COOLIFY_APP_NAME='));
expect($appNames->values()->all())->toBe(['COOLIFY_APP_NAME=custom']);
});
test('a database without the option gets no default variables but keeps its identity variables', function () {
$environment = coolifyDefaultsDatabaseEnvironment(new StartPostgresql, coolifyDefaultsPostgres(['include_coolify_default_variables' => false]));
expect(collect($environment)->first(fn ($variable) => str_starts_with($variable, 'COOLIFY_APP_NAME=')))->toBeNull()
->and(collect($environment)->first(fn ($variable) => str_starts_with($variable, 'COOLIFY_SERVER_IP=')))->toBeNull()
->and($environment)->toContain('COOLIFY_RESOURCE_UUID=coolify-defaults-db');
});
test('an application gets the default variables as quoted lines in its runtime .env file', function () {
$environment = coolifyDefaultsApplicationEnv(coolifyDefaultsApplication());
expect($environment)
->toContain('COOLIFY_APP_NAME="My web app"')
->toContain('COOLIFY_PROJECT_NAME="Shop \\$live"')
->toContain('COOLIFY_ENVIRONMENT_NAME="staging"')
->toContain("COOLIFY_SERVER_IP=\"{$this->server->ip}\"");
});
test('an application on an additional server gets the IP of the server it runs on', function () {
$additionalServer = Server::factory()->create(['team_id' => $this->team->id, 'ip' => '203.0.113.7']);
expect(coolifyDefaultsApplicationEnv(coolifyDefaultsApplication(), deploymentServer: $additionalServer))
->toContain('COOLIFY_SERVER_IP="203.0.113.7"');
});
test('an application build does not get the default variables', function () {
$environment = coolifyDefaultsApplicationEnv(coolifyDefaultsApplication(), forBuildTime: true);
expect(collect($environment)->first(fn ($variable) => str_starts_with($variable, 'COOLIFY_APP_NAME=')))->toBeNull()
->and(collect($environment)->first(fn ($variable) => str_starts_with($variable, 'COOLIFY_RESOURCE_UUID=')))->not->toBeNull();
});
test('an application without the option gets no default variables', function () {
$application = coolifyDefaultsApplication();
$application->settings->update(['include_coolify_default_variables' => false]);
$environment = coolifyDefaultsApplicationEnv($application);
expect(collect($environment)->first(fn ($variable) => str_starts_with($variable, 'COOLIFY_APP_NAME=')))->toBeNull();
});
test('a service variable defined in the compose file wins over the Coolify variable', function () {
$service = coolifyDefaultsService(" environment:\n COOLIFY_APP_NAME: custom\n");
$environment = data_get(serviceParser($service), 'services.app.environment');
expect($environment['COOLIFY_APP_NAME'])->toBe('custom')
->and($environment['COOLIFY_PROJECT_NAME'])->toBe('Shop $$live');
});
test('a service without the option gets no default variables', function () {
$service = coolifyDefaultsService();
$service->forceFill(['include_coolify_default_variables' => false])->save();
$environment = collect(data_get(serviceParser($service->fresh()), 'services.app.environment'));
expect($environment->has('COOLIFY_APP_NAME'))->toBeFalse()
->and($environment->has('COOLIFY_RESOURCE_UUID'))->toBeTrue();
});
test('a team admin turns the option off from the environment variables page', function (string $resourceType) {
$user = User::factory()->create();
$this->team->members()->attach($user, ['role' => 'admin']);
$this->actingAs($user);
$resource = match ($resourceType) {
'application' => coolifyDefaultsApplication(),
'service' => coolifyDefaultsService(),
'database' => coolifyDefaultsPostgres(),
};
Livewire::test(All::class, ['resource' => $resource])
->assertSet('include_coolify_default_variables', true)
->set('include_coolify_default_variables', false)
->call('saveCoolifyDefaultVariables');
$owner = $resource instanceof Application ? $resource->settings->fresh() : $resource->fresh();
expect($owner->include_coolify_default_variables)->toBeFalse();
})->with(['application', 'service', 'database']);
test('a team member cannot change the option', function () {
$user = User::factory()->create();
$this->team->members()->attach($user, ['role' => 'member']);
$this->actingAs($user);
$database = coolifyDefaultsPostgres();
Livewire::test(All::class, ['resource' => $database])
->set('include_coolify_default_variables', false)
->call('saveCoolifyDefaultVariables');
expect($database->fresh()->include_coolify_default_variables)->toBeTrue();
});