def test_multiple_entries(self):
WHOIS.get_contact_status_descriptions.return_value = self._get_contact_status()
WHOIS.get_contact_by_handle.return_value = self._get_contact()
WHOIS.get_nsset_status_descriptions.return_value = self._get_nsset_status()
WHOIS.get_nsset_by_handle.return_value = self._get_nsset()
WHOIS.get_keyset_status_descriptions.return_value = self._get_keyset_status()
WHOIS.get_keyset_by_handle.return_value = self._get_keyset()
WHOIS.get_registrar_by_handle.return_value = self._get_registrar()
WHOIS.get_domain_status_descriptions.return_value = self._get_domain_status()
WHOIS.get_domain_by_handle.return_value = self._get_domain()
response = self.client.get(reverse("webwhois:registry_object_type", kwargs={"handle": "testhandle.cz"}))
self.assertContains(response, "Multiple entries found")
self.assertEqual(self.LOGGER.mock_calls, [
CALL_BOOL,
call.create_request('127.0.0.1', 'Web whois', 'Info', properties=(
('handle', 'testhandle.cz'), ('handleType', 'multiple'))),
call.create_request().close(properties=[
('foundType', 'contact'),
('foundType', 'domain'),
('foundType', 'keyset'),
('foundType', 'nsset'),
('foundType', 'registrar'),
])
])
self.assertEqual(self.LOGGER.create_request().result, 'Ok')
self.assertEqual(WHOIS.mock_calls, [
call.get_contact_by_handle('testhandle.cz'),
call.get_nsset_by_handle('testhandle.cz'),
call.get_keyset_by_handle('testhandle.cz'),
call.get_registrar_by_handle('testhandle.cz'),
call.get_domain_by_handle('testhandle.cz')
])
def test_idn_domain_punycode(self):
self._mocks_for_domain_detail(handle="xn--frd-cma.cz")
response = self.client.get(reverse("webwhois:detail_domain", kwargs={"handle": "xn--frd-cma.cz"}))
self.assertContains(response, "Search results for handle <strong>xn--frd-cma.cz</strong>:")
self.assertEqual(self.LOGGER.mock_calls, [
CALL_BOOL,
call.create_request('127.0.0.1', 'Web whois', 'Info', properties=(
('handle', 'xn--frd-cma.cz'), ('handleType', 'domain'))),
call.create_request().close(properties=[('foundType', 'domain')])
])
self.assertEqual(self.LOGGER.create_request().result, 'Ok')
self.assertEqual(WHOIS.mock_calls, [
call.get_domain_by_handle('xn--frd-cma.cz'),
call.get_domain_status_descriptions('en'),
call.get_contact_by_handle('KONTAKT'),
call.get_registrar_by_handle('REG-FRED_A'),
call.get_contact_by_handle('KONTAKT'),
call.get_nsset_by_handle('NSSET-1'),
call.get_nsset_status_descriptions('en'),
call.get_contact_by_handle('KONTAKT'),
call.get_registrar_by_handle('REG-FRED_A'),
call.get_keyset_by_handle('KEYSID-1'),
call.get_keyset_status_descriptions('en'),
call.get_contact_by_handle('KONTAKT'),
call.get_registrar_by_handle('REG-FRED_A')
])
def test_download_domain_internal_server_error(self):
self.LOGGER.create_request.return_value.request_id = 42
RECORD_STATEMENT.domain_printout.side_effect = INTERNAL_SERVER_ERROR
with self.assertRaises(INTERNAL_SERVER_ERROR):
self.client.get(
reverse("webwhois:record_statement_pdf",
kwargs={
"object_type": "domain",
"handle": "foo.cz"
}))
self.assertEqual(RECORD_STATEMENT.mock_calls,
[call.domain_printout('foo.cz', False)])
self.assertEqual(self.LOGGER.mock_calls, [
CALL_BOOL,
call.create_request('127.0.0.1',
'Web whois',
'RecordStatement',
properties=[('handle', 'foo.cz'),
('objectType', 'domain'),
('documentType', 'public')]),
call.create_request().close(
properties=[('exception', 'INTERNAL_SERVER_ERROR')],
references=[])
])
self.assertEqual(self.LOGGER.create_request.return_value.result,
'Error')
def test_contact_with_ssn_type_birthday(self):
WHOIS.get_contact_status_descriptions.return_value = self._get_contact_status()
ident = DisclosableContactIdentification(
value=ContactIdentification(identification_type='BIRTHDAY', identification_data='2000-06-28'),
disclose=True,
)
WHOIS.get_contact_by_handle.return_value = self._get_contact(identification=ident)
WHOIS.get_registrar_by_handle.return_value = self._get_registrar()
response = self.client.get(reverse("webwhois:detail_contact", kwargs={"handle": "mycontact"}))
self.assertContains(response, "Contact details")
self.assertContains(response, "Search results for handle <strong>mycontact</strong>:")
self.assertEqual(response.context['registry_objects']['contact']['birthday'], date(2000, 6, 28))
self.assertEqual(self.LOGGER.mock_calls, [
CALL_BOOL,
call.create_request('127.0.0.1', 'Web whois', 'Info', properties=(
('handle', 'mycontact'), ('handleType', 'contact'))),
call.create_request().close(properties=[('foundType', 'contact')])
])
self.assertEqual(self.LOGGER.create_request().result, 'Ok')
self.assertEqual(WHOIS.mock_calls, [
call.get_contact_by_handle('mycontact'),
call.get_contact_status_descriptions('en'),
call.get_registrar_by_handle('REG-FRED_A'),
call.get_registrar_by_handle('REG-FRED_A')
])
def test_contact_verification_failed(self):
WHOIS.get_contact_status_descriptions.return_value = self._get_contact_status()
WHOIS.get_contact_by_handle.return_value = self._get_contact(
statuses=[STATUS_LINKED, STATUS_VERIFICATION_FAILED],
)
WHOIS.get_registrar_by_handle.return_value = self._get_registrar()
response = self.client.get(reverse("webwhois:detail_contact", kwargs={"handle": "mycontact"}))
self.assertContains(response, "Contact details")
verification_status = response.context["registry_objects"]['contact']['verification_status']
self.assertEqual(verification_status[0]['code'], STATUS_VERIFICATION_FAILED)
self.assertEqual(verification_status[0]['icon'], 'webwhois/img/icon-red-cross.gif')
self.assertEqual(self.LOGGER.mock_calls, [
CALL_BOOL,
call.create_request('127.0.0.1', 'Web whois', 'Info', properties=(
('handle', 'mycontact'), ('handleType', 'contact'))),
call.create_request().close(properties=[('foundType', 'contact')])
])
self.assertEqual(self.LOGGER.create_request().result, 'Ok')
self.assertEqual(WHOIS.mock_calls, [
call.get_contact_by_handle('mycontact'),
call.get_contact_status_descriptions('en'),
call.get_registrar_by_handle('REG-FRED_A'),
call.get_registrar_by_handle('REG-FRED_A')
])
def test_contact_invalid_handle_escaped(self):
WHOIS.get_contact_by_handle.side_effect = INVALID_HANDLE
response = self.client.get(reverse("webwhois:detail_contact", kwargs={"handle": "test<handle"}))
self.assertContains(response, "Invalid handle")
self.assertContains(response, "<strong>test<handle</strong> is not a valid handle.")
self.assertEqual(self.LOGGER.mock_calls, [
CALL_BOOL,
call.create_request('127.0.0.1', 'Web whois', 'Info', properties=(
('handle', 'test<handle'), ('handleType', 'contact'))),
call.create_request().close(properties=[('reason', 'INVALID_HANDLE')])
])
self.assertEqual(self.LOGGER.create_request().result, 'NotFound')
self.assertEqual(WHOIS.mock_calls, [call.get_contact_by_handle('test<handle')])
def test_domain_idna_invalid_codepoint(self):
response = self.client.get(reverse("webwhois:detail_domain", kwargs={"handle": "fr:ed.com"}))
self.assertContains(response, 'Invalid handle')
self.assertContains(response, '<strong>fr:ed.com</strong> is not a valid handle.')
self.assertNotContains(response, 'Register this domain name?')
self.assertEqual(self.LOGGER.mock_calls, [
CALL_BOOL,
call.create_request('127.0.0.1', 'Web whois', 'Info', properties=(
('handle', 'fr:ed.com'), ('handleType', 'domain'))),
call.create_request().close(properties=[('reason', 'IDNAError')])
])
self.assertEqual(self.LOGGER.create_request().result, 'NotFound')
self.assertEqual(WHOIS.mock_calls, [])
def test_results_logger(self):
self._test_results()
# Check logger
logger_calls = [
CALL_BOOL,
call.create_request('127.0.0.1',
'Web whois',
'ScanResults',
properties=(('domain', self.domain), )),
call.create_request().close()
]
self.assertEqual(self.logger.mock_calls, logger_calls)
self.assertEqual(self.logger.create_request.return_value.result, 'Ok')
def test_domain_too_many_labels_with_dot_at_the_end(self):
WHOIS.get_domain_by_handle.side_effect = TOO_MANY_LABELS
response = self.client.get(reverse("webwhois:detail_domain", kwargs={"handle": "www.fred.cz."}))
self.assertContains(response, "Incorrect input")
self.assertContains(response, "Too many parts in the domain name <strong>www.fred.cz.</strong>.")
self.assertContains(response, "Enter only the name and the zone:")
self.assertEqual(self.LOGGER.mock_calls, [
CALL_BOOL,
call.create_request('127.0.0.1', 'Web whois', 'Info', properties=(
('handle', 'www.fred.cz.'), ('handleType', 'domain'))),
call.create_request().close(properties=[('reason', 'TOO_MANY_LABELS')])
])
self.assertEqual(self.LOGGER.create_request().result, 'NotFound')
self.assertEqual(WHOIS.mock_calls, [call.get_domain_by_handle('www.fred.cz.')])
def test_domain_invalid_label_with_dash(self):
WHOIS.get_domain_by_handle.side_effect = INVALID_LABEL
response = self.client.get(reverse("webwhois:detail_domain", kwargs={"handle": "-abc"}))
self.assertContains(response, 'Invalid handle')
self.assertContains(response, '<strong>-abc</strong> is not a valid handle.')
self.assertNotContains(response, 'Register this domain name?')
self.assertEqual(self.LOGGER.mock_calls, [
CALL_BOOL,
call.create_request('127.0.0.1', 'Web whois', 'Info', properties=(
('handle', '-abc'), ('handleType', 'domain'))),
call.create_request().close(properties=[('reason', 'IDNAError')])
])
self.assertEqual(self.LOGGER.create_request().result, 'NotFound')
self.assertEqual(WHOIS.mock_calls, [])
def test_keyset_not_found(self):
WHOIS.get_keyset_by_handle.side_effect = OBJECT_NOT_FOUND
response = self.client.get(reverse("webwhois:detail_keyset", kwargs={"handle": "mykeysid"}))
self.assertContains(response, 'Key server set not found')
self.assertContains(response, 'No key set matches <strong>mykeysid</strong> handle.')
self.assertNotContains(response, 'Register this domain name?')
self.assertEqual(self.LOGGER.mock_calls, [
CALL_BOOL,
call.create_request('127.0.0.1', 'Web whois', 'Info', properties=(
('handle', 'mykeysid'), ('handleType', 'keyset'))),
call.create_request().close(properties=[])
])
self.assertEqual(self.LOGGER.create_request().result, 'NotFound')
self.assertEqual(WHOIS.mock_calls, [call.get_keyset_by_handle('mykeysid')])
def test_keyset_invalid_handle(self):
WHOIS.get_keyset_by_handle.side_effect = INVALID_HANDLE
response = self.client.get(reverse("webwhois:detail_keyset", kwargs={"handle": "mykeysid"}))
self.assertContains(response, "Invalid handle")
self.assertContains(response, "<strong>mykeysid</strong> is not a valid handle.")
self.assertNotContains(response, 'Register this domain name?')
self.assertEqual(self.LOGGER.mock_calls, [
CALL_BOOL,
call.create_request('127.0.0.1', 'Web whois', 'Info', properties=(
('handle', 'mykeysid'), ('handleType', 'keyset'))),
call.create_request().close(properties=[('reason', 'INVALID_HANDLE')])
])
self.assertEqual(self.LOGGER.create_request().result, 'NotFound')
self.assertEqual(WHOIS.mock_calls, [call.get_keyset_by_handle('mykeysid')])
def test_unexpected_exception(self):
class TestException(Exception):
pass
WHOIS.get_domain_by_handle.side_effect = TestException("Unexpected exception.")
with self.assertRaises(TestException):
self.client.get(reverse("webwhois:detail_domain", kwargs={"handle": "fred.cz"}))
self.assertEqual(WHOIS.mock_calls, [call.get_domain_by_handle('fred.cz')])
self.assertEqual(self.LOGGER.mock_calls, [
CALL_BOOL,
call.create_request('127.0.0.1', 'Web whois', 'Info', properties=(
('handle', 'fred.cz'), ('handleType', 'domain'))),
call.create_request().close(properties=[('exception', 'TestException')])
])
self.assertEqual(self.LOGGER.create_request().result, 'Error')
def test_domain_not_found_idna_formated(self):
WHOIS.get_domain_by_handle.side_effect = OBJECT_NOT_FOUND
WHOIS.get_managed_zone_list.return_value = ['cz', '0.2.4.e164.arpa']
response = self.client.get(reverse("webwhois:detail_domain", kwargs={"handle": "...fred.cz"}))
self.assertContains(response, 'Invalid handle')
self.assertContains(response, '<strong>...fred.cz</strong> is not a valid handle.')
self.assertNotContains(response, 'Register this domain name?')
self.assertEqual(self.LOGGER.mock_calls, [
CALL_BOOL,
call.create_request('127.0.0.1', 'Web whois', 'Info', properties=(
('handle', '...fred.cz'), ('handleType', 'domain'))),
call.create_request().close(properties=[('reason', 'INVALID_HANDLE')])
])
self.assertEqual(self.LOGGER.create_request().result, 'NotFound')
self.assertEqual(WHOIS.mock_calls, [])
def test_domain_unmanaged_zone(self):
WHOIS.get_domain_by_handle.side_effect = UNMANAGED_ZONE
WHOIS.get_managed_zone_list.return_value = ['cz', '0.2.4.e164.arpa']
response = self.client.get(reverse("webwhois:detail_domain", kwargs={"handle": "fred.com"}))
self.assertContains(response, 'Unmanaged zone')
msg = 'Domain <strong>fred.com</strong> cannot be found in the registry. ' \
'You can search for domains in the these zones only:'
self.assertContains(response, msg)
self.assertNotContains(response, 'Register this domain name?')
self.assertEqual(self.LOGGER.mock_calls, [
CALL_BOOL,
call.create_request('127.0.0.1', 'Web whois', 'Info', properties=(
('handle', 'fred.com'), ('handleType', 'domain'))),
call.create_request().close(properties=[('reason', 'UNMANAGED_ZONE')])
])
self.assertEqual(self.LOGGER.create_request().result, 'NotFound')
self.assertEqual(WHOIS.mock_calls, [call.get_domain_by_handle('fred.com'), call.get_managed_zone_list()])
def test_prepare_logging_request(self):
self.mock_logger.create_request.return_value = sentinel.logger_object
cleaned_data = {"foo": "oof"}
logger = LoggerView()
logger.request = RequestFactory().request()
response = logger.prepare_logging_request(cleaned_data)
self.assertEqual(response, sentinel.logger_object)
self.assertEqual(self.mock_logger.mock_calls, [call.create_request('127.0.0.1', 'FooService', 'FooService',
properties={'foo': 'oof'})])
def test_contact_without_registrars_handle(self):
WHOIS.get_contact_status_descriptions.return_value = self._get_contact_status()
WHOIS.get_contact_by_handle.return_value = self._get_contact(creating_registrar_handle="",
sponsoring_registrar_handle="")
response = self.client.get(reverse("webwhois:detail_contact", kwargs={"handle": "mycontact"}))
self.assertContains(response, "Contact details")
self.assertContains(response, "Search results for handle <strong>mycontact</strong>:")
self.assertEqual(self.LOGGER.mock_calls, [
CALL_BOOL,
call.create_request('127.0.0.1', 'Web whois', 'Info', properties=(
('handle', 'mycontact'), ('handleType', 'contact'))),
call.create_request().close(properties=[('foundType', 'contact')])
])
self.assertEqual(self.LOGGER.create_request().result, 'Ok')
self.assertEqual(WHOIS.mock_calls, [
call.get_contact_by_handle('mycontact'),
call.get_contact_status_descriptions('en')
])
def test_domain_delete_candidate(self):
WHOIS.get_domain_status_descriptions.return_value = self._get_domain_status()
WHOIS.get_domain_by_handle.side_effect = OBJECT_DELETE_CANDIDATE
WHOIS.get_managed_zone_list.return_value = ['cz', '0.2.4.e164.arpa']
response = self.client.get(reverse("webwhois:detail_domain", kwargs={"handle": "fred.cz"}))
self.assertContains(response, 'Domain name details')
self.assertEqual(response.context['handle'], 'fred.cz')
self.assertTrue(response.context['object_delete_candidate'])
self.assertEqual(WHOIS.mock_calls,
[call.get_domain_by_handle('fred.cz'), call.get_domain_status_descriptions('en')])
self.assertEqual(self.LOGGER.mock_calls, [
CALL_BOOL,
call.create_request('127.0.0.1', 'Web whois', 'Info', properties=(
('handle', 'fred.cz'), ('handleType', 'domain'))),
call.create_request().close(properties=[('foundType', 'domain')])
])
self.assertEqual(self.LOGGER.create_request().result, 'Ok')
def test_registrar(self):
WHOIS.get_registrar_by_handle.return_value = self._get_registrar()
response = self.client.get(
reverse("webwhois:detail_registrar",
kwargs={"handle": "REG_FRED_A"}))
self.assertContains(response, "Registrar details")
self.assertContains(response, "REG_FRED_A")
self.assertEqual(self.LOGGER.mock_calls, [
CALL_BOOL,
call.create_request('127.0.0.1',
'Web whois',
'Info',
properties=(('handle', 'REG_FRED_A'),
('handleType', 'registrar'))),
call.create_request().close(properties=[('foundType',
'registrar')])
])
self.assertEqual(self.LOGGER.create_request().result, 'Ok')
self.assertEqual(WHOIS.mock_calls,
[call.get_registrar_by_handle('REG_FRED_A')])
def test_registrar_not_found(self):
WHOIS.get_registrar_by_handle.side_effect = OBJECT_NOT_FOUND
response = self.client.get(
reverse("webwhois:detail_registrar",
kwargs={"handle": "REG_FRED_A"}))
self.assertContains(response, 'Registrar not found')
self.assertContains(
response,
'No registrar matches <strong>REG_FRED_A</strong> handle.')
self.assertEqual(self.LOGGER.mock_calls, [
CALL_BOOL,
call.create_request('127.0.0.1',
'Web whois',
'Info',
properties=(('handle', 'REG_FRED_A'),
('handleType', 'registrar'))),
call.create_request().close(properties=[])
])
self.assertEqual(self.LOGGER.create_request().result, 'NotFound')
self.assertEqual(WHOIS.mock_calls,
[call.get_registrar_by_handle('REG_FRED_A')])
def test_contact_linked(self):
WHOIS.get_contact_status_descriptions.return_value = self._get_contact_status()
WHOIS.get_contact_by_handle.return_value = self._get_contact()
WHOIS.get_registrar_by_handle.return_value = self._get_registrar()
response = self.client.get(reverse("webwhois:detail_contact", kwargs={"handle": "mycontact"}))
self.assertContains(response, "Contact details")
self.assertContains(response, "Search results for handle <strong>mycontact</strong>:")
self.assertTrue(response.context['registry_objects']['contact']['is_linked'])
self.assertEqual(self.LOGGER.mock_calls, [
CALL_BOOL,
call.create_request('127.0.0.1', 'Web whois', 'Info', properties=(
('handle', 'mycontact'), ('handleType', 'contact'))),
call.create_request().close(properties=[('foundType', 'contact')])
])
self.assertEqual(self.LOGGER.create_request().result, 'Ok')
self.assertEqual(WHOIS.mock_calls, [
call.get_contact_by_handle('mycontact'),
call.get_contact_status_descriptions('en'),
call.get_registrar_by_handle('REG-FRED_A'),
call.get_registrar_by_handle('REG-FRED_A')
])
def test_keyset(self):
WHOIS.get_contact_status_descriptions.return_value = self._get_contact_status()
WHOIS.get_contact_by_handle.return_value = self._get_contact()
WHOIS.get_keyset_status_descriptions.return_value = self._get_keyset_status()
WHOIS.get_keyset_by_handle.return_value = self._get_keyset()
WHOIS.get_registrar_by_handle.return_value = self._get_registrar()
response = self.client.get(reverse("webwhois:detail_keyset", kwargs={"handle": "mykeysid"}))
self.assertContains(response, "Key set details")
self.assertContains(response, "Search results for handle <strong>mykeysid</strong>:")
self.assertEqual(self.LOGGER.mock_calls, [
CALL_BOOL,
call.create_request('127.0.0.1', 'Web whois', 'Info', properties=(
('handle', 'mykeysid'), ('handleType', 'keyset'))),
call.create_request().close(properties=[('foundType', 'keyset')])
])
self.assertEqual(self.LOGGER.create_request().result, 'Ok')
self.assertEqual(WHOIS.mock_calls, [
call.get_keyset_by_handle('mykeysid'),
call.get_keyset_status_descriptions('en'),
call.get_contact_by_handle('KONTAKT'),
call.get_registrar_by_handle('REG-FRED_A')
])
def test_handle_with_dash_not_found(self):
WHOIS.get_contact_by_handle.side_effect = OBJECT_NOT_FOUND
WHOIS.get_nsset_by_handle.side_effect = OBJECT_NOT_FOUND
WHOIS.get_keyset_by_handle.side_effect = OBJECT_NOT_FOUND
WHOIS.get_registrar_by_handle.side_effect = OBJECT_NOT_FOUND
WHOIS.get_managed_zone_list.return_value = []
response = self.client.get(reverse("webwhois:registry_object_type", kwargs={"handle": "-abc"}))
self.assertContains(response, "Record not found")
self.assertEqual(self.LOGGER.mock_calls, [
CALL_BOOL,
call.create_request('127.0.0.1', 'Web whois', 'Info', properties=(
('handle', '-abc'), ('handleType', 'multiple'))),
call.create_request().close(properties=[])
])
self.assertEqual(self.LOGGER.create_request().result, 'NotFound')
self.assertEqual(WHOIS.mock_calls, [
call.get_contact_by_handle('-abc'),
call.get_nsset_by_handle('-abc'),
call.get_keyset_by_handle('-abc'),
call.get_registrar_by_handle('-abc'),
call.get_managed_zone_list(),
])
def test_domain_without_nsset_and_keyset(self):
WHOIS.get_contact_status_descriptions.return_value = self._get_contact_status()
WHOIS.get_contact_by_handle.return_value = self._get_contact()
WHOIS.get_domain_status_descriptions.return_value = self._get_domain_status()
WHOIS.get_domain_by_handle.return_value = self._get_domain(nsset_handle=None, keyset_handle=None)
WHOIS.get_registrar_by_handle.return_value = self._get_registrar()
response = self.client.get(reverse("webwhois:detail_domain", kwargs={"handle": "fred.cz"}))
self.assertContains(response, "Domain name details")
self.assertContains(response, "Search results for handle <strong>fred.cz</strong>:")
self.assertEqual(self.LOGGER.mock_calls, [
CALL_BOOL,
call.create_request('127.0.0.1', 'Web whois', 'Info', properties=(
('handle', 'fred.cz'), ('handleType', 'domain'))),
call.create_request().close(properties=[('foundType', 'domain')])
])
self.assertEqual(self.LOGGER.create_request().result, 'Ok')
self.assertEqual(WHOIS.mock_calls, [
call.get_domain_by_handle('fred.cz'),
call.get_domain_status_descriptions('en'),
call.get_contact_by_handle('KONTAKT'),
call.get_registrar_by_handle('REG-FRED_A'),
call.get_contact_by_handle('KONTAKT')
])
def test_prepare_logging_request(self):
pubreq = DebugPublicRequest()
data = {
'object_type': 'domain',
'handle': 'foo.cz',
'custom_email': '*****@*****.**',
}
logger = pubreq.prepare_logging_request(data)
self.assertEqual(self.LOGGER.mock_calls, [
call.create_request('127.0.0.1',
'Public Request',
'fooActionName',
properties=(('handle', 'foo'), ))
])
self.assertEqual(cache.get(pubreq.public_key), None)
self.assertEqual(self.LOGGER.create_request.return_value, logger)
