440 lines
16 KiB
PHP
440 lines
16 KiB
PHP
<?php
|
|
|
|
use App\Livewire\Project\CloneMe;
|
|
use App\Livewire\Project\New\Select as ResourceSelect;
|
|
use App\Livewire\Project\New\SimpleDockerfile;
|
|
use App\Livewire\Project\Shared\ResourceOperations;
|
|
use App\Livewire\Server\Show;
|
|
use App\Models\Application;
|
|
use App\Models\Environment;
|
|
use App\Models\InstanceSettings;
|
|
use App\Models\Project;
|
|
use App\Models\Server;
|
|
use App\Models\Service;
|
|
use App\Models\StandaloneDocker;
|
|
use App\Models\StandalonePostgresql;
|
|
use App\Models\SwarmDocker;
|
|
use App\Models\Team;
|
|
use App\Models\User;
|
|
use Illuminate\Foundation\Testing\RefreshDatabase;
|
|
use Illuminate\Support\Facades\Blade;
|
|
use Livewire\Livewire;
|
|
|
|
uses(RefreshDatabase::class);
|
|
|
|
beforeEach(function () {
|
|
Server::flushIdentityMap();
|
|
InstanceSettings::forceCreate(['id' => 0, 'is_api_enabled' => true]);
|
|
|
|
$this->team = Team::factory()->create();
|
|
$this->user = User::factory()->create();
|
|
$this->team->members()->attach($this->user->id, ['role' => 'owner']);
|
|
session(['currentTeam' => $this->team]);
|
|
|
|
$this->token = $this->user->createToken('resource-hosting-test', ['*']);
|
|
$this->bearerToken = $this->token->plainTextToken;
|
|
|
|
$this->server = Server::factory()->create(['team_id' => $this->team->id]);
|
|
$this->server->settings()->update([
|
|
'is_reachable' => true,
|
|
'is_usable' => true,
|
|
'is_build_server' => false,
|
|
'is_swarm_worker' => false,
|
|
'force_disabled' => false,
|
|
]);
|
|
$this->server->refresh()->load('settings');
|
|
|
|
$this->destination = StandaloneDocker::where('server_id', $this->server->id)->firstOrFail();
|
|
$this->project = Project::factory()->create(['team_id' => $this->team->id]);
|
|
$this->environment = Environment::factory()->create(['project_id' => $this->project->id]);
|
|
});
|
|
|
|
afterEach(function () {
|
|
Server::flushIdentityMap();
|
|
});
|
|
|
|
function resourceHostingApiHeaders(string $token): array
|
|
{
|
|
return [
|
|
'Authorization' => 'Bearer '.$token,
|
|
'Content-Type' => 'application/json',
|
|
];
|
|
}
|
|
|
|
function createResourceHostingTestApplication(object $test): Application
|
|
{
|
|
return Application::factory()->create([
|
|
'environment_id' => $test->environment->id,
|
|
'destination_id' => $test->destination->id,
|
|
'destination_type' => $test->destination->getMorphClass(),
|
|
]);
|
|
}
|
|
|
|
test('only eligible deployment servers can host resources', function () {
|
|
expect($this->server->canHostResources())->toBeTrue();
|
|
|
|
$this->server->settings->update(['is_build_server' => true]);
|
|
|
|
expect($this->server->fresh()->canHostResources())->toBeFalse();
|
|
});
|
|
|
|
test('a populated build server can be changed back to a deployment server', function () {
|
|
createResourceHostingTestApplication($this);
|
|
$this->server->settings()->update(['is_build_server' => true]);
|
|
|
|
Livewire::actingAs($this->user)
|
|
->test(Show::class, ['server_uuid' => $this->server->uuid])
|
|
->assertSet('isBuildServer', true)
|
|
->assertSet('isBuildServerLocked', false)
|
|
->set('isBuildServer', false)
|
|
->assertHasNoErrors();
|
|
|
|
expect((bool) $this->server->settings->fresh()->is_build_server)->toBeFalse();
|
|
});
|
|
|
|
test('a populated deployment server cannot be changed into a build server', function () {
|
|
createResourceHostingTestApplication($this);
|
|
|
|
Livewire::actingAs($this->user)
|
|
->test(Show::class, ['server_uuid' => $this->server->uuid])
|
|
->assertSet('isBuildServer', false)
|
|
->assertSet('isBuildServerLocked', true)
|
|
->set('isBuildServer', true)
|
|
->assertSet('isBuildServer', false);
|
|
|
|
expect((bool) $this->server->settings->fresh()->is_build_server)->toBeFalse();
|
|
});
|
|
|
|
test('resource selection keeps excluded build servers visible for explanation', function () {
|
|
$this->actingAs($this->user);
|
|
$buildServer = Server::factory()->create(['team_id' => $this->team->id]);
|
|
$buildServer->settings()->update([
|
|
'is_reachable' => true,
|
|
'is_usable' => true,
|
|
'is_build_server' => true,
|
|
'is_swarm_worker' => false,
|
|
'force_disabled' => false,
|
|
]);
|
|
|
|
$component = new ResourceSelect;
|
|
$component->loadServers();
|
|
|
|
expect($component->servers->pluck('id'))->toContain($this->server->id)
|
|
->not->toContain($buildServer->id)
|
|
->and(Server::isUsableBuildServer()->pluck('id'))->toContain($buildServer->id)
|
|
->not->toContain($this->server->id)
|
|
->and($component->buildServers->pluck('id'))->toContain($buildServer->id)
|
|
->and($component->allServers->pluck('id'))->toContain($this->server->id, $buildServer->id);
|
|
});
|
|
|
|
test('resource selection does not show the empty server message when only build servers are available', function () {
|
|
$html = Blade::render(
|
|
file_get_contents(resource_path('views/livewire/project/new/select.blade.php')),
|
|
[
|
|
'current_step' => 'servers',
|
|
'onlyBuildServerAvailable' => true,
|
|
'servers' => collect(),
|
|
'buildServers' => collect(),
|
|
],
|
|
);
|
|
|
|
expect($html)
|
|
->toContain('Only build servers are available')
|
|
->not->toContain('No validated & reachable servers found');
|
|
});
|
|
|
|
test('application API rejects build servers', function () {
|
|
$this->server->settings()->update(['is_build_server' => true]);
|
|
|
|
$this->withHeaders(resourceHostingApiHeaders($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' => 'latest',
|
|
'ports_exposes' => '80',
|
|
'instant_deploy' => false,
|
|
])
|
|
->assertUnprocessable()
|
|
->assertInvalid(['server_uuid']);
|
|
|
|
expect(Application::count())->toBe(0);
|
|
});
|
|
|
|
test('database API rejects build servers', function () {
|
|
$this->server->settings()->update(['is_build_server' => true]);
|
|
|
|
$this->withHeaders(resourceHostingApiHeaders($this->bearerToken))
|
|
->postJson('/api/v1/databases/postgresql', [
|
|
'project_uuid' => $this->project->uuid,
|
|
'environment_uuid' => $this->environment->uuid,
|
|
'server_uuid' => $this->server->uuid,
|
|
'instant_deploy' => false,
|
|
])
|
|
->assertUnprocessable()
|
|
->assertInvalid(['server_uuid']);
|
|
});
|
|
|
|
test('service API rejects build servers', function () {
|
|
$this->server->settings()->update(['is_build_server' => true]);
|
|
|
|
$this->withHeaders(resourceHostingApiHeaders($this->bearerToken))
|
|
->postJson('/api/v1/services', [
|
|
'project_uuid' => $this->project->uuid,
|
|
'environment_uuid' => $this->environment->uuid,
|
|
'server_uuid' => $this->server->uuid,
|
|
'docker_compose_raw' => base64_encode("services:\n app:\n image: nginx:latest"),
|
|
'instant_deploy' => false,
|
|
])
|
|
->assertUnprocessable()
|
|
->assertInvalid(['server_uuid']);
|
|
});
|
|
|
|
test('server API rejects enabling build mode when resources exist', function () {
|
|
createResourceHostingTestApplication($this);
|
|
$originalName = $this->server->name;
|
|
|
|
$this->withHeaders(resourceHostingApiHeaders($this->bearerToken))
|
|
->patchJson('/api/v1/servers/'.$this->server->uuid, [
|
|
'is_build_server' => true,
|
|
'name' => 'should-not-be-saved',
|
|
])
|
|
->assertUnprocessable()
|
|
->assertInvalid(['is_build_server']);
|
|
|
|
expect((bool) $this->server->settings->fresh()->is_build_server)->toBeFalse()
|
|
->and($this->server->fresh()->name)->toBe($originalName);
|
|
});
|
|
|
|
test('server API allows keeping build mode enabled when resources exist', function () {
|
|
createResourceHostingTestApplication($this);
|
|
$this->server->settings()->update(['is_build_server' => true]);
|
|
|
|
$this->withHeaders(resourceHostingApiHeaders($this->bearerToken))
|
|
->patchJson('/api/v1/servers/'.$this->server->uuid, [
|
|
'is_build_server' => true,
|
|
])
|
|
->assertCreated();
|
|
|
|
expect((bool) $this->server->settings->fresh()->is_build_server)->toBeTrue();
|
|
});
|
|
|
|
test('server API allows disabling build mode when resources exist', function () {
|
|
createResourceHostingTestApplication($this);
|
|
$this->server->settings()->update(['is_build_server' => true]);
|
|
|
|
$this->withHeaders(resourceHostingApiHeaders($this->bearerToken))
|
|
->patchJson('/api/v1/servers/'.$this->server->uuid, [
|
|
'is_build_server' => false,
|
|
'name' => 'Deployment Server',
|
|
])
|
|
->assertCreated();
|
|
|
|
expect((bool) $this->server->settings->fresh()->is_build_server)->toBeFalse()
|
|
->and($this->server->fresh()->name)->toBe('Deployment Server');
|
|
});
|
|
|
|
test('resource APIs still accept deployment servers', function () {
|
|
$headers = resourceHostingApiHeaders($this->bearerToken);
|
|
|
|
$this->withHeaders($headers)
|
|
->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' => 'latest',
|
|
'ports_exposes' => '80',
|
|
'instant_deploy' => false,
|
|
])
|
|
->assertCreated();
|
|
|
|
$this->withHeaders($headers)
|
|
->postJson('/api/v1/databases/postgresql', [
|
|
'project_uuid' => $this->project->uuid,
|
|
'environment_uuid' => $this->environment->uuid,
|
|
'server_uuid' => $this->server->uuid,
|
|
'instant_deploy' => false,
|
|
])
|
|
->assertCreated();
|
|
|
|
$this->withHeaders($headers)
|
|
->postJson('/api/v1/services', [
|
|
'project_uuid' => $this->project->uuid,
|
|
'environment_uuid' => $this->environment->uuid,
|
|
'server_uuid' => $this->server->uuid,
|
|
'docker_compose_raw' => base64_encode("services:\n app:\n image: nginx:latest"),
|
|
'instant_deploy' => false,
|
|
])
|
|
->assertCreated();
|
|
});
|
|
|
|
test('a crafted web request cannot create a resource on a build server', function () {
|
|
$this->actingAs($this->user);
|
|
$this->server->settings()->update(['is_build_server' => true]);
|
|
|
|
$url = route('project.resource.create', [
|
|
'project_uuid' => $this->project->uuid,
|
|
'environment_uuid' => $this->environment->uuid,
|
|
]).'?type=postgresql&destination='.$this->destination->uuid.'&server_id='.$this->server->id.'&database_image=postgres:16-alpine';
|
|
|
|
$this->get($url)->assertRedirectToRoute('dashboard');
|
|
|
|
expect(StandalonePostgresql::count())->toBe(0);
|
|
});
|
|
|
|
test('a manipulated resource form cannot submit to a build server', function () {
|
|
$this->actingAs($this->user);
|
|
$this->server->settings()->update(['is_build_server' => true]);
|
|
$routeParameters = [
|
|
'project_uuid' => $this->project->uuid,
|
|
'environment_uuid' => $this->environment->uuid,
|
|
];
|
|
|
|
expect(fn () => Livewire::withUrlParams(['destination' => $this->destination->uuid])
|
|
->test(SimpleDockerfile::class, $routeParameters)
|
|
->set('dockerfile', "FROM nginx\nCMD [\"nginx\"]\n")
|
|
->call('submit'))
|
|
->toThrow(Exception::class, 'Destination not found.');
|
|
|
|
expect(Application::count())->toBe(0);
|
|
});
|
|
|
|
test('a manipulated project clone cannot target a build server', function () {
|
|
$this->actingAs($this->user);
|
|
$this->server->settings()->update(['is_build_server' => true]);
|
|
$projectCount = Project::count();
|
|
|
|
Livewire::test(CloneMe::class, [
|
|
'project_uuid' => $this->project->uuid,
|
|
'environment_uuid' => $this->environment->uuid,
|
|
])
|
|
->set('selectedDestination', $this->destination->uuid)
|
|
->set('newName', 'blocked-clone')
|
|
->call('clone', 'project');
|
|
|
|
expect(Project::count())->toBe($projectCount);
|
|
});
|
|
|
|
test('project clone resolves overlapping destination ids by uuid', function () {
|
|
$this->actingAs($this->user);
|
|
createResourceHostingTestApplication($this);
|
|
$swarmDestination = SwarmDocker::create([
|
|
'server_id' => $this->server->id,
|
|
'name' => 'Swarm destination',
|
|
'network' => 'swarm-network',
|
|
]);
|
|
|
|
expect($swarmDestination->id)->toBe($this->destination->id);
|
|
|
|
Livewire::test(CloneMe::class, [
|
|
'project_uuid' => $this->project->uuid,
|
|
'environment_uuid' => $this->environment->uuid,
|
|
])
|
|
->set('selectedDestination', $swarmDestination->uuid)
|
|
->set('newName', 'swarm-clone')
|
|
->call('clone', 'project')
|
|
->assertNotDispatched('error');
|
|
|
|
$clonedApplication = Project::where('name', 'swarm-clone')
|
|
->firstOrFail()
|
|
->environments()
|
|
->where('name', $this->environment->name)
|
|
->firstOrFail()
|
|
->applications()
|
|
->firstOrFail();
|
|
|
|
expect($clonedApplication->destination_id)->toBe($swarmDestination->id)
|
|
->and($clonedApplication->destination_type)->toBe(SwarmDocker::class)
|
|
->and($clonedApplication->destination->is($swarmDestination))->toBeTrue();
|
|
});
|
|
|
|
test('project clone assigns services to the selected server', function () {
|
|
$this->actingAs($this->user);
|
|
Service::factory()->create([
|
|
'environment_id' => $this->environment->id,
|
|
'server_id' => $this->server->id,
|
|
'destination_id' => $this->destination->id,
|
|
'destination_type' => $this->destination->getMorphClass(),
|
|
]);
|
|
$targetServer = Server::factory()->create(['team_id' => $this->team->id]);
|
|
$targetServer->settings()->update(['is_build_server' => false]);
|
|
$targetDestination = StandaloneDocker::where('server_id', $targetServer->id)->firstOrFail();
|
|
|
|
Livewire::test(CloneMe::class, [
|
|
'project_uuid' => $this->project->uuid,
|
|
'environment_uuid' => $this->environment->uuid,
|
|
])
|
|
->set('selectedDestination', $targetDestination->uuid)
|
|
->set('newName', 'service-clone')
|
|
->call('clone', 'project')
|
|
->assertNotDispatched('error');
|
|
|
|
$clonedService = Project::where('name', 'service-clone')
|
|
->firstOrFail()
|
|
->environments()
|
|
->where('name', $this->environment->name)
|
|
->firstOrFail()
|
|
->services()
|
|
->firstOrFail();
|
|
|
|
expect($clonedService->server_id)->toBe($targetServer->id)
|
|
->and($clonedService->destination_id)->toBe($targetDestination->id)
|
|
->and($targetServer->fresh()->isEmpty())->toBeFalse();
|
|
});
|
|
|
|
test('a manipulated clone request cannot target a build server', function () {
|
|
$this->actingAs($this->user);
|
|
$source = createResourceHostingTestApplication($this);
|
|
$buildServer = Server::factory()->create(['team_id' => $this->team->id]);
|
|
$buildServer->settings()->update([
|
|
'is_reachable' => true,
|
|
'is_usable' => true,
|
|
'is_build_server' => true,
|
|
]);
|
|
$buildDestination = StandaloneDocker::where('server_id', $buildServer->id)->firstOrFail();
|
|
|
|
Livewire::test(ResourceOperations::class, ['resource' => $source])
|
|
->call('cloneTo', $buildDestination->uuid)
|
|
->assertHasErrors(['destination_id']);
|
|
|
|
expect(Application::count())->toBe(1);
|
|
});
|
|
|
|
test('resource clone resolves overlapping destination ids by uuid', function () {
|
|
$this->actingAs($this->user);
|
|
$source = createResourceHostingTestApplication($this);
|
|
$swarmDestination = SwarmDocker::create([
|
|
'server_id' => $this->server->id,
|
|
'name' => 'Swarm clone target',
|
|
'network' => 'swarm-clone-target',
|
|
]);
|
|
|
|
expect($swarmDestination->id)->toBe($this->destination->id);
|
|
|
|
Livewire::test(ResourceOperations::class, ['resource' => $source])
|
|
->call('cloneTo', $swarmDestination->uuid);
|
|
|
|
$clone = Application::whereKeyNot($source->id)->firstOrFail();
|
|
|
|
expect($clone->destination_id)->toBe($swarmDestination->id)
|
|
->and($clone->destination_type)->toBe(SwarmDocker::class)
|
|
->and($clone->destination->is($swarmDestination))->toBeTrue();
|
|
});
|
|
|
|
test('resource operations explains why build servers cannot be clone targets', function () {
|
|
$this->actingAs($this->user);
|
|
$source = createResourceHostingTestApplication($this);
|
|
$buildServer = Server::factory()->create(['team_id' => $this->team->id, 'name' => 'Dedicated Builder']);
|
|
$buildServer->settings()->update([
|
|
'is_reachable' => true,
|
|
'is_usable' => true,
|
|
'is_build_server' => true,
|
|
]);
|
|
|
|
Livewire::test(ResourceOperations::class, ['resource' => $source])
|
|
->assertSet('buildServers', fn ($servers) => $servers->contains('id', $buildServer->id))
|
|
->assertSee('Dedicated Builder')
|
|
->assertSee('Build server — cannot host resources');
|
|
});
|