private java.util.Optional<Requirement> uniqueRequirementWithName(String name) { return RequirementsList.of(getRequirements()).findByUniqueName(name); }
private void loadRequirementsFromClasses(List<Class<?>> classes) { int maxDepth = maximumClassDepth(classes,rootPackage); for (Class candidateClass : classes) { addRequirementTo(requirementsByPath, candidateClass, maxDepth); } leafRequirements = findLeafRequirementsIn(requirementsByPath); persistRequirementsAsJSON(requirementsByPath); }
private Map<Requirement, List<Requirement>> getRequirementAncestors() { if (requirementAncestors == null) { getRequirements(); } return requirementAncestors; }
private List<Requirement> readChildrenFrom(File requirementDirectory) { String childDirectory = rootDirectoryPath + "/" + requirementDirectory.getName(); RequirementsTagProvider childReader = new FileSystemRequirementsTagProvider(childDirectory, level + 1, environmentVariables); return childReader.getRequirements(); }
public static List<String> stripRootFromPath(String root, List<String> storyPathElements) { List<String> rootElements = pathElements(root); if (thePathIn(storyPathElements).startsWith(rootElements)) { return storyPathElements.subList(rootElements.size(), storyPathElements.size()); } else { return storyPathElements; } }
private boolean isMatchingRequirementFor(TestOutcome testOutcome, Requirement requirement) { if (testOutcome.getTestCase() != null) { return (fullPathOf(requirement).matchesOrIsADescendantOf(normalizedPath(testOutcome.getPathId()))); } else { return (fullPathOf(requirement).matchesOrIsADescendantOf(normalizedPath(testOutcome.getPath()))); } }
private void loadRequirementsFromClasses(List<Class<?>> classes) { for (Class candidateClass : classes) { addRequirementTo(requirementsByPath, candidateClass); } leafRequirements = findLeafRequirementsIn(requirementsByPath); persistRequirementsAsJSON(requirementsByPath); }
public FileSystemRequirmentsOutcomeFactory(EnvironmentVariables environmentVariables, IssueTracking issueTracking, ReportNameProvider reportNameProvider, String rootDirectoryPath) { this.issueTracking = issueTracking; this.environmentVariables = environmentVariables; this.tagProvider = new FileSystemRequirementsTagProvider(environmentVariables, rootDirectoryPath); this.reportNameProvider = reportNameProvider; }
private boolean childrenExistFor(String path) { if (hasSubdirectories(path)) { return true; } else if (hasFeatureOrStoryFiles(path)) { return true; } else { return classpathResourceExistsFor(path); } }
private Optional<Requirement> getParentRequirementOf(TestOutcome testOutcome, RequirementsTagProvider tagProvider) { if (requirementCache.containsKey(testOutcome)) { return requirementCache.get(testOutcome); } else { Optional<Requirement> parentRequirement = findMatchingIndexedRequirement(tagProvider.getParentRequirementOf(testOutcome)); requirementCache.put(testOutcome, parentRequirement); return parentRequirement; } }
@Override public List<Requirement> getRequirements() { requirements = fileSystemRequirementsTagProvider.getRequirements(); requirements = addParentsTo(requirements); indexRequirements(); LOGGER.debug("Requirements found:" + requirements); return requirements; }
private Optional<ReleaseProvider> getReleaseProvider() { List<RequirementsTagProvider> requirementsTagProviders = getRequirementsTagProviders(); for (RequirementsTagProvider provider : requirementsTagProviders) { if ((provider instanceof ReleaseProvider) && ((ReleaseProvider) provider).isActive()) { return Optional.of((ReleaseProvider) provider); } } return Optional.absent(); }
public SortedMap<String, Requirement> getRequirementsByPath() { getRequirements(); return requirementsByPath; }
private java.util.Optional<Requirement> getParentRequirementOf(TestOutcome testOutcome, RequirementsTagProvider tagProvider) { java.util.Optional<Requirement> parentDefinedInTags = ParentRequirementsProvided.by(tagProvider).forOutcome(testOutcome); if (parentDefinedInTags.isPresent()) { java.util.Optional<Requirement> matchingIndexedParentRequirement = findMatchingIndexedRequirement(parentDefinedInTags.get()); return matchingIndexedParentRequirement; } return java.util.Optional.empty(); }
@Override public List<Requirement> getRequirements() { if (requirements == null) { requirements = loadRequirements(); } return requirements; }
/** * Find the root directory in the classpath or on the file system from which the requirements will be read. */ public Set<String> getRootDirectoryPaths() { return new RootDirectory(environmentVariables, rootDirectory).getRootDirectoryPaths(); }
private Map<Requirement, List<Requirement>> getRequirementAncestors() { if (requirementAncestors == null) { getRequirements(); } return requirementAncestors; }
public FileSystemRequirmentsOutcomeFactory(EnvironmentVariables environmentVariables, IssueTracking issueTracking, ReportNameProvider reportNameProvider) { this.issueTracking = issueTracking; this.environmentVariables = environmentVariables; this.tagProvider = new FileSystemRequirementsTagProvider(environmentVariables); this.reportNameProvider = reportNameProvider; }
private Optional<Requirement> getParentRequirementOf(TestOutcome testOutcome, RequirementsTagProvider tagProvider) { if (requirementCache.containsKey(testOutcome)) { return requirementCache.get(testOutcome); } else { Optional<Requirement> parentRequirement = findMatchingIndexedRequirement(tagProvider.getParentRequirementOf(testOutcome)); requirementCache.put(testOutcome, parentRequirement); return parentRequirement; } }
private Map<Requirement, List<Requirement>> getRequirementAncestors() { if (requirementAncestors == null) { getRequirements(); } return requirementAncestors; }