import difflib

import json

import logging

import pickle

import posixpath

import sys

import threading

import unittest

from collections import Counter

from contextlib import contextmanager

from copy import copy, deepcopy

from difflib import get_close_matches

from functools import wraps

from unittest import mock

from unittest.suite import _DebugResult

from unittest.util import safe_repr

from urllib.parse import (

parse_qsl,

unquote,

urlencode,

urljoin,

urlparse,

urlsplit,

urlunsplit,

)

from urllib.request import url2pathname

from asgiref.sync import async_to_sync, iscoroutinefunction

from django.apps import apps

from django.conf import settings

from django.core import mail

from django.core.exceptions import ImproperlyConfigured, ValidationError

from django.core.files import locks

from django.core.handlers.wsgi import WSGIHandler, get_path_info

from django.core.management import call_command

from django.core.management.color import no_style

from django.core.management.sql import emit_post_migrate_signal

from django.core.servers.basehttp import ThreadedWSGIServer, WSGIRequestHandler

from django.core.signals import setting_changed

from django.db import DEFAULT_DB_ALIAS, connection, connections, transaction

from django.db.backends.base.base import NO_DB_ALIAS, BaseDatabaseWrapper

from django.forms.fields import CharField

from django.http import QueryDict

from django.http.request import split_domain_port, validate_host

from django.template.base import PartialTemplate

from django.test.client import AsyncClient, Client

from django.test.html import HTMLParseError, parse_html

from django.test.signals import template_rendered

from django.test.utils import (

CaptureQueriesContext,

ContextList,

compare_xml,

modify_settings,

override_settings,

)

from django.utils.functional import classproperty

from django.views.static import serve

logger = logging.getLogger("django.test")

__all__ = (

"TestCase",

"TransactionTestCase",

"SimpleTestCase",

"skipIfDBFeature",

"skipUnlessDBFeature",

)

# Make unittest ignore frames in this module when reporting failures.

__unittest = True

def to_list(value):

"""Put value into a list if it's not already one."""

if not isinstance(value, list):

value = [value]

return value

def is_pickable(obj):

"""

Returns true if the object can be dumped and loaded through the pickle

module.

"""

try:

pickle.loads(pickle.dumps(obj))

except (AttributeError, TypeError, pickle.PickleError):

return False

return True

def assert_and_parse_html(self, html, user_msg, msg):

try:

dom = parse_html(html)

except HTMLParseError as e:

standardMsg = "%s\n%s" % (msg, e)

self.fail(self._formatMessage(user_msg, standardMsg))

return dom

class _AssertNumQueriesContext(CaptureQueriesContext):

def __init__(self, test_case, num, connection):

self.test_case = test_case

self.num = num

super().__init__(connection)

def __exit__(self, exc_type, exc_value, traceback):

super().__exit__(exc_type, exc_value, traceback)

if exc_type is not None:

return

executed = len(self)

self.test_case.assertEqual(

executed,

self.num,

"%d queries executed, %d expected\nCaptured queries were:\n%s"

% (

executed,

self.num,

"\n".join(

"%d. %s" % (i, query["sql"])

for i, query in enumerate(self.captured_queries, start=1)

),

),

)

class _AssertTemplateUsedContext:

def __init__(self, test_case, template_name, msg_prefix="", count=None):

self.test_case = test_case

self.template_name = template_name

self.msg_prefix = msg_prefix

self.count = count

self.rendered_templates = []

self.context = ContextList()

def on_template_render(self, sender, signal, template, context, **kwargs):

self.rendered_templates.append(template)

self.context.append(copy(context))

@property

def rendered_template_names(self):

return [

(

f"{t.origin.template_name}#{t.name}"

if isinstance(t, PartialTemplate)

else t.name

)

for t in self.rendered_templates

if t.name is not None

]

def test(self):

self.test_case._assert_template_used(

self.template_name,

self.rendered_template_names,

self.msg_prefix,

self.count,

)

