Intermediate Selenium test (Intermediate)

Sample questions

5 sample questions from the Intermediate Selenium test, with the answers. Samples are taken out of the live test, so you will not meet these when you sit it.

1. According to the Page Object Model principles described in the study notes, what should the `login` method in the `LoginPage` class do?

   1. The login method should not use explicit waits
   2. The login method should return a DashboardPage instance
   3. The login method should not use the PageFactory
   4. The login method should be static

   Answer: B. The login method should return a DashboardPage instance

   In the Page Object Model, methods that navigate between pages should return the next page object to support fluent and readable test flows. The `login` method in the `LoginPage` class should return a `DashboardPage` instance to maintain this pattern, which ensures that tests can chain methods together without directly interacting with locators or the WebDriver.

2. How can you implement a custom test rule in JUnit to apply pre- and post-test actions in a realistic project scenario?

   1. Create a custom rule by implementing the TestWatcher interface and overriding the testStarted() and testFinished() methods.
   2. Implement a custom rule using the @Rule annotation and define a method with the same name as the rule.
   3. Extend the TestListener interface and override the beforeTest() and afterTest() methods.
   4. Create a custom rule by extending TestRule and override apply() to define pre- and post-test actions.

   Answer: D. Create a custom rule by extending TestRule and override apply() to define pre- and post-test actions.

   In JUnit, custom test rules are implemented by extending the TestRule interface and overriding the apply() method to define pre- and post-test actions. This allows developers to encapsulate common setup and teardown logic, such as logging or resource management, and apply it to multiple tests. Other options are incorrect because they do not align with JUnit's rule implementation mechanism.

3. What does the getWindowHandles() method in Selenium return?

   1. getWindowHandles() returns a Set<String> containing all open window handles
   2. getWindowHandles() returns a single String representing the current window handle
   3. getWindowHandles() returns a Map<String, String> containing window handles and their titles
   4. getWindowHandles() returns a List<String> containing all open window handles

   Answer: A. getWindowHandles() returns a Set<String> containing all open window handles

   In Selenium, when you call getWindowHandles(), it returns a Set<String> that contains all the window handles currently open in the browser session. This allows you to iterate through all open windows and switch between them using the handle. The other options are incorrect because they do not accurately describe the behavior of getWindowHandles() in Selenium.

4. What is the correct method to manage multiple browser windows in Selenium when a new window is opened?

   1. Use switchTo().window() without any parameters to automatically switch to the new window.
   2. Use getWindowHandles() to get all window handles and switch to the desired window using switchTo().window(handle).
   3. Use getHandles() to retrieve all window handles and directly switch to the new window using switchTo().window().
   4. Use getWindowHandle() to get the handle of the current window and switch to another window using switchTo().window(handle).

   Answer: B. Use getWindowHandles() to get all window handles and switch to the desired window using switchTo().window(handle).

   When managing multiple browser windows in Selenium, it is essential to use getWindowHandles() to retrieve all window handles and then switch to the desired window by passing the specific handle to switchTo().window(handle). This ensures the correct window is active for further interactions. Other options may lead to errors or incorrect handling of windows.

5. Which of the following annotations is used in JUnit 5 to exclude a test from execution?

   1. The @Exclude annotation is used to exclude a test from execution.
   2. The @Disabled annotation is used to exclude a test from execution.
   3. The @Ignore annotation is used to exclude a test from execution.
   4. The @NotRun annotation is used to exclude a test from execution.

   Answer: B. The @Disabled annotation is used to exclude a test from execution.

   In JUnit 5, the @Disabled annotation is used to exclude a test method or class from being executed. This is a common way to temporarily disable tests that are not ready, failing, or not applicable. Other options are not valid for test exclusion in JUnit.