django-nplus1-hunter 0.1.0__tar.gz

django_nplus1_hunter-0.1.0/.github/workflows/publish.yml

@@ -0,0 +1,29 @@
+name: Publish to PyPI
+
+on:
+  push:
+    tags:
+      - 'v*'
+
+jobs:
+  build-and-publish:
+    runs-on: ubuntu-latest
+    permissions:
+      id-token: write
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+
+      - name: Install hatch
+        run: pip install hatch
+
+      - name: Build package
+        run: hatch build
+
+      - name: Publish to PyPI
+        uses: pypa/gh-action-pypi-publish@release/v1

django_nplus1_hunter-0.1.0/.github/workflows/test.yml

@@ -0,0 +1,32 @@
+name: Test
+
+on:
+  push:
+    branches:
+      - main
+  pull_request:
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        python-version: ["3.10", "3.11", "3.12"]
+        django-version: ["5.2"]
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Set up Python ${{ matrix.python-version }}
+        uses: actions/setup-python@v5
+        with:
+          python-version: ${{ matrix.python-version }}
+          cache: "pip"
+
+      - name: Install dependencies
+        run: |
+          python -m pip install --upgrade pip
+          pip install hatch tox tox-gh-actions
+
+      - name: Test with tox
+        run: tox

django_nplus1_hunter-0.1.0/.gitignore

@@ -0,0 +1,78 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Editors
+.idea/
+.vscode/
+*.swp
+
+guide.md

django_nplus1_hunter-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 mohammadjalal pouromid
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

django_nplus1_hunter-0.1.0/PKG-INFO

@@ -0,0 +1,93 @@
+Metadata-Version: 2.4
+Name: django-nplus1-hunter
+Version: 0.1.0
+Summary: A development tool to detect N+1 queries in Django.
+Project-URL: Documentation, https://github.com/iamjalipo/django-nplus1-hunter#readme
+Project-URL: Issues, https://github.com/iamjalipo/django-nplus1-hunter/issues
+Project-URL: Source, https://github.com/iamjalipo/django-nplus1-hunter
+Author-email: Developer <developer@example.com>
+License-Expression: MIT
+License-File: LICENSE
+Classifier: Development Status :: 4 - Beta
+Classifier: Framework :: Django
+Classifier: Framework :: Django :: 5.2
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.10
+Requires-Dist: django>=5.2
+Description-Content-Type: text/markdown
+
+# Django N+1 Hunter
+
+A powerful, zero-configuration middleware for detecting N+1 queries in your Django applications during development.
+
+N+1 queries are the silent performance killers of Django apps. This tool automatically monitors your SQL executions and points you exactly to the line of code in your view or model that caused the problem. 
+
+**Supports:** Django 5.2+ and Python 3.10+
+**Databases:** Works with PostgreSQL, MySQL, SQLite, and any other Django-supported backend.
+
+---
+
+## Features
+
+- **Automatic Interception:** Hooks into Django's query execution to monitor SQL statements seamlessly across all configured databases.
+- **Traceback Filtering:** Analyzes the call stack to point you exactly to the line of user code that triggered the loop.
+- **Production Safe:** Automatically disables itself if `DEBUG = False`. It also raises a startup warning if accidentally deployed to production.
+- **Zero Dependencies:** Relies entirely on built-in Python and Django features.
+
+---
+
+## Installation & Setup
+
+1. Install the package via pip:
+   ```bash
+   pip install django-nplus1-hunter
+   ```
+
+2. Add it to your `INSTALLED_APPS`. For safety, it is highly recommended to only add it in your local/development settings:
+   ```python
+   # settings.py
+   if DEBUG:
+       INSTALLED_APPS += [
+           'django_nplus1_hunter',
+       ]
+   ```
+
+3. Add the middleware to `MIDDLEWARE`. Place it near the top of the list so it can track queries generated by other middlewares (like SessionMiddleware or AuthenticationMiddleware):
+   ```python
+   # settings.py
+   if DEBUG:
+       MIDDLEWARE.insert(0, 'django_nplus1_hunter.middleware.NPlus1HunterMiddleware')
+   ```
+
+That's it! Just browse your app locally. If a view triggers an N+1 query, your runserver console will light up with a warning showing the exact file and line number.
+
+---
+
+## Configuration Options
+
+You can customize the detection sensitivity by adding these variables to your `settings.py`:
+
+```python
+# Number of queries generated from the exact same line of code before it is flagged as an N+1.
+# Default: 3
+NPLUS1_HUNTER_THRESHOLD = 3
+
+# The maximum number of total queries allowed in a single request before a warning is thrown.
+# Default: 50
+NPLUS1_HUNTER_TOTAL_THRESHOLD = 50
+
+# A list of URL path prefixes to completely ignore. Useful for admin panels or debug toolbars.
+# Default: []
+NPLUS1_HUNTER_IGNORE_PATHS = [
+    '/admin/',
+    '/__debug__/',
+]
+```
+
+## How it works under the hood
+
+The middleware utilizes `contextlib.ExitStack` and Django's built-in `connections.all()[...].execute_wrapper` to wrap every database connection during the request/response lifecycle. When a query executes, the wrapper captures the raw SQL, execution time, and a full Python stack trace.
+
+It filters out internal Django frames (`django/db/models/*`) to find the first frame belonging to your codebase. If that specific line of code executes more times than `NPLUS1_HUNTER_THRESHOLD`, a warning is logged.

