def test_mock_install(self):
test_root = tempfile.mkdtemp()
try:
git1 = PathSpec('foo', 'git', 'git/uri', 'git.version')
svn1 = PathSpec('foos', 'svn', 'svn/uri', '12345')
hg1 = PathSpec('fooh', 'hg', 'hg/uri', 'hg.version')
bzr1 = PathSpec('foob', 'bzr', 'bzr/uri', 'bzr.version')
config = Config(
[git1, svn1, hg1, bzr1], test_root, None, {
"svn": MockVcsConfigElement,
"git": MockVcsConfigElement,
"hg": MockVcsConfigElement,
"bzr": MockVcsConfigElement
})
rosinstall.multiproject_cmd.cmd_install_or_update(config)
rosinstall.multiproject_cmd.cmd_install_or_update(config)
rosinstall.multiproject_cmd.cmd_install_or_update(config,
num_threads=10)
rosinstall.multiproject_cmd.cmd_install_or_update(config,
num_threads=10)
rosinstall.multiproject_cmd.cmd_install_or_update(config,
num_threads=1)
rosinstall.multiproject_cmd.cmd_install_or_update(config,
num_threads=1)
finally:
shutil.rmtree(test_root)
def test_gen_python_code_python3(self):
# requires python3 to be installed, obviously
config = Config([
PathSpec(os.path.join("test", "example_dirs", "ros_comm")),
PathSpec("bar.sh", tags=['setup-file']),
PathSpec("baz")
], self.directory, None)
rosinstall.config_yaml.generate_config_yaml(
config, '.rosinstall', '')
filename = os.path.join(self.directory, "test_gen.py")
_add_to_file(filename,
rosinstall.setupfiles.generate_embedded_python())
sh_filename = os.path.join(self.directory, "bar.sh")
_add_to_file(sh_filename, "#! /usr/bin/env sh")
cmd = "python3 %s" % filename
p = subprocess.Popen(cmd,
shell=True,
cwd=self.directory,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE)
output, err = p.communicate()
self.assertEqual(''.encode('UTF-8'), err, err)
self.assertTrue(
'/test/example_dirs/ros_comm'.encode('UTF-8') in output,
output)
self.assertTrue('baz'.encode('UTF-8') in output, output)
self.assertTrue(
'ROSINSTALL_PATH_SETUPFILE_SEPARATOR'.encode('UTF-8')
in output, output)
self.assertTrue(output.endswith('/bar.sh\n'.encode('UTF-8')),
output)
def test_remove(self):
git1 = PathSpec('foo', 'git', 'git/uri', 'git.version')
svn1 = PathSpec('foos', 'svn', 'svn/uri', '12345')
hg1 = PathSpec('fooh', 'hg', 'hg/uri', 'hg.version')
bzr1 = PathSpec('foob', 'bzr', 'bzr/uri', 'bzr.version')
config = self._get_mock_config([git1, svn1, hg1, bzr1])
self.assertEqual(4, len(config.get_config_elements()))
self.assertFalse(config.remove_element(None))
self.assertFalse(config.remove_element('bar'))
self.assertEqual(4, len(config.get_config_elements()))
self.assertTrue(config.remove_element('foo'))
self.assertEqual(3, len(config.get_config_elements()))
self.assertEqual('/install/path/foos',
config.get_config_elements()[0].get_path())
self.assertEqual('/install/path/fooh',
config.get_config_elements()[1].get_path())
self.assertEqual('/install/path/foob',
config.get_config_elements()[2].get_path())
self.assertTrue(config.remove_element('fooh'))
self.assertEqual(2, len(config.get_config_elements()))
self.assertEqual('/install/path/foos',
config.get_config_elements()[0].get_path())
self.assertEqual('/install/path/foob',
config.get_config_elements()[1].get_path())
self.assertTrue(config.remove_element('foos'))
self.assertEqual(1, len(config.get_config_elements()))
self.assertTrue(config.remove_element('foob'))
self.assertEqual(0, len(config.get_config_elements()))
def test_get_element_diff(self):
cli = MultiprojectCLI(progname='multi_cli',
config_filename='.rosinstall')
self.assertEqual('', cli._get_element_diff(None, None))
self.assertEqual('', cli._get_element_diff(None, 42))
self.assertEqual('', cli._get_element_diff(42, None))
spec = PathSpec('foolocalname',
scmtype='fooscm',
uri='foouri',
version='fooversion',
path='foopath')
spec2 = PathSpec('foolocalname')
element2 = MockConfigElement(local_name='foolocalname', spec=spec2)
elements = [element2]
config = FakeConfig(celts=elements)
output = cli._get_element_diff(spec, config)
self.assertEqual(' foolocalname', output)
output = cli._get_element_diff(spec, config, extra_verbose=True)
snippets = [
' foolocalname', 'version = fooversion', 'specified uri = foouri',
'scmtype = fooscm'
]
for s in snippets:
self.assertTrue(s in output,
"missing snippet: '%s' in '%s'" % (s, output))
def test_config_simple3(self):
git1 = PathSpec('foo', 'git', 'git/uri', 'git.version')
svn1 = PathSpec('foos', 'svn', 'svn/uri', '12345')
bzr1 = PathSpec('foob', 'bzr', 'bzr/uri', 'bzr.version')
hg1 = PathSpec('fooh', 'hg', 'hg/uri', 'hg.version')
config = self._get_mock_config([git1, svn1, hg1, bzr1])
self.assertEqual(4, len(config.get_config_elements()))
def test_cmd_generate_ros_files_catkinpp(self):
self.local_path = os.path.join(self.test_root_path, "ws4")
os.makedirs(self.local_path)
config = FakeConfig([
PathSpec(self.ros_path),
PathSpec('gitrepo', 'git', uri=self.git_path)
], self.local_path)
rosinstall.rosinstall_cmd.cmd_generate_ros_files(config,
self.local_path,
nobuild=True,
rosdep_yes=False,
catkin=True,
catkinpp=True)
self.assertFalse(
os.path.exists(os.path.join(self.local_path, 'setup.sh')))
self.assertFalse(
os.path.exists(os.path.join(self.local_path, 'setup.bash')))
self.assertFalse(
os.path.exists(os.path.join(self.local_path, 'setup.zsh')))
self.assertTrue(
os.path.exists(os.path.join(self.local_path, 'CMakeLists.txt')))
self.assertTrue(
os.path.exists(
os.path.join(self.local_path, 'workspace-config.cmake')))
def test_config_merging_kill_append(self):
git1 = PathSpec('foo', 'git', 'git/uri')
svn1 = PathSpec('foo', 'svn', 'svn/uri')
hg1 = PathSpec('foo', 'hg', 'hg/uri')
bzr1 = PathSpec('foo', 'bzr', 'bzr/uri')
config = self._get_mock_config([git1, svn1, hg1, bzr1])
self.assertEqual(1, len(config.get_config_elements()))
self.assertEqual('bzr', config.get_source()[0].get_scmtype())
self.assertEqual('/install/path/bzr/uri',
config.get_source()[0].get_uri())
config = self._get_mock_config([git1, svn1, hg1, bzr1, git1])
self.assertEqual(1, len(config.get_config_elements()))
self.assertEqual('git', config.get_source()[0].get_scmtype())
self.assertEqual('/install/path/git/uri',
config.get_source()[0].get_uri())
bzr1 = PathSpec('bar', 'bzr', 'bzr/uri')
config = self._get_mock_config([git1, svn1, hg1, bzr1])
self.assertEqual(2, len(config.get_config_elements()))
self.assertEqual('hg', config.get_source()[0].get_scmtype())
self.assertEqual('/install/path/hg/uri',
config.get_source()[0].get_uri())
self.assertEqual('bzr', config.get_source()[1].get_scmtype())
self.assertEqual('/install/path/bzr/uri',
config.get_source()[1].get_uri())
config = self._get_mock_config([git1, svn1, hg1, bzr1, git1])
self.assertEqual(2, len(config.get_config_elements()))
self.assertEqual('bzr', config.get_source()[0].get_scmtype())
self.assertEqual('/install/path/bzr/uri',
config.get_source()[0].get_uri())
self.assertEqual('git', config.get_source()[1].get_scmtype())
self.assertEqual('/install/path/git/uri',
config.get_source()[1].get_uri())
def test_mock_install_fail(self):
test_root = tempfile.mkdtemp()
try:
# robust
git1 = PathSpec('foo', 'git', 'git/uri', 'git.version')
svn1 = PathSpec('foos', 'svn', 'svn/uri', '12345')
hg1 = PathSpec('fooh', 'hg', 'hg/uri', 'hg.version')
bzr1 = PathSpec('foob', 'bzr', 'bzr/uri', 'bzr.version')
config = Config(
[git1, svn1, hg1, bzr1], test_root, None, {
"svn": MockVcsConfigElement,
"git": MockVcsConfigElement,
"hg": MockVcsConfigElement,
"bzr": MockVcsConfigElement
})
config.get_config_elements()[1].install_success = False
rosinstall.multiproject_cmd.cmd_install_or_update(config,
robust=True)
try:
rosinstall.multiproject_cmd.cmd_install_or_update(config,
robust=False)
self.fail("expected Exception")
except MultiProjectException:
pass
finally:
shutil.rmtree(test_root)
def test_require_bootstrap(self):
config = FakeConfig()
self.assertFalse(
rosinstall.rosinstall_cmd._ros_requires_boostrap(config))
config = FakeConfig([PathSpec(self.ros_path, path=self.ros_path)])
self.assertFalse(
rosinstall.rosinstall_cmd._ros_requires_boostrap(config))
config = FakeConfig(
[PathSpec(self.ros_path, 'git', 'gituri', path=self.ros_path)])
self.assertTrue(
rosinstall.rosinstall_cmd._ros_requires_boostrap(config))
def test_source_setup_sh(self):
test_folder = os.path.join(self.test_root_path, 'workspacetest')
os.makedirs(test_folder)
othersetupfile = os.path.join(test_folder, 'othersetup.sh')
testsetupfile = os.path.join(test_folder, 'testsetup.sh')
with open(othersetupfile, 'w') as fhand:
fhand.write('unset ROS_WORKSPACE')
config = Config([
PathSpec(self.ros_path),
PathSpec(othersetupfile, scmtype=None, tags=['setup-file'])
],
install_path=test_folder,
config_filename=ROSINSTALL_FILENAME)
result = rosinstall.setupfiles.generate_setup_sh_text(
config.get_base_path())
self.assertTrue('export ROS_WORKSPACE=%s' % test_folder in result)
with open(testsetupfile, 'w') as fhand:
fhand.write(result)
# check that sourcing setup.sh raises error when .rosinstall is missing
raised = False
try:
subprocess.check_call(". %s" % testsetupfile,
shell=True,
env=self.new_environ)
except:
raised = True
self.assertTrue(
raised, 'sourcing setup.sh with missing .rosinstall should fail')
# test that our otherscript really unsets ROS_WORKSPACE, else nexttest would be invalid
# using basename to check var is not set
raised = False
try:
cmd = "export ROS_WORKSPACE=foo && . %s && basename $ROS_WORKSPACE" % othersetupfile
subprocess.check_call(cmd, shell=True, env=self.new_environ)
except:
raised = True
self.assertTrue(raised, 'unsetting-sh-file did not unset var')
# now test that when sourcing setup.sh that contains a
# setup-file to other sh file which unsets ROS_WORKSPACE,
# ROS_WORKSPACE is still set in the end
generate_config_yaml(config, ROSINSTALL_FILENAME, '')
self.assertTrue(
os.path.isfile(os.path.join(test_folder, ROSINSTALL_FILENAME)))
# using basename to check var is set
cmd = "export ROS_WORKSPACE=foo && . %s && echo $ROS_WORKSPACE" % testsetupfile
po = subprocess.Popen(cmd,
shell=True,
cwd=test_folder,
stdout=subprocess.PIPE)
workspace = po.stdout.read().decode('UTF-8').rstrip('"').lstrip(
'"').strip()
po.stdout.close()
self.assertEqual(test_folder, workspace)
def test_init(self):
yaml = []
install_path = '/install/path'
config_filename = '.filename'
config = Config(yaml, install_path, config_filename)
self.assertEqual(install_path, config.get_base_path())
self.assertEqual([], config.get_config_elements())
config = Config([
PathSpec("foo"),
PathSpec(os.path.join("test", "example_dirs", "ros_comm")),
PathSpec(os.path.join("test", "example_dirs", "ros")),
PathSpec(os.path.join("test", "example_dirs", "roscpp")),
PathSpec("bar")
], ".", None)
self.assertEqual(os.path.abspath('.'), config.get_base_path())
def test_gen_setup_bash(self):
config = Config([
PathSpec(self.ros_path),
PathSpec(os.path.join("test", "example_dirs", "ros_comm")),
PathSpec("bar")
], self.test_root_path, None)
result = rosinstall.setupfiles.generate_setup_bash_text('bash')
self.assertTrue(result.count("#!/usr/bin/env bash") == 1)
self.assertTrue(result.count("CATKIN_SHELL=bash") == 1)
self.assertTrue(
result.count("ROSSHELL_PATH=`rospack find rosbash`/rosbash") == 1)
result = rosinstall.setupfiles.generate_setup_bash_text('zsh')
self.assertTrue(result.count("#!/usr/bin/env zsh") == 1)
self.assertTrue(result.count("CATKIN_SHELL=zsh") == 1)
self.assertTrue(
result.count("ROSSHELL_PATH=`rospack find rosbash`/roszsh") == 1)
def test_get_stack_element_in_config(self):
self.test_root_path = tempfile.mkdtemp()
self.install_path = os.path.join(self.test_root_path, "install")
os.makedirs(self.install_path)
f = io.open(os.path.join(self.install_path, 'stack.xml'), 'a')
f.write(unicode("hello stack"))
f.close()
config = Config([PathSpec("foo"),
PathSpec("install"),
PathSpec("bar")],
self.test_root_path,
None)
self.assertEqual(None, rosinstall.rosws_stacks_cli.get_stack_element_in_config(config, 'foo'))
self.assertEqual(None, rosinstall.rosws_stacks_cli.get_stack_element_in_config(config, None))
el = rosinstall.rosws_stacks_cli.get_stack_element_in_config(config, 'install')
self.assertEqual(self.install_path, el.get_path())
shutil.rmtree(self.test_root_path)
def test_config_simple1(self):
mock1 = PathSpec('foo')
config = self._get_mock_config([mock1])
self.assertEqual(1, len(config.get_config_elements()))
self.assertEqual('foo',
config.get_config_elements()[0].get_local_name())
self.assertEqual('/install/path/foo',
config.get_config_elements()[0].get_path())
def test_unnormalized_localname(self):
"Should source normalize local-name"
mock1 = PathSpec('foo/bar/..')
config = self._get_mock_config([mock1])
self.assertEqual(1, len(config.get_config_elements()))
self.assertEqual('foo',
config.get_config_elements()[0].get_local_name())
self.assertEqual('/install/path/foo',
config.get_config_elements()[0].get_path())
def test_absolute_localname(self):
mock1 = PathSpec('/foo/bim')
config = self._get_mock_config([mock1],
install_path='/foo/bar/ba/ra/baz/bam')
self.assertEqual(1, len(config.get_config_elements()))
self.assertEqual('/foo/bim',
config.get_config_elements()[0].get_local_name())
self.assertEqual('/foo/bim',
config.get_config_elements()[0].get_path())
def test_config_simple1_with_setupfile(self):
mock1 = PathSpec('setup.sh', tags='setup-file')
config = self._get_mock_config([mock1])
self.assertEqual(1, len(config.get_config_elements()))
self.assertEqual('setup.sh',
config.get_config_elements()[0].get_local_name())
self.assertEqual('/install/path/setup.sh',
config.get_config_elements()[0].get_path())
mock1 = PathSpec('/foo')
mock2 = PathSpec('/opt/setup.sh', tags='setup-file')
mock3 = PathSpec('/bar')
config = self._get_mock_config([mock1, mock2, mock3])
self.assertEqual(3, len(config.get_config_elements()))
self.assertEqual('/opt/setup.sh',
config.get_config_elements()[1].get_local_name())
self.assertEqual('/opt/setup.sh',
config.get_config_elements()[1].get_path())
def test_long_localname(self):
"Should source choose shorter local-name"
mock1 = PathSpec("/foo/bar/boo/far/bim")
config = self._get_mock_config([mock1], '/foo/bar/boo/far')
self.assertEqual(1, len(config.get_config_elements()))
self.assertEqual('/foo/bar/boo/far/bim',
config.get_config_elements()[0].get_local_name())
self.assertEqual('/foo/bar/boo/far/bim',
config.get_config_elements()[0].get_path())
def test_config_realfolders(self):
try:
root_path = tempfile.mkdtemp()
share_path = os.path.join(root_path, "share")
os.makedirs(share_path)
ros_path = os.path.join(share_path, "ros")
os.makedirs(ros_path)
p1 = PathSpec('share')
p2 = PathSpec('share/ros')
config = self._get_mock_config([p1, p2])
self.assertEqual(2, len(config.get_config_elements()))
try:
p1 = PathSpec('share', 'git', 'git/uri', 'git.version')
p2 = PathSpec('share/ros', 'hg', 'hg/uri', 'hg.version')
config = self._get_mock_config([p1, p2])
self.fail("expected overlap Exception")
except MultiProjectException:
pass
try:
p1 = PathSpec('share', 'git', 'git/uri', 'git.version')
p2 = PathSpec('share/ros', 'hg', 'hg/uri', 'hg.version')
config = self._get_mock_config([p2, p1])
self.fail("expected overlap Exception")
except MultiProjectException:
pass
try:
p1 = PathSpec('share', 'git', 'git/uri', 'git.version')
p2 = PathSpec('share/ros')
config = self._get_mock_config([p2, p1])
self.fail("expected overlap Exception")
except MultiProjectException:
pass
try:
p1 = PathSpec('share', 'git', 'git/uri', 'git.version')
p2 = PathSpec('share/ros')
config = self._get_mock_config([p1, p2])
self.fail("expected overlap Exception")
except MultiProjectException:
pass
finally:
shutil.rmtree(root_path)
def test_generate_with_stack(self):
self.directory = tempfile.mkdtemp()
config = rosinstall.config.Config([PathSpec('ros', 'svn', 'some/uri')], self.directory)
rosinstall.config_yaml.generate_config_yaml(config, 'foo', "# Hello\n")
filepath = os.path.join(self.directory, 'foo')
self.assertTrue(os.path.exists(filepath))
with open(filepath, 'r') as f:
read_data = f.read()
lines = read_data.splitlines()
self.assertEqual("# Hello", lines[0])
self.assertEqual("- svn: {local-name: ros, uri: %s/some/uri}" % self.directory, lines[1])
def get_path_spec(self):
"yaml as from source"
version = self.version
if version == '':
version = None
return PathSpec(local_name=self.get_local_name(),
path=self.get_path(),
scmtype=self.get_vcs_type_name(),
uri=self.uri,
version=version,
tags=self.get_properties())
def test_init_fail(self):
try:
Config(None, "path", None)
self.fail("expected Exception")
except MultiProjectException:
pass
try:
Config([PathSpec('foo', 'bar')], "path", None)
self.fail("expected Exception")
except MultiProjectException:
pass
def test_get_ros_stack_path(self):
config = Config([
PathSpec("foo"),
PathSpec(os.path.join("test", "example_dirs", "ros_comm")),
PathSpec(os.path.join("test", "example_dirs", "roscpp")),
PathSpec("bar")
], ".", None)
self.assertEqual(None, rosinstall.helpers.get_ros_stack_path(config))
config = Config([
PathSpec("foo"),
PathSpec(os.path.join("test", "example_dirs", "ros_comm")),
PathSpec(os.path.join("test", "example_dirs", "ros")),
PathSpec(os.path.join("test", "example_dirs", "roscpp")),
PathSpec("bar")
], ".", None)
self.assertEqual(os.path.abspath("test/example_dirs/ros"),
rosinstall.helpers.get_ros_stack_path(config))
def test_aggregate_from_uris(self):
self.directory = tempfile.mkdtemp()
config = rosinstall.config.Config(
[PathSpec('ros', 'svn', 'some/uri')], self.directory)
rosinstall.config_yaml.generate_config_yaml(config, 'foo', "# Hello\n")
ryaml = aggregate_from_uris(
[self.directory], config.get_config_filename())
self.assertEqual(ryaml[0].get_legacy_yaml(),
{'other': {'local-name': self.directory}})
self.assertRaises(MultiProjectException,
aggregate_from_uris,
[self.directory],
config.get_config_filename(),
allow_other_element=False)
def test_gen_setup(self):
try:
config = Config([
PathSpec(os.path.join("test", "example_dirs", "ros_comm")),
PathSpec("bar")
], self.test_root_path, None)
rosinstall.setupfiles.generate_setup(config)
self.fail('expected exception')
except ROSInstallException:
pass
config = Config([
PathSpec(self.ros_path),
PathSpec(os.path.join("test", "example_dirs", "ros_comm")),
PathSpec("bar")
], self.test_root_path, None)
rosinstall.setupfiles.generate_setup(config)
self.assertTrue(
os.path.isfile(os.path.join(self.test_root_path, 'setup.sh')))
self.assertTrue(
os.path.isfile(os.path.join(self.test_root_path, 'setup.bash')))
self.assertTrue(
os.path.isfile(os.path.join(self.test_root_path, 'setup.zsh')))
def test_config_simple2(self):
git1 = PathSpec('foo', 'git', 'git/uri')
svn1 = PathSpec('foos', 'svn', 'svn/uri')
hg1 = PathSpec('fooh', 'hg', 'hg/uri')
bzr1 = PathSpec('foob', 'bzr', 'bzr/uri')
config = self._get_mock_config([git1, svn1, hg1, bzr1])
self.assertEqual(4, len(config.get_config_elements()))
self.assertEqual('foo',
config.get_config_elements()[0].get_local_name())
self.assertEqual('/install/path/foo',
config.get_config_elements()[0].get_path())
self.assertEqual('git', config.get_source()[0].get_scmtype())
self.assertEqual('/install/path/git/uri',
config.get_source()[0].get_uri())
self.assertEqual('svn', config.get_source()[1].get_scmtype())
self.assertEqual('/install/path/svn/uri',
config.get_source()[1].get_uri())
self.assertEqual('hg', config.get_source()[2].get_scmtype())
self.assertEqual('/install/path/hg/uri',
config.get_source()[2].get_uri())
self.assertEqual('bzr', config.get_source()[3].get_scmtype())
self.assertEqual('/install/path/bzr/uri',
config.get_source()[3].get_uri())
def test_rewrite_included_source_setupfile(self):
base_path = '/foo/bar'
version = 'common_rosdeps-1.0.2'
uri = 'https://kforge.ros.org/common/rosdepcore'
# same simple
struct = [PathSpec('local', tags='setup-file')]
rewrite_included_source(struct, "/foo/bar")
self.assertEqual(PathSpec(os.path.join(base_path, "local"), tags='setup-file'), struct[0])
# absolute path
struct = [PathSpec("/opt/poo", tags='setup-file')]
rewrite_included_source(struct, "/foo/bar")
self.assertEqual([PathSpec("/opt/poo", tags='setup-file')], struct)
# absolute path, relative basepath
struct = [PathSpec("/opt/poo", tags='setup-file')]
rewrite_included_source(struct, "foo/bar")
self.assertEqual([PathSpec("/opt/poo", tags='setup-file')], struct)
# relative base path
struct = [PathSpec("../opt/poo", tags='setup-file')]
rewrite_included_source(struct, "foo/bar")
self.assertEqual([PathSpec("foo/opt/poo", tags='setup-file')], struct)
def cmd_snapshot(config, localnames=None):
elements = select_elements(config, localnames)
source_aggregate = []
for element in elements:
if element.is_vcs_element():
spec = element.get_versioned_path_spec()
export_spec = PathSpec(local_name=spec.get_local_name(),
scmtype=spec.get_scmtype(),
uri=spec.get_uri() or spec.get_curr_uri(),
version=(spec.get_current_revision()
or spec.get_revision()
or spec.get_version()),
path=spec.get_path())
if not export_spec.get_version():
sys.stderr.write('Warning, discarding non-vcs element %s\n' %
element.get_local_name())
source = export_spec.get_legacy_yaml()
source_aggregate.append(source)
else:
sys.stderr.write('Warning, discarding non-vcs element %s\n' %
element.get_local_name())
return source_aggregate
def test_gen_setupsh(self):
config = Config([
PathSpec(self.ros_path),
PathSpec(os.path.join("test", "example_dirs", "ros_comm")),
PathSpec("bar")
], self.test_root_path, None)
result = rosinstall.setupfiles.generate_setup_sh_text(
config.get_base_path())
self.assertTrue(result.count("#!/usr/bin/env sh") == 1)
config = Config([
PathSpec(self.ros_path),
PathSpec(os.path.join("test", "example_dirs", "ros_comm")),
PathSpec("bar.sh", tags=['setup-file'])
], self.test_root_path, None)
result = rosinstall.setupfiles.generate_setup_sh_text(
config.get_base_path())
self.assertTrue(result.count("#!/usr/bin/env sh") == 1, result)
def get_versioned_path_spec(self):
"yaml looking up current version"
version = self.version
if version == '':
version = None
revision = None
if version is not None:
# revision is the UID of the version spec, can be them same
revision = self._get_vcsc().get_version(self.version)
currevision = self._get_vcsc().get_version()
uri = self.uri
curr_uri = self._get_vcsc().get_url()
# uri might be a shorthand notation equivalent to curr_uri
if self._get_vcsc().url_matches(curr_uri, uri):
curr_uri = uri
return PathSpec(local_name=self.get_local_name(),
path=self.get_path(),
scmtype=self.get_vcs_type_name(),
uri=self.uri,
version=version,
revision=revision,
currevision=currevision,
curr_uri=curr_uri,
tags=self.get_properties())
