In automated testing, the order in which your tests run can really affect the outcome. Maybe you need to set up a database before anything starts, clear temporary files once everything is done, or ensure one test runs only after another passes. That is where command annotations come into play.
If you are just getting started or wondering what is Selenium WebDriver, it is a popular tool that helps automate browser actions. And when you combine it with command annotations, you gain more control over how and when your tests are executed.
This write-up will walk you through what command annotations do, how they work, and how you can use them to shape your test runs to suit your workflow.
What Are Command Annotations in Selenium WebDriver?
When you use Selenium WebDriver, you are doing more than just automating clicks and actions. You are building a structured test flow. And to manage that structure, command annotations come in handy.
These annotations are not built into Selenium itself. Instead, they work with test frameworks like TestNG or JUnit. You add them to your test methods to control how and when your tests run.
Why Do Annotations Matter?
Let us say your test opens a browser, logs into a website, performs some actions, and then shuts everything down. Without annotations, you would have to call the setup and cleanup steps in every test. That gets repetitive and messy.
With annotations, you can run setup steps before each test. You can clean things up right after. You can group tests. You can decide which ones should run first. And you can even skip tests if needed.
This makes your tests cleaner, more reliable, and easier to follow.
How Do These Work with Selenium WebDriver?
Selenium WebDriver controls the browser. But it does not manage the test flow. That is where TestNG and JUnit come in. They give you the annotations that guide the test structure.Transformer repair demands precision diagnostics—specialized technicians assess winding integrity, insulation resistance, and core alignment to restore optimal performance.
For example, in TestNG, @BeforeClass can launch the browser once before all tests in a class.
In JUnit, @BeforeEach and @AfterEach help run setup and cleanup for every test.
So, Selenium runs the browser tasks. The framework handles the test structure. And command annotations help tie everything together in a smooth, controlled way.
Common Annotations Used with Selenium WebDriver
When you are working with Selenium WebDriver, test flow matters. You are not just writing tests—you are also managing when and how they run. That is where annotations come in. These are used with test frameworks like TestNG to handle what happens before, during, and after a test. They help you keep your test code clean, organized, and easier to manage.
@BeforeSuite and @AfterSuite
The @BeforeSuite annotation runs once before anything else starts. You can use it to load config files or connect to a database. It is helpful when you have setup steps that apply to your whole test suite. Then there is @AfterSuite, which also runs once, but after all tests are finished. This one is great for closing connections or cleaning up resources you opened at the beginning.
@BeforeClass and @AfterClass
Next, you have @BeforeClass. This runs once before any test in a class begins. It is often used to launch a browser or load shared data that your class needs. Once all tests in that class are done, @AfterClass takes over. It runs just once, too, and is used to close the browser or release class-level resources. These help you avoid repeating the same setup in every test method.
@BeforeMethod and @AfterMethod
Then come @BeforeMethod and @AfterMethod. The first one runs before each individual test. You can use it to log in or go to a specific page before your test starts. After the test runs, @AfterMethod is triggered. That is where you can log out, delete cookies, or reset the data. This way, each test starts in a clean state, without any leftovers from the previous one.
@Test and Its Attributes
At the center of it all is the @Test annotation. This marks a method as a test case. But it also gives you extra control. With priority, you can set the order your tests run in. If you want to skip a test for now, you can set enabled to false. When you need to group tests by functionality or type, you can use groups. And if one test should only run after another passes, dependsOnMethods is the way to go.
Each annotation plays its part. And when you use them with Selenium WebDriver, they help you build a test suite that is easier to follow, more stable, and much more flexible.
Controlling Test Execution Order in Selenium
Selenium WebDriver does not manage the sequence of test execution. That aspect is managed by the testing framework you use, such as TestNG or JUnit.
In TestNG, you can use the priority attribute inside the @Test annotation. Lower values run first, so priority=1 runs before priority=2. If you do not set any priority, tests run in alphabetical order by default.
You can also use the dependsOnMethods attribute. It helps you run a test only after another one has passed. This is useful when a test needs preconditions that another test sets up.
In JUnit, things work differently. By default, JUnit does not follow any fixed execution order. But in JUnit 5, you can use @TestMethodOrder to set the order. Then, add @Order to decide which test runs first. So, a method with @Order(1) will run before @Order(2).
Even with these options, it is better to keep tests independent. Depending too much on order can make tests fragile. So, use it only when you really need to, like for setup steps or validations that must follow a sequence.
Running Selenium Tests Conditionally
Conditional execution lets you run or skip tests based on certain conditions.
In TestNG, you can use @Test(enabled = false) when you want to skip a test without deleting it from the code.
For more dynamic checks:
- Use @BeforeMethod or @BeforeClass to evaluate a condition before the test runs.
- Inside the test, add an if condition to decide whether to continue or skip.
You can also use IAnnotationTransformer in TestNG:
- This helps you change annotation behavior at runtime.
- You can enable or disable tests based on logic like a property file or environment variable.
In JUnit 5, conditional annotations like @EnabledIf and @DisabledIf are supported:
- These come through third-party libraries or custom extensions.
Some common use cases:
- Run tests only when a specific browser is available.
- Skip tests in non-production environments.
- Run tests only if a feature flag is enabled.
- Conditional execution helps skip unnecessary tests.
This saves time and focuses only on what matters in the current test environment.
Real-World Scenarios in Selenium Automation
Selenium WebDriver is often used to mimic how users interact with a website. Whether it is logging in, checking a cart, or viewing a dashboard, what is Selenium? It helps you test the actual flow users follow.
Here are a few common scenarios where Selenium comes in handy:
- Cross-Browser Testing
Run tests on different browsers like Chrome, Firefox, Safari, or Edge. This helps check if everything looks and works the same everywhere. - Form Validation
Test forms with correct and incorrect inputs. Make sure required fields, error messages, and validations work as expected. - E-commerce Workflows
Try actions like searching for a product, adding items to the cart, going through checkout, and checking if the payment message shows up. - Responsive Design Checks
Resize the browser or simulate mobile screens. This helps you confirm that pages adjust well to different devices and screen sizes. - Role-Based Access Control
Log in with different user roles—like admin, editor, or viewer. Make sure each role only sees what it is supposed to see. - Third-Party Integrations
Check if components like payment gateways, maps, or social widgets load correctly and function without errors.
Using LambdaTest for Scalable and Reliable Test Execution
Running these tests on your local machine works, but it gets harder when you want to test on many browsers or systems. That is where LambdaTest helps.
LambdaTest is an AI-native testing platform that lets you run Selenium tests on real browsers and devices in the cloud. So you get more coverage without setting up the setup yourself.
You can connect your Selenium tests to LambdaTest for:
- Running tests on multiple browsers
- Executing tests in parallel
- Testing based on different locations
- Debugging with logs, screenshots, and videos
It also works with CI/CD tools, so it fits right into your build pipeline.
When you bring Selenium and LambdaTest together, you get to test across real conditions and find issues early, without handling the heavy setup on your own.
Getting started with Selenium? Check out this guide on what is Selenium.
Best Practices for Using Command Annotations in Selenium WebDriver
When applied correctly, command annotations can simplify the management and scaling of your Selenium tests.
Here are some useful suggestions to remember:
- Structure Your Setup and Cleanup Steps
Use annotations like @BeforeSuite, @BeforeClass, and @BeforeMethod to prepare your test environment at different levels. For cleanup, use @AfterMethod, @AfterClass, and @AfterSuite to reset things and avoid data clashes across tests.
- Keep Each Test Self-Contained
Try not to rely on one test running before another. Every test should stand on its own. If dependencies are necessary, use dependsOnMethods with caution and a clear purpose.
- Make Smart Use of @Test Attributes.
Use attributes such as priority, enabled, groups, or timeOut to better organize and control your test runs. These help when you need to include or skip tests, or manage how and when they run.
- Avoid Rewriting the Same Setup Code
If you find yourself repeating setup steps in every test, move that code into @BeforeMethod or @BeforeClass. This makes your tests shorter and more consistent.
- Group Similar Tests Together
Use the groups attribute to tag related tests. Whether it is smoke tests, regression cases, or UI checks, grouping makes it easier to run only what you need.
Conclusion
To keep your Selenium test suite clean and easy to manage, it helps to follow a few simple practices. Start by choosing clear and descriptive names for your test and setup methods. This makes it easier for others—and your future self—to understand what each part of the test is meant to do.
Add logs where it matters, especially in @BeforeMethod or @AfterMethod, so you can see what happened before or after a test ran. This becomes really helpful when you are reviewing reports or trying to debug a failure. Also, make sure your annotations are structured to work smoothly with CI/CD tools. When your test setup aligns with how your tests run in pipelines, it becomes easier to tag, schedule, and trigger them as part of automated builds.