django-ticketing 0.8.0__py3-none-any.whl

django_ticketing-0.8.0.dist-info/METADATA

@@ -0,0 +1,201 @@
+Metadata-Version: 2.4
+Name: django-ticketing
+Version: 0.8.0
+Summary: Generate tickets efficiently in a database in Django
+Author-email: Chris Streeter <pypi@chrisstreeter.com>
+License-Expression: MIT
+Project-URL: Repository, https://github.com/streeter/django-ticketing
+Classifier: Framework :: Django
+Classifier: Framework :: Django :: 5.2
+Classifier: Framework :: Django :: 6.0
+Classifier: Framework :: Django :: 6.1
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: System Administrators
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: Python :: 3.15
+Classifier: Topic :: Software Development
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: Django>=5.2
+Provides-Extra: test
+Requires-Dist: pytest<10,>=9; extra == "test"
+Requires-Dist: pytest-django<5,>=4.14; extra == "test"
+Provides-Extra: dev
+Requires-Dist: django-ticketing[test]; extra == "dev"
+Requires-Dist: tox<5,>=4.28; extra == "dev"
+Requires-Dist: ruff==0.17.2; extra == "dev"
+Dynamic: license-file
+
+## About
+
+An implementation of a Django model that returns tickets, as described
+in the [Flickr blog post][flickr]. Requires Python 3.11 or higher and Django 5.2
+or higher. Ticket generation supports MySQL 8.4 or higher and SQLite.
+
+## Installation
+
+I uploaded it to [PyPi][pypi], so you can grab it there if you'd like with
+
+```
+pip install django-ticketing
+```
+
+or install it with pip using the git address:
+
+```
+pip install git+git@github.com:streeter/django-ticketing.git
+```
+
+Then add `ticketing` to your `INSTALLED_APPS`.
+
+## Usage
+
+To use this, you can either use the model interface, or just the shortcut
+function defined in `ticketing.models`. That usage looks like this:
+
+```python
+# Import the function
+from ticketing.models import get_ticket
+
+# Go get yourself a ticket
+ticket = get_ticket()
+# Boom. That just happened
+```
+
+Create the sequence tables before requesting tickets. The app generates its
+models from your settings and does not ship migrations; use Django's
+`migrate --run-syncdb` to create tables for this unmigrated app.
+
+### Multiple Sequences
+
+`django-ticketing` also supports multiple sequences, which allows to have
+sequences of tickets that are independent. This means you could have a sequence
+for users, a sequence for posts and a sequence for widgets. This is configured
+through your Django settings configuration.
+
+Simply define a setting called `TICKETING_SEQUENCES` with a tuple of sequence
+names that have to be valid table names. This defaults to the tuple `('default',)`.
+In addition, you can define the default sequence from which new tickets are
+taken from with the setting `TICKETING_DEFAULT_SEQUENCE`, which defaults to
+`'default'`.
+
+Note that `TICKETING_DEFAULT_SEQUENCE` has to be a sequence name that is defined
+inside of `TICKETING_SEQUENCES`, otherwise an exception will be raised
+during setup.
+
+So to have sequences for the above example, put the following lines in your
+`settings.py`:
+
+``` python
+TICKETING_DEFAULT_SEQUENCE = "users"
+TICKETING_SEQUENCES = (
+    "users",
+    "posts",
+    "widgets",
+)
+```
+
+Then, to get a ticket from a specific sequence, pass in the sequence name to
+`get_ticket()`:
+
+``` python
+# Get yourself a user ticket
+user_ticket = get_ticket("users")
+# Get yourself another user ticket
+user_ticket = get_ticket()
+# Get yourself a posts ticket
+post_ticket = get_ticket("posts")
+```
+
+Notice that the default sequence for `get_ticket()` is the value of the
+`TICKETING_DEFAULT_SEQUENCE` configuration variable.
+
+Also, after you change the value of `TICKETING_SEQUENCES`, be sure to re-run
+`python manage.py migrate --run-syncdb` to create any new sequence tables.
+
+### Other Configuration Options
+
+`TICKETING_APP_LABEL`: This is used to specify the prefix for all the DB
+tablenames. The default value is `'ticketing'`. Be sure you know what you are
+doing when you change this.
+
+
+## Testing
+
+Install the development tools in a virtual environment:
+
+```bash
+python -m venv .venv
+source .venv/bin/activate
+python -m pip install -e '.[dev]'
+```
+
+Run the pytest suite against the current environment, or use Tox for the full
+compatibility matrix and Ruff checks:
+
+```bash
+pytest
+tox
+```
+
+Tox requires each Python interpreter in the matrix to be installed. Missing
+interpreters fail the run so coverage cannot silently disappear. To run just
+one environment or one test:
+
+```bash
+tox -e py315-django61
+tox -e py315-django61 -- -k test_get_ticket
+```
+
+The matrix uses the latest patch release in each Django series. List the
+configured environments with `tox list -d --no-desc`.
+
+Tests use an in-memory SQLite database and configure multiple ticket sequences
+in `ticketing/tests/settings.py`. `tox.ini` defines the test matrix; GitHub
+Actions discovers it with `tox list -d --no-desc` and runs every combination
+and the Ruff checks on pushes and pull requests. Add or remove environments
+in `tox.ini` to update both local and CI runs. CI infers the Python version
+from each environment's `py<major><minor>` prefix (for example, `py315`).
+
+The MySQL environments cover MySQL 8.4 (the minimum supported version) and
+26.10 with each supported Django series. CI derives the MySQL service image
+from the `-mysql-<version>` suffix in `tox.ini`.
+
+For a local MySQL run, provide a disposable database server and credentials
+for a user that can create and drop test databases:
+
+```bash
+export TICKETING_TEST_DB_USER=root
+export TICKETING_TEST_DB_PASSWORD=ticketing-tests
+export TICKETING_TEST_DB_PORT=3384
+tox -e py315-django61-mysql-8.4
+```
+
+The host defaults to `127.0.0.1`; override it with `TICKETING_TEST_DB_HOST`.
+Django creates and drops `test_ticketing`; set `TICKETING_TEST_DB_NAME` to
+change the base database name. To run the complete matrix against multiple
+local MySQL servers, use `TICKETING_TEST_MYSQL_8_4_PORT` and
+`TICKETING_TEST_MYSQL_26_10_PORT` to select a port for each version.
+
+Format all Python code and check lint and formatting locally with:
+
+```bash
+tox -e format
+tox -e lint
+```
+
+
+## License
+
+Uses the [MIT][mit] license.
+
+
+[flickr]: http://code.flickr.com/blog/2010/02/08/ticket-servers-distributed-unique-primary-keys-on-the-cheap/
+[pypi]: http://pypi.python.org/pypi/django-ticketing/
+[mit]: http://opensource.org/licenses/MIT

