Introduction

The software testing is fully automated scripts racing through apps, ticking off checklists, and delivering instant results. I discovered that manual testing is still very much alive and kicking. It’s like an artist adding the final brushstrokes to a painting automation can lay the foundation, but only a human can bring it to life. Testing the Cookr mobile app and website https://cookr.in/ , I uncovered bugs that automation and learned why manual testing is essential for creating apps user adore, I share my story, the bugs I caught, and why manual testing remains a game-changer.

The Role of Manual Testing in Modern QA

Manual testing is about running tests by hand, no automation scripts involved. It’s like being a treasure hunter, searching for hidden flaws that automated tools might miss. It shines in areas like:

  • User Interface (UI) and User Experience (UX): Ensuring the app looks great and feels effortless to navigate.
  • Exploratory Testing: Roaming the app freely to spot unexpected issues.
  • Ad-Hoc Scenarios: Testing the app in real world ways, like entering odd data.
  • Early-Stage Features: Checking new functionality before automation is set up.

While automation is perfect for repetitive tasks, manual testing think like a user, catching issues that scripts using techniques like exploratory testing and Boundary Value Analysis, I saw how manual testing makes apps not just functional but delightful.

Real Testing Scenario: The Cookr Application

I tested Cookr, a mobile app for managing recipes. My role was hands on:

  • Creating detailed test cases in Excel to test forms, buttons, and user flows.
  • Testing features like profile updates and registrations manually.
  • Logging bugs in JIRA with clear steps, screenshots, and what went wrong vs. what should’ve happened.
  • Collaborating with developers to fix issues quickly.

This work uncovered bugs that automation didn’t catch, proving manual testing’s power to keep the app reliable and user-friendly.

Real Bugs Through Manual Testing

Testing Cookr was like finding cracks in a foundation. Here are some bugs I discovered that could have frustrated users:

1] Name Field Accepted Numbers

  • What I Expected: The name field should only accept letters, like “Logesh” or “Ram.”
  • What Happened: It allowed numbers, like “12345,” as a valid name.
  • Why It Matters: Odd names could create confusing profiles, making the app seem unreliable.

2] Invalid Email Format Was Accepted

  • What I Expected: Emails should follow a standard format, like logesh@example.com.
  • What Happened: It accepted weird inputs, like logesh@com or logesh@.com.
  • Why It Matters: Bad emails could block notifications or logins, leaving users stranded.

3] Success Message Without Actual Data Save

  • What I Expected: A “Profile Updated Successfully” message should confirm data was saved.
  • What Happened: The message appeared, but no data was stored.
  • Why It Matters: Users could lose their changes, get annoyed, and stop using the app.

Why Automation Didn’t Catch These Issues

Automation tools like Playwright and Pytest, which I used for projects like OrangeHRM and Facebook, are fantastic for:

  • Repeating tasks, like logging in or filling out forms.
  • Checking technical details, like server responses or page redirects.
  • Running tests across multiple browsers.

But automation has limits. It follows prewritten scripts and can’t:

  • Notice if an error message is unclear to users.
  • Test unusual inputs unless specifically told to.
  • Explore the app like a curious user would.

For Cookr, the automation scripts didn’t check for invalid emails or fake success messages because those scenarios weren’t included. Manual testing gave me the freedom to roam and find these gaps by thinking like a real user.

Example Manual Test Case

Here’s a some Test Scenarios and Description for various modules :

Automation with Page Object Model:

Testing Facebook’s registration and login pages taught me how to write reusable, reliable automation scripts, tackle real issues like URL mismatches, and appreciate the power of structured code.

Challenges I Faced and Overcame

Testing Facebook wasn’t all smooth sailing. Here are two hurdles I encountered:

1] URL Mismatch During Registration

  • What Happened: My registration test failed with a “URL mismatch” error because the page redirected to a verification step instead of staying at https://www.facebook.com/.
  • How I Handled It: I realized Facebook’s two-step verification was kicking in. I updated the test to expect the new URL or added a manual check to pause and verify the step visually.
  • Why It Matters: This taught me to account for dynamic redirects, making my scripts more robust.

2] Login Success Confirmation

  • What Happened: The login test ran fine, but I needed to confirm the logout worked too, which required navigating back to the login page.
  • How I Handled It: I created a separate logout page object and added a screenshot to verify the process, ensuring the full flow was tested.
  • Why It Matters: This ensured the entire user journey—login to logout—was covered, boosting confidence in the automation.

These challenges, logged and resolved during my work, highlighted how POM helps adapt to real-world web complexities.

Example For Automating Facebook Registration

Code Explanation For Registration Page

  • This Python script uses Playwright to automate Facebook registration, launching a browser and creating a page object.
  • It fills the registration form with details like name, email, birth date, and gender, then submits it, saving a screenshot.
  • The script verifies the URL matches “https://www.facebook.com/” and includes a commented-out pause for manual checks.
  • It uses a Registration Page class to organize page elements and actions, closing the browser at the end.

Example For Automating Facebook Login

Code Explanation For Login Page

  • This code automates a Facebook login and logout test using Playwright and the Page Object Model (POM).
  • It starts by creating page objects for the login and logout pages, then navigates to Facebook and logs in with provided credentials.
  • After taking a screenshot to confirm the login, it proceeds to log out and prints a success message.
  • The POM approach keeps the code organized and reusable for testing Facebook’s login flow.

Conclusion

Manual testing and automation are a perfect pair, While testing Cookr, I found bugs that improved the app for users, and with Facebook, I learned automating complex tasks using POM. It’s like mixing passion and technology to create apps users truly enjoy.

Post Views: 3

Leave a Reply