def test_copy_object_two_users(self): ws_name1 = self.createWs() orig_reads_ref = self.__class__.example_reads_ref # Adding DP object: dps1 = DataPaletteService(self.__class__.serviceWizardURL, token=self.getContext()['token'], service_ver=self.__class__.DataPalette_version) dps1.add_to_palette({'workspace': ws_name1, 'new_refs': [{'ref': orig_reads_ref}]}) # Share this workspace with user2 so that user2 can make DataPalette ref ws1 = self.getWsClient() ws1.set_permissions({'workspace': ws_name1, 'new_permission': 'r', 'users': [self.getContext2()['user_id']]}) # Get ref-path to reads object ret = self.getImpl().list_objects_with_sets(self.getContext(), {"ws_name": ws_name1, "include_data_palettes": 1})[0]['data'] reads_ref_path = None for item in ret: if 'dp_info' in item: info = item['object_info'] reads_ref_path = (item['dp_info']['ref'] + ';' + str(info[6]) + '/' + str(info[0]) + '/' + str(info[4])) # Adding Reads to DP of second user ws_name2 = self.createWs2() dps2 = DataPaletteService(self.__class__.serviceWizardURL, token=self.getContext2()['token'], service_ver=self.__class__.DataPalette_version) dps2.add_to_palette({'workspace': ws_name2, 'new_refs': [{'ref': reads_ref_path}]})
def test_two_users_set_inside_dp(self): ws_name1_1 = self.createWs() # Injecting reads object (real copy) into workspace1 orig_reads_obj_ref = self.__class__.example_reads_ref reads_obj_name = "TestReads" self.getWsClient().copy_object({'from': {'ref': orig_reads_obj_ref}, 'to': {'workspace': ws_name1_1, 'name': reads_obj_name}}) copy_reads_obj_ref = ws_name1_1 + '/' + reads_obj_name ws_name1_2 = self.createWs() set_obj_name = "MyReadsSet.1" sapi = SetAPI(self.__class__.serviceWizardURL, token=self.getContext()['token'], service_ver=self.__class__.SetAPI_version) sapi.save_reads_set_v1({'workspace': ws_name1_2, 'output_object_name': set_obj_name, 'data': {'description': '', 'items': [{'ref': copy_reads_obj_ref}]}}) orig_set_ref = ws_name1_2 + '/' + set_obj_name # Making DP-copy of reads set object by user2 ws_name2 = self.createWs2() # Let's share workspace containing set with user2 self.getWsClient().set_permissions({'workspace': ws_name1_2, 'new_permission': 'r', 'users': [self.getContext2()['user_id']]}) # Import reads set ref into DataPalette of third workspace dps = DataPaletteService(self.__class__.serviceWizardURL, token=self.getContext2()['token'], service_ver=self.__class__.DataPalette_version) dps.add_to_palette({'workspace': ws_name2, 'new_refs': [{'ref': orig_set_ref}]}) dp_ref_map = dps.list_data({'workspaces': [ws_name2]})['data_palette_refs'] set_ref_path = next(iter(dp_ref_map.values())) + ';' + orig_set_ref reads_ref_path = set_ref_path + ';' + copy_reads_obj_ref # Un-share original workspace self.getWsClient().set_permissions({'workspace': ws_name1_2, 'new_permission': 'n', 'users': [self.getContext2()['user_id']]}) # Let's check that we can list set and see reads object as set item ret = self.getImpl().list_objects_with_sets(self.getContext2(), {"ws_name": ws_name2})[0]["data"] self.assertEqual(1, len(ret)) item = ret[0] self.assertTrue('set_items' in item) self.assertTrue('set_items_info' in item['set_items']) self.assertEqual(1, len(item['set_items']['set_items_info'])) # Check access to reads and to set objects info = self.getWsClient2().get_object_info_new({'objects': [{'ref': set_ref_path}]})[0] self.assertEqual(set_obj_name, info[1]) info = self.getWsClient2().get_object_info_new({'objects': [{'ref': reads_ref_path}]})[0] self.assertEqual(reads_obj_name, info[1])
def test_unique_items(self): # Create original workspace with reads object + ReadsSet object ws_name1 = self.createWs() foft = FakeObjectsForTests(os.environ['SDK_CALLBACK_URL']) reads_obj_name = "testreads1" foft.create_fake_reads({'ws_name': ws_name1, 'obj_names': [reads_obj_name]}) reads_obj_ref = ws_name1 + '/' + reads_obj_name set_obj_name = "testreads_set1" sapi = SetAPI(self.__class__.serviceWizardURL, token=self.getContext()['token'], service_ver=self.__class__.SetAPI_version) sapi.save_reads_set_v1({'workspace': ws_name1, 'output_object_name': set_obj_name, 'data': {'description': '', 'items': [{'ref': reads_obj_ref}]}}) set_obj_ref = ws_name1 + '/' + set_obj_name # Create workspace with DataPalette copy of Reads object and copy of ReadsSet ws_name2 = self.createWs() dps = DataPaletteService(self.__class__.serviceWizardURL, token=self.getContext()['token'], service_ver=self.__class__.DataPalette_version) dps.add_to_palette({'workspace': ws_name2, 'new_refs': [{'ref': reads_obj_ref}, {'ref': set_obj_ref}]}) # Check if listing in both these workspaces at the same time gives unique items ret = self.getImpl().list_objects_with_sets(self.getContext(), {"workspaces": [ws_name1, ws_name2]})[0]["data"] self.assertEqual(2, len(ret))
def test_two_users_sharing_dp(self): dps = DataPaletteService(self.__class__.serviceWizardURL, token=self.getContext2()['token'], service_ver=self.__class__.DataPalette_version) ws_name1 = self.createWs() # Injecting reads object (real copy) into workspace1 orig_reads_obj_ref = self.__class__.example_reads_ref target_name = "TestReads" self.getWsClient().copy_object({'from': {'ref': orig_reads_obj_ref}, 'to': {'workspace': ws_name1, 'name': target_name}}) copy_reads_obj_ref = ws_name1 + '/' + target_name # Making DP-copy of reads object by user2 ws_name2 = self.createWs2() # Check that user2 can't import reads object until workspace is shared try: dps.add_to_palette({'workspace': ws_name2, 'new_refs': [{'ref': copy_reads_obj_ref}]}) raise ValueError("We shouldn't be able to import reads object to DataPalette") except Exception as e: self.assertTrue("Object TestReads cannot be accessed" in str(e)) # Let's share this workspace with user2 self.getWsClient().set_permissions({'workspace': ws_name1, 'new_permission': 'r', 'users': [self.getContext2()['user_id']]}) # Import reads ref into DataPalette of second workspace dps.add_to_palette({'workspace': ws_name2, 'new_refs': [{'ref': copy_reads_obj_ref}]}) # Un-share original workspace self.getWsClient().set_permissions({'workspace': ws_name1, 'new_permission': 'n', 'users': [self.getContext2()['user_id']]}) # Let's check that we can list and access reads object ret = self.getImpl().list_objects_with_sets(self.getContext2(), {"ws_name": ws_name2, "includeMetadata": 0, "include_data_palettes": 1})[0]["data"] self.assertEqual(1, len(ret)) item = ret[0] self.assertTrue('dp_info' in item) # Check that we can't access reads object directly try: self.getWsClient2().get_object_info_new({'objects': [{'ref': copy_reads_obj_ref}]}) raise ValueError("We shouldn't be able to access reads object") except Exception as e: self.assertTrue("Object TestReads cannot be accessed" in str(e)) # Check that we have an access to reads object through DataPalette reads_ref_path = item['dp_info']['ref'] + ';' + copy_reads_obj_ref info = self.getWsClient2().get_object_info_new({'objects': [{'ref': reads_ref_path}]})[0] self.assertEqual(item['object_info'][1], info[1]) # Even if original workspace is deleted... self.getWsClient().delete_workspace({'workspace': ws_name1}) # User2 is still able to access reads object info = self.getWsClient2().get_object_info_new({'objects': [{'ref': reads_ref_path}]})[0] self.assertEqual(item['object_info'][1], info[1])
def test_list_sets(self): workspace = self.getWsName() setAPI = self.getImpl() # make sure we can see an empty list of sets before WS has any res = setAPI.list_sets(self.getContext(), { 'workspace': workspace, 'include_set_item_info': 1 })[0] self.assertEqual(len(res['sets']), 0) # create the test sets self.create_sets() res = setAPI.list_sets(self.getContext(), { 'workspace': workspace, 'include_set_item_info': 1 })[0] self.assertTrue('sets' in res) self.assertEqual(len(res['sets']), len(self.setNames)) for s in res['sets']: self.assertTrue('ref' in s) self.assertTrue('info' in s) self.assertTrue('items' in s) self.assertEqual(len(s['info']), 11) self.assertEqual(len(s['items']), 2) for item in s['items']: self.assertTrue('ref' in item) self.assertTrue('info' in item) self.assertEqual(len(item['info']), 11) res2 = setAPI.list_sets(self.getContext(), {'workspace': workspace})[0] self.assertTrue('sets' in res2) self.assertEqual(len(res2['sets']), len(self.setNames)) for s in res2['sets']: self.assertTrue('ref' in s) self.assertTrue('info' in s) self.assertTrue('items' in s) self.assertEqual(len(s['info']), 11) self.assertEqual(len(s['items']), 2) for item in s['items']: self.assertTrue('ref' in item) self.assertTrue('info' not in item) res3 = setAPI.list_sets(self.getContext(), { 'workspace': workspace, 'include_set_item_ref_paths': 1 })[0] if self.DEBUG: print('Result from list_items with ref_paths') pprint(res3) print('=====================================') self.assertTrue('sets' in res3) self.assertEqual(len(res3['sets']), len(self.setNames)) for s in res3['sets']: self.assertTrue('ref' in s) self.assertTrue('info' in s) self.assertTrue('items' in s) self.assertEqual(len(s['info']), 11) self.assertEqual(len(s['items']), 2) for item in s['items']: self.assertTrue('ref' in item) self.assertTrue('info' not in item) self.assertTrue('ref_path' in item) self.assertEqual(item['ref_path'], s['ref'] + ';' + item['ref']) self.unit_test_get_set_items() set_obj_name = self.setNames[0] wsName2 = "test_SetAPI_" + str(int(time.time() * 1000)) + "_two" self.getWsClient().create_workspace({'workspace': wsName2}) try: set_obj_ref = self.getWsName() + '/' + set_obj_name dps = DataPaletteService( self.serviceWizardURL, token=self.getContext()['token'], service_ver=self.dataPaletteServiceVersion) dps.add_to_palette({ 'workspace': wsName2, 'new_refs': [{ 'ref': set_obj_ref }] }) ret = self.getImpl().list_sets( self.getContext(), { 'workspace': wsName2, 'include_set_item_info': 1, 'include_raw_data_palettes': 1 })[0] set_list = ret['sets'] self.assertEqual(1, len(set_list)) set_info = set_list[0] info = set_info['info'] self.assertEqual(self.getWsName(), info[7]) self.assertEqual(set_obj_name, info[1]) self.assertTrue('raw_data_palettes' in ret) self.assertEqual(1, len(ret['raw_data_palettes'])) self.assertIn('info', ret['raw_data_palettes'][0]) self.assertIn('ref', ret['raw_data_palettes'][0]) self.assertTrue('raw_data_palette_refs' in ret) self.assertEqual(1, len(ret['raw_data_palette_refs'])) set_list2 = self.getImpl().list_sets( self.getContext(), { 'workspaces': [workspace, wsName2], 'include_set_item_info': 1, 'include_metadata': 1 })[0]['sets'] self.assertEqual(len(set_list2), len(self.setNames)) self.assertTrue(len(set_list2) > 0) for set_obj in set_list2: self.assertIsNotNone(set_obj['info'][10]) for item in set_obj['items']: self.assertIsNotNone(item['info'][10]) finally: self.getWsClient().delete_workspace({'workspace': wsName2})
def test_copy_narrative_two_users(self): # Create workspace with Reads object for user1 ws_name1 = self.createWs() orig_reads_ref = self.__class__.example_reads_ref target_reads_name = "MyReads.copy.1" ws1 = self.getWsClient() reads_info = ws1.copy_object({'from': {'ref': orig_reads_ref}, 'to': {'workspace': ws_name1, 'name': target_reads_name}}) # Share this workspace with user2 so that user2 can make DataPalette ref ws1.set_permissions({'workspace': ws_name1, 'new_permission': 'r', 'users': [self.getContext2()['user_id']]}) reads_ref = str(reads_info[6]) + '/' + str(reads_info[0]) + '/' + str(reads_info[4]) # Create workspace with Narrative for user2 ws2 = self.getWsClient2() with open("/kb/module/test/data/narrative1.json", "r") as f1: nar_obj_data = json.load(f1) user_id = self.getContext2()['user_id'] ws_name2 = self.createWs2() nar_obj_data['metadata']['creator'] = user_id nar_obj_data['metadata']['ws_name'] = ws_name2 nar_obj_data['metadata']['kbase']['creator'] = user_id nar_obj_data['metadata']['kbase']['ws_name'] = ws_name2 nar_obj_name = "Narrative." + str(int(round(time.time() * 1000))) job_info = json.dumps({"queue_time": 0, "running": 0, "completed": 0, "run_time": 0, "error": 0}) nar_obj_meta = {"description": "", "format": "ipynb", "creator": user_id, "job_info": job_info, "data_dependencies": "[]", "jupyter.markdown": "1", "ws_name": ws_name2, "type": "KBaseNarrative.Narrative", "name": "NarrativeCopyTest"} ws2.save_objects({'workspace': ws_name2, 'objects': [{'type': self.NARRATIVE_TYPE, 'data': nar_obj_data, 'name': nar_obj_name, 'meta': nar_obj_meta}]}) # Adding DP object: dps = DataPaletteService(self.__class__.serviceWizardURL, token=self.getContext2()['token'], service_ver=self.__class__.DataPalette_version) dps.add_to_palette({'workspace': ws_name2, 'new_refs': [{'ref': reads_ref}]}) target_reads_name2 = "MyReads.copy.2" ws2.copy_object({'from': {'ref': reads_ref}, 'to': {'workspace': ws_name2, 'name': target_reads_name2}}) #Un-share ws_name1 with user2 ws1.set_permissions({'workspace': ws_name1, 'new_permission': 'n', 'users': [self.getContext2()['user_id']]}) try: self.getWsClient2().get_object_info_new({'objects': [{'ref': reads_ref}]}) raise ValueError("We shouldn't be able to access reads object") except Exception as e: self.assertTrue("cannot be accessed" in str(e)) # Copy copy_nar_name = "NarrativeCopyTest - Copy" ret = self.getImpl().copy_narrative(self.getContext2(), {'workspaceRef': ws_name2 + '/' + nar_obj_name, 'newName': copy_nar_name})[0] copy_ws_id = ret['newWsId'] try: ret = self.getImpl().list_objects_with_sets(self.getContext2(), {"ws_name": str(copy_ws_id), "include_data_palettes": 1})[0]["data"] found = False for item in ret: info = item['object_info'] if info[1] == target_reads_name and info[7] == ws_name1: found = True self.assertFalse(found) finally: # Cleaning up new created workspace ws2.delete_workspace({'id': copy_ws_id})