DEV Community: RODRIGO SIDNEY COLQUE QUISPE

Testing Management Tools: A Comparative Guide and Real-World Reporting

RODRIGO SIDNEY COLQUE QUISPE — Sat, 27 Jun 2026 15:58:53 +0000

Testing Management Tools: A Comparative Guide and Real-World Reporting

As software projects grow, keeping track of what has been tested, what failed, and what needs to be re-tested becomes a logistical nightmare. Spreadsheets just don't cut it anymore. This is where Testing Management and Reporting Tools come into play.

In this article, we will compare three of the most popular test management tools in the industry and provide a real-world code example showing how to generate a management dashboard locally for your automated tests.

1. TestRail

TestRail is a dedicated, standalone web-based test case management tool.

Pros: Incredible UI/UX, highly customizable, excellent reporting metrics, and a robust REST API.
Cons: Can be expensive for large teams, not natively built inside Jira (though it has an integration plugin).
Best for: Teams that want a dedicated, powerful platform solely for QA and testing.

2. Zephyr Scale (formerly TM4J)

Zephyr Scale is built directly into Jira.

Pros: Seamless Jira integration (issues, epics, and bugs are natively linked to tests), very cost-effective if you already use Jira.
Cons: The UI can feel cluttered since it lives inside Jira. Slower performance on massive test suites compared to standalone tools.
Best for: Agile teams already heavily invested in the Atlassian (Jira) ecosystem.

3. Pytest-HTML / Local Reporting Tools

While TestRail and Zephyr are enterprise solutions, many developers use open-source local reporting plugins like pytest-html or Allure to generate self-contained HTML management dashboards from their test runs.

Pros: 100% Free, runs offline on your own machine, extremely fast, generates a beautiful visual HTML dashboard.
Cons: Doesn't support manual test case writing (purely for automated tests), and doesn't store historical data across years unless you save the files.
Best for: Individual developers, students, or teams that need instant, visual reporting directly from their CI pipeline without paying for a SaaS tool.

Real-World Code Example: Generating a Test Dashboard Locally

Let's look at how we can implement a local reporting/management tool using Python and the pytest-html plugin. This will allow us to run tests and instantly get a professional HTML dashboard showing exactly what passed, what failed, and how long it took.

The Code

First, we install Pytest and the HTML reporting plugin:

pip install pytest pytest-html

Next, we write some simple tests for a mock Login system in a file called test_login.py:

import pytest

def test_successful_login():
    """
    Test a valid login scenario.
    """
    username = "admin"
    password = "password123"

    # Mock login logic
    is_logged_in = (username == "admin" and password == "password123")

    # We expect this test to PASS
    assert is_logged_in == True

def test_failed_login():
    """
    Test an invalid login scenario.
    """
    username = "admin"
    password = "wrongpassword"

    is_logged_in = (username == "admin" and password == "password123")

    # We expect this test to FAIL (because it returns False)
    assert is_logged_in == True

Execution and Dashboard Generation

Normally, you would run pytest and get a text output in the terminal. To use our reporting tool, we pass a special flag to generate the dashboard:

python -m pytest test_login.py --html=report.html --self-contained-html

When this runs, pytest-html intercepts the results and creates a visually appealing file named report.html. If you open this file in Google Chrome or any browser, you will see a full Test Management dashboard displaying:

Environment metrics (Python version, OS).
A Summary table (1 Passed, 1 Failed).
The exact logs and tracebacks for the failed tests.

Public Example Repository:
You can find the complete, runnable code example for this integration in this GitHub repository:
🔗 https://github.com/Rodrig0496/U3_Article.git

By automating your test reporting, your QA managers get real-time visibility into the health of the application without the developers or testers having to do any manual data entry.

Applying API Testing Frameworks in the Real World: A Practical Guide with Pytest

RODRIGO SIDNEY COLQUE QUISPE — Sat, 27 Jun 2026 15:40:37 +0000

In today's interconnected software landscape, Application Programming Interfaces (APIs) are the bridges that allow different systems to communicate. With the growing reliance on microservices and third-party integrations, ensuring that your APIs are robust, secure, and performant is no longer optional—it's critical.

This is where API testing frameworks come in. In this article, we'll explore how to apply API testing in the real world using Python and Pytest, one of the most popular and powerful testing frameworks available.

Why Do We Need API Testing Frameworks?

Manual testing using tools like Postman or Insomnia is great for exploration, but it doesn't scale. When you have hundreds of endpoints and continuous integration/continuous deployment (CI/CD) pipelines, you need automated frameworks to:

