/*******************************************************************************
* (c) Copyright 2016 Hewlett-Packard Development Company, L.P.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Apache License v2.0 which accompany this distribution.
*
* The Apache License is available at
* http://www.apache.org/licenses/LICENSE-2.0
*
*******************************************************************************/
package io.cloudslang.lang.tools.build;
import io.cloudslang.lang.compiler.modeller.model.Executable;
import io.cloudslang.lang.entities.CompilationArtifact;
import io.cloudslang.lang.logging.LoggingService;
import io.cloudslang.lang.tools.build.SlangBuildMain.BulkRunMode;
import io.cloudslang.lang.tools.build.constants.Messages;
import io.cloudslang.lang.tools.build.tester.IRunTestResults;
import io.cloudslang.lang.tools.build.tester.RunTestsResults;
import io.cloudslang.lang.tools.build.tester.SlangTestRunner;
import io.cloudslang.lang.tools.build.tester.SlangTestRunner.TestCaseRunState;
import io.cloudslang.lang.tools.build.tester.parallel.report.ThreadSafeRunTestResults;
import io.cloudslang.lang.tools.build.tester.parse.SlangTestCase;
import io.cloudslang.lang.tools.build.tester.runconfiguration.BuildModeConfig;
import io.cloudslang.lang.tools.build.verifier.CompileResult;
import io.cloudslang.lang.tools.build.verifier.PreCompileResult;
import io.cloudslang.lang.tools.build.verifier.SlangContentVerifier;
import org.apache.commons.io.FilenameUtils;
import org.apache.commons.lang3.NotImplementedException;
import org.apache.commons.lang3.StringUtils;
import org.apache.log4j.Level;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import java.io.File;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import static io.cloudslang.lang.tools.build.SlangBuildMain.BulkRunMode.ALL_PARALLEL;
import static io.cloudslang.lang.tools.build.SlangBuildMain.BulkRunMode.ALL_SEQUENTIAL;
import static io.cloudslang.lang.tools.build.SlangBuildMain.BulkRunMode.POSSIBLY_MIXED;
/*
* Created by stoneo on 2/9/2015.
*/
/**
* Verifies all files with extensions: .sl, .sl.yaml or .sl.yml in a given directory are valid
*/
@Component
public class SlangBuilder {
private static final String UNSUPPORTED_BULK_RUN_MODE = "Unsupported bulk run mode '%s'.";
@Autowired
private SlangContentVerifier slangContentVerifier;
@Autowired
private SlangTestRunner slangTestRunner;
@Autowired
private LoggingService loggingService;
public SlangBuildResults buildSlangContent(
String projectPath,
String contentPath,
String testsPath,
List<String> testSuits,
boolean shouldValidateDescription,
boolean shouldValidateCheckstyle,
BulkRunMode bulkRunMode,
SlangBuildMain.BuildMode buildMode,
Set<String> changedFiles) {
String projectName = FilenameUtils.getName(projectPath);
loggingService.logEvent(Level.INFO, "");
loggingService.logEvent(Level.INFO, "------------------------------------------------------------");
loggingService.logEvent(Level.INFO, "Building project: " + projectName);
loggingService.logEvent(Level.INFO, "------------------------------------------------------------");
loggingService.logEvent(Level.INFO, "");
loggingService.logEvent(Level.INFO, "--- compiling sources ---");
PreCompileResult preCompileResult =
slangContentVerifier.createModelsAndValidate(contentPath,
shouldValidateDescription, shouldValidateCheckstyle);
Map<String, Executable> slangModels = preCompileResult.getResults();
List<RuntimeException> exceptions = new ArrayList<>(preCompileResult.getExceptions());
CompileResult compileResult = compileModels(slangModels);
exceptions.addAll(compileResult.getExceptions());
IRunTestResults runTestsResults = new RunTestsResults();
if (compileResult.getExceptions().size() == 0 &&
StringUtils.isNotBlank(testsPath) && new File(testsPath).isDirectory()) {
runTestsResults =
runTests(slangModels, projectPath, testsPath, testSuits, bulkRunMode, buildMode, changedFiles);
}
exceptions.addAll(runTestsResults.getExceptions());
return new SlangBuildResults(compileResult.getResults().size(), runTestsResults, exceptions);
}
/**
* Compiles all CloudSlang models
*
* @return the number of valid CloudSlang files in the given directory
*/
private CompileResult compileModels(Map<String, Executable> slangModels) {
CompileResult compileResult = slangContentVerifier.compileSlangModels(slangModels);
Map<String, CompilationArtifact> compiledSlangFiles = compileResult.getResults();
if (compiledSlangFiles.size() != slangModels.size()) {
compileResult.addException(new RuntimeException("Some Slang files were not compiled.\n" +
"Found: " + slangModels.size() + " slang models, but managed to compile only: " +
compiledSlangFiles.size()));
}
loggingService.logEvent(Level.INFO, "Successfully finished Compilation of: " +
compiledSlangFiles.size() + " Slang files");
return compileResult;
}
IRunTestResults runTests(
Map<String, Executable> contentSlangModels,
String projectPath,
String testsPath,
List<String> testSuites,
BulkRunMode bulkRunMode,
SlangBuildMain.BuildMode buildMode,
Set<String> changedFiles) {
loggingService.logEvent(Level.INFO, "");
loggingService.logEvent(Level.INFO, "--- compiling tests sources ---");
// Compile all slang test flows under the test directory
PreCompileResult preCompileResult = slangContentVerifier.createModelsAndValidate(testsPath, false, false);
Map<String, Executable> testFlowModels = preCompileResult.getResults();
// Add also all of the slang models of the content in order to allow for compilation of the test flows
Map<String, Executable> allTestedFlowModels = new HashMap<>(testFlowModels);
allTestedFlowModels.putAll(contentSlangModels);
// Compiling all the test flows
CompileResult compileResult = slangContentVerifier.compileSlangModels(allTestedFlowModels);
final Map<String, CompilationArtifact> compiledFlows =
compileResult.getResults();
Set<String> allTestedFlowsFqn = mapExecutablesToFullyQualifiedName(allTestedFlowModels.values());
Map<String, SlangTestCase> testCases = slangTestRunner.createTestCases(testsPath, allTestedFlowsFqn);
loggingService.logEvent(Level.INFO, "");
loggingService.logEvent(Level.INFO, "--- running tests ---");
loggingService.logEvent(Level.INFO, "Found " + testCases.size() + " tests");
IRunTestResults runTestsResults;
BuildModeConfig buildModeConfig = createBuildModeConfig(buildMode, changedFiles, allTestedFlowModels);
runTestsResults =
processRunTests(projectPath, testSuites, bulkRunMode, compiledFlows, testCases, buildModeConfig);
runTestsResults.addExceptions(preCompileResult.getExceptions());
runTestsResults.addExceptions(compileResult.getExceptions());
addCoverageDataToRunTestsResults(contentSlangModels, testFlowModels, testCases, runTestsResults);
return runTestsResults;
}
private BuildModeConfig createBuildModeConfig(SlangBuildMain.BuildMode buildMode, Set<String> changedFiles,
Map<String, Executable> allTestedFlowModels) {
BuildModeConfig buildModeConfig;
switch (buildMode) {
case BASIC:
buildModeConfig = BuildModeConfig.createBasicBuildModeConfig();
break;
case CHANGED:
buildModeConfig = BuildModeConfig.createChangedBuildModeConfig(changedFiles, allTestedFlowModels);
break;
default:
throw new NotImplementedException(Messages.UNKNOWN_BUILD_MODE);
}
return buildModeConfig;
}
IRunTestResults processRunTests(
String projectPath,
List<String> testSuites,
BulkRunMode bulkRunMode,
Map<String, CompilationArtifact> compiledFlows,
Map<String, SlangTestCase> testCases,
BuildModeConfig buildModeConfig) {
IRunTestResults runTestsResults;
if (bulkRunMode == ALL_PARALLEL) { // Run All tests in parallel
ThreadSafeRunTestResults parallelRunTestResults = new ThreadSafeRunTestResults();
Map<TestCaseRunState, Map<String, SlangTestCase>> testCaseRunState =
slangTestRunner.splitTestCasesByRunState(bulkRunMode, testCases, testSuites,
parallelRunTestResults, buildModeConfig);
slangTestRunner.runTestsParallel(projectPath, testCaseRunState.get(TestCaseRunState.PARALLEL),
compiledFlows, parallelRunTestResults);
runTestsResults = parallelRunTestResults;
} else if (bulkRunMode == ALL_SEQUENTIAL) { // Run all tests sequentially
RunTestsResults sequentialRunTestResults = new RunTestsResults();
Map<TestCaseRunState, Map<String, SlangTestCase>> testCaseRunState =
slangTestRunner.splitTestCasesByRunState(bulkRunMode, testCases, testSuites,
sequentialRunTestResults, buildModeConfig);
slangTestRunner.runTestsSequential(projectPath, testCaseRunState.get(TestCaseRunState.SEQUENTIAL),
compiledFlows, sequentialRunTestResults);
runTestsResults = sequentialRunTestResults;
} else if (bulkRunMode == POSSIBLY_MIXED) { // Run some tests in parallel and rest of tests sequentially
ThreadSafeRunTestResults mixedTestResults = new ThreadSafeRunTestResults();
Map<TestCaseRunState, Map<String, SlangTestCase>> testCaseRunState =
slangTestRunner.splitTestCasesByRunState(bulkRunMode, testCases, testSuites,
mixedTestResults, buildModeConfig);
slangTestRunner.runTestsSequential(projectPath, testCaseRunState.get(TestCaseRunState.SEQUENTIAL),
compiledFlows, mixedTestResults);
slangTestRunner.runTestsParallel(projectPath, testCaseRunState.get(TestCaseRunState.PARALLEL),
compiledFlows, mixedTestResults);
runTestsResults = mixedTestResults;
} else {
throw new IllegalStateException(String
.format(UNSUPPORTED_BULK_RUN_MODE, (bulkRunMode == null) ? null : bulkRunMode.toString()));
}
return runTestsResults;
}
private Set<String> mapExecutablesToFullyQualifiedName(Collection<Executable> executables) {
Set<String> fullyQualifiedNames = new HashSet<>();
for (Executable executable : executables) {
fullyQualifiedNames.add(executable.getId());
}
return fullyQualifiedNames;
}
void addCoverageDataToRunTestsResults(Map<String, Executable> contentSlangModels,
Map<String, Executable> testFlowModels,
Map<String, SlangTestCase> testCases, IRunTestResults runTestsResults) {
Set<String> coveredContent = new HashSet<>();
Set<String> uncoveredContent = new HashSet<>();
// Add to the covered content set all the dependencies of the test flows
for (SlangTestCase testCase : testCases.values()) {
String testFlowPath = testCase.getTestFlowPath();
Executable testFlowModel;
if (testFlowModels.containsKey(testFlowPath)) {
testFlowModel = testFlowModels.get(testFlowPath);
} else {
testFlowModel = contentSlangModels.get(testFlowPath);
}
if (testFlowModel == null) {
continue;
}
addAllDependenciesToCoveredContent(coveredContent,
testFlowModel.getExecutableDependencies(), contentSlangModels);
}
Set<String> contentExecutablesNames = contentSlangModels.keySet();
// Add to the covered content set also all the direct test case's test flows,
// which are part of the tested content
for (SlangTestCase testCase : testCases.values()) {
String testFlowPath = testCase.getTestFlowPath();
// Add the test flow only if it part of the content, and not of the test flows
if (contentExecutablesNames.contains(testFlowPath)) {
coveredContent.add(testFlowPath);
}
}
// Create the uncovered content set from the content which does not appear in the covered set
for (String contentModelName : contentExecutablesNames) {
if (!coveredContent.contains(contentModelName)) {
uncoveredContent.add(contentModelName);
}
}
runTestsResults.addCoveredExecutables(coveredContent);
runTestsResults.addUncoveredExecutables(uncoveredContent);
}
/**
* Collect recursively all the dependencies of an executable
*
* @param allDependencies
* @param directDependencies
* @param contentSlangModels
*/
private void addAllDependenciesToCoveredContent(Set<String> allDependencies, Set<String> directDependencies,
Map<String, Executable> contentSlangModels) {
for (String dependency : directDependencies) {
if (allDependencies.contains(dependency)) {
continue;
}
allDependencies.add(dependency);
Executable executable = contentSlangModels.get(dependency);
// Executable will be null in case of a dependecy which is a test flow (and not patr of the content)
if (executable != null) {
addAllDependenciesToCoveredContent(allDependencies,
executable.getExecutableDependencies(), contentSlangModels);
}
}
}
}