Behave: Python BDD Test Framework

Behavior-driven development (BDD) is a software development approach that enhances collaboration between developers, testers, and non-technical stakeholders. By focusing on the expected behavior of the application, BDD helps ensure that everyone has a clear understanding of the requirements. One of the popular BDD frameworks for Python is Behave. In this blog post, we'll explore what Behave is, its key features, and how to use it with a simple example.

What is Behave?

Behave is a BDD framework for Python that allows you to write tests in a natural language style, similar to how you describe the behavior of an application. Behave uses Gherkin syntax to define test scenarios, making it easy for non-technical stakeholders to understand and contribute to the test specifications. It supports a wide range of testing needs, from unit tests to integration tests.

Key Features of Behave

1. Gherkin Syntax

Behave uses Gherkin syntax for writing test scenarios. Gherkin is a simple, readable language that describes the behavior of the application in terms of features, scenarios, and steps.

2. Human-Readable Tests

With Gherkin, tests are written in a natural language format, making them easy to read and understand by non-technical team members.

3. Separation of Concerns

Behave promotes the separation of test definitions (written in Gherkin) and test implementation (written in Python). This separation allows different team members to focus on their areas of expertise.

4. Integration with Other Tools

Behave can be integrated with other testing tools and frameworks, such as Selenium for browser automation or Requests for API testing.

5. Extensibility

Behave is highly extensible, allowing developers to write custom step definitions, hooks, and fixtures to suit their testing needs.

Getting Started with Behave

Installation

To get started with Behave, you need to install it using pip:

pip install behave        

Creating a Simple Test Project

Let's create a simple test project to demonstrate how Behave works. We'll build a basic calculator application and write BDD tests for it.

Step 1: Create a Project Directory

First, create a directory for your project:

mkdir behave_example
cd behave_example        

Step 2: Create the Calculator Application

Create a file named calculator.py and add the following code:

class Calculator:
    def add(self, a, b):
        return a + b

    def subtract(self, a, b):
        return a - b

    def multiply(self, a, b):
        return a * b

    def divide(self, a, b):
        if b == 0:
            raise ValueError("Cannot divide by zero")
        return a / b        

Step 3: Define Features and Scenarios

Create a directory named features in your project directory. Inside the features directory, create a file named calculator.feature and add the following content:

Feature: Calculator
  In order to perform basic arithmetic operations
  As a user
  I want to use a calculator

  Scenario: Addition
    Given I have a calculator
    When I add 2 and 3
    Then the result should be 5

  Scenario: Subtraction
    Given I have a calculator
    When I subtract 3 from 5
    Then the result should be 2        

Step 4: Implement Step Definitions

Create a directory named steps inside the features directory. Inside the steps directory, create a file named calculator_steps.py and add the following code:

from behave import given, when, then
from calculator import Calculator

@given('I have a calculator')
def step_given_i_have_a_calculator(context):
    context.calculator = Calculator()

@when('I add {a:d} and {b:d}')
def step_when_i_add(context, a, b):
    context.result = context.calculator.add(a, b)

@when('I subtract {a:d} from {b:d}')
def step_when_i_subtract(context, a, b):
    context.result = context.calculator.subtract(b, a)

@then('the result should be {expected_result:d}')
def step_then_the_result_should_be(context, expected_result):
    assert context.result == expected_result        

In this code, we define the step definitions that correspond to the Gherkin steps in the calculator.feature file. Each step definition is implemented as a Python function with decorators (@given, @when, @then) to match the Gherkin steps.

Step 5: Run the Tests

With everything set up, you can now run the tests using Behave:

behave        

You should see output indicating that all the scenarios have passed:

Feature: Calculator
  In order to perform basic arithmetic operations
  As a user
  I want to use a calculator

  Scenario: Addition                              # features/calculator.feature:6
    Given I have a calculator                     # steps/calculator_steps.py:5 0.001s
    When I add 2 and 3                            # steps/calculator_steps.py:9 0.001s
    Then the result should be 5                   # steps/calculator_steps.py:18 0.001s

  Scenario: Subtraction                           # features/calculator.feature:10
    Given I have a calculator                     # steps/calculator_steps.py:5 0.001s
    When I subtract 3 from 5                      # steps/calculator_steps.py:13 0.001s
    Then the result should be 2                   # steps/calculator_steps.py:18 0.001s
        

