Moved validation tool one level up, as it is now the sole content of this repository

src/main/java/de/kosit/validationtool/cmd/CheckAssertionAction.java

@@ -0,0 +1,132 @@
+/*
+ * Licensed to the Koordinierungsstelle für IT-Standards (KoSIT) under
+ * one or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  KoSIT 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 de.kosit.validationtool.cmd;
+
+import de.kosit.validationtool.cmd.assertions.AssertionType;
+import de.kosit.validationtool.cmd.assertions.Assertions;
+import de.kosit.validationtool.impl.model.Result;
+import de.kosit.validationtool.impl.tasks.CheckAction;
+import lombok.AccessLevel;
+import lombok.Getter;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import net.sf.saxon.s9api.*;
+import org.apache.commons.lang3.StringUtils;
+import org.w3c.dom.Document;
+
+import javax.xml.transform.dom.DOMSource;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * Überprüft den Report mittels bereitgestellter Assertions. Diese {@link CheckAction} dient der Überprüfung der von der
+ * KoSIT bereitgestellten Prüfszenarien und den darin enthaltenen Artefakten.
+ * 
+ * @author Andreas Penski
+ */
+@Slf4j
+@RequiredArgsConstructor
+public class CheckAssertionAction implements CheckAction {
+
+    private final Assertions assertions;
+
+    @Getter(AccessLevel.PRIVATE)
+    private final Processor processor;
+
+    private Map<String, List<AssertionType>> mappedAssertions;
+
+    private static boolean matches(String key, String name) {
+        return key.startsWith(name) || (name + ".xml").endsWith(key);
+    }
+
+    @Override
+    public void check(Bag results) {
+        log.info("Checking assertions for {}", results.getInput().getName());
+        final List<AssertionType> toCheck = findAssertions(results.getName());
+        final List<String> errors = new ArrayList<>();
+        if (toCheck != null && !toCheck.isEmpty()) {
+            final XdmNode node = loadDocument(results.getReport());
+            toCheck.forEach(a -> {
+                if (!check(node, a)) {
+                    log.error("Assertion mismatch: {}", a.getValue());
+                    errors.add(a.getValue());
+                }
+            });
+            if (errors.isEmpty()) {
+                log.info("{} assertions successfully verified for {}", toCheck.size(), results.getName());
+            } else {
+                log.warn("{} assertion of {} failed while checking {}", errors.size(), toCheck.size(), results.getName());
+            }
+            results.setAssertionResult(new Result<>(toCheck.size(), errors));
+        } else {
+            log.warn("Can not find assertions for {}", results.getName());
+        }
+    }
+
+    private List<AssertionType> findAssertions(String name) {
+        return getMapped().entrySet().stream().filter(e -> matches(e.getKey(), name)).map(Map.Entry::getValue).findFirst().orElse(null);
+    }
+
+    private XdmNode loadDocument(Document d) {
+        DocumentBuilder documentBuilder = getProcessor().newDocumentBuilder();
+        try {
+            return documentBuilder.build(new DOMSource(d));
+        } catch (SaxonApiException e) {
+            log.error("Can not load result document. Therefore can not run defined assertions", e);
+        }
+        return null;
+    }
+
+    private boolean check(XdmNode document, AssertionType assertion) {
+        try {
+            final XPathSelector selector = createSelector(assertion);
+            selector.setContextItem(document);
+            return selector.effectiveBooleanValue();
+        } catch (SaxonApiException e) {
+            log.error("Error evaluating assertion {} for {}", assertion.getTest(), assertion.getReportDoc(), e);
+        }
+        return false;
+
+    }
+
+    private XPathSelector createSelector(AssertionType assertion) throws SaxonApiException {
+        try {
+            final XPathCompiler compiler = getProcessor().newXPathCompiler();
+            assertions.getNamespace().forEach(ns -> compiler.declareNamespace(ns.getPrefix(), ns.getValue()));
+            return compiler.compile(assertion.getTest()).load();
+        } catch (SaxonApiException e) {
+            throw new IllegalStateException(String.format("Can not compile xpath match expression '%s'",
+                    StringUtils.isNotBlank(assertion.getTest()) ? assertion.getTest() : "EMPTY EXPRESSION"), e);
+        }
+    }
+
+    private Map<String, List<AssertionType>> getMapped() {
+        if (mappedAssertions == null) {
+            mappedAssertions = new HashMap<>();
+            for (AssertionType assertionType : assertions.getAssertion()) {
+                List<AssertionType> list = mappedAssertions.computeIfAbsent(assertionType.getReportDoc(), k -> new ArrayList<>());
+                list.add(assertionType);
+            }
+        }
+        return mappedAssertions;
+    }
+}