generator-jhipster-playwright 1.0.0

package/generators/cypress/templates/src/test/javascript/cypress/e2e/account/logout.spec.ts.ejs

@@ -0,0 +1,39 @@
+<%#
+  Source EJS variables: authenticationUsesCsrf
+-%>
+import { test, expect } from '@playwright/test';
+import {
+  accountMenuSelector,
+  credentials,
+  login,
+  loginItemSelector,
+  navbarSelector,
+} from '../../support/commands';
+import { clickOnLogoutItem } from '../../support/navbar';
+
+test.describe('logout', () => {
+  let username: string;
+  let password: string;
+
+  test.beforeAll(() => {
+    const creds = credentials();
+    username = creds.username;
+    password = creds.password;
+  });
+
+  test('go to home page when successfully logs out', async ({ page, request }) => {
+    await login(page, request, username, password);
+<%_ if (authenticationUsesCsrf) { _%>
+    const logoutPromise = page.waitForResponse('**/api/logout');
+<%_ } _%>
+    await clickOnLogoutItem(page);
+<%_ if (authenticationUsesCsrf) { _%>
+    await logoutPromise;
+<%_ } _%>
+    // Wait for the logout item to disappear (React processed the logout)
+    await expect(page.locator('[data-cy="logout"]')).not.toBeVisible({ timeout: 10000 });
+    // Open the account menu and verify login item is visible
+    await page.locator(navbarSelector).locator(accountMenuSelector).click();
+    await expect(page.locator(navbarSelector).locator(accountMenuSelector).locator(loginItemSelector)).toBeVisible({ timeout: 10000 });
+  });
+});

package/generators/cypress/templates/src/test/javascript/cypress/e2e/account/password-page.spec.ts.ejs

@@ -0,0 +1,88 @@
+<%#
+  Source EJS variables: clientFrameworkReact
+-%>
+import { test, expect } from '@playwright/test';
+import {
+  currentPasswordSelector,
+  newPasswordSelector,
+  confirmPasswordSelector,
+  submitPasswordSelector,
+  classInvalid,
+  classValid,
+  credentials,
+} from '../../support/commands';
+import { login } from '../../support/commands';
+import { clickOnPasswordItem } from '../../support/navbar';
+
+test.describe('/account/password', () => {
+  let username: string;
+  let password: string;
+
+  test.beforeAll(() => {
+    const creds = credentials();
+    username = creds.username;
+    password = creds.password;
+  });
+
+  test.beforeEach(async ({ page, request }) => {
+    await login(page, request, username, password);
+    await page.goto('/account/password');
+  });
+
+  test('should be accessible through menu', async ({ page }) => {
+    await page.goto('/');
+    await clickOnPasswordItem(page);
+    await expect(page).toHaveURL(/\/account\/password$/);
+  });
+
+  test('requires current password', async ({ page }) => {
+    <%_ if (clientFrameworkReact) { _%>
+    await page.locator(submitPasswordSelector).click();
+    <%_ } _%>
+    await expect(page.locator(currentPasswordSelector)).toHaveClass(new RegExp(classInvalid));
+    await page.locator(currentPasswordSelector).fill('wrong-current-password');
+    await page.locator(currentPasswordSelector).evaluate(e => e.blur());
+    await expect(page.locator(currentPasswordSelector)).toHaveClass(new RegExp(classValid));
+  });
+
+  test('requires new password', async ({ page }) => {
+    <%_ if (clientFrameworkReact) { _%>
+    await page.locator(submitPasswordSelector).click();
+    <%_ } _%>
+    await expect(page.locator(newPasswordSelector)).toHaveClass(new RegExp(classInvalid));
+    await page.locator(newPasswordSelector).fill('jhipster');
+    await page.locator(newPasswordSelector).evaluate(e => e.blur());
+    await expect(page.locator(newPasswordSelector)).toHaveClass(new RegExp(classValid));
+  });
+
+  test('requires confirm new password', async ({ page }) => {
+    <%_ if (clientFrameworkReact) { _%>
+    await page.locator(submitPasswordSelector).click();
+    <%_ } _%>
+    await page.locator(newPasswordSelector).fill('jhipster');
+    await expect(page.locator(confirmPasswordSelector)).toHaveClass(new RegExp(classInvalid));
+    await page.locator(confirmPasswordSelector).fill('jhipster');
+    await page.locator(confirmPasswordSelector).evaluate(e => e.blur());
+    await expect(page.locator(confirmPasswordSelector)).toHaveClass(new RegExp(classValid));
+  });
+
+  test('should fail to update password when using incorrect current password', async ({ page }) => {
+    await page.locator(currentPasswordSelector).fill('wrong-current-password');
+    await page.locator(newPasswordSelector).fill('jhipster');
+    await page.locator(confirmPasswordSelector).fill('jhipster');
+    const responsePromise = page.waitForResponse('**/api/account/change-password');
+    await page.locator(submitPasswordSelector).click();
+    const response = await responsePromise;
+    expect(response.status()).toBe(400);
+  });
+
+  test('should be able to update password', async ({ page }) => {
+    await page.locator(currentPasswordSelector).fill(password);
+    await page.locator(newPasswordSelector).fill(password);
+    await page.locator(confirmPasswordSelector).fill(password);
+    const responsePromise = page.waitForResponse('**/api/account/change-password');
+    await page.locator(submitPasswordSelector).click();
+    const response = await responsePromise;
+    expect(response.status()).toBe(200);
+  });
+});

