Sentry Testkit

https://github.com/zivl/sentry-testkit
Admin
A Sentry plugin to allow Sentry report interception and further inspection of the data being sent
Tokens:8,256
Snippets:74
Trust Score:6.4
License:MIT
Update:1 year ago
Show doc for...
Tokens:
Raw
### Installing Sentry Testkit with yarn

Source: https://github.com/zivl/sentry-testkit/blob/master/website/docs/getting-started.md

Command to install sentry-testkit as a development dependency using yarn.

```yarn
yarn add sentry-testkit --dev
```

--------------------------------

### Installing Sentry Testkit with npm

Source: https://github.com/zivl/sentry-testkit/blob/master/website/docs/getting-started.md

Command to install sentry-testkit as a development dependency using npm.

```npm
npm install sentry-testkit --save-dev
```

--------------------------------

### Start Development Server - Expo App Setup - Bash

Source: https://github.com/zivl/sentry-testkit/blob/master/expo-react-native-test-app/README.md

Starts the Expo development server, providing options to open the app in various environments like a development build, emulator, simulator, or Expo Go.

```bash
npx expo start
```

--------------------------------

### Puppeteer Integration with Custom Base URL

Source: https://github.com/zivl/sentry-testkit/blob/master/website/docs/getting-started.md

Example demonstrating how to provide a custom base URL when starting the Sentry Testkit listener for Puppeteer, useful for self-hosted Sentry instances.

```javascript
testkit.puppeteer.startListening(page, 'https://my-self-hosted-sentry.com');
```

--------------------------------

### Install Dependencies - Expo App Setup - Bash

Source: https://github.com/zivl/sentry-testkit/blob/master/expo-react-native-test-app/README.md

Installs the necessary project dependencies listed in the package.json file using npm.

```bash
npm install
```

--------------------------------

### Basic Sentry Testkit Usage with Jest

Source: https://github.com/zivl/sentry-testkit/blob/master/website/docs/getting-started.md

Demonstrates initializing Sentry with the testkit transport and writing Jest tests to assert on captured error reports and performance transactions.

```javascript
// some.spec.js
const sentryTestkit = require('sentry-testkit')

const {testkit, sentryTransport} = sentryTestkit()

// initialize your Sentry instance with sentryTransport
Sentry.init({
    dsn: 'some_dummy_dsn',
    transport: sentryTransport,
    //... other configurations
})

test('collect error events', function () {
  // run any scenario that eventually calls Sentry.captureException(...)
  expect(testkit.reports()).toHaveLength(1)
  const report = testkit.reports()[0]
  expect(report).toHaveProperty(...)
});

// Similarly for performance events
test('collect performance events', function () {
  // run any scenario that eventually calls Sentry.startTransaction(...)
  expect(testkit.transactions()).toHaveLength(1)
});
```

--------------------------------

### Setting Up Local Development Environment (npm)

Source: https://github.com/zivl/sentry-testkit/blob/master/CONTRIBUTING.md

Provides the command-line instructions to clone the Sentry Testkit repository and install the necessary project dependencies using npm.

```shell
git clone git@github.com:zivl/sentry-testkit.git
```

```shell
npm install
```

--------------------------------

### Start Local Development Server (yarn) - shell

Source: https://github.com/zivl/sentry-testkit/blob/master/website/README.md

Starts a local development server for the Docusaurus website. It enables live reloading for most changes during development.

```shell
$ yarn start
```

--------------------------------

### Integrating Sentry Testkit with Puppeteer

Source: https://github.com/zivl/sentry-testkit/blob/master/website/docs/getting-started.md

Shows how to use testkit.puppeteer.startListening and stopListening to capture Sentry events triggered within a Puppeteer browser page and assert on them.

```javascript
const sentryTestkit = require('sentry-testkit')

const {testkit} = sentryTestkit()

testkit.puppeteer.startListening(page);

// Run any scenario that will call Sentry.captureException(...), for example:
await page.addScriptTag({ content: `throw new Error('An error');` });

expect(testkit.reports()).toHaveLength(1)

const report = testkit.reports()[0]
expect(report).toHaveProperty(...)

testkit.puppeteer.stopListening(page);
```

--------------------------------

### Install Dependencies (yarn) - shell

Source: https://github.com/zivl/sentry-testkit/blob/master/website/README.md

Installs project dependencies using the Yarn package manager. This is typically the first step after cloning the repository.

```shell
$ yarn
```

--------------------------------

### Installing sentry-testkit with yarn

Source: https://github.com/zivl/sentry-testkit/blob/master/docs/getting-started/README.md

Installs the sentry-testkit package as a development dependency using yarn.

```shell
yarn add sentry-testkit --dev
```

--------------------------------

### Resetting Sentry Testkit State Before Each Test (Jest)

Source: https://github.com/zivl/sentry-testkit/blob/master/website/docs/getting-started.md

Uses Jest's beforeEach hook to call testkit.reset(), ensuring a clean state for Sentry Testkit reports and transactions before every individual test run.

```javascript
beforeEach(function(){
    testkit.reset()
})
```

--------------------------------

### Full React Native Testing Example with sentry-testkit (JavaScript)

Source: https://github.com/zivl/sentry-testkit/blob/master/website/docs/react-native.md

A comprehensive example demonstrating the setup, initialization, and usage of sentry-testkit within a Jest test suite for a React Native application, including capturing exceptions and asserting reported data.