def __enter__(self):

template_rendered.connect(self.on_template_render)

return self

def __exit__(self, exc_type, exc_value, traceback):

template_rendered.disconnect(self.on_template_render)

if exc_type is not None:

return

self.test()

class _AssertTemplateNotUsedContext(_AssertTemplateUsedContext):

def test(self):

self.test_case.assertFalse(

self.template_name in self.rendered_template_names,

f"{self.msg_prefix}Template '{self.template_name}' was used "

f"unexpectedly in rendering the response",

)

class DatabaseOperationForbidden(AssertionError):

pass

class _DatabaseFailure:

def __init__(self, wrapped, message):

self.wrapped = wrapped

self.message = message

def __call__(self):

raise DatabaseOperationForbidden(self.message)

class SimpleTestCase(unittest.TestCase):

# The class we'll use for the test client self.client.

# Can be overridden in derived classes.

client_class = Client

async_client_class = AsyncClient

_overridden_settings = None

_modified_settings = None

_pre_setup_ran_eagerly = False

databases = set()

_disallowed_database_msg = (

"Database %(operation)s to %(alias)r are not allowed in SimpleTestCase "

"subclasses. Either subclass TestCase or TransactionTestCase to ensure "

"proper test isolation or add %(alias)r to %(test)s.databases to silence "

"this failure."

)

_disallowed_connection_methods = [

("connect", "connections"),

("temporary_connection", "connections"),

("cursor", "queries"),

("chunked_cursor", "queries"),

]

@classmethod

def setUpClass(cls):

super().setUpClass()

if cls._overridden_settings:

cls.enterClassContext(override_settings(**cls._overridden_settings))

if cls._modified_settings:

cls.enterClassContext(modify_settings(cls._modified_settings))

cls._add_databases_failures()

cls.addClassCleanup(cls._remove_databases_failures)

@classmethod

def _validate_databases(cls):

if cls.databases == "__all__":

return frozenset(connections)

for alias in cls.databases:

if alias not in connections:

message = (

"%s.%s.databases refers to %r which is not defined in "

"settings.DATABASES."

% (

cls.__module__,

cls.__qualname__,

alias,

)

)

close_matches = get_close_matches(alias, list(connections))

if close_matches:

message += " Did you mean %r?" % close_matches[0]

raise ImproperlyConfigured(message)

return frozenset(cls.databases)

@classmethod

def _add_databases_failures(cls):

cls.databases = cls._validate_databases()

for alias in connections:

if alias in cls.databases:

continue

connection = connections[alias]

for name, operation in cls._disallowed_connection_methods:

message = cls._disallowed_database_msg % {

"test": "%s.%s" % (cls.__module__, cls.__qualname__),

"alias": alias,

"operation": operation,

}

method = getattr(connection, name)

setattr(connection, name, _DatabaseFailure(method, message))

cls.enterClassContext(

mock.patch.object(

BaseDatabaseWrapper,

"ensure_connection",

new=cls.ensure_connection_patch_method(),

)

)

@classmethod

def _remove_databases_failures(cls):

for alias in connections:

if alias in cls.databases:

continue

connection = connections[alias]

for name, _ in cls._disallowed_connection_methods:

method = getattr(connection, name)

setattr(connection, name, method.wrapped)

@classmethod

def ensure_connection_patch_method(cls):

real_ensure_connection = BaseDatabaseWrapper.ensure_connection

def patched_ensure_connection(self, *args, **kwargs):

if (

self.connection is None

and self.alias not in cls.databases

and self.alias != NO_DB_ALIAS

# Dynamically created connections are always allowed.

and self.alias in connections

):

# Connection has not yet been established, but the alias is not

# allowed.

message = cls._disallowed_database_msg % {

"test": f"{cls.__module__}.{cls.__qualname__}",

"alias": self.alias,

"operation": "threaded connections",

}

