#730

Committed 23 Oct 2025 09:26AM UTC coverage: 86.354% (-0.06%) from 86.412%

Build # #730

Build Type

push

Committed by

Commit Message

Fix OR, AND and ContentType checkers

Run Details

15 of 34 new or added lines in 5 files covered. (44.12%)

1 existing line in 1 file now uncovered.

5670 of 6566 relevant lines covered (86.35%)

0.86 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

59.76

/src/main/java/de/gwdg/metadataqa/api/rule/logical/AndChecker.java

package de.gwdg.metadataqa.api.rule.logical;

import de.gwdg.metadataqa.api.counter.FieldCounter;
import de.gwdg.metadataqa.api.json.DataElement;
import de.gwdg.metadataqa.api.model.XmlFieldInstance;
import de.gwdg.metadataqa.api.model.selector.Selector;
import de.gwdg.metadataqa.api.rule.RuleChecker;
import de.gwdg.metadataqa.api.rule.RuleCheckerOutput;
import de.gwdg.metadataqa.api.rule.RuleCheckingOutputStatus;
import de.gwdg.metadataqa.api.rule.RuleCheckingOutputType;
import de.gwdg.metadataqa.api.rule.singlefieldchecker.DependencyChecker;
import de.gwdg.metadataqa.api.rule.singlefieldchecker.MinCountChecker;

import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.logging.Logger;

public class AndChecker extends LogicalChecker {

  private static final Logger LOGGER = Logger.getLogger(AndChecker.class.getCanonicalName());

  private static final long serialVersionUID = 1114999259831619599L;
  public static final String PREFIX = "and";
  private boolean priorityOnFail = false;

  /**
   * @param field The field
   * @param checkers The list of checkers
   */
  public AndChecker(DataElement field, List<RuleChecker> checkers) {
    this(field, field.getLabel(), checkers);
  }

  public AndChecker(DataElement field, String header, List<RuleChecker> checkers) {
    super(field,header + ":" + PREFIX + ":" + getChildrenHeader(checkers));
    this.checkers = checkers;
  }

  @Override
  public void update(Selector selector, FieldCounter<RuleCheckerOutput> results, RuleCheckingOutputType outputType) {
    if (isDebug())
      LOGGER.info(String.format("%s %s,  alwaysCheckDependencies: %s, priorityOnFail: %s", this.getClass().getSimpleName(), this.id, alwaysCheckDependencies, priorityOnFail));

    var allPassed = true;
    var isNA = false;
    List<RuleCheckingOutputStatus> statuses = new ArrayList<>();
    List<XmlFieldInstance> instances = selector.get(field);
    if (instances != null && !instances.isEmpty()) {
      FieldCounter<RuleCheckerOutput> localResults = new FieldCounter<>();
      for (RuleChecker checker : checkers) {
        if (checker instanceof DependencyChecker) {
          ((DependencyChecker) checker).update(selector, localResults, outputType, results);
        } else if (checker instanceof OrChecker) {
          ((OrChecker) checker).update(selector, localResults, outputType, results);
        } else if (checker instanceof NotChecker) {
          ((NotChecker) checker).update(selector, localResults, outputType, results);
        } else {
          checker.update(selector, localResults, outputType);
        }
        String key = outputType.equals(RuleCheckingOutputType.BOTH)
          ? checker.getIdOrHeader(RuleCheckingOutputType.SCORE)
          : checker.getIdOrHeader();
        RuleCheckingOutputStatus status = localResults.get(key).getStatus();
        statuses.add(status);
        if (status.equals(RuleCheckingOutputStatus.NA))
          isNA = true;

        if (!status.equals(RuleCheckingOutputStatus.PASSED) && !priorityOnFail) {
          allPassed = false;
          break;
        }
      }
    } else {
      if (isDebug())
        LOGGER.info("empty branch");
      isNA = true;
      for (RuleChecker checker : checkers) {
        if (checker instanceof MinCountChecker) {
          MinCountChecker minCountChecker = (MinCountChecker) checker;
          if (!minCountChecker.isEmptyInstancesAllowed() || minCountChecker.getMinCount() > 0)
            allPassed = false;
        }
        else if (alwaysCheckDependencies) {
          if (checker instanceof DependencyChecker) {
            DependencyChecker dependencyChecker = (DependencyChecker) checker;
            Map<String, Boolean> localResult = dependencyChecker.getResult(outputType, results);
            if (isDebug())
              LOGGER.info(String.format("DependencyChecker result for %s: %s",
                dependencyChecker.getDependencies(), localResult));
            allPassed = localResult.get("allPassed");
            isNA = localResult.get("isNA");
            statuses.add(allPassed ? RuleCheckingOutputStatus.PASSED : RuleCheckingOutputStatus.FAILED);
          } else if (checker instanceof OrChecker) {
            OrChecker orChecker = (OrChecker) checker;
            boolean hasDependency = false;
            for (RuleChecker current : orChecker.getCheckers()) {
              if (current instanceof DependencyChecker) {
                hasDependency = true;
                break;
              }
            }
            if (hasDependency) {
              orChecker.update(selector, results, outputType);
              Map<RuleCheckingOutputType, Object> orResult = orChecker.getResult(outputType, results);
              RuleCheckerOutput orStatus = (RuleCheckerOutput) orResult.get(RuleCheckingOutputType.STATUS);
              if (orStatus.getStatus().equals(RuleCheckingOutputStatus.FAILED)) {
                allPassed = false;
                isNA = false;
              }
            }
          }
        }

        // if (!allPassed)
        //  break;
      }
    }

    if (priorityOnFail) {
      allPassed = !statuses.contains(RuleCheckingOutputStatus.FAILED);
      if (!allPassed || statuses.contains(RuleCheckingOutputStatus.PASSED))
        isNA = false;
    }

    if (isDebug())
      LOGGER.info(String.format("isNA: %s, allPassed: %s", isNA, allPassed));
    addOutput(results, isNA, allPassed, outputType);

    if (isDebug())
      LOGGER.info(this.getClass().getSimpleName() + " " + this.id + ") result: " + RuleCheckingOutputStatus.create(isNA, allPassed, isMandatory()));
  }

