First Selenium Java test - Deep Dive

Overview - First Selenium Java test

What is it?

A Selenium Java test is a simple program that uses Selenium WebDriver with Java to open a web browser, visit a website, and check if something on the page works as expected. It helps automate checking websites so testers don't have to do it by hand. This test usually includes opening the browser, finding elements on the page, and making sure they behave correctly.

Why it matters

Without automated tests like Selenium Java tests, testers would spend a lot of time clicking and checking websites manually, which is slow and error-prone. Automated tests save time, catch bugs early, and make sure websites work well for users. This helps companies release better software faster and with more confidence.

Where it fits

Before learning Selenium Java tests, you should know basic Java programming and understand what web browsers and websites are. After this, you can learn more advanced Selenium features like handling forms, waits, and running tests on different browsers or in the cloud.

Mental Model

Core Idea

A Selenium Java test is like a robot using Java instructions to open a browser and check if a website works correctly.

Think of it like...

Imagine giving a friend a checklist and instructions to visit a store, find a product, and tell you if it’s there and looks right. Selenium Java test is that friend, but it uses code to do the checking automatically.

┌─────────────────────────────┐
│ Selenium Java Test Process   │
├─────────────────────────────┤
│ 1. Start WebDriver (browser) │
│ 2. Open website URL          │
│ 3. Find page elements        │
│ 4. Check element behavior    │
│ 5. Report pass or fail       │
│ 6. Close browser             │
└─────────────────────────────┘

Build-Up - 6 Steps

1

Foundation

Setup Selenium WebDriver in Java

Concept: Learn how to prepare your Java project to use Selenium WebDriver.

To start, you need to add Selenium WebDriver to your Java project. This usually means adding Selenium libraries via Maven or downloading the JAR files. You also need a browser driver like ChromeDriver to control the browser. Place the driver executable in your system path or specify its location in your code.

Result

Your Java project can now use Selenium classes to control browsers.

Knowing how to set up Selenium is essential because without it, your code cannot communicate with browsers to run tests.

2

Foundation

Write a Basic Selenium Java Test

Concept: Create a simple Java program that opens a browser and visits a website.

Here is a minimal Selenium Java test: import org.openqa.selenium.WebDriver; import org.openqa.selenium.chrome.ChromeDriver; public class BasicTest { public static void main(String[] args) { System.setProperty("webdriver.chrome.driver", "path/to/chromedriver"); WebDriver driver = new ChromeDriver(); driver.get("https://example.com"); driver.quit(); } } This code opens Chrome, goes to example.com, then closes the browser.

Result

When run, Chrome opens, loads example.com, then closes.

Understanding this simple test shows how Selenium controls browsers step-by-step.

3

Intermediate

Locate Elements on the Webpage

🤔Before reading on: do you think Selenium can find page elements only by their visible text or also by other ways? Commit to your answer.

Concept: Learn how to find elements on a page using different locators.

Selenium can find elements by ID, name, class, tag, CSS selector, or XPath. For example: WebElement heading = driver.findElement(By.tagName("h1")); String text = heading.getText(); This finds the first

tag and reads its text.

Result

You can access and check parts of the webpage to verify content or interact with it.

Knowing multiple ways to locate elements lets you write flexible tests that work even if the page changes slightly.

4

Intermediate

Add Assertions to Verify Behavior

🤔Before reading on: do you think Selenium itself checks if page content is correct, or do you need extra code for that? Commit to your answer.

Concept: Use assertions in Java to check if the webpage shows expected results.

Selenium controls the browser but does not check correctness by itself. You use Java assertions or testing frameworks like JUnit or TestNG. Example with JUnit: import static org.junit.Assert.assertEquals; String title = driver.getTitle(); assertEquals("Example Domain", title); This checks if the page title matches the expected text.

Result

Tests will pass if the page is correct, or fail if something is wrong.

Separating browser control and verification helps keep tests clear and reliable.

5

Advanced

Handle Browser Driver Setup Dynamically

🤔Before reading on: do you think hardcoding driver paths is best practice or is there a better way? Commit to your answer.

Concept: Use WebDriverManager to manage browser drivers automatically.

Instead of manually downloading and setting driver paths, use WebDriverManager: import io.github.bonigarcia.wdm.WebDriverManager; WebDriverManager.chromedriver().setup(); WebDriver driver = new ChromeDriver(); This downloads the correct driver version and sets it up automatically.

Result

Your tests run smoothly on any machine without manual driver setup.

Automating driver management reduces setup errors and saves time in real projects.

6

Expert

Understand Selenium WebDriver Architecture

🤔Before reading on: do you think Selenium sends commands directly to the browser or uses an intermediate protocol? Commit to your answer.

Concept: Learn how Selenium communicates with browsers under the hood using WebDriver protocol.

Selenium WebDriver sends commands as HTTP requests to a browser-specific driver (like ChromeDriver). The driver translates commands into browser actions using the browser's automation API. This separation allows Selenium to support many browsers uniformly.

Result

You understand why tests can run on different browsers with the same code and how communication happens behind the scenes.

Knowing this architecture helps debug issues and design better tests that work across browsers.

Under the Hood

