Revised the API once more.

Author: tim-schilling

CHANGELOG.md

@@ -1,5 +1,9 @@
 # Changelog
 
+## Pending
+
+* Shortened the name ``AssertModelQueriesContext`` to ``AssertModelQueries``.
+
 ## 1.0.2 (2024-11-29)
 
 * Getting the versioning in sync, no functional changes.

README.md

@@ -16,7 +16,7 @@ not something that should be relied upon in production.
 
 There are integrations for both pytest and Django / `unittest`. Both of
 which use the context manager,
-``django_assert_model_queries.AssertModelQueriesContext`` under the
+``django_assert_model_queries.AssertModelQueries`` under the
 hood.
 
 The basic usage is to define a dictionary of expected queries to be
@@ -25,15 +25,15 @@ differ, a helpful error message will be rendered indicating what the
 differences were and what *all* the queries were during the context.
 
 ```python
-from django_assert_model_queries import AssertModelQueriesContext
+from django_assert_model_queries import AssertModelQueries
 from testapp.models import Community
 
-with AssertModelQueriesContext({"testapp.Community": 2}):
+with AssertModelQueries({"testapp.Community": 2}):
     Community.objects.create(name="test")
     Community.objects.update(name="test")
 ```
 
-When an unexpected query runs, this ``AssertModelQueriesContext`` will
+When an unexpected query runs, this ``AssertModelQueries`` will
 tell you which model generated an unexpected query.
 
 
@@ -42,26 +42,26 @@ tell you which model generated an unexpected query.
 Here is an example of what you can expect from the tool:
 
 ```pycon
->>>  from django_assert_model_queries import AssertModelQueriesContext
+>>>  from django_assert_model_queries import AssertModelQueries
 >>>  from django.contrib.auth.models import User
->>>  with AssertModelQueriesContext({}):
+>>>  with AssertModelQueries({}):
 >>>      User.objects.first()
 
 ---------------------------------------------------------------------------
 AssertionError                            Traceback (most recent call last)
 Cell In[1], line 3
-      1 from django_assert_model_queries import AssertModelQueriesContext
+      1 from django_assert_model_queries import AssertModelQueries
       2 from django.contrib.auth.models import User
-----> 3 with AssertModelQueriesContext({}):
+----> 3 with AssertModelQueries({}):
       4     User.objects.only("id").first()
 
-File ~/site-packages/django_assert_model_queries/test.py:145, in AssertModelQueriesContext.__exit__(self, exc_type, exc_value, traceback)
+File ~/site-packages/django_assert_model_queries/test.py:145, in AssertModelQueries.__exit__(self, exc_type, exc_value, traceback)
     142 if exc_type is not None:
     143     return
 --> 145 self.handle_assertion(actual, expected)
     146 self.expected_model_counts = None
 
-File ~/site-packages/django_assert_model_queries/test.py:172, in AssertModelQueriesContext.handle_assertion(self, actual, expected)
+File ~/site-packages/django_assert_model_queries/test.py:172, in AssertModelQueries.handle_assertion(self, actual, expected)
     170         pytest.fail(self.failure_message(actual, expected))
     171 else:
 --> 172     assert actual == expected, self.failure_message(actual, expected)
@@ -109,14 +109,14 @@ If you test with Django's ``TestCase``, inherit from the mixin
 # Django TestCase example
 
 from django.test import TestCase
-from django_assert_model_queries import AssertModelQueriesContext, ModelNumQueriesHelper
+from django_assert_model_queries import AssertModelQueries, ModelNumQueriesHelper
 from testapp.models import Community
 
 class TestDjangoIntegration(ModelNumQueriesHelper, TestCase):
     def test_assert_model_num_queries_context(self):
-        with AssertModelQueriesContext({"testapp.Community": 1}):
+        with AssertModelQueries({"testapp.Community": 1}):
             Community.objects.create(name="test")
-        with AssertModelQueriesContext({"testapp.Community": 2, "testapp.Chapter": 1, "testapp.Community_topics": 1}):
+        with AssertModelQueries({"testapp.Community": 2, "testapp.Chapter": 1, "testapp.Community_topics": 1}):
             Community.objects.all().delete()
 
 class TestDjangoHelperIntegration(ModelNumQueriesHelper, TestCase):
@@ -139,18 +139,18 @@ There are a few parameters that may help in certain scenarios.
   hide N+1 issues.
 
 To use these, you must specify them when instantiating
-``AssertModelQueriesContext``.
+``AssertModelQueries``.
 
 ```python
-from django_assert_model_queries import AssertModelQueriesContext
+from django_assert_model_queries import AssertModelQueries
 from django.contrib.sessions.models import Session
 
-assert_context = AssertModelQueriesContext(ignore={Session})
+assert_context = AssertModelQueries(ignore={Session})
 with assert_context({"testapp.Community": 1}):
     do_something()
 
 
