Add initial integration tests for @sentry/browser public API.

packages/integration-tests/suites/public-api/addBreadcrumb/empty_obj/subject.js

@@ -0,0 +1,3 @@
+Sentry.addBreadcrumb({});
+
+Sentry.captureMessage('test_empty_obj');

packages/integration-tests/suites/public-api/addBreadcrumb/empty_obj/test.ts

@@ -0,0 +1,20 @@
+import { expect } from '@playwright/test';
+
+import { sentryTest } from '../../../../utils/fixtures';
+import { getSentryRequest } from '../../../../utils/helpers';
+
+sentryTest(
+  'should add an empty breadcrumb initialized with a timestamp, when an empty object is given',
+  async ({ getLocalTestPath, page }) => {
+    const url = await getLocalTestPath({ testDir: __dirname });
+
+    const eventData = await getSentryRequest(page, url);
+
+    expect(eventData.breadcrumbs).toHaveLength(1);
+    expect(eventData.breadcrumbs?.[0]).toMatchObject({
+      timestamp: expect.any(Number),
+    });
+
+    expect(eventData.message).toBe('test_empty_obj');
+  },
+);

packages/integration-tests/suites/public-api/addBreadcrumb/multiple_breadcrumbs/subject.js

@@ -0,0 +1,11 @@
+Sentry.addBreadcrumb({
+  category: 'foo',
+  message: 'bar',
+  level: 'baz',
+});
+
+Sentry.addBreadcrumb({
+  category: 'qux',
+});
+
+Sentry.captureMessage('test_multi_breadcrumbs');

packages/integration-tests/suites/public-api/addBreadcrumb/multiple_breadcrumbs/test.ts

@@ -0,0 +1,21 @@
+import { expect } from '@playwright/test';
+
+import { sentryTest } from '../../../../utils/fixtures';
+import { getSentryRequest } from '../../../../utils/helpers';
+
+sentryTest('should add multiple breadcrumbs', async ({ getLocalTestPath, page }) => {
+  const url = await getLocalTestPath({ testDir: __dirname });
+
+  const eventData = await getSentryRequest(page, url);
+
+  expect(eventData.breadcrumbs).toHaveLength(2);
+  expect(eventData.breadcrumbs?.[0]).toMatchObject({
+    category: 'foo',
+    message: 'bar',
+    level: 'baz',
+  });
+  expect(eventData.breadcrumbs?.[1]).toMatchObject({
+    category: 'qux',
+  });
+  expect(eventData.message).toBe('test_multi_breadcrumbs');
+});

packages/integration-tests/suites/public-api/addBreadcrumb/simple_breadcrumb/subject.js

@@ -0,0 +1,7 @@
+Sentry.addBreadcrumb({
+  category: 'foo',
+  message: 'bar',
+  level: 'baz',
+});
+
+Sentry.captureMessage('test');

packages/integration-tests/suites/public-api/addBreadcrumb/simple_breadcrumb/test.ts

@@ -0,0 +1,18 @@
+import { expect } from '@playwright/test';
+
+import { sentryTest } from '../../../../utils/fixtures';
+import { getSentryRequest } from '../../../../utils/helpers';
+
+sentryTest('should add a simple breadcrumb', async ({ getLocalTestPath, page }) => {
+  const url = await getLocalTestPath({ testDir: __dirname });
+
+  const eventData = await getSentryRequest(page, url);
+
+  expect(eventData.breadcrumbs).toHaveLength(1);
+  expect(eventData.breadcrumbs?.[0]).toMatchObject({
+    category: 'foo',
+    message: 'bar',
+    level: 'baz',
+  });
+  expect(eventData.message).toBe('test');
+});

packages/integration-tests/suites/public-api/addBreadcrumb/undefined_arg/subject.js

@@ -0,0 +1,3 @@
+Sentry.addBreadcrumb();
+
+Sentry.captureMessage('test_undefined_arg');

