DEV Community: Mohaiminul Shovon

how to use AI to create automation testing with playwirght

Mohaiminul Shovon — Wed, 05 Feb 2025 11:43:59 +0000

Really useful tips to organize the test suite.

Mohaiminul Shovon — Wed, 22 Jan 2025 03:22:06 +0000

Organizing Playwright Tests Effectively

Debbie O'Brien for Playwright end to end Testing ・ Jan 21

#testing #playwright #webdev #javascript

Clean Coding Essentials: Tips for Writing Readable Code

Mohaiminul Shovon — Wed, 30 Oct 2024 11:36:16 +0000

“Any fool can write code that a computer can understand. Good programmers write code that humans can understand.”

Martin Fowler’s quote captures the essence of clean coding: creating code that’s functional and easy for other developers to read. In the line duty, I myself has faced numerous challenges while writing code. But It was never the technical things that make me concerned. It the cleanliness and readability of my code. Here’s my take on clean coding principles that might help to maintain utmost readability of the code.

Naming Variables

Good variable names are critical for clear, maintainable code.

According to the famous software nerd Phil Karlton,

"There are only two hard things in Computer Science: cache invalidation and naming things."

Here’s how to improve your naming practices:

Avoiding Disinformation: Use variable names that accurately describe what they hold. Avoid misleading terms.
- Bad: int hp; // Is it hit points or horsepower?
- Good: int hitPoints;
Avoiding Noise Words: Words like "data" or "info" add clutter and don’t clarify what the variable holds.
- Bad: string productInfo;
- Good: string productName;
Using Pronounceable Names: Names should be easy to read and say out loud.
- Bad: string prdctNm;
- Good: string productName;
Using Searchable Names: Avoid short, non-descriptive names that make it hard to locate variables.
- Bad: for (int i = 0; i < 10; i++) { ... }
- Good: for (int itemIndex = 0; itemIndex < items.Count; itemIndex++) { ... }
Be Consistent: Stick to a single naming convention throughout.
- Inconsistent: userName in one place and user_name in another.
- Consistent: Always use userName.

Writing Functions

Writing clean, effective functions is essential for readability and maintainability.

Keeping Functions Small: Short functions are easier to understand. Aim to fit each function on one screen.

Bad:

def calculateTotal(cart):
    # Several lines of calculation logic

Good:

def calculateItemTotal(item):
    ...

def calculateCartTotal(cart):
    total = 0
    for item in cart:
        total += calculateItemTotal(item)
    return total

Single Responsibility: Each function should do only one thing.

Bad:

def sendEmail(email, subject, message, log):
    log.append("Sending email to " + email)
    # Code to send email
    log.append("Email sent")

Good:

def logMessage(log, message):
    log.append(message)

def sendEmail(email, subject, message):
    # Code to send email

Encapsulate Conditionals in Functions: Long, complex conditionals are confusing. Encapsulate them with clear function names.

Bad:

if (user && user.isActive && user.isVerified) { ... }

Good:

function isUserEligible(user) {
    return user && user.isActive && user.isVerified;
}
if (isUserEligible(user)) { ... }

Fewer Arguments: Aim for functions with three or fewer parameters.

Bad:

function createUser(name, email, password, age, address) { ... }

Good:


function createUser({ name, email, password, age, address }) { ... }

Avoid Flag Arguments: Flags complicate function logic.

Bad:

function displayUserProfile(user, isAdmin) {
    if (isAdmin) {
        // Show admin view
    } else {
        // Show regular view
    }
}

Good:

function displayUserProfile(user) { ... }
function displayAdminProfile(user) { ... }

No Side Effects: Functions should not alter external states unless intended.

Bad:

function addToCart(item) {
    cart.push(item); // modifies an external cart
    return cart.length;
}

Good:

function createUpdatedCart(cart, item) {
    const updatedCart = [...cart, item];
    return updatedCart;
}

Don’t Repeat Yourself (DRY): Avoid duplicating logic. Reuse functions wherever possible.

Bad:

function calculateDiscountedPrice(price) {
    return price - (price * 0.1);
}

function calculateFinalPrice(price) {
    return price - (price * 0.1); // Duplicate logic
}

Good:


function applyDiscount(price, discountRate = 0.1) {
    return price - (price * discountRate);
}

Don’t Leave Code in Comments

Comments can be helpful, but avoid leaving commented-out code. It adds clutter and can mislead readers.

Bad:

# This is a function to add two numbers
# def add(a, b):
#     return a + b
def add(a, b):
    return a + b

Good:

# Function to add two numbers
def add(a, b):
    return a + b

Know Your Language Conventions

Each language has unique conventions for naming, indentation, and structure. Following them improves consistency and readability.

JavaScript Example:

// Follow camelCase for variables and functions
let userName = "John Doe";

// Use PascalCase for classes
class UserProfile { ... }

Python Example:

# Use snake_case for variables and functions
user_name = "John Doe"

# Use CapitalizedWords for classes
class UserProfile:
    ...

Clean coding practices are an investment that pays off with better readability, easier maintenance, and a codebase that other developers will thank you for. Start with these practices to make your code cleaner, clearer, and more effective.

