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(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_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 test_valid_object_types(start_processes: None, ars: ARServer, model: ObjectModel) -> None: event(ars, events.c.ShowMainScreen) type_name = "TestType" model.model().id = type_name if model.mesh: project_service.upload_file(mesh_filename, b"") assert ars.call_rpc( rpc.o.NewObjectType.Request( get_id(), objects.ObjectTypeMeta(type_name, base=CollisionObject.__name__, object_model=model) ), rpc.o.NewObjectType.Response, ).result evt = event(ars, events.o.ChangedObjectTypes) assert len(evt.data) == 1 assert evt.data[0].has_pose assert evt.data[0].type == type_name assert evt.data[0].base == CollisionObject.__name__ assert evt.data[0].object_model == model project_service.get_model(model.model().id, model.type) project_service.get_object_type(type_name)
def unlock_object(ars: ARServer, obj_id: str) -> None: assert ars.call_rpc( rpc.lock.WriteUnlock.Request( uid(), rpc.lock.WriteUnlock.Request.Args(obj_id)), rpc.lock.WriteUnlock.Response) event(ars, events.lk.ObjectsUnlocked)
def lock_object(ars: ARServer, obj_id: str, lock_tree: bool = False) -> None: assert ars.call_rpc( rpc.lock.WriteLock.Request( uid(), rpc.lock.WriteLock.Request.Args(obj_id, lock_tree)), rpc.lock.WriteLock.Response, ).result event(ars, events.lk.ObjectsLocked)
def test_project_ap_rpcs(start_processes: None, ars: ARServer, scene: common.Scene) -> None: assert ars.call_rpc( rpc.p.NewProject.Request( uid(), rpc.p.NewProject.Request.Args(scene.id, "Project name")), rpc.p.NewProject.Response, ).result event(ars, events.p.OpenProject)
def ars() -> Iterator[ARServer]: with ARServer(ars_connection_str(), timeout=30, event_mapping=event_mapping) as ws: test_username = "******" assert ws.call_rpc( rpc.u.RegisterUser.Request( uid(), rpc.u.RegisterUser.Request.Args(test_username)), rpc.u.RegisterUser.Response, ).result yield ws
def add_logic_item( ars: ARServer, start: str, end: str, condition: Optional[common.ProjectLogicIf] = None) -> common.LogicItem: assert ars.call_rpc( rpc.p.AddLogicItem.Request( uid(), rpc.p.AddLogicItem.Request.Args(start, end, condition)), rpc.p.AddLogicItem.Response, ).result evt = event(ars, events.p.LogicItemChanged) assert evt.data return evt.data
def test_valid_object_types(start_processes: None, ars: ARServer, model: ObjectModel) -> None: event(ars, events.c.ShowMainScreen) type_name = "TestType" model.model().id = type_name assert ars.call_rpc( rpc.o.NewObjectType.Request( uid(), objects.ObjectTypeMeta(type_name, base=GenericWithPose.__name__, object_model=model) ), rpc.o.NewObjectType.Response, ).result evt = event(ars, events.o.ChangedObjectTypes) assert len(evt.data) == 1 assert evt.data[0].has_pose assert evt.data[0].type == type_name assert evt.data[0].base == GenericWithPose.__name__ assert evt.data[0].object_model == model
def test_object_parameters(start_processes: None, ars: ARServer, scene: Scene) -> None: assert ars.call_rpc(rpc.s.OpenScene.Request(uid(), IdArgs(scene.id)), rpc.s.OpenScene.Response).result event(ars, events.s.OpenScene) assert ars.call_rpc( rpc.s.AddObjectToScene.Request( uid(), rpc.s.AddObjectToScene.Request.Args("ows", ObjectWithActions.__name__)), rpc.s.AddObjectToScene.Response, ).result obj = event(ars, events.s.SceneObjectChanged).data assert obj is not None assert ars.call_rpc( rpc.p.NewProject.Request( uid(), rpc.p.NewProject.Request.Args(scene.id, "Project name")), rpc.p.NewProject.Response, ).result event(ars, events.p.OpenProject) assert ars.call_rpc( rpc.p.AddActionPoint.Request( uid(), rpc.p.AddActionPoint.Request.Args("ap", Position())), rpc.p.AddActionPoint.Response, ).result ap = event(ars, events.p.ActionPointChanged).data assert ap is not None assert ars.call_rpc( rpc.p.AddAction.Request( uid(), rpc.p.AddAction.Request.Args( ap.id, "a1", f"{obj.id}/{ObjectWithActions.bool_action.__name__}", [], [Flow(outputs=["bool_result"])], ), ), rpc.p.AddAction.Response, ).result a1 = event(ars, events.p.ActionChanged).data assert a1 is not None assert ars.call_rpc( rpc.p.AddAction.Request( uid(), rpc.p.AddAction.Request.Args( ap.id, "a2", f"{obj.id}/{ObjectWithActions.str_action.__name__}", [], [Flow()], ), ), rpc.p.AddAction.Response, ).result a2 = event(ars, events.p.ActionChanged).data assert a2 is not None add_logic_item(ars, LogicItem.START, a1.id) add_logic_item( ars, a1.id, a2.id, ProjectLogicIf(f"{a1.id}/{FlowTypes.DEFAULT}/{0}", json.dumps(True))) add_logic_item(ars, a2.id, LogicItem.END) add_logic_item( ars, a1.id, LogicItem.END, ProjectLogicIf(f"{a1.id}/{FlowTypes.DEFAULT}/{0}", json.dumps(False))) # TODO try to add some invalid connections here? save_project(ars)
def test_virtual_collision_object(start_processes: None, ars: ARServer) -> None: event(ars, events.c.ShowMainScreen) assert ars.call_rpc( rpc.s.NewScene.Request(get_id(), rpc.s.NewScene.Request.Args("TestScene")), rpc.s.NewScene.Response ).result event(ars, events.s.OpenScene) event(ars, events.s.SceneState) name = "vco" box = Box(name, 0.1, 0.1, 0.1) om = ObjectModel(box.type(), box=box) add_vco = ars.call_rpc( rpc.s.AddVirtualCollisionObjectToScene.Request( get_id(), rpc.s.AddVirtualCollisionObjectToScene.Request.Args(name, Pose(), om) ), rpc.s.AddVirtualCollisionObjectToScene.Response, ) ot = project_service.get_object_type(name) assert ot.source assert add_vco.result ot_evt = event(ars, events.o.ChangedObjectTypes) assert ot_evt.change_type == ot_evt.Type.ADD assert len(ot_evt.data) == 1 assert ot_evt.data[0].object_model == om assert ot_evt.data[0].type == name scn_evt = event(ars, events.s.SceneObjectChanged) assert scn_evt.change_type == ot_evt.Type.ADD assert scn_evt.data.name == name assert ars.call_rpc( rpc.s.StartScene.Request(get_id()), rpc.s.StartScene.Response, ).result assert event(ars, events.s.SceneState).data.state == events.s.SceneState.Data.StateEnum.Starting assert event(ars, events.s.SceneState).data.state == events.s.SceneState.Data.StateEnum.Started # stop can't be called just after start, because of assertion in start_scene coroutine (arserver): # assert ret == await scene_srv.started() # assertions are disabled in release, so this is issue only when running tests, and it happens randomly time.sleep(1) assert ars.call_rpc( rpc.s.StopScene.Request(get_id()), rpc.s.StopScene.Response, ).result assert event(ars, events.s.SceneState).data.state == events.s.SceneState.Data.StateEnum.Stopping assert event(ars, events.s.SceneState).data.state == events.s.SceneState.Data.StateEnum.Stopped delete_res_2 = ars.call_rpc( rpc.s.RemoveFromScene.Request(get_id(), rpc.s.RemoveFromScene.Request.Args(scn_evt.data.id)), rpc.s.RemoveFromScene.Response, ) assert delete_res_2.result scn_evt2 = event(ars, events.s.SceneObjectChanged) assert scn_evt2.change_type == ot_evt.Type.REMOVE assert scn_evt2.data.name == name assert ars.call_rpc( rpc.s.SaveScene.Request(get_id()), rpc.s.SaveScene.Response, ).result assert event(ars, events.s.SceneSaved) ot_evt2 = event(ars, events.o.ChangedObjectTypes) assert ot_evt2.change_type == ot_evt2.Type.REMOVE assert len(ot_evt2.data) == 1 assert ot_evt2.data[0].object_model == om assert ot_evt2.data[0].type == name assert name not in {ot.id for ot in project_service.get_object_type_ids()}
def test_project_ap_rpcs(start_processes: None, ars: ARServer) -> None: upload_def(Box, BoxModel(Box.__name__, 1, 2, 3)) event(ars, events.c.ShowMainScreen) assert ars.call_rpc( rpc.s.NewScene.Request(get_id(), rpc.s.NewScene.Request.Args("Test scene")), rpc.s.NewScene.Response ).result assert len(event(ars, events.o.ChangedObjectTypes).data) == 1 scene_data = event(ars, events.s.OpenScene).data assert scene_data scene = scene_data.scene event(ars, events.s.SceneState) assert ars.call_rpc( rpc.s.AddObjectToScene.Request(get_id(), rpc.s.AddObjectToScene.Request.Args("box", Box.__name__, Pose())), rpc.s.AddObjectToScene.Response, ).result obj = event(ars, events.s.SceneObjectChanged).data assert obj # ------------------------------------------------------------------------------------------------------------------ assert ars.call_rpc( rpc.p.NewProject.Request(get_id(), rpc.p.NewProject.Request.Args(scene.id, "Project name")), rpc.p.NewProject.Response, ).result event(ars, events.s.SceneSaved) event(ars, events.p.OpenProject) event(ars, events.s.SceneState) assert ars.call_rpc( rpc.p.AddActionPoint.Request(get_id(), rpc.p.AddActionPoint.Request.Args("parent_ap", Position())), rpc.p.AddActionPoint.Response, ).result parent_ap_evt = event(ars, events.p.ActionPointChanged) assert ars.call_rpc( rpc.p.AddActionPoint.Request( get_id(), rpc.p.AddActionPoint.Request.Args("child_ap", Position(-1), parent_ap_evt.data.id) ), rpc.p.AddActionPoint.Response, ).result child_ap_evt = event(ars, events.p.ActionPointChanged) assert child_ap_evt.data.parent == parent_ap_evt.data.id lock_object(ars, child_ap_evt.data.id) assert ars.call_rpc( rpc.p.AddActionPointOrientation.Request( get_id(), rpc.p.AddActionPointOrientation.Request.Args(child_ap_evt.data.id, Orientation()) ), rpc.p.AddActionPointOrientation.Response, ).result ori = event(ars, events.p.OrientationChanged) assert ars.call_rpc( rpc.p.AddAction.Request( get_id(), rpc.p.AddAction.Request.Args( child_ap_evt.data.id, "act_name", f"{obj.id}/{Box.update_pose.__name__}", [ActionParameter("new_pose", PosePlugin.type_name(), json.dumps(ori.data.id))], [Flow()], ), ), rpc.p.AddAction.Response, ).result event(ars, events.p.ActionChanged) unlock_object(ars, child_ap_evt.data.id) ars.event_mapping[ActionChanged.__name__] = ActionChanged assert ars.call_rpc( rpc.p.CopyActionPoint.Request(get_id(), rpc.p.CopyActionPoint.Request.Args(parent_ap_evt.data.id)), rpc.p.CopyActionPoint.Response, ).result new_parent_ap = event(ars, events.p.ActionPointChanged) assert not new_parent_ap.data.parent new_child_ap = event(ars, events.p.ActionPointChanged) assert new_child_ap.data.parent == new_parent_ap.data.id new_ori = event(ars, events.p.OrientationChanged) assert new_ori.parent_id == new_child_ap.data.id # with events.p.ActionChanged it would return only BareAction (without parameters) new_action = event(ars, ActionChanged) ars.event_mapping[ActionChanged.__name__] = events.p.ActionChanged assert new_action.parent_id == new_child_ap.data.id # Pose parameter (orientation id) should be updated now assert len(new_action.data.parameters) == 1 assert json.loads(new_action.data.parameters[0].value) == new_ori.data.id
def test_update_object_model(start_processes: None, ars: ARServer) -> None: upload_def(BoxType, Box(BoxType.__name__, 0.1, 0.1, 0.1)) upload_def(DummyMultiArmRobot) event(ars, events.c.ShowMainScreen) assert ars.call_rpc( rpc.s.NewScene.Request(get_id(), rpc.s.NewScene.Request.Args("TestScene")), rpc.s.NewScene.Response ).result assert len(event(ars, events.o.ChangedObjectTypes).data) == 2 event(ars, events.s.OpenScene) event(ars, events.s.SceneState) lock_object(ars, BoxType.__name__) om = ObjectModel(Model3dType.SPHERE, sphere=Sphere(BoxType.__name__, 0.1)) assert ars.call_rpc( rpc.o.UpdateObjectModel.Request(get_id(), rpc.o.UpdateObjectModel.Request.Args(BoxType.__name__, om)), rpc.o.UpdateObjectModel.Response, ).result ot_evt = event(ars, events.o.ChangedObjectTypes) assert ot_evt.change_type == ot_evt.Type.UPDATE assert len(ot_evt.data) == 1 assert ot_evt.data[0].object_model == om assert ot_evt.data[0].type == BoxType.__name__ assert ot_evt.data[0].has_pose assert not ot_evt.data[0].disabled assert BoxType.__name__ in {obj.id for obj in project_service.get_object_type_ids()} assert BoxType.__name__ in {mod.id for mod in project_service.get_models()} unlock_object(ars, BoxType.__name__) lock_object(ars, DummyMultiArmRobot.__name__) assert not ars.call_rpc( rpc.o.UpdateObjectModel.Request( get_id(), rpc.o.UpdateObjectModel.Request.Args( DummyMultiArmRobot.__name__, ObjectModel(Model3dType.SPHERE, sphere=Sphere(DummyMultiArmRobot.__name__, 0.1)), ), ), rpc.o.UpdateObjectModel.Response, ).result unlock_object(ars, DummyMultiArmRobot.__name__) delete_res_1 = ars.call_rpc( rpc.o.DeleteObjectTypes.Request(get_id(), {BoxType.__name__}, dry_run=True), rpc.o.DeleteObjectTypes.Response, ) assert delete_res_1.result assert delete_res_1.data is None delete_res_2 = ars.call_rpc( rpc.o.DeleteObjectTypes.Request(get_id(), {BoxType.__name__}), rpc.o.DeleteObjectTypes.Response, ) assert delete_res_2.result assert delete_res_2.data is None ot_evt2 = event(ars, events.o.ChangedObjectTypes) assert ot_evt2.change_type == ot_evt.Type.REMOVE assert len(ot_evt2.data) == 1 assert ot_evt2.data[0].object_model == om assert ot_evt2.data[0].type == BoxType.__name__ assert BoxType.__name__ not in {obj.id for obj in project_service.get_object_type_ids()} assert BoxType.__name__ not in {mod.id for mod in project_service.get_models()}
def close_project(ars: ARServer) -> None: assert ars.call_rpc(rpc.p.CloseProject.Request(uid()), rpc.p.CloseProject.Response).result event(ars, events.p.ProjectClosed)
def test_object_parameters(start_processes: None, ars: ARServer, scene: Scene) -> None: assert ars.call_rpc(rpc.s.OpenScene.Request(uid(), IdArgs(scene.id)), rpc.s.OpenScene.Response).result event(ars, events.s.OpenScene) event(ars, events.s.SceneState) req_params = [ # TODO create settings_to_params and use it Parameter("str_param", "string", json.dumps("str_param")), Parameter("float_param", "double", json.dumps(1.0)), Parameter("int_param", "integer", json.dumps(1)), Parameter("bool_param", "boolean", json.dumps(True)), ] assert ars.call_rpc( rpc.s.AddObjectToScene.Request( uid(), rpc.s.AddObjectToScene.Request.Args("ows", ObjectWithSettings.__name__, parameters=req_params) ), rpc.s.AddObjectToScene.Response, ).result soc = event(ars, events.s.SceneObjectChanged) assert soc.change_type assert soc.change_type == soc.change_type.ADD assert soc.data.type == ObjectWithSettings.__name__ assert soc.data.parameters == req_params obj_id = soc.data.id req_params2 = [ # TODO create settings_to_params and use it Parameter("str_param", "string", json.dumps("str_param2")), Parameter("float_param", "double", json.dumps(2.0)), Parameter("int_param", "integer", json.dumps(2)), Parameter("bool_param", "boolean", json.dumps(True)), ] lock_object(ars, soc.data.id) assert ars.call_rpc( rpc.s.UpdateObjectParameters.Request( uid(), rpc.s.UpdateObjectParameters.Request.Args(soc.data.id, parameters=req_params2) ), rpc.s.AddObjectToScene.Response, ).result soc2 = event(ars, events.s.SceneObjectChanged) assert soc2.change_type == soc.change_type.UPDATE assert soc2.data.type == ObjectWithSettings.__name__ assert soc2.data.parameters == req_params2 unlock_object(ars, soc.data.id) # let's continue with testing overrides assert ars.call_rpc( rpc.p.NewProject.Request(uid(), rpc.p.NewProject.Request.Args(scene.id, "Project name")), rpc.p.NewProject.Response, ).result event(ars, events.p.OpenProject) event(ars, events.s.SceneState) assert not ars.call_rpc( rpc.o.DeleteOverride.Request( uid(), rpc.o.DeleteOverride.Request.Args(obj_id, Parameter("bool_param", "boolean", json.dumps(True))) ), rpc.o.DeleteOverride.Response, ).result assert not ars.call_rpc( rpc.o.UpdateOverride.Request( uid(), rpc.o.UpdateOverride.Request.Args(obj_id, Parameter("bool_param", "boolean", json.dumps(True))) ), rpc.o.UpdateOverride.Response, ).result # int_param has to be set to special value, so without override, StartScene should fail now assert ars.call_rpc( rpc.s.StartScene.Request(uid()), rpc.s.StartScene.Response, ).result assert event(ars, events.s.SceneState).data.state == events.s.SceneState.Data.StateEnum.Starting assert event(ars, events.s.SceneState).data.state == events.s.SceneState.Data.StateEnum.Stopping assert event(ars, events.s.SceneState).data.state == events.s.SceneState.Data.StateEnum.Stopped lock_object(ars, obj_id) override = Parameter("int_param", "integer", json.dumps(ObjectWithSettings.INT_PARAM_SPECIAL_VALUE)) assert ars.call_rpc( rpc.o.AddOverride.Request(uid(), rpc.o.AddOverride.Request.Args(obj_id, override)), rpc.o.AddOverride.Response, ).result override_evt = event(ars, events.o.OverrideUpdated) assert override_evt.data == override assert override_evt.change_type assert override_evt.change_type == override_evt.change_type.ADD assert override_evt.parent_id == obj_id override2 = Parameter("str_param", "string", json.dumps("test")) assert ars.call_rpc( rpc.o.AddOverride.Request(uid(), rpc.o.AddOverride.Request.Args(obj_id, override2)), rpc.o.AddOverride.Response, ).result event(ars, events.o.OverrideUpdated) unlock_object(ars, obj_id) save_project(ars) # now it should be possible to start the scene assert ars.call_rpc( rpc.s.StartScene.Request(uid()), rpc.s.StartScene.Response, ).result assert event(ars, events.s.SceneState).data.state == events.s.SceneState.Data.StateEnum.Starting assert event(ars, events.s.SceneState).data.state == events.s.SceneState.Data.StateEnum.Started
def test_list_problems(start_processes: None, ars: ARServer) -> None: """This is a test for a bug in get_scene_problems and get_project_problems functions. Because of the bug, the RPC returned result=False when there was non-existing ObjectType. :param start_processes: :param ars: :return: """ upload_def(DummyMultiArmRobot ) # OT has to exist first, otherwise scene can't be stored invalid_scene_1 = Scene("invalidScene", objects=[ SceneObject("invalidObject", DummyMultiArmRobot.__name__, Pose()) ]) invalid_project_1 = Project("invalidProject", invalid_scene_1.id) project_service.update_scene(invalid_scene_1) project_service.update_project(invalid_project_1) project_service.delete_object_type( DummyMultiArmRobot.__name__) # now the OT can be deleted # initial event show_main_screen_event = event(ars, events.c.ShowMainScreen) assert show_main_screen_event.data assert show_main_screen_event.data.what == events.c.ShowMainScreen.Data.WhatEnum.ScenesList scenes = ars.call_rpc(rpc.s.ListScenes.Request(get_id()), rpc.s.ListScenes.Response) assert scenes.result assert scenes.data assert len(scenes.data) == 1 assert scenes.data[0].id == invalid_scene_1.id assert scenes.data[0].name == invalid_scene_1.name assert scenes.data[0].problems assert len(scenes.data[0].problems) == 1 projects = ars.call_rpc(rpc.p.ListProjects.Request(get_id()), rpc.p.ListProjects.Response) assert projects.result assert projects.data assert len(projects.data) == 1 assert projects.data[0].id == invalid_project_1.id assert projects.data[0].name == invalid_project_1.name assert projects.data[0].problems assert len(projects.data[0].problems) == 1 upload_def(DummyMultiArmRobot) # now the ObjectType exists, so the scene/project should be ok scenes2 = ars.call_rpc(rpc.s.ListScenes.Request(get_id()), rpc.s.ListScenes.Response) assert scenes2.result assert scenes2.data assert len(scenes2.data) == 1 assert scenes2.data[0].id == invalid_scene_1.id assert scenes2.data[0].name == invalid_scene_1.name assert scenes2.data[0].problems is None projects2 = ars.call_rpc(rpc.p.ListProjects.Request(get_id()), rpc.p.ListProjects.Response) assert projects2.result assert projects2.data assert len(projects2.data) == 1 assert projects2.data[0].id == invalid_project_1.id assert projects2.data[0].name == invalid_project_1.name assert projects2.data[0].problems is None
def test_update_object_pose(start_processes: None, ars: ARServer) -> None: upload_def(Box, BoxModel("Box", 0.1, 0.1, 0.1)) upload_def(DummyMultiArmRobot) test = "test" event(ars, events.c.ShowMainScreen) assert ars.call_rpc( rpc.s.NewScene.Request(get_id(), rpc.s.NewScene.Request.Args(test)), rpc.s.NewScene.Response).result assert len(event(ars, events.o.ChangedObjectTypes).data) == 2 event(ars, events.s.OpenScene) event(ars, events.s.SceneState) assert ars.call_rpc( rpc.s.AddObjectToScene.Request( get_id(), rpc.s.AddObjectToScene.Request.Args("obj", Box.__name__, Pose())), rpc.s.AddObjectToScene.Response, ).result scene_obj = event(ars, events.s.SceneObjectChanged).data assert ars.call_rpc( rpc.s.AddObjectToScene.Request( get_id(), rpc.s.AddObjectToScene.Request.Args("robot", DummyMultiArmRobot.__name__, Pose())), rpc.s.AddObjectToScene.Response, ).result scene_robot = event(ars, events.s.SceneObjectChanged).data new_pose = Pose(Position(1)) lock_object(ars, scene_obj.id) assert ars.call_rpc( rpc.s.UpdateObjectPose.Request( get_id(), rpc.s.UpdateObjectPose.Request.Args(scene_obj.id, new_pose)), rpc.s.UpdateObjectPose.Response, ).result assert event(ars, events.s.SceneObjectChanged).data.pose == new_pose unlock_object(ars, scene_obj.id) lock_object(ars, scene_robot.id) assert ars.call_rpc( rpc.s.UpdateObjectPose.Request( get_id(), rpc.s.UpdateObjectPose.Request.Args(scene_robot.id, new_pose)), rpc.s.UpdateObjectPose.Response, ).result assert event(ars, events.s.SceneObjectChanged).data.pose == new_pose unlock_object(ars, scene_robot.id) assert ars.call_rpc( rpc.s.StartScene.Request(get_id()), rpc.s.StartScene.Response, ).result assert event(ars, events.s.SceneState ).data.state == events.s.SceneState.Data.StateEnum.Starting assert event(ars, events.s.SceneState ).data.state == events.s.SceneState.Data.StateEnum.Started lock_object(ars, scene_obj.id) # with started scene, it should still be possible to manipulate the object assert ars.call_rpc( rpc.s.UpdateObjectPose.Request( get_id(), rpc.s.UpdateObjectPose.Request.Args(scene_obj.id, Pose())), rpc.s.UpdateObjectPose.Response, ).result assert event(ars, events.s.SceneObjectChanged).data.pose == Pose() unlock_object(ars, scene_obj.id) lock_object(ars, scene_robot.id) # ...but it should not be possible to manipulate the robot assert not ars.call_rpc( rpc.s.UpdateObjectPose.Request( get_id(), rpc.s.UpdateObjectPose.Request.Args(scene_robot.id, Pose())), rpc.s.UpdateObjectPose.Response, ).result unlock_object(ars, scene_robot.id)
def test_object_aiming(start_processes: None, ars: ARServer) -> None: mesh = Mesh(Box.__name__, "mesh.dae", [Pose(), Pose(), Pose()]) assert mesh.focus_points Box.mesh_filename = mesh.data_id with tempfile.NamedTemporaryFile("wb") as file: upload_def(Box, model=mesh, file_to_upload=file.name) upload_def(DummyMultiArmRobot) test = "test" event(ars, events.c.ShowMainScreen) assert ars.call_rpc( rpc.s.NewScene.Request(get_id(), rpc.s.NewScene.Request.Args(test)), rpc.s.NewScene.Response ).result assert len(event(ars, events.o.ChangedObjectTypes).data) == 2 event(ars, events.s.OpenScene) event(ars, events.s.SceneState) assert ars.call_rpc( rpc.s.AddObjectToScene.Request(get_id(), rpc.s.AddObjectToScene.Request.Args("obj", Box.__name__, Pose())), rpc.s.AddObjectToScene.Response, ).result scene_obj = event(ars, events.s.SceneObjectChanged).data assert ars.call_rpc( rpc.s.AddObjectToScene.Request( get_id(), rpc.s.AddObjectToScene.Request.Args("robot", DummyMultiArmRobot.__name__, Pose()) ), rpc.s.AddObjectToScene.Response, ).result scene_robot = event(ars, events.s.SceneObjectChanged).data assert ars.call_rpc( rpc.s.StartScene.Request(get_id()), rpc.s.StartScene.Response, ).result assert event(ars, events.s.SceneState).data.state == events.s.SceneState.Data.StateEnum.Starting assert event(ars, events.s.SceneState).data.state == events.s.SceneState.Data.StateEnum.Started arm = DummyMultiArmRobot.Arms.left robot_arg = RobotArg(scene_robot.id, list(DummyMultiArmRobot.EEF[arm])[0], arm) # ------------------------------------------------------------------------------------------------------------------ lock_object(ars, scene_obj.id) lock_object(ars, scene_robot.id) assert ars.call_rpc( rpc.o.ObjectAimingStart.Request(get_id(), rpc.o.ObjectAimingStart.Request.Args(scene_obj.id, robot_arg)), rpc.o.ObjectAimingStart.Response, ).result assert not ars.call_rpc( rpc.o.ObjectAimingStart.Request(get_id(), rpc.o.ObjectAimingStart.Request.Args(scene_obj.id, robot_arg)), rpc.o.ObjectAimingStart.Response, ).result assert ars.call_rpc( rpc.o.ObjectAimingAddPoint.Request(get_id(), rpc.o.ObjectAimingAddPoint.Request.Args(0)), rpc.o.ObjectAimingAddPoint.Response, ).result assert ars.call_rpc( rpc.o.ObjectAimingCancel.Request(get_id()), rpc.o.ObjectAimingCancel.Response, ).result unlock_object(ars, scene_obj.id) unlock_object(ars, scene_robot.id) # ------------------------------------------------------------------------------------------------------------------ lock_object(ars, scene_obj.id) lock_object(ars, scene_robot.id) assert ars.call_rpc( rpc.o.ObjectAimingStart.Request(get_id(), rpc.o.ObjectAimingStart.Request.Args(scene_obj.id, robot_arg)), rpc.o.ObjectAimingStart.Response, ).result assert not ars.call_rpc( rpc.o.ObjectAimingAddPoint.Request(get_id(), rpc.o.ObjectAimingAddPoint.Request.Args(-1)), rpc.o.ObjectAimingAddPoint.Response, ).result assert not ars.call_rpc( rpc.o.ObjectAimingAddPoint.Request(get_id(), rpc.o.ObjectAimingAddPoint.Request.Args(len(mesh.focus_points))), rpc.o.ObjectAimingAddPoint.Response, ).result assert not ars.call_rpc( rpc.o.ObjectAimingDone.Request(get_id()), rpc.o.ObjectAimingDone.Response, ).result for idx in range(len(mesh.focus_points)): assert ars.call_rpc( rpc.o.ObjectAimingAddPoint.Request(get_id(), rpc.o.ObjectAimingAddPoint.Request.Args(idx)), rpc.o.ObjectAimingAddPoint.Response, ).result assert ars.call_rpc( rpc.o.ObjectAimingDone.Request(get_id()), rpc.o.ObjectAimingDone.Response, ).result assert event(ars, events.s.SceneObjectChanged).data.id == scene_obj.id unlock_object(ars, scene_obj.id) unlock_object(ars, scene_robot.id)
def test_project_basic_rpcs(start_processes: None, ars: ARServer, scene: common.Scene) -> None: # first, there are no projects projects = ars.call_rpc(rpc.p.ListProjects.Request(uid()), rpc.p.ListProjects.Response) assert projects.result assert not projects.data project_name = "Test project" # attempt to use non-existent scene_id assert not ars.call_rpc( rpc.p.NewProject.Request( uid(), rpc.p.NewProject.Request.Args("some non-sense string", project_name)), rpc.p.NewProject.Response, ).result # attempt to open non-existent project assert not ars.call_rpc( rpc.p.OpenProject.Request(uid(), IdArgs("some-random-nonsense")), rpc.p.OpenProject.Response).result # correct scene_id assert ars.call_rpc( rpc.p.NewProject.Request( uid(), rpc.p.NewProject.Request.Args(scene.id, project_name)), rpc.p.NewProject.Response, ).result open_project_evt = event(ars, events.p.OpenProject) event(ars, events.s.SceneState) assert open_project_evt.data assert open_project_evt.change_type is None assert open_project_evt.parent_id is None assert open_project_evt.data.scene.id == scene.id project_id = open_project_evt.data.project.id assert open_project_evt.data.project.name == project_name assert not open_project_evt.data.project.action_points assert not open_project_evt.data.project.parameters assert not open_project_evt.data.project.functions assert not open_project_evt.data.project.logic # attempt to create project while another project is opened assert not ars.call_rpc( rpc.p.NewProject.Request( uid(), rpc.p.NewProject.Request.Args("some non-sense string", "blah")), rpc.p.NewProject.Response, ).result save_project(ars) close_project(ars) show_main_screen_event = event(ars, events.c.ShowMainScreen) assert show_main_screen_event.data assert show_main_screen_event.data.what == events.c.ShowMainScreen.Data.WhatEnum.ProjectsList assert show_main_screen_event.data.highlight == project_id list_of_projects = ars.call_rpc(rpc.p.ListProjects.Request(uid()), rpc.p.ListProjects.Response) assert list_of_projects.result assert list_of_projects.data assert len(list_of_projects.data) == 1 assert list_of_projects.data[0].id == project_id """ TODO: fix this with ARServer(WS_CONNECTION_STR, timeout=10, event_mapping=event_mapping) as ars_2: smse = event(ars_2, events.c.ShowMainScreen) assert smse.data assert smse.data.what == events.c.ShowMainScreen.Data.WhatEnum.ProjectsList assert smse.data.highlight is None """ # it should not be possible to delete scene used by a project assert not ars.call_rpc(rpc.s.DeleteScene.Request(uid(), IdArgs(scene.id)), rpc.s.DeleteScene.Response).result assert ars.call_rpc(rpc.p.DeleteProject.Request(uid(), IdArgs(project_id)), rpc.p.DeleteProject.Response).result project_changed_evt = event(ars, events.p.ProjectChanged) assert project_changed_evt.data assert project_changed_evt.data.id == project_id assert project_changed_evt.change_type == Event.Type.REMOVE assert ars.call_rpc(rpc.s.DeleteScene.Request(uid(), IdArgs(scene.id)), rpc.s.DeleteScene.Response).result scene_changed_evt = event(ars, events.s.SceneChanged) assert scene_changed_evt.data assert scene_changed_evt.data.id == scene.id assert scene_changed_evt.change_type == Event.Type.REMOVE list_of_projects_2 = ars.call_rpc(rpc.p.ListProjects.Request(uid()), rpc.p.ListProjects.Response) assert list_of_projects_2.result assert not list_of_projects_2.data
def test_project_const(start_processes: None, ars: ARServer) -> None: event(ars, events.c.ShowMainScreen) assert ars.call_rpc( rpc.s.NewScene.Request(uid(), rpc.s.NewScene.Request.Args("Test scene")), rpc.s.NewScene.Response).result scene_data = event(ars, events.s.OpenScene).data assert scene_data scene = scene_data.scene event(ars, events.s.SceneState) assert ars.call_rpc( rpc.s.AddObjectToScene.Request( uid(), rpc.s.AddObjectToScene.Request.Args("random_actions", RandomActions.__name__)), rpc.s.AddObjectToScene.Response, ).result obj = event(ars, events.s.SceneObjectChanged).data assert obj # ------------------------------------------------------------------------------------------------------------------ assert ars.call_rpc( rpc.p.NewProject.Request( uid(), rpc.p.NewProject.Request.Args(scene.id, "Project name")), rpc.p.NewProject.Response, ).result proj = event(ars, events.p.OpenProject).data assert proj event(ars, events.s.SceneState) assert ars.call_rpc( rpc.p.AddConstant.Request( uid(), rpc.p.AddConstant.Request.Args("min_time", "double", json.dumps(0.45))), rpc.p.AddConstant.Response, ).result c1 = event(ars, events.p.ProjectConstantChanged).data assert c1 assert not ars.call_rpc( rpc.p.AddConstant.Request( uid(), rpc.p.AddConstant.Request.Args("min_time", "double", json.dumps(0.62))), rpc.p.AddConstant.Response, ).result assert not ars.call_rpc( # attempt to update without lock rpc.p.UpdateConstant.Request( uid(), rpc.p.UpdateConstant.Request.Args(c1.id, name="min_time_updated")), rpc.p.UpdateConstant.Response, ).result # ------------------------------------------------------------------------------------------------------------------ # the user opens a menu and then closes it without actually changing anything lock_object(ars, c1.id) assert ars.call_rpc( rpc.p.UpdateConstant.Request(uid(), rpc.p.UpdateConstant.Request.Args( c1.id, name="min_time_1"), dry_run=True), rpc.p.UpdateConstant.Response, ).result assert ars.call_rpc( rpc.p.UpdateConstant.Request(uid(), rpc.p.UpdateConstant.Request.Args( c1.id, name="min_time_2"), dry_run=True), rpc.p.UpdateConstant.Response, ).result unlock_object(ars, c1.id) # ------------------------------------------------------------------------------------------------------------------ lock_object(ars, c1.id) assert ars.call_rpc( rpc.p.UpdateConstant.Request( uid(), rpc.p.UpdateConstant.Request.Args(c1.id, name="min_time_updated")), rpc.p.UpdateConstant.Response, ).result c1u = event(ars, events.p.ProjectConstantChanged).data assert c1u event(ars, events.lk.ObjectsUnlocked) assert c1u.id == c1.id assert c1.name != c1u.name assert c1.type == c1u.type # ------------------------------------------------------------------------------------------------------------------ # try to add and remove assert ars.call_rpc( rpc.p.AddConstant.Request( uid(), rpc.p.AddConstant.Request.Args("min_time_2", "double", json.dumps(0.62))), rpc.p.AddConstant.Response, ).result c2 = event(ars, events.p.ProjectConstantChanged).data assert c2 assert ars.call_rpc( rpc.p.RemoveConstant.Request(uid(), rpc.p.RemoveConstant.Request.Args(c2.id)), rpc.p.RemoveConstant.Response, ).result c2e = event(ars, events.p.ProjectConstantChanged) assert c2e.data assert c2e.data.id == c2.id assert c2e.change_type == c2e.Type.REMOVE # ------------------------------------------------------------------------------------------------------------------ # attempt to add a constant with duplicate name assert not ars.call_rpc( rpc.p.AddConstant.Request( uid(), rpc.p.AddConstant.Request.Args(c1u.name, "double", json.dumps(0.62))), rpc.p.AddConstant.Response, ).result # ------------------------------------------------------------------------------------------------------------------ assert ars.call_rpc( rpc.p.AddActionPoint.Request( uid(), rpc.p.AddActionPoint.Request.Args("ap1", common.Position())), rpc.p.AddActionPoint.Response, ).result ap = event(ars, events.p.ActionPointChanged).data assert ap is not None assert ars.call_rpc( rpc.p.AddAction.Request( uid(), rpc.p.AddAction.Request.Args( ap.id, "test_action", f"{obj.id}/{RandomActions.random_double.__name__}", [ common.ActionParameter( "range_min", common.ActionParameter.TypeEnum.CONSTANT, json.dumps(c1.id)), common.ActionParameter("range_max", "double", "0.55"), ], [common.Flow(outputs=["random_value"])], ), ), rpc.p.AddAction.Response, ).result action = event(ars, events.p.ActionChanged).data assert action assert not ars.call_rpc( rpc.p.RemoveConstant.Request(uid(), rpc.p.RemoveConstant.Request.Args(c1.id)), rpc.p.RemoveConstant.Response).result # ------------------------------------------------------------------------------------------------------------------ # try to execute action using constant parameter assert ars.call_rpc((rpc.s.StartScene.Request(uid())), rpc.s.StartScene.Response).result assert event(ars, events.s.SceneState ).data.state == events.s.SceneState.Data.StateEnum.Starting assert event(ars, events.s.SceneState ).data.state == events.s.SceneState.Data.StateEnum.Started assert ars.call_rpc( rpc.p.ExecuteAction.Request( uid(), rpc.p.ExecuteAction.Request.Args(action.id)), rpc.p.ExecuteAction.Response) event(ars, events.a.ActionExecution) res = event(ars, events.a.ActionResult) assert res.data assert res.data.action_id == action.id assert not res.data.error assert ars.call_rpc((rpc.s.StopScene.Request(uid())), rpc.s.StopScene.Response).result assert event(ars, events.s.SceneState ).data.state == events.s.SceneState.Data.StateEnum.Stopping assert event(ars, events.s.SceneState ).data.state == events.s.SceneState.Data.StateEnum.Stopped assert ars.call_rpc( rpc.p.RemoveAction.Request(uid(), rpc.p.IdArgs(action.id)), rpc.p.RemoveAction.Response).result assert event(ars, events.p.ActionChanged).data assert ars.call_rpc( rpc.p.RemoveConstant.Request(uid(), rpc.p.RemoveConstant.Request.Args(c1.id)), rpc.p.RemoveConstant.Response).result event(ars, events.p.ProjectConstantChanged)
def test_run_simple_project(start_processes: None, ars: ARServer) -> None: event(ars, events.c.ShowMainScreen) assert ars.call_rpc( rpc.s.NewScene.Request(get_id(), rpc.s.NewScene.Request.Args("Test scene")), rpc.s.NewScene.Response).result scene_data = event(ars, events.s.OpenScene).data assert scene_data scene = scene_data.scene event(ars, events.s.SceneState) assert ars.call_rpc( rpc.s.AddObjectToScene.Request( get_id(), rpc.s.AddObjectToScene.Request.Args("time_actions", TimeActions.__name__)), rpc.s.AddObjectToScene.Response, ).result obj = event(ars, events.s.SceneObjectChanged).data assert obj assert ars.call_rpc( rpc.s.AddObjectToScene.Request( get_id(), rpc.s.AddObjectToScene.Request.Args("random_actions", RandomActions.__name__)), rpc.s.AddObjectToScene.Response, ).result obj2 = event(ars, events.s.SceneObjectChanged).data assert obj2 # ------------------------------------------------------------------------------------------------------------------ assert ars.call_rpc( rpc.p.NewProject.Request( get_id(), rpc.p.NewProject.Request.Args(scene.id, "Project name")), rpc.p.NewProject.Response, ).result event(ars, events.s.SceneSaved) proj = event(ars, events.p.OpenProject).data assert proj event(ars, events.s.SceneState) assert ars.call_rpc( rpc.p.AddActionPoint.Request( get_id(), rpc.p.AddActionPoint.Request.Args("ap1", common.Position())), rpc.p.AddActionPoint.Response, ).result ap = event(ars, events.p.ActionPointChanged).data assert ap is not None assert ars.call_rpc( rpc.p.AddProjectParameter.Request( get_id(), rpc.p.AddProjectParameter.Request.Args("min_time", "double", json.dumps(0.45))), rpc.p.AddActionPoint.Response, ).result c1 = event(ars, events.p.ProjectParameterChanged).data assert c1 assert ars.call_rpc( rpc.p.AddAction.Request( get_id(), rpc.p.AddAction.Request.Args( ap.id, "test_action", f"{obj2.id}/{RandomActions.random_double.__name__}", [ common.ActionParameter( "range_min", common.ActionParameter.TypeEnum.PROJECT_PARAMETER, json.dumps(c1.id)), common.ActionParameter("range_max", "double", "0.55"), ], [common.Flow(outputs=["random_value"])], ), ), rpc.p.AddAction.Response, ).result action = event(ars, events.p.ActionChanged).data assert action is not None assert ars.call_rpc( rpc.p.AddAction.Request( get_id(), rpc.p.AddAction.Request.Args( ap.id, "test_action2", f"{obj.id}/{TimeActions.sleep.__name__}", [ common.ActionParameter( "seconds", common.ActionParameter.TypeEnum.LINK, json.dumps( f"{action.id}/{common.FlowTypes.DEFAULT}/0"), ) ], [common.Flow()], ), ), rpc.p.AddAction.Response, ).result action2 = event(ars, events.p.ActionChanged).data assert action2 is not None add_logic_item(ars, common.LogicItem.START, action.id) event(ars, events.lk.ObjectsUnlocked) add_logic_item(ars, action.id, action2.id) event(ars, events.lk.ObjectsUnlocked) add_logic_item(ars, action2.id, common.LogicItem.END) event(ars, events.lk.ObjectsUnlocked) save_project(ars) LOGGER.debug(project_service.get_project(proj.project.id)) # TODO test also temporary package close_project(ars) # ------------------------------------------------------------------------------------------------------------------ event(ars, events.c.ShowMainScreen) assert ars.call_rpc( rpc.b.BuildProject.Request( get_id(), rpc.b.BuildProject.Request.Args(proj.project.id, "Package name")), rpc.b.BuildProject.Response, ).result package = event(ars, eevents.PackageChanged).data assert package is not None assert ars.call_rpc( erpc.RunPackage.Request(get_id(), erpc.RunPackage.Request.Args(package.id)), erpc.RunPackage.Response).result ps = event(ars, arcor2_events.PackageState).data assert ps assert ps.package_id == package.id assert ps.state == ps.state.RUNNING pi = event(ars, arcor2_events.PackageInfo).data assert pi assert pi.package_id == package.id # random_double action act_state_before = event(ars, arcor2_events.ActionStateBefore).data assert act_state_before assert act_state_before.action_id == action.id assert act_state_before.parameters assert len(act_state_before.parameters) == 2 act_state_after = event(ars, arcor2_events.ActionStateAfter).data assert act_state_after assert act_state_after.action_id == action.id assert act_state_after.results assert len(act_state_after.results) == 1 assert isinstance(json.loads(act_state_after.results[0]), float) # sleep action act2_state_before = event(ars, arcor2_events.ActionStateBefore).data assert act2_state_before assert act2_state_before.action_id == action2.id assert act2_state_before.parameters assert len(act2_state_before.parameters) == 1 act2_state_after = event(ars, arcor2_events.ActionStateAfter).data assert act2_state_after assert act2_state_after.action_id == action2.id assert act2_state_after.results is None # TODO pause, resume assert ars.call_rpc(erpc.StopPackage.Request(get_id()), erpc.StopPackage.Response).result ps2 = wait_for_event(ars, arcor2_events.PackageState).data assert ps2 assert ps2.package_id == package.id assert ps2.state == ps.state.STOPPING ps3 = wait_for_event(ars, arcor2_events.PackageState).data assert ps3 assert ps3.package_id == package.id assert ps3.state == ps.state.STOPPED show_main_screen_event = event(ars, events.c.ShowMainScreen) assert show_main_screen_event.data assert show_main_screen_event.data.what == events.c.ShowMainScreen.Data.WhatEnum.PackagesList assert show_main_screen_event.data.highlight == package.id
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 test_scene_basic_rpcs(start_processes: None, ars: ARServer) -> None: test = "Test" # initial event show_main_screen_event = event(ars, events.c.ShowMainScreen) assert show_main_screen_event.data assert show_main_screen_event.data.what == events.c.ShowMainScreen.Data.WhatEnum.ScenesList # first, there are no scenes scenes = ars.call_rpc(rpc.s.ListScenes.Request(get_id()), rpc.s.ListScenes.Response) assert scenes.result assert not scenes.data assert ars.call_rpc( rpc.s.NewScene.Request(get_id(), rpc.s.NewScene.Request.Args(test, test)), rpc.s.NewScene.Response).result open_scene_event = event(ars, events.s.OpenScene) assert open_scene_event.parent_id is None assert open_scene_event.change_type is None assert open_scene_event.data assert open_scene_event.data.scene.id scene_id = open_scene_event.data.scene.id assert open_scene_event.data.scene.name == test assert open_scene_event.data.scene.description == test assert not open_scene_event.data.scene.objects event(ars, events.s.SceneState) # attempt to create a new scene while scene is open should fail assert not ars.call_rpc( rpc.s.NewScene.Request(get_id(), rpc.s.NewScene.Request.Args( test, test)), rpc.s.NewScene.Response).result assert ars.call_rpc(rpc.s.SaveScene.Request(get_id()), rpc.s.SaveScene.Response).result event(ars, events.s.SceneSaved) assert ars.call_rpc(rpc.s.CloseScene.Request(get_id()), rpc.s.CloseScene.Response).result event(ars, events.s.SceneClosed) show_main_screen_event_2 = event(ars, events.c.ShowMainScreen) assert show_main_screen_event_2.data assert show_main_screen_event_2.data.what == events.c.ShowMainScreen.Data.WhatEnum.ScenesList assert show_main_screen_event_2.data.highlight == scene_id # attempt to open non-existent scene assert not ars.call_rpc( rpc.s.OpenScene.Request(get_id(), IdArgs("some-random-nonsense")), rpc.s.OpenScene.Response).result list_of_scenes = ars.call_rpc(rpc.s.ListScenes.Request(get_id()), rpc.s.ListScenes.Response) assert list_of_scenes.result assert list_of_scenes.data assert len(list_of_scenes.data) == 1 assert list_of_scenes.data[0].id == scene_id # open previously saved scene assert ars.call_rpc(rpc.s.OpenScene.Request(get_id(), IdArgs(scene_id)), rpc.s.OpenScene.Response).result open_scene_event_2 = event(ars, events.s.OpenScene) assert open_scene_event_2.data assert open_scene_event_2.data.scene.id == scene_id event(ars, events.s.SceneState) assert ars.call_rpc(rpc.s.CloseScene.Request(get_id()), rpc.s.CloseScene.Response).result event(ars, events.s.SceneClosed) show_main_screen_event_3 = event(ars, events.c.ShowMainScreen) assert show_main_screen_event_3.data assert show_main_screen_event_3.data.what == events.c.ShowMainScreen.Data.WhatEnum.ScenesList assert show_main_screen_event_3.data.highlight == scene_id with ARServer(ars_connection_str(), timeout=10, event_mapping=event_mapping) as ars_2: smse = event(ars_2, events.c.ShowMainScreen) assert smse.data assert smse.data.what == events.c.ShowMainScreen.Data.WhatEnum.ScenesList assert smse.data.highlight is None assert ars.call_rpc(rpc.s.DeleteScene.Request(get_id(), IdArgs(scene_id)), rpc.s.DeleteScene.Response).result scene_changed_evt = event(ars, events.s.SceneChanged) assert scene_changed_evt.data assert scene_changed_evt.data.id == scene_id assert scene_changed_evt.change_type == Event.Type.REMOVE list_of_scenes_2 = ars.call_rpc(rpc.s.ListScenes.Request(get_id()), rpc.s.ListScenes.Response) assert list_of_scenes_2.result assert not list_of_scenes_2.data
def project(ars: ARServer, scene: common.Scene) -> common.Project: """Creates project with following objects: ap - global AP ap_ap - child of ap ap_ap_ap - child of ap_ap ori - ap_ap_ap orientation """ test = "Test project" assert ars.call_rpc( rpc.p.NewProject.Request( uid(), rpc.p.NewProject.Request.Args(scene.id, test, test)), rpc.p.NewProject.Response).result project_evt = event(ars, events.p.OpenProject) assert project_evt.data event(ars, events.s.SceneState) assert ars.call_rpc( rpc.p.AddActionPoint.Request( uid(), rpc.p.AddActionPoint.Request.Args("ap", common.Position(0, 0, 0))), rpc.p.AddActionPoint.Response, ).result ap_evt = event(ars, events.p.ActionPointChanged) assert ap_evt.data assert ars.call_rpc( rpc.p.AddActionPoint.Request( uid(), rpc.p.AddActionPoint.Request.Args("ap_ap", common.Position(0, 0, 1), ap_evt.data.id)), rpc.p.AddActionPoint.Response, ).result ap_ap_evt = event(ars, events.p.ActionPointChanged) assert ap_ap_evt.data assert ars.call_rpc( rpc.p.AddActionPoint.Request( uid(), rpc.p.AddActionPoint.Request.Args("ap_ap_ap", common.Position(0, 0, 2), ap_ap_evt.data.id)), rpc.p.AddActionPoint.Response, ).result ap_ap_ap_evt = event(ars, events.p.ActionPointChanged) assert ap_ap_ap_evt.data lock_object(ars, ap_ap_ap_evt.data.id) assert ars.call_rpc( rpc.p.AddActionPointOrientation.Request( uid(), rpc.p.AddActionPointOrientation.Request.Args( ap_ap_ap_evt.data.id, common.Orientation(), "ori")), rpc.p.AddActionPointOrientation.Response, ).result ori_evt = event(ars, events.p.OrientationChanged) assert ori_evt.data unlock_object(ars, ap_ap_ap_evt.data.id) assert ars.call_rpc(rpc.p.SaveProject.Request(uid()), rpc.p.SaveProject.Response).result event(ars, events.p.ProjectSaved) assert ars.call_rpc(rpc.p.CloseProject.Request(uid()), rpc.p.CloseProject.Response).result event(ars, events.p.ProjectClosed) event(ars, events.c.ShowMainScreen) return project_evt.data.project
def test_lock_events(start_processes: None, ars: ARServer, scene: cmn.Scene, project: cmn.Project) -> None: assert ars.call_rpc(rpc.p.OpenProject.Request(get_id(), IdArgs(project.id)), rpc.p.OpenProject.Response).result prj_evt = event(ars, events.p.OpenProject) event(ars, events.s.SceneState) prj = prj_evt.data.project # get default project objects ap = next(ap for ap in prj.action_points if ap.name == "ap") ap_ap = next(ap for ap in prj.action_points if ap.name == "ap_ap") ap_ap_ap = next(ap for ap in prj.action_points if ap.name == "ap_ap_ap") ori = ap_ap_ap.orientations[0] lock_object(ars, ap.id, True) # lock object and expect event about it on newly logged UI ars2 = ARServer(ars_connection_str(), timeout=30, event_mapping=event_mapping) event(ars2, events.p.OpenProject) event(ars2, events.s.SceneState) second_ui = "ars2" assert ars2.call_rpc( rpc.u.RegisterUser.Request(get_id(), rpc.u.RegisterUser.Request.Args(second_ui)), rpc.u.RegisterUser.Response, ).result locked_evt = event(ars2, events.lk.ObjectsLocked) assert locked_evt.data.owner == "testUser" for obj_id in (ap.id, ap_ap.id, ap_ap_ap.id, ori.id): assert obj_id in locked_evt.data.object_ids # attempt to lock/unlock objects locked by someone else for obj_id in (ap.id, ap_ap.id, ap_ap_ap.id, ori.id): # lock assert not ars2.call_rpc( rpc.lock.WriteLock.Request(get_id(), rpc.lock.WriteLock.Request.Args(obj_id)), rpc.lock.WriteLock.Response ).result # lock tree assert not ars2.call_rpc( rpc.lock.WriteLock.Request(get_id(), rpc.lock.WriteLock.Request.Args(obj_id, True)), rpc.lock.WriteLock.Response, ).result # unlock assert not ars2.call_rpc( rpc.lock.WriteUnlock.Request(get_id(), rpc.lock.WriteUnlock.Request.Args(obj_id)), rpc.lock.WriteUnlock.Response, ).result unlock_object(ars, ap.id) event(ars2, events.lk.ObjectsUnlocked) # test lock will stay locked after logout for a while lock_object(ars2, ori.id) event(ars, events.lk.ObjectsLocked) ars2.close() # wait for some time sleep(2) # TODO fill this sleep with another actions # register again and check if objects still locked ars2 = ARServer(ars_connection_str(), timeout=30, event_mapping=event_mapping) event(ars2, events.p.OpenProject) event(ars2, events.s.SceneState) assert ars2.call_rpc( rpc.u.RegisterUser.Request(get_id(), rpc.u.RegisterUser.Request.Args("ars2")), rpc.u.RegisterUser.Response, ).result locked_evt = event(ars2, events.lk.ObjectsLocked) assert locked_evt.data.owner == second_ui assert len(locked_evt.data.object_ids) == 1 assert ori.id in locked_evt.data.object_ids ars2.close()
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 ars() -> Iterator[ARServer]: with ARServer(ars_connection_str(), timeout=30, event_mapping=event_mapping) as ws: yield ws
def save_project(ars: ARServer) -> None: assert ars.call_rpc(rpc.p.SaveProject.Request(get_id()), rpc.p.SaveProject.Response).result event(ars, events.p.ProjectSaved)