DEV Community: Ujjwal Kumar Singh

Python for Testers : Validating a JSON API Response Without Any Framework

Ujjwal Kumar Singh — Tue, 21 Jul 2026 16:27:25 +0000

Most Testers validate API responses inside a test framework. But do we know how to do it with just Python?

Scenario: Our API returns a JSON response after creating a user. We need to verify the status, the message, and the user details are exactly what we expected.

Here is the JSON response:

*JSON data:
*

{
    "status": "success",
    "message": "User created",
    "user": {
        "id": 101,
        "name": "Ujjwal"
    }
}

Here is the Python validation:

*Python code:
*

import json

with open("data.json", "r") as file:
    data = json.load(file)

    if data["status"] == "success" and data["user"]["name"] == "Ujjwal" and data["user"]["id"] == 101:
        print("Validation Passed")
    else:
        print("Validation Failed")

Output:

Validation Passed

****Why this matters as a Tester:

Before we reach for requests or pytest, understanding how Python reads and validates JSON at the base level makes us a sharper tester. Every API assertion we write in a framework is doing exactly this under the hood.

Knowing the foundation makes us better at debugging when the framework gives us a result we did not expect.

GitHub: https://github.com/beinghumantester/Fundamental-Coding-Programs

Python for Testers: Finding Unique Status Values from an API Response String

Ujjwal Kumar Singh — Mon, 20 Jul 2026 17:47:42 +0000

Ever got a concatenated API response string and needed to know what unique status values were present?

Scenario: our API returns a long string of status codes like "Automation and Python" and we need to extract every unique status that appeared, in the order it first showed up.

Here is the Python code:

api_response = "Automation and Python"
api_response = api_response.lower().replace(" ", "")

seen = ""
for ch in api_response:
    if ch not in seen:
        print(ch)
        seen = seen + ch

No library. No regex. Just Python iterating through the string and tracking what it has already seen.

Why this matters as a Tester:

Not every API response comes in a clean, structured format. Sometimes you are dealing with concatenated strings, log outputs, or raw response bodies. Knowing how to extract unique values from messy string data is a practical skill that shows up more often than we would expect in real test automation work.

Today’s Python Challenge for Testers: Deduplicating API Response Values Before Assertion

Ujjwal Kumar Singh — Sun, 19 Jul 2026 06:24:33 +0000

Have we ever received an API response with duplicate values and our assertion failed, not because the data was wrong, but because duplicates were messing up our comparison?

Scenario: our API returns a list of user IDs, but some IDs appear more than once. Before we assert, we need a clean, unique list.

Here is the Python code :

response_data = [1, 2, 3, 4, 5, 2, 7, 8, 9]
unique_values = []

for data in response_data:
    if data not in unique_values:
        unique_values.append(data)

print(unique_values)

Output:

[1, 2, 3, 4, 5, 7, 8, 9]

Duplicate data is removed. Now our assertion runs against clean data.

Why this matters as a Tester:

Asserting against raw API responses without cleaning the data first is a common source of false failures. Understanding how deduplication works at the code level makes us a better judge of when to clean data and when the duplicate itself is the bug.

Github Repo Link

Python for SDETs: Comparing Two API Response Arrays

Ujjwal Kumar Singh — Sat, 18 Jul 2026 15:42:03 +0000

Ever got two API responses and needed to know what matched?
Classic scenario — your API returns a list of user IDs. Your expected list has what should be there. You need to know what actually matched and how many.
Here is the Python pattern I use:

expected = [10, 12, 14, 15, 16, 28]
actual = [13, 14, 16, 17]
matched = []
count = 0
for i in expected:
    for j in actual:
        if i == j:
            count += 1
            matched.append(i)

print("Number of matching elements:", count)

print(matched)

*Output *
Number of matching elements: 2
[14, 16]

Two values matched. Everything else is either missing or unexpected, both of which are bugs worth reporting.

Weekly Challenge-3: Building an AI-Powered Open Source Contribution Assistant with n8n