Additional Use Cases for Behave

1. Web Application Testing

Scenario: A team is developing a web application and wants to ensure that the user interface works as expected across different browsers and devices.

Application: Behave can be integrated with Selenium to automate browser interactions and test web applications. By writing Gherkin scenarios, the team can describe user interactions and validate the application's behavior. This helps catch issues early in the development cycle and ensures a consistent user experience.

Example:

Feature: User Login
  In order to access my account
  As a registered user
  I want to be able to log in

  Scenario: Successful login
    Given I am on the login page
    When I enter valid credentials
    And I click the login button
    Then I should be redirected to the dashboard        

Feature: User Login In order to access my account As a registered user I want to be able to log in Scenario: Successful login Given I am on the login page When I enter valid credentials And I click the login button Then I should be redirected to the dashboard

from behave import given, when, then
from selenium import webdriver

@given('I am on the login page')
def step_given_i_am_on_the_login_page(context):
    context.browser = webdriver.Chrome()
    context.browser.get('https://example.com/login')

@when('I enter valid credentials')
def step_when_i_enter_valid_credentials(context):
    context.browser.find_element_by_name('username').send_keys('user')
    context.browser.find_element_by_name('password').send_keys('pass')

@when('I click the login button')
def step_when_i_click_the_login_button(context):
    context.browser.find_element_by_name('login').click()

@then('I should be redirected to the dashboard')
def step_then_i_should_be_redirected_to_the_dashboard(context):
    assert context.browser.current_url == 'https://example.com/dashboard'
    context.browser.quit()        

2. API Testing

Scenario: A team is developing a RESTful API and wants to ensure that all endpoints behave correctly under various conditions.

Application: Behave can be used to write tests for API endpoints, validating responses, status codes, and data consistency. By defining Gherkin scenarios, the team can describe API interactions and expected outcomes, making it easier to test and maintain the API.

Example:

Feature: User Management API
  In order to manage users
  As an admin
  I want to use the User Management API

  Scenario: Create a new user
    Given I have valid user data
    When I send a POST request to the /users endpoint
    Then the response status code should be 201
    And the response body should contain the user details
        

Feature: User Management API In order to manage users As an admin I want to use the User Management API Scenario: Create a new user Given I have valid user data When I send a POST request to the /users endpoint Then the response status code should be 201 And the response body should contain the user details

from behave import given, when, then
import requests

@given('I have valid user data')
def step_given_i_have_valid_user_data(context):
    context.user_data = {'name': 'John Doe', 'email': '[email protected]'}

@when('I send a POST request to the /users endpoint')
def step_when_i_send_a_post_request(context):
    context.response = requests.post('https://api.example.com/users', json=context.user_data)

@then('the response status code should be 201')
def step_then_status_code_should_be_201(context):
    assert context.response.status_code == 201

@then('the response body should contain the user details')
def step_then_response_body_should_contain_user_details(context):
    response_data = context.response.json()
    assert response_data['name'] == 'John Doe'
    assert response_data['email'] == '[email protected]'
        

3. Mobile Application Testing

Scenario: A team is developing a mobile application and wants to ensure that it works correctly on different devices and operating systems.

Application: Behave can be integrated with Appium to automate mobile application testing. By writing Gherkin scenarios, the team can describe user interactions with the mobile app and validate its behavior across various devices and operating systems.

Example:

Feature: Mobile App Login
  In order to access my account
  As a registered user
  I want to log in using the mobile app

  Scenario: Successful login
    Given I am on the mobile app login screen
    When I enter valid credentials
    And I tap the login button
    Then I should see the home screen        

Feature: Mobile App Login In order to access my account As a registered user I want to log in using the mobile app Scenario: Successful login Given I am on the mobile app login screen When I enter valid credentials And I tap the login button Then I should see the home screen

from behave import given, when, then
from appium import webdriver

