def setUpClass(cls): token = environ.get('KB_AUTH_TOKEN', None) config_file = environ.get('KB_DEPLOYMENT_CONFIG', None) cls.cfg = {} config = ConfigParser() config.read(config_file) for nameval in config.items('SetAPI'): cls.cfg[nameval[0]] = nameval[1] authServiceUrl = cls.cfg.get( "auth-service-url", "https://kbase.us/services/authorization/Sessions/Login") auth_client = _KBaseAuth(authServiceUrl) user_id = auth_client.get_user(token) # WARNING: don't call any logging methods on the context object, # it'll result in a NoneType error cls.ctx = MethodContext(None) cls.ctx.update({ 'token': token, 'user_id': user_id, 'provenance': [{ 'service': 'SetAPI', 'method': 'please_never_use_it_in_production', 'method_params': [] }], 'authenticated': 1 }) cls.wsURL = cls.cfg['workspace-url'] cls.wsClient = workspaceService(cls.wsURL, token=token) cls.serviceImpl = SetAPI(cls.cfg) # setup data at the class level for now (so that the code is run # once for all tests, not before each test case. Not sure how to # do that outside this function..) suffix = int(time.time() * 1000) wsName = "test_SetAPI_" + str(suffix) cls.wsClient.create_workspace({'workspace': wsName}) cls.wsName = wsName foft = FakeObjectsForTests(os.environ['SDK_CALLBACK_URL']) # Make fake genomes [fake_genome, fake_genome2] = foft.create_fake_genomes({ "ws_name": wsName, "obj_names": ["fake_genome", "fake_genome2"] }) cls.genome_refs = [info_to_ref(fake_genome), info_to_ref(fake_genome2)] # Make some fake feature sets cls.featureset_refs = [ make_fake_feature_set("feature_set_{}".format(i), cls.genome_refs[0], wsName, cls.wsClient) for i in range(3) ]
def test_get_dem_set_ref_path(self): set_name = "test_diff_expression_set_ref_path" set_items = list() for ref in self.diff_exps_no_genome: set_items.append({ "label": "wt", "ref": ref }) dem_set = { "description": "test_diffExprMatrixSet_ref_path", "items": set_items } dem_set_ref = self.getImpl().save_differential_expression_matrix_set_v1(self.getContext(), { "workspace": self.getWsName(), "output_object_name": set_name, "data": dem_set })[0]["set_ref"] fetched_set_with_ref_path = self.getImpl().get_differential_expression_matrix_set_v1(self.getContext(), { "ref": dem_set_ref, "include_item_info": 0, "include_set_item_ref_paths": 1 })[0] self.assertIsNotNone(fetched_set_with_ref_path) self.assertIn("data", fetched_set_with_ref_path) self.assertIn("info", fetched_set_with_ref_path) self.assertEqual(len(fetched_set_with_ref_path["data"]["items"]), 3) self.assertEqual(dem_set_ref, info_to_ref(fetched_set_with_ref_path["info"])) for item in fetched_set_with_ref_path["data"]["items"]: self.assertNotIn("info", item) self.assertIn("ref", item) self.assertIn("label", item) self.assertIn("ref_path", item) self.assertEqual(item["ref_path"], dem_set_ref + ';' + item["ref"])
def test_get_alignment_set_ref_path(self): alignment_set_name = "test_alignment_set_ref_path" alignment_items = list() for ref in self.alignment_refs: alignment_items.append({"label": "wt", "ref": ref}) alignment_set = { "description": "test_alignments", "items": alignment_items } alignment_set_ref = self.getImpl().save_reads_alignment_set_v1( self.getContext(), { "workspace": self.getWsName(), "output_object_name": alignment_set_name, "data": alignment_set })[0]["set_ref"] fetched_set = self.getImpl().get_reads_alignment_set_v1( self.getContext(), { "ref": alignment_set_ref, "include_item_info": 0, "include_set_item_ref_paths": 1 })[0] self.assertIsNotNone(fetched_set) self.assertIn("data", fetched_set) self.assertIn("info", fetched_set) self.assertEqual(len(fetched_set["data"]["items"]), 3) self.assertEqual(alignment_set_ref, info_to_ref(fetched_set["info"])) for item in fetched_set["data"]["items"]: self.assertNotIn("info", item) self.assertIn("ref", item) self.assertIn("label", item) self.assertIn("ref_path", item) self.assertEqual(item["ref_path"], alignment_set_ref + ";" + item["ref"])
def test_get_old_alignment_set_ref_path_to_set(self): alignment_ref = self.fake_rnaseq_alignment_set1 ref_path_to_set = [self.fake_rnaseq_expression_set, alignment_ref] fetched_set = self.getImpl().get_reads_alignment_set_v1( self.getContext(), { "ref": alignment_ref, "ref_path_to_set": ref_path_to_set, "include_item_info": 0, "include_set_item_ref_paths": 1 })[0] self.assertIsNotNone(fetched_set) self.assertIn("data", fetched_set) self.assertIn("info", fetched_set) self.assertEqual(len(fetched_set["data"]["items"]), 3) self.assertEqual(alignment_ref, info_to_ref(fetched_set["info"])) for item in fetched_set["data"]["items"]: self.assertNotIn("info", item) self.assertIn("ref", item) self.assertIn("label", item) self.assertIn("ref_path", item) self.assertEqual(item["ref_path"], ";".join(ref_path_to_set) + ";" + item["ref"]) if self.DEBUG: print('====== RNASeq Alignment with ref_path_to_set ========') pprint(fetched_set) print('======================================================')
def test_get_old_alignment_set(self): for ref in [ self.fake_rnaseq_alignment_set1, self.fake_rnaseq_alignment_set2 ]: fetched_set = self.getImpl().get_reads_alignment_set_v1( self.getContext(), { "ref": ref, "include_item_info": 0 })[0] self.assertIsNotNone(fetched_set) self.assertIn("data", fetched_set) self.assertIn("info", fetched_set) self.assertEqual(len(fetched_set["data"]["items"]), 3) self.assertEqual(ref, info_to_ref(fetched_set["info"])) for item in fetched_set["data"]["items"]: self.assertNotIn("info", item) self.assertIn("ref", item) self.assertIn("label", item) fetched_set_with_info = self.getImpl().get_reads_alignment_set_v1( self.getContext(), { "ref": ref, "include_item_info": 1, "include_set_item_ref_paths": 1 })[0] self.assertIsNotNone(fetched_set_with_info) self.assertIn("data", fetched_set_with_info) for item in fetched_set_with_info["data"]["items"]: self.assertIn("info", item) self.assertIn("ref", item) self.assertIn("label", item) self.assertIn("ref_path", item) self.assertEqual(item["ref_path"], ref + ";" + item["ref"])
def test_get_expression_set(self): expression_set_name = "test_expression_set" expression_items = list() for ref in self.expression_refs: expression_items.append({"label": "wt", "ref": ref}) expression_set = { "description": "test_alignments", "items": expression_items } expression_set_ref = self.getImpl().save_expression_set_v1( self.getContext(), { "workspace": self.getWsName(), "output_object_name": expression_set_name, "data": expression_set })[0]["set_ref"] fetched_set = self.getImpl().get_expression_set_v1( self.getContext(), { "ref": expression_set_ref, "include_item_info": 0 })[0] self.assertIsNotNone(fetched_set) self.assertIn("data", fetched_set) self.assertIn("info", fetched_set) self.assertEqual(len(fetched_set["data"]["items"]), 3) self.assertEqual(expression_set_ref, info_to_ref(fetched_set["info"])) for item in fetched_set["data"]["items"]: self.assertNotIn("info", item) self.assertNotIn("ref_path", item) self.assertIn("ref", item) self.assertIn("label", item) fetched_set_with_info = self.getImpl().get_expression_set_v1( self.getContext(), { "ref": expression_set_ref, "include_item_info": 1 })[0] self.assertIsNotNone(fetched_set_with_info) self.assertIn("data", fetched_set_with_info) for item in fetched_set_with_info["data"]["items"]: self.assertIn("info", item) self.assertIn("ref", item) self.assertIn("label", item) self.assertNotIn("ref_path", item)
def test_save_diff_exp_matrix_set_no_genome(self): set_name = "test_de_matrix_set_no_genome" set_items = list() for ref in self.diff_exps_no_genome: set_items.append({"label": "foo", "ref": ref}) matrix_set = {"description": "test_matrix_set", "items": set_items} result = self.getImpl().save_differential_expression_matrix_set_v1( self.getContext(), { "workspace": self.getWsName(), "output_object_name": set_name, "data": matrix_set })[0] self.assertIsNotNone(result) self.assertIn("set_ref", result) self.assertIn("set_info", result) self.assertEqual(result["set_ref"], info_to_ref(result["set_info"])) self.assertEqual(result["set_info"][1], set_name) self.assertIn("KBaseSets.DifferentialExpressionMatrixSet", result["set_info"][2])
def test_save_expression_set(self): expression_set_name = "test_expression_set" expression_items = list() for ref in self.expression_refs: expression_items.append({"label": "foo", "ref": ref}) expression_set = { "description": "test_expressions", "items": expression_items } result = self.getImpl().save_expression_set_v1( self.getContext(), { "workspace": self.getWsName(), "output_object_name": expression_set_name, "data": expression_set })[0] self.assertIsNotNone(result) self.assertIn("set_ref", result) self.assertIn("set_info", result) self.assertEqual(result["set_ref"], info_to_ref(result["set_info"])) self.assertEqual(result["set_info"][1], expression_set_name) self.assertIn("KBaseSets.ExpressionSet", result["set_info"][2])
def test_save_alignment_set(self): alignment_set_name = "test_alignment_set" alignment_items = list() for ref in self.alignment_refs: alignment_items.append({"label": "wt", "ref": ref}) alignment_set = { "description": "test_alignments", "items": alignment_items } result = self.getImpl().save_reads_alignment_set_v1( self.getContext(), { "workspace": self.getWsName(), "output_object_name": alignment_set_name, "data": alignment_set })[0] self.assertIsNotNone(result) self.assertIn("set_ref", result) self.assertIn("set_info", result) self.assertEqual(result["set_ref"], info_to_ref(result["set_info"])) self.assertEqual(result["set_info"][1], alignment_set_name) self.assertIn("KBaseSets.ReadsAlignmentSet", result["set_info"][2])
def setUpClass(cls): token = environ.get('KB_AUTH_TOKEN', None) config_file = environ.get('KB_DEPLOYMENT_CONFIG', None) cls.cfg = {} config = ConfigParser() config.read(config_file) for nameval in config.items('SetAPI'): cls.cfg[nameval[0]] = nameval[1] authServiceUrl = cls.cfg.get( "auth-service-url", "https://kbase.us/services/authorization/Sessions/Login") auth_client = _KBaseAuth(authServiceUrl) user_id = auth_client.get_user(token) # WARNING: don't call any logging methods on the context object, # it'll result in a NoneType error cls.ctx = MethodContext(None) cls.ctx.update({ 'token': token, 'user_id': user_id, 'provenance': [{ 'service': 'SetAPI', 'method': 'please_never_use_it_in_production', 'method_params': [] }], 'authenticated': 1 }) cls.wsURL = cls.cfg['workspace-url'] cls.wsClient = workspaceService(cls.wsURL, token=token) cls.serviceImpl = SetAPI(cls.cfg) # setup data at the class level for now (so that the code is run # once for all tests, not before each test case. Not sure how to # do that outside this function..) suffix = int(time.time() * 1000) wsName = "test_SetAPI_" + str(suffix) cls.wsClient.create_workspace({'workspace': wsName}) cls.wsName = wsName foft = FakeObjectsForTests(os.environ['SDK_CALLBACK_URL']) # Make a fake genome [fake_genome, fake_genome2] = foft.create_fake_genomes({ "ws_name": wsName, "obj_names": ["fake_genome", "fake_genome2"] }) cls.genome_refs = [info_to_ref(fake_genome), info_to_ref(fake_genome2)] # Make some fake reads objects fake_reads_list = foft.create_fake_reads({ 'ws_name': wsName, "obj_names": ["reads1", "reads2", "reads3"] }) cls.alignment_refs = list() cls.reads_refs = list() # Make some fake alignments referencing those reads and genome dummy_filename = "dummy.txt" cls.dummy_path = os.path.join(cls.cfg['scratch'], dummy_filename) shutil.copy(os.path.join("data", dummy_filename), cls.dummy_path) for idx, reads_info in enumerate(fake_reads_list): reads_ref = info_to_ref(reads_info) cls.reads_refs.append(reads_ref) cls.alignment_refs.append( make_fake_alignment(os.environ['SDK_CALLBACK_URL'], cls.dummy_path, "fake_alignment_{}".format(idx), reads_ref, cls.genome_refs[0], wsName, cls.wsClient)) # Need a fake annotation to get the expression objects cls.annotation_ref = make_fake_annotation( os.environ['SDK_CALLBACK_URL'], cls.dummy_path, "fake_annotation", wsName, cls.wsClient) # Now we can phony up some expression objects to build sets out of. # name, genome_ref, annotation_ref, alignment_ref, ws_name, ws_client cls.expression_refs = list() for idx, alignment_ref in enumerate(cls.alignment_refs): cls.expression_refs.append( make_fake_expression(os.environ['SDK_CALLBACK_URL'], cls.dummy_path, "fake_expression_{}".format(idx), cls.genome_refs[0], cls.annotation_ref, alignment_ref, wsName, cls.wsClient)) # Make a fake RNASeq Alignment Set object # Make a fake RNASeqSampleSet cls.sampleset_ref = make_fake_sampleset("fake_sampleset", [], [], wsName, cls.wsClient) # Finally, make a couple fake RNASeqAlignmentSts objects from those alignments cls.fake_rnaseq_alignment_set = make_fake_old_alignment_set( "fake_rnaseq_alignment_set", cls.reads_refs, cls.genome_refs[0], cls.sampleset_ref, cls.alignment_refs, wsName, cls.wsClient) # Make a fake RNASeq Expression Set object cls.fake_rnaseq_expression_set = make_fake_old_expression_set( "fake_rnaseq_expression_set", cls.genome_refs[0], cls.sampleset_ref, cls.alignment_refs, cls.fake_rnaseq_alignment_set, cls.expression_refs, wsName, cls.wsClient, True)