Implementation of DDT data-driven in python

DDT (Data-Driven Testing) is a software testing method that drives the execution of test cases through external data sources (such as Excel, CSV, database, etc.). Its core idea is to separate test data from test logic, thereby improving the flexibility and maintainability of tests.

The following is a detailed introduction and implementation method about DDT:

1. Core concept of DDT

• Test data is separated from logic:

  • The test logic is fixed, and the test data can be loaded dynamically from an external file or database.

  • The data can be input parameters, expected results, or configuration information.

• Data source:

  • Common data sources include: CSV files, Excel files, JSON files, databases, APIs, etc.

• Test cases dynamically generated:

  • A test case is dynamically generated based on each row of data in the data source.

2. Advantages of DDT

• Improve test coverage:

  • Test the same logic through multiple sets of data to cover more scenarios.

• Reduce code duplication:

  • The test logic only needs to be written once, and the data can be loaded dynamically.

• Easy to maintain:

  • When the test data changes, you only need to modify the data source without modifying the test code.

• Support complex scenarios:

  • Boundary conditions and exceptions can be tested with a large amount of data combination.

3. DDT implementation method

Here are some common ways to implement DDT using Python:

Method 1: Unittest and ddt libraries

ddtis a Python library specially used for data-driven testing.

Installddt：

pip install ddt

Example Code 1:

import unittest
from ddt import ddt, data, unpack

@ddt
class TestMathOperations():

    @data((1, 2, 3), (4, 5, 9), (10, -5, 5))
    @unpack
    def test_addition(self, a, b, expected_result):
        (a + b, expected_result)

if __name__ == "__main__":
    ()

Running results:

• Each set of data generates an independent test case.

Example Code 2:

import requests
import unittest
from ddt import ddt, data
test_data = [
    {'method':'post', 'url':''},
    {'method':'put', 'url':''},
    {'method':'put', 'url':''},
]
@ddt
class Test():
    @data(*test_data)
    def test01(self, case):
        print('ask', type(case))
        res = (method=case['method'], url=case['url'])
        print(res)


if __name__ == '__main__':
    ()

Running results:

Request <class 'dict'>
<Response [200]>
Request <class 'dict'>
<Response [200]>
Request <class 'dict'>

<Response [200]>
Ran 3 tests in 0.423s

OK

Method 2: Use pytest and parameterization

pytestIt is a powerful testing framework that supports data-driven testing.

Sample code:

import pytest

# Test datatest_data = [
    (1, 2, 3),
    (4, 5, 9),
    (10, -5, 5)
]

@("a, b, expected_result", test_data)
def test_addition(a, b, expected_result):
    assert a + b == expected_result

Running results:

Each set of data generates an independent test case.

Method 3: Load data from external files

Test data can be loaded from CSV, Excel, or JSON files.

Loading data from a CSV file:

import csv
import pytest

def load_test_data_from_csv(file_path):
    test_data = []
    with open(file_path, newline='') as csvfile:
        reader = (csvfile)
        next(reader)  # Skip the header        for row in reader:
            test_data.append(tuple(map(int, row)))  # Convert data to integers    return test_data

test_data = load_test_data_from_csv("test_data.csv")

@("a, b, expected_result", test_data)
def test_addition(a, b, expected_result):
    assert a + b == expected_result

CSV file example (test_data.csv)：

a,b,expected_result
1,2,3
4,5,9
10,-5,5

Loading data from a JSON file:

import json
import pytest

def load_test_data_from_json(file_path):
    with open(file_path) as f:
        return (f)

test_data = load_test_data_from_json("test_data.json")

@("data", test_data)
def test_addition(data):
    assert data["a"] + data["b"] == data["expected_result"]

JSON file example (test_data.json)：

[
    {"a": 1, "b": 2, "expected_result": 3},
    {"a": 4, "b": 5, "expected_result": 9},
    {"a": 10, "b": -5, "expected_result": 5}
]

4. Best Practices for DDT

• Data source management:

  • Store test data in external files for easy maintenance and sharing.

• Data format standardization:

  • Use a unified format (such as CSV, JSON) to store test data.

• Boundary Test:

  • Include boundary values ​​and outliers in the data to ensure full coverage of the test.

• Data Cleanup:

  • Clean the test environment before and after testing to avoid data contamination.

• Test report:

  • Generate a detailed test report and record the test results of each set of data.

5. Application scenarios of DDT

• API Testing:

  • Test the API's response using multiple sets of input parameters.

• UI Test:

  • Use multiple sets of data to test form submission, login and other functions.

• Database Test:

  • Test database query and write operations using multiple sets of data.

• Performance Test:

  • Use multiple sets of data to simulate different load scenarios.

This is the end of this article about the implementation of DDT data driver in python. For more related python DDT data driver content, please search for my previous articles or continue browsing the related articles below. I hope everyone will support me in the future!