return _DatabaseFailure(self.ensure_connection, message)()

real_ensure_connection(self, *args, **kwargs)

return patched_ensure_connection

def __call__(self, result=None):

"""

Wrapper around default __call__ method to perform common Django test

set up. This means that user-defined TestCases aren't required to

include a call to super().setUp().

"""

self._setup_and_call(result)

def __getstate__(self):

"""

Make SimpleTestCase picklable for parallel tests using subtests.

"""

state = super().__dict__

# _outcome and _subtest cannot be tested on picklability, since they

# contain the TestCase itself, leading to an infinite recursion.

if state["_outcome"]:

pickable_state = {"_outcome": None, "_subtest": None}

for key, value in state.items():

if key in pickable_state or not is_pickable(value):

continue

pickable_state[key] = value

return pickable_state

return state

def debug(self):

"""Perform the same as __call__(), without catching the exception."""

debug_result = _DebugResult()

self._setup_and_call(debug_result, debug=True)

def _setup_and_call(self, result, debug=False):

"""

Perform the following in order: pre-setup, run test, post-teardown,

skipping pre/post hooks if test is set to be skipped.

If debug=True, reraise any errors in setup and use super().debug()

instead of __call__() to run the test.

"""

testMethod = getattr(self, self._testMethodName)

skipped = getattr(self.__class__, "__unittest_skip__", False) or getattr(

testMethod, "__unittest_skip__", False

)

# Convert async test methods.

if iscoroutinefunction(testMethod):

setattr(self, self._testMethodName, async_to_sync(testMethod))

if not skipped:

try:

if self.__class__._pre_setup_ran_eagerly:

self.__class__._pre_setup_ran_eagerly = False

else:

self._pre_setup()

except Exception:

if debug:

raise

result.addError(self, sys.exc_info())

return

if debug:

super().debug()

else:

super().__call__(result)

if not skipped:

try:

self._post_teardown()

except Exception:

if debug:

raise

result.addError(self, sys.exc_info())

return

@classmethod

def _pre_setup(cls):

"""

Perform pre-test setup:

* Create a test client.

* Clear the mail test outbox.

"""

cls.client = cls.client_class()

cls.async_client = cls.async_client_class()

mail.outbox = []

def _post_teardown(self):

"""Perform post-test things."""

pass

def settings(self, **kwargs):

"""

A context manager that temporarily sets a setting and reverts to the

original value when exiting the context.

"""

return override_settings(**kwargs)

def modify_settings(self, **kwargs):

"""

A context manager that temporarily applies changes to a list setting

and reverts back to the original value when exiting the context.

"""

return modify_settings(**kwargs)

def assertRedirects(

self,

response,

expected_url,

status_code=302,

target_status_code=200,

msg_prefix="",

fetch_redirect_response=True,

):

"""

Assert that a response redirected to a specific URL and that the

redirect URL can be loaded.

Won't work for external links since it uses the test client to do a

request (use fetch_redirect_response=False to check such links without

fetching them).

"""

if msg_prefix:

msg_prefix += ": "

if hasattr(response, "redirect_chain"):

# The request was a followed redirect

self.assertTrue(

response.redirect_chain,

msg_prefix

+ (

"Response didn't redirect as expected: Response code was %d "

"(expected %d)"

)

% (response.status_code, status_code),

)

self.assertEqual(

response.redirect_chain[0][1],

status_code,

msg_prefix

+ (

"Initial response didn't redirect as expected: Response code was "

"%d (expected %d)"

)

% (response.redirect_chain[0][1], status_code),

)

url, status_code = response.redirect_chain[-1]

self.assertEqual(

response.status_code,

target_status_code,

msg_prefix

+ (

"Response didn't redirect as expected: Final Response code was %d "

"(expected %d)"

)

% (response.status_code, target_status_code),

)

else:

# Not a followed redirect

