---
title: "Variables"
sidebarTitle: "Variables"
description: "Learn how to use variables in TestDriver for dynamic data handling."
icon: "square-root-variable"
---

# Using variables in TestDriver

Variables in **TestDriver** allow you to dynamically store and reuse data during test execution. This feature is particularly useful for handling dynamic content, passing data between steps, and customizing test behavior based on runtime conditions.

- Generate a random number or string and use it to fill out a form.
- Capture API responses and validate their content.
- Capture text or values from the screen and use them in assertions.
- Pass different values to the test using environment variables for testing multiple scenarios.

By leveraging variables in TestDriver, you can create dynamic, flexible, and reusable test scripts that adapt to changing conditions and data.

#### Example:

```yaml random.yaml highlight={6, 11, 19, 20}
version: 6.0.0
steps:
  - prompt: Generate a random number
    commands:
      - command: exec
        output: randomNumber
        js: |
          result = Math.floor(Math.random() * 1000);
      - command: exec
        js: |
          console.log("Generated Random Number: ${OUTPUT.randomNumber}");

  - prompt: Use the random number in a form
    commands:
      - command: hover-text
        text: Enter Number
        description: Input field for numbers
        action: click
      - command: type
        text: ${OUTPUT.randomNumber}
```

## CI/CD pipeline example (platform-agnostic)

You can run TestDriver in any CI/CD pipeline. Here is an example using the CLI in a generic workflow (adapt for your platform, e.g., GitHub Actions, GitLab CI, CircleCI, Jenkins, etc.):

```yaml workflows/testdriver.yml focus={6-13}
steps:
  - name: Check out repository
    # For GitHub Actions: uses: actions/checkout@v4
    # For GitLab CI: git clone ...

  - name: Run TestDriver CLI
    env:
      TD_API_KEY: ${{ secrets.TD_API_KEY }}
      TD_USERNAME: ${{ secrets.TD_USERNAME }}
      TD_PASSWORD: ${{ secrets.TD_PASSWORD }}
      # Add any other required environment variables
    run: |
      npx testdriverai@latest run testdriver/login.yaml
```

Now inside the `login.yaml` test file you can refer the variables

```yaml login.yaml highlight={21, 22, 27, 28}
version: 6.0.0
steps:
  - prompt: Open the homepage
    commands:
      - command: hover-text
        text: Login
        description: Login button in the top-right corner
        action: click

  - prompt: Verify the login form is displayed
    commands:
      - command: assert
        expect: The login form is displayed

  - prompt: Enter credentials and submit
    commands:
      - command: hover-text
        text: Email
        description: Email input field
        action: click
      - command: type
        text: ${TD_USERNAME}
      - command: hover-text
        text: Password
        description: Password input field
        action: click
      - command: type
        text: ${TD_PASSWORD}
      - command: hover-text
        text: Submit
        description: Submit button
        action: click
```

## **Capturing outputs as variables**

#### Example:

```yaml capture-text.yaml highlight={5, 6, 14, 15}
version: 6.0.0
steps:
  - prompt: Capture text from the screen
    commands:
      - command: remember
        output: welcomeMessage
        description: Capture the welcome message

  - prompt: Verify the dashboard is displayed
    commands:
      - command: exec
        js: |
          console.log("Captured Text: ${OUTPUT.welcomeMessage}");
      - command: assert
        expect: "${OUTPUT.welcomeMessage}" == "Welcome, Test User!"
```

## Best practices for using variables

1. **Use Descriptive Names**:

- Name variables clearly to indicate their purpose (for example, `capturedText`, `randomNumber`).

2. **Secure Sensitive Data**:

- Use environment variables for sensitive information like credentials or API keys.

3. **Log Variable Values**:

- Use `console.log` or similar commands to log variable values for debugging.

4. **Test Variable Logic Locally**:

- Verify the logic for custom variables locally before integrating them into workflows.

5. **Combine Variables with Assertions**:

- Use variables in assertions to validate dynamic content or conditions.
