snapshot of https://github.com/ory/kratos.git (master, 2026-09-15; blobs > 131072B omitted)

test/e2e/playwright/fixtures/index.ts

@@ -0,0 +1,241 @@
+// Copyright © 2023 Ory Corp
+// SPDX-License-Identifier: Apache-2.0
+
+import { Identity } from "@ory/kratos-client"
+import {
+  APIRequestContext,
+  CDPSession,
+  expect as baseExpect,
+  Page,
+  test as base,
+} from "@playwright/test"
+import { writeFile } from "fs/promises"
+import { merge } from "lodash"
+import { OryKratosConfiguration } from "../../shared/config"
+import { default_config } from "../setup/default_config"
+import { APIResponse } from "playwright-core"
+import { SessionWithResponse } from "../types"
+import { retryOptions } from "../lib/request"
+import promiseRetry from "promise-retry"
+import { Protocol } from "playwright-core/types/protocol"
+import {
+  createIdentityWithEmail,
+  createIdentityWithPassword,
+} from "../actions/identity"
+import { randomBytes } from "crypto"
+
+// from https://stackoverflow.com/questions/61132262/typescript-deep-partial
+type DeepPartial<T> = T extends object
+  ? {
+      [P in keyof T]?: DeepPartial<T[P]>
+    }
+  : T
+
+type TestFixtures = {
+  identity: { oryIdentity: Identity; email: string; password: string }
+  identityWithoutPassword: { oryIdentity: Identity; email: string }
+  configOverride: DeepPartial<OryKratosConfiguration>
+  config: OryKratosConfiguration
+  virtualAuthenticatorOptions: Partial<Protocol.WebAuthn.VirtualAuthenticatorOptions>
+  pageCDPSession: CDPSession
+  virtualAuthenticator: Protocol.WebAuthn.addVirtualAuthenticatorReturnValue
+}
+
+type WorkerFixtures = {
+  kratosAdminURL: string
+  kratosPublicURL: string
+  mode:
+    | "reconfigure_kratos"
+    | "reconfigure_ory_network_project"
+    | "existing_kratos"
+    | "existing_ory_network_project"
+}
+
+export const test = base.extend<TestFixtures, WorkerFixtures>({
+  configOverride: {},
+  config: [
+    async ({ request, configOverride }, use) => {
+      const configToWrite = merge(default_config, configOverride)
+
+      const revision = randomBytes(16).toString("hex")
+      const fileDirectory = __dirname + "/../.."
+      await writeFile(
+        fileDirectory + "/playwright/kratos.config.json",
+        JSON.stringify(
+          {
+            ...configToWrite,
+            // Forces a new hash, even if the config was not changed.
+            revision,
+          },
+          null,
+          2,
+        ),
+      )
+
+      await expect(async () => {
+        const resp = await request.get(
+          "http://localhost:4434/admin/health/config",
+        )
+        const updatedRevision = (await resp.body()).toString()
+        expect(updatedRevision).toBe(revision)
+      }).toPass()
+
+      await use(configToWrite)
+    },
+    { auto: true },
+  ],
+  virtualAuthenticatorOptions: undefined,
+  pageCDPSession: async ({ page }, use) => {
+    const cdpSession = await page.context().newCDPSession(page)
+    await use(cdpSession)
+    await cdpSession.detach()
+  },
+  virtualAuthenticator: async (
+    { pageCDPSession, virtualAuthenticatorOptions },
+    use,
+  ) => {
+    await pageCDPSession.send("WebAuthn.enable")
+    const { authenticatorId } = await pageCDPSession.send(
+      "WebAuthn.addVirtualAuthenticator",
+      {
+        options: {
+          protocol: "ctap2",
+          transport: "internal",
+          hasResidentKey: true,
+          hasUserVerification: true,
+          isUserVerified: true,
+          ...virtualAuthenticatorOptions,
+        },
+      },
+    )
+    await use({ authenticatorId })
+    await pageCDPSession.send("WebAuthn.removeVirtualAuthenticator", {
+      authenticatorId,
+    })
+
+    await pageCDPSession.send("WebAuthn.disable")
+  },
+  identity: async ({ request }, use, i) => {
+    const {
+      identity: oryIdentity,
+      password,
+      email,
+    } = await createIdentityWithPassword(request)
+    i.attach("identity", {
+      body: JSON.stringify(oryIdentity, null, 2),
+      contentType: "application/json",
+    })
+    await use({
+      oryIdentity,
+      email,
+      password,
+    })
+  },
+  identityWithoutPassword: async ({ request }, use, i) => {
+    const { identity: oryIdentity, email } =
+      await createIdentityWithEmail(request)
+    i.attach("identity", {
+      body: JSON.stringify(oryIdentity, null, 2),
+      contentType: "application/json",
+    })
+    await use({
+      oryIdentity,
+      email,
+    })
+  },
+  kratosAdminURL: ["http://localhost:4434", { option: true, scope: "worker" }],
+  kratosPublicURL: ["http://localhost:4433", { option: true, scope: "worker" }],
+})
+
+export const expect = baseExpect.extend({
+  toHaveSession,
+  toMatchResponseData,
+})
+
+async function toHaveSession(
+  requestOrPage: APIRequestContext | Page,
+  baseUrl: string,
+) {
+  let r: APIRequestContext
+  if ("request" in requestOrPage) {
+    r = requestOrPage.request
+  } else {
+    r = requestOrPage
+  }
+  let pass = true
+
+  let responseData: string
+  let response: APIResponse = null
+  try {
+    const result = await promiseRetry(
+      () =>
+        r
+          .get(baseUrl + "/sessions/whoami", {
+            failOnStatusCode: false,
+          })
+          .then<SessionWithResponse>(
+            async (res: APIResponse): Promise<SessionWithResponse> => {
+              return {
+                session: await res.json(),
+                response: res,
+              }
+            },
+          ),
+      retryOptions,
+    )
+    pass = !!result.session.active
+    responseData = await result.response.text()
+    response = result.response
+  } catch (e) {
+    pass = false
+    responseData = JSON.stringify(e.message, undefined, 2)
+  }
+
+  const message = () =>
+    this.utils.matcherHint("toHaveSession", undefined, undefined, {
+      isNot: this.isNot,
+    }) +
+    `\n
+    \n
+    Expected: ${this.isNot ? "not" : ""} to have session\n
+    Session data received: ${responseData}\n
+    Headers: ${JSON.stringify(response?.headers(), null, 2)}\n
+    `
+
+  return {
+    message,
+    pass,
+    name: "toHaveSession",
+  }
+}
+
+async function toMatchResponseData(
+  res: APIResponse,
+  options: {
+    statusCode?: number
+    failureHint?: string
+  },
+) {
+  const body = await res.text()
+  const statusCode = options.statusCode ?? 200
+  const failureHint = options.failureHint ?? ""
+  const message = () =>
+    this.utils.matcherHint("toMatch", undefined, undefined, {
+      isNot: this.isNot,
+    }) +
+    `\n
+    ${failureHint}
+    \n
+    Expected: ${this.isNot ? "not" : ""} to match\n
+    Status Code: ${statusCode}\n
+    Body: ${body}\n
+    Headers: ${JSON.stringify(res.headers(), null, 2)}\n
+    URL: ${JSON.stringify(res.url(), null, 2)}\n
+    `
+
+  return {
+    message,
+    pass: res.status() === statusCode,
+    name: "toMatch",
+  }
+}