django_nplus1_hunter-0.1.0/README.md

@@ -0,0 +1,73 @@
+# Django N+1 Hunter
+
+A powerful, zero-configuration middleware for detecting N+1 queries in your Django applications during development.
+
+N+1 queries are the silent performance killers of Django apps. This tool automatically monitors your SQL executions and points you exactly to the line of code in your view or model that caused the problem. 
+
+**Supports:** Django 5.2+ and Python 3.10+
+**Databases:** Works with PostgreSQL, MySQL, SQLite, and any other Django-supported backend.
+
+---
+
+## Features
+
+- **Automatic Interception:** Hooks into Django's query execution to monitor SQL statements seamlessly across all configured databases.
+- **Traceback Filtering:** Analyzes the call stack to point you exactly to the line of user code that triggered the loop.
+- **Production Safe:** Automatically disables itself if `DEBUG = False`. It also raises a startup warning if accidentally deployed to production.
+- **Zero Dependencies:** Relies entirely on built-in Python and Django features.
+
+---
+
+## Installation & Setup
+
+1. Install the package via pip:
+   ```bash
+   pip install django-nplus1-hunter
+   ```
+
+2. Add it to your `INSTALLED_APPS`. For safety, it is highly recommended to only add it in your local/development settings:
+   ```python
+   # settings.py
+   if DEBUG:
+       INSTALLED_APPS += [
+           'django_nplus1_hunter',
+       ]
+   ```
+
+3. Add the middleware to `MIDDLEWARE`. Place it near the top of the list so it can track queries generated by other middlewares (like SessionMiddleware or AuthenticationMiddleware):
+   ```python
+   # settings.py
+   if DEBUG:
+       MIDDLEWARE.insert(0, 'django_nplus1_hunter.middleware.NPlus1HunterMiddleware')
+   ```
+
+That's it! Just browse your app locally. If a view triggers an N+1 query, your runserver console will light up with a warning showing the exact file and line number.
+
+---
+
+## Configuration Options
+
+You can customize the detection sensitivity by adding these variables to your `settings.py`:
+
+```python
+# Number of queries generated from the exact same line of code before it is flagged as an N+1.
+# Default: 3
+NPLUS1_HUNTER_THRESHOLD = 3
+
+# The maximum number of total queries allowed in a single request before a warning is thrown.
+# Default: 50
+NPLUS1_HUNTER_TOTAL_THRESHOLD = 50
+
+# A list of URL path prefixes to completely ignore. Useful for admin panels or debug toolbars.
+# Default: []
+NPLUS1_HUNTER_IGNORE_PATHS = [
+    '/admin/',
+    '/__debug__/',
+]
+```
+
+## How it works under the hood
+
+The middleware utilizes `contextlib.ExitStack` and Django's built-in `connections.all()[...].execute_wrapper` to wrap every database connection during the request/response lifecycle. When a query executes, the wrapper captures the raw SQL, execution time, and a full Python stack trace.
+
+It filters out internal Django frames (`django/db/models/*`) to find the first frame belonging to your codebase. If that specific line of code executes more times than `NPLUS1_HUNTER_THRESHOLD`, a warning is logged.

