prefix stringlengths 512 512 | suffix stringlengths 256 256 | middle stringlengths 14 229 | meta dict |
|---|---|---|---|
r_5 = Customer.objects.create(customer_id=1, company="e")
cls.contact_1 = Contact.objects.create(customer=cls.customer_1)
cls.contact_2 = Contact.objects.create(customer=cls.customer_1)
cls.contact_3 = Contact.objects.create(customer=cls.customer_2)
cls.contact_4 = Contact.objects.create... | stomer_4, ()),
(self.customer_5, (self.contact_6,)),
)
for customer, contacts in test_cases:
with self.subTest(
"filter(customer=customer)",
customer=customer,
contact | lf):
test_cases = (
(self.customer_1, (self.contact_1, self.contact_2, self.contact_5)),
(self.customer_2, (self.contact_3,)),
(self.customer_3, (self.contact_4,)),
(self.cu | {
"filepath": "tests/foreign_object/test_tuple_lookups.py",
"language": "python",
"file_size": 19564,
"cut_index": 1331,
"middle_length": 229
} |
cls.usa = Country.objects.create(name="United States of America")
cls.soviet_union = Country.objects.create(name="Soviet Union")
# Creating People
cls.bob = Person.objects.create(name="Bob", person_country=cls.usa)
cls.jim = Person.objects.create(name="Jim", person_country=cls.usa)
... | oup_country=cls.soviet_union)
cls.cia = Group.objects.create(name="CIA", group_country=cls.usa)
cls.republican = Group.objects.create(name="Republican", group_country=cls.usa)
cls.democrat = Group.objects.create(name="Democrat", gro | on.objects.create(name="Mark", person_country=cls.soviet_union)
cls.sam = Person.objects.create(name="Sam", person_country=cls.soviet_union)
# Creating Groups
cls.kgb = Group.objects.create(name="KGB", gr | {
"filepath": "tests/foreign_object/tests.py",
"language": "python",
"file_size": 32616,
"cut_index": 1331,
"middle_length": 229
} |
om django.db.models.lookups import StartsWith
from django.db.models.query_utils import PathInfo
class CustomForeignObjectRel(models.ForeignObjectRel):
"""
Define some extra Field methods so this Rel acts more like a Field, which
lets us use ReverseManyToOneDescriptor in both directions.
"""
@prop... | oOneDescriptor in both directions.
"""
auto_created = False
many_to_many = False
many_to_one = True
one_to_many = False
one_to_one = False
rel_class = CustomForeignObjectRel
def __init__(self, *args, **kwargs):
k | artsWithRelation(models.ForeignObject):
"""
A ForeignObject that uses StartsWith operator in its joins instead of
the default equality operator. This is logically a many-to-many relation
and creates a ReverseManyT | {
"filepath": "tests/foreign_object/models/empty_join.py",
"language": "python",
"file_size": 3564,
"cut_index": 614,
"middle_length": 229
} |
one.get_fixed_timezone(180) # Africa/Nairobi
ICT = timezone.get_fixed_timezone(420) # Asia/Bangkok
@contextmanager
def override_database_connection_timezone(timezone):
try:
orig_timezone = connection.settings_dict["TIME_ZONE"]
connection.settings_dict["TIME_ZONE"] = timezone
# Clear cach... | del connection.timezone
connection.timezone_name
del connection.timezone_name
@override_settings(TIME_ZONE="Africa/Nairobi", USE_TZ=False)
class LegacyDatabaseTests(TestCase):
def test_naive_datetime(self):
dt = datetime.dat | mezone_name
yield
finally:
connection.settings_dict["TIME_ZONE"] = orig_timezone
# Clear cached properties, after first accessing them to ensure they
# exist.
connection.timezone
| {
"filepath": "tests/timezones/tests.py",
"language": "python",
"file_size": 57967,
"cut_index": 2151,
"middle_length": 229
} |
om django.db import models
class Band(models.Model):
name = models.CharField(max_length=100)
bio = models.TextField()
rank = models.IntegerField()
class Meta:
ordering = ("name",)
class Song(models.Model):
band = models.ForeignKey(Band, models.CASCADE)
name = models.CharField(max_le... |
class SongInlineNewOrdering(admin.StackedInline):
model = Song
ordering = ("duration",)
class DynOrderingBandAdmin(admin.ModelAdmin):
def get_ordering(self, request):
if request.user.is_superuser:
return ["rank"]
| ultOrdering(admin.StackedInline):
model = Song
| {
"filepath": "tests/admin_ordering/models.py",
"language": "python",
"file_size": 889,
"cut_index": 547,
"middle_length": 52
} |
ef.sync import async_to_sync
from django.core.cache import DEFAULT_CACHE_ALIAS, caches
from django.core.exceptions import ImproperlyConfigured, SynchronousOnlyOperation
from django.http import HttpResponse, HttpResponseNotAllowed
from django.test import RequestFactory, SimpleTestCase
from django.utils.asyncio import a... | database connection cannot be used in an async context."""
async def test_get_async_connection(self):
with self.assertRaises(SynchronousOnlyOperation):
list(SimpleModel.objects.all())
class AsyncUnsafeTest(SimpleTestCase):
"" | def async_cache():
return caches[DEFAULT_CACHE_ALIAS]
cache_1 = async_cache()
cache_2 = async_cache()
self.assertIs(cache_1, cache_2)
class DatabaseConnectionTest(SimpleTestCase):
"""A | {
"filepath": "tests/async/tests.py",
"language": "python",
"file_size": 4918,
"cut_index": 614,
"middle_length": 229
} |
nd
class AdminActionsTests(TestCase):
@classmethod
def setUpTestData(cls):
cls.superuser = User.objects.create_superuser(
username="super", password="secret", email="super@example.com"
)
content_type = ContentType.objects.get_for_model(Band)
Permission.objects.creat... | er_type, content_type=content_type
)
user.user_permissions.add(permission)
setattr(cls, username, user)
def test_get_actions_respects_permissions(self):
class MockRequest:
pass
class Ban | " % user_type
user = User.objects.create_user(
username=username, password="secret", is_staff=True
)
permission = Permission.objects.get(
codename="%s_band" % us | {
"filepath": "tests/modeladmin/test_actions.py",
"language": "python",
"file_size": 5520,
"cut_index": 716,
"middle_length": 229
} |
raction ##############################
def test_default_fields(self):
ma = ModelAdmin(Band, self.site)
self.assertEqual(
list(ma.get_form(request).base_fields), ["name", "bio", "sign_date"]
)
self.assertEqual(list(ma.get_fields(request)), ["name", "bio", "sign_date"])
... | stom form, the fields
# argument, or nothing at all.
#
# Here's the default case. There are no custom form_add/form_change
# methods, no fields argument, and no fieldsets argument.
ma = ModelAdmin(Band, self.site)
| default_fieldsets(self):
# fieldsets_add and fieldsets_change should return a special data
# structure that is used in the templates. They should generate the
# "right thing" whether we have specified a cu | {
"filepath": "tests/modeladmin/tests.py",
"language": "python",
"file_size": 44169,
"cut_index": 2151,
"middle_length": 229
} |
t SimpleTestCase
from django.test.utils import isolate_apps
@isolate_apps("absolute_url_overrides")
class AbsoluteUrlOverrideTests(SimpleTestCase):
def test_get_absolute_url(self):
"""
get_absolute_url() functions as a normal method.
"""
def get_absolute_url(o):
return... | olute_url(o):
return "/test-b/%s/" % o.pk
with self.settings(
ABSOLUTE_URL_OVERRIDES={
"absolute_url_overrides.testb": lambda o: "/overridden-test-b/%s/"
% o.pk,
},
):
| self.assertEqual("/test-a/%s/" % obj.pk, obj.get_absolute_url())
def test_override_get_absolute_url(self):
"""
ABSOLUTE_URL_OVERRIDES should override get_absolute_url().
"""
def get_abs | {
"filepath": "tests/absolute_url_overrides/tests.py",
"language": "python",
"file_size": 2139,
"cut_index": 563,
"middle_length": 229
} |
onista,
FootNote,
Holder,
Holder2,
Holder3,
Holder4,
Holder5,
Inner,
Inner2,
Inner3,
Inner4Stacked,
Inner4Tabular,
Inner5Stacked,
Inner5Tabular,
NonAutoPKBook,
NonAutoPKBookChild,
Novel,
NovelReadonlyChapter,
OutfitItem,
ParentModelWithCustomPk... | del = Author.books.through
class NonAutoPKBookTabularInline(admin.TabularInline):
model = NonAutoPKBook
classes = ("collapse",)
class NonAutoPKBookChildTabularInline(admin.TabularInline):
model = NonAutoPKBookChild
classes = ("collapse" | Sighting,
SomeChildModel,
SomeParentModel,
SottoCapo,
Teacher,
Title,
TitleCollection,
UUIDChild,
UUIDParent,
)
site = admin.AdminSite(name="admin")
class BookInline(admin.TabularInline):
mo | {
"filepath": "tests/admin_inlines/admin.py",
"language": "python",
"file_size": 13197,
"cut_index": 921,
"middle_length": 229
} |
django.test import SimpleTestCase
class TestTemplates(SimpleTestCase):
def test_javascript_escaping(self):
context = {
"inline_admin_formset": {
"inline_formset_data": json.dumps(
{
"formset": {"prefix": "my-prefix"},
... | my-prefix"", output)
self.assertIn(""verbose_name": "verbose name\\\\"", output)
output = render_to_string("admin/edit_inline/tabular.html", context)
self.assertIn(""prefix": "my-prefix" | t)
self.assertIn(""prefix": " | {
"filepath": "tests/admin_inlines/test_templates.py",
"language": "python",
"file_size": 989,
"cut_index": 582,
"middle_length": 52
} |
ulting in missing objects in the queryset.
#
# Model A
# | (Relation A/B : nullable)
# Model B
# | (Relation B/C : non-nullable)
# Model C
#
# Because of the possibility of NULL rows resulting from the LEFT OUTER JOIN
# between Model A and Model B (i.e. instances of A without reference to B),
# the second joi... | erry Jones")
cls.movie = Movie.objects.create(
title="Monty Python and the Holy Grail", director=cls.director
)
# This test failed in #16715 because in some cases INNER JOIN was selected
# for the second foreign key rel | as introduced by one-to-one relations (through multi-table
# inheritance).
class NestedForeignKeysTests(TestCase):
@classmethod
def setUpTestData(cls):
cls.director = Person.objects.create(name="Terry Gilliam / T | {
"filepath": "tests/nested_foreign_keys/tests.py",
"language": "python",
"file_size": 11248,
"cut_index": 921,
"middle_length": 229
} |
els
class Article(models.Model):
CHOICES = (
(1, "first"),
(2, "second"),
)
headline = models.CharField(max_length=100, default="Default headline")
pub_date = models.DateTimeField()
status = models.IntegerField(blank=True, null=True, choices=CHOICES)
misc_data = models.CharFiel... | models.CharField(max_length=60)
class Party(models.Model):
when = models.DateField(null=True)
class Event(models.Model):
when = models.DateTimeField()
class Department(models.Model):
id = models.PositiveIntegerField(primary_key=True)
| ey are valid.
verbose_name = "\xc3\x85ngstr\xc3\xb6m's Articles"
class Movie(models.Model):
# Test models with non-default primary keys / AutoFields #5218
movie_id = models.AutoField(primary_key=True)
name = | {
"filepath": "tests/model_regress/models.py",
"language": "python",
"file_size": 1839,
"cut_index": 537,
"middle_length": 229
} |
"""
Regression tests for #7314 and #7372
"""
rm = RevisionableModel.objects.create(
title="First Revision", when=datetime.datetime(2008, 9, 28, 10, 30, 0)
)
self.assertEqual(rm.pk, rm.base.pk)
rm2 = rm.new_revision()
rm2.title = "Second Revision"
... | s.id IN "
"(SELECT MAX(rev.id) FROM %(table)s rev GROUP BY rev.base_id)"
% {
"table": RevisionableModel._meta.db_table,
}
]
)
self.assertQuerySetEqual(
| self.assertNotEqual(rm2.pk, rm.pk)
self.assertEqual(rm2.base.pk, rm.pk)
# Queryset to match most recent revision:
qs = RevisionableModel.objects.extra(
where=[
"%(table) | {
"filepath": "tests/extra_regress/tests.py",
"language": "python",
"file_size": 16177,
"cut_index": 921,
"middle_length": 229
} |
ort datetime
from django import forms
from django.test import TestCase
from .models import Article
class FormsTests(TestCase):
# ForeignObjects should not have any form fields, currently the user needs
# to manually deal with the foreignobject relation.
class ArticleForm(forms.ModelForm):
class ... | tr(datetime.date.today())})
self.assertTrue(form.is_valid())
a = form.save()
self.assertEqual(a.pub_date, datetime.date.today())
form = FormsTests.ArticleForm(instance=a, data={"pub_date": "2013-01-01"})
a2 = form.sa | form fields.
form = FormsTests.ArticleForm()
self.assertIn("id_pub_date", form.as_table())
self.assertNotIn("active_translation", form.as_table())
form = FormsTests.ArticleForm(data={"pub_date": s | {
"filepath": "tests/foreign_object/test_forms.py",
"language": "python",
"file_size": 1108,
"cut_index": 515,
"middle_length": 229
} |
els
class Address(models.Model):
company = models.CharField(max_length=1)
customer_id = models.IntegerField()
class Meta:
unique_together = [
("company", "customer_id"),
]
class Customer(models.Model):
company = models.CharField(max_length=1)
customer_id = models.Int... | ld(max_length=1)
customer_code = models.IntegerField()
customer = models.ForeignObject(
Customer,
models.CASCADE,
related_name="contacts",
to_fields=["customer_id", "company"],
from_fields=["customer_code", " | , "customer_id"],
to_fields=["company", "customer_id"],
)
class Meta:
unique_together = [
("company", "customer_id"),
]
class Contact(models.Model):
company_code = models.CharFie | {
"filepath": "tests/foreign_object/models/customers.py",
"language": "python",
"file_size": 1544,
"cut_index": 537,
"middle_length": 229
} |
ss AsyncRelatedManagersOperationTest(TestCase):
@classmethod
def setUpTestData(cls):
cls.mtm1 = ManyToManyModel.objects.create()
cls.s1 = SimpleModel.objects.create(field=0)
cls.mtm2 = ManyToManyModel.objects.create()
cls.mtm2.simples.set([cls.s1])
async def test_acreate(sel... | simple, created = await self.mtm1.simples.aget_or_create(field=2)
self.assertIs(created, True)
self.assertEqual(await self.mtm1.simples.acount(), 1)
self.assertEqual(new_simple.field, 2)
new_simple, created = await self.mtm1 | :
await self.s1.relatedmodel_set.acreate()
new_relatedmodel = await self.s1.relatedmodel_set.aget()
self.assertEqual(new_relatedmodel.simple, self.s1)
async def test_aget_or_create(self):
new_ | {
"filepath": "tests/async/test_async_related_managers.py",
"language": "python",
"file_size": 4944,
"cut_index": 614,
"middle_length": 229
} |
ort Http404
from django.shortcuts import aget_list_or_404, aget_object_or_404
from django.test import TestCase
from .models import RelatedModel, SimpleModel
class GetListObjectOr404Test(TestCase):
@classmethod
def setUpTestData(cls):
cls.s1 = SimpleModel.objects.create(field=0)
cls.s2 = Simpl... |
self.assertEqual(
await aget_object_or_404(self.s1.relatedmodel_set, pk=self.r1.pk), self.r1
)
# Http404 is returned if the list is empty.
msg = "No SimpleModel matches the given query."
with self.assert | eModel, field=1), self.s2)
self.assertEqual(await aget_object_or_404(SimpleModel, Q(field=0)), self.s1)
self.assertEqual(
await aget_object_or_404(SimpleModel.objects.all(), field=1), self.s2
) | {
"filepath": "tests/async/test_async_shortcuts.py",
"language": "python",
"file_size": 2432,
"cut_index": 563,
"middle_length": 229
} |
ured
from django.db import DEFAULT_DB_ALIAS, ProgrammingError, connection
from django.db.utils import ConnectionHandler, load_backend
from django.test import SimpleTestCase, TestCase
from django.utils.connection import ConnectionDoesNotExist
class ConnectionHandlerTests(SimpleTestCase):
def test_connection_handle... | ed(self, DATABASES):
conns = ConnectionHandler(DATABASES)
self.assertEqual(
conns[DEFAULT_DB_ALIAS].settings_dict["ENGINE"], "django.db.backends.dummy"
)
msg = (
"settings.DATABASES is improperly conf | ABASES setting.
{"default": {}}, # Empty 'default' database.
):
with self.subTest(DATABASES=DATABASES):
self.assertImproperlyConfigured(DATABASES)
def assertImproperlyConfigur | {
"filepath": "tests/db_utils/tests.py",
"language": "python",
"file_size": 3828,
"cut_index": 614,
"middle_length": 229
} |
er(models.Model):
name = models.CharField(max_length=50)
def __str__(self):
return self.name
class Child(models.Model):
name = models.CharField(max_length=50)
teacher = models.ForeignKey(Teacher, models.CASCADE)
content_type = models.ForeignKey(ContentType, models.CASCADE)
object_id ... | ld("Person", models.CASCADE, null=True)
class NonAutoPKBook(models.Model):
rand_pk = models.IntegerField(primary_key=True, editable=False)
author = models.ForeignKey(Author, models.CASCADE)
title = models.CharField(max_length=50)
def sav | = models.CharField(max_length=50)
def __str__(self):
return self.name
class Author(models.Model):
name = models.CharField(max_length=50)
books = models.ManyToManyField(Book)
person = models.OneToOneFie | {
"filepath": "tests/admin_inlines/models.py",
"language": "python",
"file_size": 10259,
"cut_index": 921,
"middle_length": 229
} |
django.test import SimpleTestCase
from django.test.utils import garbage_collect
from .models import Worker, WorkerProfile
class ModelStateTests(SimpleTestCase):
def test_fields_cache_descriptor(self):
self.assertIsInstance(ModelState.fields_cache, ModelStateFieldsCacheDescriptor)
def test_one_to_one... | rker()
profile = WorkerProfile(worker=worker)
worker_id = id(worker)
del worker
del profile
garbage_collect()
leaked = [obj for obj in gc.garbage if id(obj) == worker_id]
self.assertEqual(leaked, [ | self.addCleanup(clear_garbage)
worker = Wo | {
"filepath": "tests/model_regress/test_state.py",
"language": "python",
"file_size": 917,
"cut_index": 606,
"middle_length": 52
} |
test import TestCase
from .models import SlugPage
class RestrictedConditionsTests(TestCase):
@classmethod
def setUpTestData(cls):
slugs = [
"a",
"a/a",
"a/b",
"a/b/a",
"x",
"x/y/z",
]
SlugPage.objects.bulk_create(... | "a", "a/a", "a/b", "a/b/a"],
)
self.assertEqual(
[p.slug for p in a.descendants.all()],
["a", "a/a", "a/b", "a/b/a"],
)
aba = SlugPage.objects.get(slug="a/b/a")
self.assertEqual(
| any joining columns, as long as an extra restriction is supplied.
"""
a = SlugPage.objects.get(slug="a")
self.assertEqual(
[p.slug for p in SlugPage.objects.filter(ascendants=a)],
[ | {
"filepath": "tests/foreign_object/test_empty_join.py",
"language": "python",
"file_size": 1500,
"cut_index": 524,
"middle_length": 229
} |
om django.utils.translation import get_language
class ArticleTranslationDescriptor(ForwardManyToOneDescriptor):
"""
The set of articletranslation should not set any local fields.
"""
def __set__(self, instance, value):
if instance is None:
raise AttributeError("%s must be accessed... | lue
def as_sql(self, compiler, connection):
qn = compiler.quote_name
return "%s.%s = %%s" % (qn(self.alias), qn(self.col)), [self.value]
class ActiveTranslationField(models.ForeignObject):
"""
This field will allow querying a | d.set_cached_value(value, instance)
class ColConstraint:
# Anything with as_sql() method works in get_extra_restriction().
def __init__(self, alias, col, value):
self.alias, self.col, self.value = alias, col, va | {
"filepath": "tests/foreign_object/models/article.py",
"language": "python",
"file_size": 3255,
"cut_index": 614,
"middle_length": 229
} |
models import User
from django.db import models
class Band(models.Model):
name = models.CharField(max_length=100)
bio = models.TextField()
sign_date = models.DateField()
class Meta:
ordering = ("name",)
def __str__(self):
return self.name
class Song(models.Model):
name = mo... | ank=True
)
day = models.CharField(max_length=3, choices=((1, "Fri"), (2, "Sat")))
transport = models.CharField(
max_length=100, choices=((1, "Plane"), (2, "Train"), (3, "Bus")), blank=True
)
class ValidationTestModel(models.Model) | elf.name
class Concert(models.Model):
main_band = models.ForeignKey(Band, models.CASCADE, related_name="main_concerts")
opening_band = models.ForeignKey(
Band, models.CASCADE, related_name="opening_concerts", bl | {
"filepath": "tests/modeladmin/models.py",
"language": "python",
"file_size": 1823,
"cut_index": 537,
"middle_length": 229
} |
label(self):
"""Bug #13174."""
holder = Holder.objects.create(dummy=42)
Inner.objects.create(holder=holder, dummy=42, readonly="")
response = self.client.get(
reverse("admin:admin_inlines_holder_change", args=(holder.id,))
)
self.assertContains(response, "<lab... | n" name="uuidchild_set-0-id" value="{child.id}" '
'id="id_uuidchild_set-0-id">',
html=True,
)
def test_many_to_many_inlines(self):
"Autogenerated many-to-many inlines are displayed correctly (#13407)"
re | oo", parent=parent)
response = self.client.get(
reverse("admin:admin_inlines_uuidparent_change", args=(parent.id,))
)
self.assertContains(
response,
f'<input type="hidde | {
"filepath": "tests/admin_inlines/tests.py",
"language": "python",
"file_size": 105058,
"cut_index": 3790,
"middle_length": 229
} |
self.assertEqual(error.obj, invalid_obj)
self.assertEqual(error.id, id)
self.assertRegex(error.msg, msg)
def assertIsValid(self, model_admin, model, admin_site=None):
if admin_site is None:
admin_site = AdminSite()
admin_obj = model_admin(model, admin_site)
... | class TestModelAdmin(ModelAdmin):
raw_id_fields = ["non_existent_field"]
self.assertIsInvalid(
TestModelAdmin,
ValidationTestModel,
"The value of 'raw_id_fields[0]' refers to 'non_existent_fiel | self.assertIsInvalid(
TestModelAdmin,
ValidationTestModel,
"The value of 'raw_id_fields' must be a list or tuple.",
"admin.E001",
)
def test_missing_field(self):
| {
"filepath": "tests/modeladmin/test_checks.py",
"language": "python",
"file_size": 57982,
"cut_index": 2151,
"middle_length": 229
} |
m django.db import connection
from django.db.models import Max
from django.test import TestCase
from .models import Cash, CashModel
class FromDBValueTest(TestCase):
@classmethod
def setUpTestData(cls):
CashModel.objects.create(cash="12.50")
def test_simple_load(self):
instance = CashMode... | cts.aggregate(m=Max("cash"))["m"]
self.assertIsInstance(maximum, Cash)
def test_defer(self):
instance = CashModel.objects.defer("cash").get()
self.assertIsInstance(instance.cash, Cash)
def test_connection(self):
in | Instance(values_list[0], Cash)
def test_values(self):
values = CashModel.objects.values("cash")
self.assertIsInstance(values[0]["cash"], Cash)
def test_aggregation(self):
maximum = CashModel.obje | {
"filepath": "tests/from_db_value/tests.py",
"language": "python",
"file_size": 1099,
"cut_index": 515,
"middle_length": 229
} |
name = models.CharField(max_length=50)
def __str__(self):
return self.name
class Person(models.Model):
# Table Column Fields
name = models.CharField(max_length=128)
person_country_id = models.IntegerField()
# Relation Fields
person_country = models.ForeignObject(
Country... | eignKey(Country, models.CASCADE)
members = models.ManyToManyField(
Person, related_name="groups", through="Membership"
)
class Meta:
ordering = ("name",)
def __str__(self):
return self.name
class Membership(model | lse)
class Meta:
ordering = ("name",)
def __str__(self):
return self.name
class Group(models.Model):
# Table Column Fields
name = models.CharField(max_length=128)
group_country = models.For | {
"filepath": "tests/foreign_object/models/person.py",
"language": "python",
"file_size": 3122,
"cut_index": 614,
"middle_length": 229
} |
only().
"""
from django.db import models
class Secondary(models.Model):
first = models.CharField(max_length=50)
second = models.CharField(max_length=50)
class Primary(models.Model):
name = models.CharField(max_length=50)
value = models.CharField(max_length=50)
related = models.ForeignKey(Secon... | xy(Child):
class Meta:
proxy = True
class RefreshPrimaryProxy(Primary):
class Meta:
proxy = True
def refresh_from_db(self, using=None, fields=None, **kwargs):
# Reloads all deferred fields if any of the fields is defe | =50)
related = models.OneToOneField(
Secondary, models.CASCADE, related_name="primary_o2o"
)
class Child(Primary):
pass
class BigChild(Primary):
other = models.CharField(max_length=50)
class ChildPro | {
"filepath": "tests/defer/models.py",
"language": "python",
"file_size": 1668,
"cut_index": 537,
"middle_length": 229
} |
num)
class DeferTests(AssertionMixin, TestCase):
@classmethod
def setUpTestData(cls):
cls.s1 = Secondary.objects.create(first="x1", second="y1")
cls.p1 = Primary.objects.create(name="p1", value="xx", related=cls.s1)
cls.p2 = Primary.objects.create(name="p2", value="yy", related=cls.s1... | 2)
self.assert_delayed(qs.only("name").get(pk=self.p1.pk), 2)
self.assert_delayed(qs.only("name").only("value")[0], 2)
self.assert_delayed(qs.only("related__first")[0], 2)
# Using 'pk' with only() should result in 3 deferre | self.assert_delayed(qs.defer("related__first")[0], 0)
self.assert_delayed(qs.defer("name").defer("value")[0], 2)
def test_only(self):
qs = Primary.objects.all()
self.assert_delayed(qs.only("name")[0], | {
"filepath": "tests/defer/tests.py",
"language": "python",
"file_size": 18774,
"cut_index": 1331,
"middle_length": 229
} |
from django.forms import CharField, Form, HiddenInput
from .base import WidgetTest
class HiddenInputTest(WidgetTest):
widget = HiddenInput()
def test_render(self):
self.check_html(
self.widget, "email", "", html='<input type="hidden" name="email">'
)
def test_use_required_at... | use_fieldset.html"
field = CharField(widget=self.widget)
form = TestForm()
self.assertIs(self.widget.use_fieldset, False)
self.assertHTMLEqual(
'<input type="hidden" name="field" id="id_field">',
| assertIs(self.widget.use_required_attribute(""), False)
self.assertIs(self.widget.use_required_attribute("foo"), False)
def test_fieldset(self):
class TestForm(Form):
template_name = "forms_tests/ | {
"filepath": "tests/forms_tests/widget_tests/test_hiddeninput.py",
"language": "python",
"file_size": 1023,
"cut_index": 512,
"middle_length": 229
} |
es import MultiValueDict
from .base import WidgetTest
class MultipleHiddenInputTest(WidgetTest):
widget = MultipleHiddenInput()
def test_render_single(self):
self.check_html(
self.widget,
"email",
["test@example.com"],
html='<input type="hidden" name="... | render_attrs(self):
self.check_html(
self.widget,
"email",
["test@example.com"],
attrs={"class": "fun"},
html=(
'<input type="hidden" name="email" value="test@example.com" | xample.com"],
html=(
'<input type="hidden" name="email" value="test@example.com">\n'
'<input type="hidden" name="email" value="foo@example.com">'
),
)
def test_ | {
"filepath": "tests/forms_tests/widget_tests/test_multiplehiddeninput.py",
"language": "python",
"file_size": 4032,
"cut_index": 614,
"middle_length": 229
} |
rn value.split("__")
return ["", ""]
class ComplexMultiWidget(MultiWidget):
def __init__(self, attrs=None):
widgets = (
TextInput(),
SelectMultiple(choices=WidgetTest.beatles),
SplitDateTimeWidget(),
)
super().__init__(widgets, attrs)
def de... | eld(),
MultipleChoiceField(choices=WidgetTest.beatles),
SplitDateTimeField(),
)
super().__init__(
fields, required=required, widget=widget, label=label, initial=initial
)
def compress(self, d | [2], "%Y-%m-%d %H:%M:%S"),
]
return [None, None, None]
class ComplexField(MultiValueField):
def __init__(self, required=True, widget=None, label=None, initial=None):
fields = (
CharFi | {
"filepath": "tests/forms_tests/widget_tests/test_multiwidget.py",
"language": "python",
"file_size": 10494,
"cut_index": 921,
"middle_length": 229
} |
n
from .base import WidgetTest
class NullBooleanSelectTest(WidgetTest):
widget = NullBooleanSelect()
def test_render_true(self):
self.check_html(
self.widget,
"is_cool",
True,
html=("""<select name="is_cool">
<option value="unknown">Unknown... | <option value="false" selected>No</option>
</select>"""),
)
def test_render_none(self):
self.check_html(
self.widget,
"is_cool",
None,
html=("""<select name="is_cool" | lf.check_html(
self.widget,
"is_cool",
False,
html=("""<select name="is_cool">
<option value="unknown">Unknown</option>
<option value="true">Yes</option>
| {
"filepath": "tests/forms_tests/widget_tests/test_nullbooleanselect.py",
"language": "python",
"file_size": 4719,
"cut_index": 614,
"middle_length": 229
} |
rom django.forms import CharField, Form, NumberInput
from django.test import override_settings
from .base import WidgetTest
class NumberInputTests(WidgetTest):
widget = NumberInput(attrs={"max": 12345, "min": 1234, "step": 9999})
@override_settings(USE_THOUSAND_SEPARATOR=True)
def test_attrs_not_localiz... | self.assertIs(self.widget.use_fieldset, False)
self.assertHTMLEqual(
'<div><label for="id_field">Field:</label>'
'<input id="id_field" max="12345" min="1234" '
'name="field" required step="9999" type="num | 'step="9999">',
)
def test_fieldset(self):
class TestForm(Form):
template_name = "forms_tests/use_fieldset.html"
field = CharField(widget=self.widget)
form = TestForm()
| {
"filepath": "tests/forms_tests/widget_tests/test_numberinput.py",
"language": "python",
"file_size": 1049,
"cut_index": 513,
"middle_length": 229
} |
CharField, Form, PasswordInput
from .base import WidgetTest
class PasswordInputTest(WidgetTest):
widget = PasswordInput()
def test_render(self):
self.check_html(
self.widget, "password", "", html='<input type="password" name="password">'
)
def test_render_ignore_value(self):... | e=True)
self.check_html(
widget, "password", "", html='<input type="password" name="password">'
)
self.check_html(
widget, "password", None, html='<input type="password" name="password">'
)
se | e_true(self):
"""
The render_value argument lets you specify whether the widget should
render its value. For security reasons, this is off by default.
"""
widget = PasswordInput(render_valu | {
"filepath": "tests/forms_tests/widget_tests/test_passwordinput.py",
"language": "python",
"file_size": 1664,
"cut_index": 537,
"middle_length": 229
} |
def test_render(self):
html = """
<div>
<div>
<label><input type="radio" name="beatle" value="">
- Select an option -
</label>
</div>
<div>
<label><input checked type="radio" name="beatle" value="J">John</label>
... | les
for choices in (beatles_with_blank, dict(beatles_with_blank)):
with self.subTest(choices):
self.check_html(self.widget(choices=choices), "beatle", "J", html=html)
def test_nested_choices(self):
nested_ch | ue="G">George</label>
</div>
<div>
<label><input type="radio" name="beatle" value="R">Ringo</label>
</div>
</div>
"""
beatles_with_blank = BLANK_CHOICE + self.beat | {
"filepath": "tests/forms_tests/widget_tests/test_radioselect.py",
"language": "python",
"file_size": 17151,
"cut_index": 921,
"middle_length": 229
} |
ption>
<option value="P">Paul</option>
<option value="G">George</option>
<option value="R">Ringo</option>
</select>
"""
for choices in (self.beatles, dict(self.beatles)):
with self.subTest(choices):
self.check_html(self.widget(choices=cho... | ue="G">George</option>
<option value="R">Ringo</option>
</select>"""),
)
def test_render_label_value(self):
"""
If the value corresponds to a label (but not to an option value), none
of the optio | elf.widget(choices=self.beatles),
"beatle",
None,
html=("""<select name="beatle">
<option value="J">John</option>
<option value="P">Paul</option>
<option val | {
"filepath": "tests/forms_tests/widget_tests/test_select.py",
"language": "python",
"file_size": 14647,
"cut_index": 921,
"middle_length": 229
} |
<option selected value="">---</option>
<option value="1">January</option>
<option value="2">February</option>
<option value="3">March</option>
<option value="4">April</option>
<option value="5">May</option>
<opt... | <option selected value="">---</option>
<option value="1">1</option>
<option value="2">2</option>
<option value="3">3</option>
<option value="4">4</option>
<option | <option value="10">October</option>
<option value="11">November</option>
<option value="12">December</option>
</select>
<select name="mydate_day" id="id_mydate_day">
| {
"filepath": "tests/forms_tests/widget_tests/test_selectdatewidget.py",
"language": "python",
"file_size": 30912,
"cut_index": 1331,
"middle_length": 229
} |
("2", "2"), ("3", "3"), ("0", "extra"))
def test_format_value(self):
widget = self.widget(choices=self.numeric_choices)
self.assertEqual(widget.format_value(None), [])
self.assertEqual(widget.format_value(""), [""])
self.assertEqual(widget.format_value([3, 0, 1]), ["3", "0", "1"])
... | )
def test_render_multiple_selected(self):
self.check_html(
self.widget(choices=self.beatles),
"beatles",
["J", "P"],
html=("""<select multiple name="beatles">
<option value="J" | ="beatles">
<option value="J" selected>John</option>
<option value="P">Paul</option>
<option value="G">George</option>
<option value="R">Ringo</option>
</select>"""),
| {
"filepath": "tests/forms_tests/widget_tests/test_selectmultiple.py",
"language": "python",
"file_size": 6510,
"cut_index": 716,
"middle_length": 229
} |
eTimeWidget
from .base import WidgetTest
class SplitDateTimeWidgetTest(WidgetTest):
widget = SplitDateTimeWidget()
def test_render_empty(self):
self.check_html(
self.widget,
"date",
"",
html=('<input type="text" name="date_0"><input type="text" name="d... | '<input type="text" name="date_0" value="2006-01-10">'
'<input type="text" name="date_1" value="07:30:00">'
),
)
def test_render_date_and_time(self):
self.check_html(
self.widget,
| "><input type="text" name="date_1">'),
)
def test_render_datetime(self):
self.check_html(
self.widget,
"date",
datetime(2006, 1, 10, 7, 30),
html=(
| {
"filepath": "tests/forms_tests/widget_tests/test_splitdatetimewidget.py",
"language": "python",
"file_size": 3965,
"cut_index": 614,
"middle_length": 229
} |
idget
from django.utils import translation
from .base import WidgetTest
class SplitHiddenDateTimeWidgetTest(WidgetTest):
widget = SplitHiddenDateTimeWidget()
def test_render_empty(self):
self.check_html(
self.widget,
"date",
"",
html=(
... | "12:51:34">'
),
)
self.check_html(
self.widget,
"date",
datetime(2007, 9, 17, 12, 51, 34),
html=(
'<input type="hidden" name="date_0" value="2007-09-17">'
| self.check_html(
self.widget,
"date",
d,
html=(
'<input type="hidden" name="date_0" value="2007-09-17">'
'<input type="hidden" name="date_1" value= | {
"filepath": "tests/forms_tests/widget_tests/test_splithiddendatetimewidget.py",
"language": "python",
"file_size": 4017,
"cut_index": 614,
"middle_length": 229
} |
from django.utils.safestring import mark_safe
from .base import WidgetTest
class TextareaTest(WidgetTest):
widget = Textarea()
def test_render(self):
self.check_html(
self.widget,
"msg",
"value",
html=('<textarea rows="10" cols="40" name="msg">value</t... | html='<textarea rows="10" cols="40" name="msg"></textarea>',
)
def test_render_none(self):
self.check_html(
self.widget,
"msg",
None,
html='<textarea rows="10" cols="40" name="msg"></ | "value",
html='<textarea rows="10" cols="40" name="msg">value</textarea>',
)
def test_render_empty(self):
self.check_html(
self.widget,
"msg",
"",
| {
"filepath": "tests/forms_tests/widget_tests/test_textarea.py",
"language": "python",
"file_size": 2205,
"cut_index": 563,
"middle_length": 229
} |
m .base import WidgetTest
class TextInputTest(WidgetTest):
widget = TextInput()
def test_render(self):
self.check_html(
self.widget, "email", "", html='<input type="text" name="email">'
)
def test_render_none(self):
self.check_html(
self.widget, "email", N... | """
self.check_html(
self.widget,
"get_spam",
False,
html=('<input type="text" name="get_spam" value="False">'),
)
self.check_html(
self.widget,
"get_spam" | html=('<input type="text" name="email" value="test@example.com">'),
)
def test_render_boolean(self):
"""
Boolean values are rendered to their string forms ("True" and
"False").
| {
"filepath": "tests/forms_tests/widget_tests/test_textinput.py",
"language": "python",
"file_size": 4126,
"cut_index": 614,
"middle_length": 229
} |
CharField, Form, TimeInput
from django.utils import translation
from .base import WidgetTest
class TimeInputTest(WidgetTest):
widget = TimeInput()
def test_render_none(self):
self.check_html(
self.widget, "time", None, html='<input type="text" name="time">'
)
def test_rende... | ,
time(12, 51, 34),
html=('<input type="text" name="time" value="12:51:34">'),
)
self.check_html(
self.widget,
"time",
time(12, 51),
html=('<input type="text" name="tim | self.check_html(
self.widget,
"time",
t,
html='<input type="text" name="time" value="12:51:34">',
)
self.check_html(
self.widget,
"time" | {
"filepath": "tests/forms_tests/widget_tests/test_timeinput.py",
"language": "python",
"file_size": 2383,
"cut_index": 563,
"middle_length": 229
} |
m django.forms import Widget
from django.forms.widgets import Input
from .base import WidgetTest
class WidgetTests(WidgetTest):
def test_format_value(self):
widget = Widget()
self.assertIsNone(widget.format_value(None))
self.assertIsNone(widget.format_value(""))
self.assertEqual(w... | self.check_html(
Input(),
"name",
"value",
strict=True,
html='<input type="None" name="name" value="value">',
)
def test_attr_false_not_rendered(self):
html = '<input type= | Is(widget.value_omitted_from_data({}, {}, "field"), True)
self.assertIs(
widget.value_omitted_from_data({"field": "value"}, {}, "field"), False
)
def test_no_trailing_newline_in_attrs(self):
| {
"filepath": "tests/forms_tests/widget_tests/test_widget.py",
"language": "python",
"file_size": 1125,
"cut_index": 515,
"middle_length": 229
} |
forms import ChoiceField, Field, Form, Select
from django.test import SimpleTestCase
class BasicFieldsTests(SimpleTestCase):
def test_field_sets_widget_is_required(self):
self.assertTrue(Field(required=True).widget.is_required)
self.assertFalse(Field(required=False).widget.is_required)
def te... | ield(ChoiceField):
widget = Select(attrs={"class": "my-custom-class"})
class TestForm(Form):
field1 = CustomChoiceField(choices=[])
field2 = CustomChoiceField(choices=[])
f = TestForm()
f.fields | ld(Field, A):
def __init__(self):
super().__init__()
f = ComplexField()
self.assertTrue(f.class_a_var)
def test_field_deepcopies_widget_instance(self):
class CustomChoiceF | {
"filepath": "tests/forms_tests/field_tests/test_base.py",
"language": "python",
"file_size": 1454,
"cut_index": 524,
"middle_length": 229
} |
alidationError
from django.forms import BooleanField
from django.test import SimpleTestCase
class BooleanFieldTest(SimpleTestCase):
def test_booleanfield_clean_1(self):
f = BooleanField()
with self.assertRaisesMessage(ValidationError, "'This field is required.'"):
f.clean("")
w... | f.clean("Django rocks"))
self.assertTrue(f.clean("True"))
with self.assertRaisesMessage(ValidationError, "'This field is required.'"):
f.clean("False")
def test_booleanfield_clean_2(self):
f = BooleanField(required= | or, "'This field is required.'"):
f.clean(False)
self.assertTrue(f.clean(1))
with self.assertRaisesMessage(ValidationError, "'This field is required.'"):
f.clean(0)
self.assertTrue( | {
"filepath": "tests/forms_tests/field_tests/test_booleanfield.py",
"language": "python",
"file_size": 2770,
"cut_index": 563,
"middle_length": 229
} |
ionsMixin
class CharFieldTest(FormFieldAssertionsMixin, SimpleTestCase):
def test_charfield_1(self):
f = CharField()
self.assertEqual("1", f.clean(1))
self.assertEqual("hello", f.clean("hello"))
with self.assertRaisesMessage(ValidationError, "'This field is required.'"):
... | llo"))
self.assertEqual("", f.clean(None))
self.assertEqual("", f.clean(""))
self.assertEqual("[1, 2, 3]", f.clean([1, 2, 3]))
self.assertIsNone(f.max_length)
self.assertIsNone(f.min_length)
def test_charfield_3 | elf.assertIsNone(f.max_length)
self.assertIsNone(f.min_length)
def test_charfield_2(self):
f = CharField(required=False)
self.assertEqual("1", f.clean(1))
self.assertEqual("hello", f.clean("he | {
"filepath": "tests/forms_tests/field_tests/test_charfield.py",
"language": "python",
"file_size": 6444,
"cut_index": 716,
"middle_length": 229
} |
class ChoiceFieldTest(FormFieldAssertionsMixin, SimpleTestCase):
def test_choicefield_1(self):
f = ChoiceField(choices=[("1", "One"), ("2", "Two")])
with self.assertRaisesMessage(ValidationError, "'This field is required.'"):
f.clean("")
with self.assertRaisesMessage(ValidationEr... | lse)
self.assertEqual("", f.clean(""))
self.assertEqual("", f.clean(None))
self.assertEqual("1", f.clean(1))
self.assertEqual("1", f.clean("1"))
msg = "'Select a valid choice. 3 is not one of the available choices.'" | ot one of the available choices.'"
with self.assertRaisesMessage(ValidationError, msg):
f.clean("3")
def test_choicefield_2(self):
f = ChoiceField(choices=[("1", "One"), ("2", "Two")], required=Fa | {
"filepath": "tests/forms_tests/field_tests/test_choicefield.py",
"language": "python",
"file_size": 5533,
"cut_index": 716,
"middle_length": 229
} |
ns import ValidationError
from django.forms import CharField, ComboField, EmailField
from django.test import SimpleTestCase
class ComboFieldTest(SimpleTestCase):
def test_combofield_1(self):
f = ComboField(fields=[CharField(max_length=20), EmailField()])
self.assertEqual("test@example.com", f.clea... | ionError, "'This field is required.'"):
f.clean("")
with self.assertRaisesMessage(ValidationError, "'This field is required.'"):
f.clean(None)
def test_combofield_2(self):
f = ComboField(fields=[CharField(max_le | ean("longemailaddress@example.com")
with self.assertRaisesMessage(
ValidationError, "'Enter a valid email address.'"
):
f.clean("not an email")
with self.assertRaisesMessage(Validat | {
"filepath": "tests/forms_tests/field_tests/test_combofield.py",
"language": "python",
"file_size": 1576,
"cut_index": 537,
"middle_length": 229
} |
tCase
from django.utils import translation
class GetDate(Form):
mydate = DateField(widget=SelectDateWidget)
class DateFieldTest(SimpleTestCase):
def test_form_field(self):
a = GetDate({"mydate_month": "4", "mydate_day": "1", "mydate_year": "2008"})
self.assertTrue(a.is_valid())
self.... | lf.assertTrue(b.is_valid())
self.assertEqual(b.cleaned_data["mydate"], date(2008, 4, 1))
# Invalid dates shouldn't be allowed
c = GetDate({"mydate_month": "2", "mydate_day": "31", "mydate_year": "2010"})
self.assertFalse(c. | ng as well.
self.assertHTMLEqual(
a["mydate"].as_hidden(),
'<input type="hidden" name="mydate" value="2008-04-01" id="id_mydate">',
)
b = GetDate({"mydate": "2008-4-1"})
se | {
"filepath": "tests/forms_tests/field_tests/test_datefield.py",
"language": "python",
"file_size": 8892,
"cut_index": 716,
"middle_length": 229
} |
get_fixed_timezone
class DateTimeFieldTest(SimpleTestCase):
def test_datetimefield_clean(self):
tests = [
(date(2006, 10, 25), datetime(2006, 10, 25, 0, 0)),
(datetime(2006, 10, 25, 14, 30), datetime(2006, 10, 25, 14, 30)),
(datetime(2006, 10, 25, 14, 30, 59), datetime... | ("2006-10-25 14:30:00", datetime(2006, 10, 25, 14, 30)),
("2006-10-25 14:30", datetime(2006, 10, 25, 14, 30)),
("2006-10-25", datetime(2006, 10, 25, 0, 0)),
("10/25/2006 14:30:45.000200", datetime(2006, 10, 25, 14, 3 | 0-25 14:30:45.000200", datetime(2006, 10, 25, 14, 30, 45, 200)),
("2006-10-25 14:30:45.0002", datetime(2006, 10, 25, 14, 30, 45, 200)),
("2006-10-25 14:30:45", datetime(2006, 10, 25, 14, 30, 45)),
| {
"filepath": "tests/forms_tests/field_tests/test_datetimefield.py",
"language": "python",
"file_size": 5964,
"cut_index": 716,
"middle_length": 229
} |
4, decimal_places=2)
self.assertWidgetRendersTo(
f, '<input id="id_f" step="0.01" type="number" name="f" required>'
)
with self.assertRaisesMessage(ValidationError, "'This field is required.'"):
f.clean("")
with self.assertRaisesMessage(ValidationError, "'This fie... | decimal.Decimal("3.14"))
self.assertEqual(f.clean("1.0 "), decimal.Decimal("1.0"))
self.assertEqual(f.clean(" 1.0"), decimal.Decimal("1.0"))
self.assertEqual(f.clean(" 1.0 "), decimal.Decimal("1.0"))
with self.assertRaisesM | (f.clean("23"), decimal.Decimal("23"))
self.assertEqual(f.clean("3.14"), decimal.Decimal("3.14"))
self.assertEqual(f.clean(3.14), decimal.Decimal("3.14"))
self.assertEqual(f.clean(decimal.Decimal("3.14")), | {
"filepath": "tests/forms_tests/field_tests/test_decimalfield.py",
"language": "python",
"file_size": 10074,
"cut_index": 921,
"middle_length": 229
} |
ield
from django.test import SimpleTestCase
from django.utils import translation
from django.utils.duration import duration_string
from . import FormFieldAssertionsMixin
class DurationFieldTest(FormFieldAssertionsMixin, SimpleTestCase):
def test_durationfield_clean(self):
f = DurationField()
self... | f.clean("1 1:15:30.3"),
)
self.assertEqual(
datetime.timedelta(0, 10800),
f.clean(datetime.timedelta(0, 10800)),
)
msg = "This field is required."
with self.assertRaisesMessage(Validation | e.timedelta(hours=1, minutes=15, seconds=30), f.clean("1:15:30")
)
self.assertEqual(
datetime.timedelta(
days=1, hours=1, minutes=15, seconds=30, milliseconds=300
),
| {
"filepath": "tests/forms_tests/field_tests/test_durationfield.py",
"language": "python",
"file_size": 3091,
"cut_index": 614,
"middle_length": 229
} |
t import SimpleTestCase
from . import FormFieldAssertionsMixin
class EmailFieldTest(FormFieldAssertionsMixin, SimpleTestCase):
def test_emailfield_1(self):
f = EmailField()
self.assertEqual(f.max_length, 320)
self.assertWidgetRendersTo(
f, '<input type="email" name="f" id="id_... | email address.'"
):
f.clean("foo")
self.assertEqual(
"local@domain.with.idn.xyz\xe4\xf6\xfc\xdfabc.part.com",
f.clean("local@domain.with.idn.xyzäöüßabc.part.com"),
)
def test_email_regexp_fo | ationError, "'This field is required.'"):
f.clean(None)
self.assertEqual("person@example.com", f.clean("person@example.com"))
with self.assertRaisesMessage(
ValidationError, "'Enter a valid | {
"filepath": "tests/forms_tests/field_tests/test_emailfield.py",
"language": "python",
"file_size": 3091,
"cut_index": 614,
"middle_length": 229
} |
sion
from django.forms import FileField, FileInput
from django.test import SimpleTestCase
try:
from PIL import Image # NOQA
except ImportError:
HAS_PILLOW = False
else:
HAS_PILLOW = True
class FileFieldTest(SimpleTestCase):
def test_filefield_1(self):
f = FileField()
with self.assert... | e(ValidationError, "'This field is required.'"):
f.clean(None, "")
self.assertEqual("files/test2.pdf", f.clean(None, "files/test2.pdf"))
no_file_msg = "'No file was submitted. Check the encoding type on the form.'"
file | , "")
self.assertEqual("files/test1.pdf", f.clean("", "files/test1.pdf"))
with self.assertRaisesMessage(ValidationError, "'This field is required.'"):
f.clean(None)
with self.assertRaisesMessag | {
"filepath": "tests/forms_tests/field_tests/test_filefield.py",
"language": "python",
"file_size": 7041,
"cut_index": 716,
"middle_length": 229
} |
mport FilePathField
from django.test import SimpleTestCase
PATH = os.path.dirname(os.path.abspath(__file__))
def fix_os_paths(x):
if isinstance(x, str):
return x.removeprefix(PATH).replace("\\", "/")
elif isinstance(x, tuple):
return tuple(fix_os_paths(list(x)))
elif isinstance(x, list):
... | ("/filepathfield_test_dir/c/d.py", "d.py"),
("/filepathfield_test_dir/c/e.py", "e.py"),
("/filepathfield_test_dir/c/f/__init__.py", "__init__.py"),
("/filepathfield_test_dir/c/f/g.py", "g.py"),
("/filepathfield_test_ | it__.py"),
("/filepathfield_test_dir/a.py", "a.py"),
("/filepathfield_test_dir/ab.py", "ab.py"),
("/filepathfield_test_dir/b.py", "b.py"),
("/filepathfield_test_dir/c/__init__.py", "__init__.py"),
| {
"filepath": "tests/forms_tests/field_tests/test_filepathfield.py",
"language": "python",
"file_size": 4775,
"cut_index": 614,
"middle_length": 229
} |
t.utils import override_settings
from django.urls import reverse
from django.utils import formats, translation
from . import FormFieldAssertionsMixin
class FloatFieldTest(FormFieldAssertionsMixin, SimpleTestCase):
def test_floatfield_1(self):
f = FloatField()
self.assertWidgetRendersTo(
... | .0, f.clean("23"))
self.assertEqual(3.1400000000000001, f.clean("3.14"))
self.assertEqual(3.1400000000000001, f.clean(3.14))
self.assertEqual(42.0, f.clean(42))
with self.assertRaisesMessage(ValidationError, "'Enter a number | with self.assertRaisesMessage(ValidationError, "'This field is required.'"):
f.clean(None)
self.assertEqual(1.0, f.clean("1"))
self.assertIsInstance(f.clean("1"), float)
self.assertEqual(23 | {
"filepath": "tests/forms_tests/field_tests/test_floatfield.py",
"language": "python",
"file_size": 6473,
"cut_index": 716,
"middle_length": 229
} |
self.assertRaises(ValueError):
GenericIPAddressField(protocol="ipv4", unpack_ipv4=True)
def test_generic_ipaddress_as_generic(self):
# The edge cases of the IPv6 validation code are not deeply tested
# here, they are covered in the tests for django.utils.ipv6
f = GenericIPAddres... | f.clean("foo")
with self.assertRaisesMessage(
ValidationError, "'Enter a valid IPv4 or IPv6 address.'"
):
f.clean("127.0.0.")
with self.assertRaisesMessage(
ValidationError, "'Enter a valid IPv4 | uired.'"):
f.clean(None)
self.assertEqual(f.clean(" 127.0.0.1 "), "127.0.0.1")
with self.assertRaisesMessage(
ValidationError, "'Enter a valid IPv4 or IPv6 address.'"
):
| {
"filepath": "tests/forms_tests/field_tests/test_genericipaddressfield.py",
"language": "python",
"file_size": 9451,
"cut_index": 921,
"middle_length": 229
} |
ploadedfile import SimpleUploadedFile, TemporaryUploadedFile
from django.forms import ClearableFileInput, FileInput, ImageField, Widget
from django.test import SimpleTestCase
from . import FormFieldAssertionsMixin
try:
from PIL import Image
except ImportError:
Image = None
def get_img_path(path):
return... | mg_file:
img_data = img_file.read()
img_file = SimpleUploadedFile("1x1.png", img_data)
img_file.content_type = "text/plain"
uploaded_file = f.clean(img_file)
self.assertEqual("PNG", uploaded_file.image.format) | FieldAssertionsMixin, SimpleTestCase):
def test_imagefield_annotate_with_image_after_clean(self):
f = ImageField()
img_path = get_img_path("filepath_test_files/1x1.png")
with open(img_path, "rb") as i | {
"filepath": "tests/forms_tests/field_tests/test_imagefield.py",
"language": "python",
"file_size": 4140,
"cut_index": 614,
"middle_length": 229
} |
ormFieldAssertionsMixin, SimpleTestCase):
def test_integerfield_1(self):
f = IntegerField()
self.assertWidgetRendersTo(
f, '<input type="number" name="f" id="id_f" required>'
)
with self.assertRaisesMessage(ValidationError, "'This field is required.'"):
f.clea... | ssertRaisesMessage(ValidationError, "'Enter a whole number.'"):
f.clean(3.14)
self.assertEqual(1, f.clean("1 "))
self.assertEqual(1, f.clean(" 1"))
self.assertEqual(1, f.clean(" 1 "))
with self.assertRaisesMessag | lean("1"), int)
self.assertEqual(23, f.clean("23"))
with self.assertRaisesMessage(ValidationError, "'Enter a whole number.'"):
f.clean("a")
self.assertEqual(42, f.clean(42))
with self.a | {
"filepath": "tests/forms_tests/field_tests/test_integerfield.py",
"language": "python",
"file_size": 7430,
"cut_index": 716,
"middle_length": 229
} |
go.test.utils import captured_stderr, captured_stdout
from django.utils import translation
from django.utils.encoding import DEFAULT_LOCALE_ENCODING
from django.utils.functional import cached_property
from django.utils.translation import gettext
from .utils import RunInTmpDirMixin, copytree
has_msgfmt = find_command(... |
with self.assertRaisesMessage(
CommandError, "compilemessages generated one or more errors."
):
call_command(
"compilemessages", locale=[self.LOCALE], verbosity=0, stderr=stderr
)
| PoFileTests(MessageCompilationTests):
LOCALE = "es_AR"
MO_FILE = "locale/%s/LC_MESSAGES/django.mo" % LOCALE
MO_FILE_EN = "locale/en/LC_MESSAGES/django.mo"
def test_bom_rejection(self):
stderr = StringIO() | {
"filepath": "tests/i18n/test_compilation.py",
"language": "python",
"file_size": 14388,
"cut_index": 921,
"middle_length": 229
} |
stack, use_quotes=True):
return self._assertPoKeyword(
"msgid_plural", msgid, haystack, use_quotes=use_quotes
)
def assertMsgStr(self, msgstr, haystack, use_quotes=True):
return self._assertPoKeyword("msgstr", msgstr, haystack, use_quotes=use_quotes)
def assertNotMsgId(self... | # #: .\path\to\file.html:123
cwd_prefix = "%s%s" % (os.curdir, os.sep)
else:
# #: path/to/file.html:123
cwd_prefix = ""
path = os.path.join(cwd_prefix, *comment_parts)
parts = [path]
| .MULTILINE))
def _assertPoLocComment(
self, assert_presence, po_filename, line_number, *comment_parts
):
with open(po_filename) as fp:
po_contents = fp.read()
if os.name == "nt":
| {
"filepath": "tests/i18n/test_extraction.py",
"language": "python",
"file_size": 49902,
"cut_index": 2151,
"middle_length": 229
} |
rs", 2) % {"num": 2}, "2 years")
@override_settings(LOCALE_PATHS=extended_locale_paths)
@translation.override("fr")
def test_multiple_plurals_per_language(self):
"""
Normally, French has 2 plurals. As
other/locale/fr/LC_MESSAGES/django.po has a different plural equation
with... | po files).
self.assertEqual(french._catalog[("%d singular", 0)], "%d singulier")
self.assertEqual(french._catalog[("%(num)d hour", 0)], "%(num)d heure")
@translation.override("fr")
@skipUnless(find_command("msgfmt"), "msgfmt is man | ar", "%d plural", 1) % 1, "1 singulier")
self.assertEqual(ngettext("%d singular", "%d plural", 2) % 2, "2 pluriel2")
french = trans_real.catalog()
# Internal _catalog can query subcatalogs (from different | {
"filepath": "tests/i18n/tests.py",
"language": "python",
"file_size": 92868,
"cut_index": 3790,
"middle_length": 229
} |
"
Helper script to update sampleproject's translation catalogs.
When a bug has been identified related to i18n, this helps capture the issue
by using catalogs created from management commands.
Example:
The string "Two %% Three %%%" renders differently using translate and
blocktranslate. This issue is difficult to de... |
that is rendered using an activated language from sampleproject's locale.
* Tests should fail, issue captured.
* Fix issue.
* Run this script.
* Tests all pass.
"""
import os
import re
import sys
proj_dir = os.path.dirname(os.path.abspath(__file_ | script.
* Test extraction - verify the new msgid in sampleproject's django.po.
* Add a translation to sampleproject's django.po.
* Run this script.
* Test interpolation - verify templatetag rendering, test each in a template | {
"filepath": "tests/i18n/sampleproject/update_catalogs.py",
"language": "python",
"file_size": 1799,
"cut_index": 537,
"middle_length": 229
} |
conf.urls.i18n import i18n_patterns
from django.urls import include, path, re_path
from django.utils.translation import gettext_lazy as _
from django.views.generic import TemplateView
view = TemplateView.as_view(template_name="dummy.html")
urlpatterns = [
path("not-prefixed/", view, name="not-prefixed"),
path... | view, name="prefixed"),
path("prefixed.xml", view, name="prefixed_xml"),
re_path(
_(r"^with-arguments/(?P<argument>[\w-]+)/(?:(?P<optional>[\w-]+).html)?$"),
view,
name="with-arguments",
),
path(
_("path-wit | ranslated-regex"),
re_path(
_(r"^translated/(?P<slug>[\w-]+)/$"),
view,
{"slug": "default-slug"},
name="no-prefix-translated-slug",
),
]
urlpatterns += i18n_patterns(
path("prefixed/", | {
"filepath": "tests/i18n/patterns/urls/default.py",
"language": "python",
"file_size": 1254,
"cut_index": 524,
"middle_length": 229
} |
db.models.manager
from django.db import migrations, models
class Migration(migrations.Migration):
dependencies = [
("sites", "0001_initial"),
]
operations = [
migrations.CreateModel(
name="CustomArticle",
fields=[
(
"id",
... | tes.Site", models.CASCADE),
),
],
options={
"abstract": False,
},
managers=[
("objects", django.db.models.manager.Manager()),
(
| name="ID",
),
),
("title", models.CharField(max_length=50)),
(
"places_this_article_should_appear",
models.ForeignKey("si | {
"filepath": "tests/sites_framework/migrations/0001_initial.py",
"language": "python",
"file_size": 2969,
"cut_index": 563,
"middle_length": 229
} |
"django.contrib.messages",
"admin_checks",
],
)
class SystemChecksTestCase(SimpleTestCase):
databases = "__all__"
def test_checks_are_performed(self):
admin.site.register(Song, MyAdmin)
try:
errors = checks.run_checks()
expected = ["error!"]
... | ion.",
id="admin.E401",
),
checks.Error(
"'django.contrib.auth' must be in INSTALLED_APPS in order "
"to use the admin application.",
id="admin.E405",
),
| lf):
errors = admin.checks.check_dependencies()
expected = [
checks.Error(
"'django.contrib.contenttypes' must be in "
"INSTALLED_APPS in order to use the admin applicat | {
"filepath": "tests/admin_checks/tests.py",
"language": "python",
"file_size": 35360,
"cut_index": 2151,
"middle_length": 229
} |
Tests for the order_with_respect_to Meta attribute.
"""
from django.db import models
class Question(models.Model):
text = models.CharField(max_length=200)
class Answer(models.Model):
text = models.CharField(max_length=200)
question = models.ForeignKey(Question, models.CASCADE)
class Meta:
... | a OneToOneField primary key.
class Entity(models.Model):
pass
class Dimension(models.Model):
entity = models.OneToOneField("Entity", primary_key=True, on_delete=models.CASCADE)
class Component(models.Model):
dimension = models.ForeignKey("D | "self", models.SET_NULL, related_name="children", null=True
)
class Meta:
order_with_respect_to = "parent"
def __str__(self):
return self.title
# order_with_respect_to points to a model with | {
"filepath": "tests/order_with_respect_to/models.py",
"language": "python",
"file_size": 1098,
"cut_index": 515,
"middle_length": 229
} |
age
from django.db import models
callable_default_counter = itertools.count()
def callable_default():
return next(callable_default_counter)
temp_storage = FileSystemStorage(location=tempfile.mkdtemp())
class BoundaryModel(models.Model):
positive_integer = models.PositiveIntegerField(null=True, blank=True... | "No Preference"),
("f", "Foo"),
("b", "Bar"),
]
INTEGER_CHOICES = [
(None, "No Preference"),
(1, "Foo"),
(2, "Bar"),
]
STRING_CHOICES_WITH_NONE = [
(None, "No Preference"),
("f", "Fo | ls.IntegerField(default=42)
callable_default = models.IntegerField(default=callable_default)
class ChoiceModel(models.Model):
"""For ModelChoiceField and ModelMultipleChoiceField tests."""
CHOICES = [
("", | {
"filepath": "tests/forms_tests/models.py",
"language": "python",
"file_size": 3399,
"cut_index": 614,
"middle_length": 229
} |
boxInputTest(WidgetTest):
widget = CheckboxInput()
def test_render_empty(self):
self.check_html(
self.widget, "is_cool", "", html='<input type="checkbox" name="is_cool">'
)
def test_render_none(self):
self.check_html(
self.widget, "is_cool", None, html='<inp... | nder_value(self):
"""
Using any value that's not in ('', None, False, True) will check the
checkbox and set the 'value' attribute.
"""
self.check_html(
self.widget,
"is_cool",
"foo | '
)
def test_render_true(self):
self.check_html(
self.widget,
"is_cool",
True,
html='<input checked type="checkbox" name="is_cool">',
)
def test_re | {
"filepath": "tests/forms_tests/widget_tests/test_checkboxinput.py",
"language": "python",
"file_size": 4482,
"cut_index": 614,
"middle_length": 229
} |
eWidgetTest(WidgetTest):
widget = ChoiceWidget
@property
def nested_widgets(self):
nested_widget = self.widget(
choices=(
("outer1", "Outer 1"),
('Group "1"', (("inner1", "Inner 1"), ("inner2", "Inner 2"))),
),
)
nested_widget_... | ed_widget_dict, nested_widget_dict_tuple)
def test_deepcopy(self):
"""
__deepcopy__() should copy all attributes properly.
"""
widget = self.widget()
obj = copy.deepcopy(widget)
self.assertIsNot(widget, | widget_dict_tuple = self.widget(
choices={
"outer1": "Outer 1",
'Group "1"': (("inner1", "Inner 1"), ("inner2", "Inner 2")),
},
)
return (nested_widget, nest | {
"filepath": "tests/forms_tests/widget_tests/test_choicewidget.py",
"language": "python",
"file_size": 3150,
"cut_index": 614,
"middle_length": 229
} |
CharField, DateInput, Form
from django.utils import translation
from .base import WidgetTest
class DateInputTest(WidgetTest):
widget = DateInput()
def test_render_none(self):
self.check_html(
self.widget, "date", None, html='<input type="text" name="date">'
)
def test_rende... | -09-17">'),
)
def test_string(self):
"""
Should be able to initialize from a string value.
"""
self.check_html(
self.widget,
"date",
"2007-09-17",
html=('<input ty | ml='<input type="text" name="date" value="2007-09-17">',
)
self.check_html(
self.widget,
"date",
date(2007, 9, 17),
html=('<input type="text" name="date" value="2007 | {
"filepath": "tests/forms_tests/widget_tests/test_dateinput.py",
"language": "python",
"file_size": 2135,
"cut_index": 563,
"middle_length": 229
} |
port CharField, DateTimeInput, Form
from django.utils import translation
from .base import WidgetTest
class DateTimeInputTest(WidgetTest):
widget = DateTimeInput()
def test_render_none(self):
self.check_html(self.widget, "date", None, '<input type="text" name="date">')
def test_render_value(sel... | elf.widget,
"date",
datetime(2007, 9, 17, 12, 51, 34),
html=('<input type="text" name="date" value="2007-09-17 12:51:34">'),
)
self.check_html(
self.widget,
"date",
dat | 1:34.482548")
self.check_html(
self.widget,
"date",
d,
html=('<input type="text" name="date" value="2007-09-17 12:51:34">'),
)
self.check_html(
s | {
"filepath": "tests/forms_tests/widget_tests/test_datetimeinput.py",
"language": "python",
"file_size": 2379,
"cut_index": 563,
"middle_length": 229
} |
ort TestCase
from .models import Article, Category
class M2MMultipleTests(TestCase):
def test_multiple(self):
c1, c2, c3, c4 = [
Category.objects.create(name=name)
for name in ["Sports", "News", "Crime", "Life"]
]
a1 = Article.objects.create(
headline=... | [
"Crime",
"News",
],
lambda c: c.name,
)
self.assertQuerySetEqual(
a2.primary_categories.all(),
[
"News",
"Sports",
| eadline="Parrot runs", pub_date=datetime(2005, 11, 28)
)
a2.primary_categories.add(c1, c2)
a2.secondary_categories.add(c4)
self.assertQuerySetEqual(
a1.primary_categories.all(),
| {
"filepath": "tests/m2m_multiple/tests.py",
"language": "python",
"file_size": 2332,
"cut_index": 563,
"middle_length": 229
} |
def setUpTestData(cls):
cls.t1 = Tournament.objects.create(name="Tourney 1")
cls.t2 = Tournament.objects.create(name="Tourney 2")
cls.o1 = Organiser.objects.create(name="Organiser 1")
cls.p1 = Pool.objects.create(
name="T1 Pool 1", tournament=cls.t1, organiser=cls.o1
... | cls.p2)
cls.ps2 = PoolStyle.objects.create(name="T2 Pool 1 Style", pool=cls.p3)
cls.ps3 = PoolStyle.objects.create(
name="T1 Pool 1/3 Style", pool=cls.p1, another_pool=cls.p3
)
def test_foreign_key(self):
wi | rnament=cls.t2, organiser=cls.o1
)
cls.p4 = Pool.objects.create(
name="T2 Pool 2", tournament=cls.t2, organiser=cls.o1
)
cls.ps1 = PoolStyle.objects.create(name="T1 Pool 2 Style", pool= | {
"filepath": "tests/known_related_objects/tests.py",
"language": "python",
"file_size": 8039,
"cut_index": 716,
"middle_length": 229
} |
import forms
from .models import Company
class I18nForm(forms.Form):
decimal_field = forms.DecimalField(localize=True)
float_field = forms.FloatField(localize=True)
date_field = forms.DateField(localize=True)
datetime_field = forms.DateTimeField(localize=True)
time_field = forms.TimeField(localiz... | nts_paid = forms.DecimalField(max_digits=4, decimal_places=2, localize=True)
products_delivered = forms.IntegerField(localize=True)
date_added = forms.DateTimeField(localize=True)
class Meta:
model = Company
fields = "__all__"
| lForm):
ce | {
"filepath": "tests/i18n/forms.py",
"language": "python",
"file_size": 794,
"cut_index": 524,
"middle_length": 14
} |
mport os
from django.core.management.commands.makemessages import TranslatableFile
from django.test import SimpleTestCase
class TranslatableFileTests(SimpleTestCase):
def test_repr(self):
dirpath = "dir"
file_name = "example"
trans_file = TranslatableFile(
dirpath=dirpath, fil... | dirpath=dirpath, file_name=file_name, locale_dir=None
)
trans_file_not_eq = TranslatableFile(
dirpath="tmp", file_name=file_name, locale_dir=None
)
self.assertEqual(trans_file, trans_file_eq)
sel | test_eq(self):
dirpath = "dir"
file_name = "example"
trans_file = TranslatableFile(
dirpath=dirpath, file_name=file_name, locale_dir=None
)
trans_file_eq = TranslatableFile(
| {
"filepath": "tests/i18n/test_management.py",
"language": "python",
"file_size": 1046,
"cut_index": 513,
"middle_length": 229
} |
AGES=[
("nl", "Dutch"),
("en", "English"),
("pt-br", "Brazilian Portuguese"),
],
MIDDLEWARE=[
"django.middleware.locale.LocaleMiddleware",
"django.middleware.common.CommonMiddleware",
],
ROOT_URLCONF="i18n.patterns.urls.default",
TEMPLATES=[
{
... |
def setUp(self):
# Make sure the cache is empty before we are doing our tests.
clear_url_caches()
# Make sure we will leave an empty cache for other testcases.
self.addCleanup(clear_url_caches)
class URLPrefixTests(UR | processors": [
"django.template.context_processors.i18n",
],
},
}
],
)
class URLTestCaseBase(SimpleTestCase):
"""
TestCase base-class for the URL tests.
"""
| {
"filepath": "tests/i18n/patterns/tests.py",
"language": "python",
"file_size": 20118,
"cut_index": 1331,
"middle_length": 229
} |
b.sites.managers import CurrentSiteManager
from django.contrib.sites.models import Site
from django.core import checks
from django.db import models
from django.test import SimpleTestCase, TestCase
from django.test.utils import isolate_apps
from .models import CustomArticle, ExclusiveArticle, SyndicatedArticle
class ... | king News!", site_id=settings.SITE_ID
)
self.assertEqual(ExclusiveArticle.on_site.get(), article)
def test_sites_m2m(self):
article = SyndicatedArticle.objects.create(title="Fresh News!")
article.sites.add(Site.objects. | )
Site.objects.create(
id=settings.SITE_ID + 1, domain="example2.com", name="example2.com"
)
def test_site_fk(self):
article = ExclusiveArticle.objects.create(
title="Brea | {
"filepath": "tests/sites_framework/tests.py",
"language": "python",
"file_size": 2763,
"cut_index": 563,
"middle_length": 229
} |
r import attrgetter
from django.db import models
from django.test import SimpleTestCase, TestCase
from django.test.utils import isolate_apps
from .base_tests import BaseOrderWithRespectToTests
from .models import Answer, Dimension, Entity, Post, Question
class OrderWithRespectToBaseTests(BaseOrderWithRespectToTests... | der = models.OrderWrt()
class Meta:
order_with_respect_to = "bar"
app_label = "order_with_respect_to"
count = 0
for field in Foo._meta.local_fields:
if isinstance(field, models.Order | r_field(self):
class Bar(models.Model):
class Meta:
app_label = "order_with_respect_to"
class Foo(models.Model):
bar = models.ForeignKey(Bar, models.CASCADE)
or | {
"filepath": "tests/order_with_respect_to/tests.py",
"language": "python",
"file_size": 1477,
"cut_index": 524,
"middle_length": 229
} |
"],
html="""
<div>
<div><label><input checked type="checkbox" name="beatles" value="J"> John
</label></div>
<div><label><input type="checkbox" name="beatles" value="P"> Paul
</label></div>
<div><label><input type="checkbox" name="beatle... | <input checked type="checkbox" name="beatles" value="J"> John
</label></div>
<div><label><input checked type="checkbox" name="beatles" value="P"> Paul
</label></div>
<div><label><input type="checkbox" name="b | )
def test_render_value_multiple(self):
self.check_html(
self.widget(choices=self.beatles),
"beatles",
["J", "P"],
html="""
<div>
<div><label> | {
"filepath": "tests/forms_tests/widget_tests/test_checkboxselectmultiple.py",
"language": "python",
"file_size": 10021,
"cut_index": 921,
"middle_length": 229
} |
Input, Form
from django.utils.datastructures import MultiValueDict
from .base import WidgetTest
class FileInputTest(WidgetTest):
widget = FileInput()
def test_render(self):
"""
FileInput widgets never render the value attribute. The old value
isn't useful if a form is updated or an e... |
def test_value_omitted_from_data(self):
self.assertIs(self.widget.value_omitted_from_data({}, {}, "field"), True)
self.assertIs(
self.widget.value_omitted_from_data({}, {"field": "value"}, "field"), False
)
def |
self.check_html(
self.widget, "email", "", html='<input type="file" name="email">'
)
self.check_html(
self.widget, "email", None, html='<input type="file" name="email">'
)
| {
"filepath": "tests/forms_tests/widget_tests/test_fileinput.py",
"language": "python",
"file_size": 3464,
"cut_index": 614,
"middle_length": 229
} |
hips between the same two tables
In this example, an ``Article`` can have many "primary" ``Category`` objects
and many "secondary" ``Category`` objects.
Set ``related_name`` to designate what the reverse relationship is called.
"""
from django.db import models
class Category(models.Model):
name = models.CharFi... | tegories = models.ManyToManyField(
Category, related_name="primary_article_set"
)
secondary_categories = models.ManyToManyField(
Category, related_name="secondary_article_set"
)
class Meta:
ordering = ("pub_date",)
| pub_date = models.DateTimeField()
primary_ca | {
"filepath": "tests/m2m_multiple/models.py",
"language": "python",
"file_size": 908,
"cut_index": 547,
"middle_length": 52
} |
rt POFileAssertionMixin
SAMPLEPROJECT_DIR = os.path.join(
os.path.dirname(os.path.abspath(__file__)), "sampleproject"
)
SAMPLEPROJECT_LOCALE = os.path.join(SAMPLEPROJECT_DIR, "locale")
@override_settings(LOCALE_PATHS=[SAMPLEPROJECT_LOCALE])
class FrenchTestCase(SimpleTestCase):
"""Tests using the French tran... | rtionMixin, FrenchTestCase):
"""
Tests the extracted string found in the gettext catalog.
Percent signs are python formatted.
These tests should all have an analogous translation tests below, ensuring
the Python formatting does not pe | ._translations = trans_real._translations
activate("fr")
def tearDown(self):
trans_real._translations = self._translations
activate(self._language)
class ExtractingStringsWithPercentSigns(POFileAsse | {
"filepath": "tests/i18n/test_percents.py",
"language": "python",
"file_size": 7199,
"cut_index": 716,
"middle_length": 229
} |
source_code_dir = os.path.dirname(__file__)
def copytree(src, dst):
shutil.copytree(src, dst, ignore=shutil.ignore_patterns("__pycache__"))
class POFileAssertionMixin:
def _assertPoKeyword(self, keyword, expected_value, haystack, use_quotes=True):
q = '"'
if use_quotes:
expected_... | aystack, use_quotes=True):
return self._assertPoKeyword("msgid", msgid, haystack, use_quotes=use_quotes)
class RunInTmpDirMixin:
"""
Allow i18n tests that need to generate .po/.mo files to run in an isolated
temporary filesystem tree | re.search("^%s %s" % (keyword, expected_value), haystack, re.MULTILINE),
"Could not find %(q)s%(n)s%(q)s in generated PO file"
% {"n": needle, "q": q},
)
def assertMsgId(self, msgid, h | {
"filepath": "tests/i18n/utils.py",
"language": "python",
"file_size": 2363,
"cut_index": 563,
"middle_length": 229
} |
od
def setUpTestData(cls):
cls.q1 = cls.Question.objects.create(
text="Which Beatle starts with the letter 'R'?"
)
cls.Answer.objects.create(text="John", question=cls.q1)
cls.Answer.objects.create(text="Paul", question=cls.q1)
cls.Answer.objects.create(text="Georg... | ttrgetter("text"),
)
def test_previous_and_next_in_order(self):
# We can retrieve the answers related to a particular object, in the
# order they were created, once we have a particular object.
a1 = self.q1.answer_set.a | were inserted.
self.assertQuerySetEqual(
self.q1.answer_set.all(),
[
"John",
"Paul",
"George",
"Ringo",
],
a | {
"filepath": "tests/order_with_respect_to/base_tests.py",
"language": "python",
"file_size": 11565,
"cut_index": 921,
"middle_length": 229
} |
earableFileInputTest(WidgetTest):
def setUp(self):
self.widget = ClearableFileInput()
def test_clear_input_renders(self):
"""
A ClearableFileInput with is_required False and rendered with an
initial value that is a file renders a clear checkbox.
"""
self.check_ht... | "
A ClearableFileInput should escape name, filename, and URL
when rendering HTML (#15182).
"""
class StrangeFieldFile:
url = "something?chapter=1§=2©=3&lang=en"
def __str__(self):
| " name="myfile-clear" id="myfile-clear_id">
<label for="myfile-clear_id">Clear</label><br>
Change: <input type="file" name="myfile">
"""),
)
def test_html_escaped(self):
"" | {
"filepath": "tests/forms_tests/widget_tests/test_clearablefileinput.py",
"language": "python",
"file_size": 9209,
"cut_index": 921,
"middle_length": 229
} |
te
from django.core.exceptions import ImproperlyConfigured
from django.test import SimpleTestCase
from .models import Guest, Location, Person, Place, Traveler
class NameAdmin(admin.ModelAdmin):
list_display = ["name"]
save_on_top = True
class CustomSite(admin.AdminSite):
pass
class TestRegistration(S... | self.assertIsInstance(self.site.get_model_admin(Person), NameAdmin)
self.site.unregister(Person)
self.assertEqual(self.site._registry, {})
def test_prevent_double_registration(self):
self.site.register(Person)
msg = | _model_admin(Person), admin.ModelAdmin)
self.site.unregister(Person)
self.assertEqual(self.site._registry, {})
def test_registration_with_model_admin(self):
self.site.register(Person, NameAdmin)
| {
"filepath": "tests/admin_registration/tests.py",
"language": "python",
"file_size": 6255,
"cut_index": 716,
"middle_length": 229
} |
ystem checks logic.
"""
from django.contrib.contenttypes.fields import GenericForeignKey
from django.contrib.contenttypes.models import ContentType
from django.db import models
class Album(models.Model):
title = models.CharField(max_length=150)
class Song(models.Model):
title = models.CharField(max_length=... | models.ForeignKey(Album, models.CASCADE, related_name="album2_set")
e = models.CharField(max_length=1)
class Author(models.Model):
name = models.CharField(max_length=100)
class Book(models.Model):
name = models.CharField(max_length=100)
| return self.title
def readonly_method_on_model(self):
# does nothing
pass
class TwoAlbumFKAndAnE(models.Model):
album1 = models.ForeignKey(Album, models.CASCADE, related_name="album1_set")
album2 = | {
"filepath": "tests/admin_checks/models.py",
"language": "python",
"file_size": 1745,
"cut_index": 537,
"middle_length": 229
} |
forms.renderers import DjangoTemplates, Jinja2
from django.test import SimpleTestCase
try:
import jinja2
except ImportError:
jinja2 = None
class WidgetTest(SimpleTestCase):
beatles = (("J", "John"), ("P", "Paul"), ("G", "George"), ("R", "Ringo"))
@classmethod
def setUpClass(cls):
cls.dja... | LEqual
if self.jinja2_renderer:
output = widget.render(
name, value, attrs=attrs, renderer=self.jinja2_renderer, **kwargs
)
# Django escapes quotes with '"' while Jinja2 uses '"'.
| nderer else []
)
super().setUpClass()
def check_html(
self, widget, name, value, html="", attrs=None, strict=False, **kwargs
):
assertEqual = self.assertEqual if strict else self.assertHTM | {
"filepath": "tests/forms_tests/widget_tests/base.py",
"language": "python",
"file_size": 1403,
"cut_index": 524,
"middle_length": 229
} |
f = forms.TimeField(localize=True)
# Parse a time in an unaccepted format; get an error
with self.assertRaises(ValidationError):
f.clean("1:30:05 PM")
# Parse a time in a valid format, get a parsed result
result = f.clean("13:30:05")
self.assertEqual(result, tim... | lt)
self.assertEqual(text, "13:30:00")
def test_timeField_with_inputformat(self):
"""
TimeFields with manually specified input formats can accept those
formats
"""
f = forms.TimeField(input_formats=["%H. | in a valid format, get a parsed result
result = f.clean("13:30")
self.assertEqual(result, time(13, 30, 0))
# The parsed result does a round trip to default format
text = f.widget.format_value(resu | {
"filepath": "tests/forms_tests/tests/test_input_formats.py",
"language": "python",
"file_size": 39395,
"cut_index": 2151,
"middle_length": 229
} |
mingError, connection
from django.db.backends.base.base import NO_DB_ALIAS
from django.test import TestCase
try:
from django.contrib.gis.db.backends.postgis.operations import PostGISOperations
HAS_POSTGRES = True
except ImportError:
HAS_POSTGRES = False
class BaseSpatialFeaturesTests(TestCase):
def ... | ngs_dict = {
"NAME": "test",
}
class FakePostGISOperations(PostGISOperations):
def __init__(self, version=None):
self.version = version
self.connection = FakeConnection()
def _get_po | d_functions?"
)
with self.assertRaisesMessage(ValueError, msg):
connection.features.has_Invalid_function
if HAS_POSTGRES:
class FakeConnection:
def __init__(self):
self.setti | {
"filepath": "tests/gis_tests/tests.py",
"language": "python",
"file_size": 3920,
"cut_index": 614,
"middle_length": 229
} |
raps
from unittest import mock
from django.conf import settings
from django.contrib.gis.geos.libgeos import geos_version_tuple
from django.db import DEFAULT_DB_ALIAS, connection
from django.db.models import Func
def skipUnlessGISLookup(*gis_lookups):
"""
Skip a test unless a database supports all of gis_look... | return skip_wrapper
return decorator
_default_db = settings.DATABASES[DEFAULT_DB_ALIAS]["ENGINE"].rsplit(".")[-1]
# MySQL spatial indices can't handle NULL geometries.
gisfield_may_be_null = _default_db != "mysql"
# GEOSWKTWriter_write() behavior | ps):
raise unittest.SkipTest(
"Database doesn't support all the lookups: %s"
% ", ".join(gis_lookups)
)
return test_func(*args, **kwargs)
| {
"filepath": "tests/gis_tests/utils.py",
"language": "python",
"file_size": 2870,
"cut_index": 563,
"middle_length": 229
} |
rom .models import City, site, site_gis, site_gis_custom
@override_settings(ROOT_URLCONF="django.contrib.gis.tests.geoadmin.urls")
class GeoAdminTest(SimpleTestCase):
admin_site = site # ModelAdmin
def test_widget_empty_string(self):
geoadmin = self.admin_site.get_model_admin(City)
form = ge... |
def test_widget_invalid_string(self):
geoadmin = self.admin_site.get_model_admin(City)
form = geoadmin.get_changelist_form(None)({"point": "INVALID()"})
with self.assertLogs("django.contrib.gis", "ERROR") as cm:
out | output = str(form["point"])
self.assertInHTML(
'<textarea id="id_point" class="vSerializedField required" cols="150"'
' rows="10" name="point" hidden></textarea>',
output,
)
| {
"filepath": "tests/gis_tests/geoadmin/tests.py",
"language": "python",
"file_size": 3280,
"cut_index": 614,
"middle_length": 229
} |
test import mock
from django.contrib.gis.gdal import GDAL_VERSION, Driver, GDALException
valid_drivers = (
# vector
"ESRI Shapefile",
"MapInfo File",
"S57",
"DGN",
"Memory" if GDAL_VERSION[:2] <= (3, 10) else "MEM",
"CSV",
"GML",
"KML",
# raster
"GTiff",
"JPEG",
"ME... | riverTest(unittest.TestCase):
def test01_valid_driver(self):
"Testing valid GDAL/OGR Data Source Drivers."
for d in valid_drivers:
dr = Driver(d)
self.assertEqual(d, str(dr))
def test02_invalid_driver(self): | iFf": "GTiff",
"tIf": "GTiff",
"jPEg": "JPEG",
"jpG": "JPEG",
}
if GDAL_VERSION[:2] <= (3, 10):
aliases.update(
{
"tiger": "TIGER",
"tiger/line": "TIGER",
}
)
class D | {
"filepath": "tests/gis_tests/gdal_tests/test_driver.py",
"language": "python",
"file_size": 1974,
"cut_index": 537,
"middle_length": 229
} |
'GEOGCS["GCS_WGS_1984",DATUM["WGS_1984",SPHEROID["WGS_1984",'
'6378137,298.257223563]],PRIMEM["Greenwich",0],UNIT["Degree",'
"0.017453292519943295]]"
)
# Using a regex because of small differences depending on GDAL versions.
wgs_84_wkt_regex = r'^GEOGCS\["(GCS_)?WGS[ _](19)?84".*$'
datetime_format = "%Y-%m-%... | [float(i) for i in range(1, 6)],
"int": list(range(1, 6)),
"str": [str(i) for i in range(1, 6)],
},
fids=range(5),
),
TestDS(
"test_vrt",
ext="vrt",
nfeat=3,
nfld=3,
ge | file",
fields={"dbl": OFTReal, "int": OFTInteger, "str": OFTString},
extent=(-1.35011, 0.166623, -0.524093, 0.824508), # Got extent from QGIS
srs_wkt=wgs_84_wkt,
field_values={
"dbl": | {
"filepath": "tests/gis_tests/gdal_tests/test_ds.py",
"language": "python",
"file_size": 13800,
"cut_index": 921,
"middle_length": 229
} |
f __init__(self, x, y):
self.x = x
self.y = y
class EnvelopeTest(unittest.TestCase):
def setUp(self):
self.e = Envelope(0, 0, 5, 5)
def test01_init(self):
"Testing Envelope initialization."
e1 = Envelope((0, 0, 5, 5))
Envelope(0, 0, 5, 5)
Envelope(0, "0... | eError):
Envelope(0, "a", 5, 5)
with self.assertRaises(TypeError):
Envelope("foo")
with self.assertRaises(GDALException):
Envelope((1, 1, 0, 0))
# Shouldn't raise an exception for min_x == max_x o | n):
Envelope(5, 5, 0, 0)
with self.assertRaises(GDALException):
Envelope((0, 0, 5, 5, 3))
with self.assertRaises(GDALException):
Envelope(())
with self.assertRaises(Valu | {
"filepath": "tests/gis_tests/gdal_tests/test_envelope.py",
"language": "python",
"file_size": 3638,
"cut_index": 614,
"middle_length": 229
} |
"), OGRGeomType(6))
# Testing the Django field name equivalent property.
self.assertEqual("PointField", OGRGeomType("Point").django)
self.assertEqual("GeometryField", OGRGeomType("Geometry").django)
self.assertEqual("GeometryField", OGRGeomType("Unknown").django)
self.assertIsNo... | wkb25bit = OGRGeomType.wkb25bit
self.assertEqual(OGRGeomType(wkb25bit + 1), "Point25D")
self.assertEqual(OGRGeomType("MultiLineString25D"), (5 + wkb25bit))
self.assertEqual(
"GeometryCollectionField", OGRGeomType( | rtEqual("Unknown", gt.name)
def test_geom_type_repr(self):
self.assertEqual(repr(OGRGeomType("point")), "<OGRGeomType: Point>")
def test_geomtype_25d(self):
"Testing OGRGeomType object with 25D types."
| {
"filepath": "tests/gis_tests/gdal_tests/test_geom.py",
"language": "python",
"file_size": 45150,
"cut_index": 2151,
"middle_length": 229
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.