test/e2e/playwright/fixtures/mappers/hydra-phone.jsonnet

@@ -0,0 +1,12 @@
+local claims = std.extVar('claims');
+
+if std.length(claims.sub) == 0 then
+  error 'claim sub not set'
+else
+  {
+    identity: {
+      traits: {
+        phone: claims.sub,
+      },
+    },
+  }

test/e2e/playwright/fixtures/schemas/sms-oidc.ts

@@ -0,0 +1,35 @@
+// Copyright © 2024 Ory Corp
+// SPDX-License-Identifier: Apache-2.0
+
+export default {
+  $id: "https://schemas.ory.sh/presets/kratos/test/sms-oidc/identity.schema.json",
+  $schema: "http://json-schema.org/draft-07/schema#",
+  title: "Person",
+  type: "object",
+  properties: {
+    traits: {
+      type: "object",
+      properties: {
+        phone: {
+          type: "string",
+          format: "tel",
+          title: "Your Phone Number",
+          minLength: 3,
+          "ory.sh/kratos": {
+            credentials: {
+              code: {
+                identifier: true,
+                via: "sms",
+              },
+            },
+            verification: {
+              via: "sms",
+            },
+          },
+        },
+      },
+      required: ["phone"],
+      additionalProperties: false,
+    },
+  },
+}

test/e2e/playwright/fixtures/schemas/sms-password.ts

@@ -0,0 +1,41 @@
+// Copyright © 2024 Ory Corp
+// SPDX-License-Identifier: Apache-2.0
+
+export default {
+  $id: "https://schemas.ory.sh/presets/kratos/test/sms-password/identity.schema.json",
+  $schema: "http://json-schema.org/draft-07/schema#",
+  title: "Person",
+  type: "object",
+  properties: {
+    traits: {
+      type: "object",
+      properties: {
+        phone: {
+          type: "string",
+          format: "tel",
+          title: "Your Phone Number",
+          minLength: 3,
+          "ory.sh/kratos": {
+            credentials: {
+              password: {
+                identifier: true,
+              },
+              code: {
+                identifier: true,
+                via: "sms",
+              },
+            },
+            verification: {
+              via: "sms",
+            },
+            recovery: {
+              via: "sms",
+            },
+          },
+        },
+      },
+      required: ["phone"],
+      additionalProperties: false,
+    },
+  },
+}

test/e2e/playwright/fixtures/schemas/sms.ts

@@ -0,0 +1,35 @@
+// Copyright © 2024 Ory Corp
+// SPDX-License-Identifier: Apache-2.0
+
+export default {
+  $id: "https://schemas.ory.sh/presets/kratos/quickstart/email-password/identity.schema.json",
+  $schema: "http://json-schema.org/draft-07/schema#",
+  title: "Person",
+  type: "object",
+  properties: {
+    traits: {
+      type: "object",
+      properties: {
+        phone: {
+          type: "string",
+          format: "tel",
+          title: "Your Phone Number",
+          minLength: 3,
+          "ory.sh/kratos": {
+            credentials: {
+              code: {
+                identifier: true,
+                via: "sms",
+              },
+            },
+            verification: {
+              via: "sms",
+            },
+          },
+        },
+      },
+      required: ["phone"],
+      additionalProperties: false,
+    },
+  },
+}