Dependency between tests in Selenium Java - Build an Automation Script

Verify user profile update depends on successful login

Preconditions (2)

Step 1: Open the login page at 'https://example.com/login'

Step 2: Enter 'testuser' in the username field with id 'username'

Step 3: Enter 'Test@1234' in the password field with id 'password'

Step 4: Click the login button with id 'loginBtn'

Step 5: Verify that the URL changes to 'https://example.com/dashboard'

Step 6: Navigate to the profile page by clicking the profile link with id 'profileLink'

Step 7: Update the profile name field with id 'profileName' to 'Test User Updated'

Step 8: Click the save button with id 'saveProfileBtn'

Step 9: Verify that a success message with id 'successMsg' is displayed containing text 'Profile updated successfully'

✅ Expected Result: User can only update profile after successful login. Profile update shows success message.

Automation Requirements - TestNG with Selenium WebDriver

Assertions Needed:

Assert URL after login is 'https://example.com/dashboard'

Assert success message text after profile update

Best Practices:

Use @Test(dependsOnMethods = ...) to create dependency between login and profile update tests

Use explicit waits to wait for elements to be visible or clickable

Use Page Object Model to separate page interactions

Use assertions from TestNG Assert class

Automated Solution

Selenium Java

import org.openqa.selenium.By;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.WebElement;
import org.openqa.selenium.chrome.ChromeDriver;
import org.openqa.selenium.support.ui.ExpectedConditions;
import org.openqa.selenium.support.ui.WebDriverWait;
import org.testng.Assert;
import org.testng.annotations.AfterClass;
import org.testng.annotations.BeforeClass;
import org.testng.annotations.Test;

import java.time.Duration;

public class DependencyBetweenTests {
    private WebDriver driver;
    private WebDriverWait wait;

    @BeforeClass
    public void setUp() {
        // Set path to chromedriver if needed
        driver = new ChromeDriver();
        wait = new WebDriverWait(driver, Duration.ofSeconds(10));
        driver.manage().window().maximize();
    }

    @Test
    public void testLogin() {
        driver.get("https://example.com/login");

        WebElement usernameField = wait.until(ExpectedConditions.visibilityOfElementLocated(By.id("username")));
        usernameField.sendKeys("testuser");

        WebElement passwordField = driver.findElement(By.id("password"));
        passwordField.sendKeys("Test@1234");

        WebElement loginButton = driver.findElement(By.id("loginBtn"));
        loginButton.click();

        wait.until(ExpectedConditions.urlToBe("https://example.com/dashboard"));
        Assert.assertEquals(driver.getCurrentUrl(), "https://example.com/dashboard", "URL after login should be dashboard");
    }

    @Test(dependsOnMethods = {"testLogin"})
    public void testProfileUpdate() {
        WebElement profileLink = wait.until(ExpectedConditions.elementToBeClickable(By.id("profileLink")));
        profileLink.click();

        WebElement profileNameField = wait.until(ExpectedConditions.visibilityOfElementLocated(By.id("profileName")));
        profileNameField.clear();
        profileNameField.sendKeys("Test User Updated");

        WebElement saveButton = driver.findElement(By.id("saveProfileBtn"));
        saveButton.click();

        WebElement successMsg = wait.until(ExpectedConditions.visibilityOfElementLocated(By.id("successMsg")));
        String successText = successMsg.getText();
        Assert.assertTrue(successText.contains("Profile updated successfully"), "Success message should confirm profile update");
    }

    @AfterClass
    public void tearDown() {
        if (driver != null) {
            driver.quit();
        }
    }
}

The setUp method initializes the Chrome WebDriver and sets an explicit wait for 10 seconds.

The testLogin method opens the login page, enters username and password, clicks login, and waits until the URL changes to the dashboard URL. It asserts the URL to confirm successful login.

The testProfileUpdate method depends on testLogin using @Test(dependsOnMethods = {"testLogin"}). This ensures it runs only if login passes. It clicks the profile link, updates the profile name, clicks save, and asserts the success message is displayed.

Explicit waits ensure elements are ready before interacting, avoiding flaky tests.

The tearDown method closes the browser after tests finish.

This structure shows how to create test dependencies in TestNG and use Selenium best practices.

Common Mistakes - 3 Pitfalls

{'mistake': 'Not using dependsOnMethods and running dependent tests independently', 'why_bad': 'Profile update test may run without login, causing failures and false negatives.', 'correct_approach': 'Use @Test(dependsOnMethods = {"testLogin"}) to ensure profile update runs only after successful login.'}

Using Thread.sleep instead of explicit waits

Hardcoding URLs or element locators without validation

Bonus Challenge

