def test_robot_meta(start_processes: None, ars: ARServer) -> None:
assert isinstance(ars.get_event(), events.c.ShowMainScreen)
res = ars.call_rpc(rpc.r.GetRobotMeta.Request(uid()),
rpc.r.GetRobotMeta.Response)
assert res.result
assert res.data is not None
robots: Dict[str, RobotMeta] = {robot.type: robot for robot in res.data}
magician = robots[DobotMagician.__name__]
assert magician.features.move_to_pose
assert magician.features.move_to_joints
assert magician.features.inverse_kinematics
assert magician.features.forward_kinematics
assert not magician.features.stop
assert not magician.features.hand_teaching
m1 = robots[DobotM1.__name__]
assert m1.features.move_to_pose
assert m1.features.move_to_joints
assert m1.features.hand_teaching
assert not m1.features.inverse_kinematics
assert not m1.features.forward_kinematics
assert not m1.features.stop
def test_objects(start_processes: None, ars: ARServer) -> None:
assert isinstance(ars.get_event(), events.c.ShowMainScreen)
res = ars.call_rpc(rpc.o.GetObjectTypes.Request(get_id()),
rpc.o.GetObjectTypes.Response)
assert res.result
assert res.data is not None
assert {obj.type
for obj in res.data if not obj.built_in
} == {LoggingTestObject.__name__, LoggingTestRobot.__name__}
for obj in res.data:
assert not obj.disabled, f"ObjectType {obj.type} disabled. {obj.problem}"
actions = ars.call_rpc(
rpc.o.GetActions.Request(get_id(), TypeArgs(obj.type)),
rpc.o.GetActions.Response)
assert actions.result
assert actions.data is not None
for act in actions.data:
assert act.disabled == (act.problem is not None)
assert not act.disabled, f"Action {act.name} of {obj.type} disabled. {act.problem}"
def test_objects(start_processes: None, ars: ARServer) -> None:
assert isinstance(ars.get_event(), events.c.ShowMainScreen)
res = ars.call_rpc(rpc.o.GetObjectTypes.Request(uid()),
rpc.o.GetObjectTypes.Response)
assert res.result
assert res.data is not None
for obj in res.data:
assert not obj.disabled, f"ObjectType {obj.type} disabled. {obj.problem}"
actions = ars.call_rpc(
rpc.o.GetActions.Request(uid(), TypeArgs(obj.type)),
rpc.o.GetActions.Response)
assert actions.result
assert actions.data is not None
for act in actions.data:
assert act.disabled == (act.problem is not None)
# some of the kinali ObjectTypes use unsupported parameter types and it is ok
if act.disabled:
assert act.problem
if act.problem.startswith("Unknown parameter type"):
continue
assert not act.disabled, f"Action {act.name} of {obj.type} disabled. {act.problem}"
def test_robot_meta(start_processes: None, ars: ARServer) -> None:
assert isinstance(ars.get_event(), events.c.ShowMainScreen)
res = ars.call_rpc(rpc.r.GetRobotMeta.Request(get_id()),
rpc.r.GetRobotMeta.Response)
assert res.result
assert res.data is not None
robots: dict[str, RobotMeta] = {robot.type: robot for robot in res.data}
yumi = robots[YuMi.__name__]
assert yumi.features.move_to_pose
assert yumi.features.move_to_joints
assert yumi.features.inverse_kinematics
assert yumi.features.forward_kinematics
def wait_for_event(ars: ARServer, evt_type: Type[E]) -> E:
evt = ars.get_event(drop_everything_until=evt_type)
assert isinstance(evt, evt_type)
assert evt.event == evt_type.__name__ # type: ignore # TODO figure out why mypy complains
return evt
def scene(ars: ARServer) -> common.Scene:
assert isinstance(ars.get_event(), events.c.ShowMainScreen)
test = "Test scene"
assert ars.call_rpc(
rpc.s.NewScene.Request(uid(), rpc.s.NewScene.Request.Args(test, test)),
rpc.s.NewScene.Response).result
scene_evt = event(ars, events.s.OpenScene)
assert scene_evt.data
event(ars, events.s.SceneState)
test_type = "TestType"
assert ars.call_rpc(
rpc.o.NewObjectType.Request(
uid(), objects.ObjectTypeMeta(test_type, base=Generic.__name__)),
rpc.o.NewObjectType.Response,
).result
tt_evt = event(ars, events.o.ChangedObjectTypes)
assert len(tt_evt.data) == 1
assert not tt_evt.data[0].has_pose
assert tt_evt.data[0].type == test_type
assert tt_evt.data[0].base == Generic.__name__
assert ars.call_rpc(
rpc.s.AddObjectToScene.Request(
uid(), rpc.s.AddObjectToScene.Request.Args("test_type",
test_type)),
rpc.s.AddObjectToScene.Response,
).result
event(ars, events.s.SceneObjectChanged)
test_type_with_pose = "TestTypeWithPose"
assert ars.call_rpc(
rpc.o.NewObjectType.Request(
uid(),
objects.ObjectTypeMeta(test_type_with_pose,
base=GenericWithPose.__name__)),
rpc.o.NewObjectType.Response,
).result
ttwp_evt = event(ars, events.o.ChangedObjectTypes)
assert len(ttwp_evt.data) == 1
assert ttwp_evt.data[0].has_pose
assert ttwp_evt.data[0].type == test_type_with_pose
assert ttwp_evt.data[0].base == GenericWithPose.__name__
assert ars.call_rpc(
rpc.s.AddObjectToScene.Request(
uid(),
rpc.s.AddObjectToScene.Request.Args("test_type_with_pose",
test_type)),
rpc.s.AddObjectToScene.Response,
).result
event(ars, events.s.SceneObjectChanged)
assert ars.call_rpc(rpc.s.SaveScene.Request(uid()),
rpc.s.SaveScene.Response).result
event(ars, events.s.SceneSaved)
assert ars.call_rpc(rpc.s.CloseScene.Request(uid()),
rpc.s.CloseScene.Response).result
event(ars, events.s.SceneClosed)
event(ars, events.c.ShowMainScreen)
return scene_evt.data.scene
def wait_for_event(ars: ARServer, evt_type: type[E]) -> E:
evt = ars.get_event(drop_everything_until=evt_type)
assert isinstance(evt, evt_type)
assert evt.event == evt_type.__name__
return evt
def event(ars: ARServer, evt_type: type[E]) -> E:
evt = ars.get_event()
assert isinstance(evt, evt_type)
assert evt.event == evt_type.__name__
return evt