Ensure Reliability: Catch breaking changes before they reach production.
Validate Business Logic: Verify that the API returns the correct data for both valid and invalid inputs.
Check Performance and Security: Ensure the API can handle load and is secure against common vulnerabilities.

The Tooling: Python, Pytest, and Requests

For our real-world example, we'll use:

Python: A versatile language widely used for test automation.
Pytest: A mature testing framework that makes writing small tests easy, yet scales to support complex functional testing.
Requests: The elegant and simple HTTP library for Python to make API calls.

Real-World Scenario: Testing a User Management API

Imagine we are building a backend for a social media application. We have an API endpoint to retrieve user profiles. We need to ensure that:

A valid request returns a 200 OK status and the correct user data structure.
Requesting a non-existent user returns a 404 Not Found status.

Let's write tests for a free, public mock API (https://jsonplaceholder.typicode.com).

Step 1: Setting up the environment

First, install the necessary packages:

pip install pytest requests

Step 2: Writing our first tests

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

import requests
import pytest

BASE_URL = "https://jsonplaceholder.typicode.com"

def test_get_valid_user():
    """
    Test that retrieving an existing user returns a 200 status code
    and the correct data structure.
    """
    user_id = 2
    response = requests.get(f"{BASE_URL}/users/{user_id}")

    # 1. Assert Status Code
    assert response.status_code == 200, f"Expected 200, but got {response.status_code}"

    # 2. Parse JSON response
    response_data = response.json()

    # 3. Assert Data Structure and Content
    assert response_data["id"] == user_id
    assert "email" in response_data
    assert "name" in response_data

def test_get_nonexistent_user():
    """
    Test that retrieving a user that does not exist returns a 404 status code.
    """
    user_id = 9999  # Assuming this user doesn't exist
    response = requests.get(f"{BASE_URL}/users/{user_id}")

    # Assert Status Code
    assert response.status_code == 404, f"Expected 404, but got {response.status_code}"

    # Check that the response is empty as expected by this mock API
    assert response.json() == {}

Step 3: Running the tests

Execute the tests in your terminal using the pytest command:

python -m pytest test_users_api.py -v

Output:

============================= test session starts ==============================
...
test_users_api.py::test_get_valid_user PASSED                            [ 50%]
test_users_api.py::test_get_nonexistent_user PASSED                      [100%]

============================== 2 passed in 0.45s ===============================

Advanced Real-World Practices

While the example above is simple, real-world API testing frameworks incorporate more advanced patterns:

1. Data-Driven Testing with `@pytest.mark.parametrize`

Instead of writing separate functions for every edge case, you can parameterize your tests.

@pytest.mark.parametrize("user_id, expected_status", [
    (1, 200),
    (2, 200),
    (9999, 404)
])
def test_get_users_status(user_id, expected_status):
    response = requests.get(f"{BASE_URL}/users/{user_id}")
    assert response.status_code == expected_status

2. Authentication and Setup with Pytest Fixtures

If your API requires authentication (e.g., Bearer tokens), you shouldn't log in inside every test. Use fixtures to handle setup and teardown.

@pytest.fixture(scope="session")
def api_token():
    # Code to authenticate and get token
    # login_response = requests.post(f"{BASE_URL}/login", json={"email": "...", "password": "..."})
    # return login_response.json()["token"]
    return "mock_token_123"

def test_secure_endpoint(api_token):
    headers = {"Authorization": f"Bearer {api_token}"}
    response = requests.get(f"{BASE_URL}/secure-data", headers=headers)
    # ... assertions

3. Schema Validation

In the real world, APIs evolve. Instead of manually asserting every key in a JSON response, use schema validation libraries like Cerberus or jsonschema to ensure the response payload matches the expected contract.

Conclusion

Building a robust API testing framework is an investment that pays off exponentially as your application grows. By leveraging Python, requests, and the powerful features of pytest like parametrization and fixtures, you can create a test suite that is easy to maintain, highly readable, and perfectly suited for CI/CD pipelines.

Start small, automate your most critical endpoints first, and gradually build out your coverage. Happy testing!

Applying API Testing Frameworks in the Real World: A Practical Guide with Pytest

RODRIGO SIDNEY COLQUE QUISPE — Sat, 27 Jun 2026 14:35:34 +0000

Applying API Testing Frameworks in the Real World: A Practical Guide with Pytest

