Dependency between tests in Selenium Java - Deep Dive

Overview - Dependency between tests

What is it?

Dependency between tests means that one test relies on the result or state of another test to run correctly. Instead of each test being independent, some tests run only if others pass or set up certain conditions. This can happen when tests share data, setup steps, or application states. It is common in automated testing but can cause problems if not managed carefully.

Why it matters

Without understanding test dependencies, test suites can become fragile and unreliable. If one test fails, it might cause many others to fail, hiding the real problem. This makes debugging harder and slows down development. Properly managing dependencies helps keep tests stable, trustworthy, and easier to maintain, which saves time and effort in the long run.

Where it fits

Before learning about test dependencies, you should understand basic test automation concepts like writing independent tests and test setup/teardown. After this, you can learn about test design patterns, test data management, and continuous integration practices that handle dependencies better.

Mental Model

Core Idea

Tests that depend on each other form a chain where one test’s success or failure affects the next.

Think of it like...

It’s like a relay race where each runner must finish before the next can start; if one runner falls, the whole race is affected.

┌─────────────┐    ┌─────────────┐    ┌─────────────┐
│ Test A     │───▶│ Test B     │───▶│ Test C     │
└─────────────┘    └─────────────┘    └─────────────┘

If Test A fails, Test B and Test C might not run or fail too.

Build-Up - 7 Steps

1

Foundation

Understanding Independent Tests

Concept: Tests should ideally run independently without relying on others.

In Selenium with Java, each test method should set up its own data and environment. For example, a login test should not depend on a previous test creating a user. This ensures tests can run in any order or alone.

Result

Tests run reliably and can be executed in any sequence without failures caused by missing setup.

Understanding independence prevents hidden failures and makes tests easier to maintain and debug.

2

Foundation

Basic Test Setup and Teardown

Concept: Using setup and teardown methods to prepare and clean the test environment.

In Selenium Java, @BeforeEach and @AfterEach annotations run code before and after every test. For example, opening and closing the browser ensures each test starts fresh.

Result

Each test runs in a clean state, reducing unintended dependencies.

Proper setup and teardown reduce accidental dependencies by isolating tests.

3

Intermediate

Recognizing Test Dependencies

🤔Before reading on: do you think tests that share login sessions are dependent or independent? Commit to your answer.

Concept: Tests that share data or state create dependencies.

If Test B uses a user created in Test A, Test B depends on Test A. In Selenium Java, this might happen if tests share static variables or reuse browser sessions without resetting.

Result

Failing Test A causes Test B to fail or skip, making the suite fragile.

Recognizing dependencies helps identify fragile tests and plan for better isolation.

4

Intermediate

Using TestNG for Dependency Management

🤔Before reading on: do you think marking tests as dependent in TestNG makes tests more reliable or more fragile? Commit to your answer.

Concept: TestNG allows explicit declaration of dependencies between tests.

In TestNG, you can use @Test(dependsOnMethods = {"testMethodName"}) to make one test run only if another passes. Example: @Test public void loginTest() { /* login steps */ } @Test(dependsOnMethods = {"loginTest"}) public void dashboardTest() { /* dashboard checks */ } This ensures dashboardTest runs only if loginTest succeeds.

Result

Tests run in a controlled order, skipping dependent tests if prerequisites fail.

Explicit dependencies help manage test order but can increase fragility if overused.

5

Intermediate

Risks of Test Dependencies

🤔Before reading on: do you think dependencies make debugging easier or harder? Commit to your answer.

Concept: Dependencies can hide root causes and cause cascading failures.

If loginTest fails, all tests depending on it skip or fail, making it unclear which test caused the problem. This slows down fixing issues and reduces confidence in test results.

Result

Test failures become noisy and less informative.

Knowing risks helps balance dependency use and maintain test clarity.

6

Advanced

Strategies to Minimize Dependencies

🤔Before reading on: do you think sharing browser sessions reduces or increases dependencies? Commit to your answer.

Concept: Techniques to reduce dependencies improve test reliability.

Use fresh browser sessions per test, create test data within each test, and use mocks or stubs to isolate external systems. In Selenium Java, avoid static WebDriver instances shared across tests.

Result

Tests become more independent, easier to run in parallel, and less fragile.

Applying these strategies leads to more robust and maintainable test suites.

7

Expert

Handling Dependencies in Large Test Suites

🤔Before reading on: do you think large suites should rely heavily on dependencies or avoid them? Commit to your answer.

Concept: In big projects, some dependencies are unavoidable but must be managed carefully.

Use layered test design: unit tests independent, integration tests with controlled dependencies, and end-to-end tests with minimal dependencies. Use tagging and grouping in TestNG to run subsets. Automate environment resets and use CI pipelines to isolate failures.

Result

Large test suites remain stable, scalable, and provide clear feedback.

Understanding dependency management at scale prevents test suite decay and supports continuous delivery.

Under the Hood

Test frameworks like TestNG manage dependencies by controlling test execution order and skipping dependent tests if prerequisites fail. Internally, the framework tracks test results and uses dependency metadata to decide which tests to run or skip. Selenium WebDriver sessions can be shared or recreated per test, affecting state persistence and dependencies.

Why designed this way?