django_ticketing-0.8.0.dist-info/RECORD

@@ -0,0 +1,17 @@
+django_ticketing-0.8.0.dist-info/licenses/LICENSE,sha256=g97jvK9pbiXQ8HzjNig4vx6NtcNAmGikEt6LuXEnQWU,1058
+ticketing/__init__.py,sha256=pflwNqxPr6gz_EspcGGPtTqXfWUDpqCd2Q1nQXXH_Sc,91
+ticketing/conf.py,sha256=7napO1wRCRtqk34XbQz3OiM3W8TNOP5kT8XLv5l3j2E,1099
+ticketing/exceptions.py,sha256=pOT2fI_xSwCSon_PlL3mRIGlky-Ehvyj-J3wV52iKmA,93
+ticketing/fields.py,sha256=8-UEGmtVrLrkNotPzGXeQ72SWO-jJpqW-1ofcNEO01s,2641
+ticketing/managers.py,sha256=hiK-YeX5i3QbDu5s4jk4lNLn-pJ4_3JUD7LXYtb6Bjw,1867
+ticketing/models.py,sha256=NZ6YhynovM2sDRFhE9QgOMSgiEZGTHp6LAKbzG7mydg,2445
+ticketing/views.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+ticketing/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+ticketing/tests/settings.py,sha256=vNmNcyJLQ3Fx3iMJH2h8nP0_UBCV3NyADmLSE89I7_o,1093
+ticketing/tests/test_fields.py,sha256=b9tVTw877sgzdToFjsM8WYxw_VXQAtDUd1hDLulVQUI,2582
+ticketing/tests/test_managers.py,sha256=2a0yNg64elC2bVjBu2O1z-nkT4eSswho3M5aZ_IUN70,3287
+ticketing/tests/test_ticketing.py,sha256=g9jtlUcLdrIVKRqvpllet0aBTX1fT2vRwqfxxqRKwQA,1446
+django_ticketing-0.8.0.dist-info/METADATA,sha256=Uln760_2lyzhZ3sG21xV_PMFgzWNhEHqnmSZ74A6Gl0,6549
+django_ticketing-0.8.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+django_ticketing-0.8.0.dist-info/top_level.txt,sha256=eAH4TzD_rYMydICCzwBU0Wg6iJwC4BuOkof_f1Btzic,10
+django_ticketing-0.8.0.dist-info/RECORD,,