This is where API testing frameworks come in. In this article, we'll explore how to apply API testing in the real world using Python and Pytest, one of the most popular and powerful testing frameworks available.

Why Do We Need API Testing Frameworks?

Ensure Reliability: Catch breaking changes before they reach production.
Validate Business Logic: Verify that the API returns the correct data for both valid and invalid inputs.
Check Performance and Security: Ensure the API can handle load and is secure against common vulnerabilities.

The Tooling: Python, Pytest, and Requests

For our real-world example, we'll use:

Python: A versatile language widely used for test automation.
Pytest: A mature testing framework that makes writing small tests easy, yet scales to support complex functional testing.
Requests: The elegant and simple HTTP library for Python to make API calls.

Real-World Scenario: Testing a User Management API

Imagine we are building a backend for a social media application. We have an API endpoint to retrieve user profiles. We need to ensure that:

A valid request returns a 200 OK status and the correct user data structure.
Requesting a non-existent user returns a 404 Not Found status.

Let's write tests for a mock API (e.g., https://reqres.in/api/users).

Step 1: Setting up the environment

First, install the necessary packages:

pip install pytest requests

Step 2: Writing our first tests

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

import requests
import pytest

BASE_URL = "https://reqres.in/api"

def test_get_valid_user():
    """
    Test that retrieving an existing user returns a 200 status code
    and the correct data structure.
    """
    user_id = 2
    response = requests.get(f"{BASE_URL}/users/{user_id}")

    # 1. Assert Status Code
    assert response.status_code == 200, f"Expected 200, but got {response.status_code}"

    # 2. Parse JSON response
    response_data = response.json()

    # 3. Assert Data Structure and Content
    assert "data" in response_data
    assert response_data["data"]["id"] == user_id
    assert "email" in response_data["data"]
    assert "first_name" in response_data["data"]

def test_get_nonexistent_user():
    """
    Test that retrieving a user that does not exist returns a 404 status code.
    """
    user_id = 9999  # Assuming this user doesn't exist
    response = requests.get(f"{BASE_URL}/users/{user_id}")

    # Assert Status Code
    assert response.status_code == 404, f"Expected 404, but got {response.status_code}"

    # Check that the response is empty as expected by this mock API
    assert response.json() == {}

Step 3: Running the tests

Execute the tests in your terminal using the pytest command:

pytest test_users_api.py -v

Output:

============================= test session starts ==============================
...
test_users_api.py::test_get_valid_user PASSED                            [ 50%]
test_users_api.py::test_get_nonexistent_user PASSED                      [100%]

============================== 2 passed in 0.45s ===============================

Advanced Real-World Practices

While the example above is simple, real-world API testing frameworks incorporate more advanced patterns:

1. Data-Driven Testing with `@pytest.mark.parametrize`

Instead of writing separate functions for every edge case, you can parameterize your tests.

@pytest.mark.parametrize("user_id, expected_status", [
    (1, 200),
    (2, 200),
    (999, 404)
])
def test_get_users_status(user_id, expected_status):
    response = requests.get(f"{BASE_URL}/users/{user_id}")
    assert response.status_code == expected_status

2. Authentication and Setup with Pytest Fixtures

If your API requires authentication (e.g., Bearer tokens), you shouldn't log in inside every test. Use fixtures to handle setup and teardown.

@pytest.fixture(scope="session")
def api_token():
    # Code to authenticate and get token
    # login_response = requests.post(f"{BASE_URL}/login", json={"email": "...", "password": "..."})
    # return login_response.json()["token"]
    return "mock_token_123"

def test_secure_endpoint(api_token):
    headers = {"Authorization": f"Bearer {api_token}"}
    response = requests.get(f"{BASE_URL}/secure-data", headers=headers)
    # ... assertions

3. Schema Validation

Conclusion

Start small, automate your most critical endpoints first, and gradually build out your coverage. Happy testing!

Applying API Testing Frameworks in the Real World: A Practical Guide with Pytest

RODRIGO SIDNEY COLQUE QUISPE — Sat, 27 Jun 2026 14:35:34 +0000

Applying API Testing Frameworks in the Real World: A Practical Guide with Pytest

Why Do We Need API Testing Frameworks?

Ensure Reliability: Catch breaking changes before they reach production.
Validate Business Logic: Verify that the API returns the correct data for both valid and invalid inputs.
Check Performance and Security: Ensure the API can handle load and is secure against common vulnerabilities.

The Tooling: Python, Pytest, and Requests

