def test_pull_pip_dependencies(self): plugin = colcon.ColconPlugin("test-part", self.properties, self.project) os.makedirs(os.path.join(plugin.sourcedir, "src")) self.dependencies_mock.return_value = {"pip": {"foo", "bar", "baz"}} plugin.pull() self.assert_rosdep_setup( plugin.options.colcon_rosdistro, os.path.join(plugin.sourcedir, "src"), os.path.join(plugin.partdir, "rosdep"), self.ubuntu_distro, plugin.PLUGIN_STAGE_SOURCES, plugin.PLUGIN_STAGE_KEYRINGS, ) self.assert_pip_setup("3", plugin.partdir, plugin.installdir, plugin.project.stage_dir) # 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.assertThat(self.dependencies_mock.call_count, Equals(1)) self.assertThat(self.dependencies_mock.call_args[0][0], Equals({"my_package"})) # Verify that the pip dependencies were installed self.pip_mock.return_value.download.assert_called_once_with( {"foo", "bar", "baz"}) self.pip_mock.return_value.install.assert_called_once_with( {"foo", "bar", "baz"})
def test_valid_colcon_workspace_src(self): # sourcedir is expected to be the root of the Colcon workspace. Since # it contains a 'src' directory, this is a valid Colcon workspace. plugin = colcon.ColconPlugin("test-part", self.properties, self.project) 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_pull_local_dependencies(self): self.properties.colcon_packages.append("package_2") self.properties.source_subdir = "subdir" plugin = colcon.ColconPlugin("test-part", self.properties, self.project) os.makedirs(os.path.join(plugin.sourcedir, "subdir", "src")) # No system dependencies (only local) self.dependencies_mock.return_value = {} plugin.pull() self.assert_rosdep_setup( plugin.options.colcon_rosdistro, os.path.join(plugin.sourcedir, "subdir", "src"), os.path.join(plugin.partdir, "rosdep"), self.ubuntu_distro, plugin.PLUGIN_STAGE_SOURCES, plugin.PLUGIN_STAGE_KEYRINGS, ) # 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.assertThat(self.dependencies_mock.call_count, Equals(1)) self.assertThat(self.dependencies_mock.call_args[0][0], Equals({"my_package", "package_2"})) # Verify that no .deb packages were installed self.assertTrue(mock.call().unpack(plugin.installdir) not in self.ubuntu_mock.mock_calls)
def test_source_setup_sh(self): plugin = colcon.ColconPlugin("test-part", self.properties, self.project) underlay = os.path.join("test-root", "opt", "ros", plugin.options.colcon_rosdistro) underlay_setup = os.path.join(underlay, "setup.sh") overlay = os.path.join("test-root", "opt", "ros", "snap") overlay_setup = os.path.join(overlay, "setup.sh") # Make sure $@ is zeroed, then setup.sh sourced, then $@ is restored lines_of_interest = [ "set --", 'if [ -f "{}" ]; then'.format(underlay_setup), '. "{}"'.format(underlay_setup), "fi", 'if [ -f "{}" ]; then'.format(overlay_setup), '. "{}"'.format(overlay_setup), "fi", 'eval "set -- $BACKUP_ARGS"', ] actual_lines = [] for line in plugin._source_setup_sh("test-root").split("\n"): line = line.strip() if line in lines_of_interest: actual_lines.append(line) self.assertThat( actual_lines, Equals(lines_of_interest), "Expected setups to be sourced after args were zeroed, followed by the " "args being restored.", )
def test_build_multiple(self, finish_build_mock, prepare_build_mock, run_output_mock, run_mock): self.properties.colcon_packages.append("package_2") plugin = colcon.ColconPlugin("test-part", self.properties, self.project) 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("--packages-select") packages = args[index + 1:index + 3] self.test.assertIn("my_package", packages) self.test.assertIn("package_2", packages) return True run_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_run_environment(self, run_mock): plugin = colcon.ColconPlugin("test-part", self.properties, self.project) with mock.patch.object(plugin, "_source_setup_sh", wraps=plugin._source_setup_sh) as sh_mock: # Joining and re-splitting to get hacked script in there as well environment = "\n".join(plugin.env(plugin.installdir)).split("\n") sh_mock.assert_called_with(plugin.installdir) underlay_setup = os.path.join(plugin.options.colcon_rosdistro, "setup.sh") overlay_setup = os.path.join("snap", "setup.sh") # Verify that LD_LIBRARY_PATH was set before any setup.sh is sourced. Also # verify that the underlay setup is sourced before the overlay. ld_library_path_index = [ i for i, line in enumerate(environment) if "LD_LIBRARY_PATH" in line ][0] underlay_source_setup_index = [ i for i, line in enumerate(environment) if underlay_setup in line ][0] overlay_source_setup_index = [ i for i, line in enumerate(environment) if overlay_setup in line ][0] self.assertThat(ld_library_path_index, LessThan(underlay_source_setup_index)) self.assertThat(underlay_source_setup_index, LessThan(overlay_source_setup_index))
def test_invalid_colcon_workspace_invalid_source_no_packages(self): """Test that an invalid source space is fine iff no packages.""" self.properties.colcon_source_space = "foo" self.properties.colcon_packages = [] plugin = colcon.ColconPlugin("test-part", self.properties, self.project) # Normally pulling should fail, but since there are no packages to # build, even an invalid workspace should be okay. plugin.pull()
def test_valid_colcon_workspace_source_space(self): self.properties.colcon_source_space = "foo" # sourcedir is expected to be the root of the Colcon workspace. # Normally this would mean it contained a `src` directory, but it can # be remapped via the `colcon-source-space` key. plugin = colcon.ColconPlugin("test-part", self.properties, self.project) os.makedirs(os.path.join(plugin.sourcedir, self.properties.colcon_source_space)) # An exception will be raised if pull can't handle the source space. plugin.pull()
def test_clean_pull(self): plugin = colcon.ColconPlugin("test-part", self.properties, self.project) os.makedirs(os.path.join(plugin.sourcedir, "src")) self.dependencies_mock.return_value = {"apt": {"foo", "bar", "baz"}} plugin.pull() os.makedirs(plugin._rosdep_path) plugin.clean_pull() self.assertFalse(os.path.exists(plugin._rosdep_path))
def test_invalid_colcon_workspace_no_src(self): # sourcedir is expected to be the root of the Colcon workspace. Since # it does not contain a `src` folder and `source-space` is 'src', this # should fail. plugin = colcon.ColconPlugin("test-part", self.properties, self.project) raised = self.assertRaises(colcon.ColconPackagePathNotFoundError, plugin.pull) self.assertThat( str(raised), Equals("Failed to find package path: {!r}".format( os.path.join(plugin.sourcedir, "src"))), )
def test_invalid_colcon_workspace_invalid_source_space(self): self.properties.colcon_source_space = "foo" # sourcedir is expected to be the root of the Colcon workspace. Since # it does not contain a `src` folder and source_space wasn't # specified, this should fail. plugin = colcon.ColconPlugin("test-part", self.properties, self.project) raised = self.assertRaises(colcon.ColconPackagePathNotFoundError, plugin.pull) self.assertThat( str(raised), Equals("Failed to find package path: {!r}".format( os.path.join(plugin.sourcedir, self.properties.colcon_source_space))), )
def test_pull_invalid_dependency(self): plugin = colcon.ColconPlugin("test-part", self.properties, self.project) os.makedirs(os.path.join(plugin.sourcedir, "src")) self.dependencies_mock.return_value = {"apt": {"foo"}} mock_instance = self.ubuntu_mock.return_value mock_instance.get.side_effect = repo.errors.PackageNotFoundError("foo") raised = self.assertRaises(colcon.ColconAptDependencyFetchError, plugin.pull) self.assertThat( str(raised), Equals( "Failed to fetch apt dependencies: The package 'foo' was not found." ), )
def test_run_environment(self, run_mock): plugin = colcon.ColconPlugin("test-part", self.properties, self.project) with mock.patch.object(plugin, "_source_setup_sh", wraps=plugin._source_setup_sh) as sh_mock: # Joining and re-splitting to get hacked script in there as well environment = "\n".join(plugin.env(plugin.installdir)).split("\n") sh_mock.assert_called_with(plugin.installdir) underlay_setup = os.path.join(plugin.options.colcon_rosdistro, "setup.sh") overlay_setup = os.path.join("snap", "setup.sh") # Verify that the python executables and root are set before any setup.sh is # sourced. Also verify that the underlay setup is sourced before the overlay. ament_python_index = [ i for i, line in enumerate(environment) if "AMENT_PYTHON_EXECUTABLE" in line ][0] colcon_python_index = [ i for i, line in enumerate(environment) if "COLCON_PYTHON_EXECUTABLE" in line ][0] root_index = [ i for i, line in enumerate(environment) if "SNAP_COLCON_ROOT" in line ][0] underlay_source_setup_index = [ i for i, line in enumerate(environment) if underlay_setup in line ][0] overlay_source_setup_index = [ i for i, line in enumerate(environment) if overlay_setup in line ][0] self.assertThat(ament_python_index, LessThan(underlay_source_setup_index)) self.assertThat(colcon_python_index, LessThan(underlay_source_setup_index)) self.assertThat(root_index, LessThan(underlay_source_setup_index)) self.assertThat(underlay_source_setup_index, LessThan(overlay_source_setup_index))
def test_build(self, finish_build_mock, prepare_build_mock, run_output_mock, run_mock): plugin = colcon.ColconPlugin("test-part", self.properties, self.project) os.makedirs(os.path.join(plugin.sourcedir, "src")) plugin.build() prepare_build_mock.assert_called_once_with() if self.colcon_packages or self.colcon_packages is None: run_mock.assert_called_with(_CheckBuildCommand(self, plugin)) else: run_mock.assert_not_called() self.assertFalse( self.dependencies_mock.called, "Dependencies should have been discovered in the pull() step", ) finish_build_mock.assert_called_once_with()
def setUp(self): super().setUp() self.plugin = colcon.ColconPlugin("test-part", self.properties, self.project)
def test_build(self, finish_build_mock, prepare_build_mock, run_output_mock, run_mock): plugin = colcon.ColconPlugin("test-part", self.properties, self.project) 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) build_attributes = self.build_attributes colcon_cmake_args = self.colcon_cmake_args colcon_catkin_cmake_args = self.colcon_catkin_cmake_args colcon_ament_cmake_args = self.colcon_ament_cmake_args disable_parallel = self.properties.disable_parallel class _check_build_command: def __init__(self, test): self.test = test def __eq__(self, args): command = " ".join(args) if "debug" in build_attributes: self.test.assertThat( command, MatchesRegex( ".*--cmake-args.*-DCMAKE_BUILD_TYPE=Debug"), ) else: self.test.assertThat( command, MatchesRegex( ".*--cmake-args.*-DCMAKE_BUILD_TYPE=Release"), ) if colcon_cmake_args: expected_args = " ".join(colcon_cmake_args) self.test.assertThat( command, MatchesRegex(".*--cmake-args.*{}".format( re.escape(expected_args))), ) if disable_parallel: self.test.assertThat( command, MatchesRegex(".*--parallel-workers=1")) else: self.test.assertThat( command, MatchesRegex(".*--parallel-workers={}".format( plugin.parallel_build_count)), ) if colcon_catkin_cmake_args: expected_args = " ".join(colcon_catkin_cmake_args) self.test.assertThat( command, MatchesRegex(".*--catkin-cmake-args.*{}".format( re.escape(expected_args))), ) if colcon_ament_cmake_args: expected_args = " ".join(colcon_ament_cmake_args) self.test.assertThat( command, MatchesRegex(".*--ament-cmake-args.*{}".format( re.escape(expected_args))), ) if self.test.colcon_packages: self.test.assertThat( command, Contains("--packages-select {}".format(" ".join( self.test.colcon_packages))), ) else: self.test.assertThat(command, Not(Contains("--packages-select"))) self.test.assertThat(args[0:2], Equals(["colcon", "build"])) self.test.assertThat(command, Contains("--merge-install")) self.test.assertThat( command, Contains("--build-base {}".format(plugin.builddir))) self.test.assertThat( command, Contains("--base-paths {}".format( plugin._ros_package_path)), ) self.test.assertThat( command, Contains("--install-base {}".format(plugin._ros_overlay))) return True if self.colcon_packages or self.colcon_packages is None: run_mock.assert_called_with(_check_build_command(self)) else: run_mock.assert_not_called() self.assertFalse( self.dependencies_mock.called, "Dependencies should have been discovered in the pull() step", ) finish_build_mock.assert_called_once_with()