#!/usr/bin/env python

#

# run-tests.py - Run a set of tests on Mercurial

#

# Copyright 2006 Matt Mackall <mpm@selenic.com>

#

# This software may be used and distributed according to the terms of the

# GNU General Public License version 2 or any later version.

# Modifying this script is tricky because it has many modes:

#   - serial (default) vs parallel (-jN, N > 1)

#   - no coverage (default) vs coverage (-c, -C, -s)

#   - temp install (default) vs specific hg script (--with-hg, --local)

#   - tests are a mix of shell scripts and Python scripts

#

# If you change this script, it is recommended that you ensure you

# haven't broken it by running it in various modes with a representative

# sample of test scripts.  For example:

#

#  1) serial, no coverage, temp install:

#      ./run-tests.py test-s*

#  2) serial, no coverage, local hg:

#      ./run-tests.py --local test-s*

#  3) serial, coverage, temp install:

#      ./run-tests.py -c test-s*

#  4) serial, coverage, local hg:

#      ./run-tests.py -c --local test-s*      # unsupported

#  5) parallel, no coverage, temp install:

#      ./run-tests.py -j2 test-s*

#  6) parallel, no coverage, local hg:

#      ./run-tests.py -j2 --local test-s*

#  7) parallel, coverage, temp install:

#      ./run-tests.py -j2 -c test-s*          # currently broken

#  8) parallel, coverage, local install:

#      ./run-tests.py -j2 -c --local test-s*  # unsupported (and broken)

#  9) parallel, custom tmp dir:

#      ./run-tests.py -j2 --tmpdir /tmp/myhgtests

#

# (You could use any subset of the tests: test-s* happens to match

# enough that it's worth doing parallel runs, few enough that it

# completes fairly quickly, includes both shell and Python scripts, and

# includes some scripts that run daemon processes.)

from distutils import version

import difflib

import errno

import optparse

import os

import shutil

import subprocess

import signal

import sys

import tempfile

import time

import random

import re

import threading

import killdaemons as killmod

import Queue as queue

import unittest

processlock = threading.Lock()

# subprocess._cleanup can race with any Popen.wait or Popen.poll on py24

# http://bugs.python.org/issue1731717 for details. We shouldn't be producing

# zombies but it's pretty harmless even if we do.

if sys.version_info < (2, 5):

    subprocess._cleanup = lambda: None

closefds = os.name == 'posix'

def Popen4(cmd, wd, timeout, env=None):

    processlock.acquire()

    p = subprocess.Popen(cmd, shell=True, bufsize=-1, cwd=wd, env=env,

                         close_fds=closefds,

                         stdin=subprocess.PIPE, stdout=subprocess.PIPE,

                         stderr=subprocess.STDOUT)

    processlock.release()

    p.fromchild = p.stdout

    p.tochild = p.stdin

    p.childerr = p.stderr

    p.timeout = False

    if timeout:

        def t():

            start = time.time()

            while time.time() - start < timeout and p.returncode is None:

                time.sleep(.1)

            p.timeout = True

            if p.returncode is None:

                terminate(p)

        threading.Thread(target=t).start()

    return p

PYTHON = sys.executable.replace('\\', '/')

IMPL_PATH = 'PYTHONPATH'

if 'java' in sys.platform:

    IMPL_PATH = 'JYTHONPATH'

TESTDIR = HGTMP = INST = BINDIR = TMPBINDIR = PYTHONDIR = None

defaults = {

    'jobs': ('HGTEST_JOBS', 1),

    'timeout': ('HGTEST_TIMEOUT', 180),

    'port': ('HGTEST_PORT', 20059),

    'shell': ('HGTEST_SHELL', 'sh'),

}

def parselistfiles(files, listtype, warn=True):

    entries = dict()

    for filename in files:

        try:

            path = os.path.expanduser(os.path.expandvars(filename))

            f = open(path, "r")

        except IOError, err:

            if err.errno != errno.ENOENT:

                raise

            if warn:

                print "warning: no such %s file: %s" % (listtype, filename)

            continue

        for line in f.readlines():

            line = line.split('#', 1)[0].strip()

            if line:

                entries[line] = filename

        f.close()

    return entries

