public PackageBasedLeafRequirements(EnvironmentVariables environmentVariables) { this.rootPackage = THUCYDIDES_TEST_ROOT.from(environmentVariables); this.requirementTypesProvider = new PackageRequirementsTagProvider(environmentVariables, rootPackage); }
private Optional<List<Requirement>> requirementsReadFromClasspath() { List<Requirement> classpathRequirements = null; try { List<String> requirementPaths = requirementPathsStartingFrom(rootPackage); int requirementsDepth = longestPathIn(requirementPaths); Set<Requirement> allRequirements = new HashSet(); for (String path : requirementPaths) { addRequirementsDefinedIn(path, requirementsDepth, allRequirements); } allRequirements = removeChildrenFromTopLevelRequirementsIn(allRequirements); if (!allRequirements.isEmpty()) { classpathRequirements =new ArrayList<>(allRequirements); Collections.sort(classpathRequirements); requirementsStore.write(classpathRequirements); } } catch (IOException e) { return Optional.empty(); } return Optional.ofNullable(classpathRequirements); }
@Override public List<String> getActiveRequirementTypes() { List<String> allRequirementTypes = requirementsConfiguration.getRequirementTypes(); int maxDepth = longestPathIn(requirementPathsStartingFrom(rootPackage));// RequirementsList.of(getRequirements()).maxDepth(); return applicableRequirements(allRequirementTypes, maxDepth); }
private List<String> requirementPathsStartingFrom(String rootPackage){ if (requirementPaths == null) { readingPaths.lock(); List<String> paths = requirementPathsFromClassesInPackage(rootPackage); Collections.sort(paths, byDescendingPackageLength()); requirementPaths = NewList.copyOf(paths); readingPaths.unlock(); } return requirementPaths; }
@Override public Set<TestTag> getTagsFor(TestOutcome testOutcome) { if (testOutcome.getUserStory() == null) { return new HashSet(); } Set<TestTag> tags = new HashSet<>(); java.util.Optional<Requirement> matchingRequirement = getRequirementFor(testOutcome.getUserStory().asTag()); if (matchingRequirement.isPresent()) { tags.add(matchingRequirement.get().asTag()); Optional<Requirement> parent = parentOf(matchingRequirement.get()); while (parent.isPresent()) { tags.add(parent.get().asTag()); parent = parentOf(parent.get()); } } return tags; }
@Override public java.util.Optional<Requirement> getRequirementFor(TestTag testTag) { for (Requirement requirement : AllRequirements.in(getRequirements())) { if (requirement.asTag().isAsOrMoreSpecificThan(testTag)) { return Optional.of(requirement); } } return uniqueRequirementWithName(testTag.getName()); }
private java.util.Optional<Requirement> uniqueRequirementWithName(String name) { return RequirementsList.of(getRequirements()).findByUniqueName(name); }
@Override public List<Requirement> getRequirements() { if (rootPackage == null) { return NO_REQUIREMENTS; } if (requirements == null) { fetchRequirements(); } return requirements; }
private List<String> requirementPathsFromClassesInPackage(String rootPackage) { List<String> requirementPaths = new ArrayList<>(); ClassPath classpath; try { classpath = ClassPath.from(Thread.currentThread().getContextClassLoader()); } catch (IOException e) { throw new CouldNotLoadRequirementsException(e); } for (ClassPath.ClassInfo classInfo : classpath.getTopLevelClassesRecursive(rootPackage)) { if (classRepresentsARequirementIn(classInfo)) { requirementPaths.add(classInfo.getName()); } } return requirementPaths; }
public PackageRequirementsTagProvider(EnvironmentVariables environmentVariables, String rootPackage) { this(environmentVariables, rootPackage, new FileSystemRequirementsStore(getRequirementsDirectory(ConfiguredEnvironment.getConfiguration().getOutputDirectory()), rootPackage + "-package-requirements.json")); }
private void addRequirementsDefinedIn(String path, int requirementsDepth, Collection<Requirement> allRequirements) { Requirement leafRequirement = LeafRequirementAdder.addLeafRequirementDefinedIn(path) .withAMaximumRequirementsDepthOf(requirementsDepth) .usingRequirementTypes(getActiveRequirementTypes()) .startingAt(rootPackage) .to(allRequirements); NonLeafRequirementsAdder.addParentsOf(leafRequirement) .in(path) .withAMaximumRequirementsDepthOf(requirementsDepth) .startingAt(rootPackage) .to(allRequirements); }
public java.util.Optional<Requirement> getTestCaseRequirementOf(TestOutcome testOutcome) { for (Requirement requirement : AllRequirements.in(getRequirements())) { if (requirement.asTag().isAsOrMoreSpecificThan(testOutcome.getUserStory().asTag())) { return java.util.Optional.of(requirement); } } return java.util.Optional.empty(); }
public PackageRequirementsTagProvider withCacheDisabled() { return new PackageRequirementsTagProvider(environmentVariables, rootPackage, new DisabledRequirementsStore()); }
@Override public Iterable<? extends TagProvider> getTagProviders() { return NewSet.of( new PackageRequirementsTagProvider(), new AnnotationBasedTagProvider(), new FileSystemRequirementsTagProvider(), new FeatureStoryTagProvider(), new InjectedTagProvider(), new ContextTagProvider() ); }