From 203bd69893f8113b20afb5ba271494819b94adf5 Mon Sep 17 00:00:00 2001 From: jflorez Date: Wed, 10 Apr 2024 07:16:30 +1000 Subject: [PATCH 1/4] Update fresh_browser_per_test.en.md --- .../test_practices/encouraged/fresh_browser_per_test.en.md | 7 +++++++ 1 file changed, 7 insertions(+) diff --git a/website_and_docs/content/documentation/test_practices/encouraged/fresh_browser_per_test.en.md b/website_and_docs/content/documentation/test_practices/encouraged/fresh_browser_per_test.en.md index b5b6d249358..c00c802d3b1 100644 --- a/website_and_docs/content/documentation/test_practices/encouraged/fresh_browser_per_test.en.md +++ b/website_and_docs/content/documentation/test_practices/encouraged/fresh_browser_per_test.en.md @@ -14,6 +14,13 @@ If spinning up a new virtual machine is not practical, at least start a new WebDriver for each test. Most browser drivers like GeckoDriver and ChromeDriver will start with a clean known state with a new user profile, by default. + +A new browser per test can be achieved by using a test framework's "before each test" hook. This also implies using the "after each test" hook to close the browser + ```java WebDriver driver = new FirefoxDriver(); ``` + +```java +driver.close(); +``` From 7bc6b2135a5881eb880ac84d59c2aee6a6e6f454 Mon Sep 17 00:00:00 2001 From: Juan Florez Date: Thu, 11 Apr 2024 10:12:19 +1000 Subject: [PATCH 2/4] extend explanation of browser per test with additional code examples --- .../encouraged/fresh_browser_per_test.en.md | 20 ++++++++++++++++++- 1 file changed, 19 insertions(+), 1 deletion(-) diff --git a/website_and_docs/content/documentation/test_practices/encouraged/fresh_browser_per_test.en.md b/website_and_docs/content/documentation/test_practices/encouraged/fresh_browser_per_test.en.md index c00c802d3b1..b87834fa4c0 100644 --- a/website_and_docs/content/documentation/test_practices/encouraged/fresh_browser_per_test.en.md +++ b/website_and_docs/content/documentation/test_practices/encouraged/fresh_browser_per_test.en.md @@ -15,12 +15,30 @@ at least start a new WebDriver for each test. Most browser drivers like GeckoDriver and ChromeDriver will start with a clean known state with a new user profile, by default. -A new browser per test can be achieved by using a test framework's "before each test" hook. This also implies using the "after each test" hook to close the browser +A new browser per test can be achieved by using a test framework's "before each test" hook or fixture. This also implies using the "after each test" hook to close the browser +Using a Java framework with hooks ```java +# Before each test create a new WebDriver instance WebDriver driver = new FirefoxDriver(); ``` ```java +# After each test close the browser driver.close(); ``` + +Using python fixtures +```python +@pytest.fixture(autouse=True, scope='function') +def driver(self, request, page: Page): + # Create the driver + driver = webdriver.Firefox() + + # Return control to the test + yield self.driver + + # Test ends driver quits + driver.quit() +``` + From 70ce085792d165d06dfb7f45574707c7259094c0 Mon Sep 17 00:00:00 2001 From: Juan Florez Date: Thu, 11 Apr 2024 14:28:06 +1000 Subject: [PATCH 3/4] extend explanation of browser per test with additional code examples --- .../encouraged/fresh_browser_per_test.en.md | 45 +++++++++++++++---- 1 file changed, 37 insertions(+), 8 deletions(-) diff --git a/website_and_docs/content/documentation/test_practices/encouraged/fresh_browser_per_test.en.md b/website_and_docs/content/documentation/test_practices/encouraged/fresh_browser_per_test.en.md index b87834fa4c0..a9f4db3926f 100644 --- a/website_and_docs/content/documentation/test_practices/encouraged/fresh_browser_per_test.en.md +++ b/website_and_docs/content/documentation/test_practices/encouraged/fresh_browser_per_test.en.md @@ -15,20 +15,30 @@ at least start a new WebDriver for each test. Most browser drivers like GeckoDriver and ChromeDriver will start with a clean known state with a new user profile, by default. -A new browser per test can be achieved by using a test framework's "before each test" hook or fixture. This also implies using the "after each test" hook to close the browser +A new browser per test can be achieved by using a test framework's "before each test" hook or fixture. This also implies using the "after each test" hook to close the browser. -Using a Java framework with hooks ```java -# Before each test create a new WebDriver instance -WebDriver driver = new FirefoxDriver(); -``` +# Using a class variable +public abstract class BaseTest { + protected WebDriver driver; + ... -```java -# After each test close the browser -driver.close(); + # Before each test hook + public void setupTest() { + driver = new FirefoxDriver(); + ... + } + + # After each test hook + public void teardownTest() { + ... + driver.quit(); + } +} ``` Using python fixtures + ```python @pytest.fixture(autouse=True, scope='function') def driver(self, request, page: Page): @@ -42,3 +52,22 @@ def driver(self, request, page: Page): driver.quit() ``` +A static WebDriver will cause multiple issues both with parallel test execution but also with keeping alignment with this approach of one browser per test. Aditionally this forces the code to deal with ThreadLocal type techniques that unneccesarily complicate the code. + +```java +# Using a static variable + +# This forces the ThreadLocal variable to call driver.get() every time the driver wants to be used. + +# In general static variables in non-thread safe code can have unintended consequences and increase the maintanance effort in the code base. + +public abstract class BaseTest { + protected ThreadLocal driver; + ... + # Before each test hook + public void setupTest() { + BaseTest.driver = ThreadLocal.withInitial(()->new FirefoxDriver()); + ... + } +} +``` From bbee03ecb147f8288e9950e06c5f71a8d83cb227 Mon Sep 17 00:00:00 2001 From: Juan Florez Date: Mon, 15 Apr 2024 10:50:27 +1000 Subject: [PATCH 4/4] extend explanation of browser per test with additional code examples --- .../encouraged/fresh_browser_per_test.en.md | 11 ++-- .../encouraged/fresh_browser_per_test.ja.md | 51 ++++++++++++++++++- .../fresh_browser_per_test.pt-br.md | 50 +++++++++++++++++- .../fresh_browser_per_test.zh-cn.md | 50 +++++++++++++++++- 4 files changed, 153 insertions(+), 9 deletions(-) diff --git a/website_and_docs/content/documentation/test_practices/encouraged/fresh_browser_per_test.en.md b/website_and_docs/content/documentation/test_practices/encouraged/fresh_browser_per_test.en.md index a9f4db3926f..971cc4550d5 100644 --- a/website_and_docs/content/documentation/test_practices/encouraged/fresh_browser_per_test.en.md +++ b/website_and_docs/content/documentation/test_practices/encouraged/fresh_browser_per_test.en.md @@ -18,18 +18,18 @@ known state with a new user profile, by default. A new browser per test can be achieved by using a test framework's "before each test" hook or fixture. This also implies using the "after each test" hook to close the browser. ```java -# Using a class variable +// Using a class variable public abstract class BaseTest { protected WebDriver driver; ... - # Before each test hook + // Before each test hook public void setupTest() { driver = new FirefoxDriver(); ... } - # After each test hook + // After each test hook public void teardownTest() { ... driver.quit(); @@ -37,9 +37,8 @@ public abstract class BaseTest { } ``` -Using python fixtures - ```python +# Using python fixtures @pytest.fixture(autouse=True, scope='function') def driver(self, request, page: Page): # Create the driver @@ -64,7 +63,7 @@ A static WebDriver will cause multiple issues both with parallel test execution public abstract class BaseTest { protected ThreadLocal driver; ... - # Before each test hook + // Before each test hook public void setupTest() { BaseTest.driver = ThreadLocal.withInitial(()->new FirefoxDriver()); ... diff --git a/website_and_docs/content/documentation/test_practices/encouraged/fresh_browser_per_test.ja.md b/website_and_docs/content/documentation/test_practices/encouraged/fresh_browser_per_test.ja.md index a5c0a4a978a..84ae4a54b77 100644 --- a/website_and_docs/content/documentation/test_practices/encouraged/fresh_browser_per_test.ja.md +++ b/website_and_docs/content/documentation/test_practices/encouraged/fresh_browser_per_test.ja.md @@ -15,6 +15,55 @@ aliases: [ Firefoxの場合、既知のプロファイルでWebDriverを起動します。 Most browser drivers like GeckoDriver and ChromeDriver will start with a clean known state with a new user profile, by default. + +```java +// Using a class variable +public abstract class BaseTest { + protected WebDriver driver; + ... + + // Before each test hook + public void setupTest() { + driver = new FirefoxDriver(); + ... + } + + // After each test hook + public void teardownTest() { + ... + driver.quit(); + } +} +``` + +```python +# Using python fixtures +@pytest.fixture(autouse=True, scope='function') +def driver(self, request, page: Page): + # Create the driver + driver = webdriver.Firefox() + + # Return control to the test + yield self.driver + + # Test ends driver quits + driver.quit() +``` + ```java -WebDriver driver = new FirefoxDriver(); +# Using a static variable + +# This forces the ThreadLocal variable to call driver.get() every time the driver wants to be used. + +# In general static variables in non-thread safe code can have unintended consequences and increase the maintanance effort in the code base. + +public abstract class BaseTest { + protected ThreadLocal driver; + ... + // Before each test hook + public void setupTest() { + BaseTest.driver = ThreadLocal.withInitial(()->new FirefoxDriver()); + ... + } +} ``` diff --git a/website_and_docs/content/documentation/test_practices/encouraged/fresh_browser_per_test.pt-br.md b/website_and_docs/content/documentation/test_practices/encouraged/fresh_browser_per_test.pt-br.md index 1e13fe15f92..6106c18dfd2 100644 --- a/website_and_docs/content/documentation/test_practices/encouraged/fresh_browser_per_test.pt-br.md +++ b/website_and_docs/content/documentation/test_practices/encouraged/fresh_browser_per_test.pt-br.md @@ -15,5 +15,53 @@ pelo menos inicie um novo WebDriver para cada teste. Most browser drivers like GeckoDriver and ChromeDriver will start with a clean known state with a new user profile, by default. ```java -WebDriver driver = new FirefoxDriver(); +// Using a class variable +public abstract class BaseTest { + protected WebDriver driver; + ... + + // Before each test hook + public void setupTest() { + driver = new FirefoxDriver(); + ... + } + + // After each test hook + public void teardownTest() { + ... + driver.quit(); + } +} +``` + +```python +# Using python fixtures +@pytest.fixture(autouse=True, scope='function') +def driver(self, request, page: Page): + # Create the driver + driver = webdriver.Firefox() + + # Return control to the test + yield self.driver + + # Test ends driver quits + driver.quit() +``` + +```java +# Using a static variable + +# This forces the ThreadLocal variable to call driver.get() every time the driver wants to be used. + +# In general static variables in non-thread safe code can have unintended consequences and increase the maintanance effort in the code base. + +public abstract class BaseTest { + protected ThreadLocal driver; + ... + // Before each test hook + public void setupTest() { + BaseTest.driver = ThreadLocal.withInitial(()->new FirefoxDriver()); + ... + } +} ``` diff --git a/website_and_docs/content/documentation/test_practices/encouraged/fresh_browser_per_test.zh-cn.md b/website_and_docs/content/documentation/test_practices/encouraged/fresh_browser_per_test.zh-cn.md index d6b988f8b9c..b251bf4a462 100644 --- a/website_and_docs/content/documentation/test_practices/encouraged/fresh_browser_per_test.zh-cn.md +++ b/website_and_docs/content/documentation/test_practices/encouraged/fresh_browser_per_test.zh-cn.md @@ -15,5 +15,53 @@ aliases: [ 对于Firefox, 请使用您已知的配置文件去启动WebDriver. 大多数浏览器驱动器，像GeckoDriver和ChromeDriver那样，默认都会以干净的已知状态和一个新的用户配置文件开始。 ```java -WebDriver driver = new FirefoxDriver(); +// Using a class variable +public abstract class BaseTest { + protected WebDriver driver; + ... + + // Before each test hook + public void setupTest() { + driver = new FirefoxDriver(); + ... + } + + // After each test hook + public void teardownTest() { + ... + driver.quit(); + } +} +``` + +```python +# Using python fixtures +@pytest.fixture(autouse=True, scope='function') +def driver(self, request, page: Page): + # Create the driver + driver = webdriver.Firefox() + + # Return control to the test + yield self.driver + + # Test ends driver quits + driver.quit() +``` + +```java +# Using a static variable + +# This forces the ThreadLocal variable to call driver.get() every time the driver wants to be used. + +# In general static variables in non-thread safe code can have unintended consequences and increase the maintanance effort in the code base. + +public abstract class BaseTest { + protected ThreadLocal driver; + ... + // Before each test hook + public void setupTest() { + BaseTest.driver = ThreadLocal.withInitial(()->new FirefoxDriver()); + ... + } +} ```