self.assertEqual(

response.status_code,

status_code,

msg_prefix

+ (

"Response didn't redirect as expected: Response code was %d "

"(expected %d)"

)

% (response.status_code, status_code),

)

url = response.url

scheme, netloc, path, query, fragment = urlsplit(url)

# Prepend the request path to handle relative path redirects.

if not path.startswith("/"):

url = urljoin(response.request["PATH_INFO"], url)

path = urljoin(response.request["PATH_INFO"], path)

if fetch_redirect_response:

# netloc might be empty, or in cases where Django tests the

# HTTP scheme, the convention is for netloc to be 'testserver'.

# Trust both as "internal" URLs here.

domain, port = split_domain_port(netloc)

if domain and not validate_host(domain, settings.ALLOWED_HOSTS):

raise ValueError(

"The test client is unable to fetch remote URLs (got %s). "

"If the host is served by Django, add '%s' to ALLOWED_HOSTS. "

"Otherwise, use "

"assertRedirects(..., fetch_redirect_response=False)."

% (url, domain)

)

# Get the redirection page, using the same client that was used

# to obtain the original response.

extra = response.client.extra or {}

headers = response.client.headers or {}

redirect_response = response.client.get(

path,

QueryDict(query),

secure=(scheme == "https"),

headers=headers,

**extra,

)

self.assertEqual(

redirect_response.status_code,

target_status_code,

msg_prefix

+ (

"Couldn't retrieve redirection page '%s': response code was %d "

"(expected %d)"

)

% (path, redirect_response.status_code, target_status_code),

)

self.assertURLEqual(

url,

expected_url,

msg_prefix

+ "Response redirected to '%s', expected '%s'" % (url, expected_url),

)

def assertURLEqual(self, url1, url2, msg_prefix=""):

"""

Assert that two URLs are the same, ignoring the order of query string

parameters except for parameters with the same name.

For example, /path/?x=1&y=2 is equal to /path/?y=2&x=1, but

/path/?a=1&a=2 isn't equal to /path/?a=2&a=1.

"""

def normalize(url):

"""Sort the URL's query string parameters."""

url = str(url) # Coerce reverse_lazy() URLs.

scheme, netloc, path, query, fragment = urlsplit(url)

query_parts = sorted(parse_qsl(query))

return urlunsplit((scheme, netloc, path, urlencode(query_parts), fragment))

if msg_prefix:

msg_prefix += ": "

self.assertEqual(

normalize(url1),

normalize(url2),

msg_prefix + "Expected '%s' to equal '%s'." % (url1, url2),

)

def _text_repr(self, content, force_string):

if isinstance(content, bytes) and not force_string:

return safe_repr(content)

return "'%s'" % str(content)

def _assert_contains(self, response, text, status_code, msg_prefix, html):

# If the response supports deferred rendering and hasn't been rendered

# yet, then ensure that it does get rendered before proceeding further.

if (

hasattr(response, "render")

and callable(response.render)

and not response.is_rendered

):

response.render()

if msg_prefix:

msg_prefix += ": "

self.assertEqual(

response.status_code,

status_code,

msg_prefix + "Couldn't retrieve content: Response code was %d"

" (expected %d)" % (response.status_code, status_code),

)

if response.streaming:

content = b"".join(response.streaming_content)

else:

content = response.content

response_content = content

if not isinstance(text, bytes) or html:

text = str(text)

content = content.decode(response.charset)

if html:

content = assert_and_parse_html(

self, content, None, "Response's content is not valid HTML:"

)

text = assert_and_parse_html(

self, text, None, "Second argument is not valid HTML:"

)

real_count = content.count(text)

return real_count, msg_prefix, response_content

def assertContains(

self, response, text, count=None, status_code=200, msg_prefix="", html=False

):

"""

Assert that a response indicates that some content was retrieved

successfully, (i.e., the HTTP status code was as expected) and that

``text`` occurs ``count`` times in the content of the response.

If ``count`` is None, the count doesn't matter - the assertion is true

if the text occurs at least once in the response.

"""

