url-normalize 2.2.0__tar.gz → 3.0.0__tar.gz

url_normalize-3.0.0/PKG-INFO

@@ -0,0 +1,211 @@
+Metadata-Version: 2.4
+Name: url-normalize
+Version: 3.0.0
+Summary: URL normalization for Python
+Author-email: Nikolay Panov <github@npanov.com>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/niksite/url-normalize
+Project-URL: Repository, https://github.com/niksite/url-normalize
+Project-URL: Issues, https://github.com/niksite/url-normalize/issues
+Project-URL: Changelog, https://github.com/niksite/url-normalize/blob/master/CHANGELOG.md
+Keywords: url,normalization,normalize,normalizer
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: idna>=3.3
+Provides-Extra: dev
+Requires-Dist: mypy; extra == "dev"
+Requires-Dist: pre-commit; extra == "dev"
+Requires-Dist: pytest-cov; extra == "dev"
+Requires-Dist: pytest-socket; extra == "dev"
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: ruff; extra == "dev"
+Dynamic: license-file
+
+# url-normalize
+
+[![tests](https://github.com/niksite/url-normalize/actions/workflows/ci.yml/badge.svg)](https://github.com/niksite/url-normalize/actions/workflows/ci.yml)
+[![Coveralls](https://img.shields.io/coveralls/github/niksite/url-normalize/master.svg)](https://coveralls.io/r/niksite/url-normalize)
+[![PyPI](https://img.shields.io/pypi/v/url-normalize.svg)](https://pypi.org/project/url-normalize/)
+[![Python Versions](https://img.shields.io/pypi/pyversions/url-normalize.svg)](https://pypi.org/project/url-normalize/)
+[![License](https://img.shields.io/pypi/l/url-normalize.svg)](https://github.com/niksite/url-normalize/blob/master/LICENSE)
+[![Ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json)](https://github.com/astral-sh/ruff)
+
+A Python library for standardizing and normalizing URLs. Ideal for database deduplication, caching, web crawling, and anywhere you need to ensure that equivalent URLs resolve to the exact same string.
+
+```python
+from url_normalize import url_normalize
+
+# Fixes IDN, lowercases host/scheme, removes default ports, resolves path segments
+url_normalize("HTTP://User:Pass@www.FOO.com:80///foo/../bar/./baz?q=1#frag")
+# -> 'http://User:Pass@www.foo.com/bar/baz?q=1#frag'
+```
+
+## Features
+
+url-normalize provides a robust URI normalization function that handles IDN domains, scheme/host lowercasing, and RFC-compliant path normalization.
+
+- **IDN Support**: Full internationalized domain name handling (using IDNA2008 with UTS46).
+- **Humanization**: Convert normalized URLs to a readable display format while preserving round-trip normalization.
+- **RFC Compliance**:
+  - Proper percent-encoding (minimal, uppercase hex).
+  - Dot-segment removal in paths.
+  - Default port and authority handling.
+  - UTF-8 NFC normalization.
+- **Configurable Defaults**:
+  - Customizable default scheme (https by default).
+  - Configurable default domain for absolute paths.
+- **Query Parameter Control**:
+  - Parameter filtering with allowlists.
+  - Support for domain-specific parameter rules.
+- **Versatile URL Handling**: Handles empty strings, double-slash URLs (//domain.tld), and shebang (#!) URLs.
+- **Developer Friendly**:
+  - Python 3.10+ compatibility.
+  - 100% test coverage.
+  - Modern type hints and string handling.
+
+Inspired by Sam Ruby's [urlnorm.py](http://intertwingly.net/blog/2004/08/04/Urlnorm).
+
+## Installation
+
+Install as a library:
+
+```sh
+pip install url-normalize
+```
+
+Or install as a standalone CLI tool using [uv](https://docs.astral.sh/uv/):
+
+```sh
+uv tool install url-normalize
+```
+
+## Usage
+
+### Python API
+
+#### Basic Normalization
+
+```python
+from url_normalize import url_normalize
+
+# Basic normalization (uses https by default)
+print(url_normalize("www.foo.com:80/foo"))
+# Output: https://www.foo.com/foo
+
+# With custom default scheme
+print(url_normalize("www.foo.com/foo", default_scheme="http"))
+# Output: http://www.foo.com/foo
+```
+
+#### Query Parameter Filtering
+
+You can strip out tracking parameters and only keep the ones you care about using allowlists.
+
+```python
+# With query parameter filtering enabled (strips all params by default)
+print(url_normalize("www.google.com/search?q=test&utm_source=test", filter_params=True))
+# Output: https://www.google.com/search?q=test
+
+# With custom parameter allowlist as a list
+print(url_normalize(
+    "example.com?page=1&id=123&ref=test",
+    filter_params=True,
+    param_allowlist=["page", "id"]
+))
+# Output: https://example.com?page=1&id=123
+
+# With domain-specific parameter allowlists
+print(url_normalize(
+    "example.com?page=1&id=123&ref=test",
+    filter_params=True,
+    param_allowlist={"example.com": ["page", "id"]}
+))
+# Output: https://example.com?page=1&id=123
+```
+
+#### Default Domain & Scheme
+
+Useful for resolving relative URLs found on a specific page.
+
+```python
+# With default domain for absolute paths
+print(url_normalize("/images/logo.png", default_domain="example.com"))
+# Output: https://example.com/images/logo.png
+
+# With default domain and custom scheme
+print(url_normalize("/images/logo.png", default_scheme="http", default_domain="example.com"))
+# Output: http://example.com/images/logo.png
+```
+
+#### Humanizing URLs
+
+Convert normalized URLs back into a user-friendly format for display, particularly useful for IDN domains and percent-encoded paths.
+
+```python
+from url_normalize import url_humanize
+
+# Human-readable display form that still normalizes back to the same URL
+print(url_humanize("https://xn--e1afmkfd.xn--80akhbyknj4f/%D0%A1%D0%BB%D1%83%D0%B6%D0%B5%D0%B1%D0%BD%D0%B0%D1%8F"))
+# Output: https://пример.испытание/Служебная
+
+# Humanization accepts the same normalization options
+print(url_humanize("/%D0%A1%D0%BB%D1%83%D0%B6%D0%B5%D0%B1%D0%BD%D0%B0%D1%8F", default_domain="xn--e1afmkfd.xn--80akhbyknj4f"))
+# Output: https://пример.испытание/Служебная
+```
+
+### Command-line Usage
+
+You can also use `url-normalize` directly from the terminal to process URLs.
+
+```bash
+$ url-normalize "www.foo.com:80/foo"
+# Output: https://www.foo.com/foo
+
+# With custom default scheme
+$ url-normalize -s http "www.foo.com/foo"
+# Output: http://www.foo.com/foo
+
+# With query parameter filtering
+$ url-normalize -f "www.google.com/search?q=test&utm_source=test"
+# Output: https://www.google.com/search?q=test
+
+# With custom allowlist
+$ url-normalize -f -p page,id "example.com?page=1&id=123&ref=test"
+# Output: https://example.com/?page=1&id=123
+
+# With default domain for absolute paths
+$ url-normalize -d example.com "/images/logo.png"
+# Output: https://example.com/images/logo.png
+
+# With default domain and custom scheme
+$ url-normalize -d example.com -s http "/images/logo.png"
+# Output: http://example.com/images/logo.png
+
+# Human-readable display form
+$ url-normalize -H "https://xn--e1afmkfd.xn--80akhbyknj4f/%D0%A1%D0%BB%D1%83%D0%B6%D0%B5%D0%B1%D0%BD%D0%B0%D1%8F"
+# Output: https://пример.испытание/Служебная
+
+# Via uv tool/uvx
+$ uvx url-normalize www.foo.com:80/foo
+# Output: https://www.foo.com:80/foo
+```
+
+## Documentation
+
+For a complete history of changes, see [CHANGELOG.md](CHANGELOG.md).
+
+## Contributing
+
+Contributions are welcome! Please feel free to submit a Pull Request.
+
+## License
+
+MIT License

url_normalize-3.0.0/README.md

@@ -0,0 +1,180 @@
+# url-normalize
+
+[![tests](https://github.com/niksite/url-normalize/actions/workflows/ci.yml/badge.svg)](https://github.com/niksite/url-normalize/actions/workflows/ci.yml)
+[![Coveralls](https://img.shields.io/coveralls/github/niksite/url-normalize/master.svg)](https://coveralls.io/r/niksite/url-normalize)
+[![PyPI](https://img.shields.io/pypi/v/url-normalize.svg)](https://pypi.org/project/url-normalize/)
+[![Python Versions](https://img.shields.io/pypi/pyversions/url-normalize.svg)](https://pypi.org/project/url-normalize/)
+[![License](https://img.shields.io/pypi/l/url-normalize.svg)](https://github.com/niksite/url-normalize/blob/master/LICENSE)
+[![Ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json)](https://github.com/astral-sh/ruff)
+
+A Python library for standardizing and normalizing URLs. Ideal for database deduplication, caching, web crawling, and anywhere you need to ensure that equivalent URLs resolve to the exact same string.
+
+```python
+from url_normalize import url_normalize
+
+# Fixes IDN, lowercases host/scheme, removes default ports, resolves path segments
+url_normalize("HTTP://User:Pass@www.FOO.com:80///foo/../bar/./baz?q=1#frag")
+# -> 'http://User:Pass@www.foo.com/bar/baz?q=1#frag'
+```
+
+## Features
+
+url-normalize provides a robust URI normalization function that handles IDN domains, scheme/host lowercasing, and RFC-compliant path normalization.
+
+- **IDN Support**: Full internationalized domain name handling (using IDNA2008 with UTS46).
+- **Humanization**: Convert normalized URLs to a readable display format while preserving round-trip normalization.
+- **RFC Compliance**:
+  - Proper percent-encoding (minimal, uppercase hex).
+  - Dot-segment removal in paths.
+  - Default port and authority handling.
+  - UTF-8 NFC normalization.
+- **Configurable Defaults**:
+  - Customizable default scheme (https by default).
+  - Configurable default domain for absolute paths.
+- **Query Parameter Control**:
+  - Parameter filtering with allowlists.
+  - Support for domain-specific parameter rules.
+- **Versatile URL Handling**: Handles empty strings, double-slash URLs (//domain.tld), and shebang (#!) URLs.
+- **Developer Friendly**:
+  - Python 3.10+ compatibility.
+  - 100% test coverage.
+  - Modern type hints and string handling.
+
+Inspired by Sam Ruby's [urlnorm.py](http://intertwingly.net/blog/2004/08/04/Urlnorm).
+
+## Installation
+
+Install as a library:
+
+```sh
+pip install url-normalize
+```
+
+Or install as a standalone CLI tool using [uv](https://docs.astral.sh/uv/):
+
+```sh
+uv tool install url-normalize
+```
+
+## Usage
+
+### Python API
+
+#### Basic Normalization
+
+```python
+from url_normalize import url_normalize
+
+# Basic normalization (uses https by default)
+print(url_normalize("www.foo.com:80/foo"))
+# Output: https://www.foo.com/foo
+
+# With custom default scheme
+print(url_normalize("www.foo.com/foo", default_scheme="http"))
+# Output: http://www.foo.com/foo
+```
+
+#### Query Parameter Filtering
+
+You can strip out tracking parameters and only keep the ones you care about using allowlists.
+
+```python
+# With query parameter filtering enabled (strips all params by default)
+print(url_normalize("www.google.com/search?q=test&utm_source=test", filter_params=True))
+# Output: https://www.google.com/search?q=test
+
+# With custom parameter allowlist as a list
+print(url_normalize(
+    "example.com?page=1&id=123&ref=test",
+    filter_params=True,
+    param_allowlist=["page", "id"]
+))
+# Output: https://example.com?page=1&id=123
+
+# With domain-specific parameter allowlists
+print(url_normalize(
+    "example.com?page=1&id=123&ref=test",
+    filter_params=True,
+    param_allowlist={"example.com": ["page", "id"]}
+))
+# Output: https://example.com?page=1&id=123
+```
+
+#### Default Domain & Scheme
+
+Useful for resolving relative URLs found on a specific page.
+
+```python
+# With default domain for absolute paths
+print(url_normalize("/images/logo.png", default_domain="example.com"))
+# Output: https://example.com/images/logo.png
+
+# With default domain and custom scheme
+print(url_normalize("/images/logo.png", default_scheme="http", default_domain="example.com"))
+# Output: http://example.com/images/logo.png
+```
+
+#### Humanizing URLs
+
+Convert normalized URLs back into a user-friendly format for display, particularly useful for IDN domains and percent-encoded paths.
+
+```python
+from url_normalize import url_humanize
+
+# Human-readable display form that still normalizes back to the same URL
+print(url_humanize("https://xn--e1afmkfd.xn--80akhbyknj4f/%D0%A1%D0%BB%D1%83%D0%B6%D0%B5%D0%B1%D0%BD%D0%B0%D1%8F"))
+# Output: https://пример.испытание/Служебная
+
+# Humanization accepts the same normalization options
+print(url_humanize("/%D0%A1%D0%BB%D1%83%D0%B6%D0%B5%D0%B1%D0%BD%D0%B0%D1%8F", default_domain="xn--e1afmkfd.xn--80akhbyknj4f"))
+# Output: https://пример.испытание/Служебная
+```
+
+### Command-line Usage
+
+You can also use `url-normalize` directly from the terminal to process URLs.
+
+```bash
+$ url-normalize "www.foo.com:80/foo"
+# Output: https://www.foo.com/foo
+
+# With custom default scheme
+$ url-normalize -s http "www.foo.com/foo"
+# Output: http://www.foo.com/foo
+
+# With query parameter filtering
+$ url-normalize -f "www.google.com/search?q=test&utm_source=test"
+# Output: https://www.google.com/search?q=test
+
+# With custom allowlist
+$ url-normalize -f -p page,id "example.com?page=1&id=123&ref=test"
+# Output: https://example.com/?page=1&id=123
+
+# With default domain for absolute paths
+$ url-normalize -d example.com "/images/logo.png"
+# Output: https://example.com/images/logo.png
+
+# With default domain and custom scheme
+$ url-normalize -d example.com -s http "/images/logo.png"
+# Output: http://example.com/images/logo.png
+
+# Human-readable display form
+$ url-normalize -H "https://xn--e1afmkfd.xn--80akhbyknj4f/%D0%A1%D0%BB%D1%83%D0%B6%D0%B5%D0%B1%D0%BD%D0%B0%D1%8F"
+# Output: https://пример.испытание/Служебная
+
+# Via uv tool/uvx
+$ uvx url-normalize www.foo.com:80/foo
+# Output: https://www.foo.com:80/foo
+```
+
+## Documentation
+
+For a complete history of changes, see [CHANGELOG.md](CHANGELOG.md).
+
+## Contributing
+
+Contributions are welcome! Please feel free to submit a Pull Request.
+
+## License
+
+MIT License

{url_normalize-2.2.0 → url_normalize-3.0.0}/pyproject.toml

@@ -1,12 +1,21 @@
 [project]
 name = "url-normalize"
-version = "2.2.0"
+version = "3.0.0"
 description = "URL normalization for Python"
 authors = [{ name = "Nikolay Panov", email = "github@npanov.com" }]
-license = { text = "MIT" }
+license = "MIT"
 readme = "README.md"
-requires-python = ">=3.8"
-keywords = ["url", "normalization", "normalize"]
+requires-python = ">=3.10"
+keywords = ["url", "normalization", "normalize", "normalizer"]
+classifiers = [
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3 :: Only",
+  "Programming Language :: Python :: 3.10",
+  "Programming Language :: Python :: 3.11",
+  "Programming Language :: Python :: 3.12",
+  "Programming Language :: Python :: 3.13",
+  "Programming Language :: Python :: 3.14",
+]
 dependencies = ["idna>=3.3"]
 
 [project.urls]
@@ -19,19 +28,10 @@ Changelog = "https://github.com/niksite/url-normalize/blob/master/CHANGELOG.md"
 url-normalize = "url_normalize.cli:main"
 
 [project.optional-dependencies]
-dev = [
-  "mypy",
-  "pre-commit",
-  "pytest-cov",
-  "pytest-ruff",
-  "pytest-socket",
-  "pytest",
-  "ruff",
-  "tox",
-]
+dev = ["mypy", "pre-commit", "pytest-cov", "pytest-socket", "pytest", "ruff"]
 
 [tool.ruff]
-target-version = "py38"
+target-version = "py310"
 line-length = 88
 unsafe-fixes = true
 
@@ -62,20 +62,18 @@ indent-style = "space"
 [tool.mypy]
 ignore_missing_imports = true
 exclude = ["tests"]
-python_version = "3.8"
+python_version = "3.10"
 show_error_codes = true
 
 [build-system]
-requires = ["setuptools>=42", "wheel"]
+requires = ["setuptools>=77", "wheel"]
 build-backend = "setuptools.build_meta"
 
 [tool.pytest.ini_options]
 addopts = [
-  "--cov-fail-under=100",
   "--cov-report=term-missing:skip-covered",
   "--cov=url_normalize",
   "--disable-socket",
-  "--ruff",
   "-v",
 ]
 python_files = ["tests.py", "test_*.py", "*_tests.py"]

{url_normalize-2.2.0 → url_normalize-3.0.0}/tests/test_cli.py

@@ -22,7 +22,7 @@ def run_cli(*args: str) -> subprocess.CompletedProcess:
     """
     command = [sys.executable, "-m", "url_normalize.cli", *list(args)]
     return subprocess.run(  # noqa: S603
-        command, capture_output=True, text=True, check=False
+        command, capture_output=True, text=True, encoding="utf-8", check=False
     )
 
 
@@ -66,6 +66,56 @@ def test_cli_basic_normalization_short_args() -> None:
     assert not result.stderr
 
 
+def test_cli_humanize() -> None:
+    """Test human-readable URL output via CLI."""
+    url = (
+        "https://xn--e1afmkfd.xn--80akhbyknj4f/"
+        "%D0%A1%D0%BB%D1%83%D0%B6%D0%B5%D0%B1%D0%BD%D0%B0%D1%8F"
+    )
+    expected = "https://пример.испытание/Служебная"
+
+    result = run_cli("--humanize", url)
+
+    assert result.returncode == 0
+    assert result.stdout.strip() == expected
+    assert not result.stderr
+
+
+def test_cli_humanize_short_arg() -> None:
+    """Test human-readable URL output via CLI using short argument."""
+    url = (
+        "https://xn--e1afmkfd.xn--80akhbyknj4f/"
+        "%D0%A1%D0%BB%D1%83%D0%B6%D0%B5%D0%B1%D0%BD%D0%B0%D1%8F"
+    )
+    expected = "https://пример.испытание/Служебная"
+
+    result = run_cli("-H", url)
+
+    assert result.returncode == 0
+    assert result.stdout.strip() == expected
+    assert not result.stderr
+
+
+def test_cli_humanize_respects_normalization_options() -> None:
+    """Test humanized output keeps the existing CLI normalization options."""
+    url = "/%D0%A1%D0%BB%D1%83%D0%B6%D0%B5%D0%B1%D0%BD%D0%B0%D1%8F"
+    expected = "https://пример.испытание/Служебная?keep=Ç"
+
+    result = run_cli(
+        "--humanize",
+        "--default-domain",
+        "xn--e1afmkfd.xn--80akhbyknj4f",
+        "--filter-params",
+        "--param-allowlist",
+        "keep",
+        f"{url}?utm_source=ignored&keep=%C3%87",
+    )
+
+    assert result.returncode == 0
+    assert result.stdout.strip() == expected
+    assert not result.stderr
+
+
 def test_cli_default_scheme() -> None:
     """Test default scheme addition via CLI."""
     url = "//example.com"

url_normalize-3.0.0/tests/test_deconstruct_url.py

@@ -0,0 +1,40 @@
+"""Deconstruct url tests."""
+
+import pytest
+
+from url_normalize.tools import URL, deconstruct_url
+
+
+@pytest.mark.parametrize(
+    ("url", "expected"),
+    [
+        (
+            "http://site.com",
+            URL(
+                fragment="",
+                host="site.com",
+                path="",
+                port="",
+                query="",
+                scheme="http",
+                userinfo="",
+            ),
+        ),
+        (
+            "http://user@www.example.com:8080/path/index.html?param=val#fragment",
+            URL(
+                fragment="fragment",
+                host="www.example.com",
+                path="/path/index.html",
+                port="8080",
+                query="param=val",
+                scheme="http",
+                userinfo="user@",
+            ),
+        ),
+    ],
+)
+def test_deconstruct_url_result_is_expected(url: str, expected: URL) -> None:
+    """Assert we got expected results from the deconstruct_url function."""
+    result = deconstruct_url(url)
+    assert result == expected, url

url_normalize-3.0.0/tests/test_normalize_fragment.py

@@ -0,0 +1,23 @@
+"""Tests for normalize_fragment function."""
+
+import pytest
+
+from url_normalize.url_normalize import normalize_fragment
+
+
+@pytest.mark.parametrize(
+    ("fragment", "expected"),
+    [
+        ("", ""),
+        ("fragment", "fragment"),
+        ("пример", "%D0%BF%D1%80%D0%B8%D0%BC%D0%B5%D1%80"),
+        ("!fragment", "%21fragment"),
+        ("~fragment", "~fragment"),
+        # Issue #36: Equal sign should not be encoded
+        ("gid=1234", "gid=1234"),
+    ],
+)
+def test_normalize_fragment_result_is_expected(fragment: str, expected: str) -> None:
+    """Assert we got expected results from the normalize_fragment function."""
+    result = normalize_fragment(fragment)
+    assert result == expected, fragment

url_normalize-3.0.0/tests/test_normalize_host.py

@@ -0,0 +1,32 @@
+"""Tests for normalize_host function."""
+
+import pytest
+
+from url_normalize.url_normalize import normalize_host
+
+
+@pytest.mark.parametrize(
+    ("host", "expected"),
+    [
+        # Basic cases
+        ("site.com", "site.com"),
+        ("SITE.COM", "site.com"),
+        ("site.com.", "site.com"),
+        # Cyrillic domains
+        ("пример.испытание", "xn--e1afmkfd.xn--80akhbyknj4f"),
+        # Mixed case with Cyrillic
+        ("ExAmPle.РФ", "example.xn--p1ai"),
+        # IDNA2008 with UTS46
+        ("faß.de", "xn--fa-hia.de"),
+        # Edge cases
+        ("ドメイン.テスト", "xn--eckwd4c7c.xn--zckzah"),  # Japanese
+        ("domain.café", "domain.xn--caf-dma"),  # Latin with diacritic
+        # Normalization tests
+        ("über.example", "xn--ber-goa.example"),  # IDNA 2008 for umlaut
+        ("example。com", "example.com"),  # Normalize full-width punctuation
+    ],
+)
+def test_normalize_host_result_is_expected(host: str, expected: str) -> None:
+    """Assert we got expected results from the normalize_host function."""
+    result = normalize_host(host)
+    assert result == expected, host

url_normalize-3.0.0/tests/test_normalize_path.py

@@ -0,0 +1,44 @@
+"""Tests for normalize_path function."""
+
+import pytest
+
+from url_normalize.url_normalize import normalize_path
+
+
+@pytest.mark.parametrize(
+    ("path", "expected"),
+    [
+        ("..", "/"),
+        ("", "/"),
+        ("/../foo", "/foo"),
+        ("/..foo", "/..foo"),
+        ("/./../foo", "/foo"),
+        ("/./foo", "/foo"),
+        ("/./foo/.", "/foo/"),
+        ("/.foo", "/.foo"),
+        ("/", "/"),
+        ("/foo..", "/foo.."),
+        ("/foo.", "/foo."),
+        ("/FOO", "/FOO"),
+        ("/foo/../bar", "/bar"),
+        ("/foo/./bar", "/foo/bar"),
+        ("/foo//", "/foo/"),
+        ("/foo///bar//", "/foo/bar/"),
+        ("/foo/bar/..", "/foo/"),
+        ("/foo/bar/../..", "/"),
+        ("/foo/bar/../../../../baz", "/baz"),
+        ("/foo/bar/../../../baz", "/baz"),
+        ("/foo/bar/../../", "/"),
+        ("/foo/bar/../../baz", "/baz"),
+        ("/foo/bar/../", "/foo/"),
+        ("/foo/bar/../baz", "/foo/baz"),
+        ("/foo/bar/.", "/foo/bar/"),
+        ("/foo/bar/./", "/foo/bar/"),
+        # Issue #25: we should preserve ? in the path
+        ("/More+Tea+Vicar%3F/discussion", "/More+Tea+Vicar%3F/discussion"),
+    ],
+)
+def test_normalize_path_result_is_expected(path: str, expected: str) -> None:
+    """Assert we got expected results from the normalize_path function."""
+    result = normalize_path(path, "http")
+    assert result == expected, path