def test_set_node_path(self): stub_mod_call(self, cli) stub_base_which(self) node_path = mkdtemp(self) driver = cli.PackageManagerDriver(node_path=node_path, pkg_manager_bin='mgr') # ensure env is passed into the call. with pretty_logging(stream=mocks.StringIO()): driver.pkg_manager_install() self.assertEqual(self.call_args, ((['mgr', 'install'], ), { 'env': finalize_env({'NODE_PATH': node_path}), })) # will be overridden by instance settings. with pretty_logging(stream=mocks.StringIO()): driver.pkg_manager_install( env={ 'PATH': '.', 'MGR_ENV': 'dev', 'NODE_PATH': '/tmp/somewhere/else/node_mods', }) self.assertEqual(self.call_args, ((['mgr', 'install'], ), { 'env': finalize_env({ 'NODE_PATH': node_path, 'MGR_ENV': 'dev', 'PATH': '.' }), }))
def test_pkg_manager_init(self): # we still need a temporary directory, but the difference is # that whether the instance contains it or not. self.setup_requirements_json() remember_cwd(self) cwd = mkdtemp(self) os.chdir(cwd) driver = cli.PackageManagerDriver( pkg_manager_bin='mgr', pkgdef_filename='requirements.json', dep_keys=('require', ), ) driver.pkg_manager_init('calmpy.pip', interactive=False) target = join(cwd, 'requirements.json') self.assertTrue(exists(target)) with open(target) as fd: result = json.load(fd) self.assertEqual(result, { "require": { "setuptools": "25.1.6" }, "name": "calmpy.pip", })
def test_set_env_path_with_node_modules_fail(self): stub_os_environ(self) tmpdir = mkdtemp(self) driver = cli.PackageManagerDriver(pkg_manager_bin='mgr', working_dir=tmpdir) self.assertFalse(driver._set_env_path_with_node_modules()) self.assertIsNone(driver.env_path)
def test_set_binary_with_package(self): stub_mod_call(self, cli) stub_base_which(self) driver = cli.PackageManagerDriver(pkg_manager_bin='bower') # this will call ``bower install`` instead. driver.pkg_manager_install(['calmjs']) self.assertEqual(self.call_args[0], (['bower', 'install'], ))
def test_pkg_manager_init_merge(self): self.setup_requirements_json() cwd = mkdtemp(self) driver = cli.PackageManagerDriver( pkg_manager_bin='mgr', pkgdef_filename='requirements.json', dep_keys=('require', ), working_dir=cwd, ) target = join(cwd, 'requirements.json') with open(target, 'w') as fd: result = json.dump({"require": {"calmpy": "1.0.0"}}, fd) driver.pkg_manager_init('calmpy.pip', merge=True, overwrite=True) self.assertNotEqual( result, { "require": { "calmpy": "1.0.0", "setuptools": "25.1.6", }, "name": "calmpy.pip", }) stub_mod_call(self, cli) stub_base_which(self) with pretty_logging(stream=mocks.StringIO()): # ensure the return value is True, assuming successful self.assertTrue( driver.pkg_manager_install('calmpy.pip', overwrite=True))
def test_pkg_manager_init_working_dir(self): self.setup_requirements_json() remember_cwd(self) original = mkdtemp(self) os.chdir(original) cwd = mkdtemp(self) target = join(cwd, 'requirements.json') driver = cli.PackageManagerDriver( pkg_manager_bin='mgr', pkgdef_filename='requirements.json', dep_keys=('require', ), working_dir=cwd, ) driver.pkg_manager_init('calmpy.pip', interactive=False) self.assertFalse(exists(join(original, 'requirements.json'))) self.assertTrue(exists(target)) with open(target) as fd: result = json.load(fd) self.assertEqual(result, { "require": { "setuptools": "25.1.6" }, "name": "calmpy.pip", })
def test_pkg_manager_init_exists_and_overwrite(self): self.setup_requirements_json() cwd = mkdtemp(self) driver = cli.PackageManagerDriver( pkg_manager_bin='mgr', pkgdef_filename='requirements.json', dep_keys=('require', ), working_dir=cwd, ) target = join(cwd, 'requirements.json') with open(target, 'w') as fd: result = json.dump({"require": {}}, fd) with pretty_logging(stream=mocks.StringIO()) as err: driver.pkg_manager_init('calmpy.pip', interactive=False, overwrite=False) self.assertIn('not overwriting existing ', err.getvalue()) self.assertIn('requirements.json', err.getvalue()) with open(target) as fd: result = json.load(fd) self.assertNotEqual(result, {"require": {"setuptools": "25.1.6"}}) driver.pkg_manager_init('calmpy.pip', interactive=False, overwrite=True) with open(target) as fd: result = json.load(fd) self.assertEqual(result, { "require": { "setuptools": "25.1.6" }, "name": "calmpy.pip", })
def test_pkg_manager_init_merge(self): self.setup_requirements_json() cwd = mkdtemp(self) driver = cli.PackageManagerDriver( pkg_manager_bin='mgr', pkgdef_filename='requirements.json', dep_keys=('require', ), working_dir=cwd, ) target = join(cwd, 'requirements.json') with open(target, 'w') as fd: result = json.dump({"require": {"calmpy": "1.0.0"}}, fd) driver.pkg_manager_init('calmpy.pip', interactive=False, merge=True, overwrite=True) self.assertNotEqual( result, { "require": { "calmpy": "1.0.0", "setuptools": "25.1.6", }, "name": "calmpy.pip", })
def test_pkg_manager_view_extras_requires(self): working_set = self.setup_requirements_json() working_set.add( pkg_resources.Distribution( metadata=MockProvider({ 'requires.txt': '[dev]\ncalmpy.pip', }), project_name='site', version='0.0.0', )) driver = cli.PackageManagerDriver( pkg_manager_bin='mgr', pkgdef_filename='requirements.json', dep_keys=('require', ), ) result = driver.pkg_manager_view('site') self.assertEqual(result, { "require": {}, "name": "site", }) result = driver.pkg_manager_view('site[dev]') self.assertEqual(result, { "require": { "setuptools": "25.1.6" }, "name": "site[dev]", })
def test_install_arguments(self): stub_mod_call(self, cli) stub_base_which(self) driver = cli.PackageManagerDriver(pkg_manager_bin='mgr') with pretty_logging(stream=mocks.StringIO()): driver.pkg_manager_install(args=('--pedantic', )) self.assertEqual(self.call_args, ((['mgr', 'install', '--pedantic'], ), {}))
def test_command_creation(self): driver = cli.PackageManagerDriver(pkg_manager_bin='mgr') cmd = runtime.PackageManagerRuntime(driver) text = cmd.argparser.format_help() self.assertIn( "run 'mgr install' with generated 'default.json';", text, )
def test_set_env_path_with_node_path_with_environ(self): stub_os_environ(self) tmpdir, bin_dir = self.fake_mgr_bin() # define a NODE_PATH set to a valid node_modules os.environ['NODE_PATH'] = join(tmpdir, 'node_modules') driver = cli.PackageManagerDriver(pkg_manager_bin='mgr') self.assertTrue(driver._set_env_path_with_node_modules()) self.assertEqual(driver.env_path, bin_dir)
def test_install_failure(self): stub_mod_call(self, cli, fake_error(IOError)) stub_base_which(self) driver = cli.PackageManagerDriver(pkg_manager_bin='mgr') with pretty_logging(stream=mocks.StringIO()) as stderr: with self.assertRaises(IOError): driver.mgr_install() val = stderr.getvalue() self.assertIn("invocation of the 'mgr' binary failed", val)
def test_driver_run_failure(self): # testing for success may actually end up being extremely # annoying, so we are going to avoid that and let the integrated # subclasses deal with it. stub_os_environ(self) driver = cli.PackageManagerDriver(pkg_manager_bin='mgr') os.environ['PATH'] = '' with self.assertRaises(OSError): driver.run()
def test_paths_unset(self): stub_mod_call(self, cli) stub_base_which(self) driver = cli.PackageManagerDriver(pkg_manager_bin='mgr') with pretty_logging(stream=mocks.StringIO()): driver.pkg_manager_install() args, kwargs = self.call_args self.assertNotIn('PATH', kwargs) self.assertNotIn('cwd', kwargs)
def test_env_path_not_exist(self): stub_mod_call(self, cli) stub_base_which(self) bad_path = '/no/such/path/for/sure/at/here' driver = cli.PackageManagerDriver(pkg_manager_bin='mgr', env_path=bad_path) with pretty_logging(stream=mocks.StringIO()): driver.pkg_manager_install() args, kwargs = self.call_args self.assertNotEqual(kwargs['env']['PATH'].split(pathsep)[0], bad_path)
def test_install_other_environ(self): stub_mod_call(self, cli) stub_base_which(self) driver = cli.PackageManagerDriver(pkg_manager_bin='mgr') with pretty_logging(stream=mocks.StringIO()): driver.pkg_manager_install(env={'MGR_ENV': 'production'}) self.assertEqual(self.call_args, ((['mgr', 'install'], ), { 'env': finalize_env({'MGR_ENV': 'production'}), }))
def test_set_binary_no_package(self): stub_mod_call(self, cli) stub_base_which(self) driver = cli.PackageManagerDriver(pkg_manager_bin='bower') with pretty_logging(stream=mocks.StringIO()) as fd: driver.pkg_manager_install() self.assertIn( "no package name supplied, " "not continuing with 'bower install'", fd.getvalue()) self.assertIsNone(self.call_args)
def test_which_is_set(self): stub_os_environ(self) tmpdir = mkdtemp(self) mgr_bin = self.create_fake_mgr_bin(tmpdir) driver = cli.PackageManagerDriver(pkg_manager_bin='mgr') driver.env_path = tmpdir self.assertEqual(normcase(driver.which()), normcase(mgr_bin)) driver.env_path = None self.assertIsNone(driver.which())
def test_pkg_manager_cmd_production_flag_warnings_noninteractive(self): stub_check_interactive(self, False) driver = cli.PackageManagerDriver(pkg_manager_bin='mgr', devkey='blah') with pretty_logging(stream=mocks.StringIO()) as log: self.assertEqual(driver._prodev_flag(None, None, True), []) self.assertIn('WARNING', log.getvalue()) self.assertIn( 'undefined production flag may result in unexpected installation ' 'behavior', log.getvalue()) self.assertIn("non-interactive", log.getvalue()) self.assertIn("'blah' may be ignored", log.getvalue())
def test_helper_attr(self): stub_mod_call(self, cli) stub_base_which(self) driver = cli.PackageManagerDriver(pkg_manager_bin='mgr') with self.assertRaises(AttributeError) as e: driver.no_such_attr_here self.assertIn('no_such_attr_here', str(e.exception)) self.assertIsNot(driver.mgr_init, None) self.assertIsNot(driver.get_mgr_version, None) self.assertTrue(driver.mgr_install(['calmjs'])) self.assertEqual(self.call_args[0], (['mgr', 'install'], ))
def test_set_env_path_with_node_modules_success(self): tmpdir, bin_dir = self.fake_mgr_bin() # constructor with an explicit working directory. driver = cli.PackageManagerDriver(pkg_manager_bin='mgr', working_dir=tmpdir) self.assertIsNone(driver.env_path) self.assertTrue(driver._set_env_path_with_node_modules()) self.assertEqual(driver.env_path, bin_dir) # should still result in the same thing. self.assertTrue(driver._set_env_path_with_node_modules()) self.assertEqual(driver.env_path, bin_dir)
def test_working_dir_set(self): stub_mod_call(self, cli) stub_base_which(self) some_cwd = mkdtemp(self) driver = cli.PackageManagerDriver(pkg_manager_bin='mgr', working_dir=some_cwd) with pretty_logging(stream=mocks.StringIO()): driver.pkg_manager_install() args, kwargs = self.call_args self.assertNotIn('PATH', kwargs) self.assertEqual(kwargs['cwd'], some_cwd)
def test_set_binary(self): stub_mod_call(self, cli) stub_base_which(self) driver = cli.PackageManagerDriver(pkg_manager_bin='bower') # this will call ``bower install`` instead. with pretty_logging(stream=mocks.StringIO()) as fd: driver.pkg_manager_install() self.assertIn( "no package name supplied, " "but continuing with 'bower install'", fd.getvalue()) self.assertEqual(self.call_args, ((['bower', 'install'], ), {}))
def test_set_env_path_with_node_path_success(self): tmpdir, bin_dir = self.fake_mgr_bin() # default constructor driver = cli.PackageManagerDriver(pkg_manager_bin='mgr') self.assertIsNone(driver.env_path) # using NODE_PATH set to a valid node_modules driver.node_path = join(tmpdir, 'node_modules') self.assertTrue(driver._set_env_path_with_node_modules()) self.assertEqual(driver.env_path, bin_dir) # should still result in the same thing. self.assertTrue(driver._set_env_path_with_node_modules()) self.assertEqual(driver.env_path, bin_dir)
def test_which_is_set_env_path(self): stub_os_environ(self) tmpdir = mkdtemp(self) mgr_bin = self.create_fake_mgr_bin(tmpdir) driver = cli.PackageManagerDriver(pkg_manager_bin='mgr') # With both env_path attr and environ PATH set os.environ['PATH'] = driver.env_path = tmpdir self.assertEqual(normcase(driver.which()), normcase(mgr_bin)) # the autodetection should still work through ENV_PATH driver.env_path = None self.assertEqual(normcase(driver.which()), normcase(mgr_bin))
def test_alternative_install_cmd(self): stub_mod_call(self, cli) stub_base_which(self) driver = cli.PackageManagerDriver(pkg_manager_bin='mgr', install_cmd='sync') driver.pkg_manager_install(['calmjs']) self.assertEqual(self.call_args[0], (['mgr', 'sync'], )) # Naturally, the short hand call will be changed. # note that args is NOT the package_name, and thus this just # means that the installation may not operate as expected off # the package. driver.mgr_sync(['calmjs'], args=('all', )) self.assertEqual(self.call_args[0], (['mgr', 'sync', 'all'], ))
def test_install_other_environ(self): stub_mod_call(self, cli) stub_base_which(self) stub_os_environ(self) # pop out NODE_PATH if available os.environ.pop('NODE_PATH', '') driver = cli.PackageManagerDriver(pkg_manager_bin='mgr') with pretty_logging(stream=mocks.StringIO()): driver.pkg_manager_install(['calmjs'], env={'MGR_ENV': 'production'}) self.assertEqual(self.call_args, ((['mgr', 'install'], ), { 'env': finalize_env({'MGR_ENV': 'production'}), }))
def test_predefined_path(self): # ensure that the various paths are passed to env or cwd. stub_mod_call(self, cli) stub_base_which(self) somepath = mkdtemp(self) cwd = mkdtemp(self) driver = cli.PackageManagerDriver(pkg_manager_bin='mgr', env_path=somepath, working_dir=cwd) with pretty_logging(stream=mocks.StringIO()): driver.pkg_manager_install() args, kwargs = self.call_args self.assertEqual(kwargs['env']['PATH'].split(pathsep)[0], somepath) self.assertEqual(kwargs['cwd'], cwd)
def test_helper_attr(self): stub_mod_call(self, cli) stub_base_which(self) driver = cli.PackageManagerDriver(pkg_manager_bin='mgr') with self.assertRaises(AttributeError) as e: driver.no_such_attr_here self.assertIn('no_such_attr_here', str(e.exception)) self.assertIsNot(driver.mgr_init, None) self.assertIsNot(driver.get_mgr_version, None) with pretty_logging(stream=mocks.StringIO()) as stderr: driver.mgr_install() self.assertIn( "no package name supplied, " "but continuing with 'mgr install'", stderr.getvalue()) self.assertEqual(self.call_args, ((['mgr', 'install'], ), {}))