DEV Community: Christian Dennis HINOJOSA MUCHO

🔧 Comparative Analysis of Testing Management Tools with Real CI/CD Pipelines

Christian Dennis HINOJOSA MUCHO — Wed, 03 Dec 2025 18:16:03 +0000

Automated testing has become a core practice in modern software development.

Today, testing doesn’t just happen on a local machine—it is integrated directly into Continuous Integration (CI/CD) pipelines, ensuring every code change is validated before reaching production.

In this article, we explore and compare three widely used testing management tools within CI/CD environments: GitHub Actions, GitLab CI/CD, and Jenkins.

Each one includes a real-world pipeline example so you can understand how test automation works in practice.

💡 Why Testing in CI/CD Matters

Automated test executions help teams:

Prevent bugs before merging code
Detect regressions quickly
Standardize test execution across environments
Improve software reliability and delivery speed
Reduce manual testing overhead

Today’s development workflows expect speed and consistency—CI/CD testing delivers both.

🧩 Tools Overview

🟦 GitHub Actions

A cloud-based automation platform built into GitHub.

It uses YAML workflows and triggers on events like push, merge, or pull_request.

🟥 GitLab CI/CD

A complete DevOps platform where CI/CD is deeply integrated.

It uses “runners” to execute jobs and supports built-in testing, security scans, and deployment pipelines.

🟩 Jenkins

An open-source automation server used for customizable pipelines.

Requires installation and configuration but offers massive flexibility.

🌍 Example Scenario

To compare the tools fairly, we use the same simple case:

👉 Run test scripts automatically after every push.

We assume the project uses a test command such as:

npm test -- --coverage

🔧 Real CI/CD Pipelines

🟦 1. GitHub Actions Pipeline

Create a file:

.github/workflows/ci.yml

Add:

name: Run Automated Tests

on:
  push:
    branches: [ "main" ]

jobs:
  test:
    runs-on: ubuntu-latest

    steps:
      - name: Checkout repo
        uses: actions/checkout@v3

      - name: Install packages
        run: npm install

      - name: Run unit tests
        run: npm test -- --coverage

      - name: Upload coverage results
        uses: actions/upload-artifact@v4
        with:
          name: coverage
          path: coverage/

🟥 2. GitLab CI/CD Pipeline

Create:

.gitlab-ci.yml

Add:

stages:
  - test

unit_tests:
  stage: test
  script:
    - npm install
    - npm test -- --coverage
  artifacts:
    paths:
      - coverage/

🟩 3. Jenkins Pipeline (Jenkinsfile)

Create:

Jenkinsfile

Add:

pipeline {
    agent any

    stages {

        stage('Install') {
            steps {
                sh 'npm install'
            }
        }

        stage('Run Tests') {
            steps {
                sh 'npm test -- --coverage'
            }
        }

        stage('Archive Coverage') {
            steps {
                archiveArtifacts artifacts: 'coverage/**'
            }
        }
    }
}

📊 Quick Comparison

Feature	GitHub Actions	GitLab CI/CD	Jenkins
Hosting	Cloud	Cloud + Self-host	Self-host
Language	YAML	YAML	Groovy
Difficulty	Easy	Medium	Advanced
Integration	GitHub	GitLab	Universal
Test Artifacts	Yes	Yes	Yes
Scalability	High	High	Very High

📁 Public Example Repository

Example structure:

/src
/tests
.github/workflows/ci.yml
.gitlab-ci.yml
Jenkinsfile
README.md

You can publish it as:

https://github.com/dennisdhm7/ci-testing-demo

🧩 Key Takeaways

GitHub Actions is the easiest for cloud-native projects.
GitLab CI/CD provides an all-in-one DevOps solution.
Jenkins offers powerful customization for enterprise environments.
All three support automated testing inside CI/CD pipelines.

Automating tests ensures consistent, reliable, and high-quality software delivery.