django_ticketing-0.8.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

django_ticketing-0.8.0.dist-info/licenses/LICENSE

@@ -0,0 +1,7 @@
+Copyright (c) 2013 Chris Streeter
+
+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_ticketing-0.8.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+ticketing

ticketing/__init__.py

@@ -0,0 +1,7 @@
+"""
+Ticketing
+~~~~~~~~~
+"""
+
+VERSION = (0, 8, 0)
+__version__ = ".".join(map(str, VERSION))

ticketing/conf.py

@@ -0,0 +1,29 @@
+from django.conf import settings
+
+# Testing and Debug settings
+TESTING = getattr(settings, "TICKETING_TESTING", False)
+DEBUG = getattr(settings, "DEBUG", False) and not TESTING
+
+# Let the user redefine the APP_LABEL, which is used for the table
+# prefixes.
+APP_LABEL = getattr(settings, "TICKETING_APP_LABEL", "ticketing")
+
+# A list of names that define all the different ticketing tables. Every
+# sequence is a sequence of tickets that can be retrieved.
+SEQUENCES = getattr(settings, "TICKETING_SEQUENCES", ("default",))
+
+# When testing, add a second sequence so we can test specifying sequences
+if TESTING:
+    SEQUENCES = SEQUENCES + ("test",)
+
+# The name of the default sequence that is queried when creating tickets.
+DEFAULT_SEQUENCE = getattr(settings, "TICKETING_DEFAULT_SEQUENCE", "default")
+
+if DEFAULT_SEQUENCE not in SEQUENCES:
+    msg = (
+        "Cannot specify a default sequence '%s' that "
+        + "is not in the list of allowed sequences %s"
+    ) % (DEFAULT_SEQUENCE, str(SEQUENCES))
+    from ticketing.exceptions import ImproperlyConfigured
+
+    raise ImproperlyConfigured(msg)

ticketing/exceptions.py

@@ -0,0 +1,6 @@
+class BadSequenceName(Exception):
+    pass
+
+
+class ImproperlyConfigured(Exception):
+    pass

ticketing/fields.py

