assert-element 0.3.0__tar.gz → 0.5.0__tar.gz

assert_element-0.5.0/.github/workflows/main.yml

@@ -0,0 +1,104 @@
+# This is a basic workflow to help you get started with Actions
+
+name: CI
+
+# Controls when the workflow will run
+on:
+  # Triggers the workflow on push or pull request events but only for the master branch
+  push:
+    branches: [ master ]
+  pull_request:
+    branches: [ '**' ]
+
+  # Allows you to run this workflow manually from the Actions tab
+  workflow_dispatch:
+
+# A workflow run is made up of one or more jobs that can run sequentially or in parallel
+jobs:
+  # This workflow contains a single job called "build"
+  tests:
+    # The type of runner that the job will run on
+    runs-on: ubuntu-latest
+
+    strategy:
+      matrix:
+        python-version: ['3.8', '3.9', '3.10', '3.11', '3.12', '3.13']
+        DJANGO_VERSION: ['4.0.*', '4.1.*', '4.2.*', '5.0.*', '5.1.*', '5.2.*']
+        exclude:
+          # Django 4.0 incompatibilities
+          - python-version: '3.11'
+            DJANGO_VERSION: '4.0.*'
+          - python-version: '3.12'
+            DJANGO_VERSION: '4.0.*'
+          - python-version: '3.13'
+            DJANGO_VERSION: '4.0.*'
+
+          # Django 4.1 incompatibilities
+          - python-version: '3.12'
+            DJANGO_VERSION: '4.1.*'
+          - python-version: '3.13'
+            DJANGO_VERSION: '4.1.*'
+
+          # Django 4.2 incompatibilities
+          - python-version: '3.13'
+            DJANGO_VERSION: '4.2.*'
+
+          # Django 5.0 incompatibilities
+          - python-version: '3.8'
+            DJANGO_VERSION: '5.0.*'
+          - python-version: '3.9'
+            DJANGO_VERSION: '5.0.*'
+          - python-version: '3.13'
+            DJANGO_VERSION: '5.0.*'
+
+          # Django 5.1 incompatibilities
+          - python-version: '3.8'
+            DJANGO_VERSION: '5.1.*'
+          - python-version: '3.9'
+            DJANGO_VERSION: '5.1.*'
+          - python-version: '3.13'
+            DJANGO_VERSION: '5.1.*'
+
+          # Django 5.2 incompatibilities
+          - python-version: '3.8'
+            DJANGO_VERSION: '5.2.*'
+          - python-version: '3.9'
+            DJANGO_VERSION: '5.2.*'
+      fail-fast: false
+
+    steps:
+      - uses: actions/checkout@v2
+
+      - name: Set up Python ${{ matrix.python-version }}
+        uses: actions/setup-python@v2
+        with:
+              python-version: ${{ matrix.python-version }}
+      - uses: actions/cache@v4
+        with:
+          path: ~/.cache/pip
+          key: ${{ hashFiles('setup.py') }}-${{ hashFiles('demoproject/requirements.txt') }}-${{ hashFiles('requirements.txt') }}-${{ matrix.DJANGO_VERSION }}
+
+      - name: Install
+        run: |
+           pip install -e .
+           pip install tox codecov
+
+      - name: Testing
+        run: |
+          tox -e py$(echo ${{ matrix.python-version }} | sed 's/\.//g')-django$(echo ${{ matrix.DJANGO_VERSION }} | cut -d'.' -f1-2 | sed 's/\.//g')
+          codecov
+  lint:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+      - name: Install
+        run: |
+          pip install -r requirements_test.txt
+      - name: Running Flake8
+        run: flake8
+      - name: Running isort
+        run: python -m isort . --check-only --diff
+      - name: Running black
+        run: black --check .
+      - name: Running mypy
+        run: mypy .

assert_element-0.5.0/HISTORY.rst

