Buckets:
AnonymousSpottedToad/candidate_bucket / codebase /python /FastJango_FastJango /tests /test_url_conf.py
| #!/usr/bin/env python | |
| """ | |
| Tests for FastJango URL configuration functionality. | |
| """ | |
| import os | |
| import sys | |
| import unittest | |
| from unittest.mock import MagicMock, patch | |
| # Add project root to path if script is run from tests directory | |
| sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))) | |
| # Import FastJango URL components | |
| from fastjango.urls import ( | |
| path, | |
| include, | |
| Path, | |
| URLResolver, | |
| ) | |
| from fastjango.http import JsonResponse | |
| from fastapi import APIRouter | |
| # Define some test views | |
| def index_view(request): | |
| return JsonResponse({"message": "Index"}) | |
| def detail_view(request, id): | |
| return JsonResponse({"id": id}) | |
| def another_view(request): | |
| return JsonResponse({"message": "Another"}) | |
| class URLPatternTest(unittest.TestCase): | |
| """Test suite for URL pattern creation.""" | |
| def test_path_function(self): | |
| """Test the path function.""" | |
| # Create a path | |
| url_path = path("/test", index_view, name="test") | |
| # Check that the path has the correct attributes | |
| self.assertIsInstance(url_path, Path) | |
| self.assertEqual(url_path.path, "test") # Leading slash should be removed | |
| self.assertEqual(url_path.view, index_view) | |
| self.assertEqual(url_path.name, "test") | |
| def test_path_with_parameters(self): | |
| """Test path with parameters.""" | |
| # Create a path with parameters | |
| url_path = path("/items/<int:id>", detail_view, name="item-detail") | |
| # Check that the path has the correct attributes | |
| self.assertEqual(url_path.path, "items/<int:id>") | |
| self.assertEqual(url_path.view, detail_view) | |
| self.assertEqual(url_path.name, "item-detail") | |
| class IncludeTest(unittest.TestCase): | |
| """Test suite for include function.""" | |
| def setUp(self): | |
| """Set up test environment.""" | |
| # Create a test module with urlpatterns | |
| self.module_name = "test_urls_module" | |
| self.module = type(sys)(self.module_name) | |
| sys.modules[self.module_name] = self.module | |
| # Define urlpatterns in the module | |
| self.module.urlpatterns = [ | |
| path("/", index_view, name="index"), | |
| path("/items/<int:id>", detail_view, name="item-detail"), | |
| ] | |
| # Add app_name to the module | |
| self.module.app_name = "test_app" | |
| def tearDown(self): | |
| """Clean up after tests.""" | |
| # Remove the test module | |
| del sys.modules[self.module_name] | |
| def test_include_function(self): | |
| """Test the include function.""" | |
| # Include the test module | |
| included = include(self.module_name) | |
| # Check that include returns the correct tuple | |
| self.assertIsInstance(included, tuple) | |
| self.assertEqual(len(included), 3) | |
| # Check the components of the tuple | |
| patterns, namespace, prefix = included | |
| # Check patterns | |
| self.assertEqual(len(patterns), 2) | |
| self.assertEqual(patterns[0].name, "index") | |
| self.assertEqual(patterns[1].name, "item-detail") | |
| # Check namespace | |
| self.assertEqual(namespace, "test_app") | |
| # Check prefix | |
| self.assertEqual(prefix, "test_urls_module") | |
| def test_include_with_namespace(self): | |
| """Test include with custom namespace.""" | |
| # Include the test module with a custom namespace | |
| included = include(self.module_name, namespace="custom") | |
| # Check that namespace is overridden | |
| patterns, namespace, prefix = included | |
| self.assertEqual(namespace, "custom") | |
| class URLResolverTest(unittest.TestCase): | |
| """Test suite for URLResolver.""" | |
| def test_register_patterns(self): | |
| """Test registering URL patterns.""" | |
| # Create URL patterns | |
| urlpatterns = [ | |
| path("/", index_view, name="index"), | |
| path("/items/<int:id>", detail_view, name="item-detail"), | |
| path("/another", another_view, name="another"), | |
| ] | |
| # Create a router and resolver | |
| router = APIRouter() | |
| resolver = URLResolver(router) | |
| # Register the patterns | |
| resolver.register(urlpatterns) | |
| # Check that the patterns were registered | |
| self.assertEqual(len(router.routes), 3) | |
| # Check the paths | |
| route_paths = [route.path for route in router.routes] | |
| self.assertIn("/", route_paths) | |
| self.assertIn("/items/{id}", route_paths) # Parameters should be converted | |
| self.assertIn("/another", route_paths) | |
| # Check the names | |
| route_names = [getattr(route, "name", None) for route in router.routes] | |
| self.assertIn("index", route_names) | |
| self.assertIn("item-detail", route_names) | |
| self.assertIn("another", route_names) | |
| def test_register_included_patterns(self): | |
| """Test registering patterns with includes.""" | |
| # Create a test module with urlpatterns | |
| module_name = "test_included_urls" | |
| module = type(sys)(module_name) | |
| sys.modules[module_name] = module | |
| # Define urlpatterns in the module | |
| module.urlpatterns = [ | |
| path("/included", index_view, name="included-index"), | |
| path("/included/<int:id>", detail_view, name="included-detail"), | |
| ] | |
| # Create URL patterns with include | |
| urlpatterns = [ | |
| path("/", index_view, name="index"), | |
| path("/sub", include(module_name)), | |
| ] | |
| # Create a router and resolver | |
| router = APIRouter() | |
| resolver = URLResolver(router) | |
| # Register the patterns | |
| resolver.register(urlpatterns) | |
| # Check that all patterns were registered | |
| self.assertEqual(len(router.routes), 3) | |
| # Check the paths | |
| route_paths = [route.path for route in router.routes] | |
| self.assertIn("/", route_paths) | |
| self.assertIn("/sub/included", route_paths) | |
| self.assertIn("/sub/included/{id}", route_paths) | |
| # Clean up | |
| del sys.modules[module_name] | |
| def test_path_normalization(self): | |
| """Test path normalization.""" | |
| # Create URL patterns with various path formats | |
| urlpatterns = [ | |
| path("no-leading-slash", index_view, name="no-leading"), | |
| path("/with-leading-slash", index_view, name="with-leading"), | |
| path("trailing-slash/", index_view, name="trailing"), | |
| path("//double//slashes//", index_view, name="double"), | |
| ] | |
| # Create a router and resolver | |
| router = APIRouter() | |
| resolver = URLResolver(router) | |
| # Register the patterns | |
| resolver.register(urlpatterns) | |
| # Check that the paths were normalized | |
| route_paths = [route.path for route in router.routes] | |
| self.assertIn("/no-leading-slash", route_paths) | |
| self.assertIn("/with-leading-slash", route_paths) | |
| self.assertIn("/trailing-slash", route_paths) | |
| self.assertIn("/double/slashes", route_paths) | |
| def test_path_parameters(self): | |
| """Test path parameter conversion.""" | |
| # Create URL patterns with various parameter formats | |
| urlpatterns = [ | |
| path("/int/<int:id>", detail_view, name="int-param"), | |
| path("/str/<str:name>", detail_view, name="str-param"), | |
| path("/slug/<slug:slug>", detail_view, name="slug-param"), | |
| path("/uuid/<uuid:uuid>", detail_view, name="uuid-param"), | |
| path("/path/<path:path>", detail_view, name="path-param"), | |
| path("/multi/<int:id>/<str:name>", detail_view, name="multi-param"), | |
| ] | |
| # Create a router and resolver | |
| router = APIRouter() | |
| resolver = URLResolver(router) | |
| # Register the patterns | |
| resolver.register(urlpatterns) | |
| # Check that the parameters were converted | |
| route_paths = [route.path for route in router.routes] | |
| self.assertIn("/int/{id}", route_paths) | |
| self.assertIn("/str/{name}", route_paths) | |
| self.assertIn("/slug/{slug}", route_paths) | |
| self.assertIn("/uuid/{uuid}", route_paths) | |
| self.assertIn("/path/{path}", route_paths) | |
| self.assertIn("/multi/{id}/{name}", route_paths) | |
| def run_tests(): | |
| """Run the URL configuration tests.""" | |
| unittest.main(argv=['first-arg-is-ignored'], exit=False) | |
| if __name__ == "__main__": | |
| run_tests() |
Xet Storage Details
- Size:
- 8.58 kB
- Xet hash:
- dacb0386f4fd16c5780fa1f27bc3818540efaffcc2106fdb27f61894fa41abab
·
Xet efficiently stores files, intelligently splitting them into unique chunks and accelerating uploads and downloads. More info.