# Sequential Task Set

In load testing, some scenarios require tasks to be executed in a specific sequence to mimic real-world workflows. Locust addresses this need with the `SequentialTaskSet`, allowing you to define tasks that follow a set order. This contrasts with the default `TaskSet`, where tasks are chosen randomly based on their weights.

In this chapter, we’ll explore how to use `SequentialTaskSet` with an example to create a realistic load-testing scenario.

### What Is `SequentialTaskSet`?

The `SequentialTaskSet` class in Locust is a specialized version of the `TaskSet`. It ensures that tasks are executed sequentially, one after the other, in the order they are defined. This is ideal for scenarios like:

* Simulating multi-step workflows (e.g., login, browse, add to cart, checkout).
* Testing APIs with a fixed sequence of calls.

### Example: Sequential Task Execution

Here’s an example that demonstrates the use of `SequentialTaskSet`

```python
from locust import User, SequentialTaskSet, task, constant

class RandomOrderTasks(SequentialTaskSet):
    @task(2)
    def task_one(self):
        print("Task one")

    @task(1)
    def task_two(self):
        print("Task two")

    @task(3)
    def task_three(self):
        print("Task three")

class MyUser(User):
    tasks = [RandomOrderTasks]
    wait_time = constant(1)

```

### Explanation of the Code

**1. `RandomOrderTasks` Class**

This class defines the sequence of tasks to be executed by a simulated user. The key points are:

* **`@task` Decorator:**\
  Each method in the class is marked with the `@task` decorator, making it part of the task sequence.
  * The argument (e.g., `@task(2)`) specifies the **weight** of the task. However, in a `SequentialTaskSet`, weights are ignored, and tasks are executed strictly in the order they appear.
* **Defined Tasks:**
  * `task_one`: Prints "Task one".
  * `task_two`: Prints "Task two".
  * `task_three`: Prints "Task three".

**2. `MyUser` Class**

This class represents the user behavior:

* **`tasks` Attribute:**\
  Assigns the `RandomOrderTasks` as the set of tasks for the user.
* **`wait_time` Attribute:**\
  Specifies a fixed wait time of 1 second between each task using `constant(1)`.

### Benefits of `SequentialTaskSet`

1. **Realistic Testing:**\
   Represents real-world user behavior more accurately compared to randomly ordered tasks.
2. **Control Over Task Flow:**\
   Ensures tasks are executed in the desired order, which is critical for workflows with dependencies.
3. **Simplicity:**\
   Easy to define and understand, even for complex workflows.

#### Enhancing Sequential Task Sets with Custom Logic

You can extend the functionality of `SequentialTaskSet` by overriding its `on_start` and `on_stop` methods

```python
from locust import SequentialTaskSet, User, task, constant

class Workflow(SequentialTaskSet):
    def on_start(self):
        print("Starting the workflow")
    
    @task
    def step_one(self):
        print("Step one completed")
    
    @task
    def step_two(self):
        print("Step two completed")
    
    def on_stop(self):
        print("Workflow completed")

class MyUser(User):
    tasks = [Workflow]
    wait_time = constant(1)

```

In this example:

* `on_start` runs once before the first task.
* `on_stop` runs after the last task, signaling the end of the workflow.


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://courses.parottasalna.com/locust/sequential-task-set.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.