packages/integration-tests/suites/public-api/addBreadcrumb/undefined_arg/test.ts

@@ -0,0 +1,20 @@
+import { expect } from '@playwright/test';
+
+import { sentryTest } from '../../../../utils/fixtures';
+import { getSentryRequest } from '../../../../utils/helpers';
+
+sentryTest(
+  'should add an empty breadcrumb initialized with a timestamp, when no argument is given',
+  async ({ getLocalTestPath, page }) => {
+    const url = await getLocalTestPath({ testDir: __dirname });
+
+    const eventData = await getSentryRequest(page, url);
+
+    expect(eventData.breadcrumbs).toHaveLength(1);
+    expect(eventData.breadcrumbs?.[0]).toMatchObject({
+      timestamp: expect.any(Number),
+    });
+
+    expect(eventData.message).toBe('test_undefined_arg');
+  },
+);

packages/integration-tests/suites/public-api/captureException/empty_obj/subject.js

@@ -0,0 +1 @@
+Sentry.captureException({});

packages/integration-tests/suites/public-api/captureException/empty_obj/test.ts

@@ -0,0 +1,20 @@
+import { expect } from '@playwright/test';
+
+import { sentryTest } from '../../../../utils/fixtures';
+import { getSentryRequest } from '../../../../utils/helpers';
+
+sentryTest('should capture an empty object', async ({ getLocalTestPath, page }) => {
+  const url = await getLocalTestPath({ testDir: __dirname });
+
+  const eventData = await getSentryRequest(page, url);
+
+  expect(eventData.exception?.values).toHaveLength(1);
+  expect(eventData.exception?.values?.[0]).toMatchObject({
+    type: 'Error',
+    value: 'Non-Error exception captured with keys: [object has no keys]',
+    mechanism: {
+      type: 'generic',
+      handled: true,
+    },
+  });
+});

packages/integration-tests/suites/public-api/captureException/init.js

@@ -0,0 +1,7 @@
+import * as Sentry from '@sentry/browser';
+
+window.Sentry = Sentry;
+
+Sentry.init({
+  dsn: 'https://[email protected]/1337',
+});

packages/integration-tests/suites/public-api/captureException/simple_error/subject.js

@@ -0,0 +1,5 @@
+try {
+  throw Error('test_simple_error');
+} catch (err) {
+  Sentry.captureException(err);
+}

packages/integration-tests/suites/public-api/captureException/simple_error/test.ts

@@ -0,0 +1,23 @@
+import { expect } from '@playwright/test';
+
+import { sentryTest } from '../../../../utils/fixtures';
+import { getSentryRequest } from '../../../../utils/helpers';
+
+sentryTest('should capture a simple error with message', async ({ getLocalTestPath, page }) => {
+  const url = await getLocalTestPath({ testDir: __dirname });
+
+  const eventData = await getSentryRequest(page, url);
+
+  expect(eventData.exception?.values).toHaveLength(1);
+  expect(eventData.exception?.values?.[0]).toMatchObject({
+    type: 'Error',
+    value: 'test_simple_error',
+    mechanism: {
+      type: 'generic',
+      handled: true,
+    },
+    stacktrace: {
+      frames: expect.any(Array),
+    },
+  });
+});

packages/integration-tests/suites/public-api/captureException/template.hbs

@@ -0,0 +1,11 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <meta charset="utf-8" />
+    <title></title>
+  <script src="{{htmlWebpackPlugin.options.initialization}}"></script>
+  </head>
+  <body>
+    <script src="{{htmlWebpackPlugin.options.subject}}"></script>
+  </body>
+</html>

packages/integration-tests/suites/public-api/captureException/undefined_arg/subject.js

@@ -0,0 +1 @@
+Sentry.captureException();

packages/integration-tests/suites/public-api/captureException/undefined_arg/test.ts

