Transaction-Based Vs Endpoint-Only Testing Documentation

Matching docs

Search across docs titles, summaries, groups, and section headings.

Use Up and Down Arrow to move through results, then press Enter to open the active page.

What this page helps you do

Compare endpoint-only testing with full transaction testing so you can measure the whole downstream workflow instead of just the first request.

Who this is for

Engineers deciding how to frame the workload before they choose transports, thresholds, or reports.

Prerequisites

A workflow where business completion matters more than the first request alone

By the end

A clearer definition of what the transaction should mean for this workload.

Run the quick start Compare endpoint-only testing

Use this page when

Use this page when the team needs to agree on the workload model before debating transport, threshold, or reporting details.

Visual guide

Guide

Endpoint-Only Testing

Endpoint tests focus on whether one request returns and how quickly it does so. That is useful for isolated services, but it often stops before the business workflow is actually finished.

Transaction-Based Testing

Transaction testing follows the workflow across systems, matches the source and destination events, and reports the latency, timeout, duplicate, and failure behavior of the full path.

Practical Difference

In distributed systems, the real problem often appears after the first hop: queues back up, consumers slow down, retries rise, or orchestration breaks. Transaction-based testing exposes those downstream failures, while endpoint-only testing can leave them hidden.

Concept and scenario samples

Use these examples to connect the concept on this page back to the scenario and reporting model that the runtime actually exposes.

If you run these examples locally, add a valid runner key before execution starts. Set it with WithRunnerKey("...") or the config key LoadStrike:RunnerKey.

Transaction Model

using LoadStrike;

var source = new HttpEndpointDefinition
{
    Name = "orders-api",
    Mode = TrafficEndpointMode.Produce,
    TrackingField = TrackingFieldSelector.Parse("header:X-Correlation-Id"),
    Url = "https://api.example.com/orders",
    Method = "POST",
    MessagePayload = new { orderId = "ord-1001", amount = 49.95m }
};

var destination = new KafkaEndpointDefinition
{
    Name = "orders-completed",
    Mode = TrafficEndpointMode.Consume,
    TrackingField = TrackingFieldSelector.Parse("header:X-Correlation-Id"),
    BootstrapServers = "localhost:9092",
    Topic = "orders.completed",
    ConsumerGroupId = "loadstrike-orders"
};

var tracking = new CrossPlatformTrackingConfiguration
{
    Source = source,
    Destination = destination,
    RunMode = TrackingRunMode.GenerateAndCorrelate,
    CorrelationTimeout = TimeSpan.FromSeconds(30)
};

var scenario = CrossPlatformScenarioConfigurator
    .Configure(LoadStrikeScenario.Empty("orders-http-to-kafka"), tracking)
    .WithLoadSimulations(
        LoadStrikeSimulation.Inject(10, TimeSpan.FromSeconds(1), TimeSpan.FromSeconds(20))
    );

LoadStrikeRunner.RegisterScenarios(scenario)
    .WithRunnerKey("rkl_your_local_runner_key")
    .Run();

package main

import loadstrike "loadstrike.com/sdk/go"

func main() {
    payload, _ := loadstrike.RawPayloadFromAny(map[string]any{
        "orderId": "ord-1001",
        "amount":  49.95,
    })

    tracking := &loadstrike.TrackingConfigurationSpec{
        RunMode:                   "GenerateAndCorrelate",
        CorrelationTimeoutSeconds: 30,
        Source: &loadstrike.EndpointSpec{
            Kind:          "Http",
            Name:          "orders-api",
            Mode:          "Produce",
            TrackingField: "header:X-Correlation-Id",
            MessagePayload: payload,
            HTTP: &loadstrike.HTTPEndpointOptions{
                URL:    "https://api.example.com/orders",
                Method: "POST",
            },
        },
        Destination: &loadstrike.EndpointSpec{
            Kind:          "Kafka",
            Name:          "orders-completed",
            Mode:          "Consume",
            TrackingField: "header:X-Correlation-Id",
            Kafka: &loadstrike.KafkaEndpointOptions{
                BootstrapServers: "localhost:9092",
                Topic:            "orders.completed",
                ConsumerGroupID:  "loadstrike-orders",
            },
        },
    }

    scenario := loadstrike.CreateScenario("orders-http-to-kafka", func(loadstrike.LoadStrikeScenarioContext) loadstrike.LoadStrikeReply {
        return loadstrike.OK()
    }).
        WithTrackingConfiguration(tracking).
        WithLoadSimulations(loadstrike.LoadStrikeSimulation.Inject(15, loadstrike.DurationFromSeconds(1), loadstrike.DurationFromSeconds(30)))

    loadstrike.RegisterScenarios(scenario).
        WithRunnerKey("rkl_your_local_runner_key").
        Run()
}

