def test_websubmit_admin_interface_pages_availability(self):
"""websubmitadmin - availability of WebSubmit Admin interface pages"""
baseurl = cfg["CFG_SITE_URL"] + "/admin/websubmit/websubmitadmin.py/"
_exports = [
"",
"showall",
"doctypelist",
"doctypeadd",
"doctyperemove",
"actionlist",
"jschecklist",
"elementlist",
"functionlist",
]
error_messages = []
for url in [baseurl + page for page in _exports]:
# first try as guest:
error_messages.extend(test_web_page_content(url, username="******", expected_text="Authorization failure"))
# then try as admin:
error_messages.extend(test_web_page_content(url, username="******"))
if error_messages:
self.fail(merge_error_messages(error_messages))
return
def test_get_result(self):
"""solrutils - web search results"""
self.assertEqual([],
test_web_page_content(
cfg['CFG_SITE_URL'] +
'/search?of=id&p=fulltext%3AWillnotfind&rg=100',
expected_text="[]"))
self.assertEqual(
[],
test_web_page_content(
cfg['CFG_SITE_URL'] +
'/search?of=id&p=fulltext%3Ahiggs&rg=100',
expected_text=
"[12, 47, 48, 51, 52, 55, 56, 58, 68, 79, 80, 81, 85, 89, 96]")
)
self.assertEqual(
[],
test_web_page_content(
cfg['CFG_SITE_URL'] + '/search?of=id&p=fulltext%3Aof&rg=100',
expected_text=
"[8, 10, 11, 12, 15, 43, 44, 45, 46, 47, 48, 49, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 64, 68, 74, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97]"
))
self.assertEqual(
[],
test_web_page_content(
cfg['CFG_SITE_URL'] +
'/search?of=id&p=fulltext%3A%22higgs+boson%22&rg=100',
expected_text="[12, 47, 51, 55, 56, 68, 81, 85]"))
def test_bibindex_admin_interface_pages_availability(self):
"""bibindexadmin - availability of BibIndex Admin interface pages"""
baseurl = cfg['CFG_SITE_URL'] + '/admin/bibindex/bibindexadmin.py/'
_exports = [
'', 'index', 'index?mtype=perform_showindexoverview',
'index?mtype=perform_showvirtualindexoverview',
'index?mtype=perform_editindexes', 'index?mtype=perform_addindex',
'index?mtype=perform_editvirtualindex',
'index?mtype=perform_addvirtualindex', 'field',
'field?mtype=perform_showfieldoverview',
'field?mtype=perform_editfields', 'field?mtype=perform_addfield',
'editindex?mtype=perform_modifysynonymkb',
'editindex?mtype=perform_modifystopwords',
'editindex?mtype=perform_modifyremovehtml',
'editindex?mtype=perform_modifyremovelatex',
'editindex?mtype=perform_modifytokenizer'
]
error_messages = []
for url in [baseurl + page for page in _exports]:
# first try as guest:
error_messages.extend(
test_web_page_content(url,
username='******',
expected_text='Authorization failure'))
# then try as admin:
error_messages.extend(test_web_page_content(url, username='******'))
if error_messages:
self.fail(merge_error_messages(error_messages))
return
def test_websearch_admin_interface_pages_availability(self):
"""websearchadmin - availability of WebSearch Admin interface pages"""
baseurl = cfg['CFG_SITE_URL'] + '/admin/websearch/websearchadmin.py'
_exports = [
'',
'?mtype=perform_showall',
'?mtype=perform_addcollection',
'?mtype=perform_addcollectiontotree',
'?mtype=perform_modifycollectiontree',
'?mtype=perform_checkwebcollstatus',
'?mtype=perform_checkcollectionstatus',
]
error_messages = []
for url in [baseurl + page for page in _exports]:
# first try as guest:
error_messages.extend(
test_web_page_content(url,
username='******',
expected_text='Authorization failure'))
# then try as admin:
error_messages.extend(test_web_page_content(url, username='******'))
if error_messages:
self.fail(merge_error_messages(error_messages))
return
def test_article_in_unreleased_issue(self):
"""webjournal - check access to unreleased article"""
from invenio.legacy.search_engine import record_public_p
# Record is not public
self.assertEqual(record_public_p(112), False)
# Unreleased article is not visible to guest
error_messages = test_web_page_content(
cfg['CFG_SITE_URL'] + '/journal/AtlantisTimes/2009/06/News/112',
expected_text=["A naturalist's voyage around the world"],
unexpected_text=['Galapagos Archipelago'])
if error_messages:
self.fail(merge_error_messages(error_messages))
# Unreleased article is visible to editor
error_messages = test_web_page_content(
cfg['CFG_SITE_URL'] + '/journal/AtlantisTimes/2009/06/News/112',
username='******',
password='******',
expected_text=['Galapagos Archipelago'],
unexpected_text=[
'This file is restricted', 'You are not authorized'
])
if error_messages:
self.fail(merge_error_messages(error_messages))
def test_websearch_admin_interface_pages_availability(self):
"""websearchadmin - availability of WebSearch Admin interface pages"""
baseurl = cfg['CFG_SITE_URL'] + '/admin/websearch/websearchadmin.py'
_exports = ['',
'?mtype=perform_showall',
'?mtype=perform_addcollection',
'?mtype=perform_addcollectiontotree',
'?mtype=perform_modifycollectiontree',
'?mtype=perform_checkwebcollstatus',
'?mtype=perform_checkcollectionstatus',]
error_messages = []
for url in [baseurl + page for page in _exports]:
# first try as guest:
error_messages.extend(test_web_page_content(url,
username='******',
expected_text=
'Authorization failure'))
# then try as admin:
error_messages.extend(test_web_page_content(url,
username='******'))
if error_messages:
self.fail(merge_error_messages(error_messages))
return
def test_detailed_html_output(self):
"""bibformat - Detailed HTML output"""
# Test record 74 (Article)
pageurl = cfg['CFG_SITE_URL'] + '/%s/74?of=hd' % cfg['CFG_SITE_RECORD']
result = test_web_page_content(
pageurl,
expected_text=[
self.record_74_hd_header,
self.record_74_hd_title,
self.record_74_hd_authors,
self.record_74_hd_abstract,
self.record_74_hd_pubinfo,
self.record_74_hd_fulltext,
#self.record_74_hd_citations,
#self.record_74_hd_references
])
self.assertEqual([], result)
# Test record 7 (Picture)
pageurl = cfg['CFG_SITE_URL'] + '/%s/7?of=hd' % cfg['CFG_SITE_RECORD']
result = test_web_page_content(
pageurl,
expected_text=[
self.record_7_hd_header, self.record_7_hd_title,
self.record_7_hd_date, self.record_7_hd_abstract,
self.record_7_hd_resource, self.record_7_hd_resource_link
])
self.assertEqual([], result)
def test_precached_area_authorization(self):
"""webaccess - login-time precached authorizations for usebaskets"""
error_messages = test_web_page_content(CFG_SITE_SECURE_URL + '/youraccount/display?ln=en', username='******', password='******', expected_text='Your Baskets')
error_messages.extend(test_web_page_content(CFG_SITE_SECURE_URL + '/youraccount/display?ln=en', username='******', password='******', unexpected_text='Your Baskets'))
if error_messages:
self.fail(merge_error_messages(error_messages))
def test_robot_login_method_merging_accounts(self):
"""webaccess - robot login method merging accounts"""
for method_name, method in self.robot_login_methods.iteritems():
url = method.test_create_example_url(self.a_email, method_name, self.a_robot, self.myip, nickname=self.a_nickname)
url2 = method.test_create_example_url(self.another_email, method_name, self.a_robot, self.myip, nickname=self.another_nickname)
url3 = method.test_create_example_url(self.a_email, method_name, self.a_robot, self.myip, nickname=self.another_nickname)
try:
error_messages = test_web_page_content(url, expected_text=self.a_nickname)
if error_messages:
self.fail(merge_error_messages(error_messages))
id_user = run_sql("SELECT id FROM user WHERE email=%s", (self.a_email, ))[0][0]
self.failUnless(run_sql("SELECT * FROM userEXT WHERE id=%s AND id_user=%s AND method=%s", (self.a_nickname, id_user, method_name)))
error_messages = test_web_page_content(url2, expected_text=self.another_nickname)
if error_messages:
self.fail(merge_error_messages(error_messages))
id_user2 = run_sql("SELECT id FROM user WHERE email=%s", (self.another_email, ))[0][0]
self.failIfEqual(id_user, id_user2)
self.failUnless(run_sql("SELECT * FROM userEXT WHERE id=%s AND id_user=%s AND method=%s", (self.another_nickname, id_user2, method_name)), "Can't find id %s for user %s with metod %s. userEXT contains: %s" % (self.another_nickname, id_user2, method_name, run_sql("SELECT * FROM userEXT")))
## The first email should still exists
self.failUnless(run_sql("SELECT * FROM user WHERE email=%s", (self.a_email, )))
## We log in with the 1st email but with the second nickname.
## That means the 1st user should be merged into the second.
error_messages = test_web_page_content(url3, expected_text=self.another_nickname)
if error_messages:
self.fail(merge_error_messages(error_messages))
## The another_email should not exist any longer.
self.failIf(run_sql("SELECT * FROM user WHERE email=%s", (self.another_email, )), "%s still exists! while it should have been merged into %s: %s, userEXT contains: %s" % (self.another_email, self.a_email, run_sql("SELECT * FROM user WHERE email=%s", (self.another_email, )), run_sql("SELECT * FROM userEXT")))
## And the corresponding user should not exist anymore as it has been
## merged into id_user
self.failIf(run_sql("SELECT * FROM user WHERE id=%s", (id_user2, )))
self.failUnless(run_sql("SELECT * FROM user WHERE id=%s AND email=%s", (id_user, self.a_email)))
finally:
self._erase_example_user_and_groups()
def test_detailed_html_output(self):
"""bibformat - Detailed HTML output"""
# Test record 74 (Article)
pageurl = cfg['CFG_SITE_URL'] + '/%s/74?of=hd' % cfg['CFG_SITE_RECORD']
result = test_web_page_content(pageurl,
expected_text=[self.record_74_hd_header,
self.record_74_hd_title,
self.record_74_hd_authors,
self.record_74_hd_abstract,
self.record_74_hd_pubinfo,
self.record_74_hd_fulltext,
#self.record_74_hd_citations,
#self.record_74_hd_references
])
self.assertEqual([], result)
# Test record 7 (Picture)
pageurl = cfg['CFG_SITE_URL'] + '/%s/7?of=hd' % cfg['CFG_SITE_RECORD']
result = test_web_page_content(pageurl,
expected_text=[self.record_7_hd_header,
self.record_7_hd_title,
self.record_7_hd_date,
self.record_7_hd_abstract,
self.record_7_hd_resource,
self.record_7_hd_resource_link])
self.assertEqual([], result)
def test_i18n_ranking_method_names(self):
"""bibrank - I18N ranking method names"""
self.assertEqual([],
test_web_page_content(cfg['CFG_SITE_URL'] + '/collection/Articles%20%26%20Preprints?as=1',
expected_text="times cited"))
self.assertEqual([],
test_web_page_content(cfg['CFG_SITE_URL'] + '/collection/Articles%20%26%20Preprints?as=1',
expected_text="journal impact factor"))
def test_access_restricted_record_public_discussion_public_comment(self):
"""webcomment - accessing "public" comment in a "public" discussion of a restricted record"""
# Guest user should not be able to access it
self.assertNotEqual(
[],
test_web_page_content("%s/%s/%i/comments/" %
(cfg['CFG_SITE_URL'], cfg['CFG_SITE_RECORD'],
self.restr_record),
expected_text=self.msg2))
# Accessing a non existing file for a restricted comment should also ask to login
self.assertEqual([],
test_web_page_content("%s/%s/%i/comments/attachments/get/%i/not_existing_file" % \
(cfg['CFG_SITE_URL'], cfg['CFG_SITE_RECORD'], self.restr_record, self.restr_comid_1),
expected_text='You are not authorized to perform this action'))
# Check accessing file of a restricted comment
self.assertEqual([],
test_web_page_content("%s/%s/%i/comments/attachments/get/%i/file2" % \
(cfg['CFG_SITE_URL'], cfg['CFG_SITE_RECORD'], self.restr_record, self.restr_comid_1),
expected_text='You are not authorized to perform this action'))
# Juliet should not be able to access the comment
self.login('juliet', 'j123uliet')
response = self.client.get("%s/%s/%i/comments/" %
(cfg['CFG_SITE_SECURE_URL'],
cfg['CFG_SITE_RECORD'], self.restr_record))
response = response.data
if not self.msg2 in response:
pass
else:
self.fail("Oops, this user should not have access to this comment")
# Juliet should not be able to access the attached files
response = self.client.get("%s/%s/%i/comments/attachments/get/%i/file2" % \
(cfg['CFG_SITE_SECURE_URL'], cfg['CFG_SITE_RECORD'], self.restr_record, self.restr_comid_1))
response = response.data
if "You are not authorized" in response:
pass
else:
self.fail(
"Oops, this user should not have access to this comment attachment"
)
# Jekyll should be able to access the comment
self.login('jekyll', 'j123ekyll')
response = self.client.get("%s/%s/%i/comments/" %
(cfg['CFG_SITE_SECURE_URL'],
cfg['CFG_SITE_RECORD'], self.restr_record))
response = response.data
if not self.msg2 in response:
self.fail("Oops, this user should have access to this comment")
# Jekyll should be able to access the attached files
response = self.client.get("%s/%s/%i/comments/attachments/get/%i/file2" % \
(cfg['CFG_SITE_SECURE_URL'], cfg['CFG_SITE_RECORD'], self.restr_record, self.restr_comid_1))
response = response.data
self.assertEqual(self.attached_file2_content, response)
def test_availability_bibconvert_hacking_pages(self):
"""bibconvert - availability of BibConvert Hacking Guide pages"""
self.assertEqual([],
test_web_page_content(cfg['CFG_SITE_URL'] + '/help/hacking/bibconvert-internals',
expected_text="BibConvert Internals"))
self.assertEqual([],
test_web_page_content(cfg['CFG_SITE_URL'] + '/help/hacking/bibconvert-api',
expected_text="BibConvert API"))
return
def test_get_similar_ranked(self):
"""solrutils - web similar results"""
self.assertEqual([],
test_web_page_content(cfg['CFG_SITE_URL'] + '/search?of=id&p=recid%3A30&rm=wrd',
expected_text="[1, 3, 4, 8, 9, 12, 13, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 31, 34, 43, 44, 49, 50, 56, 58, 61, 64, 66, 67, 69, 71, 73, 75, 76, 77, 78, 82, 85, 86, 87, 89, 90, 95, 96, 98, 104, 107, 109, 113, 65, 62, 60, 47, 46, 100, 99, 102, 91, 80, 7, 5, 92, 88, 74, 57, 55, 108, 84, 81, 79, 54, 101, 11, 103, 94, 48, 83, 72, 63, 2, 68, 51, 53, 97, 93, 70, 45, 52, 14, 59, 6, 10, 32, 33, 29, 30]"))
self.assertEqual([],
test_web_page_content(cfg['CFG_SITE_URL'] + '/search?of=id&p=recid%3A30&rg=100&rm=wrd',
expected_text="[3, 4, 8, 9, 13, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 31, 34, 43, 49, 56, 66, 67, 69, 71, 73, 75, 76, 87, 90, 98, 104, 107, 109, 113, 12, 95, 85, 82, 44, 1, 89, 64, 58, 15, 96, 61, 50, 86, 78, 77, 65, 62, 60, 47, 46, 100, 99, 102, 91, 80, 7, 5, 92, 88, 74, 57, 55, 108, 84, 81, 79, 54, 101, 11, 103, 94, 48, 83, 72, 63, 2, 68, 51, 53, 97, 93, 70, 45, 52, 14, 59, 6, 10, 32, 33, 29, 30]"))
def test_xss_in_submission_page(self):
"""websubmit - no XSS vulnerability in access parameter"""
self.assertEqual([],
test_web_page_content(cfg['CFG_SITE_URL'] +
'/submit?doctype=DEMOTHE&access=/../../../etc/passwd&act=SBI&startPg=1&ln=en&ln=en', expected_text='Invalid parameters', username="******",
password="******"))
self.assertEqual([],
test_web_page_content(cfg['CFG_SITE_URL'] +
'/submit?doctype=DEMOTHE&access=%3CSCRIPT%3Ealert%28%22XSS%22%29%3B%3C%2FSCRIPT%3E&act=SBI', expected_text='Invalid parameters', username="******",
password="******"))
def test_availability_bibclassify_hacking_pages(self):
"""bibclassify - availability of BibClassify Hacking Guide pages"""
self.assertEqual([], test_web_page_content(CFG_SITE_URL +
'/help/hacking/bibclassify-internals',
expected_text="BibClassify Internals"))
self.assertEqual([], test_web_page_content(CFG_SITE_URL +
'/help/hacking/bibclassify-hep-taxonomy',
expected_text="The HEP taxonomy: rationale and extensions"))
self.assertEqual([], test_web_page_content(CFG_SITE_URL +
'/help/hacking/bibclassify-extraction-algorithm',
expected_text="The code behind BibClassify: the extraction algorithm"))
return
def test_availability_bibconvert_hacking_pages(self):
"""bibconvert - availability of BibConvert Hacking Guide pages"""
self.assertEqual(
[],
test_web_page_content(cfg['CFG_SITE_URL'] +
'/help/hacking/bibconvert-internals',
expected_text="BibConvert Internals"))
self.assertEqual([],
test_web_page_content(cfg['CFG_SITE_URL'] +
'/help/hacking/bibconvert-api',
expected_text="BibConvert API"))
return
def test_nlm_output(self):
"""bibformat - NLM output"""
pageurl = cfg['CFG_SITE_URL'] + '/%s/70?of=xn' % cfg['CFG_SITE_RECORD']
result = test_web_page_content(pageurl,
expected_text=self.record_70_xn)
try:
self.assertEqual([], result)
except AssertionError:
result = test_web_page_content(pageurl,
expected_text=self.record_70_xn.replace('<fpage/>', '<fpage></fpage>').replace('<lpage/>', '<lpage></lpage>'))
self.assertEqual([], result)
def test_twpc_expected_text_arg(self):
"""testutils - test_web_page_content() and expected_text argument"""
# should find HTML in an HTML page:
self.assertEqual([],
test_web_page_content(cfg['CFG_SITE_URL'] + "/search?p=ellis",
expected_text="</html>"))
# should not find HTML tag in an XML page:
errmsgs = test_web_page_content(cfg['CFG_SITE_URL'] + "/search?p=ellis&of=xm")
if errmsgs[0].find(" does not contain </html>") > -1:
pass
else:
self.fail("Should not find </html> in an XML page.")
return
def test_legacy_help_page_link(self):
"""websubmit - legacy Submit Guide page link"""
self.assertEqual([],
test_web_page_content(cfg['CFG_SITE_URL'] + '/help/submit',
expected_text="Submit Guide"))
self.assertEqual([],
test_web_page_content(cfg['CFG_SITE_URL'] + '/help/submit/',
expected_text="Submit Guide"))
self.assertEqual([],
test_web_page_content(cfg['CFG_SITE_URL'] + '/help/submit/index.en.html',
expected_text="Submit Guide"))
self.assertEqual([],
test_web_page_content(cfg['CFG_SITE_URL'] + '/help/submit/access.en.html',
expected_text="Submit Guide"))
def test_detailed_html_no_error_message(self):
"""bibformat - Detailed HTML output without error message"""
# No error message should be displayed in the web interface, whatever happens
pageurl = cfg['CFG_SITE_URL'] + '/%s/74?of=hd' % cfg['CFG_SITE_RECORD']
result = test_web_page_content(pageurl, username='******',
expected_text=["Exception",
"Could not"])
self.assertNotEqual([], result)
pageurl = cfg['CFG_SITE_URL'] + '/%s/7?of=hd' % cfg['CFG_SITE_RECORD']
result = test_web_page_content(pageurl, username='******',
expected_text=["Exception",
"Could not"])
self.assertNotEqual([], result)
def test_access_public_record_restricted_discussion_public_comment(self):
"""webcomment - accessing "public" comment in a restricted discussion of a public record"""
# Guest user should not be able to access it
self.assertNotEqual(
[],
test_web_page_content("%s/%s/%i/comments/" %
(cfg['CFG_SITE_URL'], cfg['CFG_SITE_RECORD'],
self.restricted_discussion),
expected_text=self.msg2))
# Accessing a non existing file for a restricted comment should also ask to login
self.assertEqual([],
test_web_page_content("%s/%s/%i/comments/attachments/get/%i/not_existing_file" % \
(cfg['CFG_SITE_URL'], cfg['CFG_SITE_RECORD'], self.restricted_discussion, self.restr_comid_5),
expected_text='You are not authorized to perform this action'))
# Check accessing file of a restricted comment
self.assertEqual([],
test_web_page_content("%s/%s/%i/comments/attachments/get/%i/file2" % \
(cfg['CFG_SITE_URL'], cfg['CFG_SITE_RECORD'], self.restricted_discussion, self.restr_comid_5),
expected_text='You are not authorized to perform this action'))
# Juliet should not be able to access the comment
self.login('juliet', 'j123uliet')
response = self.client.get(
url_for('comments.comments',
recid=self.restricted_discussion,
_external=True,
_scheme='https'))
self.assertNotIn(self.msg6, response.data)
# Juliet should not be able to access the attached files
response = self.client.get("%s/%s/%i/comments/attachments/get/%i/file2" % \
(cfg['CFG_SITE_SECURE_URL'], cfg['CFG_SITE_RECORD'], self.restricted_discussion, self.restr_comid_5))
self.assertIn("You are not authorized", response.data)
# Romeo should be able to access the comment
self.login('romeo', 'r123omeo')
response = self.client.get(
url_for('comments.comments',
recid=self.restricted_discussion,
_external=True,
_scheme='https'))
self.assertIn(self.msg6, response.data)
# Romeo should be able to access the attached files
response = self.client.get("/%s/%i/comments/attachments/get/%i/file2" % \
(cfg['CFG_SITE_RECORD'], self.restricted_discussion, self.restr_comid_5))
self.assertEqual(self.attached_file2_content, response.data)
def test_access_restricted_record_public_discussion_public_comment(self):
"""webcomment - accessing "public" comment in a "public" discussion of a restricted record"""
# Guest user should not be able to access it
self.assertNotEqual([],
test_web_page_content("%s/%s/%i/comments/" % (cfg['CFG_SITE_URL'], cfg['CFG_SITE_RECORD'], self.restr_record),
expected_text=self.msg2))
# Accessing a non existing file for a restricted comment should also ask to login
self.assertEqual([],
test_web_page_content("%s/%s/%i/comments/attachments/get/%i/not_existing_file" % \
(cfg['CFG_SITE_URL'], cfg['CFG_SITE_RECORD'], self.restr_record, self.restr_comid_1),
expected_text='You are not authorized to perform this action'))
# Check accessing file of a restricted comment
self.assertEqual([],
test_web_page_content("%s/%s/%i/comments/attachments/get/%i/file2" % \
(cfg['CFG_SITE_URL'], cfg['CFG_SITE_RECORD'], self.restr_record, self.restr_comid_1),
expected_text='You are not authorized to perform this action'))
# Juliet should not be able to access the comment
self.login('juliet', 'j123uliet')
response = self.client.get("%s/%s/%i/comments/" % (cfg['CFG_SITE_SECURE_URL'], cfg['CFG_SITE_RECORD'], self.restr_record))
response = response.data
if not self.msg2 in response:
pass
else:
self.fail("Oops, this user should not have access to this comment")
# Juliet should not be able to access the attached files
response = self.client.get("%s/%s/%i/comments/attachments/get/%i/file2" % \
(cfg['CFG_SITE_SECURE_URL'], cfg['CFG_SITE_RECORD'], self.restr_record, self.restr_comid_1))
response = response.data
if "You are not authorized" in response:
pass
else:
self.fail("Oops, this user should not have access to this comment attachment")
# Jekyll should be able to access the comment
self.login('jekyll', 'j123ekyll')
response = self.client.get("%s/%s/%i/comments/" % (cfg['CFG_SITE_SECURE_URL'], cfg['CFG_SITE_RECORD'], self.restr_record))
response = response.data
if not self.msg2 in response:
self.fail("Oops, this user should have access to this comment")
# Jekyll should be able to access the attached files
response = self.client.get("%s/%s/%i/comments/attachments/get/%i/file2" % \
(cfg['CFG_SITE_SECURE_URL'], cfg['CFG_SITE_RECORD'], self.restr_record, self.restr_comid_1))
response = response.data
self.assertEqual(self.attached_file2_content, response)
def test_nlm_output(self):
"""bibformat - NLM output"""
pageurl = cfg['CFG_SITE_URL'] + '/%s/70?of=xn' % cfg['CFG_SITE_RECORD']
result = test_web_page_content(pageurl,
expected_text=self.record_70_xn)
try:
self.assertEqual([], result)
except AssertionError:
result = test_web_page_content(
pageurl,
expected_text=self.record_70_xn.replace(
'<fpage/>',
'<fpage></fpage>').replace('<lpage/>', '<lpage></lpage>'))
self.assertEqual([], result)
def test_publinfo_in_html_brief(self):
"""bibformat - publication reference info in HTML brief formats"""
self.assertEqual(
[],
test_web_page_content(
cfg['CFG_SITE_URL'] + '/search?p=recid%3A84',
expected_text="Nucl. Phys. B: 656 (2003) pp. 23-36"))
def test_search_results_ranked_by_citations_verbose(self):
"""bibrank - search results ranked by number of citations, verbose output"""
#FIXME verbose is not supported in jinja2 templates
self.assertEqual([],
test_web_page_content(cfg['CFG_SITE_URL'] + '/search?cc=Articles+%26+Preprints&p=Klebanov&rm=citation&verbose=2',
username="******",
expected_text="find_citations retlist [[85, 0], [77, 2], [84, 3]]"))
def test_brief_output(self):
"""bibformat - brief authority record format outputs something"""
self.assertEqual(
[],
test_web_page_content(cfg['CFG_SITE_URL'] +
'/search?cc=Authority+Records&rg=100',
expected_text="Ellis, John, 1946-"))
def test_isbn_in_html_detailed(self):
"""bibformat - ISBN in HTML detailed formats"""
self.assertEqual(
[],
test_web_page_content(cfg['CFG_SITE_URL'] +
'/search?p=analyse+informatique&of=HD',
expected_text="ISBN: 2225350574"))
def test_stats_pages_availability(self):
"""webstat - availability of /stats pages"""
baseurl = cfg["CFG_SITE_URL"] + "/stats/"
_exports = ["", "collection_population", "search_frequency", "search_type_distribution", "download_frequency"]
error_messages = []
if cfg["CFG_WEBSESSION_DIFFERENTIATE_BETWEEN_GUESTS"]:
for url in [baseurl + page for page in _exports]:
error_messages.extend(test_web_page_content(url))
for url in [baseurl + page for page in _exports]:
error_messages.extend(test_web_page_content(url, username="******"))
if error_messages:
self.fail(merge_error_messages(error_messages))
return
def test_oairepositoryadmin_interface_pages_availability(self):
"""oairepositoryadmin - availability of OAI Repository Admin interface pages"""
baseurl = cfg["CFG_SITE_URL"] + "/admin/oairepository/oairepositoryadmin.py/"
_exports = ["", "delset", "editset", "addset"]
error_messages = []
for url in [baseurl + page for page in _exports]:
# first try as guest:
error_messages.extend(test_web_page_content(url, username="******", expected_text="Authorization failure"))
# then try as admin:
error_messages.extend(test_web_page_content(url, username="******"))
if error_messages:
self.fail(merge_error_messages(error_messages))
return
def test_marcxml_output(self):
"""bibformat - MARCXML output"""
pageurl = cfg['CFG_SITE_URL'] + '/%s/9?of=xm' % cfg['CFG_SITE_RECORD']
result = test_web_page_content(
pageurl,
expected_text=[self.record_9_xm_beg, self.record_9_xm_end])
self.assertEqual([], result)
def test_title_part_in_html_brief(self):
"""bibformat - title part in HTML brief formats"""
self.assertEqual(
[],
test_web_page_content(cfg['CFG_SITE_URL'] +
'/search?p=analyse+informatique',
expected_text="Analyse informatique, t.2"))
def test_oai_server_pages_availability(self):
"""oairepository - availability of OAI server pages"""
baseurl = CFG_SITE_URL + "/oai2d"
_exports = [ # fast commands first:
"?verb=Identify",
"?verb=ListMetadataFormats",
# sleepy commands now:
"?verb=ListSets",
"?verb=ListRecords",
"?verb=GetRecord",
]
error_messages = []
for url in [baseurl + page for page in _exports]:
if url.endswith("Identify") or url.endswith("ListMetadataFormats"):
pass
else:
# some sleep required for verbs other than Identify
# and ListMetadataFormats, since oai2d refuses too
# frequent access:
time.sleep(CFG_OAI_SLEEP)
error_messages.extend(test_web_page_content(url, expected_text="</OAI-PMH>"))
if error_messages:
self.fail(merge_error_messages(error_messages))
return
def test_marcxml_output(self):
"""bibformat - MARCXML output"""
pageurl = cfg['CFG_SITE_URL'] + '/%s/9?of=xm' % cfg['CFG_SITE_RECORD']
result = test_web_page_content(pageurl,
expected_text=[self.record_9_xm_beg,
self.record_9_xm_end])
self.assertEqual([], result)
def test_kb_pages_curator_can_read(self):
"""bibknowledge - test that balthasar from the curator group can read page"""
kbpage = cfg['CFG_SITE_URL']+"/kb"
errs = test_web_page_content(kbpage, username="******",
password="******",
expected_text="BibKnowledge Admin")
self.assertEqual([], errs)
def test_subtitle_in_html_detailed(self):
"""bibformat - title subtitle in HTML detailed formats"""
self.assertEqual(
[],
test_web_page_content(
cfg['CFG_SITE_URL'] + '/search?p=statistics+computer&of=HD',
expected_text="Statistics: a computer approach"))
def test_bibtex_output(self):
"""bibformat - BibTeX output"""
pageurl = cfg['CFG_SITE_URL'] + '/%s/74?of=hx' % cfg['CFG_SITE_RECORD']
result = test_web_page_content(pageurl,
expected_text=self.record_74_hx)
self.assertEqual([], result)
def test_bibtex_output(self):
"""bibformat - BibTeX output"""
pageurl = cfg['CFG_SITE_URL'] + '/%s/74?of=hx' % cfg['CFG_SITE_RECORD']
result = test_web_page_content(pageurl,
expected_text=self.record_74_hx)
self.assertEqual([], result)
def test_similar_records_link(self):
"""bibrank - 'Similar records' link"""
self.assertEqual(
[],
test_web_page_content(cfg['CFG_SITE_URL'] +
'/search?p=recid%3A77&rm=wrd&of=id',
expected_text="[96, 95, 85, 77]"))
def test_oairepositoryadmin_delete_set(self):
"""oairepositoryadmin - delete set page"""
test_edit_url = cfg["CFG_SITE_URL"] + "/admin/oairepository/oairepositoryadmin.py/delset?oai_set_id=2"
error_messages = test_web_page_content(test_edit_url, username="******")
if error_messages:
self.fail(merge_error_messages(error_messages))
return
def test_title_part_in_html_detailed(self):
"""bibformat - title part in HTML detailed formats"""
self.assertEqual(
[],
test_web_page_content(
cfg['CFG_SITE_URL'] + '/search?p=analyse+informatique&of=HD',
expected_text="Analyse informatique, t.2: L'accomplissement"))
def test_your_account_pages_availability(self):
"""websession - availability of Your Account pages"""
baseurl = CFG_SITE_SECURE_URL + "/youraccount/"
_exports = [
"",
"edit",
"change",
"lost",
"display",
"send_email",
"youradminactivities",
"delete",
"logout",
"login",
"register",
]
error_messages = []
for url in [baseurl + page for page in _exports]:
error_messages.extend(test_web_page_content(url, username="******", expected_text=[]))
if error_messages:
self.fail(merge_error_messages(error_messages))
return
def test_kbd_search_as_json(self):
"""bibknowledge - search dynamic kb on web; get json hits"""
kbpage = cfg[
'CFG_SITE_URL'] + "/kb/export?kbname=" + self.dyn_kbname + '&format=jquery&term=Rodentia'
errs = test_web_page_content(kbpage,
expected_text='["Charles Darwin"]')
self.assertEqual([], errs)
def test_publinfo_in_html_detailed(self):
"""bibformat - publication reference info in HTML detailed formats"""
self.assertEqual(
[],
test_web_page_content(
cfg['CFG_SITE_URL'] + '/%s/84' % cfg['CFG_SITE_RECORD'],
expected_text="Nucl. Phys. B: 656 (2003) pp. 23-36"))
def test_robot_login_method_with_invalid_signature(self):
"""webaccess - robot login method with invalid signature"""
for method_name, method in self.robot_login_methods.iteritems():
url = method.test_create_example_url(self.a_email, method_name,
self.a_robot, self.myip)
url = list(urlparse(url))
query = cgi.parse_qs(url[4])
for key, value in query.items():
query[key] = value[0]
digest = query['digest']
digest0 = digest[0]
if digest0 == '0':
digest0 = '1'
else:
digest0 = '0'
digest = digest0 + digest[1:]
query['digest'] = digest
url[4] = urlencode(query)
url = urlunparse(url)
try:
error_messages = test_web_page_content(
url,
expected_text="does not validate against the digest")
if error_messages:
self.fail(merge_error_messages(error_messages))
finally:
self._erase_example_user_and_groups()
def test_detailed_html_edit_record(self):
"""bibformat - Detailed HTML output edit record link presence"""
pageurl = cfg['CFG_SITE_URL'] + '/%s/74?of=hd' % cfg['CFG_SITE_RECORD']
result = test_web_page_content(pageurl,
username='******',
expected_text="Edit This Record")
self.assertEqual([], result)
def test_language_handling_in_whatsnew_widget(self):
"""webjournal - check handling of ln parameter in "what's new" widget"""
error_messages = test_web_page_content(cfg['CFG_SITE_URL'] + '/journal/AtlantisTimes/2009/03/News?ln=fr' ,
expected_link_label="Scissor-beak",
expected_link_target=cfg['CFG_SITE_URL'].encode('utf8') + "/journal/AtlantisTimes/2009/03/Science/111?ln=fr")
if error_messages:
self.fail(merge_error_messages(error_messages))
def test_precached_area_authorization(self):
"""webaccess - login-time precached authorizations for usebaskets"""
error_messages = test_web_page_content(cfg['CFG_SITE_SECURE_URL'] +
'/youraccount/display?ln=en',
username='******',
password='******',
expected_text='Your Baskets')
error_messages.extend(
test_web_page_content(cfg['CFG_SITE_SECURE_URL'] +
'/youraccount/display?ln=en',
username='******',
password='******',
unexpected_text='Your Baskets'))
if error_messages:
self.fail(merge_error_messages(error_messages))
def test_detailed_html_no_error_message(self):
"""bibformat - Detailed HTML output without error message"""
# No error message should be displayed in the web interface, whatever happens
pageurl = cfg['CFG_SITE_URL'] + '/%s/74?of=hd' % cfg['CFG_SITE_RECORD']
result = test_web_page_content(
pageurl,
username='******',
expected_text=["Exception", "Could not"])
self.assertNotEqual([], result)
pageurl = cfg['CFG_SITE_URL'] + '/%s/7?of=hd' % cfg['CFG_SITE_RECORD']
result = test_web_page_content(
pageurl,
username='******',
expected_text=["Exception", "Could not"])
self.assertNotEqual([], result)
def test_oai_server_pages_availability(self):
"""oairepository - availability of OAI server pages"""
baseurl = cfg['CFG_SITE_URL'] + '/oai2d'
_exports = [ #fast commands first:
'?verb=Identify',
'?verb=ListMetadataFormats',
# sleepy commands now:
'?verb=ListSets',
'?verb=ListRecords',
'?verb=GetRecord'
]
error_messages = []
for url in [baseurl + page for page in _exports]:
if url.endswith('Identify') or \
url.endswith('ListMetadataFormats'):
pass
else:
# some sleep required for verbs other than Identify
# and ListMetadataFormats, since oai2d refuses too
# frequent access:
time.sleep(cfg['CFG_OAI_SLEEP'])
error_messages.extend(
test_web_page_content(url, expected_text='</OAI-PMH>'))
if error_messages:
self.fail(merge_error_messages(error_messages))
return
def test_websearch_admin_guide_availability(self):
"""websearchadmin - availability of WebSearch Admin guide pages"""
url = CFG_SITE_URL + "/help/admin/websearch-admin-guide"
error_messages = test_web_page_content(url, expected_text="WebSearch Admin Guide")
if error_messages:
self.fail(merge_error_messages(error_messages))
return
def test_your_baskets_pages_availability(self):
"""webcomment - availability of comments pages"""
baseurl = cfg['CFG_SITE_URL'] + '/%s/10/comments/' % cfg['CFG_SITE_RECORD']
basesecureurl = cfg['CFG_SITE_SECURE_URL'] + '/%s/10/comments/' % cfg['CFG_SITE_RECORD']
_exports = ['', 'display', 'vote', 'report']
_auth_exports = ['add']
error_messages = []
for url in [baseurl + page for page in _exports]:
error_messages.extend(test_web_page_content(url))
for url in [basesecureurl + page for page in _auth_exports]:
error_messages.extend(test_web_page_content(url, username='******'))
if error_messages:
self.fail(merge_error_messages(error_messages))
return
def test_language_handling_in_record(self):
"""webjournal - check washing of ln parameter in /record handler"""
error_messages = test_web_page_content(cfg['CFG_SITE_URL'] + '/record/103?verbose=9&ln=hello' ,
expected_text=["we rode to another estate",
"The forest abounded with beautiful objects"],
unexpected_text=["Error when evaluating format element WEBJOURNAL_"])
if error_messages:
self.fail(merge_error_messages(error_messages))
def test_stats_pages_availability(self):
"""webstat - availability of /stats pages"""
baseurl = CFG_SITE_URL + '/stats/'
_exports = ['', 'collection_population', 'search_frequency',
'search_type_distribution', 'download_frequency']
error_messages = []
if CFG_WEBSESSION_DIFFERENTIATE_BETWEEN_GUESTS:
for url in [baseurl + page for page in _exports]:
error_messages.extend(test_web_page_content(url))
for url in [baseurl + page for page in _exports]:
error_messages.extend(test_web_page_content(url, username='******'))
if error_messages:
self.fail(merge_error_messages(error_messages))
return
def test_twpc_username_arg(self):
"""testutils - test_web_page_content() and username arguments"""
# should login as admin without password:
self.assertEqual([],
test_web_page_content(cfg['CFG_SITE_URL'],
username="******",
expected_text="</html>"))
# should not login as admin with password:
errmsgs = test_web_page_content(cfg['CFG_SITE_URL'],
username="******",
password="******",
expected_text="</html>")
if errmsgs[0].find("ERROR: Cannot login as admin.") > -1:
pass
else:
self.fail("Should not be able to login as admin with foo password.")
return
