test(e2e): add for onboarding and lldap authorization (#1834)

* test(e2e): add for onboarding and lldap authorization

* ci: add playwright chrome installation to e2e test

* fix(e2e): timeout between lldap login redirect to short

* test(e2e): add oidc azure test

* fix(e2e): lldap test fails

* wip: add temporary error log for failed ldap server connection

* fix(e2e): github actions don't support host.docker.internal

* chore: address pull request feedback

* refactor(e2e): move onboarding steps to onboarding actions and assertions

* fix(e2e): increase timeout for navigating back from azure login

* fix: wait for url network changed error

* fix: revert to wait for url

* fix(e2e): remove oidc test

* refactor(e2e): remove env validation

* ci: remove azure oidc env variables

e2e/shared/actions/onboarding-actions.ts

@@ -0,0 +1,53 @@
+import { createId } from "@paralleldrive/cuid2";
+import type { Page } from "playwright";
+
+import * as sqliteSchema from "../../../packages/db/schema/sqlite";
+import type { SqliteDatabase } from "../e2e-db";
+
+export class OnboardingActions {
+  private readonly page: Page;
+  private readonly db: SqliteDatabase;
+
+  constructor(page: Page, db: SqliteDatabase) {
+    this.page = page;
+    this.db = db;
+  }
+
+  public async skipOnboardingAsync(input?: { group?: string }) {
+    await this.db.update(sqliteSchema.onboarding).set({
+      step: "finish",
+    });
+
+    if (input?.group) {
+      await this.db.insert(sqliteSchema.groups).values({
+        id: createId(),
+        name: input.group,
+      });
+    }
+  }
+
+  public async startOnboardingAsync(type: "scratch" | "before 1.0") {
+    await this.page.locator("button", { hasText: type }).click();
+  }
+
+  public async processUserStepAsync(input: { username: string; password: string; confirmPassword: string }) {
+    await this.page.waitForSelector("text=administrator user");
+
+    await this.page.getByLabel("Username").fill(input.username);
+    await this.page.getByLabel("Password", { exact: true }).fill(input.password);
+    await this.page.getByLabel("Confirm password").fill(input.confirmPassword);
+
+    await this.page.locator("css=button[type='submit']").click();
+  }
+
+  public async processExternalGroupStepAsync(input: { name: string }) {
+    await this.page.waitForSelector("text=external provider");
+    await this.page.locator("input").fill(input.name);
+    await this.page.locator("css=button[type='submit']").click();
+  }
+
+  public async processSettingsStepAsync() {
+    await this.page.waitForSelector("text=Analytics");
+    await this.page.locator("css=button[type='submit']").click();
+  }
+}

e2e/shared/assertions/onboarding-assertions.ts

@@ -0,0 +1,62 @@
+import { eq } from "drizzle-orm";
+import type { Page } from "playwright";
+import { expect } from "vitest";
+
+import * as sqliteSchema from "../../../packages/db/schema/sqlite";
+import { OnboardingStep } from "../../../packages/definitions/src";
+import { credentialsAdminGroup } from "../../../packages/definitions/src/group";
+import type { SqliteDatabase } from "../e2e-db";
+
+export class OnboardingAssertions {
+  private readonly page: Page;
+  private readonly db: SqliteDatabase;
+
+  constructor(page: Page, db: SqliteDatabase) {
+    this.page = page;
+    this.db = db;
+  }
+
+  public async assertDbOnboardingStepAsync(expectedStep: OnboardingStep) {
+    const onboarding = await this.db.query.onboarding.findFirst();
+    expect(onboarding?.step).toEqual(expectedStep);
+  }
+
+  public async assertUserAndAdminGroupInsertedAsync(expectedUsername: string) {
+    const users = await this.db.query.users.findMany({
+      with: {
+        groups: {
+          with: {
+            group: {
+              with: {
+                permissions: true,
+              },
+            },
+          },
+        },
+      },
+    });
+
+    const user = users.find((u) => u.name === expectedUsername);
+    expect(user).toBeDefined();
+
+    const adminGroup = user!.groups.find((g) => g.group.name === credentialsAdminGroup);
+    expect(adminGroup).toBeDefined();
+    expect(adminGroup!.group.permissions).toEqual([expect.objectContaining({ permission: "admin" })]);
+  }
+
+  public async assertExternalGroupInsertedAsync(expectedGroupName: string) {
+    const group = await this.db.query.groups.findFirst({
+      where: eq(sqliteSchema.groups.name, expectedGroupName),
+      with: {
+        permissions: true,
+      },
+    });
+
+    expect(group).toBeDefined();
+    expect(group!.permissions).toEqual([expect.objectContaining({ permission: "admin" })]);
+  }
+
+  public async assertFinishStepVisibleAsync() {
+    await this.page.waitForSelector("text=completed the setup", { timeout: 5000 });
+  }
+}

e2e/shared/create-homarr-container.ts

@@ -1,18 +1,43 @@
 import { GenericContainer, Wait } from "testcontainers";
+import { Environment } from "testcontainers/build/types";
 
-export const createHomarrContainer = () => {
+export const createHomarrContainer = (
+  options: {
+    environment?: Environment;
+    mounts?: {
+      "/appdata"?: string;
+      "/var/run/docker.sock"?: string;
+    };
+  } = {},
+) => {
   if (!process.env.CI) {
     throw new Error("This test should only be run in CI or with a homarr image named 'homarr-e2e'");
   }
 
-  return withLogs(
-    new GenericContainer("homarr-e2e")
-      .withExposedPorts(7575)
-      .withEnvironment({
-        SECRET_ENCRYPTION_KEY: "0".repeat(64),
-      })
-      .withWaitStrategy(Wait.forHttp("/api/health/ready", 7575)),
-  );
+  const container = new GenericContainer("homarr-e2e")
+    .withExposedPorts(7575)
+    .withEnvironment({
+      ...options.environment,
+      SECRET_ENCRYPTION_KEY: "0".repeat(64),
+    })
+    .withBindMounts(
+      Object.entries(options.mounts ?? {})
+        .filter((item) => item?.[0] !== undefined)
+        .map(([container, local]) => ({
+          source: local,
+          target: container,
+        })),
+    )
+    .withWaitStrategy(Wait.forHttp("/api/health/ready", 7575))
+    .withExtraHosts([
+      {
+        // This enabled the usage of host.docker.internal as hostname in the container
+        host: "host.docker.internal",
+        ipAddress: "host-gateway",
+      },
+    ]);
+
+  return withLogs(container);
 };
 
 export const withLogs = (container: GenericContainer) => {

e2e/shared/e2e-db.ts

@@ -0,0 +1,32 @@
+import { mkdir } from "fs/promises";
+import path from "path";
+import { createId } from "@paralleldrive/cuid2";
+import Database from "better-sqlite3";
+import { BetterSQLite3Database, drizzle } from "drizzle-orm/better-sqlite3";
+import { migrate } from "drizzle-orm/better-sqlite3/migrator";
+
+import * as sqliteSchema from "../../packages/db/schema/sqlite";
+
+export const createSqliteDbFileAsync = async () => {
+  const localMountPath = path.join(__dirname, "tmp", createId());
+  await mkdir(path.join(localMountPath, "db"), { recursive: true });
+
+  const localDbUrl = path.join(localMountPath, "db", "db.sqlite");
+
+  const connection = new Database(localDbUrl);
+  const db = drizzle(connection, {
+    schema: sqliteSchema,
+    casing: "snake_case",
+  });
+
+  await migrate(db, {
+    migrationsFolder: path.join(__dirname, "..", "..", "packages", "db", "migrations", "sqlite"),
+  });
+
+  return {
+    db,
+    localMountPath,
+  };
+};
+
+export type SqliteDatabase = BetterSQLite3Database<typeof sqliteSchema>;