|
|
# encoding: utf-8
|
|
|
"""Tests for IPython.utils.path.py"""
|
|
|
|
|
|
# Copyright (c) IPython Development Team.
|
|
|
# Distributed under the terms of the Modified BSD License.
|
|
|
|
|
|
import os
|
|
|
import shutil
|
|
|
import sys
|
|
|
import tempfile
|
|
|
import unittest
|
|
|
from contextlib import contextmanager
|
|
|
from importlib import reload
|
|
|
from os.path import abspath, join
|
|
|
from unittest.mock import patch
|
|
|
|
|
|
import pytest
|
|
|
from tempfile import TemporaryDirectory
|
|
|
|
|
|
import IPython
|
|
|
from IPython import paths
|
|
|
from IPython.testing import decorators as dec
|
|
|
from IPython.testing.decorators import (
|
|
|
onlyif_unicode_paths,
|
|
|
skip_if_not_win32,
|
|
|
skip_win32,
|
|
|
)
|
|
|
from IPython.testing.tools import make_tempfile
|
|
|
from IPython.utils import path
|
|
|
|
|
|
# Platform-dependent imports
|
|
|
try:
|
|
|
import winreg as wreg
|
|
|
except ImportError:
|
|
|
#Fake _winreg module on non-windows platforms
|
|
|
import types
|
|
|
wr_name = "winreg"
|
|
|
sys.modules[wr_name] = types.ModuleType(wr_name)
|
|
|
try:
|
|
|
import winreg as wreg
|
|
|
except ImportError:
|
|
|
import _winreg as wreg
|
|
|
|
|
|
#Add entries that needs to be stubbed by the testing code
|
|
|
(wreg.OpenKey, wreg.QueryValueEx,) = (None, None)
|
|
|
|
|
|
#-----------------------------------------------------------------------------
|
|
|
# Globals
|
|
|
#-----------------------------------------------------------------------------
|
|
|
env = os.environ
|
|
|
TMP_TEST_DIR = tempfile.mkdtemp()
|
|
|
HOME_TEST_DIR = join(TMP_TEST_DIR, "home_test_dir")
|
|
|
#
|
|
|
# Setup/teardown functions/decorators
|
|
|
#
|
|
|
|
|
|
def setup_module():
|
|
|
"""Setup testenvironment for the module:
|
|
|
|
|
|
- Adds dummy home dir tree
|
|
|
"""
|
|
|
# Do not mask exceptions here. In particular, catching WindowsError is a
|
|
|
# problem because that exception is only defined on Windows...
|
|
|
os.makedirs(os.path.join(HOME_TEST_DIR, 'ipython'))
|
|
|
|
|
|
|
|
|
def teardown_module():
|
|
|
"""Teardown testenvironment for the module:
|
|
|
|
|
|
- Remove dummy home dir tree
|
|
|
"""
|
|
|
# Note: we remove the parent test dir, which is the root of all test
|
|
|
# subdirs we may have created. Use shutil instead of os.removedirs, so
|
|
|
# that non-empty directories are all recursively removed.
|
|
|
shutil.rmtree(TMP_TEST_DIR)
|
|
|
|
|
|
|
|
|
# Build decorator that uses the setup_environment/setup_environment
|
|
|
@pytest.fixture
|
|
|
def environment():
|
|
|
global oldstuff, platformstuff
|
|
|
oldstuff = (
|
|
|
env.copy(),
|
|
|
os.name,
|
|
|
sys.platform,
|
|
|
path.get_home_dir,
|
|
|
IPython.__file__,
|
|
|
os.getcwd(),
|
|
|
)
|
|
|
|
|
|
yield
|
|
|
|
|
|
(
|
|
|
oldenv,
|
|
|
os.name,
|
|
|
sys.platform,
|
|
|
path.get_home_dir,
|
|
|
IPython.__file__,
|
|
|
old_wd,
|
|
|
) = oldstuff
|
|
|
os.chdir(old_wd)
|
|
|
reload(path)
|
|
|
|
|
|
for key in list(env):
|
|
|
if key not in oldenv:
|
|
|
del env[key]
|
|
|
env.update(oldenv)
|
|
|
assert not hasattr(sys, "frozen")
|
|
|
|
|
|
|
|
|
with_environment = pytest.mark.usefixtures("environment")
|
|
|
|
|
|
|
|
|
@skip_if_not_win32
|
|
|
@with_environment
|
|
|
def test_get_home_dir_1(monkeypatch):
|
|
|
"""Testcase for py2exe logic, un-compressed lib
|
|
|
"""
|
|
|
unfrozen = path.get_home_dir()
|
|
|
monkeypatch.setattr(sys, "frozen", True, raising=False)
|
|
|
|
|
|
#fake filename for IPython.__init__
|
|
|
IPython.__file__ = abspath(join(HOME_TEST_DIR, "Lib/IPython/__init__.py"))
|
|
|
|
|
|
home_dir = path.get_home_dir()
|
|
|
assert home_dir == unfrozen
|
|
|
|
|
|
|
|
|
@skip_if_not_win32
|
|
|
@with_environment
|
|
|
def test_get_home_dir_2(monkeypatch):
|
|
|
"""Testcase for py2exe logic, compressed lib
|
|
|
"""
|
|
|
unfrozen = path.get_home_dir()
|
|
|
monkeypatch.setattr(sys, "frozen", True, raising=False)
|
|
|
# fake filename for IPython.__init__
|
|
|
IPython.__file__ = abspath(
|
|
|
join(HOME_TEST_DIR, "Library.zip/IPython/__init__.py")
|
|
|
).lower()
|
|
|
|
|
|
home_dir = path.get_home_dir(True)
|
|
|
assert home_dir == unfrozen
|
|
|
|
|
|
|
|
|
@skip_win32
|
|
|
@with_environment
|
|
|
def test_get_home_dir_3():
|
|
|
"""get_home_dir() uses $HOME if set"""
|
|
|
env["HOME"] = HOME_TEST_DIR
|
|
|
home_dir = path.get_home_dir(True)
|
|
|
# get_home_dir expands symlinks
|
|
|
assert home_dir == os.path.realpath(env["HOME"])
|
|
|
|
|
|
|
|
|
@with_environment
|
|
|
def test_get_home_dir_4():
|
|
|
"""get_home_dir() still works if $HOME is not set"""
|
|
|
|
|
|
if 'HOME' in env: del env['HOME']
|
|
|
# this should still succeed, but we don't care what the answer is
|
|
|
home = path.get_home_dir(False)
|
|
|
|
|
|
@skip_win32
|
|
|
@with_environment
|
|
|
def test_get_home_dir_5(monkeypatch):
|
|
|
"""raise HomeDirError if $HOME is specified, but not a writable dir"""
|
|
|
env['HOME'] = abspath(HOME_TEST_DIR+'garbage')
|
|
|
# set os.name = posix, to prevent My Documents fallback on Windows
|
|
|
monkeypatch.setattr(os, "name", "posix")
|
|
|
pytest.raises(path.HomeDirError, path.get_home_dir, True)
|
|
|
|
|
|
# Should we stub wreg fully so we can run the test on all platforms?
|
|
|
@skip_if_not_win32
|
|
|
@with_environment
|
|
|
def test_get_home_dir_8(monkeypatch):
|
|
|
"""Using registry hack for 'My Documents', os=='nt'
|
|
|
|
|
|
HOMESHARE, HOMEDRIVE, HOMEPATH, USERPROFILE and others are missing.
|
|
|
"""
|
|
|
monkeypatch.setattr(os, "name", "nt")
|
|
|
# Remove from stub environment all keys that may be set
|
|
|
for key in ['HOME', 'HOMESHARE', 'HOMEDRIVE', 'HOMEPATH', 'USERPROFILE']:
|
|
|
env.pop(key, None)
|
|
|
|
|
|
class key:
|
|
|
def __enter__(self):
|
|
|
pass
|
|
|
def Close(self):
|
|
|
pass
|
|
|
def __exit__(*args, **kwargs):
|
|
|
pass
|
|
|
|
|
|
with patch.object(wreg, 'OpenKey', return_value=key()), \
|
|
|
patch.object(wreg, 'QueryValueEx', return_value=[abspath(HOME_TEST_DIR)]):
|
|
|
home_dir = path.get_home_dir()
|
|
|
assert home_dir == abspath(HOME_TEST_DIR)
|
|
|
|
|
|
@with_environment
|
|
|
def test_get_xdg_dir_0(monkeypatch):
|
|
|
"""test_get_xdg_dir_0, check xdg_dir"""
|
|
|
monkeypatch.setattr(path, "_writable_dir", lambda path: True)
|
|
|
monkeypatch.setattr(path, "get_home_dir", lambda: "somewhere")
|
|
|
monkeypatch.setattr(os, "name", "posix")
|
|
|
monkeypatch.setattr(sys, "platform", "linux2")
|
|
|
env.pop('IPYTHON_DIR', None)
|
|
|
env.pop('IPYTHONDIR', None)
|
|
|
env.pop('XDG_CONFIG_HOME', None)
|
|
|
|
|
|
assert path.get_xdg_dir() == os.path.join("somewhere", ".config")
|
|
|
|
|
|
|
|
|
@with_environment
|
|
|
def test_get_xdg_dir_1(monkeypatch):
|
|
|
"""test_get_xdg_dir_1, check nonexistent xdg_dir"""
|
|
|
monkeypatch.setattr(path, "get_home_dir", lambda: HOME_TEST_DIR)
|
|
|
monkeypatch.setattr(os, "name", "posix")
|
|
|
monkeypatch.setattr(sys, "platform", "linux2")
|
|
|
env.pop("IPYTHON_DIR", None)
|
|
|
env.pop("IPYTHONDIR", None)
|
|
|
env.pop("XDG_CONFIG_HOME", None)
|
|
|
assert path.get_xdg_dir() is None
|
|
|
|
|
|
@with_environment
|
|
|
def test_get_xdg_dir_2(monkeypatch):
|
|
|
"""test_get_xdg_dir_2, check xdg_dir default to ~/.config"""
|
|
|
monkeypatch.setattr(path, "get_home_dir", lambda: HOME_TEST_DIR)
|
|
|
monkeypatch.setattr(os, "name", "posix")
|
|
|
monkeypatch.setattr(sys, "platform", "linux2")
|
|
|
env.pop("IPYTHON_DIR", None)
|
|
|
env.pop("IPYTHONDIR", None)
|
|
|
env.pop("XDG_CONFIG_HOME", None)
|
|
|
cfgdir = os.path.join(path.get_home_dir(), ".config")
|
|
|
if not os.path.exists(cfgdir):
|
|
|
os.makedirs(cfgdir)
|
|
|
|
|
|
assert path.get_xdg_dir() == cfgdir
|
|
|
|
|
|
@with_environment
|
|
|
def test_get_xdg_dir_3(monkeypatch):
|
|
|
"""test_get_xdg_dir_3, check xdg_dir not used on non-posix systems"""
|
|
|
monkeypatch.setattr(path, "get_home_dir", lambda: HOME_TEST_DIR)
|
|
|
monkeypatch.setattr(os, "name", "nt")
|
|
|
monkeypatch.setattr(sys, "platform", "win32")
|
|
|
env.pop("IPYTHON_DIR", None)
|
|
|
env.pop("IPYTHONDIR", None)
|
|
|
env.pop("XDG_CONFIG_HOME", None)
|
|
|
cfgdir = os.path.join(path.get_home_dir(), ".config")
|
|
|
os.makedirs(cfgdir, exist_ok=True)
|
|
|
|
|
|
assert path.get_xdg_dir() is None
|
|
|
|
|
|
def test_filefind():
|
|
|
"""Various tests for filefind"""
|
|
|
f = tempfile.NamedTemporaryFile()
|
|
|
# print('fname:',f.name)
|
|
|
alt_dirs = paths.get_ipython_dir()
|
|
|
t = path.filefind(f.name, alt_dirs)
|
|
|
# print('found:',t)
|
|
|
|
|
|
|
|
|
@dec.skip_if_not_win32
|
|
|
def test_get_long_path_name_win32():
|
|
|
with TemporaryDirectory() as tmpdir:
|
|
|
|
|
|
# Make a long path. Expands the path of tmpdir prematurely as it may already have a long
|
|
|
# path component, so ensure we include the long form of it
|
|
|
long_path = os.path.join(path.get_long_path_name(tmpdir), 'this is my long path name')
|
|
|
os.makedirs(long_path)
|
|
|
|
|
|
# Test to see if the short path evaluates correctly.
|
|
|
short_path = os.path.join(tmpdir, 'THISIS~1')
|
|
|
evaluated_path = path.get_long_path_name(short_path)
|
|
|
assert evaluated_path.lower() == long_path.lower()
|
|
|
|
|
|
|
|
|
@dec.skip_win32
|
|
|
def test_get_long_path_name():
|
|
|
p = path.get_long_path_name("/usr/local")
|
|
|
assert p == "/usr/local"
|
|
|
|
|
|
|
|
|
@dec.skip_win32 # can't create not-user-writable dir on win
|
|
|
@with_environment
|
|
|
def test_not_writable_ipdir():
|
|
|
tmpdir = tempfile.mkdtemp()
|
|
|
os.name = "posix"
|
|
|
env.pop("IPYTHON_DIR", None)
|
|
|
env.pop("IPYTHONDIR", None)
|
|
|
env.pop("XDG_CONFIG_HOME", None)
|
|
|
env["HOME"] = tmpdir
|
|
|
ipdir = os.path.join(tmpdir, ".ipython")
|
|
|
os.mkdir(ipdir, 0o555)
|
|
|
try:
|
|
|
open(os.path.join(ipdir, "_foo_"), "w", encoding="utf-8").close()
|
|
|
except IOError:
|
|
|
pass
|
|
|
else:
|
|
|
# I can still write to an unwritable dir,
|
|
|
# assume I'm root and skip the test
|
|
|
pytest.skip("I can't create directories that I can't write to")
|
|
|
|
|
|
with pytest.warns(UserWarning, match="is not a writable location"):
|
|
|
ipdir = paths.get_ipython_dir()
|
|
|
env.pop("IPYTHON_DIR", None)
|
|
|
|
|
|
|
|
|
@with_environment
|
|
|
def test_get_py_filename():
|
|
|
os.chdir(TMP_TEST_DIR)
|
|
|
with make_tempfile("foo.py"):
|
|
|
assert path.get_py_filename("foo.py") == "foo.py"
|
|
|
assert path.get_py_filename("foo") == "foo.py"
|
|
|
with make_tempfile("foo"):
|
|
|
assert path.get_py_filename("foo") == "foo"
|
|
|
pytest.raises(IOError, path.get_py_filename, "foo.py")
|
|
|
pytest.raises(IOError, path.get_py_filename, "foo")
|
|
|
pytest.raises(IOError, path.get_py_filename, "foo.py")
|
|
|
true_fn = "foo with spaces.py"
|
|
|
with make_tempfile(true_fn):
|
|
|
assert path.get_py_filename("foo with spaces") == true_fn
|
|
|
assert path.get_py_filename("foo with spaces.py") == true_fn
|
|
|
pytest.raises(IOError, path.get_py_filename, '"foo with spaces.py"')
|
|
|
pytest.raises(IOError, path.get_py_filename, "'foo with spaces.py'")
|
|
|
|
|
|
@onlyif_unicode_paths
|
|
|
def test_unicode_in_filename():
|
|
|
"""When a file doesn't exist, the exception raised should be safe to call
|
|
|
str() on - i.e. in Python 2 it must only have ASCII characters.
|
|
|
|
|
|
https://github.com/ipython/ipython/issues/875
|
|
|
"""
|
|
|
try:
|
|
|
# these calls should not throw unicode encode exceptions
|
|
|
path.get_py_filename('fooéè.py')
|
|
|
except IOError as ex:
|
|
|
str(ex)
|
|
|
|
|
|
|
|
|
class TestShellGlob(unittest.TestCase):
|
|
|
|
|
|
@classmethod
|
|
|
def setUpClass(cls):
|
|
|
cls.filenames_start_with_a = ['a0', 'a1', 'a2']
|
|
|
cls.filenames_end_with_b = ['0b', '1b', '2b']
|
|
|
cls.filenames = cls.filenames_start_with_a + cls.filenames_end_with_b
|
|
|
cls.tempdir = TemporaryDirectory()
|
|
|
td = cls.tempdir.name
|
|
|
|
|
|
with cls.in_tempdir():
|
|
|
# Create empty files
|
|
|
for fname in cls.filenames:
|
|
|
open(os.path.join(td, fname), "w", encoding="utf-8").close()
|
|
|
|
|
|
@classmethod
|
|
|
def tearDownClass(cls):
|
|
|
cls.tempdir.cleanup()
|
|
|
|
|
|
@classmethod
|
|
|
@contextmanager
|
|
|
def in_tempdir(cls):
|
|
|
save = os.getcwd()
|
|
|
try:
|
|
|
os.chdir(cls.tempdir.name)
|
|
|
yield
|
|
|
finally:
|
|
|
os.chdir(save)
|
|
|
|
|
|
def check_match(self, patterns, matches):
|
|
|
with self.in_tempdir():
|
|
|
# glob returns unordered list. that's why sorted is required.
|
|
|
assert sorted(path.shellglob(patterns)) == sorted(matches)
|
|
|
|
|
|
def common_cases(self):
|
|
|
return [
|
|
|
(['*'], self.filenames),
|
|
|
(['a*'], self.filenames_start_with_a),
|
|
|
(['*c'], ['*c']),
|
|
|
(['*', 'a*', '*b', '*c'], self.filenames
|
|
|
+ self.filenames_start_with_a
|
|
|
+ self.filenames_end_with_b
|
|
|
+ ['*c']),
|
|
|
(['a[012]'], self.filenames_start_with_a),
|
|
|
]
|
|
|
|
|
|
@skip_win32
|
|
|
def test_match_posix(self):
|
|
|
for (patterns, matches) in self.common_cases() + [
|
|
|
([r'\*'], ['*']),
|
|
|
([r'a\*', 'a*'], ['a*'] + self.filenames_start_with_a),
|
|
|
([r'a\[012]'], ['a[012]']),
|
|
|
]:
|
|
|
self.check_match(patterns, matches)
|
|
|
|
|
|
@skip_if_not_win32
|
|
|
def test_match_windows(self):
|
|
|
for (patterns, matches) in self.common_cases() + [
|
|
|
# In windows, backslash is interpreted as path
|
|
|
# separator. Therefore, you can't escape glob
|
|
|
# using it.
|
|
|
([r'a\*', 'a*'], [r'a\*'] + self.filenames_start_with_a),
|
|
|
([r'a\[012]'], [r'a\[012]']),
|
|
|
]:
|
|
|
self.check_match(patterns, matches)
|
|
|
|
|
|
|
|
|
@pytest.mark.parametrize(
|
|
|
"globstr, unescaped_globstr",
|
|
|
[
|
|
|
(r"\*\[\!\]\?", "*[!]?"),
|
|
|
(r"\\*", r"\*"),
|
|
|
(r"\\\*", r"\*"),
|
|
|
(r"\\a", r"\a"),
|
|
|
(r"\a", r"\a"),
|
|
|
],
|
|
|
)
|
|
|
def test_unescape_glob(globstr, unescaped_globstr):
|
|
|
assert path.unescape_glob(globstr) == unescaped_globstr
|
|
|
|
|
|
|
|
|
@onlyif_unicode_paths
|
|
|
def test_ensure_dir_exists():
|
|
|
with TemporaryDirectory() as td:
|
|
|
d = os.path.join(td, '∂ir')
|
|
|
path.ensure_dir_exists(d) # create it
|
|
|
assert os.path.isdir(d)
|
|
|
path.ensure_dir_exists(d) # no-op
|
|
|
f = os.path.join(td, "ƒile")
|
|
|
open(f, "w", encoding="utf-8").close() # touch
|
|
|
with pytest.raises(IOError):
|
|
|
path.ensure_dir_exists(f)
|
|
|
|
|
|
class TestLinkOrCopy(unittest.TestCase):
|
|
|
def setUp(self):
|
|
|
self.tempdir = TemporaryDirectory()
|
|
|
self.src = self.dst("src")
|
|
|
with open(self.src, "w", encoding="utf-8") as f:
|
|
|
f.write("Hello, world!")
|
|
|
|
|
|
def tearDown(self):
|
|
|
self.tempdir.cleanup()
|
|
|
|
|
|
def dst(self, *args):
|
|
|
return os.path.join(self.tempdir.name, *args)
|
|
|
|
|
|
def assert_inode_not_equal(self, a, b):
|
|
|
assert (
|
|
|
os.stat(a).st_ino != os.stat(b).st_ino
|
|
|
), "%r and %r do reference the same indoes" % (a, b)
|
|
|
|
|
|
def assert_inode_equal(self, a, b):
|
|
|
assert (
|
|
|
os.stat(a).st_ino == os.stat(b).st_ino
|
|
|
), "%r and %r do not reference the same indoes" % (a, b)
|
|
|
|
|
|
def assert_content_equal(self, a, b):
|
|
|
with open(a, "rb") as a_f:
|
|
|
with open(b, "rb") as b_f:
|
|
|
assert a_f.read() == b_f.read()
|
|
|
|
|
|
@skip_win32
|
|
|
def test_link_successful(self):
|
|
|
dst = self.dst("target")
|
|
|
path.link_or_copy(self.src, dst)
|
|
|
self.assert_inode_equal(self.src, dst)
|
|
|
|
|
|
@skip_win32
|
|
|
def test_link_into_dir(self):
|
|
|
dst = self.dst("some_dir")
|
|
|
os.mkdir(dst)
|
|
|
path.link_or_copy(self.src, dst)
|
|
|
expected_dst = self.dst("some_dir", os.path.basename(self.src))
|
|
|
self.assert_inode_equal(self.src, expected_dst)
|
|
|
|
|
|
@skip_win32
|
|
|
def test_target_exists(self):
|
|
|
dst = self.dst("target")
|
|
|
open(dst, "w", encoding="utf-8").close()
|
|
|
path.link_or_copy(self.src, dst)
|
|
|
self.assert_inode_equal(self.src, dst)
|
|
|
|
|
|
@skip_win32
|
|
|
def test_no_link(self):
|
|
|
real_link = os.link
|
|
|
try:
|
|
|
del os.link
|
|
|
dst = self.dst("target")
|
|
|
path.link_or_copy(self.src, dst)
|
|
|
self.assert_content_equal(self.src, dst)
|
|
|
self.assert_inode_not_equal(self.src, dst)
|
|
|
finally:
|
|
|
os.link = real_link
|
|
|
|
|
|
@skip_if_not_win32
|
|
|
def test_windows(self):
|
|
|
dst = self.dst("target")
|
|
|
path.link_or_copy(self.src, dst)
|
|
|
self.assert_content_equal(self.src, dst)
|
|
|
|
|
|
def test_link_twice(self):
|
|
|
# Linking the same file twice shouldn't leave duplicates around.
|
|
|
# See https://github.com/ipython/ipython/issues/6450
|
|
|
dst = self.dst('target')
|
|
|
path.link_or_copy(self.src, dst)
|
|
|
path.link_or_copy(self.src, dst)
|
|
|
self.assert_inode_equal(self.src, dst)
|
|
|
assert sorted(os.listdir(self.tempdir.name)) == ["src", "target"]
|
|
|
|
