result = new HashMap<>();
for (int i = 0; i < nnm.getLength(); i++) {
@@ -606,6 +608,7 @@ public void readMatcherBuilders() {
nodeListConsumer(document.getElementsByTagName(XMLConfig.MATCHER), this::parseMatcherBuilder);
}
+ @SuppressFBWarnings("URLCONNECTION_SSRF_FD")
@Override
public void addMatchers(final URI uri) {
read(uri);
diff --git a/apache-rat-core/src/main/java/org/apache/rat/configuration/builders/ChildContainerBuilder.java b/apache-rat-core/src/main/java/org/apache/rat/configuration/builders/ChildContainerBuilder.java
index d40a657d2..172314fbe 100644
--- a/apache-rat-core/src/main/java/org/apache/rat/configuration/builders/ChildContainerBuilder.java
+++ b/apache-rat-core/src/main/java/org/apache/rat/configuration/builders/ChildContainerBuilder.java
@@ -59,7 +59,7 @@ protected ChildContainerBuilder() {
*/
public AbstractBuilder setResource(final String resourceName) {
// this method is called by reflection
- URL url = this.getClass().getResource(resourceName);
+ URL url = AbstractBuilder.class.getResource(resourceName);
if (url == null) {
throw new ConfigurationException("Unable to read matching text file: " + resourceName);
}
diff --git a/apache-rat-core/src/main/java/org/apache/rat/configuration/builders/MatcherRefBuilder.java b/apache-rat-core/src/main/java/org/apache/rat/configuration/builders/MatcherRefBuilder.java
index 68598d4c7..1662220f3 100644
--- a/apache-rat-core/src/main/java/org/apache/rat/configuration/builders/MatcherRefBuilder.java
+++ b/apache-rat-core/src/main/java/org/apache/rat/configuration/builders/MatcherRefBuilder.java
@@ -27,6 +27,8 @@
import org.apache.rat.config.parameters.ConfigComponent;
import org.apache.rat.config.parameters.MatcherBuilder;
+import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
+
/**
* A reference matching Matcher builder.
*
@@ -62,6 +64,7 @@ public MatcherRefBuilder setRefId(final String refId) {
* @param matchers the Map of ids to instances.
* @return this builder for chaining.
*/
+ @SuppressFBWarnings(value = "EI_EXPOSE_REP2", justification = "Expected external update of matchers.")
public MatcherRefBuilder setMatcherMap(final Map matchers) {
// this method is called by reflection
this.matchers = matchers;
@@ -109,6 +112,7 @@ public static class IHeaderMatcherProxy implements IHeaderMatcher {
* @param proxyId the id of the matcher to find.
* @param matchers a mapping of matchers that have been found.
*/
+ @SuppressFBWarnings(value = "EI_EXPOSE_REP2", justification = "Expected external update of matchers.")
public IHeaderMatcherProxy(final String proxyId, final Map matchers) {
this.proxyId = proxyId;
this.matchers = matchers;
diff --git a/apache-rat-core/src/main/java/org/apache/rat/document/ArchiveEntryDocument.java b/apache-rat-core/src/main/java/org/apache/rat/document/ArchiveEntryDocument.java
deleted file mode 100644
index dabc848bc..000000000
--- a/apache-rat-core/src/main/java/org/apache/rat/document/ArchiveEntryDocument.java
+++ /dev/null
@@ -1,62 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one *
- * or more contributor license agreements. See the NOTICE file *
- * distributed with this work for additional information *
- * regarding copyright ownership. The ASF licenses this file *
- * to you under the Apache License, Version 2.0 (the *
- * "License"); you may not use this file except in compliance *
- * with the License. You may obtain a copy of the License at *
- * *
- * http://www.apache.org/licenses/LICENSE-2.0 *
- * *
- * Unless required by applicable law or agreed to in writing, *
- * software distributed under the License is distributed on an *
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY *
- * KIND, either express or implied. See the License for the *
- * specific language governing permissions and limitations *
- * under the License. *
- */
-
-package org.apache.rat.document;
-
-import java.io.ByteArrayInputStream;
-import java.io.InputStream;
-import java.util.Collections;
-import java.util.SortedSet;
-
-import org.apache.rat.api.Document;
-
-/**
- * A Document that wraps an Archive entry.
- */
-public class ArchiveEntryDocument extends Document {
-
- /** The contents of the entry */
- private final byte[] contents;
-
- /**
- * Creates an Archive entry.
- * @param entryName the name of this entry from outside the archive.
- * @param contents the contents of the entry.
- * @param nameMatcher the name matcher to filter contents with.
- */
- public ArchiveEntryDocument(final ArchiveEntryName entryName, final byte[] contents, final DocumentNameMatcher nameMatcher) {
- super(entryName, nameMatcher);
- this.contents = contents;
- }
-
- @Override
- public InputStream inputStream() {
- return new ByteArrayInputStream(contents);
- }
-
- @Override
- public boolean isDirectory() {
- return false;
- }
-
- @Override
- public SortedSet listChildren() {
- return Collections.emptySortedSet();
- }
-}
diff --git a/apache-rat-core/src/main/java/org/apache/rat/header/HeaderMatcher.java b/apache-rat-core/src/main/java/org/apache/rat/header/HeaderMatcher.java
index 89b71b0a2..7f05afa3a 100644
--- a/apache-rat-core/src/main/java/org/apache/rat/header/HeaderMatcher.java
+++ b/apache-rat-core/src/main/java/org/apache/rat/header/HeaderMatcher.java
@@ -18,6 +18,7 @@
*/
package org.apache.rat.header;
+import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
import org.apache.rat.DeprecationReporter;
import java.io.IOException;
@@ -35,6 +36,7 @@
* Note: use only from a single thread.
*
*/
+@SuppressFBWarnings("EI_EXPOSE_REP2")
@Deprecated // since 0.17
@DeprecationReporter.Info(since = "0.17", forRemoval = true)
public class HeaderMatcher {
diff --git a/apache-rat-core/src/main/java/org/apache/rat/help/Licenses.java b/apache-rat-core/src/main/java/org/apache/rat/help/Licenses.java
index 0277186b0..bac55af54 100644
--- a/apache-rat-core/src/main/java/org/apache/rat/help/Licenses.java
+++ b/apache-rat-core/src/main/java/org/apache/rat/help/Licenses.java
@@ -43,6 +43,8 @@
import org.apache.rat.license.ILicenseFamily;
import org.apache.rat.license.LicenseSetFactory.LicenseFilter;
+import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
+
import static java.lang.String.format;
/**
@@ -64,6 +66,7 @@ public final class Licenses extends AbstractHelp {
* @param config The configuration that contains the license information.
* @param writer the writer to write the report to.
*/
+ @SuppressFBWarnings("EI_EXPOSE_REP2")
public Licenses(final ReportConfiguration config, final Writer writer) {
this.config = config;
this.licenses = config.getLicenses(LicenseFilter.ALL);
diff --git a/apache-rat-core/src/main/java/org/apache/rat/license/LicenseSetFactory.java b/apache-rat-core/src/main/java/org/apache/rat/license/LicenseSetFactory.java
index 6fe00db5a..5474501ff 100644
--- a/apache-rat-core/src/main/java/org/apache/rat/license/LicenseSetFactory.java
+++ b/apache-rat-core/src/main/java/org/apache/rat/license/LicenseSetFactory.java
@@ -20,13 +20,19 @@
import java.util.Collection;
import java.util.Collections;
+import java.util.HashSet;
import java.util.Optional;
+import java.util.Set;
import java.util.SortedSet;
import java.util.TreeSet;
import java.util.function.Predicate;
+import java.util.stream.Collectors;
+import org.apache.commons.collections4.set.UnmodifiableSortedSet;
+import org.apache.rat.ConfigurationException;
import org.apache.rat.analysis.IHeaderMatcher;
import org.apache.rat.analysis.IHeaders;
+import org.apache.rat.utils.DefaultLog;
import org.apache.rat.utils.Log;
import org.apache.rat.utils.ReportingSet;
@@ -121,6 +127,31 @@ public LicenseSetFactory(final SortedSet licenses) {
licenses.forEach(l -> families.addIfNotPresent(l.getLicenseFamily()));
}
+ public void validate() {
+ Log log = DefaultLog.getInstance();
+
+ // verify license definitions exist
+ if (getLicenses(LicenseFilter.ALL).isEmpty()) {
+ String msg = "At least one license must be defined";
+ log.error(msg);
+ throw new ConfigurationException(msg);
+ }
+
+ // verify that all approved license families exist
+ Set exists = getLicenseFamilies(LicenseFilter.ALL)
+ .stream().map(ILicenseFamily::getFamilyCategory).collect(Collectors.toSet());
+ Set approved = new HashSet<>(approvedLicenseCategories);
+ approved.removeIf(exists::contains);
+ approved.forEach(name -> log.warn(String.format("License category '%s' was approved but does not exist.", name)));
+
+ // verify that all approved licenses exist
+ exists = getLicenses(LicenseFilter.ALL)
+ .stream().map(ILicense::getId).collect(Collectors.toSet());
+ approved = new HashSet<>(approvedLicenseIds);
+ approved.removeIf(exists::contains);
+ approved.forEach(name -> log.warn(String.format("License '%s' was approved but does not exist.", name)));
+ }
+
public void add(final LicenseSetFactory other) {
this.families.addAll(other.families);
this.licenses.addAll(other.licenses);
@@ -289,18 +320,21 @@ public Predicate getApprovedLicensePredicate() {
* @param filter the types of LicenseFamily objects to return.
* @return a SortedSet of ILicense objects.
*/
- public SortedSet getLicenses(final LicenseFilter filter) {
+ public UnmodifiableSortedSet getLicenses(final LicenseFilter filter) {
+ SortedSet result;
switch (filter) {
case ALL:
- return Collections.unmodifiableSortedSet(licenses);
+ result = licenses;
+ break;
case APPROVED:
- SortedSet result = new TreeSet<>();
+ result = new TreeSet<>();
licenses.stream().filter(getApprovedLicensePredicate()).forEach(result::add);
- return result;
+ break;
case NONE:
default:
- return Collections.emptySortedSet();
+ result = Collections.emptySortedSet();
}
+ return (UnmodifiableSortedSet) UnmodifiableSortedSet.unmodifiableSortedSet(result);
}
/**
diff --git a/apache-rat-core/src/main/java/org/apache/rat/report/IReportable.java b/apache-rat-core/src/main/java/org/apache/rat/report/Reportable.java
similarity index 96%
rename from apache-rat-core/src/main/java/org/apache/rat/report/IReportable.java
rename to apache-rat-core/src/main/java/org/apache/rat/report/Reportable.java
index 2c108af6c..9d131ed85 100644
--- a/apache-rat-core/src/main/java/org/apache/rat/report/IReportable.java
+++ b/apache-rat-core/src/main/java/org/apache/rat/report/Reportable.java
@@ -21,7 +21,7 @@
import org.apache.rat.api.RatException;
import org.apache.rat.document.DocumentName;
-public interface IReportable {
+public interface Reportable {
/**
* Adds the reportable to the RatReport.
* @param report the report to add the results to.
@@ -33,5 +33,5 @@ public interface IReportable {
* Returns the DocumentName for the reportable.
* @return the DocumentName for the reportable.
*/
- DocumentName getName();
+ DocumentName name();
}
diff --git a/apache-rat-core/src/main/java/org/apache/rat/report/claim/ClaimStatistic.java b/apache-rat-core/src/main/java/org/apache/rat/report/claim/ClaimStatistic.java
index 62572916c..f2aac3a88 100644
--- a/apache-rat-core/src/main/java/org/apache/rat/report/claim/ClaimStatistic.java
+++ b/apache-rat-core/src/main/java/org/apache/rat/report/claim/ClaimStatistic.java
@@ -19,14 +19,24 @@
package org.apache.rat.report.claim;
+import java.io.IOException;
+import java.io.InputStream;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;
import java.util.Locale;
+import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
+import javax.xml.parsers.DocumentBuilder;
+
+import org.apache.commons.io.function.IOSupplier;
import org.apache.commons.lang3.StringUtils;
import org.apache.rat.api.Document;
+import org.apache.rat.configuration.XMLConfigurationReader;
+import org.apache.rat.report.xml.writer.XmlWriter;
+import org.apache.rat.utils.StandardXmlFactory;
+import org.xml.sax.SAXException;
/**
* This class provides a numerical overview about
@@ -113,6 +123,9 @@ public String displayName() {
/** Map of counter type to value */
private final ConcurrentHashMap counterMap = new ConcurrentHashMap<>();
+ public Serde serde() {
+ return new Serde();
+ }
/**
* Converts null counter to 0.
*
@@ -141,6 +154,15 @@ public void incCounter(final Counter counter, final int value) {
counterMap.compute(counter, (k, v) -> v == null ? new IntCounter().increment(value) : v.increment(value));
}
+ /**
+ * Increments the counts for the counter.
+ * @param counter the counter to increment.
+ * @param value the value to increment the counter by.
+ */
+ public void setCounter(final Counter counter, final int value) {
+ counterMap.put(counter, new IntCounter().increment(value));
+ }
+
/**
* Gets the counts for the Document.Type.
* @param documentType the Document.Type to get the counter for.
@@ -288,5 +310,105 @@ public IntCounter increment(final int count) {
public int value() {
return value;
}
+
+ @Override
+ public String toString() {
+ return String.valueOf(value);
+ }
+ }
+
+ /**
+ * Serialze and deserialze the claim Statistic.
+ */
+ public class Serde {
+ /** The count attribute string */
+ private static final String COUNT = "count";
+ /** the name attribute string */
+ private static final String NAME = "name";
+
+ /**
+ * Serializes the claim statistic into an appendable.
+ * @param appendable the appendable to write to
+ * @throws IOException on error.
+ */
+ public void serialize(final Appendable appendable) throws IOException {
+ try (XmlWriter writer = new XmlWriter(appendable)) {
+ writer.startDocument().startElement("ClaimStatistic")
+ .startElement("licenseNameMap");
+ for (Map.Entry entry : licenseNameMap.entrySet()) {
+ if (entry.getValue().value > 0) {
+ writer.startElement("licenseName")
+ .attribute(COUNT, entry.getValue().toString())
+ .attribute(NAME, entry.getKey()).closeElement();
+ }
+ }
+ writer.closeElement()
+ .startElement("licenseFamilyCategoryMap");
+ for (Map.Entry entry : licenseFamilyCategoryMap.entrySet()) {
+ if (entry.getValue().value > 0) {
+ writer.startElement("familyCategory")
+ .attribute(COUNT, entry.getValue().toString())
+ .attribute(NAME, entry.getKey()).closeElement();
+ }
+ }
+ writer.closeElement()
+ .startElement("documentTypeMap");
+ for (Map.Entry entry : documentTypeMap.entrySet()) {
+ if (entry.getValue().value > 0) {
+ writer.startElement("documentType")
+ .attribute(COUNT, entry.getValue().toString())
+ .attribute(NAME, entry.getKey().name()).closeElement();
+ }
+ }
+ writer.closeElement()
+ .startElement("counterMap");
+ for (Map.Entry entry : counterMap.entrySet()) {
+ if (entry.getValue().value > 0) {
+ writer.startElement("counter")
+ .attribute(COUNT, entry.getValue().toString())
+ .attribute(NAME, entry.getKey().name()).closeElement();
+ }
+ }
+ writer.closeElement();
+ }
+ }
+
+ /**
+ * Deserializes a ClaimStatistic from an input stream.
+ * @param inputStreamSupplier the supplier of the input stream to deserialize from.
+ * @throws IOException on error.
+ */
+ public void deserialize(final IOSupplier inputStreamSupplier) throws IOException {
+ DocumentBuilder builder = StandardXmlFactory.documentBuilder();
+ org.w3c.dom.Document document;
+ try (InputStream stream = inputStreamSupplier.get()) {
+ document = builder.parse(stream);
+
+ } catch (SAXException e) {
+ throw new IOException("Unable to read input", e);
+ }
+
+ XMLConfigurationReader.nodeListConsumer(document.getElementsByTagName("licenseName"), node -> {
+ Map attributes = XMLConfigurationReader.attributes(node);
+ incLicenseNameCount(attributes.get(NAME), Integer.parseInt(attributes.get(COUNT)));
+ });
+
+ XMLConfigurationReader.nodeListConsumer(document.getElementsByTagName("familyCategory"), node -> {
+ Map attributes = XMLConfigurationReader.attributes(node);
+ incLicenseCategoryCount(attributes.get(NAME), Integer.parseInt(attributes.get(COUNT)));
+ });
+
+ XMLConfigurationReader.nodeListConsumer(document.getElementsByTagName("documentType"), node -> {
+ Map attributes = XMLConfigurationReader.attributes(node);
+ Document.Type type = Document.Type.valueOf(attributes.get(NAME));
+ incCounter(type, Integer.parseInt(attributes.get(COUNT)));
+ });
+
+ XMLConfigurationReader.nodeListConsumer(document.getElementsByTagName("counter"), node -> {
+ Map attributes = XMLConfigurationReader.attributes(node);
+ Counter type = Counter.valueOf(attributes.get(NAME));
+ setCounter(type, Integer.parseInt(attributes.get(COUNT)));
+ });
+ }
}
}
diff --git a/apache-rat-core/src/test/java/org/apache/rat/testhelpers/FileUtils.java b/apache-rat-core/src/main/java/org/apache/rat/utils/FileUtils.java
similarity index 79%
rename from apache-rat-core/src/test/java/org/apache/rat/testhelpers/FileUtils.java
rename to apache-rat-core/src/main/java/org/apache/rat/utils/FileUtils.java
index 5681e7972..453f7ec60 100644
--- a/apache-rat-core/src/test/java/org/apache/rat/testhelpers/FileUtils.java
+++ b/apache-rat-core/src/main/java/org/apache/rat/utils/FileUtils.java
@@ -16,24 +16,27 @@
* specific language governing permissions and limitations *
* under the License. *
*/
-package org.apache.rat.testhelpers;
+package org.apache.rat.utils;
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;
+import java.nio.file.Files;
import java.util.Arrays;
import java.util.Collections;
-import static org.assertj.core.api.Fail.fail;
-public class FileUtils {
+public final class FileUtils {
+ private FileUtils() {
+ // do not instantiate
+ }
/**
* Creates a directory if it does not exist.
* @param dir the directory to make.
*/
- public static void mkDir(File dir) {
+ public static void mkDir(final File dir) {
boolean ignored = dir.mkdirs();
}
@@ -41,7 +44,7 @@ public static void mkDir(File dir) {
* Deletes a file if it exists.
* @param file the file to delete.
*/
- public static void delete(File file) {
+ public static void delete(final File file) throws IOException {
if (file.exists()) {
if (file.isDirectory()) {
try {
@@ -50,7 +53,7 @@ public static void delete(File file) {
//
}
} else {
- boolean ignored = file.delete();
+ Files.delete(file.toPath());
}
}
}
@@ -62,15 +65,16 @@ public static void delete(File file) {
* @param lines the lines to write into the file.
* @return the new File.
*/
- static public File writeFile(File dir, final String name, final Iterable lines) {
+ public static File writeFile(final File dir, final String name, final Iterable lines) {
if (dir == null) {
- fail("base directory not specified");
+ throw new IllegalArgumentException("base directory not specified");
}
+ mkDir(dir);
File file = new File(dir, name);
try (PrintWriter writer = new PrintWriter(new FileWriter(file))) {
lines.forEach(writer::println);
} catch (IOException e) {
- fail(e.getMessage());
+ throw new RuntimeException(e.getMessage(), e);
}
return file;
}
@@ -82,7 +86,7 @@ static public File writeFile(File dir, final String name, final Iterable
* @param lines the lines to write into the file.
* @return the new File.
*/
- static public File writeFile(File dir, final String name, final String... lines) {
+ public static File writeFile(final File dir, final String name, final String... lines) {
return writeFile(dir, name, Arrays.asList(lines));
}
@@ -92,7 +96,7 @@ static public File writeFile(File dir, final String name, final String... lines)
* @param name the name of the file.
* @return the new file.
*/
- public static File writeFile(File dir, String name) {
+ public static File writeFile(final File dir, final String name) {
return writeFile(dir, name, Collections.singletonList(name));
}
}
diff --git a/apache-rat-core/src/main/java/org/apache/rat/utils/StandardXmlFactory.java b/apache-rat-core/src/main/java/org/apache/rat/utils/StandardXmlFactory.java
index 38f4cd08e..9b833fbf5 100644
--- a/apache-rat-core/src/main/java/org/apache/rat/utils/StandardXmlFactory.java
+++ b/apache-rat-core/src/main/java/org/apache/rat/utils/StandardXmlFactory.java
@@ -18,7 +18,12 @@
*/
package org.apache.rat.utils;
+import java.io.File;
+import java.io.FileWriter;
+import java.io.IOException;
import java.io.InputStream;
+import java.io.StringWriter;
+import java.util.Properties;
import javax.xml.XMLConstants;
import javax.xml.parsers.DocumentBuilder;
@@ -27,9 +32,15 @@
import javax.xml.transform.OutputKeys;
import javax.xml.transform.Transformer;
import javax.xml.transform.TransformerConfigurationException;
+import javax.xml.transform.TransformerException;
import javax.xml.transform.TransformerFactory;
+import javax.xml.transform.dom.DOMSource;
+import javax.xml.transform.stream.StreamResult;
import javax.xml.transform.stream.StreamSource;
+import org.w3c.dom.Document;
+
+
/**
* Factory to create standard XML objects. The intention of this class is to resolve in a consistent manner the
* XXE errors and similar XML IO errors.
@@ -53,16 +64,28 @@ private StandardXmlFactory() {
* @throws TransformerConfigurationException on error.
*/
public static Transformer create() throws TransformerConfigurationException {
- return create(null);
+ return create(null, new Properties());
}
/**
- * Create a transformer with the specified stylesheet.
- * @param styleIn the stylesheet to use.
+ * Create a transformer with specified style sheet.
+ * @param styleIn the style sheet input stream
* @return the transformer.
* @throws TransformerConfigurationException on error.
*/
public static Transformer create(final InputStream styleIn) throws TransformerConfigurationException {
+ return create(styleIn, new Properties());
+ }
+
+ /**
+ * Create a transformer with the specified stylesheet and additional properties.
+ * By default, the output omits the XML declaration, uses XML output, indents rsult with 4 spaces.
+ * @param styleIn the stylesheet to use.
+ * @param transformerProperties Additional output transformer properties.
+ * @return the transformer.
+ * @throws TransformerConfigurationException on error.
+ */
+ public static Transformer create(final InputStream styleIn, final Properties transformerProperties) throws TransformerConfigurationException {
TransformerFactory factory = TransformerFactory.newInstance();
factory.setFeature(XMLConstants.FEATURE_SECURE_PROCESSING, true);
factory.setAttribute(XMLConstants.ACCESS_EXTERNAL_DTD, "");
@@ -73,6 +96,9 @@ public static Transformer create(final InputStream styleIn) throws TransformerCo
transformer.setOutputProperty(OutputKeys.INDENT, "yes");
transformer.setOutputProperty(OutputKeys.ENCODING, "UTF-8");
transformer.setOutputProperty("{http://xml.apache.org/xslt}indent-amount", "4");
+ if (transformerProperties != null) {
+ transformer.setOutputProperties(transformerProperties);
+ }
return transformer;
}
@@ -94,4 +120,28 @@ public static DocumentBuilder documentBuilder() {
throw new IllegalStateException("No XML parser defined", e);
}
}
+
+ /**
+ * Write an XML document to a file.
+ * @param document the document to write
+ * @param file the file to write to.
+ */
+ public static void writeDocument(final Document document, final File file) throws IOException, TransformerException {
+ DOMSource source = new DOMSource(document);
+ FileWriter writer = new FileWriter(file);
+ StreamResult result = new StreamResult(writer);
+ create().transform(source, result);
+ }
+
+ /**
+ * Write an XML document to a file.
+ * @param document the document to write.
+ */
+ public static String serializeDocument(final Document document) throws TransformerException {
+ DOMSource source = new DOMSource(document);
+ StringWriter writer = new StringWriter();
+ StreamResult result = new StreamResult(writer);
+ create().transform(source, result);
+ return writer.toString();
+ }
}
diff --git a/apache-rat-core/src/main/java/org/apache/rat/walker/ArchiveWalker.java b/apache-rat-core/src/main/java/org/apache/rat/walker/ArchiveWalker.java
index a50aa5ef8..4ad410449 100644
--- a/apache-rat-core/src/main/java/org/apache/rat/walker/ArchiveWalker.java
+++ b/apache-rat-core/src/main/java/org/apache/rat/walker/ArchiveWalker.java
@@ -20,12 +20,15 @@
package org.apache.rat.walker;
import java.io.BufferedInputStream;
+import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.Collection;
+import java.util.Collections;
import java.util.List;
+import java.util.SortedSet;
import org.apache.commons.compress.archivers.ArchiveEntry;
import org.apache.commons.compress.archivers.ArchiveException;
@@ -34,9 +37,9 @@
import org.apache.commons.io.IOUtils;
import org.apache.rat.api.Document;
import org.apache.rat.api.RatException;
-import org.apache.rat.document.ArchiveEntryDocument;
import org.apache.rat.document.ArchiveEntryName;
import org.apache.rat.document.DocumentName;
+import org.apache.rat.document.DocumentNameMatcher;
import org.apache.rat.report.RatReport;
import org.apache.rat.utils.DefaultLog;
@@ -87,13 +90,29 @@ public Collection getDocuments() throws RatException {
ArchiveEntry entry;
while ((entry = input.getNextEntry()) != null) {
if (!entry.isDirectory() && input.canReadEntryData(entry)) {
- DocumentName innerName = DocumentName.builder().setName(entry.getName())
+ final DocumentName innerName = DocumentName.builder().setName(entry.getName())
.setBaseName(".").build();
- if (this.getDocument().getNameMatcher().matches(innerName)) {
+ final DocumentNameMatcher documentNameMatcher = getDocument().getNameMatcher();
+ if (documentNameMatcher.matches(innerName)) {
+ ArchiveEntryName entryName = new ArchiveEntryName(getDocument().getName(), entry.getName());
ByteArrayOutputStream baos = new ByteArrayOutputStream();
IOUtils.copy(input, baos);
- ArchiveEntryName entryName = new ArchiveEntryName(getDocument().getName(), entry.getName());
- result.add(new ArchiveEntryDocument(entryName, baos.toByteArray(), getDocument().getNameMatcher()));
+ result.add(new Document(entryName, documentNameMatcher) {
+ @Override
+ public InputStream inputStream() {
+ return new ByteArrayInputStream(baos.toByteArray());
+ }
+
+ @Override
+ public boolean isDirectory() {
+ return false;
+ }
+
+ @Override
+ public SortedSet listChildren() {
+ return Collections.emptySortedSet();
+ }
+ });
}
}
}
diff --git a/apache-rat-core/src/main/java/org/apache/rat/walker/FileListWalker.java b/apache-rat-core/src/main/java/org/apache/rat/walker/FileListWalker.java
index 056090858..eb62c0f29 100644
--- a/apache-rat-core/src/main/java/org/apache/rat/walker/FileListWalker.java
+++ b/apache-rat-core/src/main/java/org/apache/rat/walker/FileListWalker.java
@@ -29,15 +29,15 @@
import org.apache.rat.document.DocumentName;
import org.apache.rat.document.DocumentNameMatcher;
import org.apache.rat.document.FileDocument;
-import org.apache.rat.report.IReportable;
import org.apache.rat.report.RatReport;
+import org.apache.rat.report.Reportable;
import org.apache.rat.utils.DefaultLog;
/**
* Implementation of IReportable that traverses over a resource collection
* internally.
*/
-public class FileListWalker implements IReportable {
+public class FileListWalker implements Reportable {
/** The source document name. */
private final FileDocument source;
/** The root document name. */
@@ -72,7 +72,7 @@ private FileDocument createDocument(final String unixFileName) {
@Override
public void run(final RatReport report) throws RatException {
DefaultLog.getInstance().debug(String.format("Reading file name: %s due to option %s", source, Arg.SOURCE.option()));
- DocumentName sourceName = getName();
+ DocumentName sourceName = name();
try (Reader reader = source.reader()) {
for (String docName : IOUtils.readLines(reader)) {
try {
@@ -93,7 +93,7 @@ public void run(final RatReport report) throws RatException {
}
@Override
- public DocumentName getName() {
+ public DocumentName name() {
return source.getName();
}
}
diff --git a/apache-rat-core/src/main/java/org/apache/rat/walker/IReportableListWalker.java b/apache-rat-core/src/main/java/org/apache/rat/walker/ReportableListWalker.java
similarity index 85%
rename from apache-rat-core/src/main/java/org/apache/rat/walker/IReportableListWalker.java
rename to apache-rat-core/src/main/java/org/apache/rat/walker/ReportableListWalker.java
index b028b9c68..b4afad47e 100644
--- a/apache-rat-core/src/main/java/org/apache/rat/walker/IReportableListWalker.java
+++ b/apache-rat-core/src/main/java/org/apache/rat/walker/ReportableListWalker.java
@@ -24,18 +24,18 @@
import org.apache.rat.api.RatException;
import org.apache.rat.document.DocumentName;
-import org.apache.rat.report.IReportable;
import org.apache.rat.report.RatReport;
+import org.apache.rat.report.Reportable;
import org.apache.rat.utils.DefaultLog;
/**
* A Reportable that walks a list of IReportables and executes the run on each.
*/
-public final class IReportableListWalker implements IReportable {
+public final class ReportableListWalker implements Reportable {
/** The document name for this walker. */
private final DocumentName documentName;
/** The list of reportables for this walker. */
- private final List reportables;
+ private final List reportables;
/**
* Create a builder for the list walker.
@@ -50,24 +50,24 @@ public static Builder builder(final DocumentName name) {
* Construct the builder.
* @param builder for the reportable.
*/
- private IReportableListWalker(final Builder builder) {
+ private ReportableListWalker(final Builder builder) {
this.documentName = builder.documentName;
this.reportables = builder.reportables;
}
@Override
public void run(final RatReport report) {
- for (IReportable reportable : reportables) {
+ for (Reportable reportable : reportables) {
try {
reportable.run(report);
} catch (RatException e) {
- DefaultLog.getInstance().error("Error processing " + reportable.getName(), e);
+ DefaultLog.getInstance().error("Error processing " + reportable.name(), e);
}
}
}
@Override
- public DocumentName getName() {
+ public DocumentName name() {
return documentName;
}
@@ -78,7 +78,7 @@ public static final class Builder {
/** The document name for the walker. */
private final DocumentName documentName;
/** The list of IReportable objects to execute. */
- private List reportables = new ArrayList<>();
+ private List reportables = new ArrayList<>();
/**
* Constructs the builder.
@@ -94,7 +94,7 @@ private Builder(final DocumentName name) {
* @param reportable the reportable to run.
* @return this.
*/
- public Builder addReportable(final IReportable reportable) {
+ public Builder addReportable(final Reportable reportable) {
this.reportables.add(reportable);
return this;
}
@@ -104,11 +104,11 @@ public Builder addReportable(final IReportable reportable) {
* @return the reportable.
* @throws RatException on error.
*/
- public IReportable build() throws RatException {
+ public Reportable build() throws RatException {
if (reportables == null) {
throw new RatException("Builder may only be used once");
}
- IReportable result = new IReportableListWalker(this);
+ Reportable result = new ReportableListWalker(this);
this.reportables = null;
return result;
}
diff --git a/apache-rat-core/src/main/java/org/apache/rat/walker/Walker.java b/apache-rat-core/src/main/java/org/apache/rat/walker/Walker.java
index 5651f7ab9..a6df1e25c 100644
--- a/apache-rat-core/src/main/java/org/apache/rat/walker/Walker.java
+++ b/apache-rat-core/src/main/java/org/apache/rat/walker/Walker.java
@@ -21,12 +21,12 @@
import org.apache.rat.api.Document;
import org.apache.rat.document.DocumentName;
-import org.apache.rat.report.IReportable;
+import org.apache.rat.report.Reportable;
/**
* Abstract walker.
*/
-public abstract class Walker implements IReportable {
+public abstract class Walker implements Reportable {
/** The document this walker is walking */
private final Document document;
@@ -48,7 +48,7 @@ protected Document getDocument() {
}
@Override
- public DocumentName getName() {
+ public DocumentName name() {
return document.getName();
}
}
diff --git a/apache-rat-core/src/main/resources/org/apache/rat/xhtml5.xsl b/apache-rat-core/src/main/resources/org/apache/rat/xhtml5.xsl
new file mode 100644
index 000000000..b15224605
--- /dev/null
+++ b/apache-rat-core/src/main/resources/org/apache/rat/xhtml5.xsl
@@ -0,0 +1,354 @@
+
+
+
+
+
+
+
+
+ ❗
+ 🗜
+ 🔠
+ 🚫
+ ℹ
+ ✅
+ ❓
+ 📂
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Rat Report
+
+
+
+
+
+
+
+
+
+
+
+
+ Detail
+
+
+ Documents with unapproved licenses will start with a
+ The first character on the next line identifies the document type.
+
+
+
+ Symbols used in this RAT report
+
+
+ | Symbol |
+ Type |
+
+
+ |
+ Archive file |
+
+
+ |
+ Binary file |
+
+
+ |
+ Ignored file |
+
+
+ |
+ Notice file |
+
+
+ |
+ Standard file |
+
+
+ |
+ Unknown file |
+
+
+ |
+ Directory |
+
+
+
+
+
+ Resources discovered in this RAT report
+
+
+
+ |
+
+
+
+
+
+
+
+
+
+
+ |
+
+
+
+
+
+
+
+
+
+
+ ID:
+
+ UUID
+
+
+
+ Family:
+
+ Unknown
+
+
+
+ |
+
+
+
+
+
+
+ Summary
+
+
+
Generated at by
+
+
+
+
+
+ Table 1: A summary of statistics from this RAT report.
+
+
+ | Name: |
+ Count: |
+ Description: |
+
+
+
+ |
+
+
+
+
+ Unknown
+
+
+ |
+ |
+ |
+
+
+
+
+
License Statistics
+
+
Categories
+
+
+
+ Table 2: License categories found in this RAT report.
+
+
+ | Name: |
+ Count: |
+
+
+
+
+ |
+
+
+
+
+ Unknown
+
+
+ |
+ |
+
+
+
+
+
+
Licenses
+
+
+
+ Table 3: Licenses found in this RAT report.
+
+
+ | Name: |
+ Count: |
+
+
+
+
+ |
+
+
+
+
+ Unknown
+
+
+ |
+ |
+
+
+
+
+
+
+
Document types
+
+
+
+ Table 4: Document types found in this RAT report.
+
+
+ | Name: |
+ Count: |
+
+
+
+
+ |
+ |
+
+
+
+
+
Files with unapproved licenses
+
+
+
+
+
+ Archives
+
+
+
+
+
+
+
+
+
+
+
+ | |
+
+
+ |
+
+
+
diff --git a/apache-rat-core/src/test/java/org/apache/rat/DefaultsTest.java b/apache-rat-core/src/test/java/org/apache/rat/DefaultsTest.java
index bfd5f31e7..db9edb03f 100644
--- a/apache-rat-core/src/test/java/org/apache/rat/DefaultsTest.java
+++ b/apache-rat-core/src/test/java/org/apache/rat/DefaultsTest.java
@@ -22,6 +22,7 @@
import java.util.Set;
import java.util.TreeSet;
+import org.apache.commons.collections4.set.UnmodifiableSortedSet;
import org.apache.rat.license.ILicense;
import org.apache.rat.license.LicenseSetFactory.LicenseFilter;
import org.junit.jupiter.api.Test;
@@ -36,7 +37,7 @@ public class DefaultsTest {
public void defaultConfigTest() {
Defaults defaults = Defaults.builder().build();
- Set licenses = defaults.getLicenseSetFactory().getLicenses(LicenseFilter.ALL);
+ UnmodifiableSortedSet licenses = defaults.getLicenseSetFactory().getLicenses(LicenseFilter.ALL);
Set names = new TreeSet<>();
licenses.forEach(x -> names.add(x.getLicenseFamily().getFamilyCategory()));
diff --git a/apache-rat-core/src/test/java/org/apache/rat/OptionCollectionParserTest.java b/apache-rat-core/src/test/java/org/apache/rat/OptionCollectionParserTest.java
index f18ee2ab9..2b2411497 100644
--- a/apache-rat-core/src/test/java/org/apache/rat/OptionCollectionParserTest.java
+++ b/apache-rat-core/src/test/java/org/apache/rat/OptionCollectionParserTest.java
@@ -19,7 +19,7 @@
package org.apache.rat;
import org.apache.commons.cli.Option;
-import org.apache.commons.cli.ParseException;
+import org.apache.rat.api.RatException;
import org.apache.rat.commandline.ArgumentContext;
import org.apache.rat.ui.UIOption;
import org.apache.rat.ui.UIOptionCollection;
@@ -28,7 +28,6 @@
import org.junit.jupiter.api.io.CleanupMode;
import org.junit.jupiter.api.io.TempDir;
-import java.io.IOException;
import java.nio.file.Path;
import static org.assertj.core.api.Assertions.assertThat;
@@ -42,7 +41,7 @@ class OptionCollectionParserTest {
private final OptionCollectionParser underTest = new OptionCollectionParser(optionCollection);
@Test
- void parseCommands() throws IOException, ParseException {
+ void parseCommands() throws RatException {
String[] args = {"arg1", "arg2"};
ArgumentContext ctxt = underTest.parseCommands(testPath.toFile(), args);
assertThat(ctxt.getCommandLine().getArgList()).containsExactly(args);
diff --git a/apache-rat-core/src/test/java/org/apache/rat/OptionCollectionTest.java b/apache-rat-core/src/test/java/org/apache/rat/OptionCollectionTest.java
index 238bc69c1..9b2592acf 100644
--- a/apache-rat-core/src/test/java/org/apache/rat/OptionCollectionTest.java
+++ b/apache-rat-core/src/test/java/org/apache/rat/OptionCollectionTest.java
@@ -30,20 +30,20 @@
import java.util.Locale;
import java.util.Map;
import java.util.TreeMap;
-import org.apache.commons.cli.CommandLine;
-import org.apache.commons.cli.DefaultParser;
+
import org.apache.commons.cli.Option;
import org.apache.commons.cli.ParseException;
import org.apache.commons.lang3.tuple.Pair;
import org.apache.rat.commandline.ArgumentContext;
import org.apache.rat.document.DocumentName;
import org.apache.rat.license.LicenseSetFactory;
-import org.apache.rat.report.IReportable;
+import org.apache.rat.report.Reportable;
import org.apache.rat.test.AbstractConfigurationOptionsProvider;
import org.apache.rat.test.utils.OptionFormatter;
import org.apache.rat.testhelpers.TestingLog;
import org.apache.rat.utils.CasedString;
import org.apache.rat.utils.DefaultLog;
+import org.apache.rat.utils.FileUtils;
import org.apache.rat.utils.Log;
import org.apache.rat.walker.ArchiveWalker;
import org.apache.rat.walker.DirectoryWalker;
@@ -181,6 +181,7 @@ public static Map processTestFunctionAnnotations(Object test
public void testDeprecatedUseLogged() throws IOException {
TestingLog log = new TestingLog();
try {
+ FileUtils.mkDir(testPath.resolve("target").toFile());
DefaultLog.setInstance(log);
String[] args = {"--dir", "target", "-a"};
ReportConfiguration config = OptionCollection.parseCommands(testPath.toFile(), args, o -> fail("Help printed"), true);
@@ -220,8 +221,7 @@ public void testShortenedOptions() throws IOException {
@Test
public void testDefaultConfiguration() throws ParseException {
String[] empty = {};
- CommandLine cl = new DefaultParser().parse(OptionCollection.buildOptions(), empty);
- ArgumentContext context = new ArgumentContext(new File("."), cl);
+ ArgumentContext context = new ArgumentContext(new File("."), OptionCollection.buildOptions(), empty);
ReportConfiguration config = OptionCollection.createConfiguration(context);
ReportConfigurationTest.validateDefault(config);
}
@@ -233,9 +233,9 @@ public void getReportableTest(String fName) throws IOException {
DocumentName.FSInfo fsInfo = new DocumentName.FSInfo(testPath.getFileSystem());
String expected = fsInfo.normalize(base.getAbsolutePath());
ReportConfiguration config = OptionCollection.parseCommands(testPath.toFile(), new String[]{fName}, o -> fail("Help called"), false);
- IReportable reportable = OptionCollection.getReportable(base, config);
+ Reportable reportable = OptionCollection.getReportable(base, config);
assertThat(reportable).as(() -> format("'%s' returned null", fName)).isNotNull();
- assertThat(reportable.getName().getName()).isEqualTo(expected);
+ assertThat(reportable.name().getName()).isEqualTo(expected);
}
@Test
@@ -250,7 +250,7 @@ void getReportable() throws IOException {
reportConfiguration.addExcludedPatterns(List.of(dir2.getName()));
assertThat(OptionCollection.getReportable(dir2, reportConfiguration)).isNull();
- IReportable reportable = OptionCollection.getReportable(dir1, new ReportConfiguration());
+ Reportable reportable = OptionCollection.getReportable(dir1, new ReportConfiguration());
assertThat(reportable).isInstanceOf(DirectoryWalker.class);
File file1 = new File(dir1, "file1");
diff --git a/apache-rat-core/src/test/java/org/apache/rat/OutputTest.java b/apache-rat-core/src/test/java/org/apache/rat/OutputTest.java
new file mode 100644
index 000000000..32602b60e
--- /dev/null
+++ b/apache-rat-core/src/test/java/org/apache/rat/OutputTest.java
@@ -0,0 +1,160 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one *
+ * or more contributor license agreements. See the NOTICE file *
+ * distributed with this work for additional information *
+ * regarding copyright ownership. The ASF licenses this file *
+ * to you under the Apache License, Version 2.0 (the *
+ * "License"); you may not use this file except in compliance *
+ * with the License. You may obtain a copy of the License at *
+ * *
+ * https://www.apache.org/licenses/LICENSE-2.0 *
+ * *
+ * Unless required by applicable law or agreed to in writing, *
+ * software distributed under the License is distributed on an *
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY *
+ * KIND, either express or implied. See the License for the *
+ * specific language governing permissions and limitations *
+ * under the License. *
+ */
+package org.apache.rat;
+
+import org.apache.rat.commandline.StyleSheets;
+import org.apache.rat.config.AddLicenseHeaders;
+import org.apache.rat.config.exclusion.StandardCollection;
+import org.apache.rat.config.results.ClaimValidator;
+import org.apache.rat.document.DocumentName;
+import org.apache.rat.document.DocumentNameMatcher;
+import org.apache.rat.license.LicenseSetFactory;
+import org.apache.rat.report.claim.ClaimStatistic;
+import org.apache.rat.report.claim.ClaimStatisticTest;
+import org.apache.rat.utils.FileUtils;
+import org.apache.rat.utils.StandardXmlFactory;
+import org.junit.jupiter.api.AfterAll;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.Test;
+import org.w3c.dom.Document;
+import org.xml.sax.SAXException;
+import org.xmlunit.assertj3.XmlAssert;
+
+import javax.xml.transform.TransformerException;
+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.StringWriter;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.List;
+
+class OutputTest {
+
+ static Path tempPath;
+
+ @BeforeAll
+ static void setup() throws IOException {
+ tempPath = Files.createTempDirectory("outputTest").toAbsolutePath();
+ }
+
+ @AfterAll
+ static void teardown() throws IOException {
+ FileUtils.delete(tempPath.toFile());
+ }
+
+ @Test
+ void documentReadingTest() throws IOException, SAXException, TransformerException {
+ Path testPath = tempPath.resolve("documentReading");
+ File testFile = testPath.toFile();
+ FileUtils.mkDir(testFile);
+ DocumentName workingDirectory = DocumentName.builder(testPath.toFile()).setBaseName(testFile).build();
+ Document document;
+ DocumentName documentFile = workingDirectory.resolve("document.xml");
+ try (InputStream inputStream = OutputTest.class.getClassLoader().getResourceAsStream("XmlOutputExamples/elements.xml");) {
+ document = StandardXmlFactory.documentBuilder().parse(inputStream);
+ StandardXmlFactory.writeDocument(document, documentFile.asFile());
+ }
+
+ Reporter.Output.Builder builder = Reporter.Output.builder().document(documentFile.getName(), workingDirectory);
+
+ Reporter.Output output = builder.build();
+ XmlAssert.assertThat(output.getDocument()).and(document)
+ .ignoreWhitespace()
+ .areIdentical();
+ }
+
+ @Test
+ void stasticReadingTest() throws IOException {
+ Path testPath = tempPath.resolve("statisticReading");
+ File testFile = testPath.toFile();
+ FileUtils.mkDir(testFile);
+ DocumentName workingDirectory = DocumentName.builder(testPath.toFile()).setBaseName(testFile).build();
+ DocumentName documentFile = workingDirectory.resolve("statistic.xml");
+
+ ClaimStatistic underTest = new ClaimStatistic();
+ underTest.incLicenseCategoryCount("familyCagegory", 1);
+ underTest.incCounter(ClaimStatistic.Counter.APPROVED, 2);
+ underTest.incCounter(org.apache.rat.api.Document.Type.IGNORED, 3);
+ underTest.incLicenseNameCount("licenseName", 4);
+
+ ClaimStatistic.Serde serde = underTest.serde();
+ StringWriter stringWriter = new StringWriter();
+ serde.serialize(stringWriter);
+ try (FileOutputStream fos = new FileOutputStream(documentFile.asFile())) {
+ fos.write(stringWriter.toString().getBytes(StandardCharsets.UTF_8));
+ }
+
+ Reporter.Output.Builder builder = Reporter.Output.builder().statistic(documentFile.getName(), workingDirectory);
+
+ Reporter.Output output = builder.build();
+ ClaimStatisticTest.assertSame(output.getStatistic(), underTest);
+ }
+
+ @Test
+ void configurationReadingTest() throws IOException {
+ Path testPath = tempPath.resolve("configurationReading");
+ File testFile = testPath.toFile();
+ FileUtils.mkDir(testFile);
+ DocumentName workingDirectory = DocumentName.builder(testPath.toFile()).setBaseName(testFile).build();
+ DocumentName documentFile = workingDirectory.resolve("configuration.xml");
+
+ ReportConfiguration underTest = new ReportConfiguration();
+ underTest.setAddLicenseHeaders(AddLicenseHeaders.FORCED);
+ underTest.listFamilies(LicenseSetFactory.LicenseFilter.APPROVED);
+ underTest.listLicenses(LicenseSetFactory.LicenseFilter.ALL);
+ underTest.setDryRun(true);
+ underTest.setArchiveProcessing(ReportConfiguration.Processing.NOTIFICATION);
+ underTest.setStandardProcessing(ReportConfiguration.Processing.ABSENCE);
+ underTest.setStyleSheet(StyleSheets.MISSING_HEADERS.getStyleSheet());
+ underTest.setOut(new File("/some/file/somewhere"));
+ underTest.setCopyrightMessage("the copyright message");
+ underTest.addSource(new File("/my/file"));
+ underTest.addSource(new ReportConfigurationTest.TestingReportable());
+ underTest.addExcludedPatterns(List.of("pattern/**", "pattern2/**"));
+ underTest.addExcludedCollection(StandardCollection.BAZAAR);
+ underTest.addExcludedCollection(StandardCollection.MISC);
+ underTest.addExcludedFileProcessor(StandardCollection.HIDDEN_FILE);
+ underTest.addExcludedMatcher(DocumentNameMatcher.MATCHES_ALL);
+ underTest.addIncludedPatterns(List.of("**/pattern3", "**/pattern4"));
+ underTest.addIncludedCollection(StandardCollection.ARCH);
+ underTest.addIncludedCollection(StandardCollection.BITKEEPER);
+ underTest.addIncludedMatcher(DocumentNameMatcher.MATCHES_NONE);
+
+ ClaimValidator claimValidator = underTest.getClaimValidator();
+ claimValidator.setMax(ClaimStatistic.Counter.APPROVED, 5);
+ claimValidator.setMin(ClaimStatistic.Counter.APPROVED, 3);
+ claimValidator.setMax(ClaimStatistic.Counter.ARCHIVES, 10);
+ claimValidator.setMin(ClaimStatistic.Counter.BINARIES, 4);
+
+ StringWriter stringWriter = new StringWriter();
+ underTest.serde().serialize(stringWriter);
+
+ try (FileOutputStream fos = new FileOutputStream(documentFile.asFile())) {
+ fos.write(stringWriter.toString().getBytes(StandardCharsets.UTF_8));
+ }
+
+ Reporter.Output.Builder builder = Reporter.Output.builder().configuration(documentFile.getName(), workingDirectory);
+
+ Reporter.Output output = builder.build();
+ ReportConfigurationTest.assertSame(output.getConfiguration(), underTest);
+ }
+}
diff --git a/apache-rat-core/src/test/java/org/apache/rat/ReportConfigurationTest.java b/apache-rat-core/src/test/java/org/apache/rat/ReportConfigurationTest.java
index 69af88b2b..d6c492c15 100644
--- a/apache-rat-core/src/test/java/org/apache/rat/ReportConfigurationTest.java
+++ b/apache-rat-core/src/test/java/org/apache/rat/ReportConfigurationTest.java
@@ -24,6 +24,7 @@
import static org.mockito.Mockito.when;
import java.io.BufferedReader;
+import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.IOException;
@@ -31,31 +32,41 @@
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.PrintWriter;
+import java.io.StringWriter;
import java.net.URI;
import java.net.URISyntaxException;
import java.net.URL;
+import java.nio.charset.StandardCharsets;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.SortedSet;
import java.util.function.Function;
+import java.util.stream.Collectors;
import org.apache.commons.io.filefilter.DirectoryFileFilter;
import org.apache.commons.io.output.CloseShieldOutputStream;
import org.apache.rat.analysis.IHeaderMatcher;
+import org.apache.rat.api.RatException;
+import org.apache.rat.commandline.StyleSheets;
import org.apache.rat.config.AddLicenseHeaders;
+import org.apache.rat.config.exclusion.ExclusionProcessorTest;
import org.apache.rat.config.exclusion.StandardCollection;
+import org.apache.rat.config.results.ClaimValidator;
import org.apache.rat.configuration.XMLConfigurationReaderTest;
import org.apache.rat.document.DocumentName;
import org.apache.rat.document.DocumentNameMatcher;
import org.apache.rat.license.ILicense;
import org.apache.rat.license.ILicenseFamily;
import org.apache.rat.license.LicenseSetFactory.LicenseFilter;
-import org.apache.rat.report.IReportable;
+import org.apache.rat.report.RatReport;
+import org.apache.rat.report.Reportable;
+import org.apache.rat.report.claim.ClaimStatistic;
import org.apache.rat.testhelpers.TestingLog;
import org.apache.rat.testhelpers.TestingLicense;
import org.apache.rat.testhelpers.TestingMatcher;
import org.apache.rat.utils.DefaultLog;
+import org.apache.rat.utils.Log;
import org.apache.rat.utils.Log.Level;
import org.apache.rat.utils.ReportingSet.Options;
import org.junit.jupiter.api.AfterEach;
@@ -64,6 +75,7 @@
import org.junit.jupiter.api.io.TempDir;
import org.mockito.Mockito;
+
public class ReportConfigurationTest {
private ReportConfiguration underTest;
@@ -456,7 +468,7 @@ public void outputTest() throws IOException {
assertThat(underTest.getWriter()).isNotNull();
ByteArrayOutputStream stream = new ByteArrayOutputStream();
- underTest.setOut(() -> stream);
+ underTest.setOut(new ReportConfiguration.IODescriptor<>("outputTest", () -> stream));
assertThat(underTest.getOutput().get()).isEqualTo(stream);
PrintWriter writer = underTest.getWriter().get();
assertThat(writer).isNotNull();
@@ -468,10 +480,10 @@ public void outputTest() throws IOException {
@Test
public void reportableTest() {
assertThat(underTest.hasSource()).isFalse();
- IReportable reportable = mock(IReportable.class);
+ Reportable reportable = mock(Reportable.class);
underTest.addSource(reportable);
assertThat(underTest.hasSource()).isTrue();
- assertThatThrownBy(() -> underTest.addSource((IReportable)null)).isExactlyInstanceOf(ConfigurationException.class)
+ assertThatThrownBy(() -> underTest.addSource((Reportable)null)).isExactlyInstanceOf(ConfigurationException.class)
.hasMessageContaining("Reportable may not be null.");
}
@@ -480,9 +492,9 @@ public void stylesheetTest() throws IOException, URISyntaxException {
URL url = this.getClass().getResource("ReportConfigurationTestFile");
assertThat(url).isNotNull();
- assertThat(underTest.getStyleSheet()).isNull();
+ assertThat(underTest.getStyleSheetDescriptor()).isNull();
InputStream stream = mock(InputStream.class);
- underTest.setStyleSheet(() -> stream);
+ underTest.setStyleSheet(new ReportConfiguration.IODescriptor<>("stylesheetTest", () -> stream));
assertThat(underTest.getStyleSheet().get()).isEqualTo(stream);
File file = mock(File.class);
@@ -515,32 +527,37 @@ public void testFlags() {
@Test
public void testValidate() {
- final StringBuilder sb = new StringBuilder();
+ TestingLog testLog = new TestingLog();
+ Log oldLog = DefaultLog.getInstance();
+ try {
+ DefaultLog.setInstance(testLog);
+
String msg = "At least one source must be specified";
- assertThatThrownBy(() -> underTest.validate(sb::append)).isExactlyInstanceOf(ConfigurationException.class)
+ assertThatThrownBy(underTest::validate).isExactlyInstanceOf(ConfigurationException.class)
.hasMessageContaining(msg);
- assertThat(sb.toString()).isEqualTo(msg);
+ testLog.assertContains(msg);
+ testLog.clear();
- sb.setLength(0);
- msg = "You must specify at least one license";
- underTest.addSource(mock(IReportable.class));
+ msg = "At least one license must be defined";
+ underTest.addSource(mock(Reportable.class));
- assertThatThrownBy(() -> underTest.validate(sb::append)).isExactlyInstanceOf(ConfigurationException.class)
+ assertThatThrownBy(underTest::validate).isExactlyInstanceOf(ConfigurationException.class)
.hasMessageContaining(msg);
- assertThat(sb.toString()).isEqualTo(msg);
+ testLog.assertContains(msg);
- sb.setLength(0);
underTest.addLicense(testingLicense("valid", "Validation testing license"));
- underTest.validate(sb::append);
- assertThat(sb.length()).isEqualTo(0);
+ underTest.validate();
+ } finally {
+ DefaultLog.setInstance(oldLog);
+ }
}
@Test
public void testSetOut() throws IOException {
ReportConfiguration config = new ReportConfiguration();
try (OutputStreamInterceptor osi = new OutputStreamInterceptor()) {
- config.setOut(() -> osi);
+ config.setOut(new ReportConfiguration.IODescriptor<>("testSetOut", () -> osi));
assertThat(osi.closeCount).isEqualTo(0);
try (OutputStream os = config.getOutput().get()) {
assertThat(os).isNotNull();
@@ -563,16 +580,18 @@ public void logFamilyCollisionTest() {
// verify default collision logs WARNING
underTest.addFamily(ILicenseFamily.builder().setLicenseFamilyCategory("CAT").setLicenseFamilyName("name2"));
- assertThat(log.getCaptured().contains("WARN")).as("default value not WARN").isTrue();
- assertThat(log.getCaptured().contains("CAT")).as("'CAT' not found").isTrue();
+ assertThat(log.getCaptured()).contains("WARN").contains("CAT");
// verify level setting works.
for (Level l : Level.values()) {
log.clear();
underTest.logFamilyCollisions(l);
underTest.addFamily(ILicenseFamily.builder().setLicenseFamilyCategory("CAT").setLicenseFamilyName("name2"));
- assertThat(log.getCaptured().contains("CAT")).as("'CAT' not found").isTrue();
- assertThat(log.getCaptured().contains(l.name())).as("logging not set to "+l).isTrue();
+ if (DefaultLog.getInstance().isEnabled(l)) {
+ assertThat(log.getCaptured()).contains("CAT").contains(l.name());
+ } else {
+ assertThat(log.getCaptured()).doesNotContain("CAT").doesNotContain(l.name());
+ }
}
}
@@ -662,51 +681,52 @@ public void licenseDuplicateOptionsTest() {
.isExactlyInstanceOf(IllegalArgumentException.class);
}
- /**
- * Validates that the configuration contains the default approved licenses.
- * @param config The configuration to test.
- */
- public static void validateDefaultApprovedLicenses(ReportConfiguration config) {
- validateDefaultApprovedLicenses(config, 0);
- }
/**
* Validates that the configuration contains the default approved licenses.
* @param config The configuration to test.
*/
- public static void validateDefaultApprovedLicenses(ReportConfiguration config, int additionalIdCount) {
- assertThat(config.getLicenseCategories(LicenseFilter.APPROVED)).hasSize(XMLConfigurationReaderTest.APPROVED_IDS.length + additionalIdCount);
- for (String s : XMLConfigurationReaderTest.APPROVED_IDS) {
- assertThat(config.getLicenseCategories(LicenseFilter.APPROVED)).contains(ILicenseFamily.makeCategory(s));
+ public static void validateDefaultApprovedLicenses(ReportConfiguration config, String... additionalIds) {
+ validateLicenses(config, Arrays.asList(additionalIds), LicenseFilter.APPROVED, XMLConfigurationReaderTest.APPROVED_LICENSES);
}
+
+ /**
+ * Validates that the configuration contains all the default licenses along with any addiitonal licenses
+ * @param config the configuration to test.
+ * @param additionalLicenses Additional licence IDs that are expected.
+ */
+ public static void validateDefaultLicenses(ReportConfiguration config, String...additionalLicenses) {
+ validateLicenses(config, Arrays.asList(additionalLicenses), LicenseFilter.ALL, XMLConfigurationReaderTest.EXPECTED_LICENSES);
+ }
+
+ private static void validateLicenses(ReportConfiguration config, List additionalIds, LicenseFilter filter, String[] approvedIds) {
+ List expected = new ArrayList<>(Arrays.asList(approvedIds));
+ expected.addAll(additionalIds);
+ assertThat(config.getLicenses(filter).stream().map(ILicense::getId).collect(Collectors.toSet())).containsExactlyInAnyOrderElementsOf(expected);
}
+
/**
* Validates that the configuration contains the default license families.
* @param config the configuration to test.
*/
public static void validateDefaultLicenseFamilies(ReportConfiguration config, String...additionalIds) {
- assertThat(config.getLicenseFamilies(LicenseFilter.ALL)).hasSize(XMLConfigurationReaderTest.EXPECTED_IDS.length + additionalIds.length);
- List expected = new ArrayList<>();
- expected.addAll(Arrays.asList(XMLConfigurationReaderTest.EXPECTED_IDS));
- expected.addAll(Arrays.asList(additionalIds));
- for (ILicenseFamily family : config.getLicenseFamilies(LicenseFilter.ALL)) {
- assertThat(expected).contains(family.getFamilyCategory().trim());
- }
+ validateLicenseFamilies(config, Arrays.asList(additionalIds), LicenseFilter.ALL, XMLConfigurationReaderTest.EXPECTED_IDS);
}
/**
- * Validates that the configuration contains the default licenses.
+ * Validates that the configuration contains the default license families.
* @param config the configuration to test.
*/
- public static void validateDefaultLicenses(ReportConfiguration config, String...additionalLicenses) {
- assertThat(config.getLicenses(LicenseFilter.ALL)).hasSize(XMLConfigurationReaderTest.EXPECTED_LICENSES.length + additionalLicenses.length);
- List expected = new ArrayList<>();
- expected.addAll(Arrays.asList(XMLConfigurationReaderTest.EXPECTED_LICENSES));
- expected.addAll(Arrays.asList(additionalLicenses));
- for (ILicense license : config.getLicenses(LicenseFilter.ALL)) {
- assertThat(expected).contains(license.getId());
+ public static void validateDefaultApprovedLicenseFamilies(ReportConfiguration config, String...additionalIds) {
+ validateLicenseFamilies(config, Arrays.asList(additionalIds), LicenseFilter.APPROVED, XMLConfigurationReaderTest.APPROVED_IDS);
}
+
+ private static void validateLicenseFamilies(ReportConfiguration config, List additionalIds, LicenseFilter filter, String[] approvedIds) {
+ List expected = new ArrayList<>(Arrays.asList(approvedIds));
+ expected.addAll(additionalIds);
+ assertThat(config.getLicenseFamilies(filter).stream().map(lf -> lf.getFamilyCategory().trim())
+ .collect(Collectors.toSet())).containsExactlyInAnyOrderElementsOf(expected);
}
/**
@@ -719,9 +739,68 @@ public static void validateDefault(ReportConfiguration config) {
assertThat(config.getCopyrightMessage()).isNull();
assertThat(config.getStyleSheet()).withFailMessage("Stylesheet should not be null").isNotNull();
- validateDefaultApprovedLicenses(config);
validateDefaultLicenseFamilies(config);
+ validateDefaultApprovedLicenseFamilies(config);
validateDefaultLicenses(config);
+ validateDefaultApprovedLicenses(config);
+ }
+
+ public static void assertSame(ReportConfiguration actual, ReportConfiguration expected) {
+ assertThat(actual.isAddingLicenses()).isEqualTo(expected.isAddingLicenses());
+ assertThat(actual.isAddingLicensesForced()).isEqualTo(expected.isAddingLicensesForced());
+ assertThat(actual.listFamilies()).isEqualTo(expected.listFamilies());
+ assertThat(actual.listLicenses()).isEqualTo(expected.listLicenses());
+ assertThat(actual.isDryRun()).isEqualTo(expected.isDryRun());
+ assertThat(actual.getArchiveProcessing()).isEqualTo(expected.getArchiveProcessing());
+ assertThat(actual.getStandardProcessing()).isEqualTo(expected.getStandardProcessing());
+ assertThat(actual.getStyleSheetDescriptor().name()).isEqualTo(expected.getStyleSheetDescriptor().name());
+ assertThat(actual.getOutputDescriptor().name()).isEqualTo(expected.getOutputDescriptor().name());
+
+ assertThat(actual.getCopyrightMessage()).isEqualTo(expected.getCopyrightMessage());
+
+ assertThat(actual.sources()).containsExactlyElementsOf(expected.sources());
+ assertThat(actual.reportables()).containsExactlyElementsOf(expected.reportables().toList());
+ ExclusionProcessorTest.assertSame(actual.getExclusionProcessor(), expected.getExclusionProcessor());
+
+ }
+ @Test
+ void serdeTest() throws IOException {
+ underTest.setAddLicenseHeaders(AddLicenseHeaders.FORCED);
+ underTest.listFamilies(LicenseFilter.APPROVED);
+ underTest.listLicenses(LicenseFilter.ALL);
+ underTest.setDryRun(true);
+ underTest.setArchiveProcessing(ReportConfiguration.Processing.NOTIFICATION);
+ underTest.setStandardProcessing(ReportConfiguration.Processing.ABSENCE);
+ underTest.setStyleSheet(StyleSheets.MISSING_HEADERS.getStyleSheet());
+ underTest.setOut(new File("/some/file/somewhere"));
+ underTest.setCopyrightMessage("the copyright message");
+ underTest.addSource(new File("/my/file"));
+ underTest.addSource(new TestingReportable());
+
+ underTest.addExcludedPatterns(List.of("pattern/**", "pattern2/**"));
+ underTest.addExcludedCollection(StandardCollection.BAZAAR);
+ underTest.addExcludedCollection(StandardCollection.MISC);
+ underTest.addExcludedFileProcessor(StandardCollection.HIDDEN_FILE);
+ underTest.addExcludedMatcher(DocumentNameMatcher.MATCHES_ALL);
+ underTest.addIncludedPatterns(List.of("**/pattern3", "**/pattern4"));
+ underTest.addIncludedCollection(StandardCollection.ARCH);
+ underTest.addIncludedCollection(StandardCollection.BITKEEPER);
+ underTest.addIncludedMatcher(DocumentNameMatcher.MATCHES_NONE);
+
+ ClaimValidator claimValidator = underTest.getClaimValidator();
+
+ claimValidator.setMax(ClaimStatistic.Counter.APPROVED, 5);
+ claimValidator.setMin(ClaimStatistic.Counter.APPROVED, 3);
+ claimValidator.setMax(ClaimStatistic.Counter.ARCHIVES, 10);
+ claimValidator.setMin(ClaimStatistic.Counter.BINARIES, 4);
+
+ StringWriter stringWriter = new StringWriter();
+ underTest.serde().serialize(stringWriter);
+
+ ReportConfiguration actual = new ReportConfiguration();
+ actual.serde().deserialize(() -> new ByteArrayInputStream(stringWriter.toString().getBytes(StandardCharsets.UTF_8)),
+ DocumentName.builder(new File("/rootDir")).build());
+ assertSame(actual, underTest);
}
/**
@@ -734,10 +813,26 @@ static class OutputStreamInterceptor extends OutputStream {
public void write(int arg0) {
throw new UnsupportedOperationException();
}
-
+
@Override
public void close() {
++closeCount;
}
}
+
+ /**
+ * A reportable that only reports its name. Does no actual work.
+ */
+ static class TestingReportable implements Reportable {
+
+ @Override
+ public void run(RatReport report) throws RatException {
+ // does nothing
+ }
+
+ @Override
+ public DocumentName name() {
+ return DocumentName.builder().setBaseName("").setName("TestingReportable").build();
+ }
+ }
}
diff --git a/apache-rat-core/src/test/java/org/apache/rat/ReporterOptionsProvider.java b/apache-rat-core/src/test/java/org/apache/rat/ReporterOptionsProvider.java
index 0ef6f019c..67ad8fd7b 100644
--- a/apache-rat-core/src/test/java/org/apache/rat/ReporterOptionsProvider.java
+++ b/apache-rat-core/src/test/java/org/apache/rat/ReporterOptionsProvider.java
@@ -20,7 +20,6 @@
import java.io.ByteArrayOutputStream;
import java.io.File;
-import java.io.FileInputStream;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStream;
@@ -54,7 +53,7 @@
import org.apache.rat.test.AbstractOptionsProvider;
import org.apache.rat.test.utils.OptionFormatter;
import org.apache.rat.test.utils.Resources;
-import org.apache.rat.testhelpers.FileUtils;
+import org.apache.rat.utils.FileUtils;
import org.apache.rat.testhelpers.TestingLog;
import org.apache.rat.testhelpers.TextUtils;
import org.apache.rat.testhelpers.XmlUtils;
@@ -65,6 +64,7 @@
import static org.apache.rat.commandline.Arg.HELP_LICENSES;
import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
import static org.assertj.core.api.Fail.fail;
import static org.junit.jupiter.api.Assertions.assertDoesNotThrow;
@@ -114,18 +114,26 @@ protected final ReportConfiguration generateConfig(List>
return config;
}
- private File configureRatDir(Option option) {
- configureSourceDir(option);
- File result = new File(sourceDir, ".rat");
- FileUtils.mkDir(result);
- return result;
- }
-
+ /**
+ * Creates the srcDir.,.
+ * @param option the name for the srcDir.
+ */
private void configureSourceDir(Option option) {
sourceDir = new File(baseDir, OptionFormatter.getName(option));
FileUtils.mkDir(sourceDir);
}
+ /**
+ * Creates the option/.rat directory
+ * @param option the name for the sourceDirectory.
+ */
+ private File configureRatDir(Option option) {
+ configureSourceDir(option);
+ File ratDir = new File(sourceDir, ".rat");
+ FileUtils.mkDir(ratDir);
+ return ratDir;
+ }
+
private void validateNoArgSetup() throws IOException, RatException {
// verify that without args the report is ok.
TestingLog log = new TestingLog();
@@ -133,9 +141,9 @@ private void validateNoArgSetup() throws IOException, RatException {
try {
ReportConfiguration config = generateConfig(Collections.emptyList());
Reporter reporter = new Reporter(config);
- ClaimStatistic claimStatistic = reporter.execute();
+ Reporter.Output output = reporter.execute();
ClaimValidator validator = config.getClaimValidator();
- assertThat(validator.listIssues(claimStatistic)).isEmpty();
+ assertThat(validator.listIssues(output.getStatistic())).isEmpty();
} finally {
DefaultLog.setInstance(null);
}
@@ -160,8 +168,8 @@ private void editLicenseTest(final Option option) {
FileUtils.delete(resultFile);
Reporter reporter = new Reporter(config);
- ClaimStatistic claimStatistic = reporter.execute();
- assertThat(claimStatistic).isNotNull();
+ Reporter.Output output = reporter.execute();
+ assertThat(output.getStatistic()).isNotNull();
String contents = String.join("\n", IOUtils.readLines(new FileReader(testFile)));
assertThat(contents).isEqualTo("class NoLicense {}");
assertThat(resultFile).exists();
@@ -214,9 +222,9 @@ private void execLicensesDeniedTest(final Option option, final String[] args) {
ReportConfiguration config = generateConfig(ImmutablePair.of(option, args));
Reporter reporter = new Reporter(config);
- ClaimStatistic claimStatistic = reporter.execute();
+ Reporter.Output output = reporter.execute();
ClaimValidator validator = config.getClaimValidator();
- assertThat(validator.listIssues(claimStatistic)).containsExactly("UNAPPROVED");
+ assertThat(validator.listIssues(output.getStatistic())).containsExactly("UNAPPROVED");
});
}
@@ -228,8 +236,7 @@ protected void licensesDeniedTest() {
@OptionCollectionTest.TestFunction
protected void licensesDeniedFileTest() {
Option option = Arg.LICENSES_DENIED_FILE.find("licenses-denied-file");
- File ratDir = configureRatDir(option);
- File outputFile = FileUtils.writeFile(ratDir, "licensesDenied.txt", Collections.singletonList("ILLUMOS"));
+ File outputFile = FileUtils.writeFile(configureRatDir(option), "licensesDenied.txt", Collections.singletonList("ILLUMOS"));
execLicensesDeniedTest(option, new String[]{outputFile.getAbsolutePath()});
}
@@ -240,17 +247,11 @@ private void noDefaultsTest(final Option option) {
"*/\n\n", "class Test {}\n"));
validateNoArgSetup();
-
ReportConfiguration config = generateConfig(ImmutablePair.of(option, null));
Reporter reporter = new Reporter(config);
- try {
- reporter.execute();
- fail("Should have thrown exception");
- } catch (RatException e) {
- ClaimStatistic claimStatistic = reporter.getClaimsStatistic();
- ClaimValidator validator = config.getClaimValidator();
- assertThat(validator.listIssues(claimStatistic)).containsExactlyInAnyOrder("DOCUMENT_TYPES", "LICENSE_CATEGORIES", "LICENSE_NAMES", "STANDARDS");
- }
+ assertThatThrownBy(reporter::execute)
+ .isInstanceOf(RatException.class)
+ .hasMessageContaining("At least one license must be defined");
});
}
@@ -276,16 +277,16 @@ protected void counterMaxTest() {
ReportConfiguration config = generateConfig(Collections.emptyList());
Reporter reporter = new Reporter(config);
- ClaimStatistic claimStatistic = reporter.execute();
+ Reporter.Output output = reporter.execute();
ClaimValidator validator = config.getClaimValidator();
- assertThat(validator.listIssues(claimStatistic)).containsExactly("UNAPPROVED");
+ assertThat(validator.listIssues(output.getStatistic())).containsExactly("UNAPPROVED");
arg[0] = "Unapproved:1";
config = generateConfig(ImmutablePair.of(option, arg));
reporter = new Reporter(config);
- claimStatistic = reporter.execute();
+ output = reporter.execute();
validator = config.getClaimValidator();
- assertThat(validator.listIssues(claimStatistic)).isEmpty();
+ assertThat(validator.listIssues(output.getStatistic())).isEmpty();
});
}
@@ -301,21 +302,26 @@ protected void counterMinTest() {
ReportConfiguration config = generateConfig(Collections.emptyList());
Reporter reporter = new Reporter(config);
- ClaimStatistic claimStatistic = reporter.execute();
+ Reporter.Output output = reporter.execute();
ClaimValidator validator = config.getClaimValidator();
- assertThat(validator.listIssues(claimStatistic)).containsExactly("UNAPPROVED");
+ assertThat(validator.listIssues(output.getStatistic())).containsExactly("UNAPPROVED");
arg[0] = "Unapproved:1";
config = generateConfig(ImmutablePair.of(option, arg));
reporter = new Reporter(config);
- claimStatistic = reporter.execute();
+ output = reporter.execute();
validator = config.getClaimValidator();
- assertThat(validator.listIssues(claimStatistic)).isEmpty();
+ assertThat(validator.listIssues(output.getStatistic())).isEmpty();
});
}
- // exclude tests
- private void execExcludeTest(final Option option, final String[] args, final boolean addIgnored) {
+ /**
+ * Runs the exclude tests.
+ * @param option The exclude option to run.
+ * @param args the arguments for the command line.
+ * @param includesRatDir @{code true} if the .rat directory was created.
+ */
+ private void execExcludeTest(final Option option, final String[] args, final boolean includesRatDir) {
String[] notExcluded = {"notbaz", "well._afile"};
String[] excluded = {"some.foo", "B.bar", "justbaz"};
@@ -329,22 +335,21 @@ private void execExcludeTest(final Option option, final String[] args, final boo
ReportConfiguration config = generateConfig(Collections.emptyList());
Reporter reporter = new Reporter(config);
- ClaimStatistic claimStatistic = reporter.execute();
- assertThat(claimStatistic.getCounter(ClaimStatistic.Counter.STANDARDS)).isEqualTo(5);
- assertThat(claimStatistic.getCounter(ClaimStatistic.Counter.IGNORED)).isEqualTo(addIgnored ? 1 : 0);
+ Reporter.Output output = reporter.execute();
+ assertThat(output.getStatistic().getCounter(ClaimStatistic.Counter.STANDARDS)).isEqualTo(5);
+ assertThat(output.getStatistic().getCounter(ClaimStatistic.Counter.IGNORED)).isEqualTo(includesRatDir ? 1 : 0);
// filter out source
config = generateConfig(ImmutablePair.of(option, args));
reporter = new Reporter(config);
- claimStatistic = reporter.execute();
- assertThat(claimStatistic.getCounter(ClaimStatistic.Counter.STANDARDS)).isEqualTo(2);
- assertThat(claimStatistic.getCounter(ClaimStatistic.Counter.IGNORED)).isEqualTo(addIgnored ? 4 : 3);
+ output = reporter.execute();
+ assertThat(output.getStatistic().getCounter(ClaimStatistic.Counter.STANDARDS)).isEqualTo(2);
+ assertThat(output.getStatistic().getCounter(ClaimStatistic.Counter.IGNORED)).isEqualTo(includesRatDir ? 4 : 3);
});
}
private void excludeFileTest(final Option option) {
- File ratDir = configureRatDir(option);
- File outputFile = FileUtils.writeFile(ratDir, "exclude.txt", Arrays.asList(EXCLUDE_ARGS));
+ File outputFile = FileUtils.writeFile(configureRatDir(option), "exclude.txt", Arrays.asList(EXCLUDE_ARGS));
execExcludeTest(option, new String[]{outputFile.getAbsolutePath()}, true);
}
@@ -381,16 +386,16 @@ protected void inputExcludeSizeTest() {
ReportConfiguration config = generateConfig(Collections.emptyList());
Reporter reporter = new Reporter(config);
- ClaimStatistic claimStatistic = reporter.execute();
- assertThat(claimStatistic.getCounter(ClaimStatistic.Counter.STANDARDS)).isEqualTo(3);
- assertThat(claimStatistic.getCounter(ClaimStatistic.Counter.IGNORED)).isEqualTo(0);
+ Reporter.Output output = reporter.execute();
+ assertThat(output.getStatistic().getCounter(ClaimStatistic.Counter.STANDARDS)).isEqualTo(3);
+ assertThat(output.getStatistic().getCounter(ClaimStatistic.Counter.IGNORED)).isZero();
// filter out source
config = generateConfig(ImmutablePair.of(option, args));
reporter = new Reporter(config);
- claimStatistic = reporter.execute();
- assertThat(claimStatistic.getCounter(ClaimStatistic.Counter.STANDARDS)).isEqualTo(2);
- assertThat(claimStatistic.getCounter(ClaimStatistic.Counter.IGNORED)).isEqualTo(1);
+ output = reporter.execute();
+ assertThat(output.getStatistic().getCounter(ClaimStatistic.Counter.STANDARDS)).isEqualTo(2);
+ assertThat(output.getStatistic().getCounter(ClaimStatistic.Counter.IGNORED)).isEqualTo(1);
});
}
@@ -415,15 +420,15 @@ protected void inputExcludeStdTest() {
ReportConfiguration config = generateConfig(Collections.emptyList());
Reporter reporter = new Reporter(config);
- ClaimStatistic claimStatistic = reporter.execute();
- assertThat(claimStatistic.getCounter(ClaimStatistic.Counter.STANDARDS)).isEqualTo(5);
- assertThat(claimStatistic.getCounter(ClaimStatistic.Counter.IGNORED)).isEqualTo(4);
+ Reporter.Output output = reporter.execute();
+ assertThat(output.getStatistic().getCounter(ClaimStatistic.Counter.STANDARDS)).isEqualTo(5);
+ assertThat(output.getStatistic().getCounter(ClaimStatistic.Counter.IGNORED)).isEqualTo(4);
config = generateConfig(ImmutablePair.of(option, args));
reporter = new Reporter(config);
- claimStatistic = reporter.execute();
- assertThat(claimStatistic.getCounter(ClaimStatistic.Counter.STANDARDS)).isEqualTo(4);
- assertThat(claimStatistic.getCounter(ClaimStatistic.Counter.IGNORED)).isEqualTo(5);
+ output = reporter.execute();
+ assertThat(output.getStatistic().getCounter(ClaimStatistic.Counter.STANDARDS)).isEqualTo(4);
+ assertThat(output.getStatistic().getCounter(ClaimStatistic.Counter.IGNORED)).isEqualTo(5);
});
}
@@ -471,21 +476,26 @@ protected void inputExcludeParsedScmTest() {
ReportConfiguration config = generateConfig(Collections.emptyList());
Reporter reporter = new Reporter(config);
- ClaimStatistic claimStatistic = reporter.execute();
- assertThat(claimStatistic.getCounter(ClaimStatistic.Counter.STANDARDS)).isEqualTo(11);
+ Reporter.Output output = reporter.execute();
+ assertThat(output.getStatistic().getCounter(ClaimStatistic.Counter.STANDARDS)).isEqualTo(11);
// .gitignore is ignored by default as it is hidden but not counted
- assertThat(claimStatistic.getCounter(ClaimStatistic.Counter.IGNORED)).isEqualTo(0);
+ assertThat(output.getStatistic().getCounter(ClaimStatistic.Counter.IGNORED)).isZero();
config = generateConfig(ImmutablePair.of(option, args));
reporter = new Reporter(config);
- claimStatistic = reporter.execute();
- assertThat(claimStatistic.getCounter(ClaimStatistic.Counter.STANDARDS)).isEqualTo(3);
- assertThat(claimStatistic.getCounter(ClaimStatistic.Counter.IGNORED)).isEqualTo(8);
+ output = reporter.execute();
+ assertThat(output.getStatistic().getCounter(ClaimStatistic.Counter.STANDARDS)).isEqualTo(3);
+ assertThat(output.getStatistic().getCounter(ClaimStatistic.Counter.IGNORED)).isEqualTo(8);
});
}
- // include tests
- private void execIncludeTest(final Option option, final String[] args, boolean addIgnored) {
+ /**
+ * Runs the include tests.
+ * @param option The include option to run.
+ * @param args the arguments for the command line.
+ * @param includesRatDir @{code true} if the .rat directory was created.
+ */
+ private void execIncludeTest(final Option option, final String[] args, final boolean includesRatDir) {
Option excludeOption = Arg.EXCLUDE.option();
String[] notExcluded = {"B.bar", "justbaz", "notbaz"};
String[] excluded = {"some.foo"};
@@ -499,31 +509,31 @@ private void execIncludeTest(final Option option, final String[] args, boolean a
ReportConfiguration config = generateConfig(Collections.emptyList());
Reporter reporter = new Reporter(config);
- ClaimStatistic claimStatistic = reporter.execute();
- assertThat(claimStatistic.getCounter(ClaimStatistic.Counter.STANDARDS)).isEqualTo(4);
- assertThat(claimStatistic.getCounter(ClaimStatistic.Counter.IGNORED)).isEqualTo(addIgnored ? 1 : 0);
+ Reporter.Output output = reporter.execute();
+ assertThat(output.getStatistic().getCounter(ClaimStatistic.Counter.STANDARDS)).isEqualTo(4);
+
+ assertThat(output.getStatistic().getCounter(ClaimStatistic.Counter.IGNORED)).isEqualTo(includesRatDir ? 1 : 0);
// verify exclude removes most files.
config = generateConfig(ImmutablePair.of(excludeOption, EXCLUDE_ARGS));
reporter = new Reporter(config);
- claimStatistic = reporter.execute();
- assertThat(claimStatistic.getCounter(ClaimStatistic.Counter.STANDARDS)).isEqualTo(1);
+ output = reporter.execute();
+ assertThat(output.getStatistic().getCounter(ClaimStatistic.Counter.STANDARDS)).isEqualTo(1);
// .gitignore is ignored by default as it is hidden but not counted
- assertThat(claimStatistic.getCounter(ClaimStatistic.Counter.IGNORED)).isEqualTo(addIgnored ? 4 : 3);
+ assertThat(output.getStatistic().getCounter(ClaimStatistic.Counter.IGNORED)).isEqualTo(includesRatDir ? 4 : 3);
// verify include pust them back
config = generateConfig(ImmutablePair.of(option, args), ImmutablePair.of(excludeOption, EXCLUDE_ARGS));
reporter = new Reporter(config);
- claimStatistic = reporter.execute();
- assertThat(claimStatistic.getCounter(ClaimStatistic.Counter.STANDARDS)).isEqualTo(3);
+ output = reporter.execute();
+ assertThat(output.getStatistic().getCounter(ClaimStatistic.Counter.STANDARDS)).isEqualTo(3);
// .gitignore is ignored by default as it is hidden but not counted
- assertThat(claimStatistic.getCounter(ClaimStatistic.Counter.IGNORED)).isEqualTo(addIgnored ? 2 : 1);
+ assertThat(output.getStatistic().getCounter(ClaimStatistic.Counter.IGNORED)).isEqualTo(includesRatDir ? 2 : 1 );
});
}
private void includeFileTest(final Option option) {
- File ratDir = configureRatDir(option);
- File outputFile = FileUtils.writeFile(ratDir, "include.txt", Arrays.asList(INCLUDE_ARGS));
+ File outputFile = FileUtils.writeFile(configureRatDir(option), "include.txt", Arrays.asList(INCLUDE_ARGS));
execIncludeTest(option, new String[]{outputFile.getAbsolutePath()}, true);
}
@@ -569,15 +579,15 @@ protected void inputIncludeStdTest() {
ReportConfiguration config = generateConfig(Collections.singletonList(excludes));
Reporter reporter = new Reporter(config);
- ClaimStatistic claimStatistic = reporter.execute();
- assertThat(claimStatistic.getCounter(ClaimStatistic.Counter.STANDARDS)).isEqualTo(3);
- assertThat(claimStatistic.getCounter(ClaimStatistic.Counter.IGNORED)).isEqualTo(5);
+ Reporter.Output output = reporter.execute();
+ assertThat(output.getStatistic().getCounter(ClaimStatistic.Counter.STANDARDS)).isEqualTo(3);
+ assertThat(output.getStatistic().getCounter(ClaimStatistic.Counter.IGNORED)).isEqualTo(5);
config = generateConfig(excludes, ImmutablePair.of(option, args));
reporter = new Reporter(config);
- claimStatistic = reporter.execute();
- assertThat(claimStatistic.getCounter(ClaimStatistic.Counter.STANDARDS)).isEqualTo(7);
- assertThat(claimStatistic.getCounter(ClaimStatistic.Counter.IGNORED)).isEqualTo(1);
+ output = reporter.execute();
+ assertThat(output.getStatistic().getCounter(ClaimStatistic.Counter.STANDARDS)).isEqualTo(7);
+ assertThat(output.getStatistic().getCounter(ClaimStatistic.Counter.IGNORED)).isEqualTo(1);
});
}
@@ -594,15 +604,15 @@ protected void inputSourceTest() {
ReportConfiguration config = generateConfig();
Reporter reporter = new Reporter(config);
- ClaimStatistic claimStatistic = reporter.execute();
- assertThat(claimStatistic.getCounter(ClaimStatistic.Counter.STANDARDS)).isEqualTo(3);
- assertThat(claimStatistic.getCounter(ClaimStatistic.Counter.IGNORED)).isEqualTo(0);
+ Reporter.Output output = reporter.execute();
+ assertThat(output.getStatistic().getCounter(ClaimStatistic.Counter.STANDARDS)).isEqualTo(3);
+ assertThat(output.getStatistic().getCounter(ClaimStatistic.Counter.IGNORED)).isZero();
config = generateConfig(ImmutablePair.of(option, new String[]{inputFile.getAbsolutePath()}));
reporter = new Reporter(config);
- claimStatistic = reporter.execute();
- assertThat(claimStatistic.getCounter(ClaimStatistic.Counter.STANDARDS)).isEqualTo(1);
- assertThat(claimStatistic.getCounter(ClaimStatistic.Counter.IGNORED)).isEqualTo(0);
+ output = reporter.execute();
+ assertThat(output.getStatistic().getCounter(ClaimStatistic.Counter.STANDARDS)).isEqualTo(1);
+ assertThat(output.getStatistic().getCounter(ClaimStatistic.Counter.IGNORED)).isZero();
});
}
@@ -624,18 +634,18 @@ private void execLicenseFamiliesApprovedTest(final Option option, final String[]
ReportConfiguration config = addCatzLicense(generateConfig());
Reporter reporter = new Reporter(config);
- ClaimStatistic claimStatistic = reporter.execute();
+ Reporter.Output output = reporter.execute();
- assertThat(claimStatistic.getCounter(ClaimStatistic.Counter.STANDARDS)).isEqualTo(1);
- assertThat(claimStatistic.getCounter(ClaimStatistic.Counter.APPROVED)).isEqualTo(0);
- assertThat(claimStatistic.getCounter(ClaimStatistic.Counter.UNAPPROVED)).isEqualTo(1);
+ assertThat(output.getStatistic().getCounter(ClaimStatistic.Counter.STANDARDS)).isEqualTo(1);
+ assertThat(output.getStatistic().getCounter(ClaimStatistic.Counter.APPROVED)).isZero();
+ assertThat(output.getStatistic().getCounter(ClaimStatistic.Counter.UNAPPROVED)).isEqualTo(1);
config = addCatzLicense(generateConfig(arg1));
reporter = new Reporter(config);
- claimStatistic = reporter.execute();
- assertThat(claimStatistic.getCounter(ClaimStatistic.Counter.STANDARDS)).isEqualTo(1);
- assertThat(claimStatistic.getCounter(ClaimStatistic.Counter.APPROVED)).isEqualTo(1);
- assertThat(claimStatistic.getCounter(ClaimStatistic.Counter.UNAPPROVED)).isEqualTo(0);
+ output = reporter.execute();
+ assertThat(output.getStatistic().getCounter(ClaimStatistic.Counter.STANDARDS)).isEqualTo(1);
+ assertThat(output.getStatistic().getCounter(ClaimStatistic.Counter.APPROVED)).isEqualTo(1);
+ assertThat(output.getStatistic().getCounter(ClaimStatistic.Counter.UNAPPROVED)).isZero();
});
}
@@ -664,17 +674,17 @@ private void execLicenseFamiliesDeniedTest(final Option option, final String[] a
ReportConfiguration config = generateConfig();
Reporter reporter = new Reporter(config);
- ClaimStatistic claimStatistic = reporter.execute();
- assertThat(claimStatistic.getCounter(ClaimStatistic.Counter.STANDARDS)).isEqualTo(1);
- assertThat(claimStatistic.getCounter(ClaimStatistic.Counter.APPROVED)).isEqualTo(1);
- assertThat(claimStatistic.getCounter(ClaimStatistic.Counter.UNAPPROVED)).isEqualTo(0);
+ Reporter.Output output = reporter.execute();
+ assertThat(output.getStatistic().getCounter(ClaimStatistic.Counter.STANDARDS)).isEqualTo(1);
+ assertThat(output.getStatistic().getCounter(ClaimStatistic.Counter.APPROVED)).isEqualTo(1);
+ assertThat(output.getStatistic().getCounter(ClaimStatistic.Counter.UNAPPROVED)).isZero();
config = generateConfig(arg1);
reporter = new Reporter(config);
- claimStatistic = reporter.execute();
- assertThat(claimStatistic.getCounter(ClaimStatistic.Counter.STANDARDS)).isEqualTo(1);
- assertThat(claimStatistic.getCounter(ClaimStatistic.Counter.APPROVED)).isEqualTo(0);
- assertThat(claimStatistic.getCounter(ClaimStatistic.Counter.UNAPPROVED)).isEqualTo(1);
+ output = reporter.execute();
+ assertThat(output.getStatistic().getCounter(ClaimStatistic.Counter.STANDARDS)).isEqualTo(1);
+ assertThat(output.getStatistic().getCounter(ClaimStatistic.Counter.APPROVED)).isZero();
+ assertThat(output.getStatistic().getCounter(ClaimStatistic.Counter.UNAPPROVED)).isEqualTo(1);
});
}
@@ -705,26 +715,26 @@ private void configTest(final Option option) {
ReportConfiguration config = generateConfig();
Reporter reporter = new Reporter(config);
- ClaimStatistic claimStatistic = reporter.execute();
- assertThat(claimStatistic.getCounter(ClaimStatistic.Counter.STANDARDS)).isEqualTo(2);
- assertThat(claimStatistic.getCounter(ClaimStatistic.Counter.APPROVED)).isEqualTo(1);
- assertThat(claimStatistic.getCounter(ClaimStatistic.Counter.UNAPPROVED)).isEqualTo(1);
+ Reporter.Output output = reporter.execute();
+ assertThat(output.getStatistic().getCounter(ClaimStatistic.Counter.STANDARDS)).isEqualTo(2);
+ assertThat(output.getStatistic().getCounter(ClaimStatistic.Counter.APPROVED)).isEqualTo(1);
+ assertThat(output.getStatistic().getCounter(ClaimStatistic.Counter.UNAPPROVED)).isEqualTo(1);
config = generateConfig(arg1);
reporter = new Reporter(config);
- claimStatistic = reporter.execute();
- assertThat(claimStatistic.getCounter(ClaimStatistic.Counter.STANDARDS)).isEqualTo(2);
- assertThat(claimStatistic.getCounter(ClaimStatistic.Counter.APPROVED)).isEqualTo(2);
- assertThat(claimStatistic.getCounter(ClaimStatistic.Counter.UNAPPROVED)).isEqualTo(0);
+ output = reporter.execute();
+ assertThat(output.getStatistic().getCounter(ClaimStatistic.Counter.STANDARDS)).isEqualTo(2);
+ assertThat(output.getStatistic().getCounter(ClaimStatistic.Counter.APPROVED)).isEqualTo(2);
+ assertThat(output.getStatistic().getCounter(ClaimStatistic.Counter.UNAPPROVED)).isZero();
Pair arg2 = ImmutablePair.of(Arg.CONFIGURATION_NO_DEFAULTS.find("configuration-no-defaults"), null);
config = generateConfig(arg1, arg2);
reporter = new Reporter(config);
- claimStatistic = reporter.execute();
- assertThat(claimStatistic.getCounter(ClaimStatistic.Counter.STANDARDS)).isEqualTo(2);
- assertThat(claimStatistic.getCounter(ClaimStatistic.Counter.APPROVED)).isEqualTo(1);
- assertThat(claimStatistic.getCounter(ClaimStatistic.Counter.UNAPPROVED)).isEqualTo(1);
+ output = reporter.execute();
+ assertThat(output.getStatistic().getCounter(ClaimStatistic.Counter.STANDARDS)).isEqualTo(2);
+ assertThat(output.getStatistic().getCounter(ClaimStatistic.Counter.APPROVED)).isEqualTo(1);
+ assertThat(output.getStatistic().getCounter(ClaimStatistic.Counter.UNAPPROVED)).isEqualTo(1);
});
}
@@ -751,25 +761,24 @@ protected void execLicensesApprovedTest(final Option option, String[] args) {
ReportConfiguration config = generateConfig();
Reporter reporter = new Reporter(config);
- ClaimStatistic claimStatistic = reporter.execute();
- assertThat(claimStatistic.getCounter(ClaimStatistic.Counter.STANDARDS)).isEqualTo(2);
- assertThat(claimStatistic.getCounter(ClaimStatistic.Counter.APPROVED)).isEqualTo(1);
- assertThat(claimStatistic.getCounter(ClaimStatistic.Counter.UNAPPROVED)).isEqualTo(1);
+ Reporter.Output output = reporter.execute();
+ assertThat(output.getStatistic().getCounter(ClaimStatistic.Counter.STANDARDS)).isEqualTo(2);
+ assertThat(output.getStatistic().getCounter(ClaimStatistic.Counter.APPROVED)).isEqualTo(1);
+ assertThat(output.getStatistic().getCounter(ClaimStatistic.Counter.UNAPPROVED)).isEqualTo(1);
config = generateConfig(arg1);
reporter = new Reporter(config);
- claimStatistic = reporter.execute();
- assertThat(claimStatistic.getCounter(ClaimStatistic.Counter.STANDARDS)).isEqualTo(2);
- assertThat(claimStatistic.getCounter(ClaimStatistic.Counter.APPROVED)).isEqualTo(2);
- assertThat(claimStatistic.getCounter(ClaimStatistic.Counter.UNAPPROVED)).isEqualTo(0);
+ output = reporter.execute();
+ assertThat(output.getStatistic().getCounter(ClaimStatistic.Counter.STANDARDS)).isEqualTo(2);
+ assertThat(output.getStatistic().getCounter(ClaimStatistic.Counter.APPROVED)).isEqualTo(2);
+ assertThat(output.getStatistic().getCounter(ClaimStatistic.Counter.UNAPPROVED)).isZero();
});
}
@OptionCollectionTest.TestFunction
protected void licensesApprovedFileTest() {
Option option = Arg.LICENSES_APPROVED_FILE.find("licenses-approved-file");
- File ratDir = configureRatDir(option);
- File outputFile = FileUtils.writeFile(ratDir, "licensesApproved.txt", Collections.singletonList("GPL1"));
+ File outputFile = FileUtils.writeFile(configureRatDir(option), "licensesApproved.txt", Collections.singletonList("GPL1"));
execLicensesApprovedTest(option, new String[]{outputFile.getAbsolutePath()});
}
@@ -795,17 +804,17 @@ protected void scanHiddenDirectoriesTest() {
ReportConfiguration config = generateConfig();
Reporter reporter = new Reporter(config);
- ClaimStatistic claimStatistic = reporter.execute();
- assertThat(claimStatistic.getCounter(ClaimStatistic.Counter.STANDARDS)).isEqualTo(1);
- assertThat(claimStatistic.getCounter(ClaimStatistic.Counter.APPROVED)).isEqualTo(1);
- assertThat(claimStatistic.getCounter(ClaimStatistic.Counter.UNAPPROVED)).isEqualTo(0);
+ Reporter.Output output = reporter.execute();
+ assertThat(output.getStatistic().getCounter(ClaimStatistic.Counter.STANDARDS)).isEqualTo(1);
+ assertThat(output.getStatistic().getCounter(ClaimStatistic.Counter.APPROVED)).isEqualTo(1);
+ assertThat(output.getStatistic().getCounter(ClaimStatistic.Counter.UNAPPROVED)).isZero();
config = generateConfig(arg1);
reporter = new Reporter(config);
- claimStatistic = reporter.execute();
- assertThat(claimStatistic.getCounter(ClaimStatistic.Counter.STANDARDS)).isEqualTo(2);
- assertThat(claimStatistic.getCounter(ClaimStatistic.Counter.APPROVED)).isEqualTo(1);
- assertThat(claimStatistic.getCounter(ClaimStatistic.Counter.UNAPPROVED)).isEqualTo(1);
+ output = reporter.execute();
+ assertThat(output.getStatistic().getCounter(ClaimStatistic.Counter.STANDARDS)).isEqualTo(2);
+ assertThat(output.getStatistic().getCounter(ClaimStatistic.Counter.APPROVED)).isEqualTo(1);
+ assertThat(output.getStatistic().getCounter(ClaimStatistic.Counter.UNAPPROVED)).isEqualTo(1);
});
}
@@ -819,10 +828,11 @@ private void outTest(final Option option) {
ReportConfiguration config = generateConfig(ImmutablePair.of(option, args));
Reporter reporter = new Reporter(config);
- ClaimStatistic claimStatistic = reporter.output();
- assertThat(claimStatistic.getCounter(ClaimStatistic.Counter.STANDARDS)).isEqualTo(1);
- assertThat(claimStatistic.getCounter(ClaimStatistic.Counter.APPROVED)).isEqualTo(1);
- assertThat(claimStatistic.getCounter(ClaimStatistic.Counter.UNAPPROVED)).isEqualTo(0);
+ Reporter.Output output = reporter.execute();
+ output.format(config);
+ assertThat(output.getStatistic().getCounter(ClaimStatistic.Counter.STANDARDS)).isEqualTo(1);
+ assertThat(output.getStatistic().getCounter(ClaimStatistic.Counter.APPROVED)).isEqualTo(1);
+ assertThat(output.getStatistic().getCounter(ClaimStatistic.Counter.UNAPPROVED)).isZero();
String actualText = TextUtils.readFile(outFile);
TextUtils.assertContainsExactly(1, "Apache License 2.0: 1 ", actualText);
@@ -859,10 +869,11 @@ private void styleSheetTest(final Option option) {
args[0] = sheet.arg();
ReportConfiguration config = generateConfig(ImmutablePair.of(option, args));
Reporter reporter = new Reporter(config);
- ClaimStatistic claimStatistic = reporter.output();
- assertThat(claimStatistic.getCounter(ClaimStatistic.Counter.STANDARDS)).isEqualTo(1);
- assertThat(claimStatistic.getCounter(ClaimStatistic.Counter.APPROVED)).isEqualTo(0);
- assertThat(claimStatistic.getCounter(ClaimStatistic.Counter.UNAPPROVED)).isEqualTo(1);
+ Reporter.Output output = reporter.execute();
+ output.format(config);
+ assertThat(output.getStatistic().getCounter(ClaimStatistic.Counter.STANDARDS)).isEqualTo(1);
+ assertThat(output.getStatistic().getCounter(ClaimStatistic.Counter.APPROVED)).isZero();
+ assertThat(output.getStatistic().getCounter(ClaimStatistic.Counter.UNAPPROVED)).isEqualTo(1);
String actualText = baos.toString(StandardCharsets.UTF_8);
switch (sheet) {
@@ -880,6 +891,9 @@ private void styleSheetTest(final Option option) {
case UNAPPROVED_LICENSES:
TextUtils.assertContainsExactly(1, "Files with unapproved licenses:" + System.lineSeparator() + " /stylesheet", actualText);
break;
+ case XHTML5:
+ TextUtils.assertPatternInTarget("Approved<\\/td>\\s+ | \\d+<\\/td>\\s+ | A count of approved licenses.<\\/td>", actualText);
+ break;
default:
fail("No test for stylesheet " + sheet);
break;
@@ -889,10 +903,11 @@ private void styleSheetTest(final Option option) {
args[0] = file.getAbsolutePath();
ReportConfiguration config = generateConfig(ImmutablePair.of(option, args));
Reporter reporter = new Reporter(config);
- ClaimStatistic claimStatistic = reporter.output();
- assertThat(claimStatistic.getCounter(ClaimStatistic.Counter.STANDARDS)).isEqualTo(1);
- assertThat(claimStatistic.getCounter(ClaimStatistic.Counter.APPROVED)).isEqualTo(0);
- assertThat(claimStatistic.getCounter(ClaimStatistic.Counter.UNAPPROVED)).isEqualTo(1);
+ Reporter.Output output = reporter.execute();
+ output.format(config);
+ assertThat(output.getStatistic().getCounter(ClaimStatistic.Counter.STANDARDS)).isEqualTo(1);
+ assertThat(output.getStatistic().getCounter(ClaimStatistic.Counter.APPROVED)).isZero();
+ assertThat(output.getStatistic().getCounter(ClaimStatistic.Counter.UNAPPROVED)).isEqualTo(1);
String actualText = baos.toString(StandardCharsets.UTF_8);
TextUtils.assertContainsExactly(1, "Hello world", actualText);
@@ -931,15 +946,16 @@ protected void xmlTest() {
ReportConfiguration config = generateConfig(ImmutablePair.of(option, null));
Reporter reporter = new Reporter(config);
- ClaimStatistic claimStatistic = reporter.output();
- assertThat(claimStatistic.getCounter(ClaimStatistic.Counter.STANDARDS)).isEqualTo(1);
- assertThat(claimStatistic.getCounter(ClaimStatistic.Counter.APPROVED)).isEqualTo(0);
- assertThat(claimStatistic.getCounter(ClaimStatistic.Counter.UNAPPROVED)).isEqualTo(1);
+ Reporter.Output output = reporter.execute();
+ output.format(config);
+ assertThat(output.getStatistic().getCounter(ClaimStatistic.Counter.STANDARDS)).isEqualTo(1);
+ assertThat(output.getStatistic().getCounter(ClaimStatistic.Counter.APPROVED)).isZero();
+ assertThat(output.getStatistic().getCounter(ClaimStatistic.Counter.UNAPPROVED)).isEqualTo(1);
String actualText = baos.toString(StandardCharsets.UTF_8);
TextUtils.assertContainsExactly(1, "", actualText);
- try (InputStream expected = StyleSheets.getStyleSheet("xml").get();
+ try (InputStream expected = StyleSheets.getStyleSheet("xml", null).ioSupplier().get();
InputStream actual = config.getStyleSheet().get()) {
assertThat(IOUtils.contentEquals(expected, actual)).as("'xml' does not match").isTrue();
}
@@ -962,12 +978,12 @@ protected void logLevelTest() {
ReportConfiguration config = generateConfig();
Reporter reporter = new Reporter(config);
- reporter.output();
+ reporter.execute();
TextUtils.assertNotContains("DEBUG", baos.toString(StandardCharsets.UTF_8));
config = generateConfig(ImmutablePair.of(option, new String[]{"debug"}));
reporter = new Reporter(config);
- reporter.output();
+ reporter.execute();
TextUtils.assertContains("DEBUG", baos.toString(StandardCharsets.UTF_8));
} catch (IOException | RatException e) {
fail(e.getMessage(), e);
@@ -983,16 +999,11 @@ private void listLicenses(final Option option) {
assertDoesNotThrow(() -> {
configureSourceDir(option);
- File outFile = new File(sourceDir, "out.xml");
- FileUtils.delete(outFile);
- ImmutablePair outputFile = ImmutablePair.of(Arg.OUTPUT_FILE.option(), new String[]{outFile.getAbsolutePath()});
- ImmutablePair stylesheet = ImmutablePair.of(Arg.OUTPUT_STYLE.option(), new String[]{StyleSheets.XML.arg()});
for (LicenseSetFactory.LicenseFilter filter : LicenseSetFactory.LicenseFilter.values()) {
args[0] = filter.name();
- ReportConfiguration config = generateConfig(outputFile, stylesheet, ImmutablePair.of(option, args));
+ ReportConfiguration config = generateConfig(ImmutablePair.of(option, args));
Reporter reporter = new Reporter(config);
- reporter.output();
- Document document = XmlUtils.toDom(new FileInputStream(outFile));
+ Document document = reporter.execute().getDocument();
switch (filter) {
case ALL:
XmlUtils.assertIsPresent(filter.name(), document, xPath, "/rat-report/rat-config/licenses/license[@id='AL2.0']");
@@ -1029,16 +1040,12 @@ private void listFamilies(final Option option) {
assertDoesNotThrow(() -> {
configureSourceDir(option);
- File outFile = new File(sourceDir, "out.xml");
- FileUtils.delete(outFile);
- ImmutablePair outputFile = ImmutablePair.of(Arg.OUTPUT_FILE.option(), new String[]{outFile.getAbsolutePath()});
- ImmutablePair stylesheet = ImmutablePair.of(Arg.OUTPUT_STYLE.option(), new String[]{StyleSheets.XML.arg()});
for (LicenseSetFactory.LicenseFilter filter : LicenseSetFactory.LicenseFilter.values()) {
args[0] = filter.name();
- ReportConfiguration config = generateConfig(outputFile, stylesheet, ImmutablePair.of(option, args));
+ ReportConfiguration config = generateConfig(ImmutablePair.of(option, args));
Reporter reporter = new Reporter(config);
- reporter.output();
- Document document = XmlUtils.toDom(Files.newInputStream(outFile.toPath()));
+ Reporter.Output output = reporter.execute();
+ Document document = output.getDocument();
switch (filter) {
case ALL:
XmlUtils.assertIsPresent(filter.name(), document, xPath, "/rat-report/rat-config/families/family[@id='AL']");
@@ -1090,9 +1097,8 @@ private void archiveTest(final Option option) {
args[0] = proc.name();
ReportConfiguration config = generateConfig(outputFile, stylesheet, ImmutablePair.of(option, args));
Reporter reporter = new Reporter(config);
- reporter.output();
- Document document = XmlUtils.toDom(Files.newInputStream(outFile.toPath()));
+ Document document = reporter.execute().getDocument();
XmlUtils.assertIsPresent(proc.name(), document, xPath, "/rat-report/resource[@name='/dummy.jar']");
switch (proc) {
case ABSENCE:
@@ -1140,9 +1146,9 @@ private void standardTest(final Option option) {
args[0] = proc.name();
ReportConfiguration config = generateConfig(outputFile, stylesheet, ImmutablePair.of(option, args));
Reporter reporter = new Reporter(config);
- reporter.output();
+ Reporter.Output output = reporter.execute();
- Document document = XmlUtils.toDom(Files.newInputStream(outFile.toPath()));
+ Document document = output.getDocument();
XmlUtils.assertIsPresent(proc.name(), document, xPath, testDoc);
XmlUtils.assertIsPresent(proc.name(), document, xPath, missingDoc);
diff --git a/apache-rat-core/src/test/java/org/apache/rat/ReporterOptionsTest.java b/apache-rat-core/src/test/java/org/apache/rat/ReporterOptionsTest.java
index ccb82f3c6..4f52a31a5 100644
--- a/apache-rat-core/src/test/java/org/apache/rat/ReporterOptionsTest.java
+++ b/apache-rat-core/src/test/java/org/apache/rat/ReporterOptionsTest.java
@@ -27,7 +27,7 @@
import org.apache.rat.api.RatException;
import org.apache.rat.report.claim.ClaimStatistic;
import org.apache.rat.test.AbstractConfigurationOptionsProvider;
-import org.apache.rat.testhelpers.FileUtils;
+import org.apache.rat.utils.FileUtils;
import org.apache.rat.testhelpers.XmlUtils;
import org.apache.rat.utils.DefaultLog;
import org.apache.rat.utils.Log;
@@ -78,14 +78,14 @@ void testRat362() {
FileUtils.writeFile(testDir, "foo.md");
ReportConfiguration config = OptionCollection.parseCommands(testDir, args, o -> fail("Help called"), true);
Reporter reporter = new Reporter(config);
- ClaimStatistic claimStatistic = reporter.execute();
- XmlUtils.printDocument(System.out, reporter.getDocument());
+ Reporter.Output output = reporter.execute();
+ XmlUtils.printDocument(System.out, output.getDocument());
XPath xpath = XPathFactory.newInstance().newXPath();
- XmlUtils.assertIsPresent(reporter.getDocument(), xpath, "/rat-report/resource[@name='/foo.md']");
- XmlUtils.assertAttributes(reporter.getDocument(), xpath, "/rat-report/resource[@name='/foo.md']",
+ XmlUtils.assertIsPresent(output.getDocument(), xpath, "/rat-report/resource[@name='/foo.md']");
+ XmlUtils.assertAttributes(output.getDocument(), xpath, "/rat-report/resource[@name='/foo.md']",
XmlUtils.mapOf("type", "IGNORED"));
- assertThat(claimStatistic.getCounter(ClaimStatistic.Counter.STANDARDS)).isEqualTo(0);
- assertThat(claimStatistic.getCounter(ClaimStatistic.Counter.IGNORED)).isEqualTo(2);
+ assertThat(output.getStatistic().getCounter(ClaimStatistic.Counter.STANDARDS)).isEqualTo(0);
+ assertThat(output.getStatistic().getCounter(ClaimStatistic.Counter.IGNORED)).isEqualTo(2);
} catch (IOException | RatException | XPathExpressionException e) {
fail(e);
}
diff --git a/apache-rat-core/src/test/java/org/apache/rat/ReporterTest.java b/apache-rat-core/src/test/java/org/apache/rat/ReporterTest.java
index 3d9c84e7c..9472ba3df 100644
--- a/apache-rat-core/src/test/java/org/apache/rat/ReporterTest.java
+++ b/apache-rat-core/src/test/java/org/apache/rat/ReporterTest.java
@@ -7,7 +7,7 @@
* "License"); you may not use this file except in compliance *
* with the License. You may obtain a copy of the License at *
* *
- * http://www.apache.org/licenses/LICENSE-2.0 *
+ * https://www.apache.org/licenses/LICENSE-2.0 *
* *
* Unless required by applicable law or agreed to in writing, *
* software distributed under the License is distributed on an *
@@ -19,21 +19,28 @@
package org.apache.rat;
import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
import static org.assertj.core.api.Fail.fail;
-import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.File;
+import java.io.IOException;
import java.io.PrintStream;
+import java.lang.reflect.Method;
import java.net.URISyntaxException;
import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.nio.file.Path;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
+import java.util.Optional;
import java.util.TreeMap;
+import java.util.UUID;
+import java.util.stream.Stream;
import javax.xml.XMLConstants;
import javax.xml.transform.Source;
import javax.xml.transform.dom.DOMSource;
@@ -45,12 +52,10 @@
import javax.xml.xpath.XPathConstants;
import javax.xml.xpath.XPathFactory;
-import org.apache.commons.cli.CommandLine;
-import org.apache.commons.cli.DefaultParser;
-import org.apache.commons.cli.ParseException;
import org.apache.commons.io.FileUtils;
import org.apache.rat.api.Document.Type;
import org.apache.rat.api.RatException;
+import org.apache.rat.commandline.Arg;
import org.apache.rat.commandline.ArgumentContext;
import org.apache.rat.commandline.StyleSheets;
import org.apache.rat.document.FileDocument;
@@ -59,11 +64,21 @@
import org.apache.rat.license.LicenseSetFactory;
import org.apache.rat.report.claim.ClaimStatistic;
import org.apache.rat.test.utils.Resources;
+import org.apache.rat.testhelpers.BaseOptionCollection;
import org.apache.rat.testhelpers.TextUtils;
import org.apache.rat.testhelpers.XmlUtils;
+import org.apache.rat.testhelpers.data.ReportTestDataProvider;
+import org.apache.rat.testhelpers.data.TestData;
+import org.apache.rat.testhelpers.data.ValidatorData;
import org.apache.rat.walker.DirectoryWalker;
+import org.junit.jupiter.api.AfterAll;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
-import org.junit.jupiter.api.io.TempDir;
+import org.junit.jupiter.api.TestInfo;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.MethodSource;
import org.w3c.dom.Document;
import org.w3c.dom.NodeList;
import org.xml.sax.SAXException;
@@ -72,22 +87,62 @@
* Tests the output of the Reporter.
*/
public class ReporterTest {
- @TempDir
- File tempDirectory;
+ /**
+ * temporary file. Not using tempDir because it does not
+ * always work.
+ */
+ private static Path tempPath;
+
+ /**
+ * The directory for the test.
+ */
+ private Path testPath;
+
+ /**
+ * Directory for the test data.
+ */
final String basedir;
+ private final OptionCollectionParser collectionParser;
+
ReporterTest() throws URISyntaxException {
basedir = Resources.getExampleResource("exampleData").getPath();
+ collectionParser = new OptionCollectionParser(BaseOptionCollection.builder().build());
}
- @Test
- public void testExecute() throws RatException, ParseException {
- File output = new File(tempDirectory, "testExecute");
+ @BeforeAll
+ static void setUp() throws IOException {
+ tempPath = Files.createTempDirectory("ReporterTest");
+ }
+
+ @AfterAll
+ static void cleanup() throws IOException {
+ FileUtils.deleteDirectory(tempPath.toFile());
+ }
+
+ @BeforeEach
+ void setUpTest(TestInfo testInfo) {
+ Optional testMethod = testInfo.getTestMethod();
+ this.testPath = tempPath.resolve(testMethod.isPresent() ?
+ testMethod.get().getName() :
+ UUID.randomUUID().toString());
+ File file = testPath.toFile();
+ if (!file.exists()) {
+ if (!file.mkdirs()) {
+ throw new RuntimeException("Unable to create temp directory: " + file.getName());
+ }
+ } else {
+ if (!file.isDirectory()) {
+ throw new RuntimeException(file.getName() + " is NOT a directory.");
+ }
+ }
+ }
- CommandLine cl = new DefaultParser().parse(OptionCollection.buildOptions(), new String[]{"--output-style", "xml", "--output-file", output.getPath(), basedir});
- ArgumentContext ctxt = new ArgumentContext(new File("."), cl);
- ReportConfiguration config = OptionCollection.createConfiguration(ctxt);
- ClaimStatistic statistic = new Reporter(config).execute();
+ @Test
+ void testExecute() throws RatException {
+ File output = testPath.resolve("output.xml").toFile();
+ ArgumentContext ctxt = collectionParser.parseCommands(new File("."), new String[]{"--output-style", "xml", "--output-file", output.getPath(), basedir});
+ ClaimStatistic statistic = new Reporter(ctxt.getConfiguration()).execute().getStatistic();
assertThat(statistic.getCounter(Type.ARCHIVE)).isEqualTo(1);
assertThat(statistic.getCounter(Type.BINARY)).isEqualTo(2);
@@ -136,13 +191,10 @@ public void testExecute() throws RatException, ParseException {
}
@Test
- public void testOutputOption() throws Exception {
- File output = new File(tempDirectory, "test");
- CommandLine commandLine = new DefaultParser().parse(OptionCollection.buildOptions(), new String[]{"-o", output.getCanonicalPath(), basedir});
- ArgumentContext ctxt = new ArgumentContext(new File("."), commandLine);
-
- ReportConfiguration config = OptionCollection.createConfiguration(ctxt);
- new Reporter(config).output();
+ void testOutputOption() throws Exception {
+ File output = testPath.resolve("output.txt").toFile();
+ ArgumentContext ctxt = collectionParser.parseCommands(new File("."), new String[]{"--output-file", output.getCanonicalPath(), basedir});
+ new Reporter(ctxt.getConfiguration()).execute().format(ctxt.getConfiguration());
assertThat(output.exists()).isTrue();
String content = FileUtils.readFileToString(output, StandardCharsets.UTF_8);
TextUtils.assertPatternInTarget("^! Unapproved:\\s*2 ", content);
@@ -151,17 +203,14 @@ public void testOutputOption() throws Exception {
}
@Test
- public void testDefaultOutput() throws Exception {
- File output = new File(tempDirectory, "testDefaultOutput");
+ void testDefaultOutput() throws Exception {
+ File output = testPath.resolve("captured.txt").toFile();
PrintStream origin = System.out;
try (PrintStream out = new PrintStream(output)) {
System.setOut(out);
- CommandLine commandLine = new DefaultParser().parse(OptionCollection.buildOptions(), new String[]{basedir});
- ArgumentContext ctxt = new ArgumentContext(new File("."), commandLine);
-
- ReportConfiguration config = OptionCollection.createConfiguration(ctxt);
- new Reporter(config).output();
+ ArgumentContext ctxt = collectionParser.parseCommands(new File("."), new String[]{basedir});
+ new Reporter(ctxt.getConfiguration()).execute().format(ctxt.getConfiguration());
} finally {
System.setOut(origin);
}
@@ -179,7 +228,7 @@ private static Map mapOf(String... parts) {
}
@Test
- public void testXMLOutput() throws Exception {
+ void testXMLOutput() throws Exception {
Map> expected = new HashMap<>();
expected.put("/.hiddenDirectory", mapOf("isDirectory", "true", "mediaType", "application/octet-stream",
"type", "IGNORED"));
@@ -209,13 +258,10 @@ public void testXMLOutput() throws Exception {
expected.put("/tri.txt", mapOf("encoding", "ISO-8859-1", "mediaType", "text/plain",
"type", "STANDARD"));
- File output = new File(tempDirectory, ".rat/testXMLOutput");
+ File output = testPath.resolve(".rat/testXMLOutput").toFile();
output.getParentFile().mkdir();
- CommandLine commandLine = new DefaultParser().parse(OptionCollection.buildOptions(), new String[]{"--output-style", "xml", "--output-file", output.getPath(), basedir});
- ArgumentContext ctxt = new ArgumentContext(tempDirectory, commandLine);
-
- ReportConfiguration config = OptionCollection.createConfiguration(ctxt);
- new Reporter(config).output();
+ ArgumentContext ctxt = collectionParser.parseCommands(testPath.toFile(), new String[]{"--output-style", "xml", "--output-file", output.getPath(), basedir});
+ new Reporter(ctxt.getConfiguration()).execute().format(ctxt.getConfiguration());
assertThat(output).exists();
Document doc = XmlUtils.toDom(java.nio.file.Files.newInputStream(output.toPath()));
@@ -404,14 +450,9 @@ private Validator initValidator() throws SAXException {
}
@Test
- public void xmlReportTest() throws Exception {
- ByteArrayOutputStream out = new ByteArrayOutputStream();
-
+ void xmlReportTest() throws Exception {
ReportConfiguration configuration = initializeConfiguration();
- configuration.setStyleSheet(StyleSheets.XML.getStyleSheet());
- configuration.setOut(() -> out);
- new Reporter(configuration).output();
- Document doc = XmlUtils.toDom(new ByteArrayInputStream(out.toByteArray()));
+ Document doc = new Reporter(configuration).execute().getDocument();
XPath xPath = XPathFactory.newInstance().newXPath();
@@ -448,7 +489,7 @@ public void xmlReportTest() throws Exception {
}
@Test
- public void plainReportTest() throws Exception {
+ void plainReportTest() throws Exception {
final String NL = System.lineSeparator();
final String SEPARATOR = "*****************************************************";
final String HEADER = SEPARATOR + NL + //
@@ -457,10 +498,9 @@ public void plainReportTest() throws Exception {
"Generated at: ";
ByteArrayOutputStream out = new ByteArrayOutputStream();
ReportConfiguration configuration = initializeConfiguration();
- configuration.setOut(() -> out);
- new Reporter(configuration).output();
+ configuration.setOut(new ReportConfiguration.IODescriptor<>("plainReportTest", () -> out));
+ new Reporter(configuration).execute().format(configuration);
- out.flush();
String document = out.toString();
TextUtils.assertNotContains("", document);
@@ -470,14 +510,13 @@ public void plainReportTest() throws Exception {
}
@Test
- public void unapprovedLicensesReportTest() throws Exception {
+ void unapprovedLicensesReportTest() throws Exception {
ByteArrayOutputStream out = new ByteArrayOutputStream();
ReportConfiguration configuration = initializeConfiguration();
- configuration.setOut(() -> out);
+ configuration.setOut(new ReportConfiguration.IODescriptor<>("unapprovedLicensesReportTest", () -> out));
configuration.setStyleSheet(this.getClass().getResource("/org/apache/rat/unapproved-licenses.xsl"));
- new Reporter(configuration).output();
+ new Reporter(configuration).execute().format(configuration);
- out.flush();
String document = out.toString();
TextUtils.assertContains("Generated at: ", document );
@@ -489,44 +528,72 @@ public void unapprovedLicensesReportTest() throws Exception {
void listLicensesReportTest() throws Exception {
ByteArrayOutputStream out = new ByteArrayOutputStream();
ReportConfiguration configuration = initializeConfiguration();
- configuration.setOut(() -> out);
+ configuration.setOut(new ReportConfiguration.IODescriptor<>("listLicensesReportTest", () -> out));
configuration.setStyleSheet(StyleSheets.UNAPPROVED_LICENSES.getStyleSheet());
Reporter.listLicenses(configuration, LicenseSetFactory.LicenseFilter.NONE);
out.flush();
String document = out.toString();
-
assertThat(document).contains("Licenses (NONE):");
}
@Test
void counterMaxTest() throws Exception {
ReportConfiguration config = initializeConfiguration();
- Reporter reporter = new Reporter(config);
- reporter.output();
+ Reporter.Output output = new Reporter(config).execute();
assertThat(config.getClaimValidator().hasErrors()).isTrue();
- assertThat(config.getClaimValidator().isValid(ClaimStatistic.Counter.UNAPPROVED, reporter.getClaimsStatistic().getCounter(ClaimStatistic.Counter.UNAPPROVED)))
+ assertThat(config.getClaimValidator().isValid(ClaimStatistic.Counter.UNAPPROVED, output.getStatistic().getCounter(ClaimStatistic.Counter.UNAPPROVED)))
.isFalse();
config = initializeConfiguration();
config.getClaimValidator().setMax(ClaimStatistic.Counter.UNAPPROVED, 2);
- reporter = new Reporter(config);
- reporter.output();
+ output = new Reporter(config).execute();
assertThat(config.getClaimValidator().hasErrors()).isFalse();
- assertThat(config.getClaimValidator().isValid(ClaimStatistic.Counter.UNAPPROVED, reporter.getClaimsStatistic().getCounter(ClaimStatistic.Counter.UNAPPROVED)))
+ assertThat(config.getClaimValidator().isValid(ClaimStatistic.Counter.UNAPPROVED, output.getStatistic().getCounter(ClaimStatistic.Counter.UNAPPROVED)))
.isTrue();
}
+ static Stream getTestData() {
+ BaseOptionCollection.Builder builder = BaseOptionCollection.builder()
+ .unsupported(Arg.OUTPUT_FILE);
+ return new ReportTestDataProvider().getOptionTests(builder.build()).stream().map(testData ->
+ Arguments.of(testData.getTestName(), testData));
+ }
+
+ @ParameterizedTest( name = "{index} {0}")
+ @MethodSource("getTestData")
+ void testReportData(String name, TestData test) throws Exception {
+ Path invokePath = testPath.resolve(test.getTestName());
+ org.apache.rat.utils.FileUtils.mkDir(invokePath.toFile());
+
+ test.setupFiles(invokePath);
+ ArgumentContext ctxt = collectionParser.parseCommands(invokePath.toFile(),
+ test.getCommandLine(invokePath.toString()));
+ if (test.expectingException()) {
+ assertThatThrownBy(() -> new Reporter(ctxt.getConfiguration()).execute()).as("Expected throws from " + name)
+ .hasMessageContaining(test.getExpectedException().getMessage());
+ ValidatorData data = new ValidatorData(Reporter.Output.builder().configuration(ctxt.getConfiguration()).build(),
+ invokePath.toString());
+ test.getValidator().accept(data);
+ } else {
+ Reporter.Output output = ctxt.getConfiguration() != null ? new Reporter(ctxt.getConfiguration()).execute() :
+ Reporter.Output.builder().build();
+ ValidatorData data = new ValidatorData(output, invokePath.toString());
+ data.getOutput().format(data.getConfiguration());
+ test.getValidator().accept(data);
+ }
+ }
+
private record LicenseInfo(String id, String family, boolean approval, boolean hasNotes) {
- LicenseInfo(String id, boolean approval, boolean hasNotes) {
- this(id, id, approval, hasNotes);
- }
+ LicenseInfo(String id, boolean approval, boolean hasNotes) {
+ this(id, id, approval, hasNotes);
+ }
- private LicenseInfo(String id, String family, boolean approval, boolean hasNotes) {
- this.id = id;
- this.family = ILicenseFamily.makeCategory(family);
- this.approval = approval;
- this.hasNotes = hasNotes;
- }
+ private LicenseInfo(String id, String family, boolean approval, boolean hasNotes) {
+ this.id = id;
+ this.family = ILicenseFamily.makeCategory(family);
+ this.approval = approval;
+ this.hasNotes = hasNotes;
}
+ }
}
diff --git a/apache-rat-core/src/test/java/org/apache/rat/analysis/HeaderCheckWorkerTest.java b/apache-rat-core/src/test/java/org/apache/rat/analysis/HeaderCheckWorkerTest.java
index b00aec082..02a51085d 100644
--- a/apache-rat-core/src/test/java/org/apache/rat/analysis/HeaderCheckWorkerTest.java
+++ b/apache-rat-core/src/test/java/org/apache/rat/analysis/HeaderCheckWorkerTest.java
@@ -21,8 +21,11 @@
import java.io.StringReader;
-import java.util.Collections;
+import java.util.List;
+import java.util.SortedSet;
+import java.util.TreeSet;
+import org.apache.commons.collections4.set.UnmodifiableSortedSet;
import org.apache.rat.Defaults;
import org.apache.rat.api.Document;
import org.apache.rat.configuration.builders.AnyBuilder;
@@ -31,19 +34,25 @@
import org.apache.rat.license.ILicense;
import org.apache.rat.testhelpers.TestingLicense;
import org.apache.rat.testhelpers.TestingMatcher;
-import org.assertj.core.util.Lists;
import org.junit.jupiter.api.Test;
import static org.assertj.core.api.AssertionsForClassTypes.assertThat;
public class HeaderCheckWorkerTest {
+ /** Create an unmodifiable sorted set from members */
+ private UnmodifiableSortedSet asLicenses(ILicense... licenses) {
+ SortedSet inner = new TreeSet<>();
+ inner.addAll(List.of(licenses));
+ return (UnmodifiableSortedSet) UnmodifiableSortedSet.unmodifiableSortedSet(inner);
+ }
+
@Test
public void emptyInputIsUnknownTest() throws RatHeaderAnalysisException {
final Document subject = new TestingDocument("subject");
subject.getMetaData().setApprovalPredicate(Defaults.builder().build().getLicenseSetFactory().getApprovedLicensePredicate());
ILicense matcher = new TestingLicense("test", "test");
- HeaderCheckWorker worker = new HeaderCheckWorker(new TestingMatcher(), new StringReader(""), Lists.list(matcher), subject);
+ HeaderCheckWorker worker = new HeaderCheckWorker(new TestingMatcher(), new StringReader(""), asLicenses(matcher), subject);
worker.read();
assertThat(subject.getMetaData().unapprovedLicenses().count()).isEqualTo(1);
assertThat(subject.getMetaData().unapprovedLicenses().toList().get(0).getLicenseFamily()).isEqualTo(ILicenseFamily.UNKNOWN);
@@ -53,7 +62,7 @@ public void emptyInputIsUnknownTest() throws RatHeaderAnalysisException {
public void generatedFileDetectionTest() throws Exception {
final Document subject = new TestingDocument(new StringReader("Generated from configure.ac by autoheader"), "subject");
IHeaderMatcher matcher = new AnyBuilder().setResource("/org/apache/rat/generation-keywords.txt").build();
- HeaderCheckWorker worker = new HeaderCheckWorker(matcher, subject.reader(), Collections.emptyList(), subject);
+ HeaderCheckWorker worker = new HeaderCheckWorker(matcher, subject.reader(), asLicenses(), subject);
worker.read();
assertThat(subject.getMetaData().getDocumentType()).isEqualTo(Document.Type.IGNORED);
}
diff --git a/apache-rat-core/src/test/java/org/apache/rat/commandline/ArgTests.java b/apache-rat-core/src/test/java/org/apache/rat/commandline/ArgTests.java
index 742632c5a..bd8affac4 100644
--- a/apache-rat-core/src/test/java/org/apache/rat/commandline/ArgTests.java
+++ b/apache-rat-core/src/test/java/org/apache/rat/commandline/ArgTests.java
@@ -18,13 +18,8 @@
*/
package org.apache.rat.commandline;
-import org.apache.commons.cli.CommandLine;
-import org.apache.commons.cli.DefaultParser;
-import org.apache.commons.cli.Options;
import org.apache.commons.cli.ParseException;
import org.apache.rat.CLIOptionCollection;
-import org.apache.rat.DeprecationReporter;
-import org.apache.rat.OptionCollection;
import org.apache.rat.ReportConfiguration;
import org.apache.rat.document.DocumentName;
import org.junit.jupiter.params.ParameterizedTest;
@@ -37,12 +32,6 @@
public class ArgTests {
- private CommandLine createCommandLine(String[] args) throws ParseException {
- Options opts = OptionCollection.buildOptions();
- return DefaultParser.builder().setDeprecatedHandler(DeprecationReporter.getLogReporter())
- .setAllowPartialMatching(true).build().parse(opts, args);
- }
-
@ParameterizedTest(name = "{0}")
@ValueSource(strings = { "rat.txt", "./rat.txt", "/rat.txt", "target/rat.test" })
public void outputFileNameNoDirectoryTest(String name) throws ParseException {
@@ -62,9 +51,8 @@ public void setOut(File file) {
Path workingPath = localFile.getAbsoluteFile().toPath();
String expected = fsInfo.normalize(workingPath.resolve("./" + fileName).toString());
- CommandLine commandLine = createCommandLine(new String[]{"--output-file", fileName});
OutputFileConfig configuration = new OutputFileConfig();
- ArgumentContext ctxt = new ArgumentContext(localFile, configuration, commandLine);
+ ArgumentContext ctxt = new ArgumentContext(localFile, configuration, CLIOptionCollection.INSTANCE.getOptions(), new String[]{"--output-file", fileName});
Arg.processArgs(ctxt, CLIOptionCollection.INSTANCE);
if (name.equals("/rat.txt")) {
assertThat(fsInfo.normalize(configuration.actual.getAbsolutePath())).isEqualTo(localFileName.getRoot() + "rat.txt");
diff --git a/apache-rat-core/src/test/java/org/apache/rat/config/exclusion/ExclusionProcessorTest.java b/apache-rat-core/src/test/java/org/apache/rat/config/exclusion/ExclusionProcessorTest.java
index 19e2e1542..c30579431 100644
--- a/apache-rat-core/src/test/java/org/apache/rat/config/exclusion/ExclusionProcessorTest.java
+++ b/apache-rat-core/src/test/java/org/apache/rat/config/exclusion/ExclusionProcessorTest.java
@@ -18,6 +18,9 @@
*/
package org.apache.rat.config.exclusion;
+import java.io.ByteArrayInputStream;
+import java.io.StringWriter;
+import java.nio.charset.StandardCharsets;
import java.nio.file.FileSystems;
import java.nio.file.Path;
import java.util.ArrayList;
@@ -26,6 +29,9 @@
import org.apache.commons.io.FileUtils;
import org.apache.rat.document.DocumentNameMatcher;
import org.apache.rat.document.DocumentName;
+import org.apache.rat.report.xml.writer.XmlWriter;
+import org.apache.rat.utils.StandardXmlFactory;
+import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.io.TempDir;
import java.io.File;
@@ -37,6 +43,8 @@
import org.junit.jupiter.params.provider.Arguments;
import org.junit.jupiter.params.provider.MethodSource;
import org.mockito.Mockito;
+import org.w3c.dom.Document;
+import org.xml.sax.SAXException;
import static java.lang.String.format;
import static org.assertj.core.api.Assertions.assertThat;
@@ -264,4 +272,196 @@ private static Stream getDocumentNames() {
return lst.stream();
}
+
+ @Test
+ void addNullIncludedMatcherTest() {
+ ExclusionProcessor underTest = new ExclusionProcessor();
+ assertThat(underTest.getIncludedPaths()).isEmpty();
+ underTest.addIncludedMatcher(null);
+ assertThat(underTest.getIncludedPaths()).isEmpty();
+ underTest.addIncludedMatcher(DocumentNameMatcher.MATCHES_ALL)
+ .addIncludedMatcher(null);
+ assertThat(underTest.getIncludedPaths()).hasSize(1);
+ List actualPaths = underTest.getIncludedPaths().stream().map(DocumentNameMatcher::toString).toList();
+ assertThat(actualPaths).containsExactly(DocumentNameMatcher.MATCHES_ALL.toString());
+ }
+
+ @Test
+ void addNullExcludedMatcherTest() {
+ ExclusionProcessor underTest = new ExclusionProcessor();
+ assertThat(underTest.getExcludedPaths()).isEmpty();
+ underTest.addExcludedMatcher(null);
+ assertThat(underTest.getExcludedPaths()).isEmpty();
+ underTest.addExcludedMatcher(DocumentNameMatcher.MATCHES_ALL)
+ .addExcludedMatcher(null);
+ assertThat(underTest.getExcludedPaths()).hasSize(1);
+ List actualPaths = underTest.getExcludedPaths().stream().map(DocumentNameMatcher::toString).toList();
+ assertThat(actualPaths).containsExactly(DocumentNameMatcher.MATCHES_ALL.toString());
+ }
+
+ @Test
+ void addFileProcessor() {
+ ExclusionProcessor underTest = new ExclusionProcessor();
+ assertThat(underTest.getFileProcessors()).isEmpty();
+ underTest.addFileProcessor(null);
+ assertThat(underTest.getFileProcessors()).isEmpty();
+ underTest.addFileProcessor(StandardCollection.HIDDEN_FILE)
+ .addFileProcessor(null);
+ assertThat(underTest.getFileProcessors()).containsExactly(StandardCollection.HIDDEN_FILE);
+ }
+
+ @Test
+ void addNullIncludedPatternTest() {
+ ExclusionProcessor underTest = new ExclusionProcessor();
+ assertThat(underTest.getIncludedPatterns()).isEmpty();
+ underTest.addIncludedPatterns(null);
+ assertThat(underTest.getIncludedPatterns()).isEmpty();
+ underTest.addIncludedPatterns(Collections.emptyList());
+ assertThat(underTest.getIncludedPatterns()).isEmpty();
+ underTest.addIncludedPatterns(List.of("hello/world"))
+ .addIncludedPatterns(null)
+ .addIncludedPatterns(Collections.emptyList());
+ assertThat(underTest.getIncludedPatterns()).containsExactly("hello/world");
+ }
+
+ @Test
+ void addNullExcludedPatternTest() {
+ ExclusionProcessor underTest = new ExclusionProcessor();
+ assertThat(underTest.getExcludedPatterns()).isEmpty();
+ underTest.addExcludedPatterns(null);
+ assertThat(underTest.getExcludedPatterns()).isEmpty();
+ underTest.addExcludedPatterns(Collections.emptyList());
+ assertThat(underTest.getExcludedPatterns()).isEmpty();
+ underTest.addExcludedPatterns(List.of("hello/world"))
+ .addExcludedPatterns(null)
+ .addExcludedPatterns(Collections.emptyList());
+ assertThat(underTest.getExcludedPatterns()).containsExactly("hello/world");
+ }
+
+ public static void assertSame(ExclusionProcessor actual, ExclusionProcessor expected) {
+ assertThat(actual.getExcludedCollections()).containsExactlyElementsOf(expected.getExcludedCollections());
+ assertThat(actual.getFileProcessors()).containsExactlyElementsOf(expected.getFileProcessors());
+ assertThat(actual.getIncludedCollections()).containsExactlyElementsOf(expected.getIncludedCollections());
+ assertThat(actual.getExcludedPatterns()).containsExactlyElementsOf(expected.getExcludedPatterns());
+ assertThat(actual.getIncludedPatterns()).containsExactlyElementsOf(expected.getIncludedPatterns());
+
+ // paths only match on name. deserialized paths are not functional.
+ List actualPaths = actual.getExcludedPaths().stream().map(DocumentNameMatcher::toString).toList();
+ List expectedPaths = expected.getExcludedPaths().stream().map(DocumentNameMatcher::toString).toList();
+ assertThat(actualPaths).as("excluded paths").containsExactlyElementsOf(expectedPaths);
+
+ actualPaths = actual.getIncludedPaths().stream().map(DocumentNameMatcher::toString).toList();
+ expectedPaths = expected.getIncludedPaths().stream().map(DocumentNameMatcher::toString).toList();
+ assertThat(actualPaths).as("included paths").containsExactlyElementsOf(expectedPaths);
+ }
+
+ @ParameterizedTest
+ @MethodSource("serdeTestData")
+ void serdeTest(ExclusionProcessor underTest) throws IOException, SAXException {
+ StringWriter stringWriter = new StringWriter();
+ try (XmlWriter writer = new XmlWriter(stringWriter)) {
+ underTest.serde().serialize(writer);
+ }
+ Document document = StandardXmlFactory.documentBuilder().parse(new ByteArrayInputStream(stringWriter.toString().getBytes(StandardCharsets.UTF_8)));
+ ExclusionProcessor actual = new ExclusionProcessor();
+ actual.serde().deserialize(document.getElementsByTagName("ExclusionProcessor").item(0));
+ assertSame(actual, underTest);
+ }
+
+ static List serdeTestData() {
+ List tests = new ArrayList<>();
+ tests.add(new ExclusionProcessor());
+
+ // single exclusions
+ tests.add(new ExclusionProcessor()
+ .addExcludedPatterns(List.of("pattern/**")));
+
+ tests.add(new ExclusionProcessor()
+ .addExcludedCollection(StandardCollection.BAZAAR));
+
+
+ tests.add(new ExclusionProcessor()
+ .addExcludedMatcher(DocumentNameMatcher.MATCHES_ALL));
+
+ // single inclusions
+ tests.add(new ExclusionProcessor()
+ .addIncludedPatterns(List.of("pattern/**")));
+
+ tests.add(new ExclusionProcessor()
+ .addIncludedCollection(StandardCollection.BAZAAR));
+
+ tests.add(new ExclusionProcessor()
+ .addIncludedMatcher(DocumentNameMatcher.MATCHES_NONE));
+
+ // full population
+ tests.add(new ExclusionProcessor()
+ .addExcludedPatterns(List.of("pattern/**", "pattern2/**"))
+ .addExcludedCollection(StandardCollection.BAZAAR)
+ .addExcludedCollection(StandardCollection.MISC)
+ .addExcludedMatcher(DocumentNameMatcher.MATCHES_ALL)
+ .addIncludedPatterns(List.of("**/pattern3", "**/pattern4"))
+ .addIncludedCollection(StandardCollection.ARCH)
+ .addIncludedCollection(StandardCollection.BITKEEPER)
+ .addIncludedMatcher(DocumentNameMatcher.MATCHES_NONE));
+
+ return tests;
+ }
+
+ @Test
+ void reportExclusionsTest() throws IOException {
+ ExclusionProcessor underTest = new ExclusionProcessor()
+ .addExcludedPatterns(List.of("pattern/**", "pattern2/**"))
+ .addExcludedCollection(StandardCollection.BAZAAR)
+ .addExcludedCollection(StandardCollection.MISC)
+ .addFileProcessor(StandardCollection.HIDDEN_FILE)
+ .addExcludedMatcher(DocumentNameMatcher.MATCHES_ALL)
+ .addIncludedPatterns(List.of("**/pattern3", "**/pattern4"))
+ .addIncludedCollection(StandardCollection.ARCH)
+ .addIncludedCollection(StandardCollection.BITKEEPER)
+ .addIncludedMatcher(DocumentNameMatcher.MATCHES_NONE);
+
+ StringWriter writer = new StringWriter();
+ underTest.reportExclusions(writer);
+ String actual = writer.toString();
+
+ assertThat(actual).containsPattern("Excluding patterns:[^$]+\\Qpattern/**\\E")
+ .containsPattern("Excluding patterns:[^$]+\\Qpattern2/**\\E")
+ .containsPattern("Including patterns:[^$]+\\Q**/pattern3\\E")
+ .containsPattern("Including patterns:[^$]+\\Q**/pattern4\\E")
+ .contains("Excluding " + StandardCollection.BAZAAR + " collection.")
+ .contains("Excluding " + StandardCollection.MISC + " collection.")
+ .contains("Including " + StandardCollection.ARCH + " collection.")
+ .contains("Including " + StandardCollection.BITKEEPER + " collection.")
+ .contains("Processing exclude file from " + StandardCollection.HIDDEN_FILE)
+ .contains("Excluding " + DocumentNameMatcher.MATCHES_ALL + ".")
+ .contains("Including " + DocumentNameMatcher.MATCHES_NONE + ".");
+ }
+
+ @Test
+ void getNameMatcherTest() {
+ ExclusionProcessor underTest = new ExclusionProcessor()
+ .addExcludedPatterns(List.of("pattern/**", "pattern2/**"))
+ .addExcludedCollection(StandardCollection.BAZAAR)
+ .addExcludedCollection(StandardCollection.MISC)
+ .addFileProcessor(StandardCollection.HIDDEN_FILE)
+ .addExcludedMatcher(DocumentNameMatcher.MATCHES_ALL)
+ .addIncludedPatterns(List.of("**/pattern3", "**/pattern4"))
+ .addIncludedCollection(StandardCollection.ARCH)
+ .addIncludedCollection(StandardCollection.BITKEEPER)
+ .addIncludedMatcher(DocumentNameMatcher.MATCHES_NONE);
+
+ assertThat(underTest.getLastMatcherBaseDir()).isNull();
+ assertThat(underTest.getLastMatcher()).isNull();
+ DocumentName base = DocumentName.builder(new File(".")).build();
+
+ DocumentNameMatcher matcher = underTest.getNameMatcher(base);
+ assertThat(underTest.getLastMatcherBaseDir()).isEqualTo(base);
+ assertThat(underTest.getLastMatcher()).isEqualTo(matcher);
+
+ DocumentNameMatcher matcher2 = underTest.getNameMatcher(base);
+ assertThat(underTest.getLastMatcherBaseDir()).isEqualTo(base);
+ assertThat(underTest.getLastMatcher()).isEqualTo(matcher);
+ assertThat(underTest.getLastMatcherBaseDir()).isEqualTo(base);
+ assertThat(matcher2).isEqualTo(matcher);
+ }
}
diff --git a/apache-rat-core/src/test/java/org/apache/rat/configuration/XMLConfigurationReaderTest.java b/apache-rat-core/src/test/java/org/apache/rat/configuration/XMLConfigurationReaderTest.java
index f0779b31f..10c9759fb 100644
--- a/apache-rat-core/src/test/java/org/apache/rat/configuration/XMLConfigurationReaderTest.java
+++ b/apache-rat-core/src/test/java/org/apache/rat/configuration/XMLConfigurationReaderTest.java
@@ -52,6 +52,10 @@ public class XMLConfigurationReaderTest {
public static final String[] EXPECTED_LICENSES = {"AL1.0", "AL1.1", "AL2.0", "BSD-3", "DOJO", "TMF", "CDDL1", "ILLUMOS", "GPL1", "GPL2",
"GPL3", "MIT", "OASIS", "W3C", "W3CD"};
+ public static final String[] APPROVED_LICENSES = { "AL1.0", "AL1.1", "AL2.0", "BSD-3", "DOJO", "TMF", "CDDL1", "ILLUMOS",
+ "MIT", "OASIS", "W3C", "W3CD" };
+
+
@Test
void approvedLicenseIdTest() throws URISyntaxException {
XMLConfigurationReader reader = new XMLConfigurationReader();
@@ -59,9 +63,8 @@ void approvedLicenseIdTest() throws URISyntaxException {
assertThat(url).isNotNull();
reader.read(url.toURI());
- Collection readCategories = reader.approvedLicenseId();
- assertThat(readCategories.toArray(new String[readCategories.size()]))
- .containsExactly(APPROVED_IDS);
+ Collection actual = reader.approvedLicenseId();
+ assertThat(actual).containsExactlyInAnyOrder(APPROVED_IDS);
}
@Test
@@ -77,10 +80,12 @@ void LicensesTest() throws URISyntaxException {
void LicenseFamiliesTest() throws URISyntaxException {
XMLConfigurationReader reader = new XMLConfigurationReader();
URL url = XMLConfigurationReaderTest.class.getResource("/org/apache/rat/default.xml");
+ assertThat(url).isNotNull();
reader.read(url.toURI());
- assertThat(reader.readFamilies().stream().map(x -> x.getFamilyCategory().trim()).toArray(String[]::new))
- .containsExactly(EXPECTED_IDS);
+ Collection actual = reader.readFamilies().stream().map(lf -> lf.getFamilyCategory().trim())
+ .toList();
+ assertThat(actual).containsExactlyInAnyOrder(EXPECTED_IDS);
}
private void checkMatcher(String name, Class clazz) {
diff --git a/apache-rat-core/src/test/java/org/apache/rat/report/claim/ClaimStatisticTest.java b/apache-rat-core/src/test/java/org/apache/rat/report/claim/ClaimStatisticTest.java
new file mode 100644
index 000000000..ef8a31e2c
--- /dev/null
+++ b/apache-rat-core/src/test/java/org/apache/rat/report/claim/ClaimStatisticTest.java
@@ -0,0 +1,148 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one *
+ * or more contributor license agreements. See the NOTICE file *
+ * distributed with this work for additional information *
+ * regarding copyright ownership. The ASF licenses this file *
+ * to you under the Apache License, Version 2.0 (the *
+ * "License"); you may not use this file except in compliance *
+ * with the License. You may obtain a copy of the License at *
+ * *
+ * https://www.apache.org/licenses/LICENSE-2.0 *
+ * *
+ * Unless required by applicable law or agreed to in writing, *
+ * software distributed under the License is distributed on an *
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY *
+ * KIND, either express or implied. See the License for the *
+ * specific language governing permissions and limitations *
+ * under the License. *
+ */
+package org.apache.rat.report.claim;
+
+import org.apache.rat.api.Document;
+import org.junit.jupiter.api.Test;
+import java.io.ByteArrayInputStream;
+import java.io.IOException;
+import java.io.StringWriter;
+import java.nio.charset.StandardCharsets;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+public class ClaimStatisticTest {
+
+ @Test
+ void counterTests() {
+ ClaimStatistic underTest = new ClaimStatistic();
+ assertThat(underTest.getCounter(ClaimStatistic.Counter.APPROVED)).isZero();
+ underTest.incCounter(ClaimStatistic.Counter.APPROVED, 1);
+ assertThat(underTest.getCounter(ClaimStatistic.Counter.APPROVED)).isEqualTo(1);
+ underTest.incCounter(ClaimStatistic.Counter.APPROVED, -2);
+ assertThat(underTest.getCounter(ClaimStatistic.Counter.APPROVED)).isEqualTo(-1);
+ underTest.setCounter(ClaimStatistic.Counter.APPROVED, Integer.MAX_VALUE);
+ assertThat(underTest.getCounter(ClaimStatistic.Counter.APPROVED)).isEqualTo(Integer.MAX_VALUE);
+ }
+
+ @Test
+ void typeTests() {
+ ClaimStatistic underTest = new ClaimStatistic();
+ assertThat(underTest.getCounter(Document.Type.NOTICE)).isZero();
+ underTest.incCounter(Document.Type.NOTICE, 1);
+ assertThat(underTest.getCounter(Document.Type.NOTICE)).isEqualTo(1);
+ underTest.incCounter(Document.Type.NOTICE, -2);
+ assertThat(underTest.getCounter(Document.Type.NOTICE)).isEqualTo(-1);
+ }
+
+ @Test
+ void documentTypeTest() {
+ ClaimStatistic underTest = new ClaimStatistic();
+ assertThat(underTest.getDocumentTypes()).isEmpty();
+ underTest.incCounter(Document.Type.NOTICE, 1);
+ underTest.incCounter(Document.Type.BINARY, -1);
+ assertThat(underTest.getDocumentTypes()).containsExactly(Document.Type.BINARY, Document.Type.NOTICE);
+ }
+
+ @Test
+ void licenseCategoryCountTest() {
+ ClaimStatistic underTest = new ClaimStatistic();
+ assertThat(underTest.getLicenseCategoryCount("fam")).isZero();
+ underTest.incLicenseCategoryCount("fam", 1);
+ assertThat(underTest.getLicenseCategoryCount("fam")).isEqualTo(1);
+ underTest.incLicenseCategoryCount("fam", -2);
+ assertThat(underTest.getLicenseCategoryCount("fam")).isEqualTo(-1);
+ underTest.incLicenseCategoryCount("wayToLongAName", 5);
+ assertThat(underTest.getLicenseCategoryCount("wayToLongAName")).isEqualTo(5);
+ }
+
+ @Test
+ void licenseNameCountTest() {
+ ClaimStatistic underTest = new ClaimStatistic();
+ assertThat(underTest.getLicenseNameCount("fam")).isZero();
+ underTest.incLicenseNameCount("fam", 1);
+ assertThat(underTest.getLicenseNameCount("fam")).isEqualTo(1);
+ underTest.incLicenseNameCount("fam", -2);
+ assertThat(underTest.getLicenseNameCount("fam")).isEqualTo(-1);
+ }
+
+ @Test
+ void licenseFamilyCategoriesTest() {
+ ClaimStatistic underTest = new ClaimStatistic();
+ assertThat(underTest.getLicenseFamilyCategories()).isEmpty();
+ underTest.incLicenseCategoryCount("one", 1);
+ underTest.incLicenseCategoryCount("neg", -1);
+ assertThat(underTest.getLicenseFamilyCategories()).containsExactly("neg", "one");
+ underTest.incLicenseCategoryCount("wayToLongAName", 5);
+ assertThat(underTest.getLicenseFamilyCategories()).containsExactly("neg", "one", "wayToLongAName");
+ }
+
+ @Test
+ void licenseFamilyNameTest() {
+ ClaimStatistic underTest = new ClaimStatistic();
+ assertThat(underTest.getLicenseNames()).isEmpty();
+ underTest.incLicenseNameCount("one", 1);
+ underTest.incLicenseNameCount("neg", -1);
+ assertThat(underTest.getLicenseNames()).containsExactly("neg", "one");
+ underTest.incLicenseNameCount("wayToLongAName", 5);
+ assertThat(underTest.getLicenseNames()).containsExactly("neg", "one", "wayToLongAName");
+ }
+
+ /**
+ * Compares two claim statistics for similarity after serialization/deserialization.
+ * @param actual the deserialized verison.
+ * @param expected the original version.
+ */
+ public static void assertSame(final ClaimStatistic actual, final ClaimStatistic expected) {
+
+ assertThat(actual.getLicenseFamilyCategories()).containsExactlyElementsOf(expected.getLicenseFamilyCategories());
+ assertThat(actual.getLicenseNames()).containsExactlyElementsOf(expected.getLicenseNames());
+ assertThat(actual.getDocumentTypes()).containsExactlyElementsOf(expected.getDocumentTypes());
+ for (String cat : expected.getLicenseFamilyCategories()) {
+ assertThat(actual.getLicenseCategoryCount(cat)).isEqualTo(expected.getLicenseCategoryCount(cat));
+ }
+ for (String name : expected.getLicenseNames()) {
+ assertThat(actual.getLicenseNameCount(name)).isEqualTo(expected.getLicenseNameCount(name));
+ }
+ for (Document.Type type : expected.getDocumentTypes()) {
+ assertThat(actual.getCounter(type)).isEqualTo(expected.getCounter(type));
+ }
+ for (ClaimStatistic.Counter counter : ClaimStatistic.Counter.values()) {
+ assertThat(actual.getCounter(counter)).isEqualTo(expected.getCounter(counter));
+ }
+ }
+
+ @Test
+ void serdeRoundTrip() throws IOException {
+ ClaimStatistic underTest = new ClaimStatistic();
+ underTest.incLicenseCategoryCount("familyCagegory", 1);
+ underTest.incCounter(ClaimStatistic.Counter.APPROVED, 2);
+ underTest.incCounter(Document.Type.IGNORED, 3);
+ underTest.incLicenseNameCount("licenseName", 4);
+
+ ClaimStatistic.Serde serde = underTest.serde();
+ StringWriter stringWriter = new StringWriter();
+ serde.serialize(stringWriter);
+ ClaimStatistic actual = new ClaimStatistic();
+ ClaimStatistic.Serde serde2 = actual.serde();
+ serde2.deserialize(() -> new ByteArrayInputStream(stringWriter.toString().getBytes(StandardCharsets.UTF_8)));
+
+ assertSame(actual, underTest);
+ }
+}
diff --git a/apache-rat-core/src/test/java/org/apache/rat/report/xml/writer/impl/base/XmlWriterTest.java b/apache-rat-core/src/test/java/org/apache/rat/report/xml/writer/XmlWriterTest.java
similarity index 98%
rename from apache-rat-core/src/test/java/org/apache/rat/report/xml/writer/impl/base/XmlWriterTest.java
rename to apache-rat-core/src/test/java/org/apache/rat/report/xml/writer/XmlWriterTest.java
index 287db7677..b86ad72f0 100644
--- a/apache-rat-core/src/test/java/org/apache/rat/report/xml/writer/impl/base/XmlWriterTest.java
+++ b/apache-rat-core/src/test/java/org/apache/rat/report/xml/writer/XmlWriterTest.java
@@ -16,11 +16,8 @@
* specific language governing permissions and limitations *
* under the License. *
*/
-package org.apache.rat.report.xml.writer.impl.base;
+package org.apache.rat.report.xml.writer;
-import org.apache.rat.report.xml.writer.InvalidXmlException;
-import org.apache.rat.report.xml.writer.OperationNotAllowedException;
-import org.apache.rat.report.xml.writer.XmlWriter;
import org.apache.rat.testhelpers.XmlUtils;
import org.junit.jupiter.api.Test;
import org.w3c.dom.Document;
diff --git a/apache-rat-core/src/test/java/org/apache/rat/test/AbstractConfigurationOptionsProvider.java b/apache-rat-core/src/test/java/org/apache/rat/test/AbstractConfigurationOptionsProvider.java
index 5d34d80a8..5bee29740 100644
--- a/apache-rat-core/src/test/java/org/apache/rat/test/AbstractConfigurationOptionsProvider.java
+++ b/apache-rat-core/src/test/java/org/apache/rat/test/AbstractConfigurationOptionsProvider.java
@@ -19,6 +19,7 @@
package org.apache.rat.test;
import java.io.FileWriter;
+import java.nio.charset.StandardCharsets;
import java.nio.file.FileSystems;
import java.nio.file.Path;
import org.apache.commons.cli.Option;
@@ -80,7 +81,7 @@ public abstract class AbstractConfigurationOptionsProvider extends AbstractOptio
*/
public static void preserveData(File baseDir, String targetDir) {
final Path recordPath = FileSystems.getDefault().getPath("target", targetDir);
- org.apache.rat.testhelpers.FileUtils.mkDir(recordPath.toFile());
+ org.apache.rat.utils.FileUtils.mkDir(recordPath.toFile());
try {
FileUtils.copyDirectory(baseDir, recordPath.toFile());
} catch (IOException e) {
@@ -232,10 +233,10 @@ protected void inputExcludeParsedScmTest() {
writeFile(".gitignore", Arrays.asList(lines));
File dir = new File(baseDir, "red");
- org.apache.rat.testhelpers.FileUtils.mkDir(dir);
+ org.apache.rat.utils.FileUtils.mkDir(dir);
dir = new File(baseDir, "blue");
dir = new File(dir, "fish");
- org.apache.rat.testhelpers.FileUtils.mkDir(dir);
+ org.apache.rat.utils.FileUtils.mkDir(dir);
assertDoesNotThrow(() -> {
ReportConfiguration config = generateConfig(ImmutablePair.of(option, args));
@@ -815,12 +816,19 @@ private void styleSheetTest(final Option option) {
// run the test
String[] args = {null};
assertDoesNotThrow(() -> {
- for (String sheet : new String[]{"plain-rat", "missing-headers", "unapproved-licenses", file.getAbsolutePath()}) {
+ for (String sheet : new String[]{"plain-rat", "missing-headers", "unapproved-licenses", "stylesheet-" + option.getLongOpt()}) {
args[0] = sheet;
ReportConfiguration config = generateConfig(ImmutablePair.of(option, args));
- try (InputStream expected = StyleSheets.getStyleSheet(sheet).get();
+ DocumentName base = DocumentName.builder(baseDir).build();
+ DocumentName expectedName = base.resolve(sheet);
+ try (InputStream expected = StyleSheets.getStyleSheet(sheet, base).ioSupplier().get();
InputStream actual = config.getStyleSheet().get()) {
- assertThat(IOUtils.contentEquals(expected, actual)).as(() -> String.format("'%s' does not match", sheet)).isTrue();
+ String expectedStr = IOUtils.toString(expected, StandardCharsets.UTF_8);
+ String actualStr = IOUtils.toString(actual, StandardCharsets.UTF_8);
+ assertThat(actualStr).as(() -> String.format("'%s' does not match '%s': %s != %s",
+ config.getStyleSheetDescriptor().name(),
+ expectedName.getName(),
+ actualStr, expectedStr)).isEqualTo(expectedStr);
}
}
});
@@ -845,7 +853,7 @@ protected void scanHiddenDirectoriesTest() {
protected void xmlTest() {
assertDoesNotThrow(() -> {
ReportConfiguration config = generateConfig(ImmutablePair.of(Arg.OUTPUT_STYLE.find("xml"), null));
- try (InputStream expected = StyleSheets.getStyleSheet("xml").get();
+ try (InputStream expected = StyleSheets.getStyleSheet("xml", null).ioSupplier().get();
InputStream actual = config.getStyleSheet().get()) {
assertThat(IOUtils.contentEquals(expected, actual)).as("'xml' does not match").isTrue();
}
diff --git a/apache-rat-core/src/test/java/org/apache/rat/test/AbstractOptionsProvider.java b/apache-rat-core/src/test/java/org/apache/rat/test/AbstractOptionsProvider.java
index f4a188099..1f55d2ba0 100644
--- a/apache-rat-core/src/test/java/org/apache/rat/test/AbstractOptionsProvider.java
+++ b/apache-rat-core/src/test/java/org/apache/rat/test/AbstractOptionsProvider.java
@@ -170,7 +170,7 @@ public static String[] extractArgs(List> args) {
}
protected File writeFile(final String name, final Iterable lines) {
- return org.apache.rat.testhelpers.FileUtils.writeFile(baseDir, name, lines);
+ return org.apache.rat.utils.FileUtils.writeFile(baseDir, name, lines);
}
final protected DocumentName mkDocName(final String name) {
diff --git a/apache-rat-core/src/test/java/org/apache/rat/testhelpers/BaseOption.java b/apache-rat-core/src/test/java/org/apache/rat/testhelpers/BaseOption.java
new file mode 100644
index 000000000..4a22d9d7e
--- /dev/null
+++ b/apache-rat-core/src/test/java/org/apache/rat/testhelpers/BaseOption.java
@@ -0,0 +1,42 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one *
+ * or more contributor license agreements. See the NOTICE file *
+ * distributed with this work for additional information *
+ * regarding copyright ownership. The ASF licenses this file *
+ * to you under the Apache License, Version 2.0 (the *
+ * "License"); you may not use this file except in compliance *
+ * with the License. You may obtain a copy of the License at *
+ * *
+ * https://www.apache.org/licenses/LICENSE-2.0 *
+ * *
+ * Unless required by applicable law or agreed to in writing, *
+ * software distributed under the License is distributed on an *
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY *
+ * KIND, either express or implied. See the License for the *
+ * specific language governing permissions and limitations *
+ * under the License. *
+ */
+package org.apache.rat.testhelpers;
+
+import org.apache.commons.cli.Option;
+import org.apache.rat.ui.ArgumentTracker;
+import org.apache.rat.ui.UIOption;
+import org.apache.rat.ui.UIOptionCollection;
+import org.apache.rat.utils.CasedString;
+
+public final class BaseOption extends UIOption {
+ BaseOption(final UIOptionCollection collection, Option option) {
+ super(collection, option, new CasedString(CasedString.StringCase.KEBAB, ArgumentTracker.extractKey(option)));
+ }
+ protected String cleanupName(Option option) {
+ return ArgumentTracker.extractKey(option);
+ }
+
+ public String getExample() {
+ return "";
+ }
+
+ public String getText() {
+ return "";
+ }
+}
diff --git a/apache-rat-core/src/test/java/org/apache/rat/testhelpers/BaseOptionCollection.java b/apache-rat-core/src/test/java/org/apache/rat/testhelpers/BaseOptionCollection.java
new file mode 100644
index 000000000..3500c44d0
--- /dev/null
+++ b/apache-rat-core/src/test/java/org/apache/rat/testhelpers/BaseOptionCollection.java
@@ -0,0 +1,42 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one *
+ * or more contributor license agreements. See the NOTICE file *
+ * distributed with this work for additional information *
+ * regarding copyright ownership. The ASF licenses this file *
+ * to you under the Apache License, Version 2.0 (the *
+ * "License"); you may not use this file except in compliance *
+ * with the License. You may obtain a copy of the License at *
+ * *
+ * https://www.apache.org/licenses/LICENSE-2.0 *
+ * *
+ * Unless required by applicable law or agreed to in writing, *
+ * software distributed under the License is distributed on an *
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY *
+ * KIND, either express or implied. See the License for the *
+ * specific language governing permissions and limitations *
+ * under the License. *
+ */
+package org.apache.rat.testhelpers;
+
+import org.apache.rat.ui.UIOptionCollection;
+
+public final class BaseOptionCollection extends UIOptionCollection {
+ private BaseOptionCollection(Builder builder) {
+ super(builder);
+ }
+
+ public static Builder builder() {
+ return new Builder();
+ }
+
+ public static final class Builder extends UIOptionCollection.Builder {
+ private Builder() {
+ super(BaseOption::new);
+ }
+
+ @Override
+ public BaseOptionCollection build() {
+ return new BaseOptionCollection(this);
+ }
+ }
+}
diff --git a/apache-rat-core/src/test/java/org/apache/rat/testhelpers/TestingLog.java b/apache-rat-core/src/test/java/org/apache/rat/testhelpers/TestingLog.java
index 171cacacd..0298eb52c 100644
--- a/apache-rat-core/src/test/java/org/apache/rat/testhelpers/TestingLog.java
+++ b/apache-rat-core/src/test/java/org/apache/rat/testhelpers/TestingLog.java
@@ -26,6 +26,7 @@
public class TestingLog implements Log {
private StringBuilder captured = new StringBuilder();
+ private Log.Level level = Log.Level.INFO;
/**
* Clears the captured buffer
@@ -86,12 +87,18 @@ public void assertNotContainsPattern(String pattern) {
@Override
public Level getLevel() {
- return Level.DEBUG;
+ return level;
+ }
+
+ @Override
+ public void setLevel(Level level) {
+ this.level = level;
}
@Override
public void log(Level level, String msg) {
- captured.append(String.format("%s: %s%n", level, msg));
+ if (isEnabled(level))
+ captured.append(String.format("%s: %s%n", level, msg));
}
/**
diff --git a/apache-rat-core/src/test/java/org/apache/rat/testhelpers/TextUtils.java b/apache-rat-core/src/test/java/org/apache/rat/testhelpers/TextUtils.java
index e90a30b9c..72931b49e 100644
--- a/apache-rat-core/src/test/java/org/apache/rat/testhelpers/TextUtils.java
+++ b/apache-rat-core/src/test/java/org/apache/rat/testhelpers/TextUtils.java
@@ -40,7 +40,9 @@ public class TextUtils {
*
* @param pattern the pattern to match.
* @param target the string to match.
+ * @deprecated use assertThat(target).containsPattern(pattern)
*/
+ @Deprecated
public static void assertPatternInTarget(String pattern, String target) {
assertThat(isMatching(pattern, target)).as(() -> format("Target does not match string: %s%n%s", pattern, target))
.isTrue();
@@ -51,7 +53,9 @@ public static void assertPatternInTarget(String pattern, String target) {
*
* @param pattern the pattern to match.
* @param target the string to match.
+ * @deprecated use assertThat(target).dosNotContainPattern(pattern)
*/
+ @Deprecated
public static void assertPatternNotInTarget(String pattern, String target) {
assertThat(isMatching(pattern, target)).as(() -> format("Target matches the pattern: %s%n%s", pattern, target))
.isFalse();
@@ -63,7 +67,9 @@ public static void assertPatternNotInTarget(String pattern, String target) {
* @param pattern the pattern to match.
* @param target the string to match.
* @return {@code true} if a regular expression pattern is in a string
+ * @deprecated use assertThat(target).matches(pattern)
*/
+ @Deprecated
public static boolean isMatching(final String pattern, final String target) {
return Pattern.compile(pattern, Pattern.MULTILINE).matcher(target).find();
}
diff --git a/apache-rat-core/src/test/java/org/apache/rat/testhelpers/data/AbstractTestDataProvider.java b/apache-rat-core/src/test/java/org/apache/rat/testhelpers/data/AbstractTestDataProvider.java
new file mode 100644
index 000000000..d72ea19b5
--- /dev/null
+++ b/apache-rat-core/src/test/java/org/apache/rat/testhelpers/data/AbstractTestDataProvider.java
@@ -0,0 +1,201 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one *
+ * or more contributor license agreements. See the NOTICE file *
+ * distributed with this work for additional information *
+ * regarding copyright ownership. The ASF licenses this file *
+ * to you under the Apache License, Version 2.0 (the *
+ * "License"); you may not use this file except in compliance *
+ * with the License. You may obtain a copy of the License at *
+ * *
+ * http://www.apache.org/licenses/LICENSE-2.0 *
+ * *
+ * Unless required by applicable law or agreed to in writing, *
+ * software distributed under the License is distributed on an *
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY *
+ * KIND, either express or implied. See the License for the *
+ * specific language governing permissions and limitations *
+ * under the License. *
+ */
+package org.apache.rat.testhelpers.data;
+
+
+import com.google.common.collect.ImmutableList;
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.TreeMap;
+import java.util.TreeSet;
+import java.util.stream.Stream;
+import org.apache.commons.cli.Option;
+import org.apache.commons.lang3.tuple.ImmutablePair;
+import org.apache.rat.OptionCollectionParser;
+import org.apache.rat.commandline.Arg;
+import org.apache.rat.ui.UIOptionCollection;
+import org.apache.rat.ui.ArgumentTracker;
+import org.apache.rat.utils.DefaultLog;
+
+/**
+ * Generates a list of TestData for executing the Report.
+ * Use of this interface ensures consistent testing across the UIs. Each method
+ * tests an Option from {@link OptionCollectionParser} that must be implemented in the UI.
+ */
+public abstract class AbstractTestDataProvider {
+
+ /** The list of exclude args */
+ static final String[] EXCLUDE_ARGS = {"*.foo", "%regex[[A-Z]\\.bar]", "justbaz"};
+ /** the list of include args */
+ static final String[] INCLUDE_ARGS = {"B.bar", "justbaz"};
+ // Sonar suggests List of but we need an Immutable list.
+ public static final ImmutableList> NO_OPTIONS = ImmutableList.of(ImmutablePair.nullPair()); // NOSONAR
+
+ /**
+ * Generates a map of TestData indexed by the testName
+ * @param optionCollection the collection of options for the UI under test.
+ * @return the map of testName to Test Data.
+ */
+ public final Map getOptionTestMap(final UIOptionCollection optionCollection) {
+ Map map = new TreeMap<>();
+ for (TestData test : getOptionTests(optionCollection)) {
+ map.put(test.getTestName(), test);
+ }
+ return map;
+ }
+
+ /**
+ * Generates a list of test data for Option testing.
+ * This is different from UI testing as this is to test
+ * that the command line is properly parsed into a configuration.
+ * @param optionCollection the collection of options for the UI under test.
+ * @return a set of TestData for the tests.
+ */
+ public final Set getOptionTests(final UIOptionCollection optionCollection) {
+ // the optionCollection establishes any changes to the Arg values.
+ List |