From 317697fb39d4ce8c7f9092567ef0f3f6382de661 Mon Sep 17 00:00:00 2001 From: Peter Thomas Date: Sun, 23 Sep 2018 18:35:04 +0530 Subject: [PATCH] sweeping cleanup, deprecating cucumber references #444 --- README.md | 65 ++++--- .../resources/archetype-resources/pom.xml | 2 +- .../java/com/intuit/karate/CallContext.java | 2 +- .../main/java/com/intuit/karate/IdeUtils.java | 2 +- .../java/com/intuit/karate/KarateOptions.java | 108 ++---------- .../java/com/intuit/karate/KarateStats.java | 150 ++++++++++++++++ .../main/java/com/intuit/karate/Runner.java | 166 ++++++++++++++++++ .../java/com/intuit/karate/RunnerOptions.java | 155 ++++++++++++++++ .../com/intuit/karate/ScenarioContext.java | 2 +- .../karate/core/FeatureExecutionUnit.java | 1 - .../{cucumber => core}/ScenarioInfo.java | 2 +- .../karate/cucumber/CucumberRunner.java | 131 ++------------ .../intuit/karate/cucumber/KarateStats.java | 16 +- .../java/cucumber/api/CucumberOptions.java | 3 +- .../com/intuit/karate/KarateOptionsTest.java | 33 ---- .../test/java/com/intuit/karate/MainTest.java | 27 --- .../com/intuit/karate/RunnerOptionsTest.java | 44 +++++ ...ucumberRunnerTest.java => RunnerTest.java} | 32 ++-- .../{cucumber => }/called-arg-loop.feature | 0 .../{cucumber => }/called-arg-null.feature | 0 .../{cucumber => }/called-arg-single.feature | 0 .../karate/{cucumber => }/caller-arg.feature | 0 .../FeatureEditTest.java} | 6 +- .../{cucumber => core}/FeatureResultTest.java | 4 +- .../{cucumber => core}/FeatureReuseTest.java | 4 +- .../intuit/karate/core/ScenarioHookTest.java | 8 +- .../karate/{cucumber => core}/aborted.feature | 0 .../{cucumber => core}/called-shared.feature | 0 .../{cucumber => core}/called-shared2.feature | 0 .../karate/{cucumber => core}/called.feature | 0 .../{cucumber => core}/called_2.feature | 0 .../{cucumber => core}/caller-shared.feature | 0 .../karate/{cucumber => core}/caller.feature | 0 .../{cucumber => core}/caller_2.feature | 0 .../karate/{cucumber => core}/failed.feature | 0 .../karate/{cucumber => core}/outline.feature | 0 .../{cucumber => core}/scenario.feature | 0 .../karate/{cucumber => core}/table.feature | 0 .../com/intuit/karate/core/test-error.feature | 1 + .../multi-scenario-fail.feature | 0 .../{cucumber => }/multi-scenario.feature | 0 .../{cucumber => }/no-scenario-name.feature | 0 .../com/intuit/karate/ui/threadtest.feature | 1 + karate-demo/README.md | 2 +- karate-demo/build.gradle | 4 +- karate-demo/src/test/java/demo/DemoTest.java | 4 +- .../src/test/java/demo/DemoTestParallel.java | 10 +- .../demo/callarray/CallJsonArrayRunner.java | 4 +- .../calldynamic/CallDynamicJsonRunner.java | 4 +- .../demo/callfeature/CallFeatureRunner.java | 4 +- .../demo/callnested/CallNestedRunner.java | 4 +- .../java/demo/calltable/CallTableRunner.java | 4 +- .../test/java/demo/cats/CatsPutRunner.java | 4 +- .../src/test/java/demo/cats/CatsRunner.java | 4 +- .../test/java/demo/cats/CatsXmlRunner.java | 4 +- .../test/java/demo/cats/KittensRunner.java | 4 +- .../src/test/java/demo/cats/SyntaxRunner.java | 4 +- .../src/test/java/demo/dogs/DogsRunner.java | 4 +- .../src/test/java/demo/error/ErrorRunner.java | 4 +- .../headers/CallIsolatedConfigRunner.java | 4 +- .../headers/CallIsolatedHeadersRunner.java | 4 +- .../demo/headers/CallUpdatesConfigRunner.java | 4 +- .../headers/CallonceBackgroundRunner.java | 4 +- .../java/demo/headers/ContentTypeRunner.java | 4 +- .../demo/headers/HeadersFormGetRunner.java | 4 +- .../test/java/demo/headers/HeadersRunner.java | 4 +- .../demo/headers/HeadersSingleRunner.java | 4 +- .../java/demo/headers/NullHeaderRunner.java | 4 +- .../test/java/demo/hooks/CalledRunner.java | 4 +- .../src/test/java/demo/hooks/HooksRunner.java | 4 +- .../java/demo/loopcall/AltLoopCallRunner.java | 4 +- .../java/demo/loopcall/LoopCallRunner.java | 4 +- .../test/java/demo/oauth/Oauth1Runner.java | 4 +- .../test/java/demo/oauth/Oauth2Runner.java | 4 +- .../test/java/demo/outline/OutlineRunner.java | 4 +- .../test/java/demo/polling/PollingRunner.java | 4 +- .../src/test/java/demo/read/ReadRunner.java | 4 +- .../java/demo/redirect/RedirectRunner.java | 4 +- .../test/java/demo/search/SearchRunner.java | 4 +- .../test/java/demo/tags/TagsFireRunner.java | 4 +- .../demo/tags/TagsSmokeNotFireRunner.java | 4 +- .../test/java/demo/tags/TagsSmokeRunner.java | 4 +- .../java/demo/upload/UploadImageRunner.java | 4 +- .../upload/UploadMultipleFieldsRunner.java | 4 +- .../upload/UploadMultipleFilesRunner.java | 4 +- .../test/java/demo/upload/UploadRunner.java | 4 +- .../PaymentServiceContractSslTest.java | 4 +- .../contract/PaymentServiceContractTest.java | 4 +- ...aymentServiceContractUsingMockSslTest.java | 4 +- .../PaymentServiceContractUsingMockTest.java | 4 +- .../test/java/mock/micro/MicroMockRunner.java | 4 +- .../test/java/mock/micro/WebMockRunner.java | 4 +- .../mock/proxy/DemoMockProceedRunner.java | 10 +- .../java/mock/proxy/DemoMockProxyRunner.java | 10 +- .../test/java/mock/proxy/DemoMockRunner.java | 10 +- .../java/mock/proxy/DemoMockSslRunner.java | 10 +- .../test/java/mock/web/CatsTestRunner.java | 4 +- karate-demo/src/test/java/ssl/SslTest.java | 4 +- .../intuit/karate/gatling/KarateAction.scala | 4 +- .../test/java/demo/JerseyHttpClientTest.java | 10 +- karate-jersey/src/test/java/ssl/SslTest.java | 10 +- .../java/com/intuit/karate/junit4/Karate.java | 30 +--- .../intuit/karate/junit4/KarateJunitTest.java | 4 +- .../junit4/cukeoptions/FirstRunner.java | 16 -- .../karate/junit4/cukeoptions/FirstTest.java | 15 -- .../junit4/cukeoptions/ParallelWarnTest.java | 22 --- .../junit4/cukeoptions/SecondRunner.java | 16 -- .../karate/junit4/demos/CallOnceRunner.java | 4 +- .../karate/junit4/demos/CallTagRunner.java | 4 +- .../karate/junit4/demos/ChineseRunner.java | 4 +- .../karate/junit4/demos/CompatRunner.java | 4 +- .../junit4/demos/ConfigReuseRunner.java | 4 +- .../karate/junit4/demos/CopyCallerRunner.java | 4 +- .../karate/junit4/demos/CountriesRunner.java | 4 +- .../demos/EachPredicateDollarRunner.java | 4 +- .../karate/junit4/demos/ExamplesRunner.java | 4 +- .../karate/junit4/demos/FailRunner.java | 4 +- .../demos/FailSkippedParallelRunner.java | 10 +- .../junit4/demos/FailSkippedRunner.java | 4 +- .../karate/junit4/demos/JsArraysRunner.java | 4 +- .../karate/junit4/demos/LowerCaseRunner.java | 4 +- .../MatchFailureReportingInArraysRunner.java | 6 +- .../karate/junit4/demos/NotEqualsRunner.java | 4 +- .../karate/junit4/demos/PrintRunner.java | 4 +- .../junit4/demos/RandomJsonPathRunner.java | 4 +- .../demos/ReadFromRelativePathRunner.java | 4 +- .../karate/junit4/demos/ReplaceRunner.java | 4 +- .../demos/ScenarioVariableScopeRunner.java | 4 +- .../karate/junit4/demos/SchemaLikeRunner.java | 4 +- .../karate/junit4/demos/SoapCalcRunner.java | 4 +- .../karate/junit4/demos/SoapRunner.java | 4 +- .../karate/junit4/demos/SortArrayRunner.java | 4 +- .../karate/junit4/demos/TagsRunner.java | 4 +- .../karate/junit4/demos/TypeConvRunner.java | 4 +- .../karate/junit4/demos/UsersRunner.java | 4 +- .../junit4/demos/XmlAndXpathRunner.java | 4 +- .../karate/junit4/files/PropertiesRunner.java | 4 +- .../karate/junit4/files/WorkingDirRunner.java | 4 +- .../junit4/files/relative/CallerRunner.java | 4 +- .../karate/junit4/http/ChromeRunner.java | 4 +- .../junit4/large/LargePayloadRunner.java | 5 +- .../karate/junit4/options/FirstRunner.java | 16 ++ .../karate/junit4/options/OptionsTest.java | 13 ++ .../junit4/options/ParallelWarnTest.java | 21 +++ .../karate/junit4/options/SecondRunner.java | 16 ++ .../{cukeoptions => options}/first.feature | 0 .../outline-only.feature | 0 .../{cukeoptions => options}/second.feature | 0 .../karate/junit4/selenium/SampleRunner.java | 4 +- .../java/demo/MockSpringMvcServletTest.java | 10 +- .../com/intuit/karate/mock/BinaryRunner.java | 4 +- .../intuit/karate/mock/HelloWorldRunner.java | 4 +- .../intuit/karate/mock/MockServerTest.java | 10 +- .../intuit/karate/mock/NoHeadersRunner.java | 4 +- .../com/intuit/karate/netty/ClientRunner.java | 4 +- .../karate/netty/FeatureServerTest.java | 4 +- 156 files changed, 920 insertions(+), 675 deletions(-) create mode 100644 karate-core/src/main/java/com/intuit/karate/KarateStats.java create mode 100644 karate-core/src/main/java/com/intuit/karate/Runner.java create mode 100644 karate-core/src/main/java/com/intuit/karate/RunnerOptions.java rename karate-core/src/main/java/com/intuit/karate/{cucumber => core}/ScenarioInfo.java (98%) delete mode 100644 karate-core/src/test/java/com/intuit/karate/KarateOptionsTest.java delete mode 100644 karate-core/src/test/java/com/intuit/karate/MainTest.java create mode 100644 karate-core/src/test/java/com/intuit/karate/RunnerOptionsTest.java rename karate-core/src/test/java/com/intuit/karate/{cucumber/CucumberRunnerTest.java => RunnerTest.java} (80%) rename karate-core/src/test/java/com/intuit/karate/{cucumber => }/called-arg-loop.feature (100%) rename karate-core/src/test/java/com/intuit/karate/{cucumber => }/called-arg-null.feature (100%) rename karate-core/src/test/java/com/intuit/karate/{cucumber => }/called-arg-single.feature (100%) rename karate-core/src/test/java/com/intuit/karate/{cucumber => }/caller-arg.feature (100%) rename karate-core/src/test/java/com/intuit/karate/{cucumber/CucumberUtilsTest.java => core/FeatureEditTest.java} (98%) rename karate-core/src/test/java/com/intuit/karate/{cucumber => core}/FeatureResultTest.java (98%) rename karate-core/src/test/java/com/intuit/karate/{cucumber => core}/FeatureReuseTest.java (97%) rename karate-core/src/test/java/com/intuit/karate/{cucumber => core}/aborted.feature (100%) rename karate-core/src/test/java/com/intuit/karate/{cucumber => core}/called-shared.feature (100%) rename karate-core/src/test/java/com/intuit/karate/{cucumber => core}/called-shared2.feature (100%) rename karate-core/src/test/java/com/intuit/karate/{cucumber => core}/called.feature (100%) rename karate-core/src/test/java/com/intuit/karate/{cucumber => core}/called_2.feature (100%) rename karate-core/src/test/java/com/intuit/karate/{cucumber => core}/caller-shared.feature (100%) rename karate-core/src/test/java/com/intuit/karate/{cucumber => core}/caller.feature (100%) rename karate-core/src/test/java/com/intuit/karate/{cucumber => core}/caller_2.feature (100%) rename karate-core/src/test/java/com/intuit/karate/{cucumber => core}/failed.feature (100%) rename karate-core/src/test/java/com/intuit/karate/{cucumber => core}/outline.feature (100%) rename karate-core/src/test/java/com/intuit/karate/{cucumber => core}/scenario.feature (100%) rename karate-core/src/test/java/com/intuit/karate/{cucumber => core}/table.feature (100%) rename karate-core/src/test/java/com/intuit/karate/{cucumber => }/multi-scenario-fail.feature (100%) rename karate-core/src/test/java/com/intuit/karate/{cucumber => }/multi-scenario.feature (100%) rename karate-core/src/test/java/com/intuit/karate/{cucumber => }/no-scenario-name.feature (100%) delete mode 100755 karate-junit4/src/test/java/com/intuit/karate/junit4/cukeoptions/FirstRunner.java delete mode 100644 karate-junit4/src/test/java/com/intuit/karate/junit4/cukeoptions/FirstTest.java delete mode 100644 karate-junit4/src/test/java/com/intuit/karate/junit4/cukeoptions/ParallelWarnTest.java delete mode 100755 karate-junit4/src/test/java/com/intuit/karate/junit4/cukeoptions/SecondRunner.java create mode 100755 karate-junit4/src/test/java/com/intuit/karate/junit4/options/FirstRunner.java create mode 100644 karate-junit4/src/test/java/com/intuit/karate/junit4/options/OptionsTest.java create mode 100644 karate-junit4/src/test/java/com/intuit/karate/junit4/options/ParallelWarnTest.java create mode 100755 karate-junit4/src/test/java/com/intuit/karate/junit4/options/SecondRunner.java rename karate-junit4/src/test/java/com/intuit/karate/junit4/{cukeoptions => options}/first.feature (100%) rename karate-junit4/src/test/java/com/intuit/karate/junit4/{cukeoptions => options}/outline-only.feature (100%) rename karate-junit4/src/test/java/com/intuit/karate/junit4/{cukeoptions => options}/second.feature (100%) diff --git a/README.md b/README.md index f78a275b4..0c8d722cb 100755 --- a/README.md +++ b/README.md @@ -451,18 +451,18 @@ file:/projects/myproject/target/surefire-reports/TEST-mypackage.myfeature.html You can easily select (double-click), copy and paste this `file:` URL into your browser address bar. This report is useful for troubleshooting and debugging a test because all requests and responses are shown in-line with the steps, along with error messages and the output of [`print`](#print) statements. Just re-fresh your browser window if you re-run the test. -## Cucumber Options -To run only a specific feature file from a JUnit test even if there are multiple `*.feature` files in the same folder (or sub-folders), use the [`@CucumberOptions`](https://cucumber.io/docs/reference/jvm#configuration) annotation. +## Karate Options +To run only a specific feature file from a JUnit test even if there are multiple `*.feature` files in the same folder (or sub-folders), use the `@KarateOptions` annotation. ```java package animals.cats; +import com.intuit.karate.KarateOptions; import com.intuit.karate.junit4.Karate; -import cucumber.api.CucumberOptions; import org.junit.runner.RunWith; @RunWith(Karate.class) -@CucumberOptions(features = "classpath:animals/cats/cats-post.feature") +@KarateOptions(features = "classpath:animals/cats/cats-post.feature") public class CatsPostRunner { } @@ -471,7 +471,7 @@ public class CatsPostRunner { The `features` parameter in the annotation can take an array, so if you wanted to associate multiple feature files with a JUnit test, you could do this: ```java -@CucumberOptions(features = { +@KarateOptions(features = { "classpath:animals/cats/cats-post.feature", "classpath:animals/cats/cats-get.feature"}) ``` @@ -479,13 +479,11 @@ The `features` parameter in the annotation can take an array, so if you wanted t And most convenient of all, you can even point to a directory (or package). Combine this with [tags](#test-suites) to execute multiple features, without having to list every one of them. ```java -@CucumberOptions(features = "classpath:animals/cats", tags = "~@ignore") +@KarateOptions(features = "classpath:animals/cats", tags = "~@ignore") // this will run all feature files in 'animals/cats' // except the ones tagged as @ignore ``` -> Note that any `plugins` specified on the [`@CucumberOptions`](https://cucumber.io/docs/reference/jvm) annotation will be ignored when using `@RunWith(Karate.class)`, because Karate's execution life-cycle is not compatible with 'native' Cucumber reports. This is not a limitation of Karate at all - as for API tests, you will only ever need the [parallel report](#test-reports) (which also produces standard JUnit and Cucumber-JSON output) or the [HTML report](#junit-html-report). - ## Command Line Normally in dev mode, you will use your IDE to run a `*.feature` file directly or via the companion 'runner' JUnit Java class. When you have a 'runner' class in place, it would be possible to run it from the command-line as well. @@ -495,23 +493,23 @@ Note that the `mvn test` command only runs test classes that follow the `*Test.j mvn test -Dtest=CatsRunner ``` -When your Java test "runner" is linked to multiple feature files, which will be the case when you use the recommended [parallel runner](#parallel-execution), you can narrow down your scope to a single feature (or even directory) via the command-line, useful in dev-mode. Note how even [tags](#tags) to exclude (or include) can be specified using the [Cucumber options](#cucumber-options). +When your Java test "runner" is linked to multiple feature files, which will be the case when you use the recommended [parallel runner](#parallel-execution), you can narrow down your scope to a single feature (or even directory) via the command-line, useful in dev-mode. Note how even [tags](#tags) to exclude (or include) can be specified using the [Karate options](#karate-options). ``` -mvn test -Dcucumber.options="--tags ~@ignore classpath:demo/cats/cats.feature" -Dtest=DemoTestParallel +mvn test -Dkarate.options="--tags ~@ignore classpath:demo/cats/cats.feature" -Dtest=DemoTestParallel ``` -Multiple feature files (or paths) can be specified, de-limited by the space character. They should be at the end of the `cucumber.options`. +Multiple feature files (or paths) can be specified, de-limited by the space character. They should be at the end of the `karate.options`. ### Command Line - Gradle -For gradle you must extend the test task to allow the `cucumber.options` to be passed to the Cucumber-JVM (otherwise they get consumed by gradle itself). To do that, add the following: +For gradle you must extend the test task to allow the `karate.options` to be passed to the runtime (otherwise they get consumed by Gradle itself). To do that, add the following: ```yml test { - // pull cucumber options into the cucumber jvm - systemProperty "cucumber.options", System.properties.getProperty("cucumber.options") - // pull karate options into the jvm + // pull karate options into the runtime + systemProperty "karate.options", System.properties.getProperty("karate.options") + // pull karate env into the runtime systemProperty "karate.env", System.properties.getProperty("karate.env") // ensure tests are always run outputs.upToDateWhen { false } @@ -530,15 +528,15 @@ And then the above command in gradle would look like: One way to define 'test-suites' in Karate is to have a JUnit class with the `@RunWith(Karate.class)` annotation at a level 'above' (in terms of folder hierarchy) all the `*.feature` files in your project. So if you take the previous [folder structure example](#naming-conventions), you can do this on the command-line: ``` -mvn test -Dcucumber.options="--tags ~@ignore" -Dtest=AnimalsTest +mvn test -Dkarate.options="--tags ~@ignore" -Dtest=AnimalsTest ``` -Here, `AnimalsTest` is the name of the Java class we designated to run the multiple `*.feature` files that make up your test-suite. Cucumber has a neat way to [tag your tests](#cucumber-tags) and the above example demonstrates how to run all tests _except_ the ones tagged `@ignore`. +Here, `AnimalsTest` is the name of the Java class we designated to run the multiple `*.feature` files that make up your test-suite. There is a neat way to [tag your tests](#cucumber-tags) and the above example demonstrates how to run all tests _except_ the ones tagged `@ignore`. -The tag options can be specified in the test-class via the `@CucumberOptions` annotation, in which case you don't need to pass the `-Dcucumber.options` on the command-line: +The tag options can be specified in the test-class via the `@KarateOptions` annotation, in which case you don't need to pass the `-Dkarate.options` on the command-line: ```java -@CucumberOptions(tags = {"~@ignore"}) +@KarateOptions(tags = {"~@ignore"}) ``` You can 'lock down' the fact that you only want to execute the single JUnit class that functions as a test-suite - by using the following [maven-surefire-plugin configuration](http://maven.apache.org/surefire/maven-surefire-plugin/examples/inclusion-exclusion.html): @@ -553,29 +551,29 @@ You can 'lock down' the fact that you only want to execute the single JUnit clas animals/AnimalsTest.java - --tags ~@ignore + --tags ~@ignore ``` -Note how the `cucumber.options` can be specified using the `` configuration. Options here would over-ride corresponding options specified if a `@CucumberOptions` annotation is present (on `AnimalsTest.java`). +Note how the `karate.options` can be specified using the `` configuration. Options here would over-ride corresponding options specified if a `@KarateOptions` annotation is present (on `AnimalsTest.java`). For Gradle, you simply specify the test which is to be `include`-d: ```yml test { include 'animals/AnimalsTest.java' - // pull cucumber options into the cucumber jvm - systemProperty "cucumber.options", System.properties.getProperty("cucumber.options") - // pull karate options into the jvm + // pull karate options into the runtime + systemProperty "karate.options", System.properties.getProperty("karate.options") + // pull karate env into the runtime systemProperty "karate.env", System.properties.getProperty("karate.env") // ensure tests are always run outputs.upToDateWhen { false } } ``` -The big drawback of the 'Cucumber-native' approach is that you cannot run tests in parallel. The recommended approach for Karate reporting in a Continuous Integration set-up is described in the next section which focuses on generating the [JUnit XML](https://wiki.jenkins-ci.org/display/JENKINS/JUnit+Plugin) format that most CI tools can consume. The [Cucumber JSON format](https://relishapp.com/cucumber/cucumber/docs/formatters/json-output-formatter) is also emitted, which gives you plenty of options for generating pretty reports using third-party maven plugins. +The big drawback of the approach above is that you cannot run tests in parallel. The recommended approach for Karate reporting in a Continuous Integration set-up is described in the next section which focuses on generating the [JUnit XML](https://wiki.jenkins-ci.org/display/JENKINS/JUnit+Plugin) format that most CI tools can consume. The [Cucumber JSON format](https://relishapp.com/cucumber/cucumber/docs/formatters/json-output-formatter) is also emitted, which gives you plenty of options for generating pretty reports using third-party maven plugins. And most importantly - you can run tests in parallel without having to depend on third-party hacks that introduce code-generation and config 'bloat' into your `pom.xml` or `build.gradle`. @@ -585,18 +583,18 @@ Karate can run tests in parallel, and dramatically cut down execution time. This > Important: **do not** use the `@RunWith(Karate.class)` annotation. This is a *normal* JUnit test class ! ```java -import com.intuit.karate.cucumber.CucumberRunner; -import com.intuit.karate.cucumber.KarateStats; -import cucumber.api.CucumberOptions; +import com.intuit.karate.KarateOptions; +import com.intuit.karate.KarateStats; +import com.intuit.karate.Runner; import static org.junit.Assert.assertTrue; import org.junit.Test; -@CucumberOptions(tags = {"~@ignore"}) +@KarateOptions(tags = {"~@ignore"}) public class TestParallel { @Test public void testParallel() { - KarateStats stats = CucumberRunner.parallel(getClass(), 5, "target/surefire-reports"); + KarateStats stats = Runner.parallel(getClass(), 5, "target/surefire-reports"); assertTrue("scenarios failed", stats.getFailCount() == 0); } @@ -604,14 +602,13 @@ public class TestParallel { ``` Things to note: -* You don't use a JUnit runner (no `@RunWith` annotation), and you write a plain vanilla JUnit test (it could even be a normal Java class with a `main` method) using the `CucumberRunner.parallel()` static method in `karate-core`. +* You don't use a JUnit runner (no `@RunWith` annotation), and you write a plain vanilla JUnit test (it could even be a normal Java class with a `main` method) using the `Runner.parallel()` static method in `karate-core`. * You can use the returned `KarateStats` to check if any scenarios failed. -* The first argument can be any class that marks the 'root package' in which `*.feature` files will be looked for, and sub-directories will be also scanned. As shown above you would typically refer to the enclosing test-class itself. If the class you refer to has a `@CucumberOptions` annotation, it will be processed (see below). +* The first argument can be any class that marks the 'root package' in which `*.feature` files will be looked for, and sub-directories will be also scanned. As shown above you would typically refer to the enclosing test-class itself. If the class you refer to has a `@KarateOptions` annotation, it will be processed (see below). * The second argument is the number of threads to use. * [JUnit XML](https://wiki.jenkins-ci.org/display/JENKINS/JUnit+Plugin) reports will be generated in the path you specify as the third parameter, and you can easily configure your CI to look for these files after a build (for e.g. in `**/*.xml` or `**/surefire-reports/*.xml`). This argument is optional and will default to `target/surefire-reports`. * [Cucumber JSON reports](https://relishapp.com/cucumber/cucumber/docs/formatters/json-output-formatter) will be generated side-by-side with the JUnit XML reports and with the same name, except that the extension will be `.json` instead of `.xml`. -* No other reports will be generated. If you specify a `plugin` option via the [`@CucumberOptions`](#cucumber-options) annotation, or the [command-line](#test-suites), or the 'maven-surefire-plugin' `` - it will be ignored. -* But all other options passed to `@CucumberOptions` would work as expected, provided you point the `CucumberRunner` to the annotated class as the first argument. Note that in this example, any `*.feature` file tagged as `@ignore` will be skipped. You can also specify tags on the [command-line](#test-suites). +* Options passed to `@KarateOptions` would work as expected, provided you point the `Runner` to the annotated class as the first argument. Note that in this example, any `*.feature` file tagged as `@ignore` will be skipped. You can also specify tags on the [command-line](#test-suites). * For convenience, some stats are logged to the console when execution completes, which should look something like this: ``` diff --git a/karate-archetype/src/main/resources/archetype-resources/pom.xml b/karate-archetype/src/main/resources/archetype-resources/pom.xml index b4c551fcc..db2ce9679 100755 --- a/karate-archetype/src/main/resources/archetype-resources/pom.xml +++ b/karate-archetype/src/main/resources/archetype-resources/pom.xml @@ -11,7 +11,7 @@ UTF-8 1.8 3.6.0 - 0.8.0 + 0.9.0 diff --git a/karate-core/src/main/java/com/intuit/karate/CallContext.java b/karate-core/src/main/java/com/intuit/karate/CallContext.java index eb8946783..6c5e402eb 100644 --- a/karate-core/src/main/java/com/intuit/karate/CallContext.java +++ b/karate-core/src/main/java/com/intuit/karate/CallContext.java @@ -23,7 +23,7 @@ */ package com.intuit.karate; -import com.intuit.karate.cucumber.ScenarioInfo; +import com.intuit.karate.core.ScenarioInfo; import java.util.Map; import com.intuit.karate.core.ExecutionHook; import com.intuit.karate.core.Tags; diff --git a/karate-core/src/main/java/com/intuit/karate/IdeUtils.java b/karate-core/src/main/java/com/intuit/karate/IdeUtils.java index 0282a8f0b..c3b126a0d 100644 --- a/karate-core/src/main/java/com/intuit/karate/IdeUtils.java +++ b/karate-core/src/main/java/com/intuit/karate/IdeUtils.java @@ -52,7 +52,7 @@ public static void exec(String[] args) { String command = System.getProperty("sun.java.command"); System.out.println("command: " + command); boolean isIntellij = command.contains("org.jetbrains"); - KarateOptions options = KarateOptions.parseCommandLine(command); + RunnerOptions options = RunnerOptions.parseCommandLine(command); String name = options.getName(); List features = options.getFeatures(); ClassLoader cl = Thread.currentThread().getContextClassLoader(); diff --git a/karate-core/src/main/java/com/intuit/karate/KarateOptions.java b/karate-core/src/main/java/com/intuit/karate/KarateOptions.java index 1f43a7edb..1126e7703 100644 --- a/karate-core/src/main/java/com/intuit/karate/KarateOptions.java +++ b/karate-core/src/main/java/com/intuit/karate/KarateOptions.java @@ -23,109 +23,21 @@ */ package com.intuit.karate; -import java.util.ArrayList; -import java.util.List; -import java.util.regex.Matcher; -import java.util.regex.Pattern; -import org.slf4j.LoggerFactory; -import picocli.CommandLine; +import java.lang.annotation.ElementType; +import java.lang.annotation.Retention; +import java.lang.annotation.RetentionPolicy; +import java.lang.annotation.Target; /** * * @author pthomas3 */ -public class KarateOptions { +@Retention(RetentionPolicy.RUNTIME) +@Target({ElementType.TYPE}) +public @interface KarateOptions { - private static final org.slf4j.Logger logger = LoggerFactory.getLogger(KarateOptions.class); - - private static final Pattern COMMAND_NAME = Pattern.compile("--name (\\^.+?\\$)"); - - @CommandLine.Option(names = {"-h", "--help"}, usageHelp = true, description = "display this help message") - boolean help; - - @CommandLine.Option(names = {"-m", "--monochrome"}, description = "monochrome (not supported)") - boolean monochrome; - - @CommandLine.Option(names = {"-g", "--glue"}, description = "glue (not supported)") - String glue; - - @CommandLine.Option(names = {"-t", "--tags"}, description = "tags") - List tags; - - @CommandLine.Option(names = {"-", "--plugin"}, description = "plugin (not supported)") - List plugins; - - @CommandLine.Option(names = {"-n", "--name"}, description = "name of scenario to run") - String name; - - @CommandLine.Parameters(description = "one or more tests (features) or search-paths to run") - List features; - - public List getTags() { - return tags; - } - - public List getPlugins() { - return plugins; - } - - public String getName() { - return name; - } - - public List getFeatures() { - return features; - } - - public static KarateOptions parseStringArgs(String[] args) { - KarateOptions options = CommandLine.populateCommand(new KarateOptions(), args); - List featuresTemp = new ArrayList(); - if (options.features != null) { - for (String s : options.features) { - if (s.startsWith("com.") || s.startsWith("cucumber.") || s.startsWith("org.")) { - continue; - } - featuresTemp.add(s); - } - options.features = featuresTemp.isEmpty() ? null : featuresTemp; - } - return options; - } - - public static KarateOptions parseCommandLine(String line) { - Matcher matcher = COMMAND_NAME.matcher(line); - String nameTemp; - if (matcher.find()) { - nameTemp = matcher.group(1); - line = matcher.replaceFirst(""); - } else { - nameTemp = null; - } - String[] args = line.split("\\s+"); - KarateOptions options = parseStringArgs(args); - options.name = nameTemp; - return options; - } - - public static KarateOptions updateFromSystemProperties(List tags, List features) { - String line = System.getProperty("cucumber.options"); - line = StringUtils.trimToNull(line); - KarateOptions options; - if (line == null) { - options = new KarateOptions(); - options.tags = tags; - options.features = features; - } else { - logger.info("found system property 'cucumber.options': {}", line); - options = parseCommandLine(line); - if (options.tags == null) { - options.tags = tags; - } - if (options.features == null) { - options.features = features; - } - } - return options; - } + String[] features() default {}; + String[] tags() default {}; + } diff --git a/karate-core/src/main/java/com/intuit/karate/KarateStats.java b/karate-core/src/main/java/com/intuit/karate/KarateStats.java new file mode 100644 index 000000000..d85dd3b93 --- /dev/null +++ b/karate-core/src/main/java/com/intuit/karate/KarateStats.java @@ -0,0 +1,150 @@ +/* + * The MIT License + * + * Copyright 2018 Intuit Inc. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + */ +package com.intuit.karate; + +import java.util.LinkedHashMap; +import java.util.Map; + +/** + * + * @author pthomas3 + */ +public class KarateStats { + + private int featureCount; + private int testCount; + private int failCount; + private double timeTaken; + private final long startTime; + private long endTime; + private Map failedMap; + private Throwable failureReason; + private String reportDir; + + private KarateStats(long startTime) { + this.startTime = startTime; + } + + public void addToFailedList(String name, String errorMessage) { + if (failedMap == null) { + failedMap = new LinkedHashMap(); + } + failedMap.put(name, errorMessage); + } + + public static KarateStats startTimer() { + return new KarateStats(System.currentTimeMillis()); + } + + public String getReportDir() { + return reportDir; + } + + public void setReportDir(String reportDir) { + this.reportDir = reportDir; + } + + public void setFailureReason(Throwable failureReason) { + this.failureReason = failureReason; + } + + public Throwable getFailureReason() { + return failureReason; + } + + public void addToTestCount(int count) { + testCount += count; + } + + public void addToFailCount(int count) { + failCount += count; + } + + public void addToTimeTaken(double time) { + timeTaken += time; + } + + public void stopTimer() { + endTime = System.currentTimeMillis(); + } + + public void printStats(int threadCount) { + double elapsedTime = endTime - startTime; + System.out.println("Karate version: " + FileUtils.getKarateVersion()); + System.out.println("===================================================="); + System.out.println(String.format("elapsed time: %.2f | total thread time: %.2f", elapsedTime / 1000, timeTaken)); + double efficiency = 1000 * timeTaken / (elapsedTime * threadCount); + System.out.println(String.format("features: %5d | threads: %3d | efficiency: %.2f", + featureCount, threadCount, efficiency)); + System.out.println(String.format("scenarios: %4d | passed: %4d | failed: %4d", + testCount, testCount - failCount, failCount)); + System.out.println("===================================================="); + if (failedMap != null) { + System.out.println("failed features:"); + failedMap.forEach((k, v) -> { + System.out.println(k + ": " + v); + }); + } + if (failureReason != null) { + if (failCount == 0) { + failCount = 1; + } + System.out.println("*** runner exception stack trace ***"); + failureReason.printStackTrace(); + } + } + + public void setFeatureCount(int featureCount) { + this.featureCount = featureCount; + } + + public int getFeatureCount() { + return featureCount; + } + + public int getTestCount() { + return testCount; + } + + public int getFailCount() { + return failCount; + } + + public double getTimeTaken() { + return timeTaken; + } + + public long getStartTime() { + return startTime; + } + + public long getEndTime() { + return endTime; + } + + public Map getFailedMap() { + return failedMap; + } + +} diff --git a/karate-core/src/main/java/com/intuit/karate/Runner.java b/karate-core/src/main/java/com/intuit/karate/Runner.java new file mode 100644 index 000000000..4a15ecdc2 --- /dev/null +++ b/karate-core/src/main/java/com/intuit/karate/Runner.java @@ -0,0 +1,166 @@ +/* + * The MIT License + * + * Copyright 2018 Intuit Inc. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + */ +package com.intuit.karate; + +import com.intuit.karate.core.Engine; +import com.intuit.karate.core.ExecutionContext; +import com.intuit.karate.core.ExecutionHook; +import com.intuit.karate.core.Feature; +import com.intuit.karate.core.FeatureExecutionUnit; +import com.intuit.karate.core.FeatureParser; +import com.intuit.karate.core.FeatureResult; +import com.intuit.karate.core.Tags; +import java.io.File; +import java.util.ArrayList; +import java.util.List; +import java.util.Map; +import java.util.concurrent.Callable; +import java.util.concurrent.ExecutorService; +import java.util.concurrent.Executors; +import java.util.concurrent.Future; +import java.util.function.Consumer; +import org.slf4j.LoggerFactory; + +/** + * + * @author pthomas3 + */ +public class Runner { + + private static final org.slf4j.Logger logger = LoggerFactory.getLogger(Runner.class); + + public static KarateStats parallel(Class clazz, int threadCount) { + return parallel(clazz, threadCount, null); + } + + public static KarateStats parallel(Class clazz, int threadCount, String reportDir) { + RunnerOptions options = RunnerOptions.fromAnnotationAndSystemProperties(clazz); + return parallel(options.getTags(), options.getFeatures(), null, threadCount, reportDir); + } + + public static KarateStats parallel(List tags, List paths, int threadCount, String reportDir) { + return parallel(tags, paths, null, threadCount, reportDir); + } + + public static KarateStats parallel(List tags, List paths, ExecutionHook hook, int threadCount, String reportDir) { + String tagSelector = tags == null ? null : Tags.fromCucumberOptionsTags(tags); + List files = FileUtils.scanForFeatureFiles(paths, Thread.currentThread().getContextClassLoader()); + return parallel(tagSelector, files, hook, threadCount, reportDir); + } + + public static KarateStats parallel(String tagSelector, List resources, int threadCount, String reportDir) { + return parallel(tagSelector, resources, null, threadCount, reportDir); + } + + public static KarateStats parallel(String tagSelector, List resources, ExecutionHook hook, int threadCount, String reportDir) { + if (reportDir == null) { + reportDir = Engine.getBuildDir() + File.separator + "surefire-reports"; + new File(reportDir).mkdirs(); + } + final String finalReportDir = reportDir; + logger.info("Karate version: {}", FileUtils.getKarateVersion()); + KarateStats stats = KarateStats.startTimer(); + ExecutorService executor = Executors.newFixedThreadPool(threadCount); + int executedFeatureCount = 0; + try { + int count = resources.size(); + List> callables = new ArrayList<>(count); + for (int i = 0; i < count; i++) { + Resource resource = resources.get(i); + int index = i + 1; + Feature feature = FeatureParser.parse(resource); + callables.add(() -> { + // we are now within a separate thread. the reporter filters logs by self thread + String threadName = Thread.currentThread().getName(); + FeatureResult result = Engine.executeFeatureSync(feature, tagSelector, new CallContext(true, hook)); + if (result.getScenarioCount() > 0) { // possible that zero scenarios matched tags + File file = Engine.saveResultJson(finalReportDir, result); + Engine.saveResultXml(finalReportDir, result); + String status = result.isFailed() ? "fail" : "pass"; + logger.info("<<{}>> feature {} of {}: {}", status, index, count, feature.getRelativePath()); + result.printStats(feature.getRelativePath(), file.getPath()); + } else { + logger.info("<> feature {} of {}: {}", index, count, feature.getRelativePath()); + } + return result; + }); + } + List> futures = executor.invokeAll(callables); + stats.stopTimer(); + for (Future future : futures) { + FeatureResult result = future.get(); // guaranteed to be not-null + int scenarioCount = result.getScenarioCount(); + stats.addToTestCount(scenarioCount); + if (scenarioCount != 0) { + executedFeatureCount++; + } + stats.addToFailCount(result.getFailedCount()); + stats.addToTimeTaken(result.getDuration()); + if (result.isFailed()) { + stats.addToFailedList(result.getPackageQualifiedName(), result.getErrorMessages()); + } + } + } catch (Exception e) { + logger.error("karate parallel runner failed: ", e.getMessage()); + stats.setFailureReason(e); + } finally { + executor.shutdownNow(); + } + stats.setFeatureCount(executedFeatureCount); + stats.printStats(threadCount); + stats.setReportDir(reportDir); + return stats; + } + + public static Map runFeature(Feature feature, Map vars, boolean evalKarateConfig) { + CallContext callContext = new CallContext(vars, evalKarateConfig); + FeatureResult result = Engine.executeFeatureSync(feature, null, callContext); + return result.getResultAsPrimitiveMap(); + } + + public static Map runFeature(File file, Map vars, boolean evalKarateConfig) { + Feature feature = FeatureParser.parse(file); + return runFeature(feature, vars, evalKarateConfig); + } + + public static Map runFeature(Class relativeTo, String path, Map vars, boolean evalKarateConfig) { + File file = FileUtils.getFileRelativeTo(relativeTo, path); + return runFeature(file, vars, evalKarateConfig); + } + + public static Map runFeature(String path, Map vars, boolean evalKarateConfig) { + Feature feature = FeatureParser.parse(path); + return runFeature(feature, vars, evalKarateConfig); + } + + // this is called by karate-gatling ! + public static void callAsync(String path, CallContext callContext, Consumer system, Runnable next) { + Feature feature = FileUtils.parseFeatureAndCallTag(path); + FeatureContext featureContext = new FeatureContext(feature, null); + ExecutionContext ec = new ExecutionContext(featureContext, callContext, system); + FeatureExecutionUnit exec = new FeatureExecutionUnit(ec); + exec.submit(next); + } + +} diff --git a/karate-core/src/main/java/com/intuit/karate/RunnerOptions.java b/karate-core/src/main/java/com/intuit/karate/RunnerOptions.java new file mode 100644 index 000000000..3e5df0461 --- /dev/null +++ b/karate-core/src/main/java/com/intuit/karate/RunnerOptions.java @@ -0,0 +1,155 @@ +/* + * The MIT License + * + * Copyright 2018 Intuit Inc. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + */ +package com.intuit.karate; + +import cucumber.api.CucumberOptions; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.Collections; +import java.util.List; +import java.util.regex.Matcher; +import java.util.regex.Pattern; +import org.slf4j.LoggerFactory; +import picocli.CommandLine; + +/** + * + * @author pthomas3 + */ +public class RunnerOptions { + + private static final org.slf4j.Logger logger = LoggerFactory.getLogger(RunnerOptions.class); + + private static final Pattern COMMAND_NAME = Pattern.compile("--name (\\^.+?\\$)"); + + @CommandLine.Option(names = {"-h", "--help"}, usageHelp = true, description = "display this help message") + boolean help; + + @CommandLine.Option(names = {"-m", "--monochrome"}, description = "monochrome (not supported)") + boolean monochrome; + + @CommandLine.Option(names = {"-g", "--glue"}, description = "glue (not supported)") + String glue; + + @CommandLine.Option(names = {"-t", "--tags"}, description = "tags") + List tags; + + @CommandLine.Option(names = {"-", "--plugin"}, description = "plugin (not supported)") + List plugins; + + @CommandLine.Option(names = {"-n", "--name"}, description = "name of scenario to run") + String name; + + @CommandLine.Parameters(description = "one or more tests (features) or search-paths to run") + List features; + + public List getTags() { + return tags; + } + + public List getPlugins() { + return plugins; + } + + public String getName() { + return name; + } + + public List getFeatures() { + return features; + } + + public static RunnerOptions parseStringArgs(String[] args) { + RunnerOptions options = CommandLine.populateCommand(new RunnerOptions(), args); + List featuresTemp = new ArrayList(); + if (options.features != null) { + for (String s : options.features) { + if (s.startsWith("com.") || s.startsWith("cucumber.") || s.startsWith("org.")) { + continue; + } + featuresTemp.add(s); + } + options.features = featuresTemp.isEmpty() ? null : featuresTemp; + } + return options; + } + + public static RunnerOptions parseCommandLine(String line) { + Matcher matcher = COMMAND_NAME.matcher(line); + String nameTemp; + if (matcher.find()) { + nameTemp = matcher.group(1); + line = matcher.replaceFirst(""); + } else { + nameTemp = null; + } + String[] args = line.split("\\s+"); + RunnerOptions options = parseStringArgs(args); + options.name = nameTemp; + return options; + } + + public static RunnerOptions fromAnnotationAndSystemProperties(Class clazz) { + List tags = null; + List features = null; + KarateOptions ko = clazz.getAnnotation(KarateOptions.class); + if (ko == null) { + CucumberOptions co = clazz.getAnnotation(CucumberOptions.class); + if (co != null) { + tags = Arrays.asList(co.tags()); + features = Arrays.asList(co.features()); + } + } else { + tags = Arrays.asList(ko.tags()); + features = Arrays.asList(ko.features()); + } + if (features == null || features.isEmpty()) { + String relative = FileUtils.toRelativeClassPath(clazz); + features = Collections.singletonList(relative); + } + String line = System.getProperty("karate.options"); + line = StringUtils.trimToNull(line); + if (line == null) { + line = System.getProperty("cucumber.options"); + line = StringUtils.trimToNull(line); + } + RunnerOptions options; + if (line == null) { + options = new RunnerOptions(); + options.tags = tags; + options.features = features; + } else { + logger.info("found system property 'karate.options': {}", line); + options = parseCommandLine(line); + if (options.tags == null) { + options.tags = tags; + } + if (options.features == null) { + options.features = features; + } + } + return options; + } + +} diff --git a/karate-core/src/main/java/com/intuit/karate/ScenarioContext.java b/karate-core/src/main/java/com/intuit/karate/ScenarioContext.java index 09d1ab871..9ef3a9d84 100755 --- a/karate-core/src/main/java/com/intuit/karate/ScenarioContext.java +++ b/karate-core/src/main/java/com/intuit/karate/ScenarioContext.java @@ -25,7 +25,7 @@ import com.intuit.karate.core.ExecutionHook; import com.intuit.karate.core.FeatureResult; -import com.intuit.karate.cucumber.ScenarioInfo; +import com.intuit.karate.core.ScenarioInfo; import com.intuit.karate.exception.KarateException; import com.intuit.karate.exception.KarateFileNotFoundException; import com.intuit.karate.http.Cookie; diff --git a/karate-core/src/main/java/com/intuit/karate/core/FeatureExecutionUnit.java b/karate-core/src/main/java/com/intuit/karate/core/FeatureExecutionUnit.java index eeb7c579b..44510a179 100644 --- a/karate-core/src/main/java/com/intuit/karate/core/FeatureExecutionUnit.java +++ b/karate-core/src/main/java/com/intuit/karate/core/FeatureExecutionUnit.java @@ -26,7 +26,6 @@ import com.intuit.karate.StepActions; import com.intuit.karate.FeatureContext; import com.intuit.karate.ScenarioContext; -import com.intuit.karate.cucumber.ScenarioInfo; import java.util.Collection; import java.util.Iterator; diff --git a/karate-core/src/main/java/com/intuit/karate/cucumber/ScenarioInfo.java b/karate-core/src/main/java/com/intuit/karate/core/ScenarioInfo.java similarity index 98% rename from karate-core/src/main/java/com/intuit/karate/cucumber/ScenarioInfo.java rename to karate-core/src/main/java/com/intuit/karate/core/ScenarioInfo.java index 6408a9fcd..f46dd3c1d 100644 --- a/karate-core/src/main/java/com/intuit/karate/cucumber/ScenarioInfo.java +++ b/karate-core/src/main/java/com/intuit/karate/core/ScenarioInfo.java @@ -21,7 +21,7 @@ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN * THE SOFTWARE. */ -package com.intuit.karate.cucumber; +package com.intuit.karate.core; /** * diff --git a/karate-core/src/main/java/com/intuit/karate/cucumber/CucumberRunner.java b/karate-core/src/main/java/com/intuit/karate/cucumber/CucumberRunner.java index a6bdf5efd..85d832d33 100644 --- a/karate-core/src/main/java/com/intuit/karate/cucumber/CucumberRunner.java +++ b/karate-core/src/main/java/com/intuit/karate/cucumber/CucumberRunner.java @@ -23,39 +23,23 @@ */ package com.intuit.karate.cucumber; -import com.intuit.karate.CallContext; import com.intuit.karate.Resource; -import com.intuit.karate.FileUtils; -import com.intuit.karate.FeatureContext; -import com.intuit.karate.KarateOptions; -import com.intuit.karate.core.Engine; -import com.intuit.karate.core.ExecutionContext; +import com.intuit.karate.Runner; import com.intuit.karate.core.Feature; -import com.intuit.karate.core.FeatureParser; -import com.intuit.karate.core.FeatureResult; -import cucumber.api.CucumberOptions; import java.io.File; -import java.util.ArrayList; import java.util.List; import java.util.Map; -import java.util.concurrent.Callable; -import java.util.concurrent.ExecutorService; -import java.util.concurrent.Executors; -import java.util.concurrent.Future; -import java.util.Arrays; -import java.util.Collections; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import com.intuit.karate.core.ExecutionHook; -import com.intuit.karate.core.FeatureExecutionUnit; -import com.intuit.karate.core.Tags; -import java.util.function.Consumer; /** - * + * as of version 0.9.0 - replaced by {@link com.intuit.karate.Runner} + * * @author pthomas3 */ +@Deprecated public class CucumberRunner { private static final Logger logger = LoggerFactory.getLogger(CucumberRunner.class); @@ -65,26 +49,7 @@ public static KarateStats parallel(Class clazz, int threadCount) { } public static KarateStats parallel(Class clazz, int threadCount, String reportDir) { - CucumberOptions co = clazz.getAnnotation(CucumberOptions.class); - List tags; - List features; - if (co == null) { - logger.warn("CucumberOptions annotation not found on class: {}", clazz); - tags = null; - features = null; - } else { - String[] tagsArray = co.tags(); - tags = Arrays.asList(tagsArray); - String[] featuresArray = co.features(); - features = Arrays.asList(featuresArray); - } - if (features == null || features.isEmpty()) { - String relative = FileUtils.toRelativeClassPath(clazz); - features = Collections.singletonList(relative); - } - // override with system properties if applicable - KarateOptions options = KarateOptions.updateFromSystemProperties(tags, features); - return parallel(options.getTags(), options.getFeatures(), null, threadCount, reportDir); + return new KarateStats(Runner.parallel(clazz, threadCount, reportDir)); } public static KarateStats parallel(List tags, List paths, int threadCount, String reportDir) { @@ -92,9 +57,7 @@ public static KarateStats parallel(List tags, List paths, int th } public static KarateStats parallel(List tags, List paths, ExecutionHook hook, int threadCount, String reportDir) { - String tagSelector = tags == null ? null : Tags.fromCucumberOptionsTags(tags); - List files = FileUtils.scanForFeatureFiles(paths, Thread.currentThread().getContextClassLoader()); - return parallel(tagSelector, files, hook, threadCount, reportDir); + return new KarateStats(Runner.parallel(tags, paths, hook, threadCount, reportDir)); } public static KarateStats parallel(String tagSelector, List resources, int threadCount, String reportDir) { @@ -102,93 +65,23 @@ public static KarateStats parallel(String tagSelector, List resources, } public static KarateStats parallel(String tagSelector, List resources, ExecutionHook hook, int threadCount, String reportDir) { - if (reportDir == null) { - reportDir = Engine.getBuildDir() + File.separator + "surefire-reports"; - new File(reportDir).mkdirs(); - } - final String finalReportDir = reportDir; - logger.info("Karate version: {}", FileUtils.getKarateVersion()); - KarateStats stats = KarateStats.startTimer(); - ExecutorService executor = Executors.newFixedThreadPool(threadCount); - int executedFeatureCount = 0; - try { - int count = resources.size(); - List> callables = new ArrayList<>(count); - for (int i = 0; i < count; i++) { - Resource resource = resources.get(i); - int index = i + 1; - Feature feature = FeatureParser.parse(resource); - callables.add(() -> { - // we are now within a separate thread. the reporter filters logs by self thread - String threadName = Thread.currentThread().getName(); - FeatureResult result = Engine.executeFeatureSync(feature, tagSelector, new CallContext(true, hook)); - if (result.getScenarioCount() > 0) { // possible that zero scenarios matched tags - File file = Engine.saveResultJson(finalReportDir, result); - Engine.saveResultXml(finalReportDir, result); - String status = result.isFailed() ? "fail" : "pass"; - logger.info("<<{}>> feature {} of {}: {}", status, index, count, feature.getRelativePath()); - result.printStats(feature.getRelativePath(), file.getPath()); - } else { - logger.info("<> feature {} of {}: {}", index, count, feature.getRelativePath()); - } - return result; - }); - } - List> futures = executor.invokeAll(callables); - stats.stopTimer(); - for (Future future : futures) { - FeatureResult result = future.get(); // guaranteed to be not-null - int scenarioCount = result.getScenarioCount(); - stats.addToTestCount(scenarioCount); - if (scenarioCount != 0) { - executedFeatureCount++; - } - stats.addToFailCount(result.getFailedCount()); - stats.addToTimeTaken(result.getDuration()); - if (result.isFailed()) { - stats.addToFailedList(result.getPackageQualifiedName(), result.getErrorMessages()); - } - } - } catch (Exception e) { - logger.error("karate parallel runner failed: ", e.getMessage()); - stats.setFailureReason(e); - } finally { - executor.shutdownNow(); - } - stats.setFeatureCount(executedFeatureCount); - stats.printStats(threadCount); - stats.setReportDir(reportDir); - return stats; + return new KarateStats(Runner.parallel(tagSelector, resources, hook, threadCount, reportDir)); } public static Map runFeature(Feature feature, Map vars, boolean evalKarateConfig) { - CallContext callContext = new CallContext(vars, evalKarateConfig); - FeatureResult result = Engine.executeFeatureSync(feature, null, callContext); - return result.getResultAsPrimitiveMap(); + return Runner.runFeature(feature, vars, evalKarateConfig); } public static Map runFeature(File file, Map vars, boolean evalKarateConfig) { - Feature feature = FeatureParser.parse(file); - return runFeature(feature, vars, evalKarateConfig); + return Runner.runFeature(file, vars, evalKarateConfig); } public static Map runFeature(Class relativeTo, String path, Map vars, boolean evalKarateConfig) { - File file = FileUtils.getFileRelativeTo(relativeTo, path); - return runFeature(file, vars, evalKarateConfig); + return Runner.runFeature(relativeTo, path, vars, evalKarateConfig); } public static Map runFeature(String path, Map vars, boolean evalKarateConfig) { - Feature feature = FeatureParser.parse(path); - return runFeature(feature, vars, evalKarateConfig); - } - - // this is called by karate-gatling ! - public static void callAsync(String path, CallContext callContext, Consumer system, Runnable next) { - Feature feature = FileUtils.parseFeatureAndCallTag(path); - FeatureContext featureContext = new FeatureContext(feature, null); - ExecutionContext ec = new ExecutionContext(featureContext, callContext, system); - FeatureExecutionUnit exec = new FeatureExecutionUnit(ec); - exec.submit(next); - } + return Runner.runFeature(path, vars, evalKarateConfig); + } } diff --git a/karate-core/src/main/java/com/intuit/karate/cucumber/KarateStats.java b/karate-core/src/main/java/com/intuit/karate/cucumber/KarateStats.java index 3a7d33a2c..3b3a210c8 100644 --- a/karate-core/src/main/java/com/intuit/karate/cucumber/KarateStats.java +++ b/karate-core/src/main/java/com/intuit/karate/cucumber/KarateStats.java @@ -28,9 +28,11 @@ import java.util.Map; /** - * + * as of version 0.9.0 - replaced by {@link com.intuit.karate.KarateStats} + * * @author pthomas3 */ +@Deprecated public class KarateStats { private int featureCount; @@ -43,6 +45,18 @@ public class KarateStats { private Throwable failureReason; private String reportDir; + protected KarateStats(com.intuit.karate.KarateStats from) { + featureCount = from.getFeatureCount(); + testCount = from.getTestCount(); + failCount = from.getFailCount(); + timeTaken = from.getTimeTaken(); + startTime = from.getStartTime(); + endTime = from.getEndTime(); + failedMap = from.getFailedMap(); + failureReason = from.getFailureReason(); + reportDir = from.getReportDir(); + } + private KarateStats(long startTime) { this.startTime = startTime; } diff --git a/karate-core/src/main/java/cucumber/api/CucumberOptions.java b/karate-core/src/main/java/cucumber/api/CucumberOptions.java index 9cfcc42e4..0c295b3ce 100644 --- a/karate-core/src/main/java/cucumber/api/CucumberOptions.java +++ b/karate-core/src/main/java/cucumber/api/CucumberOptions.java @@ -6,10 +6,11 @@ import java.lang.annotation.Target; /** - * replaces cucumber-jvm code + * as of version 0.9.0 - replaced by {@link com.intuit.karate.KarateOptions} * * @author pthomas3 */ +@Deprecated @Retention(RetentionPolicy.RUNTIME) @Target({ElementType.TYPE}) public @interface CucumberOptions { diff --git a/karate-core/src/test/java/com/intuit/karate/KarateOptionsTest.java b/karate-core/src/test/java/com/intuit/karate/KarateOptionsTest.java deleted file mode 100644 index 72b24f6ae..000000000 --- a/karate-core/src/test/java/com/intuit/karate/KarateOptionsTest.java +++ /dev/null @@ -1,33 +0,0 @@ -package com.intuit.karate; - -import org.junit.Test; -import static org.junit.Assert.*; - -/** - * - * @author pthomas3 - */ -public class KarateOptionsTest { - - @Test - public void testArgs() { - KarateOptions options = KarateOptions.parseStringArgs(new String[]{}); - assertNull(options.features); - assertNull(options.tags); - assertNull(options.name); - options = KarateOptions.parseStringArgs(new String[]{"--name", "foo"}); - assertNull(options.features); - assertNull(options.tags); - assertEquals("foo", options.name); - options = KarateOptions.parseStringArgs(new String[]{"--tags", "~@ignore"}); - assertNull(options.features); - assertEquals("~@ignore", options.tags.get(0)); - assertNull(options.name); - options = KarateOptions.parseStringArgs(new String[]{"--tags", "~@ignore", "foo.feature"}); - assertEquals("foo.feature", options.features.get(0)); - assertEquals("~@ignore", options.tags.get(0)); - assertNull(options.name); - - } - -} diff --git a/karate-core/src/test/java/com/intuit/karate/MainTest.java b/karate-core/src/test/java/com/intuit/karate/MainTest.java deleted file mode 100644 index 362d58a7d..000000000 --- a/karate-core/src/test/java/com/intuit/karate/MainTest.java +++ /dev/null @@ -1,27 +0,0 @@ -package com.intuit.karate; - -import org.junit.Test; -import static org.junit.Assert.*; -import org.slf4j.LoggerFactory; - -/** - * - * @author pthomas3 - */ -public class MainTest { - - private static final org.slf4j.Logger logger = LoggerFactory.getLogger(MainTest.class); - - @Test - public void testParsingCommandLine() { - KarateOptions options = KarateOptions.parseCommandLine(IdeUtilsTest.INTELLIJ1); - assertEquals("^get users and then get first by id$", options.getName()); - assertNull(options.getTags()); - assertEquals(1, options.getFeatures().size()); - assertEquals("/Users/pthomas3/dev/zcode/karate/karate-junit4/src/test/java/com/intuit/karate/junit4/demos/users.feature", options.getFeatures().get(0)); - options = KarateOptions.parseCommandLine(IdeUtilsTest.ECLIPSE1); - assertEquals(1, options.getFeatures().size()); - assertEquals("/Users/pthomas3/dev/zcode/karate/karate-junit4/src/test/resources/com/intuit/karate/junit4/demos/users.feature", options.getFeatures().get(0)); - } - -} diff --git a/karate-core/src/test/java/com/intuit/karate/RunnerOptionsTest.java b/karate-core/src/test/java/com/intuit/karate/RunnerOptionsTest.java new file mode 100644 index 000000000..75fe23005 --- /dev/null +++ b/karate-core/src/test/java/com/intuit/karate/RunnerOptionsTest.java @@ -0,0 +1,44 @@ +package com.intuit.karate; + +import org.junit.Test; +import static org.junit.Assert.*; + +/** + * + * @author pthomas3 + */ +public class RunnerOptionsTest { + + @Test + public void testArgs() { + RunnerOptions options = RunnerOptions.parseStringArgs(new String[]{}); + assertNull(options.features); + assertNull(options.tags); + assertNull(options.name); + options = RunnerOptions.parseStringArgs(new String[]{"--name", "foo"}); + assertNull(options.features); + assertNull(options.tags); + assertEquals("foo", options.name); + options = RunnerOptions.parseStringArgs(new String[]{"--tags", "~@ignore"}); + assertNull(options.features); + assertEquals("~@ignore", options.tags.get(0)); + assertNull(options.name); + options = RunnerOptions.parseStringArgs(new String[]{"--tags", "~@ignore", "foo.feature"}); + assertEquals("foo.feature", options.features.get(0)); + assertEquals("~@ignore", options.tags.get(0)); + assertNull(options.name); + } + + @Test + public void testParsingCommandLine() { + RunnerOptions options = RunnerOptions.parseCommandLine(IdeUtilsTest.INTELLIJ1); + assertEquals("^get users and then get first by id$", options.getName()); + assertNull(options.getTags()); + assertEquals(1, options.getFeatures().size()); + assertEquals("/Users/pthomas3/dev/zcode/karate/karate-junit4/src/test/java/com/intuit/karate/junit4/demos/users.feature", options.getFeatures().get(0)); + options = RunnerOptions.parseCommandLine(IdeUtilsTest.ECLIPSE1); + assertEquals(1, options.getFeatures().size()); + assertEquals("/Users/pthomas3/dev/zcode/karate/karate-junit4/src/test/resources/com/intuit/karate/junit4/demos/users.feature", options.getFeatures().get(0)); + } + +} diff --git a/karate-core/src/test/java/com/intuit/karate/cucumber/CucumberRunnerTest.java b/karate-core/src/test/java/com/intuit/karate/RunnerTest.java similarity index 80% rename from karate-core/src/test/java/com/intuit/karate/cucumber/CucumberRunnerTest.java rename to karate-core/src/test/java/com/intuit/karate/RunnerTest.java index 00d32b9dd..0db1d04b7 100644 --- a/karate-core/src/test/java/com/intuit/karate/cucumber/CucumberRunnerTest.java +++ b/karate-core/src/test/java/com/intuit/karate/RunnerTest.java @@ -21,14 +21,12 @@ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN * THE SOFTWARE. */ -package com.intuit.karate.cucumber; +package com.intuit.karate; -import com.intuit.karate.FileUtils; import com.intuit.karate.core.Engine; import com.intuit.karate.core.Feature; import com.intuit.karate.core.FeatureParser; import com.intuit.karate.core.FeatureResult; -import cucumber.api.CucumberOptions; import java.io.File; import java.util.Map; import static org.junit.Assert.assertTrue; @@ -41,10 +39,10 @@ * * @author pthomas3 */ -@CucumberOptions(tags = {"~@ignore"}) -public class CucumberRunnerTest { +@KarateOptions(tags = {"~@ignore"}) +public class RunnerTest { - private static final Logger logger = LoggerFactory.getLogger(CucumberRunnerTest.class); + private static final Logger logger = LoggerFactory.getLogger(RunnerTest.class); private boolean contains(String reportPath, String textToFind) { String contents = FileUtils.toString(new File(reportPath)); @@ -52,7 +50,7 @@ private boolean contains(String reportPath, String textToFind) { } private static String resultXml(String name) { - Feature feature = FeatureParser.parse("classpath:com/intuit/karate/cucumber/" + name); + Feature feature = FeatureParser.parse("classpath:com/intuit/karate/" + name); FeatureResult result = Engine.executeFeatureSync(feature, null, null); File file = Engine.saveResultXml("target", result); return FileUtils.toString(file); @@ -60,34 +58,34 @@ private static String resultXml(String name) { @Test public void testScenario() throws Exception { - String contents = resultXml("scenario.feature"); + String contents = resultXml("core/scenario.feature"); assertTrue(contents.contains("Then match b == { foo: 'bar'}")); } @Test public void testScenarioOutline() throws Exception { - String contents = resultXml("outline.feature"); + String contents = resultXml("core/outline.feature"); assertTrue(contents.contains("When def a = 55")); } @Test public void testParallel() { - KarateStats stats = CucumberRunner.parallel(getClass(), 1); + KarateStats stats = Runner.parallel(getClass(), 1); assertEquals(2, stats.getFailCount()); - String pathBase = "target/surefire-reports/com.intuit.karate.cucumber."; - assertTrue(contains(pathBase + "scenario.xml", "Then match b == { foo: 'bar'}")); - assertTrue(contains(pathBase + "outline.xml", "Then assert a == 55")); + String pathBase = "target/surefire-reports/com.intuit.karate."; + assertTrue(contains(pathBase + "core.scenario.xml", "Then match b == { foo: 'bar'}")); + assertTrue(contains(pathBase + "core.outline.xml", "Then assert a == 55")); assertTrue(contains(pathBase + "multi-scenario.xml", "Then assert a != 2")); // a scenario failure should not stop other features from running assertTrue(contains(pathBase + "multi-scenario-fail.xml", "Then assert a != 2 ........................................................ passed")); assertEquals(2, stats.getFailedMap().size()); - assertTrue(stats.getFailedMap().keySet().contains("com.intuit.karate.cucumber.no-scenario-name")); - assertTrue(stats.getFailedMap().keySet().contains("com.intuit.karate.cucumber.multi-scenario-fail")); + assertTrue(stats.getFailedMap().keySet().contains("com.intuit.karate.no-scenario-name")); + assertTrue(stats.getFailedMap().keySet().contains("com.intuit.karate.multi-scenario-fail")); } @Test public void testRunningFeatureFromJavaApi() { - Map result = CucumberRunner.runFeature(getClass(), "scenario.feature", null, true); + Map result = Runner.runFeature(getClass(), "core/scenario.feature", null, true); assertEquals(1, result.get("a")); Map temp = (Map) result.get("b"); assertEquals("bar", temp.get("foo")); @@ -96,7 +94,7 @@ public void testRunningFeatureFromJavaApi() { @Test public void testRunningRelativePathFeatureFromJavaApi() { - Map result = CucumberRunner.runFeature("classpath:com/intuit/karate/test-called.feature", null, true); + Map result = Runner.runFeature("classpath:com/intuit/karate/test-called.feature", null, true); assertEquals(1, result.get("a")); assertEquals(2, result.get("b")); assertEquals("someValue", result.get("someConfig")); diff --git a/karate-core/src/test/java/com/intuit/karate/cucumber/called-arg-loop.feature b/karate-core/src/test/java/com/intuit/karate/called-arg-loop.feature similarity index 100% rename from karate-core/src/test/java/com/intuit/karate/cucumber/called-arg-loop.feature rename to karate-core/src/test/java/com/intuit/karate/called-arg-loop.feature diff --git a/karate-core/src/test/java/com/intuit/karate/cucumber/called-arg-null.feature b/karate-core/src/test/java/com/intuit/karate/called-arg-null.feature similarity index 100% rename from karate-core/src/test/java/com/intuit/karate/cucumber/called-arg-null.feature rename to karate-core/src/test/java/com/intuit/karate/called-arg-null.feature diff --git a/karate-core/src/test/java/com/intuit/karate/cucumber/called-arg-single.feature b/karate-core/src/test/java/com/intuit/karate/called-arg-single.feature similarity index 100% rename from karate-core/src/test/java/com/intuit/karate/cucumber/called-arg-single.feature rename to karate-core/src/test/java/com/intuit/karate/called-arg-single.feature diff --git a/karate-core/src/test/java/com/intuit/karate/cucumber/caller-arg.feature b/karate-core/src/test/java/com/intuit/karate/caller-arg.feature similarity index 100% rename from karate-core/src/test/java/com/intuit/karate/cucumber/caller-arg.feature rename to karate-core/src/test/java/com/intuit/karate/caller-arg.feature diff --git a/karate-core/src/test/java/com/intuit/karate/cucumber/CucumberUtilsTest.java b/karate-core/src/test/java/com/intuit/karate/core/FeatureEditTest.java similarity index 98% rename from karate-core/src/test/java/com/intuit/karate/cucumber/CucumberUtilsTest.java rename to karate-core/src/test/java/com/intuit/karate/core/FeatureEditTest.java index dc9ea8dd8..5b385e33c 100644 --- a/karate-core/src/test/java/com/intuit/karate/cucumber/CucumberUtilsTest.java +++ b/karate-core/src/test/java/com/intuit/karate/core/FeatureEditTest.java @@ -1,4 +1,4 @@ -package com.intuit.karate.cucumber; +package com.intuit.karate.core; import com.intuit.karate.FileUtils; import com.intuit.karate.Resource; @@ -20,9 +20,9 @@ * * @author pthomas3 */ -public class CucumberUtilsTest { +public class FeatureEditTest { - private static final Logger logger = LoggerFactory.getLogger(CucumberUtilsTest.class); + private static final Logger logger = LoggerFactory.getLogger(FeatureEditTest.class); private Feature parse(String name) { InputStream is = getClass().getResourceAsStream(name); diff --git a/karate-core/src/test/java/com/intuit/karate/cucumber/FeatureResultTest.java b/karate-core/src/test/java/com/intuit/karate/core/FeatureResultTest.java similarity index 98% rename from karate-core/src/test/java/com/intuit/karate/cucumber/FeatureResultTest.java rename to karate-core/src/test/java/com/intuit/karate/core/FeatureResultTest.java index c4d8f19b2..cf4c48e7a 100644 --- a/karate-core/src/test/java/com/intuit/karate/cucumber/FeatureResultTest.java +++ b/karate-core/src/test/java/com/intuit/karate/core/FeatureResultTest.java @@ -21,7 +21,7 @@ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN * THE SOFTWARE. */ -package com.intuit.karate.cucumber; +package com.intuit.karate.core; import com.intuit.karate.FileUtils; import com.intuit.karate.core.Engine; @@ -45,7 +45,7 @@ public class FeatureResultTest { private static final Logger logger = LoggerFactory.getLogger(FeatureResultTest.class); private static FeatureResult result(String name) { - Feature feature = FeatureParser.parse("classpath:com/intuit/karate/cucumber/" + name); + Feature feature = FeatureParser.parse("classpath:com/intuit/karate/core/" + name); return Engine.executeFeatureSync(feature, null, null); } diff --git a/karate-core/src/test/java/com/intuit/karate/cucumber/FeatureReuseTest.java b/karate-core/src/test/java/com/intuit/karate/core/FeatureReuseTest.java similarity index 97% rename from karate-core/src/test/java/com/intuit/karate/cucumber/FeatureReuseTest.java rename to karate-core/src/test/java/com/intuit/karate/core/FeatureReuseTest.java index c42456a80..fedf23498 100644 --- a/karate-core/src/test/java/com/intuit/karate/cucumber/FeatureReuseTest.java +++ b/karate-core/src/test/java/com/intuit/karate/core/FeatureReuseTest.java @@ -21,7 +21,7 @@ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN * THE SOFTWARE. */ -package com.intuit.karate.cucumber; +package com.intuit.karate.core; import com.intuit.karate.FileUtils; import com.intuit.karate.core.Engine; @@ -43,7 +43,7 @@ public class FeatureReuseTest { private static final Logger logger = LoggerFactory.getLogger(FeatureReuseTest.class); private static String resultXml(String name) { - Feature feature = FeatureParser.parse("classpath:com/intuit/karate/cucumber/" + name); + Feature feature = FeatureParser.parse("classpath:com/intuit/karate/core/" + name); FeatureResult result = Engine.executeFeatureSync(feature, null, null); File file = Engine.saveResultXml("target", result); return FileUtils.toString(file); diff --git a/karate-core/src/test/java/com/intuit/karate/core/ScenarioHookTest.java b/karate-core/src/test/java/com/intuit/karate/core/ScenarioHookTest.java index 4b6b005f2..31c179477 100644 --- a/karate-core/src/test/java/com/intuit/karate/core/ScenarioHookTest.java +++ b/karate-core/src/test/java/com/intuit/karate/core/ScenarioHookTest.java @@ -23,8 +23,8 @@ */ package com.intuit.karate.core; -import com.intuit.karate.cucumber.CucumberRunner; -import com.intuit.karate.cucumber.KarateStats; +import com.intuit.karate.KarateStats; +import com.intuit.karate.Runner; import java.util.Collections; import static org.junit.Assert.*; import org.junit.Test; @@ -38,7 +38,7 @@ public class ScenarioHookTest { @Test public void testStopIfScenarioHasNoTags() { String path = "classpath:com/intuit/karate/core/test-hook-notags.feature"; - KarateStats stats = CucumberRunner.parallel(null, Collections.singletonList(path), new MandatoryTagHook(), 1, null); + KarateStats stats = Runner.parallel(null, Collections.singletonList(path), new MandatoryTagHook(), 1, null); assertEquals(1, stats.getFeatureCount()); assertEquals(1, stats.getFailCount()); } @@ -46,7 +46,7 @@ public void testStopIfScenarioHasNoTags() { @Test public void testHookForExamplesWithTags() { String path = "classpath:com/intuit/karate/core/test-hook-multiexample.feature"; - KarateStats stats = CucumberRunner.parallel(null, Collections.singletonList(path), new MandatoryTagHook(), 1, null); + KarateStats stats = Runner.parallel(null, Collections.singletonList(path), new MandatoryTagHook(), 1, null); assertEquals(1, stats.getFeatureCount()); assertEquals(7, stats.getTestCount()); assertEquals(0, stats.getFailCount()); diff --git a/karate-core/src/test/java/com/intuit/karate/cucumber/aborted.feature b/karate-core/src/test/java/com/intuit/karate/core/aborted.feature similarity index 100% rename from karate-core/src/test/java/com/intuit/karate/cucumber/aborted.feature rename to karate-core/src/test/java/com/intuit/karate/core/aborted.feature diff --git a/karate-core/src/test/java/com/intuit/karate/cucumber/called-shared.feature b/karate-core/src/test/java/com/intuit/karate/core/called-shared.feature similarity index 100% rename from karate-core/src/test/java/com/intuit/karate/cucumber/called-shared.feature rename to karate-core/src/test/java/com/intuit/karate/core/called-shared.feature diff --git a/karate-core/src/test/java/com/intuit/karate/cucumber/called-shared2.feature b/karate-core/src/test/java/com/intuit/karate/core/called-shared2.feature similarity index 100% rename from karate-core/src/test/java/com/intuit/karate/cucumber/called-shared2.feature rename to karate-core/src/test/java/com/intuit/karate/core/called-shared2.feature diff --git a/karate-core/src/test/java/com/intuit/karate/cucumber/called.feature b/karate-core/src/test/java/com/intuit/karate/core/called.feature similarity index 100% rename from karate-core/src/test/java/com/intuit/karate/cucumber/called.feature rename to karate-core/src/test/java/com/intuit/karate/core/called.feature diff --git a/karate-core/src/test/java/com/intuit/karate/cucumber/called_2.feature b/karate-core/src/test/java/com/intuit/karate/core/called_2.feature similarity index 100% rename from karate-core/src/test/java/com/intuit/karate/cucumber/called_2.feature rename to karate-core/src/test/java/com/intuit/karate/core/called_2.feature diff --git a/karate-core/src/test/java/com/intuit/karate/cucumber/caller-shared.feature b/karate-core/src/test/java/com/intuit/karate/core/caller-shared.feature similarity index 100% rename from karate-core/src/test/java/com/intuit/karate/cucumber/caller-shared.feature rename to karate-core/src/test/java/com/intuit/karate/core/caller-shared.feature diff --git a/karate-core/src/test/java/com/intuit/karate/cucumber/caller.feature b/karate-core/src/test/java/com/intuit/karate/core/caller.feature similarity index 100% rename from karate-core/src/test/java/com/intuit/karate/cucumber/caller.feature rename to karate-core/src/test/java/com/intuit/karate/core/caller.feature diff --git a/karate-core/src/test/java/com/intuit/karate/cucumber/caller_2.feature b/karate-core/src/test/java/com/intuit/karate/core/caller_2.feature similarity index 100% rename from karate-core/src/test/java/com/intuit/karate/cucumber/caller_2.feature rename to karate-core/src/test/java/com/intuit/karate/core/caller_2.feature diff --git a/karate-core/src/test/java/com/intuit/karate/cucumber/failed.feature b/karate-core/src/test/java/com/intuit/karate/core/failed.feature similarity index 100% rename from karate-core/src/test/java/com/intuit/karate/cucumber/failed.feature rename to karate-core/src/test/java/com/intuit/karate/core/failed.feature diff --git a/karate-core/src/test/java/com/intuit/karate/cucumber/outline.feature b/karate-core/src/test/java/com/intuit/karate/core/outline.feature similarity index 100% rename from karate-core/src/test/java/com/intuit/karate/cucumber/outline.feature rename to karate-core/src/test/java/com/intuit/karate/core/outline.feature diff --git a/karate-core/src/test/java/com/intuit/karate/cucumber/scenario.feature b/karate-core/src/test/java/com/intuit/karate/core/scenario.feature similarity index 100% rename from karate-core/src/test/java/com/intuit/karate/cucumber/scenario.feature rename to karate-core/src/test/java/com/intuit/karate/core/scenario.feature diff --git a/karate-core/src/test/java/com/intuit/karate/cucumber/table.feature b/karate-core/src/test/java/com/intuit/karate/core/table.feature similarity index 100% rename from karate-core/src/test/java/com/intuit/karate/cucumber/table.feature rename to karate-core/src/test/java/com/intuit/karate/core/table.feature diff --git a/karate-core/src/test/java/com/intuit/karate/core/test-error.feature b/karate-core/src/test/java/com/intuit/karate/core/test-error.feature index 8b01fa8dd..9680d9da0 100644 --- a/karate-core/src/test/java/com/intuit/karate/core/test-error.feature +++ b/karate-core/src/test/java/com/intuit/karate/core/test-error.feature @@ -1,3 +1,4 @@ +@ignore Feature: the first line Scenario: has name diff --git a/karate-core/src/test/java/com/intuit/karate/cucumber/multi-scenario-fail.feature b/karate-core/src/test/java/com/intuit/karate/multi-scenario-fail.feature similarity index 100% rename from karate-core/src/test/java/com/intuit/karate/cucumber/multi-scenario-fail.feature rename to karate-core/src/test/java/com/intuit/karate/multi-scenario-fail.feature diff --git a/karate-core/src/test/java/com/intuit/karate/cucumber/multi-scenario.feature b/karate-core/src/test/java/com/intuit/karate/multi-scenario.feature similarity index 100% rename from karate-core/src/test/java/com/intuit/karate/cucumber/multi-scenario.feature rename to karate-core/src/test/java/com/intuit/karate/multi-scenario.feature diff --git a/karate-core/src/test/java/com/intuit/karate/cucumber/no-scenario-name.feature b/karate-core/src/test/java/com/intuit/karate/no-scenario-name.feature similarity index 100% rename from karate-core/src/test/java/com/intuit/karate/cucumber/no-scenario-name.feature rename to karate-core/src/test/java/com/intuit/karate/no-scenario-name.feature diff --git a/karate-core/src/test/java/com/intuit/karate/ui/threadtest.feature b/karate-core/src/test/java/com/intuit/karate/ui/threadtest.feature index 05b69a0da..32c3a4cd1 100644 --- a/karate-core/src/test/java/com/intuit/karate/ui/threadtest.feature +++ b/karate-core/src/test/java/com/intuit/karate/ui/threadtest.feature @@ -1,3 +1,4 @@ +@ignore Feature: Thread Test Scenario: Scenario-1 diff --git a/karate-demo/README.md b/karate-demo/README.md index 18e353a7f..f0d9339d2 100644 --- a/karate-demo/README.md +++ b/karate-demo/README.md @@ -32,7 +32,7 @@ This is a sample [Spring Boot](http://projects.spring.io/spring-boot/) web-appli [`karate-config.js`](src/test/java/karate-config.js) | Shows how the `demoBaseUrl` property is injected into all the test scripts [on startup](https://github.com/intuit/karate#configuration). Notice how JavaScript allows you to perform simple conditional logic and string manipulation, while still being a 'devops-friendly' plain-text file. It is good practice to set the `connectTimeout` and `readTimeout` so that your tests 'fail fast' if servers don't respond. For advanced users - you can even run a 'global' init routine using [`karate.callSingle()`](https://github.com/intuit/karate#the-karate-object). [`karate-config-contract.js`](src/test/java/karate-config-contract.js) | When your project gets complex, you can over-ride config per environment ([`karate.env`](https://github.com/intuit/karate#configuration)). Refer to the documentation on [environment specific config](https://github.com/intuit/karate#environment-specific-config). [`TestBase.java`](src/test/java/demo/TestBase.java#L22) | This is specific to Spring Boot, but this code takes care of starting the embedded app-server and dynamically chooses a free port. The chosen port value is passed to the above config routine via a Java `System.setProperty()` call. -[`DemoTest.java`](src/test/java/demo/DemoTest.java) | This Java class is strategically placed at the root of the [directory structure](https://github.com/intuit/karate#naming-conventions) containing `*.feature` files. Note how the [`@CucumberOptions`](https://cucumber.io/docs/reference/jvm#configuration) annotation allows you to skip any `*.feature` files if they have `@ignore` at the start. +[`DemoTest.java`](src/test/java/demo/DemoTest.java) | This Java class is strategically placed at the root of the [directory structure](https://github.com/intuit/karate#naming-conventions) containing `*.feature` files. Note how the `@KarateOptions` annotation allows you to skip any `*.feature` files if they have `@ignore` at the start. [`DemoTestParallel.java`](src/test/java/demo/DemoTestParallel.java) | Karate has a utility to [run tests in parallel](https://github.com/intuit/karate#parallel-execution) and this does not depend on JUnit, TestNG or even Maven. A JUnit XML report file and Cucumber JSON report file would be generated for each feature executed. You can easily configure your CI with the location of these files so that you get proper test-reports after a build. This is **the** recommended way of running Karate as part of an automated build or CI pipeline. Here, the (optional) third-party [cucumber-reporting](https://github.com/damianszczepanik/cucumber-reporting) library is being used (see details below). [`pom.xml`](pom.xml#L131) | Line 131 shows how the [`maven-surefire-plugin`](http://maven.apache.org/surefire/maven-surefire-plugin/examples/inclusion-exclusion.html) can be configured to point to what is basically your 'test-suite'. You may not even need to do this if you follow the [recommended naming conventions and folder structure](https://github.com/intuit/karate#naming-conventions), and then Maven defaults would work as you would expect. Note that this demo application has many dependencies that you will *not* need for a typical Karate project. diff --git a/karate-demo/build.gradle b/karate-demo/build.gradle index 37fe6b8a5..387a9cbcd 100644 --- a/karate-demo/build.gradle +++ b/karate-demo/build.gradle @@ -84,8 +84,8 @@ test { // When running the test task, only run the base Test class which runs all cucumber // tests in parallel. include '**/*DemoTestParallel*' - // Pull cucumber options into the cucumber JVM - systemProperty "cucumber.options", System.properties.getProperty("cucumber.options") + // Pull karate options into the runtime + systemProperty "karate.options", System.properties.getProperty("karate.options") // Pull karate options into the JVM systemProperty "karate.env", System.properties.getProperty("karate.env") // Ensure tests are always run diff --git a/karate-demo/src/test/java/demo/DemoTest.java b/karate-demo/src/test/java/demo/DemoTest.java index 7171c46d3..24334e579 100644 --- a/karate-demo/src/test/java/demo/DemoTest.java +++ b/karate-demo/src/test/java/demo/DemoTest.java @@ -1,12 +1,12 @@ package demo; -import cucumber.api.CucumberOptions; +import com.intuit.karate.KarateOptions; /** * * @author pthomas3 */ -@CucumberOptions(tags = {"~@ignore"}) +@KarateOptions(tags = {"~@ignore"}) public class DemoTest extends TestBase { // this class will automatically pick up all *.feature files // in src/test/java/demo and even recurse sub-directories diff --git a/karate-demo/src/test/java/demo/DemoTestParallel.java b/karate-demo/src/test/java/demo/DemoTestParallel.java index 48794754e..2b5e72611 100644 --- a/karate-demo/src/test/java/demo/DemoTestParallel.java +++ b/karate-demo/src/test/java/demo/DemoTestParallel.java @@ -1,8 +1,8 @@ package demo; -import com.intuit.karate.cucumber.CucumberRunner; -import com.intuit.karate.cucumber.KarateStats; -import cucumber.api.CucumberOptions; +import com.intuit.karate.Runner; +import com.intuit.karate.KarateStats; +import com.intuit.karate.KarateOptions; import java.io.File; import java.util.ArrayList; import java.util.Collection; @@ -18,7 +18,7 @@ * * @author pthomas3 */ -@CucumberOptions(tags = {"~@ignore"}) // important: do not use @RunWith(Karate.class) ! +@KarateOptions(tags = {"~@ignore"}) // important: do not use @RunWith(Karate.class) ! public class DemoTestParallel { @BeforeClass @@ -28,7 +28,7 @@ public static void beforeClass() throws Exception { @Test public void testParallel() { - KarateStats stats = CucumberRunner.parallel(getClass(), 5); + KarateStats stats = Runner.parallel(getClass(), 5); generateReport(stats.getReportDir()); assertTrue("there are scenario failures", stats.getFailCount() == 0); } diff --git a/karate-demo/src/test/java/demo/callarray/CallJsonArrayRunner.java b/karate-demo/src/test/java/demo/callarray/CallJsonArrayRunner.java index 3dce2a697..edf50c198 100644 --- a/karate-demo/src/test/java/demo/callarray/CallJsonArrayRunner.java +++ b/karate-demo/src/test/java/demo/callarray/CallJsonArrayRunner.java @@ -1,13 +1,13 @@ package demo.callarray; -import cucumber.api.CucumberOptions; +import com.intuit.karate.KarateOptions; import demo.TestBase; /** * * @author pthomas3 */ -@CucumberOptions(features = "classpath:demo/callarray/call-json-array.feature") +@KarateOptions(features = "classpath:demo/callarray/call-json-array.feature") public class CallJsonArrayRunner extends TestBase { } diff --git a/karate-demo/src/test/java/demo/calldynamic/CallDynamicJsonRunner.java b/karate-demo/src/test/java/demo/calldynamic/CallDynamicJsonRunner.java index a89c500cb..74306b853 100644 --- a/karate-demo/src/test/java/demo/calldynamic/CallDynamicJsonRunner.java +++ b/karate-demo/src/test/java/demo/calldynamic/CallDynamicJsonRunner.java @@ -1,13 +1,13 @@ package demo.calldynamic; -import cucumber.api.CucumberOptions; +import com.intuit.karate.KarateOptions; import demo.TestBase; /** * * @author pthomas3 */ -@CucumberOptions(features = "classpath:demo/calldynamic/call-dynamic-json.feature") +@KarateOptions(features = "classpath:demo/calldynamic/call-dynamic-json.feature") public class CallDynamicJsonRunner extends TestBase { } diff --git a/karate-demo/src/test/java/demo/callfeature/CallFeatureRunner.java b/karate-demo/src/test/java/demo/callfeature/CallFeatureRunner.java index 41a80c10f..b3d37c5a6 100644 --- a/karate-demo/src/test/java/demo/callfeature/CallFeatureRunner.java +++ b/karate-demo/src/test/java/demo/callfeature/CallFeatureRunner.java @@ -1,13 +1,13 @@ package demo.callfeature; -import cucumber.api.CucumberOptions; +import com.intuit.karate.KarateOptions; import demo.TestBase; /** * * @author pthomas3 */ -@CucumberOptions(features = "classpath:demo/callfeature/call-feature.feature") +@KarateOptions(features = "classpath:demo/callfeature/call-feature.feature") public class CallFeatureRunner extends TestBase { } diff --git a/karate-demo/src/test/java/demo/callnested/CallNestedRunner.java b/karate-demo/src/test/java/demo/callnested/CallNestedRunner.java index f2787458c..19a8caf32 100644 --- a/karate-demo/src/test/java/demo/callnested/CallNestedRunner.java +++ b/karate-demo/src/test/java/demo/callnested/CallNestedRunner.java @@ -1,13 +1,13 @@ package demo.callnested; -import cucumber.api.CucumberOptions; +import com.intuit.karate.KarateOptions; import demo.TestBase; /** * * @author pthomas3 */ -@CucumberOptions(features = "classpath:demo/callnested/call-nested.feature") +@KarateOptions(features = "classpath:demo/callnested/call-nested.feature") public class CallNestedRunner extends TestBase { } diff --git a/karate-demo/src/test/java/demo/calltable/CallTableRunner.java b/karate-demo/src/test/java/demo/calltable/CallTableRunner.java index 9f2a4ce1e..232c21227 100644 --- a/karate-demo/src/test/java/demo/calltable/CallTableRunner.java +++ b/karate-demo/src/test/java/demo/calltable/CallTableRunner.java @@ -1,13 +1,13 @@ package demo.calltable; -import cucumber.api.CucumberOptions; +import com.intuit.karate.KarateOptions; import demo.TestBase; /** * * @author pthomas3 */ -@CucumberOptions(features = "classpath:demo/calltable/call-table.feature") +@KarateOptions(features = "classpath:demo/calltable/call-table.feature") public class CallTableRunner extends TestBase { } diff --git a/karate-demo/src/test/java/demo/cats/CatsPutRunner.java b/karate-demo/src/test/java/demo/cats/CatsPutRunner.java index 3996db5cc..f5030ba3a 100644 --- a/karate-demo/src/test/java/demo/cats/CatsPutRunner.java +++ b/karate-demo/src/test/java/demo/cats/CatsPutRunner.java @@ -1,13 +1,13 @@ package demo.cats; -import cucumber.api.CucumberOptions; +import com.intuit.karate.KarateOptions; import demo.TestBase; /** * * @author pthomas3 */ -@CucumberOptions(features = "classpath:demo/cats/cats-put.feature") +@KarateOptions(features = "classpath:demo/cats/cats-put.feature") public class CatsPutRunner extends TestBase { } diff --git a/karate-demo/src/test/java/demo/cats/CatsRunner.java b/karate-demo/src/test/java/demo/cats/CatsRunner.java index 91735b875..1d304f6f1 100644 --- a/karate-demo/src/test/java/demo/cats/CatsRunner.java +++ b/karate-demo/src/test/java/demo/cats/CatsRunner.java @@ -1,13 +1,13 @@ package demo.cats; -import cucumber.api.CucumberOptions; +import com.intuit.karate.KarateOptions; import demo.TestBase; /** * * @author pthomas3 */ -@CucumberOptions(features = "classpath:demo/cats/cats.feature") +@KarateOptions(features = "classpath:demo/cats/cats.feature") public class CatsRunner extends TestBase { } diff --git a/karate-demo/src/test/java/demo/cats/CatsXmlRunner.java b/karate-demo/src/test/java/demo/cats/CatsXmlRunner.java index bd8831cf1..3d49b8163 100644 --- a/karate-demo/src/test/java/demo/cats/CatsXmlRunner.java +++ b/karate-demo/src/test/java/demo/cats/CatsXmlRunner.java @@ -1,13 +1,13 @@ package demo.cats; -import cucumber.api.CucumberOptions; +import com.intuit.karate.KarateOptions; import demo.TestBase; /** * * @author pthomas3 */ -@CucumberOptions(features = "classpath:demo/cats/cats-xml.feature") +@KarateOptions(features = "classpath:demo/cats/cats-xml.feature") public class CatsXmlRunner extends TestBase { } diff --git a/karate-demo/src/test/java/demo/cats/KittensRunner.java b/karate-demo/src/test/java/demo/cats/KittensRunner.java index af1177a15..493b41bf7 100644 --- a/karate-demo/src/test/java/demo/cats/KittensRunner.java +++ b/karate-demo/src/test/java/demo/cats/KittensRunner.java @@ -1,13 +1,13 @@ package demo.cats; -import cucumber.api.CucumberOptions; +import com.intuit.karate.KarateOptions; import demo.TestBase; /** * * @author pthomas3 */ -@CucumberOptions(features = "classpath:demo/cats/kittens.feature") +@KarateOptions(features = "classpath:demo/cats/kittens.feature") public class KittensRunner extends TestBase { } diff --git a/karate-demo/src/test/java/demo/cats/SyntaxRunner.java b/karate-demo/src/test/java/demo/cats/SyntaxRunner.java index ed3d93d96..9dafc32ef 100644 --- a/karate-demo/src/test/java/demo/cats/SyntaxRunner.java +++ b/karate-demo/src/test/java/demo/cats/SyntaxRunner.java @@ -1,7 +1,7 @@ package demo.cats; import com.intuit.karate.junit4.Karate; -import cucumber.api.CucumberOptions; +import com.intuit.karate.KarateOptions; import org.junit.runner.RunWith; /** @@ -9,7 +9,7 @@ * @author pthomas3 */ @RunWith(Karate.class) -@CucumberOptions(features = "classpath:demo/cats/syntax-demo.feature") +@KarateOptions(features = "classpath:demo/cats/syntax-demo.feature") public class SyntaxRunner { } diff --git a/karate-demo/src/test/java/demo/dogs/DogsRunner.java b/karate-demo/src/test/java/demo/dogs/DogsRunner.java index bcfd269ca..ea8f0c795 100644 --- a/karate-demo/src/test/java/demo/dogs/DogsRunner.java +++ b/karate-demo/src/test/java/demo/dogs/DogsRunner.java @@ -1,13 +1,13 @@ package demo.dogs; -import cucumber.api.CucumberOptions; +import com.intuit.karate.KarateOptions; import demo.TestBase; /** * * @author pthomas3 */ -@CucumberOptions(features = "classpath:demo/dogs/dogs.feature") +@KarateOptions(features = "classpath:demo/dogs/dogs.feature") public class DogsRunner extends TestBase { } diff --git a/karate-demo/src/test/java/demo/error/ErrorRunner.java b/karate-demo/src/test/java/demo/error/ErrorRunner.java index 88c3de5e0..ba1a6aff8 100644 --- a/karate-demo/src/test/java/demo/error/ErrorRunner.java +++ b/karate-demo/src/test/java/demo/error/ErrorRunner.java @@ -1,13 +1,13 @@ package demo.error; -import cucumber.api.CucumberOptions; +import com.intuit.karate.KarateOptions; import demo.TestBase; /** * * @author pthomas3 */ -@CucumberOptions(features = "classpath:demo/error/error.feature") +@KarateOptions(features = "classpath:demo/error/error.feature") public class ErrorRunner extends TestBase { } diff --git a/karate-demo/src/test/java/demo/headers/CallIsolatedConfigRunner.java b/karate-demo/src/test/java/demo/headers/CallIsolatedConfigRunner.java index 619939418..99041fe61 100644 --- a/karate-demo/src/test/java/demo/headers/CallIsolatedConfigRunner.java +++ b/karate-demo/src/test/java/demo/headers/CallIsolatedConfigRunner.java @@ -1,13 +1,13 @@ package demo.headers; -import cucumber.api.CucumberOptions; +import com.intuit.karate.KarateOptions; import demo.TestBase; /** * * @author pthomas3 */ -@CucumberOptions(features = "classpath:demo/headers/call-isolated-config.feature") +@KarateOptions(features = "classpath:demo/headers/call-isolated-config.feature") public class CallIsolatedConfigRunner extends TestBase { } diff --git a/karate-demo/src/test/java/demo/headers/CallIsolatedHeadersRunner.java b/karate-demo/src/test/java/demo/headers/CallIsolatedHeadersRunner.java index 0b86d7820..dcee74af4 100644 --- a/karate-demo/src/test/java/demo/headers/CallIsolatedHeadersRunner.java +++ b/karate-demo/src/test/java/demo/headers/CallIsolatedHeadersRunner.java @@ -1,13 +1,13 @@ package demo.headers; -import cucumber.api.CucumberOptions; +import com.intuit.karate.KarateOptions; import demo.TestBase; /** * * @author pthomas3 */ -@CucumberOptions(features = "classpath:demo/headers/call-isolated-headers.feature") +@KarateOptions(features = "classpath:demo/headers/call-isolated-headers.feature") public class CallIsolatedHeadersRunner extends TestBase { } diff --git a/karate-demo/src/test/java/demo/headers/CallUpdatesConfigRunner.java b/karate-demo/src/test/java/demo/headers/CallUpdatesConfigRunner.java index 8cf4b17ca..45739a97d 100644 --- a/karate-demo/src/test/java/demo/headers/CallUpdatesConfigRunner.java +++ b/karate-demo/src/test/java/demo/headers/CallUpdatesConfigRunner.java @@ -1,13 +1,13 @@ package demo.headers; -import cucumber.api.CucumberOptions; +import com.intuit.karate.KarateOptions; import demo.TestBase; /** * * @author pthomas3 */ -@CucumberOptions(features = "classpath:demo/headers/call-updates-config.feature") +@KarateOptions(features = "classpath:demo/headers/call-updates-config.feature") public class CallUpdatesConfigRunner extends TestBase { } diff --git a/karate-demo/src/test/java/demo/headers/CallonceBackgroundRunner.java b/karate-demo/src/test/java/demo/headers/CallonceBackgroundRunner.java index 02bf3d442..e5323295f 100644 --- a/karate-demo/src/test/java/demo/headers/CallonceBackgroundRunner.java +++ b/karate-demo/src/test/java/demo/headers/CallonceBackgroundRunner.java @@ -1,13 +1,13 @@ package demo.headers; -import cucumber.api.CucumberOptions; +import com.intuit.karate.KarateOptions; import demo.TestBase; /** * * @author pthomas3 */ -@CucumberOptions(features = "classpath:demo/headers/callonce-background-multiscenario.feature") +@KarateOptions(features = "classpath:demo/headers/callonce-background-multiscenario.feature") public class CallonceBackgroundRunner extends TestBase { } diff --git a/karate-demo/src/test/java/demo/headers/ContentTypeRunner.java b/karate-demo/src/test/java/demo/headers/ContentTypeRunner.java index 4bf2b2114..95837cd5a 100644 --- a/karate-demo/src/test/java/demo/headers/ContentTypeRunner.java +++ b/karate-demo/src/test/java/demo/headers/ContentTypeRunner.java @@ -1,13 +1,13 @@ package demo.headers; -import cucumber.api.CucumberOptions; +import com.intuit.karate.KarateOptions; import demo.TestBase; /** * * @author pthomas3 */ -@CucumberOptions(features = "classpath:demo/headers/content-type.feature") +@KarateOptions(features = "classpath:demo/headers/content-type.feature") public class ContentTypeRunner extends TestBase { } diff --git a/karate-demo/src/test/java/demo/headers/HeadersFormGetRunner.java b/karate-demo/src/test/java/demo/headers/HeadersFormGetRunner.java index 064ac352b..53b9e3027 100644 --- a/karate-demo/src/test/java/demo/headers/HeadersFormGetRunner.java +++ b/karate-demo/src/test/java/demo/headers/HeadersFormGetRunner.java @@ -1,13 +1,13 @@ package demo.headers; -import cucumber.api.CucumberOptions; +import com.intuit.karate.KarateOptions; import demo.TestBase; /** * * @author pthomas3 */ -@CucumberOptions(features = "classpath:demo/headers/headers-form-get.feature") +@KarateOptions(features = "classpath:demo/headers/headers-form-get.feature") public class HeadersFormGetRunner extends TestBase { } diff --git a/karate-demo/src/test/java/demo/headers/HeadersRunner.java b/karate-demo/src/test/java/demo/headers/HeadersRunner.java index b431d4f04..458b5d2f0 100644 --- a/karate-demo/src/test/java/demo/headers/HeadersRunner.java +++ b/karate-demo/src/test/java/demo/headers/HeadersRunner.java @@ -1,13 +1,13 @@ package demo.headers; -import cucumber.api.CucumberOptions; +import com.intuit.karate.KarateOptions; import demo.TestBase; /** * * @author pthomas3 */ -@CucumberOptions(features = "classpath:demo/headers/headers.feature") +@KarateOptions(features = "classpath:demo/headers/headers.feature") public class HeadersRunner extends TestBase { } diff --git a/karate-demo/src/test/java/demo/headers/HeadersSingleRunner.java b/karate-demo/src/test/java/demo/headers/HeadersSingleRunner.java index ba36a3f40..f5a7d80c5 100644 --- a/karate-demo/src/test/java/demo/headers/HeadersSingleRunner.java +++ b/karate-demo/src/test/java/demo/headers/HeadersSingleRunner.java @@ -1,13 +1,13 @@ package demo.headers; -import cucumber.api.CucumberOptions; +import com.intuit.karate.KarateOptions; import demo.TestBase; /** * * @author pthomas3 */ -@CucumberOptions(features = "classpath:demo/headers/headers-single.feature") +@KarateOptions(features = "classpath:demo/headers/headers-single.feature") public class HeadersSingleRunner extends TestBase { } diff --git a/karate-demo/src/test/java/demo/headers/NullHeaderRunner.java b/karate-demo/src/test/java/demo/headers/NullHeaderRunner.java index d068275b6..b64c3664a 100644 --- a/karate-demo/src/test/java/demo/headers/NullHeaderRunner.java +++ b/karate-demo/src/test/java/demo/headers/NullHeaderRunner.java @@ -1,13 +1,13 @@ package demo.headers; -import cucumber.api.CucumberOptions; +import com.intuit.karate.KarateOptions; import demo.TestBase; /** * * @author pthomas3 */ -@CucumberOptions(features = "classpath:demo/headers/null-header.feature") +@KarateOptions(features = "classpath:demo/headers/null-header.feature") public class NullHeaderRunner extends TestBase { } diff --git a/karate-demo/src/test/java/demo/hooks/CalledRunner.java b/karate-demo/src/test/java/demo/hooks/CalledRunner.java index c3480b19c..6366b823c 100644 --- a/karate-demo/src/test/java/demo/hooks/CalledRunner.java +++ b/karate-demo/src/test/java/demo/hooks/CalledRunner.java @@ -1,7 +1,7 @@ package demo.hooks; import com.intuit.karate.junit4.Karate; -import cucumber.api.CucumberOptions; +import com.intuit.karate.KarateOptions; import org.junit.BeforeClass; import org.junit.runner.RunWith; @@ -10,7 +10,7 @@ * @author pthomas3 */ @RunWith(Karate.class) -@CucumberOptions(features = "classpath:demo/hooks/called.feature") +@KarateOptions(features = "classpath:demo/hooks/called.feature") public class CalledRunner { @BeforeClass diff --git a/karate-demo/src/test/java/demo/hooks/HooksRunner.java b/karate-demo/src/test/java/demo/hooks/HooksRunner.java index ca9cea26f..e3bb69d3d 100644 --- a/karate-demo/src/test/java/demo/hooks/HooksRunner.java +++ b/karate-demo/src/test/java/demo/hooks/HooksRunner.java @@ -1,7 +1,7 @@ package demo.hooks; import com.intuit.karate.junit4.Karate; -import cucumber.api.CucumberOptions; +import com.intuit.karate.KarateOptions; import org.junit.BeforeClass; import org.junit.runner.RunWith; @@ -10,7 +10,7 @@ * @author pthomas3 */ @RunWith(Karate.class) -@CucumberOptions(features = "classpath:demo/hooks/hooks.feature") +@KarateOptions(features = "classpath:demo/hooks/hooks.feature") public class HooksRunner { @BeforeClass diff --git a/karate-demo/src/test/java/demo/loopcall/AltLoopCallRunner.java b/karate-demo/src/test/java/demo/loopcall/AltLoopCallRunner.java index 800d1e920..fe1effcee 100644 --- a/karate-demo/src/test/java/demo/loopcall/AltLoopCallRunner.java +++ b/karate-demo/src/test/java/demo/loopcall/AltLoopCallRunner.java @@ -1,13 +1,13 @@ package demo.loopcall; -import cucumber.api.CucumberOptions; +import com.intuit.karate.KarateOptions; import demo.TestBase; /** * * @author pthomas3 */ -@CucumberOptions(features = "classpath:demo/loopcall/alt-loop.feature") +@KarateOptions(features = "classpath:demo/loopcall/alt-loop.feature") public class AltLoopCallRunner extends TestBase { } diff --git a/karate-demo/src/test/java/demo/loopcall/LoopCallRunner.java b/karate-demo/src/test/java/demo/loopcall/LoopCallRunner.java index 53c9a7789..86e186a38 100644 --- a/karate-demo/src/test/java/demo/loopcall/LoopCallRunner.java +++ b/karate-demo/src/test/java/demo/loopcall/LoopCallRunner.java @@ -1,13 +1,13 @@ package demo.loopcall; -import cucumber.api.CucumberOptions; +import com.intuit.karate.KarateOptions; import demo.TestBase; /** * * @author pthomas3 */ -@CucumberOptions(features = "classpath:demo/loopcall/loop.feature") +@KarateOptions(features = "classpath:demo/loopcall/loop.feature") public class LoopCallRunner extends TestBase { } diff --git a/karate-demo/src/test/java/demo/oauth/Oauth1Runner.java b/karate-demo/src/test/java/demo/oauth/Oauth1Runner.java index 75428fa5e..ec196227b 100644 --- a/karate-demo/src/test/java/demo/oauth/Oauth1Runner.java +++ b/karate-demo/src/test/java/demo/oauth/Oauth1Runner.java @@ -1,9 +1,9 @@ package demo.oauth; -import cucumber.api.CucumberOptions; +import com.intuit.karate.KarateOptions; import demo.TestBase; -@CucumberOptions(features = "classpath:demo/oauth/oauth1.feature") +@KarateOptions(features = "classpath:demo/oauth/oauth1.feature") public class Oauth1Runner extends TestBase { diff --git a/karate-demo/src/test/java/demo/oauth/Oauth2Runner.java b/karate-demo/src/test/java/demo/oauth/Oauth2Runner.java index d3392ad64..3364a5610 100644 --- a/karate-demo/src/test/java/demo/oauth/Oauth2Runner.java +++ b/karate-demo/src/test/java/demo/oauth/Oauth2Runner.java @@ -1,12 +1,12 @@ package demo.oauth; import com.intuit.karate.junit4.Karate; -import cucumber.api.CucumberOptions; +import com.intuit.karate.KarateOptions; import org.junit.BeforeClass; import org.junit.runner.RunWith; @RunWith(Karate.class) -@CucumberOptions(features = "classpath:demo/oauth/oauth2.feature") +@KarateOptions(features = "classpath:demo/oauth/oauth2.feature") public class Oauth2Runner { @BeforeClass diff --git a/karate-demo/src/test/java/demo/outline/OutlineRunner.java b/karate-demo/src/test/java/demo/outline/OutlineRunner.java index ae2418dbc..32c499c20 100644 --- a/karate-demo/src/test/java/demo/outline/OutlineRunner.java +++ b/karate-demo/src/test/java/demo/outline/OutlineRunner.java @@ -1,13 +1,13 @@ package demo.outline; -import cucumber.api.CucumberOptions; +import com.intuit.karate.KarateOptions; import demo.TestBase; /** * * @author pthomas3 */ -@CucumberOptions(features = "classpath:demo/outline/examples.feature") +@KarateOptions(features = "classpath:demo/outline/examples.feature") public class OutlineRunner extends TestBase { } diff --git a/karate-demo/src/test/java/demo/polling/PollingRunner.java b/karate-demo/src/test/java/demo/polling/PollingRunner.java index d702fbe79..756daab13 100644 --- a/karate-demo/src/test/java/demo/polling/PollingRunner.java +++ b/karate-demo/src/test/java/demo/polling/PollingRunner.java @@ -1,13 +1,13 @@ package demo.polling; -import cucumber.api.CucumberOptions; +import com.intuit.karate.KarateOptions; import demo.TestBase; /** * * @author pthomas3 */ -@CucumberOptions(features = "classpath:demo/polling/polling.feature") +@KarateOptions(features = "classpath:demo/polling/polling.feature") public class PollingRunner extends TestBase { } diff --git a/karate-demo/src/test/java/demo/read/ReadRunner.java b/karate-demo/src/test/java/demo/read/ReadRunner.java index 422f03072..a78479cc8 100644 --- a/karate-demo/src/test/java/demo/read/ReadRunner.java +++ b/karate-demo/src/test/java/demo/read/ReadRunner.java @@ -1,13 +1,13 @@ package demo.read; -import cucumber.api.CucumberOptions; +import com.intuit.karate.KarateOptions; import demo.TestBase; /** * * @author pthomas3 */ -@CucumberOptions(features = "classpath:demo/read/read-files.feature") +@KarateOptions(features = "classpath:demo/read/read-files.feature") public class ReadRunner extends TestBase { } diff --git a/karate-demo/src/test/java/demo/redirect/RedirectRunner.java b/karate-demo/src/test/java/demo/redirect/RedirectRunner.java index 32d3508e9..71eee66fa 100644 --- a/karate-demo/src/test/java/demo/redirect/RedirectRunner.java +++ b/karate-demo/src/test/java/demo/redirect/RedirectRunner.java @@ -1,13 +1,13 @@ package demo.redirect; -import cucumber.api.CucumberOptions; +import com.intuit.karate.KarateOptions; import demo.TestBase; /** * * @author pthomas3 */ -@CucumberOptions(features = "classpath:demo/redirect/redirect.feature") +@KarateOptions(features = "classpath:demo/redirect/redirect.feature") public class RedirectRunner extends TestBase { } diff --git a/karate-demo/src/test/java/demo/search/SearchRunner.java b/karate-demo/src/test/java/demo/search/SearchRunner.java index 0088b6485..42f42f315 100644 --- a/karate-demo/src/test/java/demo/search/SearchRunner.java +++ b/karate-demo/src/test/java/demo/search/SearchRunner.java @@ -1,13 +1,13 @@ package demo.search; -import cucumber.api.CucumberOptions; +import com.intuit.karate.KarateOptions; import demo.TestBase; /** * * @author pthomas3 */ -@CucumberOptions(features = "classpath:demo/search/dynamic-params.feature") +@KarateOptions(features = "classpath:demo/search/dynamic-params.feature") public class SearchRunner extends TestBase { } diff --git a/karate-demo/src/test/java/demo/tags/TagsFireRunner.java b/karate-demo/src/test/java/demo/tags/TagsFireRunner.java index fa12fd6ff..05df5b310 100644 --- a/karate-demo/src/test/java/demo/tags/TagsFireRunner.java +++ b/karate-demo/src/test/java/demo/tags/TagsFireRunner.java @@ -1,7 +1,7 @@ package demo.tags; import com.intuit.karate.junit4.Karate; -import cucumber.api.CucumberOptions; +import com.intuit.karate.KarateOptions; import org.junit.BeforeClass; import org.junit.runner.RunWith; @@ -10,7 +10,7 @@ * @author pthomas3 */ @RunWith(Karate.class) -@CucumberOptions(tags="@fire") +@KarateOptions(tags="@fire") public class TagsFireRunner { @BeforeClass diff --git a/karate-demo/src/test/java/demo/tags/TagsSmokeNotFireRunner.java b/karate-demo/src/test/java/demo/tags/TagsSmokeNotFireRunner.java index 368e56f20..ba2b303f1 100644 --- a/karate-demo/src/test/java/demo/tags/TagsSmokeNotFireRunner.java +++ b/karate-demo/src/test/java/demo/tags/TagsSmokeNotFireRunner.java @@ -1,7 +1,7 @@ package demo.tags; import com.intuit.karate.junit4.Karate; -import cucumber.api.CucumberOptions; +import com.intuit.karate.KarateOptions; import org.junit.BeforeClass; import org.junit.runner.RunWith; @@ -10,7 +10,7 @@ * @author pthomas3 */ @RunWith(Karate.class) -@CucumberOptions(tags={"@smoke", "~@fire"}) +@KarateOptions(tags={"@smoke", "~@fire"}) public class TagsSmokeNotFireRunner { @BeforeClass diff --git a/karate-demo/src/test/java/demo/tags/TagsSmokeRunner.java b/karate-demo/src/test/java/demo/tags/TagsSmokeRunner.java index 190e8f71a..7b76d5439 100644 --- a/karate-demo/src/test/java/demo/tags/TagsSmokeRunner.java +++ b/karate-demo/src/test/java/demo/tags/TagsSmokeRunner.java @@ -1,7 +1,7 @@ package demo.tags; import com.intuit.karate.junit4.Karate; -import cucumber.api.CucumberOptions; +import com.intuit.karate.KarateOptions; import org.junit.BeforeClass; import org.junit.runner.RunWith; @@ -10,7 +10,7 @@ * @author pthomas3 */ @RunWith(Karate.class) -@CucumberOptions(tags="@smoke") +@KarateOptions(tags="@smoke") public class TagsSmokeRunner { @BeforeClass diff --git a/karate-demo/src/test/java/demo/upload/UploadImageRunner.java b/karate-demo/src/test/java/demo/upload/UploadImageRunner.java index 313dfeedb..a0be1c81b 100644 --- a/karate-demo/src/test/java/demo/upload/UploadImageRunner.java +++ b/karate-demo/src/test/java/demo/upload/UploadImageRunner.java @@ -1,13 +1,13 @@ package demo.upload; -import cucumber.api.CucumberOptions; +import com.intuit.karate.KarateOptions; import demo.TestBase; /** * * @author pthomas3 */ -@CucumberOptions(features = "classpath:demo/upload/upload-image.feature") +@KarateOptions(features = "classpath:demo/upload/upload-image.feature") public class UploadImageRunner extends TestBase { } diff --git a/karate-demo/src/test/java/demo/upload/UploadMultipleFieldsRunner.java b/karate-demo/src/test/java/demo/upload/UploadMultipleFieldsRunner.java index 9a13bc68e..c4b177451 100644 --- a/karate-demo/src/test/java/demo/upload/UploadMultipleFieldsRunner.java +++ b/karate-demo/src/test/java/demo/upload/UploadMultipleFieldsRunner.java @@ -1,13 +1,13 @@ package demo.upload; -import cucumber.api.CucumberOptions; +import com.intuit.karate.KarateOptions; import demo.TestBase; /** * * @author ssishtla */ -@CucumberOptions(features = "classpath:demo/upload/upload-multiple-fields.feature") +@KarateOptions(features = "classpath:demo/upload/upload-multiple-fields.feature") public class UploadMultipleFieldsRunner extends TestBase { } diff --git a/karate-demo/src/test/java/demo/upload/UploadMultipleFilesRunner.java b/karate-demo/src/test/java/demo/upload/UploadMultipleFilesRunner.java index 52e48b532..a2e24ca77 100644 --- a/karate-demo/src/test/java/demo/upload/UploadMultipleFilesRunner.java +++ b/karate-demo/src/test/java/demo/upload/UploadMultipleFilesRunner.java @@ -1,13 +1,13 @@ package demo.upload; -import cucumber.api.CucumberOptions; +import com.intuit.karate.KarateOptions; import demo.TestBase; /** * * @author ssishtla */ -@CucumberOptions(features = "classpath:demo/upload/upload-multiple-files.feature") +@KarateOptions(features = "classpath:demo/upload/upload-multiple-files.feature") public class UploadMultipleFilesRunner extends TestBase { } diff --git a/karate-demo/src/test/java/demo/upload/UploadRunner.java b/karate-demo/src/test/java/demo/upload/UploadRunner.java index a8264d27e..d68b32fcd 100644 --- a/karate-demo/src/test/java/demo/upload/UploadRunner.java +++ b/karate-demo/src/test/java/demo/upload/UploadRunner.java @@ -1,13 +1,13 @@ package demo.upload; -import cucumber.api.CucumberOptions; +import com.intuit.karate.KarateOptions; import demo.TestBase; /** * * @author pthomas3 */ -@CucumberOptions(features = "classpath:demo/upload/upload.feature") +@KarateOptions(features = "classpath:demo/upload/upload.feature") public class UploadRunner extends TestBase { } diff --git a/karate-demo/src/test/java/mock/contract/PaymentServiceContractSslTest.java b/karate-demo/src/test/java/mock/contract/PaymentServiceContractSslTest.java index 4f60a6692..e4819db65 100644 --- a/karate-demo/src/test/java/mock/contract/PaymentServiceContractSslTest.java +++ b/karate-demo/src/test/java/mock/contract/PaymentServiceContractSslTest.java @@ -1,7 +1,7 @@ package mock.contract; import com.intuit.karate.junit4.Karate; -import cucumber.api.CucumberOptions; +import com.intuit.karate.KarateOptions; import org.junit.AfterClass; import org.junit.BeforeClass; import org.junit.runner.RunWith; @@ -12,7 +12,7 @@ * @author pthomas3 */ @RunWith(Karate.class) -@CucumberOptions(features = "classpath:mock/contract/payment-service.feature") +@KarateOptions(features = "classpath:mock/contract/payment-service.feature") public class PaymentServiceContractSslTest { private static ConfigurableApplicationContext context; diff --git a/karate-demo/src/test/java/mock/contract/PaymentServiceContractTest.java b/karate-demo/src/test/java/mock/contract/PaymentServiceContractTest.java index d6e4b7420..642c14871 100644 --- a/karate-demo/src/test/java/mock/contract/PaymentServiceContractTest.java +++ b/karate-demo/src/test/java/mock/contract/PaymentServiceContractTest.java @@ -1,7 +1,7 @@ package mock.contract; import com.intuit.karate.junit4.Karate; -import cucumber.api.CucumberOptions; +import com.intuit.karate.KarateOptions; import org.junit.AfterClass; import org.junit.BeforeClass; import org.junit.runner.RunWith; @@ -12,7 +12,7 @@ * @author pthomas3 */ @RunWith(Karate.class) -@CucumberOptions(features = "classpath:mock/contract/payment-service.feature") +@KarateOptions(features = "classpath:mock/contract/payment-service.feature") public class PaymentServiceContractTest { private static ConfigurableApplicationContext context; diff --git a/karate-demo/src/test/java/mock/contract/PaymentServiceContractUsingMockSslTest.java b/karate-demo/src/test/java/mock/contract/PaymentServiceContractUsingMockSslTest.java index 0b24f5a22..4031c58b4 100644 --- a/karate-demo/src/test/java/mock/contract/PaymentServiceContractUsingMockSslTest.java +++ b/karate-demo/src/test/java/mock/contract/PaymentServiceContractUsingMockSslTest.java @@ -3,7 +3,7 @@ import com.intuit.karate.FileUtils; import com.intuit.karate.junit4.Karate; import com.intuit.karate.netty.FeatureServer; -import cucumber.api.CucumberOptions; +import com.intuit.karate.KarateOptions; import java.io.File; import java.util.Collections; import org.junit.AfterClass; @@ -15,7 +15,7 @@ * @author pthomas3 */ @RunWith(Karate.class) -@CucumberOptions(features = "classpath:mock/contract/payment-service.feature") +@KarateOptions(features = "classpath:mock/contract/payment-service.feature") public class PaymentServiceContractUsingMockSslTest { private static FeatureServer server; diff --git a/karate-demo/src/test/java/mock/contract/PaymentServiceContractUsingMockTest.java b/karate-demo/src/test/java/mock/contract/PaymentServiceContractUsingMockTest.java index 408b0867b..039769aa6 100644 --- a/karate-demo/src/test/java/mock/contract/PaymentServiceContractUsingMockTest.java +++ b/karate-demo/src/test/java/mock/contract/PaymentServiceContractUsingMockTest.java @@ -3,7 +3,7 @@ import com.intuit.karate.FileUtils; import com.intuit.karate.junit4.Karate; import com.intuit.karate.netty.FeatureServer; -import cucumber.api.CucumberOptions; +import com.intuit.karate.KarateOptions; import java.io.File; import java.util.Collections; import org.junit.AfterClass; @@ -15,7 +15,7 @@ * @author pthomas3 */ @RunWith(Karate.class) -@CucumberOptions(features = "classpath:mock/contract/payment-service.feature") +@KarateOptions(features = "classpath:mock/contract/payment-service.feature") public class PaymentServiceContractUsingMockTest { private static FeatureServer server; diff --git a/karate-demo/src/test/java/mock/micro/MicroMockRunner.java b/karate-demo/src/test/java/mock/micro/MicroMockRunner.java index 9ade1e423..20e6125d2 100644 --- a/karate-demo/src/test/java/mock/micro/MicroMockRunner.java +++ b/karate-demo/src/test/java/mock/micro/MicroMockRunner.java @@ -3,7 +3,7 @@ import com.intuit.karate.FileUtils; import com.intuit.karate.junit4.Karate; import com.intuit.karate.netty.FeatureServer; -import cucumber.api.CucumberOptions; +import com.intuit.karate.KarateOptions; import java.io.File; import org.junit.BeforeClass; import org.junit.runner.RunWith; @@ -13,7 +13,7 @@ * @author pthomas3 */ @RunWith(Karate.class) -@CucumberOptions(features = "classpath:mock/micro/cats.feature") +@KarateOptions(features = "classpath:mock/micro/cats.feature") public class MicroMockRunner { @BeforeClass diff --git a/karate-demo/src/test/java/mock/micro/WebMockRunner.java b/karate-demo/src/test/java/mock/micro/WebMockRunner.java index f8a56c108..dc1966c7c 100644 --- a/karate-demo/src/test/java/mock/micro/WebMockRunner.java +++ b/karate-demo/src/test/java/mock/micro/WebMockRunner.java @@ -3,7 +3,7 @@ import com.intuit.karate.FileUtils; import com.intuit.karate.junit4.Karate; import com.intuit.karate.netty.FeatureServer; -import cucumber.api.CucumberOptions; +import com.intuit.karate.KarateOptions; import java.io.File; import org.junit.BeforeClass; import org.junit.runner.RunWith; @@ -13,7 +13,7 @@ * @author pthomas3 */ @RunWith(Karate.class) -@CucumberOptions(features = "classpath:mock/micro/web.feature") +@KarateOptions(features = "classpath:mock/micro/web.feature") public class WebMockRunner { @BeforeClass diff --git a/karate-demo/src/test/java/mock/proxy/DemoMockProceedRunner.java b/karate-demo/src/test/java/mock/proxy/DemoMockProceedRunner.java index ad56bd3b2..814bc4c38 100644 --- a/karate-demo/src/test/java/mock/proxy/DemoMockProceedRunner.java +++ b/karate-demo/src/test/java/mock/proxy/DemoMockProceedRunner.java @@ -2,10 +2,10 @@ import com.intuit.karate.FileUtils; import com.intuit.karate.Match; -import com.intuit.karate.cucumber.CucumberRunner; -import com.intuit.karate.cucumber.KarateStats; +import com.intuit.karate.Runner; +import com.intuit.karate.KarateStats; import com.intuit.karate.netty.FeatureServer; -import cucumber.api.CucumberOptions; +import com.intuit.karate.KarateOptions; import demo.TestBase; import java.io.File; import java.util.Map; @@ -18,7 +18,7 @@ * * @author pthomas3 */ -@CucumberOptions(tags = "~@ignore", features = { +@KarateOptions(tags = "~@ignore", features = { "classpath:demo/cats", "classpath:demo/greeting"}) public class DemoMockProceedRunner { @@ -45,7 +45,7 @@ public void testParallel() { System.setProperty("demo.server.port", port + ""); System.setProperty("demo.server.https", "false"); String karateOutputPath = "target/mock-proceed"; - KarateStats stats = CucumberRunner.parallel(getClass(), 1, karateOutputPath); + KarateStats stats = Runner.parallel(getClass(), 1, karateOutputPath); // DemoMockUtils.generateReport(karateOutputPath); assertTrue("there are scenario failures", stats.getFailCount() == 0); } diff --git a/karate-demo/src/test/java/mock/proxy/DemoMockProxyRunner.java b/karate-demo/src/test/java/mock/proxy/DemoMockProxyRunner.java index caedc9dcb..6cee8d5f7 100644 --- a/karate-demo/src/test/java/mock/proxy/DemoMockProxyRunner.java +++ b/karate-demo/src/test/java/mock/proxy/DemoMockProxyRunner.java @@ -2,10 +2,10 @@ import com.intuit.karate.FileUtils; import com.intuit.karate.Match; -import com.intuit.karate.cucumber.CucumberRunner; -import com.intuit.karate.cucumber.KarateStats; +import com.intuit.karate.Runner; +import com.intuit.karate.KarateStats; import com.intuit.karate.netty.FeatureServer; -import cucumber.api.CucumberOptions; +import com.intuit.karate.KarateOptions; import demo.TestBase; import java.io.File; import java.util.Map; @@ -18,7 +18,7 @@ * * @author pthomas3 */ -@CucumberOptions(tags = "~@ignore", features = { +@KarateOptions(tags = "~@ignore", features = { "classpath:demo/cats", "classpath:demo/greeting"}) public class DemoMockProxyRunner { @@ -46,7 +46,7 @@ public void testParallel() { System.setProperty("demo.proxy.port", server.getPort() + ""); System.setProperty("demo.server.https", "false"); String karateOutputPath = "target/mock-proxy"; - KarateStats stats = CucumberRunner.parallel(getClass(), 1, karateOutputPath); + KarateStats stats = Runner.parallel(getClass(), 1, karateOutputPath); // DemoMockUtils.generateReport(karateOutputPath); assertTrue("there are scenario failures", stats.getFailCount() == 0); } diff --git a/karate-demo/src/test/java/mock/proxy/DemoMockRunner.java b/karate-demo/src/test/java/mock/proxy/DemoMockRunner.java index e6006393f..b096e88ce 100644 --- a/karate-demo/src/test/java/mock/proxy/DemoMockRunner.java +++ b/karate-demo/src/test/java/mock/proxy/DemoMockRunner.java @@ -1,10 +1,10 @@ package mock.proxy; import com.intuit.karate.FileUtils; -import com.intuit.karate.cucumber.CucumberRunner; -import com.intuit.karate.cucumber.KarateStats; +import com.intuit.karate.Runner; +import com.intuit.karate.KarateStats; import com.intuit.karate.netty.FeatureServer; -import cucumber.api.CucumberOptions; +import com.intuit.karate.KarateOptions; import java.io.File; import org.junit.AfterClass; import static org.junit.Assert.assertTrue; @@ -15,7 +15,7 @@ * * @author pthomas3 */ -@CucumberOptions(tags = "~@ignore", features = { +@KarateOptions(tags = "~@ignore", features = { "classpath:demo/cats", "classpath:demo/greeting"}) public class DemoMockRunner { @@ -40,7 +40,7 @@ public void testParallel() { System.setProperty("demo.server.port", port + ""); System.setProperty("demo.server.https", "false"); String karateOutputPath = "target/mock"; - KarateStats stats = CucumberRunner.parallel(getClass(), 1, karateOutputPath); + KarateStats stats = Runner.parallel(getClass(), 1, karateOutputPath); DemoMockUtils.generateReport(karateOutputPath); assertTrue("there are scenario failures", stats.getFailCount() == 0); } diff --git a/karate-demo/src/test/java/mock/proxy/DemoMockSslRunner.java b/karate-demo/src/test/java/mock/proxy/DemoMockSslRunner.java index dc7f3a13b..00db23e69 100644 --- a/karate-demo/src/test/java/mock/proxy/DemoMockSslRunner.java +++ b/karate-demo/src/test/java/mock/proxy/DemoMockSslRunner.java @@ -1,10 +1,10 @@ package mock.proxy; import com.intuit.karate.FileUtils; -import com.intuit.karate.cucumber.CucumberRunner; -import com.intuit.karate.cucumber.KarateStats; +import com.intuit.karate.Runner; +import com.intuit.karate.KarateStats; import com.intuit.karate.netty.FeatureServer; -import cucumber.api.CucumberOptions; +import com.intuit.karate.KarateOptions; import java.io.File; import org.junit.AfterClass; import static org.junit.Assert.assertTrue; @@ -15,7 +15,7 @@ * * @author pthomas3 */ -@CucumberOptions(tags = "~@ignore", features = { +@KarateOptions(tags = "~@ignore", features = { "classpath:demo/cats", "classpath:demo/greeting"}) public class DemoMockSslRunner { @@ -40,7 +40,7 @@ public void testParallel() { System.setProperty("demo.server.port", port + ""); System.setProperty("demo.server.https", "true"); String karateOutputPath = "target/mock-ssl"; - KarateStats stats = CucumberRunner.parallel(getClass(), 1, karateOutputPath); + KarateStats stats = Runner.parallel(getClass(), 1, karateOutputPath); DemoMockUtils.generateReport(karateOutputPath); assertTrue("there are scenario failures", stats.getFailCount() == 0); } diff --git a/karate-demo/src/test/java/mock/web/CatsTestRunner.java b/karate-demo/src/test/java/mock/web/CatsTestRunner.java index 60a00d595..3dbb088d5 100644 --- a/karate-demo/src/test/java/mock/web/CatsTestRunner.java +++ b/karate-demo/src/test/java/mock/web/CatsTestRunner.java @@ -1,7 +1,7 @@ package mock.web; import com.intuit.karate.junit4.Karate; -import cucumber.api.CucumberOptions; +import com.intuit.karate.KarateOptions; import org.junit.BeforeClass; import org.junit.runner.RunWith; @@ -10,7 +10,7 @@ * @author pthomas3 */ @RunWith(Karate.class) -@CucumberOptions(features = "classpath:mock/web/cats-test.feature") +@KarateOptions(features = "classpath:mock/web/cats-test.feature") public class CatsTestRunner { @BeforeClass diff --git a/karate-demo/src/test/java/ssl/SslTest.java b/karate-demo/src/test/java/ssl/SslTest.java index 56dff4663..557dd03d9 100644 --- a/karate-demo/src/test/java/ssl/SslTest.java +++ b/karate-demo/src/test/java/ssl/SslTest.java @@ -1,7 +1,7 @@ package ssl; import com.intuit.karate.junit4.Karate; -import cucumber.api.CucumberOptions; +import com.intuit.karate.KarateOptions; import org.junit.AfterClass; import org.junit.BeforeClass; import org.junit.runner.RunWith; @@ -12,7 +12,7 @@ * @author pthomas3 */ @RunWith(Karate.class) -@CucumberOptions(features = "classpath:ssl") +@KarateOptions(features = "classpath:ssl") public class SslTest { private static ConfigurableApplicationContext context; diff --git a/karate-gatling/src/main/scala/com/intuit/karate/gatling/KarateAction.scala b/karate-gatling/src/main/scala/com/intuit/karate/gatling/KarateAction.scala index 843a58782..63890998b 100644 --- a/karate-gatling/src/main/scala/com/intuit/karate/gatling/KarateAction.scala +++ b/karate-gatling/src/main/scala/com/intuit/karate/gatling/KarateAction.scala @@ -6,7 +6,7 @@ import java.util.function.Consumer import akka.actor.{Actor, ActorRef, ActorSystem, Props} import com.intuit.karate.{CallContext, PerfEvent, ScenarioContext} import com.intuit.karate.core._ -import com.intuit.karate.cucumber.CucumberRunner +import com.intuit.karate.Runner import com.intuit.karate.http.HttpRequestBuilder import io.gatling.commons.stats.{KO, OK} import io.gatling.core.action.{Action, ExitableAction} @@ -59,7 +59,7 @@ class KarateAction(val name: String, val protocol: KarateProtocol, val system: A val asyncNext: Runnable = () => next ! session val callContext = new CallContext(false, executionHook) - CucumberRunner.callAsync(name, callContext, asyncSystem, asyncNext) + Runner.callAsync(name, callContext, asyncSystem, asyncNext) } diff --git a/karate-jersey/src/test/java/demo/JerseyHttpClientTest.java b/karate-jersey/src/test/java/demo/JerseyHttpClientTest.java index 4c1c347d4..ed36e6f68 100644 --- a/karate-jersey/src/test/java/demo/JerseyHttpClientTest.java +++ b/karate-jersey/src/test/java/demo/JerseyHttpClientTest.java @@ -1,10 +1,10 @@ package demo; -import com.intuit.karate.cucumber.CucumberRunner; -import com.intuit.karate.cucumber.KarateStats; +import com.intuit.karate.Runner; +import com.intuit.karate.KarateStats; import com.intuit.karate.demo.Application; import com.intuit.karate.demo.config.ServerStartedInitializingBean; -import cucumber.api.CucumberOptions; +import com.intuit.karate.KarateOptions; import java.io.File; import org.apache.commons.io.FileUtils; import static org.junit.Assert.assertTrue; @@ -15,7 +15,7 @@ * * @author pthomas3 */ -@CucumberOptions(tags = {"~@ignore", "~@apache"}) +@KarateOptions(tags = {"~@ignore", "~@apache"}) public class JerseyHttpClientTest { @Test @@ -28,7 +28,7 @@ public void testJerseyClient() throws Exception { System.setProperty("karate.env", "jersey"); System.setProperty("demo.server.port", ss.getLocalPort() + ""); System.setProperty("demo.server.https", "false"); - KarateStats stats = CucumberRunner.parallel(getClass(), 5); + KarateStats stats = Runner.parallel(getClass(), 5); assertTrue("there are scenario failures", stats.getFailCount() == 0); } diff --git a/karate-jersey/src/test/java/ssl/SslTest.java b/karate-jersey/src/test/java/ssl/SslTest.java index 273992625..50fdb5d12 100644 --- a/karate-jersey/src/test/java/ssl/SslTest.java +++ b/karate-jersey/src/test/java/ssl/SslTest.java @@ -1,8 +1,8 @@ package ssl; -import com.intuit.karate.cucumber.CucumberRunner; -import com.intuit.karate.cucumber.KarateStats; -import cucumber.api.CucumberOptions; +import com.intuit.karate.Runner; +import com.intuit.karate.KarateStats; +import com.intuit.karate.KarateOptions; import org.junit.AfterClass; import static org.junit.Assert.assertTrue; import org.junit.BeforeClass; @@ -13,7 +13,7 @@ * * @author pthomas3 */ -@CucumberOptions(features = "classpath:ssl") +@KarateOptions(features = "classpath:ssl") public class SslTest { private static ConfigurableApplicationContext context; @@ -29,7 +29,7 @@ public void testSsl() { // skip callSingle, note that the karate-config.js copied from demo may be present System.setProperty("karate.env", "mock"); System.setProperty("jersey.ssl.port", port + ""); - KarateStats stats = CucumberRunner.parallel(getClass(), 1, "target/ssl"); + KarateStats stats = Runner.parallel(getClass(), 1, "target/ssl"); assertTrue("there are scenario failures", stats.getFailCount() == 0); } diff --git a/karate-junit4/src/main/java/com/intuit/karate/junit4/Karate.java b/karate-junit4/src/main/java/com/intuit/karate/junit4/Karate.java index c2d0714e1..e89e75f72 100644 --- a/karate-junit4/src/main/java/com/intuit/karate/junit4/Karate.java +++ b/karate-junit4/src/main/java/com/intuit/karate/junit4/Karate.java @@ -2,7 +2,7 @@ import com.intuit.karate.Resource; import com.intuit.karate.FileUtils; -import com.intuit.karate.KarateOptions; +import com.intuit.karate.RunnerOptions; import com.intuit.karate.core.Engine; import com.intuit.karate.core.Feature; import com.intuit.karate.core.FeatureParser; @@ -10,12 +10,9 @@ import com.intuit.karate.core.Scenario; import com.intuit.karate.core.ScenarioResult; import com.intuit.karate.core.Tags; -import cucumber.api.CucumberOptions; import java.io.File; import java.io.IOException; import java.util.ArrayList; -import java.util.Arrays; -import java.util.Collections; import java.util.List; import org.junit.Test; import org.junit.runner.Description; @@ -44,33 +41,14 @@ public Karate(Class clazz) throws InitializationError, IOException { if (!testMethods.isEmpty()) { logger.warn("WARNING: there are methods annotated with '@Test', they will NOT be run when using '@RunWith(Karate.class)'"); } - CucumberOptions co = clazz.getAnnotation(CucumberOptions.class); - List tags; - List features; - if (co == null) { - logger.warn("CucumberOptions annotation not found on class: {}", clazz); - tags = null; - features = null; - } else { - String[] tagsArray = co.tags(); - tags = Arrays.asList(tagsArray); - String[] featuresArray = co.features(); - features = Arrays.asList(featuresArray); - } - KarateOptions options = KarateOptions.updateFromSystemProperties(tags, features); - tags = options.getTags(); - features = options.getFeatures(); - if (features == null || features.isEmpty()) { - String relative = FileUtils.toRelativeClassPath(clazz); - features = Collections.singletonList(relative); - } - List resources = FileUtils.scanForFeatureFiles(features, clazz.getClassLoader()); + RunnerOptions options = RunnerOptions.fromAnnotationAndSystemProperties(clazz); + List resources = FileUtils.scanForFeatureFiles(options.getFeatures(), clazz.getClassLoader()); children = new ArrayList(resources.size()); for (Resource resource : resources) { Feature feature = FeatureParser.parse(resource); children.add(feature); } - tagSelector = Tags.fromCucumberOptionsTags(tags); + tagSelector = Tags.fromCucumberOptionsTags(options.getTags()); } @Override diff --git a/karate-junit4/src/test/java/com/intuit/karate/junit4/KarateJunitTest.java b/karate-junit4/src/test/java/com/intuit/karate/junit4/KarateJunitTest.java index 7b2117141..aa0307dee 100644 --- a/karate-junit4/src/test/java/com/intuit/karate/junit4/KarateJunitTest.java +++ b/karate-junit4/src/test/java/com/intuit/karate/junit4/KarateJunitTest.java @@ -1,14 +1,14 @@ package com.intuit.karate.junit4; -import cucumber.api.CucumberOptions; +import com.intuit.karate.KarateOptions; import org.junit.runner.RunWith; /** * * @author pthomas3 */ -@CucumberOptions(tags = "~@ignore") +@KarateOptions(tags = "~@ignore") @RunWith(Karate.class) public class KarateJunitTest { diff --git a/karate-junit4/src/test/java/com/intuit/karate/junit4/cukeoptions/FirstRunner.java b/karate-junit4/src/test/java/com/intuit/karate/junit4/cukeoptions/FirstRunner.java deleted file mode 100755 index 6d128da5d..000000000 --- a/karate-junit4/src/test/java/com/intuit/karate/junit4/cukeoptions/FirstRunner.java +++ /dev/null @@ -1,16 +0,0 @@ -package com.intuit.karate.junit4.cukeoptions; - -import com.intuit.karate.junit4.Karate; -import cucumber.api.CucumberOptions; -import org.junit.runner.RunWith; - -/** - * - * @author pthomas3 - */ -@RunWith(Karate.class) -@CucumberOptions(features = "classpath:com/intuit/karate/junit4/cukeoptions/first.feature") -public class FirstRunner { - - -} diff --git a/karate-junit4/src/test/java/com/intuit/karate/junit4/cukeoptions/FirstTest.java b/karate-junit4/src/test/java/com/intuit/karate/junit4/cukeoptions/FirstTest.java deleted file mode 100644 index 4c786706a..000000000 --- a/karate-junit4/src/test/java/com/intuit/karate/junit4/cukeoptions/FirstTest.java +++ /dev/null @@ -1,15 +0,0 @@ -package com.intuit.karate.junit4.cukeoptions; - -import com.intuit.karate.junit4.Karate; -import cucumber.api.CucumberOptions; -import org.junit.runner.RunWith; - -/** - * - * @author pthomas3 - */ -@RunWith(Karate.class) -@CucumberOptions(plugin = {"pretty", "json:target/first.json"}) -public class FirstTest { - -} diff --git a/karate-junit4/src/test/java/com/intuit/karate/junit4/cukeoptions/ParallelWarnTest.java b/karate-junit4/src/test/java/com/intuit/karate/junit4/cukeoptions/ParallelWarnTest.java deleted file mode 100644 index d3bf36750..000000000 --- a/karate-junit4/src/test/java/com/intuit/karate/junit4/cukeoptions/ParallelWarnTest.java +++ /dev/null @@ -1,22 +0,0 @@ -package com.intuit.karate.junit4.cukeoptions; - -import com.intuit.karate.cucumber.CucumberRunner; -import com.intuit.karate.cucumber.KarateStats; -import com.intuit.karate.junit4.Karate; -import cucumber.api.CucumberOptions; -import org.junit.Test; -import org.junit.runner.RunWith; - -/** - * - * @author pthomas3 - */ -@RunWith(Karate.class) -public class ParallelWarnTest { - - @Test - public void testParallel() { - KarateStats stats = CucumberRunner.parallel(getClass(), 1); - } - -} diff --git a/karate-junit4/src/test/java/com/intuit/karate/junit4/cukeoptions/SecondRunner.java b/karate-junit4/src/test/java/com/intuit/karate/junit4/cukeoptions/SecondRunner.java deleted file mode 100755 index 6161d110d..000000000 --- a/karate-junit4/src/test/java/com/intuit/karate/junit4/cukeoptions/SecondRunner.java +++ /dev/null @@ -1,16 +0,0 @@ -package com.intuit.karate.junit4.cukeoptions; - -import com.intuit.karate.junit4.Karate; -import cucumber.api.CucumberOptions; -import org.junit.runner.RunWith; - -/** - * - * @author pthomas3 - */ -@RunWith(Karate.class) -@CucumberOptions(features = "classpath:com/intuit/karate/junit4/cukeoptions/second.feature") -public class SecondRunner { - - -} diff --git a/karate-junit4/src/test/java/com/intuit/karate/junit4/demos/CallOnceRunner.java b/karate-junit4/src/test/java/com/intuit/karate/junit4/demos/CallOnceRunner.java index 432d5b8bd..219bc7741 100644 --- a/karate-junit4/src/test/java/com/intuit/karate/junit4/demos/CallOnceRunner.java +++ b/karate-junit4/src/test/java/com/intuit/karate/junit4/demos/CallOnceRunner.java @@ -1,11 +1,11 @@ package com.intuit.karate.junit4.demos; import com.intuit.karate.junit4.Karate; -import cucumber.api.CucumberOptions; +import com.intuit.karate.KarateOptions; import org.junit.runner.RunWith; @RunWith(Karate.class) -@CucumberOptions(features = "classpath:com/intuit/karate/junit4/demos/call-once.feature") +@KarateOptions(features = "classpath:com/intuit/karate/junit4/demos/call-once.feature") public class CallOnceRunner { } \ No newline at end of file diff --git a/karate-junit4/src/test/java/com/intuit/karate/junit4/demos/CallTagRunner.java b/karate-junit4/src/test/java/com/intuit/karate/junit4/demos/CallTagRunner.java index 4bf3c0965..cfd79e9e2 100644 --- a/karate-junit4/src/test/java/com/intuit/karate/junit4/demos/CallTagRunner.java +++ b/karate-junit4/src/test/java/com/intuit/karate/junit4/demos/CallTagRunner.java @@ -1,11 +1,11 @@ package com.intuit.karate.junit4.demos; import com.intuit.karate.junit4.Karate; -import cucumber.api.CucumberOptions; +import com.intuit.karate.KarateOptions; import org.junit.runner.RunWith; @RunWith(Karate.class) -@CucumberOptions(features = "classpath:com/intuit/karate/junit4/demos/call-tag.feature") +@KarateOptions(features = "classpath:com/intuit/karate/junit4/demos/call-tag.feature") public class CallTagRunner { } \ No newline at end of file diff --git a/karate-junit4/src/test/java/com/intuit/karate/junit4/demos/ChineseRunner.java b/karate-junit4/src/test/java/com/intuit/karate/junit4/demos/ChineseRunner.java index 7bb8158d2..9a5cac439 100644 --- a/karate-junit4/src/test/java/com/intuit/karate/junit4/demos/ChineseRunner.java +++ b/karate-junit4/src/test/java/com/intuit/karate/junit4/demos/ChineseRunner.java @@ -1,11 +1,11 @@ package com.intuit.karate.junit4.demos; import com.intuit.karate.junit4.Karate; -import cucumber.api.CucumberOptions; +import com.intuit.karate.KarateOptions; import org.junit.runner.RunWith; @RunWith(Karate.class) -@CucumberOptions(features = "classpath:com/intuit/karate/junit4/demos/中文测试.feature") +@KarateOptions(features = "classpath:com/intuit/karate/junit4/demos/中文测试.feature") public class ChineseRunner { } \ No newline at end of file diff --git a/karate-junit4/src/test/java/com/intuit/karate/junit4/demos/CompatRunner.java b/karate-junit4/src/test/java/com/intuit/karate/junit4/demos/CompatRunner.java index 7ea60c5e7..11ca144bb 100644 --- a/karate-junit4/src/test/java/com/intuit/karate/junit4/demos/CompatRunner.java +++ b/karate-junit4/src/test/java/com/intuit/karate/junit4/demos/CompatRunner.java @@ -1,11 +1,11 @@ package com.intuit.karate.junit4.demos; import com.intuit.karate.junit4.Karate; -import cucumber.api.CucumberOptions; +import com.intuit.karate.KarateOptions; import org.junit.runner.RunWith; @RunWith(Karate.class) -@CucumberOptions(features = "classpath:com/intuit/karate/junit4/demos/compat.feature") +@KarateOptions(features = "classpath:com/intuit/karate/junit4/demos/compat.feature") public class CompatRunner { } \ No newline at end of file diff --git a/karate-junit4/src/test/java/com/intuit/karate/junit4/demos/ConfigReuseRunner.java b/karate-junit4/src/test/java/com/intuit/karate/junit4/demos/ConfigReuseRunner.java index 7ef4d8881..c2cd9b740 100644 --- a/karate-junit4/src/test/java/com/intuit/karate/junit4/demos/ConfigReuseRunner.java +++ b/karate-junit4/src/test/java/com/intuit/karate/junit4/demos/ConfigReuseRunner.java @@ -1,11 +1,11 @@ package com.intuit.karate.junit4.demos; import com.intuit.karate.junit4.Karate; -import cucumber.api.CucumberOptions; +import com.intuit.karate.KarateOptions; import org.junit.runner.RunWith; @RunWith(Karate.class) -@CucumberOptions(features = "classpath:com/intuit/karate/junit4/demos/config-reuse.feature") +@KarateOptions(features = "classpath:com/intuit/karate/junit4/demos/config-reuse.feature") public class ConfigReuseRunner { } \ No newline at end of file diff --git a/karate-junit4/src/test/java/com/intuit/karate/junit4/demos/CopyCallerRunner.java b/karate-junit4/src/test/java/com/intuit/karate/junit4/demos/CopyCallerRunner.java index 62a29b97f..d5aa04a38 100644 --- a/karate-junit4/src/test/java/com/intuit/karate/junit4/demos/CopyCallerRunner.java +++ b/karate-junit4/src/test/java/com/intuit/karate/junit4/demos/CopyCallerRunner.java @@ -1,11 +1,11 @@ package com.intuit.karate.junit4.demos; import com.intuit.karate.junit4.Karate; -import cucumber.api.CucumberOptions; +import com.intuit.karate.KarateOptions; import org.junit.runner.RunWith; @RunWith(Karate.class) -@CucumberOptions(features = "classpath:com/intuit/karate/junit4/demos/copy-caller.feature") +@KarateOptions(features = "classpath:com/intuit/karate/junit4/demos/copy-caller.feature") public class CopyCallerRunner { } \ No newline at end of file diff --git a/karate-junit4/src/test/java/com/intuit/karate/junit4/demos/CountriesRunner.java b/karate-junit4/src/test/java/com/intuit/karate/junit4/demos/CountriesRunner.java index 4658097c9..cb21c6cc6 100644 --- a/karate-junit4/src/test/java/com/intuit/karate/junit4/demos/CountriesRunner.java +++ b/karate-junit4/src/test/java/com/intuit/karate/junit4/demos/CountriesRunner.java @@ -1,11 +1,11 @@ package com.intuit.karate.junit4.demos; import com.intuit.karate.junit4.Karate; -import cucumber.api.CucumberOptions; +import com.intuit.karate.KarateOptions; import org.junit.runner.RunWith; @RunWith(Karate.class) -@CucumberOptions(features = "classpath:com/intuit/karate/junit4/demos/countries.feature") +@KarateOptions(features = "classpath:com/intuit/karate/junit4/demos/countries.feature") public class CountriesRunner { } \ No newline at end of file diff --git a/karate-junit4/src/test/java/com/intuit/karate/junit4/demos/EachPredicateDollarRunner.java b/karate-junit4/src/test/java/com/intuit/karate/junit4/demos/EachPredicateDollarRunner.java index 243d6e3b2..532915f5d 100644 --- a/karate-junit4/src/test/java/com/intuit/karate/junit4/demos/EachPredicateDollarRunner.java +++ b/karate-junit4/src/test/java/com/intuit/karate/junit4/demos/EachPredicateDollarRunner.java @@ -1,7 +1,7 @@ package com.intuit.karate.junit4.demos; import com.intuit.karate.junit4.Karate; -import cucumber.api.CucumberOptions; +import com.intuit.karate.KarateOptions; import org.junit.runner.RunWith; /** @@ -9,7 +9,7 @@ * @author pthomas3 */ @RunWith(Karate.class) -@CucumberOptions(features = "classpath:com/intuit/karate/junit4/demos/each-predicate-dollar.feature") +@KarateOptions(features = "classpath:com/intuit/karate/junit4/demos/each-predicate-dollar.feature") public class EachPredicateDollarRunner { diff --git a/karate-junit4/src/test/java/com/intuit/karate/junit4/demos/ExamplesRunner.java b/karate-junit4/src/test/java/com/intuit/karate/junit4/demos/ExamplesRunner.java index 444528cc8..1a9aab9b7 100644 --- a/karate-junit4/src/test/java/com/intuit/karate/junit4/demos/ExamplesRunner.java +++ b/karate-junit4/src/test/java/com/intuit/karate/junit4/demos/ExamplesRunner.java @@ -1,11 +1,11 @@ package com.intuit.karate.junit4.demos; import com.intuit.karate.junit4.Karate; -import cucumber.api.CucumberOptions; +import com.intuit.karate.KarateOptions; import org.junit.runner.RunWith; @RunWith(Karate.class) -@CucumberOptions(features = "classpath:com/intuit/karate/junit4/demos/examples.feature") +@KarateOptions(features = "classpath:com/intuit/karate/junit4/demos/examples.feature") public class ExamplesRunner { } \ No newline at end of file diff --git a/karate-junit4/src/test/java/com/intuit/karate/junit4/demos/FailRunner.java b/karate-junit4/src/test/java/com/intuit/karate/junit4/demos/FailRunner.java index 932e7c257..3010cc628 100644 --- a/karate-junit4/src/test/java/com/intuit/karate/junit4/demos/FailRunner.java +++ b/karate-junit4/src/test/java/com/intuit/karate/junit4/demos/FailRunner.java @@ -1,11 +1,11 @@ package com.intuit.karate.junit4.demos; import com.intuit.karate.junit4.Karate; -import cucumber.api.CucumberOptions; +import com.intuit.karate.KarateOptions; import org.junit.runner.RunWith; @RunWith(Karate.class) -@CucumberOptions(features = "classpath:com/intuit/karate/junit4/demos/fail.feature") +@KarateOptions(features = "classpath:com/intuit/karate/junit4/demos/fail.feature") public class FailRunner { } \ No newline at end of file diff --git a/karate-junit4/src/test/java/com/intuit/karate/junit4/demos/FailSkippedParallelRunner.java b/karate-junit4/src/test/java/com/intuit/karate/junit4/demos/FailSkippedParallelRunner.java index a05ffcc7d..c82a5bfb1 100644 --- a/karate-junit4/src/test/java/com/intuit/karate/junit4/demos/FailSkippedParallelRunner.java +++ b/karate-junit4/src/test/java/com/intuit/karate/junit4/demos/FailSkippedParallelRunner.java @@ -1,8 +1,8 @@ package com.intuit.karate.junit4.demos; -import com.intuit.karate.cucumber.CucumberRunner; -import com.intuit.karate.cucumber.KarateStats; -import cucumber.api.CucumberOptions; +import com.intuit.karate.Runner; +import com.intuit.karate.KarateStats; +import com.intuit.karate.KarateOptions; import java.io.File; import java.util.ArrayList; import java.util.Collection; @@ -17,7 +17,7 @@ * * @author pthomas3 */ -@CucumberOptions(features = { +@KarateOptions(features = { "classpath:com/intuit/karate/junit4/demos/fail-skipped.feature", "classpath:com/intuit/karate/junit4/demos/fail.feature"}) public class FailSkippedParallelRunner { @@ -25,7 +25,7 @@ public class FailSkippedParallelRunner { @Test public void testParallel() { String karateOutputPath = "target/surefire-reports"; - KarateStats stats = CucumberRunner.parallel(getClass(), 1, karateOutputPath); + KarateStats stats = Runner.parallel(getClass(), 1, karateOutputPath); generateReport(karateOutputPath); assertTrue("there are scenario failures", stats.getFailCount() == 0); } diff --git a/karate-junit4/src/test/java/com/intuit/karate/junit4/demos/FailSkippedRunner.java b/karate-junit4/src/test/java/com/intuit/karate/junit4/demos/FailSkippedRunner.java index e29d970cb..e557c6d60 100644 --- a/karate-junit4/src/test/java/com/intuit/karate/junit4/demos/FailSkippedRunner.java +++ b/karate-junit4/src/test/java/com/intuit/karate/junit4/demos/FailSkippedRunner.java @@ -1,11 +1,11 @@ package com.intuit.karate.junit4.demos; import com.intuit.karate.junit4.Karate; -import cucumber.api.CucumberOptions; +import com.intuit.karate.KarateOptions; import org.junit.runner.RunWith; @RunWith(Karate.class) -@CucumberOptions(features = "classpath:com/intuit/karate/junit4/demos/fail-skipped.feature") +@KarateOptions(features = "classpath:com/intuit/karate/junit4/demos/fail-skipped.feature") public class FailSkippedRunner { } \ No newline at end of file diff --git a/karate-junit4/src/test/java/com/intuit/karate/junit4/demos/JsArraysRunner.java b/karate-junit4/src/test/java/com/intuit/karate/junit4/demos/JsArraysRunner.java index 36fbb5810..26cb736fd 100644 --- a/karate-junit4/src/test/java/com/intuit/karate/junit4/demos/JsArraysRunner.java +++ b/karate-junit4/src/test/java/com/intuit/karate/junit4/demos/JsArraysRunner.java @@ -1,11 +1,11 @@ package com.intuit.karate.junit4.demos; import com.intuit.karate.junit4.Karate; -import cucumber.api.CucumberOptions; +import com.intuit.karate.KarateOptions; import org.junit.runner.RunWith; @RunWith(Karate.class) -@CucumberOptions(features = "classpath:com/intuit/karate/junit4/demos/js-arrays.feature") +@KarateOptions(features = "classpath:com/intuit/karate/junit4/demos/js-arrays.feature") public class JsArraysRunner { } \ No newline at end of file diff --git a/karate-junit4/src/test/java/com/intuit/karate/junit4/demos/LowerCaseRunner.java b/karate-junit4/src/test/java/com/intuit/karate/junit4/demos/LowerCaseRunner.java index 6f3525e18..9c4253550 100644 --- a/karate-junit4/src/test/java/com/intuit/karate/junit4/demos/LowerCaseRunner.java +++ b/karate-junit4/src/test/java/com/intuit/karate/junit4/demos/LowerCaseRunner.java @@ -1,11 +1,11 @@ package com.intuit.karate.junit4.demos; import com.intuit.karate.junit4.Karate; -import cucumber.api.CucumberOptions; +import com.intuit.karate.KarateOptions; import org.junit.runner.RunWith; @RunWith(Karate.class) -@CucumberOptions(features = "classpath:com/intuit/karate/junit4/demos/lower-case.feature") +@KarateOptions(features = "classpath:com/intuit/karate/junit4/demos/lower-case.feature") public class LowerCaseRunner { } \ No newline at end of file diff --git a/karate-junit4/src/test/java/com/intuit/karate/junit4/demos/MatchFailureReportingInArraysRunner.java b/karate-junit4/src/test/java/com/intuit/karate/junit4/demos/MatchFailureReportingInArraysRunner.java index c6029aa79..4caf228a6 100644 --- a/karate-junit4/src/test/java/com/intuit/karate/junit4/demos/MatchFailureReportingInArraysRunner.java +++ b/karate-junit4/src/test/java/com/intuit/karate/junit4/demos/MatchFailureReportingInArraysRunner.java @@ -1,15 +1,15 @@ package com.intuit.karate.junit4.demos; import com.intuit.karate.junit4.Karate; -import cucumber.api.CucumberOptions; +import com.intuit.karate.KarateOptions; import org.junit.runner.RunWith; /** * * @author pthomas3 */ -// @RunWith(Karate.class) -@CucumberOptions(features = "classpath:com/intuit/karate/junit4/demos/match-report-arrays.feature") +@RunWith(Karate.class) +@KarateOptions(features = "classpath:com/intuit/karate/junit4/demos/match-report-arrays.feature") public class MatchFailureReportingInArraysRunner { diff --git a/karate-junit4/src/test/java/com/intuit/karate/junit4/demos/NotEqualsRunner.java b/karate-junit4/src/test/java/com/intuit/karate/junit4/demos/NotEqualsRunner.java index 2f550acbe..359c32f26 100644 --- a/karate-junit4/src/test/java/com/intuit/karate/junit4/demos/NotEqualsRunner.java +++ b/karate-junit4/src/test/java/com/intuit/karate/junit4/demos/NotEqualsRunner.java @@ -1,11 +1,11 @@ package com.intuit.karate.junit4.demos; import com.intuit.karate.junit4.Karate; -import cucumber.api.CucumberOptions; +import com.intuit.karate.KarateOptions; import org.junit.runner.RunWith; @RunWith(Karate.class) -@CucumberOptions(features = "classpath:com/intuit/karate/junit4/demos/not-equals.feature") +@KarateOptions(features = "classpath:com/intuit/karate/junit4/demos/not-equals.feature") public class NotEqualsRunner { } \ No newline at end of file diff --git a/karate-junit4/src/test/java/com/intuit/karate/junit4/demos/PrintRunner.java b/karate-junit4/src/test/java/com/intuit/karate/junit4/demos/PrintRunner.java index 091718f47..0ec86dc6b 100644 --- a/karate-junit4/src/test/java/com/intuit/karate/junit4/demos/PrintRunner.java +++ b/karate-junit4/src/test/java/com/intuit/karate/junit4/demos/PrintRunner.java @@ -1,11 +1,11 @@ package com.intuit.karate.junit4.demos; import com.intuit.karate.junit4.Karate; -import cucumber.api.CucumberOptions; +import com.intuit.karate.KarateOptions; import org.junit.runner.RunWith; @RunWith(Karate.class) -@CucumberOptions(features = "classpath:com/intuit/karate/junit4/demos/print.feature") +@KarateOptions(features = "classpath:com/intuit/karate/junit4/demos/print.feature") public class PrintRunner { } \ No newline at end of file diff --git a/karate-junit4/src/test/java/com/intuit/karate/junit4/demos/RandomJsonPathRunner.java b/karate-junit4/src/test/java/com/intuit/karate/junit4/demos/RandomJsonPathRunner.java index 7f89dbc05..e9952bee6 100644 --- a/karate-junit4/src/test/java/com/intuit/karate/junit4/demos/RandomJsonPathRunner.java +++ b/karate-junit4/src/test/java/com/intuit/karate/junit4/demos/RandomJsonPathRunner.java @@ -1,11 +1,11 @@ package com.intuit.karate.junit4.demos; import com.intuit.karate.junit4.Karate; -import cucumber.api.CucumberOptions; +import com.intuit.karate.KarateOptions; import org.junit.runner.RunWith; @RunWith(Karate.class) -@CucumberOptions(features = "classpath:com/intuit/karate/junit4/demos/random-jsonpath.feature") +@KarateOptions(features = "classpath:com/intuit/karate/junit4/demos/random-jsonpath.feature") public class RandomJsonPathRunner { } \ No newline at end of file diff --git a/karate-junit4/src/test/java/com/intuit/karate/junit4/demos/ReadFromRelativePathRunner.java b/karate-junit4/src/test/java/com/intuit/karate/junit4/demos/ReadFromRelativePathRunner.java index e1d641153..e1b272b28 100644 --- a/karate-junit4/src/test/java/com/intuit/karate/junit4/demos/ReadFromRelativePathRunner.java +++ b/karate-junit4/src/test/java/com/intuit/karate/junit4/demos/ReadFromRelativePathRunner.java @@ -1,7 +1,7 @@ package com.intuit.karate.junit4.demos; import com.intuit.karate.junit4.Karate; -import cucumber.api.CucumberOptions; +import com.intuit.karate.KarateOptions; import org.junit.runner.RunWith; /** @@ -9,7 +9,7 @@ * @author pthomas3 */ @RunWith(Karate.class) -@CucumberOptions(features = "classpath:com/intuit/karate/junit4/demos/read-from-relative-path.feature") +@KarateOptions(features = "classpath:com/intuit/karate/junit4/demos/read-from-relative-path.feature") public class ReadFromRelativePathRunner { } diff --git a/karate-junit4/src/test/java/com/intuit/karate/junit4/demos/ReplaceRunner.java b/karate-junit4/src/test/java/com/intuit/karate/junit4/demos/ReplaceRunner.java index 53e62a115..1973cc91a 100644 --- a/karate-junit4/src/test/java/com/intuit/karate/junit4/demos/ReplaceRunner.java +++ b/karate-junit4/src/test/java/com/intuit/karate/junit4/demos/ReplaceRunner.java @@ -1,11 +1,11 @@ package com.intuit.karate.junit4.demos; import com.intuit.karate.junit4.Karate; -import cucumber.api.CucumberOptions; +import com.intuit.karate.KarateOptions; import org.junit.runner.RunWith; @RunWith(Karate.class) -@CucumberOptions(features = "classpath:com/intuit/karate/junit4/demos/replace.feature") +@KarateOptions(features = "classpath:com/intuit/karate/junit4/demos/replace.feature") public class ReplaceRunner { } \ No newline at end of file diff --git a/karate-junit4/src/test/java/com/intuit/karate/junit4/demos/ScenarioVariableScopeRunner.java b/karate-junit4/src/test/java/com/intuit/karate/junit4/demos/ScenarioVariableScopeRunner.java index d83dce3fa..3ce40019b 100644 --- a/karate-junit4/src/test/java/com/intuit/karate/junit4/demos/ScenarioVariableScopeRunner.java +++ b/karate-junit4/src/test/java/com/intuit/karate/junit4/demos/ScenarioVariableScopeRunner.java @@ -1,7 +1,7 @@ package com.intuit.karate.junit4.demos; import com.intuit.karate.junit4.Karate; -import cucumber.api.CucumberOptions; +import com.intuit.karate.KarateOptions; import org.junit.runner.RunWith; /** @@ -9,7 +9,7 @@ * @author pthomas3 */ @RunWith(Karate.class) -@CucumberOptions(features = "classpath:com/intuit/karate/junit4/demos/scenario-variable-scope.feature") +@KarateOptions(features = "classpath:com/intuit/karate/junit4/demos/scenario-variable-scope.feature") public class ScenarioVariableScopeRunner { diff --git a/karate-junit4/src/test/java/com/intuit/karate/junit4/demos/SchemaLikeRunner.java b/karate-junit4/src/test/java/com/intuit/karate/junit4/demos/SchemaLikeRunner.java index d5269c836..97cf41858 100644 --- a/karate-junit4/src/test/java/com/intuit/karate/junit4/demos/SchemaLikeRunner.java +++ b/karate-junit4/src/test/java/com/intuit/karate/junit4/demos/SchemaLikeRunner.java @@ -1,11 +1,11 @@ package com.intuit.karate.junit4.demos; import com.intuit.karate.junit4.Karate; -import cucumber.api.CucumberOptions; +import com.intuit.karate.KarateOptions; import org.junit.runner.RunWith; @RunWith(Karate.class) -@CucumberOptions(features = "classpath:com/intuit/karate/junit4/demos/schema-like.feature") +@KarateOptions(features = "classpath:com/intuit/karate/junit4/demos/schema-like.feature") public class SchemaLikeRunner { } \ No newline at end of file diff --git a/karate-junit4/src/test/java/com/intuit/karate/junit4/demos/SoapCalcRunner.java b/karate-junit4/src/test/java/com/intuit/karate/junit4/demos/SoapCalcRunner.java index 6a65efe5b..8b259ac42 100644 --- a/karate-junit4/src/test/java/com/intuit/karate/junit4/demos/SoapCalcRunner.java +++ b/karate-junit4/src/test/java/com/intuit/karate/junit4/demos/SoapCalcRunner.java @@ -1,11 +1,11 @@ package com.intuit.karate.junit4.demos; import com.intuit.karate.junit4.Karate; -import cucumber.api.CucumberOptions; +import com.intuit.karate.KarateOptions; import org.junit.runner.RunWith; @RunWith(Karate.class) -@CucumberOptions(features = "classpath:com/intuit/karate/junit4/demos/soap-calc.feature") +@KarateOptions(features = "classpath:com/intuit/karate/junit4/demos/soap-calc.feature") public class SoapCalcRunner { } \ No newline at end of file diff --git a/karate-junit4/src/test/java/com/intuit/karate/junit4/demos/SoapRunner.java b/karate-junit4/src/test/java/com/intuit/karate/junit4/demos/SoapRunner.java index f51198374..f93ea1a96 100644 --- a/karate-junit4/src/test/java/com/intuit/karate/junit4/demos/SoapRunner.java +++ b/karate-junit4/src/test/java/com/intuit/karate/junit4/demos/SoapRunner.java @@ -1,11 +1,11 @@ package com.intuit.karate.junit4.demos; import com.intuit.karate.junit4.Karate; -import cucumber.api.CucumberOptions; +import com.intuit.karate.KarateOptions; import org.junit.runner.RunWith; @RunWith(Karate.class) -@CucumberOptions(features = "classpath:com/intuit/karate/junit4/demos/soap.feature") +@KarateOptions(features = "classpath:com/intuit/karate/junit4/demos/soap.feature") public class SoapRunner { } \ No newline at end of file diff --git a/karate-junit4/src/test/java/com/intuit/karate/junit4/demos/SortArrayRunner.java b/karate-junit4/src/test/java/com/intuit/karate/junit4/demos/SortArrayRunner.java index 4f38d5835..f486ca438 100644 --- a/karate-junit4/src/test/java/com/intuit/karate/junit4/demos/SortArrayRunner.java +++ b/karate-junit4/src/test/java/com/intuit/karate/junit4/demos/SortArrayRunner.java @@ -1,11 +1,11 @@ package com.intuit.karate.junit4.demos; import com.intuit.karate.junit4.Karate; -import cucumber.api.CucumberOptions; +import com.intuit.karate.KarateOptions; import org.junit.runner.RunWith; @RunWith(Karate.class) -@CucumberOptions(features = "classpath:com/intuit/karate/junit4/demos/sort-array.feature") +@KarateOptions(features = "classpath:com/intuit/karate/junit4/demos/sort-array.feature") public class SortArrayRunner { } \ No newline at end of file diff --git a/karate-junit4/src/test/java/com/intuit/karate/junit4/demos/TagsRunner.java b/karate-junit4/src/test/java/com/intuit/karate/junit4/demos/TagsRunner.java index c9b9624af..611838d96 100644 --- a/karate-junit4/src/test/java/com/intuit/karate/junit4/demos/TagsRunner.java +++ b/karate-junit4/src/test/java/com/intuit/karate/junit4/demos/TagsRunner.java @@ -1,11 +1,11 @@ package com.intuit.karate.junit4.demos; import com.intuit.karate.junit4.Karate; -import cucumber.api.CucumberOptions; +import com.intuit.karate.KarateOptions; import org.junit.runner.RunWith; @RunWith(Karate.class) -@CucumberOptions(features = "classpath:com/intuit/karate/junit4/demos/tags.feature") +@KarateOptions(features = "classpath:com/intuit/karate/junit4/demos/tags.feature") public class TagsRunner { } \ No newline at end of file diff --git a/karate-junit4/src/test/java/com/intuit/karate/junit4/demos/TypeConvRunner.java b/karate-junit4/src/test/java/com/intuit/karate/junit4/demos/TypeConvRunner.java index 9f3ad5c76..fd1529976 100644 --- a/karate-junit4/src/test/java/com/intuit/karate/junit4/demos/TypeConvRunner.java +++ b/karate-junit4/src/test/java/com/intuit/karate/junit4/demos/TypeConvRunner.java @@ -1,11 +1,11 @@ package com.intuit.karate.junit4.demos; import com.intuit.karate.junit4.Karate; -import cucumber.api.CucumberOptions; +import com.intuit.karate.KarateOptions; import org.junit.runner.RunWith; @RunWith(Karate.class) -@CucumberOptions(features = "classpath:com/intuit/karate/junit4/demos/type-conv.feature") +@KarateOptions(features = "classpath:com/intuit/karate/junit4/demos/type-conv.feature") public class TypeConvRunner { } \ No newline at end of file diff --git a/karate-junit4/src/test/java/com/intuit/karate/junit4/demos/UsersRunner.java b/karate-junit4/src/test/java/com/intuit/karate/junit4/demos/UsersRunner.java index 983f1342f..eb6a13173 100644 --- a/karate-junit4/src/test/java/com/intuit/karate/junit4/demos/UsersRunner.java +++ b/karate-junit4/src/test/java/com/intuit/karate/junit4/demos/UsersRunner.java @@ -1,11 +1,11 @@ package com.intuit.karate.junit4.demos; import com.intuit.karate.junit4.Karate; -import cucumber.api.CucumberOptions; +import com.intuit.karate.KarateOptions; import org.junit.runner.RunWith; @RunWith(Karate.class) -@CucumberOptions(features = "classpath:com/intuit/karate/junit4/demos/users.feature") +@KarateOptions(features = "classpath:com/intuit/karate/junit4/demos/users.feature") public class UsersRunner { } \ No newline at end of file diff --git a/karate-junit4/src/test/java/com/intuit/karate/junit4/demos/XmlAndXpathRunner.java b/karate-junit4/src/test/java/com/intuit/karate/junit4/demos/XmlAndXpathRunner.java index 0cfdbf22c..41319ec42 100644 --- a/karate-junit4/src/test/java/com/intuit/karate/junit4/demos/XmlAndXpathRunner.java +++ b/karate-junit4/src/test/java/com/intuit/karate/junit4/demos/XmlAndXpathRunner.java @@ -1,11 +1,11 @@ package com.intuit.karate.junit4.demos; import com.intuit.karate.junit4.Karate; -import cucumber.api.CucumberOptions; +import com.intuit.karate.KarateOptions; import org.junit.runner.RunWith; @RunWith(Karate.class) -@CucumberOptions(features = "classpath:com/intuit/karate/junit4/demos/xml-and-xpath.feature") +@KarateOptions(features = "classpath:com/intuit/karate/junit4/demos/xml-and-xpath.feature") public class XmlAndXpathRunner { } \ No newline at end of file diff --git a/karate-junit4/src/test/java/com/intuit/karate/junit4/files/PropertiesRunner.java b/karate-junit4/src/test/java/com/intuit/karate/junit4/files/PropertiesRunner.java index 77849d388..a34dff5b4 100644 --- a/karate-junit4/src/test/java/com/intuit/karate/junit4/files/PropertiesRunner.java +++ b/karate-junit4/src/test/java/com/intuit/karate/junit4/files/PropertiesRunner.java @@ -1,11 +1,11 @@ package com.intuit.karate.junit4.files; import com.intuit.karate.junit4.Karate; -import cucumber.api.CucumberOptions; +import com.intuit.karate.KarateOptions; import org.junit.runner.RunWith; @RunWith(Karate.class) -@CucumberOptions(features = "classpath:com/intuit/karate/junit4/files/properties.feature") +@KarateOptions(features = "classpath:com/intuit/karate/junit4/files/properties.feature") public class PropertiesRunner { } \ No newline at end of file diff --git a/karate-junit4/src/test/java/com/intuit/karate/junit4/files/WorkingDirRunner.java b/karate-junit4/src/test/java/com/intuit/karate/junit4/files/WorkingDirRunner.java index 3ece6fb8e..d4f23ed47 100644 --- a/karate-junit4/src/test/java/com/intuit/karate/junit4/files/WorkingDirRunner.java +++ b/karate-junit4/src/test/java/com/intuit/karate/junit4/files/WorkingDirRunner.java @@ -1,11 +1,11 @@ package com.intuit.karate.junit4.files; import com.intuit.karate.junit4.Karate; -import cucumber.api.CucumberOptions; +import com.intuit.karate.KarateOptions; import org.junit.runner.RunWith; @RunWith(Karate.class) -@CucumberOptions(features = "classpath:com/intuit/karate/junit4/files/working-dir.feature") +@KarateOptions(features = "classpath:com/intuit/karate/junit4/files/working-dir.feature") public class WorkingDirRunner { } \ No newline at end of file diff --git a/karate-junit4/src/test/java/com/intuit/karate/junit4/files/relative/CallerRunner.java b/karate-junit4/src/test/java/com/intuit/karate/junit4/files/relative/CallerRunner.java index 04ba72a14..ac88d6531 100644 --- a/karate-junit4/src/test/java/com/intuit/karate/junit4/files/relative/CallerRunner.java +++ b/karate-junit4/src/test/java/com/intuit/karate/junit4/files/relative/CallerRunner.java @@ -1,7 +1,7 @@ package com.intuit.karate.junit4.files.relative; import com.intuit.karate.junit4.Karate; -import cucumber.api.CucumberOptions; +import com.intuit.karate.KarateOptions; import org.junit.runner.RunWith; /** @@ -9,7 +9,7 @@ * @author pthomas3 */ @RunWith(Karate.class) -@CucumberOptions(features = "classpath:com/intuit/karate/junit4/files/relative/caller.feature") +@KarateOptions(features = "classpath:com/intuit/karate/junit4/files/relative/caller.feature") public class CallerRunner { } diff --git a/karate-junit4/src/test/java/com/intuit/karate/junit4/http/ChromeRunner.java b/karate-junit4/src/test/java/com/intuit/karate/junit4/http/ChromeRunner.java index 5d1e29119..db7cd65e1 100644 --- a/karate-junit4/src/test/java/com/intuit/karate/junit4/http/ChromeRunner.java +++ b/karate-junit4/src/test/java/com/intuit/karate/junit4/http/ChromeRunner.java @@ -1,11 +1,11 @@ package com.intuit.karate.junit4.http; import com.intuit.karate.junit4.Karate; -import cucumber.api.CucumberOptions; +import com.intuit.karate.KarateOptions; import org.junit.runner.RunWith; @RunWith(Karate.class) -@CucumberOptions(features = "classpath:com/intuit/karate/junit4/http/chrome.feature") +@KarateOptions(features = "classpath:com/intuit/karate/junit4/http/chrome.feature") public class ChromeRunner { } \ No newline at end of file diff --git a/karate-junit4/src/test/java/com/intuit/karate/junit4/large/LargePayloadRunner.java b/karate-junit4/src/test/java/com/intuit/karate/junit4/large/LargePayloadRunner.java index f0a566be3..9e34645ce 100644 --- a/karate-junit4/src/test/java/com/intuit/karate/junit4/large/LargePayloadRunner.java +++ b/karate-junit4/src/test/java/com/intuit/karate/junit4/large/LargePayloadRunner.java @@ -3,10 +3,9 @@ import com.intuit.karate.FileUtils; import com.intuit.karate.XmlUtils; import com.intuit.karate.junit4.Karate; -import cucumber.api.CucumberOptions; +import com.intuit.karate.KarateOptions; import java.io.File; import org.junit.BeforeClass; -import org.junit.Test; import org.junit.runner.RunWith; import org.slf4j.Logger; import org.slf4j.LoggerFactory; @@ -18,7 +17,7 @@ * @author pthomas3 */ @RunWith(Karate.class) -@CucumberOptions(features = "classpath:com/intuit/karate/junit4/large/large.feature") +@KarateOptions(features = "classpath:com/intuit/karate/junit4/large/large.feature") public class LargePayloadRunner { private static final Logger logger = LoggerFactory.getLogger(LargePayloadRunner.class); diff --git a/karate-junit4/src/test/java/com/intuit/karate/junit4/options/FirstRunner.java b/karate-junit4/src/test/java/com/intuit/karate/junit4/options/FirstRunner.java new file mode 100755 index 000000000..c6de2cc29 --- /dev/null +++ b/karate-junit4/src/test/java/com/intuit/karate/junit4/options/FirstRunner.java @@ -0,0 +1,16 @@ +package com.intuit.karate.junit4.options; + +import com.intuit.karate.junit4.Karate; +import com.intuit.karate.KarateOptions; +import org.junit.runner.RunWith; + +/** + * + * @author pthomas3 + */ +@RunWith(Karate.class) +@KarateOptions(features = "classpath:com/intuit/karate/junit4/options/first.feature") +public class FirstRunner { + + +} diff --git a/karate-junit4/src/test/java/com/intuit/karate/junit4/options/OptionsTest.java b/karate-junit4/src/test/java/com/intuit/karate/junit4/options/OptionsTest.java new file mode 100644 index 000000000..54445d6d7 --- /dev/null +++ b/karate-junit4/src/test/java/com/intuit/karate/junit4/options/OptionsTest.java @@ -0,0 +1,13 @@ +package com.intuit.karate.junit4.options; + +import com.intuit.karate.junit4.Karate; +import org.junit.runner.RunWith; + +/** + * + * @author pthomas3 + */ +@RunWith(Karate.class) +public class OptionsTest { + +} diff --git a/karate-junit4/src/test/java/com/intuit/karate/junit4/options/ParallelWarnTest.java b/karate-junit4/src/test/java/com/intuit/karate/junit4/options/ParallelWarnTest.java new file mode 100644 index 000000000..cae97ffc9 --- /dev/null +++ b/karate-junit4/src/test/java/com/intuit/karate/junit4/options/ParallelWarnTest.java @@ -0,0 +1,21 @@ +package com.intuit.karate.junit4.options; + +import com.intuit.karate.Runner; +import com.intuit.karate.KarateStats; +import com.intuit.karate.junit4.Karate; +import org.junit.Test; +import org.junit.runner.RunWith; + +/** + * + * @author pthomas3 + */ +@RunWith(Karate.class) +public class ParallelWarnTest { + + @Test + public void testParallel() { + KarateStats stats = Runner.parallel(getClass(), 1); + } + +} diff --git a/karate-junit4/src/test/java/com/intuit/karate/junit4/options/SecondRunner.java b/karate-junit4/src/test/java/com/intuit/karate/junit4/options/SecondRunner.java new file mode 100755 index 000000000..e93f3e07d --- /dev/null +++ b/karate-junit4/src/test/java/com/intuit/karate/junit4/options/SecondRunner.java @@ -0,0 +1,16 @@ +package com.intuit.karate.junit4.options; + +import com.intuit.karate.KarateOptions; +import com.intuit.karate.junit4.Karate; +import org.junit.runner.RunWith; + +/** + * + * @author pthomas3 + */ +@RunWith(Karate.class) +@KarateOptions(features = "classpath:com/intuit/karate/junit4/cukeoptions/second.feature") +public class SecondRunner { + + +} diff --git a/karate-junit4/src/test/java/com/intuit/karate/junit4/cukeoptions/first.feature b/karate-junit4/src/test/java/com/intuit/karate/junit4/options/first.feature similarity index 100% rename from karate-junit4/src/test/java/com/intuit/karate/junit4/cukeoptions/first.feature rename to karate-junit4/src/test/java/com/intuit/karate/junit4/options/first.feature diff --git a/karate-junit4/src/test/java/com/intuit/karate/junit4/cukeoptions/outline-only.feature b/karate-junit4/src/test/java/com/intuit/karate/junit4/options/outline-only.feature similarity index 100% rename from karate-junit4/src/test/java/com/intuit/karate/junit4/cukeoptions/outline-only.feature rename to karate-junit4/src/test/java/com/intuit/karate/junit4/options/outline-only.feature diff --git a/karate-junit4/src/test/java/com/intuit/karate/junit4/cukeoptions/second.feature b/karate-junit4/src/test/java/com/intuit/karate/junit4/options/second.feature similarity index 100% rename from karate-junit4/src/test/java/com/intuit/karate/junit4/cukeoptions/second.feature rename to karate-junit4/src/test/java/com/intuit/karate/junit4/options/second.feature diff --git a/karate-junit4/src/test/java/com/intuit/karate/junit4/selenium/SampleRunner.java b/karate-junit4/src/test/java/com/intuit/karate/junit4/selenium/SampleRunner.java index 67fd48178..601fb518a 100644 --- a/karate-junit4/src/test/java/com/intuit/karate/junit4/selenium/SampleRunner.java +++ b/karate-junit4/src/test/java/com/intuit/karate/junit4/selenium/SampleRunner.java @@ -1,7 +1,7 @@ package com.intuit.karate.junit4.selenium; import com.intuit.karate.junit4.Karate; -import cucumber.api.CucumberOptions; +import com.intuit.karate.KarateOptions; import org.junit.runner.RunWith; /** @@ -9,7 +9,7 @@ * @author pthomas3 */ @RunWith(Karate.class) -@CucumberOptions(features = "classpath:com/intuit/karate/junit4/selenium/sample.feature") +@KarateOptions(features = "classpath:com/intuit/karate/junit4/selenium/sample.feature") public class SampleRunner { } diff --git a/karate-mock-servlet/src/test/java/demo/MockSpringMvcServletTest.java b/karate-mock-servlet/src/test/java/demo/MockSpringMvcServletTest.java index 9eb5438da..511c97f1d 100644 --- a/karate-mock-servlet/src/test/java/demo/MockSpringMvcServletTest.java +++ b/karate-mock-servlet/src/test/java/demo/MockSpringMvcServletTest.java @@ -23,9 +23,9 @@ */ package demo; -import com.intuit.karate.cucumber.CucumberRunner; -import com.intuit.karate.cucumber.KarateStats; -import cucumber.api.CucumberOptions; +import com.intuit.karate.Runner; +import com.intuit.karate.KarateStats; +import com.intuit.karate.KarateOptions; import java.io.File; import org.apache.commons.io.FileUtils; import static org.junit.Assert.assertTrue; @@ -35,7 +35,7 @@ * * @author pthomas3 */ -@CucumberOptions(tags = {"~@ignore", "~@mock-servlet-todo"}) +@KarateOptions(tags = {"~@ignore", "~@mock-servlet-todo"}) public class MockSpringMvcServletTest { @Test @@ -45,7 +45,7 @@ public void testSpringBootDemo() throws Exception { FileUtils.copyDirectory(srcDir, destDir, f -> !f.getName().equals("karate-config.js"), false); // don't over-write karate-config.js System.setProperty("karate.env", "dev-mock-springmvc"); - KarateStats stats = CucumberRunner.parallel(getClass(), 5); + KarateStats stats = Runner.parallel(getClass(), 5); assertTrue("there are scenario failures", stats.getFailCount() == 0); } diff --git a/karate-netty/src/test/java/com/intuit/karate/mock/BinaryRunner.java b/karate-netty/src/test/java/com/intuit/karate/mock/BinaryRunner.java index 20badd66b..da2b68b31 100644 --- a/karate-netty/src/test/java/com/intuit/karate/mock/BinaryRunner.java +++ b/karate-netty/src/test/java/com/intuit/karate/mock/BinaryRunner.java @@ -3,7 +3,7 @@ import com.intuit.karate.FileUtils; import com.intuit.karate.junit4.Karate; import com.intuit.karate.netty.FeatureServer; -import cucumber.api.CucumberOptions; +import com.intuit.karate.KarateOptions; import java.io.File; import org.junit.BeforeClass; import org.junit.runner.RunWith; @@ -13,7 +13,7 @@ * @author pthomas3 */ @RunWith(Karate.class) -@CucumberOptions(features = "classpath:com/intuit/karate/mock/binary.feature") +@KarateOptions(features = "classpath:com/intuit/karate/mock/binary.feature") public class BinaryRunner { private static FeatureServer server; diff --git a/karate-netty/src/test/java/com/intuit/karate/mock/HelloWorldRunner.java b/karate-netty/src/test/java/com/intuit/karate/mock/HelloWorldRunner.java index 44eb2badf..097a1cd15 100644 --- a/karate-netty/src/test/java/com/intuit/karate/mock/HelloWorldRunner.java +++ b/karate-netty/src/test/java/com/intuit/karate/mock/HelloWorldRunner.java @@ -3,7 +3,7 @@ import com.intuit.karate.FileUtils; import com.intuit.karate.junit4.Karate; import com.intuit.karate.netty.FeatureServer; -import cucumber.api.CucumberOptions; +import com.intuit.karate.KarateOptions; import java.io.File; import org.junit.BeforeClass; import org.junit.runner.RunWith; @@ -13,7 +13,7 @@ * @author pthomas3 */ @RunWith(Karate.class) -@CucumberOptions(features = "classpath:com/intuit/karate/mock/hello-world.feature") +@KarateOptions(features = "classpath:com/intuit/karate/mock/hello-world.feature") public class HelloWorldRunner { private static FeatureServer server; diff --git a/karate-netty/src/test/java/com/intuit/karate/mock/MockServerTest.java b/karate-netty/src/test/java/com/intuit/karate/mock/MockServerTest.java index d2bf8a8f4..02e450064 100644 --- a/karate-netty/src/test/java/com/intuit/karate/mock/MockServerTest.java +++ b/karate-netty/src/test/java/com/intuit/karate/mock/MockServerTest.java @@ -2,9 +2,9 @@ import com.intuit.karate.netty.*; import com.intuit.karate.FileUtils; -import com.intuit.karate.cucumber.CucumberRunner; -import com.intuit.karate.cucumber.KarateStats; -import cucumber.api.CucumberOptions; +import com.intuit.karate.Runner; +import com.intuit.karate.KarateStats; +import com.intuit.karate.KarateOptions; import java.io.File; import java.util.ArrayList; import java.util.Collection; @@ -19,7 +19,7 @@ * * @author pthomas3 */ -@CucumberOptions(tags = "~@ignore") +@KarateOptions(tags = "~@ignore") public class MockServerTest { private static FeatureServer server; @@ -38,7 +38,7 @@ public static void beforeClass() { public void testServer() { // will run all features in 'this' package String karateOutputPath = "target/surefire-reports"; - KarateStats stats = CucumberRunner.parallel(getClass(), 1, karateOutputPath); + KarateStats stats = Runner.parallel(getClass(), 1, karateOutputPath); generateReport(karateOutputPath); assertTrue("there are scenario failures", stats.getFailCount() == 0); } diff --git a/karate-netty/src/test/java/com/intuit/karate/mock/NoHeadersRunner.java b/karate-netty/src/test/java/com/intuit/karate/mock/NoHeadersRunner.java index b133a94a7..60feac812 100644 --- a/karate-netty/src/test/java/com/intuit/karate/mock/NoHeadersRunner.java +++ b/karate-netty/src/test/java/com/intuit/karate/mock/NoHeadersRunner.java @@ -3,7 +3,7 @@ import com.intuit.karate.FileUtils; import com.intuit.karate.junit4.Karate; import com.intuit.karate.netty.FeatureServer; -import cucumber.api.CucumberOptions; +import com.intuit.karate.KarateOptions; import java.io.File; import org.junit.BeforeClass; import org.junit.runner.RunWith; @@ -13,7 +13,7 @@ * @author pthomas3 */ @RunWith(Karate.class) -@CucumberOptions(features = "classpath:com/intuit/karate/mock/no-headers.feature") +@KarateOptions(features = "classpath:com/intuit/karate/mock/no-headers.feature") public class NoHeadersRunner { private static FeatureServer server; diff --git a/karate-netty/src/test/java/com/intuit/karate/netty/ClientRunner.java b/karate-netty/src/test/java/com/intuit/karate/netty/ClientRunner.java index f9dc3a192..73cd9b268 100644 --- a/karate-netty/src/test/java/com/intuit/karate/netty/ClientRunner.java +++ b/karate-netty/src/test/java/com/intuit/karate/netty/ClientRunner.java @@ -1,7 +1,7 @@ package com.intuit.karate.netty; import com.intuit.karate.junit4.Karate; -import cucumber.api.CucumberOptions; +import com.intuit.karate.KarateOptions; import org.junit.runner.RunWith; /** @@ -9,7 +9,7 @@ * @author pthomas3 */ @RunWith(Karate.class) -@CucumberOptions(features = "classpath:com/intuit/karate/netty/client.feature") +@KarateOptions(features = "classpath:com/intuit/karate/netty/client.feature") public class ClientRunner { } diff --git a/karate-netty/src/test/java/com/intuit/karate/netty/FeatureServerTest.java b/karate-netty/src/test/java/com/intuit/karate/netty/FeatureServerTest.java index e9b683ddf..0724c36d5 100644 --- a/karate-netty/src/test/java/com/intuit/karate/netty/FeatureServerTest.java +++ b/karate-netty/src/test/java/com/intuit/karate/netty/FeatureServerTest.java @@ -2,7 +2,7 @@ import com.intuit.karate.FileUtils; import com.intuit.karate.junit4.Karate; -import cucumber.api.CucumberOptions; +import com.intuit.karate.KarateOptions; import java.io.File; import org.junit.AfterClass; import org.junit.BeforeClass; @@ -13,7 +13,7 @@ * @author pthomas3 */ @RunWith(Karate.class) -@CucumberOptions(features = "classpath:com/intuit/karate/netty/client.feature") +@KarateOptions(features = "classpath:com/intuit/karate/netty/client.feature") public class FeatureServerTest { private static FeatureServer server;