django_nplus1_hunter-0.1.0/pyproject.toml

@@ -0,0 +1,65 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "django-nplus1-hunter"
+dynamic = ["version"]
+description = "A development tool to detect N+1 queries in Django."
+readme = "README.md"
+license = "MIT"
+requires-python = ">=3.10"
+authors = [
+    { name = "Developer", email = "developer@example.com" },
+]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Framework :: Django",
+    "Framework :: Django :: 5.2",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+]
+dependencies = [
+    "Django>=5.2",
+]
+
+[project.urls]
+Documentation = "https://github.com/iamjalipo/django-nplus1-hunter#readme"
+Issues = "https://github.com/iamjalipo/django-nplus1-hunter/issues"
+Source = "https://github.com/iamjalipo/django-nplus1-hunter"
+
+[tool.hatch.version]
+path = "src/django_nplus1_hunter/__init__.py"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/django_nplus1_hunter"]
+
+[tool.ruff]
+line-length = 88
+target-version = "py310"
+
+[tool.ruff.lint]
+select = ["E", "F", "W", "I", "UP"]
+ignore = []
+
+[tool.pytest.ini_options]
+minversion = "7.0"
+addopts = "-ra -q --ds=tests.test_project.settings"
+testpaths = ["tests"]
+python_files = "test_*.py"
+
+[tool.tox]
+legacy_tox_ini = """
+[tox]
+envlist = py310-django52, py311-django52, py312-django52
+isolated_build = True
+
+[testenv]
+deps =
+    django52: Django>=5.2,<6.0
+    pytest
+    pytest-django
+commands =
+    pytest {posargs}
+"""

django_nplus1_hunter-0.1.0/src/django_nplus1_hunter/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.1.0"

django_nplus1_hunter-0.1.0/src/django_nplus1_hunter/apps.py

@@ -0,0 +1,29 @@
+import sys
+import warnings
+from django.apps import AppConfig
+from django.conf import settings
+
+class NPlus1HunterConfig(AppConfig):
+    name = "django_nplus1_hunter"
+    verbose_name = "N+1 Hunter"
+
+    def ready(self):
+        """
+        Safety check: Ensure the app is not accidentally deployed to production.
+        """
+        if not getattr(settings, "DEBUG", False):
+            # Try to determine if we are running in a test suite.
+            # If so, we might not want to scream, but in real production we do.
+            is_testing = "test" in sys.argv or "pytest" in sys.modules
+            
+            if not is_testing:
+                warnings.warn(
+                    "\n\n"
+                    "========================================================================\n"
+                    "WARNING: django-nplus1-hunter is installed but settings.DEBUG is False.\n"
+                    "This tool incurs significant performance overhead by capturing stack\n"
+                    "traces for every database query. It MUST NOT be used in production.\n"
+                    "Please remove 'django_nplus1_hunter' from INSTALLED_APPS.\n"
+                    "========================================================================\n",
+                    RuntimeWarning,
+                )

django_nplus1_hunter-0.1.0/src/django_nplus1_hunter/middleware.py