For our real-world example, we'll use:

Python: A versatile language widely used for test automation.
Pytest: A mature testing framework that makes writing small tests easy, yet scales to support complex functional testing.
Requests: The elegant and simple HTTP library for Python to make API calls.

Real-World Scenario: Testing a User Management API

Imagine we are building a backend for a social media application. We have an API endpoint to retrieve user profiles. We need to ensure that:

A valid request returns a 200 OK status and the correct user data structure.
Requesting a non-existent user returns a 404 Not Found status.

Let's write tests for a mock API (e.g., https://reqres.in/api/users).

Step 1: Setting up the environment

First, install the necessary packages:

pip install pytest requests

Step 2: Writing our first tests

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

import requests
import pytest

BASE_URL = "https://reqres.in/api"

def test_get_valid_user():
    """
    Test that retrieving an existing user returns a 200 status code
    and the correct data structure.
    """
    user_id = 2
    response = requests.get(f"{BASE_URL}/users/{user_id}")

    # 1. Assert Status Code
    assert response.status_code == 200, f"Expected 200, but got {response.status_code}"

    # 2. Parse JSON response
    response_data = response.json()

    # 3. Assert Data Structure and Content
    assert "data" in response_data
    assert response_data["data"]["id"] == user_id
    assert "email" in response_data["data"]
    assert "first_name" in response_data["data"]

def test_get_nonexistent_user():
    """
    Test that retrieving a user that does not exist returns a 404 status code.
    """
    user_id = 9999  # Assuming this user doesn't exist
    response = requests.get(f"{BASE_URL}/users/{user_id}")

    # Assert Status Code
    assert response.status_code == 404, f"Expected 404, but got {response.status_code}"

    # Check that the response is empty as expected by this mock API
    assert response.json() == {}

Step 3: Running the tests

Execute the tests in your terminal using the pytest command:

pytest test_users_api.py -v

Output:

============================= test session starts ==============================
...
test_users_api.py::test_get_valid_user PASSED                            [ 50%]
test_users_api.py::test_get_nonexistent_user PASSED                      [100%]

============================== 2 passed in 0.45s ===============================

Advanced Real-World Practices

While the example above is simple, real-world API testing frameworks incorporate more advanced patterns:

1. Data-Driven Testing with `@pytest.mark.parametrize`

Instead of writing separate functions for every edge case, you can parameterize your tests.

@pytest.mark.parametrize("user_id, expected_status", [
    (1, 200),
    (2, 200),
    (999, 404)
])
def test_get_users_status(user_id, expected_status):
    response = requests.get(f"{BASE_URL}/users/{user_id}")
    assert response.status_code == expected_status

2. Authentication and Setup with Pytest Fixtures

If your API requires authentication (e.g., Bearer tokens), you shouldn't log in inside every test. Use fixtures to handle setup and teardown.

@pytest.fixture(scope="session")
def api_token():
    # Code to authenticate and get token
    # login_response = requests.post(f"{BASE_URL}/login", json={"email": "...", "password": "..."})
    # return login_response.json()["token"]
    return "mock_token_123"

def test_secure_endpoint(api_token):
    headers = {"Authorization": f"Bearer {api_token}"}
    response = requests.get(f"{BASE_URL}/secure-data", headers=headers)
    # ... assertions

3. Schema Validation

Conclusion

Start small, automate your most critical endpoints first, and gradually build out your coverage. Happy testing!

Breaking the SQL Barrier: How to Build a Natural Language Database Assistant

RODRIGO SIDNEY COLQUE QUISPE — Sat, 27 Jun 2026 04:45:15 +0000

Tags: #DataEngineering #AI #Python #HuggingFace #Streamlit

For decades, SQL has been the universal language for extracting insights from databases. But there's a catch: it creates a bottleneck. Business analysts, product managers, and marketers often have to wait for data teams to write queries for them.

What if we could skip the code and just talk to our databases in plain English?

Thanks to the rapid advancements in Artificial Intelligence and Large Language Models (LLMs), this is now entirely possible. Today, I'll walk you through how I built a Text-to-SQL assistant using Python, and how you can do it too.

What is Text-to-SQL?

At its core, Text-to-SQL is an AI capability that translates conversational questions into executable SQL code. Imagine typing, "Show me all employees in the Sales department earning over 50k" and having the AI instantly generate:

SELECT * FROM employees WHERE Department = 'Sales' AND Salary > 50000;

It’s like having a senior data engineer at your fingertips 24/7.