```javascript
import { Event, ErrorEvent } from '@sentry/core';
import * as ReactNativeSentry from '@sentry/react-native';
import sentryTestkit from 'sentry-testkit';

const { testkit, sentryTransport } = sentryTestkit();
const DUMMY_DSN = 'https://acacaeaccacacacabcaacdacdacadaca@sentry.io/000001';
const Sentry = ReactNativeSentry;

describe('React Native Sentry integration tests', function() {
  beforeAll(() =>
    Sentry.init({
      dsn: DUMMY_DSN,
      release: 'test',
      tracesSampleRate: 1,
      transport: sentryTransport,
      beforeSend(event: Event) {
        event.extra = { os: 'mobile-device' };
        return event as ErrorEvent;
      },
    })
  );

  beforeEach(() => testkit.reset());

  test('should capture React Native exceptions', async () => {
    Sentry.captureException(new Error('React Native test error'));

    // Use a mechanism like waitForExpect to allow async operations to complete
    expect(testkit.reports()).toHaveLength(1);

    const report = testkit.reports()[0];
    expect(report.error).toMatchObject({
      name: 'Error',
      message: 'React Native test error',
    });
  });

  test('should include platform-specific information', async () => {
    Sentry.captureException(new Error('Platform-specific error'));

    expect(testkit.reports()).toHaveLength(1);
    expect(testkit.reports()[0].extra).toEqual({ os: 'mobile-device' });
  });
});
```

--------------------------------

### Installing sentry-testkit with npm

Source: https://github.com/zivl/sentry-testkit/blob/master/docs/getting-started/README.md

Installs the sentry-testkit package as a development dependency using npm.

```shell
npm install sentry-testkit --save-dev
```

--------------------------------

### Reset Project Structure - Expo App Setup - Bash

Source: https://github.com/zivl/sentry-testkit/blob/master/expo-react-native-test-app/README.md

Executes a script defined in package.json to reset the project structure, typically by moving starter code and creating a blank app directory.

```bash
npm run reset-project
```

--------------------------------

### Resetting Sentry Testkit State Before All Tests (Jest)

Source: https://github.com/zivl/sentry-testkit/blob/master/website/docs/getting-started.md

Uses Jest's beforeAll hook to call testkit.reset(), clearing any accumulated Sentry Testkit state once before the entire test suite begins.

```javascript
beforeAll(function(){
    testkit.reset()
})
```

--------------------------------

### Installing Raven Test Kit

Source: https://github.com/zivl/sentry-testkit/blob/master/LEGACY_API.md

Command to install raven-testkit as a development dependency using npm.

```Shell
npm install raven-testkit --save-dev
```

--------------------------------

### Executing Release Process with standard-version (npm)

Source: https://github.com/zivl/sentry-testkit/blob/master/CONTRIBUTING.md

Details the command-line steps for creating a new release using standard-version, which includes fetching tags, generating the changelog, updating version numbers, creating a git tag, committing changes, pushing to master, and publishing the package to npm.

```shell
git fetch --all --tags
```

```shell
npm run release
```

```shell
git push --follow-tags origin master && npm publish
```

--------------------------------

### Using Raven Test Kit in Tests

Source: https://github.com/zivl/sentry-testkit/blob/master/LEGACY_API.md

Example demonstrating how to initialize the test kit with the Raven instance and assert on captured reports.

```JavaScript
const testKit = testKitInitializer(Raven)

// any scenario that should call Raven.catchException(...)

expect(testKit.reports()).toHaveLength(1)
const report = testKit.reports()[0]
expect(report).toHaveProperty('release', 'test')
```

--------------------------------

### Build Static Website (yarn) - shell

Source: https://github.com/zivl/sentry-testkit/blob/master/website/README.md

Generates static content for the website into the 'build' directory. The output can be served by any static hosting service.

```shell
$ yarn build
```

--------------------------------

### Installing Raven Testkit via npm

Source: https://github.com/zivl/sentry-testkit/blob/master/website/docs/raven-testkit-legacy.md

This command installs the raven-testkit package using npm. It is typically installed as a development dependency because it is primarily used in testing environments.

```shell
npm install raven-testkit --save-dev
```

--------------------------------

### Install Sentry Testkit via npm

Source: https://github.com/zivl/sentry-testkit/blob/master/README.md

Installs the sentry-testkit package as a development dependency using the npm package manager. This is the standard way to add the library to your project for testing purposes.

```Shell
npm install sentry-testkit --save-dev
```

--------------------------------

### Install raven-testkit via npm

Source: https://github.com/zivl/sentry-testkit/blob/master/docs/raven/LEGACY_API.md

Install the raven-testkit package as a development dependency using the npm package manager.

```Shell
npm install raven-testkit --save-dev
```

--------------------------------

### Getting Reports with Sentry Testkit in JavaScript

Source: https://github.com/zivl/sentry-testkit/blob/master/website/docs/api/README.md

Demonstrates how to retrieve all captured error reports using `testkit.reports()`. The example uses `wait-for-expect` to handle the asynchronous nature of report capturing, ensuring reports are available before assertions.

```javascript
const waitForExpect = require('wait-for-expect')

test('reports example', async function() {
    // Some scenario that will report the exceptions...

    await waitForExpect(() => expect(testkit.reports().length).toBeGreaterThan(0))
    const reports = testkit.reports()

    // Do what ever you want with the reports list
})
```

--------------------------------

### Install Sentry Testkit via yarn