📺 Video: Testing Management Tools Guide
📦 View GitHub Repository

✍️ Author

Christian Dennis Hinojosa Mucho

Systems Engineering student — UPT

Applying API Testing Frameworks with Postman: Real-World Code Examples

Christian Dennis HINOJOSA MUCHO — Wed, 03 Dec 2025 18:15:24 +0000

🧪 API Testing with Postman and Newman

Testing APIs has become an essential part of modern software development.

Before connecting the backend with the user interface, we need to make sure every endpoint behaves as expected — returning the correct data, handling errors properly, and performing under different conditions.

In this guide, we’ll explore how to apply Postman and Newman to automate API testing through a simple and realistic example.

💡 Understanding the Purpose

APIs are like bridges between different systems.

When one part of an app sends a request, the API is responsible for sending the correct response back.

If something fails here, the entire application can break.

API testing ensures that:

Each endpoint returns the right HTTP status code.
The JSON data structure is consistent.
Response times stay within acceptable limits.
Security tokens and authentication mechanisms work as intended.

⚙️ Tools Overview

🧩 Postman

A graphical tool that lets you design, test, and document APIs easily.

You can manually send requests or create automated test scripts.

🧭 Newman

A command-line companion for Postman.

It allows developers to run Postman collections automatically, which is ideal for continuous integration (CI/CD) pipelines.

🌍 Example Scenario

Let’s work with a public REST API called JSONPlaceholder, commonly used for learning and testing.

Endpoint to test:

GET https://jsonplaceholder.typicode.com/users/1

This API returns user information.

We’ll create tests to verify that:

The request is successful.
The response contains valid user data.
The user ID matches the expected value.

🧪 Writing Tests in Postman

Once you create the request in Postman, go to the Tests tab and paste this script:

// Check if response is OK
pm.test("Status code should be 200", () => {
  pm.response.to.have.status(200);
});

// Validate JSON response structure
pm.test("Response contains user details", () => {
  const data = pm.response.json();
  pm.expect(data).to.have.property("id");
  pm.expect(data).to.have.property("name");
  pm.expect(data).to.have.property("email");
});

// Check that the correct user is returned
pm.test("User ID matches expected value", () => {
  const data = pm.response.json();
  pm.expect(data.id).to.eql(1);
});

After sending the request, you’ll see green checkmarks ✅ in the test results panel, confirming that all validations passed.

🧭 Running Tests Automatically with Newman

Once your collection is ready, export it from Postman:

File → Export → Collection → JSON file

Now open your terminal and run:

newman run MyCollection.json

Newman will execute every test automatically and display detailed output directly in the console:

→ GET https://jsonplaceholder.typicode.com/users/1
  ✓ Status code should be 200
  ✓ Response contains user details
  ✓ User ID matches expected value
---------------------------------------------------
Total tests: 3 | Passed: 3 | Failed: 0

This workflow helps teams include API testing in their deployment pipelines — for example with GitHub Actions, Jenkins, or Azure DevOps.

📈 Test Output Example

When all tests pass successfully, you might see something like this:

Collection run complete.
✔ 3 tests passed.
0 tests failed.
Average response time: 410ms

If something goes wrong, Newman highlights the failed test and shows the expected vs actual values.

🧩 Key Takeaways

Postman makes it easy to design and execute API tests visually.
Newman adds automation and integration capabilities for professional workflows.
Using both together allows you to:
- Detect bugs early before integration.
- Maintain consistent API behavior across environments.
- Automate test runs after each deployment.

By including API testing as part of the development process, you build more reliable, stable, and maintainable systems.

📚 References

✍️ Author

Christian Dennis Hinojosa Mucho

Research Team Work Nº 02 – API Testing Frameworks Comparative

Applying API Testing Frameworks with Postman: Real-World Code Examples

Christian Dennis HINOJOSA MUCHO — Sat, 08 Nov 2025 13:47:06 +0000

🧪 API Testing with Postman and Newman

