def test_get_package_prefix():
set_ament_prefix_path(['prefix1', 'prefix2'])
def get_package_prefix_basename(package_name):
return os.path.basename(get_package_prefix(package_name))
assert get_package_prefix_basename(
'foo') == 'prefix1', "Expected 'foo' in 'prefix1'"
# found in both prefix1 and prefix2, but prefix1 is ahead on the APP
assert get_package_prefix_basename(
'bar') == 'prefix1', "Expected 'bar' in 'prefix2'"
assert get_package_prefix_basename(
'baz') == 'prefix2', "Expected 'baz' in 'prefix2'"
try:
get_package_prefix('does_not_exist')
except PackageNotFoundError:
pass
except Exception as exc:
assert False, 'Expected PackageNotFoundError, got: {}'.format(
type(exc))
try:
get_package_prefix('does_not_exist')
except KeyError:
pass
except Exception as exc:
assert False, 'Expected KeyError or subclass, got: {}'.format(
type(exc))
def generate_test_description():
TEST_PROC_PATH = os.path.join(
ament_index_python.get_package_prefix('launch_testing'),
'lib/launch_testing',
'terminating_proc.py'
)
EXIT_PROC_PATH = os.path.join(
ament_index_python.get_package_prefix('launch_testing'),
'lib/launch_testing',
'exit_code_proc.py'
)
return launch.LaunchDescription([
launch.actions.ExecuteProcess(
cmd=[sys.executable, TEST_PROC_PATH, '--exception']
),
# This process makes sure we can handle processes that exit with a code but don't
# generate any output. This is a regression test for an issue fixed in PR31
launch.actions.ExecuteProcess(
cmd=[sys.executable, EXIT_PROC_PATH, '--silent']
),
launch_testing.actions.ReadyToTest(),
])
def test_get_package_prefix():
set_ament_prefix_path(['prefix1', 'prefix2'])
def get_package_prefix_basename(package_name):
return PurePath(get_package_prefix(package_name)).name
assert get_package_prefix_basename('foo') == 'prefix1', "Expected 'foo' in 'prefix1'"
# found in both prefix1 and prefix2, but prefix1 is ahead on the APP
assert get_package_prefix_basename('bar') == 'prefix1', "Expected 'bar' in 'prefix2'"
assert get_package_prefix_basename('baz') == 'prefix2', "Expected 'baz' in 'prefix2'"
with pytest.raises(PackageNotFoundError):
get_package_prefix('does_not_exist')
assert issubclass(PackageNotFoundError, KeyError)
def generate_test_description():
dut_process = launch.actions.ExecuteProcess(
cmd=[
sys.executable,
os.path.join(
ament_index_python.get_package_prefix('launch_testing'),
'lib/launch_testing',
'terminating_proc',
),
# Arguments
launch.substitutions.LaunchConfiguration('dut_arg')
], )
return launch.LaunchDescription([
# This argument can be passed into the test, and can be discovered by running
# launch_test --show-args
launch.actions.DeclareLaunchArgument(
'dut_arg',
default_value=['default'],
description='Passed to the terminating process',
),
dut_process,
# In tests where all of the procs under tests terminate themselves, it's necessary
# to add a dummy process not under test to keep the launch alive. launch_test
# provides a simple launch action that does this:
launch_testing.util.KeepAliveProc(),
launch_testing.actions.ReadyToTest()
]), {
'dut_process': dut_process
}
def test_nominally_good_dut(source_test_loader):
def test_ok(self):
pass
TEST_PROC_PATH = os.path.join(
ament_index_python.get_package_prefix('launch_testing'),
'lib/launch_testing', 'good_proc')
def generate_test_description():
return launch.LaunchDescription([
launch.actions.ExecuteProcess(
cmd=[sys.executable, TEST_PROC_PATH]),
launch_testing.actions.ReadyToTest(),
])
runner = LaunchTestRunner(
source_test_loader(
generate_test_description,
pre_shutdown_tests=[test_ok],
post_shutdown_tests=[test_ok],
))
results = runner.run()
for result in results.values():
assert result.wasSuccessful()
def generate_test_description(ready_fn):
TEST_PROC_PATH = os.path.join(
ament_index_python.get_package_prefix('apex_launchtest'),
'lib/apex_launchtest', 'terminating_proc')
EXIT_PROC_PATH = os.path.join(
ament_index_python.get_package_prefix('apex_launchtest'),
'lib/apex_launchtest', 'exit_code_proc')
return launch.LaunchDescription([
launch.actions.ExecuteProcess(cmd=[TEST_PROC_PATH, '--exception']),
# This process makes sure we can handle processes that exit with a code but don't
# generate any output. This is a regression test for an issue fixed in PR31
launch.actions.ExecuteProcess(cmd=[EXIT_PROC_PATH, '--silent']),
launch.actions.OpaqueFunction(function=lambda context: ready_fn()),
])
def generate_test_description(ready_fn):
TEST_PROC_PATH = os.path.join(
ament_index_python.get_package_prefix('apex_launchtest'),
'lib/apex_launchtest', 'terminating_proc')
return launch.LaunchDescription([
launch.actions.ExecuteProcess(cmd=[TEST_PROC_PATH]),
launch.actions.OpaqueFunction(function=lambda context: ready_fn()),
])
def generate_test_description():
TEST_PROC_PATH = os.path.join(
ament_index_python.get_package_prefix('launch_testing'),
'lib/launch_testing', 'terminating_proc')
return launch.LaunchDescription([
launch.actions.ExecuteProcess(
cmd=[sys.executable, TEST_PROC_PATH]),
launch_testing.actions.ReadyToTest(),
])
def get_test_process_action():
TEST_PROC_PATH = os.path.join(
ament_index_python.get_package_prefix('launch_testing'),
'lib/launch_testing', 'good_proc')
return launch.actions.ExecuteProcess(
cmd=[sys.executable, TEST_PROC_PATH],
name='good_proc',
# This is necessary to get unbuffered output from the process under test
additional_env={'PYTHONUNBUFFERED': '1'},
)
def get_test_process_action(*, args=[]):
test_proc_path = os.path.join(
ament_index_python.get_package_prefix('launch_testing'),
'lib/launch_testing', 'terminating_proc')
return launch.actions.ExecuteProcess(
cmd=[sys.executable, test_proc_path, *args],
name='terminating_proc',
# This is necessary to get unbuffered output from the process under test
additional_env={'PYTHONUNBUFFERED': '1'},
output='screen')
def setUpClass(cls):
# Run a launch so we can get some real looking proc_info and proc_output objects to test
# against
proc_command = os.path.join(
ament_index_python.get_package_prefix('launch_testing'),
'lib/launch_testing',
'good_proc',
)
proc_env = os.environ.copy()
proc_env['PYTHONUNBUFFERED'] = '1'
def generate_test_description():
no_arg_proc = launch.actions.ExecuteProcess(cmd=[sys.executable],
env=proc_env)
one_arg_proc = launch.actions.ExecuteProcess(
cmd=[sys.executable, proc_command, '--one-arg'], env=proc_env)
two_arg_proc = launch.actions.ExecuteProcess(
cmd=[sys.executable, proc_command, '--two-arg', 'arg_two'],
env=proc_env)
ld = launch.LaunchDescription([
no_arg_proc,
one_arg_proc,
two_arg_proc,
launch_testing.actions.ReadyToTest(),
])
return (ld, locals())
arr = []
class PreShutdownTests(unittest.TestCase):
def test_wait_self(self, proc_output, proc_info, no_arg_proc,
one_arg_proc, two_arg_proc):
proc_output.assertWaitFor('--one-arg', stream='stdout')
proc_output.assertWaitFor('--two-arg', stream='stdout')
proc_output.assertWaitFor('arg_two', stream='stdout')
arr.append(proc_info)
# Set up a fake module containing the test data:
test_module = types.ModuleType('test_module')
test_module.generate_test_description = generate_test_description
test_module.FakePreShutdownTests = PreShutdownTests
# Run the test:
runner = LaunchTestRunner(LoadTestsFromPythonModule(test_module))
runner.run()
# Grab the very realistic proc_info object to use for tests below
cls.proc_info = arr[0]
def __find_csharp_libs(self):
for package_name in self.ament_dependencies:
try:
package_install_path = get_package_prefix(package_name)
package_lib_path = package_install_path + '/lib/dotnet'
if os.path.isdir(package_lib_path):
for csharp_lib_file in os.listdir(package_lib_path):
if csharp_lib_file.endswith('.dll'):
self.cs_lib_source_dict[csharp_lib_file] = (
package_lib_path + '/' + csharp_lib_file)
except PackageNotFoundError:
print('{} not found!'.format(package_name))
def generate_test_description():
TEST_PROC_PATH = os.path.join(
ament_index_python.get_package_prefix('launch_testing'),
'lib/launch_testing', 'good_proc.py')
good_process = launch.actions.ExecuteProcess(
cmd=[sys.executable, TEST_PROC_PATH], )
# Start 'good_proc.py' after a ten second timer elapses
return launch.LaunchDescription([
launch.actions.TimerAction(period=10.0, actions=[good_process]),
launch_testing.actions.ReadyToTest(),
]), {
'good_process': good_process
}
def generate_test_description(arg_val):
TEST_PROC_PATH = os.path.join(
ament_index_python.get_package_prefix('launch_testing'),
'lib/launch_testing', 'good_proc')
# This is necessary to get unbuffered output from the process under test
proc_env = os.environ.copy()
proc_env['PYTHONUNBUFFERED'] = '1'
return launch.LaunchDescription([
launch.actions.ExecuteProcess(
cmd=[sys.executable, TEST_PROC_PATH],
env=proc_env,
),
launch_testing.actions.ReadyToTest(),
])
def generate_test_description(arg_val, ready_fn):
TEST_PROC_PATH = os.path.join(
ament_index_python.get_package_prefix('apex_launchtest'),
'lib/apex_launchtest', 'good_proc')
# This is necessary to get unbuffered output from the process under test
proc_env = os.environ.copy()
proc_env['PYTHONUNBUFFERED'] = '1'
return launch.LaunchDescription([
launch.actions.ExecuteProcess(
cmd=[TEST_PROC_PATH],
env=proc_env,
),
launch.actions.OpaqueFunction(function=lambda context: ready_fn())
])
def test_nominally_good_dut():
# The following is test setup nonsense to turn a string into a python module that can be
# passed to the test runner. You can skip over this. It does not add to your understanding
# of the test.
test_code = """
import unittest
from launch_testing import post_shutdown_test
class PreTest(unittest.TestCase):
def test_pre_ok(self):
pass
@post_shutdown_test()
class PostTest(unittest.TestCase):
def test_post_ok(self):
pass
"""
module = imp.new_module('test_module')
exec(test_code, module.__dict__)
# Here's the actual 'test' part of the test:
TEST_PROC_PATH = os.path.join(
ament_index_python.get_package_prefix('launch_testing'),
'lib/launch_testing',
'good_proc'
)
def generate_test_description(ready_fn):
return launch.LaunchDescription([
launch.actions.ExecuteProcess(
cmd=[sys.executable, TEST_PROC_PATH]
),
launch.actions.OpaqueFunction(function=lambda context: ready_fn()),
])
module.generate_test_description = generate_test_description
runner = LaunchTestRunner(
LoadTestsFromPythonModule(module)
)
results = runner.run()
for result in results.values():
assert result.wasSuccessful()
def generate_test_description(ready_fn):
package_name = 'ifm3d_ros2'
node_exe = 'camera_standalone'
namespace = NS_
nodename = NN_
exe = os.path.join(get_package_prefix(package_name), 'lib', package_name,
node_exe)
return launch.LaunchDescription([
ExecuteProcess(
cmd=[exe, '__ns:=%s' % namespace,
'__node:=%s' % nodename],
log_cmd=True,
output='screen'),
OpaqueFunction(function=lambda context: ready_fn()),
])
def setUp(self):
# Set up a launch description for the tests to use
proc_env = os.environ.copy()
proc_env["PYTHONUNBUFFERED"] = "1"
self.terminating_proc = launch.actions.ExecuteProcess(cmd=[
os.path.join(
ament_index_python.get_package_prefix('apex_launchtest'),
'lib/apex_launchtest',
'terminating_proc',
)
],
env=proc_env)
self.launch_description = launch.LaunchDescription([
self.terminating_proc,
])
def setUp(self):
# Set up a launch description for the tests to use
proc_env = os.environ.copy()
proc_env['PYTHONUNBUFFERED'] = '1'
self.terminating_proc = launch.actions.ExecuteProcess(cmd=[
sys.executable,
os.path.join(
ament_index_python.get_package_prefix('launch_testing'),
'lib/launch_testing',
'terminating_proc',
)
],
env=proc_env)
self.launch_description = launch.LaunchDescription([
self.terminating_proc,
])
def generate_test_description(arg_param, ready_fn):
terminating_process = launch.actions.ExecuteProcess(cmd=[
os.path.join(
ament_index_python.get_package_prefix('apex_launchtest'),
'lib/apex_launchtest',
'terminating_proc',
),
# Use the parameter passed to generate_test_description as an argument
# to the terminating_proc
'--{}'.format(arg_param),
])
return (launch.LaunchDescription([
terminating_process,
apex_launchtest.util.KeepAliveProc(),
launch.actions.OpaqueFunction(function=lambda context: ready_fn())
]), {
'dut_process': terminating_process
})
def generate_test_description():
TEST_PROC_PATH = os.path.join(
ament_index_python.get_package_prefix('launch_testing'),
'lib/launch_testing', 'good_proc.py')
# This is necessary to get unbuffered output from the process under test
proc_env = os.environ.copy()
proc_env['PYTHONUNBUFFERED'] = '1'
dut_process = launch.actions.ExecuteProcess(
cmd=[sys.executable, TEST_PROC_PATH], env=proc_env, output='screen')
return launch.LaunchDescription([
dut_process,
# Start tests right away - no need to wait for anything
launch_testing.actions.ReadyToTest(),
]), {
'dut_process': dut_process
}
def generate_test_description(arg_param):
terminating_process = launch.actions.ExecuteProcess(cmd=[
sys.executable,
os.path.join(
ament_index_python.get_package_prefix('launch_testing'),
'lib/launch_testing',
'terminating_proc',
),
# Use the parameter passed to generate_test_description as an argument
# to the terminating_proc
'--{}'.format(arg_param),
])
return (launch.LaunchDescription([
terminating_process,
launch_testing.util.KeepAliveProc(),
launch_testing.actions.ReadyToTest(),
]), {
'dut_process': terminating_process
})
def test_nominally_good_dut():
# The following is test setup nonsense to turn a string into a python module that can be
# passed to the apex runner. You can skip over this. It does not add to your understanding
# of the test.
test_code = """
import unittest
from apex_launchtest import post_shutdown_test
class PreTest(unittest.TestCase):
def test_pre_ok(self):
pass
@post_shutdown_test()
class PostTest(unittest.TestCase):
def test_post_ok(self):
pass
"""
module = imp.new_module("test_module")
exec(test_code, module.__dict__)
# Here's the actual 'test' part of the test:
TEST_PROC_PATH = os.path.join(
ament_index_python.get_package_prefix('apex_launchtest'),
'lib/apex_launchtest', 'good_proc')
def generate_test_description(ready_fn):
return launch.LaunchDescription([
launch.actions.ExecuteProcess(cmd=[TEST_PROC_PATH]),
launch.actions.OpaqueFunction(function=lambda context: ready_fn()),
])
runner = ApexRunner(gen_launch_description_fn=generate_test_description,
test_module=module)
pre_result, post_result = runner.run()
assert pre_result.wasSuccessful()
assert pre_result.wasSuccessful()
def __find_c_libs(self):
for package_name in self.ament_dependencies:
try:
package_install_path = get_package_prefix(package_name)
package_install_parent_directory = os.path.abspath(
os.path.join(package_install_path, os.pardir))
if platform.system() == 'Windows':
filename_extensions = ('.dll')
lib_folder = '\\bin'
package_lib_path = package_install_path + lib_folder
else:
filename_extensions = ('.so', '.so.1', 'so.2')
lib_folder = '/lib'
package_lib_path = package_install_path + lib_folder
if os.path.isdir(package_lib_path):
for c_lib_file in os.listdir(package_lib_path):
if c_lib_file.endswith(filename_extensions):
self.c_lib_source_dict[c_lib_file] = (
package_lib_path + '/' + c_lib_file)
# Find ament compiled projects not found by ament_index
# by looking in parent folders of ros install directories
for non_ros_package in self.dependencies:
if non_ros_package in os.listdir(
package_install_parent_directory):
lib_path = package_install_parent_directory + '/' + non_ros_package + lib_folder
if os.path.isdir(lib_path):
try:
for c_lib_file in os.listdir(lib_path):
if c_lib_file.endswith(
filename_extensions):
self.c_lib_source_dict[c_lib_file] = (
lib_path + '/' + c_lib_file)
except PackageNotFoundError:
pass
except PackageNotFoundError:
print('{} not found!'.format(package_name))
def generate_test_description():
TEST_PROC_PATH = os.path.join(
ament_index_python.get_package_prefix('launch_testing'),
'lib/launch_testing', 'good_proc.py')
good_process = launch.actions.ExecuteProcess(
cmd=[sys.executable, TEST_PROC_PATH], )
# Let 'good_process' run for 10 seconds, then terminate it
return launch.LaunchDescription([
good_process,
launch_testing.util.KeepAliveProc(),
launch.actions.TimerAction(
period=10.0,
actions=[
launch.actions.EmitEvent(
event=launch.events.process.SignalProcess(
signal_number=signal.SIGINT,
process_matcher=lambda proc: proc is good_process))
]),
launch_testing.actions.ReadyToTest(),
]), {
'good_process': good_process
}
def get_package_prefix_basename(package_name):
return os.path.basename(get_package_prefix(package_name))
def get_prefix_path(package_name):
try:
prefix_path = get_package_prefix(package_name)
except (PackageNotFoundError, ValueError):
return None
return prefix_path
def get_package_prefix_basename(package_name):
return PurePath(get_package_prefix(package_name)).name
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import os
import unittest
import ament_index_python
import apex_launchtest
from apex_launchtest.asserts import assertSequentialStdout
import launch
import launch.actions
TEST_PROC_PATH = os.path.join(
ament_index_python.get_package_prefix('apex_launchtest'),
'lib/apex_launchtest', 'good_proc')
# This is necessary to get unbuffered output from the process under test
proc_env = os.environ.copy()
proc_env['PYTHONUNBUFFERED'] = '1'
dut_process = launch.actions.ExecuteProcess(
cmd=[TEST_PROC_PATH],
env=proc_env,
)
def generate_test_description(ready_fn):
return launch.LaunchDescription([
import sys
import unittest
import ament_index_python
import launch
from launch.actions import RegisterEventHandler
from launch.event_handlers import OnProcessIO
from launch.event_handlers import OnProcessStart
from launch_testing import ActiveIoHandler
from launch_testing.asserts import assertInStdout
# from launch_testing.asserts import NO_CMD_ARGS
TEST_PROC_PATH = os.path.join(
ament_index_python.get_package_prefix('launch_testing'),
'lib/launch_testing', 'terminating_proc')
TEST_CMD = [sys.executable, TEST_PROC_PATH]
class TestIoHandlerAndAssertions(unittest.TestCase):
EXPECTED_TEXT = 'Ready' # Expected to be in every test run
NOT_FOUND_TEXT = 'Zazzlefraz' # Not expected to be in the output anywhere
@classmethod
def setUpClass(cls):
# It's easier to actually capture some IO from the launch system than it is to fake it
# but it takes a few seconds. We'll do it once and run tests on the same captured
# IO