The Tech Stack

To keep things simple and accessible, I chose a modern, lightweight stack for this project:

Hugging Face: To power the AI model (we're using t5-base-finetuned-wikiSQL).
Streamlit: To quickly build a clean, interactive user interface.
SQLite & Pandas: To handle our local mock data.

How It Works Under the Hood

1. The Brains (Hugging Face API)

Instead of training a model from scratch, we leverage Hugging Face's Inference API. By sending an HTTP request with our user's question, the API returns the translated SQL query. It's incredibly fast and requires very little code:

import requests

API_URL = "https://api-inference.huggingface.co/models/mrm8488/t5-base-finetuned-wikiSQL"

def get_sql_from_text(user_query):
    payload = {"inputs": f"translate English to SQL: {user_query}"}
    response = requests.post(API_URL, json=payload)
    return response.json()[0]['generated_text']

2. The Data Layer

For demonstration purposes, the app initializes an in-memory SQLite database loaded with some dummy employee records. This allows the app to actually execute the AI-generated SQL and prove that it works, rather than just showing the query on the screen.

3. Putting it together with Streamlit

Streamlit ties everything beautifully. We capture the user's input through a text box. When they hit "Generate", the app fetches the SQL from Hugging Face, executes it against our SQLite database using pandas.read_sql_query, and renders the final dataset directly in the browser.

Why This Matters

Tools like this represent a massive shift in data democratization. When you remove the technical barrier of SQL, you empower everyone in an organization to be data-driven, speeding up decision-making across the board.

Want to see the code in action or try running it yourself?
I've made the entire project open-source. Check out my repository here:
👉 https://github.com/FabricioRams/Research-Team-Work-N-01-SQL-AI-Database-Solutions.git

(Note: Just install the requirements and run streamlit run app.py to start chatting with your data!)

Under the Hood: How Bandit SAST Analyzes Your Python Code

RODRIGO SIDNEY COLQUE QUISPE — Tue, 21 Apr 2026 16:10:54 +0000

Abstract
While many developers use security scanners, few understand how they actually "read" code. This article explains the inner workings of Bandit, focusing on its use of the Abstract Syntax Tree (AST) to identify security patterns without ever executing a single line of code.

1. The Core Engine: AST (Abstract Syntax Tree)
Unlike a simple text search (which might give many false positives), Bandit doesn't just look for words like "password". It converts your Python code into an AST.

What is AST? It is a tree representation of the abstract syntactic structure of your source code.

Why it matters: By building a tree, Bandit understands the context. It knows if a string is just a comment or if it's actually being assigned to a sensitive variable or passed to a dangerous function like eval().

2. How the "Scanning" Happens
Bandit works through a set of plugins. Each plugin is designed to look for a specific type of vulnerability:
Blacklist Plugins: These look for the use of insecure modules (like pickle or telnetlib).
Function Call Plugins: These trigger when they see dangerous calls (like subprocess.shell=True).
Hardcoded Secret Plugins: These use heuristics to identify strings that look like passwords or API keys.

3. Severity and Confidence levels
One of Bandit's best features is its scoring system:
Severity: How bad is the bug? (Low, Medium, High).
Confidence: How sure is Bandit that this is actually a bug and not a mistake?

Why use it in the CI/CD?
The main advantage is speed. Because it doesn't need to compile or run the code, it can scan thousands of lines in seconds. Integrating it into GitHub Actions (as shown in my previous post) ensures that no "illegal" AST patterns make it into the main branch.

Conclusion
Bandit isn't just a linter; it's a security-focused parser. By understanding the structure of Python, it provides a robust first line of defense for any backend developer.

Implementing SAST in Your Infrastructure: Detecting Vulnerabilities with Checkov and GitHub Actions

RODRIGO SIDNEY COLQUE QUISPE — Tue, 21 Apr 2026 03:50:44 +0000

Abstract
This article explores the implementation of Static Application Security Testing (SAST) for Infrastructure as Code (IaC) using Checkov. We demonstrate how to identify common security misconfigurations, such as publicly accessible S3 buckets, and seamlessly integrate the scanning process into a CI/CD pipeline using GitHub Actions.

What is Checkov?
Checkov is an open-source static analysis tool (maintained by Bridgecrew / Prisma Cloud) designed specifically for Infrastructure as Code.

Unlike tools aimed at application code (like Bandit for Python), Checkov scans configuration files for misconfigurations that could lead to security vulnerabilities or compliance issues.

Why use Checkov?

Built-in policies: It comes with hundreds of out-of-the-box policies covering AWS, Azure, and GCP best practices.
Multi-framework: Supports Terraform, CloudFormation, Kubernetes, Dockerfiles, Serverless, and more.
Easy integration: Runs from the command line or directly in your CI/CD pipelines.

The Scenario: Vulnerable Infrastructure

Imagine you have a Terraform file (main.tf) where you define an S3 bucket. By mistake (or for a quick test), you configure it to have public read access:

# main.tf resource "aws_s3_bucket" "my_vulnerable_bucket" { bucket = "my-dev-test-bucket" acl = "public-read" # ❌ Security risk! }

If we deploy this, anyone on the internet could access our data. Let's make our repository catch this error before it gets merged into the main branch.

Automating with GitHub Actions
The real magic happens when we integrate Checkov into our CI/CD workflow. This way, every time someone pushes code or opens a Pull Request, Checkov will analyze the infrastructure automatically.

In your repository, create a file at .github/workflows/checkov.yml and add the following:

What exactly does this workflow do?

1. Checkout: Clones your code into the GitHub Actions virtual environment.
2. Run Checkov: Uses the official Bridgecrew action. The directory: . parameter tells it to look for infrastructure files throughout the repository.
3. soft_fail: false: This is the key to DevSecOps. If Checkov finds a failing policy (like our public bucket), the pipeline will fail, preventing vulnerable code from being integrated.

Conclusion
Shifting security to the left (Shift-Left Security) by implementing SAST in your Infrastructure as Code is no longer optional. With tools like Checkov and GitHub Actions, it's a fast and highly effective process. With just a few lines of code, you can ensure your team doesn't accidentally deploy insecure configurations.

DEV Community: RODRIGO SIDNEY COLQUE QUISPE

Testing Management Tools: A Comparative Guide and Real-World Reporting

Testing Management Tools: A Comparative Guide and Real-World Reporting

1. TestRail

2. Zephyr Scale (formerly TM4J)

3. Pytest-HTML / Local Reporting Tools

Real-World Code Example: Generating a Test Dashboard Locally

The Code

Execution and Dashboard Generation

Applying API Testing Frameworks in the Real World: A Practical Guide with Pytest

Why Do We Need API Testing Frameworks?

The Tooling: Python, Pytest, and Requests

Real-World Scenario: Testing a User Management API

Step 1: Setting up the environment

Step 2: Writing our first tests

Step 3: Running the tests

Advanced Real-World Practices

1. Data-Driven Testing with @pytest.mark.parametrize

2. Authentication and Setup with Pytest Fixtures

3. Schema Validation

Conclusion

Applying API Testing Frameworks in the Real World: A Practical Guide with Pytest

Applying API Testing Frameworks in the Real World: A Practical Guide with Pytest

Why Do We Need API Testing Frameworks?

The Tooling: Python, Pytest, and Requests

Real-World Scenario: Testing a User Management API

Step 1: Setting up the environment

Step 2: Writing our first tests

Step 3: Running the tests

Advanced Real-World Practices

1. Data-Driven Testing with @pytest.mark.parametrize

2. Authentication and Setup with Pytest Fixtures

3. Schema Validation

Conclusion

Applying API Testing Frameworks in the Real World: A Practical Guide with Pytest

Applying API Testing Frameworks in the Real World: A Practical Guide with Pytest

Why Do We Need API Testing Frameworks?

The Tooling: Python, Pytest, and Requests

Real-World Scenario: Testing a User Management API

Step 1: Setting up the environment

Step 2: Writing our first tests

Step 3: Running the tests

Advanced Real-World Practices

1. Data-Driven Testing with @pytest.mark.parametrize

2. Authentication and Setup with Pytest Fixtures

3. Schema Validation

Conclusion

Breaking the SQL Barrier: How to Build a Natural Language Database Assistant

What is Text-to-SQL?

The Tech Stack

How It Works Under the Hood

1. The Brains (Hugging Face API)

2. The Data Layer

3. Putting it together with Streamlit

Why This Matters

Under the Hood: How Bandit SAST Analyzes Your Python Code

Implementing SAST in Your Infrastructure: Detecting Vulnerabilities with Checkov and GitHub Actions

1. Data-Driven Testing with `@pytest.mark.parametrize`

1. Data-Driven Testing with `@pytest.mark.parametrize`

1. Data-Driven Testing with `@pytest.mark.parametrize`