Source: https://github.com/zivl/sentry-testkit/blob/master/README.md

Adds the sentry-testkit package as a development dependency using the yarn package manager. This provides an alternative installation method to npm.

```Shell
yarn add sentry-testkit --dev
```

--------------------------------

### Getting Transactions from Testkit (JavaScript)

Source: https://github.com/zivl/sentry-testkit/blob/master/docs/api/transactions.md

This example demonstrates how to use the `testkit.transactions()` method within a JavaScript test. It shows how to wait for transactions to be captured by the testkit using `waitForExpect` and then retrieve the array of captured transactions for further processing.

```javascript
test('transactions example', async function() {
    // Some scenario that will create a transaction...

    await waitForExpect(() => expect(testkit.transactions().length).toBeGreaterThan(0))
    const transactions = testkit.transactions()

    // Do what ever you want with the transactions
})
```

--------------------------------

### Deploy Website via SSH (yarn) - shell

Source: https://github.com/zivl/sentry-testkit/blob/master/website/README.md

Deploys the built website content using SSH. This command is often used for deploying to platforms like GitHub Pages when SSH is configured.

```shell
$ USE_SSH=true yarn deploy
```

--------------------------------

### Instantiating Raven Testkit

Source: https://github.com/zivl/sentry-testkit/blob/master/website/docs/raven-testkit-legacy.md

These examples show how to import or require the raven-testkit initializer function depending on whether you are using CommonJS or ES6 modules. The initializer function is then used to create a testkit instance by passing the Raven SDK object.

```javascript
// CommonJS
const testKitInitializer = require('raven-testkit')
```

```javascript
// ES6 Modules
import testKitInitializer from 'raven-testkit'
```

--------------------------------

### Initializing Raven Testkit with Custom shouldSendCallback

Source: https://github.com/zivl/sentry-testkit/blob/master/website/docs/raven-testkit-legacy.md

This example shows how to initialize the testkit while providing your own shouldSendCallback function. This allows you to control which reports are processed by the testkit based on custom logic, similar to how Raven's own shouldSendCallback works.

```javascript
const shouldSendCallback = data => {
    return /* your own logic */
}
const testKit = testKitInitializer(Raven, shouldSendCallback)
```

--------------------------------

### Installing sentry-testkit for React Native (Bash)

Source: https://github.com/zivl/sentry-testkit/blob/master/website/docs/react-native.md

Instructions for adding sentry-testkit as a development dependency to a React Native project using npm or yarn.

```bash
npm install --save-dev sentry-testkit
# or
yarn add --dev sentry-testkit
```

--------------------------------

### Using Custom shouldSendCallback

Source: https://github.com/zivl/sentry-testkit/blob/master/LEGACY_API.md

Example showing how to provide a custom function to control which reports are captured by the test kit.

```JavaScript
const shouldSendCallback = data => {
    return /* your own logic */
}
const testKit = testKitInitializer(Raven, shouldSendCallback)
```

--------------------------------

### Deploy Website without SSH (yarn) - shell

Source: https://github.com/zivl/sentry-testkit/blob/master/website/README.md

Deploys the built website content without using SSH, typically requiring a Git username. Useful for deploying to platforms like GitHub Pages when SSH is not used.

```shell
$ GIT_USER=<Your GitHub username> yarn deploy
```

--------------------------------

### Example Usage of reports() in JavaScript Test

Source: https://github.com/zivl/sentry-testkit/blob/master/docs/api/reports.md

This snippet demonstrates how to use the `testkit.reports()` method within a JavaScript test function. It waits for reports to be available using `waitForExpect` and then retrieves the list of reports for further processing.

```javascript
test('reports example', async function() {
    // Some scenario that will report the exceptions...

    await waitForExpect(() => expect(testkit.reports().length).toBeGreaterThan(0))
    const reports = testkit.reports()

    // Do what ever you want with the reports list
})
```

--------------------------------

### Getting Transactions with Sentry Testkit in JavaScript

Source: https://github.com/zivl/sentry-testkit/blob/master/website/docs/api/README.md

Shows how to retrieve all captured transactions using `testkit.transactions()`. Similar to reports, this method returns an array of transaction objects, often requiring waiting for asynchronous capture.

```javascript
test('transactions example', async function() {
    // Some scenario that will create a transaction...

    await waitForExpect(() => expect(testkit.transactions().length).toBeGreaterThan(0))
    const transactions = testkit.transactions()

    // Do what ever you want with the transactions
})
```

--------------------------------

### Example Usage of findReport in JavaScript

Source: https://github.com/zivl/sentry-testkit/blob/master/docs/api/findReport.md

Demonstrates how to use the `findReport` function within a test case to verify that a report exists for a given error object after a scenario that should trigger a Sentry report.

```javascript
test('findReport example', async function() {
    const err = new Error('error to look for')

    // Some faulty scenario that will report err

    const report = testkit.findReport(err)
    expect(report).toBeDefined()
})
```

--------------------------------

### Testing External Process Error Reporting with Sentry Testkit (JavaScript)

Source: https://github.com/zivl/sentry-testkit/blob/master/docs/api/external-process.md

This snippet demonstrates setting up a test suite using sentry-testkit to intercept Sentry reports from a child process executed via execa. It starts the local server, runs the external script with the testkit's DSN, and asserts that the expected error report is received by the testkit. Dependencies include execa, wait-for-expect, and sentry-testkit.

