Skip to content

Modern Docker Management, Designed for Everyone

22.6 KB
Raw Blame
import { removeApiResource } from '../utils/fetch.util';
import { waitForDialogReady } from '../utils/playwright.util';
import { test, expect, type Locator, type Page, type Route } from '../fixtures/test.fixture';

type MockEnvironment = {
	id: string;
	name: string;
	apiUrl: string;
	status: 'online' | 'standby' | 'offline' | 'error' | 'pending';
	enabled: boolean;
	isEdge: boolean;
};

type MockActivity = {
	id: string;
	environmentId: string;
	sourceEnvironmentId?: string;
	sourceEnvironmentName?: string;
	type: string;
	status: string;
	resourceType?: string;
	resourceId?: string;
	resourceName?: string;
	latestMessage?: string;
	startedAt: string;
	createdAt: string;
	updatedAt?: string;
};

type MockUser = {
	id: string;
	username: string;
	roleAssignments: never[];
	permissionsByEnv: Record<string, string[]>;
	isGlobalAdmin: boolean;
	createdAt: string;
};

const localEnvironment: MockEnvironment = {
	id: '0',
	name: 'Local',
	apiUrl: 'unix:///var/run/docker.sock',
	status: 'online',
	enabled: true,
	isEdge: false
};

const remoteEnvironment: MockEnvironment = {
	id: 'remote-activity-test',
	name: 'Remote Lab',
	apiUrl: 'https://remote.example.invalid',
	status: 'offline',
	enabled: true,
	isEdge: false
};

function paginated<T>(data: T[]) {
	return {
		success: true,
		data,
		pagination: {
			totalPages: 1,
			totalItems: data.length,
			currentPage: 1,
			itemsPerPage: data.length,
			grandTotalItems: data.length
		}
	};
}

function activity(
	id: string,
	environmentId: string,
	sourceEnvironmentName: string,
	resourceName: string,
	minutesAgo: number
): MockActivity {
	const timestamp = new Date(Date.now() - minutesAgo * 60_000).toISOString();
	return {
		id,
		environmentId,
		sourceEnvironmentId: environmentId,
		sourceEnvironmentName,
		type: 'resource_action',
		status: 'success',
		resourceType: 'network',
		resourceId: resourceName,
		resourceName,
		latestMessage: `${resourceName} completed`,
		startedAt: timestamp,
		createdAt: timestamp,
		updatedAt: timestamp
	};
}

function activityEnvironmentIdFromPath(pathname: string): string | null {
	const match = pathname.match(/^\/api\/environments\/([^/]+)\/activities$/);
	return match ? decodeURIComponent(match[1]) : null;
}

async function preserveLocalEnvironmentSelection(page: Page) {
	await page.addInitScript(() => {
		localStorage.removeItem('selectedEnvironmentId');
	});
}

async function mockEnvironmentList(page: Page, environments: MockEnvironment[]) {
	await page.context().route(/\/api\/environments(?:\?.*)?$/, async (route) => {
		await route.fulfill({
			status: 200,
			contentType: 'application/json',
			body: JSON.stringify(paginated(environments))
		});
	});
}

async function mockCurrentUser(page: Page, resolveUser: () => MockUser) {
	await page.context().route(/\/api\/auth\/me$/, async (route) => {
		await route.fulfill({
			status: 200,
			contentType: 'application/json',
			body: JSON.stringify({ success: true, data: resolveUser() })
		});
	});
}

function user(id: string, permissionsByEnv: Record<string, string[]>): MockUser {
	return {
		id,
		username: id,
		roleAssignments: [],
		permissionsByEnv,
		isGlobalAdmin: false,
		createdAt: new Date().toISOString()
	};
}