Now add data-driven testing with 3 different user credentials for login and profile names

Show Hint

Practice

1. What is the main purpose of using dependsOnMethods in Selenium Java tests?

easy

A. To skip tests that have no assertions

B. To run all tests in parallel regardless of order

C. To automatically retry failed tests

D. To make one test run only after another test has passed

Solution

1. Step 1: Understand test dependencies

   The dependsOnMethods attribute is used to specify that a test should run only after another test method has successfully completed.

2. Step 2: Recognize the effect on test execution order

   This ensures that dependent tests do not run if the test they depend on fails, maintaining logical test flow.

3. Final Answer:

   To make one test run only after another test has passed -> Option D

4. Quick Check:

   dependsOnMethods controls test order and dependency [OK]

Hint: dependsOnMethods links tests to run in sequence [OK]

Common Mistakes:

• Thinking dependsOnMethods runs tests in parallel
• Assuming it retries failed tests automatically
• Believing it skips tests without assertions

2. Which of the following is the correct syntax to make testB depend on testA in TestNG?

easy

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

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

C. @Test(dependsOn = "testA") public void testB() {}

D. @Test(dependOn = "testA") public void testB() {}

Solution

1. Step 1: Recall TestNG annotation syntax

   The correct attribute name is dependsOnMethods and it expects an array of method names as strings.

2. Step 2: Check the syntax correctness

   @Test(dependsOnMethods = {"testA"}) public void testB() {} correctly uses @Test(dependsOnMethods = {"testA"}) with the method name in quotes inside braces.

3. Final Answer:

   @Test(dependsOnMethods = {"testA"}) public void testB() {} -> Option B

4. Quick Check:

   dependsOnMethods requires string array syntax [OK]

Hint: Use dependsOnMethods with braces and quotes [OK]

Common Mistakes:

• Using dependsOn instead of dependsOnMethods
• Omitting quotes around method name
• Not using braces for the array

3. Given the following TestNG code:

@Test
public void login() { Assert.assertTrue(false); }

@Test(dependsOnMethods = {"login"})
public void dashboard() { System.out.println("Dashboard loaded"); }

What will happen when these tests run?

medium

A. login fails, dashboard is skipped

B. login fails, dashboard runs and prints message

C. Both login and dashboard run and pass

D. login passes, dashboard is skipped

Solution

1. Step 1: Analyze login test result

   The login test asserts false, so it will fail.

2. Step 2: Understand effect on dependent test

   The dashboard test depends on login. Since login failed, dashboard will be skipped and not run.

3. Final Answer:

   login fails, dashboard is skipped -> Option A

4. Quick Check:

   Dependent tests skip if dependency fails [OK]

Hint: Failed dependency causes dependent test to skip [OK]

Common Mistakes:

• Assuming dependent test runs despite failure
• Thinking both tests pass
• Confusing skip with fail

4. Identify the error in this TestNG test dependency code:

@Test(dependsOnMethods = "setup")
public void testFeature() {}

@Test
public void setup() {}

medium

A. setup method must be private

B. testFeature should not depend on setup

C. dependsOnMethods should be an array of strings, not a single string

D. setup method must have parameters

Solution

1. Step 1: Check dependsOnMethods syntax

   The attribute dependsOnMethods requires an array of method names, even if only one method is listed.

2. Step 2: Identify the syntax mistake

   Here, dependsOnMethods = "setup" is a single string, missing braces to make it an array.

3. Final Answer:

   dependsOnMethods should be an array of strings, not a single string -> Option C

4. Quick Check:

   dependsOnMethods needs braces for method names [OK]

Hint: Always use braces {} for dependsOnMethods even if one method [OK]

Common Mistakes:

• Using single string instead of string array
• Making dependent method private
• Adding parameters to setup method unnecessarily

5. You have three tests: init(), login(), and purchase(). login() depends on init(), and purchase() depends on login(). If init() fails, what happens when you run all tests together?

hard

A. init fails, login and purchase are skipped

B. init fails, login runs but purchase is skipped

C. init fails, login and purchase run anyway

D. init fails, only purchase runs

Solution

1. Step 1: Understand the dependency chain

   login depends on init, and purchase depends on login, forming a chain: init -> login -> purchase.

2. Step 2: Analyze failure impact

   If init fails, login will be skipped because it depends on init. Since login is skipped, purchase will also be skipped because it depends on login.

3. Final Answer:

   init fails, login and purchase are skipped -> Option A

4. Quick Check:

   Failure cascades down dependent tests [OK]

Hint: Failure in first test skips all dependent tests down the chain [OK]

Common Mistakes:

• Assuming dependent tests run despite failure
• Thinking only immediate dependent test skips
• Believing tests run independently