```javascript
const execa = require('execa')
const waitForExpect = require('wait-for-expect')
const sentryTestkit = require('sentry-testkit')

const { testkit, localServer } = sentryTestkit()
const MY_APP_DSN = 'http://acacaeaccacacacabcaacdacdacadaca@sentry.io/000001'

describe('my app - error reporting', function() {
  beforeAll(() => localServer.start(MY_APP_DSN))

  afterAll(() => localServer.stop())

  beforeEach(() => testkit.reset())

  test('should report to test kit from an external process', async function() {
    const dsn = localServer.getDsn()
    const errorMessage = 'sentry test kit is awesome!'
    execa
      .node('my-app.js', [
        dsn,
        errorMessage,
      ])
      .stdout.pipe(process.stdout)

    await waitForExpect(() => {
      expect(testkit.reports()[0].error).toMatchObject({
        name: 'Error',
        message: errorMessage,
      })
    })
  })
})
```

--------------------------------

### Resetting Sentry Testkit State in JavaScript

Source: https://github.com/zivl/sentry-testkit/blob/master/website/docs/api/README.md

Illustrates how to clear all captured reports and reset the internal state of the testkit using `testkit.reset()`. This is crucial for ensuring tests are independent and start with a clean state.

```javascript
test('reset example', async function() {
    Sentry.captureException(new Error('Sentry test kit is awesome!'))
    await waitForExpect(() => expect(testkit.reports()).toHaveLength(1))
    expect(testkit.reports()).toHaveLength(1)
    testkit.reset()
    expect(testkit.reports()).toHaveLength(0)
})
```

--------------------------------

### Using sentry-testkit/dist/jestMock in Jest (JavaScript)

Source: https://github.com/zivl/sentry-testkit/blob/master/website/docs/migration/version-5.md

Demonstrates how to import and use the `testkit` mock provided by `sentry-testkit` within a Jest test file (`.spec.js`). It shows importing `testkit` and then using it to assert the number of captured Sentry reports. This snippet was originally presented in the context of a potential breaking change issue that has since been fixed.

```javascript
// some.spec.js
import { testkit } from 'sentry-testkit/dist/jestMock';

test('something', function () {
    // click
    // clack
    // BOOM!
    expect(testkit.reports().length).toBeGreaterThan(0);
});
```

--------------------------------

### Defining Conventional Commit Message Format

Source: https://github.com/zivl/sentry-testkit/blob/master/CONTRIBUTING.md

Describes the required format for commit messages based on conventional commits, including the structure with type, scope, subject, body, and footer. This format is used for generating project history and release notes.

```text
<type>[optional scope]: <description>

[optional body]

[optional footer]
```

--------------------------------

### Integrating Sentry Testkit with Nock for Network Interception

Source: https://github.com/zivl/sentry-testkit/blob/master/docs/api/network-interception.md

This snippet shows how to initialize Sentry testkit's network interceptor using nock. It sets up nock to intercept Sentry store and envelope requests based on the provided base URL and passes the request bodies to the testkit's handler functions. It uses nock's `reply` for store requests and the `on('request')` event for envelope requests due to Sentry's non-standard JSON format in envelopes.

```javascript
const nock = require('nock')
const sentryTestkit = require('sentry-testkit')
const { testkit, initNetworkInterceptor } = sentryTestkit()

beforeAll(() => {
    const myAppDSN = '<your DSN goes here>'
    initNetworkInterceptor(myAppDSN, (baseUrl, handleRequestBody, handleEnvelopeRequestBody) => {
      // This callback is where we init our interceptor.
      // The interceptor should intercept requests from `baseUrl` and pass the
      // request body (as json) to the `handleRequestBody` function.
      // For envelope requests (such as performance events), we use the emitted request event,
      // since in a reply function nock automatically tries to parse the body as json,
      // and fails since Sentry are using a non-standard json with a json request header.
      // See https://develop.sentry.dev/sdk/envelopes/ for more information on envelope requests.
      nock(baseUrl)
        .persist()
        .post(//api/.*/store/)
          .reply(200, (_, requestBody) => {
            handleRequestBody(requestBody)
          })
          .post(//api/.*/envelope/)
          .reply(200)
          .on('request', (_, interceptor, body) => {
            if (interceptor.uri.test('/api/000000/envelope')) {
              handleEnvelopeRequestBody(body)
            }
          })
    })
})

test('findReport example', async function() {
    const err = new Error('error to look for')

    // Some faulty scenario that will report err

    const report = testkit.findReport(err)
    expect(report).toBeDefined()
})
```

--------------------------------

### Testing Sentry/React Error Boundary with sentry-testkit (JavaScript)

Source: https://github.com/zivl/sentry-testkit/blob/master/website/docs/error-boundary-usage.md

This snippet provides a test case using @testing-library/react and sentry-testkit to verify Sentry error reporting within a React Error Boundary. It initializes Sentry with the testkit's transport, renders a component that throws an error wrapped in <Sentry.ErrorBoundary>, and asserts that testkit.reports() captures the expected number of events (3 in this specific scenario). It also includes setup and teardown for mocking console.error.