@@ -0,0 +1,74 @@
+import logging
+from collections import defaultdict
+from django.conf import settings
+from contextlib import ExitStack
+from django.db import connections
+from .trackers import NPlus1QueryWrapper, get_query_data, clear_query_data
+
+logger = logging.getLogger("django_nplus1_hunter")
+
+class NPlus1HunterMiddleware:
+    def __init__(self, get_response):
+        self.get_response = get_response
+        
+        # Configuration defaults
+        # We only enable it if DEBUG is True to prevent production catastrophes.
+        self.enabled = getattr(settings, "DEBUG", False)
+        # How many times the same line of code must generate a query to be considered N+1
+        self.nplus1_threshold = getattr(settings, "NPLUS1_HUNTER_THRESHOLD", 3)
+        # Warn if the total query count per request exceeds this
+        self.total_query_threshold = getattr(settings, "NPLUS1_HUNTER_TOTAL_THRESHOLD", 50)
+        # Paths to completely ignore
+        self.ignore_paths = getattr(settings, "NPLUS1_HUNTER_IGNORE_PATHS", [])
+
+    def __call__(self, request):
+        if not self.enabled or any(request.path.startswith(p) for p in self.ignore_paths):
+            return self.get_response(request)
+
+        # Clear any stale data from previous requests on this thread
+        clear_query_data()
+        
+        # Wrap all database executions for the duration of the request
+        with ExitStack() as stack:
+            for conn in connections.all():
+                stack.enter_context(conn.execute_wrapper(NPlus1QueryWrapper()))
+            response = self.get_response(request)
+            
+        # Analysis Engine
+        self.analyze_queries(request)
+        
+        # Cleanup memory
+        clear_query_data()
+        
+        return response
+
+    def analyze_queries(self, request):
+        queries = get_query_data()
+        total_queries = len(queries)
+        
+        if total_queries >= self.total_query_threshold:
+            logger.warning(
+                f"\n[N+1 Hunter] HIGH QUERY COUNT DETECTED: {total_queries} queries "
+                f"executed on {request.path}"
+            )
+            
+        # Detect N+1 patterns by grouping queries by the exact line of user code
+        # that generated them. If a loop is executing queries, the same line will
+        # trigger multiple queries.
+        frame_counts = defaultdict(list)
+        for q in queries:
+            if q["frame"]:
+                key = f"{q['frame'].filename}:{q['frame'].lineno}"
+                frame_counts[key].append(q)
+                
+        for frame_key, q_list in frame_counts.items():
+            if len(q_list) >= self.nplus1_threshold:
+                sample_sql = q_list[0]["sql"]
+                if len(sample_sql) > 100:
+                    sample_sql = sample_sql[:100] + "..."
+                    
+                logger.warning(
+                    f"\n[N+1 Hunter] N+1 QUERY DETECTED: {len(q_list)} queries originated from "
+                    f"{frame_key}.\n"
+                    f"Sample SQL: {sample_sql}\n"
+                )

django_nplus1_hunter-0.1.0/src/django_nplus1_hunter/trackers.py

@@ -0,0 +1,67 @@
+import time
+import traceback
+from threading import local
+
+# Thread-local storage for queries during a request
+_thread_locals = local()
+
+def get_query_data():
+    """Retrieve the query data for the current thread."""
+    if not hasattr(_thread_locals, 'query_data'):
+        _thread_locals.query_data = []
+    return _thread_locals.query_data
+
+def clear_query_data():
+    """Clear the query data for the current thread."""
+    if hasattr(_thread_locals, 'query_data'):
+        del _thread_locals.query_data
+
+def filter_traceback(tb_list):
+    """
+    Filter the traceback to find the first frame that is NOT from django internals.
+    This helps pinpoint the exact line of user code that triggered the query.
+    """
+    # Start from the bottom of the stack (most recent call) and work backwards
+    for tb in reversed(tb_list):
+        filename = tb.filename
+        
+        # Ignore Django internal database frames
+        if 'django/db/' in filename.replace('\\', '/'):
+            continue
+            
+        # Ignore Python standard library or test runner internals if needed here
+        
+        return tb
+        
+    return tb_list[-1] if tb_list else None
+
+class NPlus1QueryWrapper:
+    """
+    A callable that wraps database executions to capture query data and tracebacks.
+    Designed to be used with Django's connection.execute_wrapper().
+    """
+    def __call__(self, execute, sql, params, many, context):
+        start_time = time.time()
+        try:
+            return execute(sql, params, many, context)
+        finally:
+            duration = time.time() - start_time
+            
+            # Capture the current call stack
+            # extract_stack() returns a list of FrameSummary objects
+            tb = traceback.extract_stack()
+            
+            # Remove the last few frames which belong to this wrapper and traceback module itself
+            # Typically: traceback.extract_stack(), __call__(), etc.
+            tb = tb[:-2]
+            
+            user_frame = filter_traceback(tb)
+            
+            query_info = {
+                'sql': sql,
+                'params': params,
+                'duration': duration,
+                'frame': user_frame,
+            }
+            
+            get_query_data().append(query_info)

