def test_recordeditview_post_submit(client_admin, mock_create_record,
mock_delete_record, record_data,
signed_record_data):
record_data['rtype'] = 'AAAA'
response = client_admin.post(reverse('zoneeditor:zone_record_edit',
kwargs={'zone': 'example.com.'}),
data={
'identifier': signed_record_data,
**record_data
})
TestCase().assertRedirects(response,
'/zones/example.com.',
fetch_redirect_response=False)
mock_delete_record.assert_called_once_with(
zone='example.com.',
name='mail.example.com.',
rtype='MX',
content='0 example.org.',
)
mock_create_record.assert_called_once_with(
zone='example.com.',
name='mail.example.com.',
rtype='AAAA',
ttl=300,
content='0 example.org.',
)
def _run_test(serializer_cls, model_cls, sql_queries=1, *,
excluded_fields=None,
extra_select_fields=None,
extra_prefetch_fields=None, ) -> ReturnList:
"""
Boilerplate for running the tests
:return: the serializer data to assert one
"""
print(
f'Running test with serializer "{serializer_cls.__name__}" and model {model_cls.__name__}'
)
case = TestCase()
request = APIRequestFactory().get("/FOO")
with case.assertNumQueries(sql_queries):
print(excluded_fields, extra_select_fields, extra_prefetch_fields)
prefetched_queryset = prefetch(model_cls.objects.all(), serializer_cls, excluded_fields=excluded_fields,
extra_select_fields=extra_select_fields,
extra_prefetch_fields=extra_prefetch_fields)
serializer_instance = serializer_cls(
instance=prefetched_queryset, many=True, context={"request": request}
)
print("Data returned:")
pprint_result(serializer_instance.data)
return serializer_instance.data
def test_zonedeleteview_post_no_confirm(client_admin, mock_pdns_delete_zone, signed_example_com):
response = client_admin.post(reverse('zoneeditor:zone_delete'), data={
'identifier': signed_example_com,
'confirm': 'false',
})
TestCase().assertRedirects(response, '/zones', fetch_redirect_response=False)
mock_pdns_delete_zone.assert_not_called()
def _django_db_fixture_helper(transactional, request, _django_cursor_wrapper):
if is_django_unittest(request.node):
return
if transactional:
_django_cursor_wrapper.enable()
def flushdb():
"""Flush the database and close database connections"""
# Django does this by default *before* each test
# instead of after.
from django.db import connections
from django.core.management import call_command
for db in connections:
call_command('flush', verbosity=0,
interactive=False, database=db)
for conn in connections.all():
conn.close()
request.addfinalizer(_django_cursor_wrapper.disable)
request.addfinalizer(flushdb)
else:
if 'live_server' in request.funcargnames:
return
from django.test import TestCase
_django_cursor_wrapper.enable()
_django_cursor_wrapper._is_transactional = False
case = TestCase(methodName='__init__')
case._pre_setup()
request.addfinalizer(_django_cursor_wrapper.disable)
request.addfinalizer(case._post_teardown)
def dj_asserts():
from django.test import TestCase
testcase = TestCase()
class Asserts:
html_equal = testcase.assertHTMLEqual
return Asserts()
def djasserts():
from django.test import TestCase
testcase = TestCase()
class Asserts:
redirects = testcase.assertRedirects
return Asserts()
def compare_projects_files(orig_file, new_file):
with open(orig_file) as orig:
orig_json = json.load(orig)
with open(new_file) as exported:
exported_json = json.load(exported)
test = TestCase()
test.maxDiff = None
test.assertDictEqual(orig_json, exported_json)
def test_zonedeleteview_post_granted(client, mock_pdns_delete_zone, zone_data, db_zone):
assert Zone.objects.filter(name='example.com.').exists()
response = client.post(reverse('zoneeditor:zone_delete'), data={
'identifier': zone_data,
'confirm': 'true',
})
TestCase().assertRedirects(response, '/zones', fetch_redirect_response=False)
mock_pdns_delete_zone.assert_called_once_with('example.com.')
assert not Zone.objects.filter(name='example.com.').exists()
def assertRecordMetadataEqual(serialized, record_metadata_instance):
t = TestCase()
t.assertDictEqual(serialized['json'], record_metadata_instance.json)
t.assertEquals(serialized['id'], str(record_metadata_instance.id))
t.assertEquals(serialized['created'].split('Z')[0],
record_metadata_instance.created.isoformat().split('+')[0])
t.assertEquals(serialized['updated'].split('Z')[0],
record_metadata_instance.updated.isoformat().split('+')[0])
t.assertEquals(serialized['version_id'],
record_metadata_instance.version_id)
def compare_models(models_json, format_=None):
# The Prosoul database must only contains the models imported
exported_models_json = fetch_models()
if format_ == 'ossmeter':
exported_models_json = gl2ossmeter(exported_models_json)
elif format_ == 'alambic':
exported_models_json = gl2alambic(exported_models_json)
test = TestCase()
test.maxDiff = None
test.assertDictEqual(models_json, exported_models_json)
logging.info("Check completed")
def test_zonecreateview_post_granted(client, tenant, mock_create_zone,
zone_name):
response = client.post(reverse('zoneeditor:zone_create'),
data={
'name': zone_name,
'tenants': tenant.pk,
})
TestCase().assertRedirects(response,
'/zones/example.co.uk.',
target_status_code=302)
mock_create_zone.assert_called_with(kind='Native',
name='example.co.uk.',
nameservers=[])
def test_recorddeleteview_post_no_confirm(client_admin,
mock_pdns_delete_record,
signed_record_data_example_com):
response = client_admin.post(reverse('zoneeditor:zone_record_delete',
kwargs={'zone': 'example.com.'}),
data={
'identifier':
signed_record_data_example_com,
'confirm': 'false',
})
TestCase().assertRedirects(response,
'/zones/example.com./records',
fetch_redirect_response=False)
mock_pdns_delete_record.assert_not_called()
def test_non_ascii_message(self):
try:
self.explode_with_unicode_message()
except ValueError:
err = sys.exc_info()
else:
self.fail()
self.exml_result._add_tb_to_test(TestCase('fail'), self.result_element,
err)
output = self.write_element(self.result_element)
self.assert_(output)
def test_recorddeleteview_granted(client, mock_pdns_delete_record,
record_data):
response = client.post(reverse('zoneeditor:zone_record_delete',
kwargs={'zone': 'example.com.'}),
data={
'identifier': record_data,
'confirm': 'true',
})
TestCase().assertRedirects(response,
'/zones/example.com./records',
fetch_redirect_response=False)
mock_pdns_delete_record.assert_called_once_with('example.com.',
'www.example.com.', 'A',
'1.1.1.1')
def __init__(self, purpose_price, users):
self.test_case = TestCase()
self.purpose_price = purpose_price
def create_account(number):
account = Account(user=User.objects.create_user(
get_username(number), '*****@*****.**', 'qwerty12'))
account.save()
return account
for key in users:
create_account(key)
Funds.objects.create(owner=get_account(1),
purpose='TestParty',
purpose_price=self.purpose_price)
def _run_test(serializer_cls, model_cls, sql_queries=1) -> ReturnList:
"""
Boilerplate for running the tests
:return: the serializer data to assert one
"""
print(
f'Running test with serializer "{serializer_cls.__name__}" and model {model_cls.__name__}'
)
case = TestCase()
with case.assertNumQueries(sql_queries):
prefetched_queryset = prefetch(model_cls.objects.all(), serializer_cls)
serializer_instance = serializer_cls(instance=prefetched_queryset,
many=True)
print("Data returned:")
pprint_result(serializer_instance.data)
return serializer_instance.data
def test_recordcreateview_post_granted(client, mock_create_record):
response = client.post(reverse('zoneeditor:zone_record_create',
kwargs={'zone': 'example.com.'}),
data={
'name': 'mail.anexample.com.example.com.',
'rtype': 'MX',
'ttl': 300,
'content': '0 example.org.',
})
TestCase().assertRedirects(response,
'/zones/example.com.',
fetch_redirect_response=False)
mock_create_record.assert_called_once_with(
zone='example.com.',
name='mail.anexample.com.example.com.',
rtype='MX',
ttl=300,
content='0 example.org.',
)
def __init__(self):
self.test_case = TestCase()
self.message = "Default message"
def create_account(number):
account = Account(user=User.objects.create_user(
get_username(number), '*****@*****.**', 'qwerty12'))
account.save()
return account
users = [1, 2]
for key in users:
create_account(key)
self.funds = Funds.objects.create(owner=get_account(1),
purpose='TestParty',
purpose_price=10.0)
self.due = Due.objects.create(funds=self.funds,
account=get_account(1),
for_account=get_account(2),
amount=20)
def assertOrcidIdentityEqual(serialized,
orcid_identity_instance,
has_token=False):
t = TestCase()
t.assertEquals(serialized['id'], orcid_identity_instance.id)
t.assertEquals(serialized['orcid_value'],
str(orcid_identity_instance.orcid_value))
t.assertEquals(serialized['useridentity_user_id'],
orcid_identity_instance.useridentity_user_id)
t.assertEquals(serialized['client_id'],
str(orcid_identity_instance.client_id))
t.assertDictEqual(serialized['extra_data'],
orcid_identity_instance.extra_data)
t.assertEquals(serialized['user'], orcid_identity_instance.user.id)
if has_token:
try:
plain = orcid_identity_instance.remote_token.access_token_plain
except ObjectDoesNotExist:
plain = None
t.assertEquals(serialized['token'], plain)
def setUpTestData(cls):
cls.Client = TestCase()
cls.user1 = User.objects.create_user('test_user1',
email='*****@*****.**',
password='******')
cls.user2 = User.objects.create_user('test_user2',
email='*****@*****.**',
password='******')
cls.device2 = Device.objects.create(device_id=2,
name='test_device1',
user=cls.user1)
cls.device3 = Device.objects.create(device_id=3,
name='test_device2',
user=cls.user2)
cls.device4 = Device.objects.create(device_id=4,
name='test_device3',
user=cls.user1,
is_active=False)
cls.device5 = Device.objects.create(device_id=5,
name='test_device3',
user=cls.user2)
def db(request, _django_db_setup, _django_cursor_wrapper):
"""Require a django test database
This database will be setup with the default fixtures and will
have the transaction management disabled. At the end of the test
the transaction will be rolled back to undo any changes to the
database. This is more limited then the ``transaction_db``
resource but faster.
If both this and ``transaction_db`` are requested then the
database setup will behave as only ``transaction_db`` was
requested.
"""
if ('transactional_db' not in request.funcargnames
and 'live_server' not in request.funcargnames
and not is_django_unittest(request.node)):
from django.test import TestCase
_django_cursor_wrapper.enable()
case = TestCase(methodName='__init__')
case._pre_setup()
request.addfinalizer(_django_cursor_wrapper.disable)
request.addfinalizer(case._post_teardown)
def test_case():
return TestCase('run')
def response_is_html(response, title=None):
test = TestCase()
test.assertTrue(response.content.startswith(b'<!DOCTYPE html>'))
if title is not None:
test.assertContains(response, '<title>%s</title>' % (title,))
test.assertTrue(response.content.endswith(b'</html>'))
def error_code_test(errors, expect_flag, code):
errors = list(errors)
for error in errors:
if error.code == code:
if expect_flag:
return True
else:
raise ValueError("Code %r found in %r, did not expect it" % (code, errors))
if expect_flag:
raise ValueError("Code %r not found in %r, did expect it" % (code, errors))
return True
def error_exists(errors, code):
return error_code_test(errors, True, code)
def error_does_not_exist(errors, code):
return error_code_test(errors, False, code)
def very_recently(datetime, how_recently=1):
return (abs(datetime - now()).total_seconds() < how_recently)
_test_case = TestCase('setUp') # gotta pass something to the ctor.
assert_contains = _test_case.assertContains
assert_not_contains = _test_case.assertNotContains
# Copyright (C) 2019 The Software Heritage developers
# See the AUTHORS file at the top-level directory of this distribution
# License: GNU Affero General Public License version 3, or any later version
# See top-level LICENSE file for more information
# https://github.com/pytest-dev/pytest-django/pull/709 proposes a more
# generic way to expose all asserts but it makes mypy unhappy.
# So explicitly expose the assertions we need for swh-web tests to
# avoid mypy errors
"""
Expose some Django assertions to be used with pytest
"""
from django.test import TestCase
_test_case = TestCase("run")
assert_template_used = _test_case.assertTemplateUsed
assert_contains = _test_case.assertContains
assert_not_contains = _test_case.assertNotContains
def test_zonedeleteview_post_unauthenicated(client):
url = reverse('zoneeditor:zone_delete')
response = client.post(url)
TestCase().assertRedirects(response, f'/accounts/login/?next={url}')
def method(self, *args, **kwargs):
try:
testcase = self._testcase
except AttributeError:
testcase = self._testcase = TestCase()
return func(testcase, *args, **kwargs)
"""
Dynamically load all Django assertion cases and expose them for importing.
"""
from functools import wraps
from django.test import (TestCase, SimpleTestCase, LiveServerTestCase,
TransactionTestCase)
test_case = TestCase('run')
def _wrapper(name):
func = getattr(test_case, name)
@wraps(func)
def assertion_func(*args, **kwargs):
return func(*args, **kwargs)
return assertion_func
__all__ = []
assertions_names = set()
assertions_names.update(
set(attr for attr in vars(TestCase) if attr.startswith('assert')),
set(attr for attr in vars(SimpleTestCase) if attr.startswith('assert')),
set(attr for attr in vars(LiveServerTestCase)
if attr.startswith('assert')),
set(attr for attr in vars(TransactionTestCase)
if attr.startswith('assert')),
)
from django.test import TestCase _test_case = TestCase() assert_contains = _test_case.assertContains assert_not_contains = _test_case.assertNotContains
def test_recorddeleteview_get_unauthenicated(client):
url = reverse('zoneeditor:zone_record_delete',
kwargs={'zone': 'example.com.'})
response = client.get(url)
TestCase().assertRedirects(response, f'/accounts/login/?next={url}')