```javascript
import React from 'react'
import '@testing-library/jest-dom'
import { render } from '@testing-library/react'
import * as Sentry from '@sentry/react'
import sentryTestkit from 'sentry-testkit'

const { testkit, sentryTransport } = sentryTestkit()

const ThrowError = () => {
  // eslint-disable-next-line
  throw Error('test error')
}

describe('Inside ErrorBoundary', () => {
  const consoleError = console.error
  beforeAll(() => {
    console.error = jest.fn()
    Sentry.init({
      dsn: 'https://acacaeaccacacacabcaacdacdacadaca@sentry.io/000001',
      transport: sentryTransport,
    })
  })
  afterAll(() => {
    console.error = consoleError
  })

  test('should render fallback component and captureException when error is thrown', async () => {
    expect(testkit.reports()).toHaveLength(0)
    render(
      <Sentry.ErrorBoundary fallback={<div>some error</div>}>
        <ThrowError />
      </Sentry.ErrorBoundary>
    )
    expect(testkit.reports()).toHaveLength(3)
  })
})
```

--------------------------------

### Testing External Process Error Reporting with Sentry Testkit (JavaScript)

Source: https://github.com/zivl/sentry-testkit/blob/master/website/docs/external-process.md

This JavaScript code snippet demonstrates how to use Sentry Testkit's local server to test error reporting from an external Node.js process. It sets up a test suite, starts and stops the local server, resets the testkit, executes an external script (`my-app.js`) passing the test DSN and an error message, and then waits for and verifies the captured error report using `wait-for-expect`.

```javascript
const execa = require('execa')
const waitForExpect = require('wait-for-expect')
const sentryTestkit = require('sentry-testkit')

const { testkit, localServer } = sentryTestkit()
const MY_APP_DSN = 'http://acacaeaccacacacabcaacdacdacadaca@sentry.io/000001'

describe('my app - error reporting', function() {
  beforeAll(() => localServer.start(MY_APP_DSN))

  afterAll(() => localServer.stop())

  beforeEach(() => testkit.reset())

  test('should report to test kit from an external process', async function() {
    const dsn = localServer.getDsn()
    const errorMessage = 'sentry test kit is awesome!'
    execa
      .node('my-app.js', [
        dsn,
        errorMessage,
      ])
      .stdout.pipe(process.stdout)

    await waitForExpect(() => {
      expect(testkit.reports()[0].error).toMatchObject({
        name: 'Error',
        message: errorMessage,
      })
    })
  })
})
```

--------------------------------

### Verifying Transaction Span ID with sentry-testkit - JavaScript

Source: https://github.com/zivl/sentry-testkit/blob/master/website/docs/span-ids.md

This snippet illustrates how to start a Sentry transaction using the Sentry SDK and then use sentry-testkit to retrieve the captured transaction and assert that it has a defined spanId. It demonstrates integration between the Sentry SDK and sentry-testkit for testing transactions.

```javascript
const transaction = Sentry.startTransaction({ name: 'My Transaction' })
Sentry.configureScope(scope => scope.setSpan(transaction))

// Later in your tests
expect(testkit.transactions()[0].spanId).toBeDefined()
```

--------------------------------

### Intercepting Sentry Requests using nock with Sentry Testkit

Source: https://github.com/zivl/sentry-testkit/blob/master/website/docs/network-interception.md

This snippet demonstrates how to configure Sentry Testkit's network interception using the nock library. It sets up request interceptors for Sentry's 'store' and 'envelope' endpoints before tests run, passing the request body to the appropriate Sentry Testkit handlers. It also includes an example test showing how to find a reported error using `testkit.findReport`.

```javascript
const nock = require('nock')
const sentryTestkit = require('sentry-testkit')
const { testkit, initNetworkInterceptor } = sentryTestkit()

beforeAll(() => {
    const myAppDSN = '<your DSN goes here>'
    initNetworkInterceptor(myAppDSN, (baseUrl, handleRequestBody, handleEnvelopeRequestBody) => {
      nock(baseUrl)
        .persist()
        .post(//api/.*/store/)
          .reply(200, (_, requestBody) => {
            handleRequestBody(requestBody)
          })
          .post(//api/.*/envelope/)
          .reply(200)
          .on('request', (_, interceptor, body) => {
            if (interceptor.uri.test('/api/000000/envelope')) {
              handleEnvelopeRequestBody(body)
            }
          })
    })
})

test('findReport example', async function() {
    const err = new Error('error to look for')

    // Some faulty scenario that will report err

    const report = testkit.findReport(err)
    expect(report).toBeDefined()
})
```

--------------------------------

### Testing Parent-Child Span Relationships with sentry-testkit - JavaScript

Source: https://github.com/zivl/sentry-testkit/blob/master/website/docs/span-ids.md

This example shows a test case verifying that child spans correctly reference their parent span using the parentSpanId property. It uses sentry-testkit to retrieve reports and asserts the relationship, assuming a test runner like Jest and a function that generates linked spans.

```javascript
test('should create child spans with correct parent references', async () => {
  // Trigger a parent operation that creates child spans
  await performParentOperationWithChildren()

  const reports = testkit.reports()

  // Find the parent span
  const parentReport = reports.find(r => r.transaction === 'parentOperation')

  // Verify child spans reference the parent
  const childReports = reports.filter(
    r => r.parentSpanId === parentReport.spanId
  )

  expect(childReports.length).toBeGreaterThan(0)
  expect(childReports[0].transaction).toBe('childOperation')
})
```

--------------------------------

### Basic Usage with Sentry and Jest

Source: https://github.com/zivl/sentry-testkit/blob/master/docs/getting-started/README.md

Demonstrates how to initialize Sentry with the sentry-testkit transport and write Jest tests to collect and assert on captured error and performance events.

