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'r(_: &'r GooseClient) -> Pin<Box<dyn Future<Output = ()> + Send + 'r>>,
}

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'r(_: &'r GooseClient) -> Pin<Box<dyn Future<Output = ()> + Send + 'r>>

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

Implementations

impl GooseTask

pub fn new(
    function: fn'r(_: &'r GooseClient) -> Pin<Box<dyn Future<Output = ()> + Send + 'r>>
) -> Self

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

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

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

Example

    use goose::prelude::*;

    task!(my_task_function).set_name("foo");

    async fn my_task_function(client: &GooseClient) {
      let _response = client.get("/");
    }

pub fn set_on_start(self) -> Self

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

    use goose::prelude::*;

    task!(my_on_start_function).set_on_start();

    async fn my_on_start_function(client: &GooseClient) {
      let _response = client.get("/");
    }

pub fn set_on_stop(self) -> Self

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

    use goose::prelude::*;

    task!(my_on_stop_function).set_on_stop();

    async fn my_on_stop_function(client: &GooseClient) {
      let _response = client.get("/");
    }

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

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

    use goose::prelude::*;

    task!(task_function).set_weight(3);

    async fn task_function(client: &GooseClient) {
      let _response = client.get("/");
    }

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

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:

    use goose::prelude::*;

    let runs_first = task!(first_task_function).set_sequence(3);
    let runs_second = task!(second_task_function).set_sequence(5835);
    let runs_last = task!(third_task_function);

    async fn first_task_function(client: &GooseClient) {
      let _response = client.get("/1");
    }

    async fn second_task_function(client: &GooseClient) {
      let _response = client.get("/2");
    }

    async fn third_task_function(client: &GooseClient) {
      let _response = client.get("/3");
    }

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:

    use goose::prelude::*;

    let runs_first = task!(first_task_function).set_sequence(1).set_weight(2);
    let runs_second = task!(second_task_function_a).set_sequence(2);
    let also_runs_second = task!(second_task_function_b).set_sequence(2).set_weight(2);

    async fn first_task_function(client: &GooseClient) {
      let _response = client.get("/1");
    }

    async fn second_task_function_a(client: &GooseClient) {
      let _response = client.get("/2a");
    }

    async fn second_task_function_b(client: &GooseClient) {
      let _response = client.get("/2b");
    }

Trait Implementations

impl Clone for GooseTask

fn clone(&self) -> GooseTask

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Hash for GooseTask

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, 

Feeds a slice of this type into the given [Hasher].