real_count, msg_prefix, response_content = self._assert_contains(

response, text, status_code, msg_prefix, html

)

if (count is None and real_count > 0) or (

(count is not None and real_count == count)

):

return

text_repr = self._text_repr(text, force_string=html)

if count is not None:

msg = (

f"{real_count} != {count} : {msg_prefix}Found {real_count} instances "

f"of {text_repr} (expected {count}) in the following response\n"

f"{response_content!r}"

)

else:

msg = (

f"False is not true : {msg_prefix}Couldn't find {text_repr} in the "

f"following response\n{response_content!r}"

)

self.fail(msg)

def assertNotContains(

self, response, text, status_code=200, msg_prefix="", html=False

):

"""

Assert that a response indicates that some content was retrieved

successfully, (i.e., the HTTP status code was as expected) and that

``text`` doesn't occur in the content of the response.

"""

real_count, msg_prefix, response_content = self._assert_contains(

response, text, status_code, msg_prefix, html

)

if real_count != 0:

text_repr = self._text_repr(text, force_string=html)

self.fail(

f"{real_count} != 0 :{msg_prefix}{text_repr} unexpectedly found in the "

f"following response\n{response_content!r}"

)

def _check_test_client_response(self, response, attribute, method_name):

"""

Raise a ValueError if the given response doesn't have the required

attribute.

"""

if not hasattr(response, attribute):

raise ValueError(

f"{method_name}() is only usable on responses fetched using "

"the Django test Client."

)

def _form_repr(self, form, formset, form_index):

if formset is None:

return f"form {form!r}"

return f"form {form_index} of formset {formset!r}"

def _assert_form_error(

self, form, field, errors, msg_prefix, formset=None, form_index=None

):

if not form.is_bound:

self.fail(

"%sThe %s is not bound, it will never have any errors."

% (msg_prefix, self._form_repr(form, formset, form_index))

)

if field is not None and field not in form.fields:

self.fail(

"%sThe %s does not contain the field %r."

% (msg_prefix, self._form_repr(form, formset, form_index), field)

)

field_errors = (

form.non_field_errors() if field is None else form.errors.get(field, [])

)

if field_errors == errors:

return

# Use assertEqual to show detailed diff if errors don't match.

if field is None:

failure_message = "The non-field errors of %s don't match." % (

self._form_repr(form, formset, form_index),

)

else:

failure_message = "The errors of field %r on %s don't match." % (

field,

self._form_repr(form, formset, form_index),

)

self.assertEqual(field_errors, errors, msg_prefix + failure_message)

def assertFormError(self, form, field, errors, msg_prefix=""):

"""

Assert that a field named "field" on the given form object has specific

errors.

errors can be either a single error message or a list of errors

messages. Using errors=[] test that the field has no errors.

You can pass field=None to check the form's non-field errors.

"""

if msg_prefix:

msg_prefix += ": "

errors = to_list(errors)

self._assert_form_error(form, field, errors, msg_prefix)

def assertFormSetError(self, formset, form_index, field, errors, msg_prefix=""):

"""

Similar to assertFormError() but for formsets.

Use form_index=None to check the formset's non-form errors (in that

case, you must also use field=None).

Otherwise use an integer to check the formset's n-th form for errors.

Other parameters are the same as assertFormError().

"""

if form_index is None and field is not None:

raise ValueError("You must use field=None with form_index=None.")

if msg_prefix:

msg_prefix += ": "

errors = to_list(errors)

if not formset.is_bound:

self.fail(

f"{msg_prefix}The formset {formset!r} is not bound, it will never have "

f"any errors."

)

if form_index is not None and form_index >= formset.total_form_count():

form_count = formset.total_form_count()

form_or_forms = "forms" if form_count > 1 else "form"