django_nplus1_hunter-0.1.0/tasks.md

@@ -0,0 +1,45 @@
+Task Tracker: Django N+1 Hunter
+Phase 1: Setup & Foundation
+[x] 1.1 Project Initialization
+[x] Initialize project with hatch (or manually create pyproject.toml and src/ layout).
+[x] Set up .gitignore.
+[x] 1.2 Tooling Configuration
+[x] Configure Ruff in pyproject.toml.
+[x] Configure pytest and pytest-django.
+[x] Set up tox for multi-environment testing.
+[x] 1.3 CI/CD Pipeline
+[x] Create GitHub Actions workflow (.github/workflows/test.yml).
+[x] 1.4 Test Project Setup
+[x] Create tests/test_project/.
+[x] Configure minimal manage.py, settings.py, and urls.py.
+[x] Create dummy models/views for testing.
+Phase 2: Core Logic & Tracking
+[x] 2.1 Query Tracker
+[x] Implement ExecuteWrapper to capture SQL, time, and raw traceback.
+[x] Write tests to confirm interception.
+[x] 2.2 Traceback Filtering
+[x] Implement logic to filter Django/Python internal frames.
+[x] Isolate user code lines originating the query.
+[x] 2.3 Thread-Local Storage
+[x] Implement threading.local() or contextvars to store per-request queries.
+Phase 3: Middleware & Developer Experience
+[x] 3.1 Django Middleware
+[x] Create middleware class.
+[x] Enable tracking on process_request.
+[x] Process data on process_response.
+[x] 3.2 Analysis Engine
+[x] Detect N+1 patterns (consecutive similar queries).
+[x] Detect total query threshold violations.
+[x] 3.3 Reporting Interface
+[x] Output structured warnings showing the offending file and line.
+[x] 3.4 AppConfig Safety
+[x] Create apps.py with checks for settings.DEBUG to prevent production execution.
+Phase 4: Polish & Documentation
+[x] 4.1 Configuration Options
+[x] Define customizable thresholds and ignored URLs in settings.py.
+[x] 4.2 README & Docs
+[x] Write comprehensive documentation.
+[x] 4.3 Test Coverage
+[x] Ensure high test coverage for all modules.
+[x] 4.4 PyPI Publish Setup
+[x] Configure GitHub Actions for PyPI deployment (publish.yml).

django_nplus1_hunter-0.1.0/tests/__init__.py

@@ -0,0 +1 @@
+# Empty init

django_nplus1_hunter-0.1.0/tests/test_middleware.py

@@ -0,0 +1,35 @@
+import pytest
+from django.test import Client
+from tests.test_project.models import Author, Book
+
+@pytest.fixture
+def client():
+    return Client()
+
+@pytest.fixture
+def setup_data():
+    author1 = Author.objects.create(name="Author 1")
+    author2 = Author.objects.create(name="Author 2")
+    Book.objects.create(title="Book 1", author=author1)
+    Book.objects.create(title="Book 2", author=author2)
+    Book.objects.create(title="Book 3", author=author1)
+    Book.objects.create(title="Book 4", author=author2)
+
+@pytest.mark.django_db
+def test_n_plus_one_view(client, setup_data, caplog):
+    # Call the view that triggers N+1
+    response = client.get('/test-n-plus-one/')
+    assert response.status_code == 200
+    
+    # Check that our middleware logged an N+1 warning
+    assert "N+1 QUERY DETECTED" in caplog.text
+    assert "queries originated from" in caplog.text
+
+@pytest.mark.django_db
+def test_ok_view(client, setup_data, caplog):
+    # Call the view that does NOT trigger N+1
+    response = client.get('/test-ok/')
+    assert response.status_code == 200
+    
+    # Check that our middleware did NOT log an N+1 warning
+    assert "N+1 QUERY DETECTED" not in caplog.text

django_nplus1_hunter-0.1.0/tests/test_project/__init__.py

@@ -0,0 +1 @@
+# Empty init

django_nplus1_hunter-0.1.0/tests/test_project/apps.py

