test: remove automatic logout for all tests

Author: xrutayisire

playwright/fixtures/index.ts

@@ -1,6 +1,3 @@
-import * as fs from "fs/promises";
-import * as os from "os";
-import * as path from "path";
 import { test as baseTest, expect } from "@playwright/test";
 import { SharedSlice } from "@prismicio/types-internal/lib/customtypes";
 import {
@@ -21,7 +18,7 @@ import { SimulatorPage } from "../pages/SimulatorPage";
 import { SliceMachinePage } from "../pages/SliceMachinePage";
 import { generateRandomId } from "../utils/generateRandomId";
 import { MockManagerProcedures } from "../utils";
-import config from "../playwright.config";
+import config, { auth, baseUrl } from "../playwright.config";
 
 type Options = {
   onboarded: boolean;
@@ -48,10 +45,10 @@ type Fixtures = {
   /**
    * Data
    */
-  reusablePageType: { name: string };
-  singlePageType: { name: string };
-  reusableCustomType: { name: string };
-  singleCustomType: { name: string };
+  reusablePageType: { name: string; id: string };
+  singlePageType: { name: string; id: string };
+  reusableCustomType: { name: string; id: string };
+  singleCustomType: { name: string; id: string };
   slice: { name: string };
   repeatableZoneSlice: { name: string };
   firstSliceLibrary: { id: string };
@@ -65,6 +62,11 @@ type Fixtures = {
    * Mocks
    */
   procedures: MockManagerProcedures;
+
+  /**
+   * Authentication
+   */
+  userApiToken: string;
 };
 
 export const test = baseTest.extend<Options & Fixtures>({
@@ -112,55 +114,79 @@ export const test = baseTest.extend<Options & Fixtures>({
   /**
    * Data
    */
-  reusablePageType: async ({ pageTypesTablePage }, use) => {
+  reusablePageType: async ({ pageTypesTablePage, manager }, use) => {
     await pageTypesTablePage.goto();
     await pageTypesTablePage.openCreateDialog();
 
-    const pageTypeName = "Page Type " + generateRandomId();
+    const uuid = generateRandomId();
+    const pageTypeName = "Page Type " + uuid;
+    const pageTypeId = `page_type_${uuid}`;
     await pageTypesTablePage.createTypeDialog.createType(
       pageTypeName,
       "reusable",
     );
 
-    await use({ name: pageTypeName });
+    await use({ name: pageTypeName, id: pageTypeId });
+
+    await manager.customTypes.deleteCustomType({
+      id: pageTypeId,
+    });
   },
-  singlePageType: async ({ pageTypesTablePage }, use) => {
+  singlePageType: async ({ pageTypesTablePage, manager }, use) => {
     await pageTypesTablePage.goto();
     await pageTypesTablePage.openCreateDialog();
 
-    const pageTypeName = "Page Type " + generateRandomId();
+    const uuid = generateRandomId();
+    const pageTypeName = "Page Type " + uuid;
+    const pageTypeId = `page_type_${uuid}`;
     await pageTypesTablePage.createTypeDialog.createType(
       pageTypeName,
       "single",
     );
 
-    await use({ name: pageTypeName });
+    await use({ name: pageTypeName, id: pageTypeId });
+
+    await manager.customTypes.deleteCustomType({
+      id: pageTypeId,
+    });
   },
-  reusableCustomType: async ({ customTypesTablePage }, use) => {
+  reusableCustomType: async ({ customTypesTablePage, manager }, use) => {
     await customTypesTablePage.goto();
     await customTypesTablePage.openCreateDialog();
 
-    const customTypeName = "Custom Type " + generateRandomId();
+    const uuid = generateRandomId();
+    const customTypeName = "Custom Type " + uuid;
+    const customTypeId = `custom_type_${uuid}`;
     await customTypesTablePage.createTypeDialog.createType(
       customTypeName,
       "reusable",
     );
 
-    await use({ name: customTypeName });
+    await use({ name: customTypeName, id: customTypeId });
+
+    await manager.customTypes.deleteCustomType({
+      id: customTypeId,
+    });
   },
-  singleCustomType: async ({ customTypesTablePage }, use) => {
+  singleCustomType: async ({ customTypesTablePage, manager }, use) => {
     await customTypesTablePage.goto();
     await customTypesTablePage.openCreateDialog();
 
-    const customTypeName = "Custom Type " + generateRandomId();
+    const uuid = generateRandomId();
+    const customTypeName = "Custom Type " + uuid;
+    const customTypeId = `custom_type_${uuid}`;
     await customTypesTablePage.createTypeDialog.createType(
       customTypeName,
       "single",
     );
 
-    await use({ name: customTypeName });
+    await use({ name: customTypeName, id: customTypeId });
+
+    await manager.customTypes.deleteCustomType({
+      id: customTypeId,
+    });
   },
-  slice: async ({ slicesListPage }, use) => {
+  slice: async ({ slicesListPage, manager, firstSliceLibrary }, use) => {
     await slicesListPage.goto();
     await expect(slicesListPage.breadcrumbLabel).toBeVisible();
     await slicesListPage.addSliceDropdown.click();
@@ -170,6 +196,12 @@ export const test = baseTest.extend<Options & Fixtures>({
     await slicesListPage.createSliceDialog.createSlice(sliceName);
 
     await use({ name: sliceName });
+
+    const sliceId = sliceName.toLowerCase();
+    await manager.slices.deleteSlice({
+      libraryID: firstSliceLibrary.id,
+      sliceID: sliceId,
+    });
   },
   repeatableZoneSlice: async ({ firstSliceLibrary, manager }, use) => {
     const sliceName = "Slice" + generateRandomId();
@@ -280,13 +312,6 @@ export const test = baseTest.extend<Options & Fixtures>({
     const newContext = await browser.newContext({ storageState });
     const page = await newContext.newPage();
 
-    // Logout user by default
-    try {
-      await fs.rm(path.join(os.homedir(), ".prismic"));
-    } catch (error) {
-      // Ignore since it means the user is already logged out
-    }
-
     // Propagate the modified page to the test
     await use(page);
 
@@ -316,4 +341,22 @@ export const test = baseTest.extend<Options & Fixtures>({
 
     await use(procedures);
   },
+
+  /**
+   * Authentication
+   */
+  // eslint-disable-next-line no-empty-pattern
+  userApiToken: async ({}, use) => {
+    const authUrl = baseUrl.replace("https://", "https://auth.");
+    const loginResponse = await fetch(`${authUrl}login`, {
+      method: "POST",
+      body: JSON.stringify({
+        email: auth.username,
+        password: auth.password,
+      }),
+    });
+    const userApiToken = await loginResponse.text();
+
+    await use(userApiToken);
+  },
 });

playwright/pages/ChangesPage.ts

@@ -12,6 +12,7 @@ export class ChangesPage extends SliceMachinePage {
   readonly notLoggedInTitle: Locator;
   readonly notAuthorizedTitle: Locator;
   readonly blankSlateTitle: Locator;
+  readonly postPushBlankSlateTitle: Locator;
   readonly unknownErrorMessage: Locator;
   readonly softLimitTitle: Locator;
   readonly softLimitCheckbox: Locator;
@@ -50,6 +51,10 @@ export class ChangesPage extends SliceMachinePage {
     this.blankSlateTitle = page.getByText("Everything is up-to-date", {
       exact: true,
     });
+    this.postPushBlankSlateTitle = page.getByText(
+      "Success! Your changes have been pushed to the Page Builder.",
+      { exact: true },
+    );
     this.unknownErrorMessage = page.getByText(
       "Something went wrong when pushing your changes. Check your terminal logs.",
       {
@@ -100,6 +105,7 @@ export class ChangesPage extends SliceMachinePage {
     await this.pushChangesButton.click();
     await expect(this.pushChangesButton).toBeDisabled();
     await this.checkPushedMessage();
+    await expect(this.postPushBlankSlateTitle).toBeVisible();
   }
 
   async confirmDeleteDocuments() {
@@ -136,6 +142,18 @@ export class ChangesPage extends SliceMachinePage {
     ).toBeVisible();
   }
 
+  async checkSliceName(name: string) {
+    await expect(
+      this.getSliceCard(name).getByText(name, { exact: true }),
+    ).toBeVisible();
+  }
+
+  async checkSliceStatus(name: string, status: string) {
+    await expect(
+      this.getSliceCard(name).getByText(status, { exact: true }),
+    ).toBeVisible();
+  }
+
   async checkPushedMessage() {
     await expect(this.pushedMessaged).toBeVisible();
     await expect(this.pushedMessaged).not.toBeVisible();

playwright/playwright.config.ts

@@ -108,9 +108,7 @@ const config = {
   // Run local dev servers before starting the tests if needed.
   webServer: {
     cwd: "..",
-    command: process.env["CI"]
-      ? `yarn play --prefix ${REPOSITORY_NAME_PREFIX}`
-      : `yarn play`,
+    command: "yarn play",
     url: "http://localhost:9999/",
     reuseExistingServer: !process.env["CI"],
     stdout: "pipe",

playwright/tests/changes/changes.spec.ts

@@ -1,19 +1,14 @@
-import { CustomType } from "@prismicio/types-internal/lib/customtypes";
 import { expect } from "@playwright/test";
 
 import { test } from "../../fixtures";
 import { generateLibraries, generateTypes } from "../../mocks";
+import { savePrismicAuthFile } from "../../utils/savePrismicAuthFile";
 
 test("I cannot see the login screen when logged in", async ({
   changesPage,
-  procedures,
+  userApiToken,
 }) => {
-  procedures.mock("getState", ({ data }) => ({
-    ...(data as Record<string, unknown>),
-    clientError: {
-      clientError: undefined,
-    },
-  }));
+  await savePrismicAuthFile(userApiToken);
 
   await changesPage.goto();
   await expect(changesPage.loginButton).not.toBeVisible();
@@ -73,27 +68,26 @@ test("I can see the empty state when I don't have any changes to push", async ({
 
 test("I can see the changes I have to push", async ({
   changesPage,
-  procedures,
+  reusablePageType,
+  slice,
+  userApiToken,
 }) => {
-  const types = generateTypes({ typesCount: 1 });
-  const customType = types[0] as CustomType;
-  procedures.mock("getState", ({ data }) => ({
-    ...(data as Record<string, unknown>),
-    libraries: generateLibraries({ slicesCount: 0 }),
-    customTypes: types,
-    remoteCustomTypes: [],
-    remoteSlices: [],
-    clientError: undefined,
-  }));
+  await savePrismicAuthFile(userApiToken);
 
   await changesPage.goto();
   await expect(changesPage.loginButton).not.toBeVisible();
+
+  // Custom Type
   await changesPage.checkCustomTypeName(
-    customType.id,
-    customType.label as string,
+    reusablePageType.id,
+    reusablePageType.name,
   );
-  await changesPage.checkCustomTypeApiId(customType.id);
-  await changesPage.checkCustomTypeStatus(customType.id, "New");
+  await changesPage.checkCustomTypeApiId(reusablePageType.id);
+  await changesPage.checkCustomTypeStatus(reusablePageType.id, "New");
+
+  // Slice
+  await changesPage.checkSliceName(slice.name);
+  await changesPage.checkSliceStatus(slice.name, "New");
 });
 
 test("I can update screenshots", async ({ changesPage, procedures, slice }) => {
@@ -116,22 +110,22 @@ test("I can update screenshots", async ({ changesPage, procedures, slice }) => {
   ).not.toBeVisible();
 });
 
-test("I can push the changes I have", async ({ changesPage, procedures }) => {
-  procedures.mock("getState", ({ data }) => ({
-    ...(data as Record<string, unknown>),
-    libraries: generateLibraries({ slicesCount: 0 }),
-    customTypes: generateTypes({ typesCount: 1 }),
-    remoteCustomTypes: [],
-    remoteSlices: [],
-    clientError: undefined,
-  }));
-  procedures.mock("prismicRepository.pushChanges", () => undefined, {
-    execute: false,
-  });
+test("I can push the changes I have", async ({
+  changesPage,
+  reusablePageType,
+  slice,
+  userApiToken,
+}) => {
+  await savePrismicAuthFile(userApiToken);
 
   await changesPage.goto();
   await expect(changesPage.loginButton).not.toBeVisible();
   await changesPage.pushChanges();
+
+  await expect(
+    changesPage.getCustomType(reusablePageType.id),
+  ).not.toBeVisible();
+  await expect(changesPage.getSliceCard(slice.name)).not.toBeVisible();
 });
 
 test("I can see an error when the push failed", async ({

playwright/tests/common/environment.spec.ts

@@ -3,13 +3,39 @@ import { expect } from "@playwright/test";
 import { test } from "../../fixtures";
 import { environments } from "../../mocks";
 
-test("I can click on the text to log in", async ({ sliceMachinePage }) => {
+test("I can click on the text to log in", async ({
+  sliceMachinePage,
+  procedures,
+}) => {
+  procedures.mock(
+    "prismicRepository.fetchEnvironments",
+    () => {
+      const error = new Error();
+      error.name = "SMUnauthenticatedError";
+      throw error;
+    },
+    { execute: false },
+  );
+
   await sliceMachinePage.gotoDefaultPage();
   await sliceMachinePage.menu.environmentSelector.loginTextButton.click();
   await expect(sliceMachinePage.loginDialog.submitButton).toBeVisible();
 });
 
-test("I can click on the icon to log in", async ({ sliceMachinePage }) => {
+test("I can click on the icon to log in", async ({
+  sliceMachinePage,
+  procedures,
+}) => {
+  procedures.mock(
+    "prismicRepository.fetchEnvironments",
+    () => {
+      const error = new Error();
+      error.name = "SMUnauthenticatedError";
+      throw error;
+    },
+    { execute: false },
+  );
+
   await sliceMachinePage.gotoDefaultPage();
   await sliceMachinePage.menu.environmentSelector.loginIconButton.click();
   await expect(sliceMachinePage.loginDialog.submitButton).toBeVisible();

playwright/tests/common/navigation.spec.ts

@@ -56,7 +56,7 @@ test("I can navigate through all menu entries", async ({
   );
 });
 
-test("I can access the repository using the open icon", async ({
+test.skip("I can access the repository using the open icon", async ({
   sliceMachinePage,
   procedures,
 }) => {