self.fail(

f"{msg_prefix}The formset {formset!r} only has {form_count} "

f"{form_or_forms}."

)

if form_index is not None:

self._assert_form_error(

formset.forms[form_index],

field,

errors,

msg_prefix,

formset=formset,

form_index=form_index,

)

else:

formset_errors = formset.non_form_errors()

if formset_errors == errors:

# Skip assertion if errors already match.

return

failure_message = f"The non-form errors of formset {formset!r} don't match."

self.assertEqual(formset_errors, errors, msg_prefix + failure_message)

def _get_template_used(self, response, template_name, msg_prefix, method_name):

if response is None and template_name is None:

raise TypeError("response and/or template_name argument must be provided")

if msg_prefix:

msg_prefix += ": "

if template_name is not None and response is not None:

self._check_test_client_response(response, "templates", method_name)

if not hasattr(response, "templates") or (response is None and template_name):

if response:

template_name = response

response = None

# use this template with context manager

return template_name, None, msg_prefix

template_names = [t.name for t in response.templates if t.name is not None]

return None, template_names, msg_prefix

def _assert_template_used(self, template_name, template_names, msg_prefix, count):

if not template_names:

self.fail(msg_prefix + "No templates used to render the response")

self.assertTrue(

template_name in template_names,

msg_prefix + "Template '%s' was not a template used to render"

" the response. Actual template(s) used: %s"

% (template_name, ", ".join(template_names)),

)

if count is not None:

self.assertEqual(

template_names.count(template_name),

count,

msg_prefix + "Template '%s' was expected to be rendered %d "

"time(s) but was actually rendered %d time(s)."

% (template_name, count, template_names.count(template_name)),

)

def assertTemplateUsed(

self, response=None, template_name=None, msg_prefix="", count=None

):

"""

Assert that the template with the provided name was used in rendering

the response. Also usable as context manager.

"""

context_mgr_template, template_names, msg_prefix = self._get_template_used(

response,

template_name,

msg_prefix,

"assertTemplateUsed",

)

if context_mgr_template:

# Use assertTemplateUsed as context manager.

return _AssertTemplateUsedContext(

self, context_mgr_template, msg_prefix, count

)

self._assert_template_used(template_name, template_names, msg_prefix, count)

def assertTemplateNotUsed(self, response=None, template_name=None, msg_prefix=""):

"""

Assert that the template with the provided name was NOT used in

rendering the response. Also usable as context manager.

"""

context_mgr_template, template_names, msg_prefix = self._get_template_used(

response,

template_name,

msg_prefix,

"assertTemplateNotUsed",

)

if context_mgr_template:

# Use assertTemplateNotUsed as context manager.

return _AssertTemplateNotUsedContext(self, context_mgr_template, msg_prefix)

self.assertFalse(

template_name in template_names,

msg_prefix

+ "Template '%s' was used unexpectedly in rendering the response"

% template_name,

)

@contextmanager

def _assert_raises_or_warns_cm(

self, func, cm_attr, expected_exception, expected_message

):

with func(expected_exception) as cm:

yield cm

self.assertIn(expected_message, str(getattr(cm, cm_attr)))

def _assertFooMessage(

self, func, cm_attr, expected_exception, expected_message, *args, **kwargs

):

callable_obj = None

if args:

callable_obj, *args = args

cm = self._assert_raises_or_warns_cm(

func, cm_attr, expected_exception, expected_message

)

# Assertion used in context manager fashion.

if callable_obj is None:

return cm

# Assertion was passed a callable.

with cm:

callable_obj(*args, **kwargs)

def assertRaisesMessage(

self, expected_exception, expected_message, *args, **kwargs

):

"""

Assert that expected_message is found in the message of a raised

exception.

Args:

expected_exception: Exception class expected to be raised.

expected_message: expected error message string value.

args: Function to be called and extra positional args.

kwargs: Extra kwargs.

"""

