I have Selenium+Eclipse+Java Project+Eclipse TestNG plugin.
For example, my code is:
public class TestClass {
#Test
public void test1() throws Exception {
...
}
//#Test
public void test2() throws Exception {
...
}
When i run TestClass as TestNG, both tests are executed.
I can't understand why test2 is executed also.
Because there is a comment "//" before #Test annotations.
Any ideas?
thanks in advance
First, you should clean the class files, then compile the project again
Related
I have a JUnit Framework with the following annotations #before, #test, #After.
However when I run through my tests the #After Annotation is never initialised and therefore the browser doesn't close.
I've run my tests using JUnit and they all pass but the tear down step never works.
I decided to try see if any of the annotations worked, so I removed the #before and #test and the test still run and passed which suggests to me that they are not being used at all.
This is my Selenium set up:
public SeleniumSetup() {
}
#Before
public void prepareBrowserForSelenium() throws Exception {
// setup();
if(DriverSingleton.getDriver() == null)
{
setup();
}
else
{
driver = DriverSingleton.getDriver();
}
}
public void setup() throws Exception {
System.setProperty("webdriver.chrome.driver", "C:\\Users\\antho\\Automation\\WebAutomation\\chromedriver.exe");
driver = new ChromeDriver();
driver.get("https://www.ultimateqa.com");
driver.manage().window().maximize();
DuringTest();
}
#Test
public void DuringTest() throws Exception{
System.out.println("test has started");
assertEquals(true, driver.getPageSource().contains("Learn Critical Automation and Dev Skills"));
System.out.println("Learn Critical Automation and Dev Skills copy has been verified");
driver.findElement(By.linkText("Automation Exercises")).click();
assertEquals(true, driver.getPageSource().contains("Automation Practice"));
System.out.println("Automation Practice copy has been verified");
driver.findElement(By.linkText("Big page with many elements")).click();
}
#After
public static void tearDown() throws Exception {
driver.close();
}
This is my DriverSingleton;
private static WebDriver driver;
public DriverSingleton () {
}
public static WebDriver getDriver() {
return driver;
}
public static void setDriver (WebDriver driver) {
DriverSingleton.driver = driver;
}
}
After my tests have run I expect the browser to close down.
I have added DuringTest(); to my #Before class, which I suspect is the only reason the #Test class is getting called, without that this the #Test doesn't work.
First you shall not invoke #Test inside your setup method by calling DuringTest(). JUnit framework would take care of Test Method by looking #Test annotations. So you do not need to call it explicitly.
Make both #Before & #After method as non static.
If you were running a test with this code you should have seen an exception with the following message being thrown by JUnit:
Method tearDown() should not be static
Method annotated with JUnit test annotations should always be non-static and located inside dedicated classes used exclusively for running tests. Use the following code as a base to further build your test class:
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
public class SeleniumTest {
#Before
public void prepareBrowserForSelenium() throws Exception {
System.out.println("Running method annotated with #Before");
}
#Test
public void DuringTest() throws Exception {
System.out.println("Running main test method");
}
#After
public static void tearDown() throws Exception {
System.out.println("Running method annotated with #After");
}
}
Console output:
Running method annotated with #Before
Running main test method
Running method annotated with #After
As you see everything work just fine. I would suggest reading more about JUnit testing in general and here is a good place to start:
https://github.com/junit-team/junit4/wiki/Getting-started
My #Before and #After methods are not picking up by Junit
public class TestSetup {
#Before
public void browserSetUp() {
// code for before a test
}
#After
public void tearDown() {
// code after a test
}
}
In Another class file I have defined
public class Steps{
#Step
public void step1() {
//Code for step 1
}
#Step
public void step2() {
// Code for Step 2
}
}
Finally I am calling those steps for my Test
public class Tests {
Steps step = new Steps();
#Test
public void TC_0001 {
step.step1();
step.step2();
}
}
#Test method are getting executed but the #Before and #After methods are not executing before #Test method.Do I have to include the TestSetup class to somewhere ? Any help will be appreciated.
**Thought 1: As I am using Maven to build, my #Before #After methods resides in a class (TestSetup.java - Name is not ending with *Test.java and may be thats why Maven is not picking it up for execution?
#Before and #After are used in the same class that your test is running. You should put this methods on your test class:
public class Tests {
Steps step = new Steps();
#Test
public void TC_0001 {
step.step1();
step.step2();
}
#Before
public void browserSetUp() {
// code for before a test
}
#After
public void tearDown() {
// code after a test
}
}
#Before and #After are only executed before a single test, if they are defined in the same class as the #Test. In your case, the TestSetup class contains no tests. So either you let Test inherit from TestSetup or you create a rule that is executed "around" your test.
I can use Arquillian TestRunner JUnit Container to write sequential tests.
import org.jboss.arquillian.junit.InSequence;
import org.jboss.arquillian.junit.Arquillian;
#RunWith(Arquillian.class)
public class ClassToTest{
#Test
#InSequence(1)
public void test1() {
// test something (1)
}
#Test
#InSequence(2)
public void test2() {
// test something (2)
}
}
It is possible to do same thing using Arquillian TestRunner TestNG Container? If so how can I do that.
Yes. You can do the sequencing of test methods by dependency chaining in TestNG.
it would be like the below
#Test
public void test1() {
// test something (1)
}
#Test(dependsOnMethods = { "test1" })
public void test2() {
// test something (2)
}
Please refer the below for more info
http://www.tutorialspoint.com/testng/testng_dependency_test.htm
I have few JUnit Tests and I want to decide which one to use at runtime. I checked previous answers at SO and I ended up creating Test Suite dynamically.
This class is where my application starts. I have CustomTestSuite class and Main class adds Tests to my custom suite.
public class Main {
public static junit.framework.TestSuite suite()
{
CustomTestSuite suite = new CustomTestSuite();
suite.addTest(new JUnit4TestAdapter(BTest.class));
suite.addTest(new JUnit4TestAdapter(ATest.class));
return suite;
}
}
CustomTestSuite.java
public class CustomTestSuite extends TestSuite {
#BeforeClass
public static void setUp() throws Exception {
System.out.println("Before class test");
}
#After
public void tearDown() throws Exception {
System.out.println("After class test");
}
}
My ATest and BTest are simple Test classes, I will just show ATest as sample:
public class ATest{
#Test
public void testMethod() {
System.out.println("testMethod");
}
}
When I start running my project from Main class, it is expected to run the method with #BeforeClass first, do testing, and then run the method with #AfterClass annotation.
Tests are working fine but it skips setUp method and tearDown method. I tried #Before and #BeforeClass annotations both.
I am confused with suite structure. Any help would be appreciated.
Thanks
#Before and #BeforeClass are supposed to be used in Test class not in TestSuite. If need to have common setUp and tearDown for more than one Test class, then put those both methods in a super class and extend that super by ATest and BTest test classes. And also the Suite can be built and run simply with #RunWith and #SuiteClasses annotations and the CustomTestSuite class is not needed.
So the changes are as below.
The CustomTestSuite becomes TestSuper
public class TestSuper {
#BeforeClass
public static void setUp() throws Exception {
System.out.println("Before class test");
}
#After
public void tearDown() throws Exception {
System.out.println("After class test");
}
}
Now the ATest extends TestSuper
public class ATest extends TestSuper {
#Test
public void testMethod() {
System.out.println("testMethod");
}
}
Similarly BTest also should extend TestSuper.
Simply add #RunWith and #SuiteClasses annotations to Main class as below and run Main.
#RunWith(Suite.class)
#SuiteClasses({ATest.class, BTest.class})
public class Main {
}
Have a go with these changes.
I have the following code:
#BeforeClass
public static void setUpOnce() throws InterruptedException {
fail("LOL");
}
And various other methods that are either #Before, #After, #Test or #AfterClass methods.
The test doesn't fail on start up as it seems it should. Can someone help me please?
I have JUnit 4.5
The method is failing in an immediate call to setUp() which is annotated as #before.
Class def is :
public class myTests extends TestCase {
do NOT extend TestCase AND use annotations at the same time!
If you need to create a test suite with annotations, use the RunWith annotation like:
#RunWith(Suite.class)
#Suite.SuiteClasses({ MyTests.class, OtherTest.class })
public class AllTests {
// empty
}
public class MyTests { // no extends here
#BeforeClass
public static void setUpOnce() throws InterruptedException {
...
#Test
...
(by convention: class names with uppercase letter)
the method must be static and not directly call fail (otherwise the other methods won't be executed).
The following class shows all the standard JUnit 4 method types:
public class Sample {
#BeforeClass
public static void beforeClass() {
System.out.println("#BeforeClass");
}
#Before
public void before() {
System.out.println("#Before");
}
#Test
public void test() {
System.out.println("#Test");
}
#After
public void after() {
System.out.println("#After");
}
#AfterClass
public static void afterClass() {
System.out.println("#AfterClass");
}
}
and the ouput is (not surprisingly):
#BeforeClass
#Before
#Test
#After
#AfterClass
Make sure you imported #Test from the correct package.
Correct package: org.junit.Test
Incorrect pacakge: org.junit.jupiter.api.Test
Please note that this is a solution for: If your #Before, #Atter, etc did not get called at all.
Make sure that :
Your test class doesn't inherits from TestCase
The #BeforeClass method is static
You don't have more than one #BeforeClass method in test class hierarchy (only the most specialized #BeforeClass method will be executed)
Check your imports.
#Before
#After
#BeforeClass (this should be static)
#AfterClass (this should be static)
and #Test annotations should import from same path.
In order that the before annotated function will run , I had to do the following:
If you use Maven , add a dependency to Junit 4.11+:
<properties>
<version.java>1.7</version.java>
<version.log4j>1.2.13</version.log4j>
<version.mockito>1.9.0</version.mockito>
<version.power-mockito>1.4.12</version.power-mockito>
<version.junit>4.11</version.junit>
<version.power-mockito>1.4.12</version.power-mockito>
</properties>
and the dependency:
<dependencies>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>${version.junit}</version>
<scope>test</scope>
</dependency>
.
.
.
</dependencies>
Make sure your Junit Test class is not extending The TestCase class, since this will cause overlapping with Older version:
public class TuxedoExceptionMapperTest{
protected TuxedoExceptionMapper subject;
#Before
public void before() throws Exception {
subject = TuxedoExceptionMapper.getInstance();
System.out.println("Start");
MockitoAnnotations.initMocks(this);
}
}