def test_set_abstract_jats_abstract_format(self):
"""test the abstract using jats abstract format set to true"""
doi = "10.7554/eLife.00666"
title = "Test article"
article = Article(doi, title)
article.abstract = self.abstract
article.abstract_xml = self.abstract_xml
expected_contains = (
'<jats:abstract xmlns:xlink="http://www.w3.org/1999/xlink">'
'<jats:p xmlns:xlink="http://www.w3.org/1999/xlink">'
"<jats:bold><jats:italic><jats:underline><jats:sub><jats:sup>"
"An abstract. "
'<jats:ext-link ext-link-type="uri" xlink:href="http://dx.doi.org/10.1601/nm.3602">'
"Desulfocapsa sulfexigens</jats:ext-link>."
"</jats:sup></jats:sub></jats:underline></jats:italic></jats:bold> "
'<jats:xref ref-type="bibr">Stock and Wise (1990)</jats:xref>.'
"</jats:p></jats:abstract>"
)
# generate
raw_config_object = raw_config("elife")
jats_abstract = raw_config_object.get("jats_abstract")
raw_config_object["jats_abstract"] = "true"
crossref_config = parse_raw_config(raw_config_object)
crossref_object = generate.CrossrefXML([article], crossref_config, None, True)
crossref_xml_string = crossref_object.output_xml()
# test assertion
self.assertTrue(expected_contains in crossref_xml_string)
# now set the config back to normal
raw_config_object["jats_abstract"] = jats_abstract
def test_set_clinical_trials_edge_case(self, fake_name_map):
"""test edge case of crossref-doi type and alternate content-type value"""
fake_name_map.return_value = OrderedDict([
("ClinicalTrials.gov", "10.18810/clinical-trials-gov")
])
parent = Element("custom_metadata")
article = Article("10.7554/eLife.00666")
clinical_trial = ClinicalTrial()
clinical_trial.source_id = "10.18810/clinical-trials-gov"
clinical_trial.source_id_type = "crossref-doi"
clinical_trial.document_id = "TEST999"
clinical_trial.content_type = "post-results"
article.clinical_trials = [clinical_trial]
expected = (
"<custom_metadata>"
"<ct:program>"
'<ct:clinical-trial-number registry="10.18810/clinical-trials-gov" type="postResults">'
"TEST999"
"</ct:clinical-trial-number>"
"</ct:program>"
"</custom_metadata>")
clinical_trials.set_clinical_trials(
parent,
article,
{
"clinical_trials_registries":
"https://doi.org/10.18810/registries"
},
)
rough_string = ElementTree.tostring(parent).decode("utf-8")
self.assertEqual(rough_string, expected)
def test_do_relations_program_dataset(self):
article = Article("10.7554/eLife.00666")
dataset = Dataset()
dataset.accession_id = "something"
article.datasets = [dataset]
do_result = related.do_relations_program(article)
self.assertTrue(do_result)
def test_component_subtitle_with_face_markup(self):
"""build an article object and component, generate Crossref XML"""
doi = "10.7554/eLife.00666"
title = "Test article"
article = Article(doi, title)
component = Component()
component.title = "A component"
component.subtitle = (
"A <sc>STRANGE</sc> <italic>subtitle</italic>, " +
"and this tag is <not_allowed>!</not_allowed>")
expected_subtitle = (
"A <sc>STRANGE</sc> <i>subtitle</i>, and this tag " +
"is <not_allowed>!</not_allowed>")
article.component_list = [component]
# load a config and override the value
raw_config_object = raw_config("elife")
face_markup = raw_config_object.get("face_markup")
raw_config_object["face_markup"] = "true"
crossref_config = parse_raw_config(raw_config_object)
# generate the crossrefXML
c_xml = generate.CrossrefXML([article], crossref_config, None, True)
crossref_xml_string = c_xml.output_xml()
self.assertIsNotNone(crossref_xml_string)
# A quick test just look for the expected string to test for tags and escape characters
self.assertTrue(expected_subtitle in crossref_xml_string)
# now set the config back to normal
raw_config_object["face_markup"] = face_markup
def test_do_relations_program_citation(self):
article = Article("10.7554/eLife.00666")
citation = Citation()
citation.publication_type = "data"
citation.doi = "10.7554/eLife.00666"
article.ref_list = [citation]
do_result = related.do_relations_program(article)
self.assertTrue(do_result)
def test_do_set_collection_empty_license(self):
"""test when an article has no license"""
article = Article("10.7554/eLife.00666", "Test article")
# create an empty license
license_object = License()
article.license = license_object
# test assertion
self.assertFalse(
collection.do_set_collection(article, "text-mining",
self.crossref_config))
def test_ref_list_citation_with_no_id(self):
"""for test coverage an article with a ref_list with a citation that has no id attribute"""
doi = "10.7554/eLife.00666"
title = "Test article"
article = Article(doi, title)
citation = Citation()
citation.article_title = "An article title"
article.ref_list = [citation]
c_xml = generate.build_crossref_xml([article])
crossref_xml_string = c_xml.output_xml()
self.assertTrue('<citation key="1">' in crossref_xml_string)
def test_do_set_collection_with_license(self):
"""test when an article has no license"""
article = Article("10.7554/eLife.00666", "Test article")
# create a license with a href value
license_object = License()
license_object.href = "http://example.org/license.txt"
article.license = license_object
# test assertion
self.assertTrue(
collection.do_set_collection(article, "text-mining",
self.crossref_config))
def test_set_abstract(self):
"""test stripping unwanted tags from abstract"""
doi = "10.7554/eLife.00666"
title = "Test article"
article = Article(doi, title)
article.abstract = self.abstract
expected_contains = (
"<jats:abstract><jats:p>An abstract. Desulfocapsa sulfexigens." +
" Stock and Wise (1990).</jats:p></jats:abstract>")
# generate
crossref_object = generate.build_crossref_xml([article])
crossref_xml_string = crossref_object.output_xml()
# test assertion
self.assertTrue(expected_contains in crossref_xml_string)
def setUp(self):
self.crossref_config = create_crossref_config()
self.article = Article()
article_license = License()
article_license.href = "https://example.org"
self.article.license = article_license
self.parent = Element("crossmark")
def test_add_date_to_article_cannot_add_date(self):
"for coverage test supplying no article"
article = Article(doi="10.7554/eLife.00000")
date_type = "accepted"
date_string = "2012-11"
return_value = parse.add_date_to_article(article, date_type, date_string)
self.assertFalse(return_value)
def test_do_set_collection_no_license(self):
"""test when an article has no license"""
# create CrossrefXML object to test
article = Article("10.7554/eLife.00666", "Test article")
# test assertion
self.assertFalse(
collection.do_set_collection(article, "text-mining",
self.crossref_config))
def test_set_categories(self):
article = parse.instantiate_article("12")
return_value = parse.set_categories(article, "12")
self.assertTrue(return_value)
self.assertEqual(article.article_categories, ["Neuroscience"])
# test not finding a value, currently still returns True
article = Article()
return_value = parse.set_categories(article, "99999")
self.assertTrue(return_value)
def test_article_preprint(self):
"""test for an article with preprint data"""
doi = "10.7554/eLife.00666"
article = Article(doi, title="Sample article")
article.preprint = Preprint(uri="https://example.org/")
expected_contains = (
"<rel:program>"
"<rel:related_item>"
'<rel:intra_work_relation identifier-type="uri"'
' relationship-type="hasPreprint">https://example.org/'
"</rel:intra_work_relation>"
"</rel:related_item>"
"</rel:program>")
# generate
crossref_object = generate.build_crossref_xml([article])
crossref_xml_string = crossref_object.output_xml()
# test assertion
self.assertTrue(expected_contains in crossref_xml_string)
def test_component_subtitle_no_face_markup(self):
"""build an article object and component, generate Crossref XML"""
doi = "10.7554/eLife.00666"
title = "Test article"
article = Article(doi, title)
component = Component()
component.title = "A component"
component.subtitle = (
"A <sc>STRANGE</sc> <italic>subtitle</italic>, " +
"and this tag is <not_allowed>!</not_allowed>")
expected_subtitle = ("A STRANGE subtitle, and this tag is"
" <not_allowed>!</not_allowed>")
article.component_list = [component]
# generate the crossrefXML
c_xml = generate.build_crossref_xml([article])
crossref_xml_string = c_xml.output_xml()
self.assertIsNotNone(crossref_xml_string)
# A quick test just look for the expected string to test for tags and escape characters
self.assertTrue(expected_subtitle in crossref_xml_string)
def test_set_article_type(self):
article = parse.instantiate_article("12")
return_value = parse.set_article_type(article, "12")
self.assertTrue(return_value)
self.assertEqual(article.article_type, "research-article")
self.assertEqual(article.display_channel, "Short Report")
# test not finding a value
article = Article()
return_value = parse.set_article_type(article, "99999")
self.assertFalse(return_value)
def test_set_dates(self):
article = parse.instantiate_article("12")
return_value = parse.set_dates(article, "12")
self.assertTrue(return_value)
self.assertEqual(article.get_date("received").date, generate_date("2012-05-04"))
self.assertEqual(article.get_date("accepted").date, generate_date("2012-11-29"))
self.assertEqual(article.get_date("license").date, generate_date("2012-11-29"))
# test not finding a value
article = Article()
return_value = parse.set_dates(article, "99999")
self.assertFalse(return_value)
def test_ref_list_citation_elocation_id(self):
"""for test coverage for schema where elocation_id goes into first_page element"""
# load a config and override the value
raw_config_object = raw_config("elife")
original_schema_version = raw_config_object.get(
"crossref_schema_version")
raw_config_object["crossref_schema_version"] = "4.4.0"
crossref_config = parse_raw_config(raw_config_object)
doi = "10.7554/eLife.00666"
title = "Test article"
article = Article(doi, title)
citation = Citation()
citation.elocation_id = "e00003"
article.ref_list = [citation]
c_xml = generate.CrossrefXML([article], crossref_config, None, True)
crossref_xml_string = c_xml.output_xml()
self.assertTrue(
"<first_page>e00003</first_page>" in crossref_xml_string)
# now set the config back to normal
raw_config_object["crossref_schema_version"] = original_schema_version
def test_generate_no_contributors(self):
"""Test when an article has no contributors"""
# build an article object and component, generate Crossref XML
doi = "10.7554/eLife.00666"
title = "Test article"
article = Article(doi, title)
# generate the crossrefXML
c_xml = generate.build_crossref_xml([article])
crossref_xml_string = c_xml.output_xml()
self.assertIsNotNone(crossref_xml_string)
# A quick test just look for a string value to test
self.assertTrue("<contributors" not in crossref_xml_string)
def test_set_titles(self):
"""test stripping unwanted tags from title"""
doi = "10.7554/eLife.00666"
article = Article(doi, self.title)
expected_contains = (
"<titles><title>Test article for Desulfocapsa sulfexigens</title></titles>"
)
# generate
crossref_object = generate.build_crossref_xml([article])
crossref_xml_string = crossref_object.output_xml()
# test assertion
self.assertTrue(expected_contains in crossref_xml_string)
def test_ref_list_data_citation_with_pmid(self):
"""
for test coverage an article with a ref_list with a
data citation that has a pmid attribute
"""
doi = "10.7554/eLife.00666"
title = "Test article"
article = Article(doi, title)
citation = Citation()
citation.data_title = "An data title"
citation.publication_type = "data"
citation.pmid = "pmid"
article.ref_list = [citation]
expected_contains = (
"<rel:program><rel:related_item><rel:description>An data title</rel:description>"
+
'<rel:inter_work_relation identifier-type="pmid" relationship-type="references">'
+
"pmid</rel:inter_work_relation></rel:related_item></rel:program>")
# generate
c_xml = generate.build_crossref_xml([article])
crossref_xml_string = c_xml.output_xml()
# test assertion
self.assertTrue(expected_contains in crossref_xml_string)
def test_generate_blank_affiliation(self):
"""Test when a contributor has a blank affiliation"""
doi = "10.7554/eLife.00666"
title = "Test article"
article = Article(doi, title)
author = Contributor("author", "Surname", "Given names")
aff = Affiliation()
aff.text = ""
author.set_affiliation(aff)
# generate the crossrefXML
c_xml = generate.build_crossref_xml([article])
crossref_xml_string = c_xml.output_xml()
self.assertIsNotNone(crossref_xml_string)
# A quick test just look for a string value to test
self.assertTrue("<affiliation>" not in crossref_xml_string)
def test_set_title(self):
article = parse.instantiate_article("12")
return_value = parse.set_title(article, "12")
self.assertTrue(return_value)
self.assertEqual(
article.title,
(
"A title with Y<sup>1</sup>S<sup>2</sup>P<sup>3</sup>T<sup>4</sup>S<sup>5</sup>"
+ 'P<sup>6</sup>S<sup>7</sup> repeats, <italic>Drosophila</italic> and "quotations".'
),
)
# test not finding a value
article = Article()
return_value = parse.set_title(article, "99999")
self.assertFalse(return_value)
def test_set_license(self):
article = parse.instantiate_article("12")
return_value = parse.set_license(article, "12")
self.assertTrue(return_value)
self.assertIsNotNone(article.license, "did not create a license")
self.assertEqual(article.license.license_id, "1")
self.assertEqual(article.license.license_type, "open-access")
self.assertEqual(article.license.copyright, True)
self.assertEqual(
article.license.href, "http://creativecommons.org/licenses/by/4.0/"
)
self.assertEqual(article.license.name, "Creative Commons Attribution License")
self.assertEqual(
article.license.paragraph1,
"This article is distributed under the terms of the ",
)
self.assertEqual(
article.license.paragraph2,
(
" permitting unrestricted use and redistribution provided that the original "
+ "author and source are credited."
),
)
# test license_id 2
article = parse.instantiate_article("2935")
return_value = parse.set_license(article, "2935")
self.assertTrue(return_value)
self.assertIsNotNone(article.license, "did not create a license")
self.assertEqual(article.license.license_id, "2")
self.assertEqual(article.license.license_type, "open-access")
self.assertEqual(article.license.copyright, False)
self.assertEqual(
article.license.href, "http://creativecommons.org/publicdomain/zero/1.0/"
)
self.assertEqual(article.license.name, "Creative Commons CC0")
self.assertEqual(
article.license.paragraph1,
(
"This is an open-access article, free of all copyright, and may be freely "
+ "reproduced, distributed, transmitted, modified, built upon, or otherwise "
+ "used by anyone for any lawful purpose. The work is made available under the "
),
)
self.assertEqual(article.license.paragraph2, " public domain dedication.")
# test not finding a value
article = Article()
return_value = parse.set_license(article, "99999")
self.assertFalse(return_value)
def test_set_abstract(self):
article = parse.instantiate_article("12")
return_value = parse.set_abstract(article, "12")
self.assertTrue(return_value)
self.assertEqual(
article.abstract,
(
"In this abstract are consensus Y<sup>1</sup>S<sup>2</sup>P<sup>3</sup>"
+ "T<sup>4</sup>S<sup>5</sup>P<sup>6</sup>S<sup>7</sup> repeats, "
+ '<italic>Drosophila</italic> and "quotations".'
),
)
# test not finding a value
article = Article()
return_value = parse.set_abstract(article, "99999")
self.assertFalse(return_value)
def test_set_datasets(self):
article = parse.instantiate_article("14997")
return_value = parse.set_datasets(article, "14997")
self.assertTrue(return_value)
self.assertEqual(len(article.datasets), 2)
# check dataset 1
self.assertEqual(article.datasets[0].dataset_type, "datasets")
self.assertEqual(article.datasets[0].authors, ["Cembrowski M", "Spruston N"])
self.assertEqual(
article.datasets[0].source_id,
"http://www.ncbi.nlm.nih.gov/geo/query/acc.cgi?token=adsveykeprejbej&acc=GSE74985",
)
self.assertEqual(article.datasets[0].year, "2016")
self.assertEqual(
article.datasets[0].title,
"Hipposeq: an RNA-seq based atlas of gene expression in excitatory hippocampal neurons",
)
self.assertEqual(article.datasets[0].license_info, "GSE74985")
# check dataset 2
self.assertEqual(article.datasets[1].dataset_type, "prev_published_datasets")
self.assertEqual(article.datasets[1].authors, ["Cembrowski M", "Spruston N"])
self.assertEqual(
article.datasets[1].source_id,
"http://www.ncbi.nlm.nih.gov/geo/query/acc.cgi?acc=GSE67403",
)
self.assertEqual(article.datasets[1].year, "2016")
self.assertEqual(
article.datasets[1].title,
(
"Spatial gene expression gradients underlie prominent heterogeneity "
+ "of CA1 pyramidal neurons"
),
)
self.assertEqual(article.datasets[1].license_info, "GSE67403")
# check data availability
self.assertEqual(
article.data_availability,
u'\u2022Data Availability text <italic>"here"</italic> & such',
)
# test not finding a value, currently still returns True
article = Article()
return_value = parse.set_datasets(article, "99999")
self.assertTrue(return_value)
self.assertEqual(article.datasets, [])
self.assertEqual(article.data_availability, None)
def test_set_author_info(self):
"test settings some authors"
# article 7 has an author with a competing interest
article = parse.instantiate_article("7")
return_value = parse.set_author_info(article, "7")
self.assertTrue(return_value)
self.assertEqual(len(article.contributors), 3)
# article 7 contributor 3
contrib = article.contributors[2]
self.assertEqual(contrib.contrib_type, "author")
self.assertEqual(contrib.surname, "Baldwin")
self.assertEqual(contrib.given_name, "Ian T")
self.assertEqual(contrib.corresp, True)
self.assertEqual(contrib.equal_contrib, False)
self.assertEqual(contrib.auth_id, "1013")
self.assertEqual(contrib.orcid, None)
self.assertEqual(contrib.suffix, None)
self.assertEqual(contrib.collab, None)
self.assertEqual(contrib.conflict, ["Senior Editor, <italic>eLife</italic>"])
self.assertEqual(contrib.group_author_key, None)
# count affiliations
self.assertEqual(len(article.contributors[2].affiliations), 1)
aff = article.contributors[2].affiliations[0]
self.assertEqual(aff.phone, None)
self.assertEqual(aff.fax, None)
self.assertEqual(aff.department, "Department of Molecular Ecology")
self.assertEqual(aff.institution, "Max Planck Institute for Chemical Ecology")
self.assertEqual(aff.city, "Jena")
self.assertEqual(aff.country, "Germany")
self.assertEqual(aff.text, None)
# article 2935 has some group authors
article = parse.instantiate_article("2935")
return_value = parse.set_author_info(article, "2935")
self.assertTrue(return_value)
self.assertEqual(len(article.contributors), 53)
# article 2935 contributor 34 is a group author
contrib = article.contributors[33]
self.assertEqual(contrib.contrib_type, "author")
self.assertEqual(contrib.surname, None)
self.assertEqual(contrib.given_name, None)
self.assertEqual(contrib.collab, "ICGC Breast Cancer Group")
# test not finding a value
article = Article()
return_value = parse.set_author_info(article, "99999")
self.assertFalse(return_value)
def test_set_organsims(self):
article = parse.instantiate_article("3")
return_value = parse.set_organsims(article, "3")
self.assertTrue(return_value)
self.assertEqual(
article.research_organisms,
[
u"<italic>B. subtilis</italic>",
u"<italic>D. melanogaster</italic>",
u"<italic>E. coli</italic>",
u"Mouse",
],
)
# test not finding a value, currently still returns True
article = Article()
return_value = parse.set_organsims(article, "99999")
self.assertTrue(return_value)
def test_set_titles_face_markup_format(self):
"""test the title using face markup set to true"""
doi = "10.7554/eLife.00666"
article = Article(doi, self.title)
expected_contains = ("<titles><title><b>Test article</b> for"
" Desulfocapsa sulfexigens</title></titles>")
# generate
raw_config_object = raw_config("elife")
face_markup = raw_config_object.get("face_markup")
raw_config_object["face_markup"] = "true"
crossref_config = parse_raw_config(raw_config_object)
crossref_object = generate.CrossrefXML([article], crossref_config,
None, True)
crossref_xml_string = crossref_object.output_xml()
# test assertion
self.assertTrue(expected_contains in crossref_xml_string)
# now set the config back to normal
raw_config_object["face_markup"] = face_markup
def test_set_keywords(self):
article = parse.instantiate_article("12")
return_value = parse.set_keywords(article, "12")
self.assertTrue(return_value)
self.assertEqual(
article.author_keywords,
[
"circuits",
"in vivo",
"spiking patterns",
"STDP",
"synaptic plasticity",
"visual cortex",
],
)
# test not finding a value, currently still returns True
article = Article()
return_value = parse.set_keywords(article, "99999")
self.assertTrue(return_value)
