def test_parse_fail(self): bads = [ "123/456", "123", "123/456/789/8", "123/456/", "123/", "foo/bar/baz" ] for bad in bads: with self.assertRaises(ValueError): NarrativeRef.parse(bad)
def test_equality(self): ref1 = NarrativeRef.parse("1/2/3") ref2 = NarrativeRef.parse("1/2/3") ref_ws = NarrativeRef.parse("4/2/3") ref_obj = NarrativeRef.parse("1/4/3") ref_ver = NarrativeRef.parse("1/2/4") self.assertEqual(ref1, ref1) self.assertEqual(ref1, ref2) self.assertEqual(ref2, ref1) self.assertNotEqual(ref1, ref_ws) self.assertNotEqual(ref1, ref_obj) self.assertNotEqual(ref1, ref_ver) self.assertNotEqual(ref_ws, ref1) self.assertNotEqual(ref_obj, ref1) self.assertNotEqual(ref_ver, ref1)
def test_save_narrative_url_bad(self, rqm): mock_ws_bad(rqm, "Failed to alter metadata") ws_id = 234 with self.assertRaises(WorkspaceError) as e: save_narrative_url(self.cfg["workspace-url"], self.token, NarrativeRef.parse("234/1/2"), "/234/1") self.assertIn("Failed to alter metadata", str(e.exception)) self.assertIn(str(ws_id), str(e.exception))
def test_read_narrative_bad_client(self, rqm): ws_id = 908 mock_ws_bad(rqm, "Can't fetch object") with self.assertRaises(WorkspaceError) as e: read_narrative( NarrativeRef.parse("908/1/1"), Workspace(url=self.cfg["workspace-url"], token=self.token)) self.assertIn(str(ws_id), str(e.exception)) self.assertIn("Can't fetch object", str(e.exception))
def create_static_narrative(self, ctx, params): """ Creates a static Narrative from the given Narrative ref string. :param params: instance of type "CreateStaticNarrativeInput" (narrative_ref - the reference to the Narrative object to make a static version of. must include version! overwrite - if true, overwrite any previous version of the static Narrative.) -> structure: parameter "narrative_ref" of type "ws_ref" (a workspace object reference string (of the form wsid/objid/ver)), parameter "overwrite" of type "boolean" (allowed 0 or 1) :returns: instance of type "CreateStaticNarrativeOutput" -> structure: parameter "static_narrative_url" of type "url" """ # ctx is the context object # return variables are: output #BEGIN create_static_narrative # init - get NarrativeRef and Exporter set up ref = NarrativeRef.parse(params["narrative_ref"]) ws_url = self.config["workspace-url"] self.logger.info(f"Creating Static Narrative {ref}") verify_admin_privilege(ws_url, ctx["user_id"], ctx["token"], ref.wsid) verify_public_narrative(ws_url, ref.wsid) exporter = NarrativeExporter(self.config, ctx["user_id"], ctx["token"]) # set up output directories try: output_dir = os.path.join(self.config["scratch"], str(ref.wsid), str(ref.objid), str(ref.ver)) os.makedirs(output_dir, exist_ok=True) except IOError as e: self.logger.error( "Error while creating Static Narrative directory", e) raise # export the narrative to a file try: output_path = exporter.export_narrative(ref, output_dir) except Exception as e: self.logger.error("Error while exporting Narrative", e) raise # upload it and save it to the Workspace metadata before returning the url path static_url = upload_static_narrative(ref, output_path, self.config["static-file-root"]) save_narrative_url(self.config["workspace-url"], ctx["token"], ref, static_url) output = {"static_narrative_url": static_url} self.logger.info(f"Finished creating Static Narrative {ref}") #END create_static_narrative # At some point might do deeper type checking... if not isinstance(output, dict): raise ValueError('Method create_static_narrative return value ' + 'output is not type dict as required.') # return the results return [output]
def test_read_narrative_not_narrative(self, rqm): ref = "43666/3/1" ref_to_file = {ref: "data/43666/report-43666.3.1.json"} set_up_ok_mocks(rqm, ref_to_file=ref_to_file) with self.assertRaises(ValueError) as e: read_narrative( NarrativeRef.parse(ref), Workspace(url=self.cfg["workspace-url"], token=self.token)) self.assertIn( f"Expected a Narrative object with reference {ref}, got a KBaseReport.Report-3.0", str(e.exception))
def test_read_narrative_ok(self, rqm): ref = "43666/1/18" ref_to_file = {ref: "data/43666/narrative-43666.1.18.json"} set_up_ok_mocks(rqm, ref_to_file=ref_to_file) nar = read_narrative( NarrativeRef.parse("43666/1/18"), Workspace(url=self.cfg["workspace-url"], token=self.token)) # spot check that it's loaded and formatted self.assertIsNotNone(nar) self.assertIn("cells", nar) self.assertEqual(len(nar["cells"]), 9)
def test_validate_narr_type(self): good_types = [ "KBaseNarrative.Narrative-1.0", "KBaseNarrative.Narrative-4.0" ] bad_types = [ "SomeObject.Name", "kbasenarrative.Narrative-1.0" "KBaseNarrative.Narrative-1.0.0" ] invalid_types = [5, str, {"lol": "no"}, ["wat"], None] ref = NarrativeRef.parse("1/2/3") for t in good_types: self.assertIsNone(_validate_narr_type(t, ref)) for t in bad_types: with self.assertRaises(ValueError) as e: _validate_narr_type(t, ref) self.assertIn( f"Expected a Narrative object with reference {str(ref)}, got a", str(e.exception)) for t in invalid_types: with self.assertRaises(ValueError) as e: _validate_narr_type(t, ref) self.assertIn(f"The type string must be a string", str(e.exception))
def setUpClass(cls): cls.ref = NarrativeRef.parse("1/2/3") cls.cfg = get_test_config()
def test_ok_from_parse(self): ref = NarrativeRef.parse("123/456/7") self.assertEqual(ref.wsid, 123) self.assertEqual(ref.objid, 456) self.assertEqual(ref.ver, 7)