function aggregatedActivityStreamBody(
	activitiesByEnvironment: Record<string, MockActivity[]>,
	failedEnvironmentIds: Set<string>
): string {
	const timestamp = new Date().toISOString();
	const events: string[] = [];
	for (const [environmentId, activities] of Object.entries(activitiesByEnvironment)) {
		events.push(
			JSON.stringify({
				channel: 'activities',
				activity: { type: 'snapshot', environmentId, activities, timestamp },
				timestamp
			})
		);
	}
	for (const environmentId of failedEnvironmentIds) {
		events.push(
			JSON.stringify({
				channel: 'activities',
				activity: { type: 'error', environmentId, error: 'environment unavailable', timestamp },
				timestamp
			})
		);
	}
	return events.map((event) => `data: ${event}\n\n`).join('');
}

async function mockActivityReads(
	page: Page,
	activitiesByEnvironment: Record<string, MockActivity[]>,
	failedEnvironmentIds = new Set<string>(),
	failedActivityStatus = 503,
	readEnvironmentIds?: string[]
) {
	await page.context().route(/\/api\/stream(?:\?.*)?$/, async (route: Route) => {
		const channels = new URL(route.request().url()).searchParams.get('channels')?.split(',') ?? [];
		await route.fulfill({
			status: 200,
			contentType: 'text/event-stream',
			body: channels.includes('activities')
				? aggregatedActivityStreamBody(activitiesByEnvironment, failedEnvironmentIds)
				: ''
		});
	});

	await page
		.context()
		.route(/\/api\/environments\/[^/]+\/activities(?:\?.*)?$/, async (route: Route) => {
			const url = new URL(route.request().url());
			const environmentId = activityEnvironmentIdFromPath(url.pathname);
			if (!environmentId) {
				await route.continue();
				return;
			}
			readEnvironmentIds?.push(environmentId);

			if (failedEnvironmentIds.has(environmentId)) {
				await route.fulfill({
					status: failedActivityStatus,
					contentType: 'application/json',
					body: JSON.stringify({
						success: false,
						message: 'environment unavailable',
						detail: 'permission denied: activities:read'
					})
				});
				return;
			}

			await route.fulfill({
				status: 200,
				contentType: 'application/json',
				body: JSON.stringify(paginated(activitiesByEnvironment[environmentId] ?? []))
			});
		});
}

function waitForActivityRead(page: Page, environmentId: string) {
	return page.waitForResponse((response) => {
		const url = new URL(response.url());
		return (
			response.request().method() === 'GET' &&
			activityEnvironmentIdFromPath(url.pathname) === environmentId
		);
	});
}

function extractActivityId(value: unknown): string | undefined {
	if (!value || typeof value !== 'object') return undefined;

	const activityId = (value as { activityId?: unknown }).activityId;
	if (typeof activityId === 'string' && activityId.trim()) return activityId;

	if (Array.isArray(value)) {
		for (const item of value) {
			const nested = extractActivityId(item);
			if (nested) return nested;
		}
		return undefined;
	}

	for (const item of Object.values(value)) {
		const nested = extractActivityId(item);
		if (nested) return nested;
	}

	return undefined;
}

function extractCreatedNetworkId(value: unknown): string | undefined {
	if (!value || typeof value !== 'object') return undefined;
	const data = (value as { data?: { id?: unknown } }).data;
	return typeof data?.id === 'string' ? data.id : undefined;
}

async function createNetworkViaUI(page: Page, networkName: string) {
	await page.goto('/networks');
	await page.waitForLoadState('load');
	await expect(page.getByRole('heading', { level: 1, name: 'Networks' })).toBeVisible();

	await page.getByRole('button', { name: 'Create Network' }).first().click();
	const dialog = page.getByRole('dialog');
	await waitForDialogReady(dialog);
	await dialog.locator('#network-name').fill(networkName);

	const createRequest = page.waitForResponse(
		(response) => {
			const request = response.request();
			return (
				request.method() === 'POST' &&
				/\/api\/environments\/[^/]+\/networks$/.test(new URL(response.url()).pathname)
			);
		},
		{ timeout: 15000 }
	);

	await dialog.getByRole('button', { name: 'Create Network' }).click();
	const createResponse = await createRequest;
	const body = await createResponse.json();
	if (!createResponse.ok()) {
		throw new Error(`Failed to create network ${networkName}: ${createResponse.status()}`);
	}

	return {
		activityId: extractActivityId(body),
		networkId: extractCreatedNetworkId(body)
	};
}