@@ -0,0 +1,20 @@
+import { expect } from '@playwright/test';
+
+import { sentryTest } from '../../../../utils/fixtures';
+import { getSentryRequest } from '../../../../utils/helpers';
+
+sentryTest('should capture an undefined error when no arguments are provided', async ({ getLocalTestPath, page }) => {
+  const url = await getLocalTestPath({ testDir: __dirname });
+
+  const eventData = await getSentryRequest(page, url);
+
+  expect(eventData.exception?.values).toHaveLength(1);
+  expect(eventData.exception?.values?.[0]).toMatchObject({
+    type: 'Error',
+    value: 'undefined',
+    mechanism: {
+      type: 'generic',
+      handled: true,
+    },
+  });
+});

packages/integration-tests/suites/public-api/captureException/with_context/init.js

@@ -0,0 +1,11 @@
+import * as Sentry from '@sentry/browser';
+
+window.Sentry = Sentry;
+
+Sentry.init({
+  dsn: 'https://[email protected]/1337',
+  beforeSend: (event, hint) => {
+    event.hint = hint;
+    return event;
+  },
+});

packages/integration-tests/suites/public-api/captureException/with_context/subject.js

@@ -0,0 +1,5 @@
+try {
+  undefinedFn();
+} catch (err) {
+  Sentry.captureException(err, { foo: 'bar' });
+}

packages/integration-tests/suites/public-api/captureException/with_context/test.ts

@@ -0,0 +1,27 @@
+import { expect } from '@playwright/test';
+import { EventHint } from '@sentry/types';
+
+import { sentryTest } from '../../../../utils/fixtures';
+import { getSentryRequest } from '../../../../utils/helpers';
+
+sentryTest('should capture an error with provided hint context', async ({ getLocalTestPath, page, browserName }) => {
+  const url = await getLocalTestPath({ testDir: __dirname });
+
+  const eventData = await getSentryRequest(page, url);
+
+  expect(eventData.exception?.values).toHaveLength(1);
+  expect(eventData.exception?.values?.[0]).toMatchObject({
+    type: 'ReferenceError',
+    value: browserName === 'webkit' ? `Can't find variable: undefinedFn` : 'undefinedFn is not defined',
+    mechanism: {
+      type: 'generic',
+      handled: true,
+    },
+    stacktrace: {
+      frames: expect.any(Array),
+    },
+  });
+  expect((eventData as Event & { hint: EventHint }).hint.captureContext).toMatchObject({
+    foo: 'bar',
+  });
+});

packages/integration-tests/suites/public-api/captureMessage/init.js

@@ -0,0 +1,7 @@
+import * as Sentry from '@sentry/browser';
+
+window.Sentry = Sentry;
+
+Sentry.init({
+  dsn: 'https://[email protected]/1337',
+});

packages/integration-tests/suites/public-api/captureMessage/simple_message/subject.js

@@ -0,0 +1 @@
+Sentry.captureMessage('foo');

packages/integration-tests/suites/public-api/captureMessage/simple_message/test.ts

@@ -0,0 +1,13 @@
+import { expect } from '@playwright/test';
+
+import { sentryTest } from '../../../../utils/fixtures';
+import { getSentryRequest } from '../../../../utils/helpers';
+
+sentryTest('should capture a simple message string', async ({ getLocalTestPath, page }) => {
+  const url = await getLocalTestPath({ testDir: __dirname });
+
+  const eventData = await getSentryRequest(page, url);
+
+  expect(eventData.message).toBe('foo');
+  expect(eventData.level).toBe('info');
+});

packages/integration-tests/suites/public-api/captureMessage/template.hbs

@@ -0,0 +1,11 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <meta charset="utf-8" />
+    <title></title>
+  <script src="{{htmlWebpackPlugin.options.initialization}}"></script>
+  </head>
+  <body>
+    <script src="{{htmlWebpackPlugin.options.subject}}"></script>
+  </body>
+</html>

