neetob 0.5.69 → 0.5.77

data/scripts/workflows/honeybadger.ts

@@ -0,0 +1,169 @@
+import { NEETO_HEALTH_WORKSPACE, PRODUCTION_APPS } from "@auditData";
+import { ROUTES } from "@routes";
+import { HONEYBADGER_TEXTS } from "@texts";
+import { faker } from "@faker-js/faker";
+import test, { expect } from "@playwright/test";
+import { addRow } from "@utils/markdown";
+import { HONEYBADGER_TABLE } from "@constants/table";
+
+const { honeybadger } = ROUTES;
+const randomUserAgent = faker.internet.userAgent();
+const randomTimezone = faker.location.timeZone();
+test.use({ userAgent: randomUserAgent, timezoneId: randomTimezone });
+
+test.describe("Honeybadger", () => {
+  test.beforeEach(async ({ page }) => {
+    await page.goto(honeybadger.signIn);
+    await page.waitForLoadState();
+    await page
+      .getByLabel(HONEYBADGER_TEXTS.email)
+      .fill(process.env.HONEYBADGER_EMAIL);
+
+    await page
+      .getByLabel(HONEYBADGER_TEXTS.password)
+      .fill(process.env.HONEYBADGER_PASSWORD);
+
+    await page
+      .getByRole("button", { name: HONEYBADGER_TEXTS.signIn, exact: true })
+      .click();
+
+    await expect(
+      page.getByRole("link", { name: HONEYBADGER_TEXTS.addProject })
+    ).toBeVisible();
+  });
+
+  test("Check whether honeybadger is configured for apps", async ({ page }) => {
+    for (const [i, app] of PRODUCTION_APPS.entries()) {
+      const { name, honebadgerId, channelId, integrationName } = app;
+      const prodName = `neeto-${name}-web-production`;
+      const row = [prodName];
+      const comments: string[] = [];
+
+      const errorPage = page.getByRole("heading", {
+        name: HONEYBADGER_TEXTS.pageNotFound,
+      });
+      const projectsHeading = page.getByRole("link", {
+        name: HONEYBADGER_TEXTS.projects,
+        exact: true,
+      });
+
+      await test.step(`Step ${
+        i + 1
+      }: Check whether honeybadger is configured for neeto-${name}-web`, async () => {
+        await page.goto(honeybadger.settings.general(honebadgerId));
+        await page.waitForLoadState();
+        await expect(errorPage.or(projectsHeading)).toBeVisible({
+          timeout: 30_000,
+        });
+
+        if (await errorPage.isVisible()) {
+          const comment = `HoneyBadger is not configured for ${prodName}`;
+          const rowData = [prodName, "No", "No", "No", "No", comment, "No"];
+          addRow(HONEYBADGER_TABLE, rowData);
+
+          return;
+        }
+
+        const notificationsCheckbox = page.getByLabel(
+          HONEYBADGER_TEXTS.enableNotifications
+        );
+
+        const [isHidden, isChecked] = await Promise.all([
+          notificationsCheckbox.isHidden(),
+          notificationsCheckbox.isChecked(),
+        ]);
+
+        const isNotificationsEnabled = isHidden || !isChecked ? "No" : "Yes";
+        row.push(isNotificationsEnabled);
+
+        if (isNotificationsEnabled === "No") {
+          comments.push("Notifications are not turned on");
+        }
+
+        await page.goto(
+          ROUTES.honeybadger.settings.integrations.channels(honebadgerId)
+        );
+        await page.waitForLoadState();
+
+        const githubIntegration = page
+          .getByRole("cell", {
+            name: HONEYBADGER_TEXTS.githubIntegration(name),
+          })
+          .or(
+            page.getByRole("cell", {
+              name: HONEYBADGER_TEXTS.githubIntegration(integrationName),
+            })
+          );
+
+        const slackIntegration = page.getByRole("cell", {
+          name: HONEYBADGER_TEXTS.slackIntegration(name),
+        });
+
+        const [isGithubVisible, isSlackVisible] = await Promise.all([
+          githubIntegration.isVisible(),
+          slackIntegration.isVisible(),
+        ]);
+
+        const gitHubIntegrationStatus = isGithubVisible ? "Yes" : "No";
+        row.push(gitHubIntegrationStatus);
+
+        if (gitHubIntegrationStatus === "No") {
+          comments.push(`GitHub is not integrated`);
+          row.push(gitHubIntegrationStatus);
+        } else {
+          await page
+            .getByRole("row")
+            .filter({ has: githubIntegration })
+            .getByRole("link")
+            .click();
+
+          const [isCreateIssueChecked, isReopenIssueChecked] =
+            await Promise.all([
+              page.getByLabel(HONEYBADGER_TEXTS.createIssue).isChecked(),
+              page.getByLabel(HONEYBADGER_TEXTS.reOpenIssue).isChecked(),
+            ]);
+
+          const isGitHubIssueEnabled =
+            isCreateIssueChecked && isReopenIssueChecked ? "Yes" : "No";
+
+          row.push(isGitHubIssueEnabled);
+
+          if (isGitHubIssueEnabled === "No") {
+            comments.push(
+              "`Automatically create GitHub issue` or `Automatically re-open issue` options are not enabled"
+            );
+          }
+        }
+
+        const slackIntegrationStatus = isSlackVisible ? "Yes" : "No";
+
+        if (slackIntegrationStatus === "No") {
+          comments.push("Slack is not integrated");
+          row.push(slackIntegrationStatus);
+        } else {
+          await page.goto(
+            honeybadger.settings.integrations.slack(honebadgerId, channelId)
+          );
+          await page.waitForLoadState();
+
+          const isNeetoHealthVisible = await page
+            .getByText(NEETO_HEALTH_WORKSPACE)
+            .isVisible();
+
+          row.push(isNeetoHealthVisible ? "Yes" : "No");
+
+          if (!isNeetoHealthVisible) {
+            comments.push("Slack is not configured in neeto-health workspace");
+          }
+        }
+
+        row.push(comments.join(","));
+        row.push(row.includes("No") ? "No" : "Yes");
+
+        addRow(HONEYBADGER_TABLE, row);
+      });
+    }
+
+    console.log(JSON.stringify(HONEYBADGER_TABLE, null, 2));
+  });
+});

