Fix a Django N+1 query and protect it with a query-count test

• Use select_related for the single-valued customer relation.
• Use prefetch_related for order lines and their products.
• Evaluate serialization inside the query-count assertion.
• Use several orders and lines so lazy loading cannot hide.
• Do not weaken the response shape to make the test pass.

1. List every relation the serializer touches.
2. Join the customer with select_related.
3. Prefetch the collection path lines__product.
4. Materialize the serialized dictionaries inside assertNumQueries.
5. Add more orders and verify the expected count does not grow.

def order_rows():
    orders = (
        Order.objects
        .select_related("customer")
        .prefetch_related("lines__product")
        .order_by("id")[:20]
    )
    return [
        {
            "id": order.id,
            "customer": order.customer.name,
            "lines": [
                {"sku": line.product.sku, "quantity": line.quantity}
                for line in order.lines.all()
            ],
        }
        for order in orders
    ]

def test_order_rows_has_bounded_queries(django_assert_num_queries, order_factory):
    for _ in range(5):
        order_factory(lines=3)
    with django_assert_num_queries(3):
        rows = order_rows()
    assert len(rows) == 5

The database performs a constant number of queries and returns O(orders + lines) rows. Application serialization is O(orders + lines).

• Pagination should happen before prefetching an unbounded order set.
• Filtering a prefetched related manager differently can issue a new query.
• Large joined collections can duplicate rows, which is why collections are prefetched.
• The expected count can include middleware or fixture queries if the assertion boundary is too wide.

• Repeat with one and twenty orders and keep the same query bound.
• Include orders with zero lines.
• Verify every accessed product field is prefetched.
• Move list materialization outside the assertion and confirm the test would become ineffective.

• Using select_related for a to-many relation is the wrong loading shape.
• Prefetching lines but not lines__product leaves another N+1.
• Asserting only queryset construction runs no SQL.
• Testing one order can make a linear query pattern look constant.