public OutcomeCounter getTotal() { return count(TestType.ANY); }
public int getEstimatedUnimplementedTests() { return getRequirementsWithoutTestsCount() * estimatedTestsPerRequirement(); }
public int getRequirementsWithoutTestsCount() { int requirementsWithNoTests = 0; List<RequirementOutcome> flattenedRequirementOutcomes = getFlattenedRequirementOutcomes(); for (Requirement requirement : getAllRequirements()) { if (!testsRecordedFor(flattenedRequirementOutcomes, requirement)) { requirementsWithNoTests++; } } return requirementsWithNoTests; }
private int totalEstimatedAndImplementedTests() { int totalImplementedTests = getTotalTestCount(); return totalImplementedTests + getEstimatedUnimplementedTests(); }
public List<RequirementOutcome> getLeafRequirementOutcomes() { if (leafRequirementOutcomes == null) { leafRequirementOutcomes = geLeafRequirementOutcomes(getFlattenedRequirementOutcomes(requirementOutcomes)); } return leafRequirementOutcomes; }
public RequirementsOutcomes getReleasedRequirementsFor(Release release) { Set<Requirement> matchingRequirements = new HashSet<>(); Set<TestOutcome> matchingTestOutcomes = new HashSet<>(); // Add all test outcomes with a matching release List<RequirementOutcome> requirementOutcomes = releaseManager.enrichRequirementsOutcomesWithReleaseTags(getRequirementOutcomes()); for (RequirementOutcome outcome : requirementOutcomes) { Collection<String> releaseVersions = outcome.getReleaseVersions(); if (releaseVersions.contains(release.getName())) { List<TestOutcome> outcomesForRelease = outcomesForRelease(outcome.getTestOutcomes().getOutcomes(), release.getName()); if (!outcomesForRelease.isEmpty()) { matchingTestOutcomes.addAll(outcomesForRelease); matchingRequirements.add(outcome.getRequirement()); } } } matchingRequirements = removeRequirementsWithoutTestsFrom(matchingRequirements); return new RequirementsOutcomes(new ArrayList<>(matchingRequirements), TestOutcomes.of(matchingTestOutcomes), issueTracking, environmentVariables, requirementsTagProviders, reportNameProvider, overview).withoutUnrelatedRequirements(); }
public List<RequirementOutcome> getFlattenedRequirementOutcomes(List<RequirementOutcome> outcomes) { Set<RequirementOutcome> flattenedOutcomes = Sets.newHashSet(); for (RequirementOutcome requirementOutcome : outcomes) { flattenedOutcomes.add(requirementOutcome); for(Requirement requirement : requirementOutcome.getRequirement().getChildren()) { // TestTag requirementTag = TestTag.withName(requirement.getName()).andType(requirement.getType()); // TestOutcomes testOutcomesForRequirement = requirementOutcome.getTestOutcomes().withTag(requirementTag); TestOutcomes testOutcomesForRequirement = requirementOutcome.getTestOutcomes().withTag(requirement.asTag()); flattenedOutcomes.add(new RequirementOutcome(requirement, testOutcomesForRequirement, issueTracking)); List<Requirement> childRequirements = requirement.getChildren(); RequirementsOutcomes childOutcomes = new RequirementsOutcomes(childRequirements, testOutcomesForRequirement, issueTracking, environmentVariables, requirementsTagProviders); flattenedOutcomes.addAll(getFlattenedRequirementOutcomes(childOutcomes.getRequirementOutcomes())); } } return ImmutableList.copyOf(flattenedOutcomes); }
public List<RequirementOutcome> getFlattenedRequirementOutcomes(List<RequirementOutcome> outcomes) { Set<RequirementOutcome> flattenedOutcomes = new HashSet(); for (RequirementOutcome requirementOutcome : outcomes) { flattenedOutcomes.add(requirementOutcome); for (Requirement requirement : requirementOutcome.getRequirement().getChildren()) { TestOutcomes testOutcomesForRequirement = requirementOutcome.getTestOutcomes().forRequirement(requirement); flattenedOutcomes.add(new RequirementOutcome(requirement, testOutcomesForRequirement, issueTracking)); List<Requirement> childRequirements = requirement.getChildren(); RequirementsOutcomes childOutcomes = new RequirementsOutcomes(childRequirements, testOutcomesForRequirement, issueTracking, environmentVariables, requirementsTagProviders, reportNameProvider, overview).withoutUnrelatedRequirements(); flattenedOutcomes.addAll(getFlattenedRequirementOutcomes(childOutcomes.getRequirementOutcomes())); } } return NewList.copyOf(flattenedOutcomes); }
private void buildRequirements(List<RequirementOutcome> outcomes, List<RequirementsTagProvider> requirementsTagProviders, Requirement requirement) { TestOutcomes outcomesForRequirement = testOutcomes.forRequirement(requirement); int requirementsWithoutTests = countRequirementsWithoutTestsIn(requirement); int estimatedUnimplementedTests = requirementsWithoutTests * estimatedTestsPerRequirement(); outcomes.add(new RequirementOutcome(requirement, outcomesForRequirement, requirementsWithoutTests, estimatedUnimplementedTests, issueTracking)); }
public RequirementsOutcomes buildRequirementsOutcomesFrom(Requirement parentRequirement, TestOutcomes testOutcomes) { List<Requirement> childRequirements = parentRequirement.getChildren(); return new RequirementsOutcomes(parentRequirement, childRequirements, testOutcomes, issueTracking, environmentVariables, requirementsTagProviders, reportNameProvider, ""); }
public RequirementsOutcomes requirementsOfType(String type) { List<Requirement> matchingRequirements = Lists.newArrayList(); List<TestOutcome> matchingTests = Lists.newArrayList(); for(RequirementOutcome requirementOutcome : getFlattenedRequirementOutcomes()) { if (requirementOutcome.getRequirement().getType().equalsIgnoreCase(type)) { matchingRequirements.add(requirementOutcome.getRequirement()); matchingTests.addAll(requirementOutcome.getTestOutcomes().getOutcomes()); } } return new RequirementsOutcomes(matchingRequirements, TestOutcomes.of(matchingTests), issueTracking, environmentVariables, requirementsTagProviders); }
public RequirementsOutcomes ofType(String type) { List<Requirement> matchingRequirements = new ArrayList<>(); List<TestOutcome> matchingTests = new ArrayList<>(); getFlattenedRequirementOutcomes().stream() .filter(requirementOutcome -> requirementOutcome.getRequirement().getType().equalsIgnoreCase(type)) .forEach( requirementOutcome -> { matchingRequirements.add(requirementOutcome.getRequirement()); matchingTests.addAll(requirementOutcome.getTestOutcomes().getOutcomes()); } ); return new RequirementsOutcomes(matchingRequirements, TestOutcomes.of(matchingTests), issueTracking, environmentVariables, requirementsTagProviders, reportNameProvider, overview).withoutUnrelatedRequirements(); }
public int getTotalRequirements() { return getAllRequirements().size(); }
private void addFlattenedRequirements(Requirement requirement, List<Requirement> allRequirements) { allRequirements.add(requirement); for (Requirement child : requirement.getChildren()) { addFlattenedRequirements(child, allRequirements); } }
public List<RequirementOutcome> getFlattenedRequirementOutcomes() { if (flattenedRequirementOutcomes == null) { flattenedRequirementOutcomes = getFlattenedRequirementOutcomes(requirementOutcomes); } return flattenedRequirementOutcomes; }
private long countRequirementsWithoutTestsIn(Requirement rootRequirement) { return getFlattenedRequirements(rootRequirement).stream() .filter( requirement -> testOutcomes.forRequirement(requirement).getTotal() == 0) .count(); }
public RequirementsOutcomes(Requirement parentRequirement, List<Requirement> requirements, TestOutcomes testOutcomes, IssueTracking issueTracking, EnvironmentVariables environmentVariables, List<? extends RequirementsTagProvider> requirementsTagProviders, ReportNameProvider reportNameProvider, String overview) { this.testOutcomes = testOutcomes; this.parentRequirement = Optional.ofNullable(parentRequirement); this.environmentVariables = environmentVariables; this.issueTracking = issueTracking; this.requirementsTagProviders = requirementsTagProviders; this.requirementOutcomes = buildRequirementOutcomes(requirements); this.reportNameProvider = reportNameProvider; this.releaseManager = new ReleaseManager(environmentVariables, reportNameProvider); this.overview = overview; }
public RequirementsOutcomes withoutUnrelatedRequirements() { if (isEmpty(ThucydidesSystemProperty.THUCYDIDES_EXCLUDE_UNRELATED_REQUIREMENTS_OF_TYPE.from(environmentVariables))) { return this; } return new RequirementsOutcomes( reportNameProvider, pruned(requirementOutcomes), testOutcomes, parentRequirement, environmentVariables, issueTracking, requirementsTagProviders, releaseManager, overview); }
public RequirementsOutcomes getReleasedRequirementsFor(Release release) { List<Requirement> matchingRequirements = Lists.newArrayList(); List<TestOutcome> matchingTestOutcomes = Lists.newArrayList(); // Add all test outcomes with a matching release List<RequirementOutcome> requirementOutcomes = releaseManager.enrichRequirementsOutcomesWithReleaseTags(getRequirementOutcomes()); for(RequirementOutcome outcome : requirementOutcomes) { Collection<String> releaseVersions = outcome.getReleaseVersions(); if (releaseVersions.contains(release.getName())) { List<TestOutcome> outcomesForRelease = outcomesForRelease(outcome.getTestOutcomes().getOutcomes(), release.getName()); if (!outcomesForRelease.isEmpty()) { matchingTestOutcomes.addAll(outcomesForRelease); matchingRequirements.add(outcome.getRequirement()); } } } matchingRequirements = removeRequirementsWithoutTestsFrom(matchingRequirements); return new RequirementsOutcomes(Lists.newArrayList(matchingRequirements), TestOutcomes.of(matchingTestOutcomes), issueTracking, environmentVariables, requirementsTagProviders); }
public List<RequirementOutcome> getFlattenedRequirementOutcomes(List<RequirementOutcome> outcomes) { Set<RequirementOutcome> flattenedOutcomes = Sets.newHashSet(); for (RequirementOutcome requirementOutcome : outcomes) { flattenedOutcomes.add(requirementOutcome); for(Requirement requirement : requirementOutcome.getRequirement().getChildren()) { // TestTag requirementTag = TestTag.withName(requirement.getName()).andType(requirement.getType()); // TestOutcomes testOutcomesForRequirement = requirementOutcome.getTestOutcomes().withTag(requirementTag); TestOutcomes testOutcomesForRequirement = requirementOutcome.getTestOutcomes().withTag(requirement.asTag()); flattenedOutcomes.add(new RequirementOutcome(requirement, testOutcomesForRequirement, issueTracking)); List<Requirement> childRequirements = requirement.getChildren(); RequirementsOutcomes childOutcomes = new RequirementsOutcomes(childRequirements, testOutcomesForRequirement, issueTracking, environmentVariables, requirementsTagProviders); flattenedOutcomes.addAll(getFlattenedRequirementOutcomes(childOutcomes.getRequirementOutcomes())); } } return ImmutableList.copyOf(flattenedOutcomes); }