prefix stringlengths 512 512 | suffix stringlengths 256 256 | middle stringlengths 14 229 | meta dict |
|---|---|---|---|
ip_longest
from django.utils.functional import Promise
__all__ = [
"BaseChoiceIterator",
"BlankChoiceIterator",
"CallableChoiceIterator",
"flatten_choices",
"normalize_choices",
]
class BaseChoiceIterator:
"""Base class for lazy iterators for choices."""
def __eq__(self, other):
... | slice(self, index, index + 1))
except StopIteration:
raise IndexError("index out of range") from None
def __iter__(self):
raise NotImplementedError(
"BaseChoiceIterator subclasses must implement __iter__()."
|
if isinstance(index, slice) or index < 0:
# Suboptimally consume whole iterator to handle slices and negative
# indexes.
return list(self)[index]
try:
return next(i | {
"filepath": "django/utils/choices.py",
"language": "python",
"file_size": 4202,
"cut_index": 614,
"middle_length": 229
} |
mport warnings
from django.conf import settings
from django.utils.deprecation import RemovedInDjango70Warning, django_file_prefixes
from django.utils.encoding import force_bytes
class InvalidAlgorithm(ValueError):
"""Algorithm is not supported by hashlib."""
pass
# RemovedInDjango70Warning: algorithm="sha... | hm to silence the warning.
A different key_salt should be passed in for every application of HMAC.
"""
if algorithm is None:
warnings.warn(
"The default argument for algorithm in salted_hmac() will change "
"fro | SECRET_KEY). Default algorithm is SHA1,
but any algorithm name supported by hashlib can be passed.
Removed in Django70Warning: The default algorithm will change to SHA256
in Django 7.0, so provide an explicit algorit | {
"filepath": "django/utils/crypto.py",
"language": "python",
"file_size": 3347,
"cut_index": 614,
"middle_length": 229
} |
ove(item)
except KeyError:
pass
def __iter__(self):
return iter(self.dict)
def __reversed__(self):
return reversed(self.dict)
def __contains__(self, item):
return item in self.dict
def __bool__(self):
return bool(self.dict)
def __len__(self):
... | tion': ['Developer']}
... )
>>> d['name']
'Simon'
>>> d.getlist('name')
['Adrian', 'Simon']
>>> d.getlist('doesnotexist')
[]
>>> d.getlist('doesnotexist', ['Adrian', 'Simon'])
['Adrian', 'Simon']
>>> d.get('lastname' | eyError(KeyError):
pass
class MultiValueDict(dict):
"""
A subclass of dictionary customized to handle multiple values for the
same key.
>>> d = MultiValueDict(
... {'name': ['Adrian', 'Simon'], 'posi | {
"filepath": "django/utils/datastructures.py",
"language": "python",
"file_size": 10863,
"cut_index": 921,
"middle_length": 229
} |
The date/datetime/time constructors produce friendlier error messages.
import datetime
from django.utils.regex_helper import _lazy_re_compile
from django.utils.timezone import get_fixed_timezone
date_re = _lazy_re_compile(r"(?P<year>\d{4})-(?P<month>\d{1,2})-(?P<day>\d{1,2})$")
time_re = _lazy_re_compile(
r"(?P... | r"^"
r"(?:(?P<days>-?\d+) (days?, )?)?"
r"(?P<sign>-?)"
r"((?:(?P<hours>\d+):)(?=\d+:\d+))?"
r"(?:(?P<minutes>\d+):)?"
r"(?P<seconds>\d+)"
r"(?:[.,](?P<microseconds>\d{1,6})\d{0,6})?"
r"$"
)
# Support the sections of ISO 8601 | y>\d{1,2})"
r"[T ](?P<hour>\d{1,2}):(?P<minute>\d{1,2})"
r"(?::(?P<second>\d{1,2})(?:[.,](?P<microsecond>\d{1,6})\d{0,6})?)?"
r"\s*(?P<tzinfo>Z|[+-]\d{2}(?::?\d{2})?)?$"
)
standard_duration_re = _lazy_re_compile(
| {
"filepath": "django/utils/dateparse.py",
"language": "python",
"file_size": 5414,
"cut_index": 716,
"middle_length": 229
} |
ils.version import get_docs_version
def deconstructible(*args, path=None):
"""
Class decorator that allows the decorated class to be serialized
by the migrations subsystem.
The `path` kwarg specifies the import path.
"""
def decorator(klass):
def __new__(cls, *args, **kwargs):
... | ) is klass:
module_name, _, name = path.rpartition(".")
else:
module_name = obj.__module__
name = obj.__class__.__name__
# Make sure it's actually there and not an inner class
| def deconstruct(obj):
"""
Return a 3-tuple of class import path, positional arguments,
and keyword arguments.
"""
# Fallback version
if path and type(obj | {
"filepath": "django/utils/deconstruct.py",
"language": "python",
"file_size": 2126,
"cut_index": 563,
"middle_length": 229
} |
cache, it is possible to avoid running get_format_modules
# repeatedly.
_format_cache = {}
_format_modules_cache = {}
ISO_INPUT_FORMATS = {
"DATE_INPUT_FORMATS": ["%Y-%m-%d"],
"TIME_INPUT_FORMATS": ["%H:%M:%S", "%H:%M:%S.%f", "%H:%M"],
"DATETIME_INPUT_FORMATS": [
"%Y-%m-%d %H:%M:%S",
"%Y-%... | "DATE_INPUT_FORMATS",
"TIME_INPUT_FORMATS",
"DATETIME_INPUT_FORMATS",
]
)
def reset_format_cache():
"""Clear any cached formats.
This method is provided primarily for testing purposes,
so that the effects of cached f | NG",
"FIRST_DAY_OF_WEEK",
"MONTH_DAY_FORMAT",
"TIME_FORMAT",
"DATE_FORMAT",
"DATETIME_FORMAT",
"SHORT_DATE_FORMAT",
"SHORT_DATETIME_FORMAT",
"YEAR_MONTH_FORMAT",
| {
"filepath": "django/utils/formats.py",
"language": "python",
"file_size": 10255,
"cut_index": 921,
"middle_length": 229
} |
method(classmethod):
def __get__(self, instance, cls=None):
if instance is not None:
raise AttributeError(
"This method is available only on the class, not on instances."
)
return super().__get__(instance, cls)
def _update_method_wrapper(_wrapper, decorator)... | decorators, "__iter__"):
# Apply a list/tuple of decorators if 'decorators' is one. Decorator
# functions are applied so that the call order is the same as the
# order in which they appear in the iterable.
decorators = decor | pper(_wrapper, dummy)
def _multi_decorate(decorators, method):
"""
Decorate `method` with one or more function decorators. `decorators` can be
a single decorator or an iterable of decorators.
"""
if hasattr( | {
"filepath": "django/utils/decorators.py",
"language": "python",
"file_size": 8322,
"cut_index": 716,
"middle_length": 229
} |
datetime
def _get_duration_components(duration):
days = duration.days
seconds = duration.seconds
microseconds = duration.microseconds
minutes = seconds // 60
seconds %= 60
hours = minutes // 60
minutes %= 60
return days, hours, minutes, seconds, microseconds
def duration_string(d... | duration < datetime.timedelta(0):
sign = "-"
duration *= -1
else:
sign = ""
days, hours, minutes, seconds, microseconds = _get_duration_components(duration)
ms = ".{:06d}".format(microseconds) if microseconds else ""
| :02d}".format(hours, minutes, seconds)
if days:
string = "{} ".format(days) + string
if microseconds:
string += ".{:06d}".format(microseconds)
return string
def duration_iso_string(duration):
if | {
"filepath": "django/utils/duration.py",
"language": "python",
"file_size": 1230,
"cut_index": 518,
"middle_length": 229
} |
m .base import (
clear_script_prefix,
clear_url_caches,
get_script_prefix,
get_urlconf,
is_valid_path,
resolve,
reverse,
reverse_lazy,
set_script_prefix,
set_urlconf,
translate_url,
)
from .conf import include, path, re_path
from .converters import register_converter
from .ex... | ,
"get_callable",
"get_mod_func",
"get_ns_resolver",
"get_resolver",
"get_script_prefix",
"get_urlconf",
"include",
"is_valid_path",
"path",
"re_path",
"register_converter",
"resolve",
"reverse",
"rev | .utils import get_callable, get_mod_func
__all__ = [
"LocalePrefixPattern",
"NoReverseMatch",
"URLPattern",
"URLResolver",
"Resolver404",
"ResolverMatch",
"clear_script_prefix",
"clear_url_caches" | {
"filepath": "django/urls/__init__.py",
"language": "python",
"file_size": 1079,
"cut_index": 515,
"middle_length": 229
} |
le
from django.core.exceptions import ImproperlyConfigured
from .resolvers import (
LocalePrefixPattern,
RegexPattern,
RoutePattern,
URLPattern,
URLResolver,
)
def include(arg, namespace=None):
app_name = None
if isinstance(arg, tuple):
# Callable returning a namespace hint.
... | "2-tuple containing the list of patterns and app_name, and "
"provide the namespace argument to include() instead." % len(arg)
)
else:
# No namespace hint - use manually provided namespace.
urlconf_module = | mespace for a dynamic module that "
"provides a namespace."
)
raise ImproperlyConfigured(
"Passing a %d-tuple to include() is not supported. Pass a "
| {
"filepath": "django/urls/conf.py",
"language": "python",
"file_size": 3426,
"cut_index": 614,
"middle_length": 229
} |
django.utils.regex_helper import _lazy_re_compile, normalize
from django.utils.translation import get_language
from .converters import get_converters
from .exceptions import NoReverseMatch, Resolver404
from .utils import get_callable
class ResolverMatch:
def __init__(
self,
func,
args,
... | _kwargs = extra_kwargs
# If a URLRegexResolver doesn't have a namespace or app_name, it passes
# in an empty value.
self.app_names = [x for x in app_names if x] if app_names else []
self.app_name = ":".join(self.app_names)
| self.func = func
self.args = args
self.kwargs = kwargs
self.url_name = url_name
self.route = route
self.tried = tried
self.captured_kwargs = captured_kwargs
self.extra | {
"filepath": "django/urls/resolvers.py",
"language": "python",
"file_size": 32056,
"cut_index": 1331,
"middle_length": 229
} |
e_template_fragment_key
from django.template import Library, Node, TemplateSyntaxError, VariableDoesNotExist
register = Library()
class CacheNode(Node):
def __init__(self, nodelist, expire_time_var, fragment_name, vary_on, cache_name):
self.nodelist = nodelist
self.expire_time_var = expire_time_v... | is not None:
try:
expire_time = int(expire_time)
except (ValueError, TypeError):
raise TemplateSyntaxError(
'"cache" tag got a non-integer timeout value: %r' % expire_time
| pire_time_var.resolve(context)
except VariableDoesNotExist:
raise TemplateSyntaxError(
'"cache" tag got an unknown variable: %r' % self.expire_time_var.var
)
if expire_time | {
"filepath": "django/templatetags/cache.py",
"language": "python",
"file_size": 3550,
"cut_index": 614,
"middle_length": 229
} |
ib import Path
from django.core.exceptions import SuspiciousFileOperation
# Copied verbatim (minus `os.path` fixes) from:
# https://github.com/python/cpython/pull/23901.
# Python versions >= PY315 may include this fix, so periodic checks are needed
# to remove this vendored copy of `makedirs` once solved upstream.
d... | alse. Otherwise no exception is
raised. If parent_mode is not None, it will be used as the mode for any
newly-created, intermediate-level directories. Otherwise, intermediate
directories are created with the default permissions (respecting uma | intermediate ones. Works like
mkdir, except that any intermediate path segment (not just the rightmost)
will be created if it does not exist. If the target directory already
exists, raise an OSError if exist_ok is F | {
"filepath": "django/utils/_os.py",
"language": "python",
"file_size": 4853,
"cut_index": 614,
"middle_length": 229
} |
take
into account when building its cache key. Requests with the same path but
different header content for headers named in "Vary" need to get different
cache keys to prevent delivery of wrong content.
An example: i18n middleware would need to distinguish caches by the
"Accept-language" header.
"""
import time
from ... | ezone_name
from django.utils.translation import get_language
cc_delim_re = _lazy_re_compile(r"\s*,\s*")
def patch_cache_control(response, **kwargs):
"""
Patch the Cache-Control header by adding all keyword arguments to it.
The transformation | django.utils.http import http_date, parse_etags, parse_http_date_safe, quote_etag
from django.utils.log import log_response
from django.utils.regex_helper import _lazy_re_compile
from django.utils.timezone import get_current_tim | {
"filepath": "django/utils/cache.py",
"language": "python",
"file_size": 16589,
"cut_index": 921,
"middle_length": 229
} |
rom django.utils.html import format_html
# Template context key for the CSP nonce.
CONTEXT_KEY = "csp_nonce"
class CSP(StrEnum):
"""
Content Security Policy constants for directive values and special tokens.
These constants represent:
1. Standard quoted string values from the CSP spec (e.g., 'self',... |
Example usage in Django settings:
SECURE_CSP = {
"default-src": [CSP.NONE],
"script-src": [CSP.SELF, CSP.NONCE],
}
"""
# HTTP Headers.
HEADER_ENFORCE = "Content-Security-Policy"
HEADER_REPORT | tion, and protection against common mistakes like:
- Typos (e.g., 'noone' instead of 'none')
- Missing quotes (e.g., ["self"] instead of ["'self'"])
- Inconsistent quote styles (e.g., ["'self'", "\"unsafe-inline\""]) | {
"filepath": "django/utils/csp.py",
"language": "python",
"file_size": 3971,
"cut_index": 614,
"middle_length": 229
} |
translation import gettext_lazy as _
from django.utils.translation import pgettext_lazy
WEEKDAYS = {
0: _("Monday"),
1: _("Tuesday"),
2: _("Wednesday"),
3: _("Thursday"),
4: _("Friday"),
5: _("Saturday"),
6: _("Sunday"),
}
WEEKDAYS_ABBR = {
0: _("Mon"),
1: _("Tue"),
2: _("Wed"),... | ay"),
6: _("jun"),
7: _("jul"),
8: _("aug"),
9: _("sep"),
10: _("oct"),
11: _("nov"),
12: _("dec"),
}
MONTHS_AP = { # month names in Associated Press style
1: pgettext_lazy("abbrev. month", "Jan."),
2: pgettext_lazy("ab | ne"),
7: _("July"),
8: _("August"),
9: _("September"),
10: _("October"),
11: _("November"),
12: _("December"),
}
MONTHS_3 = {
1: _("jan"),
2: _("feb"),
3: _("mar"),
4: _("apr"),
5: _("m | {
"filepath": "django/utils/dates.py",
"language": "python",
"file_size": 2179,
"cut_index": 563,
"middle_length": 229
} |
b.parse import urlparse
from django.forms.utils import flatatt
from django.utils.encoding import iri_to_uri
from django.utils.xmlutils import SimplerXMLGenerator
def rfc2822_date(date):
if not isinstance(date, datetime.datetime):
date = datetime.datetime.combine(date, datetime.time())
return email.ut... | bits = urlparse(url)
d = ""
if date is not None:
d = ",%s" % date.strftime("%Y-%m-%d")
return "tag:%s%s:%s/%s" % (bits.hostname, d, bits.path, bits.fragment)
def _guess_stylesheet_mimetype(url):
"""
Return the given stylesheet | + ("Z" if date.utcoffset() is None else "")
def get_tag_uri(url, date):
"""
Create a TagURI.
See
https://web.archive.org/web/20110514113830/http://diveintomark.org/archives/2004/05/28/howto-atom-id
"""
| {
"filepath": "django/utils/feedgenerator.py",
"language": "python",
"file_size": 18069,
"cut_index": 1331,
"middle_length": 229
} |
ror(UnicodeDecodeError):
def __str__(self):
return "%s. You passed in %r (%s)" % (
super().__str__(),
self.object,
type(self.object),
)
def smart_str(s, encoding="utf-8", strings_only=False, errors="strict"):
"""
Return a string representing 's'. Treat b... |
)
def is_protected_type(obj):
"""Determine if the object instance is of a protected type.
Objects of protected types are preserved as-is when passed to
force_str(strings_only=True).
"""
return isinstance(obj, _PROTECTED_TYPES)
def | of a gettext_lazy() call.
return s
return force_str(s, encoding, strings_only, errors)
_PROTECTED_TYPES = (
NoneType,
int,
float,
Decimal,
datetime.datetime,
datetime.date,
datetime.time, | {
"filepath": "django/utils/encoding.py",
"language": "python",
"file_size": 8793,
"cut_index": 716,
"middle_length": 229
} |
import override
from .exceptions import NoReverseMatch, Resolver404
from .resolvers import _get_cached_resolver, get_ns_resolver, get_resolver
from .utils import get_callable
# SCRIPT_NAME prefixes for each thread are stored here. If there's no entry for
# the current thread (which is the only one we ever access), i... | f is None:
urlconf = get_urlconf()
resolver = get_resolver(urlconf)
args = args or []
kwargs = kwargs or {}
prefix = get_script_prefix()
if not isinstance(viewname, str):
view = viewname
else:
*path, view = | rlconf = get_urlconf()
return get_resolver(urlconf).resolve(path)
def reverse(
viewname,
urlconf=None,
args=None,
kwargs=None,
current_app=None,
*,
query=None,
fragment=None,
):
if urlcon | {
"filepath": "django/urls/base.py",
"language": "python",
"file_size": 6191,
"cut_index": 716,
"middle_length": 229
} |
ools
import uuid
class IntConverter:
regex = "[0-9]+"
def to_python(self, value):
return int(value)
def to_url(self, value):
return str(value)
class StringConverter:
regex = "[^/]+"
def to_python(self, value):
return value
def to_url(self, value):
return v... | verter(),
"slug": SlugConverter(),
"str": StringConverter(),
"uuid": UUIDConverter(),
}
REGISTERED_CONVERTERS = {}
def register_converter(converter, type_name):
if type_name in REGISTERED_CONVERTERS or type_name in DEFAULT_CONVERTERS:
| lue):
return str(value)
class SlugConverter(StringConverter):
regex = "[-a-zA-Z0-9_]+"
class PathConverter(StringConverter):
regex = ".+"
DEFAULT_CONVERTERS = {
"int": IntConverter(),
"path": PathCon | {
"filepath": "django/urls/converters.py",
"language": "python",
"file_size": 1358,
"cut_index": 524,
"middle_length": 229
} |
os
from asyncio import get_running_loop
from functools import wraps
from django.core.exceptions import SynchronousOnlyOperation
def async_unsafe(message):
"""
Decorator to mark functions as async-unsafe. Someone trying to access
the function while in an async context will get an error message.
"""
... | return func(*args, **kwargs)
return inner
# If the message is actually a function, then be a no-arguments decorator.
if callable(message):
func = message
message = (
"You cannot call this from an asyn | except RuntimeError:
pass
else:
if not os.environ.get("DJANGO_ALLOW_ASYNC_UNSAFE"):
raise SynchronousOnlyOperation(message)
# Pass onward.
| {
"filepath": "django/utils/asyncio.py",
"language": "python",
"file_size": 1138,
"cut_index": 518,
"middle_length": 229
} |
mport settings as django_settings
from django.utils.functional import cached_property
class ConnectionProxy:
"""Proxy for accessing a connection object's attributes."""
def __init__(self, connections, alias):
self.__dict__["_connections"] = connections
self.__dict__["_alias"] = alias
def... | n self._connections[self._alias] == other
class ConnectionDoesNotExist(Exception):
pass
class BaseConnectionHandler:
settings_name = None
exception_class = ConnectionDoesNotExist
thread_critical = False
def __init__(self, settings= | ue)
def __delattr__(self, name):
return delattr(self._connections[self._alias], name)
def __contains__(self, key):
return key in self._connections[self._alias]
def __eq__(self, other):
retur | {
"filepath": "django/utils/connection.py",
"language": "python",
"file_size": 2554,
"cut_index": 563,
"middle_length": 229
} |
.path.dirname(file), ""),)
class RemovedInDjango70Warning(DeprecationWarning):
pass
class RemovedInDjango71Warning(PendingDeprecationWarning):
pass
RemovedInNextVersionWarning = RemovedInDjango70Warning
RemovedAfterNextVersionWarning = RemovedInDjango71Warning
def warn_about_external_use(
message,
... | re). By default, this is the third frame from the top
(ignoring this helper plus the call site).
Provide `skip_name_prefixes` (a string or tuple of strings) to skip
additional frames by prefix-matching each frame's fully qualified name
(do | ing when called from within Django, to avoid cascading
warnings when one deprecated feature is implemented on top of another.
Examine the stack to determine the "effective caller" (the code using the
deprecated featu | {
"filepath": "django/utils/deprecation.py",
"language": "python",
"file_size": 15599,
"cut_index": 921,
"middle_length": 229
} |
r(self, context):
lang_code = self.lang_code.resolve(context)
context[self.variable] = translation.get_language_info(lang_code)
return ""
class GetLanguageInfoListNode(Node):
def __init__(self, languages, variable):
self.languages = languages
self.variable = variable
d... | ontext[self.variable] = [self.get_language_info(lang) for lang in langs]
return ""
class GetCurrentLanguageNode(Node):
def __init__(self, variable):
self.variable = variable
def render(self, context):
context[self.variabl | return translation.get_language_info(language[0])
else:
return translation.get_language_info(str(language))
def render(self, context):
langs = self.languages.resolve(context)
c | {
"filepath": "django/templatetags/i18n.py",
"language": "python",
"file_size": 19961,
"cut_index": 1331,
"middle_length": 229
} |
e
from django.core.exceptions import ViewDoesNotExist
from django.utils.module_loading import module_has_submodule
@functools.cache
def get_callable(lookup_view):
"""
Return a callable corresponding to lookup_view.
* If lookup_view is already a callable, return it.
* If lookup_view is a string import... | up_view)
if not func_name: # No '.' in lookup_view
raise ImportError(
"Could not import '%s'. The path must be fully qualified." % lookup_view
)
try:
mod = import_module(mod_name)
except ImportError:
| return lookup_view
if not isinstance(lookup_view, str):
raise ViewDoesNotExist(
"'%s' is not a callable or a dot-notation path" % lookup_view
)
mod_name, func_name = get_mod_func(look | {
"filepath": "django/urls/utils.py",
"language": "python",
"file_size": 2179,
"cut_index": 563,
"middle_length": 229
} |
raise TypeError(
"Cannot use cached_property instance without calling "
"__set_name__() on it."
)
def __init__(self, func):
self.real_func = func
self.__doc__ = getattr(func, "__doc__")
def __set_name__(self, owner, name):
if self.name is None:
... | attribute access on the instance returns the cached value
instead of calling cached_property.__get__().
"""
if instance is None:
return self
res = instance.__dict__[self.name] = self.func(instance)
return | names "
"(%r and %r)." % (self.name, name)
)
def __get__(self, instance, cls=None):
"""
Call the function and put the return value in instance.__dict__ so that
subsequent | {
"filepath": "django/utils/functional.py",
"language": "python",
"file_size": 14782,
"cut_index": 921,
"middle_length": 229
} |
,
MONTHS_3,
MONTHS_ALT,
MONTHS_AP,
WEEKDAYS,
WEEKDAYS_ABBR,
)
from django.utils.regex_helper import _lazy_re_compile
from django.utils.timezone import (
_datetime_ambiguous_or_imaginary,
get_default_timezone,
is_naive,
make_aware,
)
from django.utils.translation import gettext as _
... | "The format for date objects may not contain "
"time-related format specifiers (found '%s')." % piece
)
pieces.append(str(getattr(self, piece)()))
elif piece:
| ces = []
for i, piece in enumerate(re_formatchars.split(str(formatstr))):
if i % 2:
if type(self.data) is date and hasattr(TimeFormat, piece):
raise TypeError(
| {
"filepath": "django/utils/dateformat.py",
"language": "python",
"file_size": 10159,
"cut_index": 921,
"middle_length": 229
} |
e import datetime
from django.test import TestCase
from .models import Article, Reporter, Writer
class M2MIntermediaryTests(TestCase):
def test_intermediary(self):
r1 = Reporter.objects.create(first_name="John", last_name="Smith")
r2 = Reporter.objects.create(first_name="Jane", last_name="Doe")
... | ("John Smith", "Main writer"),
("Jane Doe", "Contributor"),
],
lambda w: (str(w.reporter), w.position),
)
self.assertEqual(w1.reporter, r1)
self.assertEqual(w2.reporter, r2)
| writer")
w2 = Writer.objects.create(reporter=r2, article=a, position="Contributor")
self.assertQuerySetEqual(
a.writer_set.select_related("reporter", "article").order_by("-position"),
[
| {
"filepath": "tests/m2m_intermediary/tests.py",
"language": "python",
"file_size": 1262,
"cut_index": 524,
"middle_length": 229
} |
lenium import SeleniumTestCase
from django.test.utils import modify_settings, override_settings
from django.utils.csp import CSP
from .views import csp_reports
@override_settings(
MIDDLEWARE=["django.middleware.csp.ContentSecurityPolicyMiddleware"],
ROOT_URLCONF="middleware.urls",
)
class CSPMiddlewareTest(S... | URE_CSP set to a valid value, the middleware adds a
"Content-Security-Policy" header to the response.
"""
response = self.client.get("/csp-base/")
self.assertEqual(response[CSP.HEADER_ENFORCE], basic_policy)
self.ass | tIn(CSP.HEADER_ENFORCE, response)
self.assertNotIn(CSP.HEADER_REPORT_ONLY, response)
@override_settings(SECURE_CSP=basic_config, SECURE_CSP_REPORT_ONLY=None)
def test_csp_basic(self):
"""
With SEC | {
"filepath": "tests/middleware/test_csp.py",
"language": "python",
"file_size": 7434,
"cut_index": 716,
"middle_length": 229
} |
self):
return {"wsgi.url_scheme": "https"}
def response(self, *args, headers=None, **kwargs):
def get_response(req):
response = HttpResponse(*args, **kwargs)
if headers:
for k, v in headers.items():
response.headers[k] = v
retu... | return ret
return self.middleware(*args, **kwargs)(request)
request = RequestFactory()
def process_request(self, method, *args, secure=False, **kwargs):
if secure:
kwargs.update(self.secure_request_kwargs)
| .update(self.secure_request_kwargs)
if request is None:
request = self.request.get("/some/url", **request_kwargs)
ret = self.middleware(*args, **kwargs).process_request(request)
if ret:
| {
"filepath": "tests/middleware/test_security.py",
"language": "python",
"file_size": 12079,
"cut_index": 921,
"middle_length": 229
} |
self):
"""
Matches to explicit slashless URLs should go unmolested.
"""
def get_response(req):
return HttpResponse("Here's the text of the web page.")
request = self.rf.get("/noslash")
self.assertIsNone(CommonMiddleware(get_response).process_request(request)... | 04)(request)
self.assertEqual(response.status_code, 404)
@override_settings(APPEND_SLASH=True)
def test_append_slash_redirect(self):
"""
APPEND_SLASH should redirect slashless URLs to a valid pattern.
"""
re | def test_append_slash_slashless_unknown(self):
"""
APPEND_SLASH should not redirect to unknown resources.
"""
request = self.rf.get("/unknown")
response = CommonMiddleware(get_response_4 | {
"filepath": "tests/middleware/tests.py",
"language": "python",
"file_size": 47177,
"cut_index": 2151,
"middle_length": 229
} |
rom django.urls import path, re_path
from . import views
urlpatterns = [
path("noslash", views.empty_view),
path("slash/", views.empty_view),
path("needsquoting#/", views.empty_view),
# Accepts paths with two leading slashes.
re_path(r"^(.+)/security/$", views.empty_view),
# Should not append ... | led_enforced),
path("csp-disabled-report-only/", views.csp_disabled_ro),
path("csp-override-both/", views.csp_override_both),
path("csp-override-enforced/", views.csp_override_enforced),
path("csp-override-report-only/", views.csp_override_ | ("csp-report/", views.csp_report_view),
path("csp-base/", views.empty_view),
path("csp-nonce/", views.csp_nonce),
path("csp-disabled-both/", views.csp_disabled_both),
path("csp-disabled-enforced/", views.csp_disab | {
"filepath": "tests/middleware/urls.py",
"language": "python",
"file_size": 1051,
"cut_index": 513,
"middle_length": 229
} |
pResponse
from django.middleware.csp import get_nonce
from django.utils.csp import CSP
from django.utils.decorators import method_decorator
from django.views.debug import default_urlconf, technical_500_response
from django.views.decorators.common import no_append_slash
from django.views.decorators.csp import csp_overri... | se()
def csp_nonce(request):
return HttpResponse(get_nonce(request))
@csp_override({})
def csp_disabled_enforced(request):
return HttpResponse()
@csp_report_only_override({})
def csp_disabled_ro(request):
return HttpResponse()
@csp_over | @no_append_slash
def sensitive_fbv(request, *args, **kwargs):
return HttpResponse()
@method_decorator(no_append_slash, name="dispatch")
class SensitiveCBV(View):
def get(self, *args, **kwargs):
return HttpRespon | {
"filepath": "tests/middleware/views.py",
"language": "python",
"file_size": 2208,
"cut_index": 563,
"middle_length": 229
} |
ptions import SuspiciousOperation
from django.test import SimpleTestCase
from django.utils import archive
try:
import bz2 # NOQA
HAS_BZ2 = True
except ImportError:
HAS_BZ2 = False
try:
import lzma # NOQA
HAS_LZMA = True
except ImportError:
HAS_LZMA = False
class TestArchive(unittest.Test... | if (entry.name.endswith(".bz2") and not HAS_BZ2) or (
entry.name.endswith((".lzma", ".xz")) and not HAS_LZMA
):
continue
archive.extract(entry.path, tmp | hdir, old_cwd)
def test_extract_function(self):
with os.scandir(self.testdir) as entries:
for entry in entries:
with self.subTest(entry.name), tempfile.TemporaryDirectory() as tmpdir:
| {
"filepath": "tests/utils_tests/test_archive.py",
"language": "python",
"file_size": 4652,
"cut_index": 614,
"middle_length": 229
} |
)
def assertFileNotFound(self, filename):
resolved_filename = filename.resolve(strict=True)
self.clear_autoreload_caches()
# Test uncached access
self.assertNotIn(
resolved_filename, list(autoreload.iter_all_python_module_files())
)
# Test cached access
... | filename in autoreload.iter_all_python_module_files():
self.assertIsInstance(filename, Path)
def test_file_added(self):
"""
When a file is added, it's returned by iter_all_python_module_files().
"""
filenam | 1)
def temporary_file(self, filename):
dirname = tempfile.mkdtemp()
self.addCleanup(shutil.rmtree, dirname)
return Path(dirname) / filename
def test_paths_are_pathlib_instances(self):
for | {
"filepath": "tests/utils_tests/test_autoreload.py",
"language": "python",
"file_size": 38497,
"cut_index": 2151,
"middle_length": 229
} |
i, f"Item #{i}") for i in range(1, 4))
class ChoiceIteratorTests(SimpleTestCase):
def test_not_implemented_error_on_missing_iter(self):
class InvalidChoiceIterator(BaseChoiceIterator):
pass # Not overriding __iter__().
msg = "BaseChoiceIterator subclasses must implement __iter__()."
... | ))
def test_not_equal_subset(self):
self.assertNotEqual(SimpleChoiceIterator(), [(1, "Item #1"), (2, "Item #2")])
def test_not_equal_superset(self):
self.assertNotEqual(
SimpleChoiceIterator(),
[(1, "Item # | #3")]
self.assertEqual(SimpleChoiceIterator(), unrolled)
self.assertEqual(unrolled, SimpleChoiceIterator())
def test_eq_instances(self):
self.assertEqual(SimpleChoiceIterator(), SimpleChoiceIterator( | {
"filepath": "tests/utils_tests/test_choices.py",
"language": "python",
"file_size": 14017,
"cut_index": 921,
"middle_length": 229
} |
eprecation import RemovedInDjango70Warning
class TestUtilsCryptoMisc(SimpleTestCase):
def test_constant_time_compare(self):
# It's hard to test for constant time, just test the result.
self.assertTrue(constant_time_compare(b"spam", b"spam"))
self.assertFalse(constant_time_compare(b"spam", ... | (self):
tests = [
(
(b"salt", b"value"),
{"algorithm": "sha1"},
"b51a2e619c43b1ca4f91d15c57455521d71d61eb",
),
(
("salt", "value"),
| "spam"))
self.assertFalse(constant_time_compare("spam", b"eggs"))
self.assertTrue(constant_time_compare("ありがとう", "ありがとう"))
self.assertFalse(constant_time_compare("ありがとう", "おはよう"))
def test_salted_hmac | {
"filepath": "tests/utils_tests/test_crypto.py",
"language": "python",
"file_size": 7506,
"cut_index": 716,
"middle_length": 229
} |
onal import empty
basic_config = {
"default-src": [CSP.SELF],
}
alt_config = {
"default-src": [CSP.SELF, CSP.UNSAFE_INLINE],
}
basic_policy = "default-src 'self'"
class CSPConstantsTests(SimpleTestCase):
def test_constants(self):
self.assertEqual(CSP.NONE, "'none'")
self.assertEqual(CSP.R... | (CSP.NONCE, "<CSP_NONCE_SENTINEL>")
class CSPBuildPolicyTest(SimpleTestCase):
def assertPolicyEqual(self, a, b):
parts_a = sorted(a.split("; ")) if a is not None else None
parts_b = sorted(b.split("; ")) if b is not None else None
| e-eval'")
self.assertEqual(CSP.UNSAFE_HASHES, "'unsafe-hashes'")
self.assertEqual(CSP.UNSAFE_INLINE, "'unsafe-inline'")
self.assertEqual(CSP.WASM_UNSAFE_EVAL, "'wasm-unsafe-eval'")
self.assertEqual | {
"filepath": "tests/utils_tests/test_csp.py",
"language": "python",
"file_size": 6280,
"cut_index": 716,
"middle_length": 229
} |
le(self):
s = OrderedSet([1, 2, 3])
self.assertEqual(list(s.dict.keys()), [1, 2, 3])
def test_remove(self):
s = OrderedSet()
self.assertEqual(len(s), 0)
s.add(1)
s.add(2)
s.remove(2)
self.assertEqual(len(s), 1)
self.assertNotIn(2, s)
def ... | 0)
s.add(1)
self.assertIn(1, s)
def test_bool(self):
# Refs #23664
s = OrderedSet()
self.assertFalse(s)
s.add(1)
self.assertTrue(s)
def test_len(self):
s = OrderedSet()
self. | s = reversed(OrderedSet([1, 2, 3]))
self.assertIsInstance(s, collections.abc.Iterator)
self.assertEqual(list(s), [3, 2, 1])
def test_contains(self):
s = OrderedSet()
self.assertEqual(len(s), | {
"filepath": "tests/utils_tests/test_datastructures.py",
"language": "python",
"file_size": 14664,
"cut_index": 921,
"middle_length": 229
} |
ass DateFormatTests(SimpleTestCase):
@classmethod
def setUpClass(cls):
cls.enterClassContext(translation.override("en-us"))
super().setUpClass()
def test_date(self):
d = date(2009, 5, 16)
self.assertEqual(date.fromtimestamp(int(format(d, "U"))), d)
def test_naive_dateti... | self.assertEqual(format(dt, "T"), "")
self.assertEqual(format(dt, "Z"), "")
@requires_tz_support
def test_datetime_with_local_tzinfo(self):
ltz = get_default_timezone()
dt = make_aware(datetime(2009, 5, 16, 5, 30, 3 | ambiguous in Europe/Copenhagen.
dt = datetime(2015, 10, 25, 2, 30, 0)
# Try all formatters that involve self.timezone.
self.assertEqual(format(dt, "I"), "")
self.assertEqual(format(dt, "O"), "")
| {
"filepath": "tests/utils_tests/test_dateformat.py",
"language": "python",
"file_size": 10860,
"cut_index": 921,
"middle_length": 229
} |
self.assertEqual(parse_date("2012-4-9"), date(2012, 4, 9))
self.assertEqual(parse_date("20120423"), date(2012, 4, 23))
# Invalid inputs
self.assertIsNone(parse_date("2012423"))
with self.assertRaises(ValueError):
parse_date("2012-04-56")
def test_parse_time(self):
... | # Time zone offset is ignored.
self.assertEqual(parse_time("00:05:23+04:00"), time(0, 5, 23))
# Invalid inputs
self.assertIsNone(parse_time("00:05:"))
self.assertIsNone(parse_time("00:05:23,"))
self.assertIsNo | , 10))
self.assertEqual(parse_time("10:20:30.400"), time(10, 20, 30, 400000))
self.assertEqual(parse_time("10:20:30,400"), time(10, 20, 30, 400000))
self.assertEqual(parse_time("4:8:16"), time(4, 8, 16))
| {
"filepath": "tests/utils_tests/test_dateparse.py",
"language": "python",
"file_size": 9444,
"cut_index": 921,
"middle_length": 229
} |
o.utils.version import get_docs_version
@deconstructible()
class DeconstructibleClass:
pass
class DeconstructibleChildClass(DeconstructibleClass):
pass
@deconstructible(
path="utils_tests.deconstructible_classes.DeconstructibleWithPathClass"
)
class DeconstructibleWithPathClass:
pass
class Decon... | arg", key="value")
path, args, kwargs = obj.deconstruct()
self.assertEqual(path, "utils_tests.test_deconstruct.DeconstructibleClass")
self.assertEqual(args, ("arg",))
self.assertEqual(kwargs, {"key": "value"})
def test_ | InvalidPathClass:
pass
class DeconstructibleInvalidPathChildClass(DeconstructibleInvalidPathClass):
pass
class DeconstructibleTests(SimpleTestCase):
def test_deconstruct(self):
obj = DeconstructibleClass(" | {
"filepath": "tests/utils_tests/test_deconstruct.py",
"language": "python",
"file_size": 3270,
"cut_index": 614,
"middle_length": 229
} |
import TemplateResponse
from django.test import RequestFactory, SimpleTestCase
from django.utils.decorators import decorator_from_middleware
class ProcessViewMiddleware:
def __init__(self, get_response):
self.get_response = get_response
def process_view(self, request, view_func, view_args, view_kwar... | process_request(self, request):
request.process_request_reached = True
def process_view(self, request, view_func, view_args, view_kwargs):
request.process_view_reached = True
def process_template_response(self, request, response) | ef __call__(self, request):
return HttpResponse()
class_process_view = process_view_dec(ClassProcessView())
class FullMiddleware:
def __init__(self, get_response):
self.get_response = get_response
def | {
"filepath": "tests/utils_tests/test_decorators.py",
"language": "python",
"file_size": 4085,
"cut_index": 614,
"middle_length": 229
} |
uration import (
duration_iso_string,
duration_microseconds,
duration_string,
)
class TestDurationString(unittest.TestCase):
def test_simple(self):
duration = datetime.timedelta(hours=1, minutes=3, seconds=5)
self.assertEqual(duration_string(duration), "01:03:05")
def test_days(se... | urs=1, minutes=3, seconds=5)
self.assertEqual(duration_string(duration), "-1 01:03:05")
class TestParseDurationRoundtrip(unittest.TestCase):
def test_simple(self):
duration = datetime.timedelta(hours=1, minutes=3, seconds=5)
s | ration = datetime.timedelta(hours=1, minutes=3, seconds=5, microseconds=12345)
self.assertEqual(duration_string(duration), "01:03:05.012345")
def test_negative(self):
duration = datetime.timedelta(days=-1, ho | {
"filepath": "tests/utils_tests/test_duration.py",
"language": "python",
"file_size": 3941,
"cut_index": 614,
"middle_length": 229
} |
utils.encoding import (
DjangoUnicodeDecodeError,
escape_uri_path,
filepath_to_uri,
force_bytes,
force_str,
get_system_encoding,
iri_to_uri,
repercent_broken_unicode,
smart_bytes,
smart_str,
uri_to_iri,
)
from django.utils.functional import SimpleLazyObject
from django.utils.... | .assertRaises(TypeError):
force_str(MyString())
def test_force_str_lazy(self):
s = SimpleLazyObject(lambda: "x")
self.assertIs(type(force_str(s)), str)
def test_force_str_DjangoUnicodeDecodeError(self):
reason | ally raises an error.
"""
class MyString:
def __str__(self):
return b"\xc3\xb6\xc3\xa4\xc3\xbc"
# str(s) raises a TypeError if the result is not a text type.
with self | {
"filepath": "tests/utils_tests/test_encoding.py",
"language": "python",
"file_size": 8860,
"cut_index": 716,
"middle_length": 229
} |
mport TestCase
from .models import A01, A02, B01, B02, C01, C02, Managed1, Unmanaged2
class SimpleTests(TestCase):
def test_simple(self):
"""
The main test here is that the all the models can be created without
any database errors. We can also do some more simple insertion and
loo... | A02.objects.all()[0]
self.assertIsInstance(a2, A02)
self.assertEqual(a2.f_a, "foo")
b2 = B02.objects.all()[0]
self.assertIsInstance(b2, B02)
self.assertEqual(b2.f_a, "fred")
self.assertIsInstance(b2.fk_a, A | bjects.create(f_a="foo", f_b=42)
B01.objects.create(fk_a=a, f_a="fred", f_b=1729)
c = C01.objects.create(f_a="barney", f_b=1)
c.mm_a.set([a])
# ... and pull it out via the other set.
a2 = | {
"filepath": "tests/unmanaged_models/tests.py",
"language": "python",
"file_size": 2171,
"cut_index": 563,
"middle_length": 229
} |
cls.b1 = Bar.objects.create(place=cls.p1, serves_cocktails=False)
def test_getter(self):
# A Restaurant can access its place.
self.assertEqual(repr(self.r1.place), "<Place: Demon Dogs the place>")
# A Place can access its restaurant, if available.
self.assertEqual(
... | uteError`
# refs #21563
self.assertFalse(hasattr(self.p2, "restaurant"))
def test_setter(self):
# Set the place using assignment notation. Because place is the primary
# key on Restaurant, the save will create a new res | ant.DoesNotExist, "Place has no restaurant"
):
self.p2.restaurant
# The exception raised on attribute access when a related object
# doesn't exist should be an instance of a subclass of `Attrib | {
"filepath": "tests/one_to_one/tests.py",
"language": "python",
"file_size": 27203,
"cut_index": 1331,
"middle_length": 229
} |
.wsgi import WSGIHandler
from django.test import SimpleTestCase, override_settings
from django.test.client import (
BOUNDARY,
MULTIPART_CONTENT,
FakePayload,
encode_multipart,
)
class ExceptionHandlerTests(SimpleTestCase):
def get_suspicious_environ(self):
payload = FakePayload("a=1&a=2&a=... | GIHandler()(self.get_suspicious_environ(), lambda *a, **k: None)
self.assertEqual(response.status_code, 400)
@override_settings(DATA_UPLOAD_MAX_NUMBER_FIELDS=2)
def test_data_upload_max_number_fields_exceeded(self):
response = WSGI | put": payload,
"SERVER_NAME": "test",
"SERVER_PORT": "8000",
}
@override_settings(DATA_UPLOAD_MAX_MEMORY_SIZE=12)
def test_data_upload_max_memory_size_exceeded(self):
response = WS | {
"filepath": "tests/handlers/test_exception.py",
"language": "python",
"file_size": 1917,
"cut_index": 537,
"middle_length": 229
} |
ndlerTests(SimpleTestCase):
request_factory = RequestFactory()
def setUp(self):
request_started.disconnect(close_old_connections)
self.addCleanup(request_started.connect, close_old_connections)
def test_middleware_initialized(self):
handler = WSGIHandler()
self.assertIsNotN... | to '/%ED'.
self.assertEqual(response.status_code, 404)
def test_non_ascii_query_string(self):
"""
Non-ASCII query strings are properly decoded (#20530, #22996).
"""
environ = self.request_factory.get("/").envir | environ = self.request_factory.get("/").environ
environ["PATH_INFO"] = "\xed"
handler = WSGIHandler()
response = handler(environ, lambda *a, **k: None)
# The path of the request will be encoded | {
"filepath": "tests/handlers/tests.py",
"language": "python",
"file_size": 15982,
"cut_index": 921,
"middle_length": 229
} |
ango.core.exceptions import BadRequest, SuspiciousOperation
from django.db import connection, transaction
from django.http import HttpResponse, StreamingHttpResponse
from django.views.decorators.csrf import csrf_exempt
def regular(request):
return HttpResponse(b"regular content")
def no_response(request):
p... | )
def not_in_transaction_using_none(request):
return HttpResponse(str(connection.in_atomic_block))
@transaction.non_atomic_requests(using="incorrect")
def not_in_transaction_using_text(request):
return HttpResponse(str(connection.in_atomic_block) | :
return HttpResponse(str(connection.in_atomic_block))
@transaction.non_atomic_requests
def not_in_transaction(request):
return HttpResponse(str(connection.in_atomic_block))
@transaction.non_atomic_requests(using=None | {
"filepath": "tests/handlers/views.py",
"language": "python",
"file_size": 2141,
"cut_index": 563,
"middle_length": 229
} |
line="Django lets you build web apps easily"
)
cls.a1.publications.add(cls.p1)
cls.a2 = Article.objects.create(headline="NASA uses Python")
cls.a2.publications.add(cls.p1, cls.p2, cls.p3, cls.p4)
cls.a3 = Article.objects.create(headline="NASA finds intelligent life on Earth")
... | reate web apps easily>" needs to have '
'a value for field "id" before this many-to-many relationship can be used.'
)
with self.assertRaisesMessage(ValueError, msg):
getattr(a5, "publications")
# Save it!
| # Create an Article.
a5 = Article(headline="Django lets you create web apps easily")
# You can't associate it with a Publication until it's been saved.
msg = (
'"<Article: Django lets you c | {
"filepath": "tests/many_to_many/tests.py",
"language": "python",
"file_size": 28091,
"cut_index": 1331,
"middle_length": 229
} |
rom django.core.paginator import AsyncPage, AsyncPaginator, Page, Paginator
class ValidAdjacentNumsPage(Page):
def next_page_number(self):
if not self.has_next():
return None
return super().next_page_number()
def previous_page_number(self):
if not self.has_previous():
... | aprevious_page_number(self):
if not await self.ahas_previous():
return None
return await super().aprevious_page_number()
class AsyncValidAdjacentNumsPaginator(AsyncPaginator):
def _get_page(self, *args, **kwargs):
| *args, **kwargs)
class AsyncValidAdjacentNumsPage(AsyncPage):
async def anext_page_number(self):
if not await self.ahas_next():
return None
return await super().anext_page_number()
async def | {
"filepath": "tests/pagination/custom.py",
"language": "python",
"file_size": 1050,
"cut_index": 513,
"middle_length": 229
} |
ttpResponse
from django.test import SimpleTestCase, override_settings
from django.test.utils import freeze_time
class SignedCookieTest(SimpleTestCase):
def test_can_set_and_read_signed_cookies(self):
response = HttpResponse()
response.set_signed_cookie("c", "hello")
self.assertIn("c", resp... | uest()
request.COOKIES["a"] = response.cookies["a"].value
value = request.get_signed_cookie("a", salt="one")
self.assertEqual(value, "hello")
with self.assertRaises(signing.BadSignature):
request.get_signed_cooki | = request.get_signed_cookie("c")
self.assertEqual(value, "hello")
def test_can_use_salt(self):
response = HttpResponse()
response.set_signed_cookie("a", "hello", salt="one")
request = HttpReq | {
"filepath": "tests/signed_cookies_tests/tests.py",
"language": "python",
"file_size": 3395,
"cut_index": 614,
"middle_length": 229
} |
to,
House,
Image,
Item,
Location,
Login,
OrderedPerson,
OrgUnit,
Person,
Photo,
PlayedWith,
PlayedWithNote,
Policy,
Researcher,
Toy,
Version,
)
# Can't run this test under SQLite, because you can't
# get two connections to an in-memory database.
@skipUnlessD... | lback)
def test_concurrent_delete(self):
"""Concurrent deletes don't collide and lock the database (#9479)."""
with transaction.atomic():
Book.objects.create(pagecount=100)
book = Book.objects.create(pagecount=2 | to the default database
self.conn2 = connection.copy()
self.conn2.set_autocommit(False)
# Close down the second connection.
self.addCleanup(self.conn2.close)
self.addCleanup(self.conn2.rol | {
"filepath": "tests/delete_regress/tests.py",
"language": "python",
"file_size": 15479,
"cut_index": 921,
"middle_length": 229
} |
(1,),
("id", False),
("id", "id"),
(("id",),),
)
for i, args in enumerate(test_cases):
with (
self.subTest(args=args),
self.assertRaisesMessage(
ValueError, "CompositePrimaryKey args must be u... | expected_message = "CompositePrimaryKey cannot have a default."
with self.assertRaisesMessage(ValueError, expected_message):
models.CompositePrimaryKey("tenant_id", "id", default=(1, 1))
def test_composite_pk_cannot_have_a_dat | "CompositePrimaryKey must include at least two fields."
with self.assertRaisesMessage(ValueError, expected_message):
models.CompositePrimaryKey("id")
def test_composite_pk_cannot_have_a_default(self):
| {
"filepath": "tests/composite_pk/test_checks.py",
"language": "python",
"file_size": 11213,
"cut_index": 921,
"middle_length": 229
} |
ests(TestCase):
maxDiff = None
@classmethod
def setUpTestData(cls):
cls.tenant_1 = Tenant.objects.create()
cls.tenant_2 = Tenant.objects.create()
cls.user_1 = User.objects.create(
tenant=cls.tenant_1,
id=1,
email="user0001@example.com",
)
... | bjects.filter(pk=self.tenant_1.pk).delete()
self.assertEqual(
result,
(
3,
{
"composite_pk.Comment": 1,
"composite_pk.User": 1,
"co | id=1, user=cls.user_1)
cls.comment_2 = Comment.objects.create(id=2, user=cls.user_2)
cls.comment_3 = Comment.objects.create(id=3, user=cls.user_2)
def test_delete_tenant_by_pk(self):
result = Tenant.o | {
"filepath": "tests/composite_pk/test_delete.py",
"language": "python",
"file_size": 3235,
"cut_index": 614,
"middle_length": 229
} |
sitePKGetTests(TestCase):
maxDiff = None
@classmethod
def setUpTestData(cls):
cls.tenant_1 = Tenant.objects.create()
cls.tenant_2 = Tenant.objects.create()
cls.user_1 = User.objects.create(
tenant=cls.tenant_1,
id=1,
email="user0001@example.com",
... | (
{"pk": self.user_1.pk},
{"pk": (self.tenant_1.id, self.user_1.id)},
{"id": self.user_1.id},
)
for lookup in test_cases:
with self.subTest(lookup=lookup):
self.assertEqual(Us | ate(
tenant=cls.tenant_2,
id=3,
email="user0003@example.com",
)
cls.comment_1 = Comment.objects.create(id=1, user=cls.user_1)
def test_get_user(self):
test_cases = | {
"filepath": "tests/composite_pk/test_get.py",
"language": "python",
"file_size": 5049,
"cut_index": 614,
"middle_length": 229
} |
est import TestCase
from .models import Comment, Tenant, User
class NamesToPathTests(TestCase):
def test_id(self):
query = Query(User)
path, final_field, targets, rest = query.names_to_path(["id"], User._meta)
self.assertEqual(path, [])
self.assertEqual(final_field, User._meta.ge... | self.assertEqual(rest, [])
def test_tenant_id(self):
query = Query(User)
path, final_field, targets, rest = query.names_to_path(
["tenant", "id"], User._meta
)
self.assertEqual(
path,
| , targets, rest = query.names_to_path(["pk"], User._meta)
self.assertEqual(path, [])
self.assertEqual(final_field, User._meta.get_field("pk"))
self.assertEqual(targets, (User._meta.get_field("pk"),))
| {
"filepath": "tests/composite_pk/test_names_to_path.py",
"language": "python",
"file_size": 4624,
"cut_index": 614,
"middle_length": 229
} |
r
class CompositePKUpdateTests(TestCase):
maxDiff = None
@classmethod
def setUpTestData(cls):
cls.tenant_1 = Tenant.objects.create(name="A")
cls.tenant_2 = Tenant.objects.create(name="B")
cls.user_1 = User.objects.create(
tenant=cls.tenant_1,
id=1,
... | nt_2 = Comment.objects.create(id=2, user=cls.user_1)
cls.comment_3 = Comment.objects.create(id=3, user=cls.user_2)
cls.token_1 = Token.objects.create(id=1, tenant=cls.tenant_1)
cls.token_2 = Token.objects.create(id=2, tenant=cls.ten | cls.user_3 = User.objects.create(
tenant=cls.tenant_2,
id=3,
email="user0003@example.com",
)
cls.comment_1 = Comment.objects.create(id=1, user=cls.user_1)
cls.comme | {
"filepath": "tests/composite_pk/test_update.py",
"language": "python",
"file_size": 7663,
"cut_index": 716,
"middle_length": 229
} |
bbbbbbb"
POST_3_ID = "aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa"
@classmethod
def setUpTestData(cls):
super().setUpTestData()
cls.tenant_1 = Tenant.objects.create()
cls.tenant_2 = Tenant.objects.create()
cls.user_1 = User.objects.create(
tenant=cls.tenant_1, id=1, ema... | cls.post_3 = Post.objects.create(tenant=cls.tenant_2, id=cls.POST_3_ID)
def test_values_list(self):
with self.subTest('User.objects.values_list("pk")'):
self.assertSequenceEqual(
User.objects.values_list("pk"). | tenant=cls.tenant_2, id=3, email=cls.USER_3_EMAIL
)
cls.post_1 = Post.objects.create(tenant=cls.tenant_1, id=cls.POST_1_ID)
cls.post_2 = Post.objects.create(tenant=cls.tenant_1, id=cls.POST_2_ID)
| {
"filepath": "tests/composite_pk/test_values.py",
"language": "python",
"file_size": 9754,
"cut_index": 921,
"middle_length": 229
} |
table on various manage.py operations.
"""
from django.db import models
# All of these models are created in the database by Django.
class A01(models.Model):
f_a = models.CharField(max_length=10, db_index=True)
f_b = models.IntegerField()
class Meta:
db_table = "a01"
class B01(models.Model):... | f_b = models.IntegerField()
class Meta:
db_table = "c01"
# All of these models use the same tables as the previous set (they are shadows
# of possibly a subset of the columns). There should be no creation errors,
# since we have told Dja | 'managed' is True by default. This tests we can set it explicitly.
managed = True
class C01(models.Model):
mm_a = models.ManyToManyField(A01, db_table="d01")
f_a = models.CharField(max_length=10, db_index=True)
| {
"filepath": "tests/unmanaged_models/models.py",
"language": "python",
"file_size": 3240,
"cut_index": 614,
"middle_length": 229
} |
.core.signals import request_finished
from django.test import RequestFactory, override_settings
from .views import FILE_RESPONSE_HOLDER
# If data is too large, socket will choke, so write chunks no larger than 32MB
# at a time. The rationale behind the 32MB can be found in #5596#comment:4.
MAX_SOCKET_CHUNK_SIZE = 32 ... | # Before the first output, send the stored headers
self.bytes_sent = len(data) # make sure we know content-length
self.send_headers()
else:
self.bytes_sent += len(data)
# XXX check Content-L | by PEP 3333"""
assert isinstance(data, bytes), "write() argument must be bytestring"
if not self.status:
raise AssertionError("write() before start_response()")
elif not self.headers_sent:
| {
"filepath": "tests/builtin_server/tests.py",
"language": "python",
"file_size": 6198,
"cut_index": 716,
"middle_length": 229
} |
import path
from . import views
urlpatterns = [
path("regular/", views.regular),
path("async_regular/", views.async_regular),
path("no_response_fbv/", views.no_response),
path("no_response_cbv/", views.NoResponse()),
path("streaming/", views.streaming),
path("async_streaming/", views.async_str... | iews.not_in_transaction_using_text),
path("bad_request/", views.bad_request),
path("suspicious/", views.suspicious),
path("malformed_post/", views.malformed_post),
path("httpstatus_enum/", views.httpstatus_enum),
path("unawaited/", view | _none),
path("not_in_transaction_using_text/", v | {
"filepath": "tests/handlers/urls.py",
"language": "python",
"file_size": 859,
"cut_index": 529,
"middle_length": 52
} |
many relationships that need extra fields on the intermediary
table, use an intermediary model.
In this example, an ``Article`` can have multiple ``Reporter`` objects, and
each ``Article``-``Reporter`` combination (a ``Writer``) has a ``position``
field, which specifies the ``Reporter``'s position for the given articl... | irst_name, self.last_name)
class Article(models.Model):
headline = models.CharField(max_length=100)
pub_date = models.DateField()
class Writer(models.Model):
reporter = models.ForeignKey(Reporter, models.CASCADE)
article = models.Foreig | def __str__(self):
return "%s %s" % (self.f | {
"filepath": "tests/m2m_intermediary/models.py",
"language": "python",
"file_size": 968,
"cut_index": 582,
"middle_length": 52
} |
contenttypes.models import ContentType
from django.db import models
class Award(models.Model):
name = models.CharField(max_length=25)
object_id = models.PositiveIntegerField()
content_type = models.ForeignKey(ContentType, models.CASCADE)
content_object = GenericForeignKey()
class AwardNote(models.Mo... | Child(models.Model):
name = models.CharField(max_length=50)
toys = models.ManyToManyField(Toy, through="PlayedWith")
class PlayedWith(models.Model):
child = models.ForeignKey(Child, models.CASCADE)
toy = models.ForeignKey(Toy, models.CAS | ericRelation(Award)
class Book(models.Model):
pagecount = models.IntegerField()
owner = models.ForeignKey("Child", models.CASCADE, null=True)
class Toy(models.Model):
name = models.CharField(max_length=50)
class | {
"filepath": "tests/delete_regress/models.py",
"language": "python",
"file_size": 4054,
"cut_index": 614,
"middle_length": 229
} |
ethod
def setUpTestData(cls):
cls.tenant = Tenant.objects.create(id=1)
cls.user = User.objects.create(
tenant=cls.tenant,
id=1,
email="user0001@example.com",
)
def test_create_user(self):
test_cases = (
{"tenant": self.tenant, "id"... | e(**fields)
self.assertEqual(obj.tenant_id, self.tenant.id)
self.assertEqual(obj.id, user.id)
self.assertEqual(obj.pk, (self.tenant.id, user.id))
self.assertEqual(obj.email, user.email)
| example.com"},
)
for fields in test_cases:
with self.subTest(fields=fields):
count = User.objects.count()
user = User(**fields)
obj = User.objects.creat | {
"filepath": "tests/composite_pk/test_create.py",
"language": "python",
"file_size": 6598,
"cut_index": 716,
"middle_length": 229
} |
positePKModelsTests(TestCase):
@classmethod
def setUpTestData(cls):
cls.tenant_1 = Tenant.objects.create()
cls.tenant_2 = Tenant.objects.create()
cls.user_1 = User.objects.create(
tenant=cls.tenant_1,
id=1,
email="user0001@example.com",
)
... | _1)
cls.comment_3 = Comment.objects.create(id=3, user=cls.user_2)
cls.comment_4 = Comment.objects.create(id=4, user=cls.user_3)
def test_fields(self):
# tenant_1
self.assertSequenceEqual(
self.tenant_1.user_ | tenant=cls.tenant_2,
id=3,
email="user0003@example.com",
)
cls.comment_1 = Comment.objects.create(id=1, user=cls.user_1)
cls.comment_2 = Comment.objects.create(id=2, user=cls.user | {
"filepath": "tests/composite_pk/test_models.py",
"language": "python",
"file_size": 6374,
"cut_index": 716,
"middle_length": 229
} |
from django.test import TestCase
from .models import Comment, Post, Tenant, TimeStamped, Token, User
class CommentForm(forms.ModelForm):
class Meta:
model = Comment
fields = "__all__"
class CompositePKTests(TestCase):
maxDiff = None
@classmethod
def setUpTestData(cls):
cls... | y_columns(cursor, table)
def test_pk_updated_if_field_updated(self):
user = User.objects.get(pk=self.user.pk)
self.assertEqual(user.pk, (self.tenant.id, self.user.id))
self.assertIs(user._is_pk_set(), True)
user.tenant_ | nt = Comment.objects.create(tenant=cls.tenant, id=1, user=cls.user)
@staticmethod
def get_primary_key_columns(table):
with connection.cursor() as cursor:
return connection.introspection.get_primary_ke | {
"filepath": "tests/composite_pk/tests.py",
"language": "python",
"file_size": 17174,
"cut_index": 921,
"middle_length": 229
} |
xample, a ``Place`` optionally can be a ``Restaurant``.
"""
from django.db import models
class Place(models.Model):
name = models.CharField(max_length=50)
address = models.CharField(max_length=80)
def __str__(self):
return "%s the place" % self.name
class Restaurant(models.Model):
place = ... | odel):
place = models.OneToOneField(Place, models.SET_NULL, null=True)
serves_cocktails = models.BooleanField(default=True)
class Waiter(models.Model):
restaurant = models.ForeignKey(Restaurant, models.CASCADE)
name = models.CharField(max | lf):
return "%s the restaurant" % self.place.name
class Bar(models.Model):
place = models.OneToOneField(Place, models.CASCADE)
serves_cocktails = models.BooleanField(default=True)
class UndergroundBar(models.M | {
"filepath": "tests/one_to_one/models.py",
"language": "python",
"file_size": 3045,
"cut_index": 614,
"middle_length": 229
} |
core.exceptions import PermissionDenied
from django.template.response import TemplateResponse
from django.test import SimpleTestCase, modify_settings, override_settings
from django.urls import path
class MiddlewareAccessingContent:
def __init__(self, get_response):
self.get_response = get_response
de... | (request):
raise PermissionDenied
urlpatterns = [
path("", permission_denied_view),
]
handler403 = template_response_error_handler
@override_settings(ROOT_URLCONF="handlers.tests_custom_error_handlers")
@modify_settings(
MIDDLEWARE={
| response.
assert response.content
return response
def template_response_error_handler(request, exception=None):
return TemplateResponse(request, "test_handler.html", status=403)
def permission_denied_view | {
"filepath": "tests/handlers/tests_custom_error_handlers.py",
"language": "python",
"file_size": 1406,
"cut_index": 524,
"middle_length": 229
} |
ls):
cls.tenant_1 = Tenant.objects.create()
cls.tenant_2 = Tenant.objects.create()
cls.user_1 = User.objects.create(
tenant=cls.tenant_1,
id=1,
email="user0001@example.com",
)
cls.user_2 = User.objects.create(
tenant=cls.tenant_1,
... | ate(id=3, user=cls.user_1, text="foobar")
cls.comment_4 = Comment.objects.create(id=4, user=cls.user_3, text="foobarbaz")
cls.comment_5 = Comment.objects.create(id=5, user=cls.user_3, text="barbaz")
cls.comment_6 = Comment.objects.c | ample.com",
)
cls.comment_1 = Comment.objects.create(id=1, user=cls.user_2, text="foo")
cls.comment_2 = Comment.objects.create(id=2, user=cls.user_1, text="bar")
cls.comment_3 = Comment.objects.cre | {
"filepath": "tests/composite_pk/test_aggregate.py",
"language": "python",
"file_size": 6636,
"cut_index": 716,
"middle_length": 229
} |
)
cls.user_2 = User.objects.create(
tenant=cls.tenant_1,
id=2,
email="user0002@example.com",
)
cls.user_3 = User.objects.create(
tenant=cls.tenant_2,
id=3,
email="user0003@example.com",
)
cls.user_4 = User.o... | Comment.objects.create(id=5, user=cls.user_1)
def test_filter_and_count_user_by_pk(self):
test_cases = (
({"pk": self.user_1.pk}, 1),
({"pk": self.user_2.pk}, 1),
({"pk": self.user_3.pk}, 1),
({ | cls.comment_2 = Comment.objects.create(id=2, user=cls.user_1)
cls.comment_3 = Comment.objects.create(id=3, user=cls.user_2)
cls.comment_4 = Comment.objects.create(id=4, user=cls.user_3)
cls.comment_5 = | {
"filepath": "tests/composite_pk/test_filter.py",
"language": "python",
"file_size": 21775,
"cut_index": 1331,
"middle_length": 229
} |
-many relationship, use ``ManyToManyField()``.
In this example, an ``Article`` can be published in multiple ``Publication``
objects, and a ``Publication`` has multiple ``Article`` objects.
"""
from django.db import models
class Publication(models.Model):
title = models.CharField(max_length=30)
class Meta:
... | headline = models.CharField(max_length=100)
# Assign a string as name to make sure the intermediary model is
# correctly created. Refs #20207
publications = models.ManyToManyField(Publication, name="publications")
tags = models.ManyToMan | =50)
def __str__(self):
return self.name
class NoDeletedArticleManager(models.Manager):
def get_queryset(self):
return super().get_queryset().exclude(headline="deleted")
class Article(models.Model):
| {
"filepath": "tests/many_to_many/models.py",
"language": "python",
"file_size": 2339,
"cut_index": 563,
"middle_length": 229
} |
"""words(n) returns n + 19 words, even if n is negative."""
self.assertEqual(
words(-5),
"lorem ipsum dolor sit amet consectetur adipisicing elit sed do "
"eiusmod tempor incididunt ut",
)
def test_same_or_less_common_words(self):
"""words(n) for n < 19... | ut labore et dolore magna aliqua"
)
)
def test_more_words_than_common(self):
"""words(n) returns n words for n > 19."""
self.assertEqual(len(words(25).split()), 25)
def test_common_large_number_of_words(self):
| rd lorem ipsum words for n > 19.
"""
self.assertTrue(
words(25).startswith(
"lorem ipsum dolor sit amet consectetur adipisicing elit sed "
"do eiusmod tempor incididunt | {
"filepath": "tests/utils_tests/test_lorem_ipsum.py",
"language": "python",
"file_size": 5452,
"cut_index": 716,
"middle_length": 229
} |
ontrib import admin
from django.db import models
from django.http import HttpResponseRedirect
from django.urls import reverse
class Action(models.Model):
name = models.CharField(max_length=50, primary_key=True)
description = models.CharField(max_length=70)
def __str__(self):
return self.name
cl... | for url in super().get_urls() if url.name != name]
def get_urls(self):
# Add the URL of our custom 'add_view' view to the front of the URLs
# list. Remove the existing one(s) first
from django.urls import re_path
def | d PK.
"""
list_display = ("name", "description")
def remove_url(self, name):
"""
Remove all entries named 'name' from the ModelAdmin instance URL
patterns list
"""
return [url | {
"filepath": "tests/admin_custom_urls/models.py",
"language": "python",
"file_size": 2446,
"cut_index": 563,
"middle_length": 229
} |
django.test import TestCase, override_settings
from django.urls import reverse
from .models import Action, Car, Person
@override_settings(
ROOT_URLCONF="admin_custom_urls.urls",
)
class AdminCustomUrlsTest(TestCase):
"""
Remember that:
* The Action model has a CharField PK.
* The ModelAdmin for ... | her names.")
Action.objects.create(name="add", description="Add things.")
Action.objects.create(
name="path/to/file/", description="An action with '/' in its name."
)
Action.objects.create(
name="path | username="super", password="secret", email="super@example.com"
)
Action.objects.create(name="delete", description="Remove things.")
Action.objects.create(name="rename", description="Gives things ot | {
"filepath": "tests/admin_custom_urls/tests.py",
"language": "python",
"file_size": 5801,
"cut_index": 716,
"middle_length": 229
} |
ango.db import connection
from django.test import TestCase, override_settings
from .models import Article, Category, Comment
class DatesTests(TestCase):
def test_related_model_traverse(self):
a1 = Article.objects.create(
title="First one",
pub_date=datetime.date(2005, 7, 28),
... | create(
text="HULK SMASH!",
pub_date=datetime.date(2005, 7, 29),
)
a2.comments.create(
text="LMAO",
pub_date=datetime.date(2010, 7, 28),
)
a3.comments.create(
text= | hird one, in the first day",
pub_date=datetime.date(2005, 7, 28),
)
a1.comments.create(
text="Im the HULK!",
pub_date=datetime.date(2005, 7, 28),
)
a1.comments. | {
"filepath": "tests/dates/tests.py",
"language": "python",
"file_size": 4934,
"cut_index": 614,
"middle_length": 229
} |
before/after saving and deleting
To execute arbitrary code around ``save()`` and ``delete()``, just subclass
the methods.
"""
from django.db import models
class Person(models.Model):
first_name = models.CharField(max_length=20)
last_name = models.CharField(max_length=20)
def __init__(self, *args, **kwa... | ll the "real" save() method
super().save(*args, **kwargs)
self.data.append("After save")
def delete(self):
self.data.append("Before deletion")
# Call the "real" delete() method
super().delete()
self.data | self.data.append("Before save")
# Ca | {
"filepath": "tests/save_delete_hooks/models.py",
"language": "python",
"file_size": 863,
"cut_index": 529,
"middle_length": 52
} |
.test import TestCase
from .models import Person
class SaveDeleteHookTests(TestCase):
def test_basic(self):
p = Person(first_name="John", last_name="Smith")
self.assertEqual(p.data, [])
p.save()
self.assertEqual(
p.data,
[
"Before save",
... | rtEqual(
p.data,
[
"Before save",
"After save",
"Before deletion",
"After deletion",
],
)
self.assertQuerySetEqual(Person.objects.all(), []) | str,
)
p.delete()
self.asse | {
"filepath": "tests/save_delete_hooks/tests.py",
"language": "python",
"file_size": 832,
"cut_index": 523,
"middle_length": 52
} |
contenttypes.models import ContentType
from django.db import models
class Square(models.Model):
root = models.IntegerField()
square = models.PositiveIntegerField(db_default=9)
def __str__(self):
return "%s ** 2 == %s" % (self.root, self.square)
class Person(models.Model):
first_name = model... | ast_updated = models.DateTimeField()
objects = SchoolClassManager()
class SchoolBusManager(models.Manager):
def get_queryset(self):
return super().get_queryset().prefetch_related("schoolclasses")
class SchoolBus(models.Model):
numb | Manager):
def get_queryset(self):
return super().get_queryset().exclude(year=1000)
class SchoolClass(models.Model):
year = models.PositiveIntegerField()
day = models.CharField(max_length=9, blank=True)
l | {
"filepath": "tests/backends/models.py",
"language": "python",
"file_size": 4600,
"cut_index": 614,
"middle_length": 229
} |
TestCase
from .models import Person
class TableTests(SimpleTestCase):
def setUp(self):
self.reference = Table("table", lambda table: table.upper())
def test_references_table(self):
self.assertIs(self.reference.references_table("table"), True)
self.assertIs(self.reference.references_t... | .assertIs(self.reference.references_table("other"), True)
def test_repr(self):
self.assertEqual(repr(self.reference), "<Table 'TABLE'>")
def test_str(self):
self.assertEqual(str(self.reference), "TABLE")
class ColumnsTests(Table | "), True)
self.assertIs(self.reference.references_table("other"), False)
self.reference.rename_table_references("table", "other")
self.assertIs(self.reference.references_table("table"), False)
self | {
"filepath": "tests/backends/test_ddl_references.py",
"language": "python",
"file_size": 13384,
"cut_index": 921,
"middle_length": 229
} |
tifier,
split_tzname_delta,
truncate_name,
)
from django.test import (
SimpleTestCase,
TransactionTestCase,
skipIfDBFeature,
skipUnlessDBFeature,
)
class TestUtils(SimpleTestCase):
def test_truncate_name(self):
self.assertEqual(truncate_name("some_table", 10), "some_table")
... | e_name('username"."some_long_table', 10), 'username"."some_la38a'
)
self.assertEqual(
truncate_name('username"."some_long_table', 10, 3), 'username"."some_loa38'
)
def test_split_identifier(self):
self.asser | me_long_table"), "some_long_table")
# "user"."table" syntax
self.assertEqual(
truncate_name('username"."some_table', 10), 'username"."some_table'
)
self.assertEqual(
truncat | {
"filepath": "tests/backends/test_utils.py",
"language": "python",
"file_size": 5559,
"cut_index": 716,
"middle_length": 229
} |
ar against
fields which clash with strings passed to it (e.g. 'day') (#12818).
"""
updated = datetime.datetime(2010, 2, 20)
SchoolClass.objects.create(year=2009, last_updated=updated)
classes = SchoolClass.objects.filter(last_updated__day=20)
self.assertEqual(len(classes)... | cursor.statement = None
# No previous query has been run.
connection.ops.last_executed_query(cursor, "", ())
# Previous query crashed.
connection.ops.last_executed_query(cursor, "SELECT %s" + suffi | aise an exception even if no previous
query has been run.
"""
suffix = connection.features.bare_select_suffix
with connection.cursor() as cursor:
if connection.vendor == "oracle":
| {
"filepath": "tests/backends/tests.py",
"language": "python",
"file_size": 39806,
"cut_index": 2151,
"middle_length": 229
} |
ion
from django.db.backends.mysql.creation import DatabaseCreation
from django.test import SimpleTestCase
from django.test.utils import captured_stderr
@unittest.skipUnless(connection.vendor == "mysql", "MySQL tests")
class DatabaseCreationTests(SimpleTestCase):
def _execute_raise_database_exists(self, cursor, pa... | "_execute_create_test_db", execute_create_test_db
)
@mock.patch("sys.stdout", new_callable=StringIO)
@mock.patch("sys.stderr", new_callable=StringIO)
def test_create_test_db_database_exists(self, *mocked_objects):
# Simulate te | f, cursor, parameters, keepdb=False):
raise DatabaseError(1044, "Access denied for user")
def patch_test_db_creation(self, execute_create_test_db):
return mock.patch.object(
BaseDatabaseCreation, | {
"filepath": "tests/backends/mysql/test_creation.py",
"language": "python",
"file_size": 6423,
"cut_index": 716,
"middle_length": 229
} |
db import connection
from django.db.backends.mysql.features import DatabaseFeatures
from django.test import TestCase
@skipUnless(connection.vendor == "mysql", "MySQL tests")
class TestFeatures(TestCase):
def test_supports_transactions(self):
"""
All storage engines except MyISAM support transactio... | self.assertFalse(connection.features.supports_transactions)
del connection.features.supports_transactions
def test_allows_auto_pk_0(self):
with mock.MagicMock() as _connection:
_connection.sql_mode = {"NO_AUTO_VAL | self.assertTrue(connection.features.supports_transactions)
del connection.features.supports_transactions
with mock.patch(
"django.db.connection.features._mysql_storage_engine", "MyISAM"
):
| {
"filepath": "tests/backends/mysql/test_features.py",
"language": "python",
"file_size": 2050,
"cut_index": 563,
"middle_length": 229
} |
def test_parse_constraint_columns(self):
_parse_constraint_columns = connection.introspection._parse_constraint_columns
tests = (
("`height` >= 0", ["height"], ["height"]),
("`cost` BETWEEN 1 AND 10", ["cost"], ["cost"]),
("`ref1` > `ref2`", ["id", "ref1", "ref2"], [... | `ref1`) != 'test'", ["id", "lower", "ref1"], ["ref1"]),
("`name` LIKE 'test%'", ["name"], ["name"]),
)
for check_clause, table_columns, expected_columns in tests:
with self.subTest(check_clause):
chec | ("JSON_VALID(`json_field`)", ["json_field"], ["json_field"]),
("CHAR_LENGTH(`name`) > 2", ["name"], ["name"]),
("lower(`ref1`) != 'test'", ["id", "owe", "ref1"], ["ref1"]),
("lower( | {
"filepath": "tests/backends/mysql/test_introspection.py",
"language": "python",
"file_size": 5318,
"cut_index": 716,
"middle_length": 229
} |
ngo.core.management.color import no_style
from django.db import connection
from django.test import SimpleTestCase
from ..models import Person, Tag
@unittest.skipUnless(connection.vendor == "mysql", "MySQL tests.")
class MySQLOperationsTests(SimpleTestCase):
def test_sql_flush(self):
# allow_cascade doesn... | "SET FOREIGN_KEY_CHECKS = 0;",
"DELETE FROM `backends_person`;",
"DELETE FROM `backends_tag`;",
"SET FOREIGN_KEY_CHECKS = 1;",
],
| nection.ops.sql_flush(
no_style(),
[Person._meta.db_table, Tag._meta.db_table],
allow_cascade=allow_cascade,
),
[
| {
"filepath": "tests/backends/mysql/test_operations.py",
"language": "python",
"file_size": 1819,
"cut_index": 537,
"middle_length": 229
} |
est
from django.db import connection
from django.test import TestCase
@unittest.skipUnless(connection.vendor == "mysql", "MySQL tests")
class SchemaEditorTests(TestCase):
def test_quote_value(self):
import MySQLdb
editor = connection.schema_editor()
tested_values = [
("string... | se "1.754"),
(False, b"0" if MySQLdb.version_info >= (1, 4, 0) else "0"),
]
for value, expected in tested_values:
with self.subTest(value=value):
self.assertEqual(editor.quote_value(value), expected)
| (1, 3, 14) el | {
"filepath": "tests/backends/mysql/test_schema.py",
"language": "python",
"file_size": 800,
"cut_index": 524,
"middle_length": 14
} |
ptions import ImproperlyConfigured
from django.db import NotSupportedError, connection
from django.test import TestCase, override_settings
@contextmanager
def get_connection():
new_connection = connection.copy()
yield new_connection
new_connection.close()
@override_settings(DEBUG=True)
@unittest.skipUnl... | or cls.isolation_values[cls.repeatable_read]
)
cls.configured_isolation_level = configured_isolation_level.upper()
cls.other_isolation_level = (
cls.read_committed
if configured_isolation_level != cls.isolati | level: level.upper() for level in (read_committed, repeatable_read)
}
@classmethod
def setUpClass(cls):
super().setUpClass()
configured_isolation_level = (
connection.isolation_level | {
"filepath": "tests/backends/mysql/tests.py",
"language": "python",
"file_size": 4510,
"cut_index": 614,
"middle_length": 229
} |
ngo.db import connection
from django.db.models.expressions import RawSQL
from django.db.utils import DataError
from django.test import TestCase
from ..models import Article, Reporter, Square
@unittest.skipUnless(connection.vendor == "postgresql", "PostgreSQL tests")
class BulkCreateUnnestTests(TestCase):
def tes... | ertNotIn("UNNEST", ctx[0]["sql"])
def test_unnest_eligible(self):
with self.assertNumQueries(1) as ctx:
Square.objects.bulk_create(
[Square(root=2, square=4), Square(root=3, square=9)]
)
self.ass | ef test_non_literal(self):
with self.assertNumQueries(1) as ctx:
Square.objects.bulk_create(
[Square(root=2, square=RawSQL("%s", (4,))), Square(root=3, square=9)]
)
self.ass | {
"filepath": "tests/backends/postgresql/test_compilation.py",
"language": "python",
"file_size": 2180,
"cut_index": 563,
"middle_length": 229
} |
tion
from django.db.backends.base.creation import BaseDatabaseCreation
from django.test import SimpleTestCase
try:
from django.db.backends.postgresql.psycopg_any import errors
except ImportError:
pass
else:
from django.db.backends.postgresql.creation import DatabaseCreation
@unittest.skipUnless(connectio... | value
try:
yield
finally:
for name in kwargs:
if name in saved_values:
settings[name] = saved_values[name]
else:
del settings[name]
def ch | ings_dict["TEST"]
saved_values = {}
for name in kwargs:
if name in settings:
saved_values[name] = settings[name]
for name, value in kwargs.items():
settings[name] = | {
"filepath": "tests/backends/postgresql/test_creation.py",
"language": "python",
"file_size": 5337,
"cut_index": 716,
"middle_length": 229
} |
ngo.db import connection
from django.test import TestCase
from ..models import Person
@unittest.skipUnless(connection.vendor == "postgresql", "Test only for PostgreSQL")
class DatabaseSequenceTests(TestCase):
def test_get_sequences(self):
with connection.cursor() as cursor:
seqs = connection.... | _seq RENAME TO pers_seq")
seqs = connection.introspection.get_sequences(cursor, Person._meta.db_table)
self.assertEqual(
seqs,
[{"table": Person._meta.db_table, "column": "id", "name": "pers_seq"}],
| meta.db_table,
"column": "id",
"name": "backends_person_id_seq",
}
],
)
cursor.execute("ALTER SEQUENCE backends_person_id | {
"filepath": "tests/backends/postgresql/test_introspection.py",
"language": "python",
"file_size": 1577,
"cut_index": 537,
"middle_length": 229
} |
import no_style
from django.db import connection
from django.db.models.expressions import Col
from django.db.models.functions import Cast
from django.test import SimpleTestCase
from ..models import Author, Book, Person, Tag
@unittest.skipUnless(connection.vendor == "postgresql", "PostgreSQL tests.")
class PostgreSQL... | no_style(),
[Person._meta.db_table, Tag._meta.db_table],
allow_cascade=True,
),
['TRUNCATE "backends_person", "backends_tag" CASCADE;'],
)
def test_sql_flush_sequences(self):
| e, Tag._meta.db_table],
),
['TRUNCATE "backends_person", "backends_tag";'],
)
def test_sql_flush_allow_cascade(self):
self.assertEqual(
connection.ops.sql_flush(
| {
"filepath": "tests/backends/postgresql/test_operations.py",
"language": "python",
"file_size": 2836,
"cut_index": 563,
"middle_length": 229
} |
test import TestCase
from django.test.utils import garbage_collect
from django.utils.version import PYPY
from ..models import Person
try:
from django.db.backends.postgresql.psycopg_any import is_psycopg3
except ImportError:
is_psycopg3 = False
@unittest.skipUnless(connection.vendor == "postgresql", "Postgre... | f inspect_cursors(self):
with connection.cursor() as cursor:
cursor.execute(
"SELECT {fields} FROM pg_cursors;".format(fields=self.cursor_fields)
)
cursors = cursor.fetchall()
return [self | le("PostgresCursor", cursor_fields)
@classmethod
def setUpTestData(cls):
cls.p0 = Person.objects.create(first_name="a", last_name="a")
cls.p1 = Person.objects.create(first_name="b", last_name="b")
de | {
"filepath": "tests/backends/postgresql/test_server_side_cursors.py",
"language": "python",
"file_size": 6073,
"cut_index": 716,
"middle_length": 229
} |
new_connection.settings_dict["OPTIONS"]["pool"] = False
return new_connection
@unittest.skipUnless(connection.vendor == "postgresql", "PostgreSQL tests")
class Tests(TestCase):
databases = {"default", "other"}
def test_nodb_cursor(self):
"""
The _nodb_cursor() fallbacks to the defaul... | self.assertIsNotNone(cursor.db.connection)
self.assertIsNone(cursor.db.settings_dict["NAME"])
self.assertIs(cursor.closed, True)
self.assertIsNone(cursor.db.connection)
# Now assume the 'postgres' db isn't available
| if self.settings_dict["NAME"] is None:
raise DatabaseError()
return orig_connect(self)
with connection._nodb_cursor() as cursor:
self.assertIs(cursor.closed, False)
| {
"filepath": "tests/backends/postgresql/tests.py",
"language": "python",
"file_size": 25920,
"cut_index": 1331,
"middle_length": 229
} |
estCase
@unittest.skipUnless(connection.vendor == "oracle", "Oracle tests")
@mock.patch.object(DatabaseCreation, "_maindb_connection", return_value=connection)
@mock.patch("sys.stdout", new_callable=StringIO)
@mock.patch("sys.stderr", new_callable=StringIO)
class DatabaseCreationTests(TestCase):
def _execute_rais... | exists(
self, cursor, statements, parameters, verbosity, allow_quiet_fail=False
):
raise DatabaseError("ORA-01543: tablespace 'string' already exists")
def _execute_raise_insufficient_privileges(
self, cursor, statements, p | ents and statements[0].startswith("CREATE USER"):
raise DatabaseError(
"ORA-01920: user name 'string' conflicts with another user or role name"
)
def _execute_raise_tablespace_already_ | {
"filepath": "tests/backends/oracle/test_creation.py",
"language": "python",
"file_size": 5543,
"cut_index": 716,
"middle_length": 229
} |
essDBFeature
from ..models import Person, Square
@unittest.skipUnless(connection.vendor == "oracle", "Oracle tests")
class DatabaseSequenceTests(TransactionTestCase):
available_apps = []
def test_get_sequences(self):
with connection.cursor() as cursor:
seqs = connection.introspection.get... | with connection.schema_editor() as editor:
editor._drop_identity(Square._meta.db_table, "id")
seqs = connection.introspection.get_sequences(
cursor, Square._meta.db_table, Square._meta.local_fiel | self.assertEqual(seqs[0]["table"], Square._meta.db_table)
self.assertEqual(seqs[0]["column"], "id")
def test_get_sequences_manually_created_index(self):
with connection.cursor() as cursor:
| {
"filepath": "tests/backends/oracle/test_introspection.py",
"language": "python",
"file_size": 3638,
"cut_index": 614,
"middle_length": 229
} |
om django.test import TransactionTestCase
from ..models import Person, Tag
@unittest.skipUnless(connection.vendor == "oracle", "Oracle tests")
class OperationsTests(TransactionTestCase):
available_apps = ["backends"]
def test_sequence_name_truncation(self):
seq_name = connection.ops._get_no_autofiel... | tatements[0],
'ALTER TABLE "BACKENDS_TAG" DISABLE CONSTRAINT '
'"BACKENDS__CONTENT_T_FD9D7A85_F" KEEP INDEX;',
)
self.assertEqual(
sorted(statements[1:-1]),
[
'TRUNCATE TABLE " | connection.ops.sql_flush(
no_style(),
[Person._meta.db_table, Tag._meta.db_table],
)
# The tables and constraints are processed in an unordered set.
self.assertEqual(
s | {
"filepath": "tests/backends/oracle/test_operations.py",
"language": "python",
"file_size": 4604,
"cut_index": 614,
"middle_length": 229
} |
mport BooleanField
from django.test import TestCase, TransactionTestCase
from ..models import VeryLongModelNameZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZ
def no_pool_connection(alias=None):
new_connection = connection.copy(alias)
new_connection.settings_dict = copy.deepcopy(connection.settings_dict)
# En... | E%NAME"'
quoted_name = connection.ops.quote_name(name)
self.assertEqual(quoted_name % (), name)
def test_quote_name_db_table(self):
model = VeryLongModelNameZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZ
db_table = model._m | e
return new_connection
@unittest.skipUnless(connection.vendor == "oracle", "Oracle tests")
class Tests(TestCase):
def test_quote_name(self):
"""'%' chars are escaped for query execution."""
name = '"SOM | {
"filepath": "tests/backends/oracle/tests.py",
"language": "python",
"file_size": 6596,
"cut_index": 716,
"middle_length": 229
} |
s attributes like client_class and
creation_class should be set on the class and reflected in the
corresponding instance attributes of the instantiated backend.
"""
conn = connections[DEFAULT_DB_ALIAS]
conn_class = type(conn)
attr_names = [
("client_class", "c... | ue)
instance_attr_value = getattr(conn, instance_attr_name)
self.assertIsInstance(instance_attr_value, class_attr_value)
def test_initialization_display_name(self):
self.assertEqual(BaseDatabaseWrapper.display_name, "un | ("validation_class", "validation"),
]
for class_attr_name, instance_attr_name in attr_names:
class_attr_value = getattr(conn_class, class_attr_name)
self.assertIsNotNone(class_attr_val | {
"filepath": "tests/backends/base/test_base.py",
"language": "python",
"file_size": 18911,
"cut_index": 1331,
"middle_length": 229
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.