import com.loadstrike.runtime.CrossPlatformScenarioConfigurator;
import com.loadstrike.runtime.CrossPlatformTrackingConfiguration;
import com.loadstrike.runtime.HttpEndpointDefinition;
import com.loadstrike.runtime.KafkaEndpointDefinition;
import com.loadstrike.runtime.LoadStrikeRuntime.LoadStrikeRunner;
import com.loadstrike.runtime.LoadStrikeRuntime.LoadStrikeScenario;
import com.loadstrike.runtime.LoadStrikeRuntime.LoadStrikeSimulation;
import com.loadstrike.runtime.LoadStrikeCorrelation.TrackingFieldSelector;
import com.loadstrike.runtime.LoadStrikeTransports;

var source = new HttpEndpointDefinition();
source.name = "orders-api";
source.mode = LoadStrikeTransports.TrafficEndpointMode.Produce;
source.trackingField = TrackingFieldSelector.parse("header:X-Correlation-Id");
source.url = "https://api.example.com/orders";
source.method = "POST";
source.messagePayload = java.util.Map.of("orderId", "ord-1001", "amount", 49.95);

var destination = new KafkaEndpointDefinition();
destination.name = "orders-completed";
destination.mode = LoadStrikeTransports.TrafficEndpointMode.Consume;
destination.trackingField = TrackingFieldSelector.parse("header:X-Correlation-Id");
destination.bootstrapServers = "localhost:9092";
destination.topic = "orders.completed";
destination.consumerGroupId = "loadstrike-orders";

var tracking = new CrossPlatformTrackingConfiguration();
tracking.source = source;
tracking.destination = destination;
tracking.runMode = LoadStrikeTransports.TrackingRunMode.GenerateAndCorrelate;
tracking.correlationTimeout = java.time.Duration.ofSeconds(30);

var scenario = CrossPlatformScenarioConfigurator.Configure(
    LoadStrikeScenario.empty("orders-http-to-kafka"),
    tracking
).withLoadSimulations(LoadStrikeSimulation.inject(10, 1d, 20d));

LoadStrikeRunner
    .registerScenarios(scenario)
    .withRunnerKey("rkl_your_local_runner_key")
    .run();

from loadstrike_sdk import (
    CrossPlatformScenarioConfigurator,
    HttpEndpointDefinition,
    KafkaEndpointDefinition,
    LoadStrikeRunner,
    LoadStrikeScenario,
    LoadStrikeSimulation,
    TrackingFieldSelector,
)

source = HttpEndpointDefinition(
    name="orders-api",
    mode="Produce",
    tracking_field=TrackingFieldSelector.parse("header:X-Correlation-Id"),
    url="https://api.example.com/orders",
    method="POST",
    message_payload={"orderId": "ord-1001", "amount": 49.95},
)

destination = KafkaEndpointDefinition(
    name="orders-completed",
    mode="Consume",
    tracking_field=TrackingFieldSelector.parse("header:X-Correlation-Id"),
    bootstrap_servers="localhost:9092",
    topic="orders.completed",
    consumer_group_id="loadstrike-orders",
)

