Python django 模块，test() 实例源码
我们从Python开源项目中，提取了以下42个代码示例，用于说明如何使用django.test()。
def test_instance_details_unauthorized(self):
server = self.servers.first()
api.nova.server_get(IsA(http.HttpRequest), server.id)\
.AndRaise(self.exceptions.nova_unauthorized)
self.mox.ReplayAll()
url = reverse('horizon:project:instances:detail',
args=[server.id])
# Avoid the log message in the test
# when unauthorized exception will be logged
logging.disable(logging.ERROR)
res = self.client.get(url)
logging.disable(logging.NOTSET)
self.assertEqual(302, res.status_code)
self.assertEqual(('Location', settings.TESTSERVER +
settings.LOGIN_URL + '?' +
REDIRECT_FIELD_NAME + '=' + url),
res._headers.get('location', None),)
def test_delete_files_or_folders_action_with_mixed_types(self):
# add more files/images so we can test the polymorphic queryset with multiple types
self.create_file(folder=self.src_folder)
self.create_image(folder=self.src_folder)
self.create_file(folder=self.src_folder)
self.create_image(folder=self.src_folder)
self.assertNotEqual(File.objects.count(), 0)
self.assertNotEqual(Image.objects.count(), 0)
url = reverse('admin:filer-directory_listing', args=(self.folder.id,))
folders = []
for f in File.objects.filter(folder=self.folder):
folders.append('file-%d' % (f.id,))
folders.append('folder-%d' % self.sub_folder1.id)
response = self.client.post(url, {
'action': 'delete_files_or_folders',
'post': 'yes',
helpers.ACTION_CHECKBOX_NAME: folders,
})
self.assertEqual(File.objects.filter(folder__in=[self.folder.id, self.sub_folder1.id]).count(), 0)
def test_search_special_characters(self):
"""
Regression test for https://github.com/divio/django-filer/pull/945.
Because of a wrong unquoting function being used, searches with
some "_XX" sequences got unquoted as unicode characters.
For example, "_ec" gets unquoted as u'ì'.
"""
url = reverse('admin:filer-directory_listing',
kwargs={'folder_id': self.parent.id})
# Create a file with a problematic filename
problematic_file = django.core.files.base.ContentFile('some data')
filename = u'christopher_eccleston'
problematic_file.name = filename
self.spam_file = File.objects.create(
owner=self.staff_user, original_filename=filename,
file=problematic_file, folder=self.parent)
# Valid search for the filename, should have one result
response = self.client.get(url, {'q': filename})
item_list = response.context['paginated_items'].object_list
self.assertEqual(len(item_list), 1)
def test_order_by_two_virtual_fields(self):
ca = Category.objects.create(name='foo a', title='test a', title_nl='testje a')
cb = Category.objects.create(name='foo b', title='test b', title_nl='testje b')
Blog.objects.bulk_create([
Blog(title='a', title_nl='d', category=cb),
Blog(title='b', title_nl='c', category=cb),
Blog(title='c', title_nl='b', category=cb),
Blog(title='z', title_nl='a', category=ca),
Blog(title='y', title_nl='b', category=ca),
Blog(title='x', title_nl='c', category=ca)
])
qs = Blog.objects.filter(category__title_nl__contains='test').order_by(
'-category__title_nl',
'-title_nl'
)
self.assertEquals([m.title for m in qs], 'a b c x y z'.split())
def test_reverse(self):
"""Test all code paths through reverse_fallback and reverse_any"""
self.assertEqual(
reverse_fallback('test', reverse, 'not-exists'),
'test',
)
self.assertEqual(
reverse_fallback('test', reverse, 'admin:index'),
'/admin/',
)
self.assertEqual(
reverse_any((
'not-exists',
'admin:index',
)),
'/admin/',
)
with six.assertRaisesRegex(
self,
NoReverseMatch,
"Reverse for any of 'not-exists-1', 'not-exists-2' with"
" arguments '\[\]' and keyword arguments '{}' not found."
):
reverse_any(('not-exists-1', 'not-exists-2'))
def setUpClass(cls):
from django.test.utils import setup_test_environment
from django.core.management import call_command
from django.conf import settings
settings.configure(
INSTALLED_APPS=[
'django.contrib.auth',
'django.contrib.contenttypes',
'lifter.contrib.django',
],
DATABASES={
'default': {'NAME': ':memory:', 'ENGINE': 'django.db.backends.sqlite3'}
},
)
django.setup()
setup_test_environment()
super(DjangoTestCase, cls).setUpClass()
call_command('migrate')
def test_has_perm(self):
user = self.UserModel._default_manager.get(pk=self.user.pk)
self.assertEqual(user.has_perm('auth.test'), False)
user.is_staff = True
user.save()
self.assertEqual(user.has_perm('auth.test'), False)
user.is_superuser = True
user.save()
self.assertEqual(user.has_perm('auth.test'), True)
user.is_staff = True
user.is_superuser = True
user.is_active = False
user.save()
self.assertEqual(user.has_perm('auth.test'), False)
def test_read(self):
value = b'abcd' * 2 ** 20
result = cache.set(b'test-key', value)
self.assertTrue(result)
with cache.read(b'test-key') as reader:
self.assertEqual(reader.read(), value)
try:
with cache.read(b'dne') as reader:
error = False
except KeyError:
error = True
self.assertTrue(error)
def create_test_user(self):
User = get_user_model()
test_users = User.objects.filter(
username='test'
)
if test_users.count() > 0:
self.test_user = test_users[0]
else:
self.test_user = User.objects.create_user(
username='test',
email=''
)
self.test_user.set_password('test')
self.test_user.save()
return ('test', 'test')
# Admin user is the overlord for the system.
#
def test_user_factory(self):
R = Roles.objects.create(rank=6)
P = People.objects.create(firstname='asdf')
U = Users.objects.create(username='adsf', role=R, person=P, is_active=1)
D = VariantsDb.objects.get(filename=settings.DB_TEST)
u = user_factory(U)
self.assertIsInstance(u, User)
self.assertEqual(u.username, U.username)
self.assertGreaterEqual(len(u.databases), 0)
# Add access to test db - it should reflect in User.databases
DbAccess.objects.create(user=U, variants_db=D, is_active=1)
u = user_factory(U)
self.assertGreaterEqual(len(u.databases), 1)
# Make the db inactive - it should get ignored again
D.is_active = 0
D.save()
u = user_factory(U)
self.assertGreaterEqual(len(u.databases), 0)
def _assert_datetime_not_equal(self, datetime_1, datetime_2):
"""
Assert two datetime.datetime values are NOT equal.
This method does NOT compare any division of time smaller than a minute, i.e. seconds and
milliseconds, if present, are not considered in the equality test.
This could also be implemented with datetime.replace() to zero out seconds and microseconds.
Args:
datetime_1 (datetime.datetime): The first (left) value to compare.
datetime_2 (datetime.datetime): The second (right) value to compare.
"""
required_datetime_attributes = ['date', 'hour', 'minute']
datetime_1_has_interface = set(dir(datetime_1)).issuperset(required_datetime_attributes)
datetime_2_has_interface = set(dir(datetime_2)).issuperset(required_datetime_attributes)
if datetime_1_has_interface and datetime_2_has_interface:
self.assertNotEqual(datetime_1.date(), datetime_2.date())
self.assertNotEqual(datetime_1.hour, datetime_2.hour)
self.assertNotEqual(datetime_1.minute, datetime_2.minute)
else:
self.assertNotEqual(datetime_1, datetime_2)
def test_update(self):
"""
Test that an UPDATE statement works correctly in specific cases.
Test that the timestamp field value is unchanged when only auto_now_add is enabled and test
that the timestamp field is automatically updated when only auto_now_update is enabled.
Unfortunately, this test is impossible to isolate from any side effects of a broken INSERT
operation in the timestamp field.
"""
for alias in test_utils.get_db_aliases():
engine = django.db.connections[alias].settings_dict['ENGINE']
with self.subTest(backend=engine):
self._test_update_no_auto(alias)
self._test_update_auto(alias)
def test_proxy_get_real_instance_class(self):
"""
The call to ``get_real_instance()`` also checks whether the returned model is of the correct type.
This unit test guards that this check is working properly. For instance,
proxy child models need to be handled separately.
"""
name = "Item1"
nonproxychild = NonProxyChild.objects.create(name=name)
pb = ProxyBase.objects.get(id=1)
self.assertEqual(pb.get_real_instance_class(), NonProxyChild)
self.assertEqual(pb.get_real_instance(), nonproxychild)
self.assertEqual(pb.name, name)
pbm = ProxyChild.objects.get(id=1)
self.assertEqual(pbm.get_real_instance_class(), NonProxyChild)
self.assertEqual(pbm.get_real_instance(), nonproxychild)
self.assertEqual(pbm.name, name)
def test_parent_link_and_related_name(self):
t = TestParentLinkAndRelatedName(field1="TestParentLinkAndRelatedName")
t.save()
p = ModelShow1_plain.objects.get(field1="TestParentLinkAndRelatedName")
# check that p is equal to the
self.assertIsInstance(p, TestParentLinkAndRelatedName)
self.assertEqual(p, t)
# check that the accessors to parent and sublass work correctly and return the right object
p = ModelShow1_plain.objects.non_polymorphic().get(field1="TestParentLinkAndRelatedName")
self.assertNotEqual(p, t) # p should be Plain1 and t TestParentLinkAndRelatedName, so not equal
self.assertEqual(p, t.superclass)
self.assertEqual(p.related_name_subclass, t)
# test that we can delete the object
t.delete()
def test_delete_files_or_folders_action_with_mixed_types(self):
# add more files/images so we can test the polymorphic queryset with multiple types
self.create_file(folder=self.src_folder)
self.create_image(folder=self.src_folder)
self.create_file(folder=self.src_folder)
self.create_image(folder=self.src_folder)
self.assertNotEqual(File.objects.count(), 0)
self.assertNotEqual(Image.objects.count(), 0)
url = reverse('admin:filer-directory_listing', args=(self.folder.id,))
folders = []
for f in File.objects.filter(folder=self.folder):
folders.append('file-%d' % (f.id,))
folders.append('folder-%d' % self.sub_folder1.id)
response = self.client.post(url, {
'action': 'delete_files_or_folders',
'post': 'yes',
helpers.ACTION_CHECKBOX_NAME: folders,
})
self.assertEqual(File.objects.filter(folder__in=[self.folder.id, self.sub_folder1.id]).count(), 0)
def _get_jinja2_env(self):
import jinja2
import jinja2.ext
from compressor.offline.jinja2 import url_for, SpacelessExtension
from compressor.contrib.jinja2ext import CompressorExtension
# Extensions needed for the test cases only.
extensions = [
CompressorExtension,
SpacelessExtension,
jinja2.ext.with_,
jinja2.ext.do,
]
loader = self._get_jinja2_loader()
env = jinja2.Environment(extensions=extensions, loader=loader)
env.globals['url_for'] = url_for
return env
def setup_django():
"""Provide a test database and django configuration"""
from yawn.worker.models import Queue
# these are positional arguments, written out for clarity
verbosity = 1
interactive = False # whether to ask before deleting
old_config = runner.setup_databases(verbosity, interactive)
# create the default queue outside the transaction
Queue.get_default_queue()
yield
for connection, old_name, destroy in old_config:
connection.creation.destroy_test_db(old_name)
def test_post(self):
# Build a fake file
fake_file = ContentFile(b("A boring example document"))
fake_file.name = 'test.txt'
# Submit
post_data = {
'title': "Test document",
'file': fake_file,
}
response = self.client.post(reverse('wagtaildocs:add'), post_data)
# User should be redirected back to the index
self.assertRedirects(response, reverse('wagtaildocs:index'))
# Document should be created, and be placed in the root collection
self.assertTrue(models.Document.objects.filter(title="Test document").exists())
root_collection = Collection.get_first_root_node()
self.assertEqual(
models.Document.objects.get(title="Test document").collection,
root_collection
)
def test_post(self):
# Build a fake file
fake_file = ContentFile(b("A boring example document"))
fake_file.name = 'test.txt'
# Submit
post_data = {
'title': "Test document",
'file': fake_file,
}
response = self.client.post(reverse('wagtaildocs:add'), post_data)
# User should be redirected back to the index
self.assertRedirects(response, reverse('wagtaildocs:index'))
# Document should be created in the 'evil plans' collection,
# despite there being no collection field in the form, because that's the
# only one the user has access to
self.assertTrue(models.Document.objects.filter(title="Test document").exists())
self.assertEqual(
models.Document.objects.get(title="Test document").collection,
self.evil_plans_collection
)
def test_post(self):
# Build a fake file
fake_file = ContentFile(b("A boring example document"))
fake_file.name = 'test.txt'
# Submit title change
post_data = {
'title': "Test document changed!",
'file': fake_file,
}
response = self.client.post(reverse('wagtaildocs:edit', args=(self.document.id,)), post_data)
# User should be redirected back to the index
self.assertRedirects(response, reverse('wagtaildocs:index'))
# Document title should be changed
self.assertEqual(models.Document.objects.get(id=self.document.id).title, "Test document changed!")
def test_post(self):
# Build a fake file
fake_file = ContentFile(b("A boring example document"))
fake_file.name = 'test.txt'
# Submit
post_data = {
'title': "Test document",
'file': fake_file,
}
response = self.client.post(reverse('wagtaildocs:chooser_upload'), post_data)
# Check that the response is a javascript file saying the document was chosen
self.assertTemplateUsed(response, 'wagtaildocs/chooser/document_chosen.js')
self.assertContains(response, "modal.respond('documentChosen'")
# Document should be created
self.assertTrue(models.Document.objects.filter(title="Test document").exists())
def add_document(self, **params):
# Build a fake file
fake_file = ContentFile(b("A boring example document"))
fake_file.name = 'test.txt'
# Submit
post_data = {
'title': "Test document",
'file': fake_file,
}
post_data.update(params)
response = self.client.post(reverse('wagtaildocs:add'), post_data)
# User should be redirected back to the index
self.assertRedirects(response, reverse('wagtaildocs:index'))
# Document should be created
doc = models.Document.objects.filter(title=post_data['title'])
self.assertTrue(doc.exists())
return doc.first()
def test_level(self):
"""Test if the level is correct when buying baracks"""
#Have no baracks
self.UnitTest4.addBarrack(0)
self.assertEqual(self.UnitTest4.level, 0)
#have negative baracks, shouldnt ever happen but test it anyway.
self.UnitTest2.addBarrack(0)
self.assertEqual(self.UnitTest2.level, 0)
#have -3 baracks and add 4 but don't have enough money (-900)
self.UnitTest2.addBarrack(4)
self.assertEqual(self.UnitTest2.level, 0)
#have -3 baracks and add 4 with enough money (900)
self.UnitTest6.addBarrack(4)
self.assertEqual(self.UnitTest6.level, 1)
#have 1 barack
self.UnitTest5.addBarrack(0)
self.assertEqual(self.UnitTest5.level, 1)
#Player is already level 4 and levels up by getting 1 barack
self.UnitTest7.addBarrack(1)
self.assertEqual(self.UnitTest7.level, 5)
def test_home_status(self):
"""
Home page returns HTTP 200
"""
# create GET request
request = self.factory.get('home')
# simulate logged-out user
request.user = AnonymousUser()
# test the view
response = views.home_view(request)
# check that the response is 200 OK
self.assertEqual(response.status_code, 200)
def test_home_content(self):
"""
Home page returns correct content
"""
# create GET request
request = self.factory.get('home')
# simulate logged-out user
request.user = AnonymousUser()
# test the view
response = views.home_view(request)
# check that the correct content is displayed
self.assertContains(response, "Streamlined Roleplaying", status_code=200)
self.assertContains(response, "Login", status_code=200)
self.assertContains(response, "Sign up", status_code=200)
self.assertContains(response, "Features", status_code=200)
self.assertContains(response, "Users", status_code=200)
self.assertContains(response, "Campaigns", status_code=200)
self.assertContains(response, "Creatures", status_code=200)
self.assertContains(response, "Donate", status_code=200)
self.assertContains(response, "Copyright", status_code=200)
def setUpTestData(cls):
cls.header = settings.SHIBAUTH_REMOTE_USER_HEADER
cls.headers = settings.SAMPLE_HEADERS
# Usernames to be passed in REMOTE_USER for the test_known_user test case.
cls.known_user = 'knownuser'
cls.known_user2 = 'knownuser2'
reload(middleware)
def test_valid_string_list_model_form_save(self):
form_class = modelform_factory(StringListModel, fields=('values',))
form = form_class({'values': "This,is,a,test"})
self.assertTrue(form.is_valid())
self.assertEqual(
form.cleaned_data['values'], ['This', 'is', 'a', 'test']
)
obj = form.save()
self.assertEqual(obj.values, ['This', 'is', 'a', 'test'])
def fake_conn_request(self):
# print a stacktrace to illustrate where the unmocked API call
# is being made from
traceback.print_stack()
# forcing a test failure for missing mock
self.missing_mocks = True
def tearDown(self):
HTTPConnection.connect = self._real_conn_request
context_processors.openstack = self._real_context_processor
utils.get_user = self._real_get_user
mock.patch.stopall()
super(TestCase, self).tearDown()
# cause a test failure if an unmocked API call was attempted
if self.missing_mocks:
raise AssertionError("An unmocked API call was made.")
def test_filer_remember_last_opened_directory(self):
folder = Folder.objects.create(name='remember me please')
get_last_folder = lambda: self.client.get(reverse('admin:filer-directory_listing-last'), follow=True)
self.client.get(reverse('admin:filer-directory_listing', kwargs={'folder_id': folder.id}))
self.assertEqual(int(self.client.session['filer_last_folder_id']), folder.id)
self.assertEqual(get_last_folder().context['folder'], folder)
# let's test fallback
folder.delete()
self.assertTrue(isinstance(get_last_folder().context['folder'], FolderRoot))
def test_copy_files_and_folders_action(self):
# TODO: Test recursive (files and folders tree) copy
self.assertEqual(self.src_folder.files.count(), 1)
self.assertEqual(self.dst_folder.files.count(), 0)
self.assertEqual(self.image_obj.original_filename, 'test_file.jpg')
url = reverse('admin:filer-directory_listing', kwargs={
'folder_id': self.src_folder.id,
})
response = self.client.post(url, {
'action': 'copy_files_and_folders',
'post': 'yes',
'suffix': 'test',
'destination': self.dst_folder.id,
helpers.ACTION_CHECKBOX_NAME: 'file-%d' % (self.image_obj.id,),
})
self.assertEqual(response.status_code, 302)
# check if copying to the same folder gives 403
response = self.client.post(url, {
'action': 'copy_files_and_folders',
'post': 'yes',
'suffix': 'test',
'destination': self.src_folder.id,
helpers.ACTION_CHECKBOX_NAME: 'file-%d' % (self.image_obj.id,),
})
self.assertEqual(response.status_code, 403)
self.assertEqual(self.src_folder.files.count(), 1)
self.assertEqual(self.dst_folder.files.count(), 1)
self.assertEqual(self.src_folder.files[0].id, self.image_obj.id)
dst_image_obj = self.dst_folder.files[0]
self.assertEqual(dst_image_obj.original_filename, 'test_filetest.jpg')
def test_render_add_view(self):
"""
Really stupid and simple test to see if the add Permission view can be rendered
"""
response = self.client.get(reverse('admin:filer_folderpermission_add'))
self.assertEqual(response.status_code, 200)
def test_order_by_lower(self):
from django.db.models.functions import Lower
c = Category.objects.create(name='test')
Blog.objects.create(title='A', title_nl='c', category=c)
Blog.objects.create(title='a', title_nl='b', category=c)
filtered = Blog.objects.filter(category=c)
# order by title should result in aA because it is case sensitive.
qs = filtered.order_by('title', 'title_nl')
self.assertEquals(key(qs, 'title'), ['a', 'A'])
# order by Lower('title') should result in Aa because lower('A') == lower('A')
# so the title_nl field should determine the sorting
qs = filtered.order_by(Lower('title'), 'title_nl')
self.assertEquals(key(qs, 'title'), ['a', 'A'])
# applying lower to title_nl should not matter since it is not the same letter
qs = filtered.order_by(Lower('title_nl'))
self.assertEquals(key(qs, 'title'), ['a', 'A'])
# should be the same as previous
with override('nl'):
qs = filtered.order_by(Lower('title_i18n'))
self.assertEquals(key(qs, 'title'), ['a', 'A'])
def test_protected_media(self):
m = SomeModel()
m.protected_file = SimpleUploadedFile(
"protected_file.txt", "A test file"
)
m.protected_image = SimpleUploadedFile(
"protected_image.png", "A test image"
)
m.public_file = SimpleUploadedFile(
"public_file.txt", "A test file"
)
m.public_image = SimpleUploadedFile(
"public_image.png", "A test image"
)
self.assertEqual(m.protected_file.name, "protected_file.txt")
self.assertEqual(m.protected_file.url,
"/myprotectedmedia/protected_file.txt")
self.assertEqual(m.protected_image.name, "protected_image.png")
self.assertEqual(m.protected_image.url,
"/myprotectedmedia/protected_image.png")
self.assertEqual(m.public_file.name, "public_file.txt")
self.assertEqual(m.public_file.url, "/media/public_file.txt")
self.assertEqual(m.public_image.name, "public_image.png")
self.assertEqual(m.public_image.url, "/media/public_image.png")
def setUp(self):
# Every view test needs a client.
self.client = Client()
def test_check_custom_user_model(self):
# Django doesn't re-register admins when using `override_settings`,
# so we have to do it manually in this test case.
admin.site.register(get_user_model(), HijackUserAdmin)
warnings = checks.check_custom_user_model(HijackAdminConfig)
self.assertFalse(warnings)
admin.site.unregister(get_user_model())
def test_check_custom_user_model_default_admin(self):
# Django doesn't re-register admins when using `override_settings`,
# so we have to do it manually in this test case.
admin.site.register(get_user_model(), UserAdmin)
warnings = checks.check_custom_user_model(HijackAdminConfig)
expected_warnings = [
Warning(
'django-hijack-admin does not work out the box with a custom user model.',
hint='Please mix HijackUserAdminMixin into your custom UserAdmin.',
obj=settings.AUTH_USER_MODEL,
id='hijack_admin.W001',
)
]
self.assertEqual(warnings, expected_warnings)
admin.site.unregister(get_user_model())
def test_add_empty_page(self):
"""Add a page without content, test path generation etc"""
client = self.login()
response = client.post(
'/admin/testapp/page/add/',
merge_dicts(
{
'title': 'Home EN',
'slug': 'home-en',
'path': '/en/',
'static_path': 1,
'language_code': 'en',
'application': '',
'is_active': 1,
'menu': 'main',
'template_key': 'standard',
},
zero_management_form_data('testapp_richtext_set'),
zero_management_form_data('testapp_image_set'),
zero_management_form_data('testapp_snippet_set'),
zero_management_form_data('testapp_external_set'),
zero_management_form_data('testapp_html_set'),
),
)
self.assertRedirects(
response,
'/admin/testapp/page/',
)
page = Page.objects.get()
self.assertEqual(page.slug, 'home-en')
self.assertEqual(page.path, '/en/') # static_path!
response = client.get(page.get_absolute_url())
self.assertContains(
response,
'<h1>Home EN</h1>',
1,
)
def test_positional(self):
@positional(2)
def test(a, b, c):
pass
with self.assertRaises(TypeError):
test(1, 2, 3)
test(1, 2, c=3)
def setUp(self):
self.url = reverse("django_admin_shell:shell")
username = "test"
password = "test"
self.user = get_user_model()(username=username)
self.user.set_password(password)
self.user.save()
self.client_auth = Client()
self.client_auth.login(username=username, password=password)
def test_single_code(self):
"""
Run simple code in pure python
"""
code = "1 + 1"
result = run_code(code)
assert result["code"] == code
assert result["status"] == "success"
assert result["out"] == ""
code = "print(1 + 1)"
result = run_code(code)
assert result["code"] == code
assert result["status"] == "success"
assert result["out"] == "2\n"
# !!! Warning
# Not use: """ because indention will be incorect
code = "class Test(object):\n"
code += " def pow(self, a, b):\n"
code += " return a**b\n"
code += "test = Test()\n"
code += "ret = test.pow(2, 10)\n"
code += "print(ret)"
result = run_code(code)
assert result["code"] == code
assert result["status"] == "success"
assert result["out"] == "1024\n"
def test_interact_with_env(self):
"""
Run code having access to something from environ, settings etc.
Heck if code runing in django environ
"""
code = "from django.conf import settings\n"
code += "print(settings.DEBUG)"
# Default in test DEBUG is False
result = run_code(code)
assert result["code"] == code
assert result["status"] == "success"
assert result["out"] == "False\n"
with self.settings(DEBUG=True):
result = run_code(code)
assert result["code"] == code
assert result["status"] == "success"
assert result["out"] == "True\n"
code = "from django.conf import settings\n"
code += "print(settings.SECRET_KEY)"
result = run_code(code)
assert result["code"] == code
assert result["status"] == "success"
assert result["out"] == "{0}\n".format("x" * 55)
code = "import django\n"
code += "print(django.VERSION)"
result = run_code(code)
assert result["code"] == code
assert result["status"] == "success"
assert result["out"] == "{0}\n".format(str(django.VERSION))