Selenium WebDriver works by sending commands from your Java code to a browser driver executable via a WebDriver protocol (HTTP/JSON). The driver then controls the browser using native automation APIs. Your test code creates WebDriver objects that represent the browser session, and methods like get(), findElement(), and quit() translate into commands sent over this protocol. The browser driver runs separately and manages the browser process.

Why designed this way?

This design separates test code from browser internals, allowing Selenium to support multiple browsers by writing drivers for each. It also isolates browser control in a separate process, improving stability and security. Earlier tools tried to inject code into browsers directly, which was fragile and limited. The WebDriver protocol is standardized, making Selenium more robust and extensible.

┌───────────────┐       HTTP/JSON       ┌───────────────┐
│ Selenium Test │ ─────────────────────>│ Browser Driver│
│   (Java)     │                        │ (e.g., Chrome) │
└───────────────┘                        └───────────────┘
         │                                        │
         │                                        │
         │                                Controls browser
         │                                        │
         ▼                                        ▼
   Your Java code                        Browser automation API

Myth Busters - 4 Common Misconceptions

Quick: Does Selenium itself check if your test passed or failed? Commit to yes or no.

Common Belief: Selenium automatically knows if the webpage is correct and passes or fails tests on its own.

Reality: Selenium only controls the browser and gets page data; it does not decide test success. You must write assertions in your test code to check correctness.

Why it matters: Without assertions, tests will never fail even if the page is wrong, giving false confidence.

Quick: Can you use Selenium without a browser driver executable? Commit to yes or no.

Common Belief: You can run Selenium tests without downloading or setting up a browser driver like ChromeDriver.

Reality: Selenium requires a browser driver executable to communicate with the browser; without it, tests cannot run.

Why it matters: Skipping driver setup causes tests to fail immediately, confusing beginners.

Quick: Does Selenium only work with Chrome browser? Commit to yes or no.

Common Belief: Selenium tests only run on Chrome because it is the most popular browser.

Reality: Selenium supports many browsers like Firefox, Edge, Safari, and Chrome via different drivers.

Why it matters: Limiting tests to one browser misses bugs that appear on others, reducing test coverage.

Quick: Is hardcoding driver paths the best way to manage browser drivers? Commit to yes or no.

Common Belief: Manually setting driver paths in code is the standard and best practice.

Reality: Using tools like WebDriverManager to manage drivers automatically is better and reduces errors.

Why it matters: Hardcoding paths causes setup problems on different machines and wastes time.

Expert Zone

1

Selenium commands are asynchronous at the browser level but appear synchronous in Java, which can cause timing issues if not handled with waits.

2

Different browsers implement WebDriver APIs slightly differently, so tests may behave inconsistently without careful design.

3

Using explicit waits instead of fixed sleeps prevents flaky tests caused by slow page loads or dynamic content.

When NOT to use

Selenium is not ideal for testing non-web applications or APIs; use tools like Appium for mobile apps or Postman for APIs instead. For simple unit tests, Selenium is too heavy and slow.

Production Patterns

In real projects, Selenium tests are integrated into CI/CD pipelines to run automatically on code changes. Tests use page object models to organize locators and actions, improving maintainability. Parallel test execution and cloud services like Selenium Grid or BrowserStack enable testing on many browsers and devices.

Connections

Unit Testing with JUnit

Builds-on

Understanding how to write assertions in JUnit helps verify Selenium test results effectively.

HTTP Protocol

Underlying mechanism

Knowing HTTP basics clarifies how Selenium commands are sent to browser drivers as web requests.

Robotics Automation

Same pattern

Both Selenium tests and robots follow instructions to interact with the environment automatically, showing how automation principles apply across fields.

Common Pitfalls

#1 Test fails because driver path is not set correctly.

Wrong approach:

WebDriver driver = new ChromeDriver(); // no driver path set

Correct approach:

System.setProperty("webdriver.chrome.driver", "path/to/chromedriver");
WebDriver driver = new ChromeDriver();

Root cause:

Beginners forget to tell Selenium where the browser driver executable is located.

#2 Test tries to find an element before the page loads, causing NoSuchElementException.

Wrong approach:

driver.get("https://example.com");
WebElement button = driver.findElement(By.id("submit"));

Correct approach:

driver.get("https://example.com");
new WebDriverWait(driver, Duration.ofSeconds(10))
.until(ExpectedConditions.elementToBeClickable(By.id("submit")));
WebElement button = driver.findElement(By.id("submit"));

Root cause:

Not waiting for page elements to load before interacting causes test failures.

#3 Using Thread.sleep() to wait for page elements.

Wrong approach:

Thread.sleep(5000); // fixed wait

Correct approach:

new WebDriverWait(driver, Duration.ofSeconds(5))
.until(ExpectedConditions.visibilityOfElementLocated(By.id("element")));

Root cause:

Fixed waits slow tests and cause flakiness; dynamic waits are more reliable.

Key Takeaways

Selenium Java tests automate browsers by sending commands through browser drivers to check websites automatically.

Setting up Selenium with the correct browser driver is essential for tests to run successfully.

Locating page elements and adding assertions lets you verify that the website behaves as expected.

Using tools like WebDriverManager and explicit waits improves test reliability and ease of maintenance.

Understanding Selenium’s architecture helps debug issues and write tests that work across different browsers.