def test_get_admin_change_url(self):
obj = PermissionTestModel.objects.create()
url = self.get_admin_change_url(obj)
if django.VERSION < (1, 11):
assert_pformat_equal(url, "/admin/django_tools_test_app/permissiontestmodel/%i/" % obj.pk)
else:
assert_pformat_equal(url, "/admin/django_tools_test_app/permissiontestmodel/%i/change/" % obj.pk)
def test_current_request_receives_current_request(self):
response = self.client.get("/get_current_get_parameters/?")
current_get_parameters = json.loads(response.content.decode("utf-8"))
assert_pformat_equal(current_get_parameters, {})
response = self.client.get("/get_current_get_parameters/?foo=bar")
current_get_parameters = json.loads(response.content.decode("utf-8"))
assert_pformat_equal(current_get_parameters, {"foo": "bar"})
def test_filter_permission2(self):
queryset = LimitToUsergroupsTestModel.objects.all()
# edit only for staff or users in the right user group
items = limit_to_usergroups.filter_permission(queryset,
permit_edit=self.user1)
assert_pformat_equal(len(items), 1)
def test_assert_path_not_exists_is_file(self):
with self.assertRaises(AssertionError) as cm:
assert_path_not_exists(self.existing_file_path)
assert_pformat_equal(
cm.exception.args[0],
f"Path is a existing file: {self.existing_file_path}")
def test_filter_permission1(self):
queryset = LimitToUsergroupsTestModel.objects.all()
# Anonymous can view all
items = limit_to_usergroups.filter_permission(queryset,
permit_view=self.user1)
assert_pformat_equal(len(items), 2)
def test_setup(self):
self.assert_extra_permission(self.extra_permission)
# The "normal user" has no permissions
assert_pformat_equal(self.normal_user.get_all_permissions(), set())
# The "staff user" has some permissions
assert_pformat_equal(
self.staff_user.get_all_permissions(),
{
"django_tools_test_app.extra_permission",
"django_tools_test_app.add_permissiontestmodel",
"django_tools_test_app.change_permissiontestmodel",
"django_tools_test_app.delete_permissiontestmodel",
},
)
all_permissions = [
f"{entry.content_type.app_label}.{entry.codename}"
for entry in Permission.objects.all()
]
# Default mode permissions:
self.assertIn("django_tools_test_app.add_permissiontestmodel",
all_permissions)
self.assertIn("django_tools_test_app.change_permissiontestmodel",
all_permissions)
self.assertIn("django_tools_test_app.delete_permissiontestmodel",
all_permissions)
# Own permission defined via Meta.permissions:
self.assertIn("django_tools_test_app.extra_permission",
all_permissions)
def test_allow_fragment(self):
validator = URLValidator2(allow_fragment=False)
validator("http://www.domain.test/without/fragment/")
try:
validator("http://www.domain.test/with/a/#fragment")
except ValidationError as err:
assert_pformat_equal(six.text_type(err.message), "Enter a valid URL without a fragment.")
def test_only_local_path1(self):
validator = URLValidator2(allow_schemes=None, allow_netloc=False)
validator("/path/?query#fragment")
try:
validator("http://domain.test/path/?query#fragment")
except ValidationError as err:
assert_pformat_equal(six.text_type(err.message), "Please enter a local URL (without protocol/domain).")
def test_generate_simple_parler_dummies(self):
generate_simple_parler_dummies()
assert_pformat_equal(SimpleParlerModel.objects.all().count(), 5)
with translation.override("en"):
qs = SimpleParlerModel.objects.language(language_code="en").all()
info = []
for instance in qs:
info.append((instance.slug, list(instance.get_available_languages())))
pprint(info)
# Every dummy entry should be translated in de and en:
assert_pformat_equal(
info,
[
("simpleparlermodel-en-1", ["de", "en"]),
("simpleparlermodel-en-2", ["de", "en"]),
("simpleparlermodel-en-3", ["de", "en"]),
("simpleparlermodel-en-4", ["de", "en"]),
("simpleparlermodel-en-5", ["de", "en"]),
],
)
def test_allow_query(self):
validator = URLValidator2(allow_query=False)
validator("http://www.domain.test/without/query/")
try:
validator("http://www.domain.test/with/?query")
except ValidationError as err:
assert_pformat_equal(six.text_type(err.message), "Enter a valid URL without a query.")
def test_groups(self):
group1 = Group.objects.create(name="Group 1")
group2 = Group.objects.create(name="Group 2")
create_user(username="******", password="******", groups=(group1, group2))
user = self.UserModel.objects.get(username="******")
groups = user.groups.values_list("pk", "name")
assert_pformat_equal(list(groups), [(1, "Group 1"), (2, "Group 2")])
def test_filter_and_log_skip_external_package(self):
instance = FilterAndLogWarnings()
with LoggingBuffer(name="django_tools.unittest_utils.logging_utils",
level=logging.DEBUG) as log_buffer:
for i in range(3):
instance(
message=
"test_filter_and_log_skip_external_package dist-packages %i"
% i,
category=UserWarning,
filename="/foo/dist-packages/bar.py",
lineno=456,
)
instance(
message=
"test_filter_and_log_skip_external_package site-packages %i"
% i,
category=UserWarning,
filename="/foo/site-packages/bar.py",
lineno=789,
)
log_messages = log_buffer.get_messages()
print("log_messages:\n%s" % log_messages)
assert_pformat_equal(
log_messages,
("WARNING:django_tools.unittest_utils.logging_utils:There are warnings in: /foo/dist-packages/bar.py\n"
"WARNING:django_tools.unittest_utils.logging_utils:There are warnings in: /foo/site-packages/bar.py"
),
)
def test_directory_traversal_attack_encodings(self):
base_path = os.path.abspath(os.path.dirname(django_tools.__file__))
rest_urls = (
"/etc/passwd",
"..",
"../",
"\\\\",
# URI encoded directory traversal:
"%2e%2e%2f", # ../
"%2e%2e/", # ../
"..%2f", # ../
"%2e%2e%5c", # ..\
# Unicode / UTF-8 encoded directory traversal:
"..%c1%1c", # ../
"..%c0%af", # ..\
"%c0%ae%c0%ae%c1%1c", # %c0%ae -> . -> ../
"%c0%ae%c0%ae%c0%af", # %c0%ae -> . -> ..\
)
for rest_url in rest_urls:
# print(rest_url)
try:
BaseFilesystemBrowser(request=None, absolute_path=self.BASE_PATH, base_url="bar", rest_url=rest_url)
except Http404 as err:
assert_pformat_equal(six.text_type(err), "Directory doesn't exist!")
def test_debug_message(self):
path = str(Path(settings.MEDIA_ROOT, "does/not/exist"))
print(path)
try:
self.media_root_validator(path)
except ValidationError as err:
assert_pformat_equal(six.text_type(err.message), "Directory '%s' doesn't exist!" % path)
def test_current_request_receives_current_request(self):
response = self.client.get("/get_current_get_parameters/?")
current_get_parameters = json.loads(response.content.decode("utf-8"))
assert_pformat_equal(current_get_parameters, {})
response = self.client.get("/get_current_get_parameters/?foo=bar")
current_get_parameters = json.loads(response.content.decode("utf-8"))
assert_pformat_equal(current_get_parameters, {"foo": "bar"})
def test_groups(self):
group1 = Group.objects.create(name="Group 1")
group2 = Group.objects.create(name="Group 2")
create_user(username="******", password="******", groups=(group1, group2))
user = self.UserModel.objects.get(username="******")
groups = user.groups.values_list("pk", "name")
assert_pformat_equal(list(groups), [(1, "Group 1"), (2, "Group 2")])
def test_filter_and_log_skip_external_package(self):
instance = FilterAndLogWarnings()
with LoggingBuffer(name="django_tools.unittest_utils.logging_utils", level=logging.DEBUG) as log_buffer:
for i in range(3):
instance(
message="test_filter_and_log_skip_external_package dist-packages %i" % i,
category=UserWarning,
filename="/foo/dist-packages/bar.py",
lineno=456,
)
instance(
message="test_filter_and_log_skip_external_package site-packages %i" % i,
category=UserWarning,
filename="/foo/site-packages/bar.py",
lineno=789,
)
log_messages = log_buffer.get_messages()
print("log_messages:\n%s" % log_messages)
assert_pformat_equal(
log_messages,
(
"WARNING:django_tools.unittest_utils.logging_utils:There are warnings in: /foo/dist-packages/bar.py\n"
"WARNING:django_tools.unittest_utils.logging_utils:There are warnings in: /foo/site-packages/bar.py"
),
)
def test_not_endswith(self):
with self.assertRaises(AssertionError) as cm:
assert_endswith("foo", "bar")
assert_pformat_equal(cm.exception.args[0],
"'foo' doesn't ends with 'bar'")
def test_generate_code(self):
self.login(usertype="superuser")
user_pks = User.objects.all().values_list("pk", flat=True)
response = self.client.post(
path="/admin/auth/user/",
data={"action": "generate_test_code", ACTION_CHECKBOX_NAME: user_pks, "index": 0},
HTTP_ACCEPT_LANGUAGE="en",
)
# TODO: check content-type and filename!
self.assertResponse(
response,
must_contain=(
"from auth.User <class 'django.contrib.auth.models.User'>",
"user = User.objects.create(",
"username='******', # CharField, String (up to 150)",
"username='******', # CharField, String (up to 150)",
"username='******', # CharField, String (up to 150)",
),
must_not_contain=("Error", "Traceback"),
status_code=200,
template_name=None,
messages=[],
html=False,
browser_traceback=True,
)
headers = response._headers
pprint(headers)
assert_pformat_equal(
headers["content-disposition"], ("Content-Disposition", "attachment; filename=auth.User.py")
)
assert_pformat_equal(headers["content-type"], ("Content-Type", "text/python"))
def test_basic(self):
assert_pformat_equal(
self.instance.permit_edit,
limit_to_usergroups.UsergroupsModelField.SUPERUSERS)
assert_pformat_equal(
self.instance.permit_view,
limit_to_usergroups.UsergroupsModelField.ANONYMOUS_USERS)
def test_find_executable(self):
with self.assertWarns(DeprecationWarning) as cm:
with self.assertRaises(FileNotFoundError):
find_executable("foobar")
assert_pformat_equal(str(cm.warning), "Use 'from django_tools.selenium.utils import find_executable' !")
def test_update_existing_user(self):
superuser = self.UserModel.objects.filter(is_superuser=True,
is_active=True)[0]
encrypted_password = superuser.password
group1, created = get_or_create_group(groupname="group1",
permissions=())
self.assertTrue(created)
user, created = get_or_create_user(
username="******",
group=group1,
encrypted_password=encrypted_password)
self.assertTrue(created)
assert_pformat_equal(
list(self.UserModel.objects.get(username="******").groups.all()),
[group1])
# Update user and attach group2:
group2, created = get_or_create_group(groupname="group2",
permissions=())
self.assertTrue(created)
user, created = get_or_create_user(
username="******",
group=group2,
encrypted_password=encrypted_password)
self.assertFalse(created)
assert_pformat_equal(
list(self.UserModel.objects.get(username="******").groups.all()),
[group2])
def test_get_admin_change_url(self):
obj = PermissionTestModel.objects.create()
url = self.get_admin_change_url(obj)
if django.VERSION < (1, 11):
assert_pformat_equal(url, f"/admin/django_tools_test_app/permissiontestmodel/{obj.pk:d}/")
else:
assert_pformat_equal(url, f"/admin/django_tools_test_app/permissiontestmodel/{obj.pk:d}/change/")
def test_directory_traversal_attack_encodings(self):
base_path = os.path.abspath(os.path.dirname(django_tools.__file__))
rest_urls = (
"/etc/passwd",
"..",
"../",
"\\\\",
# URI encoded directory traversal:
"%2e%2e%2f", # ../
"%2e%2e/", # ../
"..%2f", # ../
"%2e%2e%5c", # ..\
# Unicode / UTF-8 encoded directory traversal:
"..%c1%1c", # ../
"..%c0%af", # ..\
"%c0%ae%c0%ae%c1%1c", # %c0%ae -> . -> ../
"%c0%ae%c0%ae%c0%af", # %c0%ae -> . -> ..\
)
for rest_url in rest_urls:
# print(rest_url)
try:
BaseFilesystemBrowser(request=None,
absolute_path=self.BASE_PATH,
base_url="bar",
rest_url=rest_url)
except Http404 as err:
assert_pformat_equal(six.text_type(err),
"Directory doesn't exist!")
def test_assert_path_not_exists_is_dir(self):
with self.assertRaises(AssertionError) as cm:
assert_path_not_exists(str(self.existing_dir_path))
assert_pformat_equal(
cm.exception.args[0],
f"Path is a existing directory: {self.existing_dir_path}")
def test_firefox_available(self):
with self.assertWarns(DeprecationWarning) as cm:
firefox_available()
assert_pformat_equal(
str(cm.warning), "Use 'from django_tools.selenium.geckodriver import firefox_available' !"
)
def test_SeleniumFirefoxTestCase(self):
with self.assertWarns(DeprecationWarning) as cm:
SeleniumFirefoxTestCase()
assert_pformat_equal(
str(cm.warning), "Use 'from django_tools.selenium.django import SeleniumFirefoxStaticLiveServerTestCase' !"
)
def test_has_perm_log(self):
with LoggingBuffer(name="django_tools.permissions",
level=logging.DEBUG) as log:
assert_pformat_equal(has_perm(self.normal_user, "foo.bar1"), False)
assert_pformat_equal(
log.get_messages(), "DEBUG:django_tools.permissions:"
"User normal_test_user has not foo.bar1")
def test_chromium_available(self):
with self.assertWarns(DeprecationWarning) as cm:
chromium_available()
assert_pformat_equal(
str(cm.warning), "Use 'from django_tools.selenium.chromedriver import chromium_available' !"
)
def test_not_start_with_allow_all_schemes(self):
URLValidator2(allow_schemes=("svn", ))("svn://domain.test")
try:
URLValidator2(allow_schemes=("http", "ftp"))("svn://domain.test")
except ValidationError as err:
assert_pformat_equal(
str(err.message),
"The URL doesn't start with a allowed scheme.")
def test_directory_traversal_attack1(self):
try:
BaseFilesystemBrowser(request=None,
absolute_path=self.BASE_PATH,
base_url="bar",
rest_url="../")
except Http404 as err:
assert_pformat_equal(str(err), "Directory doesn't exist!")
def test_debug_message(self):
sub_path = os.path.normpath(os.path.join(self.BASE_PATH, ".."))
try:
BaseFilesystemBrowser(request=None, absolute_path=self.BASE_PATH, base_url="bar", rest_url="../")
except Http404 as err:
assert_pformat_equal(
err.args[0].message, "Directory '%s' is not in base path ('%s')" % (sub_path, self.BASE_PATH)
)
def test_filter_permission3(self):
queryset = LimitToUsergroupsTestModel.objects.all()
# Check if he is in the user group
self.user1.groups.add(self.user_group)
self.user1.save()
items = limit_to_usergroups.filter_permission(queryset, permit_edit=self.user1)
assert_pformat_equal(len(items), 2)
def test_get_messages_without_context(self):
response = self.client.get("/create_message_redirect_response/redirect-response-message/")
assert_pformat_equal(self.get_messages(response), ["redirect-response-message"])
self.assertMessages(response, ["redirect-response-message"])
self.assertResponse(response, status_code=302, messages=["redirect-response-message"])
def assert_permissiontestmodel(self, permission):
self.assertIsInstance(permission, Permission)
self.assertIsInstance(permission.content_type, ContentType)
assert_pformat_equal(permission.content_type.app_label,
"django_tools_test_app")
assert_pformat_equal(permission.content_type.model,
"permissiontestmodel")
def test_add_permissions(self):
permissions = ((LimitToUsergroupsTestModel, "extra_permission"), )
add_permissions(permission_obj=self.normal_group,
permissions=permissions)
user = self.refresh_user(self.normal_user)
assert_pformat_equal(user.get_all_permissions(),
{"django_tools_test_app.extra_permission"})
def test_enhanced_example(self):
q = GetDict()
q["next"] = "/a&b/"
q["foo"] = "bar"
q["number"] = 123
q["empty"] = None
assert_pformat_equal(q.urlencode(), "empty&foo=bar&next=%2Fa%26b%2F&number=123")
assert_pformat_equal(q.urlencode(safe="/"), "empty&foo=bar&next=/a%26b/&number=123")
def test_get_messages_without_context(self):
response = self.client.get("/create_message_redirect_response/redirect-response-message/")
assert_pformat_equal(self.get_messages(response), ["redirect-response-message"])
self.assertMessages(response, ["redirect-response-message"])
self.assertResponse(response, status_code=302, messages=["redirect-response-message"])
def test_get_filtered_permissions(self):
permissions = get_filtered_permissions(
exclude_app_labels=('easy_thumbnails', 'filer'),
exclude_models=(LimitToUsergroupsTestModel, PermissionTestModel),
exclude_codenames=('delete_group', 'delete_user'),
exclude_permissions=((ContentType, 'add_contenttype'),
(ContentType, 'delete_contenttype')),
)
permissions = permissions2list(permissions)
assert_pformat_equal(
permissions,
[
'admin.add_logentry',
'admin.change_logentry',
'admin.delete_logentry',
'admin.view_logentry',
'auth.add_group',
'auth.change_group',
'auth.view_group',
'auth.add_permission',
'auth.change_permission',
'auth.delete_permission',
'auth.view_permission',
'auth.add_user',
'auth.change_user',
'auth.view_user',
'contenttypes.change_contenttype',
'contenttypes.view_contenttype',
'django_tools_test_app.add_overwritefilesystemstoragemodel',
'django_tools_test_app.change_overwritefilesystemstoragemodel',
'django_tools_test_app.delete_overwritefilesystemstoragemodel',
'django_tools_test_app.view_overwritefilesystemstoragemodel',
'django_tools_test_app.add_simpleparlermodel',
'django_tools_test_app.change_simpleparlermodel',
'django_tools_test_app.delete_simpleparlermodel',
'django_tools_test_app.view_simpleparlermodel',
'django_tools_test_app.add_usermediafiles',
'django_tools_test_app.change_usermediafiles',
'django_tools_test_app.delete_usermediafiles',
'django_tools_test_app.view_usermediafiles',
'flatpages.add_flatpage',
'flatpages.change_flatpage',
'flatpages.delete_flatpage',
'flatpages.view_flatpage',
'serve_media_app.add_usermediatokenmodel',
'serve_media_app.change_usermediatokenmodel',
'serve_media_app.delete_usermediatokenmodel',
'serve_media_app.view_usermediatokenmodel',
'sessions.add_session',
'sessions.change_session',
'sessions.delete_session',
'sessions.view_session',
'sites.add_site',
'sites.change_site',
'sites.delete_site',
'sites.view_site',
],
)
def test_get_admin_permissions(self):
permissions = get_admin_permissions()
permissions = permissions2list(permissions)
assert_pformat_equal(
permissions,
[
"auth.add_group",
"auth.change_group",
"auth.delete_group",
"auth.view_group",
"auth.add_user",
"auth.change_user",
"auth.delete_user",
"auth.view_user",
"django_tools_test_app.add_overwritefilesystemstoragemodel",
"django_tools_test_app.change_overwritefilesystemstoragemodel",
"django_tools_test_app.delete_overwritefilesystemstoragemodel",
"django_tools_test_app.view_overwritefilesystemstoragemodel",
"django_tools_test_app.add_permissiontestmodel",
"django_tools_test_app.change_permissiontestmodel",
"django_tools_test_app.delete_permissiontestmodel",
"django_tools_test_app.extra_permission",
"django_tools_test_app.view_permissiontestmodel",
"filer.add_clipboard",
"filer.change_clipboard",
"filer.delete_clipboard",
"filer.view_clipboard",
"filer.add_file",
"filer.change_file",
"filer.delete_file",
"filer.view_file",
"filer.add_folder",
"filer.can_use_directory_listing",
"filer.change_folder",
"filer.delete_folder",
"filer.view_folder",
"filer.add_folderpermission",
"filer.change_folderpermission",
"filer.delete_folderpermission",
"filer.view_folderpermission",
"filer.add_image",
"filer.change_image",
"filer.delete_image",
"filer.view_image",
"filer.add_thumbnailoption",
"filer.change_thumbnailoption",
"filer.delete_thumbnailoption",
"filer.view_thumbnailoption",
"flatpages.add_flatpage",
"flatpages.change_flatpage",
"flatpages.delete_flatpage",
"flatpages.view_flatpage",
"sites.add_site",
"sites.change_site",
"sites.delete_site",
"sites.view_site",
],
)
def test_has_perm_log(self):
with self.assertLogs(logger="django_tools.permissions",
level=logging.DEBUG) as log:
assert_pformat_equal(has_perm(self.normal_user, "foo.bar1"), False)
assert log.output == [
"DEBUG:django_tools.permissions:"
"User normal_test_user has not foo.bar1"
]
def test_filter_permission3(self):
queryset = LimitToUsergroupsTestModel.objects.all()
# Check if he is in the user group
self.user1.groups.add(self.user_group)
self.user1.save()
items = limit_to_usergroups.filter_permission(queryset,
permit_edit=self.user1)
assert_pformat_equal(len(items), 2)
def test_create_django_file_info_image(self):
with warnings.catch_warnings(record=True) as w:
warnings.simplefilter("always") # trigger all warnings
django_file = ImageDummy(width=100, height=50).create_django_file_info_image(text="foo bar")
self.assertIsInstance(django_file, DjangoFile)
assert_pformat_equal(len(w), 0) # No warnings created
def test_log_group_permissions1(self):
with LoggingBuffer(name="django_tools.permissions",
level=logging.DEBUG) as log:
log_group_permissions(self.normal_group)
assert_pformat_equal(
log.get_messages(),
"DEBUG:django_tools.permissions:User group 'Normal User Group' has no permission!"
)
def test_create_django_file_info_image(self):
with warnings.catch_warnings(record=True) as w:
warnings.simplefilter("always") # trigger all warnings
django_file = ImageDummy(width=100, height=50).create_django_file_info_image(text="foo bar")
self.assertIsInstance(django_file, DjangoFile)
assert_pformat_equal(len(w), 0) # No warnings created
def test_create_user(self):
user1 = create_user(username="******", password="******")
user2 = self.UserModel.objects.get(username="******")
assert_pformat_equal(user1.pk, user2.pk)
assert_pformat_equal(user1, user2)
# check defaults:
self.assertFalse(user2.is_staff)
self.assertFalse(user2.is_superuser)
def test_get_super_user(self):
self.UserModel.objects.all().delete()
create_user(username="******", password="******")
user2 = create_user(username="******", password="******", is_superuser=True)
user3 = get_super_user()
assert_pformat_equal(user2.pk, user3.pk)
assert_pformat_equal(user2, user3)
self.assertTrue(user3.is_superuser)
def test_render_template_file(self):
context = {"foo": "bar"}
path = "test_template.html"
x = render_template_file(path, context)
print(x)
# Note: START/END comments added by: django_tools.template.loader.DebugCacheLoader
assert_pformat_equal(
x, ("<!-- START 'test_template.html' -->\n" "Hello bar !\n\n" "<!-- END 'test_template.html' -->")
)
def test_create_users(self):
self.UserModel.objects.all().delete()
self.create_testusers()
usernames = self.UserModel.objects.all().values_list("username", flat=True)
usernames = list(usernames)
usernames.sort()
assert_pformat_equal(usernames, ["normal_test_user", "staff_test_user", "superuser"])
# Are all users active?
assert_pformat_equal(self.UserModel.objects.filter(is_active=True).count(), 3)
def test_re_usage(self):
"""
e.g.: django.http.request.split_domain_port used RE in test environment
:return:
"""
host = self.fnmatch_ips[0]
self.assertTrue(host_validation_re.match(host))
domain, port = split_domain_port(host)
assert_pformat_equal(domain, "127.0.0.1")
assert_pformat_equal(port, "")
def test_find_executable(self):
with tempfile.NamedTemporaryFile(prefix="test_not_executable_", delete=False) as f:
filepath = Path(f.name).resolve()
self.assertTrue(filepath.is_file())
name = filepath.name
path = filepath.parent
# File is not in PATH:
with self.assertRaises(FileNotFoundError) as context_manager:
find_executable(name)
assert_pformat_equal(context_manager.exception.args, ("Can't find '%s' in PATH or None!" % name,))
old_path = os.environ["PATH"]
try:
# File is in PATH, but not executable:
os.environ["PATH"] += "%s%s" % (os.pathsep, path)
with self.assertRaises(FileNotFoundError) as context_manager:
find_executable(name)
assert_pformat_equal(
context_manager.exception.args, ("%s exists, but it's not executable!" % filepath,)
)
# File is in PATH and executable:
filepath.chmod(0x777)
result = find_executable(name)
assert_pformat_equal(result, filepath)
finally:
os.environ["PATH"] = old_path
# Executable file is not in PATH, but can be found via extra_search_paths:
result = find_executable(name, extra_search_paths=(path,))
assert_pformat_equal(result, filepath)
def test_only_local_path2(self):
"""
**Note:** Validating the network location (netloc):
Following the syntax specifications in RFC 1808, urlparse recognizes a
netloc only if it is properly introduced by '//'. Otherwise the input is
presumed to be a relative URL and thus to start with a path component.
See: http://docs.python.org/library/urlparse.html#urlparse.urlparse
"""
validator = URLValidator2(allow_schemes=None, allow_netloc=False)
validator("www.pylucid.org/path?query#fragment")
try:
validator("//www.pylucid.org/path?query#fragment")
except ValidationError as err:
assert_pformat_equal(six.text_type(err.message), "Please enter a local URL (without protocol/domain).")
def test_filter_and_log_warnings_direct_call(self):
instance = FilterAndLogWarnings()
with LoggingBuffer(name="django_tools.unittest_utils.logging_utils", level=logging.DEBUG) as log_buffer:
instance(
message="test_filter_and_log_warnings_direct_call",
category=UserWarning,
filename="/foo/bar.py",
lineno=123,
)
assert_pformat_equal(
log_buffer.get_messages(),
"WARNING:django_tools.unittest_utils.logging_utils:UserWarning:test_filter_and_log_warnings_direct_call",
)
def test_get_messages_normal_response(self):
response = self.client.get("/create_message_normal_response/normal-response-message/")
assert_pformat_equal(self.get_messages(response), ["normal-response-message"])
self.assertMessages(response, ["normal-response-message"])
self.assertResponse(
response,
must_contain=("django_tools_test_app.views.create_message_normal_response",),
must_not_contain=("error", "traceback"),
status_code=200,
messages=["normal-response-message"],
html=False,
browser_traceback=True,
)
def test_directory_traversal_attack_encodings(self):
parts = (
# URI encoded directory traversal:
"%2e%2e%2f", # ../
"%2e%2e/", # ../
"..%2f", # ../
"%2e%2e%5c", # ..\
# Unicode / UTF-8 encoded directory traversal:
"..%c1%1c", # ../
"..%c0%af", # ..\
"%c0%ae", # .
)
for part in parts:
try:
self.media_root_validator(part)
except ValidationError as err:
assert_pformat_equal(six.text_type(err.message), "Directory doesn't exist!")
