def test_contact_by_campaign_filtering(self) -> None:
self.set_tenant(0)
user = self.users[0]
first_contact = Contact.objects.create(email='*****@*****.**', first_name='First', last_name='Smith')
second_contact = Contact.objects.create(email='*****@*****.**', first_name='Second', last_name='Smith')
Contact.objects.create(email='*****@*****.**', first_name='Third', last_name='Smith')
fourth_contact = Contact.objects.create(email='*****@*****.**', first_name='Fourth', last_name='Smith')
first_campaign = Campaign.objects.create(name='first campaign for filtering test', owner=user)
second_campaign = Campaign.objects.create(name='second campaign for filtering test', owner=user)
Participation.objects.bulk_create([
Participation(campaign=first_campaign, contact=first_contact),
Participation(campaign=second_campaign, contact=second_contact),
Participation(campaign=first_campaign, contact=fourth_contact),
Participation(campaign=second_campaign, contact=fourth_contact),
])
t_client = TenantClient(self.get_current_tenant())
t_client.handler = ForceAuthClientHandler(enforce_csrf_checks=False)
t_client.handler._force_user = user
self.assertTrue(t_client.login(username=user.username, password='******'), 'Test user was not logged in')
url = reverse.reverse('api:contacts-list')
with modify_settings(ALLOWED_HOSTS={'append': self.get_current_tenant().domain_url}):
query = '?campaigns__in=%s' % ','.join(map(str, [first_campaign.id, second_campaign.id]))
response = t_client.get(urljoin(url, query))
self.assertEqual(response.status_code, status.HTTP_200_OK, str(response.content))
contacts_data = response.data
self.assertEqual(3, len(contacts_data))
self.assertSetEqual({first_contact.id, second_contact.id, fourth_contact.id},
{c['id'] for c in contacts_data})
with modify_settings(ALLOWED_HOSTS={'append': self.get_current_tenant().domain_url}):
query = '?campaigns=' + ','.join(map(str, [first_campaign.id, second_campaign.id]))
response = t_client.get(urljoin(url, query))
self.assertEqual(response.status_code, status.HTTP_200_OK, str(response.content))
contacts_data = response.data
self.assertEqual(1, len(contacts_data))
self.assertEqual(fourth_contact.id, contacts_data[0]['id'])
with modify_settings(ALLOWED_HOSTS={'append': self.get_current_tenant().domain_url}):
query = '?campaigns=%s' % second_campaign.id
response = t_client.get(urljoin(url, query))
self.assertEqual(response.status_code, status.HTTP_200_OK, str(response.content))
contacts_data = response.data
self.assertEqual(1, len(contacts_data))
self.assertEqual(second_contact.id, contacts_data[0]['id'])
def render_to_response(self, context, **response_kwargs):
self.response_class.modify_settings = modify_settings(
MENU_ITEMS={
"append": [(
"...",
[
(_("Edit"),
reverse("plan-edit", args=[self.object.pk])),
(_("Clone"),
reverse("plans-clone", args=[self.object.pk])),
(
_("History"),
"/admin/testplans/testplan/%d/history/" %
self.object.pk,
),
("-", "-"),
(
_("Object permissions"),
reverse(
"admin:testplans_testplan_permissions",
args=[self.object.pk],
),
),
("-", "-"),
(
_("Delete"),
reverse(
"admin:testplans_testplan_delete",
args=[self.object.pk],
),
),
],
)]
})
return super().render_to_response(context, **response_kwargs)
def test_bulk_post_participation(self) -> None:
self.set_tenant(0)
user = self.users[0]
first_contact = Contact.objects.create(email='*****@*****.**', first_name='First', last_name='Smith')
second_contact = Contact.objects.create(email='*****@*****.**', first_name='Second', last_name='Smith')
campaign = Campaign.objects.create(name='cool campaign', owner=user)
t_client = TenantClient(self.get_current_tenant())
t_client.handler = ForceAuthClientHandler(enforce_csrf_checks=False)
t_client.handler._force_user = user
self.assertTrue(t_client.login(username=user.username, password='******'), 'Test user was not logged in')
url = reverse.reverse('api:campaigns-contacts-list', args=[campaign.pk, ])
with modify_settings(ALLOWED_HOSTS={'append': self.get_current_tenant().domain_url}):
response = t_client.post(url,
json.dumps([
dict(contact=first_contact.id),
dict(contact=second_contact.id),
]),
content_type='application/json',
)
self.assertEqual(response.status_code, status.HTTP_201_CREATED, str(response.content))
self.assertEqual(2, Participation.objects.filter(
campaign=campaign,
contact_id__in=(first_contact.id, second_contact.id,),
).count())
contacts = campaign.contacts.all()
self.assertListEqual([first_contact, second_contact, ], list(contacts))
def test_middleware_handled_view_exception_success(client, test_spans):
"""
When an exception is raised in a view and then handled
Only the culprit span contains error properties
"""
with modify_settings(
**(
dict(MIDDLEWARE={"append": "tests.contrib.django.middleware.HandleErrorMiddlewareSuccess"})
if django.VERSION >= (2, 0, 0)
else dict(MIDDLEWARE_CLASSES={"append": "tests.contrib.django.middleware.HandleErrorMiddlewareSuccess"})
)
):
assert client.get("/error-500/").status_code == 200
error_spans = list(test_spans.filter_spans(error=1))
# There should be 1 span flagged as erroneous:
# - The view span which wraps the original error
assert len(error_spans) == 1
# Test the root span
root_span = test_spans.get_root_span()
assert root_span.error == 0
assert root_span.get_tag(errors.ERROR_STACK) is None
assert root_span.get_tag(errors.ERROR_MSG) is None
assert root_span.get_tag(errors.ERROR_TYPE) is None
# Test the view span (where the exception is generated)
view_span = list(test_spans.filter_spans(name="django.view"))
assert len(view_span) == 1
view_span = view_span[0]
assert view_span.error == 1
# Make sure the message is somewhere in the stack trace
assert "Error 500" in view_span.get_tag("error.stack")
def test_email_stage_template_validation(self) -> None:
self.set_tenant(0)
user = self.users[0]
campaign = Campaign.objects.create(name='some campaign', owner=user)
step = Step.objects.create(campaign=campaign, start=datetime.time(9, 45), end=datetime.time(18, 30))
t_client = TenantClient(self.get_current_tenant())
t_client.handler = ForceAuthClientHandler(enforce_csrf_checks=False)
t_client.handler._force_user = user
self.assertTrue(t_client.login(username=user.username, password='******'), 'Test user was not logged in')
url = reverse.reverse('api:campaigns-steps-email-list', args=[campaign.pk, step.pk, ])
with modify_settings(ALLOWED_HOSTS={'append': self.get_current_tenant().domain_url}):
response = t_client.post(url,
json.dumps(dict(
subject='Hello good fellow',
html_content='Some invalid email template to {{First name}}!',
)),
content_type='application/json',
)
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST, str(response.content))
error_data = response.data
self.assertTrue("Could not parse" in error_data['html_content'][0])
def test_process_request(self):
with modify_settings(
MIDDLEWARE_CLASSES={'append': [
'django.contrib.sites.middleware.CurrentSiteMiddleware',
'hacs.middleware.DynamicRouteMiddleware',
'hacs.middleware.FirewallMiddleware'
]}
):
browser = Client()
response = browser.get('/admin/')
# AS anonymous user so urlconf module should default site
expected_module = get_generated_urlconf_module(get_generated_urlconf_file(TEST_ROUTE_NAME))
self.assertEqual(expected_module, response.wsgi_request.urlconf)
# As anonymous user, so no direct access, should be redirected to login page
self.assertEqual(302, response.status_code)
browser.login(username=TEST_USER_NAME, password=TEST_USER_PASSWORD)
response = browser.get('/admin/')
# Authenticated admin user should have access
self.assertEqual(200, response.status_code)
# User has dedicated urlconf module, so it should be assigned
expected_module = get_generated_urlconf_module(get_generated_urlconf_file(TEST_USER_ROUTE_NAME))
self.assertEqual(expected_module, response.wsgi_request.urlconf)
ContentTypeRoutingTable.objects.filter(content_type=ContentType.objects.get_for_model(UserModel),
object_id=response.wsgi_request.user.id).delete()
# Make Session works, as we remove user's route but still should same
response = browser.get('/admin/')
self.assertEqual(expected_module, response.wsgi_request.urlconf)
self.assertEqual(expected_module, response.wsgi_request.session['settings']['urlconf'])
# Make sure caching works
browser.logout()
browser.login(username=TEST_USER_NAME, password=TEST_USER_PASSWORD)
response = browser.get('/admin/')
self.assertEqual(expected_module, response.wsgi_request.urlconf)
# Now we are cleaning session and cache as well, so we expect urlconf should come group
browser.logout()
self.cache.clear()
browser.login(username=TEST_USER_NAME, password=TEST_USER_PASSWORD)
response = browser.get('/admin/')
expected_module = get_generated_urlconf_module(get_generated_urlconf_file(TEST_GROUP_ROUTE_NAME))
self.assertEqual(expected_module, response.wsgi_request.urlconf)
ContentTypeRoutingTable.objects.filter(content_type=ContentType.objects.get_for_model(Group)).delete()
# Now we are cleaning session and cache as well, group's route also clened
# so we expect urlconf should be like site urlconf
browser.logout()
self.cache.clear()
browser.login(username=TEST_USER_NAME, password=TEST_USER_PASSWORD)
response = browser.get('/admin/')
expected_module = get_generated_urlconf_module(get_generated_urlconf_file(TEST_ROUTE_NAME))
self.assertEqual(expected_module, response.wsgi_request.urlconf)
def setUp(self):
Group.objects.bulk_create(
[Group(name=name) for name in ['group1', 'group2', 'group3']])
class GroupSerializer(ModelSerializer):
class Meta:
model = Group
fields = '__all__'
class GroupViewSet(ModelViewSet):
queryset = Group.objects.all()
serializer_class = GroupSerializer
permission_classes = [DjangoObjectPermissions]
filter_backends = [ChemoPermissionsFilter]
self.user = User.objects.create_user(username='******',
password='******')
self.perm = Permission.objects.create(
content_type=get_content_type(Group),
name='Can view group',
codename='view_group')
self.access_rule = AccessRule.objects.create(
ctype_source=get_content_type(User),
ctype_target=get_content_type(Group),
is_active=True,
relation_types=[{
'GROUPS': None
}])
self.view = GroupViewSet
self.patched_settings = modify_settings(
AUTHENTICATION_BACKENDS={'append': self.backend})
self.patched_settings.enable()
def add_new_language():
return modify_settings(
LANGUAGES={"append": [("foo-br", "Test locale")]},
LOCALE_PATHS={
"append": os.path.join(os.path.dirname(__file__), "..", "locale")
},
)
def disable_remote_auth(test):
test = modify_settings(MIDDLEWARE_CLASSES={
'remove': [
'common_dibbs.auth.CentralAuthenticationMiddleware',
],
})(test)
return test
def test_bulk_delete_participation(self) -> None:
self.set_tenant(0)
user = self.users[0]
first_contact = Contact.objects.create(email='*****@*****.**', first_name='First', last_name='Smith')
second_contact = Contact.objects.create(email='*****@*****.**', first_name='Second', last_name='Smith')
campaign = Campaign.objects.create(name='cool campaign', owner=user)
Participation.objects.bulk_create([
Participation(campaign=campaign, contact=first_contact),
Participation(campaign=campaign, contact=second_contact),
])
t_client = TenantClient(self.get_current_tenant())
t_client.handler = ForceAuthClientHandler(enforce_csrf_checks=False)
t_client.handler._force_user = user
self.assertTrue(t_client.login(username=user.username, password='******'), 'Test user was not logged in')
url = reverse.reverse('api:campaigns-contacts-list', args=[campaign.pk, ])
with modify_settings(ALLOWED_HOSTS={'append': self.get_current_tenant().domain_url}):
response = t_client.delete(urljoin(url, '?contact__in=%s' % str(first_contact.id)),
content_type='application/json',
)
self.assertEqual(response.status_code, status.HTTP_204_NO_CONTENT, str(response.content))
participation = Participation.objects.get(campaign=campaign)
self.assertEqual(second_contact, participation.contact)
def _modify_settings(self):
with modify_settings(MIDDLEWARE={
'remove': ['idempotency_key.middleware.IdempotencyKeyMiddleware'],
'append': ['idempotency_key.middleware.ExemptIdempotencyKeyMiddleware'],
}):
yield
def wrapper(*args, **kwargs):
with modify_settings(
MIDDLEWARE={
"remove": ["idempotency_key.middleware.IdempotencyKeyMiddleware"],
"append": ["idempotency_key.middleware.ExemptIdempotencyKeyMiddleware"],
}
):
return func(*args, **kwargs)
def render_to_response(self, context, **response_kwargs):
self.response_class.modify_settings = modify_settings(
MENU_ITEMS={
'append': [('...', [
(_('Edit'), reverse('bugs-edit', args=[self.object.pk])),
])]
})
return super().render_to_response(context, **response_kwargs)
def scoped_client():
scope_full_access = "super-access"
scoped_client = ScopedClient((scope_full_access, ))
with modify_settings(
MIDDLEWARE={
"append": "tests.integration.conftest.AddScopesMiddleware"
}), override_settings(SCOPE_FULL_ACCESS=scope_full_access):
yield scoped_client
def setUp(self):
self.patched_settings = modify_settings(
AUTHENTICATION_BACKENDS={'append': self.backend}, )
self.patched_settings.enable()
self.user = User.objects.create_user(**self.user_credentials)
self.superuser = User.objects.create_superuser(
email='*****@*****.**',
password='******',
)
def test_authtoken_can_be_imported_when_not_included_in_installed_apps(
self):
import rest_framework.authtoken.models
with modify_settings(
INSTALLED_APPS={'remove': 'rest_framework.authtoken'}):
importlib.reload(rest_framework.authtoken.models)
# Set the proxy and abstract properties back to the version,
# where authtoken is among INSTALLED_APPS.
importlib.reload(rest_framework.authtoken.models)
def setUp(self):
self.patched_settings = modify_settings(
AUTHENTICATION_BACKENDS={'append': self.backend},
MIDDLEWARE_CLASSES={'append': [
'django.contrib.sessions.middleware.SessionMiddleware',
'django.contrib.auth.middleware.AuthenticationMiddleware',
self.middleware,
]},
)
self.patched_settings.enable()
def _modify_settings(self):
with modify_settings(
MIDDLEWARE=
{
'prepend': ['debug_toolbar.middleware.DebugToolbarMiddleware'],
'append':
['idempotency_key.middleware.IdempotencyKeyMiddleware'],
'remove':
['idempotency_key.middleware.ExemptIdempotencyKeyMiddleware'],
}):
yield
def create_user_with_username(context, username):
context.client = Client()
user = UserFactory.create(username=username, is_staff=False, is_superuser=False)
user.set_password(username)
user.save()
with modify_settings(AUTHENTICATION_BACKENDS={
'prepend': 'django.contrib.auth.backends.ModelBackend',
'remove': ['django_cyverse_auth.authBackends.MockLoginBackend']
}):
context.user = user
context.client.login(username=username, password=username)
def create_user_with_username(context, username):
context.client = Client()
user = UserFactory.create(username=username, is_staff=False, is_superuser=False)
user.set_password(username)
user.save()
with modify_settings(AUTHENTICATION_BACKENDS={
'prepend': 'django.contrib.auth.backends.ModelBackend',
'remove': ['django_cyverse_auth.authBackends.MockLoginBackend']
}):
context.user = user
context.client.login(username=username, password=username)
def wrapper(*args, **kwargs):
with modify_settings(
MIDDLEWARE=
{
"prepend": ["debug_toolbar.middleware.DebugToolbarMiddleware"],
"append":
["idempotency_key.middleware.IdempotencyKeyMiddleware"],
"remove":
["idempotency_key.middleware.ExemptIdempotencyKeyMiddleware"],
}):
with override_settings(DEBUG=True):
return func(*args, **kwargs)
def get(request, case_id):
"""Get the case content"""
# Get the case
try:
test_case = TestCase.objects.select_related(
'author', 'default_tester',
'category', 'category',
'priority', 'case_status').get(case_id=case_id)
except ObjectDoesNotExist:
raise Http404
# Get the test executions
tcrs = test_case.case_run.select_related(
'run', 'tested_by',
'assignee', 'case',
'case', 'status').order_by('run__plan', 'run')
# Render the page
context_data = {
'test_case': test_case,
'test_case_runs': tcrs,
}
url_params = "?case=%d" % test_case.pk
case_edit_url = reverse('testcases-edit', args=[test_case.pk])
test_plan = request.GET.get('from_plan', 0)
if test_plan:
url_params += "&from_plan=%s" % test_plan
case_edit_url += "?from_plan=%s" % test_plan
with modify_settings(
MENU_ITEMS={'append': [
('...', [
(
_('Edit'),
case_edit_url
),
(
_('Clone'),
reverse('testcases-clone') + url_params
),
(
_('History'),
"/admin/testcases/testcase/%d/history/" % test_case.pk
),
('-', '-'),
(
_('Delete'),
reverse('admin:testcases_testcase_delete', args=[test_case.pk])
)])]}):
return render(request, 'testcases/get.html', context_data)
def test_middleware_trace_error_500(client, test_spans):
# ensures exceptions generated by views are traced
with modify_settings(**(dict(
MIDDLEWARE={
"append":
"tests.contrib.django.middleware.CatchExceptionMiddleware"
}) if django.VERSION >= (2, 0, 0) else dict(
MIDDLEWARE_CLASSES={
"append":
"tests.contrib.django.middleware.CatchExceptionMiddleware"
}))):
assert client.get("/error-500/").status_code == 500
error_spans = list(test_spans.filter_spans(error=1))
# There should be 3 spans flagged as errors
# 1. The view span which wraps the original error
# 2. The root span which should just be flagged as an error (no exception info)
# 3. The middleware span that catches the exception and converts it to a 500
assert len(error_spans) == 3
# Test the root span
span = test_spans.get_root_span()
assert span.error == 1
assert span.get_tag("http.status_code") == "500"
assert span.get_tag(http.URL) == "http://testserver/error-500/"
if django.VERSION >= (2, 2, 0):
assert span.resource == "GET ^error-500/$"
else:
assert span.resource == "GET tests.contrib.django.views.error_500"
assert span.get_tag(errors.ERROR_MSG) is None
assert span.get_tag(errors.ERROR_TYPE) is None
assert span.get_tag(errors.ERROR_STACK) is None
# Test the view span (where the exception is generated)
view_span = list(test_spans.filter_spans(name="django.view"))
assert len(view_span) == 1
view_span = view_span[0]
assert view_span.error == 1
# Make sure the message is somewhere in the stack trace
assert "Error 500" in view_span.get_tag(errors.ERROR_STACK)
# Test the catch exception middleware
res = "tests.contrib.django.middleware.CatchExceptionMiddleware.process_exception"
mw_span = list(test_spans.filter_spans(resource=res))[0]
assert mw_span.error == 1
# Make sure the message is somewhere in the stack trace
assert "Error 500" in view_span.get_tag(errors.ERROR_STACK)
assert mw_span.get_tag(errors.ERROR_MSG) is not None
assert mw_span.get_tag(errors.ERROR_TYPE) is not None
assert mw_span.get_tag(errors.ERROR_STACK) is not None
def test_third_engine_not_debug(self):
engine3 = {
'NAME': 'notdebug',
'BACKEND': 'django.template.backends.django.DjangoTemplates',
'DIRS': ['templates3'], # where the tests put things.
}
modified_settings = modify_settings(TEMPLATES={'append': [engine3]})
modified_settings.enable()
self.addCleanup(modified_settings.disable)
self.make_template('Hello')
with self.assert_plugin_disabled(
"Template debugging must be enabled in settings."):
self.run_django_coverage()
def test_0005_group_views(self):
module = import_module('boardinghouse.migrations.0005_group_views')
# Performing this migration operation when preconditions for table move are not met
# should be idempotent, and should not throw an exception.
module.move_existing_to_schemata(apps, connection.schema_editor())
# Test for coverage purposes
module.noop(apps, connection.schema_editor())
# Test that we get the expected values from the helper method, including when the contrib.groups
# app has been installed.
self.assertEqual([User.groups.through, User.user_permissions.through],
module.private_auth_models(apps))
with modify_settings(PRIVATE_MODELS={'append': ['auth.groups']}):
self.assertEqual(
[User.groups.through, User.user_permissions.through, Group],
module.private_auth_models(apps))
self.assertEqual([User.groups.through, User.user_permissions.through],
module.private_auth_models(apps))
# We need to test that we will move an existing table in public.X_X to <all-schemata>.X-X
# Lets get rid of the views that normally get created:
module.drop_views(apps, connection.schema_editor())
# And move the template tables into public.
with connection.cursor() as cursor:
for model in module.private_auth_models(apps):
db_table = model._meta.db_table
cursor.execute(
'ALTER TABLE __template__.{0} SET SCHEMA public'.format(
db_table))
module.move_existing_to_schemata(apps, connection.schema_editor())
# Now re-create the views.
module.create_views(apps, connection.schema_editor())
# Now test that user-group relationships are not stored unless a schema is active.
user = User.objects.create_user(username='******',
password='******')
group = Group.objects.create(name='Group')
user.groups.add(group)
self.assertEqual(0, user.groups.count())
Schema.objects.create(schema='a', name='a').activate()
user.groups.add(group)
self.assertEqual(1, user.groups.count())
def test_third_engine_not_debug(self):
from django.test import modify_settings
engine3 = {
'NAME': 'notdebug',
'BACKEND': 'django.template.backends.django.DjangoTemplates',
'DIRS': ['templates3'], # where the tests put things.
}
modified_settings = modify_settings(TEMPLATES={'append': [engine3]})
modified_settings.enable()
self.addCleanup(modified_settings.disable)
self.make_template('Hello')
msg = "Template debugging must be enabled in settings."
with self.assertRaisesRegexp(DjangoTemplatePluginException, msg):
self.run_django_coverage()
def test_create_schema_without_contrib_template_installed(self):
User.objects.create_superuser(
username="******",
password="******",
email="*****@*****.**"
)
self.client.login(username='******', password='******')
# Wow. This is a bit of a PITA to test. We can't just unset the settings, because django.contrib.admin
# doesn't consult INSTALLED_APPS when it goes to render stuff, so it gets a KeyError, because a model
# from a non-installed-app is found.
TemplateAdmin = admin.site._registry[SchemaTemplate].__class__
admin.site.unregister(SchemaTemplate)
with modify_settings(INSTALLED_APPS={'remove': ['boardinghouse.contrib.template']}):
response = self.client.get(reverse('admin:boardinghouse_schema_add'))
self.assertFalse('clone_schema' in response.context['adminform'].form.fields)
admin.site.register(SchemaTemplate, TemplateAdmin)
def setUp(self):
super(MultipleEngineTests, self).setUp()
engine = {
'NAME': 'other',
'BACKEND': 'django.template.backends.django.DjangoTemplates',
'DIRS': ['templates2'], # where the tests put things.
'OPTIONS': {
'debug': True,
},
}
modified_settings = modify_settings(TEMPLATES={'append': [engine]})
modified_settings.enable()
self.addCleanup(modified_settings.disable)
self.template_directory = 'templates2'
def create_admin_and_two_regular_users(context):
context.client = Client()
user = UserFactory.create(username='******', is_staff=True, is_superuser=True)
user.set_password('lenards')
user.save()
with modify_settings(AUTHENTICATION_BACKENDS={
'prepend': 'django.contrib.auth.backends.ModelBackend',
'remove': ['django_cyverse_auth.authBackends.MockLoginBackend']
}):
context.admin_user = user
context.client.login(username='******', password='******')
user_1 = UserFactory.create(username='******')
context.user_1 = user_1
user_2 = UserFactory.create(username='******')
context.user_2 = user_2
def step_impl(context):
context.client = Client()
user = UserFactory.create(username='******', is_staff=True, is_superuser=True)
user.set_password('lenards')
user.save()
with modify_settings(AUTHENTICATION_BACKENDS={
'prepend': 'django.contrib.auth.backends.ModelBackend',
'remove': ['django_cyverse_auth.authBackends.MockLoginBackend']
}):
context.admin_user = user
context.client.login(username='******', password='******')
user_1 = UserFactory.create(username='******')
context.user_1 = user_1
user_2 = UserFactory.create(username='******')
context.user_2 = user_2
def render_to_response(self, context, **response_kwargs):
self.response_class.modify_settings = modify_settings(
MENU_ITEMS={
'append': [(
'...', [(_('Edit'),
reverse('testcases-edit', args=[self.object.pk])),
(_('Clone'), reverse('testcases-clone') +
"?case=%d" % self.object.pk),
(_('History'),
"/admin/testcases/testcase/%d/history/" %
self.object.pk), ('-', '-'),
(_('Delete'),
reverse('admin:testcases_testcase_delete',
args=[self.object.pk]))])]
})
return super().render_to_response(context, **response_kwargs)
def test_create_schema_without_contrib_template_installed(self):
User.objects.create_superuser(username="******",
password="******",
email="*****@*****.**")
self.client.login(username='******', password='******')
# Wow. This is a bit of a PITA to test. We can't just unset the settings, because django.contrib.admin
# doesn't consult INSTALLED_APPS when it goes to render stuff, so it gets a KeyError, because a model
# from a non-installed-app is found.
TemplateAdmin = admin.site._registry[SchemaTemplate].__class__
admin.site.unregister(SchemaTemplate)
with modify_settings(
INSTALLED_APPS={'remove': ['boardinghouse.contrib.template']}):
response = self.client.get(
reverse('admin:boardinghouse_schema_add'))
self.assertFalse(
'clone_schema' in response.context['adminform'].form.fields)
admin.site.register(SchemaTemplate, TemplateAdmin)
def test_eventlog_fires():
from django.test import modify_settings
with modify_settings(INSTALLED_APPS={
'remove': ['jackfrost'],
'append': ['pinax.eventlog']
}):
reader = URLReader(urls=[reverse('content_b')])
read_results = tuple(reader())
writer = URLWriter(data=read_results)
with sortof_tidying_signal(signal=write_page):
output = writer.write(read_results[0])
assert Log.objects.count() == 1
logged = Log.objects.get()
assert logged.action == 'URL "/content/a/b/" written'
assert 'ReadResult' in logged.extra
assert 'WriteResult' in logged.extra
assert logged.extra['WriteResult']['md5'] == 'f8ee7c48dfd7f776b3d011950a5c02d1'
def setUp(self):
super(MultipleEngineTests, self).setUp()
# Move to module imports once we drop support for Django < 1.7
from django.test import modify_settings
engine = {
'NAME': 'other',
'BACKEND': 'django.template.backends.django.DjangoTemplates',
'DIRS': ['templates2'], # where the tests put things.
'OPTIONS': {
'debug': True,
},
}
modified_settings = modify_settings(TEMPLATES={'append': [engine]})
modified_settings.enable()
self.addCleanup(modified_settings.disable)
self.template_directory = 'templates2'
def test_eventlog_fires():
from django.test import modify_settings
with modify_settings(INSTALLED_APPS={
'remove': ['jackfrost'],
'append': ['pinax.eventlog']
}):
reader = URLReader(urls=[reverse('content_b')])
read_results = tuple(reader())
writer = URLWriter(data=read_results)
with sortof_tidying_signal(signal=write_page):
output = writer.write(read_results[0])
assert Log.objects.count() == 1
logged = Log.objects.get()
assert logged.action == 'URL "/content/a/b/" written'
assert 'ReadResult' in logged.extra
assert 'WriteResult' in logged.extra
assert logged.extra['WriteResult'][
'md5'] == 'f8ee7c48dfd7f776b3d011950a5c02d1'
def get(request, case_id): # pylint: disable=missing-permission-required
"""Get the case content"""
# Get the case
try:
test_case = TestCase.objects.select_related(
'author', 'default_tester',
'category', 'category',
'priority', 'case_status').get(case_id=case_id)
except ObjectDoesNotExist:
raise Http404
# Get the test executions
tcrs = test_case.case_run.select_related(
'run', 'tested_by',
'assignee', 'case',
'case', 'status').order_by('run__plan', 'run')
# Render the page
context_data = {
'test_case': test_case,
'executions': tcrs,
}
with modify_settings(
MENU_ITEMS={'append': [
('...', [
(
_('Edit'),
reverse('testcases-edit', args=[test_case.pk])
),
(
_('Clone'),
reverse('testcases-clone') + "?case=%d" % test_case.pk
),
(
_('History'),
"/admin/testcases/testcase/%d/history/" % test_case.pk
),
('-', '-'),
(
_('Delete'),
reverse('admin:testcases_testcase_delete', args=[test_case.pk])
)])]}):
return render(request, 'testcases/get.html', context_data)
def test_0005_group_views(self):
module = import_module('boardinghouse.migrations.0005_group_views')
# Performing this migration operation when preconditions for table move are not met
# should be idempotent, and should not throw an exception.
module.move_existing_to_schemata(apps, connection.schema_editor())
# Test for coverage purposes
module.noop(apps, connection.schema_editor())
# Test that we get the expected values from the helper method, including when the contrib.groups
# app has been installed.
self.assertEqual([User.groups.through, User.user_permissions.through], module.private_auth_models(apps))
with modify_settings(PRIVATE_MODELS={'append': ['auth.groups']}):
self.assertEqual([
User.groups.through, User.user_permissions.through, Group
], module.private_auth_models(apps))
self.assertEqual([User.groups.through, User.user_permissions.through], module.private_auth_models(apps))
# We need to test that we will move an existing table in public.X_X to <all-schemata>.X-X
# Lets get rid of the views that normally get created:
module.drop_views(apps, connection.schema_editor())
# And move the template tables into public.
with connection.cursor() as cursor:
for model in module.private_auth_models(apps):
db_table = model._meta.db_table
cursor.execute('ALTER TABLE __template__.{0} SET SCHEMA public'.format(db_table))
module.move_existing_to_schemata(apps, connection.schema_editor())
# Now re-create the views.
module.create_views(apps, connection.schema_editor())
# Now test that user-group relationships are not stored unless a schema is active.
user = User.objects.create_user(username='******', password='******')
group = Group.objects.create(name='Group')
user.groups.add(group)
self.assertEqual(0, user.groups.count())
Schema.objects.create(schema='a', name='a').activate()
user.groups.add(group)
self.assertEqual(1, user.groups.count())
def setUp(self):
self.patched_settings = modify_settings(
AUTHENTICATION_BACKENDS={'append': self.backend},
)
self.patched_settings.enable()
self.create_users()
def test_process_request(self):
with modify_settings(
MIDDLEWARE_CLASSES={'append': [
'django.contrib.sites.middleware.CurrentSiteMiddleware',
'hacs.middleware.DynamicRouteMiddleware',
'hacs.middleware.FirewallMiddleware',
'hacs.middleware.AccessControlMiddleware'
]}
):
browser = Client()
response = browser.get('/tests/content-manager-view/')
fake_request = RequestFactory().request()
fake_request.urlconf = None
fake_request.user = self.user_model_cls.objects.get(**{self.user_model_cls.USERNAME_FIELD: TEST_USER_NAME})
fake_request.site = Site.objects.get(domain=TEST_HOST_NAME)
user_key = get_user_key(fake_request)
# AS anonymous user so urlconf module should default site
expected_module = get_generated_urlconf_module(get_generated_urlconf_file(TEST_ROUTE_NAME))
self.assertEqual(expected_module, response.wsgi_request.urlconf)
# As anonymous user, so forbidden!, @todo: should be redirected to login page?
self.assertEqual(403, response.status_code)
browser.login(username=TEST_USER_NAME, password=TEST_USER_PASSWORD)
response = browser.get('/tests/content-manager-view/')
# Authenticated Editor user should have access
self.assertEqual(200, response.status_code)
# User has dedicated urlconf module, so it should be assigned
expected_module = get_generated_urlconf_module(get_generated_urlconf_file(TEST_USER_ROUTE_NAME))
self.assertEqual(expected_module, response.wsgi_request.urlconf)
ContentTypeRoutingRules.objects.filter(content_type=ContentType.objects.get_for_model(self.user_model_cls),
object_id=response.wsgi_request.user.id).delete()
# Make Session works, as we remove user's route but still should same
response = browser.get('/tests/content-manager-view/')
self.assertEqual(expected_module, response.wsgi_request.urlconf)
self.assertEqual(expected_module, self.cache.get(user_key)['urlconf'])
# Make sure caching works
browser.logout()
browser.login(username=TEST_USER_NAME, password=TEST_USER_PASSWORD)
response = browser.get('/tests/content-manager-view/')
self.assertEqual(expected_module, response.wsgi_request.urlconf)
# Now we are cleaning session and cache as well, so we expect urlconf should come group
browser.logout()
self.cache.clear()
browser.login(username=TEST_USER_NAME, password=TEST_USER_PASSWORD)
response = browser.get('/tests/content-manager-view/')
expected_module = get_generated_urlconf_module(get_generated_urlconf_file(TEST_GROUP_ROUTE_NAME))
self.assertEqual(expected_module, response.wsgi_request.urlconf)
ContentTypeRoutingRules.objects.filter(content_type=ContentType.objects.get_for_model(HacsGroupModel)).delete()
# Now we are cleaning session and cache as well, group's route also cleaned
# so we expect urlconf should be like site urlconf
browser.logout()
self.cache.clear()
browser.login(username=TEST_USER_NAME, password=TEST_USER_PASSWORD)
response = browser.get('/tests/content-manager-view/')
expected_module = get_generated_urlconf_module(get_generated_urlconf_file(TEST_ROUTE_NAME))
self.assertEqual(expected_module, response.wsgi_request.urlconf)
def setUp(self):
self.patched_settings = modify_settings(
AUTHENTICATION_BACKENDS={'append': self.backend},
MIDDLEWARE_CLASSES={'append': self.middleware},
)
self.patched_settings.enable()