@given('I am on the mobile app login screen')
def step_given_i_am_on_the_mobile_app_login_screen(context):
    desired_caps = {
        'platformName': 'Android',
        'deviceName': 'emulator-5554',
        'app': '/path/to/app.apk'
    }
    context.driver = webdriver.Remote('https://localhost:4723/wd/hub', desired_caps)

@when('I enter valid credentials')
def step_when_i_enter_valid_credentials(context):
    context.driver.find_element_by_id('username').send_keys('user')
    context.driver.find_element_by_id('password').send_keys('pass')

@when('I tap the login button')
def step_when_i_tap_the_login_button(context):
    context.driver.find_element_by_id('login').click()

@then('I should see the home screen')
def step_then_i_should_see_the_home_screen(context):
    assert context.driver.find_element_by_id('home').is_displayed()
    context.driver.quit()        

4. Data-Driven Testing

Scenario: A team wants to run the same test scenario with different sets of data to ensure that the application handles various inputs correctly.

Application: Behave supports data-driven testing, allowing the same scenario to be executed multiple times with different inputs. This is useful for validating how the application handles different data sets and edge cases.

Example:

Feature: User Registration
  In order to create an account
  As a new user
  I want to register on the platform

  Scenario Outline: Successful registration
    Given I am on the registration page
    When I enter "<username>" and "<email>"
    And I click the register button
    Then I should see a confirmation message

    Examples:
      | username  | email             |
      | user1     | [email protected] |
      | user2     | [email protected] |        

Feature: User Registration In order to create an account As a new user I want to register on the platform Scenario Outline: Successful registration Given I am on the registration page When I enter "<username>" and "<email>" And I click the register button Then I should see a confirmation message Examples: | username | email | | user1 | [email protected] | | user2 | [email protected] |

from behave import given, when, then

@given('I am on the registration page')
def step_given_i_am_on_the_registration_page(context):
    context.browser.get('https://example.com/register')

@when('I enter "{username}" and "{email}"')
def step_when_i_enter_credentials(context, username, email):
    context.browser.find_element_by_name('username').send_keys(username)
    context.browser.find_element_by_name('email').send_keys(email)

@when('I click the register button')
def step_when_i_click_the_register_button(context):
    context.browser.find_element_by_name('register').click()

@then('I should see a confirmation message')
def step_then_i_should_see_confirmation(context):
    assert 'Registration successful' in context.browser.page_source        

5. Continuous Integration and Continuous Deployment (CI/CD)

Scenario: A development team wants to integrate their BDD tests into their CI/CD pipeline to automatically run tests on each code commit.

Application: Behave can be integrated into CI/CD pipelines to ensure that tests are run automatically with each code change. This helps catch issues early and ensures that the codebase remains stable and reliable.

Example:

Set up a CI/CD tool like Jenkins, GitLab CI, or GitHub Actions to run Behave tests as part of the build process. Here is an example using GitHub Actions:

name: CI

on:
  push:
    branches:
      - main

jobs:
  test:
    runs-on: ubuntu-latest

    steps:
    - uses: actions/checkout@v2
    - name: Set up Python
      uses: actions/setup-python@v2
      with:
        python-version: '3.8'
    - name: Install dependencies
      run: |
        python -m pip install --upgrade pip
        pip install behave
    - name: Run Behave tests
      run: behave        

Behave is a powerful and user-friendly BDD framework for Python that helps teams collaborate more effectively on defining and testing the behavior of their applications. By using Gherkin syntax and separating test definitions from test implementations, Behave makes it easy to write human-readable tests that can be understood by all stakeholders.

In this blog post, we've explored the key features of Behave, set up a simple test project, and demonstrated how to write and run BDD tests. Whether you're a developer, tester, or business analyst, Behave can be a valuable tool in your testing toolkit. Give it a try and experience the benefits of behavior-driven development in your projects!

Author

Nadir Riyani is an accomplished and visionary Engineering Manager with a strong background in leading high-performing engineering teams. With a passion for technology and a deep understanding of software development principles, Nadir has a proven track record of delivering innovative solutions and driving engineering excellence. He possesses a comprehensive understanding of software engineering methodologies, including Agile and DevOps, and has a keen ability to align engineering practices with business objectives. Reach out to him at [email protected] for more information.