In this guide, we’ll explore how to apply Postman and Newman to automate API testing through a simple and realistic example.

💡 Understanding the Purpose

API testing ensures that:

Each endpoint returns the right HTTP status code.
The JSON data structure is consistent.
Response times stay within acceptable limits.
Security tokens and authentication mechanisms work as intended.

⚙️ Tools Overview

🧩 Postman

A graphical tool that lets you design, test, and document APIs easily.

You can manually send requests or create automated test scripts.

🧭 Newman

A command-line companion for Postman.

It allows developers to run Postman collections automatically, which is ideal for continuous integration (CI/CD) pipelines.

🌍 Example Scenario

Let’s work with a public REST API called JSONPlaceholder, commonly used for learning and testing.

Endpoint to test:

GET https://jsonplaceholder.typicode.com/users/1

This API returns user information.

We’ll create tests to verify that:

The request is successful.
The response contains valid user data.
The user ID matches the expected value.

🧪 Writing Tests in Postman

Once you create the request in Postman, go to the Tests tab and paste this script:

// Check if response is OK
pm.test("Status code should be 200", () => {
  pm.response.to.have.status(200);
});

// Validate JSON response structure
pm.test("Response contains user details", () => {
  const data = pm.response.json();
  pm.expect(data).to.have.property("id");
  pm.expect(data).to.have.property("name");
  pm.expect(data).to.have.property("email");
});

// Check that the correct user is returned
pm.test("User ID matches expected value", () => {
  const data = pm.response.json();
  pm.expect(data.id).to.eql(1);
});

After sending the request, you’ll see green checkmarks ✅ in the test results panel, confirming that all validations passed.

🧭 Running Tests Automatically with Newman

Once your collection is ready, export it from Postman:

File → Export → Collection → JSON file

Now open your terminal and run:

newman run MyCollection.json

Newman will execute every test automatically and display detailed output directly in the console:

→ GET https://jsonplaceholder.typicode.com/users/1
  ✓ Status code should be 200
  ✓ Response contains user details
  ✓ User ID matches expected value
---------------------------------------------------
Total tests: 3 | Passed: 3 | Failed: 0

This workflow helps teams include API testing in their deployment pipelines — for example with GitHub Actions, Jenkins, or Azure DevOps.

📈 Test Output Example

When all tests pass successfully, you might see something like this:

Collection run complete.
✔ 3 tests passed.
0 tests failed.
Average response time: 410ms

If something goes wrong, Newman highlights the failed test and shows the expected vs actual values.

🧩 Key Takeaways

Postman makes it easy to design and execute API tests visually.
Newman adds automation and integration capabilities for professional workflows.
Using both together allows you to:
- Detect bugs early before integration.
- Maintain consistent API behavior across environments.
- Automate test runs after each deployment.

By including API testing as part of the development process, you build more reliable, stable, and maintainable systems.

📚 References

✍️ Author

Christian Dennis Hinojosa Mucho

# 🌐 Deploying a Remote MCP Server with Python and FastAPI

Christian Dennis HINOJOSA MUCHO — Fri, 04 Jul 2025 17:13:22 +0000

A step-by-step guide to creating a remote MCP (Message Control Protocol) server using Python and FastAPI, and deploying it online with Render.

🚀 Introduction

In the era of cloud-native applications, real-time data processing, and automation, message-driven architectures are increasingly essential. MCP (Message Control Protocol) servers act as intermediaries that listen for client messages, process them, and return responses in real time.

In this article, you’ll learn how to build and deploy a remote MCP Server using Python and FastAPI. Unlike local implementations, this solution is cloud-hosted, accessible from anywhere via a public URL, and serves as a foundation for integrating smart clients, bots, or automations.

📦 What is an MCP Server?

An MCP Server is a lightweight message-processing backend that listens for structured messages—usually over HTTP—and responds based on predefined rules or logic. MCP Servers are especially useful when:

