${project.build.outputDirectory} and
63 | * ${project.build.testOutputDirectory} are included by default
64 | * @parameter property="runpath"
65 | */
66 | String runpath;
67 |
68 | /**
69 | * Comma separated list of suites to be executed.
70 | * @parameter property="suites"
71 | */
72 | String suites;
73 |
74 | /**
75 | * Comma separated list of tests to be executed
76 | * @parameter property="tests"
77 | */
78 | String tests;
79 |
80 | /**
81 | * Regex of suffixes to filter discovered suites
82 | * @parameter property="suffixes"
83 | */
84 | String suffixes;
85 |
86 | /**
87 | * Comma separated list of tags to include
88 | * @parameter property="tagsToInclude"
89 | */
90 | String tagsToInclude;
91 |
92 | /**
93 | * Comma separated list of tags to exclude
94 | * @parameter property="tagsToExclude"
95 | */
96 | String tagsToExclude;
97 |
98 | /**
99 | * Comma separated list of configuration parameters to pass to ScalaTest.
100 | * The parameters must be of the format <key>=<value>. E.g foo=bar,monkey=donkey
101 | * @parameter property="config"
102 | */
103 | String config;
104 |
105 | /**
106 | * Set to true to run suites concurrently
107 | * @parameter property="parallel"
108 | */
109 | boolean parallel;
110 |
111 | /**
112 | * Set to true to enable suite sorting, this only takes effect if parallel is set to true.
113 | * @parameter property="suiteSorting"
114 | */
115 | boolean suiteSorting;
116 |
117 | /**
118 | * Set the thread count for parallel tests execution, this only takes effect if parallel is set to true.
119 | * @parameter property="threadCount"
120 | */
121 | int threadCount;
122 |
123 | /**
124 | * Comma separated list of packages containing suites to execute
125 | * @parameter property="membersOnlySuites"
126 | */
127 | String membersOnlySuites;
128 |
129 | // TODO: Change this to wildcard and membersOnly
130 | /**
131 | * Comma separated list of wildcard suite names to execute
132 | * @parameter property="wildcardSuites"
133 | */
134 | String wildcardSuites;
135 |
136 | /**
137 | * Comma separated list of testNG xml files to execute
138 | * @parameter property="testNGXMLFiles"
139 | */
140 | String testNGConfigFiles;
141 |
142 | /**
143 | * Comma separated list of files to store names of failed and
144 | * canceled tests into.
145 | * @parameter property="memoryFiles"
146 | */
147 | String memoryFiles;
148 |
149 | /**
150 | * Comma separated list of files to store names of failed and
151 | * canceled tests into.
152 | * @parameter property="testsFiles"
153 | */
154 | String testsFiles;
155 |
156 | /**
157 | * Comma separated list of JUnit suites/tests to execute
158 | * @parameter property="junitClasses"
159 | */
160 | String jUnitClasses;
161 |
162 | /**
163 | * Option to specify the forking mode. Can be "never" or "once". "always", which would
164 | * fork for each test-class, may be supported later.
165 | *
166 | * @parameter property="forkMode" default-value="once"
167 | */
168 | String forkMode;
169 |
170 | /**
171 | * Option to specify additional JVM options to pass to the forked process.
172 | *
173 | * @parameter property="argLine"
174 | */
175 | String argLine;
176 |
177 | /**
178 | * Additional environment variables to pass to the forked process.
179 | *
180 | * @parameter
181 | */
182 | MapIf set to true, the forked process will suspend at startup and wait for a remote
195 | * debugger to attach to the configured port.
debugForkedProcess is true.
203 | *
204 | * If set to a non-empty value, the standard debug arguments are replaced by the specified arguments.
205 | * This allows customization of how remote debugging is done, without having to reconfigure the JVM
206 | * options in argLine.
207 | *
208 | * @parameter property="debugArgLine"
209 | */
210 | String debugArgLine;
211 |
212 | /**
213 | * Port to listen on when debugging the forked process.
214 | *
215 | * @parameter property="debuggerPort" default-value="5005"
216 | */
217 | int debuggerPort = 5005;
218 |
219 | /**
220 | * Timeout in seconds to allow the forked process to run before killing it and failing the test run.
221 | *
222 | *
If set to 0, process never times out.
223 | * 224 | * @parameter property="timeout" default-value="0" 225 | */ 226 | int forkedProcessTimeoutInSeconds = 0; 227 | 228 | /** 229 | * Whether or not to log the command used to launch the forked process. 230 | * 231 | * @parameter property="logForkedProcessCommand" default-value="false" 232 | */ 233 | boolean logForkedProcessCommand; 234 | 235 | /** 236 | * Span scale factor. 237 | * 238 | * @parameter property="spanScaleFactor" default-value="1.0" 239 | */ 240 | double spanScaleFactor = 1.0; 241 | 242 | /** 243 | * The current working directory for forked process. Optional. If not specified, basedir will be used. 244 | * 245 | * @parameter property="workingDirectory" 246 | */ 247 | String workingDirectory; 248 | 249 | /** 250 | * Option to specify an alternative path to JVM (or path to the java executable) to use with 251 | * the forked process. 252 | * 253 | * @parameter property="jvm" 254 | */ 255 | String jvm; 256 | 257 | // runScalaTest is called by the concrete mojo subclasses TODO: make it protected and others too 258 | // Returns true if all tests pass 259 | boolean runScalaTest(String[] args) throws MojoFailureException { 260 | getLog().debug(Arrays.toString(args)); 261 | if (forkMode.equals("never")) { 262 | return runWithoutForking(args); 263 | } 264 | else { 265 | if (!forkMode.equals("once")) { 266 | getLog().error("Invalid forkMode: \"" + forkMode + "\"; Using once instead."); 267 | } 268 | return runForkingOnce(args); 269 | } 270 | } 271 | 272 | // Returns true if all tests pass 273 | private boolean runWithoutForking(String[] args) { 274 | try { 275 | return (Boolean) run().invoke(null, new Object[]{args}); 276 | } catch (IllegalAccessException e) { 277 | throw new IllegalStateException(e); 278 | } catch (InvocationTargetException e) { 279 | Throwable target = e.getTargetException(); 280 | if(target instanceof RuntimeException){ 281 | throw (RuntimeException)target; 282 | } else { 283 | throw new IllegalArgumentException(target); 284 | } 285 | } 286 | } 287 | 288 | // Returns true if all tests pass 289 | private boolean runForkingOnce(String[] args) throws MojoFailureException { 290 | 291 | final Commandline cli = new Commandline(); 292 | if ((this.workingDirectory == null || this.workingDirectory.isEmpty())) { 293 | cli.setWorkingDirectory(project.getBasedir()); 294 | } else { 295 | cli.setWorkingDirectory(workingDirectory); 296 | } 297 | 298 | if (this.jvm == null || this.jvm.isEmpty()) { 299 | cli.setExecutable(getJvm()); 300 | } else { 301 | cli.setExecutable(this.jvm); 302 | } 303 | 304 | // Set up environment 305 | if (environmentVariables != null) { 306 | for (final Map.Entry in that doc.
61 |
62 | try {
63 | sink.head();
64 | sink.title();
65 | sink.text(getLocalizedString(locale, "reporter.mojo.outputTitle"));
66 | sink.title_();
67 | sink.head_();
68 |
69 | sink.body();
70 | sink.sectionTitle1();
71 | sink.text(getLocalizedString(locale, "reporter.mojo.outputTitle"));
72 | sink.sectionTitle1_();
73 | sink.verbatim(false);
74 | sink.text(getScalaTestOutputFromFile());
75 | sink.verbatim_();
76 | sink.body_();
77 |
78 | sink.flush();
79 | sink.close();
80 | }
81 | catch (IOException ioe) {
82 | throw new MavenReportException("Failure generating ScalaTest report", ioe);
83 | }
84 | }
85 |
86 | private String[] configuration() {
87 | return concat(
88 | sharedConfiguration(),
89 | fileReporterConfig()
90 | );
91 | }
92 |
93 | private List fileReporterConfig() {
94 | File tmpDir = new File(System.getProperty("java.io.tmpdir"));
95 | if (fileReporterOptions != null) {
96 | return reporterArg("-f", fileReporterOptions + " tempScalaTestOutput.txt", fileRelativeTo(tmpDir));
97 | }
98 | return reporterArg("-f", "tempScalaTestOutput.txt", fileRelativeTo(tmpDir));
99 | }
100 |
101 | private String getScalaTestOutputFromFile() throws IOException {
102 | StringWriter fileContents = new StringWriter(1024);
103 | PrintWriter writer = new PrintWriter(fileContents, true);
104 |
105 | // ScalaTest's FileReporter uses default character encoding so that's what we'll use here, too.
106 | File outputFile = new File(System.getProperty("java.io.tmpdir"), "tempScalaTestOutput.txt");
107 | BufferedReader reader = new BufferedReader(new FileReader(outputFile));
108 |
109 | try {
110 | String line = null;
111 | while ((line = reader.readLine()) != null) {
112 | writer.println(line);
113 | }
114 | return fileContents.toString();
115 | }
116 | finally {
117 | try {
118 | reader.close();
119 | outputFile.delete();
120 | }
121 | catch (IOException ignored) {}
122 | }
123 | }
124 |
125 | public String getOutputName() {
126 | return "scalatest-output";
127 | }
128 |
129 | public String getCategoryName() {
130 | return CATEGORY_PROJECT_REPORTS;
131 | }
132 |
133 | public String getName(Locale locale) {
134 | return getLocalizedString(locale, "reporter.mojo.name");
135 | }
136 |
137 | public String getDescription(Locale locale) {
138 | return getLocalizedString(locale, "reporter.mojo.description");
139 | }
140 |
141 | public void setReportOutputDirectory(File outputDirectory) {
142 | reportingOutputDirectory = outputDirectory;
143 | }
144 |
145 | public File getReportOutputDirectory() {
146 | return reportingOutputDirectory;
147 | }
148 |
149 | public boolean isExternalReport() {
150 | return false;
151 | }
152 |
153 | public boolean canGenerateReport() {
154 | return true;
155 | }
156 |
157 | private String getLocalizedString(Locale locale, String resourceKey) {
158 | return ResourceBundle.getBundle("mojoResources", locale, getClass().getClassLoader()).getString(resourceKey);
159 | }
160 | }
161 |
--------------------------------------------------------------------------------
/src/main/java/org/scalatest/tools/maven/TestMojo.java:
--------------------------------------------------------------------------------
1 | package org.scalatest.tools.maven;
2 |
3 | import org.apache.maven.plugin.MojoFailureException;
4 |
5 | import java.io.File;
6 | import java.io.FileWriter;
7 | import java.io.IOException;
8 | import java.io.Writer;
9 | import java.util.ArrayList;
10 | import java.util.Collections;
11 | import java.util.List;
12 |
13 | import static java.util.Collections.singletonList;
14 | import static java.util.Collections.unmodifiableList;
15 | import static org.scalatest.tools.maven.MojoUtils.*;
16 |
17 | /**
18 | * Provides a bridge between Maven and the command-line form of ScalaTest's Runner.
19 | * Many of the configuration options available on this goal
20 | * are directly reflected in the Runner ScalaDoc on http://www.scalatest.org.
21 | *
22 | * @author Sean Griffin
23 | * @author Mike Pilquist
24 | * @author Jon-Anders Teigen
25 | * @author Bill Venners
26 | * @phase test
27 | * @goal test
28 | * @threadSafe
29 | */
30 | public class TestMojo extends AbstractScalaTestMojo {
31 |
32 | /**
33 | * Output directory in which ScalaTest file reports should be written to. Passed to ScalaTest via the -f argument.
34 | * @parameter default-value="${project.build.directory}/scalatest-reports" property="scalatest.reportsDirectory"
35 | * @required
36 | */
37 | File reportsDirectory;
38 |
39 | /**
40 | * Set to true to skip execution of tests.
41 | * @parameter property="skipTests"
42 | */
43 | boolean skipTests;
44 |
45 | /**
46 | * Set to true to avoid failing the build when tests fail
47 | * @parameter property="maven.test.failure.ignore"
48 | */
49 | boolean testFailureIgnore;
50 |
51 | /**
52 | * Set to true to avoid failing the build when ScalaTest is not available on classpath
53 | * @parameter property="noScalaTestIgnore"
54 | */
55 | boolean noScalaTestIgnore;
56 |
57 | /**
58 | * Comma separated list of filereporters. A filereporter consists of an optional
59 | * configuration and a mandatory filename, separated by a whitespace. E.g all.txt,XE ignored_and_pending.txt
60 | * For more info on configuring reporters, see the scalatest documentation.
61 | * @parameter property="filereports"
62 | */
63 | String filereports;
64 |
65 | /**
66 | * Comma separated list of htmlreporters. An htmlreporter
67 | * consists of a mandatory directory and an optional css file
68 | * name, separated by whitespace. E.g:
69 | *
70 | * <htmlreporters>
71 | * target/htmldir,
72 | * target/myhtmldir src/my.css
73 | * </htmlreporters>
74 | *
75 | * For more info on configuring reporters, see the scalatest documentation.
76 | * @parameter property="htmlreporters"
77 | */
78 | String htmlreporters;
79 |
80 | /**
81 | * Comma separated list of reporters. A reporter consist of an optional configuration
82 | * and a mandatory reporter classname, separated by whitespace. The reporter classname
83 | * must be the fully qualified name of a class extending org.scalatest.Reporter
84 | * E.g C my.SuccessReporter,my.EverythingReporter
85 | * For more info on configuring reporters, see the ScalaTest documentation.
86 | * @parameter property="reporters"
87 | */
88 | String reporters;
89 |
90 | /**
91 | * Comma separated list of junitxml. A junitxml consists of an optional configuration
92 | * and a mandatory directory for the xml files, separated by whitespace.
93 | * For more info on configuring reporters, see the scalatest documentation.
94 | * @parameter property="junitxml"
95 | */
96 | String junitxml;
97 |
98 | /**
99 | * Configuration for logging to stdout. (This logger is always enabled)
100 | * For more info on configuring reporters, see the scalatest documentation.
101 | * @parameter property="stdout"
102 | */
103 | String stdout;
104 |
105 | /**
106 | * Configuration for logging to stderr. It is disabled by default, but will be enabled
107 | * when configured. Empty configuration just means enable.
108 | * For more info on configuring reporters, see the scalatest documentation.
109 | * @parameter property="stderr"
110 | */
111 | String stderr;
112 |
113 | /**
114 | * Set this to "true" to redirect the unit test standard output to a file
115 | * (found in reportsDirectory/scalatest-output.txt by default).
116 | *
117 | * NOTE: Works only if forkMode="once"
118 | *
119 | * @parameter property="maven.test.redirectTestOutputToFile" default-value="false"
120 | */
121 | boolean redirectTestOutputToFile;
122 |
123 | /**
124 | * Name of the file where the test output is redirected if enabled
125 | *
126 | * @parameter default-value="scalatest-output.txt"
127 | */
128 | String testOutputFileName;
129 |
130 | public void execute() throws MojoFailureException {
131 | getLog().info("ScalaTest report directory: " + reportsDirectory);
132 |
133 | if (skipTests) {
134 | getLog().info("Tests are skipped.");
135 | }
136 | else if (noScalaTestIgnore) {
137 | if (isScalaTestAvailable()) {
138 | if (!runScalaTest(configuration()) && !testFailureIgnore) {
139 | throw new MojoFailureException("There are test failures");
140 | }
141 | }
142 | else
143 | getLog().info("Skipped because ScalaTest not available on classpath.");
144 | }
145 | else {
146 | if (!runScalaTest(configuration()) && !testFailureIgnore) {
147 | if (isScalaTestAvailable())
148 | throw new MojoFailureException("There are test failures");
149 | else
150 | throw new MojoFailureException("Failure because ScalaTest not available on classpath.");
151 | }
152 | }
153 | }
154 |
155 | String[] configuration() {
156 | return concat(
157 | sharedConfiguration(),
158 | stdout(),
159 | stderr(),
160 | filereports(),
161 | htmlreporters(),
162 | reporters(),
163 | junitxml()
164 | );
165 | }
166 |
167 | // These private methods create the relevant portion of the command line
168 | // to pass to Runner based on the corresponding Maven configuration parameter.
169 | private List stdout() {
170 | final String stdoutProcessed = maybeRemoveAnsiCodes(stdout);
171 | return unmodifiableList(singletonList(stdoutProcessed == null ? "-o" : "-o" + stdoutProcessed));
172 | }
173 |
174 | private List stderr() {
175 | return stderr == null ? Collections.emptyList() : unmodifiableList(singletonList("-e" + stderr));
176 | }
177 |
178 | private String maybeRemoveAnsiCodes(String streamParams) {
179 | return redirectTestOutputToFile
180 | ? maybeAppendLetter(streamParams, "W")
181 | : streamParams;
182 | }
183 |
184 | private String maybeAppendLetter(String string, String letter) {
185 | if (string == null) {
186 | return letter;
187 | }
188 |
189 | if (string.contains(letter)) {
190 | return string;
191 | }
192 |
193 | return string + letter;
194 | }
195 |
196 | private List filereports() {
197 | return unmodifiableList(reporterArg("-f", filereports, fileRelativeTo(reportsDirectory)));
198 | }
199 |
200 | private List htmlreporters() {
201 | List r = new ArrayList();
202 |
203 | for (String arg : splitOnComma(htmlreporters)) {
204 | String[] split = arg.split("\\s+");
205 |
206 | if (split.length > 0) {
207 | r.add("-h");
208 | r.add(split[0]);
209 |
210 | if (split.length > 1) {
211 | r.add("-Y");
212 | r.add(split[1]);
213 | }
214 | }
215 | }
216 | return unmodifiableList(r);
217 | }
218 |
219 | private List reporters() {
220 | return reporterArg("-C", reporters, passThrough);
221 | }
222 |
223 | private List junitxml(){
224 | return reporterArg("-u", junitxml, dirRelativeTo(reportsDirectory));
225 | }
226 |
227 | protected Writer getOutputWriter() throws MojoFailureException {
228 | return redirectTestOutputToFile ? newFileWriter() : super.getOutputWriter();
229 | }
230 |
231 | private Writer newFileWriter() throws MojoFailureException {
232 | final File outputFile = new File(reportsDirectory, testOutputFileName);
233 |
234 | if (!reportsDirectory.exists() && !reportsDirectory.mkdirs()) {
235 | throw new MojoFailureException("Unable to create directory path: " + reportsDirectory);
236 | }
237 |
238 | try {
239 | return new FileWriter(outputFile);
240 | } catch (IOException e) {
241 | throw new MojoFailureException("Unable to access the output file: '" + outputFile + "'", e);
242 | }
243 | }
244 | }
245 |
--------------------------------------------------------------------------------
/src/main/resources/mojoResources.properties:
--------------------------------------------------------------------------------
1 | reporter.mojo.name = ScalaTest Results
2 | reporter.mojo.description = The test results from the ScalaTest run
3 | reporter.mojo.outputTitle = ScalaTest Results
--------------------------------------------------------------------------------
/src/site/apt/usage.apt:
--------------------------------------------------------------------------------
1 | Usage Documentation
2 |
3 | Replacing the use of Maven's Surefire plugin with this plugin involves two simple steps:
4 |
5 | [[1]] Disable the maven-surefire-plugin
6 |
7 | [[2]] Configure this scalatest-maven-plugin to run in the test phase
8 |
9 | []
10 |
11 | To replace the maven-surefire-report-plugin with this plugin, simply add the scalatest-maven-plugin instead of
12 | the maven-surefire-report-plugin to the reporting section of the POM.
13 |
14 | For example, in the build section of the POM, add something like the following:
15 |
16 | +--
17 |
18 | ...
19 |
20 |
21 |
22 | org.apache.maven.plugins
23 | maven-surefire-plugin
24 |
25 | true
26 |
27 |
28 |
29 |
30 |
31 | org.scalatest
32 | scalatest-maven-plugin
33 |
34 |
35 |
36 | test
37 |
38 |
39 | ...
40 |
41 |
42 |
43 |
44 |
45 | ...
46 |
47 | +--
48 |
49 | The important item in the above POM definition is the \ configuration specified
50 | on the maven-surefire-plugin. There is nothing inherently wrong in having Surefire run your
51 | tests, but if you want all your tests to run through ScalaTest instead, then disabling Surefire
52 | in this manner will keep your tests from running twice. Since the "test" goal of the
53 | scalatest-maven-plugin is tied to the test phase by default you do not need to do this explicitly
54 | in your POM.
55 |
56 | Optionally, in the reporting section of the POM you can add something like the following:
57 |
58 | +--
59 |
60 | ...
61 |
62 |
63 | org.scalatest
64 | scalatest-maven-plugin
65 |
66 | ...
67 |
68 |
69 |
70 | ...
71 |
72 | +--
73 |
74 | Adding this configuration will tell the plugin's "reporter" goal to execute during
75 | site generation. This goal will run the tests and output the results to an HTML file that
76 | will link into the project's site. ScalaTest does not yet have an HTML Reporter implementation,
77 | so this goal will instead embed the plain text output of ScalaTest's FileReporter into a \
78 | element in a wrapper HTML page with seamless incorporation into Maven's site infrastructure.
79 |
80 | <> Adding the reporter goal will, like the default behavior of maven-surefire-report-plugin, cause
81 | your tests to run twice: once in the test phase and again in the site phase. Unlike the maven-surefire-report-plugin,
82 | the reporter goal of this plugin have a "report-only" configuration option to incorporate the test
83 | results of the prior run.
84 |
85 | * Customizing ScalaTest
86 |
87 | While using this plugin does allow Maven to execute your tests without the need to
88 | use the "@RunWith(classOf[JUnitRunner])" boilerplate at the top of every test class, which is certainly
89 | an advantage, the main benefit of this plugin is that it allows you to leverage the customization
90 | options of ScalaTest's Runner class as part of the standard Maven build. It is true that through either
91 | the exec-maven-plugin or the "run" goal of the maven-scala-plugin you could launch the Runner class
92 | with command-line arguments tailored to your preferences, but that approach is not integrated with the
93 | Maven lifecycle; it's a manual step, test failures will not fail your build, and the test results
94 | will not be included in your project site. This plugin addresses those problems.
95 |
96 | The configuration options available to each of the goals are included in the goal documentation, but generally
97 | speaking, all or at least most of the command line arguments available on the Runner class are exposed
98 | as options on the "test" and "gui" goals. Creative use of these configuration options can allow you to
99 | run your "fast" tests in one Maven profile and your "slow" tests in a different Maven profile or to filter
100 | certain suites from the execution.
101 |
102 | For example, let's say that you have some tests tagged with a "Slow" Tag and others tagged with a "Fast" Tag.
103 | All the goals in this plugin support the "includes" and "excludes" configuration options, which map to the -n
104 | and -l Runner command-line arguments, respectively. Now let's also say that you want to run your "Fast" tests
105 | on every SCM commit while only running the "Slow" tests manually or from a nightly build. Using Maven profiles,
106 | you can configure your POM similar to the following to accomplish this objective:
107 |
108 | +--
109 |
110 | ...
111 |
112 | org.scalatest
113 | scalatest-maven-plugin
114 |
115 |
116 |
117 | test
118 |
119 |
120 | test-results
121 | Slow
122 |
123 |
124 |
125 |
126 | ...
127 |
128 | ...
129 |
130 |
131 | nightly-build
132 |
133 |
134 |
135 | org.scalatest
136 | scalatest-maven-plugin
137 |
138 |
139 |
140 | test
141 |
142 |
143 | test-results
144 |
145 |
146 |
147 |
148 |
149 |
150 |
151 |
152 |
153 | +--
154 |
155 | The "test" and "gui" goals support multiple Reporters of different types and formatting options for each
156 | of those Reporters. For example, given this elaborate Reporter configuration
157 |
158 | +--
159 | NCXEHLOWFD test-results/text/constrained.txt,test-results/text/full.txt
160 | test-results/xml
161 | +--
162 |
163 | the test results will be written to three locations:
164 |
165 | [[1]] the constrained.txt file in the test-results/text directory with the NCXEHLOWFD Reporting options applied
166 |
167 | [[2]] the full.txt file in the test-results/text directory with no Reporting options applied
168 |
169 | [[3]] the test-results/xml directory as a set of files that adhere to the JUnit XML format
170 |
171 | []
172 |
173 | The "reporter" goal does not support this level of customization, however, because it doesn't really apply.
174 | Instead, this goal has a "fileReporterOptions" option that allows you to specify the formatting options to
175 | pass to the FileReporter. The plugin itself controls the name of that file, and the location of the file
176 | is configured through the standard "reportOutputDirectory" as is convention in report goals of other plugins.
177 |
--------------------------------------------------------------------------------
/src/site/site.xml:
--------------------------------------------------------------------------------
1 |
2 |
3 |
7 |
8 |
9 |
--------------------------------------------------------------------------------
/src/test/scala/org/scalatest/tools/maven/MojoUtilsTest.scala:
--------------------------------------------------------------------------------
1 | package org.scalatest.tools.maven
2 |
3 | import org.junit.contrib.java.lang.system.{ClearSystemProperties, EnvironmentVariables}
4 | import org.junit.{Rule, Test}
5 |
6 | class MojoUtilsTest {
7 | val _env: EnvironmentVariables = new EnvironmentVariables()
8 | val _sys: ClearSystemProperties = new ClearSystemProperties("java.home")
9 |
10 | @Rule
11 | def env: EnvironmentVariables = _env
12 |
13 | @Rule
14 | def sys: ClearSystemProperties = _sys
15 |
16 | @Test
17 | def getJvmHappyPath(): Unit = {
18 | env.clear("JAVA_HOME")
19 | System.setProperty("java.home", "/test/jvm")
20 | assert(MojoUtils.getJvm == "/test/jvm/bin/java")
21 | }
22 |
23 | @Test
24 | def getJvmWithoutJavaHome(): Unit = {
25 | env.clear("JAVA_HOME")
26 | assert(MojoUtils.getJvm == "java")
27 | }
28 |
29 | @Test
30 | def getJvmFromEnvironment(): Unit = {
31 | env.clear("JAVA_HOME")
32 | env.set("JAVA_HOME", "/opt/jdk-11")
33 | Console.print(MojoUtils.getJvm)
34 | assert(MojoUtils.getJvm == "/opt/jdk-11/bin/java")
35 | }
36 |
37 | @Test
38 | def getJvmJavaHomeIsPriority(): Unit = {
39 | System.setProperty("java.home", "/test/jvm")
40 | env.set("JAVA_HOME", "/opt/jdk-11")
41 | assert(MojoUtils.getJvm == "/test/jvm/bin/java")
42 | }
43 | }
44 |
--------------------------------------------------------------------------------
/src/test/scala/org/scalatest/tools/maven/PluginMatchers.scala:
--------------------------------------------------------------------------------
1 | package org.scalatest.tools.maven
2 |
3 | import org.scalatest.matchers.{MatchResult, Matcher}
4 |
5 | /**
6 | * @author Jon-Anders Teigen
7 | */
8 | trait PluginMatchers {
9 | def containSlice(slice: String*) = new Matcher[Array[String]] {
10 | def apply(seq: Array[String]) = {
11 | MatchResult(
12 | seq containsSlice slice,
13 | "The " + seq + " did not contain the slice " + slice,
14 | "The " + seq + " did contain the slice " + slice
15 | )
16 | }
17 | }
18 |
19 | def containCompoundArgs(name:String, values:String*) = new Matcher[Array[String]] {
20 | def apply(seq: Array[String]) = {
21 | MatchResult(
22 | seq containsSlice List(name,values.mkString(" ")),
23 | "The compoundArgs for " + name + " and " + values.mkString(" ") + " where not found in " + seq,
24 | "The compoundArgs for " + name + " and " + values.mkString(" ") + " where found in " + seq
25 | )
26 | }
27 | }
28 |
29 | def containSuiteArgs(name:String, values:String*) = new Matcher[Array[String]] {
30 | def apply(seq: Array[String]) = {
31 | MatchResult(
32 | values.forall(v => seq.containsSlice(List(name, v))),
33 | "The suiteArgs " + name +" "+ values.mkString(" ") + " were not all found in " + seq,
34 | "The suiteArgs for " + name +" "+ values.mkString(" ") + " were all found in " + seq
35 | )
36 | }
37 | }
38 | }
39 |
--------------------------------------------------------------------------------
/src/test/scala/org/scalatest/tools/maven/PluginTest.scala:
--------------------------------------------------------------------------------
1 | package org.scalatest.tools.maven
2 |
3 | import java.io.File
4 | import org.scalatest.matchers.should.Matchers
5 | import org.scalatestplus.junit.JUnit3Suite
6 | import java.util.ArrayList
7 | import org.scalatest.BeforeAndAfterAll
8 |
9 | /**
10 | * @author Jon -Anders Teigen
11 | */
12 | final class PluginTest
13 | extends JUnit3Suite
14 | with BeforeAndAfterAll
15 | with Matchers
16 | with PluginMatchers {
17 | val tmpDir = new File(System.getProperty("java.io.tmpdir"))
18 | val reportsDirectory = new File(tmpDir, "reportsDirectory")
19 | val baseDir = new File(tmpDir, "basedir");
20 | val testOutputDirectory = {
21 | val dir = new File(reportsDirectory, "testOutputDirectory")
22 | dir.mkdirs()
23 | dir.getAbsolutePath
24 | }
25 | val outputDirectory = {
26 | val dir = new File(reportsDirectory, "outputDirectory")
27 | dir.mkdirs()
28 | dir.getAbsolutePath
29 | }
30 |
31 | override def afterAll() {
32 | def delete(it: File) {
33 | if (it.isFile) {
34 | it.delete()
35 | } else {
36 | for (d <- it.listFiles)
37 | delete(d)
38 | }
39 | }
40 | delete(reportsDirectory)
41 | delete(baseDir);
42 | }
43 |
44 | def jlist(a: String*) = new ArrayList[String]() {for (e <- a) this.add(e)}
45 |
46 | def comma(a: String*) = a mkString ","
47 |
48 | def configure(m: TestMojo => Unit) = {
49 | val mojo = new TestMojo
50 | mojo.reportsDirectory = reportsDirectory
51 | mojo.testOutputDirectory = new File(testOutputDirectory)
52 | mojo.outputDirectory = new File(outputDirectory)
53 | m(mojo)
54 | mojo.configuration
55 | }
56 |
57 | def testDefault {
58 | val config = configure(_ => ())
59 | config should contain("-o")
60 | config should containCompoundArgs("-R", outputDirectory, testOutputDirectory)
61 | config should have length (3)
62 | }
63 |
64 | def testConfigs {
65 | val config = configure(_.config = comma("foo=bar", "monkey=donkey"))
66 | config should contain("-Dfoo=bar")
67 | config should contain("-Dmonkey=donkey")
68 | }
69 |
70 | def testRunpath {
71 | configure(_.runpath = comma("http://foo.com/my.jar", "/some/where")) should containCompoundArgs("-R", outputDirectory, testOutputDirectory, "http://foo.com/my.jar", "/some/where")
72 | }
73 |
74 | def testFilereporters {
75 | val config = configure(_.filereports = comma("foo.txt", "YZT some.txt"))
76 | config should containSlice("-f", new File(reportsDirectory, "foo.txt").getAbsolutePath)
77 | config should containSlice("-fYZT", new File(reportsDirectory, "some.txt").getAbsolutePath)
78 | }
79 |
80 | def testHtmlreporters {
81 | val config = configure(_.htmlreporters =
82 | comma("target/htmldir", "target/myhtmldir src/resources/my.css"))
83 |
84 | config should containSlice("-h", "target/htmldir")
85 | config should containSlice("-h", "target/myhtmldir",
86 | "-Y", "src/resources/my.css")
87 | }
88 |
89 | def testReporters {
90 | val config = configure(_.reporters = comma("YZT org.my.reporter", "org.your.reporter"))
91 | config should containSlice("-CYZT", "org.my.reporter")
92 | config should containSlice("-C", "org.your.reporter")
93 | }
94 |
95 | def testJUnitXmlReporters {
96 | val config = configure(_.junitxml = comma("some/foo.xml", "XYZ other.xml"))
97 | config should containSlice("-u", new File(reportsDirectory, "some/foo.xml").getAbsolutePath)
98 | config should containSlice("-uXYZ", new File(reportsDirectory, "other.xml").getAbsolutePath)
99 | }
100 |
101 | def testStdOutReporter {
102 | configure(_.stdout = "GUP") should contain("-oGUP")
103 | }
104 |
105 | def testStdOutReporterWithRedirect {
106 | configure(_.redirectTestOutputToFile = true) should contain("-oW")
107 | }
108 |
109 | def testStdErrReporter {
110 | configure(_.stderr = "BIS") should contain("-eBIS")
111 | }
112 |
113 | def testIncludes {
114 | configure(_.tagsToInclude = comma("a", "b", "c")) should containCompoundArgs("-n", "a", "b", "c")
115 | }
116 |
117 | def testExcludes {
118 | configure(_.tagsToExclude = comma("a", "b", "c")) should containCompoundArgs("-l", "a", "b", "c")
119 | }
120 |
121 | def testConcurrent {
122 | configure(_.parallel = true) should contain("-P")
123 | configure(_.parallel = false) should not contain ("-P")
124 | }
125 |
126 | def testConcurrentSuiteSorting {
127 | configure { m =>
128 | m.parallel = true
129 | m.suiteSorting = true
130 | } should containSlice("-PS")
131 | }
132 |
133 | def testConcurrentThreadCount {
134 | configure { m =>
135 | m.parallel = true
136 | m.threadCount = 4
137 | } should containSlice("-P4")
138 | }
139 |
140 | def testConcurrentSuiteSortingThreadCount {
141 | configure { m =>
142 | m.parallel = true
143 | m.suiteSorting = true
144 | m.threadCount = 4
145 | } should containSlice("-PS4")
146 | }
147 |
148 | def testSuiteSorting {
149 | // Suite sorting count should have no effect if parallel is not set to true.
150 | configure { m =>
151 | m.suiteSorting = true
152 | } shouldNot containSlice ("-PS")
153 | }
154 |
155 | def testSuiteSortingThreadCount {
156 | // Suite sorting and thread count should have no effect if parallel is not set to true.
157 | configure { m =>
158 | m.suiteSorting = true
159 | m.threadCount = 4
160 | } shouldNot containSlice ("-PS4")
161 | }
162 |
163 | def testThreadCount {
164 | // Thread count should have no effect if parallel is not set to true.
165 | configure { m =>
166 | m.threadCount = 4
167 | } shouldNot containSlice ("-P4")
168 | }
169 |
170 | def testSuites {
171 | val suites: String = comma(" a ",
172 | "b",
173 | "foo @bar baz",
174 | " zowie\n zip zap ")
175 |
176 | val config = configure(_.suites = suites)
177 |
178 | config should containSlice ("-s", "a")
179 | config should containSlice ("-s", "b")
180 | config should containSlice ("-s", "foo", "-t", "bar baz")
181 | config should containSlice ("-s", "zowie", "-z", "zip zap")
182 | }
183 |
184 | def testSuitesAndTests {
185 | val suites: String = comma(" a ", "b c")
186 | val tests: String = comma(" d ", "@e")
187 |
188 | val config = configure(x => {x.suites = suites; x.tests = tests})
189 |
190 | config should containSlice ("-z", "d",
191 | "-t", "e",
192 | "-s", "a",
193 | "-s", "b", "-z", "c")
194 | }
195 |
196 | def testTests {
197 | val tests: String= comma(" @a ", " b ", "@c")
198 |
199 | val config = configure(_.tests = tests)
200 |
201 | config should containSlice("-t", "a")
202 | config should containSlice("-z", "b")
203 | config should containSlice("-t", "c")
204 | }
205 |
206 | //
207 | // Verify that a comma can be escaped with a backslash in order to
208 | // support a test name that contains a comma.
209 | //
210 | def testTestsWithCommas {
211 | configure(_.tests = comma("a\\, bc", "b", "c")) should containSuiteArgs("-z", "a, bc", "b", "c")
212 | }
213 |
214 | def testSuffixes {
215 | configure(_.suffixes = "(?