  public void setPriorityOnFail(boolean priorityOnFail) {
    this.priorityOnFail = priorityOnFail;
  }
}

1	package de.gwdg.metadataqa.api.rule.logical;
2
3	import de.gwdg.metadataqa.api.counter.FieldCounter;
4	import de.gwdg.metadataqa.api.json.DataElement;
5	import de.gwdg.metadataqa.api.model.XmlFieldInstance;
6	import de.gwdg.metadataqa.api.model.selector.Selector;
7	import de.gwdg.metadataqa.api.rule.RuleChecker;
8	import de.gwdg.metadataqa.api.rule.RuleCheckerOutput;
9	import de.gwdg.metadataqa.api.rule.RuleCheckingOutputStatus;
10	import de.gwdg.metadataqa.api.rule.RuleCheckingOutputType;
11	import de.gwdg.metadataqa.api.rule.singlefieldchecker.DependencyChecker;
12	import de.gwdg.metadataqa.api.rule.singlefieldchecker.MinCountChecker;
13
14	import java.util.ArrayList;
15	import java.util.List;
16	import java.util.Map;
17	import java.util.logging.Logger;
18
19	public class AndChecker extends LogicalChecker {
20
21	private static final Logger LOGGER = Logger.getLogger(AndChecker.class.getCanonicalName());	1✔
22
23	private static final long serialVersionUID = 1114999259831619599L;
24	public static final String PREFIX = "and";
25	private boolean priorityOnFail = false;	1✔
26
27	/**
28	* @param field The field
29	* @param checkers The list of checkers
30	*/
31	public AndChecker(DataElement field, List<RuleChecker> checkers) {
32	this(field, field.getLabel(), checkers);	1✔
33	}	1✔
34
35	public AndChecker(DataElement field, String header, List<RuleChecker> checkers) {
36	super(field,header + ":" + PREFIX + ":" + getChildrenHeader(checkers));	1✔
37	this.checkers = checkers;	1✔
38	}	1✔
39
40	@Override
41	public void update(Selector selector, FieldCounter<RuleCheckerOutput> results, RuleCheckingOutputType outputType) {
42	if (isDebug())	1✔
43	LOGGER.info(String.format("%s %s, alwaysCheckDependencies: %s, priorityOnFail: %s", this.getClass().getSimpleName(), this.id, alwaysCheckDependencies, priorityOnFail));	1✔
44
45	var allPassed = true;	1✔
46	var isNA = false;	1✔
47	List<RuleCheckingOutputStatus> statuses = new ArrayList<>();	1✔
48	List<XmlFieldInstance> instances = selector.get(field);	1✔
49	if (instances != null && !instances.isEmpty()) {	1✔
50	FieldCounter<RuleCheckerOutput> localResults = new FieldCounter<>();	1✔
51	for (RuleChecker checker : checkers) {	1✔
52	if (checker instanceof DependencyChecker) {	1✔
53	((DependencyChecker) checker).update(selector, localResults, outputType, results);	1✔
54	} else if (checker instanceof OrChecker) {	1✔
55	((OrChecker) checker).update(selector, localResults, outputType, results);	×
56	} else if (checker instanceof NotChecker) {	1✔
57	((NotChecker) checker).update(selector, localResults, outputType, results);	×
58	} else {
59	checker.update(selector, localResults, outputType);	1✔
60	}
61	String key = outputType.equals(RuleCheckingOutputType.BOTH)	1✔
62	? checker.getIdOrHeader(RuleCheckingOutputType.SCORE)	1✔
63	: checker.getIdOrHeader();	1✔
64	RuleCheckingOutputStatus status = localResults.get(key).getStatus();	1✔
65	statuses.add(status);	1✔
66	if (status.equals(RuleCheckingOutputStatus.NA))	1✔
67	isNA = true;	×
68
69	if (!status.equals(RuleCheckingOutputStatus.PASSED) && !priorityOnFail) {	1✔
70	allPassed = false;	1✔
71	break;	1✔
72	}
73	}	1✔
74	} else {	1✔
75	if (isDebug())	1✔
76	LOGGER.info("empty branch");	×
77	isNA = true;	1✔
78	for (RuleChecker checker : checkers) {	1✔
79	if (checker instanceof MinCountChecker) {	1✔
80	MinCountChecker minCountChecker = (MinCountChecker) checker;	1✔
81	if (!minCountChecker.isEmptyInstancesAllowed() \|\| minCountChecker.getMinCount() > 0)	1✔
82	allPassed = false;	1✔
83	}	1✔
84	else if (alwaysCheckDependencies) {	1✔
85	if (checker instanceof DependencyChecker) {	×
86	DependencyChecker dependencyChecker = (DependencyChecker) checker;	×
87	Map<String, Boolean> localResult = dependencyChecker.getResult(outputType, results);	×
88	if (isDebug())	×
NEW 89	LOGGER.info(String.format("DependencyChecker result for %s: %s",	×
NEW 90	dependencyChecker.getDependencies(), localResult));	×
91	allPassed = localResult.get("allPassed");	×
92	isNA = localResult.get("isNA");	×
NEW 93	statuses.add(allPassed ? RuleCheckingOutputStatus.PASSED : RuleCheckingOutputStatus.FAILED);	×
94	} else if (checker instanceof OrChecker) {	×
95	OrChecker orChecker = (OrChecker) checker;	×
96	boolean hasDependency = false;	×
97	for (RuleChecker current : orChecker.getCheckers()) {	×
98	if (current instanceof DependencyChecker) {	×
99	hasDependency = true;	×
100	break;	×
101	}
102	}	×
103	if (hasDependency) {	×
104	orChecker.update(selector, results, outputType);	×
105	Map<RuleCheckingOutputType, Object> orResult = orChecker.getResult(outputType, results);	×
106	RuleCheckerOutput orStatus = (RuleCheckerOutput) orResult.get(RuleCheckingOutputType.STATUS);	×
107	if (orStatus.getStatus().equals(RuleCheckingOutputStatus.FAILED)) {	×
108	allPassed = false;	×
109	isNA = false;	×
110	}
111	}
112	}
113	}
114
115	// if (!allPassed)
116	// break;
117	}	1✔
118	}
119
120	if (priorityOnFail) {	1✔
121	allPassed = !statuses.contains(RuleCheckingOutputStatus.FAILED);	×
122	if (!allPassed \|\| statuses.contains(RuleCheckingOutputStatus.PASSED))	×
123	isNA = false;	×
124	}
125
126	if (isDebug())	1✔
127	LOGGER.info(String.format("isNA: %s, allPassed: %s", isNA, allPassed));	1✔
128	addOutput(results, isNA, allPassed, outputType);	1✔
129
130	if (isDebug())	1✔
131	LOGGER.info(this.getClass().getSimpleName() + " " + this.id + ") result: " + RuleCheckingOutputStatus.create(isNA, allPassed, isMandatory()));	1✔
132	}	1✔
133
134	public void setPriorityOnFail(boolean priorityOnFail) {
135	this.priorityOnFail = priorityOnFail;	×
136	}	×
137	}

pkiraly / metadata-qa-api / #730

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous