How to use getSuiteName method of org.testng.reporters.EmailableReporter2.SuiteResult class

If you look at the source code of assertEquals method, you'll see that it all boils down to fail method (as do many other asserts).

public static void fail(String message) {
    if(message == null) {
        throw new AssertionError();
    } else {
        throw new AssertionError(message);
    }
}

As we can see, it throws AssertionError, which you are catching in catch(Throwable t). So JUnit has no way of telling that the test has failed, thus declaring it passed.

If catching an exception is part of your test (you are expecting an exception), I suggest you have a look at JUnit documentation: Exception testing

I use surefire-testng to run junit tests, but don't have any testng tests in the same run.

I extract the reports using:

**/surefire-reports/*.xml

You can configure surefire-testng to include or exclude any tests, perhaps you can exclude the junit tests by pattern, then have the junit47 provider run those?

surefire-reports can also be configured to collect junit and/or testng reports.

Later junit tests use annotations rather than naming conventions. testng seems to recognise this, but default behaviour of surefire-reports seems to be only collect data by naming convention.

I still use naming conventions as well as annotations in my junit tests (Test*/Test for unit and IT/*IT for integration), which allows me to control surefire and failsafe better.

Either utilise naming conventions to include tests in surefire plugins default behaviour, or configure the plugins to run specific tests and collect the data you want.

Contrary to the much-voted-up answer that @dlev gave, it can sometimes be very useful/needful to write a test like you're suggesting. The public API of a class, as expressed through its interface, is the most important thing to test. That being said, I would use neither of the approaches you mentioned, but a Parameterized test instead, where the parameters are the implementations to be tested:

@RunWith(Parameterized.class)
public class InterfaceTesting {
    public MyInterface myInterface;

    public InterfaceTesting(MyInterface myInterface) {
        this.myInterface = myInterface;
    }

    @Test
    public final void testMyMethod_True() {
        assertTrue(myInterface.myMethod(true));
    }

    @Test
    public final void testMyMethod_False() {
        assertFalse(myInterface.myMethod(false));
    }

    @Parameterized.Parameters
    public static Collection<Object[]> instancesToTest() {
        return Arrays.asList(
                    new Object[]{new MyClass1()},
                    new Object[]{new MyClass2()}
        );
    }
}

1. Redirection is a simpler way to handle different pages depending on role. The filter could be used simply for authentication, to get the User object and any associated Roles into the session.

   As James Black said, if you had a central controller you could obviate the need to put this logic in the filters. To do this you'd map the central controller to all urls (or all non-static urls). Then the filter passes a User and Roles to the central controller which decides where to send the user. If the user tries to access a URL he doesn't have permission for, this controller can decide what to do about it.

   Most major MVC web frameworks follow this pattern, so just check them out for a better understanding of this.

2. I agree with James here, too - you don't have to move everything there but it can make things simpler in the future. Personally, I think you often have to trade this one off in order to work efficiently with designers. I've often put the infrastructure and logic in to make it work but then littered my templates with static text while working with designers. Finally, went back and pulled all the static text out into the external files. Sure enough, found some spelling mistakes that way!

3. Testing - this is the big one. In my experience, a highly disciplined test-first approach can eliminate 90% of the stress in developing these apps. But unit tests are not quite enough.

   I use three kinds of tests, as indicated by the Agile community:

   • acceptance/functional tests - customer defines these with each requirement and we don't ship til they all pass (look at FitNesse, Selenium, Mercury)
   • integration tests - ensure that the logic is correct and that issues don't come up across tiers or with realistic data (look at Cactus, DBUnit, Canoo WebTest)
   • unit tests - both defines the usage and expectations of a class and provides assurance that breaking changes will be caught quickly (look at JUnit, TestNG)

So you see that unit testing is really for the benefit of the developers... if there are five of us working on the project, not writing unit tests leads one of two things:

• an explosion of necessary communication as developers try and figure out how to use (or how somebody broke) each other's classes
• no communication and increased risk due to "silos" - areas where only one developer touches the code and in which the company is entirely reliant on that developer

Even if it's just me, it's too easy to forget why I put that little piece of special case logic in the class six months ago. Then I break my own code and have to figure out how... it's a big waste of time and does nothing to reduce my stress level! Also, if you force yourself to think through (and type) the test for each significant function in your class, and figure out how to isolate any external resources so you can pass in a mock version, your design improves immeasurably. So I tend to work test-first regardless.

Arguably the most useful, but least often done, is automated acceptance testing. This is what ensures that the developers have understood what the customer was asking for. Sometimes this is left to QA, and I think that's fine, but the ideal situation is one in which these are an integral part of the development process.

The way this works is: for each requirement the test plan is turned into a script which is added to the test suite. Then you watch it fail. Then you write code to make it pass. Thus, if a coder is working on changes and is ready to check in, they have to do a clean build and run all the acceptance tests. If any fail, fix before you can check in.

"Continuous integration" is simply the process of automating this step - when anyone checks code in, a separate server checks out the code and runs all the tests. If any are broken it spams the last developer to check in until they are fixed.

I once consulted with a team that had a single tester. This guy was working through the test plans manually, all day long. When a change took place, however minor, he would have to start over. I built them a spreadsheet indicating that there were over 16 million possible paths through just a single screen, and they ponied up the $10k for Mercury Test Director in a hurry! Now he makes spreadsheets and automates the test plans that use them, so they have pretty thorough regression testing without ever-increasing QA time demands.

Once you've begun automating tests at every layer of your app (especially if you work test-first) a remarkable thing happens. Worry disappears!

So, no, it's not necessary. But if you find yourself worrying about technical debt, about the big deployment this weekend, or about whether you're going to break things while trying to quickly change to meet the suddenly-urgent customer requirements, you may want to more deeply investigate test-first development.

There can be different ways to do this

1. After login your URL redirect to another page then you can use following way-

   String newUrl = driver.getCurrentUrl();
   
   if(newUrl.equalsIgnoreCase("expected_URL")){
       System.out.println("Login Success");
   }
   else {
       // your further action 
   }
   

2. Another way can be, you can locate an element which comes after successful login e.g you can find username of logged in user

   String usename = driver.findElement(By.yourLocater).getText();
       try {
        if(usename.equalsIgnoreCase("expected username")) {
             // success message
         }
        else {
           // your further actions
        }
      }
       catch(Exception e) {
           System.out.println(e);
       }
   

3. You can use assert of TestNG framework as well

   assertEquals(newUrl, driver.getCurrentUrl());
   

How do I add a junit 4 dependency correctly?

Assuming you're resolving against a standard Maven (or equivalent) repo:

dependencies {
    ...
    testCompile "junit:junit:4.11"  // Or whatever version
}

Run those tests in the folders of tests/model?

You define your test source set the same way:

sourceSets {
    ...

    test {
        java {
            srcDirs = ["test/model"]  // Note @Peter's comment below
        }
    }
}

Then invoke the tests as:

./gradlew test

EDIT: If you are using JUnit 5 instead, there are more steps to complete, you should follow this tutorial.

Coworkers of mine at our company wrote a freely available DataProvider in TestNG style for JUnit which you can find on github (https://github.com/TNG/junit-dataprovider).

We use it in very large projects and it works just fine for us. It has some advantages over JUnit's Parameterized as it will reduce the overhead of separate classes and you can execute single tests as well.

An example looks something like this

@DataProvider
public static Object[][] provideStringAndExpectedLength() {
    return new Object[][] {
        { "Hello World", 11 },
        { "Foo", 3 }
    };
}

@Test
@UseDataProvider( "provideStringAndExpectedLength" )
public void testCalculateLength( String input, int expectedLength ) {
    assertThat( calculateLength( input ) ).isEqualTo( expectedLength );
}

Edit: Since v1.7, it also supports other ways to provide data (strings, lists) and can inline the provider so that a separate method is not necessarily needed.

A full, working example can be found on the manual page on github. It also has a few more features, like collecting the providers in utility classes and accessing them from other classes etc. The manual page is very detailed, I'm sure you'll find any questions answered there.

I think you just need to get rid of this line in both your TestNGClass2 and TestNGClass3

public static WebDriver driver;

You're already storing the driver in the base class TestNGClass1, so when you have that line in your other classes, you're basically hiding the one that is instantiated.

I'd also consider changing the base class access modifier to protected since you probably don't want classes that aren't children of that base class to access the driver.

Instead of using your surefire configuration with a property, you can:

1. Remove the surefire configuration and replace mvn test -DtestSuite=myCustomSuite.xml by mvn test -Dsurefire.suiteXmlFiles=myCustomSuite.xml. See Surefire documentation
2. Continue to use the mvn test -Dgroups=myGroup.

As the surefire configuration will be removed, the error testSuiteXmlFiles0 has null value won't be present with the -Dgroup option.

You can also use maven profiles which will configure surefire plugin depending on which property you pass to maven.

<profiles>
  <profile>
    <id>suite</id>
    <activation>
      <property>
        <name>testSuite</name>
      </property>
    </activation>
    <plugin>
      <groupId>org.apache.maven.plugins</groupId>
      <artifactId>maven-surefire-plugin</artifactId>
      <configuration>
        <suiteXmlFiles>
          <suiteXmlFile>${testSuite}</suiteXmlFile>
        </suiteXmlFiles>
      </configuration>
    </plugin>
  </profile>
</profiles>