@Override public List<Requirement> getRequirements() { if (requirements == null) { requirements = newArrayList(); for (RequirementsTagProvider tagProvider : getRequirementsTagProviders()) { LOGGER.info("Reading requirements from " + tagProvider); requirements = tagProvider.getRequirements(); if (!requirements.isEmpty()) { break; } } requirements = addParentsTo(requirements); indexRequirements(); LOGGER.info("Requirements found:" + requirements); } return requirements; }
public List<Requirement> getAllRequirements() { List<Requirement> allRequirements = newArrayList(); addRequirementsFrom(getRequirements(), allRequirements); return allRequirements; }
@Override public Optional<Requirement> getParentRequirementFor(TestOutcome testOutcome) { try { for (RequirementsTagProvider tagProvider : getRequirementsTagProviders()) { Optional<Requirement> requirement = getParentRequirementOf(testOutcome, tagProvider); if (requirement.isPresent()) { return requirement; } } } catch (RuntimeException handleTagProvidersElegantly) { LOGGER.error("Tag provider failure", handleTagProvidersElegantly); } return Optional.absent(); }
@Override public List<Release> getReleasesFromRequirements() { if (releases == null) { if (getReleaseProvider().isPresent() && (getReleaseProvider().get().isActive())) { releases = getReleaseProvider().get().getReleases(); } else { List<List<String>> releaseVersions = getReleaseVersionsFrom(getRequirements()); releases = getReleaseManager().extractReleasesFrom(releaseVersions); } } return releases; }
@Override public List<Requirement> getAncestorRequirementsFor(TestOutcome testOutcome) { for (RequirementsTagProvider tagProvider : getRequirementsTagProviders()) { Optional<Requirement> requirement = getParentRequirementOf(testOutcome, tagProvider); if (requirement.isPresent()) { LOGGER.info("Requirement found for test outcome " + testOutcome.getTitle() + "-" + testOutcome.getIssueKeys() + ": " + requirement); if (getRequirementAncestors().containsKey(requirement.get())) { return getRequirementAncestors().get(requirement.get()); } else { LOGGER.warn("Requirement without identified ancestors found:" + requirement.get().getCardNumber()); } } } return EMPTY_LIST; }
private List<RequirementsTagProvider> getRequirementsTagProviders() { if (requirementsTagProviders == null) { RequirementsProviderService requirementsProviderService = Injectors.getInjector().getInstance(RequirementsProviderService.class); requirementsTagProviders = reprioritizeProviders(active(requirementsProviderService.getRequirementsProviders())); } return requirementsTagProviders; }
private Optional<Requirement> findMatchingIndexedRequirement(Optional<Requirement> requirement) { if (!requirement.isPresent()) { return requirement; } for(Requirement indexedRequirement : getAllRequirements()) { if (requirement.get().matches(indexedRequirement)) { return Optional.of(indexedRequirement); } } return Optional.absent(); }
private List<Requirement> addParentsTo(List<Requirement> requirements) { return addParentsTo(requirements, null); }
@Override public List<String> getReleaseVersionsFor(TestOutcome testOutcome) { List<String> releases = newArrayList(testOutcome.getVersions()); for (Requirement parentRequirement : getAncestorRequirementsFor(testOutcome)) { releases.addAll(parentRequirement.getReleaseVersions()); } return releases; }
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 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 void addRequirementsFrom(List<Requirement> requirements, List<Requirement> allRequirements) { allRequirements.addAll(requirements); for (Requirement requirement : requirements) { addRequirementsFrom(requirement.getChildren(), allRequirements); } } }
@Override public List<Release> getReleasesFromRequirements() { if (releases == null) { if (getReleaseProvider().isPresent() && (getReleaseProvider().get().isActive())) { releases = getReleaseProvider().get().getReleases(); } else { List<List<String>> releaseVersions = getReleaseVersionsFrom(getRequirements()); releases = getReleaseManager().extractReleasesFrom(releaseVersions); } } return releases; }
@Override public List<Requirement> getAncestorRequirementsFor(TestOutcome testOutcome) { for (RequirementsTagProvider tagProvider : getRequirementsTagProviders()) { Optional<Requirement> requirement = getParentRequirementOf(testOutcome, tagProvider); if (requirement.isPresent()) { LOGGER.info("Requirement found for test outcome " + testOutcome.getTitle() + "-" + testOutcome.getIssueKeys() + ": " + requirement); if (getRequirementAncestors().containsKey(requirement.get())) { return getRequirementAncestors().get(requirement.get()); } else { LOGGER.warn("Requirement without identified ancestors found:" + requirement.get().getCardNumber()); } } } return EMPTY_LIST; }
private List<RequirementsTagProvider> getRequirementsTagProviders() { if (requirementsTagProviders == null) { RequirementsProviderService requirementsProviderService = Injectors.getInjector().getInstance(RequirementsProviderService.class); requirementsTagProviders = reprioritizeProviders(active(requirementsProviderService.getRequirementsProviders())); } return requirementsTagProviders; }
private Optional<Requirement> findMatchingIndexedRequirement(Optional<Requirement> requirement) { if (!requirement.isPresent()) { return requirement; } for(Requirement indexedRequirement : getAllRequirements()) { if (requirement.get().matches(indexedRequirement)) { return Optional.of(indexedRequirement); } } return Optional.absent(); }
private List<Requirement> addParentsTo(List<Requirement> requirements) { return addParentsTo(requirements, null); }
@Override public List<String> getReleaseVersionsFor(TestOutcome testOutcome) { List<String> releases = newArrayList(testOutcome.getVersions()); for (Requirement parentRequirement : getAncestorRequirementsFor(testOutcome)) { releases.addAll(parentRequirement.getReleaseVersions()); } return releases; }
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 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; } }