atest/atest.py

#!/usr/bin/env python
#
# Copyright 2017, The Android Open Source Project
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

"""
Command line utility for running Android tests through TradeFederation.

atest helps automate the flow of building test modules across the Android
code base and executing the tests via the TradeFederation test harness.

atest is designed to support any test types that can be ran by TradeFederation.
"""

import logging
import os
import subprocess
import sys

import cli_translator
ANDROID_BUILD_TOP = 'ANDROID_BUILD_TOP'
EXPECTED_VARS = frozenset([
    ANDROID_BUILD_TOP,
    'ANDROID_TARGET_OUT_TESTCASES',
    'OUT'])
EXIT_CODE_ENV_NOT_SETUP = 1
EXIT_CODE_BUILD_FAILURE = 2
BUILD_CMD = ['make', '-j', '-C', os.environ.get(ANDROID_BUILD_TOP)]
TESTS_HELP_TEXT = '''Tests to run.

Ways to identify a test:
MODULE NAME    Examples: CtsJankDeviceTestCases
CLASS NAME     Examples: CtsDeviceJankUi, android.jank.cts.ui.CtsDeviceJankUi
FILE PATH      Examples: ., <rel_or_abs_path>/jank, <rel_or_abs_path>/CtsDeviceJankUi.java

NOTE: CLASS NAME and FILE PATH currently will run the entire module, not just the class.
'''

def _parse_args(argv):
    """Parse command line arguments.

    Args:
        argv: A list of arguments.

    Returns:
        An argspace.Namespace class instance holding parsed args.
    """
    import argparse
    parser = argparse.ArgumentParser(
        description='Build and run Android tests locally.',
        formatter_class=argparse.RawTextHelpFormatter)
    parser.add_argument('tests', nargs='+', help=TESTS_HELP_TEXT)
    parser.add_argument('-v', '--verbose', action='store_true',
                        help='Display DEBUG level logging.')
    return parser.parse_args(argv)


def _configure_logging(verbose):
    """Configure the logger.

    Args:
        verbose: A boolean. If true display DEBUG level logs.
    """
    if verbose:
        logging.basicConfig(level=logging.DEBUG)
    else:
        logging.basicConfig(level=logging.INFO)


def _missing_environment_variables():
    """Verify the local environment has been set up to run atest.

    Returns:
        List of strings of any missing environment variables.
    """
    missing = filter(None, [x for x in EXPECTED_VARS if not os.environ.get(x)])
    if missing:
        logging.error('Local environment doesn\'t appear to have been '
                      'initialized. Did you remember to run lunch? Expected '
                      'Environment Variables: %s.', missing)
    return missing


def build_tests(build_targets, verbose=False):
    """Shell out and make build_targets.

    Args:
        build_targets: A set of strings of build targets to make.

    Returns:
        Boolean of whether build command was successful.
    """
    logging.info('Building tests')
    cmd = BUILD_CMD + list(build_targets)
    logging.debug('Executing command: %s', cmd)
    try:
        if verbose:
            subprocess.check_call(cmd, stderr=subprocess.STDOUT)
        else:
            # TODO: Save output to a log file.
            subprocess.check_output(cmd, stderr=subprocess.STDOUT)
        logging.info('Build successful')
        return True
    except subprocess.CalledProcessError as err:
        logging.error('Error building: %s', build_targets)
        if err.output:
            logging.error(err.output)
        return False


def run_tests(run_commands):
    """Shell out and execute tradefed run commands.

    Args:
        run_commands: A list of strings of Tradefed run commands.
    """
    logging.info('Running tests')
    # TODO: Build result parser for run command. Until then display raw stdout.
    for run_command in run_commands:
        logging.debug('Executing command: %s', run_command)
        subprocess.check_call(run_command, shell=True, stderr=subprocess.STDOUT)


def main(argv):
    """Entry point of atest script.

    Args:
        argv: A list of arguments.
    """
    args = _parse_args(argv)
    _configure_logging(args.verbose)
    if _missing_environment_variables():
        return EXIT_CODE_ENV_NOT_SETUP
    repo_root = os.environ.get(ANDROID_BUILD_TOP)
    translator = cli_translator.CLITranslator(root_dir=repo_root)
    build_targets, run_commands = translator.translate(args.tests)
    if not build_tests(build_targets, args.verbose):
        return EXIT_CODE_BUILD_FAILURE
    run_tests(run_commands)


if __name__ == '__main__':
    sys.exit(main(sys.argv[1:]))