from __future__ import absolute_import

from __future__ import unicode_literals

import contextlib

import distutils.spawn

import io

import os

import sys

import pytest

from pre_commit import parse_shebang

from pre_commit.envcontext import envcontext

from pre_commit.envcontext import Var

from pre_commit.util import make_executable

def test_file_doesnt_exist():

assert parse_shebang.parse_filename('herp derp derp') == ()

def test_simple_case(tmpdir):

x = tmpdir.join('f')

x.write_text('#!/usr/bin/env python', encoding='UTF-8')

make_executable(x.strpath)

assert parse_shebang.parse_filename(x.strpath) == ('python',)

def test_find_executable_full_path():

assert parse_shebang.find_executable(sys.executable) == sys.executable

def test_find_executable_on_path():

expected = distutils.spawn.find_executable('echo')

assert parse_shebang.find_executable('echo') == expected

def test_find_executable_not_found_none():

assert parse_shebang.find_executable('not-a-real-executable') is None

def write_executable(shebang, filename='run'):

os.mkdir('bin')

path = os.path.join('bin', filename)

with io.open(path, 'w') as f:

f.write('#!{}'.format(shebang))

make_executable(path)

return path

@contextlib.contextmanager

def bin_on_path():

bindir = os.path.join(os.getcwd(), 'bin')

with envcontext((('PATH', (bindir, os.pathsep, Var('PATH'))),)):

yield

def test_find_executable_path_added(in_tmpdir):

path = os.path.abspath(write_executable('/usr/bin/env sh'))

assert parse_shebang.find_executable('run') is None

with bin_on_path():

assert parse_shebang.find_executable('run') == path

def test_find_executable_path_ext(in_tmpdir):

"""Windows exports PATHEXT as a list of extensions to automatically add

to executables when doing PATH searching.

"""

exe_path = os.path.abspath(write_executable(

'/usr/bin/env sh', filename='run.myext',

))

env_path = {'PATH': os.path.dirname(exe_path)}

env_path_ext = dict(env_path, PATHEXT=os.pathsep.join(('.exe', '.myext')))

assert parse_shebang.find_executable('run') is None

assert parse_shebang.find_executable('run', _environ=env_path) is None

ret = parse_shebang.find_executable('run.myext', _environ=env_path)

assert ret == exe_path

ret = parse_shebang.find_executable('run', _environ=env_path_ext)

assert ret == exe_path

def test_normexe_does_not_exist():

with pytest.raises(OSError) as excinfo:

parse_shebang.normexe('i-dont-exist-lol')

assert excinfo.value.args == ('Executable `i-dont-exist-lol` not found',)

def test_normexe_does_not_exist_sep():

with pytest.raises(OSError) as excinfo:

parse_shebang.normexe('./i-dont-exist-lol')

assert excinfo.value.args == ('Executable `./i-dont-exist-lol` not found',)

def test_normexe_is_a_directory(tmpdir):

with tmpdir.as_cwd():

tmpdir.join('exe').ensure_dir()

exe = os.path.join('.', 'exe')

with pytest.raises(OSError) as excinfo:

parse_shebang.normexe(exe)

msg, = excinfo.value.args

assert msg == 'Executable `{}` is a directory'.format(exe)

def test_normexe_already_full_path():

assert parse_shebang.normexe(sys.executable) == sys.executable

def test_normexe_gives_full_path():

expected = distutils.spawn.find_executable('echo')

assert parse_shebang.normexe('echo') == expected

assert os.sep in expected

def test_normalize_cmd_trivial():

cmd = (distutils.spawn.find_executable('echo'), 'hi')

assert parse_shebang.normalize_cmd(cmd) == cmd

def test_normalize_cmd_PATH():

cmd = ('python', '--version')

expected = (distutils.spawn.find_executable('python'), '--version')

assert parse_shebang.normalize_cmd(cmd) == expected

def test_normalize_cmd_shebang(in_tmpdir):

python = distutils.spawn.find_executable('python').replace(os.sep, '/')

path = write_executable(python)

assert parse_shebang.normalize_cmd((path,)) == (python, path)

def test_normalize_cmd_PATH_shebang_full_path(in_tmpdir):

python = distutils.spawn.find_executable('python').replace(os.sep, '/')

path = write_executable(python)

with bin_on_path():

ret = parse_shebang.normalize_cmd(('run',))

assert ret == (python, os.path.abspath(path))

def test_normalize_cmd_PATH_shebang_PATH(in_tmpdir):

python = distutils.spawn.find_executable('python')

path = write_executable('/usr/bin/env python')

with bin_on_path():

ret = parse_shebang.normalize_cmd(('run',))

assert ret == (python, os.path.abspath(path))