Java tutorial
/******************************************************************************* * (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 com.beust.jcommander.JCommander; import com.beust.jcommander.ParameterException; import io.cloudslang.lang.api.Slang; import io.cloudslang.lang.commons.services.api.UserConfigurationService; import io.cloudslang.lang.commons.services.impl.UserConfigurationServiceImpl; import io.cloudslang.lang.logging.LoggingService; import io.cloudslang.lang.logging.LoggingServiceImpl; import io.cloudslang.lang.tools.build.commands.ApplicationArgs; import io.cloudslang.lang.tools.build.tester.IRunTestResults; import io.cloudslang.lang.tools.build.tester.TestRun; import io.cloudslang.lang.tools.build.tester.parallel.report.SlangTestCaseRunReportGeneratorService; import io.cloudslang.lang.tools.build.tester.parse.SlangTestCase; import io.cloudslang.lang.tools.build.tester.runconfiguration.TestRunInfoService; import io.cloudslang.score.events.ScoreEvent; import io.cloudslang.score.events.ScoreEventListener; import org.apache.commons.collections4.ListUtils; import org.apache.commons.io.FilenameUtils; import org.apache.commons.lang.Validate; import org.apache.commons.lang3.StringUtils; import org.apache.log4j.Level; import org.apache.log4j.Logger; import org.apache.log4j.PropertyConfigurator; import org.springframework.context.support.ClassPathXmlApplicationContext; import java.io.File; import java.io.IOException; import java.io.InputStream; import java.nio.file.Path; import java.util.ArrayList; import java.util.HashSet; import java.util.List; import java.util.Map; import java.util.Properties; import java.util.Set; import static io.cloudslang.lang.tools.build.ArgumentProcessorUtils.getBooleanFromPropertiesWithDefault; import static io.cloudslang.lang.tools.build.ArgumentProcessorUtils.getEnumInstanceFromPropertiesWithDefault; import static io.cloudslang.lang.tools.build.ArgumentProcessorUtils.getIntFromPropertiesWithDefaultAndRange; import static io.cloudslang.lang.tools.build.ArgumentProcessorUtils.getListForPrint; 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; import static io.cloudslang.lang.tools.build.SlangBuildMain.RunConfigurationProperties.TEST_COVERAGE; import static io.cloudslang.lang.tools.build.SlangBuildMain.RunConfigurationProperties.TEST_PARALLEL_THREAD_COUNT; import static io.cloudslang.lang.tools.build.SlangBuildMain.RunConfigurationProperties.TEST_SUITES_PARALLEL; import static io.cloudslang.lang.tools.build.SlangBuildMain.RunConfigurationProperties.TEST_SUITES_RUN_UNSPECIFIED; import static io.cloudslang.lang.tools.build.SlangBuildMain.RunConfigurationProperties.TEST_SUITES_SEQUENTIAL; import static io.cloudslang.lang.tools.build.SlangBuildMain.RunConfigurationProperties.TEST_SUITES_TO_RUN; import static io.cloudslang.lang.tools.build.tester.SlangTestRunner.MAX_TIME_PER_TESTCASE_IN_MINUTES; import static io.cloudslang.lang.tools.build.tester.SlangTestRunner.TEST_CASE_TIMEOUT_IN_MINUTES_KEY; import static io.cloudslang.lang.tools.build.tester.parallel.services.ParallelTestCaseExecutorService.SLANG_TEST_RUNNER_THREAD_COUNT; import static java.lang.Integer.parseInt; import static java.lang.String.format; import static java.lang.String.valueOf; import static java.lang.System.getProperty; import static java.lang.System.setProperty; import static java.nio.file.Files.createDirectories; import static java.nio.file.Files.exists; import static java.nio.file.Files.isRegularFile; import static java.nio.file.LinkOption.NOFOLLOW_LINKS; import static java.nio.file.Paths.get; import static java.util.Locale.ENGLISH; import static org.apache.commons.collections4.ListUtils.removeAll; import static org.apache.commons.collections4.ListUtils.union; import static org.apache.commons.collections4.MapUtils.isNotEmpty; import static org.apache.commons.lang3.StringUtils.defaultIfEmpty; import static org.apache.commons.lang3.StringUtils.equalsIgnoreCase; import static org.apache.commons.lang3.StringUtils.isEmpty; public class SlangBuildMain { public static final String DEFAULT_TESTS = "default"; private static final String TEST_CASE_REPORT_LOCATION = "cloudslang.test.case.report.location"; private static final String CONTENT_DIR = File.separator + "content"; private static final String TEST_DIR = File.separator + "test"; private static final Logger log = Logger.getLogger(SlangBuildMain.class); private static final int MAX_THREADS_TEST_RUNNER = 32; private static final String MESSAGE_NOT_SCHEDULED_FOR_RUN_RULES = "Rules '%s' defined in '%s' key " + "are not scheduled for run."; private static final String MESSAGE_TEST_SUITES_WITH_UNSPECIFIED_MAPPING = "Test suites '%s' have " + "unspecified mapping. They will run in '%s' mode."; private static final String PROPERTIES_FILE_EXTENSION = "properties"; private static final String DID_NOT_DETECT_RUN_CONFIGURATION_PROPERTIES_FILE = "Did not detect run " + "configuration properties file at path '%s'. " + "Check that the path you are using is an absolute path. " + "Check that the path separator is '\\\\' for Windows, or '/' for Linux."; private static final String NEW_LINE = System.lineSeparator(); private static final String MESSAGE_BOTH_PARALLEL_AND_SEQUENTIAL_EXECUTION = "The '%s' suites are configured for " + "both parallel and sequential execution." + " Each test suite must have only one execution mode (parallel or sequential)."; private static final String MESSAGE_ERROR_LOADING_SMART_MODE_CONFIG_FILE = "Error loading smart " + "mode configuration file:"; private static final String LOG4J_CONFIGURATION_KEY = "log4j.configuration"; private static final String LOG4J_ERROR_PREFIX = "log4j: error loading log4j properties file."; private static final String LOG4J_ERROR_SUFFIX = "Using default configuration."; private static final String APP_HOME_KEY = "app.home"; // This class is a used in the interaction with the run configuration property file static class RunConfigurationProperties { static final String TEST_COVERAGE = "test.coverage"; static final String TEST_PARALLEL_THREAD_COUNT = "test.parallel.thread.count"; static final String TEST_SUITES_TO_RUN = "test.suites.active"; static final String TEST_SUITES_PARALLEL = "test.suites.parallel"; static final String TEST_SUITES_SEQUENTIAL = "test.suites.sequential"; static final String TEST_SUITES_RUN_UNSPECIFIED = "test.suites.run.mode.unspecified"; } // The possible ways to execute a test case public enum TestCaseRunMode { PARALLEL, SEQUENTIAL } // The typical configuration on how to configure the run of all tests as a bulk public enum BulkRunMode { ALL_PARALLEL, ALL_SEQUENTIAL, POSSIBLY_MIXED } // The possible ways to run tests: everything or the tests affected by current changelist public enum BuildMode { BASIC, CHANGED } public static void main(String[] args) { loadUserProperties(); configureLog4j(); ApplicationArgs appArgs = new ApplicationArgs(); parseArgs(args, appArgs); String projectPath = parseProjectPathArg(appArgs); final String contentPath = defaultIfEmpty(appArgs.getContentRoot(), projectPath + CONTENT_DIR); final String testsPath = defaultIfEmpty(appArgs.getTestRoot(), projectPath + TEST_DIR); List<String> testSuites = parseTestSuites(appArgs); boolean shouldPrintCoverageData = appArgs.shouldOutputCoverage(); boolean runTestsInParallel = appArgs.isParallel(); int threadCount = parseThreadCountArg(appArgs, runTestsInParallel); String testCaseTimeout = parseTestTimeout(appArgs); setProperty(TEST_CASE_TIMEOUT_IN_MINUTES_KEY, valueOf(testCaseTimeout)); final boolean shouldValidateDescription = appArgs.shouldValidateDescription(); final boolean shouldValidateCheckstyle = appArgs.shouldValidateCheckstyle(); String runConfigPath = FilenameUtils.normalize(appArgs.getRunConfigPath()); BuildMode buildMode = null; Set<String> changedFiles = null; try { String smartModePath = appArgs.getChangesOnlyConfigPath(); if (StringUtils.isEmpty(smartModePath)) { buildMode = BuildMode.BASIC; changedFiles = new HashSet<>(); printBuildModeInfo(buildMode); } else { buildMode = BuildMode.CHANGED; changedFiles = readChangedFilesFromSource(smartModePath); printBuildModeInfo(buildMode); } } catch (Exception ex) { log.error("Exception: " + ex.getMessage()); System.exit(1); } // Override with the values from the file if configured List<String> testSuitesParallel = new ArrayList<>(); List<String> testSuitesSequential = new ArrayList<>(); BulkRunMode bulkRunMode = runTestsInParallel ? ALL_PARALLEL : ALL_SEQUENTIAL; TestCaseRunMode unspecifiedTestSuiteRunMode = runTestsInParallel ? TestCaseRunMode.PARALLEL : TestCaseRunMode.SEQUENTIAL; if (get(runConfigPath).isAbsolute() && isRegularFile(get(runConfigPath), NOFOLLOW_LINKS) && equalsIgnoreCase(PROPERTIES_FILE_EXTENSION, FilenameUtils.getExtension(runConfigPath))) { Properties runConfigurationProperties = ArgumentProcessorUtils.getPropertiesFromFile(runConfigPath); shouldPrintCoverageData = getBooleanFromPropertiesWithDefault(TEST_COVERAGE, shouldPrintCoverageData, runConfigurationProperties); threadCount = getIntFromPropertiesWithDefaultAndRange(TEST_PARALLEL_THREAD_COUNT, Runtime.getRuntime().availableProcessors(), runConfigurationProperties, 1, MAX_THREADS_TEST_RUNNER + 1); testSuites = getTestSuitesForKey(runConfigurationProperties, TEST_SUITES_TO_RUN); testSuitesParallel = getTestSuitesForKey(runConfigurationProperties, TEST_SUITES_PARALLEL); testSuitesSequential = getTestSuitesForKey(runConfigurationProperties, TEST_SUITES_SEQUENTIAL); addErrorIfSameTestSuiteIsInBothParallelOrSequential(testSuitesParallel, testSuitesSequential); unspecifiedTestSuiteRunMode = getEnumInstanceFromPropertiesWithDefault(TEST_SUITES_RUN_UNSPECIFIED, unspecifiedTestSuiteRunMode, runConfigurationProperties); addWarningsForMisconfiguredTestSuites(unspecifiedTestSuiteRunMode, testSuites, testSuitesSequential, testSuitesParallel); bulkRunMode = POSSIBLY_MIXED; } else { // Warn when file is misconfigured, relative path, file does not exist or is not a properties file log.info(format(DID_NOT_DETECT_RUN_CONFIGURATION_PROPERTIES_FILE, runConfigPath)); } String testCaseReportLocation = getProperty(TEST_CASE_REPORT_LOCATION); if (StringUtils.isBlank(testCaseReportLocation)) { log.info("Test case report location property [" + TEST_CASE_REPORT_LOCATION + "] is not defined. Report will be skipped."); } // Setting thread count for visibility in ParallelTestCaseExecutorService setProperty(SLANG_TEST_RUNNER_THREAD_COUNT, valueOf(threadCount)); log.info(NEW_LINE + "------------------------------------------------------------"); log.info("Building project: " + projectPath); log.info("Content root is at: " + contentPath); log.info("Test root is at: " + testsPath); log.info("Active test suites are: " + getListForPrint(testSuites)); log.info("Parallel run mode is configured for test suites: " + getListForPrint(testSuitesParallel)); log.info("Sequential run mode is configured for test suites: " + getListForPrint(testSuitesSequential)); log.info("Default run mode '" + unspecifiedTestSuiteRunMode.name().toLowerCase() + "' is configured for test suites: " + getListForPrint( getDefaultRunModeTestSuites(testSuites, testSuitesParallel, testSuitesSequential))); log.info("Bulk run mode for tests: " + getBulkModeForPrint(bulkRunMode)); log.info("Print coverage data: " + valueOf(shouldPrintCoverageData)); log.info("Validate description: " + valueOf(shouldValidateDescription)); log.info("Validate checkstyle: " + valueOf(shouldValidateCheckstyle)); log.info("Thread count: " + threadCount); log.info("Test case timeout in minutes: " + (isEmpty(testCaseTimeout) ? valueOf(MAX_TIME_PER_TESTCASE_IN_MINUTES) : testCaseTimeout)); log.info(NEW_LINE + "Loading..."); ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("spring/testRunnerContext.xml"); context.registerShutdownHook(); SlangBuilder slangBuilder = context.getBean(SlangBuilder.class); LoggingService loggingService = context.getBean(LoggingServiceImpl.class); Slang slang = context.getBean(Slang.class); try { updateTestSuiteMappings(context.getBean(TestRunInfoService.class), testSuitesParallel, testSuitesSequential, testSuites, unspecifiedTestSuiteRunMode); registerEventHandlers(slang); List<RuntimeException> exceptions = new ArrayList<>(); SlangBuildResults buildResults = slangBuilder.buildSlangContent(projectPath, contentPath, testsPath, testSuites, shouldValidateDescription, shouldValidateCheckstyle, bulkRunMode, buildMode, changedFiles); exceptions.addAll(buildResults.getCompilationExceptions()); if (exceptions.size() > 0) { logErrors(exceptions, projectPath, loggingService); } IRunTestResults runTestsResults = buildResults.getRunTestsResults(); Map<String, TestRun> skippedTests = runTestsResults.getSkippedTests(); if (isNotEmpty(skippedTests)) { printSkippedTestsSummary(skippedTests, loggingService); } printPassedTests(runTestsResults, loggingService); if (shouldPrintCoverageData) { printTestCoverageData(runTestsResults, loggingService); } if (isNotEmpty(runTestsResults.getFailedTests())) { printBuildFailureSummary(projectPath, runTestsResults, loggingService); } else { printBuildSuccessSummary(contentPath, buildResults, runTestsResults, loggingService); } loggingService.waitForAllLogTasksToFinish(); generateTestCaseReport(context.getBean(SlangTestCaseRunReportGeneratorService.class), runTestsResults, testCaseReportLocation); System.exit(isNotEmpty(runTestsResults.getFailedTests()) ? 1 : 0); } catch (Throwable e) { logErrorsPrefix(loggingService); loggingService.logEvent(Level.ERROR, "Exception: " + e.getMessage()); logErrorsSuffix(projectPath, loggingService); loggingService.waitForAllLogTasksToFinish(); System.exit(1); } } private static void configureLog4j() { String configFilename = System.getProperty(LOG4J_CONFIGURATION_KEY); String errorMessage = null; try { if (StringUtils.isEmpty(configFilename)) { errorMessage = "Config file name is empty."; } else { String normalizedPath = FilenameUtils.normalize(configFilename); if (normalizedPath == null) { errorMessage = "Normalized config file path is null."; } else if (!isUnderAppHome(normalizedPath, getNormalizedApplicationHome())) { errorMessage = "Normalized config file path[" + normalizedPath + "] " + "is not under application home directory"; } else { if (!isRegularFile(get(normalizedPath), NOFOLLOW_LINKS)) { errorMessage = "Normalized config file path[" + normalizedPath + "]" + " does not lead to a regular file."; } else { Properties log4jProperties = new Properties(); try (InputStream log4jInputStream = SlangBuildMain.class .getResourceAsStream(normalizedPath)) { log4jProperties.load(log4jInputStream); PropertyConfigurator.configure(log4jProperties); } } } } } catch (IOException | RuntimeException ex) { errorMessage = ex.getMessage(); } if (StringUtils.isNotEmpty(errorMessage)) { System.out.printf("%s%n\t%s%n\t%s%n", LOG4J_ERROR_PREFIX, errorMessage, LOG4J_ERROR_SUFFIX); } } private static boolean isUnderAppHome(String normalizedFilePath, String normalizedAppHome) { return normalizedFilePath.startsWith(normalizedAppHome); } private static String getNormalizedApplicationHome() { String appHome = System.getProperty(APP_HOME_KEY); if (StringUtils.isEmpty(appHome)) { throw new RuntimeException(APP_HOME_KEY + " system property is empty"); } String normalizedAppHome = FilenameUtils.normalize(appHome); if (normalizedAppHome == null) { throw new RuntimeException("Normalized app home path is null."); } return normalizedAppHome; } private static void printBuildModeInfo(BuildMode buildMode) { log.info("Build mode set to: " + buildMode); } private static Set<String> readChangedFilesFromSource(String filePath) throws IOException { String normalizedPath = FilenameUtils.normalize(filePath); if (!get(normalizedPath).isAbsolute()) { throw new RuntimeException(MESSAGE_ERROR_LOADING_SMART_MODE_CONFIG_FILE + " Path[" + normalizedPath + "] is not an absolute path."); } if (!isRegularFile(get(normalizedPath), NOFOLLOW_LINKS)) { throw new RuntimeException(MESSAGE_ERROR_LOADING_SMART_MODE_CONFIG_FILE + " Path[" + normalizedPath + "] does not lead to a regular file."); } return ArgumentProcessorUtils.loadChangedItems(normalizedPath); } private static void addErrorIfSameTestSuiteIsInBothParallelOrSequential(List<String> testSuitesParallel, List<String> testSuitesSequential) { final List<String> intersection = ListUtils.intersection(testSuitesParallel, testSuitesSequential); if (!intersection.isEmpty()) { final String message = String.format(MESSAGE_BOTH_PARALLEL_AND_SEQUENTIAL_EXECUTION, getListForPrint(intersection)); log.error(message); throw new IllegalStateException(); } } /** * @param bulkRunMode the mode to configure the run of all tests * @return String friendly version for print to the log or console */ private static String getBulkModeForPrint(final BulkRunMode bulkRunMode) { return bulkRunMode.toString().replace("_", " ").toLowerCase(ENGLISH); } /** * @param testRunInfoService the service responsible for managing run information * @param parallelSuites the suite names to be executed in parallel * @param sequentialSuites the suite names to be executed in sequential manner * @param activeSuites the suite names that are active * @param unspecifiedTestSuiteRunMode the default run mode for suites that don't explicitly mention a run mode. */ private static void updateTestSuiteMappings(final TestRunInfoService testRunInfoService, final List<String> parallelSuites, final List<String> sequentialSuites, final List<String> activeSuites, final TestCaseRunMode unspecifiedTestSuiteRunMode) { testRunInfoService.setRunModeForTestSuites(parallelSuites, TestCaseRunMode.PARALLEL); testRunInfoService.setRunModeForTestSuites(sequentialSuites, TestCaseRunMode.SEQUENTIAL); testRunInfoService.setRunModeForTestSuites( getDefaultRunModeTestSuites(activeSuites, parallelSuites, sequentialSuites), unspecifiedTestSuiteRunMode); } /** * @param activeSuites the suite names that are active * @param parallelSuites the suite names to be executed in parallel * @param sequentialSuites the suite names to be executed in sequential manner * @return */ private static List<String> getDefaultRunModeTestSuites(final List<String> activeSuites, final List<String> parallelSuites, final List<String> sequentialSuites) { return removeAll(new ArrayList<>(activeSuites), union(parallelSuites, sequentialSuites)); } /** * @param unspecifiedTestSuiteRunMode the default run mode for suites that don't explicitly mention a run mode. * @param activeSuites the suite names that are active * @param sequentialSuites the suite names to be executed in sequential manner * @param parallelSuites the suite names to be executed in parallel */ private static void addWarningsForMisconfiguredTestSuites(final TestCaseRunMode unspecifiedTestSuiteRunMode, final List<String> activeSuites, final List<String> sequentialSuites, final List<String> parallelSuites) { addWarningForSubsetOfRules(activeSuites, sequentialSuites, TEST_SUITES_SEQUENTIAL); addWarningForSubsetOfRules(activeSuites, parallelSuites, TEST_SUITES_PARALLEL); addInformativeNoteForUnspecifiedRules(unspecifiedTestSuiteRunMode, activeSuites, sequentialSuites, parallelSuites); } /** * Displays an informative message in case there is at least one test suite left for default run mode. * * @param unspecifiedTestSuiteRunMode the default run mode for suites that don't explicitly mention a run mode. * @param activeSuites the suite names that are active * @param sequentialSuites the suite names to be executed in sequential manner * @param parallelSuites the suite names to be executed in parallel */ private static void addInformativeNoteForUnspecifiedRules(final TestCaseRunMode unspecifiedTestSuiteRunMode, final List<String> activeSuites, final List<String> sequentialSuites, final List<String> parallelSuites) { List<String> union = union(sequentialSuites, parallelSuites); if (!union.containsAll(activeSuites)) { List<String> copy = new ArrayList<>(activeSuites); copy.removeAll(union); log.info(format(MESSAGE_TEST_SUITES_WITH_UNSPECIFIED_MAPPING, getListForPrint(copy), unspecifiedTestSuiteRunMode.name())); } } /** * Displays a warning message for test suites that have rules defined for sequential or parallel execution * but are not in active test suites. * * @param testSuites suite names contained in 'container' suites * @param testSuitesContained suite names contained in 'contained' suites * @param key run configuration property key */ private static void addWarningForSubsetOfRules(List<String> testSuites, List<String> testSuitesContained, String key) { List<String> intersectWithContained = ListUtils.intersection(testSuites, testSuitesContained); if (intersectWithContained.size() != testSuitesContained.size()) { List<String> notScheduledForRun = new ArrayList<>(testSuitesContained); notScheduledForRun.removeAll(intersectWithContained); log.warn(format(MESSAGE_NOT_SCHEDULED_FOR_RUN_RULES, getListForPrint(notScheduledForRun), key)); } } /** * Returns the names of the suites from the run configuration java.util.Properties object at a certain key. * * @param runConfigurationProperties * @param key * @return */ private static List<String> getTestSuitesForKey(Properties runConfigurationProperties, String key) { final String valueList = runConfigurationProperties.getProperty(key); return ArgumentProcessorUtils.parseTestSuitesToList(valueList); } private static void logErrors(List<RuntimeException> exceptions, String projectPath, final LoggingService loggingService) { logErrorsPrefix(loggingService); for (RuntimeException runtimeException : exceptions) { loggingService.logEvent(Level.ERROR, "Exception: " + runtimeException.getMessage()); } logErrorsSuffix(projectPath, loggingService); loggingService.waitForAllLogTasksToFinish(); System.exit(1); } private static void logErrorsSuffix(String projectPath, final LoggingService loggingService) { loggingService.logEvent(Level.ERROR, "FAILURE: Validation of slang files for project: \"" + projectPath + "\" failed."); loggingService.logEvent(Level.ERROR, "------------------------------------------------------------"); loggingService.logEvent(Level.ERROR, ""); } private static void logErrorsPrefix(final LoggingService loggingService) { loggingService.logEvent(Level.ERROR, ""); loggingService.logEvent(Level.ERROR, "------------------------------------------------------------"); } private static void generateTestCaseReport(SlangTestCaseRunReportGeneratorService reportGeneratorService, IRunTestResults runTestsResults, String testCaseReportLocation) throws IOException { if (StringUtils.isNotBlank(testCaseReportLocation)) { Path reportDirectoryPath = get(testCaseReportLocation); if (!exists(reportDirectoryPath)) { createDirectories(reportDirectoryPath); } reportGeneratorService.generateReport(runTestsResults, reportDirectoryPath.toString()); } } @SuppressWarnings("Duplicates") private static void loadUserProperties() { try { UserConfigurationService userConfigurationService = new UserConfigurationServiceImpl(); userConfigurationService.loadUserProperties(); } catch (Exception ex) { System.out.println("Error occurred while loading user configuration: " + ex.getMessage()); ex.printStackTrace(); } } private static void parseArgs(String[] args, ApplicationArgs appArgs) { try { JCommander commander = new JCommander(appArgs, args); if (appArgs.isHelp()) { commander.usage(); System.exit(0); } } catch (ParameterException e) { System.out.println(e.getMessage()); System.out.println("You can use '--help' for usage"); System.exit(1); } } private static List<String> parseTestSuites(ApplicationArgs appArgs) { final List<String> testSuitesArg = ListUtils.defaultIfNull(appArgs.getTestSuites(), new ArrayList<String>()); return ArgumentProcessorUtils.parseTestSuitesToList(testSuitesArg); } private static String parseTestTimeout(ApplicationArgs appArgs) { Map<String, String> dynamicArgs = appArgs.getDynamicParams(); return dynamicArgs.get(TEST_CASE_TIMEOUT_IN_MINUTES_KEY); } private static int parseThreadCountArg(ApplicationArgs appArgs, boolean isParallel) { if (!isParallel) { return 1; } else { int defaultThreadCount = Runtime.getRuntime().availableProcessors(); String threadCountErrorMessage = format( "Thread count is misconfigured. The thread count value must be a " + "positive integer less than or equal to %d. Using %d threads.", MAX_THREADS_TEST_RUNNER, defaultThreadCount); try { String stringThreadCount = appArgs.getThreadCount(); if (stringThreadCount != null) { int threadCount = parseInt(stringThreadCount); if ((threadCount > 0) && (threadCount <= MAX_THREADS_TEST_RUNNER)) { return threadCount; } else { log.warn(threadCountErrorMessage); } } } catch (NumberFormatException nfEx) { log.warn(threadCountErrorMessage); } return defaultThreadCount; } } private static void printBuildSuccessSummary(String contentPath, SlangBuildResults buildResults, IRunTestResults runTestsResults, final LoggingService loggingService) { loggingService.logEvent(Level.INFO, ""); loggingService.logEvent(Level.INFO, "------------------------------------------------------------"); loggingService.logEvent(Level.INFO, "BUILD SUCCESS"); loggingService.logEvent(Level.INFO, "------------------------------------------------------------"); loggingService.logEvent(Level.INFO, "Found " + buildResults.getNumberOfCompiledSources() + " slang files under directory: \"" + contentPath + "\" and all are valid."); printNumberOfPassedAndSkippedTests(runTestsResults, loggingService); loggingService.logEvent(Level.INFO, ""); } private static void printNumberOfPassedAndSkippedTests(IRunTestResults runTestsResults, final LoggingService loggingService) { loggingService.logEvent(Level.INFO, runTestsResults.getPassedTests().size() + " test cases passed"); Map<String, TestRun> skippedTests = runTestsResults.getSkippedTests(); if (skippedTests.size() > 0) { loggingService.logEvent(Level.INFO, skippedTests.size() + " test cases skipped"); } } private static void printPassedTests(IRunTestResults runTestsResults, final LoggingService loggingService) { if (runTestsResults.getPassedTests().size() > 0) { loggingService.logEvent(Level.INFO, "------------------------------------------------------------"); loggingService.logEvent(Level.INFO, "Following " + runTestsResults.getPassedTests().size() + " test cases passed:"); for (Map.Entry<String, TestRun> passedTest : runTestsResults.getPassedTests().entrySet()) { String testCaseReference = SlangTestCase .generateTestCaseReference(passedTest.getValue().getTestCase()); loggingService.logEvent(Level.INFO, "- " + testCaseReference.replaceAll("\n", "\n\t")); } } } private static void printBuildFailureSummary(String projectPath, IRunTestResults runTestsResults, final LoggingService loggingService) { printNumberOfPassedAndSkippedTests(runTestsResults, loggingService); final Map<String, TestRun> failedTests = runTestsResults.getFailedTests(); logErrorsPrefix(loggingService); loggingService.logEvent(Level.ERROR, "BUILD FAILURE"); loggingService.logEvent(Level.ERROR, "------------------------------------------------------------"); loggingService.logEvent(Level.ERROR, "CloudSlang build for repository: \"" + projectPath + "\" failed due to failed tests."); loggingService.logEvent(Level.ERROR, "Following " + failedTests.size() + " tests failed:"); for (Map.Entry<String, TestRun> failedTest : failedTests.entrySet()) { String failureMessage = failedTest.getValue().getMessage(); loggingService.logEvent(Level.ERROR, "- " + failureMessage.replaceAll("\n", "\n\t")); } loggingService.logEvent(Level.ERROR, ""); } private static void printSkippedTestsSummary(Map<String, TestRun> skippedTests, final LoggingService loggingService) { loggingService.logEvent(Level.INFO, ""); loggingService.logEvent(Level.INFO, "------------------------------------------------------------"); loggingService.logEvent(Level.INFO, "Following " + skippedTests.size() + " tests were skipped:"); for (Map.Entry<String, TestRun> skippedTest : skippedTests.entrySet()) { String message = skippedTest.getValue().getMessage(); loggingService.logEvent(Level.INFO, "- " + message.replaceAll("\n", "\n\t")); } } private static void printTestCoverageData(IRunTestResults runTestsResults, final LoggingService loggingService) { printCoveredExecutables(runTestsResults.getCoveredExecutables(), loggingService); printUncoveredExecutables(runTestsResults.getUncoveredExecutables(), loggingService); int coveredExecutablesSize = runTestsResults.getCoveredExecutables().size(); int uncoveredExecutablesSize = runTestsResults.getUncoveredExecutables().size(); int totalNumberOfExecutables = coveredExecutablesSize + uncoveredExecutablesSize; double coveragePercentage = (double) coveredExecutablesSize / (double) totalNumberOfExecutables * 100; loggingService.logEvent(Level.INFO, ""); loggingService.logEvent(Level.INFO, "------------------------------------------------------------"); loggingService.logEvent(Level.INFO, ((int) coveragePercentage) + "% of the content has tests"); loggingService.logEvent(Level.INFO, "Out of " + totalNumberOfExecutables + " executables, " + coveredExecutablesSize + " executables have tests"); } private static void printCoveredExecutables(Set<String> coveredExecutables, final LoggingService loggingService) { loggingService.logEvent(Level.INFO, ""); loggingService.logEvent(Level.INFO, "------------------------------------------------------------"); loggingService.logEvent(Level.INFO, "Following " + coveredExecutables.size() + " executables have tests:"); for (String executable : coveredExecutables) { loggingService.logEvent(Level.INFO, "- " + executable); } } private static void printUncoveredExecutables(Set<String> uncoveredExecutables, final LoggingService loggingService) { loggingService.logEvent(Level.INFO, ""); loggingService.logEvent(Level.INFO, "------------------------------------------------------------"); loggingService.logEvent(Level.INFO, "Following " + uncoveredExecutables.size() + " executables do not have tests:"); for (String executable : uncoveredExecutables) { loggingService.logEvent(Level.INFO, "- " + executable); } } private static String parseProjectPathArg(ApplicationArgs args) { String repositoryPath; if (args.getProjectRoot() != null) { repositoryPath = args.getProjectRoot(); // if only one parameter was passed, we treat it as the project root // i.e. './cslang-builder some/path/to/project' } else if (args.getParameters().size() == 1) { repositoryPath = args.getParameters().get(0); } else { repositoryPath = System.getProperty("user.dir"); } repositoryPath = FilenameUtils.separatorsToSystem(repositoryPath); Validate.isTrue(new File(repositoryPath).isDirectory(), "Directory path argument \'" + repositoryPath + "\' does not lead to a directory"); return repositoryPath; } private static void registerEventHandlers(Slang slang) { slang.subscribeOnAllEvents(new ScoreEventListener() { @Override public synchronized void onEvent(ScoreEvent event) { logEvent(event); } }); } private static void logEvent(ScoreEvent event) { log.debug(("Event received: " + event.getEventType() + " Data is: " + event.getData())); } }