@@ -0,0 +1,86 @@
+from django.db import models
+
+from ticketing import conf
+
+
+def _conn_is_mysql(connection):
+    return (
+        bool(connection)
+        and connection.settings_dict["ENGINE"] == "django.db.backends.mysql"
+    )
+
+
+class BigAutoField(models.AutoField):
+    def db_type(self, connection):
+        if _conn_is_mysql(connection):
+            return "bigint UNSIGNED AUTO_INCREMENT"
+        else:
+            return super().db_type(connection)
+
+
+class TicketField(models.BigIntegerField):
+    description = "A big integer pre-populated from a ticket"
+
+    def __init__(self, sequence=None, **kwargs):
+        """
+        Set up this field with the name of the sequence to use
+        """
+        self.sequence = sequence or conf.DEFAULT_SEQUENCE
+        kwargs["editable"] = False
+        super().__init__(**kwargs)
+
+    def deconstruct(self):
+        name, path, args, kwargs = super().deconstruct()
+        kwargs["sequence"] = self.sequence
+        return name, path, args, kwargs
+
+    def pre_save(self, model_instance, add):
+        """
+        When saving the DB, if we are adding this instance, get a ticket
+        value for this field. Otherwise pull it from the model instance.
+        If the field on the instance already has a value, we won't
+        a new ticketing value.
+        """
+        if add and not getattr(model_instance, self.attname):
+            from ticketing.models import get_ticket
+
+            value = get_ticket(self.sequence)
+            setattr(model_instance, self.attname, value)
+            return value
+        else:
+            return super().pre_save(model_instance, add)
+
+    def db_type(self, connection):
+        if _conn_is_mysql(connection):
+            return "bigint UNSIGNED"
+        else:
+            return super().db_type(connection)
+
+    def south_field_triple(self):
+        "Returns a suitable description of this field for South."
+        # We'll just introspect the _actual_ field.
+        from south.modelsinspector import introspector
+
+        field_class = "ticketing.fields.TicketField"
+        args, kwargs = introspector(self)
+        # That's our definition!
+        return (field_class, args, kwargs)
+
+
+try:
+    from south.modelsinspector import add_introspection_rules
+
+    add_introspection_rules(
+        rules=[
+            (
+                [TicketField],  # Class(es) these apply to
+                [],  # Positional arguments (not used)
+                {  # Keyword argument
+                    "sequence": ["sequence", {"default": None}],
+                },
+            ),
+        ],
+        patterns=[r"^ticketing\.fields\.TicketField"],
+    )
+except ImportError:
+    pass

ticketing/managers.py

@@ -0,0 +1,49 @@
+from django.db import OperationalError, connections, models, transaction
+
+exceptions = (OperationalError,)
+try:
+    # Also try to catch a MySQLdb-specific OperationalError
+    from MySQLdb import OperationalError as MySQLOperationalError
+
+    exceptions += (MySQLOperationalError,)
+except ImportError:
+    pass
+
+
+class TicketingManager(models.Manager):
+    def create(self):
+        ticket_id = self.get_ticket()
+        return self.model(id=ticket_id, stub=self.model.STUB_DEFAULT)
+
+    def get_queryset(self):
+        raise NotImplementedError()
+
+    def _internal_get_ticket(self):
+        sql = f"REPLACE INTO `{self.model._meta.db_table}` "
+        sql += "(`stub`) VALUES (%s)"
+
+        with transaction.atomic(using=self.db):
+            cursor = connections[self.db].cursor()
+            cursor.execute(sql, [self.model.STUB_DEFAULT])
+
+            lastrow_id = getattr(cursor, "lastrowid", None)
+            if lastrow_id is None:
+                # Hack. Select the row and get the id manually
+                result = super().get_queryset().filter(stub=True)[0]
+                lastrow_id = result.id
+
+            return lastrow_id
+
+    def get_ticket(self):
+        try:
+            return self._internal_get_ticket()
+        except exceptions:
+            connection = connections[self.db]
+            # If the transaction is in an `atomic` block, and needs a rollback,
+            # we should mark the database as rolled back. This is because the
+            # database backend may not prevent running SQL queries in broken
+            # transactions, in which case we need to say that we have handled
+            # the rollback so we can try one more time.
+            if connection.in_atomic_block and transaction.get_rollback(using=self.db):
+                transaction.set_rollback(False, using=self.db)
+            return self._internal_get_ticket()

ticketing/models.py