return self._assertFooMessage(

self.assertRaises,

"exception",

expected_exception,

expected_message,

*args,

**kwargs,

)

def assertWarnsMessage(self, expected_warning, expected_message, *args, **kwargs):

"""

Same as assertRaisesMessage but for assertWarns() instead of

assertRaises().

"""

return self._assertFooMessage(

self.assertWarns,

"warning",

expected_warning,

expected_message,

*args,

**kwargs,

)

def assertFieldOutput(

self,

fieldclass,

valid,

invalid,

field_args=None,

field_kwargs=None,

empty_value="",

):

"""

Assert that a form field behaves correctly with various inputs.

Args:

fieldclass: the class of the field to be tested.

valid: a dictionary mapping valid inputs to their expected

cleaned values.

invalid: a dictionary mapping invalid inputs to one or more

raised error messages.

field_args: the args passed to instantiate the field

field_kwargs: the kwargs passed to instantiate the field

empty_value: the expected clean output for inputs in empty_values

"""

if field_args is None:

field_args = []

if field_kwargs is None:

field_kwargs = {}

required = fieldclass(*field_args, **field_kwargs)

optional = fieldclass(*field_args, **{**field_kwargs, "required": False})

# test valid inputs

for input, output in valid.items():

self.assertEqual(required.clean(input), output)

self.assertEqual(optional.clean(input), output)

# test invalid inputs

for input, errors in invalid.items():

with self.assertRaises(ValidationError) as context_manager:

required.clean(input)

self.assertEqual(context_manager.exception.messages, errors)

with self.assertRaises(ValidationError) as context_manager:

optional.clean(input)

self.assertEqual(context_manager.exception.messages, errors)

# test required inputs

error_required = [required.error_messages["required"]]

for e in required.empty_values:

with self.assertRaises(ValidationError) as context_manager:

required.clean(e)

self.assertEqual(context_manager.exception.messages, error_required)

self.assertEqual(optional.clean(e), empty_value)

# test that max_length and min_length are always accepted

if issubclass(fieldclass, CharField):

field_kwargs.update({"min_length": 2, "max_length": 20})

self.assertIsInstance(fieldclass(*field_args, **field_kwargs), fieldclass)

def assertHTMLEqual(self, html1, html2, msg=None):

"""

Assert that two HTML snippets are semantically the same.

Whitespace in most cases is ignored, and attribute ordering is not

significant. The arguments must be valid HTML.

"""

dom1 = assert_and_parse_html(

self, html1, msg, "First argument is not valid HTML:"

)

dom2 = assert_and_parse_html(

self, html2, msg, "Second argument is not valid HTML:"

)

if dom1 != dom2:

standardMsg = "%s != %s" % (safe_repr(dom1, True), safe_repr(dom2, True))

diff = "\n" + "\n".join(

difflib.ndiff(

str(dom1).splitlines(),

str(dom2).splitlines(),

)

)

standardMsg = self._truncateMessage(standardMsg, diff)

self.fail(self._formatMessage(msg, standardMsg))

def assertHTMLNotEqual(self, html1, html2, msg=None):

"""Assert that two HTML snippets are not semantically equivalent."""

dom1 = assert_and_parse_html(

self, html1, msg, "First argument is not valid HTML:"

)

dom2 = assert_and_parse_html(

self, html2, msg, "Second argument is not valid HTML:"

)

if dom1 == dom2:

standardMsg = "%s == %s" % (safe_repr(dom1, True), safe_repr(dom2, True))

self.fail(self._formatMessage(msg, standardMsg))

def assertInHTML(self, needle, haystack, count=None, msg_prefix=""):

parsed_needle = assert_and_parse_html(

self, needle, None, "First argument is not valid HTML:"

)

parsed_haystack = assert_and_parse_html(

self, haystack, None, "Second argument is not valid HTML:"

)

real_count = parsed_haystack.count(parsed_needle)

if (count is None and real_count > 0) or count == real_count:

return