def test_package_and_prefix(self):
"""Test syncing a package when using a non-default prefix."""
package_dir = os.path.join(self.repository, '.config/awesome')
os.makedirs(package_dir)
touch('%s/testfile' % package_dir)
dotfiles = core.Dotfiles(homedir=self.homedir,
repository=self.repository,
prefix='.',
ignore=[],
externals={},
packages=['.config'],
dry_run=False,
quiet=True)
dotfiles.sync()
expected = os.path.join(self.homedir, ".config")
self.assertTrue(os.path.islink(expected))
expected = os.path.join(expected, "awesome")
self.assertTrue(os.path.isdir(expected))
expected = os.path.join(expected, "testfile")
self.assertTrue(os.path.isfile(expected))
def test_move_repository(self):
"""Test the move() method for a Dotfiles repository."""
touch(os.path.join(self.repository, 'bashrc'))
dotfiles = core.Dotfiles(homedir=self.homedir,
repository=self.repository,
prefix='',
ignore=[],
force=True,
externals={},
packages=[],
dry_run=False)
dotfiles.sync()
# Make sure sync() did the right thing.
self.assertPathEqual(os.path.join(self.homedir, '.bashrc'),
os.path.join(self.repository, 'bashrc'))
target = os.path.join(self.homedir, 'MyDotfiles')
dotfiles.move(target)
self.assertTrue(os.path.exists(os.path.join(target, 'bashrc')))
self.assertPathEqual(os.path.join(self.homedir, '.bashrc'),
os.path.join(target, 'bashrc'))
def test_missing_remove(self):
"""Test removing a dotfile that's been removed from the repository."""
repo_file = os.path.join(self.repository, 'testdotfile')
touch(repo_file)
dotfiles = core.Dotfiles(homedir=self.homedir,
repository=self.repository,
prefix='',
ignore=[],
externals={},
packages=[],
dry_run=False)
dotfiles.sync()
# remove the dotfile from the repository, homedir symlink is now broken
os.remove(repo_file)
# remove the broken symlink
dotfiles.remove(['.testdotfile'])
# verify symlink was removed
self.assertFalse(
os.path.exists(os.path.join(self.homedir, '.testdotfile')))
def test_add_package(self):
"""
Test adding a package that isn't already in the repository
"""
package_dir = os.path.join(self.homedir,
'.%s/%s' % ('config', 'gtk-3.0'))
os.makedirs(package_dir)
touch('%s/testfile' % package_dir)
dotfiles = core.Dotfiles(homedir=self.homedir,
repository=self.repository,
prefix='',
ignore=[],
externals={},
packages=['config'],
dry_run=False,
quiet=True)
# This should fail, you should not be able to add dotfiles that are
# defined to be packages.
dotfiles.add(['.config'])
self.assertFalse(os.path.islink(os.path.join(self.homedir, '.config')))
def test_sync_unmanaged_directory_symlink(self):
"""Test a forced sync on a directory symlink.
A bug was reported where a user wanted to replace a dotfile repository
with an other one. They had a .vim directory in their home directory
which was obviously also a symbolic link. This caused:
OSError: Cannot call rmtree on a symbolic link
"""
# Create a dotfile symlink to some directory
os.mkdir(os.path.join(self.home, 'vim'))
os.symlink(os.path.join(self.home, 'vim'),
os.path.join(self.home, '.vim'))
# Create a vim directory in the repository. This will cause the above
# symlink to be overwritten on sync.
os.mkdir(os.path.join(self.repo, 'vim'))
# Make sure the symlink points to the correct location.
self.assertEqual(os.path.realpath(os.path.join(self.home, '.vim')),
os.path.join(self.home, 'vim'))
dotfiles = core.Dotfiles(home=self.home,
repo=self.repo,
prefix='',
ignore=[],
externals={})
dotfiles.sync(force=True)
# The symlink should now point to the directory in the repository.
self.assertEqual(os.path.realpath(os.path.join(self.home, '.vim')),
os.path.join(self.repo, 'vim'))
def test_move_repository(self):
"""Test the move() method for a Dotfiles repository."""
touch(os.path.join(self.repo, 'bashrc'))
dotfiles = core.Dotfiles(home=self.home,
repo=self.repo,
prefix='',
ignore=[],
force=True,
externals={})
dotfiles.sync()
# Make sure sync() did the right thing.
self.assertEqual(os.path.realpath(os.path.join(self.home, '.bashrc')),
os.path.join(self.repo, 'bashrc'))
target = os.path.join(self.home, 'MyDotfiles')
dotfiles.move(target)
self.assertTrue(os.path.exists(os.path.join(target, 'bashrc')))
self.assertEqual(os.path.realpath(os.path.join(self.home, '.bashrc')),
os.path.join(target, 'bashrc'))
def test_packages(self):
"""
Test packages.
"""
files = ['foo', 'package/bar']
symlinks = ['.foo', '.package/bar']
join = os.path.join
# Create files
for filename in files:
path = join(self.repository, filename)
dirname = os.path.dirname(path)
if not os.path.exists(dirname):
os.makedirs(dirname)
touch(path)
# Create Dotfiles object
dotfiles = core.Dotfiles(homedir=self.homedir,
repository=self.repository,
prefix='',
ignore=[],
externals={},
packages=['package'],
dry_run=False)
# Create symlinks in homedir
dotfiles.sync()
# Verify it created what we expect
def check_all(files, symlinks):
self.assertTrue(os.path.isdir(join(self.homedir, '.package')))
for src, dst in zip(files, symlinks):
self.assertTrue(
is_link_to(join(self.homedir, dst),
join(self.repository, src)))
check_all(files, symlinks)
# Add files to the repository
new_files = [join(self.homedir, f) for f in ['.bar', '.package/foo']]
for filename in new_files:
path = join(self.homedir, filename)
touch(path)
new_repo_files = ['bar', 'package/foo']
dotfiles.add(new_files)
check_all(files + new_repo_files, symlinks + new_files)
# Remove them from the repository
dotfiles.remove(new_files)
check_all(files, symlinks)
# Move the repository
self.repository = join(self.homedir, 'Dotfiles2')
dotfiles.move(self.repository)
check_all(files, symlinks)
def test_glob_ignore_pattern(self):
""" Test that the use of glob pattern matching works in the ignores list.
The following repo dir exists:
myscript.py
myscript.pyc
myscript.pyo
bashrc
bashrc.swp
vimrc
vimrc.swp
install.sh
Using the glob pattern dotfiles should have the following sync result in home:
.myscript.py -> Dotfiles/myscript.py
.bashrc -> Dotfiles/bashrc
.vimrc -> Dotfiles/vimrc
"""
ignore = ['*.swp', '*.py?', 'install.sh']
all_repo_files = (('myscript.py', '.myscript.py'),
('myscript.pyc', None), ('myscript.pyo', None),
('bashrc', '.bashrc'), ('bashrc.swp', None),
('vimrc', '.vimrc'), ('vimrc.swp',
None), ('install.sh', None))
all_dotfiles = [f for f in all_repo_files if f[1] is not None]
for original, symlink in all_repo_files:
touch(os.path.join(self.repository, original))
dotfiles = core.Dotfiles(homedir=self.homedir,
repository=self.repository,
prefix='',
ignore=ignore,
externals={},
packages=[],
dry_run=False)
dotfiles.sync()
# Now check that the files that should have a symlink
# point to the correct file and are the only files that
# exist in the home dir.
self.assertEqual(sorted(os.listdir(self.homedir)),
sorted([f[1] for f in all_dotfiles] + ['Dotfiles']))
for original, symlink in all_dotfiles:
self.assertPathEqual(os.path.join(self.repository, original),
os.path.join(self.homedir, symlink))
def test_single_sync(self):
"""
Test syncing a single file in the repo
The following repo dir exists:
bashrc
netrc
vimrc
Syncing only vimrc should have the folowing sync result in home:
.vimrc -> Dotfiles/vimrc
"""
# define the repository contents
repo_files = (('bashrc', False), ('netrc', False), ('vimrc', True))
# populate the repository
for dotfile, _ in repo_files:
touch(os.path.join(self.repository, dotfile))
dotfiles = core.Dotfiles(homedir=self.homedir,
repository=self.repository,
prefix='',
ignore=[],
externals={},
packages=[],
dry_run=False)
# sync only certain dotfiles
for dotfile, should_sync in repo_files:
if should_sync:
dotfiles.sync(files=['.%s' % dotfile])
# verify home directory contents
for dotfile, should_sync in repo_files:
if should_sync:
self.assertPathEqual(
os.path.join(self.repository, dotfile),
os.path.join(self.homedir, '.%s' % dotfile))
else:
self.assertFalse(
os.path.exists(os.path.join(self.homedir, dotfile)))
def test_missing_package(self):
"""
Test a non-existent package.
"""
package_file = '.package/bar'
# Create Dotfiles object
dotfiles = core.Dotfiles(homedir=self.homedir,
repository=self.repository,
prefix='',
ignore=[],
externals={},
packages=['package'],
dry_run=False)
path = os.path.join(self.homedir, package_file)
dirname = os.path.dirname(path)
if not os.path.exists(dirname):
os.makedirs(dirname)
touch(path)
dotfiles.add([os.path.join(self.homedir, package_file)])
def test_force_sync_directory(self):
"""Test forced sync when the dotfile is a directory.
I installed the lastpass chrome extension which stores a socket in
~/.lastpass. So I added that directory as an external to /tmp and
attempted a forced sync. An error occurred because sync() calls
os.remove() as it mistakenly assumes the dotfile is a file and not
a directory.
"""
os.mkdir(os.path.join(self.home, '.lastpass'))
externals = {'.lastpass': '******'}
dotfiles = core.Dotfiles(home=self.home,
repo=self.repo,
prefix='',
ignore=[],
externals=externals)
dotfiles.sync(force=True)
self.assertEqual(
os.path.realpath(os.path.join(self.home, '.lastpass')), '/tmp')
