I have to following project structure:
The directory src/test/java/ic/tests contains junit tests and the directory src/test/features/ic contains cucumber test (feature files).
But when I do a maven run (mvn test -Dcucumber.options="src/test/features/ic --tags #IC-115") to execute a single cucumber test the executor starts the junit tests in the src/test/java/ic/tests directory...
Only the corresponding feature file is annotated with #IC-115.
Even the absolute version mvn test -Dcucumber.options="C:\Users_Clemens_\Documents\test-ic\src\test\resources\features\ic\IC-115-LogOut.feature" does not execute my test.
How can I execute the single cucumber test that I want to execute?
Try to run the command with the name of the feature (exact way to the feature).
mvn test -Dcucumber.options="src/test/features/ic/FeatureName.feature"
Or if the feature is composed by more than one test you could set a specific(not used for others scenarios) tag to the test and run with
mvn verify -Dcucumber.options="--tags #specifictag"
Could solve it by adding a runner class AND moved feature files to "src/test/resources" AND added the maven-surefire-plugin with adding an exclusion to the runner class. Seems like these 3 steps are all necessary.
package kiwigrid;
import org.junit.runner.RunWith;
import cucumber.api.CucumberOptions;
import cucumber.api.junit.Cucumber;
#RunWith(Cucumber.class)
#CucumberOptions(features="src/test/resources")
public class Runner {
}
Related
I have created multiple Test case java files in eclipse and version of JUnit is JUnit5.
Now, I am trying to create a Junit TestSuite through the eclipse GUI and during the creation, I am not seeing the JUnit5 in the available versions.
This is the sample code that I have written for creation of TestSuite.
import org.junit.platform.runner.JUnitPlatform;
import org.junit.platform.suite.api.IncludeClassNamePatterns;
import org.junit.platform.suite.api.IncludeEngines;
import org.junit.runner.RunWith;
#RunWith(JUnitPlatform.class)
#IncludeClassNamePatterns(".*Tests?")
#IncludeEngines("junit-jupiter")
public class AllTests {
}
This is the error I am getting while executing.
Should I do any manual setting to be able to create/run test suites?
When executing tests in a class annotated with #RunWith, that class is technically a JUnit 4 test class.
Thus, you have to execute your test suite using the "JUnit 4 Runner" in the "Run Configurations" of Eclipse.
See the following Eclipse bug for more information: https://bugs.eclipse.org/bugs/show_bug.cgi?id=512772
Regarding the "JUnit Test Suite" dialog, that won't help you if you are using #RunWith(JUnitPlatform.class) to execute a suite in JUnit 5.
you are not using JUnit5, Junit5 FQN is org.junit.jupiter.api.*
see https://www.eclipse.org/community/eclipse_newsletter/2017/october/article5.php
I finished my two projects, one is a real one, and the other simulates a server that just generates some data, and now i made a junit test suite to test it both and all works.
Now is the time to send the real project together with the tests to a friend that made the real server project, that generates real data.
So I need now to prepare the tests somehow so he can just run them on Command Line, but I have no idea how to do that.
I searched a little on the net, and there was no way to run a test suite from the command line...and I hope you can help me.
Here is what I have in the test project:
The class AllTests is a test suite, from witch I can run all the tests listed in it:
package test.dss;
import org.junit.runner.RunWith;
import org.junit.runners.Suite;
import org.junit.runners.Suite.SuiteClasses;
#RunWith(Suite.class)
#SuiteClasses({
TestAddAndDeleteScript.class,
TestEnumerateScripts.class,
TestEnumerateTemplates.class,
TestExecute.class,
TestGetAllImportsList.class,
TestGetBindings.class,
TestGetSource.class,
TestGetTemplate.class,
TestLogin.class,
TestLogout.class,
TestOpenAndCloseFile.class,
TestReloadLastLog.class,
TestSetDates.class,
TestSetPatientList.class,
TestStartStopTimer.class,
TestUpdateBindingParameters.class,
TestUpdateScript.class,
TestUpdateSharedUserList.class,
TestUpdateTextArea.class
})
public class AllTests {
}
Then there are the tests that are for the other project:
With a similar code in the AllTests class:
package test.mw;
import org.junit.runner.RunWith;
import org.junit.runners.Suite;
import org.junit.runners.Suite.SuiteClasses;
#RunWith(Suite.class)
#SuiteClasses({
TestEnumerateParams.class,
TestEnumeratePatients.class, // za properties, pogledati red 55
TestEnumerateScripts.class,
TestGetAll.class,
TestGetResults.class,
TestLogin.class,
TestLogout.class,
TestRaiseAlarm.class,
TestRegisterUnregisterScript.class,
TestSaveResult.class
})
public class AllTests {
}
Now, I removed the tests from the workspace, and placed it on the desktop and have to figure out how to test it in command line, while my two projects run in elipse on localhost.
On top, I wanna create a BAT file witch my friend can just run (from the command line) and test his part (the mw part).
Yeah, I forgot to mention, all the jars I need to run the tests are in the JRE System Library, JUnit 4 and referenced Libraries that are from the lib folder.
So, I created a CMD Tests folder on the desktop, and copied all the files from the tests, and it looks like this:
So here are the two parts of my question:
a) How to test them all at once with the two test suites?
a.b) If there is no way, how to test each class individually?
b) How to make a bat file to run it all at once?
Please help.
There is no need to create two test suites if you want to test them together. Just place all of the test classes into single Suite.
But running tests from two suites will look somehow like this:
java -cp "lib/*;bin" org.junit.runner.JUnitCore test.dss.AllTests test.mv.AllTests
Just place a .bat file in the root of your project with this content and you're ready to go.
You can also use the same command for running a particular test, means something like:
java -cp "lib/*;bin" org.junit.runner.JUnitCore test.dss.TestExecute
Note: I don't know how you compile your classes. I guess all of them are in bin folder. If they are not just add the appropriate folder to the -cp section.
When I try running JUnit tests, I get the error message
No tests found with test runner 'JUnit 4'
and therefore I have tried solutions from
No tests found with test runner 'JUnit 4'
junit: no tests found
'No JUnit tests found' in Eclipse
However, in my case, the difference seems to be that I specify the tests to run on package level instead of folder level.
Running JUnit tests works if I specify a package that directly contains test classes (e.g. com.example.tests.smoketests) but does not work if a higher level package is specified (e.g. com.example.tests).
If I define a test in com.example.tests, it is found and run.
Is there a way to let Eclipse/JUnit find tests in a package and all subpackages?
Out of the box, there is nothing to do this for you. You can use the Suite annotation to achieve this goal in JUnit4, though this still requires you to manually define a Suite test for each package, and then include all of them in a aggregate Suite test (such they recursively call child Suites).
import org.junit.runner.RunWith;
import org.junit.runners.Suite;
import a.sub.package.AnotherSuiteTest.class;
#RunWith(Suite.class)
#Suite.SuiteClasses({
PackageLocalTestClass1.class,
PackageLocalTestClass2.class,
AnotherSuiteTest.class
})
public class JunitTestSuite {
}
I've played around with building my own utility class before which creates the entire series of tests. This article provides an analogous utility.
I have a file with file extension .feature. HOw do run this from the command line?
In order to make a batch file for each feature. I am using Cucumber-JVM with Java and Selenium.
Cucumber-JVM is based on JUnit so its just like running any unit tests from the command line
java -cp /path/to/junit.jar org.junit.runner.JUnitCore [test class name]
where test class name is annotated with #CucumberOptions whose features
refer to the feature file. If youre using Maven you could use
mvn test
If you are using Maven, you can run your .feature file this way:
mvn -Dcucumber.options="from/the/root/of/module/to/the/feature/MyFeature.feature" test
This will override the #CucumberOptions in the test runner class.
You can run any test runner or override default test runner by using the command line below. This means you only want to run the test named SmokeTestRunner. By the way, you are free to set surefire plugin in your pom.xml any way. For example, you can set up your surefire plugin in your pom.xml to run the regression test named RegressionTestRunner. It doesn't matter.
mvn -Dtest=**/SmokeTestRunner.java test
Your SmokeTestRunner java file should look like this. ->
#CucumberOptions(
features = "src/test/resources/features/Smoke.feature",
glue = {"stepdefinitions", "hooks"},
tags = "#chrome", // It runs only scenarios tagged with "#chrome"
plugin = {"pretty"/*you can add more cucumber plugins here if you want.*/},
monochrome = true)
public class SmokeTestRunner extends AbstractTestNGCucumberTests {}
For more details, have a look at the maven surefire plugin docs. (https://maven.apache.org/surefire/maven-surefire-plugin/examples/single-test.html)
I want to be able to run all tests in a project programmatically. I know Eclipse has a "Run as JUnit test" configuration which somehow grabs all the tests in a project and run them. Is there any way for me to also grab the list of tests programmatically and run them? Or is there some good way to construct a test suite containing all the test cases without manually listing out every one (all 700+) of them?
I've tried the "New... -> Test Suite" option in Eclipse, but that seems to work only for JUnit 3, identifying tests by their extending from TestCase
The test classes are JUnit 4, so their only distinguishing characteristic is the annotation, no naming convention, no subclassing from TestCase.
Thanks in advance!
Though it does not really solve your immediate problem, I find it a very useful general practice to create suites and suites of suites, e.g. for a package something like PackageFooSuite etc. and assemble these suites in one or more suites again, like ModuleFooSuite and have one top-level suite, like AllTestsSuite. That way it's easy to run both all tests in one step as well as submodule tests for the package I'm currently working on (and have the tests run quicker than if I would always run all of them):
#RunWith(Suite.class)
#Suite.SuiteClasses({ PackageFooSuite.class, PackageBarSuite.class} )
public final class AllTestsSuite {} // or ModuleFooSuite, and that in AllTests
None of the other answers did it for me. I had 40k tests I needed to run, so manually listing every class was not an option.
I did it with ClasspathSuite. A test suite that runs all Junit4 and Junit3 test cases in the class path is as follows:
import org.junit.extensions.cpsuite.ClasspathSuite;
import org.junit.extensions.cpsuite.ClasspathSuite.*;
import org.junit.runner.RunWith;
import org.junit.runner.JUnitCore;
import static org.junit.extensions.cpsuite.SuiteType.*;
#RunWith(ClasspathSuite.class)
#SuiteTypes({ JUNIT38_TEST_CLASSES, TEST_CLASSES })
public class RunAllSuite {
/* main method not needed, but I use it to run the tests */
public static void main(String args[]) {
JUnitCore.runClasses(RunAllSuite.class);
}
}
I needed to run it from command line, so this is what I did:
Downloaded cp-1.2.6.jar
Create the previously mentioned RunAllSuite
Compile the class, javac RunAllSuite.java -cp cpsuite-1.2.6.jar;junit-4.8.1.jar
run it with target tests in the class path, java -cp cpsuite-1.2.6.jar;junit-4.8.1.jar;path/to/runallsuite/folder;target/classes;target/test-classes RunAllSuite
And that's it. With the RunAllSuite above, anywhere in your code you can just do JUnitCore.runClasses(RunAllSuite.class), which runs all tests in class path. There are other config options as well which are explained in the ClasspathSuite home page.
Note also that the class given above does not print anything. If that is needed, you can do
import org.junit.extensions.cpsuite.ClasspathSuite;
import org.junit.extensions.cpsuite.ClasspathSuite.*;
import org.junit.runner.RunWith;
import org.junit.runner.JUnitCore;
import org.junit.internal.TextListener;
import static org.junit.extensions.cpsuite.SuiteType.*;
#RunWith(ClasspathSuite.class)
#SuiteTypes({ JUNIT38_TEST_CLASSES, TEST_CLASSES })
public class RunAllSuite {
public static void main(String args[]) {
JUnitCore junit = new JUnitCore();
junit.addListener(new TextListener(System.out));
junit.run(RunAllSuite.class);
}
}
You can do this fairly easily from within maven using the surefire plugin: I usually clean/compile/install my projects from the command line before comparing them for eclipse usage (mvn eclipse:clean eclipse:eclipse) and you can define a test suite in your pom which lists all the tests you want to run en masse every time you run mvn install. You're not calling them programatically, exactly, but you can certainly call them en masse.
In Eclipse (I'm using 4.6.1) - Right click the project folder, select "Run As", choose "JUnit Test"
It will run all tests in that project. Same for a package.
Of the top of my head using Spring:
Implement a TypeFilter that matches classes with methods annotated with #Test (don't forget to consider the superclasses)
Invoke classpath scanning on your top-most test package
Invoke the JUnitRunner with the scan results
More info on classpath scanning and custom type filters here
With Eclipse Indigo (possibly Helios as well) in the Run Configurations dialog box, you now have the ability to Run all tests in a selected project, package or source folder.
Also a good reference from Eclipse is the article Java Unit testing with JUnit 4.x in Eclipse.
I also recommend using the JUnit Suite annotations. Follow the link for more detail.