You want to allow remote systems or users to trigger actions or computations.
You need a controlled interface for communication between components.
You're building a system where message acknowledgment or feedback is important.

In Business Intelligence (BI), an MCP server could be used to:

Trigger scheduled data processing from external systems.
Receive natural language inputs from chatbots and pass them to AI agents.
Integrate dashboards and pipelines with real-time control endpoints.

🛠️ Requirements

Before you start, ensure you have the following:

Python 3.7 or newer
A GitHub account (for code hosting)
A Render.com (or Railway) account for deployment
Basic understanding of HTTP, JSON, and API interactions

🧑‍💻 Step 1: Create the FastAPI MCP Server

Create a file named main.py with the following content:

from fastapi import FastAPI
from pydantic import BaseModel

app = FastAPI()

class Message(BaseModel):
    content: str

@app.post("/mcp")
async def handle_message(msg: Message):
    print(f"Received message: {msg.content}")
    return {"response": "Hello from the remote MCP Server!"}

This server:

Accepts POST requests at /mcp
Receives a JSON body with a "content" key
Prints the message to the server logs
Sends back a structured JSON response

This architecture is perfect for lightweight remote commands.

📦 Step 2: Add Requirements

Create a requirements.txt file with the dependencies for deployment:

fastapi
uvicorn

These packages are essential:

FastAPI: for creating modern async APIs in Python.
Uvicorn: an ASGI server to run FastAPI apps in production or locally.

🧪 Step 3: Test Locally (Optional but Recommended)

To make sure everything works before going live:

pip install -r requirements.txt
uvicorn main:app --reload

Visit: http://localhost:8000/docs

FastAPI automatically generates interactive API docs using Swagger UI. You can test your /mcp endpoint directly from there by sending a JSON like:

{
  "content": "Hello, MCP Server"
}

The server will return:

{
  "response": "Hello from the remote MCP Server!"
}

☁️ Step 4: Deploy to Render

Now, let’s make your MCP Server publicly accessible.

✅ Steps:

Push to GitHub

Create a new repository and upload your files (main.py, requirements.txt, and optionally README.md).
Log in to Render.com

Create a new Web Service and connect your GitHub account.
Deployment Settings:
- Build Command:
```
 pip install -r requirements.txt
```

Start Command:

 uvicorn main:app --host 0.0.0.0 --port 10000

Port: 10000

Click "Deploy" and wait for the build to finish.

After deploying, Render will assign a public URL like:

https://mcp-remote-example.onrender.com

You can now access your Swagger docs at:

https://mcp-remote-example.onrender.com/docs

And test it just like you did locally—only now it works from anywhere!

💡 Why Use MCP in Business Intelligence?

MCP Servers become highly useful in a modern BI pipeline when:

You want external clients or apps to trigger data ingestion or processing remotely.
You build automation workflows that respond to user input, chatbot messages, or API events.
You create a control endpoint to update dashboards, refresh models, or notify downstream tools.

Because MCP Servers are lightweight, stateless, and decoupled, they are ideal for microservice environments and rapid experimentation.

📚 References

✍️ Written by Christian Dennis Hinojosa Mucho

🔗 GitHub Repository: https://github.com/dennisdhm7/mcp_u3

Build and Deploy an Interactive Sales Dashboard with Streamlit

Christian Dennis HINOJOSA MUCHO — Tue, 29 Apr 2025 14:38:53 +0000

💡 Why Streamlit?

Streamlit is a powerful open-source Python library that turns data scripts into shareable web apps in minutes. It is perfect for data science and machine learning projects.

🚀 Features of This Project

Display data in table format
Create a line chart for monthly sales
Deploy the dashboard to the web with zero configuration

🧱 Prerequisites

Basic knowledge of Python
streamlit, pandas, and matplotlib installed (pip install streamlit pandas matplotlib)
A GitHub account
A Streamlit Cloud account

🧑‍💻 Full Code (`app.py`)