@@ -0,0 +1,89 @@
+from django.db import models
+
+from ticketing import conf
+from ticketing.fields import BigAutoField
+from ticketing.managers import TicketingManager
+
+# Container for all the ticketing models
+ticketing_models = {}
+
+
+class BaseTicketing(models.Model):
+    """
+    The base class used by all Ticket generator models.
+
+    Define the fields, methods and manager used by all
+    classes that will inherit from this abstract model.
+    All ticketing models that are created for each
+    sequence defined in the configuration will inherit
+    these properties.
+
+    """
+
+    # Explicitly set the id of the model, even though it is the same
+    # as the one Django gives it.
+    id = BigAutoField(null=False, primary_key=True)
+
+    # This is just the smallest placeholder we can create that we can
+    # replace into to generate a new id.
+    STUB_DEFAULT = True
+    stub = models.BooleanField(null=False, default=STUB_DEFAULT, unique=True)
+
+    # Override the default manager
+    objects = TicketingManager()
+
+    @property
+    def ticket(self):
+        """Alias for id"""
+        return self.id
+
+    def __str__(self):
+        return f"Ticket {self.ticket}"
+
+    class Meta:
+        abstract = True
+
+
+# Create each model for the ones defined in the configuration
+for seq in conf.SEQUENCES:
+
+    class Meta:
+        pass
+
+    # Set the application label
+    setattr(Meta, "app_label", conf.APP_LABEL)
+
+    # __module__ is used with app_label to create the name of the table.
+    # In addition, we want to have a Meta class so that the Django code
+    # will work properly.
+    attrs = {
+        "__module__": seq,
+        "Meta": Meta,
+    }
+
+    # Create the model definition
+    model = type(seq, (BaseTicketing,), attrs)
+
+    # Save the definition in a variable that we can use later. This will
+    # also let Django find this model with some python dict traversal
+    # goodness.
+    ticketing_models[seq] = model
+
+
+def get_ticket(sequence=conf.DEFAULT_SEQUENCE):
+    """
+    Get a ticket for the specified sequence.
+
+    `sequence` defaults to the configuration parameter DEFAULT_SEQUENCE
+
+    """
+    if sequence not in ticketing_models:
+        msg = (
+            f"Sequence '{sequence}' is not one of the configured sequences "
+            f"{conf.SEQUENCES}"
+        )
+        from ticketing.exceptions import BadSequenceName
+
+        raise BadSequenceName(msg)
+    ticket = ticketing_models[sequence].objects.create()
+    return ticket.ticket

ticketing/tests/settings.py

@@ -0,0 +1,28 @@
+import os
+
+SECRET_KEY = "django-ticketing-tests"
+DATABASES = {
+    "default": {
+        "ENGINE": "django.db.backends.sqlite3",
+        "NAME": ":memory:",
+    }
+}
+if os.environ.get("TICKETING_TEST_MYSQL"):
+    DATABASES["default"] = {
+        "ENGINE": "django.db.backends.mysql",
+        "NAME": os.environ.get("TICKETING_TEST_DB_NAME", "ticketing"),
+        "USER": os.environ.get("TICKETING_TEST_DB_USER", "root"),
+        "PASSWORD": os.environ.get("TICKETING_TEST_DB_PASSWORD", ""),
+        "HOST": os.environ.get("TICKETING_TEST_DB_HOST", "127.0.0.1"),
+        "PORT": os.environ.get("TICKETING_TEST_DB_PORT", "3306"),
+        "OPTIONS": {"charset": "utf8mb4"},
+    }
+    mysql_version = os.environ.get("TOX_ENV_NAME", "").partition("-mysql-")[2]
+    if mysql_version:
+        port_variable = f"TICKETING_TEST_MYSQL_{mysql_version.replace('.', '_')}_PORT"
+        DATABASES["default"]["PORT"] = os.environ.get(
+            port_variable, DATABASES["default"]["PORT"]
+        )
+INSTALLED_APPS = ["ticketing"]
+DEFAULT_AUTO_FIELD = "django.db.models.BigAutoField"
+TICKETING_TESTING = True

ticketing/tests/test_fields.py

