class DelegationBehaviourTest(unittest.TestCase):
"""
Tests for the DelegationBehaviour
"""
def setUp(self):
rospy.init_node("TestNode")
self.manager = Manager(prefix="test_manager")
self.uut = TestDelegationBehaviour(name="test_behaviour",
planner_prefix="test_manager")
self.sensor = TopicSensor(name="test_sensor",
topic="/sensor_topic",
message_type=Bool,
initial_value=False)
self.test_condition = Condition(self.sensor, BooleanActivator())
self.effect = Effect(sensor_name="test_sensor", indicator=1.0)
self.client = self.uut.delegation_client
def tearDown(self):
self.manager.unregister()
self.uut.unregister()
def test_start(self):
"""
Tests start implementation
"""
self.uut.add_effect(self.effect)
self.uut.add_condition_for_delegation(self.test_condition)
self.uut.start()
self.assertEqual("test_behaviourGoal", self.client.goal_name)
self.assertEqual([self.test_condition], self.client.conditions)
def test_do_step(self):
"""
Tests do_step implementation
"""
self.uut.do_step()
self.assertTrue(self.client.step_done)
def test_stop(self):
"""
Tests stop implementation
"""
self.uut.stop()
self.assertTrue(self.client.terminated)
def test_success_func(self):
"""
Tests success function utility
"""
self.uut.add_effect(self.effect)
self.uut.add_condition_for_delegation(self.test_condition)
self.uut.start()
self.client.success_func()
self.assertTrue(self.client.terminated)
class DecompositionGoalTest(unittest.TestCase):
"""
Unit tests for the DecompositionGoal
"""
def setUp(self):
rospy.init_node("TestNode")
sensor = TopicSensor(name="test_sensor",
topic="sensor_topic",
message_type=Bool,
initial_value=False)
self.conditions = [Condition(sensor, BooleanActivator())]
self.manager_name = "Test_manager"
self.manager = Manager(prefix=self.manager_name)
self.goal_name = "test_goal"
self.satisfaction_threshold = 1.0
def tearDown(self):
self.manager.unregister()
def test_check_alive(self):
"""
Tests the check_if_alive function
"""
uut = DecompositionGoal(
name=self.goal_name,
planner_prefix=self.manager_name,
conditions=self.conditions,
satisfaction_threshold=self.satisfaction_threshold)
self.assertTrue(uut.check_if_alive())
self.manager.unregister()
self.assertFalse(uut.check_if_alive())
uut.unregister()
class ActivationAlgorithmTestSuite(unittest.TestCase):
def setUp(self):
self._rospy_patcher = patch('rospy.Time.now')
self._rospy_patcher.start()
self._rospy_patcher.return_value = Time(0, 0)
DynamicReconfigureServer = collections.namedtuple('DynamicReconfigureServer', 'ns')
Manager.dynamic_reconfigure_server = DynamicReconfigureServer(ns="UNUSED")
self.manager = Manager(activationThreshold=7, createLogFiles=False, max_parallel_behaviours=1)
def tearDown(self):
self.manager.unregister()
self._rospy_patcher.stop()
def test_factory(self):
algo = ActivationAlgorithmFactory.create_algorithm("default", self.manager)
self.assertNotEqual(algo, None, 'Algorithm is none')
self.assertTrue(isinstance(algo, BaseActivationAlgorithm), "Not the correct algorithm")
def test_goal_priority(self):
"""
Testing priority dependent goal activation calculation
"""
algo = BaseActivationAlgorithm(self.manager, extensive_logging=True)
algo._apply_goal_priority_weights = True
class BehaviourMock(object):
def __init__(self, name, priority):
self.priority = priority
self.name =name
def __str__(self):
return self.name
b1 = BehaviourMock("A", 1)
b2 = BehaviourMock("B", 2)
self.manager._operational_goals.append(b1)
self.manager._operational_goals.append(b2)
algo.step_preparation()
self.assertEqual(algo._goal_priority_weights[b1], 1)
self.assertEqual(algo._goal_priority_weights[b2], 2)
# now test normalisation
b1.priority = 2
b2.priority = 4
algo.step_preparation()
self.assertEqual(algo._goal_priority_weights[b1], 1)
self.assertEqual(algo._goal_priority_weights[b2], 2)
b3 = BehaviourMock("C", 3)
self.manager._operational_goals.append(b3)
algo.step_preparation()
self.assertEqual(algo._goal_priority_weights[b3], 1.5)
class DelegationGoalTest(unittest.TestCase):
"""
Unit tests for the DelegationGoal
"""
def setUp(self):
rospy.init_node("TestNode")
sensor = TopicSensor(name="test_sensor",
topic="sensor_topic",
message_type=Bool,
initial_value=False)
self.conditions = [Condition(sensor, BooleanActivator())]
self.manager_name = "Test_manager"
self.manager = Manager(prefix=self.manager_name)
self.goal_name = "test_goal"
self.satisfaction_threshold = 1.0
self.mockedDM = MockedDelegationCommunicator(
manager_name=self.manager_name, name=self.manager_name)
self.goal_repr = " ".join(
[x.getPreconditionPDDL(1.0).statement for x in self.conditions])
def tearDown(self):
self.mockedDM.__del__()
self.manager.unregister()
def test_start_auction(self):
"""
Tests start auction
"""
test_goal = DelegationGoal(name=self.goal_name,
conditions=self.conditions)
self.assertFalse(test_goal.contractor_found)
self.assertFalse(test_goal.auction_running)
test_goal.start_auction()
rospy.sleep(2)
self.assertTrue(test_goal.auction_running)
self.assertFalse(test_goal.contractor_found)
self.assertTrue(self.mockedDM.got_cfp)
self.assertEqual(self.mockedDM.CFP_last.name, "/TestNode")
self.assertEqual(self.mockedDM.CFP_last.goal_representation,
self.goal_repr)
test_goal.unregister()
def test_start_contractor(self):
"""
Tests start_with_contractor
"""
test_goal = DelegationGoal(name=self.goal_name,
conditions=self.conditions)
self.assertFalse(test_goal.contractor_found)
test_goal.start_with_contractor(planner_prefix=self.manager_name)
self.assertTrue(test_goal.contractor_found)
self.assertEqual(self.manager.goals[0].name, self.goal_name)
test_goal.unregister()
def test_finish_auction(self):
"""
Tests finish auction
"""
test_goal = DelegationGoal(name=self.goal_name,
conditions=self.conditions)
test_goal.start_auction()
self.mockedDM.send_propose(3.0, "/TestNode", test_goal.delegation_id)
self.mockedDM.set_precom_response(acceptance=True,
still_bidding=True,
cost=3.0)
self.assertTrue(test_goal.finish_auction())
self.assertTrue(test_goal.contractor_found)
self.assertEqual(self.manager.goals[0].name, self.goal_name)
test_goal.unregister()
class DelegableBehaviourTest(unittest.TestCase):
"""
Tests for the DelegableBehaviour
"""
def setUp(self):
rospy.init_node("TestNode")
self.manager = Manager(prefix="test_manager")
self.uut = TestDelegableBehaviour(name="test_behaviour",
planner_prefix="test_manager",
work_cost=5)
self.sensor = TopicSensor(name="test_sensor",
topic="/sensor_topic",
message_type=Bool,
initial_value=False)
self.test_condition = Condition(self.sensor, BooleanActivator())
self.effect = Effect(sensor_name="test_sensor", indicator=1.0)
self.client = self.uut.delegation_client
def tearDown(self):
self.manager.unregister()
self.uut.unregister()
# ------ Not working myself ------
def test_start(self):
"""
Tests start implementation (Not working myself)
"""
self.assertFalse(self.uut.currently_doing_work_locally)
self.uut.add_effect(self.effect)
self.uut.add_condition_for_delegation(self.test_condition)
self.uut.start()
self.assertEqual("test_behaviourGoal", self.client.goal_name)
self.assertEqual([self.test_condition], self.client.conditions)
self.assertFalse(self.uut.currently_doing_work_locally)
self.assertIsNone(self.uut.last_work)
def test_do_step(self):
"""
Tests do_step implementation (Not working myself)
"""
self.assertFalse(self.uut.currently_doing_work_locally)
self.uut.do_step()
self.assertIsNone(self.uut.last_work)
self.assertTrue(self.client.step_done)
def test_stop(self):
"""
Tests stop implementation (Not working myself)
"""
self.assertFalse(self.uut.currently_doing_work_locally)
self.uut.stop()
self.assertIsNone(self.uut.last_work)
self.assertTrue(self.client.terminated)
def test_success_func(self):
"""
Tests success function utility
"""
self.assertFalse(self.uut.currently_doing_work_locally)
self.uut.add_effect(self.effect)
self.uut.add_condition_for_delegation(self.test_condition)
self.uut.start()
self.assertIsNone(self.uut.last_work)
self.client.success_func()
self.assertTrue(self.client.terminated)
# ------ Working myself (locally) ------
def test_start_work_func(self):
"""
Tests start work function utility
"""
self.assertFalse(self.uut.currently_doing_work_locally)
self.uut.add_effect(self.effect)
self.uut.add_condition_for_delegation(self.test_condition)
self.uut.start()
self.assertIsNone(self.uut.last_work)
self.assertFalse(self.uut.currently_doing_work_locally)
self.client.start_work_func()
self.assertTrue(self.uut.currently_doing_work_locally)
self.assertEqual(self.uut.last_work, "start")
def test_start_locally(self):
"""
Tests start implementation (Working myself)
"""
self.assertFalse(self.uut.currently_doing_work_locally)
self.uut.add_effect(self.effect)
self.uut.add_condition_for_delegation(self.test_condition)
self.client.toggle_manager_active()
self.uut.start()
self.assertTrue(self.uut.currently_doing_work_locally)
self.assertEqual(self.uut.last_work, "start")
def test_do_step_locally(self):
"""
Tests do_step implementation (Working myself)
"""
self.assertFalse(self.uut.currently_doing_work_locally)
self.uut.add_effect(self.effect)
self.uut.add_condition_for_delegation(self.test_condition)
self.uut.start()
self.client.start_work_func()
self.uut.do_step()
self.assertTrue(self.uut.currently_doing_work_locally)
self.assertEqual(self.uut.last_work, "do_step")
def test_stop_locally(self):
"""
Tests stop implementation (Working myself)
"""
self.assertFalse(self.uut.currently_doing_work_locally)
self.uut.add_effect(self.effect)
self.uut.add_condition_for_delegation(self.test_condition)
self.uut.start()
self.client.start_work_func()
self.assertTrue(self.uut.currently_doing_work_locally)
self.uut.stop()
self.assertFalse(self.uut.currently_doing_work_locally)
self.assertEqual(self.uut.last_work, "stop")