import streamlit as st
import pandas as pd
import matplotlib.pyplot as plt

# Title
st.title("Sales Dashboard")

# Sample Data
data = {
    "Month": ["Jan", "Feb", "Mar", "Apr", "May"],
    "Sales": [1500, 1800, 2400, 3000, 2800]
}
df = pd.DataFrame(data)

# Show table
st.subheader("Sales Data")
st.dataframe(df)

# Line chart
st.subheader("Sales Line Chart")
plt.plot(df["Month"], df["Sales"], marker='o')
plt.xlabel("Month")
plt.ylabel("Sales")
plt.grid(True)
st.pyplot(plt)

Explanation:

st.title, st.subheader, and st.dataframe are used to structure the page layout.
matplotlib.pyplot is used to generate the line chart.
st.pyplot directly displays the Matplotlib figure inside the Streamlit app.

🌎 How to Deploy to the Cloud

Push your app.py file to a GitHub repository.
Create a free account on Streamlit Cloud.
Click on New App and connect your GitHub repository.
Select your branch and main file (app.py).
Click Deploy.

🚀 Your app will be instantly live and ready to share!

📝 Conclusion

Streamlit makes it incredibly easy for Python developers to build beautiful, interactive dashboards and professional reports.

Whether you are creating a quick data visualization prototype or a full business intelligence solution, Streamlit offers the flexibility and speed to bring your ideas to life.

If you are looking to transform your data into powerful web applications with minimal effort, Streamlit is definitely a tool worth exploring!

The source code and the automated deployment workflow for Streamlit Cloud can be found here:

👉 https://github.com/dennisdhm7/Streamlit.git

DEV Community: Christian Dennis HINOJOSA MUCHO

🔧 Comparative Analysis of Testing Management Tools with Real CI/CD Pipelines

💡 Why Testing in CI/CD Matters

🧩 Tools Overview

🟦 GitHub Actions

🟥 GitLab CI/CD

🟩 Jenkins

🌍 Example Scenario

🔧 Real CI/CD Pipelines

🟦 1. GitHub Actions Pipeline

🟥 2. GitLab CI/CD Pipeline

🟩 3. Jenkins Pipeline (Jenkinsfile)

📊 Quick Comparison

📁 Public Example Repository

🧩 Key Takeaways

✍️ Author

Applying API Testing Frameworks with Postman: Real-World Code Examples

🧪 API Testing with Postman and Newman

💡 Understanding the Purpose

⚙️ Tools Overview

🧩 Postman

🧭 Newman

🌍 Example Scenario

🧪 Writing Tests in Postman

🧭 Running Tests Automatically with Newman

📈 Test Output Example

🧩 Key Takeaways

📚 References

✍️ Author

Applying API Testing Frameworks with Postman: Real-World Code Examples

🧪 API Testing with Postman and Newman

💡 Understanding the Purpose

⚙️ Tools Overview

🧩 Postman

🧭 Newman

🌍 Example Scenario

🧪 Writing Tests in Postman

🧭 Running Tests Automatically with Newman

📈 Test Output Example

🧩 Key Takeaways

📚 References

✍️ Author

# 🌐 Deploying a Remote MCP Server with Python and FastAPI

🚀 Introduction

📦 What is an MCP Server?

🛠️ Requirements

🧑‍💻 Step 1: Create the FastAPI MCP Server

📦 Step 2: Add Requirements

🧪 Step 3: Test Locally (Optional but Recommended)

☁️ Step 4: Deploy to Render

✅ Steps:

💡 Why Use MCP in Business Intelligence?

📚 References

Build and Deploy an Interactive Sales Dashboard with Streamlit

💡 Why Streamlit?

🚀 Features of This Project

🧱 Prerequisites

🧑‍💻 Full Code (app.py)

Explanation:

🌎 How to Deploy to the Cloud

📝 Conclusion

🧑‍💻 Full Code (`app.py`)