tracking = {
    "RunMode": "GenerateAndCorrelate",
    "CorrelationTimeoutSeconds": 30,
    "Source": source,
    "Destination": destination,
}

scenario = (
    CrossPlatformScenarioConfigurator.Configure(
        LoadStrikeScenario.empty("orders-http-to-kafka"),
        tracking,
    )
    .with_load_simulations(LoadStrikeSimulation.inject(10, 1, 20))
)

LoadStrikeRunner.register_scenarios(scenario) \
    .with_runner_key("rkl_your_local_runner_key") \
    .run()

import {
  CrossPlatformScenarioConfigurator,
  LoadStrikeRunner,
  LoadStrikeScenario,
  LoadStrikeSimulation,
  TrackingFieldSelector
} from "@loadstrike/loadstrike-sdk";

const tracking = {
  RunMode: "GenerateAndCorrelate",
  CorrelationTimeoutSeconds: 30,
  Source: {
    Kind: "Http",
    Name: "orders-api",
    Mode: "Produce",
    TrackingField: new TrackingFieldSelector("Header", "X-Correlation-Id"),
    Url: "https://api.example.com/orders",
    Method: "POST",
    MessagePayload: { orderId: "ord-1001", amount: 49.95 }
  },
  Destination: {
    Kind: "Kafka",
    Name: "orders-completed",
    Mode: "Consume",
    TrackingField: new TrackingFieldSelector("Header", "X-Correlation-Id"),
    BootstrapServers: "localhost:9092",
    Topic: "orders.completed",
    ConsumerGroupId: "loadstrike-orders"
  }
};

const scenario = CrossPlatformScenarioConfigurator
  .Configure(LoadStrikeScenario.empty("orders-http-to-kafka"), tracking)
  .withLoadSimulations(LoadStrikeSimulation.inject(10, 1, 20));

await LoadStrikeRunner
  .registerScenarios(scenario)
  .withRunnerKey("rkl_your_local_runner_key")
  .run();

const {
  CrossPlatformScenarioConfigurator,
  LoadStrikeRunner,
  LoadStrikeScenario,
  LoadStrikeSimulation,
  TrackingFieldSelector
} = require("@loadstrike/loadstrike-sdk");

(async () => {
  const tracking = {
    RunMode: "GenerateAndCorrelate",
    CorrelationTimeoutSeconds: 30,
    Source: {
      Kind: "Http",
      Name: "orders-api",
      Mode: "Produce",
      TrackingField: new TrackingFieldSelector("Header", "X-Correlation-Id"),
      Url: "https://api.example.com/orders",
      Method: "POST",
      MessagePayload: { orderId: "ord-1001", amount: 49.95 }
    },
    Destination: {
      Kind: "Kafka",
      Name: "orders-completed",
      Mode: "Consume",
      TrackingField: new TrackingFieldSelector("Header", "X-Correlation-Id"),
      BootstrapServers: "localhost:9092",
      Topic: "orders.completed",
      ConsumerGroupId: "loadstrike-orders"
    }
  };

  const scenario = CrossPlatformScenarioConfigurator
    .Configure(LoadStrikeScenario.empty("orders-http-to-kafka"), tracking)
    .withLoadSimulations(LoadStrikeSimulation.inject(10, 1, 20));

  await LoadStrikeRunner
    .registerScenarios(scenario)
    .withRunnerKey("rkl_your_local_runner_key")
    .run();
})();

Comparison

Endpoint-only test

Measures whether one request path responded and how long it took.

Transaction test

Measures whether the workflow completed across the systems that actually deliver the business outcome.

Distributed-system signal

Captures timeout, duplicate, grouped percentile, and downstream failure behavior that endpoint-only tests can miss.

Matching docs

What this page helps you do

What this page helps you do

Who this is for

Prerequisites

By the end

Use this page when

Visual guide

Guide

Endpoint-Only Testing

Transaction-Based Testing

Practical Difference

Concept and scenario samples

Transaction Model

Comparison

Related category and article pages

Transaction load testing

End-to-end load testing

Examples