def getparser():

    """Obtain the OptionParser used by the CLI."""

    parser = optparse.OptionParser("%prog [options] [tests]")

    # keep these sorted

    parser.add_option("--blacklist", action="append",

        help="skip tests listed in the specified blacklist file")

    parser.add_option("--whitelist", action="append",

        help="always run tests listed in the specified whitelist file")

    parser.add_option("--changed", type="string",

        help="run tests that are changed in parent rev or working directory")

    parser.add_option("-C", "--annotate", action="store_true",

        help="output files annotated with coverage")

    parser.add_option("-c", "--cover", action="store_true",

        help="print a test coverage report")

    parser.add_option("-d", "--debug", action="store_true",

        help="debug mode: write output of test scripts to console"

             " rather than capturing and diffing it (disables timeout)")

    parser.add_option("-f", "--first", action="store_true",

        help="exit on the first test failure")

    parser.add_option("-H", "--htmlcov", action="store_true",

        help="create an HTML report of the coverage of the files")

    parser.add_option("-i", "--interactive", action="store_true",

        help="prompt to accept changed output")

    parser.add_option("-j", "--jobs", type="int",

        help="number of jobs to run in parallel"

             " (default: $%s or %d)" % defaults['jobs'])

    parser.add_option("--keep-tmpdir", action="store_true",

        help="keep temporary directory after running tests")

    parser.add_option("-k", "--keywords",

        help="run tests matching keywords")

    parser.add_option("-l", "--local", action="store_true",

        help="shortcut for --with-hg=<testdir>/../hg")

    parser.add_option("--loop", action="store_true",

        help="loop tests repeatedly")

    parser.add_option("-n", "--nodiff", action="store_true",

        help="skip showing test changes")

    parser.add_option("-p", "--port", type="int",

        help="port on which servers should listen"

             " (default: $%s or %d)" % defaults['port'])

    parser.add_option("--compiler", type="string",

        help="compiler to build with")

    parser.add_option("--pure", action="store_true",

        help="use pure Python code instead of C extensions")

    parser.add_option("-R", "--restart", action="store_true",

        help="restart at last error")

    parser.add_option("-r", "--retest", action="store_true",

        help="retest failed tests")

    parser.add_option("-S", "--noskips", action="store_true",

        help="don't report skip tests verbosely")

    parser.add_option("--shell", type="string",

        help="shell to use (default: $%s or %s)" % defaults['shell'])

    parser.add_option("-t", "--timeout", type="int",

        help="kill errant tests after TIMEOUT seconds"

             " (default: $%s or %d)" % defaults['timeout'])

    parser.add_option("--time", action="store_true",

        help="time how long each test takes")

    parser.add_option("--tmpdir", type="string",

        help="run tests in the given temporary directory"

             " (implies --keep-tmpdir)")

    parser.add_option("--unittest", action="store_true",

        help="run tests with Python's unittest package"

             " (this is an experimental feature)")

    parser.add_option("-v", "--verbose", action="store_true",

        help="output verbose messages")

    parser.add_option("--view", type="string",

        help="external diff viewer")

    parser.add_option("--with-hg", type="string",

        metavar="HG",

        help="test using specified hg script rather than a "

             "temporary installation")

    parser.add_option("-3", "--py3k-warnings", action="store_true",

        help="enable Py3k warnings on Python 2.6+")

    parser.add_option('--extra-config-opt', action="append",

                      help='set the given config opt in the test hgrc')

    parser.add_option('--random', action="store_true",

                      help='run tests in random order')

    for option, (envvar, default) in defaults.items():

        defaults[option] = type(default)(os.environ.get(envvar, default))

    parser.set_defaults(**defaults)

    return parser