Ujjwal Kumar Singh — Mon, 22 Jun 2026 01:45:02 +0000

Introduction
One challenge in open source is not the lack of opportunities, it’s deciding which opportunity to work on next.

Many repositories have hundreds of open issues. Some are beginner-friendly, some require deep project knowledge, and others may no longer be relevant. As contributors, we often spend a significant amount of time reviewing issues before making a contribution.

To explore how automation could help, I built an AI-powered contribution assistant using n8n.

The goal was to automatically collect issues, evaluate them against predefined criteria, prioritize them, and generate a daily contribution digest.

The Problem
When reviewing open source repositories, contributors often face questions such as:

Which issue matches my current skill set?
Which issue can be worked on within the time I have available?
Which issue provides the best learning opportunity?
Which issue has a high probability of resulting in a merged contribution?
Which issue should I start with today?

Answering these questions manually across multiple repositories can become time-consuming.

The Solution
The workflow automates issue discovery and prioritization.

It:

Retrieves open issues from GitHub repositories
Filters out pull requests
Collects issue metadata
Uses an LLM to analyze and rank opportunities
Generates a daily digest
Stores recommendations in Notion for future tracking

The objective is not to replace contributor judgment, but to reduce the effort required to identify promising contribution opportunities.

Workflow Overview
The workflow consists of four major stages:

1. Issue Collection
Issues are fetched from GitHub repositories.

Relevant information is extracted, including:

Labels
Comment count
Last update time
Repository source

2. Issue Evaluation
An LLM evaluates issues against predefined criteria such as:

Technology relevance
Documentation relevance
Learning value
Expected effort
Probability of successful contribution

3. Recommendation Generation
The workflow generates:

Top contribution opportunities
Quick wins
Learning-focused opportunities
A recommended issue to start with

4. Knowledge Management
Recommendations are stored in Notion and delivered via email.

This creates a searchable backlog instead of requiring contributors to revisit repositories repeatedly.

Benefits
Reduced Decision Fatigue
Contributors spend less time searching and more time contributing.

Consistent Engagement
A daily recommendation can encourage regular participation in open source projects.

Personalized Prioritization
Different contributors value different things. The ranking criteria can be adjusted based on individual goals.

Better Visibility
Storing recommendations in Notion makes it easier to track contribution opportunities over time.

Challenges Encountered

Building the workflow surfaced several practical challenges:
Prompt design significantly impacted recommendation quality.
Structured JSON outputs were necessary for reliable automation.
Notion schema mismatches caused workflow failures.
LLM-generated outputs required validation before downstream processing.
Integration testing took considerably longer than expected.

The workflow itself was relatively straightforward. Making the components work reliably together required the most effort.

Possible Improvements
The current workflow works well as a personal assistant, but there are several areas for improvement.

Historical Tracking
Track previously recommended issues and avoid recommending the same issue repeatedly.

Contribution Feedback Loop
Record completed contributions and use that information to improve future recommendations.

Skill-Based Profiles
Allow contributors to define profiles such as:

Documentation Contributor
Automation Engineer
Backend Developer
Frontend Developer

and generate recommendations accordingly.

Multi-Repository Support
Expand beyond a single ecosystem and evaluate opportunities across multiple projects.

**Effort Estimation
**Use issue history and metadata to estimate actual effort more accurately.

Duplicate Detection
Avoid recommending issues that are very similar or represent the same underlying work.

Weekly and Monthly Reports
Generate summaries that show:

Issues reviewed
Contributions completed
Skills explored
Areas of growth

Key Takeaway
The most interesting lesson from this experiment was that the bottleneck was not finding open source work, it was selecting the right work.

Automating issue discovery and prioritization helped transform a large list of open issues into a smaller set of actionable recommendations.

While the workflow is still evolving, it demonstrates how automation and AI can be used to reduce overhead and help contributors spend more time learning, building, and contributing.

Github Repo Link