packages/integration-tests/suites/public-api/captureMessage/with_context/init.js

@@ -0,0 +1,11 @@
+import * as Sentry from '@sentry/browser';
+
+window.Sentry = Sentry;
+
+Sentry.init({
+  dsn: 'https://[email protected]/1337',
+  beforeSend: (event, hint) => {
+    event.hint = hint;
+    return event;
+  },
+});

packages/integration-tests/suites/public-api/captureMessage/with_context/subject.js

@@ -0,0 +1 @@
+Sentry.captureMessage('message_with_hint', { foo: 'bar', level: 'error' });

packages/integration-tests/suites/public-api/captureMessage/with_context/test.ts

@@ -0,0 +1,17 @@
+import { expect } from '@playwright/test';
+import { EventHint } from '@sentry/types';
+
+import { sentryTest } from '../../../../utils/fixtures';
+import { getSentryRequest } from '../../../../utils/helpers';
+
+sentryTest('should capture a message with provided hint', async ({ getLocalTestPath, page }) => {
+  const url = await getLocalTestPath({ testDir: __dirname });
+  const eventData = await getSentryRequest(page, url);
+
+  expect(eventData.message).toBe('message_with_hint');
+  expect(eventData.level).toBe('error');
+  expect((eventData as Event & { hint: EventHint }).hint.captureContext).toMatchObject({
+    foo: 'bar',
+    level: 'error',
+  });
+});

packages/integration-tests/suites/public-api/captureMessage/with_level/init.js

@@ -0,0 +1,11 @@
+import * as Sentry from '@sentry/browser';
+
+window.Sentry = Sentry;
+window.events = [];
+
+Sentry.init({
+  dsn: 'https://[email protected]/1337',
+  beforeSend: event => {
+    window.events.push(event);
+  },
+});

packages/integration-tests/suites/public-api/captureMessage/with_level/subject.js

@@ -0,0 +1,7 @@
+Sentry.captureMessage('debug_message', 'debug');
+Sentry.captureMessage('info_message', 'info');
+Sentry.captureMessage('warning_message', 'warning');
+Sentry.captureMessage('error_message', 'error');
+Sentry.captureMessage('fatal_message', 'fatal');
+Sentry.captureMessage('critical_message', 'critical');
+Sentry.captureMessage('log_message', 'log');

packages/integration-tests/suites/public-api/captureMessage/with_level/test.ts

@@ -0,0 +1,31 @@
+import { expect } from '@playwright/test';
+
+import { sentryTest } from '../../../../utils/fixtures';
+import { getSentryEvents } from '../../../../utils/helpers';
+
+sentryTest('should capture with different severity levels', async ({ getLocalTestPath, page }) => {
+  const url = await getLocalTestPath({ testDir: __dirname });
+
+  const events = await getSentryEvents(page, url);
+
+  expect(events[0].message).toBe('debug_message');
+  expect(events[0].level).toBe('debug');
+
+  expect(events[1].message).toBe('info_message');
+  expect(events[1].level).toBe('info');
+
+  expect(events[2].message).toBe('warning_message');
+  expect(events[2].level).toBe('warning');
+
+  expect(events[3].message).toBe('error_message');
+  expect(events[3].level).toBe('error');
+
+  expect(events[4].message).toBe('fatal_message');
+  expect(events[4].level).toBe('fatal');
+
+  expect(events[5].message).toBe('critical_message');
+  expect(events[5].level).toBe('critical');
+
+  expect(events[6].message).toBe('log_message');
+  expect(events[6].level).toBe('log');
+});

packages/integration-tests/suites/public-api/configureScope/clear_scope/subject.js

@@ -0,0 +1,8 @@
+Sentry.configureScope(scope => {
+  scope.setTag('foo', 'bar');
+  scope.setUser({ id: 'baz' });
+  scope.setExtra('qux', 'quux');
+  scope.clear();
+});
+
+Sentry.captureMessage('cleared_scope');