@shopware-ag/acceptance-test-suite 1.0.0

package/dist/index.mjs

@@ -0,0 +1,2259 @@
+import { test as test$c, expect, request, mergeTests } from '@playwright/test';
+export * from '@playwright/test';
+import crypto, { createHash } from 'crypto';
+import { stringify } from 'uuid';
+import { Image } from 'image-js';
+import fs from 'fs';
+
+const getLanguageData = async (languageCode, adminApiContext) => {
+  const resp = await adminApiContext.post("search/language", {
+    data: {
+      limit: 1,
+      filter: [{
+        type: "equals",
+        field: "translationCode.code",
+        value: languageCode
+      }],
+      associations: { translationCode: {} }
+    }
+  });
+  const result = await resp.json();
+  return {
+    id: result.data[0].id,
+    localeId: result.data[0].translationCode.id
+  };
+};
+const getSnippetSetId = async (languageCode, adminApiContext) => {
+  const resp = await adminApiContext.post("search/snippet-set", {
+    data: {
+      limit: 1,
+      filter: [{
+        type: "equals",
+        field: "iso",
+        value: languageCode
+      }]
+    }
+  });
+  const result = await resp.json();
+  return result.data[0].id;
+};
+const getCurrency = async (isoCode, adminApiContext) => {
+  const resp = await adminApiContext.post("search/currency", {
+    data: {
+      limit: 1,
+      filter: [{
+        type: "equals",
+        field: "isoCode",
+        value: isoCode
+      }]
+    }
+  });
+  const result = await resp.json();
+  return result.data[0];
+};
+const getTaxId = async (adminApiContext) => {
+  const resp = await adminApiContext.post("search/tax", {
+    data: { limit: 1 }
+  });
+  const result = await resp.json();
+  return result.data[0].id;
+};
+const getPaymentMethodId = async (adminApiContext, handlerId) => {
+  const handler = handlerId || "Shopware\\Core\\Checkout\\Payment\\Cart\\PaymentHandler\\InvoicePayment";
+  const resp = await adminApiContext.post("search/payment-method", {
+    data: {
+      limit: 1,
+      filter: [{
+        type: "equals",
+        field: "handlerIdentifier",
+        value: handler
+      }]
+    }
+  });
+  const result = await resp.json();
+  return result.data[0].id;
+};
+const getDefaultShippingMethodId = async (adminApiContext) => {
+  const resp = await adminApiContext.post("search/shipping-method", {
+    data: {
+      limit: 1,
+      filter: [{
+        type: "equals",
+        field: "name",
+        value: "Standard"
+      }]
+    }
+  });
+  const result = await resp.json();
+  return result.data[0].id;
+};
+const getCountryId = async (iso2, adminApiContext) => {
+  const resp = await adminApiContext.post("search/country", {
+    data: {
+      limit: 1,
+      filter: [{
+        type: "equals",
+        field: "iso",
+        value: iso2
+      }]
+    }
+  });
+  const result = await resp.json();
+  return result.data[0].id;
+};
+const getThemeId = async (technicalName, adminApiContext) => {
+  const resp = await adminApiContext.post("search/theme", {
+    data: {
+      limit: 1,
+      filter: [{
+        type: "equals",
+        field: "technicalName",
+        value: technicalName
+      }]
+    }
+  });
+  const result = await resp.json();
+  return result.data[0].id;
+};
+const getSalutationId = async (salutationKey, adminApiContext) => {
+  const resp = await adminApiContext.post("search/salutation", {
+    data: {
+      limit: 1,
+      filter: [{
+        type: "equals",
+        field: "salutationKey",
+        value: salutationKey
+      }]
+    }
+  });
+  const result = await resp.json();
+  return result.data[0].id;
+};
+const getStateMachineId = async (technicalName, adminApiContext) => {
+  const resp = await adminApiContext.post("search/state-machine", {
+    data: {
+      limit: 1,
+      filter: [{
+        type: "equals",
+        field: "technicalName",
+        value: technicalName
+      }]
+    }
+  });
+  const result = await resp.json();
+  return result.data[0].id;
+};
+const getStateMachineStateId = async (stateMachineId, adminApiContext) => {
+  const resp = await adminApiContext.post("search/state-machine-state", {
+    data: {
+      limit: 1,
+      filter: [{
+        type: "equals",
+        field: "stateMachineId",
+        value: stateMachineId
+      }]
+    }
+  });
+  const result = await resp.json();
+  return result.data[0].id;
+};
+const getFlowId = async (eventName, adminApiContext) => {
+  const resp = await adminApiContext.post("search-ids/flow", {
+    data: {
+      query: [{
+        query: {
+          type: "contains",
+          field: "flow.eventName",
+          value: eventName
+        }
+      }]
+    }
+  });
+  const result = await resp.json();
+  return result.data[0];
+};
+const getOrderTransactionId = async (orderId, adminApiContext) => {
+  const orderTransactionResponse = await adminApiContext.get(`order/${orderId}/transactions?_response`);
+  const { data: orderTransaction } = await orderTransactionResponse.json();
+  return orderTransaction[0].id;
+};
+const getMediaId = async (fileName, adminApiContext) => {
+  const resp = await adminApiContext.post("./search/media", {
+    data: {
+      limit: 1,
+      filter: [{
+        type: "equals",
+        field: "fileName",
+        value: fileName
+      }]
+    }
+  });
+  const result = await resp.json();
+  return result.data[0].id;
+};
+function extractIdFromUrl(url) {
+  const segments = url.split("/");
+  return segments.length > 0 ? segments[segments.length - 1] : null;
+}
+
+const test$a = test$c.extend({
+  SalesChannelBaseConfig: [
+    async ({ AdminApiContext }, use) => {
+      const requests = {
+        language: getLanguageData("en-GB", AdminApiContext),
+        currencyEUR: getCurrency("EUR", AdminApiContext),
+        invoicePaymentMethodId: getPaymentMethodId(AdminApiContext),
+        defaultShippingMethod: getDefaultShippingMethodId(AdminApiContext),
+        getTaxId: getTaxId(AdminApiContext),
+        deCountryId: getCountryId("de", AdminApiContext),
+        enGBSnippetSetId: getSnippetSetId("en-GB", AdminApiContext),
+        defaultThemeId: getThemeId("Storefront", AdminApiContext)
+      };
+      await Promise.all(Object.values(requests));
+      const lang = await requests.language;
+      const currency = await requests.currencyEUR;
+      await use({
+        enGBLocaleId: lang.localeId,
+        enGBLanguageId: lang.id,
+        storefrontTypeId: "8a243080f92e4c719546314b577cf82b",
+        eurCurrencyId: currency.id,
+        invoicePaymentMethodId: await requests.invoicePaymentMethodId,
+        defaultShippingMethod: await requests.defaultShippingMethod,
+        taxId: await requests.getTaxId,
+        deCountryId: await requests.deCountryId,
+        enGBSnippetSetId: await requests.enGBSnippetSetId,
+        defaultThemeId: await requests.defaultThemeId,
+        appUrl: process.env["APP_URL"],
+        adminUrl: process.env["ADMIN_URL"] || `${process.env["APP_URL"]}admin/`
+      });
+    },
+    { scope: "worker" }
+  ],
+  DefaultSalesChannel: [
+    async ({ IdProvider, AdminApiContext, SalesChannelBaseConfig }, use) => {
+      const { id, uuid } = IdProvider.getWorkerDerivedStableId("salesChannel");
+      const { uuid: rootCategoryUuid } = IdProvider.getWorkerDerivedStableId("category");
+      const { uuid: customerGroupUuid } = IdProvider.getWorkerDerivedStableId("customerGroup");
+      const { uuid: domainUuid } = IdProvider.getWorkerDerivedStableId("domain");
+      const { uuid: customerUuid } = IdProvider.getWorkerDerivedStableId("customer");
+      const baseUrl = `${SalesChannelBaseConfig.appUrl}test-${uuid}/`;
+      const currentConfigResponse = await AdminApiContext.get(`./_action/system-config?domain=storefront&salesChannelId=${uuid}`);
+      const currentConfig = await currentConfigResponse.json();
+      await AdminApiContext.delete(`./customer/${customerUuid}`);
+      const ordersResp = await AdminApiContext.post(`./search/order`, {
+        data: {
+          filter: [{
+            type: "equals",
+            field: "salesChannelId",
+            value: uuid
+          }]
+        }
+      });
+      const orders = await ordersResp.json();
+      if (orders.data) {
+        for (const order of orders.data) {
+          const deleteOrderResp = await AdminApiContext.delete(`./order/${order.id}`);
+          expect(deleteOrderResp.ok()).toBeTruthy();
+        }
+      }
+      const versionsResp = await AdminApiContext.post(`./search/version`);
+      expect(versionsResp.ok()).toBeTruthy();
+      const versions = await versionsResp.json();
+      const versionIds = versions.data.map((v) => v.id);
+      for (const versionId of versionIds) {
+        const ordersResp2 = await AdminApiContext.post(`./search/order`, {
+          data: {
+            filter: [
+              {
+                type: "equals",
+                field: "salesChannelId",
+                value: uuid
+              }
+            ]
+          },
+          headers: {
+            "sw-version-id": versionId
+          }
+        });
+        const orders2 = await ordersResp2.json();
+        if (orders2.data) {
+          for (const order of orders2.data) {
+            const deleteOrderResp = await AdminApiContext.post(
+              `./_action/version/${versionId}/order/${order.id}`
+            );
+            expect(deleteOrderResp.ok()).toBeTruthy();
+          }
+        }
+      }
+      await AdminApiContext.delete(`./sales-channel/${uuid}`);
+      const syncResp = await AdminApiContext.post("./_action/sync", {
+        data: {
+          "write-sales-channel": {
+            entity: "sales_channel",
+            action: "upsert",
+            payload: [
+              {
+                id: uuid,
+                name: `${id} acceptance test`,
+                typeId: SalesChannelBaseConfig.storefrontTypeId,
+                languageId: SalesChannelBaseConfig.enGBLanguageId,
+                currencyId: SalesChannelBaseConfig.eurCurrencyId,
+                paymentMethodId: SalesChannelBaseConfig.invoicePaymentMethodId,
+                shippingMethodId: SalesChannelBaseConfig.defaultShippingMethod,
+                countryId: SalesChannelBaseConfig.deCountryId,
+                accessKey: "SWSC" + uuid,
+                homeEnabled: true,
+                navigationCategory: {
+                  id: rootCategoryUuid,
+                  name: `${id} Acceptance test`,
+                  displayNestedProducts: true,
+                  type: "page",
+                  productAssignmentType: "product"
+                },
+                domains: [{
+                  id: domainUuid,
+                  url: baseUrl,
+                  languageId: SalesChannelBaseConfig.enGBLanguageId,
+                  snippetSetId: SalesChannelBaseConfig.enGBSnippetSetId,
+                  currencyId: SalesChannelBaseConfig.eurCurrencyId
+                }],
+                customerGroup: {
+                  id: customerGroupUuid,
+                  name: `${id} Acceptance test`
+                },
+                languages: [{ id: SalesChannelBaseConfig.enGBLanguageId }],
+                countries: [{ id: SalesChannelBaseConfig.deCountryId }],
+                shippingMethods: [{ id: SalesChannelBaseConfig.defaultShippingMethod }],
+                paymentMethods: [{ id: SalesChannelBaseConfig.invoicePaymentMethodId }],
+                currencies: [{ id: SalesChannelBaseConfig.eurCurrencyId }]
+              }
+            ]
+          },
+          "theme-assignment": {
+            entity: "theme_sales_channel",
+            action: "upsert",
+            payload: [{
+              salesChannelId: uuid,
+              themeId: SalesChannelBaseConfig.defaultThemeId
+            }]
+          }
+        }
+      });
+      expect(syncResp.ok()).toBeTruthy();
+      const salesChannelPromise = AdminApiContext.get(`./sales-channel/${uuid}`);
+      let themeAssignPromise;
+      if (currentConfig && currentConfig["storefront.themeSeed"]) {
+        const md5 = (data) => createHash("md5").update(data).digest("hex");
+        const md5Str = md5(`${SalesChannelBaseConfig.defaultThemeId}${uuid}${currentConfig["storefront.themeSeed"]}`);
+        const themeCssResp = await AdminApiContext.head(`${SalesChannelBaseConfig.appUrl}theme/${md5Str}/css/all.css`);
+        if (themeCssResp.status() === 200) {
+          themeAssignPromise = AdminApiContext.post(`./_action/system-config?salesChannelId=${uuid}`, {
+            data: {
+              "storefront.themeSeed": currentConfig["storefront.themeSeed"]
+            }
+          });
+        }
+      }
+      if (!themeAssignPromise) {
+        themeAssignPromise = AdminApiContext.post(
+          `./_action/theme/${SalesChannelBaseConfig.defaultThemeId}/assign/${uuid}`
+        );
+      }
+      const salutationResponse = await AdminApiContext.get(`./salutation`);
+      const salutations = await salutationResponse.json();
+      const customerData = {
+        id: customerUuid,
+        email: `customer_${id}@example.com`,
+        password: "shopware",
+        salutationId: salutations.data[0].id,
+        defaultShippingAddress: {
+          firstName: `${id} admin`,
+          lastName: `${id} admin`,
+          city: "not",
+          street: "not",
+          zipcode: "not",
+          countryId: SalesChannelBaseConfig.deCountryId,
+          salutationId: salutations.data[0].id
+        },
+        defaultBillingAddress: {
+          firstName: `${id} admin`,
+          lastName: `${id} admin`,
+          city: "not",
+          street: "not",
+          zipcode: "not",
+          countryId: SalesChannelBaseConfig.deCountryId,
+          salutationId: salutations.data[0].id
+        },
+        firstName: `${id} admin`,
+        lastName: `${id} admin`,
+        salesChannelId: uuid,
+        groupId: customerGroupUuid,
+        customerNumber: `${customerUuid}`,
+        defaultPaymentMethodId: SalesChannelBaseConfig.invoicePaymentMethodId
+      };
+      const customerRespPromise = AdminApiContext.post("./customer?_response", {
+        data: customerData
+      });
+      const [customerResp, themeAssignResp, salesChannelResp] = await Promise.all([
+        customerRespPromise,
+        themeAssignPromise,
+        salesChannelPromise
+      ]);
+      expect(customerResp.ok()).toBeTruthy();
+      expect(themeAssignResp.ok()).toBeTruthy();
+      expect(salesChannelResp.ok()).toBeTruthy();
+      const customer = await customerResp.json();
+      const salesChannel = await salesChannelResp.json();
+      await use({
+        salesChannel: salesChannel.data,
+        customer: { ...customer.data, password: customerData.password },
+        url: baseUrl
+      });
+    },
+    { scope: "worker" }
+  ]
+});
+
+var __defProp$k = Object.defineProperty;
+var __defNormalProp$k = (obj, key, value) => key in obj ? __defProp$k(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField$k = (obj, key, value) => {
+  __defNormalProp$k(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+const _AdminApiContext = class _AdminApiContext {
+  constructor(context, options) {
+    __publicField$k(this, "context");
+    __publicField$k(this, "options");
+    this.context = context;
+    this.options = options;
+  }
+  static async create(options) {
+    const contextOptions = { ...this.defaultOptions, ...options };
+    const tmpContext = await this.createApiRequestContext(contextOptions);
+    if (!contextOptions.client_id) {
+      contextOptions["access_token"] = await this.authenticateWithUserPassword(tmpContext, contextOptions);
+      const userContext = await this.createApiRequestContext(contextOptions);
+      const accessKeyData = await (await userContext.get("_action/access-key/integration")).json();
+      const integrationData = {
+        admin: true,
+        label: "Playwright Acceptance Test Suite",
+        ...accessKeyData
+      };
+      await userContext.post("integration", {
+        data: integrationData
+      });
+      contextOptions.client_id = accessKeyData.accessKey;
+      contextOptions.client_secret = accessKeyData.secretAccessKey;
+    }
+    contextOptions["access_token"] = await this.authenticateWithClientCredentials(tmpContext, contextOptions);
+    return new _AdminApiContext(await this.createApiRequestContext(contextOptions), contextOptions);
+  }
+  static async createApiRequestContext(options) {
+    const extraHTTPHeaders = {
+      "Accept": "application/json",
+      "Content-Type": "application/json"
+    };
+    if (options.access_token && options.access_token.length) {
+      extraHTTPHeaders["Authorization"] = "Bearer " + options.access_token;
+    }
+    return await request.newContext({
+      baseURL: `${options.app_url}api/`,
+      ignoreHTTPSErrors: options.ignoreHTTPSErrors,
+      extraHTTPHeaders
+    });
+  }
+  static async authenticateWithClientCredentials(context, options) {
+    const authResponse = await context.post("oauth/token", {
+      data: {
+        grant_type: "client_credentials",
+        client_id: options.client_id,
+        client_secret: options.client_secret,
+        scope: ["write"]
+      }
+    });
+    const authData = await authResponse.json();
+    if (!authData["access_token"]) {
+      throw new Error(`Failed to authenticate with client_id: ${options.client_id}`);
+    }
+    return authData["access_token"];
+  }
+  static async authenticateWithUserPassword(context, options) {
+    const authResponse = await context.post("oauth/token", {
+      data: {
+        client_id: "administration",
+        grant_type: "password",
+        username: options.admin_username,
+        password: options.admin_password,
+        scope: ["write"]
+      }
+    });
+    const authData = await authResponse.json();
+    if (!authData["access_token"]) {
+      throw new Error(`Failed to authenticate with user: ${options.admin_username}`);
+    }
+    return authData["access_token"];
+  }
+  isAuthenticated() {
+    return !!this.options["access_token"];
+  }
+  async get(url, options) {
+    return this.context.get(url, options);
+  }
+  async post(url, options) {
+    return this.context.post(url, options);
+  }
+  async patch(url, options) {
+    return this.context.patch(url, options);
+  }
+  async delete(url, options) {
+    return this.context.delete(url, options);
+  }
+  async fetch(url, options) {
+    return this.context.fetch(url, options);
+  }
+  async head(url, options) {
+    return this.context.head(url, options);
+  }
+};
+__publicField$k(_AdminApiContext, "defaultOptions", {
+  app_url: process.env["APP_URL"],
+  client_id: process.env["SHOPWARE_ACCESS_KEY_ID"],
+  client_secret: process.env["SHOPWARE_SECRET_ACCESS_KEY"],
+  admin_username: process.env["SHOPWARE_ADMIN_USERNAME"] || "admin",
+  admin_password: process.env["SHOPWARE_ADMIN_PASSWORD"] || "shopware",
+  ignoreHTTPSErrors: true
+});
+let AdminApiContext = _AdminApiContext;
+
+var __defProp$j = Object.defineProperty;
+var __defNormalProp$j = (obj, key, value) => key in obj ? __defProp$j(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField$j = (obj, key, value) => {
+  __defNormalProp$j(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+const _StoreApiContext = class _StoreApiContext {
+  constructor(context, options) {
+    __publicField$j(this, "context");
+    __publicField$j(this, "options");
+    this.context = context;
+    this.options = options;
+  }
+  static async create(options) {
+    const contextOptions = { ...this.defaultOptions, ...options };
+    return new _StoreApiContext(await this.createContext(contextOptions), contextOptions);
+  }
+  static async createContext(options) {
+    const extraHTTPHeaders = {
+      "Accept": "application/json",
+      "Content-Type": "application/json"
+    };
+    if (options["sw-access-key"]) {
+      extraHTTPHeaders["sw-access-key"] = options["sw-access-key"];
+    }
+    if (options["sw-context-token"]) {
+      extraHTTPHeaders["sw-context-token"] = options["sw-context-token"];
+    }
+    return await request.newContext({
+      baseURL: `${options["app_url"]}store-api/`,
+      ignoreHTTPSErrors: options.ignoreHTTPSErrors,
+      extraHTTPHeaders
+    });
+  }
+  async login(user) {
+    const loginResponse = await this.post(`account/login`, {
+      data: {
+        username: user.email,
+        password: user.password
+      }
+    });
+    const responseHeaders = loginResponse.headers();
+    if (!responseHeaders["sw-context-token"]) {
+      throw new Error(`Failed to login with user: ${user.email}`);
+    }
+    this.options["sw-context-token"] = responseHeaders["sw-context-token"];
+    this.context = await _StoreApiContext.createContext(this.options);
+    return responseHeaders;
+  }
+  async get(url, options) {
+    return this.context.get(url, options);
+  }
+  async post(url, options) {
+    return this.context.post(url, options);
+  }
+  async patch(url, options) {
+    return this.context.patch(url, options);
+  }
+  async delete(url, options) {
+    return this.context.delete(url, options);
+  }
+  async fetch(url, options) {
+    return this.context.fetch(url, options);
+  }
+  async head(url, options) {
+    return this.context.head(url, options);
+  }
+};
+__publicField$j(_StoreApiContext, "defaultOptions", {
+  app_url: process.env["APP_URL"],
+  ignoreHTTPSErrors: true
+});
+let StoreApiContext = _StoreApiContext;
+
+const test$9 = test$c.extend({
+  AdminApiContext: [
+    async ({}, use) => {
+      const adminApiContext = await AdminApiContext.create();
+      await use(adminApiContext);
+    },
+    { scope: "worker" }
+  ],
+  StoreApiContext: [
+    async ({ DefaultSalesChannel }, use) => {
+      const options = {
+        app_url: process.env["APP_URL"],
+        "sw-access-key": DefaultSalesChannel.salesChannel.accessKey,
+        ignoreHTTPSErrors: true
+      };
+      const storeApiContext = await StoreApiContext.create(options);
+      await use(storeApiContext);
+    },
+    { scope: "worker" }
+  ]
+});
+
+const test$8 = test$c.extend({
+  AdminPage: async ({ IdProvider, AdminApiContext, SalesChannelBaseConfig, browser }, use) => {
+    const context = await browser.newContext({
+      baseURL: SalesChannelBaseConfig.adminUrl
+    });
+    const page = await context.newPage();
+    const { id, uuid } = IdProvider.getIdPair();
+    const adminUser = {
+      id: uuid,
+      username: `admin_${id}`,
+      firstName: `${id} admin`,
+      lastName: `${id} admin`,
+      localeId: SalesChannelBaseConfig.enGBLocaleId,
+      email: `admin_${id}@example.com`,
+      timezone: "Europe/Berlin",
+      password: "shopware",
+      admin: true
+    };
+    const response = await AdminApiContext.post("user", {
+      data: adminUser
+    });
+    expect(response.ok()).toBeTruthy();
+    await page.goto("#/login");
+    await page.getByLabel("Username").fill(adminUser.username);
+    await page.getByLabel("Password").fill(adminUser.password);
+    await page.getByRole("button", { name: "Log in" }).click();
+    await expect(page.locator("css=.sw-admin-menu__header-logo").first()).toBeVisible({
+      timeout: 2e4
+    });
+    await expect(page.locator(".sw-skeleton")).toHaveCount(0, {
+      timeout: 1e4
+    });
+    await expect(page.locator(".sw-loader")).toHaveCount(0, {
+      timeout: 1e4
+    });
+    await page.addStyleTag({
+      content: `
+                .sf-toolbar {
+                    width: 0 !important;
+                    height: 0 !important;
+                    display: none !important;
+                    pointer-events: none !important;
+                }
+                `.trim()
+    });
+    await use(page);
+    await page.close();
+    await context.close();
+    const cleanupResponse = await AdminApiContext.delete(`user/${uuid}`);
+    expect(cleanupResponse.ok()).toBeTruthy();
+  },
+  StorefrontPage: async ({ DefaultSalesChannel, browser }, use) => {
+    const { url } = DefaultSalesChannel;
+    const context = await browser.newContext({
+      baseURL: url
+    });
+    const page = await context.newPage();
+    await page.goto("./");
+    await use(page);
+    await page.close();
+    await context.close();
+  }
+});
+
+var __defProp$i = Object.defineProperty;
+var __defNormalProp$i = (obj, key, value) => key in obj ? __defProp$i(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField$i = (obj, key, value) => {
+  __defNormalProp$i(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+class Actor {
+  constructor(name, page) {
+    __publicField$i(this, "page");
+    __publicField$i(this, "name");
+    __publicField$i(this, "expects", expect);
+    this.name = name;
+    this.page = page;
+  }
+  async attemptsTo(task) {
+    const stepTitle = `${this.name} attempts to ${this.camelCaseToLowerCase(task.name)}`;
+    await test$c.step(stepTitle, async () => await task());
+  }
+  async goesTo(pageObject) {
+    const stepTitle = `${this.name} navigates to ${this.camelCaseToLowerCase(pageObject.constructor.name)}`;
+    await test$c.step(stepTitle, async () => {
+      await pageObject.goTo();
+      await this.page.addStyleTag({
+        content: `
+                .sf-toolbar {
+                    width: 0 !important;
+                    height: 0 !important;
+                    display: none !important;
+                    pointer-events: none !important;
+                }
+                `.trim()
+      });
+    });
+  }
+  camelCaseToLowerCase(str) {
+    return str.replace(/[A-Z]/g, (letter) => ` ${letter.toLowerCase()}`);
+  }
+}
+
+const test$7 = test$c.extend({
+  ShopCustomer: async ({ StorefrontPage }, use) => {
+    const shopCustomer = new Actor("Shop customer", StorefrontPage);
+    await use(shopCustomer);
+  },
+  ShopAdmin: async ({ AdminPage }, use) => {
+    const shopAdmin = new Actor("Shop administrator", AdminPage);
+    await use(shopAdmin);
+  }
+});
+
+var __defProp$h = Object.defineProperty;
+var __defNormalProp$h = (obj, key, value) => key in obj ? __defProp$h(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField$h = (obj, key, value) => {
+  __defNormalProp$h(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+class IdProvider {
+  constructor(workerIndex, seed) {
+    __publicField$h(this, "workerIndex");
+    __publicField$h(this, "seed");
+    this.workerIndex = workerIndex;
+    this.seed = seed;
+  }
+  getIdPair() {
+    return {
+      id: `${crypto.randomInt(0, 281474976710655)}`,
+      uuid: crypto.randomUUID().replaceAll("-", "")
+    };
+  }
+  getUniqueName() {
+    return `name_${this.getIdPair().id}`;
+  }
+  getWorkerDerivedStableId(key) {
+    const hash = crypto.createHash("sha256");
+    hash.update(this.seed);
+    hash.update(key);
+    hash.update(`${this.workerIndex}`);
+    const buffer = hash.digest();
+    const bytes = Uint8Array.from(buffer).slice(0, 16);
+    bytes[6] = 1 << 5;
+    bytes[8] = 128;
+    return {
+      id: `${this.workerIndex}`,
+      uuid: stringify(bytes).replaceAll("-", "")
+    };
+  }
+}
+
+const test$6 = test$c.extend({
+  IdProvider: [
+    async ({}, use, workerInfo) => {
+      const seed = process.env.SHOPWARE_ACCESS_KEY_ID || process.env.SHOPWARE_ADMIN_PASSWORD || "test-suite";
+      const idProvider = new IdProvider(workerInfo.workerIndex, seed);
+      await use(idProvider);
+    },
+    { scope: "worker" }
+  ]
+});
+
+var __defProp$g = Object.defineProperty;
+var __defNormalProp$g = (obj, key, value) => key in obj ? __defProp$g(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField$g = (obj, key, value) => {
+  __defNormalProp$g(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+class Home {
+  constructor(page) {
+    this.page = page;
+    __publicField$g(this, "productImages");
+    this.productImages = page.locator(".product-image-link");
+  }
+  async goTo() {
+    await this.page.goto("./");
+  }
+}
+
+var __defProp$f = Object.defineProperty;
+var __defNormalProp$f = (obj, key, value) => key in obj ? __defProp$f(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField$f = (obj, key, value) => {
+  __defNormalProp$f(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+let ProductDetail$1 = class ProductDetail {
+  constructor(page, productData) {
+    this.page = page;
+    this.productData = productData;
+    __publicField$f(this, "addToCartButton");
+    __publicField$f(this, "offCanvasCartTitle");
+    __publicField$f(this, "offCanvasCart");
+    __publicField$f(this, "offCanvasCartGoToCheckoutButton");
+    __publicField$f(this, "productSingleImage");
+    __publicField$f(this, "offCanvasLineItemImages");
+    __publicField$f(this, "quantitySelect");
+    __publicField$f(this, "offCanvasSummaryTotalPrice");
+    __publicField$f(this, "offCanvas");
+    this.addToCartButton = page.getByRole("button", { name: "Add to shopping cart" });
+    this.offCanvasCartTitle = page.getByText("Shopping cart", { exact: true });
+    this.offCanvasCart = page.getByRole("dialog");
+    this.offCanvasCartGoToCheckoutButton = page.getByRole("link", { name: "Go to checkout" });
+    this.offCanvasLineItemImages = page.locator(".line-item-img-link");
+    this.quantitySelect = page.getByLabel("Quantity", { exact: true });
+    this.offCanvas = page.locator("offcanvas-body");
+    this.offCanvasSummaryTotalPrice = page.locator(".offcanvas-summary").locator('dt:has-text("Subtotal") + dd');
+    this.productSingleImage = page.locator(".gallery-slider-single-image");
+  }
+  async goTo(productData = this.productData) {
+    let namePath = "";
+    if (productData.translated && productData.translated.name) {
+      namePath = productData.translated.name.replaceAll("_", "-");
+    }
+    const url = `${namePath}/${productData.productNumber}`;
+    await this.page.goto(url);
+  }
+};
+
+var __defProp$e = Object.defineProperty;
+var __defNormalProp$e = (obj, key, value) => key in obj ? __defProp$e(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField$e = (obj, key, value) => {
+  __defNormalProp$e(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+class CheckoutCart {
+  constructor(page) {
+    this.page = page;
+    __publicField$e(this, "headline");
+    __publicField$e(this, "goToCheckoutButton");
+    __publicField$e(this, "enterDiscountInput");
+    __publicField$e(this, "grandTotalPrice");
+    __publicField$e(this, "emptyCartAlert");
+    __publicField$e(this, "stockReachedAlert");
+    __publicField$e(this, "cartLineItemImages");
+    __publicField$e(this, "unitPriceInfo");
+    this.headline = page.getByRole("heading", { name: "Shopping cart" });
+    this.goToCheckoutButton = page.getByRole("link", { name: "Go to checkout" });
+    this.enterDiscountInput = page.getByLabel("Discount code");
+    this.grandTotalPrice = page.locator('dt:has-text("Grand total") + dd:visible');
+    this.emptyCartAlert = page.getByText("Your shopping cart is empty.");
+    this.stockReachedAlert = page.getByText("only available 1 times");
+    this.cartLineItemImages = page.locator(".line-item-img-link");
+    this.unitPriceInfo = page.locator(".line-item-unit-price-value");
+  }
+  async goTo() {
+    await this.page.goto("checkout/cart");
+  }
+}
+
+var __defProp$d = Object.defineProperty;
+var __defNormalProp$d = (obj, key, value) => key in obj ? __defProp$d(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField$d = (obj, key, value) => {
+  __defNormalProp$d(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+class CheckoutConfirm {
+  constructor(page) {
+    this.page = page;
+    __publicField$d(this, "headline");
+    __publicField$d(this, "termsAndConditionsCheckbox");
+    __publicField$d(this, "immediateAccessToDigitalProductCheckbox");
+    __publicField$d(this, "grandTotalPrice");
+    __publicField$d(this, "submitOrderButton");
+    /**
+     * Payment options
+     */
+    __publicField$d(this, "paymentCashOnDelivery");
+    __publicField$d(this, "paymentPaidInAdvance");
+    __publicField$d(this, "paymentInvoice");
+    /**
+     * Shipping options
+     */
+    __publicField$d(this, "shippingStandard");
+    __publicField$d(this, "shippingExpress");
+    /**
+     * Product details
+     */
+    __publicField$d(this, "cartLineItemImages");
+    this.headline = page.getByRole("heading", { name: "Complete order" });
+    this.termsAndConditionsCheckbox = page.getByLabel("I have read and accepted the general terms and conditions.");
+    this.immediateAccessToDigitalProductCheckbox = page.getByLabel("I want immediate access to the digital content and I acknowledge that thereby I waive my right to cancel.");
+    this.grandTotalPrice = page.locator(`dt:has-text('Grand total') + dd`);
+    this.submitOrderButton = page.getByRole("button", { name: "Submit order" });
+    this.paymentCashOnDelivery = page.getByLabel("Cash on delivery");
+    this.paymentPaidInAdvance = page.getByLabel("Paid in advance");
+    this.paymentInvoice = page.getByLabel("Invoice");
+    this.shippingStandard = page.getByLabel("Standard");
+    this.shippingExpress = page.getByLabel("Express");
+    this.cartLineItemImages = page.locator(".line-item-img-link");
+  }
+  async goTo() {
+    await this.page.goto("checkout/confirm");
+  }
+}
+
+var __defProp$c = Object.defineProperty;
+var __defNormalProp$c = (obj, key, value) => key in obj ? __defProp$c(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField$c = (obj, key, value) => {
+  __defNormalProp$c(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+class CheckoutFinish {
+  constructor(page) {
+    this.page = page;
+    __publicField$c(this, "headline");
+    __publicField$c(this, "orderNumberText");
+    __publicField$c(this, "grandTotalPrice");
+    __publicField$c(this, "cartLineItemImages");
+    __publicField$c(this, "orderNumberRegex", /Your order number: #(\d+)/);
+    this.headline = page.getByRole("heading", { name: "Thank you for your order" });
+    this.orderNumberText = page.getByText(this.orderNumberRegex);
+    this.grandTotalPrice = page.locator('dt:has-text("Grand total") + dd');
+    this.cartLineItemImages = page.locator(".line-item-img-link");
+  }
+  async goTo() {
+    console.error("The checkout finish page should only be navigated to via checkout action.");
+  }
+  async getOrderNumber() {
+    const orderNumberText = await this.orderNumberText.textContent();
+    let orderNumber = null;
+    if (orderNumberText !== null) {
+      const matches = orderNumberText.match(this.orderNumberRegex);
+      if (matches !== null && matches.length) {
+        orderNumber = matches[1];
+      }
+    }
+    return orderNumber;
+  }
+  getOrderId() {
+    const url = this.page.url();
+    const [, searchString] = url.split("?");
+    const params = new URLSearchParams(searchString);
+    return params.get("orderId");
+  }
+}
+
+var __defProp$b = Object.defineProperty;
+var __defNormalProp$b = (obj, key, value) => key in obj ? __defProp$b(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField$b = (obj, key, value) => {
+  __defNormalProp$b(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+class CheckoutRegister {
+  constructor(page) {
+    this.page = page;
+    __publicField$b(this, "cartLineItemImages");
+    this.cartLineItemImages = page.locator(".line-item-img-link");
+  }
+  async goTo() {
+    await this.page.goto("checkout/register");
+  }
+}
+
+var __defProp$a = Object.defineProperty;
+var __defNormalProp$a = (obj, key, value) => key in obj ? __defProp$a(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField$a = (obj, key, value) => {
+  __defNormalProp$a(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+class Account {
+  constructor(page) {
+    this.page = page;
+    __publicField$a(this, "headline");
+    __publicField$a(this, "personalDataCardTitle");
+    this.headline = page.getByRole("heading", { name: "Overview" });
+    this.personalDataCardTitle = page.getByRole("heading", { name: "Personal data" });
+  }
+  async goTo() {
+    await this.page.goto("account");
+  }
+}
+
+var __defProp$9 = Object.defineProperty;
+var __defNormalProp$9 = (obj, key, value) => key in obj ? __defProp$9(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField$9 = (obj, key, value) => {
+  __defNormalProp$9(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+class AccountLogin {
+  constructor(page) {
+    this.page = page;
+    __publicField$9(this, "emailInput");
+    __publicField$9(this, "passwordInput");
+    __publicField$9(this, "loginButton");
+    __publicField$9(this, "logoutLink");
+    __publicField$9(this, "successAlert");
+    // Inputs for registration
+    __publicField$9(this, "personalFormArea");
+    __publicField$9(this, "billingAddressFormArea");
+    __publicField$9(this, "firstNameInput");
+    __publicField$9(this, "lastNameInput");
+    __publicField$9(this, "registerEmailInput");
+    __publicField$9(this, "registerPasswordInput");
+    __publicField$9(this, "streetAddressInput");
+    __publicField$9(this, "cityInput");
+    __publicField$9(this, "countryInput");
+    __publicField$9(this, "registerButton");
+    this.emailInput = page.getByLabel("Your email address");
+    this.passwordInput = page.getByLabel("Your password");
+    this.loginButton = page.getByRole("button", { name: "Log in" });
+    this.logoutLink = page.getByRole("link", { name: "Log out" });
+    this.personalFormArea = page.locator(".register-personal");
+    this.billingAddressFormArea = page.locator(".register-billing");
+    this.firstNameInput = this.personalFormArea.getByLabel("First name*");
+    this.lastNameInput = this.personalFormArea.getByLabel("Last name*");
+    this.registerEmailInput = this.personalFormArea.getByLabel("Email address*");
+    this.registerPasswordInput = this.personalFormArea.getByLabel("Password*");
+    this.streetAddressInput = this.billingAddressFormArea.getByLabel("Street address*");
+    this.cityInput = this.billingAddressFormArea.getByLabel("City*");
+    this.countryInput = this.billingAddressFormArea.getByLabel("Country*");
+    this.registerButton = page.getByRole("button", { name: "Continue" });
+    this.logoutLink = page.getByRole("link", { name: "Log out" });
+    this.successAlert = page.getByText("Successfully logged out.");
+  }
+  async goTo() {
+    await this.page.goto("account/login");
+  }
+}
+
+var __defProp$8 = Object.defineProperty;
+var __defNormalProp$8 = (obj, key, value) => key in obj ? __defProp$8(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField$8 = (obj, key, value) => {
+  __defNormalProp$8(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+class AccountOrder {
+  constructor(page) {
+    this.page = page;
+    __publicField$8(this, "cartLineItemImages");
+    __publicField$8(this, "orderExpandButton");
+    __publicField$8(this, "digitalProductDownloadButton");
+    this.orderExpandButton = page.getByRole("button", { name: "Expand" }).first();
+    this.cartLineItemImages = page.locator(".line-item-img-link");
+    this.digitalProductDownloadButton = page.getByRole("link", { name: "Download" }).first();
+  }
+  async goTo() {
+    await this.page.goto("account/order");
+  }
+}
+
+var __defProp$7 = Object.defineProperty;
+var __defNormalProp$7 = (obj, key, value) => key in obj ? __defProp$7(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField$7 = (obj, key, value) => {
+  __defNormalProp$7(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+class Search {
+  constructor(page) {
+    this.page = page;
+    __publicField$7(this, "productImages");
+    this.productImages = page.locator(".product-image-link");
+  }
+  async goTo() {
+    const url = `search?search`;
+    await this.page.goto(url);
+  }
+}
+
+var __defProp$6 = Object.defineProperty;
+var __defNormalProp$6 = (obj, key, value) => key in obj ? __defProp$6(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField$6 = (obj, key, value) => {
+  __defNormalProp$6(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+class SearchSuggest {
+  constructor(page) {
+    this.page = page;
+    __publicField$6(this, "searchSuggestLineItemImages");
+    this.searchSuggestLineItemImages = page.locator(".search-suggest-product-image-container");
+  }
+  async goTo() {
+    const url = `suggest?search`;
+    await this.page.goto(url);
+  }
+}
+
+const StorefrontPageObjects = {
+  Home,
+  ProductDetail: ProductDetail$1,
+  CheckoutCart,
+  CheckoutConfirm,
+  CheckoutFinish,
+  CheckoutRegister,
+  Account,
+  AccountLogin,
+  AccountOrder,
+  Search,
+  SearchSuggest
+};
+const test$5 = test$c.extend({
+  StorefrontHome: async ({ StorefrontPage }, use) => {
+    await use(new Home(StorefrontPage));
+  },
+  StorefrontProductDetail: async ({ StorefrontPage, ProductData }, use) => {
+    await use(new ProductDetail$1(StorefrontPage, ProductData));
+  },
+  StorefrontCheckoutCart: async ({ StorefrontPage }, use) => {
+    await use(new CheckoutCart(StorefrontPage));
+  },
+  StorefrontCheckoutConfirm: async ({ StorefrontPage }, use) => {
+    await use(new CheckoutConfirm(StorefrontPage));
+  },
+  StorefrontCheckoutFinish: async ({ StorefrontPage }, use) => {
+    await use(new CheckoutFinish(StorefrontPage));
+  },
+  StorefrontCheckoutRegister: async ({ StorefrontPage }, use) => {
+    await use(new CheckoutRegister(StorefrontPage));
+  },
+  StorefrontAccount: async ({ StorefrontPage }, use) => {
+    await use(new Account(StorefrontPage));
+  },
+  StorefrontAccountLogin: async ({ StorefrontPage }, use) => {
+    await use(new AccountLogin(StorefrontPage));
+  },
+  StorefrontAccountOrder: async ({ StorefrontPage }, use) => {
+    await use(new AccountOrder(StorefrontPage));
+  },
+  StorefrontSearch: async ({ StorefrontPage }, use) => {
+    await use(new Search(StorefrontPage));
+  },
+  StorefrontSearchSuggest: async ({ StorefrontPage }, use) => {
+    await use(new SearchSuggest(StorefrontPage));
+  }
+});
+
+var __defProp$5 = Object.defineProperty;
+var __defNormalProp$5 = (obj, key, value) => key in obj ? __defProp$5(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField$5 = (obj, key, value) => {
+  __defNormalProp$5(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+class ProductDetail {
+  constructor(page, productData) {
+    this.page = page;
+    /**
+     * Save interactions
+     */
+    __publicField$5(this, "savePhysicalProductButton");
+    __publicField$5(this, "saveButtonLoadingSpinner");
+    __publicField$5(this, "saveButtonCheckMark");
+    /**
+     * Media Upload interactions
+     */
+    __publicField$5(this, "uploadMediaButton");
+    __publicField$5(this, "coverImage");
+    __publicField$5(this, "productImage");
+    /**
+     * Tabs
+     */
+    __publicField$5(this, "variantsTabLink");
+    /**
+     * Variants Generation
+     */
+    __publicField$5(this, "generateVariantsButton");
+    __publicField$5(this, "variantsModal");
+    __publicField$5(this, "variantsModalHeadline");
+    __publicField$5(this, "variantsNextButton");
+    __publicField$5(this, "variantsSaveButton");
+    /**
+     * Property Selection
+     */
+    __publicField$5(this, "propertyGroupColor");
+    __publicField$5(this, "propertyGroupSize");
+    __publicField$5(this, "propertyOptionGrid");
+    __publicField$5(this, "propertyOptionColorBlue");
+    __publicField$5(this, "propertyOptionColorRed");
+    __publicField$5(this, "propertyOptionColorGreen");
+    __publicField$5(this, "propertyOptionSizeSmall");
+    __publicField$5(this, "propertyOptionSizeMedium");
+    __publicField$5(this, "propertyOptionSizeLarge");
+    __publicField$5(this, "productData");
+    this.productData = productData;
+    this.savePhysicalProductButton = page.getByRole("button", { name: "Save" });
+    this.saveButtonCheckMark = page.locator(".icon--regular-checkmark-xs");
+    this.saveButtonLoadingSpinner = page.locator("sw-loader");
+    this.uploadMediaButton = page.getByRole("button", { name: "Upload file" });
+    this.coverImage = page.locator(".sw-product-media-form__cover-image");
+    this.productImage = page.locator(".sw-media-preview-v2__item");
+    this.variantsTabLink = page.getByRole("link", { name: "Variants" });
+    this.generateVariantsButton = page.getByRole("button", { name: "Generate variants" });
+    this.variantsModal = page.getByRole("dialog", { name: "Generate variants" });
+    this.variantsModalHeadline = this.variantsModal.getByRole("heading", { name: "Generate variants" });
+    this.variantsNextButton = this.variantsModal.getByRole("button", { name: "Next" });
+    this.variantsSaveButton = this.variantsModal.getByRole("button", { name: "Save variants" });
+    this.propertyGroupColor = this.variantsModal.getByText("Color").first();
+    this.propertyGroupSize = this.variantsModal.getByText("Size").first();
+    this.propertyOptionGrid = this.variantsModal.locator(".sw-property-search__tree-selection__option_grid");
+    this.propertyOptionColorBlue = this.propertyOptionGrid.getByLabel("Blue");
+    this.propertyOptionColorRed = this.propertyOptionGrid.getByLabel("Red");
+    this.propertyOptionColorGreen = this.propertyOptionGrid.getByLabel("Green");
+    this.propertyOptionSizeSmall = this.propertyOptionGrid.getByLabel("Small");
+    this.propertyOptionSizeMedium = this.propertyOptionGrid.getByLabel("Medium");
+    this.propertyOptionSizeLarge = this.propertyOptionGrid.getByLabel("Large");
+  }
+  async goTo() {
+    await this.page.goto(`#/sw/product/detail/${this.productData.id}/base`);
+  }
+  getProductId() {
+    return this.productData.id;
+  }
+}
+
+var __defProp$4 = Object.defineProperty;
+var __defNormalProp$4 = (obj, key, value) => key in obj ? __defProp$4(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField$4 = (obj, key, value) => {
+  __defNormalProp$4(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+class OrderDetail {
+  constructor(page, orderData) {
+    this.page = page;
+    __publicField$4(this, "dataGridContextButton");
+    __publicField$4(this, "orderTag");
+    __publicField$4(this, "orderData");
+    this.orderData = orderData;
+    this.dataGridContextButton = page.locator(".sw-data-grid__actions-menu").and(page.getByRole("button"));
+    this.orderTag = page.locator(".sw-select-selection-list__item");
+  }
+  async goTo() {
+    await this.page.goto(`#/sw/order/detail/${this.orderData.id}/general`);
+  }
+}
+
+var __defProp$3 = Object.defineProperty;
+var __defNormalProp$3 = (obj, key, value) => key in obj ? __defProp$3(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField$3 = (obj, key, value) => {
+  __defNormalProp$3(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+class CustomerDetail {
+  constructor(page, customer) {
+    this.page = page;
+    __publicField$3(this, "customerId");
+    __publicField$3(this, "editButton");
+    __publicField$3(this, "generalTab");
+    __publicField$3(this, "accountCard");
+    this.customerId = customer.id;
+    this.editButton = page.getByRole("button", { name: "Edit" });
+    this.generalTab = page.getByRole("link", { name: "General" });
+    this.accountCard = page.locator(".sw-customer-card");
+  }
+  async goTo() {
+    await this.page.goto(`#/sw/customer/detail/${this.customerId}/base`);
+  }
+}
+
+var __defProp$2 = Object.defineProperty;
+var __defNormalProp$2 = (obj, key, value) => key in obj ? __defProp$2(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField$2 = (obj, key, value) => {
+  __defNormalProp$2(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+class FirstRunWizard {
+  constructor(page) {
+    this.page = page;
+    __publicField$2(this, "nextButton");
+    __publicField$2(this, "configureLaterButton");
+    __publicField$2(this, "skipButton");
+    __publicField$2(this, "finishButton");
+    __publicField$2(this, "backButton");
+    __publicField$2(this, "smtpServerButton");
+    __publicField$2(this, "dataImportHeader");
+    __publicField$2(this, "installLanguagePackButton");
+    __publicField$2(this, "installDemoDataButton");
+    __publicField$2(this, "installMigrationAssistantButton");
+    __publicField$2(this, "defaultValuesHeader");
+    __publicField$2(this, "mailerConfigurationHeader");
+    __publicField$2(this, "payPalSetupHeader");
+    __publicField$2(this, "extensionsHeader");
+    __publicField$2(this, "shopwareAccountHeader");
+    __publicField$2(this, "shopwareStoreHeader");
+    __publicField$2(this, "doneHeader");
+    __publicField$2(this, "frwSuccessText");
+    __publicField$2(this, "welcomeText");
+    __publicField$2(this, "pluginCardInfo");
+    __publicField$2(this, "dataImportCard");
+    __publicField$2(this, "salesChannelSelectionList");
+    __publicField$2(this, "salesChannelSelectionMultiSelect");
+    __publicField$2(this, "smtpServerTitle");
+    __publicField$2(this, "smtpServerFields");
+    __publicField$2(this, "payPalPaymethods");
+    __publicField$2(this, "payPalInfoCard");
+    __publicField$2(this, "emailAddressInputField");
+    __publicField$2(this, "passwordInputField");
+    __publicField$2(this, "forgotPasswordLink");
+    __publicField$2(this, "extensionStoreHeading");
+    __publicField$2(this, "documentationLink");
+    __publicField$2(this, "forumLink");
+    __publicField$2(this, "roadmapLink");
+    __publicField$2(this, "germanRegionSelector");
+    __publicField$2(this, "toolsSelector");
+    __publicField$2(this, "recommendationHeader");
+    __publicField$2(this, "toolsRecommendedPlugin");
+    this.nextButton = page.getByText("Next", { exact: true });
+    this.configureLaterButton = page.getByText("Configure later", { exact: true });
+    this.skipButton = page.getByText("Skip", { exact: true });
+    this.finishButton = page.getByText("Finish", { exact: true });
+    this.backButton = page.getByText("Back", { exact: true });
+    this.installLanguagePackButton = page.getByRole("button", { name: "Install" });
+    this.welcomeText = page.locator(".headline-welcome", { hasText: "Welcome to the Shopware 6 Administration" });
+    this.pluginCardInfo = page.locator(".sw-plugin-card__info");
+    this.installMigrationAssistantButton = page.getByRole("button", { name: "Install Migration Assistant" });
+    this.installDemoDataButton = page.getByRole("button", { name: "Install demo data" });
+    this.dataImportHeader = page.locator(".sw-modal__title", { hasText: "Getting started with Shopware 6" });
+    this.dataImportCard = page.locator(".sw-first-run-wizard-data-import__card");
+    this.defaultValuesHeader = page.locator(".sw-modal__title", { hasText: "Setup default values" });
+    this.salesChannelSelectionMultiSelect = page.getByPlaceholder("Select Sales Channels...");
+    this.salesChannelSelectionList = page.locator(".sw-popover__wrapper").getByRole("listitem");
+    this.mailerConfigurationHeader = page.locator(".sw-modal__title", { hasText: "Mailer configuration" });
+    this.smtpServerButton = page.getByText("Configure own SMTP server", { exact: true });
+    this.smtpServerTitle = page.getByText("SMTP server", { exact: true });
+    this.smtpServerFields = page.locator(".sw-field");
+    this.payPalSetupHeader = page.locator(".sw-modal__title", { hasText: "Setup PayPal" });
+    this.payPalPaymethods = page.locator(".paymethod");
+    this.payPalInfoCard = page.locator(".sw-first-run-wizard-paypal-info");
+    this.extensionsHeader = page.locator(".sw-modal__title", { hasText: "Extensions" });
+    this.germanRegionSelector = page.getByText("Germany / Austria / Switzerland");
+    this.toolsSelector = page.getByText("Tools");
+    this.recommendationHeader = page.getByText("Global recommendations", { exact: true });
+    this.toolsRecommendedPlugin = page.locator(".sw-plugin-card__info").locator(".sw-plugin-card__label");
+    this.shopwareAccountHeader = page.locator(".sw-modal__title", { hasText: "Shopware Account" });
+    this.emailAddressInputField = page.getByPlaceholder("Enter your email address...", { exact: true });
+    this.passwordInputField = page.getByPlaceholder("Enter your password...", { exact: true });
+    this.forgotPasswordLink = page.getByText("Did you forget your password?", { exact: true });
+    this.shopwareStoreHeader = page.locator(".sw-modal__title", { hasText: "Shopware Store" });
+    this.doneHeader = page.locator(".sw-modal__title", { hasText: "Done" });
+    this.extensionStoreHeading = page.locator(".sw-first-run-wizard-store__heading");
+    this.frwSuccessText = page.getByText("All done!", { exact: true });
+    this.documentationLink = page.locator('[href*="https://docs.shopware.com/en"]');
+    this.forumLink = page.locator('[href*="https://forum.shopware.com/"]');
+    this.roadmapLink = page.locator('[href*="https://www.shopware.com/en/roadmap/"]');
+  }
+  async goTo() {
+    await this.page.goto(`#/sw/first/run/wizard/index/`);
+  }
+}
+
+var __defProp$1 = Object.defineProperty;
+var __defNormalProp$1 = (obj, key, value) => key in obj ? __defProp$1(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField$1 = (obj, key, value) => {
+  __defNormalProp$1(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+class FlowBuilderCreate {
+  constructor(page) {
+    this.page = page;
+    __publicField$1(this, "saveButton");
+    __publicField$1(this, "header");
+    this.saveButton = page.locator(".sw-flow-detail__save");
+    this.header = page.locator("h2");
+  }
+  async goTo() {
+    await this.page.goto(`#/sw/flow/create/general`);
+  }
+}
+
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+class FlowBuilderListing {
+  constructor(page) {
+    this.page = page;
+    __publicField(this, "firstFlowName");
+    __publicField(this, "firstFlowContextButton");
+    __publicField(this, "flowContextMenu");
+    __publicField(this, "contextMenuDownload");
+    __publicField(this, "flowDownloadModal");
+    __publicField(this, "downloadFlowButton");
+    __publicField(this, "successAlert");
+    __publicField(this, "successAlertMessage");
+    this.firstFlowName = page.locator(".sw-data-grid__cell--name a").first();
+    this.firstFlowContextButton = page.locator(".sw-data-grid__actions-menu").first();
+    this.flowContextMenu = page.locator(".sw-context-menu__content");
+    this.contextMenuDownload = page.locator(".sw-flow-list__item-download");
+    this.flowDownloadModal = page.locator(" .sw-flow-download-modal");
+    this.downloadFlowButton = page.getByRole("button", { name: "Download flow" });
+    this.successAlert = page.locator(".sw-alert__body");
+    this.successAlertMessage = page.locator(".sw-alert__message");
+  }
+  async goTo() {
+    await this.page.goto(`#/sw/flow/index/`);
+  }
+}
+
+const AdminPageObjects = {
+  ProductDetail,
+  OrderDetail,
+  CustomerDetail,
+  FirstRunWizard,
+  FlowBuilderCreate,
+  FlowBuilderListing
+};
+const test$4 = test$c.extend({
+  AdminProductDetail: async ({ AdminPage, ProductData }, use) => {
+    await use(new ProductDetail(AdminPage, ProductData));
+  },
+  AdminOrderDetail: async ({ AdminPage, OrderData }, use) => {
+    await use(new OrderDetail(AdminPage, OrderData));
+  },
+  AdminCustomerDetail: async ({ AdminPage, DefaultSalesChannel }, use) => {
+    await use(new CustomerDetail(AdminPage, DefaultSalesChannel.customer));
+  },
+  AdminFirstRunWizard: async ({ AdminPage }, use) => {
+    await use(new FirstRunWizard(AdminPage));
+  },
+  AdminFlowBuilderCreate: async ({ AdminPage }, use) => {
+    await use(new FlowBuilderCreate(AdminPage));
+  },
+  AdminFlowBuilderListing: async ({ AdminPage }, use) => {
+    await use(new FlowBuilderListing(AdminPage));
+  }
+});
+
+const ProductData = test$c.extend({
+  ProductData: async ({ IdProvider, SalesChannelBaseConfig, AdminApiContext, DefaultSalesChannel }, use) => {
+    const { id: productId, uuid: productUuid } = IdProvider.getIdPair();
+    const productName = `Product_test_${productId}`;
+    const productResponse = await AdminApiContext.post("./product?_response", {
+      data: {
+        active: true,
+        stock: 10,
+        taxId: SalesChannelBaseConfig.taxId,
+        id: productUuid,
+        name: productName,
+        productNumber: "Product-" + productId,
+        price: [
+          {
+            currencyId: SalesChannelBaseConfig.eurCurrencyId,
+            gross: 10,
+            linked: false,
+            net: 8.4
+          }
+        ],
+        purchasePrices: [
+          {
+            currencyId: SalesChannelBaseConfig.eurCurrencyId,
+            gross: 8,
+            linked: false,
+            net: 6.7
+          }
+        ]
+      }
+    });
+    expect(productResponse.ok()).toBeTruthy();
+    const { data: product } = await productResponse.json();
+    const syncResp = await AdminApiContext.post("./_action/sync", {
+      data: {
+        "add product to sales channel": {
+          entity: "product_visibility",
+          action: "upsert",
+          payload: [
+            {
+              productId: product.id,
+              salesChannelId: DefaultSalesChannel.salesChannel.id,
+              visibility: 30
+            }
+          ]
+        },
+        "add product to root navigation": {
+          entity: "product_category",
+          action: "upsert",
+          payload: [
+            {
+              productId: product.id,
+              categoryId: DefaultSalesChannel.salesChannel.navigationCategoryId
+            }
+          ]
+        }
+      }
+    });
+    expect(syncResp.ok()).toBeTruthy();
+    await use(product);
+    const cleanupResponse = await AdminApiContext.delete(`./product/${productUuid}`);
+    expect(cleanupResponse.ok()).toBeTruthy();
+  }
+});
+
+const DigitalProductData = test$c.extend({
+  DigitalProductData: async ({ IdProvider, AdminApiContext, ProductData }, use) => {
+    const newMediaResource = await AdminApiContext.post("./media?_response", {
+      data: {
+        private: false
+      }
+    });
+    expect(newMediaResource.ok()).toBeTruthy();
+    const { data: newMediaValue } = await newMediaResource.json();
+    const newMediaId = newMediaValue.id;
+    const filename = "testfile_" + IdProvider.getUniqueName();
+    const fileContent = "This is a test file to test digital product download";
+    const newMediaUpload = await AdminApiContext.post(`./_action/media/${newMediaId}/upload?extension=txt&fileName=${filename}&_response`, {
+      headers: {
+        "content-type": "application/octet-stream"
+      },
+      data: fileContent
+    });
+    expect(newMediaUpload.ok()).toBeTruthy();
+    const productDownloadResponse = await AdminApiContext.post(`./product-download?_response`, {
+      data: {
+        productId: ProductData.id,
+        mediaId: newMediaId
+      }
+    });
+    expect(productDownloadResponse.ok()).toBeTruthy();
+    const { data: productDownload } = await productDownloadResponse.json();
+    const returnData = {
+      product: ProductData,
+      fileContent
+    };
+    await use(returnData);
+    const orderSearchResponse = await AdminApiContext.post("./search/order", {
+      data: {
+        limit: 10,
+        filter: [
+          {
+            type: "equals",
+            field: "lineItems.productId",
+            value: ProductData.id
+          }
+        ]
+      }
+    });
+    expect(orderSearchResponse.ok()).toBeTruthy();
+    const { data: ordersWithDigitalProduct } = await orderSearchResponse.json();
+    for (const order of ordersWithDigitalProduct) {
+      const deleteOrderResponse = await AdminApiContext.delete(`./order/${order.id}`);
+      expect(deleteOrderResponse.ok()).toBeTruthy();
+    }
+    const unlinkMediaResponse = await AdminApiContext.delete(`./product-download/${productDownload.id}`);
+    expect(unlinkMediaResponse.ok()).toBeTruthy();
+    const cleanupMediaResponse = await AdminApiContext.delete(`./media/${newMediaId}`);
+    expect(cleanupMediaResponse.ok()).toBeTruthy();
+  }
+});
+
+const PropertiesData = test$c.extend({
+  PropertiesData: async ({ AdminApiContext }, use) => {
+    const propertyGroupColorResponse = await AdminApiContext.post("property-group?_response=1", {
+      data: {
+        name: "Color",
+        description: "Color",
+        displayType: "color",
+        sortingType: "name",
+        options: [{
+          name: "Blue",
+          colorHexCode: "#2148d6"
+        }, {
+          name: "Red",
+          colorHexCode: "#bf0f2a"
+        }, {
+          name: "Green",
+          colorHexCode: "#12bf0f"
+        }]
+      }
+    });
+    const propertyGroupSizeResponse = await AdminApiContext.post("property-group?_response=1", {
+      data: {
+        name: "Size",
+        description: "Size",
+        displayType: "text",
+        sortingType: "name",
+        options: [{
+          name: "Small"
+        }, {
+          name: "Medium"
+        }, {
+          name: "Large"
+        }]
+      }
+    });
+    expect(propertyGroupColorResponse.ok()).toBeTruthy();
+    expect(propertyGroupSizeResponse.ok()).toBeTruthy();
+    const { data: propertyGroupColor } = await propertyGroupColorResponse.json();
+    const { data: propertyGroupSize } = await propertyGroupSizeResponse.json();
+    await use({
+      propertyGroupColor,
+      propertyGroupSize
+    });
+    const deleteGroupColor = await AdminApiContext.delete(`property-group/${propertyGroupColor.id}`);
+    const deleteGroupSize = await AdminApiContext.delete(`property-group/${propertyGroupSize.id}`);
+    expect(deleteGroupColor.ok()).toBeTruthy();
+    expect(deleteGroupSize.ok()).toBeTruthy();
+  }
+});
+
+const CartWithProductData = test$c.extend({
+  CartWithProductData: async ({ StoreApiContext, DefaultSalesChannel, ProductData }, use) => {
+    await StoreApiContext.login(DefaultSalesChannel.customer);
+    const cartResponse = await StoreApiContext.post("checkout/cart", {
+      data: {
+        name: "default-customer-cart"
+      }
+    });
+    expect(cartResponse.ok()).toBeTruthy();
+    const lineItemResponse = await StoreApiContext.post("checkout/cart/line-item", {
+      data: {
+        items: [
+          {
+            type: "product",
+            referencedId: ProductData.id,
+            quantity: 10
+          }
+        ]
+      }
+    });
+    expect(lineItemResponse.ok()).toBeTruthy();
+    const cartData = await lineItemResponse.json();
+    await use(cartData);
+  }
+});
+
+const PromotionWithCodeData = test$c.extend({
+  PromotionWithCodeData: async ({ AdminApiContext, DefaultSalesChannel, IdProvider }, use) => {
+    const promotionCode = `${IdProvider.getIdPair().id}`;
+    const promotionName = `Test Promotion ${promotionCode}`;
+    const promotionResponse = await AdminApiContext.post("promotion?_response=1", {
+      data: {
+        name: promotionName,
+        active: true,
+        maxRedemptionsGlobal: 100,
+        maxRedemptionsPerCustomer: 10,
+        priority: 1,
+        exclusive: false,
+        useCodes: true,
+        useIndividualCodes: false,
+        useSetGroups: false,
+        preventCombination: true,
+        customerRestriction: false,
+        code: promotionCode,
+        discounts: [
+          {
+            scope: "cart",
+            type: "percentage",
+            value: 10,
+            considerAdvancedRules: false
+          }
+        ],
+        salesChannels: [
+          {
+            salesChannelId: DefaultSalesChannel.salesChannel.id,
+            priority: 1
+          }
+        ]
+      }
+    });
+    expect(promotionResponse.ok()).toBeTruthy();
+    const { data: promotion } = await promotionResponse.json();
+    await use(promotion);
+    const cleanupResponse = await AdminApiContext.delete(`promotion/${promotion.id}`);
+    expect(cleanupResponse.ok()).toBeTruthy();
+  }
+});
+
+function createRandomImage(width = 800, height = 600) {
+  const buffer = Buffer.alloc(width * height * 4);
+  let i = 0;
+  while (i < buffer.length) {
+    buffer[i++] = Math.floor(Math.random() * 256);
+  }
+  return new Image(width, height, buffer);
+}
+
+const MediaData = test$c.extend({
+  MediaData: async ({ AdminApiContext, IdProvider }, use) => {
+    const imageId = IdProvider.getIdPair().id;
+    const imageFilePath = `./tmp/image-${imageId}.png`;
+    const image = createRandomImage();
+    if (!fs.existsSync("./tmp/")) {
+      try {
+        fs.mkdirSync("./tmp/");
+      } catch (err) {
+        console.error(err);
+      }
+    }
+    fs.writeFileSync(imageFilePath, image.toBuffer());
+    const mediaResponse = await AdminApiContext.post("media?_response", {
+      data: {
+        private: false
+      }
+    });
+    expect(mediaResponse.ok()).toBeTruthy();
+    const { data: media } = await mediaResponse.json();
+    const mediaCreationResponse = await AdminApiContext.post(`_action/media/${media.id}/upload?extension=png&fileName=${media.id}`, {
+      data: fs.readFileSync(imageFilePath),
+      headers: {
+        "content-type": "image/png"
+      }
+    });
+    expect(mediaCreationResponse.ok()).toBeTruthy();
+    const altTag = media.alt = `alt-${media.id}`;
+    const titleTag = media.title = `title-${media.id}`;
+    const editMediaResponse = await AdminApiContext.patch(`media/${media.id}`, {
+      data: {
+        alt: altTag,
+        title: titleTag
+      }
+    });
+    expect(editMediaResponse.ok()).toBeTruthy();
+    await use(media);
+    fs.unlink(imageFilePath, (err) => {
+      if (err) {
+        throw err;
+      }
+    });
+    const cleanupResponse = await AdminApiContext.delete(`media/${media.id}`);
+    expect(cleanupResponse.ok()).toBeTruthy();
+  }
+});
+
+const OrderData = test$c.extend({
+  OrderData: async ({ IdProvider, AdminApiContext, SalesChannelBaseConfig, DefaultSalesChannel, ProductData }, use) => {
+    const requests = {
+      currencyEUR: getCurrency("EUR", AdminApiContext),
+      mrSalutationId: getSalutationId("mr", AdminApiContext),
+      orderStateId: getStateMachineId("order.state", AdminApiContext),
+      orderTransactionStateId: getStateMachineId("order_transaction.state", AdminApiContext),
+      orderDeliveryStateId: getStateMachineId("order_delivery.state", AdminApiContext)
+    };
+    await Promise.all(Object.values(requests));
+    const { id: orderId } = IdProvider.getIdPair();
+    const addressId = IdProvider.getIdPair().uuid;
+    const mrSalutationId = await requests.mrSalutationId;
+    const orderStateId = await requests.orderStateId;
+    const currencyEUR = await requests.currencyEUR;
+    const orderTransactionStateId = await requests.orderTransactionStateId;
+    const orderDeliveryStateId = await requests.orderDeliveryStateId;
+    const orderStateStateMachineStateId = await getStateMachineStateId(orderStateId, AdminApiContext);
+    const orderTransactionStateIdMachineStateId = await getStateMachineStateId(orderTransactionStateId, AdminApiContext);
+    const orderDeliveryStateIdMachineStateId = await getStateMachineStateId(orderDeliveryStateId, AdminApiContext);
+    const orderResponse = await AdminApiContext.post("./order?_response=detail", {
+      data: {
+        billingAddressId: addressId,
+        currencyId: SalesChannelBaseConfig.eurCurrencyId,
+        languageId: SalesChannelBaseConfig.enGBLanguageId,
+        salesChannelId: DefaultSalesChannel.salesChannel.id,
+        stateId: orderStateStateMachineStateId,
+        orderDateTime: "2024-02-01 07:00:00",
+        orderNumber: orderId,
+        currencyFactor: currencyEUR.factor,
+        itemRounding: {
+          decimals: 2,
+          interval: 0.01,
+          roundForNet: true
+        },
+        totalRounding: {
+          decimals: 2,
+          interval: 0.01,
+          roundForNet: true
+        },
+        orderCustomer: {
+          customerId: `${DefaultSalesChannel.customer.id}`,
+          email: `${DefaultSalesChannel.customer.email}`,
+          firstName: `${DefaultSalesChannel.customer.firstName}`,
+          lastName: `${DefaultSalesChannel.customer.lastName}`,
+          salutationId: `${DefaultSalesChannel.customer.salutationId}`
+        },
+        addresses: [
+          {
+            id: addressId,
+            salutationId: `${DefaultSalesChannel.customer.salutationId}`,
+            firstName: `${DefaultSalesChannel.customer.firstName}`,
+            lastName: `${DefaultSalesChannel.customer.lastName}`,
+            street: `${orderId} street`,
+            zipcode: `${orderId} zipcode`,
+            city: `${orderId} city`,
+            countryId: SalesChannelBaseConfig.deCountryId,
+            company: `${orderId} company`,
+            vatId: null,
+            phoneNumber: `${orderId}`
+          }
+        ],
+        price: {
+          totalPrice: 13.98,
+          positionPrice: 13.98,
+          rawTotal: 13.98,
+          netPrice: 13.98,
+          taxStatus: "gross",
+          calculatedTaxes: [
+            {
+              tax: 0,
+              taxRate: 0,
+              price: 13.98
+            }
+          ],
+          taxRules: [
+            {
+              taxRate: 0,
+              percentage: 100
+            }
+          ]
+        },
+        shippingCosts: {
+          unitPrice: 2.99,
+          totalPrice: 2.99,
+          quantity: 1,
+          calculatedTaxes: [
+            {
+              tax: 0,
+              taxRate: 0,
+              price: 2.99
+            }
+          ],
+          taxRules: [
+            {
+              taxRate: 0,
+              percentage: 100
+            }
+          ]
+        },
+        lineItems: [
+          {
+            productId: ProductData.id,
+            referencedId: ProductData.id,
+            payload: {
+              productNumber: ProductData.productNumber
+            },
+            identifier: ProductData.id,
+            type: "product",
+            label: "Shopware Blue T-shirt",
+            quantity: 1,
+            position: 1,
+            price: {
+              unitPrice: 10.99,
+              totalPrice: 10.99,
+              quantity: 1,
+              calculatedTaxes: [
+                {
+                  tax: 0,
+                  taxRate: 0,
+                  price: 10.99
+                }
+              ],
+              taxRules: [
+                {
+                  taxRate: 0,
+                  percentage: 100
+                }
+              ]
+            },
+            priceDefinition: {
+              type: "quantity",
+              price: 10.99,
+              quantity: 1,
+              taxRules: [
+                {
+                  taxRate: 0,
+                  percentage: 100
+                }
+              ],
+              listPrice: 8,
+              isCalculated: true,
+              referencePriceDefinition: null
+            }
+          }
+        ],
+        deliveries: [
+          {
+            stateId: orderDeliveryStateIdMachineStateId,
+            shippingMethodId: SalesChannelBaseConfig.defaultShippingMethod,
+            shippingOrderAddress: {
+              id: IdProvider.getIdPair().uuid,
+              salutationId: mrSalutationId,
+              firstName: "John",
+              lastName: "Doe",
+              street: "Shortstreet 5",
+              zipcode: "12345",
+              city: "Doe City",
+              countryId: SalesChannelBaseConfig.deCountryId,
+              phoneNumber: "123 456 789"
+            },
+            shippingDateEarliest: "2024-03-01 07:00:00",
+            shippingDateLatest: "2024-03-03 07:00:00",
+            shippingCosts: {
+              unitPrice: 8.99,
+              totalPrice: 8.99,
+              quantity: 1,
+              calculatedTaxes: [
+                {
+                  tax: 0,
+                  taxRate: 0,
+                  price: 8.99
+                }
+              ],
+              taxRules: [
+                {
+                  taxRate: 0,
+                  percentage: 100
+                }
+              ]
+            }
+          }
+        ],
+        transactions: [
+          {
+            paymentMethodId: SalesChannelBaseConfig.invoicePaymentMethodId,
+            amount: {
+              unitPrice: 13.98,
+              totalPrice: 13.98,
+              quantity: 1,
+              calculatedTaxes: [
+                {
+                  tax: 0,
+                  taxRate: 0,
+                  price: 0
+                }
+              ],
+              taxRules: [
+                {
+                  taxRate: 0,
+                  percentage: 100
+                }
+              ]
+            },
+            stateId: orderTransactionStateIdMachineStateId
+          }
+        ]
+      }
+    });
+    expect(orderResponse.ok()).toBeTruthy();
+    const { data: order } = await orderResponse.json();
+    await use(order);
+    const cleanupResponse = await AdminApiContext.delete(`./order/${order.id}`);
+    expect(cleanupResponse.ok()).toBeTruthy();
+  }
+});
+
+const TagData = test$c.extend({
+  TagData: async ({ IdProvider, AdminApiContext }, use) => {
+    const tagUUID = IdProvider.getIdPair().uuid;
+    const tagId = IdProvider.getIdPair().id;
+    const tagName = `Test-${tagId}`;
+    const tagResponse = await AdminApiContext.post("./tag?_response=detail", {
+      data: {
+        id: tagUUID,
+        name: tagName
+      }
+    });
+    expect(tagResponse.ok()).toBeTruthy();
+    const { data: tag } = await tagResponse.json();
+    await use(tag);
+    const cleanupResponse = await AdminApiContext.delete(`./tag/${tag.id}`);
+    expect(cleanupResponse.ok()).toBeTruthy();
+  }
+});
+
+const test$3 = mergeTests(
+  ProductData,
+  DigitalProductData,
+  CartWithProductData,
+  PromotionWithCodeData,
+  PropertiesData,
+  MediaData,
+  OrderData,
+  TagData
+);
+
+const SaveProduct = test$c.extend({
+  SaveProduct: async ({ ShopAdmin, AdminProductDetail }, use) => {
+    const task = () => {
+      return async function SaveProduct2() {
+        await AdminProductDetail.savePhysicalProductButton.click();
+        const response = await AdminProductDetail.page.waitForResponse(`${process.env["APP_URL"]}api/_action/sync`);
+        expect(response.ok()).toBeTruthy();
+        await ShopAdmin.expects(AdminProductDetail.savePhysicalProductButton).toBeVisible();
+        await ShopAdmin.expects(AdminProductDetail.savePhysicalProductButton).toContainText("Save");
+        await ShopAdmin.expects(AdminProductDetail.saveButtonCheckMark).toBeHidden();
+        await ShopAdmin.expects(AdminProductDetail.saveButtonLoadingSpinner).toBeHidden();
+        await ShopAdmin.expects(AdminProductDetail.page.getByText("The following error occurred:")).toBeHidden();
+      };
+    };
+    await use(task);
+  }
+});
+
+const test$2 = mergeTests(
+  SaveProduct
+);
+
+const Login = test$c.extend({
+  Login: async ({ ShopCustomer, DefaultSalesChannel, StorefrontAccountLogin, StorefrontAccount }, use) => {
+    const task = () => {
+      return async function Login2() {
+        const { customer } = DefaultSalesChannel;
+        await ShopCustomer.goesTo(StorefrontAccountLogin);
+        await StorefrontAccountLogin.emailInput.fill(customer.email);
+        await StorefrontAccountLogin.passwordInput.fill(customer.password);
+        await StorefrontAccountLogin.loginButton.click();
+        await ShopCustomer.expects(StorefrontAccount.personalDataCardTitle).toBeVisible();
+      };
+    };
+    await use(task);
+  }
+});
+
+const Logout = test$c.extend({
+  Logout: async ({ ShopCustomer, StorefrontAccountLogin }, use) => {
+    const task = () => {
+      return async function Logout2() {
+        await ShopCustomer.goesTo(StorefrontAccountLogin);
+        await ShopCustomer.expects(StorefrontAccountLogin.loginButton).not.toBeVisible();
+        await StorefrontAccountLogin.logoutLink.click();
+        await ShopCustomer.expects(StorefrontAccountLogin.successAlert).toBeVisible();
+      };
+    };
+    await use(task);
+  }
+});
+
+const Register = test$c.extend({
+  Register: async ({ StorefrontAccountLogin, AdminApiContext }, use) => {
+    const registrationData = {
+      firstName: "Jeff",
+      lastName: "Goldblum",
+      email: "invalid",
+      password: "shopware",
+      street: "Ebbinghof 10",
+      city: "Sch\xF6ppingen",
+      country: "Germany"
+    };
+    const task = (email) => {
+      return async function Register2() {
+        registrationData.email = email;
+        await StorefrontAccountLogin.firstNameInput.fill(registrationData.firstName);
+        await StorefrontAccountLogin.lastNameInput.fill(registrationData.lastName);
+        await StorefrontAccountLogin.registerEmailInput.fill(registrationData.email);
+        await StorefrontAccountLogin.registerPasswordInput.fill(registrationData.password);
+        await StorefrontAccountLogin.streetAddressInput.fill(registrationData.street);
+        await StorefrontAccountLogin.cityInput.fill(registrationData.city);
+        await StorefrontAccountLogin.countryInput.selectOption(registrationData.country);
+        await StorefrontAccountLogin.registerButton.click();
+      };
+    };
+    await use(task);
+    const customerResponse = await AdminApiContext.post("search/customer", {
+      data: {
+        limit: 1,
+        filter: [{
+          type: "equals",
+          field: "email",
+          value: registrationData.email
+        }]
+      }
+    });
+    expect(customerResponse.ok()).toBeTruthy();
+    const customerResponseData = await customerResponse.json();
+    for (const customer of customerResponseData.data) {
+      await AdminApiContext.delete(`customer/${customer.id}`);
+    }
+  }
+});
+
+const AddProductToCart = test$c.extend({
+  AddProductToCart: async ({ ShopCustomer, StorefrontProductDetail }, use) => {
+    const task = (ProductData, quantity = "1") => {
+      return async function AddProductToCart2() {
+        await StorefrontProductDetail.quantitySelect.fill(quantity);
+        await StorefrontProductDetail.addToCartButton.click();
+        await ShopCustomer.expects(StorefrontProductDetail.offCanvasCartTitle).toBeVisible();
+        await ShopCustomer.expects(StorefrontProductDetail.offCanvasCart.getByText(ProductData.name)).toBeVisible();
+      };
+    };
+    await use(task);
+  }
+});
+
+const ProceedFromProductToCheckout = test$c.extend({
+  ProceedFromProductToCheckout: async ({ ShopCustomer, StorefrontProductDetail, StorefrontCheckoutConfirm }, use) => {
+    const task = () => {
+      return async function ProceedFromProductToCheckout2() {
+        await StorefrontProductDetail.offCanvasCartGoToCheckoutButton.click();
+        await ShopCustomer.expects(StorefrontCheckoutConfirm.headline).toBeVisible();
+      };
+    };
+    await use(task);
+  }
+});
+
+const ProceedFromCartToCheckout = test$c.extend({
+  ProceedFromCartToCheckout: async ({
+    ShopCustomer,
+    StorefrontCheckoutCart,
+    StorefrontCheckoutConfirm
+  }, use) => {
+    const task = () => {
+      return async function ProceedFromCartToCheckout2() {
+        await StorefrontCheckoutCart.goToCheckoutButton.click();
+        await ShopCustomer.expects(StorefrontCheckoutConfirm.headline).toBeVisible();
+      };
+    };
+    await use(task);
+  }
+});
+
+const ConfirmTermsAndConditions = test$c.extend({
+  ConfirmTermsAndConditions: async ({ ShopCustomer, StorefrontCheckoutConfirm }, use) => {
+    const task = () => {
+      return async function ConfirmTermsAndConditions2() {
+        await StorefrontCheckoutConfirm.termsAndConditionsCheckbox.check();
+        await ShopCustomer.expects(StorefrontCheckoutConfirm.termsAndConditionsCheckbox).toBeChecked();
+      };
+    };
+    await use(task);
+  }
+});
+
+const SelectCashOnDeliveryPaymentOption = test$c.extend({
+  SelectCashOnDeliveryPaymentOption: async ({ ShopCustomer, StorefrontCheckoutConfirm }, use) => {
+    const task = () => {
+      return async function SelectCashOnDeliveryPaymentOption2() {
+        await StorefrontCheckoutConfirm.paymentCashOnDelivery.check();
+        await ShopCustomer.expects(StorefrontCheckoutConfirm.paymentCashOnDelivery).toBeChecked();
+      };
+    };
+    await use(task);
+  }
+});
+
+const SelectInvoicePaymentOption = test$c.extend({
+  SelectInvoicePaymentOption: async ({ ShopCustomer, StorefrontCheckoutConfirm }, use) => {
+    const task = () => {
+      return async function SelectInvoicePaymentOption2() {
+        await StorefrontCheckoutConfirm.paymentInvoice.check();
+        await ShopCustomer.expects(StorefrontCheckoutConfirm.paymentInvoice).toBeChecked();
+      };
+    };
+    await use(task);
+  }
+});
+
+const SelectPaidInAdvancePaymentOption = test$c.extend({
+  SelectPaidInAdvancePaymentOption: async ({ ShopCustomer, StorefrontCheckoutConfirm }, use) => {
+    const task = () => {
+      return async function SelectPaidInAdvancePaymentOption2() {
+        await StorefrontCheckoutConfirm.paymentPaidInAdvance.check();
+        await ShopCustomer.expects(StorefrontCheckoutConfirm.paymentPaidInAdvance).toBeChecked();
+      };
+    };
+    await use(task);
+  }
+});
+
+const SelectStandardShippingOption = test$c.extend({
+  SelectStandardShippingOption: async ({ ShopCustomer, StorefrontCheckoutConfirm }, use) => {
+    const task = () => {
+      return async function SelectStandardShippingOption2() {
+        await StorefrontCheckoutConfirm.shippingStandard.check();
+        await ShopCustomer.expects(StorefrontCheckoutConfirm.shippingStandard).toBeChecked();
+      };
+    };
+    await use(task);
+  }
+});
+
+const SelectExpressShippingOption = test$c.extend({
+  SelectExpressShippingOption: async ({ ShopCustomer, StorefrontCheckoutConfirm }, use) => {
+    const task = () => {
+      return async function SelectExpressShippingOption2() {
+        await StorefrontCheckoutConfirm.shippingExpress.check();
+        await ShopCustomer.expects(StorefrontCheckoutConfirm.shippingExpress).toBeChecked();
+      };
+    };
+    await use(task);
+  }
+});
+
+const SubmitOrder = test$c.extend({
+  SubmitOrder: async ({ ShopCustomer, StorefrontCheckoutConfirm, StorefrontCheckoutFinish }, use) => {
+    const task = () => {
+      return async function SubmitOrder2() {
+        await StorefrontCheckoutConfirm.submitOrderButton.click();
+        await ShopCustomer.expects(StorefrontCheckoutFinish.headline).toBeVisible();
+      };
+    };
+    await use(task);
+  }
+});
+
+const OpenSearchResultPage = test$c.extend({
+  OpenSearchResultPage: async ({ StorefrontSearch }, use) => {
+    const task = (searchTerm) => {
+      return async function OpenSearchResultPage2() {
+        const url = `search?search=${searchTerm}`;
+        await StorefrontSearch.page.goto(url);
+      };
+    };
+    await use(task);
+  }
+});
+
+const OpenSearchSuggestPage = test$c.extend({
+  OpenSearchSuggestPage: async ({ StorefrontSearchSuggest }, use) => {
+    const task = (searchTerm) => {
+      return async function OpenSearchSuggestPage2() {
+        const url = `suggest?search=${searchTerm}`;
+        await StorefrontSearchSuggest.page.goto(url);
+      };
+    };
+    await use(task);
+  }
+});
+
+const test$1 = mergeTests(
+  Login,
+  Logout,
+  Register,
+  AddProductToCart,
+  ProceedFromProductToCheckout,
+  ProceedFromCartToCheckout,
+  ConfirmTermsAndConditions,
+  SelectInvoicePaymentOption,
+  SelectCashOnDeliveryPaymentOption,
+  SelectPaidInAdvancePaymentOption,
+  SelectStandardShippingOption,
+  SelectExpressShippingOption,
+  SubmitOrder,
+  OpenSearchResultPage,
+  OpenSearchSuggestPage
+);
+
+const test = mergeTests(
+  test$6,
+  test$a,
+  test$9,
+  test$8,
+  test$7,
+  test$5,
+  test$4,
+  test$3,
+  test$2,
+  test$1
+);
+
+export { AdminPageObjects, StorefrontPageObjects, createRandomImage, extractIdFromUrl, getCountryId, getCurrency, getDefaultShippingMethodId, getFlowId, getLanguageData, getMediaId, getOrderTransactionId, getPaymentMethodId, getSalutationId, getSnippetSetId, getStateMachineId, getStateMachineStateId, getTaxId, getThemeId, test };