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 List<Requirement> addParentsTo(List<Requirement> requirements) { return addParentsTo(requirements, null); }
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; } } }
private List<String> stripStorySuffixFrom(List<String> pathElements) { if ((!pathElements.isEmpty()) && isSupportedFileStoryExtension(last(pathElements))) { return dropLastElement(pathElements); } else { return pathElements; } }
public Set<TestTag> getTagsFor(final TestOutcome testOutcome) { Set<TestTag> tags = new HashSet<>(); if (testOutcome.getPath() != null) { List<String> storyPathElements = stripRootFrom(pathElements(stripRootPathFrom(testOutcome.getPath()))); addStoryTagIfPresent(tags, storyPathElements); storyPathElements = stripStorySuffixFrom(storyPathElements); tags.addAll(getMatchingCapabilities(getRequirements(), storyPathElements)); } return tags; }
public Set<TestTag> getTagsFor(final TestOutcome testOutcome) { // // For the FileSystemRequirements tag provider, the test outcome provides a path, which might be: // - a feature file for Cucumber ("add_an_item.feature"), // - a story file with a path (JBehave) ("stories/manage_items/add_an_item.story") // Set<TestTag> tags = new HashSet<>(); if (testOutcome.getPath() != null) { java.util.Optional<Requirement> matchingRequirement = requirementWithMatchingFeatureFile(testOutcome); if (matchingRequirement.isPresent()) { tags.add(matchingRequirement.get().asTag()); tags.addAll(parentRequirementsOf(matchingRequirement.get().asTag())); } // Strategy used if a full path is provided List<String> storyPathElements = stripRootFrom(pathElements(stripRootPathFrom(testOutcome.getPath()))); tags.addAll(getMatchingCapabilities(getRequirements(), stripStorySuffixFrom(storyPathElements))); if (tags.isEmpty() && storyOrFeatureDescribedIn(storyPathElements).isPresent()) { java.util.Optional<TestTag> matchingRequirementTag = getMatchingRequirementTagsFor(storyOrFeatureDescribedIn(storyPathElements).get()); if (matchingRequirementTag.isPresent()) { tags.add(matchingRequirementTag.get()); tags.addAll(parentRequirementsOf(matchingRequirementTag.get())); } } } return tags; }
/** * We look for file system requirements in the root directory path (by default, 'stories'). * First, we look on the classpath. If we don't find anything on the classpath (e.g. if the task is * being run from the Maven plugin), we look in the src/main/resources and src/test/resources directories starting * at the working directory. */ public List<Requirement> getRequirements() { if (requirements == null) { try { Set<Requirement> allRequirements = Sets.newHashSet(); Set<String> directoryPaths = getRootDirectoryPaths(); for (String rootDirectoryPath : directoryPaths) { File rootDirectory = new File(rootDirectoryPath); if (rootDirectory.exists()) { allRequirements.addAll(loadCapabilitiesFrom(rootDirectory.listFiles(thatAreDirectories()))); allRequirements.addAll(loadStoriesFrom(rootDirectory.listFiles(thatAreStories()))); } } requirements = Lists.newArrayList(allRequirements); Collections.sort(requirements); } catch (IOException e) { requirements = NO_REQUIREMENTS; throw new IllegalArgumentException("Could not load requirements from '" + rootDirectoryPath + "'", e); } if (level == 0) { requirements = addParentsTo(requirements); } } return requirements; }
/** * We look for file system requirements in the root directory path (by default, 'stories'). * First, we look on the classpath. If we don't find anything on the classpath (e.g. if the task is * being run from the Maven plugin), we look in the src/main/resources and src/test/resources directories starting * at the working directory. */ public List<Requirement> getRequirements() { if (requirements == null) { synchronized (requirementsLock) { if (requirements == null) { Set<Requirement> allRequirements = new HashSet<>(); Set<String> directoryPaths = getRootDirectoryPaths(); for (String path : directoryPaths) { File rootDirectory = new File(path); if (rootDirectory.exists()) { List<Requirement> capabilities = loadCapabilitiesFrom(rootDirectory.listFiles(thatAreFeatureDirectories())); List<Requirement> leafRequirements = loadStoriesFrom(rootDirectory.listFiles(thatAreStories())); allRequirements.addAll(capabilities); allRequirements.addAll(leafRequirements); } } requirements = new ArrayList<>(allRequirements); sort(requirements); requirements = addParentsTo(requirements); } } } return Collections.unmodifiableList(requirements); }
URL rootDirectoryPath = null; try { Optional<String> directoryPath = getRootDirectoryPath(); if (directoryPath.isPresent()) { File rootDirectory = new File(directoryPath.get()); List<Requirement> allRequirements = Lists.newArrayList(); allRequirements.addAll(loadCapabilitiesFrom(rootDirectory.listFiles(thatAreDirectories()))); allRequirements.addAll(loadStoriesFrom(rootDirectory.listFiles(thatAreStories()))); Collections.sort(allRequirements); requirements = allRequirements; requirements = addParentsTo(requirements);
private Optional<Requirement> lastRequirementMatchingPath(List<Requirement> requirements, List<String> storyPathElements) { if (storyPathElements.isEmpty()) { return Optional.absent(); } Optional<Requirement> matchingRequirement = findMatchingRequirementIn(next(storyPathElements), requirements); if (!matchingRequirement.isPresent()) { return Optional.absent(); } if (tail(storyPathElements).isEmpty()) { return matchingRequirement; } List<Requirement> childRequrements = matchingRequirement.get().getChildren(); return lastRequirementMatchingPath(childRequrements, tail(storyPathElements)); }
private Requirement requirementFromDirectoryName(File requirementDirectory) { String shortName = humanReadableVersionOf(requirementDirectory.getName()); List<Requirement> children = readChildrenFrom(requirementDirectory); return Requirement.named(shortName) .withType(getDefaultType(level)) .withNarrative("") .withPath(relativeDirectoryOf(requirementDirectory.getPath())) .withChildren(children); }
private Requirement requirementFromDirectoryName(File requirementDirectory) { System.out.println("Reading requirement from directory name " + requirementDirectory); String shortName = humanReadableVersionOf(requirementDirectory.getName()); List<Requirement> children = readChildrenFrom(requirementDirectory); return Requirement.named(shortName).withType(getDefaultType(level)).withNarrative(shortName).withChildren(children); }
private List<Requirement> readChildrenFrom(File requirementDirectory) { String childDirectory = rootDirectoryPath + "/" + requirementDirectory.getName(); if (childrenExistFor(childDirectory)) { RequirementsTagProvider childReader = new FileSystemRequirementsTagProvider(childDirectory, level + 1, environmentVariables); return childReader.getRequirements(); } else if (childrenExistFor(requirementDirectory.getPath())) { RequirementsTagProvider childReader = new FileSystemRequirementsTagProvider(requirementDirectory.getPath(), level + 1, environmentVariables); return childReader.getRequirements(); } else { return NO_REQUIREMENTS; } }
public FileSystemRequirementsTagProvider(String rootDirectory, EnvironmentVariables environmentVariables) { super(environmentVariables, rootDirectory); this.narrativeReader = NarrativeReader.forRootDirectory(rootDirectory) .withRequirementTypes(getRequirementTypes()); this.overviewReader = new OverviewReader(); this.requirementsConfiguration = new RequirementsConfiguration(environmentVariables); directoryPaths = rootDirectories(rootDirectory, environmentVariables); this.level = requirementsConfiguration.startLevelForADepthOf(maxDirectoryDepthIn(directoryPaths) + 1); }
public FileSystemRequirementsTagProvider(String rootDirectory, int level) { this(filePathFormOf(rootDirectory), level, Injectors.getInjector().getProvider(EnvironmentVariables.class).get() ); }
private Optional<Requirement> mostSpecificTagRequirementFor(TestOutcome testOutcome) { Optional<Requirement> mostSpecificRequirement = Optional.absent(); int currentSpecificity = -1; for (TestTag tag : testOutcome.getTags()) { Optional<Requirement> matchingRequirement = getRequirementFor(tag); if (matchingRequirement.isPresent()) { int specificity = requirementsConfiguration.getRequirementTypes().indexOf(matchingRequirement.get().getType()); if (currentSpecificity < specificity) { currentSpecificity = specificity; mostSpecificRequirement = matchingRequirement; } } } return mostSpecificRequirement; }
public FileSystemRequirementsTagProvider(String rootDirectory, int level, EnvironmentVariables environmentVariables) { super(environmentVariables, rootDirectory); this.narrativeReader = NarrativeReader.forRootDirectory(rootDirectory) .withRequirementTypes(getRequirementTypes()); this.overviewReader = new OverviewReader(); directoryPaths = rootDirectories(rootDirectory, environmentVariables); this.requirementsConfiguration = new RequirementsConfiguration(environmentVariables); this.level = level; }
public FileSystemRequirementsTagProvider(String rootDirectory, int level, EnvironmentVariables environmentVariables) { super(environmentVariables); this.rootDirectoryPath = rootDirectory; this.level = level; this.narrativeReader = NarrativeReader.forRootDirectory(rootDirectory) .withRequirementTypes(getRequirementTypes()); }
public Set<TestTag> getTagsFor(final TestOutcome testOutcome) { Set<TestTag> tags = new HashSet<>(); if (testOutcome.getPath() != null) { List<String> storyPathElements = stripRootFrom(pathElements(stripRootPathFrom(testOutcome.getPath()))); addStoryTagIfPresent(tags, storyPathElements); storyPathElements = stripStorySuffixFrom(storyPathElements); tags.addAll(getMatchingCapabilities(getRequirements(), storyPathElements)); } return tags; }
private Optional<Requirement> lastRequirementMatchingPath(List<Requirement> requirements, List<String> storyPathElements) { if (storyPathElements.isEmpty()) { return Optional.absent(); } Optional<Requirement> matchingRequirement = findMatchingRequirementIn(next(storyPathElements), requirements); if (!matchingRequirement.isPresent()) { return Optional.absent(); } if (tail(storyPathElements).isEmpty()) { return matchingRequirement; } List<Requirement> childRequrements = matchingRequirement.get().getChildren(); return lastRequirementMatchingPath(childRequrements, tail(storyPathElements)); }