public Requirement withParent(String parent) { return new Requirement(this.name, this.displayName, this.cardNumber, parent, this.type, this.narrative, children, examples, releaseVersions, customFields, featureFileName); }
@Override public boolean equals(Object o) { if (this == o) return true; if (o == null || getClass() != o.getClass()) return false; RequirementOutcome that = (RequirementOutcome) o; return requirement != null ? requirement.equals(that.requirement) : that.requirement == null; }
public String qualifier() { if (getCardNumber() != null) { return getCardNumber(); } return (getParent() != null) ? getParent() : null; }
private List<Requirement> addParentsTo(List<Requirement> requirements, String parent) { List<Requirement> augmentedRequirements = Lists.newArrayList(); for (Requirement requirement : requirements) { List<Requirement> children = requirement.hasChildren() ? addParentsTo(requirement.getChildren(), requirement.getName()) : NO_REQUIREMENTS; augmentedRequirements.add(requirement.withParent(parent).withChildren(children)); } return augmentedRequirements; }
public List<Requirement> in(Collection<Requirement> requirements) { List<Requirement> children = new ArrayList<>(); for (Requirement requirement : requirements) { if (isNotEmpty(requirement.getParent()) && requirement.getParent().equals(parent.getName())) { children.add(requirement); } } return children; } }
private Optional<Requirement> findMatchingRequirementWithName(Collection<Requirement> knownRequirements, String featureName, String featureType) { for(Requirement requirement : knownRequirements) { if (requirement.getName().equalsIgnoreCase(featureName) && requirement.getType().equalsIgnoreCase(featureType)) { return Optional.of(requirement); } } return Optional.empty(); }
public boolean matchesTag(TestTag testTag) { TestTag requirementTag = asTag(); return requirementTag.isAsOrMoreSpecificThan(testTag); }
private Node toNode(Requirement requirement,RequirementsOutcomes requirementsOutcomes) { List<Node> children = requirement.getChildren().stream() .map(child -> toNode(child, requirementsOutcomes)) .distinct() .collect(Collectors.toList()); TestResult result = matchingOutcome(requirement, requirementsOutcomes); String label = new ResultIconFormatter().forResult(result); String childCount = (children.isEmpty()) ? countScenariosIn(requirement, requirementsOutcomes) : countChildRequirementsIn(requirement); String report = new ReportNameProvider().forRequirement(requirement); return new Node(requirement.getName(), requirement.getType(), report, label, childCount, children); }
private List<List<String>> getReleaseVersionsFrom(List<Requirement> requirements) { List<List<String>> releaseVersions = newArrayList(); for (Requirement requirement : requirements) { releaseVersions.add(requirement.getReleaseVersions()); releaseVersions.addAll(getReleaseVersionsFrom(requirement.getChildren())); } return releaseVersions; }
private List<Requirement> getFlattenedRequirements(Requirement rootRequirement) { List<Requirement> flattenedRequirements = Lists.newArrayList(); flattenedRequirements.add(rootRequirement); flattenedRequirements.addAll(rootRequirement.getNestedChildren()); return flattenedRequirements; }
public Requirement setTo(String value, String renderedValue) { List<CustomFieldValue> customFields = new ArrayList(requirement.getCustomFieldValues()); customFields.add(new CustomFieldValue(fieldName, value, renderedValue)); return new Requirement(requirement.name, requirement.id, requirement.displayName, requirement.cardNumber, requirement.parent, requirement.type, requirement.path, requirement.narrative, requirement.children, requirement.examples, requirement.releaseVersions, customFields).withTags(requirement.tags); }
public String toString() { ByteArrayOutputStream printedRequirement = new ByteArrayOutputStream(); PrintStream printStream = new PrintStream(printedRequirement); printStream.println(indent + "- " + requirement.getType() + ": " + requirement.getDisplayName()); for(Requirement child : requirement.getChildren()) { printStream.print(stringFormOf(child).withIndentationLevel(level + 1)); } return printedRequirement.toString(); } }
private void indexRequirements() { requirementAncestors = Maps.newHashMap(); for (Requirement requirement : requirements) { List<Requirement> requirementPath = ImmutableList.of(requirement); requirementAncestors.put(requirement, ImmutableList.of(requirement)); LOGGER.info("Requirement ancestors for:" + requirement + " = " + requirementPath); indexChildRequirements(requirementPath, requirement.getChildren()); } }
public Requirement setTo(String value, String renderedValue) { List<CustomFieldValue> customFields = Lists.newArrayList(requirement.getCustomFieldValues()); customFields.add(new CustomFieldValue(fieldName, value, renderedValue)); return new Requirement(requirement.name, requirement.displayName, requirement.cardNumber, requirement.parent, requirement.type, requirement.narrative, requirement.children, requirement.examples, requirement.releaseVersions, customFields); }
public TestOutcomes forRequirement(Requirement requirement) { Set<TestOutcome> testOutcomesForThisRequirement = new HashSet(); for(Requirement childRequirement : RequirementsTree.forRequirement(requirement).asFlattenedList()) { testOutcomesForThisRequirement.addAll( withTag(childRequirement.asTag()).getOutcomes() ); if (childRequirement.getCardNumber() != null) { testOutcomesForThisRequirement.addAll( withCardNumber(childRequirement.getCardNumber()).getOutcomes() ); } } return TestOutcomes.of(testOutcomesForThisRequirement) .withLabel(requirement.getDisplayName()) .withTestTag(requirement.asTag()) .withRootOutcomes(getRootOutcomes()); }
private String typeOfFirstChildPresent() { for (RequirementOutcome outcome : requirementOutcomes) { if (!outcome.getRequirement().getChildren().isEmpty()) { Requirement firstChildRequirement = outcome.getRequirement().getChildren().get(0); return firstChildRequirement.getType(); } } return null; }
public void in(Collection<Requirement> requirements) { Requirement ancestor = parent; Requirement immediateDescendant = child; while(ancestor != null) { Requirement updatedAncestor = ancestor.withChild(immediateDescendant); replaceIn(requirements, ancestor, updatedAncestor); immediateDescendant = updatedAncestor; ancestor = requirementCalled(ancestor.getParent(), requirements); } }
private List<TestTag> getMatchingCapabilities(List<Requirement> requirements, List<String> storyPathElements) { if (storyPathElements.isEmpty()) { return NO_TEST_TAGS; } else { java.util.Optional<Requirement> matchingRequirement = findMatchingRequirementIn(next(storyPathElements), requirements); if (matchingRequirement.isPresent()) { TestTag thisTag = matchingRequirement.get().asTag(); List<TestTag> remainingTags = getMatchingCapabilities(matchingRequirement.get().getChildren(), tail(storyPathElements)); return concat(thisTag, remainingTags); } else { return NO_TEST_TAGS; } } }