```javascript
// some.spec.js
const sentryTestkit = require('sentry-testkit')

const {testkit, sentryTransport} = sentryTestkit()

// initialize your Sentry instance with sentryTransport
Sentry.init({
    dsn: 'some_dummy_dsn',
    transport: sentryTransport,
    //... other configurations
})

test('collect error events', function () {
  // run any scenario that eventually calls Sentry.captureException(...)
  expect(testkit.reports()).toHaveLength(1)
  const report = testkit.reports()[0]
  expect(report).toHaveProperty(...)
});

// Similarly for performance events
test('collect performance events', function () {
  // run any scenario that eventually calls Sentry.startTransaction(...)
  expect(testkit.transactions()).toHaveLength(1)
});
```

--------------------------------

### Instantiating Raven Test Kit (CommonJS)

Source: https://github.com/zivl/sentry-testkit/blob/master/LEGACY_API.md

Importing the test kit initializer using CommonJS syntax.

```JavaScript
const testKitInitializer = require('raven-testkit')
```

--------------------------------

### Basic Sentry Testkit Integration and Testing (Node.js)

Source: https://github.com/zivl/sentry-testkit/blob/master/README.md

Illustrates the core usage of sentry-testkit in a Node.js testing environment (like Jest). It shows how to initialize Sentry with the testkit's transport and how to access captured reports and transactions for assertions.

```JavaScript
// some.spec.js
const sentryTestkit = require('sentry-testkit')

const {testkit, sentryTransport} = sentryTestkit()

// initialize your Sentry instance with sentryTransport
Sentry.init({
    dsn: 'some_dummy_dsn',
    transport: sentryTransport,
    //... other configurations
})

test('collect error events', function () {
  // run any scenario that eventually calls Sentry.captureException(...)
  expect(testkit.reports()).toHaveLength(1)
  const report = testkit.reports()[0]
  expect(report).toHaveProperty(...)
});

// Similarly for performance events
test('collect performance events', function () {
  // run any scenario that eventually calls Sentry.startTransaction(...)
  expect(testkit.transactions()).toHaveLength(1)
});
```

--------------------------------

### Instantiate raven-testkit initializer

Source: https://github.com/zivl/sentry-testkit/blob/master/docs/raven/LEGACY_API.md

Import the raven-testkit initializer function using either CommonJS or ES6 module syntax to prepare for initializing the test kit with a Raven instance.

```JavaScript
const testKitInitializer = require('raven-testkit')
```

```JavaScript
import testKitInitializer from 'raven-testkit'
```

--------------------------------

### Importing sentry-testkit for Browser Usage in JavaScript

Source: https://github.com/zivl/sentry-testkit/blob/master/website/docs/browser-only.md

Demonstrates how to import and initialize `sentry-testkit` specifically for use in a browser environment using the `/browser` entry point. It shows how to obtain the `sentryTransport` and `testkit` instances required for integrating with Sentry and performing tests.

```javascript
import sentryTestkit from 'sentry-testkit/browser';

const { sentryTransport, testkit } = sentryTestkit();

// initialize your Sentry instance with sentryTransport

// ...the rest of the testkit usage is the same as in the Node.js example

```

--------------------------------

### Instantiating Raven Test Kit (ES6 Modules)

Source: https://github.com/zivl/sentry-testkit/blob/master/LEGACY_API.md

Importing the test kit initializer using ES6 module syntax.

```JavaScript
import testKitInitializer from 'raven-testkit'
```

--------------------------------

### Initialize with custom shouldSendCallback

Source: https://github.com/zivl/sentry-testkit/blob/master/docs/raven/LEGACY_API.md

Initialize the test kit, providing a custom function that determines whether a report should be processed by the test kit, allowing fine-grained control over report capturing.

```JavaScript
const shouldSendCallback = data => {
    return /* your own logic */
}
const testKit = testKitInitializer(Raven, shouldSendCallback)
```

--------------------------------

### Importing and Initializing sentry-testkit (JavaScript)

Source: https://github.com/zivl/sentry-testkit/blob/master/website/docs/react-native.md

Demonstrates how to import the necessary Sentry React Native package and initialize sentry-testkit to obtain the testkit instance and transport.

```javascript
import * as ReactNativeSentry from '@sentry/react-native'
import sentryTestkit from 'sentry-testkit'

const { testkit, sentryTransport } = sentryTestkit()
```

--------------------------------

### Use raven-testkit in tests

Source: https://github.com/zivl/sentry-testkit/blob/master/docs/raven/LEGACY_API.md

Initialize the test kit with the Raven instance and write assertions against the captured reports to verify that Sentry integration is working as expected.

```JavaScript
const testKit = testKitInitializer(Raven)

// any scenario that should call Raven.catchException(...)

expect(testKit.reports()).toHaveLength(1)
const report = testKit.reports()[0]
expect(report).toHaveProperty('release', 'test')
```

--------------------------------

### Configuring Sentry with Testkit Transport (JavaScript)

Source: https://github.com/zivl/sentry-testkit/blob/master/website/docs/react-native.md

Shows how to initialize the Sentry React Native SDK, providing a dummy DSN and crucially setting the `transport` option to the `sentryTransport` obtained from sentry-testkit.

```javascript
ReactNativeSentry.init({
  dsn: 'https://your-dummy-dsn@sentry.io/123456',
  release: 'test',
  tracesSampleRate: 1,
  transport: sentryTransport,
  // other configurations
})
```

