def test_run_environment(self, run_mock): plugin = catkin.CatkinPlugin('test-part', self.properties, self.project_options) python_path = os.path.join( plugin.installdir, 'usr', 'lib', 'python2.7', 'dist-packages') os.makedirs(python_path) environment = plugin.env(plugin.installdir) self.assertTrue( 'PYTHONPATH={}:$PYTHONPATH'.format(python_path) in environment, environment) self.assertTrue('ROS_MASTER_URI=http://localhost:11311' in environment) self.assertTrue('ROS_HOME=$SNAP_USER_DATA/ros' in environment) self.assertTrue('LC_ALL=C.UTF-8' in environment) self.assertTrue('_CATKIN_SETUP_DIR={}'.format(os.path.join( plugin.installdir, 'opt', 'ros', self.properties.rosdistro)) in environment) self.assertTrue( '. {}'.format(plugin.installdir, 'opt', 'ros', 'setup.sh') in '\n'.join(environment), 'Expected ROS\'s setup.sh to be sourced')
def test_pull_local_dependencies(self): self.properties.catkin_packages.append('package_2') plugin = catkin.CatkinPlugin('test-part', self.properties, self.project_options) os.makedirs(os.path.join(plugin.sourcedir, 'src')) # No system dependencies (only local) self.dependencies_mock.return_value = set() plugin.pull() self.verify_rosdep_setup(self.properties.rosdistro, os.path.join(plugin.sourcedir, 'src'), os.path.join(plugin.partdir, 'rosdep'), plugin.PLUGIN_STAGE_SOURCES) # Verify that dependencies were found as expected. TODO: Would really # like to use ANY here instead of verifying explicit arguments, but # Python issue #25195 won't let me. self.assertEqual(1, self.dependencies_mock.call_count) self.assertEqual({'my_package', 'package_2'}, self.dependencies_mock.call_args[0][0]) # Verify that no .deb packages were installed self.assertTrue(mock.call().unpack(plugin.installdir) not in self.ubuntu_mock.mock_calls)
def test_pull_debian_dependencies(self): plugin = catkin.CatkinPlugin('test-part', self.properties, self.project_options) os.makedirs(os.path.join(plugin.sourcedir, 'src')) self.dependencies_mock.return_value = {'foo', 'bar', 'baz'} plugin.pull() self.verify_rosdep_setup(self.properties.rosdistro, os.path.join(plugin.sourcedir, 'src'), os.path.join(plugin.partdir, 'rosdep'), plugin.PLUGIN_STAGE_SOURCES) # Verify that dependencies were found as expected. TODO: Would really # like to use ANY here instead of verifying explicit arguments, but # Python issue #25195 won't let me. self.assertEqual(1, self.dependencies_mock.call_count) self.assertEqual({'my_package'}, self.dependencies_mock.call_args[0][0]) # Verify that the dependencies were installed self.ubuntu_mock.return_value.get.assert_called_with( _CompareContainers(self, ['foo', 'bar', 'baz'])) self.ubuntu_mock.return_value.unpack.assert_called_with( plugin.installdir)
def test_build(self, finish_build_mock, prepare_build_mock, run_output_mock, bashrun_mock, run_mock, compilers_mock): plugin = catkin.CatkinPlugin('test-part', self.properties, self.project_options) os.makedirs(os.path.join(plugin.sourcedir, 'src')) plugin.build() prepare_build_mock.assert_called_once_with() # Matching like this for order independence (otherwise it would be # quite fragile) class check_build_command(): def __eq__(self, args): command = ' '.join(args) return ( args[0] == 'catkin_make_isolated' and '--install' in command and '--pkg my_package' in command and '--directory {}'.format(plugin.builddir) in command and '--install-space {}'.format(plugin.rosdir) in command and '--source-space {}'.format( os.path.join(plugin.builddir, plugin.options.source_space)) in command) bashrun_mock.assert_called_with(check_build_command(), env=mock.ANY) self.assertFalse( self.dependencies_mock.called, 'Dependencies should have been discovered in the pull() step') finish_build_mock.assert_called_once_with()
def test_pull_with_roscore(self): self.properties.include_roscore = True plugin = catkin.CatkinPlugin('test-part', self.properties, self.project_options) os.makedirs(os.path.join(plugin.sourcedir, 'src')) # No system dependencies self.dependencies_mock.return_value = set() def resolve(package_name): if package_name == 'ros_core': return ['ros-core-dependency'] self.rosdep_mock.return_value.resolve_dependency = resolve plugin.pull() self.verify_rosdep_setup(self.properties.rosdistro, os.path.join(plugin.sourcedir, 'src'), os.path.join(plugin.partdir, 'rosdep'), plugin.PLUGIN_STAGE_SOURCES) # Verify that roscore was installed self.ubuntu_mock.return_value.get.assert_called_with( {'ros-core-dependency'}) self.ubuntu_mock.return_value.unpack.assert_called_with( plugin.installdir)
def test_build_multiple(self, finish_build_mock, prepare_build_mock, run_output_mock, bashrun_mock, run_mock, compilers_mock): self.properties.catkin_packages.append('package_2') plugin = catkin.CatkinPlugin('test-part', self.properties, self.project_options) os.makedirs(os.path.join(plugin.sourcedir, 'src')) plugin.build() class check_pkg_arguments(): def __init__(self, test): self.test = test def __eq__(self, args): index = args.index('--pkg') packages = args[index + 1:index + 3] self.test.assertIn('my_package', packages) self.test.assertIn('package_2', packages) return True bashrun_mock.assert_called_with(check_pkg_arguments(self), env=mock.ANY) self.assertFalse( self.dependencies_mock.called, 'Dependencies should have been discovered in the pull() step') finish_build_mock.assert_called_once_with()
def test_build_multiple(self, finish_build_mock, prepare_build_mock, run_output_mock, bashrun_mock, run_mock): self.properties.catkin_packages.append('package_2') plugin = catkin.CatkinPlugin('test-part', self.properties, self.project_options) os.makedirs(os.path.join(plugin.sourcedir, 'src')) plugin.build() class check_pkg_arguments(): def __init__(self, test): self.test = test def __eq__(self, args): index = args.index('--pkg') packages = args[index+1:index+3] if 'my_package' not in packages: self.test.fail('Expected "my_package" to be installed ' 'within the same command as "package_2"') if 'package_2' not in packages: self.test.fail('Expected "package_2" to be installed ' 'within the same command as "my_package"') return True bashrun_mock.assert_called_with(check_pkg_arguments(self)) self.assertFalse( self.dependencies_mock.called, 'Dependencies should have been discovered in the pull() step') finish_build_mock.assert_called_once_with()
def test_use_in_snap_python_rewrites_shebangs(self): plugin = catkin.CatkinPlugin('test-part', self.properties, self.project_options) os.makedirs(os.path.join(plugin.rosdir, 'bin')) # Place a few files with bad shebangs, and some files that shouldn't be # changed. files = [{ 'path': os.path.join(plugin.rosdir, '_setup_util.py'), 'contents': '#!/foo/bar/baz/python', 'expected': '#!/usr/bin/env python', }, { 'path': os.path.join(plugin.rosdir, 'bin/catkin_find'), 'contents': '#!/foo/baz/python', 'expected': '#!/usr/bin/env python', }, { 'path': os.path.join(plugin.rosdir, 'foo'), 'contents': 'foo', 'expected': 'foo', }] for file_info in files: with open(file_info['path'], 'w') as f: f.write(file_info['contents']) plugin._use_in_snap_python() for file_info in files: with open(os.path.join(plugin.rosdir, file_info['path']), 'r') as f: self.assertEqual(f.read(), file_info['expected'])
def test_build_encompasses_source_space(self, finish_mock, prepare_mock): self.properties.catkin_packages = [] plugin = catkin.CatkinPlugin('test-part', self.properties) os.makedirs(os.path.join(plugin.sourcedir, 'src')) plugin.build() self.assertTrue(os.path.isdir(os.path.join(plugin.builddir, 'src')))
def test_build_runs_in_bash(self, run_output_mock, run_mock): plugin = catkin.CatkinPlugin('test-part', self.properties) os.makedirs(os.path.join(plugin.sourcedir, 'src')) plugin.build() run_mock.assert_has_calls( [mock.call(['/bin/bash', mock.ANY], cwd=mock.ANY)])
def test_valid_catkin_workspace_src(self): # sourcedir is expected to be the root of the Catkin workspace. Since # it contains a 'src' directory, this is a valid Catkin workspace. plugin = catkin.CatkinPlugin('test-part', self.properties, self.project_options) os.makedirs(os.path.join(plugin.sourcedir, 'src')) # An exception will be raised if pull can't handle the valid workspace. plugin.pull()
def test_invalid_rosdistro(self): self.properties.rosdistro = 'invalid' with self.assertRaises(RuntimeError) as raised: catkin.CatkinPlugin('test-part', self.properties, self.project_options) self.assertEqual(str(raised.exception), "Unsupported rosdistro: 'invalid'. The supported ROS " "distributions are 'indigo', 'jade', and 'kinetic'")
def test_finish_build_file_missing(self, run_output_mock, run_mock): plugin = catkin.CatkinPlugin('test-part', self.properties) os.makedirs(plugin.rosdir) try: plugin._finish_build() except FileNotFoundError: self.fail('Unexpectedly raised an exception when files were ' 'missing')
def test_log_warning_when_unable_to_find_a_catkin_package(self): fake_logger = fixtures.FakeLogger() self.useFixture(fake_logger) plugin = catkin.CatkinPlugin('test-part', self.properties) plugin._find_package_deps() self.assertEqual('Unable to find "package.xml" for "my_package"\n', fake_logger.output)
def test_build_accounts_for_source_subdir(self, finish_mock, prepare_mock): self.properties.catkin_packages = [] self.properties.source_subdir = 'workspace' self.properties.source_space = 'foo' plugin = catkin.CatkinPlugin('test-part', self.properties) os.makedirs(os.path.join(plugin.sourcedir, 'workspace', 'foo')) plugin.build() self.assertTrue(os.path.isdir(os.path.join(plugin.builddir, 'foo')))
def test_valid_catkin_workspace_src(self): # sourcedir is expected to be the root of the Catkin workspace. Since # it contains a 'src' directory, this is a valid Catkin workspace. try: plugin = catkin.CatkinPlugin('test-part', self.properties) os.makedirs(os.path.join(plugin.sourcedir, 'src')) plugin.pull() except FileNotFoundError: self.fail('Unexpectedly raised an exception when the Catkin ' 'workspace was valid')
def test_run_environment_no_python(self, run_mock): plugin = catkin.CatkinPlugin('test-part', self.properties) python_path = os.path.join(plugin.installdir, 'usr', 'lib', 'python2.7', 'dist-packages') environment = plugin.env(plugin.installdir) self.assertFalse('PYTHONPATH={}'.format(python_path) in environment, environment)
def test_build_encompasses_remapped_source_space(self, finish_mock, prepare_mock): self.properties.catkin_packages = [] self.properties.source_space = 'foo' plugin = catkin.CatkinPlugin('test-part', self.properties, self.project_options) os.makedirs(os.path.join(plugin.sourcedir, 'foo')) plugin.build() self.assertTrue(os.path.isdir(os.path.join(plugin.builddir, 'foo')))
def test_invalid_catkin_workspace_no_src(self): # sourcedir is expected to be the root of the Catkin workspace. Since # it does not contain a `src` folder and `source-space` is 'src', this # should fail. plugin = catkin.CatkinPlugin('test-part', self.properties, self.project_options) raised = self.assertRaises(FileNotFoundError, plugin.pull) self.assertEqual( str(raised), 'Unable to find package path: "{}"'.format( os.path.join(plugin.sourcedir, 'src')))
def test_invalid_catkin_workspace_source_space_same_as_source(self): self.properties.source_space = '.' # sourcedir is expected to be the root of the Catkin workspace. Since # source_space was specified to be the same as the root, this should # fail. with self.assertRaises(RuntimeError) as raised: catkin.CatkinPlugin('test-part', self.properties).pull() self.assertEqual(str(raised.exception), 'source-space cannot be the root of the Catkin ' 'workspace')
def test_valid_catkin_workspace_source_space(self): self.properties.source_space = 'foo' # sourcedir is expected to be the root of the Catkin workspace. # Normally this would mean it contained a `src` directory, but it can # be remapped via the `source-space` key. plugin = catkin.CatkinPlugin('test-part', self.properties, self.project_options) os.makedirs( os.path.join(plugin.sourcedir, self.properties.source_space)) # An exception will be raised if pull can't handle the source space. plugin.pull()
def test_clean_pull(self): plugin = catkin.CatkinPlugin('test-part', self.properties, self.project_options) os.makedirs(os.path.join(plugin.sourcedir, 'src')) self.dependencies_mock.return_value = {'foo', 'bar', 'baz'} plugin.pull() os.makedirs(plugin._rosdep_path) plugin.clean_pull() self.assertFalse(os.path.exists(plugin._rosdep_path))
def test_exception_raised_when_package_definition_cannot_be_read( self, mock_open): mock_open.side_effect = _IOError() plugin = catkin.CatkinPlugin('test-part', self.properties) with self.assertRaises(IOError) as raised: plugin._find_package_deps() self.assertEqual(raised.exception.errno, os.errno.EACCES) xml_to_open = os.path.join( os.path.abspath(os.curdir), 'parts', 'test-part', 'build', 'src', 'my_package', 'package.xml') mock_open.assert_called_once_with(xml_to_open, 'r')
def test_finish_build_raise_errors(self, run_output_mock, run_mock): plugin = catkin.CatkinPlugin('test-part', self.properties) os.makedirs(plugin.rosdir) with open(os.path.join(plugin.rosdir, '_setup_util.py'), 'w') as f: f.write('#!/foo/bar/baz/python') with mock.patch.object(builtins, 'open', side_effect=RuntimeError('foo')): with self.assertRaises(RuntimeError) as raised: plugin._finish_build() self.assertEqual(raised.exception.args[0], 'foo')
def test_invalid_catkin_workspace_invalid_source_space(self): self.properties.source_space = 'foo' # sourcedir is expected to be the root of the Catkin workspace. Since # it does not contain a `src` folder and source_space wasn't # specified, this should fail. plugin = catkin.CatkinPlugin('test-part', self.properties, self.project_options) raised = self.assertRaises(FileNotFoundError, plugin.pull) self.assertEqual( str(raised), 'Unable to find package path: "{}"'.format( os.path.join(plugin.sourcedir, self.properties.source_space)))
def test_valid_catkin_workspace_source_space(self): self.properties.source_space = 'foo' # sourcedir is expected to be the root of the Catkin workspace. # Normally this would mean it contained a `src` directory, but it can # be remapped via the `source-space` key. try: plugin = catkin.CatkinPlugin('test-part', self.properties) os.makedirs( os.path.join(plugin.sourcedir, self.properties.source_space)) plugin.pull() except FileNotFoundError: self.fail('Unexpectedly raised an exception when the Catkin ' 'src was remapped in a valid manner')
def test_prepare_build(self, use_in_snap_python_mock): plugin = catkin.CatkinPlugin('test-part', self.properties, self.project_options) os.makedirs(os.path.join(plugin.rosdir, 'test')) # Place a few .cmake files with incorrect paths, and some files that # shouldn't be changed. files = [ { 'path': 'fooConfig.cmake', 'contents': '"/usr/lib/foo"', 'expected': '"{}/usr/lib/foo"'.format(plugin.installdir), }, { 'path': 'bar.cmake', 'contents': '"/usr/lib/bar"', 'expected': '"/usr/lib/bar"', }, { 'path': 'test/bazConfig.cmake', 'contents': '"/test/baz;/usr/lib/baz"', 'expected': '"{0}/test/baz;{0}/usr/lib/baz"'.format( plugin.installdir), }, { 'path': 'test/quxConfig.cmake', 'contents': 'qux', 'expected': 'qux', }, { 'path': 'test/installedConfig.cmake', 'contents': '"{}/foo"'.format(plugin.installdir), 'expected': '"{}/foo"'.format(plugin.installdir), } ] for file_info in files: path = os.path.join(plugin.rosdir, file_info['path']) with open(path, 'w') as f: f.write(file_info['contents']) plugin._prepare_build() self.assertTrue(use_in_snap_python_mock.called) for file_info in files: path = os.path.join(plugin.rosdir, file_info['path']) with open(path, 'r') as f: self.assertEqual(f.read(), file_info['expected'])
def test_pull_unable_to_resolve_roscore(self): self.properties.include_roscore = True plugin = catkin.CatkinPlugin('test-part', self.properties, self.project_options) os.makedirs(os.path.join(plugin.sourcedir, 'src')) # No system dependencies self.dependencies_mock.return_value = set() self.rosdep_mock.return_value.resolve_dependency.return_value = None raised = self.assertRaises(RuntimeError, plugin.pull) self.assertEqual(str(raised), 'Unable to determine system dependency for roscore')
def test_pull_invalid_dependency(self, compilers_mock): plugin = catkin.CatkinPlugin('test-part', self.properties, self.project_options) os.makedirs(os.path.join(plugin.sourcedir, 'src')) self.dependencies_mock.return_value = ['foo'] mock_instance = self.ubuntu_mock.return_value mock_instance.get.side_effect = repo.PackageNotFoundError('foo') raised = self.assertRaises(RuntimeError, plugin.pull) self.assertEqual( str(raised), 'Failed to fetch system dependencies: The Ubuntu ' "package 'foo' was not found.")
def test_pull_invalid_dependency(self): plugin = catkin.CatkinPlugin('test-part', self.properties) os.makedirs(os.path.join(plugin.sourcedir, 'src')) self.dependencies_mock.return_value = ['foo'] mock_instance = self.ubuntu_mock.return_value mock_instance.get.side_effect = repo.PackageNotFoundError('foo') with self.assertRaises(RuntimeError) as raised: plugin.pull() self.assertEqual( str(raised.exception), 'Failed to fetch system dependencies: The Ubuntu ' 'package "foo" was not found')