-assert_context = AssertModelQueriesContext(strict=False)
+assert_context = AssertModelQueries(strict=False)
 with assert_context({"testapp.Community": 1}):
     do_something()
 ```

src/django_assert_model_queries/__init__.py

@@ -1 +1 @@
-from .test import AssertModelQueriesContext, ModelNumQueriesHelper  # noqa: F401
+from .test import AssertModelQueries, ModelNumQueriesHelper  # noqa: F401

src/django_assert_model_queries/pytest.py

@@ -1,6 +1,6 @@
 import pytest
 
-from .test import AssertModelQueriesContext
+from .test import AssertModelQueries
 
 
 @pytest.fixture(scope="session")
@@ -15,4 +15,4 @@ def test_something(self, assert_model_queries):
                 do_something()
 
     """
-    return AssertModelQueriesContext()
+    return AssertModelQueries()

src/django_assert_model_queries/test.py

@@ -41,7 +41,7 @@ class ExpectedModelCountsNotSet(ValueError):
     """
 
 
-class AssertModelQueriesContext(CaptureQueriesContext):
+class AssertModelQueries(CaptureQueriesContext):
     unpatch = None
 
     def __init__(
@@ -58,7 +58,7 @@ def __init__(
 
         Usage:
 
-            with AssertModelQueriesContext({"MyModel": 1}):
+            with AssertModelQueries({"MyModel": 1}):
                 do_something()
 
 
@@ -211,6 +211,6 @@ def test_something(self):
         """
         conn = connections[using]
 
-        return AssertModelQueriesContext(
+        return AssertModelQueries(
             expected_model_counts=expected_model_counts, test_case=self, connection=conn
         )

tests/test_django.py

@@ -2,23 +2,23 @@
 from django.test import TestCase
 
 from django_assert_model_queries.test import (
-    AssertModelQueriesContext,
+    AssertModelQueries,
     ModelNumQueriesHelper,
 )
 from .testapp.models import Community
 
 
 class TestDjangoIntegration(ModelNumQueriesHelper, TestCase):
     def test_assert_model_num_queries_context(self):
-        with AssertModelQueriesContext({"testapp.Community": 1}):
+        with AssertModelQueries({"testapp.Community": 1}):
             Community.objects.create(name="test")
-        with AssertModelQueriesContext({"testapp.Community": 1}):
+        with AssertModelQueries({"testapp.Community": 1}):
             Community.objects.update(name="new")
-        with AssertModelQueriesContext({"testapp.Community": 1}):
+        with AssertModelQueries({"testapp.Community": 1}):
             Community.objects.get(name="new")
-        with AssertModelQueriesContext({"testapp.Community": 1}):
+        with AssertModelQueries({"testapp.Community": 1}):
             Community.objects.aggregate(count=Count("id"))
-        with AssertModelQueriesContext(
+        with AssertModelQueries(
             {
                 "testapp.Community": 2,
                 "testapp.Chapter": 1,

tests/test_integration.py

@@ -5,7 +5,7 @@
 from _pytest.outcomes import Failed
 from django.db.models import Count
 
-from django_assert_model_queries import AssertModelQueriesContext
+from django_assert_model_queries import AssertModelQueries
 from django_assert_model_queries.patch import (
     query_counts,
     reset_query_counter,
@@ -67,10 +67,10 @@ def test_patched_compilers(self, using_db, patch):
         }
 
 
-class TestAssertModelQueriesContext:
+class TestAssertModelQueries:
     @pytest.fixture
     def assert_context(self):
-        context = AssertModelQueriesContext(
+        context = AssertModelQueries(
             connection=Mock(queries=[{"sql": "SELECT * FROM testapp.community"}])
         )
         context.initial_queries = 0
@@ -79,7 +79,7 @@ def assert_context(self):
 
     @pytest.mark.django_db
     def test_call_expects_overrides_init(self):
-        context = AssertModelQueriesContext({"testapp.Community": 0})
+        context = AssertModelQueries({"testapp.Community": 0})
         with context({"testapp.Community": 1}):
             assert Community.objects.first() is None
             assert context.expected_model_counts == {"testapp.Community": 1}
@@ -113,7 +113,7 @@ def test_failure_message(self, assert_context):
         )
 
     def test_expected_model_counts_not_set(self):
-        context = AssertModelQueriesContext()
+        context = AssertModelQueries()
         with pytest.raises(ExpectedModelCountsNotSet):
             with context():
                 pass  # pragma: no cover
@@ -135,7 +135,7 @@ def test_find_actual_ignore_models(self, assert_context):
 
     @pytest.mark.django_db
     def test_exception_still_unpatches(self):
-        context = AssertModelQueriesContext()
+        context = AssertModelQueries()
 
         class KnownException(Exception):
             pass
@@ -181,6 +181,6 @@ def test_parse_counts(self, input, expected):
 @pytest.mark.django_db
 def test_handle_assertion_not_testing():
     with pytest.raises(AssertionError) as exc_info:
-        with AssertModelQueriesContext([]):
+        with AssertModelQueries([]):
             assert Community.objects.first() is None
     assert not issubclass(exc_info.type, Failed)