@@ -0,0 +1,31 @@
+.. :changelog:
+
+History
+-------
+
+0.5.0 (2025-08-15)
+++++++++++++++++++
+
+* improved whitespace sanitization with aggressive normalization
+* enhanced test coverage for semantically meaningful whitespace differences
+* updated documentation with detailed whitespace normalization behavior
+
+0.4.0 (2023-07-21)
+++++++++++++++++++
+
+* more readable output when assertion fails
+
+0.3.0 (2022-09-16)
+++++++++++++++++++
+
+* more tolerance in whitespace differences
+
+0.2.0 (2022-09-01)
+++++++++++++++++++
+
+* first attribute can be response or content itself
+
+0.1.0 (2022-08-21)
+++++++++++++++++++
+
+* First release on PyPI.

{assert_element-0.3.0 → assert_element-0.5.0}/MANIFEST.in

@@ -3,4 +3,5 @@ include CONTRIBUTING.rst
 include HISTORY.rst
 include LICENSE
 include README.rst
+include requirements.txt
 recursive-include assert_element *.html *.png *.gif *js *.css *jpg *jpeg *svg *py

assert_element-0.5.0/PKG-INFO

@@ -0,0 +1,207 @@
+Metadata-Version: 2.4
+Name: assert_element
+Version: 0.5.0
+Summary: Simple TestCase assertion that finds element based on it's path and check if it equals with given content.
+Home-page: https://github.com/PetrDlouhy/django-assert-element
+Author: Petr Dlouhý
+Author-email: petr.dlouhy@email.cz
+License: MIT
+Keywords: assert_element
+Classifier: Development Status :: 3 - Alpha
+Classifier: Framework :: Django :: 1.11
+Classifier: Framework :: Django :: 2.1
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: BSD License
+Classifier: Natural Language :: English
+Classifier: Programming Language :: Python :: 2
+Classifier: Programming Language :: Python :: 2.7
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.5
+Classifier: Programming Language :: Python :: 3.6
+License-File: LICENSE
+License-File: AUTHORS.rst
+Requires-Dist: beautifulsoup4
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: home-page
+Dynamic: keywords
+Dynamic: license
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: summary
+
+=============================
+Django assert element
+=============================
+
+.. image:: https://badge.fury.io/py/assert_element.svg
+    :target: https://badge.fury.io/py/assert_element
+
+.. image:: https://codecov.io/gh/PetrDlouhy/assert_element/branch/master/graph/badge.svg
+    :target: https://codecov.io/gh/PetrDlouhy/assert_element
+
+.. image:: https://github.com/PetrDlouhy/django-assert-element/actions/workflows/main.yml/badge.svg?event=registry_package
+    :target: https://github.com/PetrDlouhy/django-assert-element/actions/workflows/main.yml
+
+Simple ``TestCase`` assertion that finds element based on it's xpath and check if it equals with given content.
+In case the content is not matching it outputs nice and clean diff of the two compared HTML pieces.
+
+This is more useful than the default Django ``self.assertContains(response, ..., html=True)``
+because it will find the element and show differences if something changed.
+
+Whitespace Normalization
+~~~~~~~~~~~~~~~~~~~~~~~~~
+
+The library uses aggressive whitespace normalization to focus on HTML semantic meaning
+rather than cosmetic formatting differences:
+
+* **Normalizes cosmetic differences**: Multiple spaces, tabs, newlines, and attribute spacing
+* **Handles structural variations**: Self-closing vs explicit tags (``<br/>`` vs ``<br></br>``)
+* **Preserves semantic meaning**: Only fails when HTML content actually differs in meaning
+* **Browser-consistent**: Mimics how browsers treat whitespace (collapsed to single spaces)
+
+This prevents false positive test failures caused by insignificant whitespace variations
+while still catching genuine HTML content differences.
+
+Other similar projects
+----------------------
+
+I released this package just to realize after few days, that there are some other very similar projects:
+
+* https://pypi.org/project/django_html_assertions/
+* https://django-with-asserts.readthedocs.io/en/latest/
+* https://github.com/robjohncox/python-html-assert
+
+Documentation
+-------------
+
+The full documentation is at https://assert_element.readthedocs.io.
+
+Quickstart
+----------
+
+Install by:
+
+.. code-block:: bash
+    
+    pip install assert-element
+
+Usage in tests:
+
+.. code-block:: python
+
+    from assert_element import AssertElementMixin
+
+    class MyTestCase(AssertElementMixin, TestCase):
+        def test_something(self):
+            response = self.client.get(address)
+            self.assertElementContains(
+                response,
+                'div[id="my-div"]',
+                '<div id="my-div">My div</div>',
+            )
+
+The first attribute can be response or content string.
+Second attribute is the xpath to the element.
+Third attribute is the expected content.
+
+**Error Output Example**: If response = `<html><div id="my-div">Myy div</div></html>` the error output of the `assertElementContains` looks like this:
+
+.. code-block:: console
+
+    ======================================================================
+    FAIL: test_element_differs (tests.test_models.MyTestCase.test_element_differs)
+    Element not found raises Exception
+    ----------------------------------------------------------------------
+    Traceback (most recent call last):
+      File "/home/petr/soubory/programovani/blenderkit/django-assert-element/assert_element/tests/test_models.py", line 53, in test_element_differs
+        self.assertElementContains(
+      File "/home/petr/soubory/programovani/blenderkit/django-assert-element/assert_element/assert_element/assert_element.py", line 58, in assertElementContains
+        self.assertEqual(element_txt, soup_1_txt)
+    AssertionError: '<div\n id="my-div"\n>\n Myy div \n</div>' != '<div\n id="my-div"\n>\n My div \n</div>'
+      <div
+       id="my-div"
+      >
+    -  Myy div 
+    ?    -
+    +  My div 
+      </div>
+
+which is much cleaner than the original django ``assertContains()`` output.
+
+**Whitespace Example**: These assertions would pass because the differences are cosmetic:
+
+.. code-block:: python
+
+    # These are all equivalent due to whitespace normalization:
+    self.assertElementContains(response, 'p', '<p>hello world</p>')
+    self.assertElementContains(response, 'p', '<p>hello   world</p>')  # Multiple spaces
+    self.assertElementContains(response, 'p', '<p>hello\tworld</p>')   # Tab
+    self.assertElementContains(response, 'p', '<p>\n  hello world  \n</p>')  # Newlines
+
+Running Tests
+-------------
+
+Does the code actually work?
+
+::
+
+    source <YOURVIRTUALENV>/bin/activate
+    (myenv) $ pip install tox
+    (myenv) $ tox
+
+
+Development commands
+---------------------
+
+::
+
+    pip install -r requirements_dev.txt
+    invoke -l
+
+
+Credits
+-------
+
+Tools used in rendering this package:
+
+*  Cookiecutter_
+*  `cookiecutter-djangopackage`_
+
+.. _Cookiecutter: https://github.com/audreyr/cookiecutter
+.. _`cookiecutter-djangopackage`: https://github.com/pydanny/cookiecutter-djangopackage
+
+
+
+
+History
+-------
+
+0.5.0 (2025-08-15)
+++++++++++++++++++
+
+* improved whitespace sanitization with aggressive normalization
+* enhanced test coverage for semantically meaningful whitespace differences
+* updated documentation with detailed whitespace normalization behavior
+
+0.4.0 (2023-07-21)
+++++++++++++++++++
+
+* more readable output when assertion fails
+
+0.3.0 (2022-09-16)
+++++++++++++++++++
+
+* more tolerance in whitespace differences
+
+0.2.0 (2022-09-01)
+++++++++++++++++++
+
+* first attribute can be response or content itself
+
+0.1.0 (2022-08-21)
+++++++++++++++++++
+
+* First release on PyPI.

assert_element-0.5.0/README.rst

@@ -0,0 +1,140 @@
+=============================
+Django assert element
+=============================
+
+.. image:: https://badge.fury.io/py/assert_element.svg
+    :target: https://badge.fury.io/py/assert_element
+
+.. image:: https://codecov.io/gh/PetrDlouhy/assert_element/branch/master/graph/badge.svg
+    :target: https://codecov.io/gh/PetrDlouhy/assert_element
+
+.. image:: https://github.com/PetrDlouhy/django-assert-element/actions/workflows/main.yml/badge.svg?event=registry_package
+    :target: https://github.com/PetrDlouhy/django-assert-element/actions/workflows/main.yml
+
+Simple ``TestCase`` assertion that finds element based on it's xpath and check if it equals with given content.
+In case the content is not matching it outputs nice and clean diff of the two compared HTML pieces.
+
+This is more useful than the default Django ``self.assertContains(response, ..., html=True)``
+because it will find the element and show differences if something changed.
+
+Whitespace Normalization
+~~~~~~~~~~~~~~~~~~~~~~~~~
+
+The library uses aggressive whitespace normalization to focus on HTML semantic meaning
+rather than cosmetic formatting differences:
+
+* **Normalizes cosmetic differences**: Multiple spaces, tabs, newlines, and attribute spacing
+* **Handles structural variations**: Self-closing vs explicit tags (``<br/>`` vs ``<br></br>``)
+* **Preserves semantic meaning**: Only fails when HTML content actually differs in meaning
+* **Browser-consistent**: Mimics how browsers treat whitespace (collapsed to single spaces)
+
+This prevents false positive test failures caused by insignificant whitespace variations
+while still catching genuine HTML content differences.
+
+Other similar projects
+----------------------
+
+I released this package just to realize after few days, that there are some other very similar projects:
+
+* https://pypi.org/project/django_html_assertions/
+* https://django-with-asserts.readthedocs.io/en/latest/
+* https://github.com/robjohncox/python-html-assert
+
+Documentation
+-------------
+
+The full documentation is at https://assert_element.readthedocs.io.
+
+Quickstart
+----------
+
+Install by:
+
+.. code-block:: bash
+    
+    pip install assert-element
+
+Usage in tests:
+
+.. code-block:: python
+
+    from assert_element import AssertElementMixin
+
+    class MyTestCase(AssertElementMixin, TestCase):
+        def test_something(self):
+            response = self.client.get(address)
+            self.assertElementContains(
+                response,
+                'div[id="my-div"]',
+                '<div id="my-div">My div</div>',
+            )
+
+The first attribute can be response or content string.
+Second attribute is the xpath to the element.
+Third attribute is the expected content.
+
+**Error Output Example**: If response = `<html><div id="my-div">Myy div</div></html>` the error output of the `assertElementContains` looks like this:
+
+.. code-block:: console
+
+    ======================================================================
+    FAIL: test_element_differs (tests.test_models.MyTestCase.test_element_differs)
+    Element not found raises Exception
+    ----------------------------------------------------------------------
+    Traceback (most recent call last):
+      File "/home/petr/soubory/programovani/blenderkit/django-assert-element/assert_element/tests/test_models.py", line 53, in test_element_differs
+        self.assertElementContains(
+      File "/home/petr/soubory/programovani/blenderkit/django-assert-element/assert_element/assert_element/assert_element.py", line 58, in assertElementContains
+        self.assertEqual(element_txt, soup_1_txt)
+    AssertionError: '<div\n id="my-div"\n>\n Myy div \n</div>' != '<div\n id="my-div"\n>\n My div \n</div>'
+      <div
+       id="my-div"
+      >
+    -  Myy div 
+    ?    -
+    +  My div 
+      </div>
+
+which is much cleaner than the original django ``assertContains()`` output.
+
+**Whitespace Example**: These assertions would pass because the differences are cosmetic:
+
+.. code-block:: python
+
+    # These are all equivalent due to whitespace normalization:
+    self.assertElementContains(response, 'p', '<p>hello world</p>')
+    self.assertElementContains(response, 'p', '<p>hello   world</p>')  # Multiple spaces
+    self.assertElementContains(response, 'p', '<p>hello\tworld</p>')   # Tab
+    self.assertElementContains(response, 'p', '<p>\n  hello world  \n</p>')  # Newlines
+
+Running Tests
+-------------
+
+Does the code actually work?
+
+::
+
+    source <YOURVIRTUALENV>/bin/activate
+    (myenv) $ pip install tox
+    (myenv) $ tox
+
+
+Development commands
+---------------------
+
+::
+
+    pip install -r requirements_dev.txt
+    invoke -l
+
+
+Credits
+-------
+
+Tools used in rendering this package:
+
+*  Cookiecutter_
+*  `cookiecutter-djangopackage`_
+
+.. _Cookiecutter: https://github.com/audreyr/cookiecutter
+.. _`cookiecutter-djangopackage`: https://github.com/pydanny/cookiecutter-djangopackage

{assert_element-0.3.0 → assert_element-0.5.0}/assert_element/__init__.py

@@ -1,2 +1,2 @@
-__version__ = "0.3.0"
+__version__ = "0.5.0"
 from .assert_element import AssertElementMixin  # noqa

assert_element-0.5.0/assert_element/assert_element.py

@@ -0,0 +1,78 @@
+import html.parser
+import re
+
+import bs4 as bs
+
+
+class MyHTMLFormatter(html.parser.HTMLParser):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.result = []
+
+    def handle_starttag(self, tag, attrs):
+        self.result.append(f"<{tag}")
+        for attr in attrs:
+            self.result.append(f' {attr[0]}="{attr[1]}"')
+        self.result.append(">")
+
+    def handle_endtag(self, tag):
+        self.result.append(f"</{tag}>")
+
+    def handle_data(self, data):
+        self.result.append(data)
+
+    def prettify(self):
+        return "\n".join(self.result)
+
+
+def pretty_print_html(html_str):
+    """Pretty print HTML string"""
+    formatter = MyHTMLFormatter()
+    formatter.feed(html_str)
+    return formatter.prettify()
+
+
+def sanitize_html(html_str):
+    """
+    Sanitize HTML string for reliable comparison.
+
+    Aggressively normalizes cosmetic whitespace differences (multiple spaces,
+    tabs, newlines, attribute spacing) while preserving semantically meaningful
+    structural differences. Focuses on HTML meaning rather than formatting.
+    """
+    # First, handle self-closing vs explicit closing tag normalization
+    # Use BeautifulSoup for structural normalization
+    soup = bs.BeautifulSoup(html_str, "html.parser")
+    structure_normalized = str(soup)
+
+    # Apply aggressive whitespace normalization for cosmetic differences
+    # Most whitespace variations are cosmetic and should be normalized
+
+    # Normalize line endings
+    normalized = structure_normalized.replace("\r\n", "\n").replace("\r", "\n")
+
+    # Use the original aggressive approach but be smarter about it
+    # Collapse all consecutive whitespace to single spaces, as browsers do
+    collapsed = re.sub(r"[\n\r \t]+", " ", normalized)
+
+    return pretty_print_html(collapsed.strip())
+
+
+class AssertElementMixin:
+    def assertElementContains(  # noqa
+        self,
+        request,
+        html_element="",
+        element_text="",
+    ):
+        content = request.content if hasattr(request, "content") else request
+        soup = bs.BeautifulSoup(content, "html.parser")
+        element = soup.select(html_element)
+        if len(element) == 0:
+            raise Exception(f"No element found: {html_element}")
+        if len(element) > 1:
+            raise Exception(f"More than one element found: {html_element}")
+        soup_1 = bs.BeautifulSoup(element_text, "html.parser")
+        element_txt = sanitize_html(element[0].prettify())
+        soup_1_txt = sanitize_html(soup_1.prettify())
+        self.assertEqual(element_txt, soup_1_txt)