Menu
Scheduling systems are the logistical backbone of countless businesses, from healthcare and retail to logistics and field services. They are the digital dispatchers ensuring the right people are in the right place at the right time. But their complexity makes them a nightmare to test manually. This was exactly the challenge we faced. Manual testing was slow, prone to human error, and simply couldn’t keep up with our development pace.
This is the story of how we transformed our testing process, moving from tedious manual checks to a robust, automated framework using Selenium and Java, ultimately building greater confidence in our application.
Our application is a comprehensive scheduling system designed to manage employee tasks across multiple locations and shifts. Its core functions include creating and assigning tasks, and notifying employees of open slots they can fill.
The system’s dynamic nature presented significant testing challenges:
► Dynamic Data: Constantly changing date and time fields are at the heart of the system.
► Complex Matrix: The interplay between multiple locations, employee roles, and varying schedules created a massive number of test combinations.
► Real-time Feedback: The system relies on instant notifications, a feature that is difficult to verify manually.
► Edge Cases: We had to account for tricky scenarios like overlapping schedules, timezone differences, and last-minute changes.
Our manual testing process was a bottleneck. It was:
► Tedious and Repetitive: Manually testing every combination of date, time, location, and employee role was an exhaustive task.
► Error-Prone: Testers are human, and fatigue led to mistakes in checking for scheduling conflicts or data entry errors.
► Difficult to Validate: Verifying that the correct real-time notifications were triggered for the right users was nearly impossible to do consistently.
► Slow: Full regression testing after each new feature deployment took days, significantly slowing down our release cycle.
We needed a tool that was powerful, flexible, and fit into our existing ecosystem. Selenium was the clear choice:
► Open-Source and Community-Driven: It’s free, widely adopted, and backed by a massive community.
► Strong Java Integration: As our application is built on Java, Selenium allowed us to use the same language for our tests, simplifying development and maintenance. Our pom.xml easily integrated the necessary dependencies for Selenium, TestNG, and WebDriverManager.
► Cross-Browser Support: Selenium allows us to run the same tests across Chrome, Firefox, and other browsers to ensure a consistent user experience.
► Scalable and Maintainable: It provides the foundation to build powerful, maintainable frameworks that can scale with the application and integrate into CI/CD pipelines.
We built a layered framework using a combination of industry-standard tools and design patterns:
► Framework Setup: We used TestNG as our test runner, Selenium WebDriver for browser automation, and Java as our programming language. Maven handled our dependencies, and ExtentReports provided clear, actionable test reports.
► Test Case Design: We systematically converted our manual test cases into automated TestNG scripts. For example, our EmployeeShiftTest.java automates the process of creating, modifying, and deleting a shift.
► Data-Driven Testing: To handle the multitude of scheduling scenarios, we adopted a data-driven approach. We used a utility class, InputData.java, to store arrays of test data (like place names, postcodes, and street names), which our tests could then use to create realistic and varied test cases.
► Page Object Model (POM): We implemented the POM design pattern to ensure our test code was readable and maintainable. This pattern separates the test logic from the UI interaction logic, so if the UI changes, we only need to update the corresponding page object class, not the test itself.
► Continuous Integration: Our TestNG suites, like SchedulingSystemTestSuite.xml, are configured to run automatically on every new build, providing immediate feedback to our development team.
To manage the WebDriver lifecycle and test parameters, we use a base test class that all other test classes extend. This class uses TestNG’s @BeforeSuite and @AfterSuite annotations to set up and tear down the browser instance.
package com.schedulingSystem.testng.setup;
import org.openqa.selenium.WebDriver;
import org.testng.annotations.*;
public abstract class SchedulingSystemBaseTest {
public WebDriver driver;
public String baseUrl;
public String username;
public String password;
@Parameters({"baseUrl", "email", "password"})
@BeforeSuite(alwaysRun = true)
public void setup(String baseUrl, String email, String password) throws InterruptedException {
this.baseUrl = baseUrl;
this.username = email;
this.password = password;
driver = WebDriverManager.getDriver();
if (driver == null) {
throw new RuntimeException("Driver initialization failed. Ensure WebDriver is set up properly.");
}
System.out.println("Driver initialized successfully.");
System.out.println(driver.getCurrentUrl());
}
@AfterSuite(alwaysRun = true)
public void terminate() {
WebDriverManager.quitDriver();
System.out.println("Driver terminated.");
}
}
Our automated test suite now covers the most critical functionalities of our scheduling system:
► Creating, editing, and deleting tasks.
► Assigning tasks to employees at various locations.
► Validating schedule conflicts and other edge cases.
► Verifying that notifications are triggered correctly for assigned and open tasks.
► A comprehensive regression suite that runs automatically, ensuring new features don’t break existing functionality.
Here’s a small snippet from our EmployeeShiftTest.java that shows how we automate the creation of a shift:
// Inside a loop to create multiple shifts
// Open shift creation form
PerformAction.clickElement(By.xpath("//tbody/div["+ location +"]/tr["+ i +"]/td["+ column +"]"));
PerformAction.shortWait();
//Choose a shift
PerformAction.clickElement(By.xpath("//form//mat-select"));
int totalService = PerformAction.countOption(By.xpath("//mat-option"));
int pickService = 1 + random.nextInt(totalService);
PerformAction.clickElement(By.xpath("//mat-option[" + pickService + "]"));
//Type description
PerformAction.typeField(By.tagName("textarea"), RandomInput.text());
// Submit form to create the shift
PerformAction.clickElement(By.xpath("//form/div/button[1]"));
PerformAction.longWait();
The transition wasn’t without its hurdles:
► Handling Dynamic Elements: Date and time pickers are notoriously tricky to automate. We had to write specific helper methods to handle these dynamic elements reliably.
► Synchronization Issues: The asynchronous nature of our application, especially with real-time notifications, caused flaky tests. We initially used Thread.sleep(), which is a common but unreliable practice. Later we refactor our code to use explicit waits (WebDriverWait) to make our tests more robust. This ensures that our scripts wait for elements to be in a specific state (e.g., clickable, visible) before interacting with them, rather than waiting for a fixed amount of time.
For example, here is a method from our PerformAction.java class that uses Thread.sleep():
// Before: Using Thread.sleep()
public static void clickElement(By locator) throws InterruptedException {
WebDriver driver = WebDriverManager.getDriver();
if (driver == null) {
throw new RuntimeException("WebDriver is not initialized in PerformAction.");
}
driver.findElement(locator).click();
Thread.sleep(VERY_SHORT_WAIT);
}
And here is the refactored version using WebDriverWait:
// After: Refactored with WebDriverWait
public static void clickElement(By locator) {
WebDriver driver = WebDriverManager.getDriver();
if (driver == null) {
throw new RuntimeException("WebDriver is not initialized in PerformAction.");
}
WebDriverWait wait = new WebDriverWait(driver, Duration.ofSeconds(10));
WebElement element = wait.until(ExpectedConditions.elementToBeClickable(locator));
element.click();
}
► Managing Test Data: Ensuring that our test data was consistent and reusable across different tests and environments was a challenge. Our InputData.java and RandomInput.java utilities were a first step, and we are continuously improving our data management strategy.
► Maintaining Stability: As the application evolves, our tests can become unstable. We address this by following the POM pattern strictly, using reusable locators, and regularly reviewing and refactoring our test code.
The move to test automation has had a significant, positive impact on our business:
► Time Savings: We reduced our regression testing cycle from 3-4 days to just a few hours.
► Increased Coverage: We can now test far more combinations of dates, times, locations, and roles than was ever possible manually.
► Higher Reliability: With a more comprehensive and consistent testing process, we have seen a significant reduction in production bugs related to scheduling and notifications.
► Team Benefits: Developers get faster feedback on their changes, and our QA team can now focus on more valuable exploratory testing and complex use cases, rather than repetitive manual checks.
Our journey has taught us some valuable lessons:
► Invest in a Maintainable Framework: A well-structured framework using patterns like POM is crucial for long-term success.
► Start Small, Automate High-Value Cases First: Don’t try to automate everything at once. Focus on the most critical and repetitive test cases first to get the biggest return on investment.
► Manage Test Data Carefully: A solid test data management strategy is essential for reliable and scalable automation.
► Treat Test Code Like Production Code: Your test code should be reviewed, refactored, and maintained with the same rigor as your application code.
The journey from manual to automated testing has been transformative. By leveraging the power of Selenium, TestNG, and Java, we have not only made our testing process more efficient and reliable, but we have also improved the overall quality of our product. Test automation is not just about faster testing — it’s about building confidence in delivering complex systems reliably.
We build effective teams, the ones that have your back and drive your business forwards. We bring you an innovative new way to outsource
Address: House No: 95, Floor: 1st(A1), Road – 9/A, Dhanmondi, Dhaka-1209
Phone: +8801719100702
Email: [email protected]
© Copyright 2025. All Rights Reserved Bangladesh Software Solution