Skip to content

Commit 5972fc9

Browse files
xbabalovxbabalov
committed
Merge branch 'createRootlessMachine' of https://github.com/xbabalov/podman-desktop into createRootlessMachineSigned-off-by: xbabalov <[email protected]>
2 parents 4143c2f + d6ca424 commit 5972fc9

6 files changed

+53
-91
lines changed

‎tests/playwright/src/model/pages/create-machine-page.ts

+8-14
Original file line numberDiff line numberDiff line change
@@ -25,34 +25,28 @@ import { ResourcesPage } from './resources-page';
2525

2626
export class CreateMachinePage extends BasePage {
2727
readonly heading: Locator;
28+
readonly machineCreationForm: MachineCreationForm;
2829
readonly closeButton: Locator;
29-
readonly createMachineButton: Locator;
3030

3131
constructor(page: Page) {
3232
super(page);
3333
this.heading = this.page.getByRole('heading', { name: 'Create Podman Machine' });
34+
this.machineCreationForm = new MachineCreationForm(this.page);
3435
this.closeButton = this.page.getByRole('button', { name: 'Close' });
35-
this.createMachineButton = this.page.getByRole('button', { name: 'Create' });
3636
}
3737

3838
async createMachine(
3939
machineName: string,
40-
isRootful?: boolean,
41-
enableUserNet?: boolean,
42-
startNow?: boolean,
43-
setAsDefault: boolean = true,
40+
{ isRootful = true, enableUserNet = false, startNow = true, setAsDefault = true },
4441
): Promise<ResourcesPage> {
45-
const machineCreationForm = new MachineCreationForm(this.page);
46-
await machineCreationForm.configureMachine(machineName, isRootful, enableUserNet, startNow);
42+
await this.machineCreationForm.setupAndCreateMachine(machineName, isRootful, enableUserNet, startNow);
43+
await this.page.waitForTimeout(60_000);
4744

48-
await playExpect(this.createMachineButton).toBeEnabled();
49-
await this.createMachineButton.click();
45+
const successfulCreationMessage = this.page.getByText('Successful operation');
46+
const goBackToResourcesButton = this.page.getByRole('button', { name: 'Go back to resources' });
5047

51-
// wait for machine creation and handle connections
5248
await this.handleConnectionDialog(machineName, setAsDefault);
5349

54-
const successfulCreationMessage = this.page.getByText('Successful operation');
55-
const goBackToResourcesButton = this.page.getByRole('button', { name: 'Go back to resources' });
5650
await playExpect(successfulCreationMessage).toBeVisible({ timeout: 10_000 });
5751
await playExpect(goBackToResourcesButton).toBeVisible();
5852
await goBackToResourcesButton.click();
@@ -62,7 +56,7 @@ export class CreateMachinePage extends BasePage {
6256

6357
async handleConnectionDialog(machineName: string, setAsDefault: boolean): Promise<void> {
6458
const connectionDialog = this.page.getByRole('dialog', { name: 'Podman' });
65-
await playExpect(connectionDialog).toBeVisible({ timeout: 60_000 });
59+
await playExpect(connectionDialog).toBeVisible({ timeout: 30_000 });
6660

6761
const dialogMessage = connectionDialog.getByLabel('Dialog Message');
6862
await playExpect(dialogMessage).toHaveText(

‎tests/playwright/src/model/pages/forms/machine-creation-form.ts

+20-17
Original file line numberDiff line numberDiff line change
@@ -16,7 +16,8 @@
1616
* SPDX-License-Identifier: Apache-2.0
1717
***********************************************************************/
1818

19-
import type { expect as playExpect, Locator, Page } from '@playwright/test';
19+
import type { Locator, Page } from '@playwright/test';
20+
import { expect as playExpect } from '@playwright/test';
2021

2122
import { BasePage } from '../base-page';
2223

@@ -31,6 +32,7 @@ export class MachineCreationForm extends BasePage {
3132
readonly rootPriviledgesCheckbox: Locator;
3233
readonly userModeNetworkingCheckbox: Locator;
3334
readonly startNowCheckbox: Locator;
35+
readonly createMachineButton: Locator;
3436

3537
constructor(page: Page) {
3638
super(page);
@@ -50,30 +52,31 @@ export class MachineCreationForm extends BasePage {
5052
name: 'User mode networking',
5153
});
5254
this.startNowCheckbox = this.podmanMachineConfiguration.getByRole('checkbox', { name: 'Start the machine now' });
55+
this.createMachineButton = this.podmanMachineConfiguration.getByRole('button', { name: 'Create' });
5356
}
5457

55-
async configureMachine(
58+
async setupAndCreateMachine(
5659
machineName: string,
57-
isRootful: boolean = true,
58-
enableUserNet: boolean = false,
59-
startNow: boolean = true,
60+
isRootful: boolean,
61+
enableUserNet: boolean,
62+
startNow: boolean,
6063
): Promise<void> {
61-
await playExpect(this.podmanMachineConfiguration).toBeVisible();
64+
await playExpect(this.podmanMachineConfiguration).toBeVisible({ timeout: 10_000 });
65+
await this.podmanMachineName.clear();
6266
await this.podmanMachineName.fill(machineName);
6367

64-
if (isRootful !== (await this.rootPriviledgesCheckbox.isChecked())) {
65-
await this.rootPriviledgesCheckbox.locator('..').click();
66-
playExpect(await this.rootPriviledgesCheckbox.isChecked()).toBe(isRootful);
67-
}
68+
await this.ensureCheckboxState(isRootful, this.rootPriviledgesCheckbox);
69+
await this.ensureCheckboxState(enableUserNet, this.userModeNetworkingCheckbox);
70+
await this.ensureCheckboxState(startNow, this.startNowCheckbox);
6871

69-
if (enableUserNet !== (await this.userModeNetworkingCheckbox.isChecked())) {
70-
await this.userModeNetworkingCheckbox.locator('..').click();
71-
playExpect(await this.userModeNetworkingCheckbox.isChecked()).toBe(enableUserNet);
72-
}
72+
await playExpect(this.createMachineButton).toBeEnabled();
73+
await this.createMachineButton.click();
74+
}
7375

74-
if (startNow !== (await this.startNowCheckbox.isChecked())) {
75-
await this.startNowCheckbox.locator('..').click();
76-
playExpect(await this.startNowCheckbox.isChecked()).toBe(startNow);
76+
async ensureCheckboxState(desiredState: boolean, checkbox: Locator): Promise<void> {
77+
if (desiredState !== (await checkbox.isChecked())) {
78+
await checkbox.locator('..').click();
79+
playExpect(await checkbox.isChecked()).toBe(desiredState);
7780
}
7881
}
7982
}

‎tests/playwright/src/model/pages/podman-onboarding-page.ts

+3-27
Original file line numberDiff line numberDiff line change
@@ -18,21 +18,13 @@
1818

1919
import type { Locator, Page } from '@playwright/test';
2020

21+
import { MachineCreationForm } from './forms/machine-creation-form';
2122
import { OnboardingPage } from './onboarding-page';
2223

2324
export class PodmanOnboardingPage extends OnboardingPage {
2425
readonly podmanAutostartToggle: Locator;
2526
readonly createMachinePageTitle: Locator;
26-
readonly podmanMachineConfiguration: Locator;
27-
readonly podmanMachineName: Locator;
28-
readonly podmanMachineCPUs: Locator;
29-
readonly podmanMachineMemory: Locator;
30-
readonly podmanMachineDiskSize: Locator;
31-
readonly podmanMachineImage: Locator;
32-
readonly podmanMachineRootfulCheckbox: Locator;
33-
readonly podmanMachineUserModeNetworkingCheckbox: Locator;
34-
readonly podmanMachineStartAfterCreationCheckbox: Locator;
35-
readonly podmanMachineCreateButton: Locator;
27+
readonly machineCreationForm: MachineCreationForm;
3628
readonly podmanMachineShowLogsButton: Locator;
3729
readonly goBackButton: Locator;
3830

@@ -42,23 +34,7 @@ export class PodmanOnboardingPage extends OnboardingPage {
4234
name: 'Autostart Podman engine when launching Podman Desktop',
4335
});
4436
this.createMachinePageTitle = this.onboardingComponent.getByLabel('title');
45-
this.podmanMachineConfiguration = this.page.getByRole('form', { name: 'Properties Information' });
46-
this.podmanMachineName = this.podmanMachineConfiguration.getByRole('textbox', { name: 'Name' });
47-
this.podmanMachineCPUs = this.podmanMachineConfiguration.getByRole('slider', { name: 'CPU(s)' });
48-
this.podmanMachineMemory = this.podmanMachineConfiguration.getByRole('slider', { name: 'Memory' });
49-
this.podmanMachineDiskSize = this.podmanMachineConfiguration.getByRole('slider', { name: 'Disk size' });
50-
this.podmanMachineImage = this.podmanMachineConfiguration.getByRole('textbox', { name: 'Image Path (Optional)' });
51-
this.podmanMachineRootfulCheckbox = this.podmanMachineConfiguration.getByRole('checkbox', {
52-
name: 'Machine with root privileges',
53-
});
54-
this.podmanMachineUserModeNetworkingCheckbox = this.podmanMachineConfiguration.getByRole('checkbox', {
55-
name: 'User mode networking',
56-
exact: false,
57-
});
58-
this.podmanMachineStartAfterCreationCheckbox = this.podmanMachineConfiguration.getByRole('checkbox', {
59-
name: 'Start the machine now',
60-
});
61-
this.podmanMachineCreateButton = this.podmanMachineConfiguration.getByRole('button', { name: 'Create' });
37+
this.machineCreationForm = new MachineCreationForm(this.page);
6238
this.podmanMachineShowLogsButton = this.mainPage.getByRole('button', { name: 'Show Logs' });
6339
this.goBackButton = this.page.getByRole('button', { name: 'Go back to resources' });
6440
}

‎tests/playwright/src/specs/podman-machine-onboarding.spec.ts

+12-10
Original file line numberDiff line numberDiff line change
@@ -120,18 +120,20 @@ test.describe.serial('Podman Machine verification', () => {
120120

121121
test('Verify default podman machine settings', async () => {
122122
await playExpect(podmanOnboardingPage.createMachinePageTitle).toHaveText(`Create a Podman machine`);
123-
await playExpect(podmanOnboardingPage.podmanMachineConfiguration).toBeVisible();
124-
await playExpect(podmanOnboardingPage.podmanMachineName).toHaveValue('podman-machine-default');
125-
await playExpect(podmanOnboardingPage.podmanMachineImage).toHaveValue('');
126-
await playExpect(podmanOnboardingPage.podmanMachineRootfulCheckbox).toBeChecked();
127-
await playExpect(podmanOnboardingPage.podmanMachineStartAfterCreationCheckbox).toBeChecked();
123+
await playExpect(podmanOnboardingPage.machineCreationForm.podmanMachineConfiguration).toBeVisible();
124+
await playExpect(podmanOnboardingPage.machineCreationForm.podmanMachineName).toHaveValue(
125+
'podman-machine-default',
126+
);
127+
await playExpect(podmanOnboardingPage.machineCreationForm.imagePathBox).toHaveValue('');
128+
await playExpect(podmanOnboardingPage.machineCreationForm.rootPriviledgesCheckbox).toBeChecked();
129+
await playExpect(podmanOnboardingPage.machineCreationForm.startNowCheckbox).toBeChecked();
128130

129131
if (os.platform() === 'win32') {
130-
await playExpect(podmanOnboardingPage.podmanMachineUserModeNetworkingCheckbox).not.toBeChecked();
132+
await playExpect(podmanOnboardingPage.machineCreationForm.userModeNetworkingCheckbox).not.toBeChecked();
131133
} else {
132-
await playExpect(podmanOnboardingPage.podmanMachineCPUs).toBeVisible();
133-
await playExpect(podmanOnboardingPage.podmanMachineMemory).toBeVisible();
134-
await playExpect(podmanOnboardingPage.podmanMachineDiskSize).toBeVisible();
134+
await playExpect(podmanOnboardingPage.machineCreationForm.podmanMachineCPUs).toBeVisible();
135+
await playExpect(podmanOnboardingPage.machineCreationForm.podmanMachineMemory).toBeVisible();
136+
await playExpect(podmanOnboardingPage.machineCreationForm.podmanMachineDiskSize).toBeVisible();
135137
}
136138
});
137139
});
@@ -140,7 +142,7 @@ test.describe.serial('Podman Machine verification', () => {
140142

141143
test('Create a default Podman machine', async () => {
142144
test.setTimeout(PODMAN_FULL_STARTUP_TIMEOUT);
143-
await podmanOnboardingPage.podmanMachineCreateButton.click();
145+
await podmanOnboardingPage.machineCreationForm.createMachineButton.click();
144146
await playExpect(podmanOnboardingPage.podmanMachineShowLogsButton).toBeVisible();
145147
await podmanOnboardingPage.podmanMachineShowLogsButton.click();
146148
await playExpect(podmanOnboardingPage.onboardingStatusMessage).toBeVisible({

‎tests/playwright/src/specs/podman-machine-rootless.spec.ts

+4-4
Original file line numberDiff line numberDiff line change
@@ -25,15 +25,15 @@ import { deletePodmanMachine } from '../utility/operations';
2525

2626
const PODMAN_MACHINE_NAME: string = 'podman-machine-rootless';
2727

28-
test.beforeAll(async ({ pdRunner, welcomePage }) => {
29-
pdRunner.setVideoAndTraceName('podman-rootless-machine-e2e');
28+
test.beforeAll(async ({ runner, welcomePage }) => {
29+
runner.setVideoAndTraceName('podman-rootless-machine-e2e');
3030
process.env.KEEP_TRACES_ON_PASS = 'true';
3131

3232
await welcomePage.handleWelcomePage(true);
3333
});
3434

35-
test.afterAll(async ({ pdRunner }) => {
36-
await pdRunner.close();
35+
test.afterAll(async ({ runner }) => {
36+
await runner.close();
3737
});
3838

3939
test.skip(os.platform() === 'linux', 'Runs only on Windows and Mac');

‎tests/playwright/src/specs/podman-machine-tests.spec.ts

+6-19
Original file line numberDiff line numberDiff line change
@@ -104,26 +104,13 @@ test.describe.serial(`Podman machine switching validation `, () => {
104104
});
105105

106106
const podmanMachineCreatePage = new PodmanOnboardingPage(page);
107-
await test.step('Fill in podman machine name input box', async () => {
108-
await playExpect(podmanMachineCreatePage.podmanMachineName).toBeVisible();
109-
await podmanMachineCreatePage.podmanMachineName.clear();
110-
await podmanMachineCreatePage.podmanMachineName.fill(ROOTLESS_PODMAN_MACHINE_VISIBLE);
111-
});
112-
113-
await test.step('Set podman machine to be rootless', async () => {
114-
await playExpect(podmanMachineCreatePage.podmanMachineRootfulCheckbox).toBeChecked();
115-
await podmanMachineCreatePage.podmanMachineRootfulCheckbox.locator('..').click();
116-
await playExpect(podmanMachineCreatePage.podmanMachineRootfulCheckbox).not.toBeChecked();
117-
});
118-
119-
await test.step('Set podman machine to not start after creation', async () => {
120-
await playExpect(podmanMachineCreatePage.podmanMachineStartAfterCreationCheckbox).toBeChecked();
121-
await podmanMachineCreatePage.podmanMachineStartAfterCreationCheckbox.locator('..').click();
122-
await playExpect(podmanMachineCreatePage.podmanMachineStartAfterCreationCheckbox).not.toBeChecked();
123-
});
124-
125107
await test.step('Create podman machine', async () => {
126-
await podmanMachineCreatePage.podmanMachineCreateButton.click();
108+
await podmanMachineCreatePage.machineCreationForm.setupAndCreateMachine(
109+
ROOTLESS_PODMAN_MACHINE_VISIBLE,
110+
false,
111+
false,
112+
false,
113+
);
127114
await playExpect(podmanMachineCreatePage.goBackButton).toBeEnabled({ timeout: 180_000 });
128115
await podmanMachineCreatePage.goBackButton.click();
129116
});

0 commit comments

Comments
 (0)