Dependencies were introduced to handle real-world scenarios where some tests logically require others to succeed first, such as login before dashboard access. This avoids redundant setup but trades off test independence. Frameworks provide dependency features to balance convenience and control.

┌─────────────┐       ┌─────────────┐       ┌─────────────┐
│ Test A     │──────▶│ Test B     │──────▶│ Test C     │
│ (setup)    │       │ (depends)  │       │ (depends)  │
└─────────────┘       └─────────────┘       └─────────────┘

Framework checks Test A result:
  - If pass: run Test B
  - If fail: skip Test B and Test C

Myth Busters - 4 Common Misconceptions

Quick: Do dependent tests always run in the order they are written? Commit to yes or no.

Common Belief: Dependent tests run in the order they appear in the code.

Reality: Test frameworks control execution order based on declared dependencies, not code order. Tests without dependencies may run in any order or parallel.

Why it matters: Assuming code order can cause flaky tests and confusion about test results.

Quick: Does marking tests as dependent guarantee fewer failures? Commit to yes or no.

Common Belief: Declaring dependencies reduces test failures by controlling order.

Reality: Dependencies can increase failures by causing cascading skips or hiding root causes if overused.

Why it matters: Overusing dependencies can make test suites fragile and harder to maintain.

Quick: Can tests share browser sessions without causing dependencies? Commit to yes or no.

Common Belief: Sharing browser sessions between tests does not create dependencies.

Reality: Sharing sessions often creates hidden dependencies because tests rely on previous state, breaking isolation.

Why it matters: Hidden dependencies cause unpredictable failures and make debugging difficult.

Quick: Are dependencies always bad and should be avoided? Commit to yes or no.

Common Belief: All test dependencies are bad and must be eliminated.

Reality: Some dependencies are practical and necessary, especially in integration or end-to-end tests, but must be managed carefully.

Why it matters: Ignoring useful dependencies can lead to redundant tests and wasted effort.

Expert Zone

1

Tests with dependencies can be optimized by grouping related tests and running them in isolated environments to reduce flakiness.

2

Using soft assertions in dependent tests can help gather multiple failures without stopping the test chain prematurely.

3

Dependency declarations in TestNG can be combined with test groups and priorities for fine-grained control over execution flow.

When NOT to use

Avoid dependencies in unit tests where isolation is critical; instead, use mocks and stubs. For integration tests, prefer environment setup scripts over test-to-test dependencies. Use dependency management only when test order or state sharing is unavoidable.

Production Patterns

In real projects, teams use TestNG dependencies sparingly, mostly for setup-heavy tests like login flows. They combine this with CI pipelines that reset environments between runs. Parallel test execution is enabled by minimizing dependencies and using tagging to run independent tests concurrently.

Connections

Continuous Integration (CI)

Dependency management in tests affects CI pipeline reliability and feedback speed.

Understanding test dependencies helps design CI pipelines that isolate failures and reduce false alarms, improving developer trust.

Database Transactions

Both involve managing state dependencies and rollback to maintain consistency.

Knowing how database transactions isolate changes clarifies why test isolation and avoiding dependencies improve test reliability.

Project Management - Task Dependencies

Test dependencies mirror task dependencies where some tasks must finish before others start.

Recognizing this similarity helps understand the importance of managing dependencies to avoid bottlenecks and cascading delays.

Common Pitfalls

#1 Creating tests that share browser sessions causing hidden dependencies.

Wrong approach:

@BeforeClass
public void setup() {
driver = new ChromeDriver();
}

@Test
public void testA() {
// login
}

@Test
public void testB() {
// assumes logged in from testA
}

Correct approach:

@BeforeEach
public void setup() {
driver = new ChromeDriver();
}

@Test
public void testA() {
// login
driver.quit();
}

@Test
public void testB() {
// login again independently
driver.quit();
}

Root cause:

Misunderstanding that sharing WebDriver instance across tests creates dependencies on previous test state.

#2 Overusing TestNG dependencies causing many skipped tests.

Wrong approach:

@Test(dependsOnMethods = {"testA"})
public void testB() {}

@Test(dependsOnMethods = {"testB"})
public void testC() {}

@Test(dependsOnMethods = {"testC"})
public void testD() {}

Correct approach:

Limit dependencies to essential cases only, refactor tests to be independent where possible, or combine related steps into one test.

Root cause:

Belief that chaining many dependencies improves test flow without considering fragility.

#3 Assuming dependent tests run in code order causing flaky results.

Wrong approach:

@Test(dependsOnMethods = {"testA"})
public void testB() {}

@Test
public void testA() {}

// Tests run in unpredictable order if not managed properly

Correct approach:

Declare dependencies explicitly and avoid relying on code order. Use TestNG features to control execution order.

Root cause:

Confusing code layout with test execution order.

Key Takeaways

Test dependencies mean some tests rely on others to run or pass first, creating a chain of execution.

While dependencies can help manage complex test flows, they increase fragility and make debugging harder if overused.

Best practice is to keep tests independent by setting up and cleaning their own environment and data.

Test frameworks like TestNG provide tools to declare and manage dependencies explicitly, but use them carefully.

Understanding and managing dependencies is crucial for building reliable, maintainable, and scalable automated test suites.