Java Selenium close browser after assertTrue - java

I have a code with many classes.
There is a class which creates the driver -
public class DriverDelegate {
private String baseURL = "someLink";
private WebDriver driver;
private WebDriverWait wait;
DriverDelegate(String url) {
System.setProperty("webdriver.chrome.driver", "${directory}");
driver = new ChromeDriver();
driver.get(baseURL + url);
driver.manage().window().maximize();
driver.manage().timeouts().implicitlyWait(5, TimeUnit.SECONDS);
wait = new WebDriverWait(driver, 5);
}
public WebDriver getDriver() {
return driver;
}
I create new driver for every test. And most of my lines are the ones containing assertTrue like this-
public class UserInterfaceTests extends BaseTest{
#Test
public void headerClicker() throws java.lang.Exception {
//Startup
DriverDelegate driverDelegate = new DriverDelegate("url");
WebDriver driver = driverDelegate.getDriver();
//Some random assertTrue
assertTrue("Test(HeaderClicker) - NoSuchElementException click", TestHelper.headerClicker(schedule, driver));
//I hope that it is not neccessary to put up all helper classes like TestHelper or BaseTest
Now I launch my tests from a class called Startup -
public class Startup{
#Test
public void HeaderClicker() throws Exception{ UserInterfaceTests UI = new UserInterfaceTests(); UI.headerClicker();}
My question here is how to close the browser after the assertTrue fails. Things like #AfterTest, #AfterSuite etc do not work because other methods can not use the same driver that was used in the test.
Any ideas?

Ok there are a few things I want to touch on here. First off, #shutdown -h now is correct in their comment that you shouldn't be programmatically creating test classes and running their #Test methods yourself. Let the test running framework handle that (e.g. TestNG, JUnit, etc).
To the point of your actual question, though, is that you want pre-test and post-test methods to handle behavior that occurs before and / or after your actual test method. For these to work, though, you need to let the test framework handle the running of the tests. You mentioned #AfterTest and #AfterSuite as not being correct for your use case, though not for the reason you specified (entirely). #AfterTest in TestNG only is executed once after all the test methods in all the classes inside of a <test> node specified in a suite. #AfterSuite is only executed once after all the test methods in the entire suite. What you are looking for is the #AfterMethod annotation.
Example:
public class FooTest {
private DriverDelegate driver;
#BeforeMethod
public void setup() {
try {
driver = new DriverDelegate("url");
} catch (Exception ignore) { }
}
#AfterMethod
public void tearDown() {
try {
driver.quit();
} catch (Exception ignore) { }
driver = null;
}
#Test
public void foo() {
// do test stuff
}
}
In the above code, when TestNG runs this test class, each method annotated with #Test in this class will have a corresponding #BeforeMethod execution that initializes the driver and an #AfterMethod that closes the driver even if the test fails. Couple of points to make about this type of setup with TestNG:
(1) TestNG does not create separate instances of the test class so if you save state on the class object then you cannot run the test methods themselves in parallel within a class since you would have multiple methods trying to create new drivers and save them to the same variable, corrupting the state of the other tests that are running. You can run with parallel mode of per class (e.g. have 5 threads, each running a separate test class at the same time).
(2) Why did I wrap the #BeforeMethod and #AfterMethod bodies in a try-catch block? Because TestNG takes a fail quickly on configuration method exceptions and can cause other tests that haven't run yet to be skipped so you need to deal with any code that could possibly fail. By wrapping the creating and closing of the web driver you can ignore the error and continue on running other tests. If the driver fails to be created, for instance, the driver variable will be null and that #Test method will fail but others might succeed. Ideally, you should probably have some logging of the exception so that you can investigate why the driver failed to be created, for instance.
Also, if you need to use a driver in many test classes, you can make a base class that does the creation of the driver along with the closing of it after each method and have your test classes extend that. If you have a class with a method annotated with #Test on it, it will run any #BeforeMethod methods on that test class AND on all of the super classes as well. There is guaranteed ordering of the methods between classes (though not if you have multiple #BeforeMethod methods in the same class).
public abstract class A {
#BeforeMethod
public void setupA() { }
}
public class B extends A {
#BeforeMethod
public void setupB() { }
#Test
public void foo() { }
}
In the above, when foo is run, it will have run first setupA and then setupB. After methods work in the same way, but in the reverse order.

Related

Marking test methods with #Test(dependsOnMethods=..) testNG annotation make them not to execute

I've got a problem in my production test suite runs.
testng.xml has set up to run test suite in multithreaded environment using custom listener. As result there are several driver instances that are running separately and in parallel, with each test.
Last time suite started failing and I noticed strange behavior:
Each test in each test method which has dependsOnMethods in its #Test annotation do not execute. Driver just skipps them, and does not execute #AfterTest methods as result.
Or, I suppose It does not skip them, it does not report to depend methods that "login" method is done and they can go on and execute.
But i have no idea why is it happening
Smth like this:
#BeforeClass
protected void beforeClassInit(){
setUp(///);
}
#Test
public void login() {
//login activities
}
#Test(dependsOnMethods = "login")
public void createSmth() {
///
}
#Test(dependsOnMethods = "createService")
public void deleteSmth() {
///
}
#AfterClass(alwaysRun = true)
protected void afterClass() {
shutDown();
}
See in your code,
#BeforeClass
protected void beforeClassInit(){
setUp(///);
}
#Test
public void login() {
//login activities
}
#Test(dependsOnMethods = "login", alwaysRun=true)
public void createSmth() {
///
}
#Test(dependsOnMethods = "createSmth", alwaysRun=true)
public void deleteSmth() {
///
}
#AfterClass(alwaysRun = true)
protected void afterClass() {
shutDown();
}
createSmth and deleteSmth always run even if dependant method will get fail to execute. Before and after class annotation will be run before/after the first/last test method in the current class is invoked.
#BeforeClass when multiple tests need to share the same computationally expensive setup code. #BeforeClass will be executed only once.
It works even if you will run using testng.xml in parellel
The problem was in testng logic.
Through tons of experiments it was defined, that TestNG always runs dependent methods in the end of parallel run.
Means, i.e. you have 3 Test Classes:
Test1.java
Test2.java
Test3.java
and each has some test methods.
TestNG suite contains that 3 classes will run each non-dependent method from those classes, than come back and finish run of those dependent methods which left.
Crazy behavior, but looks that's it/

How to add Grouping and Dependency in #BeforeMethod On TestNG

Is there any way to give dependency to #BeforeMethod on #Test,because in my scenario different TestMethod have different setup and I need one setup depends on TestMethod. I add here some code snippet for better understanding
#BeforeMethod(groups = {"gp2"})
public void setUp1() {
System.out.println("SetUp 1 is done");
}
#BeforeMethod(groups = {"gp1"}, dependsOnGroups = {"tgp1"})
public void setUp2() {
System.out.println("SetUp 2 is done");
}
#Test(timeOut = 1, groups = {"tgp1"})
public void testMethod() throws InterruptedException {
Thread.sleep(2000);
System.out.println("TestMethod() From Group1");
}
#Test(dependsOnMethods = {"testMethod"}, groups = {"tgp2"})
public void anotherTestMethod() {
System.out.println("AnotherTestMethod()From Group1 and Group2");
}
OutPut
SetUp 1 is done
SetUp 2 is done
but I need setUp1() should be executed not setUp2() because it is depends on tgp1 group.
Another thing I observe that,If I change dependencies from
#BeforeMethod(groups = {"gp1"}, dependsOnGroups = {"tgp1"})
to
#BeforeMethod(groups = {"gp1"}, dependsOnMethods = {"testMethod"})
then I got an Exception like
setUp2() is depending on method public void testMethod() throws java.lang.InterruptedException, which is not annotated with #Test or not included.
I need execution should be on this steps
SetUp1---->testMethod1()------->SetUp2--------->testMethod2()
I need this because different TestMethods have different work and it have different SetUp().
In your case, you can simply call respective setUp method from respective Test method as you really don't have common #BeforeMethod for each Test.
Or you can separate these two tests into different Test classes each having a #BeforeMethod.
Or you can do conditional setup call based on test method name with one #BeforeMethod method as below. Here #BeforeMethod can declare a parameter of type java.lang.reflect.Method. This parameter will receive the test method that will be called once this #BeforeMethod finishes
#BeforeMethod
public void setUp(Method method) {
if (method.getName().equals("testMethod")) {
setUp1();
} else if (method.getName().equals("anotherTestMethod")) {
setUp2();
}
}
public void setUp2() {
System.out.println("SetUp 2 is done");
}
public void setUp1() {
System.out.println("SetUp 1 is done");
}
The purpose of the #BeforeMethod is to run before each test method annotated with #Test and do some set-up work. Therefore it is somewhat confusing why you would want to create dependency that works the other way - execute the test method before set-up method.
The usual approach would be following:
#BeforeMethod
public void setUp() {
}
#Test
public void testMethod1() {
}
#Test
public void testMethod2() {
}
Which most likely generate following execution list:
setUp()
testMethod1()
setUp()
testMethod2()
If there multiple #BeforeMethods all of them will be run before the #Test method.
Now if you want to run different groups, you would annotate different methods with different groups and specify, which groups to run. However, for that you will need to provide either testng.xml or specify which groups to execute.
EDIT (based on additional comment):
I would suggest one of the following approaches:
Separate test methods into different classes and have #BeforeMethod
in each class perform required setup. This especially makes sense if
the tests are covering different areas.
Define different groups and
put corresponding test and set-up methods into same group. This
option lets you mix and match set-up methods with test method.
Some things that are unclear from your question, but if relevant could benefit from suggested approaches:
Is there need for dependency?
Does the order or the tests matter?

WeDriver FirefoxDriver cannot be used after quit() was called

i am having issues in acquiring correct driver instance.
following is my setup
public class SeleniumBase{
public static WebDriver driver;
public static void setUp(url,browser,port){
driver = new FirefoxDriver();
}
public static void tearDown(){
driver.manage().deleteAllCookies();
driver.close();
driver.quit();
}
}
public class BuildTest extends SeleniumBase{
#BeforeClass
public static void seleniumSetup(){
try{
// read properties
url = prop.getProp("baseUrl");
browser = prop.getProp("browser");
port = prop.getProp("port");
}
SeleniumBase.setUp(url,browser,port);
waitForLoginPage();
App.login();
}
#AfterClass
public static void seleniumTearDown(){
App.logOut();
SeleniumBase.tearDown();
}
}
#RunWith(Suite.class)
#Suite.SuiteClasses(
{
Test1.class,
Test2.class
})
public class SmokeSuite {
}
now, for Test1.class everything works fine but when Test2.class is invoked from the suite, new driver instance is created with the setUp method, but App.Login() throws error saying "The FirefoxDriver cannot be used after quit() was called"
is anything going wrong in my setup/teardown..?
As the comments on your question already mention, your setUp() and tearDown() methods as well as your WebDriver instance are static. So once you call driver.quit(), your driver couldn't be used any more. A new driver needs to be acquired.
However, you do not use JUnit's #Before and #After annotations but rather #BeforeClass and #AfterClass. So I guess you have multiple tests in your Test2 class, the driver quits after the first one and is not reinitialized before the second test.
Better make WebDriver, setUp() and tearDown not static and use #Before and #After in your test-classes. Then your problems should go away.
When you use driver.quit(); you close all open browsers and quit the driver. However, your driver is not set to null but remains in the void between WebDriver instance to null.
Why does this matter? Because when you call driver = new FirefoxDriver(); the constructor is "cheating" and hands you the old WebDriver instance, which considered viable because it doesn't see null, instead of initializing new instance.
Assigning null after calling quit should solve the problem.
public void tearDown() {
driver.quit();
driver = null;
}

static Webdriver instance synchronization in java

GlobalVariables class holds different variables which are used across my framework one of them is WebDriver instance:
public class GlobalVariables
{
public static WebDriver driver;
//Some other static global variables required across my framework
public GlobalVariables(String propertiesFile)
{
initializeVariables(propertiesFile);
}
public void initializeVariables(String propertiesFile)
{
GlobalInitializer obj=new GlobalInitializer();
obj.initialize(String propertiesFile);
}
}
GlobalInitializer contains methods to initialize all the GlobalVariables:
public class GlobalInitializer extends GlobalVariables
{
public void initialize(String propertiesFile)
{
//Some logic to read properties file and based on the properties set in it, call other initialization methods to set the global variables.
}
public void initializeDriverInstance(String Browser)
{
driver=new FireFoxDriver();
}
//Some other methods to initialize other global variables.
}
I have many GetElement classes which use the driver instance to get UI control elements E.g:
public class GetLabelElement extends GlobaleVariables
{
public static WebElement getLabel(String someID)
{
return driver.findElement(By.id(someId));
}
//Similar methods to get other types of label elements.
}
public class GetTextBoxElement extends GlobaleVariables
{
public static WebElement getTextBox(String someXpath)
{
return driver.findElement(By.xpath(someXpath));
}
//Similar methods to get other types of text box elements.
}
I have other classes which perform some actions on the UI Control(This classes too use the global variables) E.g:
public class GetLabelProperties extends GlobalVariables
{
public static String getLabelText(WebElement element)
{
return element.getText();
}
}
public class PerformAction extends GlobalVariables
{
public static void setText(String textBoxName,String someText)
{
driver.findElement(someLocator(textBoxName)).setText("someText");
}
//Some other methods which may or may not use the global variables to perform some action
}
My test class in testng looks like this:
public class TestClass
{
GlobalVariables globalObj=new GlobalVariables(String propertiesFile);
#Test(priority=0)
{
GlobalVariables.driver.get(someURL);
//Some assertion.
}
#Test(priority=1)
{
WebElement element=GetLabelElement.getLabel(someID);
String labelName=GetLabelProperties.getLabelText(element);
//Some assertion.
}
#Test(priority=2)
{
WebElement element=GetTextBoxElement.getTextBox(someXpath);
PerformAction.setText(element.getText(),someText);
//Some assertion.
}
}
I have similar multiple test classes based on scenarios.
Now this tests are running fine if i am running them individually. But when i try to run them in parallel, then this tests are failing in some weird fashion. On analyzing i found out that its the static global variables which are getting initialized by each tests thus leaving the other tests to fail. Now how should i go about achieving my objective to run multiple tests parallely with minimal changes in my framework design? i have tried searching for options, and i have come across some option i.e 1) use of synchronized. 2) Create ThreadLocal instance(Note : I have tried this solution but still same issue. tests are mixing up with each other resulting in failure. I had marked the WebDriver instance as ThreadLocal and overriden the initialValue method of ThreadLocal to initialize the driver instance. Still i am not sure whether i had implemented it correctly or not.). Now i am not sure how best to implement any one of this solution in the given scenario. Any help is appreciated. TIA!
I have found out the solution : Use of ThreadLocal is the best solution to run tests in a huge multithreaded environment.
Code snippet to use WebDriver in multithreaded environment:
public static ThreadLocal<WebDriver> driver;
driver=new ThreadLocal<WebDriver>()
{
#Override
protected WebDriver initialValue()
{
return new FirefoxDriver(); //You can use other driver based on your requirement.
}
};
Now every time a test thread is created a new browser will open. ThreadLocal will make sure that there's only one copy of static webdriver instance per thread. [NOTE: Make sure your other global variables are too ThreadLocals. In my case they were not thats why i was running into test goof up issue]. Some extra knowledge which i would like to share so that others may find it informative. In ThreadLocal whenever the ThreadLocal.get() method is called you have to make sure that there is a provision to initialize the thread local as shown above in initialValue() method or you may run into null pointer exception. Thanks everyone.
If you are going to run non-parallel, then using a static webdriver member (or a instance shared between test classes by passing by reference) is fine because it is a good way to not have to close the webdriver instance between test classes. If you want to run parallel though, you need to have one instance of webdriver for EACH thread and so in that case using a static member is the WRONG way to go. Instead you need to create or pass a webdriver instance when the test case class is invoked.
Also, you are breaking a test into separate tests for each step of the test. That is very unusual and I do not see the reason why you are doing that. You could really simplify your tests by keeping all the test steps within one singe test case like people usually do.
You are getting this because of how JVM handles static members and methods.
You can't have a static webdriver object if you are going to run in parallel.
Source: The automated regression system i implemented where I work - we had this issue.
you can try something like this
public class DriverManager {
private static final ThreadLocal<WebDriver> threadLocal = new ThreadLocal<WebDriver>();
public static WebDriver getDriver() {
return threadLocal.get();
}
public static void setDriver(WebDriver driver) {
threadLocal.set(driver);
}
public static void closeDriver() {
if (getDriver() != null) {
try {
getDriver().close();
} catch (Exception e) {
e.printStackTrace();
}
try {
getDriver().quit();
} catch (Exception e) {
e.printStackTrace();
}
}
threadLocal.remove();
}
}

How to run tearDown type method for a specific test in JUnit class with multiple tests?

I have a junit testCase class with multiple test methods in it ( As requirement , we don't want to create separate class for each test.)
I wanna create a tearDown type method for EACH test method , which will run specifically for that test. Not for ALL test.
My problem is , in many tests i Insert record in database, test it and delete it after test.
But, If a test fails mid way , control don't reaches till end my dummy record ain't deleting.
I think only ONE tearDown() is allowed for one class, and this tearDown() don't know what object/record i created or inserted and what to delete!!!
I want to create a tearDown() or #After method just for one specific test. Something like finally{} in java for each method.
For Eg:
public class TestDummy extends TestCase {
public void testSample1(){
InsertSomeData1();
assertFalse(true);
runTearDown1();
}
public void testSample2(){
InsertSomeData2();
assertFalse(true);
runTearDown2();
}
public void runTearDown1(){
deleteDummyDatafromTestSample1....
}
public void runTearDown2(){
deleteDummyDatafromTestSample2....
}
}
Here control will never go to runTearDown1() or runTearDown2() and I don't a one common tearDown() because it won't know what data I inserted and thats specific to each method.
It seems your test relies on a fixed database, and future tests will break if your current test breaks. What I'd recommend is not to focus on this particular problem (a test-specific tearDown method that runs for each test), but your main problem - borken tests. Before your test run, it should always work with a clean database, and this should be the case for each test. Right now, your first test has a relationship with the second (through the database).
What the right approach would be is that you recreate your database before each test, or at the very least reset it to a basic state. In this case, you'll want a test like this:
public class TestDummy {
// this code runs (once) when this test class is run.
#BeforeClass
public void setupDatabase() {
// code that creates the database schema
}
// this code runs after all tests in this class are run.
#AfterClass
public void teardownDatabase() {
// code that deletes your database, leaving no trace whatsoever.
}
// This code runs before each test case. Use it to, for example, purge the
// database and fill it with default data.
#Before
public void before() {
}
// You can use this method to delete all test data inserted by a test method too.
#After
public void after() {
}
// now for the tests themselves, we should be able to assume the database will
// always be in the correct state, independent from the previous or next test cases.
#Test
public void TestSample2() {
insertSomeData();
assertTrue(someData, isValid());
}
}
Disclaimer: JUnit 4 tests (using annotations), might not be the right annotations, might not even be the right answer(s).
You could have smth like this:
interface DBTest {
void setUpDB();
void test();
void tearDownDB();
}
class DBTestRunner {
void runTest(DBTest test) throws Exception {
test.setUpDB();
try {
test.test();
} finally {
test.tearDownDB();
}
}
}
public void test48() throws Exception {
new DBTestRunner().runTest(new DBTest() {
public void setUpDB() {...}
public void test() {...}
public void tearDownDB() {...}
});
}
#iluxa . Gr8.. Your solution is perfect!!! In one test class i created two tests test48 and test49 (same as required in my code above testSample1 and testSample2) and viola! every test method now gets its own setup() and tearDown. Only this solution looks little complicated as need to use DBTestRunner in each method, but I don't see any better solution. I was thinking Junit may have some direct solution. like #After or tearDown() with some parameter or something.
Tks a lot.
Use MethodRule:
public class MyRule implements MethodRule {
#Override
public Statement apply(final Statement base, FrameworkMethod method, Object target) {
return new Statement() {
#Override
public void evaluate() throws Throwable {
try {
base.evaluate();
} catch (AssertionError e) {
doFail();
} finally {
doAnyway();
}
}
};
}
}
Then declare it in your test class:
public class TestDummy{
public MethodRule rule = new MyRule();
......
}

Categories