@@ -0,0 +1,88 @@
+import pytest
+from django.db import connection, models
+from django.db.migrations.state import ModelState
+from django.test.utils import isolate_apps
+
+from ticketing import conf
+from ticketing.fields import BigAutoField, TicketField
+from ticketing.models import get_ticket
+
+
+@pytest.fixture
+def ticketed_model(django_db_reset_sequences):
+    with isolate_apps():
+
+        class Ticketed(models.Model):
+            ticket = TicketField(sequence="test")
+
+            class Meta:
+                app_label = "ticketing"
+
+        with connection.schema_editor() as editor:
+            editor.create_model(Ticketed)
+        try:
+            yield Ticketed
+        finally:
+            with connection.schema_editor() as editor:
+                editor.delete_model(Ticketed)
+
+
+def test_ticket_field_generates_from_requested_sequence(ticketed_model):
+    instance = ticketed_model.objects.create()
+
+    instance.refresh_from_db()
+    assert instance.ticket > 0
+    assert get_ticket("test") == instance.ticket + 1
+    assert get_ticket(conf.DEFAULT_SEQUENCE) == 1
+
+
+def test_ticket_field_preserves_explicit_value(ticketed_model):
+    instance = ticketed_model.objects.create(ticket=123)
+
+    instance.refresh_from_db()
+    assert instance.ticket == 123
+    assert get_ticket("test") == 1
+
+
+def test_ticket_field_preserves_value_when_saved_again(ticketed_model):
+    instance = ticketed_model.objects.create()
+    ticket = instance.ticket
+
+    instance.save()
+    instance.refresh_from_db()
+
+    assert instance.ticket == ticket
+    assert get_ticket("test") == ticket + 1
+
+
+@pytest.mark.parametrize("sequence", conf.SEQUENCES)
+def test_migration_state_preserves_ticket_field_sequence(sequence):
+    with isolate_apps():
+
+        class Ticketed(models.Model):
+            ticket = TicketField(sequence=sequence)
+
+            class Meta:
+                app_label = "ticketing"
+
+        state = ModelState.from_model(Ticketed)
+
+    assert state.fields["ticket"].sequence == sequence
+    assert state.fields["ticket"].editable is False
+
+
+@pytest.mark.django_db(transaction=True, reset_sequences=True)
+def test_big_auto_field_exceeds_32_bits():
+    from ticketing.models import ticketing_models
+
+    model = ticketing_models[conf.DEFAULT_SEQUENCE]
+    assert isinstance(model._meta.pk, BigAutoField)
+    large_id = 2**32
+    with connection.cursor() as cursor:
+        cursor.execute(
+            f"INSERT INTO {connection.ops.quote_name(model._meta.db_table)} "
+            "(id, stub) VALUES (%s, %s)",
+            [large_id, model.STUB_DEFAULT],
+        )
+
+    assert get_ticket() > large_id

ticketing/tests/test_managers.py

