def test_update_lock(self, mock_update):
"""Verify the 'update' command can enable locking."""
cli.main(['update', '--lock'])
mock_update.assert_called_once_with(
root=None, depth=5,
force=False, clean=False, recurse=False, lock=True)
def test_install_root(self, mock_install):
"""Verify the project's root can be specified."""
cli.main(['install', '--root', 'mock/path/to/root'])
mock_install.assert_called_once_with(
root='mock/path/to/root', depth=5,
force=False, fetch=False, clean=False)
def test_update_recursive(self, mock_update):
"""Verify the 'update' command can be run recursively."""
cli.main(['update', '--all'])
mock_update.assert_called_once_with(
root=None, depth=5,
force=False, clean=False, recurse=True, lock=None)
def test_list(self, mock_display):
"""Verify the 'list' command can be run."""
cli.main(['list'])
mock_display.assert_called_once_with(root=None,
depth=5,
allow_dirty=True)
def test_main(self):
"""Verify the top-level command can be run."""
mock_function = Mock(return_value=True)
cli.main([], mock_function)
mock_function.assert_called_once_with()
def test_update_with_depth(self, mock_update):
"""Verify the 'update' command can be limited by depth."""
cli.main(['update', '--depth', '10'])
mock_update.assert_called_once_with(
root=None, depth=10,
force=False, clean=False, recurse=False, lock=None)
def test_list_no_dirty(self, mock_display):
"""Verify the 'list' command can be set to fail when dirty."""
cli.main(['list', '--fail-if-dirty'])
mock_display.assert_called_once_with(root=None,
depth=5,
allow_dirty=False)
def test_install_specific_sources(self, mock_install):
"""Verify individual dependencies can be installed."""
cli.main(['install', 'foo', 'bar'])
mock_install.assert_called_once_with(
'foo', 'bar', root=None, depth=5,
force=False, fetch=False, clean=False)
def test_update_with_depth(self, mock_update):
"""Verify the 'list' command can be limited by depth."""
cli.main(['list', '--depth', '10'])
mock_update.assert_called_once_with(root=None,
depth=10,
allow_dirty=True)
def test_uninstall_force(self, mock_uninstall):
"""Verify the 'uninstall' command can be forced."""
cli.main(['uninstall', '--force'])
mock_uninstall.assert_called_once_with(root=None,
force=True,
keep_location=False)
def test_uninstall_root(self, mock_uninstall):
"""Verify the project's root can be specified."""
cli.main(['uninstall', '--root', 'mock/path/to/root'])
mock_uninstall.assert_called_once_with(root='mock/path/to/root',
force=False,
keep_location=False)
def test_main(self):
"""Verify the top-level command can be run."""
mock_function = Mock(return_value=True)
cli.main([], mock_function)
mock_function.assert_called_once_with()
def test_uninstall_keep_location(self, mock_uninstall):
"""Verify the 'uninstall' command can be run with keep_location."""
cli.main(['uninstall', '--keep-location'])
mock_uninstall.assert_called_once_with(root=None,
force=False,
keep_location=True)
def test_list_root(self, mock_display):
"""Verify the project's root can be specified."""
cli.main(['list', '--root', 'mock/path/to/root'])
mock_display.assert_called_once_with(root='mock/path/to/root',
depth=5,
allow_dirty=True)
def test_install_with_depth(self, mock_update):
"""Verify the 'install' command can be limited by depth."""
cli.main(['install', '--depth', '10'])
mock_update.assert_called_once_with(root=None,
depth=10,
force=False,
fetch=False,
clean=False)
def test_install_clean(self, mock_install):
"""Verify dependency cleaning can be enabled."""
cli.main(['install', '--clean'])
mock_install.assert_called_once_with(root=None,
depth=5,
force=False,
fetch=False,
clean=True)
def test_install_fetch(self, mock_install):
"""Verify fetching can be enabled."""
cli.main(['install', '--fetch'])
mock_install.assert_called_once_with(root=None,
depth=5,
force=False,
fetch=True,
clean=False)
def test_install_force(self, mock_install):
"""Verify dependencies can be force-installed."""
cli.main(['install', '--force'])
mock_install.assert_called_once_with(root=None,
depth=5,
force=True,
fetch=False,
clean=False)
def test_install_root(self, mock_install):
"""Verify the project's root can be specified."""
cli.main(['install', '--root', 'mock/path/to/root'])
mock_install.assert_called_once_with(root='mock/path/to/root',
depth=5,
force=False,
fetch=False,
clean=False)
def test_install(self, mock_install):
"""Verify the 'install' command can be run."""
cli.main(['install'])
mock_install.assert_called_once_with(root=None,
depth=5,
force=False,
fetch=False,
clean=False)
def at_each_level(argument, verbosity):
def function(*args, **kwargs):
logging.debug(args)
logging.debug(kwargs)
logging.warning("warning")
logging.error("error")
return True
cli.main([argument] if argument else [], function)
expect(_Config.verbosity) == verbosity
def test_update_lock(self, mock_update):
"""Verify the 'update' command can enable locking."""
cli.main(['update', '--lock'])
mock_update.assert_called_once_with(root=None,
depth=5,
force=False,
clean=False,
recurse=False,
lock=True)
def test_update_with_depth(self, mock_update):
"""Verify the 'update' command can be limited by depth."""
cli.main(['update', '--depth', '10'])
mock_update.assert_called_once_with(root=None,
depth=10,
force=False,
clean=False,
recurse=False,
lock=None)
def test_update_recursive(self, mock_update):
"""Verify the 'update' command can be run recursively."""
cli.main(['update', '--all'])
mock_update.assert_called_once_with(root=None,
depth=5,
force=False,
clean=False,
recurse=True,
lock=None)
def test_install_specific_sources(self, mock_install):
"""Verify individual dependencies can be installed."""
cli.main(['install', 'foo', 'bar'])
mock_install.assert_called_once_with('foo',
'bar',
root=None,
depth=5,
force=False,
fetch=False,
clean=False)
def at_each_level(argument, verbosity):
def function(*args, **kwargs):
logging.debug(args)
logging.debug(kwargs)
logging.warning("warning")
logging.error("error")
return True
cli.main([argument] if argument else [], function)
expect(_Config.verbosity) == verbosity
def test_update(self, mock_update):
"""Verify the 'update' command can be run."""
cli.main(['update'])
mock_update.assert_called_once_with(
root=None,
depth=5,
force=False,
clean=False,
recurse=False,
lock=None,
skip_changes=False,
)
def test_update_skip_changes(self, mock_update):
"""Verify the 'update' command with skip changes option."""
cli.main(['update', '--skip-changes'])
mock_update.assert_called_once_with(
root=None,
depth=5,
force=False,
clean=False,
recurse=False,
lock=None,
skip_changes=True,
)
def test_install_force(self, mock_install):
"""Verify dependencies can be force-installed."""
cli.main(['install', '--force'])
mock_install.assert_called_once_with(
root=None,
depth=5,
force=True,
force_interactive=False,
fetch=False,
clean=False,
skip_changes=False,
skip_default_group=False,
)
def test_install(self, mock_install):
"""Verify the 'install' command can be run."""
cli.main(['install'])
mock_install.assert_called_once_with(
root=None,
depth=5,
force=False,
force_interactive=False,
fetch=False,
clean=False,
skip_changes=False,
skip_default_group=False,
)
def test_install_fetch(self, mock_install):
"""Verify fetching can be enabled."""
cli.main(['install', '--fetch'])
mock_install.assert_called_once_with(
root=None,
depth=5,
force=False,
force_interactive=False,
fetch=True,
clean=False,
skip_changes=False,
skip_default_group=False,
)
def test_update_no_lock(self, mock_update):
"""Verify the 'update' command can disable locking."""
cli.main(['update', '--skip-lock'])
mock_update.assert_called_once_with(
root=None,
depth=5,
force=False,
force_interactive=False,
clean=False,
recurse=False,
lock=False,
skip_changes=False,
)
def test_update_force_interactive(self, mock_update):
"""Verify the 'update' command with force-interactive option."""
cli.main(['update', '--force-interactive'])
mock_update.assert_called_once_with(
root=None,
depth=5,
force=False,
force_interactive=True,
clean=False,
recurse=False,
lock=None,
skip_changes=False,
)
def test_update_specific_sources(self, mock_install):
"""Verify individual dependencies can be installed."""
cli.main(['update', 'foo', 'bar'])
mock_install.assert_called_once_with(
'foo',
'bar',
root=None,
depth=5,
force=False,
clean=False,
recurse=False,
lock=None,
skip_changes=False,
)
def with_root(show):
cli.main(['show', '--root', "mock/root"])
show.assert_called_once_with(root="mock/root")
def with_names(show):
cli.main(['show', 'foo', 'bar'])
show.assert_called_once_with('foo', 'bar', root=None)
def with_config(show):
cli.main(['show', '--config'])
show.assert_called_once_with('__config__', root=None)
def it_launches_the_config(launch, config):
cli.main(['edit'])
expect(launch.mock_calls) == [call(config), call().__bool__()]
def test_main_fail(self):
"""Verify error in commands are detected."""
with pytest.raises(SystemExit):
cli.main([], Mock(return_value=False))
def with_no_arguments(edit):
cli.main(['edit'])
edit.assert_called_once_with(root=None)
def test_uninstall_root(self, mock_uninstall):
"""Verify the project's root can be specified."""
cli.main(['uninstall', '--root', 'mock/path/to/root'])
mock_uninstall.assert_called_once_with(
root='mock/path/to/root', force=False)
def with_log(show):
cli.main(['show', '--log'])
show.assert_called_once_with('__log__', root=None)
def with_no_arguments(edit):
cli.main(['edit'])
edit.assert_called_once_with(root=None)
def with_root(edit):
cli.main(['edit', '--root', "mock/root"])
edit.assert_called_once_with(root="mock/root")
def test_install_clean(self, mock_install):
"""Verify dependency cleaning can be enabled."""
cli.main(['install', '--clean'])
mock_install.assert_called_once_with(
root=None, depth=5, force=False, fetch=False, clean=True)
def test_install_fetch(self, mock_install):
"""Verify fetching can be enabled."""
cli.main(['install', '--fetch'])
mock_install.assert_called_once_with(
root=None, depth=5, force=False, fetch=True, clean=False)
def test_install_force(self, mock_install):
"""Verify dependencies can be force-installed."""
cli.main(['install', '--force'])
mock_install.assert_called_once_with(
root=None, depth=5, force=True, fetch=False, clean=False)
def with_no_arguments(show):
cli.main(['show'])
show.assert_called_once_with(root=None)
def test_uninstall_force(self, mock_uninstall):
"""Verify the 'uninstall' command can be forced."""
cli.main(['uninstall', '--force'])
mock_uninstall.assert_called_once_with(
root=None, force=True)
def test_main_help(self):
"""Verify the help text can be displayed."""
with pytest.raises(SystemExit):
cli.main(['--help'])
def test_uninstall(self, mock_uninstall):
"""Verify the 'uninstall' command can be run."""
cli.main(['uninstall'])
mock_uninstall.assert_called_once_with(
root=None, force=False)
def it_prints_location_by_default(show, location):
cli.main(['show'])
expect(show.mock_calls) == [call(location)]
def with_root(edit):
cli.main(['edit', '--root', "mock/root"])
edit.assert_called_once_with(root="mock/root")
def test_main_error(self):
"""Verify runtime errors are handled."""
with pytest.raises(SystemExit):
cli.main([], Mock(side_effect=RuntimeError))
def test_install(self, mock_init):
"""Verify the 'install' command can be run."""
cli.main(['init'])
mock_init.assert_called_once_with()
def test_install(self, mock_install):
"""Verify the 'install' command can be run."""
cli.main(['install'])
mock_install.assert_called_once_with(
root=None, depth=5, force=False, fetch=False, clean=False)
def it_can_print_a_depenendcy_path(show, location):
cli.main(['show', 'bar'])
expect(show.mock_calls) == [call(os.path.join(location, "bar"))]
def test_main_interrupt(self):
"""Verify a command can be interrupted."""
with pytest.raises(SystemExit):
cli.main([], Mock(side_effect=KeyboardInterrupt))
def it_exits_when_no_config_found(tmpdir):
tmpdir.chdir()
with expect.raises(SystemExit):
cli.main(['edit'])
def test_main_none(self):
"""Verify it's an error to specify no command."""
with pytest.raises(SystemExit):
cli.main([])