run_tests.py

#!/usr/bin/env python

import os
import subprocess
import os.path as p
import sys

DIR_OF_THIS_SCRIPT = p.dirname( p.abspath( __file__ ) )
DIR_OF_THIRD_PARTY = p.join( DIR_OF_THIS_SCRIPT, 'third_party' )

python_path = []
for folder in os.listdir( DIR_OF_THIRD_PARTY ):
  python_path.append( p.abspath( p.join( DIR_OF_THIRD_PARTY, folder ) ) )
if os.environ.get( 'PYTHONPATH' ) is not None:
  python_path.append( os.environ['PYTHONPATH'] )
os.environ[ 'PYTHONPATH' ] = os.pathsep.join( python_path )

sys.path.insert( 1, p.abspath( p.join( DIR_OF_THIRD_PARTY, 'argparse' ) ) )

import argparse


def RunFlake8():
  print( 'Running flake8' )
  subprocess.check_call( [
    'flake8',
    '--select=F,C9',
    '--max-complexity=10',
    '--exclude=testdata',
    p.join( DIR_OF_THIS_SCRIPT, 'ycmd' )
  ] )


def ParseArguments():
  parser = argparse.ArgumentParser()
  parser.add_argument( '--no-clang-completer', action = 'store_true',
                       help = 'Do not test C-family '
                       'semantic completion engine.' )
  parser.add_argument( '--no-omnisharp-completer', action = 'store_true',
                       help = 'Do not test C# '
                       'semantic completion engine.' )
  parser.add_argument( '--no-tern-completer', action = 'store_true',
                       help = 'Do not test Javascript '
                       'semantic completion engine.' )
  parser.add_argument( '--no-gocode-completer', action = 'store_true',
                       help = 'Do not test GoCode '
                       'semantic completion engine.' )
  parser.add_argument( '--no-racer-completer', action = 'store_true',
                       help = 'Do not test Racer '
                       'semantic completion engine.' )
  parser.add_argument( '--no-typescript-completer', action = 'store_true',
                       help = 'Do not test TypeScript '
                       'semantic completion engine.' )
  parser.add_argument( '--no-python-completer', action = 'store_true',
                       help = 'Do not test Jedi'
                       'semantic completion engine.' )
  parser.add_argument( '--skip-build', action = 'store_true',
                       help = 'Do not build ycmd before testing.' )
  parser.add_argument( '--msvc', type = int, choices = [ 11, 12, 14 ],
                       help = 'Choose the Microsoft Visual '
                       'Studio version. (default: 14).' )
  parser.add_argument( '--arch', type = int, choices = [ 32, 64 ],
                       help = 'Force architecture to 32 or 64 bits on '
                       'Windows (default: python interpreter architecture).' )
  parser.add_argument( '--coverage', action = 'store_true',
                       help = 'Enable coverage report (requires coverage pkg)' )

  parsed_args, nosetests_args = parser.parse_known_args()

  if 'USE_CLANG_COMPLETER' in os.environ:
    parsed_args.no_clang_completer = ( os.environ[ 'USE_CLANG_COMPLETER' ]
                                       == 'false' )

  if 'COVERAGE' in os.environ:
    parsed_args.coverage = ( os.environ[ 'COVERAGE' ] == 'true' )

  return parsed_args, nosetests_args


def BuildYcmdLibs( args ):
  if not args.skip_build:
    extra_cmake_args = [ '-DUSE_DEV_FLAGS=ON' ]
    if not args.no_clang_completer:
      extra_cmake_args.append( '-DUSE_CLANG_COMPLETER=ON' )

    os.environ[ 'EXTRA_CMAKE_ARGS' ] = ' '.join(extra_cmake_args)
    os.environ[ 'YCM_TESTRUN' ] = '1'

    build_cmd = [
      sys.executable,
      p.join( DIR_OF_THIS_SCRIPT, 'build.py' ),
    ]

    if not args.no_omnisharp_completer:
      build_cmd.extend( [ '--omnisharp-completer' ] )
    if not args.no_tern_completer:
      build_cmd.extend( [ '--tern-completer' ] )
    if not args.no_gocode_completer:
      build_cmd.extend( [ '--gocode-completer' ] )
    if not args.no_racer_completer:
      build_cmd.extend( [ '--racer-completer' ] )

    if args.msvc:
      build_cmd.extend( [ '--msvc', str( args.msvc ) ] )

    if args.arch:
      build_cmd.extend( [ '--arch', str( args.arch ) ] )

    subprocess.check_call( build_cmd )


def NoseTests( parsed_args, extra_nosetests_args ):
  nosetests_args = [ '-v' ]
  if parsed_args.no_clang_completer:
    nosetests_args.append( '--exclude=.*Clang.*' )
  if parsed_args.no_tern_completer:
    nosetests_args.append( '--exclude=.*Javascript.*' )
  if parsed_args.no_gocode_completer:
    nosetests_args.append( '--exclude=.*GoCode.*' )
  if parsed_args.no_racer_completer:
    nosetests_args.append( '--exclude=.*Rust.*' )
  if parsed_args.no_typescript_completer:
    nosetests_args.append( '--exclude=.*TypeScript.*' )
  if parsed_args.no_omnisharp_completer:
    nosetests_args.append( '--exclude=.*Cs.*' )
  if parsed_args.no_python_completer:
    nosetests_args.append( '--exclude=.*Python.*' )

  if parsed_args.coverage:
    nosetests_args += [ '--with-coverage', '--cover-package=ycmd' ]

  if extra_nosetests_args:
    nosetests_args.extend( extra_nosetests_args )
  else:
    nosetests_args.append( p.join( DIR_OF_THIS_SCRIPT, 'ycmd' ) )

  subprocess.check_call( [ 'nosetests' ] + nosetests_args )


def Main():
  parsed_args, nosetests_args = ParseArguments()
  RunFlake8()
  BuildYcmdLibs( parsed_args )
  NoseTests( parsed_args, nosetests_args )

if __name__ == "__main__":
  Main()