@@ -0,0 +1,102 @@
+import os
+from unittest.mock import Mock
+
+import pytest
+from django.db import IntegrityError, OperationalError, connection, transaction
+
+from ticketing import conf
+from ticketing.models import get_ticket, ticketing_models
+
+
+@pytest.fixture
+def manager():
+    return ticketing_models[conf.DEFAULT_SEQUENCE].objects
+
+
+@pytest.mark.django_db
+def test_retries_once_after_operational_error(manager, monkeypatch):
+    allocate = Mock(side_effect=[OperationalError("deadlock"), 42])
+    monkeypatch.setattr(manager, "_internal_get_ticket", allocate)
+
+    assert manager.get_ticket() == 42
+    assert allocate.call_count == 2
+
+
+@pytest.mark.django_db
+def test_propagates_repeated_operational_error(manager, monkeypatch):
+    allocate = Mock(side_effect=OperationalError("deadlock"))
+    monkeypatch.setattr(manager, "_internal_get_ticket", allocate)
+
+    with pytest.raises(OperationalError, match="deadlock"):
+        manager.get_ticket()
+    assert allocate.call_count == 2
+
+
+@pytest.mark.django_db
+def test_does_not_retry_unrelated_error(manager, monkeypatch):
+    allocate = Mock(side_effect=IntegrityError("constraint violation"))
+    monkeypatch.setattr(manager, "_internal_get_ticket", allocate)
+
+    with pytest.raises(IntegrityError, match="constraint violation"):
+        manager.get_ticket()
+    assert allocate.call_count == 1
+
+
+@pytest.mark.django_db(transaction=True, reset_sequences=True)
+def test_retry_after_failed_sql_preserves_outer_transaction(manager):
+    attempts = 0
+
+    def fail_once(execute, sql, params, many, context):
+        nonlocal attempts
+        if sql.startswith("REPLACE INTO"):
+            attempts += 1
+            if attempts == 1:
+                raise OperationalError("deadlock")
+        return execute(sql, params, many, context)
+
+    with transaction.atomic(), connection.execute_wrapper(fail_once):
+        assert manager.get_ticket() > 0
+        assert get_ticket() > 0
+
+    assert attempts == 3
+    assert get_ticket() > 0
+
+
+@pytest.mark.django_db(transaction=True, reset_sequences=True)
+def test_retry_works_without_outer_transaction(manager):
+    attempts = 0
+
+    def fail_once(execute, sql, params, many, context):
+        nonlocal attempts
+        if sql.startswith("REPLACE INTO"):
+            attempts += 1
+            if attempts == 1:
+                raise OperationalError("deadlock")
+        return execute(sql, params, many, context)
+
+    with connection.execute_wrapper(fail_once):
+        assert manager.get_ticket() > 0
+
+    assert attempts == 2
+
+
+@pytest.mark.django_db
+def test_only_latest_ticket_row_is_retained():
+    tickets = [get_ticket() for _ in range(10)]
+    model = ticketing_models[conf.DEFAULT_SEQUENCE]
+    with connection.cursor() as cursor:
+        cursor.execute(
+            f"SELECT id FROM {connection.ops.quote_name(model._meta.db_table)}"
+        )
+        rows = cursor.fetchall()
+
+    assert list(rows) == [(tickets[-1],)]
+
+
+@pytest.mark.django_db
+@pytest.mark.skipif(connection.vendor != "mysql", reason="Requires a MySQL server")
+def test_mysql_version_matches_tox_environment():
+    assert connection.mysql_version >= (8, 4)
+    requested = os.environ.get("TOX_ENV_NAME", "").partition("-mysql-")[2]
+    if requested:
+        assert connection.mysql_version[:2] == tuple(map(int, requested.split(".")))

ticketing/tests/test_ticketing.py

@@ -0,0 +1,57 @@
+import pytest
+
+from ticketing import conf
+from ticketing.exceptions import BadSequenceName
+from ticketing.models import get_ticket, ticketing_models
+
+pytestmark = pytest.mark.django_db(transaction=True, reset_sequences=True)
+
+
+def test_get_ticket():
+    assert get_ticket() > 0
+
+
+def test_get_tickets():
+    first = get_ticket()
+    second = get_ticket()
+
+    assert 0 < first < second
+
+
+def test_get_n_tickets():
+    tickets = [get_ticket() for _ in range(200)]
+
+    assert tickets[0] > 0
+    assert all(first < second for first, second in zip(tickets, tickets[1:]))
+
+
+@pytest.mark.parametrize("sequence", conf.SEQUENCES)
+def test_get_from_sequence(sequence):
+    tickets = [get_ticket(sequence) for _ in range(10)]
+
+    assert tickets[0] > 0
+    assert all(first < second for first, second in zip(tickets, tickets[1:]))
+
+
+def test_get_sequences_in_order():
+    assert len(conf.SEQUENCES) > 1
+    for expected in range(1, 10):
+        for sequence in conf.SEQUENCES:
+            assert get_ticket(sequence) == expected
+
+
+def test_bad_sequence():
+    with pytest.raises(BadSequenceName, match="bad_sequence"):
+        get_ticket("bad_sequence")
+
+
+def test_default_sequence():
+    assert get_ticket() == 1
+    assert get_ticket(conf.DEFAULT_SEQUENCE) == 2
+
+
+def test_ticket_model_string():
+    ticket = ticketing_models[conf.DEFAULT_SEQUENCE].objects.create()
+
+    assert ticket.ticket == ticket.pk
+    assert str(ticket) == f"Ticket {ticket.pk}"