biome

Author: Lms24

packages/e2e-tests/test-applications/sveltekit/playwright.config.ts

@@ -1,15 +1,15 @@
-import type { PlaywrightTestConfig } from "@playwright/test";
-import { devices } from "@playwright/test";
+import type { PlaywrightTestConfig } from '@playwright/test';
+import { devices } from '@playwright/test';
 
 // Fix urls not resolving to localhost on Node v17+
 // See: https://github.com/axios/axios/issues/3821#issuecomment-1413727575
-import { setDefaultResultOrder } from "dns";
-setDefaultResultOrder("ipv4first");
+import { setDefaultResultOrder } from 'dns';
+setDefaultResultOrder('ipv4first');
 
 const testEnv = process.env.TEST_ENV;
 
 if (!testEnv) {
-  throw new Error("No test env defined");
+  throw new Error('No test env defined');
 }
 
 const svelteKitPort = 3030;
@@ -19,7 +19,7 @@ const eventProxyPort = 3031;
  * See https://playwright.dev/docs/test-configuration.
  */
 const config: PlaywrightTestConfig = {
-  testDir: "./test",
+  testDir: './test',
   /* Maximum time one test can run for. */
   timeout: 150_000,
   expect: {
@@ -34,9 +34,9 @@ const config: PlaywrightTestConfig = {
   /* Fail the build on CI if you accidentally left test.only in the source code. */
   forbidOnly: !!process.env.CI,
   /* `next dev` is incredibly buggy with the app dir */
-  retries: testEnv === "development" ? 3 : 0,
+  retries: testEnv === 'development' ? 3 : 0,
   /* Reporter to use. See https://playwright.dev/docs/test-reporters */
-  reporter: "list",
+  reporter: 'list',
   /* Shared settings for all the projects below. See https://playwright.dev/docs/api/class-testoptions. */
   use: {
     /* Maximum time each action such as `click()` can take. Defaults to 0 (no limit). */
@@ -45,29 +45,29 @@ const config: PlaywrightTestConfig = {
     baseURL: `http://localhost:${svelteKitPort}`,
 
     /* Collect trace when retrying the failed test. See https://playwright.dev/docs/trace-viewer */
-    trace: "on-first-retry",
+    trace: 'on-first-retry',
   },
 
   /* Configure projects for major browsers */
   projects: [
     {
-      name: "chromium",
+      name: 'chromium',
       use: {
-        ...devices["Desktop Chrome"],
+        ...devices['Desktop Chrome'],
       },
     },
   ],
 
   /* Run your local dev server before starting the tests */
   webServer: [
     {
-      command: "pnpm ts-node-script start-event-proxy.ts",
+      command: 'pnpm ts-node-script start-event-proxy.ts',
       port: eventProxyPort,
       reuseExistingServer: false,
     },
     {
       command:
-        testEnv === "development"
+        testEnv === 'development'
           ? `pnpm wait-port ${eventProxyPort} && pnpm dev --port ${svelteKitPort}`
           : `pnpm wait-port ${eventProxyPort} && pnpm preview --port ${svelteKitPort}`,
       port: svelteKitPort,

packages/e2e-tests/test-applications/sveltekit/src/hooks.client.ts

@@ -1,18 +1,18 @@
-import { env } from "$env/dynamic/public";
-import * as Sentry from "@sentry/sveltekit";
+import { env } from '$env/dynamic/public';
+import * as Sentry from '@sentry/sveltekit';
 
-console.log("Sentry DSN:", env.PUBLIC_E2E_TEST_DSN);
+console.log('Sentry DSN:', env.PUBLIC_E2E_TEST_DSN);
 
 Sentry.init({
-  environment: "qa", // dynamic sampling bias to keep transactions
+  environment: 'qa', // dynamic sampling bias to keep transactions
   dsn: env.PUBLIC_E2E_TEST_DSN,
   debug: true,
   tunnel: `http://localhost:3031/`, // proxy server
   tracesSampleRate: 1.0,
 });
 
 const myErrorHandler = ({ error, event }: any) => {
-  console.error("An error occurred on the client side:", error, event);
+  console.error('An error occurred on the client side:', error, event);
 };
 
 export const handleError = Sentry.handleErrorWithSentry(myErrorHandler);

packages/e2e-tests/test-applications/sveltekit/src/hooks.server.ts

@@ -1,8 +1,8 @@
-import { env } from "$env/dynamic/private";
-import * as Sentry from "@sentry/sveltekit";
+import { env } from '$env/dynamic/private';
+import * as Sentry from '@sentry/sveltekit';
 
 Sentry.init({
-  environment: "qa", // dynamic sampling bias to keep transactions
+  environment: 'qa', // dynamic sampling bias to keep transactions
   dsn: env.E2E_TEST_DSN,
   debug: true,
   tunnel: `http://localhost:3031/`, // proxy server

packages/e2e-tests/test-applications/sveltekit/src/routes/api/users/+server.ts

@@ -1,3 +1,3 @@
 export const GET = () => {
-  return new Response(JSON.stringify({ users: ["alice", "bob", "carol"] }));
+  return new Response(JSON.stringify({ users: ['alice', 'bob', 'carol'] }));
 };

packages/e2e-tests/test-applications/sveltekit/src/routes/server-load-error/+page.server.ts

@@ -1,6 +1,6 @@
 export const load = async () => {
-  throw new Error("Server Load Error");
+  throw new Error('Server Load Error');
   return {
-    msg: "Hello World",
+    msg: 'Hello World',
   };
 };

packages/e2e-tests/test-applications/sveltekit/src/routes/server-route-error/+page.ts

@@ -1,5 +1,5 @@
 export const load = async ({ fetch }) => {
-  const res = await fetch("/server-route-error");
+  const res = await fetch('/server-route-error');
   const data = await res.json();
   return {
     msg: data,

packages/e2e-tests/test-applications/sveltekit/src/routes/server-route-error/+server.ts

@@ -1,6 +1,6 @@
 export const GET = async () => {
-  throw new Error("Server Route Error");
+  throw new Error('Server Route Error');
   return {
-    msg: "Hello World",
+    msg: 'Hello World',
   };
 };

packages/e2e-tests/test-applications/sveltekit/src/routes/universal-load-error/+page.ts

@@ -1,8 +1,8 @@
-import { browser } from "$app/environment";
+import { browser } from '$app/environment';
 
 export const load = async () => {
-  throw new Error(`Universal Load Error (${browser ? "browser" : "server"})`);
+  throw new Error(`Universal Load Error (${browser ? 'browser' : 'server'})`);
   return {
-    msg: "Hello World",
+    msg: 'Hello World',
   };
 };

packages/e2e-tests/test-applications/sveltekit/src/routes/universal-load-fetch/+page.ts

@@ -1,5 +1,5 @@
 export const load = async ({ fetch }) => {
-  const usersRes = await fetch("/api/users");
+  const usersRes = await fetch('/api/users');
   const data = await usersRes.json();
   return { users: data.users };
 };

packages/e2e-tests/test-applications/sveltekit/src/routes/users/+page.server.ts

@@ -1,5 +1,5 @@
 export const load = async () => {
   return {
-    msg: "Hi everyone!",
+    msg: 'Hi everyone!',
   };
 };

packages/e2e-tests/test-applications/sveltekit/test/errors.client.test.ts

@@ -1,55 +1,47 @@
-import { expect, test } from "@playwright/test";
-import { waitForError } from "../event-proxy-server";
-import { waitForInitialPageload } from "./utils";
+import { expect, test } from '@playwright/test';
+import { waitForError } from '../event-proxy-server';
+import { waitForInitialPageload } from './utils';
 
-test.describe("capturing client side errors", () => {
-  test("should capture error thrown on click", async ({ page }) => {
-    await page.goto("/client-error");
+test.describe('capturing client side errors', () => {
+  test('should capture error thrown on click', async ({ page }) => {
+    await page.goto('/client-error');
 
-    await expect(page.getByText("Client error")).toBeVisible();
+    await expect(page.getByText('Client error')).toBeVisible();
 
-    const errorEventPromise = waitForError("sveltekit", (errorEvent) => {
-      return errorEvent?.exception?.values?.[0]?.value === "Click Error";
+    const errorEventPromise = waitForError('sveltekit', errorEvent => {
+      return errorEvent?.exception?.values?.[0]?.value === 'Click Error';
     });
 
-    const clickPromise = page.getByText("Throw error").click();
+    const clickPromise = page.getByText('Throw error').click();
 
-    const [errorEvent, _] = await Promise.all([
-      errorEventPromise,
-      clickPromise,
-    ]);
+    const [errorEvent, _] = await Promise.all([errorEventPromise, clickPromise]);
 
-    const errorEventFrames =
-      errorEvent.exception?.values?.[0]?.stacktrace?.frames;
+    const errorEventFrames = errorEvent.exception?.values?.[0]?.stacktrace?.frames;
 
     expect(errorEventFrames?.[errorEventFrames?.length - 1]).toEqual(
       expect.objectContaining({
-        function: expect.stringContaining("HTMLButtonElement"),
+        function: expect.stringContaining('HTMLButtonElement'),
         lineno: 1,
         in_app: true,
       }),
     );
 
-    expect(errorEvent.tags).toMatchObject({ runtime: "browser" });
+    expect(errorEvent.tags).toMatchObject({ runtime: 'browser' });
   });
 
-  test("should capture universal load error", async ({ page }) => {
+  test('should capture universal load error', async ({ page }) => {
     await waitForInitialPageload(page);
     await page.reload();
 
-    const errorEventPromise = waitForError("sveltekit", (errorEvent) => {
-      return (
-        errorEvent?.exception?.values?.[0]?.value ===
-        "Universal Load Error (browser)"
-      );
+    const errorEventPromise = waitForError('sveltekit', errorEvent => {
+      return errorEvent?.exception?.values?.[0]?.value === 'Universal Load Error (browser)';
     });
 
     // navigating triggers the error on the client
-    await page.getByText("Universal Load error").click();
+    await page.getByText('Universal Load error').click();
 
     const errorEvent = await errorEventPromise;
-    const errorEventFrames =
-      errorEvent.exception?.values?.[0]?.stacktrace?.frames;
+    const errorEventFrames = errorEvent.exception?.values?.[0]?.stacktrace?.frames;
 
     expect(errorEventFrames?.[errorEventFrames?.length - 1]).toEqual(
       expect.objectContaining({
@@ -58,6 +50,6 @@ test.describe("capturing client side errors", () => {
       }),
     );
 
-    expect(errorEvent.tags).toMatchObject({ runtime: "browser" });
+    expect(errorEvent.tags).toMatchObject({ runtime: 'browser' });
   });
 });

packages/e2e-tests/test-applications/sveltekit/test/errors.server.test.ts

@@ -1,77 +1,71 @@
-import { expect, test } from "@playwright/test";
-import { waitForError } from "../event-proxy-server";
+import { expect, test } from '@playwright/test';
+import { waitForError } from '../event-proxy-server';
 
-test.describe("capturing server side errors", () => {
-  test("should capture universal load error", async ({ page }) => {
-    const errorEventPromise = waitForError("sveltekit", (errorEvent) => {
-      return (
-        errorEvent?.exception?.values?.[0]?.value ===
-        "Universal Load Error (server)"
-      );
+test.describe('capturing server side errors', () => {
+  test('should capture universal load error', async ({ page }) => {
+    const errorEventPromise = waitForError('sveltekit', errorEvent => {
+      return errorEvent?.exception?.values?.[0]?.value === 'Universal Load Error (server)';
     });
 
-    await page.goto("/universal-load-error");
+    await page.goto('/universal-load-error');
 
     const errorEvent = await errorEventPromise;
-    const errorEventFrames =
-      errorEvent.exception?.values?.[0]?.stacktrace?.frames;
+    const errorEventFrames = errorEvent.exception?.values?.[0]?.stacktrace?.frames;
 
     expect(errorEventFrames?.[errorEventFrames?.length - 1]).toEqual(
       expect.objectContaining({
-        function: "load$1",
+        function: 'load$1',
         lineno: 3,
         in_app: true,
       }),
     );
 
-    expect(errorEvent.tags).toMatchObject({ runtime: "node" });
+    expect(errorEvent.tags).toMatchObject({ runtime: 'node' });
   });
 
-  test("should capture server load error", async ({ page }) => {
-    const errorEventPromise = waitForError("sveltekit", (errorEvent) => {
-      return errorEvent?.exception?.values?.[0]?.value === "Server Load Error";
+  test('should capture server load error', async ({ page }) => {
+    const errorEventPromise = waitForError('sveltekit', errorEvent => {
+      return errorEvent?.exception?.values?.[0]?.value === 'Server Load Error';
     });
 
-    await page.goto("/server-load-error");
+    await page.goto('/server-load-error');
 
     const errorEvent = await errorEventPromise;
-    const errorEventFrames =
-      errorEvent.exception?.values?.[0]?.stacktrace?.frames;
+    const errorEventFrames = errorEvent.exception?.values?.[0]?.stacktrace?.frames;
 
     expect(errorEventFrames?.[errorEventFrames?.length - 1]).toEqual(
       expect.objectContaining({
-        function: "load$1",
+        function: 'load$1',
         lineno: 3,
         in_app: true,
       }),
     );
 
-    expect(errorEvent.tags).toMatchObject({ runtime: "node" });
+    expect(errorEvent.tags).toMatchObject({ runtime: 'node' });
   });
 
-  test("should capture server route (GET) error", async ({ page }) => {
-    const errorEventPromise = waitForError("sveltekit", (errorEvent) => {
-      return errorEvent?.exception?.values?.[0]?.value === "Server Route Error";
+  test('should capture server route (GET) error', async ({ page }) => {
+    const errorEventPromise = waitForError('sveltekit', errorEvent => {
+      return errorEvent?.exception?.values?.[0]?.value === 'Server Route Error';
     });
 
-    await page.goto("/server-route-error");
+    await page.goto('/server-route-error');
 
     const errorEvent = await errorEventPromise;
-    const errorEventFrames =
-      errorEvent.exception?.values?.[0]?.stacktrace?.frames;
+    const errorEventFrames = errorEvent.exception?.values?.[0]?.stacktrace?.frames;
 
     expect(errorEventFrames?.[errorEventFrames?.length - 1]).toEqual(
       expect.objectContaining({
-        filename: "app:///_server.ts.js",
-        function: "GET",
+        filename: 'app:///_server.ts.js',
+        function: 'GET',
         lineno: 2,
         in_app: true,
       }),
     );
 
     expect(errorEvent.tags).toMatchObject({
-      runtime: "node",
-      transaction: "GET /server-route-error",
+      runtime: 'node',
+      transaction: 'GET /server-route-error',
     });
   });
 });