[][src]Struct goose::goose::GooseTask

pub struct GooseTask {
    pub tasks_index: usize,
    pub name: String,
    pub weight: usize,
    pub sequence: usize,
    pub on_start: bool,
    pub on_stop: bool,
    pub function: fn(_: &mut GooseClient),
}

An individual task within a GooseTaskSet.

Fields

tasks_index: usize

An index into GooseTaskSet.task, indicating which task this is.

name: String

An optional name for the task, used when displaying statistics about requests made.

weight: usize

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

sequence: usize

An integer value that controls when this task runs compared to other tasks in the same GooseTaskSet.

on_start: bool

A flag indicating that this task runs when the client starts.

on_stop: bool

A flag indicating that this task runs when the client stops.

function: fn(_: &mut GooseClient)

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

Methods

impl GooseTask[src]

pub fn new(function: fn(_: &mut GooseClient)) -> Self[src]

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

Set an optional name for the task, used when displaying statistics about requests made by the task.

Individual requests can also be named withing your load test. See the documentation for GooseClient.set_request_name()

Example

    GooseTask::new(my_task_function).set_name("foo");

pub fn set_on_start(self) -> Self[src]

Set an optional flag indicating that this task should be run when a client first starts. This could be used to log the user in, and so all subsequent tasks are done as a logged in user. A task 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 tasks can be sequenced and weighted. Sequences allow multiple on-start tasks to run in a controlled order. Weights allow on-start tasks to run multiple times when a client starts.

Example

    GooseTask::new(my_on_start_function).set_on_start();

pub fn set_on_stop(self) -> Self[src]

Set an optional flag indicating that this task should be run when a client stops. This could be used to log a user out when the client finishes its load test. A task 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 tasks can be sequenced and weighted. Sequences allow multiple on-stop tasks to run in a controlled order. Weights allow on-stop tasks to run multiple times when a client stops.

Example

    GooseTask::new(my_on_stop_function).set_on_stop();

pub fn set_weight(self, weight: usize) -> Self[src]

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

Example

    GooseTask::new(task_function).set_weight(3);

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

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

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

Examples

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

    let runs_first = GooseTask::new(first_task_function).set_sequence(3);
    let runs_second = GooseTask::new(second_task_function).set_sequence(5835);
    let runs_last = GooseTask::new(third_task_function);

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

    let runs_first = GooseTask::new(first_task_function).set_sequence(1).set_weight(2);
    let runs_second = GooseTask::new(second_task_function_a).set_sequence(2);
    let also_runs_second = GooseTask::new(second_task_function_b).set_sequence(2).set_weight(2);

Trait Implementations

impl Clone for GooseTask[src]

Auto Trait Implementations

Blanket Implementations

impl<T> Any for T where
    T: 'static + ?Sized
[src]

impl<T> Borrow<T> for T where
    T: ?Sized
[src]

impl<T> BorrowMut<T> for T where
    T: ?Sized
[src]

impl<T> From<T> for T[src]

impl<T, U> Into<U> for T where
    U: From<T>, 
[src]

impl<T> ToOwned for T where
    T: Clone
[src]

type Owned = T

The resulting type after obtaining ownership.

impl<T, U> TryFrom<U> for T where
    U: Into<T>, 
[src]

type Error = Infallible

The type returned in the event of a conversion error.

impl<T, U> TryInto<U> for T where
    U: TryFrom<T>, 
[src]

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.

impl<V, T> VZip<V> for T where
    V: MultiLane<T>,