data/scripts/workflows/sparkpost.ts

@@ -0,0 +1,204 @@
+import { ROUTES } from "@routes";
+import { faker } from "@faker-js/faker";
+import test, { BrowserContext, expect, Page } from "@playwright/test";
+import { addRow } from "@utils/markdown";
+import {
+  CHAT_WIDGET_SELECTORS,
+  CustomCommands,
+  EMPTY_STORAGE_STATE,
+  LOGIN_SELECTORS,
+  MailerUtils,
+  SIGNUP_SELECTORS,
+  simulateClickWithDelay,
+  simulateTypingWithDelay,
+} from "@neetoplaywright";
+import { NEETO_DEPLOY_TEXTS, SPARKPOST_TEXTS } from "@texts";
+import { NEETO_DEPLOY_SELECTORS } from "@selectors";
+import { SPARKPOST_TABLE } from "@constants/table";
+import { randomPick } from "@bigbinary/neeto-cist";
+import { USER_AGENTS } from "@constants/userAgents";
+import { initI18n } from "playwright-i18next-fixture";
+import {
+  DEPLOY_APPS,
+  DEPLOY_PASSWORD_PATTERN,
+  SPARKPOST_KEY_PATTERN,
+} from "@constants/auditData";
+
+const timezone = faker.location.timeZone();
+const userAgent = randomPick(...USER_AGENTS);
+test.use({ timezoneId: timezone, userAgent });
+test.slow();
+
+test.describe("Sparkpost", () => {
+  let stepNumber = 3,
+    otp: string,
+    deployPage: Page,
+    receivedAfter: Date,
+    context: BrowserContext,
+    mailerUtils: MailerUtils,
+    playwrightUtils: CustomCommands;
+
+  test.beforeEach(async ({ page: sparkPostPage }) => {
+    await test.step("1: Login to sparkPost", async () => {
+      await sparkPostPage.goto(ROUTES.sparkPost.login);
+      await sparkPostPage.waitForLoadState();
+
+      await simulateTypingWithDelay({
+        value: process.env.SPARKPOST_EMAIL,
+        field: sparkPostPage.getByRole("textbox", {
+          name: SPARKPOST_TEXTS.emailAddress,
+        }),
+      });
+
+      await simulateTypingWithDelay({
+        value: process.env.SPARKPOST_PASSWORD,
+        field: sparkPostPage.getByRole("textbox", {
+          name: SPARKPOST_TEXTS.password,
+        }),
+      });
+
+      await simulateClickWithDelay({
+        page: sparkPostPage,
+        element: sparkPostPage.getByRole("button", {
+          name: SPARKPOST_TEXTS.continue,
+        }),
+      });
+
+      await expect(
+        sparkPostPage.getByRole("heading", { name: SPARKPOST_TEXTS.welcome })
+      ).toBeVisible({ timeout: 20_000 });
+    });
+
+    await test.step("2: Navigate to SparkPost API keys section", async () => {
+      await sparkPostPage.goto(ROUTES.sparkPost.apiKeys);
+      await sparkPostPage.waitForLoadState();
+      await expect(
+        sparkPostPage.getByRole("heading", { name: SPARKPOST_TEXTS.apiKeys })
+      ).toBeVisible({ timeout: 20_000 });
+
+      await sparkPostPage
+        .getByRole("button", { name: SPARKPOST_TEXTS.hundredPerPage })
+        .click();
+    });
+  });
+
+  test("Check whether sparkPost sub-accounts are configured", async ({
+    page: sparkPostPage,
+    browser,
+  }) => {
+    for (const [i, app] of DEPLOY_APPS.entries()) {
+      const { appName, sparkPostName, workspace } = app;
+      const comment = `SparkPost sub-account is not set for ${appName}`;
+      const row = [appName];
+
+      await test.step(`${stepNumber++}: Login to ${workspace} workspace`, async () => {
+        context = await browser.newContext(EMPTY_STORAGE_STATE);
+        deployPage = await context.newPage();
+
+        // To avoid "No i18n instance initialized" error
+        await initI18n({ plugins: [], options: {}, cache: true });
+
+        playwrightUtils = new CustomCommands(deployPage, deployPage.request);
+        mailerUtils = new MailerUtils(playwrightUtils);
+
+        await expect(async () => {
+          await deployPage.goto(
+            ROUTES.neetoDeploy.configure(workspace, appName)
+          );
+          await playwrightUtils.waitForPageLoad();
+        }).toPass({ timeout: 2 * 6 * 10_000 });
+
+        await deployPage
+          .getByTestId(LOGIN_SELECTORS.emailTextField)
+          .fill(process.env.NEETO_DEPLOY_EMAIL);
+
+        receivedAfter = new Date();
+        await deployPage.getByTestId(LOGIN_SELECTORS.submitButton).click();
+        await expect(async () => {
+          await deployPage.reload({ waitUntil: "domcontentloaded" });
+          await playwrightUtils.waitForPageLoad();
+        }).toPass({ timeout: 2 * 6 * 10_000 });
+
+        let retryCount = 0;
+        await expect(async () => {
+          if (retryCount > 0) {
+            receivedAfter = new Date();
+            await deployPage
+              .getByTestId(NEETO_DEPLOY_SELECTORS.resendOtpButton)
+              .click();
+
+            await deployPage
+              .getByTestId(CHAT_WIDGET_SELECTORS.closeChat)
+              .click();
+          }
+
+          retryCount++;
+
+          otp = await mailerUtils.findOtpFromEmail({
+            email: process.env.NEETO_DEPLOY_EMAIL,
+            timeout: 45_000,
+            receivedAfter,
+          });
+        }).toPass({ timeout: 3 * 6 * 10_000 });
+
+        await deployPage.getByTestId(SIGNUP_SELECTORS.otpTextBox).fill(otp);
+        await playwrightUtils.waitForPageLoad();
+      });
+
+      await test.step(`${stepNumber++}: Check whether SparkPost sub-account is configured for ${appName}`, async () => {
+        const errorImage = deployPage.getByTestId(
+          NEETO_DEPLOY_SELECTORS.errorImage
+        );
+        const clickToShowButton = deployPage.getByRole("button", {
+          name: NEETO_DEPLOY_TEXTS.envVariable,
+        });
+
+        await expect(errorImage.or(clickToShowButton)).toBeVisible({
+          timeout: 25_000,
+        });
+
+        const sparkPostCell = sparkPostPage.getByRole("cell", {
+          name: SPARKPOST_TEXTS.subaccount(sparkPostName),
+        });
+
+        const [errorImageVisible, sparkPostCellHidden] = await Promise.all([
+          errorImage.isVisible(),
+          sparkPostCell.isHidden(),
+        ]);
+
+        if (errorImageVisible || sparkPostCellHidden) {
+          row.push("No", comment, "No");
+          addRow(SPARKPOST_TABLE, row);
+
+          return;
+        }
+
+        const [password, key] = await Promise.all([
+          deployPage
+            .getByRole("row")
+            .filter({ hasText: NEETO_DEPLOY_TEXTS.sparkPostPassword })
+            .getByRole("cell", { name: DEPLOY_PASSWORD_PATTERN })
+            .innerText(),
+
+          sparkPostPage
+            .getByRole("row")
+            .filter({ hasText: SPARKPOST_TEXTS.subaccount(sparkPostName) })
+            .getByRole("cell", { name: SPARKPOST_KEY_PATTERN })
+            .innerText(),
+        ]);
+
+        const passwordPrefix = password.slice(0, 3);
+        const keyPrefix = key.slice(0, 3);
+        const status = passwordPrefix === keyPrefix ? "Yes" : "No";
+
+        row.push(status, status === "No" ? comment : "", status);
+
+        addRow(SPARKPOST_TABLE, row);
+
+        await context.close();
+      });
+    }
+
+    console.log(JSON.stringify(SPARKPOST_TABLE, null, 2));
+  });
+});

