Skip to main content
Tarantula Logo

Tarantula

A modular, framework-agnostic test automation ecosystem for modern development teams.

Get Started
import { DesktopCrmApp, WebCustomerPortal } from '../pages';
import { test } from '@demirtag/tarantula';

test('should open customer portal from desktop app', async ({ tarantula }) => {
// 1. Start on the desktop application and perform an action.
const customerLink = tarantula.on(DesktopCrmApp)
.findCustomer('Max Mustermann')
.getPortalLink();

// 2. Intercept the browser launch triggered by the desktop action.
// This is the "magic" of the Tarantula Mock Browser.
const browser = await tarantula.desktop
.interceptBrowserLaunch(() => customerLink.click());

// 3. Seamlessly continue the test in the new browser context.
await browser.on(WebCustomerPortal).verifyCorrectDisplay();

});

An Architecture of Clarity

Tarantula isn't a monolith. It's a composable ecosystem built on clear boundaries and modern best practices.

Tarantula Core Icon

Tarantula Core

The framework-agnostic foundation defining key interfaces like `IDriver` and `IElement`. It must remain 100% blind to any specific test runner.

Adapter Layer

The bridge to specific technologies. It implements the core interfaces with concrete logic for drivers like Playwright, ensuring your tests are portable.

CLI & Tooling

Consumes core libraries to provide services like code generation with Hygen and interactive project setup with `@clack/prompts`.

IoC & Dependency Injection

Using `tsyringe`, all core services are injectable singletons. Dependencies are always injected via the constructor for clean, decoupled, and testable code.

Built on a Solid Foundation

Tarantula isn't just a tool; it's a philosophy for building scalable and maintainable test automation.

Strict Abstraction

The core is 100% blind to specific test runners. It defines interfaces (`IDriver`, `IElement`) that adapters implement, ensuring your tests are portable.

Dependency Injection

Using `tsyringe`, all services are designed as injectable singletons. This promotes clean, decoupled code and high testability.

Monorepo-First Design

The entire ecosystem lives in a single Nx monorepo. `libs` contain reusable code, and `apps` consume them, managed by a single root `node_modules`.

Integrates With Your Ecosystem

Tarantula's adapter-based architecture allows you to use the drivers and runners you already know and love.

Playwright logo

Playwright

Leverage the full power of modern browser automation with our official Playwright adapter.

Cypress logo

Cypress

Build a custom adapter to integrate Tarantula's architecture with your existing Cypress tests.

Selenium logo

Selenium

Maintain legacy test suites or build new ones with a Selenium adapter for wide browser support.