--------------------------------

### Using Raven Testkit in Tests

Source: https://github.com/zivl/sentry-testkit/blob/master/website/docs/raven-testkit-legacy.md

This snippet demonstrates a basic test scenario using raven-testkit. It initializes the testkit, simulates an action that would trigger a Raven report, and then uses the testkit's reports() method to assert that a report was captured and inspect its properties.

```javascript
const testKit = testKitInitializer(Raven)

// any scenario that should call Raven.catchException(...)

expect(testKit.reports()).toHaveLength(1)
const report = testKit.reports()[0]
expect(report).toHaveProperty('release', 'test')
```

--------------------------------

### Integrating sentry-testkit with Puppeteer

Source: https://github.com/zivl/sentry-testkit/blob/master/docs/getting-started/README.md

Demonstrates how to use sentry-testkit with Puppeteer to listen for Sentry events triggered within the browser page, simulate an error, and assert on the captured report.

```javascript
const sentryTestkit = require('sentry-testkit')

const {testkit} = sentryTestkit()

testkit.puppeteer.startListening(page);

// Run any scenario that will call Sentry.captureException(...), for example:
await page.addScriptTag({ content: `throw new Error('An error');` });

expect(testkit.reports()).toHaveLength(1)

const report = testkit.reports()[0]
expect(report).toHaveProperty(...)

testkit.puppeteer.stopListening(page);
```

--------------------------------

### Puppeteer Integration with Self-Hosted Sentry

Source: https://github.com/zivl/sentry-testkit/blob/master/docs/getting-started/README.md

Shows how to configure the Puppeteer listener to work with a self-hosted Sentry instance by providing the base URL.

```javascript
testkit.puppeteer.startListening(page, 'https://my-self-hosted-sentry.com');
```

--------------------------------

### Using Sentry Testkit in Browser Environments

Source: https://github.com/zivl/sentry-testkit/blob/master/README.md

Provides the specific require path for using sentry-testkit in browser environments, which excludes Node.js-specific dependencies like express and http.

```JavaScript
const sentryTestkit = require('sentry-testkit/browser')

const { testkit } = sentryTestkit()
// Your code for browser
```

--------------------------------

### Using getExceptionAt with Sentry Testkit (JavaScript)

Source: https://github.com/zivl/sentry-testkit/blob/master/docs/api/getExceptionAt.md

This JavaScript test demonstrates how to capture multiple exceptions using Sentry, wait for the testkit to record them, and then retrieve a specific exception object by its index using `testkit.getExceptionAt()` to verify its message.

```javascript
test('getExceptionAt example', async function() {
    Sentry.captureException(new Error('testing get exception at index 0'))
    Sentry.captureException(new Error('testing get exception at index 1'))
    await waitForExpect(() => expect(testkit.reports()).toHaveLength(2))
    const { message } = testkit.getExceptionAt(1)
    expect(message).toEqual('testing get exception at index 1')
})
```

--------------------------------

### Using Jest Mock in a Test

Source: https://github.com/zivl/sentry-testkit/blob/master/docs/getting-started/README.md

Shows a basic Jest test using the imported testkit mock to assert that Sentry reports were captured after executing a test scenario.

```javascript
test('something', function () {
    // click
    // clack
    // BOOM!
    expect(testkit.reports().length).toBeGreaterThan(0);
});
```

--------------------------------

### Importing Jest Mock for sentry-testkit

Source: https://github.com/zivl/sentry-testkit/blob/master/docs/getting-started/README.md

Imports the testkit instance specifically designed for Jest integration. This import should typically be placed before other imports in your test file.

```javascript
// some.spec.js
import { testkit } from 'sentry-testkit/dist/jestMock';
```

--------------------------------

### Checking Error Existence with Sentry Testkit (JavaScript)

Source: https://github.com/zivl/sentry-testkit/blob/master/docs/api/isExist.md

This test snippet demonstrates how to use the `testkit.isExist` function. It creates an error, captures it using `Sentry.captureException`, waits for the report to be processed by the testkit, and then asserts that the `isExist` function correctly identifies the reported error.

```javascript
 test('isExist example', async function() {
    const err = new Error('error to look for')
    Sentry.captureException(err)
    await waitForExpect(() => expect(testkit.reports()).toHaveLength(1))
    expect(testkit.isExist(err)).toBe(true)
})
```

--------------------------------

### Resetting Testkit State Before All Jest Tests

Source: https://github.com/zivl/sentry-testkit/blob/master/docs/getting-started/README.md

Uses Jest's `beforeAll` hook to reset the sentry-testkit state once before all tests in the current describe block or file begin.

```javascript
beforeAll(function(){
    testkit.reset()
})
```

--------------------------------

### Testing Network Errors with sentry-testkit (JavaScript)

Source: https://github.com/zivl/sentry-testkit/blob/master/website/docs/react-native.md

Provides a specific test case demonstrating how to simulate a network error and verify that it is captured and reported correctly by Sentry when using sentry-testkit.

```javascript
test('should report network errors', async () => {
  // Simulate a network error
  const networkError = new Error('Network request failed')
  networkError.name = 'NetworkError'

  Sentry.captureException(networkError)

  expect(testkit.reports()).toHaveLength(1)
  expect(testkit.reports()[0].error.name).toBe('NetworkError')
})
```

--------------------------------

### Configure Raven to allow duplicates