data/tsconfig.json

@@ -0,0 +1,35 @@
+{
+  "compilerOptions": {
+    "esModuleInterop": true,
+    "resolveJsonModule": true,
+    "target": "ES2019",
+    "moduleResolution": "Node",
+    "lib": ["ES2021", "dom"],
+    "baseUrl": "scripts",
+    "noEmit": true,
+    "paths": {
+      "@auth/*": ["auth/*"],
+      "@config/*": ["config/*"],
+      "@selectors": ["constants/selectors"],
+      "@selectors/*": ["constants/selectors/*"],
+      "@constants/*": ["constants/*"],
+      "@texts": ["constants/texts"],
+      "@texts/*": ["constants/texts/*"],
+      "@routes": ["constants/routes.ts"],
+      "@fixtures/*": ["fixtures/*"],
+      "@fixtures": ["fixtures"],
+      "@poms/*": ["poms/*"],
+      "@poms": ["poms"],
+      "@tests/*": ["tests/*"],
+      "@utils/*": ["utils/*"],
+      "@auditData": ["constants/auditData.ts"],
+      "@neetoplaywright": [
+        "../node_modules/@bigbinary/neeto-playwright-commons"
+      ],
+      "@neetoplaywright/*": [
+        "../node_modules/@bigbinary/neeto-playwright-commons/*"
+      ]
+    },
+    "skipLibCheck": true
+  }
+}