async function openActivityCenter(page: Page) {
	await page.getByRole('button', { name: 'Open activity center' }).first().click();
	const activityCenter = page.getByRole('dialog', { name: 'Activity Center' });
	await expect(activityCenter).toBeVisible();
	return activityCenter;
}

function activityRow(activityCenter: Locator, text: string) {
	return activityCenter
		.locator('button[aria-label="Activity Center"]')
		.filter({ hasText: text })
		.first();
}

function waitForActivityStream(page: Page) {
	return page.waitForResponse((response) => {
		const url = new URL(response.url());
		const channels = url.searchParams.get('channels')?.split(',') ?? [];
		return (
			response.request().method() === 'GET' &&
			url.pathname === '/api/stream' &&
			channels.includes('activities')
		);
	});
}

test.describe('Activity Center', () => {
	test('scopes aggregate activity and dashboard work to permitted environments', async ({
		page
	}) => {
		const onlineRemoteEnvironment = { ...remoteEnvironment, status: 'online' as const };
		const scopedUser = user('scoped-stream-user', {
			global: [],
			'0': ['dashboard:read'],
			'remote-activity-test': ['activities:read']
		});
		const activityReads: string[] = [];
		const dashboardRequests: string[] = [];
		const statsSockets: string[] = [];

		await preserveLocalEnvironmentSelection(page);
		await mockCurrentUser(page, () => scopedUser);
		await mockEnvironmentList(page, [localEnvironment, onlineRemoteEnvironment]);
		await mockActivityReads(
			page,
			{
				'0': [activity('local-activity', '0', 'Local', 'local-network', 5)],
				'remote-activity-test': [
					activity('remote-activity', 'remote-activity-test', 'Remote Lab', 'remote-network', 1)
				]
			},
			new Set(),
			503,
			activityReads
		);
		page.on('request', (request) => {
			const pathname = new URL(request.url()).pathname;
			if (/^\/api\/environments\/[^/]+\/dashboard$/.test(pathname)) {
				dashboardRequests.push(pathname);
			}
		});
		page.on('websocket', (socket) => statsSockets.push(new URL(socket.url()).pathname));

		const activityStream = waitForActivityStream(page);
		await page.goto('/dashboard');
		await activityStream;
		await expect(page.getByRole('button', { name: 'Card view', exact: true })).toBeVisible();

		const activityCenter = await openActivityCenter(page);
		await expect(activityRow(activityCenter, 'remote-network')).toBeVisible();
		await expect(activityRow(activityCenter, 'local-network')).toHaveCount(0);
		await expect.poll(() => activityReads).toContain('remote-activity-test');
		expect(activityReads).not.toContain('0');
		await expect.poll(() => dashboardRequests).toContain('/api/environments/0/dashboard');
		expect(dashboardRequests).not.toContain('/api/environments/remote-activity-test/dashboard');
		expect(statsSockets).not.toContain('/api/environments/remote-activity-test/ws/system/stats');
	});

	test('does not mount the activity center without an effective read scope', async ({ page }) => {
		const streamChannels: string[][] = [];

		await preserveLocalEnvironmentSelection(page);
		await mockCurrentUser(page, () =>
			user('dashboard-only-user', {
				global: [],
				'0': ['dashboard:read']
			})
		);
		await mockEnvironmentList(page, [localEnvironment]);
		page.on('request', (request) => {
			const url = new URL(request.url());
			if (url.pathname === '/api/stream') {
				streamChannels.push(url.searchParams.get('channels')?.split(',') ?? []);
			}
		});

		await page.goto('/dashboard');
		await expect(page.getByRole('button', { name: 'Card view', exact: true })).toBeVisible();
		await expect(page.getByRole('button', { name: 'Open activity center' })).toHaveCount(0);
		await expect
			.poll(() => streamChannels.some((channels) => channels.includes('dashboard')))
			.toBe(true);
		expect(streamChannels.some((channels) => channels.includes('activities'))).toBe(false);
	});

	test('keeps an in-flight activity snapshot when the dashboard channel restarts the stream', async ({
		page
	}) => {
		const snapshotActivity = activity('delayed-activity', '0', 'Local', 'delayed-network', 1);
		let markSnapshotRequested!: () => void;
		const snapshotRequested = new Promise<void>((resolve) => {
			markSnapshotRequested = resolve;
		});
		let releaseSnapshot!: () => void;
		const snapshotReleased = new Promise<void>((resolve) => {
			releaseSnapshot = resolve;
		});

		await preserveLocalEnvironmentSelection(page);
		await mockCurrentUser(page, () => user('snapshot-generation-user', { global: ['*'] }));
		await mockEnvironmentList(page, [localEnvironment]);
		await page.context().route(/\/api\/stream(?:\?.*)?$/, async (route) => {
			await route.fulfill({ status: 503, contentType: 'application/json', body: '{}' });
		});
		await page.context().route(/\/api\/environments\/0\/activities(?:\?.*)?$/, async (route) => {
			markSnapshotRequested();
			await snapshotReleased;
			await route.fulfill({
				status: 200,
				contentType: 'application/json',
				body: JSON.stringify(paginated([snapshotActivity]))
			});
		});

		await page.goto('/containers');
		await snapshotRequested;
		const dashboardStream = page.waitForRequest((request) => {
			const url = new URL(request.url());
			const channels = url.searchParams.get('channels')?.split(',') ?? [];
			return (
				url.pathname === '/api/stream' &&
				channels.includes('activities') &&
				channels.includes('dashboard')
			);
		});
		try {
			await Promise.all([
				dashboardStream,
				page.getByRole('link', { name: 'Dashboard', exact: true }).click()
			]);
			releaseSnapshot();

			const activityCenter = await openActivityCenter(page);
			await expect(activityRow(activityCenter, 'delayed-network')).toBeVisible();
		} finally {
			releaseSnapshot();
		}
	});

	test('clears activity state when the authenticated user changes', async ({ page }) => {
		let activeUserId = 'user-a';
		const streamedUsers: string[] = [];
		const permissions = { global: ['*'] };

		await preserveLocalEnvironmentSelection(page);
		await mockCurrentUser(page, () => user(activeUserId, permissions));
		await mockEnvironmentList(page, [localEnvironment]);
		await page.context().route(/\/api\/stream(?:\?.*)?$/, async (route) => {
			const channels =
				new URL(route.request().url()).searchParams.get('channels')?.split(',') ?? [];
			const requestedBy = activeUserId;
			if (channels.includes('activities')) {
				streamedUsers.push(requestedBy);
			}
			const resourceName = requestedBy === 'user-a' ? 'user-a-private-activity' : 'user-b-activity';
			await route.fulfill({
				status: 200,
				contentType: 'text/event-stream',
				body: channels.includes('activities')
					? aggregatedActivityStreamBody(
							{ '0': [activity(`${requestedBy}-activity`, '0', 'Local', resourceName, 1)] },
							new Set()
						)
					: ''
			});
		});
		await page.context().route(/\/api\/environments\/0\/activities(?:\?.*)?$/, async (route) => {
			const requestedBy = activeUserId;
			const resourceName = requestedBy === 'user-a' ? 'user-a-private-activity' : 'user-b-activity';
			await route.fulfill({
				status: 200,
				contentType: 'application/json',
				body: JSON.stringify(
					paginated([activity(`${requestedBy}-activity`, '0', 'Local', resourceName, 1)])
				)
			});
		});
		await page.context().route(/\/api\/auth\/logout$/, async (route) => {
			await route.fulfill({
				status: 200,
				contentType: 'application/json',
				body: JSON.stringify({ success: true })
			});
		});
		await page.context().route(/\/api\/auth\/login$/, async (route) => {
			activeUserId = 'user-b';
			await route.fulfill({
				status: 200,
				contentType: 'application/json',
				body: JSON.stringify({
					success: true,
					status: 'authenticated',
					user: user(activeUserId, permissions)
				})
			});
		});

		await page.goto('/dashboard');
		let activityCenter = await openActivityCenter(page);
		await expect(activityRow(activityCenter, 'user-a-private-activity')).toBeVisible();

		await page.goto('/logout');
		await page.waitForURL(/\/login/);
		await page.getByLabel('Username').fill('user-b');
		await page.getByLabel('Password').fill('password');
		await page.getByRole('button', { name: 'Sign in to Arcane', exact: true }).click();
		await page.waitForURL('/dashboard');
		await expect.poll(() => streamedUsers).toContain('user-b');
		activityCenter = await openActivityCenter(page);
		await expect(activityRow(activityCenter, 'user-b-activity')).toBeVisible();
		await expect(activityRow(activityCenter, 'user-a-private-activity')).toHaveCount(0);
	});

	test('shows activity from every configured environment', async ({ page }) => {
		await preserveLocalEnvironmentSelection(page);
		await mockEnvironmentList(page, [localEnvironment, remoteEnvironment]);
		await mockActivityReads(page, {
			'0': [activity('local-activity', '0', 'Local', 'local-network', 5)],
			'remote-activity-test': [
				activity('remote-activity', 'remote-activity-test', 'Remote Lab', 'remote-network', 1)
			]
		});

		const activityStream = waitForActivityStream(page);
		await page.goto('/dashboard');
		await activityStream;
		await page.waitForLoadState('load');

		const activityCenter = await openActivityCenter(page);

		await expect(activityRow(activityCenter, 'local-network')).toBeVisible();
		await expect(activityRow(activityCenter, 'remote-network')).toBeVisible();
		await expect(activityCenter.getByText('Local').first()).toBeVisible();
		await expect(activityCenter.getByText('Remote Lab').first()).toBeVisible();
		await expect(page.getByRole('button', { name: 'Local', exact: false }).first()).toBeVisible();
	});

	test('keeps reachable activity visible when a configured environment fails', async ({ page }) => {
		await preserveLocalEnvironmentSelection(page);
		await mockEnvironmentList(page, [localEnvironment, remoteEnvironment]);
		await mockActivityReads(
			page,
			{
				'0': [activity('local-activity', '0', 'Local', 'local-network', 5)]
			},
			new Set(['remote-activity-test']),
			403
		);

		const activityStream = waitForActivityStream(page);
		const remoteActivityRead = waitForActivityRead(page, 'remote-activity-test');
		await page.goto('/dashboard');
		await activityStream;
		await remoteActivityRead;
		await page.waitForLoadState('load');
		await page.waitForTimeout(250);

		await expect(
			page.locator('li[data-sonner-toast]').filter({ hasText: 'Access denied' })
		).toHaveCount(0, {
			timeout: 500
		});

		const activityCenter = await openActivityCenter(page);

		await expect(activityRow(activityCenter, 'local-network')).toBeVisible();
		await expect(activityCenter.getByText('Could not load activity from Remote Lab')).toBeVisible();
	});

	test('clears history for every configured environment and reports partial failures', async ({
		page
	}) => {
		await preserveLocalEnvironmentSelection(page);
		await mockEnvironmentList(page, [localEnvironment, remoteEnvironment]);
		await mockActivityReads(page, {
			'0': [activity('local-activity', '0', 'Local', 'local-network', 5)],
			'remote-activity-test': [
				activity('remote-activity', 'remote-activity-test', 'Remote Lab', 'remote-network', 1)
			]
		});

		const deletedEnvironments: string[] = [];
		await page.route(/\/api\/environments\/[^/]+\/activities\/history$/, async (route) => {
			const url = new URL(route.request().url());
			const match = url.pathname.match(/^\/api\/environments\/([^/]+)\/activities\/history$/);
			const environmentId = match ? decodeURIComponent(match[1]) : '';
			deletedEnvironments.push(environmentId);

			if (environmentId === 'remote-activity-test') {
				await route.fulfill({
					status: 503,
					contentType: 'application/json',
					body: JSON.stringify({ success: false, message: 'environment unavailable' })
				});
				return;
			}

			await route.fulfill({
				status: 200,
				contentType: 'application/json',
				body: JSON.stringify({ success: true, data: { deleted: 2 } })
			});
		});

		const activityStream = waitForActivityStream(page);
		await page.goto('/dashboard');
		await activityStream;
		await page.waitForLoadState('load');

		const activityCenter = await openActivityCenter(page);
		await activityCenter.getByRole('button', { name: 'More options' }).click();
		await page.getByRole('menuitem', { name: 'Clear history' }).click();
		await page.getByRole('button', { name: 'Clear History', exact: true }).last().click();

		await expect.poll(() => deletedEnvironments.sort()).toEqual(['0', 'remote-activity-test']);
		await expect(
			page.getByText('Activity history partially cleared. Succeeded for 1. Failed for Remote Lab.')
		).toBeVisible();
	});

	test('shows completed activity details for UI-triggered work', async ({ page }) => {
		const networkName = `e2e-activity-network-${Date.now()}`;
		let networkId: string | undefined;

		await preserveLocalEnvironmentSelection(page);

		try {
			const created = await createNetworkViaUI(page, networkName);
			networkId = created.networkId;
			expect(networkId, 'Created network must have an ID').toBeTruthy();
			expect(created.activityId).toBeTruthy();

			const [environmentResponse, userResponse] = await Promise.all([
				page.request.get('/api/environments/0'),
				page.request.get('/api/auth/me')
			]);
			expect(environmentResponse.ok()).toBeTruthy();
			expect(userResponse.ok()).toBeTruthy();
			const { data: environment }: { data: { name: string } } = await environmentResponse.json();
			const { data: currentUser }: { data: { username: string; displayName?: string } } =
				await userResponse.json();
			const startedBy = currentUser.displayName?.trim() || currentUser.username;
			expect(environment.name).toBeTruthy();
			expect(startedBy).toBeTruthy();

			const activityCenter = await openActivityCenter(page);
			await expect(activityCenter.getByPlaceholder('Search activity…')).toBeVisible();
			await expect(activityCenter.getByRole('button', { name: 'Filter' })).toBeVisible();
			await expect(activityCenter.getByText('History', { exact: true })).toBeVisible();

			const activityItem = activityRow(activityCenter, networkName);
			await expect(activityItem).toBeVisible();
			await expect(activityItem).toContainText('Resource Action');
			await expect(activityItem).toContainText('Success');
			await expect(activityItem.getByText(environment.name, { exact: true })).toBeVisible();
			await expect(
				activityItem.getByText(`Started by ${startedBy}`, { exact: true })
			).toBeVisible();

			await activityItem.click();
			await expect(activityItem).toHaveAttribute('aria-expanded', 'true');
			// Attribution stays in the row header when its output is expanded.
			await expect(activityItem.getByText(environment.name, { exact: true })).toBeVisible();
			await expect(
				activityItem.getByText(`Started by ${startedBy}`, { exact: true })
			).toBeVisible();
			const detailPanelId = await activityItem.getAttribute('aria-controls');
			expect(detailPanelId).toBeTruthy();
			const detailPanel = activityCenter.locator(`[id=${JSON.stringify(detailPanelId)}]`);
			await expect(detailPanel).toHaveAttribute('data-state', 'open');
			await expect(detailPanel.getByText('Output', { exact: true })).toBeVisible();
			// The output pane shows the activity's messages verbatim; step labels
			// (e.g. "Creating network") are no longer rendered in the detail panel.
			await expect(detailPanel.getByText('Network created successfully').first()).toBeVisible();
		} finally {
			await removeApiResource(
				page,
				`/api/environments/0/networks/${encodeURIComponent(networkId ?? networkName)}`
			);
		}
	});
});