Source: https://github.com/zivl/sentry-testkit/blob/master/docs/raven/LEGACY_API.md

Configure the Raven instance itself to allow duplicate reports. This is often necessary when using raven-testkit to ensure that multiple instances of the same error are captured during testing.

```JavaScript
Raven.config(dummyDsn, { allowDuplicates: true })
```

--------------------------------

### Resetting Sentry Testkit State - JavaScript

Source: https://github.com/zivl/sentry-testkit/blob/master/docs/api/reset.md

Demonstrates how to use the Sentry testkit's reset() method in a test. It captures an exception, verifies a report is present, calls reset(), and then verifies that all reports have been cleared.

```javascript
test('reset example', async function() {
    Sentry.captureException(new Error('Sentry test kit is awesome!'))
    await waitForExpect(() => expect(testkit.reports()).toHaveLength(1))
    expect(testkit.reports()).toHaveLength(1)
    testkit.reset()
    expect(testkit.reports()).toHaveLength(0)
})
```

--------------------------------

### Resetting Testkit State Before Each Jest Test

Source: https://github.com/zivl/sentry-testkit/blob/master/docs/getting-started/README.md

Uses Jest's `beforeEach` hook to reset the sentry-testkit state (clearing captured reports and transactions) before each individual test runs.

```javascript
beforeEach(function(){
    testkit.reset()
})
```

--------------------------------

### Finding a Specific Report in Sentry Testkit in JavaScript

Source: https://github.com/zivl/sentry-testkit/blob/master/website/docs/api/README.md

Shows how to find a specific error report within the captured reports using `testkit.findReport(error)`. It takes an `Error` object as an argument and returns the corresponding report if found, or `undefined` otherwise.

```javascript
test('findReport example', async function() {
    const err = new Error('error to look for')

    // Some faulty scenario that will report err

    const report = testkit.findReport(err)
    expect(report).toBeDefined()
})
```

--------------------------------

### Extracting Exception Object by Index in Sentry Testkit in JavaScript

Source: https://github.com/zivl/sentry-testkit/blob/master/website/docs/api/README.md

Demonstrates how to retrieve the exception object from a report at a specific index in the reports array using `testkit.getExceptionAt(index)`. This is useful for accessing details of a report based on its position.

```javascript
test('getExceptionAt example', async function() {
    Sentry.captureException(new Error('testing get exception at index 0'))
    Sentry.captureException(new Error('testing get exception at index 1'))
    await waitForExpect(() => expect(testkit.reports()).toHaveLength(2))
    const { message } = testkit.getExceptionAt(1)
    expect(message).toEqual('testing get exception at index 1')
})
```

--------------------------------

### Checking for Error Existence in Sentry Testkit in JavaScript

Source: https://github.com/zivl/sentry-testkit/blob/master/website/docs/api/README.md

Illustrates how to check if a specific error has been captured and exists in the reports using `testkit.isExist(error)`. It returns a boolean indicating whether the provided `Error` object is found among the reported errors.

```javascript
 test('isExist example', async function() {
    const err = new Error('error to look for')
    Sentry.captureException(err)
    await waitForExpect(() => expect(testkit.reports()).toHaveLength(1))
    expect(testkit.isExist(err)).toBe(true)
})
```

--------------------------------

### Disabling Sentry GlobalHandlers Integration (JavaScript)

Source: https://github.com/zivl/sentry-testkit/blob/master/website/docs/error-boundary-usage.md

This code demonstrates how to modify the default Sentry integrations during initialization to exclude the GlobalHandlers integration. This is achieved by providing a function to the integrations option that filters the default list, removing the integration with the name "GlobalHandlers". This can help reduce duplicate error reports caused by error boundaries re-throwing errors.

```javascript
import * as Sentry from '@sentry/react'
import { Integrations } from '@sentry/tracing'

Sentry.init({
  // ...
  integrations: function (integrations) {
    return integrations.filter(function (integration) {
      return integration.name !== "GlobalHandlers";
    });
  },
});
```

--------------------------------

### Accessing Span IDs in sentry-testkit Reports - JavaScript

Source: https://github.com/zivl/sentry-testkit/blob/master/website/docs/span-ids.md

This snippet demonstrates how to initialize sentry-testkit, retrieve captured Sentry reports, and access the spanId and parentSpanId properties from the last captured report. It requires the 'sentry-testkit' package.

```javascript
const sentryTestkit = require('sentry-testkit')
const { testkit } = sentryTestkit()

// After your code triggers a Sentry event
const reports = testkit.reports()
const lastReport = reports[reports.length - 1]

// Access span IDs
console.log(lastReport.spanId) // Unique identifier for this span
console.log(lastReport.parentSpanId) // Reference to parent span (if exists)
```

--------------------------------

### Disabling Sentry CaptureConsole Integration (JavaScript)

Source: https://github.com/zivl/sentry-testkit/blob/master/website/docs/error-boundary-usage.md

This snippet illustrates how to customize Sentry initialization to remove the CaptureConsole integration from the default list. By filtering the integrations array and excluding the integration named "CaptureConsole", Sentry will not automatically capture errors logged to the console. This can be useful for controlling which errors are reported.

```javascript
import * as Sentry from '@sentry/react'
import { Integrations } from '@sentry/tracing'

Sentry.init({
  // ...
  integrations: function (integrations) {
    return integrations.filter(function (integration) {
      return integration.name !== "CaptureConsole";
    });
  },
});
```
Tokens:
Raw