Random Data Generation for API Test Automation Using Faker

Mohaiminul Shovon — Fri, 26 Jul 2024 10:40:58 +0000

Whenever we automation engineers try to create a API chaining requests, the most common obstacle and responses we get from the API is “Content Already Exists!”. Well our test has passed, but we need to move on from there. How? For the newbies, it’s a million dollar problem. Let’s take a scenario to understand the dilemma here.

We have an API in our hand which actually creates a user with some details such as gender, nationality, age, etc. We give a JSON body such as this to the API to process.

{
”name”: “Mr. X”, 
“age”: 25, 
“gender”: “male”, 
“nationality”: “Japanese”
}

Now, the processes the body and send back a response, “New user created”. But we are in a automation journey. We can’t provide this same name and details every time our scripts run. Otherwise It will give back “Already created!”.

For this kind of test scenarios where we need to give dynamic data for each iteration. There are multiple ways to dynamically give data to request body. We can manually create some random data for this and store in a CSV file. For each iteration, we will pick from that CSV file. But this process is a manual process inside an automation process which we don’t want. There is another excellent way we can achieve our goal.

One excellent way to generate random data for API testing is by using the Faker library with TypeScript. Faker is a widely-used library that can generate fake data for various fields such as names, addresses, phone numbers, and more. Here's how you can use Faker with TypeScript to create dynamic data for your API tests.

Installing Faker

First, you need to install the Faker library. You can do this using npm:

npm install @faker-js/faker

Using Faker in TypeScript

Once the installation is complete, you can use Faker to generate fake data in your TypeScript code. Below is an example of how you can use Faker to generate dynamic data for the user creation scenario:

import { faker } from '@faker-js/faker';

// Function to create a fake user
function createFakeUser() {
  const name = faker.name.findName();
  const age = faker.datatype.number({ min: 18, max: 100 });
  const gender = faker.name.gender(true); // Generates 'male' or 'female'
  const nationality = faker.address.country();

  return {
    name: name,
    age: age,
    gender: gender,
    nationality: nationality
  };
}

// Generate a new fake user
const fakeUser = createFakeUser();
console.log(fakeUser);

// Example of how you might use this fake user data in an API request
const requestBody = JSON.stringify(fakeUser);

// Now you can send this requestBody in your API request
// For example, using fetch or axios
// fetch('your-api-endpoint', { method: 'POST', body: requestBody });

In this example, the createFakeUser function generates a new user object with a random name, age, gender, and nationality each time it is called. You can then use this object as the request body for your API tests, ensuring that each test run uses unique data and avoids the "Content Already Exists!" issue.

Software Bug Inspection: From Mytery to Mastery!

Mohaiminul Shovon — Tue, 14 Mar 2023 11:45:30 +0000

Finding bug is the sole responsibility of a software tester🕵️‍♀️ but is it all a tester should do? Most of the tester encounter a lot of hazardous bugs🐞 but some of them go a little further with this. They just put it up in bug tracking software and be gone to find some more. A proper tester will always put an effort to make the bugs more presentable and understandable for the developer who will eventually solve the bug. That’s where we get into investigation of bug.

In an article named "How far to investigate", it has been said,

"If people have to ask a lot of questions about the defects raised in order to fix them then, you have not gone far enough. Go as far as you can, while you are still adding value to the person who is following."

🤷‍♀️Investigating a bug can be a complex and time-consuming process, but it is an essential part of the software development cycle. The goal of investigating a bug is to identify the root cause, implement a solution, and prevent the bug from recurring. Let's see some common methods to go by when we try to investigate a bug.

First, it is important to reproduce the bug. Reproducing the bug will confirm its existence and provide a starting point 🔦 for the investigation. It is also important to gather as much information as possible about the bug, including the steps to reproduce it, the environment in which it occurs, and any error messages or other output that might be relevant.

Secondly, it is important to determine the scope of the bug. Is the bug affecting only one user or system👨, or is it impacting multiple users or systems👨👨👨? Understanding the scope of the bug will help you prioritize your efforts and determine the impact 💣 of the bug.

Once you have a clear understanding of the bug, you can begin to isolate🧲 the root cause. This can involve breaking down the problem into smaller parts and eliminating potential causes one by one. Using debugging tools, such as debuggers and log files, can also be helpful in isolating the root cause.

As you investigate the bug, it is important to consider the trade-offs between the time 🕒 and resources 🔧 required to investigate the bug and the potential impact of the bug. For example, a bug that is causing significant problems for users or causing financial losses may warrant a more extensive investigation. However, a minor bug that has little impact on users may not require as much investigation.

🔊Effective communication with developers, product managers, and other stakeholders is also crucial in the investigation process. It is important to keep these stakeholders🧔 informed about the progress of the investigation🕵️‍♂️ and the potential impact of the bug.

In summary, investigating a bug can be a complex and time-consuming process, but it is an essential part of ensuring the quality of a software. By reproducing the bug, determining the scope, isolating the root cause, using debugging tools, prioritizing efforts, and effectively communicating with stakeholders, you can efficiently make sense❗❗ out of a bug.