@@ -0,0 +1,5 @@
+from django.apps import AppConfig
+
+class TestProjectConfig(AppConfig):
+    default_auto_field = 'django.db.models.BigAutoField'
+    name = 'tests.test_project'

django_nplus1_hunter-0.1.0/tests/test_project/models.py

@@ -0,0 +1,8 @@
+from django.db import models
+
+class Author(models.Model):
+    name = models.CharField(max_length=100)
+
+class Book(models.Model):
+    title = models.CharField(max_length=100)
+    author = models.ForeignKey(Author, on_delete=models.CASCADE, related_name='books')

django_nplus1_hunter-0.1.0/tests/test_project/settings.py

@@ -0,0 +1,42 @@
+import os
+from pathlib import Path
+
+BASE_DIR = Path(__file__).resolve().parent
+
+SECRET_KEY = "dummy-secret-key-for-testing"
+DEBUG = True
+ALLOWED_HOSTS = []
+
+INSTALLED_APPS = [
+    "django.contrib.admin",
+    "django.contrib.auth",
+    "django.contrib.contenttypes",
+    "django.contrib.sessions",
+    "django.contrib.messages",
+    "django.contrib.staticfiles",
+    "django_nplus1_hunter",
+    "tests.test_project",
+]
+
+MIDDLEWARE = [
+    "django.middleware.security.SecurityMiddleware",
+    "django.contrib.sessions.middleware.SessionMiddleware",
+    "django.middleware.common.CommonMiddleware",
+    "django.middleware.csrf.CsrfViewMiddleware",
+    "django.contrib.auth.middleware.AuthenticationMiddleware",
+    "django.contrib.messages.middleware.MessageMiddleware",
+    "django.middleware.clickjacking.XFrameOptionsMiddleware",
+    "django_nplus1_hunter.middleware.NPlus1HunterMiddleware",
+]
+
+ROOT_URLCONF = "tests.test_project.urls"
+
+DATABASES = {
+    "default": {
+        "ENGINE": "django.db.backends.sqlite3",
+        "NAME": BASE_DIR / "db.sqlite3",
+    }
+}
+
+USE_TZ = True
+DEFAULT_AUTO_FIELD = "django.db.models.BigAutoField"

django_nplus1_hunter-0.1.0/tests/test_project/urls.py

@@ -0,0 +1,7 @@
+from django.urls import path
+from . import views
+
+urlpatterns = [
+    path('test-n-plus-one/', views.test_n_plus_one_view, name='test_n_plus_one'),
+    path('test-ok/', views.test_ok_view, name='test_ok'),
+]

django_nplus1_hunter-0.1.0/tests/test_project/views.py

@@ -0,0 +1,14 @@
+from django.http import HttpResponse
+from .models import Book
+
+def test_n_plus_one_view(request):
+    books = Book.objects.all()
+    # Trigger N+1
+    titles_with_authors = [f"{book.title} by {book.author.name}" for book in books]
+    return HttpResponse("\n".join(titles_with_authors))
+
+def test_ok_view(request):
+    books = Book.objects.select_related('author').all()
+    # No N+1
+    titles_with_authors = [f"{book.title} by {book.author.name}" for book in books]
+    return HttpResponse("\n".join(titles_with_authors))

django_nplus1_hunter-0.1.0/tests/test_trackers.py

@@ -0,0 +1,28 @@
+import pytest
+from django.db import connection
+from django_nplus1_hunter.trackers import (
+    NPlus1QueryWrapper,
+    get_query_data,
+    clear_query_data,
+)
+from tests.test_project.models import Author
+
+@pytest.mark.django_db
+def test_query_interception():
+    clear_query_data()
+    
+    with connection.execute_wrapper(NPlus1QueryWrapper()):
+        Author.objects.create(name="Test Author")
+        list(Author.objects.all())
+        
+    data = get_query_data()
+    assert len(data) >= 2
+    
+    # Check that SQL was captured
+    assert any("INSERT INTO" in item['sql'] for item in data)
+    assert any("SELECT" in item['sql'] for item in data)
+    
+    # Check that frame was captured
+    assert all(item['frame'] is not None for item in data)
+    # The frame filename should ideally be this test file
+    assert any('test_trackers.py' in item['frame'].filename for item in data)