def test_add_report_to_db_translation_none():
"""
This should raise HTTPNotFound as translation is None.
"""
with mock.patch('annotran.languages.models.Language') as language:
language.get_by_public_language_id = MagicMock(return_value=language)
with mock.patch('annotran.pages.models.Page') as page:
page.get_by_uri = MagicMock(return_value=page)
with mock.patch('h.groups.models.Group') as group:
group.get_by_pubid = MagicMock(return_value=group)
with mock.patch('h.models.User') as user:
user.get_by_username = MagicMock(return_value=user)
with mock.patch('annotran.translations.models.Translation') as translation:
translation.get_translation = MagicMock(return_value=None)
request = _mock_request(authenticated_user=mock.Mock(username="test"),
matchdict={'public_language_id': '12345',
'public_group_id': '12345',
'user_id': '12345',
'page_uri': 'http://www.annotran_test.com/'})
with pytest.raises(exc.HTTPNotFound):
views.add_report(request)
python类HTTPNotFound()的实例源码
def delete_vote(request):
"""
Delete a vote from the database
:param request: the current request object
:return: a redirect to language read
"""
if request.authenticated_user is None:
raise exc.HTTPNotFound()
public_language_id = request.matchdict["public_language_id"]
public_group_id = request.matchdict['public_group_id']
page_uri = urllib.unquote(urllib.unquote(request.matchdict['page_uri']))
page = annotran.pages.models.Page.get_by_uri(page_uri)
language = annotran.languages.models.Language.get_by_public_language_id(public_language_id)
# only authenticated used can delete translations and consequently their scores
user = h.models.User.get_by_username(request.authenticated_user.username)
group = h.groups.models.Group.get_by_pubid(public_group_id)
if language is None or page is None \
or group is None or user is None:
raise exc.HTTPNotFound()
models.Vote.delete_votes(page, language, group, user)
request.db.flush()
return {}
def test_add_vote_to_db_unauthenticated_user():
"""
This should raise HTTPNotFound because of unauthenticated user.
"""
request = _mock_request(authenticated_user=None)
with pytest.raises(httpexceptions.HTTPNotFound):
views.add_vote(request)
def test_add_vote_to_db_authenticated_user_objects_none():
"""
This should raise HTTPNotFound as all page, author, voter, group, and language are None.
"""
request = _mock_request(matchdict={'page_uri': 'http://www.annotran_test.com',
'public_group_id': "12345",
'public_language_id': "12345",
'score': 5,
'username':"test_username"},
authenticated_user=mock.Mock(id=2, username="test2", uid="test2"))
with pytest.raises(httpexceptions.HTTPNotFound):
views.add_vote(request)
def test_delete_vote_unauthenticated_user():
"""
This should raise HTTPNotFound because of unauthenticated user.
"""
request = _mock_request(authenticated_user=None)
with pytest.raises(httpexceptions.HTTPNotFound):
views.delete_vote(request)
def _wait_for_entry(self, serial):
keyfs = self.xom.keyfs
next_serial = keyfs.get_next_serial()
if serial > next_serial:
raise HTTPNotFound("can only wait for next serial")
elif serial == next_serial:
arrived = keyfs.wait_tx_serial(serial, timeout=self.MAX_REPLICA_BLOCK_TIME)
if not arrived:
raise HTTPAccepted("no new transaction yet",
headers={str("X-DEVPI-SERIAL"):
str(keyfs.get_current_serial())})
return keyfs.tx.conn.get_raw_changelog_entry(serial)
def versions(self):
versions = self.stage.list_versions(self.project)
if not versions:
raise HTTPNotFound("The project %s does not exist." % self.project)
return get_sorted_versions(versions)
def stable_versions(self):
versions = self.stage.list_versions(self.project)
if not versions:
raise HTTPNotFound("The project %s does not exist." % self.project)
versions = get_sorted_versions(versions, stable=True)
if not versions:
raise HTTPNotFound("The project %s has no stable release." % self.project)
return versions
def linkstore(self):
try:
return self.stage.get_linkstore_perstage(self.project, self.version)
except self.stage.MissesRegistration:
raise HTTPNotFound(
"%s-%s is not registered" % (self.project, self.version))
def view_job(request):
job_alias = request.matchdict['job_alias']
job = get_job_by_alias(job_alias)
if job is None:
raise HTTPNotFound()
return { 'job': job }
def _account_key_focus(self, eagerload_web=False):
dbLetsEncryptAccountKey = lib_db.get__SslLetsEncryptAccountKey__by_id(self.request.api_context, self.request.matchdict['id'], eagerload_web=eagerload_web, )
if not dbLetsEncryptAccountKey:
raise HTTPNotFound('the key was not found')
return dbLetsEncryptAccountKey
# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
def _certificate_focus(self):
dbServerCertificate = lib_db.get__SslServerCertificate__by_id(self.request.api_context, self.request.matchdict['id'])
if not dbServerCertificate:
raise HTTPNotFound('the certificate was not found')
return dbServerCertificate
def _queue_renewal_focus(self):
item = lib_db.get__SslQueueRenewal__by_id(self.request.api_context, self.request.matchdict['id'], load_events=True)
if not item:
raise HTTPNotFound('the item was not found')
return item
def _queue_domain_focus(self):
item = lib_db.get__SslQueueDomain__by_id(self.request.api_context, self.request.matchdict['id'], eagerload_log=True)
if not item:
raise HTTPNotFound('the item was not found')
return item
def _domain_focus(self, eagerload_web=False):
domain_identifier = self.request.matchdict['domain_identifier'].strip()
if domain_identifier.isdigit():
dbDomain = lib_db.get__SslDomain__by_id(self.request.api_context, domain_identifier, preload=True, eagerload_web=eagerload_web)
else:
dbDomain = lib_db.get__SslDomain__by_name(self.request.api_context, domain_identifier, preload=True, eagerload_web=eagerload_web)
if not dbDomain:
raise HTTPNotFound('the domain was not found')
return dbDomain
def _unique_fqdn_set_focus(self):
dbItem = lib_db.get__SslUniqueFQDNSet__by_id(self.request.api_context, self.request.matchdict['id'])
if not dbItem:
raise HTTPNotFound('the fqdn set was not found')
return dbItem
def _certificate_request_focus(self):
dbCertificateRequest = lib_db.get__SslCertificateRequest__by_id(self.request.api_context, self.request.matchdict['id'])
if not dbCertificateRequest:
raise HTTPNotFound('the certificate was not found')
return dbCertificateRequest
def certificate_request_deactivate(self):
dbCertificateRequest = self._certificate_request_focus()
if not dbCertificateRequest.certificate_request_type_is('acme flow'):
raise HTTPNotFound('Only availble for Acme Flow')
dbCertificateRequest.is_active = False
self.request.api_context.dbSession.flush()
return HTTPFound('%s/certificate-request/%s?result=success' % (self.request.registry.settings['admin_prefix'], dbCertificateRequest.id))
# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
def certificate_request_AcmeFlow_manage(self):
dbCertificateRequest = self._certificate_request_focus()
if not dbCertificateRequest.certificate_request_type_is('acme flow'):
raise HTTPNotFound('Only availble for Acme Flow')
return {'project': 'peter_sslers',
'SslCertificateRequest': dbCertificateRequest,
'SslCertificateRequest2SslDomain': None,
}
# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
def certificate_request_AcmeFlow_manage_domain(self):
dbCertificateRequest = self._certificate_request_focus()
if not dbCertificateRequest.certificate_request_type_is('acme flow'):
raise HTTPNotFound('Only availble for Acme Flow')
dbCertificateRequest2SslDomain = None
domain_identifier = self.request.matchdict['domain_identifier'].strip()
if domain_identifier.isdigit():
dbDomain = lib_db.get__SslDomain__by_id(self.request.api_context, domain_identifier, preload=False, eagerload_web=False)
else:
dbDomain = lib_db.get__SslDomain__by_name(self.request.api_context, domain_identifier, preload=False, eagerload_web=False)
if not dbDomain:
raise HTTPNotFound('invalid domain')
for to_domain in dbCertificateRequest.to_domains:
if to_domain.ssl_domain_id == dbDomain.id:
dbCertificateRequest2SslDomain = to_domain
break
if dbCertificateRequest2SslDomain is None:
raise HTTPNotFound('invalid domain for certificate request')
self.db_SslCertificateRequest = dbCertificateRequest
self.db_SslCertificateRequest2SslDomain = dbCertificateRequest2SslDomain
if self.request.method == 'POST':
return self._certificate_request_AcmeFlow_manage_domain__submit()
return self._certificate_request_AcmeFlow_manage_domain__print()