package/generators/cypress/templates/src/test/javascript/cypress/e2e/account/register-page.spec.ts.ejs

@@ -0,0 +1,124 @@
+<%#
+  Source EJS variables: clientFrameworkReact, clientFrameworkAngular, clientFrameworkVue, faker
+-%>
+<% const registerPage = clientFrameworkVue ? '/register' : '/account/register'; _%>
+import { test, expect } from '@playwright/test';
+import {
+  usernameRegisterSelector,
+  emailRegisterSelector,
+  firstPasswordRegisterSelector,
+  secondPasswordRegisterSelector,
+  submitRegisterSelector,
+  classInvalid,
+  classValid,
+} from '../../support/commands';
+import { clickOnRegisterItem } from '../../support/navbar';
+
+test.describe('<%= registerPage %>', () => {
+  test.beforeEach(async ({ page }) => {
+    await page.goto('<%= registerPage %>');
+  });
+
+  test('should be accessible through menu', async ({ page }) => {
+    await page.goto('/');
+    await clickOnRegisterItem(page);
+    await expect(page).toHaveURL(/<%= registerPage.replace(/\//g, '\\/') %>$/);
+  });
+
+  test('should load the register page', async ({ page }) => {
+    await expect(page.locator(submitRegisterSelector)).toBeVisible();
+  });
+
+  test('requires username', async ({ page }) => {
+    <%_ if (clientFrameworkReact) { _%>
+    await page.locator(submitRegisterSelector).click();
+    <%_ } _%>
+    await expect(page.locator(usernameRegisterSelector)).toHaveClass(new RegExp(classInvalid));
+    await page.locator(usernameRegisterSelector).fill('test');
+    await page.locator(usernameRegisterSelector).evaluate(e => e.blur());
+    await expect(page.locator(usernameRegisterSelector)).toHaveClass(new RegExp(classValid));
+  });
+
+  test('should not accept invalid email', async ({ page }) => {
+    <%_ if (clientFrameworkReact) { _%>
+    await page.locator(submitRegisterSelector).click();
+    <%_ } _%>
+    await expect(page.locator(emailRegisterSelector)).toHaveClass(new RegExp(classInvalid));
+    await page.locator(emailRegisterSelector).fill('testtest.fr');
+    await page.locator(emailRegisterSelector).evaluate(e => e.blur());
+    await expect(page.locator(emailRegisterSelector)).toHaveClass(new RegExp(classInvalid));
+  });
+
+  test('requires email in correct format', async ({ page }) => {
+    <%_ if (clientFrameworkReact) { _%>
+    await page.locator(submitRegisterSelector).click();
+    <%_ } _%>
+    await expect(page.locator(emailRegisterSelector)).toHaveClass(new RegExp(classInvalid));
+    await page.locator(emailRegisterSelector).fill('test@test.fr');
+    await page.locator(emailRegisterSelector).evaluate(e => e.blur());
+    await expect(page.locator(emailRegisterSelector)).toHaveClass(new RegExp(classValid));
+  });
+
+  test('requires first password', async ({ page }) => {
+    <%_ if (clientFrameworkReact) { _%>
+    await page.locator(submitRegisterSelector).click();
+    <%_ } _%>
+    await expect(page.locator(firstPasswordRegisterSelector)).toHaveClass(new RegExp(classInvalid));
+    await page.locator(firstPasswordRegisterSelector).fill('test@test.fr');
+    await page.locator(firstPasswordRegisterSelector).evaluate(e => e.blur());
+    await expect(page.locator(firstPasswordRegisterSelector)).toHaveClass(new RegExp(classValid));
+  });
+
+  test('requires password and confirm password to be same', async ({ page }) => {
+    <%_ if (clientFrameworkReact) { _%>
+    await page.locator(submitRegisterSelector).click();
+    <%_ } _%>
+    await expect(page.locator(firstPasswordRegisterSelector)).toHaveClass(new RegExp(classInvalid));
+    await page.locator(firstPasswordRegisterSelector).clear();
+    await page.locator(firstPasswordRegisterSelector).pressSequentially('passwd');
+    await page.locator(firstPasswordRegisterSelector).evaluate(e => e.blur());
+    await expect(page.locator(firstPasswordRegisterSelector)).toHaveClass(new RegExp(classValid));
+    await expect(page.locator(secondPasswordRegisterSelector)).toHaveClass(new RegExp(classInvalid));
+    await page.locator(secondPasswordRegisterSelector).clear();
+    await page.locator(secondPasswordRegisterSelector).pressSequentially('passwd');
+    await page.locator(secondPasswordRegisterSelector).evaluate(e => e.blur());
+    await expect(page.locator(secondPasswordRegisterSelector)).toHaveClass(new RegExp(classValid));
+  });
+
+  test('requires password and confirm password have not the same value', async ({ page }) => {
+    <%_ if (clientFrameworkReact) { _%>
+    await page.locator(submitRegisterSelector).click();
+    <%_ } _%>
+    await expect(page.locator(firstPasswordRegisterSelector)).toHaveClass(new RegExp(classInvalid));
+    await page.locator(firstPasswordRegisterSelector).clear();
+    await page.locator(firstPasswordRegisterSelector).pressSequentially('passwd');
+    await page.locator(firstPasswordRegisterSelector).evaluate(e => e.blur());
+<%_ if (!clientFrameworkReact) { _%>
+    await expect(page.locator(firstPasswordRegisterSelector)).toHaveClass(new RegExp(classValid));
+<%_ } _%>
+<%_ if (clientFrameworkAngular) { _%>
+    await expect(page.locator(secondPasswordRegisterSelector)).toHaveClass(new RegExp(classInvalid));
+    await page.locator(secondPasswordRegisterSelector).fill('otherPassword');
+    await expect(page.locator(submitRegisterSelector)).toBeDisabled();
+<%_ } else { _%>
+    await expect(page.locator(secondPasswordRegisterSelector)).toHaveClass(new RegExp(classInvalid));
+    await page.locator(secondPasswordRegisterSelector).clear();
+    await page.locator(secondPasswordRegisterSelector).pressSequentially('otherPassword');
+    await page.locator(secondPasswordRegisterSelector).evaluate(e => e.blur());
+    await expect(page.locator(secondPasswordRegisterSelector)).toHaveClass(new RegExp(classInvalid));
+<%_ } _%>
+  });
+
+  test('register a valid user', async ({ page }) => {
+    const randomEmail = '<%= faker.internet.email() %>';
+    const randomUsername = '<%= faker.internet.username() %>';
+    await page.locator(usernameRegisterSelector).fill(randomUsername);
+    await page.locator(emailRegisterSelector).fill(randomEmail);
+    await page.locator(firstPasswordRegisterSelector).fill('jondoe');
+    await page.locator(secondPasswordRegisterSelector).fill('jondoe');
+    const responsePromise = page.waitForResponse('**/api/register');
+    await page.locator(submitRegisterSelector).click();
+    const response = await responsePromise;
+    expect(response.status()).toBe(201);
+  });
+});

package/generators/cypress/templates/src/test/javascript/cypress/e2e/account/reset-password-page.spec.ts.ejs

@@ -0,0 +1,57 @@
+<%#
+  Source EJS variables: clientFrameworkReact
+-%>
+import { test, expect } from '@playwright/test';
+import {
+  usernameLoginSelector,
+  forgetYourPasswordSelector,
+  emailResetPasswordSelector,
+  submitInitResetPasswordSelector,
+  classInvalid,
+  classValid,
+  credentials,
+} from '../../support/commands';
+import { clickOnLoginItem } from '../../support/navbar';
+
+test.describe('forgot your password', () => {
+  let username: string;
+
+  test.beforeAll(() => {
+    const creds = credentials();
+    username = creds.username;
+  });
+
+  test.beforeEach(async ({ page }) => {
+    await page.goto('/');
+    await clickOnLoginItem(page);
+    await page.locator(usernameLoginSelector).fill(username);
+    await page.locator(forgetYourPasswordSelector).click();
+  });
+
+  test('requires email', async ({ page }) => {
+    // Focus then blur to trigger the field validation state.
+    await page.locator(emailResetPasswordSelector).focus();
+    await page.locator(emailResetPasswordSelector).evaluate(e => e.blur());
+<%_ if (clientFrameworkReact) { _%>
+    await page.locator(submitInitResetPasswordSelector).click();
+<%_ } _%>
+    await expect(page.locator(emailResetPasswordSelector)).toHaveClass(new RegExp(classInvalid), { timeout: 10000 });
+    await page.locator(emailResetPasswordSelector).fill('user@gmail.com');
+<%_ if (clientFrameworkReact) { _%>
+    await page.locator(submitInitResetPasswordSelector).click();
+<%_ } _%>
+    await expect(page.locator(emailResetPasswordSelector)).toHaveClass(new RegExp(classValid), { timeout: 10000 });
+  });
+
+  test('should be able to init reset password', async ({ page }) => {
+    await page.locator(emailResetPasswordSelector).fill('user@gmail.com');
+    const responsePromise = page.waitForResponse('**/api/account/reset-password/init');
+<%_ if (clientFrameworkReact) { _%>
+    await page.locator(submitInitResetPasswordSelector).click();
+<%_ } else { _%>
+    await page.locator(submitInitResetPasswordSelector).click({ force: true });
+<%_ } _%>
+    const response = await responsePromise;
+    expect(response.status()).toBe(200);
+  });
+});

package/generators/cypress/templates/src/test/javascript/cypress/e2e/account/settings-page.spec.ts.ejs

@@ -0,0 +1,85 @@
+<%#
+  Source EJS variables: ZERO — settings-page.cy.ts.ejs has no EJS variables.
+-%>
+import { test, expect } from '@playwright/test';
+import {
+  firstNameSettingsSelector,
+  lastNameSettingsSelector,
+  submitSettingsSelector,
+  emailSettingsSelector,
+  credentials,
+  login,
+  authenticatedRequest,
+} from '../../support/commands';
+import { clickOnSettingsItem } from '../../support/navbar';
+import type { Account } from '../../support/account';
+
+test.describe('/account/settings', () => {
+  let adminUsername: string;
+  let adminPassword: string;
+  let username: string;
+  let password: string;
+
+  const testUserEmail = 'user@localhost.fr';
+  let originalUserAccount: Account;
+  let testUserAccount: Account;
+
+  test.beforeAll(() => {
+    const creds = credentials();
+    ({ adminUsername, adminPassword, username, password } = creds);
+  });
+
+  test.beforeEach(async ({ page, request }) => {
+    await login(page, request, username, password);
+
+    const accountResp = await authenticatedRequest(request, { method: 'GET', url: '/api/account' });
+    originalUserAccount = await accountResp.json() as Account;
+    testUserAccount = { ...originalUserAccount, email: testUserEmail };
+    const saveResp = await authenticatedRequest(request, { method: 'POST', url: '/api/account', data: testUserAccount });
+    expect(saveResp.status()).toBe(200);
+
+    await page.goto('/account/settings');
+    await expect(page.locator(emailSettingsSelector)).toHaveValue(testUserEmail);
+  });
+
+  test.afterEach(async ({ request }) => {
+    if (testUserAccount) {
+      await authenticatedRequest(request, { method: 'POST', url: '/api/account', data: testUserAccount });
+    }
+  });
+
+  test('should be accessible through menu', async ({ page }) => {
+    await page.goto('/');
+    await clickOnSettingsItem(page);
+    await expect(page).toHaveURL(/\/account\/settings$/);
+  });
+
+  test("should be able to change 'user' firstname settings", async ({ page }) => {
+    await page.locator(firstNameSettingsSelector).clear();
+    await page.locator(firstNameSettingsSelector).fill('jhipster');
+    const responsePromise = page.waitForResponse('**/api/account');
+    await page.locator(submitSettingsSelector).click();
+    const response = await responsePromise;
+    expect(response.status()).toBe(200);
+  });
+
+  test("should be able to change 'user' lastname settings", async ({ page }) => {
+    await page.locator(lastNameSettingsSelector).clear();
+    await page.locator(firstNameSettingsSelector).fill('jhipster');
+    await page.locator(lastNameSettingsSelector).fill('retspihj');
+    const responsePromise = page.waitForResponse('**/api/account');
+    await page.locator(submitSettingsSelector).click();
+    const response = await responsePromise;
+    expect(response.status()).toBe(200);
+  });
+
+  test("should be able to change 'user' email settings", async ({ page }) => {
+    await page.locator(emailSettingsSelector).clear();
+    await page.locator(firstNameSettingsSelector).fill('jhipster');
+    await page.locator(emailSettingsSelector).fill('user@localhost.fr');
+    const responsePromise = page.waitForResponse('**/api/account');
+    await page.locator(submitSettingsSelector).click();
+    const response = await responsePromise;
+    expect(response.status()).toBe(200);
+  });
+});

package/generators/cypress/templates/src/test/javascript/cypress/e2e/administration/administration.spec.ts.ejs

@@ -0,0 +1,73 @@
+<%#
+  Source EJS variables: withAdminUi, communicationSpringWebsocket
+-%>
+import { test, expect } from '@playwright/test';
+import {
+<%_ if (withAdminUi) { _%>
+  metricsPageHeadingSelector,
+  healthPageHeadingSelector,
+  logsPageHeadingSelector,
+  configurationPageHeadingSelector,
+<%_ } _%>
+  swaggerPageSelector,
+  swaggerFrameSelector,
+  credentials,
+} from '../../support/commands';
+import { login } from '../../support/commands';
+import { clickOnAdminMenuItem } from '../../support/navbar';
+import { getManagementInfo } from '../../support/management';
+
+test.describe('/admin', () => {
+  let adminUsername: string;
+  let adminPassword: string;
+
+  test.beforeAll(() => {
+    const creds = credentials();
+    adminUsername = creds.adminUsername;
+    adminPassword = creds.adminPassword;
+  });
+
+  test.beforeEach(async ({ page, request }) => {
+    await login(page, request, adminUsername, adminPassword);
+  });
+
+<%_ if (withAdminUi) { _%>
+  test('should load metrics', async ({ page }) => {
+    await clickOnAdminMenuItem(page, 'admin/metrics');
+    await expect(page.locator(metricsPageHeadingSelector)).toBeVisible();
+  });
+
+  test('should load health', async ({ page }) => {
+    await clickOnAdminMenuItem(page, 'admin/health');
+    await expect(page.locator(healthPageHeadingSelector)).toBeVisible();
+  });
+
+  test('should load logs', async ({ page }) => {
+    await clickOnAdminMenuItem(page, 'admin/logs');
+    await expect(page.locator(logsPageHeadingSelector)).toBeVisible();
+  });
+
+  test('should load configuration', async ({ page }) => {
+    await clickOnAdminMenuItem(page, 'admin/configuration');
+    await expect(page.locator(configurationPageHeadingSelector)).toBeVisible();
+  });
+
+<%_ } _%>
+  test('should load swagger', async ({ page, request }) => {
+    const info = await getManagementInfo(request);
+    if (info.activeProfiles && info.activeProfiles.includes('api-docs')) {
+      await clickOnAdminMenuItem(page, 'admin/docs');
+      await expect(page.locator(swaggerFrameSelector)).toBeVisible();
+      // Use frameLocator for iframe content
+      const frame = page.frameLocator(swaggerFrameSelector);
+      await expect(frame.locator(swaggerPageSelector)).toBeVisible({ timeout: 15000 });
+    }
+  });
+<%_ if (communicationSpringWebsocket) { _%>
+
+  test('should load tracker', async ({ page }) => {
+    await clickOnAdminMenuItem(page, 'admin/tracker');
+    await expect(page.locator('[data-cy="trackerPageHeading"]')).toBeVisible();
+  });
+<%_ } _%>
+});