def parseargs(args, parser):

    """Parse arguments with our OptionParser and validate results."""

    (options, args) = parser.parse_args(args)

    # jython is always pure

    if 'java' in sys.platform or '__pypy__' in sys.modules:

        options.pure = True

    if options.with_hg:

        options.with_hg = os.path.expanduser(options.with_hg)

        if not (os.path.isfile(options.with_hg) and

                os.access(options.with_hg, os.X_OK)):

            parser.error('--with-hg must specify an executable hg script')

        if not os.path.basename(options.with_hg) == 'hg':

            sys.stderr.write('warning: --with-hg should specify an hg script\n')

    if options.local:

        testdir = os.path.dirname(os.path.realpath(sys.argv[0]))

        hgbin = os.path.join(os.path.dirname(testdir), 'hg')

        if os.name != 'nt' and not os.access(hgbin, os.X_OK):

            parser.error('--local specified, but %r not found or not executable'

                         % hgbin)

        options.with_hg = hgbin

    options.anycoverage = options.cover or options.annotate or options.htmlcov

    if options.anycoverage:

        try:

            import coverage

            covver = version.StrictVersion(coverage.__version__).version

            if covver < (3, 3):

                parser.error('coverage options require coverage 3.3 or later')

        except ImportError:

            parser.error('coverage options now require the coverage package')

    if options.anycoverage and options.local:

        # this needs some path mangling somewhere, I guess

        parser.error("sorry, coverage options do not work when --local "

                     "is specified")

    global verbose

    if options.verbose:

        verbose = ''

    if options.tmpdir:

        options.tmpdir = os.path.expanduser(options.tmpdir)

    if options.jobs < 1:

        parser.error('--jobs must be positive')

    if options.interactive and options.debug:

        parser.error("-i/--interactive and -d/--debug are incompatible")

    if options.debug:

        if options.timeout != defaults['timeout']:

            sys.stderr.write(

                'warning: --timeout option ignored with --debug\n')

        options.timeout = 0

    if options.py3k_warnings:

        if sys.version_info[:2] < (2, 6) or sys.version_info[:2] >= (3, 0):

            parser.error('--py3k-warnings can only be used on Python 2.6+')

    if options.blacklist:

        options.blacklist = parselistfiles(options.blacklist, 'blacklist')

    if options.whitelist:

        options.whitelisted = parselistfiles(options.whitelist, 'whitelist')

    else:

        options.whitelisted = {}

    return (options, args)

def rename(src, dst):

    """Like os.rename(), trade atomicity and opened files friendliness

    for existing destination support.

    """

    shutil.copy(src, dst)

    os.remove(src)

def showdiff(expected, output, ref, err):

    print

    servefail = False

    for line in difflib.unified_diff(expected, output, ref, err):

        sys.stdout.write(line)

        if not servefail and line.startswith(

                             '+  abort: child process failed to start'):

            servefail = True

    return {'servefail': servefail}

verbose = False

def vlog(*msg):

    if verbose is not False:

        iolock.acquire()

        if verbose:

            print verbose,

        for m in msg:

            print m,

        print

        sys.stdout.flush()

        iolock.release()

def log(*msg):

    iolock.acquire()

    if verbose:

        print verbose,

    for m in msg:

        print m,

    print

    sys.stdout.flush()

    iolock.release()

def terminate(proc):

    """Terminate subprocess (with fallback for Python versions < 2.6)"""

    vlog('# Terminating process %d' % proc.pid)

    try:

        getattr(proc, 'terminate', lambda : os.kill(proc.pid, signal.SIGTERM))()

    except OSError:

        pass

def killdaemons(pidfile):

    return killmod.killdaemons(pidfile, tryhard=False, remove=True,

                               logfn=vlog)

class Test(object):

    """Encapsulates a single, runnable test.

    Test instances can be run multiple times via run(). However, multiple

    runs cannot be run concurrently.

    """

    # Status code reserved for skipped tests (used by hghave).

    SKIPPED_STATUS = 80

    def __init__(self, runner, test, count, refpath, unittest=False):

        path = os.path.join(runner.testdir, test)

        errpath = os.path.join(runner.testdir, '%s.err' % test)

        self.name = test

        self._runner = runner

        self._testdir = runner.testdir

        self._path = path

        self._options = runner.options

        self._count = count

        self._daemonpids = []

        self._refpath = refpath

        self._errpath = errpath

        self._unittest = unittest

        self._finished = None

        # If we're not in --debug mode and reference output file exists,

        # check test output against it.

        if runner.options.debug:

            self._refout = None # to match "out is None"

        elif os.path.exists(refpath):

            f = open(refpath, 'r')

            self._refout = f.read().splitlines(True)

            f.close()

        else: