How to use getStart method of org.testng.TestNG class

Okay, I was able to figure it out. And of course it was incredibly dumb and makes you question all of your years being a software engineer.

The problem was this line:

String className = type.toString();

The value type was of class java.lang.reflect.Type.

Can you see the issue? Don't feel bad if you can't because I couldn't either.

If you run this code:

System.out.println(type.toString());
System.out.println(type.getTypeName());

You end up with the following output:

class java.lang.String
java.lang.String

The issue is quite obvious seeing that, I should be using getTypeName() not toString(). Of course it will throw ClassNotFoundException because class<SPACE> precedes the actual class name.

Yet when I looked at the stacktrace, I overlooked it had class<SPACE> before the name of the class.

Sigh. Good times were had learning about class loaders though.

Allure 2 listeners are managed by SPI mechanism. So there're several steps you need to do to make it works:

• Implement StepLifecycleListener interface and override required methods.
• Create META-INF/services folders in your project's resources root.
• Create a new file by the full name of this interface in the above folder.
• Add the full path to your implementation class into this file.

You can find an example in the the following project: https://github.com/sskorol/allure2-testng-report/blob/master/src/test/resources/META-INF/services/io.qameta.allure.listener.StepLifecycleListener

More info about SPI: http://docs.oracle.com/javase/tutorial/sound/SPI-intro.html

These sites both give some examples:

http://luizfar.wordpress.com/2010/09/29/page-objects/

http://www.wakaleo.com/blog/selenium-2-web-driver-the-land-where-page-objects-are-king

This page gives some details on using PageFactory to support page objects: http://code.google.com/p/selenium/wiki/PageFactory

You could extend your example to work with page objects by creating a class for each page, e.g.:

public class MainPage 
{ 
  private final WebDriver driver;  

  public MainPage(WebDriver driver) 
  {     
    this.driver = driver;  
  }   

  public void doSomething() 
  {      
    driver.findElement(By.id("something")).Click;     
  }
} 

and changing loginAs to return a class that represents the page that the browser navigates to after login:

public MainPage loginAs(String username, String password) 
{       
    driver.get("http://url_to_my_webapp");             
    driver.findElement(By.id("username")).sendKeys(username);     
    driver.findElement(By.id("pwd")).sendKeys(password);     
    driver.findElement(By.className("button")).submit();
    // Add some error checking here for login failure
    return new MainPage(driver);                   
}

In Intellij, go to "edit configurations" (Run -> Edit Configurations), in the configuration tab that comes up in the line "shorten command line" select option "classpath file"/"@argFiles (Java 9+)", last option in the drop down menu. Fixed it for me.

Let's assume your API throws if called with 0:

public static CompletableFuture<Integer> apiCall(int id) {
  return CompletableFuture.supplyAsync(() -> {
    if (id == 0) throw new RuntimeException("Please not 0!!");
    else return id;
  });
}

You can test that it works as expected with the following code (I'm using TestNG but I suspect it won't be too difficult to translate into a JUnit test):

@Test public void test_ok() throws Exception {
  CompletableFuture<Integer> result = apiCall(1);
  assertEquals(result.get(), (Integer) 1);
}

@Test(expectedExceptions = ExecutionException.class,
      expectedExceptionsMessageRegExp = ".*RuntimeException.*Please not 0!!")
public void test_ex() throws Throwable {
  CompletableFuture<Integer> result = apiCall(0);
  result.get();
}

Note that the second test uses the fact that the ExecutionException message will contain the original exception type and message and captures the expectation with a regex. If you can't do that with JUnit, you can call result.get() in a try/catch block and call throw e.getCause(); in the catch block. In other words, something like this:

@Test(expectedExceptions = RuntimeException.class,
      expectedExceptionsMessageRegExp = "Please not 0!!")
public void test_ex() throws Throwable {
  CompletableFuture<Integer> result = apiCall(0);
  try {
    result.get();
  } catch (ExecutionException e) {
    throw e.getCause();
  }
}

Make the code reusable using inheritance. Create a super class DefaultTestCase:

public class DefaultTestCase{
  @BeforeTest
  public void beforeTest() {
     System.out.println("beforeTest");
  }  
  @BeforeMethod
  public void beforeMethod() {
    System.out.println("beforeMethod");
  }  
}

and each test case class extends the DefaultTestCase:

public class ATest extends DefaultTestCase{
  @Test
  public void test() {
     System.out.println("test");
  }
  @Test
  public void anotherTest() {
     System.out.println("anotherTest");
  }
}

Output:

beforeTest
beforeMethod
test
beforeMethod
anotherTest

From testng documentation, this is how @optional is used.

@Parameters("db")
@Test
public void testNonExistentParameter(@Optional("mysql") String db) { ... }

If no parameter named "db" is found in your testng.xml file, your test method will receive the default value specified inside the @Optional annotation: "mysql".

Try by correcting your code accordingly. I think that should resolve the issue. If it still doesn't then declare the parameters at the suite tag level in testng.xml and test it.

You haven't changed the default surefire execution which is bound to the test phase in the superpom, so it's still running with its default config. The id of that execution is "default-test". You'll either need to override it to unbind it from the test phase or else just use that id for one of your own executions.

If you have same type of parameters then you can pass as a array in method parameter.

@Test (dataProvider = "Dataprovider1")
public void testScenario1(String args [])
            ) throws Exception {
    System.out.println(args[0]+"---------------- "+args[1]+" ---------------   "+args[3]+" .. so on");
}

Also if you have different type of parameter field then you can beak it with help of a helper class and then pass the reference of this class in parameter. e.g:

class Helper {
  String data1;
  String data2;
  String data3;
  Long data4;
  int data5;
  flot data6;
 -----so on------
 ----getter setter and constructor----
}

your test class

class Test {
@DataProvider(name="Dataprovider1")
public static Object[][] testData() {
    return new Object[][] {
            { new Helper("hey", "you", "guys" ..... another constructor parameters..) } }
    };

}

@Test (dataProvider = "Dataprovider1")
public void testScenario1(Helper helper) throws Exception {
    System.out.println(helper.data1+"---------------- "+helper.data2+" ---------------   "+helper.data3+" .. so on");
}
}