Struct goose::GooseAttack

pub struct GooseAttack { /* fields omitted */ }

Internal global state for load test.

Implementations

impl GooseAttack

Goose's internal global state.

pub fn initialize() -> GooseAttack

Load configuration from command line and initialize a GooseAttack.

Example

    use goose::GooseAttack;

    let mut goose_attack = GooseAttack::initialize();

pub fn initialize_with_config(config: GooseConfiguration) -> GooseAttack

Initialize a GooseAttack with an already loaded configuration. This should only be called by worker instances.

Example

    use goose::{GooseAttack, GooseConfiguration};
    use structopt::StructOpt;

    let configuration = GooseConfiguration::from_args();
    let mut goose_attack = GooseAttack::initialize_with_config(configuration);

pub fn setup(self) -> Self

pub fn register_taskset(self, taskset: GooseTaskSet) -> Self

A load test must contain one or more GooseTaskSets. Each task set must be registered into Goose's global state with this method for it to run.

Example

    use goose::{GooseAttack, task, taskset};
    use goose::goose::{GooseTaskSet, GooseTask, GooseClient};

    // Needed to wrap and store async functions.
    use std::boxed::Box;

    GooseAttack::initialize()
        .register_taskset(taskset!("ExampleTasks")
            .register_task(task!(example_task))
        )
        .register_taskset(taskset!("OtherTasks")
            .register_task(task!(other_task))
        );

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

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

pub fn set_host(self, host: &str) -> Self

Optionally configure a default host for the load test. This is used if no per-GooseTaskSet host is defined, no --host CLI option is configurared, and if the GooseTask itself doesn't hard-code the host in its request. The host is prepended on all requests.

For example, your load test may default to running against your local development container, and the --host option could be used to override host to run the load test against production.

Example

    use goose::GooseAttack;

    GooseAttack::initialize()
        .set_host("local.dev");

pub fn execute(self)

Execute the load test.

Example

    use goose::{GooseAttack, task, taskset};
    use goose::goose::{GooseTaskSet, GooseTask, GooseClient};

    // Needed to wrap and store async functions.
    use std::boxed::Box;

    GooseAttack::initialize()
        .register_taskset(taskset!("ExampleTasks")
            .register_task(task!(example_task).set_weight(2))
            .register_task(task!(another_example_task).set_weight(3))
        )
        .execute();

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

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

Trait Implementations

impl Clone for GooseAttack

fn clone(&self) -> GooseAttack

Returns a copy of the value.

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

Performs copy-assignment from source.