Struct goose::goose::Transaction

pub struct Transaction {
    pub transactions_index: usize,
    pub name: String,
    pub weight: usize,
    pub sequence: usize,
    pub on_start: bool,
    pub on_stop: bool,
    pub function: TransactionFunction,
}

An individual transaction within a Scenario.

Fields

transactions_index: usize

An index into Scenario.transaction, indicating which transaction this is.

name: String

An optional name for the transaction, used when displaying metrics.

weight: usize

An integer value that controls the frequency that this transaction will be run.

sequence: usize

An integer value that controls when this transaction runs compared to other transactions in the same Scenario.

on_start: bool

A flag indicating that this transaction runs when the user starts.

on_stop: bool

A flag indicating that this transaction runs when the user stops.

function: TransactionFunction

A required function that is executed each time this transaction runs.

Implementations

impl Transaction

pub fn new(function: TransactionFunction) -> Self

pub fn set_name(self, name: &str) -> Self

Set an optional name for the transaction, used when displaying metrics.

Individual requests can also be named using GooseRequestBuilder, or for GET requests with the GooseUser::get_named helper.

Example

use goose::prelude::*;

transaction!(my_transaction_function).set_name("foo");

async fn my_transaction_function(user: &mut GooseUser) -> TransactionResult {
    let _goose = user.get("").await?;

    Ok(())
}

pub fn set_on_start(self) -> Self

Set an optional flag indicating that this transaction should be run when a user first starts. This could be used to log the user in, and so all subsequent transaction are done as a logged in user. A transaction with this flag set will only run at start time (and optionally at stop time as well, if that flag is also set).

On-start transactions can be sequenced and weighted. Sequences allow multiple on-start transactions to run in a controlled order. Weights allow on-start transactions to run multiple times when a user starts.

Example

use goose::prelude::*;

transaction!(my_on_start_function).set_on_start();

async fn my_on_start_function(user: &mut GooseUser) -> TransactionResult {
    let _goose = user.get("").await?;

    Ok(())
}

pub fn set_on_stop(self) -> Self

Set an optional flag indicating that this transaction should be run when a user stops. This could be used to log a user out when the user finishes its load test. A transaction with this flag set will only run at stop time (and optionally at start time as well, if that flag is also set).

On-stop transactions can be sequenced and weighted. Sequences allow multiple on-stop transactions to run in a controlled order. Weights allow on-stop transactions to run multiple times when a user stops.

Example

use goose::prelude::*;

transaction!(my_on_stop_function).set_on_stop();

async fn my_on_stop_function(user: &mut GooseUser) -> TransactionResult {
    let _goose = user.get("").await?;

    Ok(())
}

pub fn set_weight(self, weight: usize) -> Result<Self, GooseError>

Sets a weight on an individual transaction. The larger the value of weight, the more often it will be run in the Scenario. For example, if one transaction has a weight of 3 and another transaction has a weight of 1, the first transaction will run 3 times as often.

Example

use goose::prelude::*;

#[tokio::main]
async fn main() -> Result<(), GooseError> {
    transaction!(transaction_function).set_weight(3)?;

    Ok(())
}

async fn transaction_function(user: &mut GooseUser) -> TransactionResult {
    let _goose = user.get("").await?;

    Ok(())
}

pub fn set_sequence(self, sequence: usize) -> Self

Defines the sequence value of an individual transactions. Transactions are run in order of their sequence value, so a transaction with a sequence value of 1 will run before a transaction with a sequence value of 2. Transactions with no sequence value (or a sequence value of 0) will run last, after all transactions with positive sequence values.

All transactions with the same sequence value will run in a random order. Transactions can be assigned both squence values and weights.

Examples

In this first example, the variable names indicate the order the transactions will be run in:

use goose::prelude::*;

let runs_first = transaction!(first_transaction_function).set_sequence(3);
let runs_second = transaction!(second_transaction_function).set_sequence(5835);
let runs_last = transaction!(third_transaction_function);

async fn first_transaction_function(user: &mut GooseUser) -> TransactionResult {
    let _goose = user.get("1").await?;

    Ok(())
}

async fn second_transaction_function(user: &mut GooseUser) -> TransactionResult {
    let _goose = user.get("2").await?;

    Ok(())
}

async fn third_transaction_function(user: &mut GooseUser) -> TransactionResult {
    let _goose = user.get("3").await?;

    Ok(())
}

In the following example, the runs_first transactions runs two times, then one instance of runs_second and two instances of also_runs_second are all three run. The user will do this over and over the entire time it runs, with runs_first always running first, then the other transactions being run in a random and weighted order:

use goose::prelude::*;

#[tokio::main]
async fn main() -> Result<(), GooseError> {
    let runs_first = transaction!(first_transaction_function).set_sequence(1).set_weight(2)?;
    let runs_second = transaction!(second_transaction_function_a).set_sequence(2);
    let also_runs_second = transaction!(second_transaction_function_b).set_sequence(2).set_weight(2)?;

    Ok(())
}

async fn first_transaction_function(user: &mut GooseUser) -> TransactionResult {
    let _goose = user.get("1").await?;

    Ok(())
}

async fn second_transaction_function_a(user: &mut GooseUser) -> TransactionResult {
    let _goose = user.get("2a").await?;

    Ok(())
}

    async fn second_transaction_function_b(user: &mut GooseUser) -> TransactionResult {
      let _goose = user.get("2b").await?;

      Ok(())
    }

Trait Implementations

impl Clone for Transaction

fn clone(&self) -> Transaction

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Hash for Transaction

fn hash<H: Hasher>(&self, state: &mut H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.