Generic Views

from django.conf import settings
from django.core.validators import MaxValueValidator, MinValueValidator
from django.db import models
from django.urls import reverse


class Author(models.Model):
    name = models.CharField(max_length=200)
    slug = models.SlugField(unique=True)

    def __str__(self):
        return self.name

    def get_absolute_url(self):
        return reverse("catalog:author-books", kwargs={"slug": self.slug})


class Book(models.Model):
    title = models.CharField(max_length=200)
    slug = models.SlugField(unique=True)
    isbn = models.CharField(max_length=13, unique=True)
    author = models.ForeignKey(Author, on_delete=models.PROTECT, related_name="books")
    price = models.DecimalField(max_digits=6, decimal_places=2)
    published = models.DateField()
    is_published = models.BooleanField(default=True)
    views = models.PositiveIntegerField(default=0)

    class Meta:
        ordering = ["-published", "title"]

    def __str__(self):
        return self.title

    def get_absolute_url(self):
        return reverse("catalog:book-detail", kwargs={"slug": self.slug})


class Review(models.Model):
    book = models.ForeignKey(Book, on_delete=models.CASCADE, related_name="reviews")
    reviewer = models.ForeignKey(settings.AUTH_USER_MODEL, on_delete=models.CASCADE)
    rating = models.PositiveSmallIntegerField(
        validators=[MinValueValidator(1), MaxValueValidator(5)]
    )
    body = models.TextField(blank=True)
    created = models.DateTimeField(auto_now_add=True)

    class Meta:
        ordering = ["-created"]
        constraints = [
            models.UniqueConstraint(
                fields=["book", "reviewer"], name="one_review_per_reader_and_book"
            )
        ]

    def __str__(self):
        return f"{self.book} ({self.rating}/5)"

    def get_absolute_url(self):
        return reverse("catalog:book-detail", kwargs={"slug": self.book.slug})

from django import forms
from django.core.exceptions import ValidationError
from django.core.mail import send_mail

from .models import Review


class SuggestionForm(forms.Form):
    title = forms.CharField(max_length=200)
    author_name = forms.CharField(max_length=200)
    reason = forms.CharField(widget=forms.Textarea, required=False)

    def send_email(self, suggested_by):
        send_mail(
            subject=f"Book suggestion: {self.cleaned_data['title']}",
            message=(
                f"{suggested_by} suggests {self.cleaned_data['title']} "
                f"by {self.cleaned_data['author_name']}.\n\n"
                f"{self.cleaned_data['reason']}"
            ),
            from_email=None,  # DEFAULT_FROM_EMAIL
            recipient_list=["curators@example.com"],
        )


class ReviewForm(forms.ModelForm):
    class Meta:
        model = Review
        fields = ["rating", "body"]
        widgets = {"body": forms.Textarea(attrs={"rows": 4})}

    def __init__(self, *args, book, reviewer, **kwargs):
        super().__init__(*args, **kwargs)
        self.book = book
        self.reviewer = reviewer

    def clean(self):
        cleaned_data = super().clean()
        duplicates = Review.objects.filter(
            book=self.book, reviewer=self.reviewer
        ).exclude(pk=self.instance.pk)
        if duplicates.exists():
            raise ValidationError("You have already reviewed this book.")
        return cleaned_data


class ConfirmDeleteForm(forms.Form):
    confirm = forms.BooleanField(label="Yes, delete this review")

from django.urls import path
from django.views.generic import TemplateView

from . import views

app_name = "catalog"

urlpatterns = [
    # display views
    path("", views.BookListView.as_view(), name="book-list"),
    path("authors/<slug:slug>/", views.AuthorBookListView.as_view(), name="author-books"),
    path("books.json", views.BookJsonListView.as_view(), name="book-json"),
    path("flexible/", views.FlexibleBookListView.as_view(), name="flexible-list"),
    # editing views
    path("suggest/", views.SuggestBookView.as_view(), name="suggest"),
    path(
        "suggest/thanks/",
        TemplateView.as_view(template_name="catalog/suggest_thanks.html"),
        name="suggest-thanks",
    ),
    path("books/add/", views.BookCreateView.as_view(), name="book-add"),
    path("books/<slug:slug>/", views.BookDetailView.as_view(), name="book-detail"),
    path("books/<slug:slug>/review/", views.ReviewCreateView.as_view(), name="review-add"),
    path("my-reviews/", views.MyReviewListView.as_view(), name="my-reviews"),
    path("my-reviews/<int:pk>/edit/", views.ReviewUpdateView.as_view(), name="review-edit"),
    path(
        "my-reviews/<int:pk>/delete/", views.ReviewDeleteView.as_view(), name="review-delete"
    ),
    # date-based views
    path("archive/", views.BookArchiveIndexView.as_view(), name="archive"),
    path("archive/today/", views.BookTodayArchiveView.as_view(), name="archive-today"),
    path("archive/<int:year>/", views.BookYearArchiveView.as_view(), name="archive-year"),
    path(
        "archive/<int:year>/<int:month>/",
        views.BookMonthArchiveView.as_view(),
        name="archive-month",
    ),
    path(
        "archive/<int:year>/week/<int:week>/",
        views.BookWeekArchiveView.as_view(),
        name="archive-week",
    ),
    path(
        "archive/<int:year>/<int:month>/<int:day>/",
        views.BookDayArchiveView.as_view(),
        name="archive-day",
    ),
    path(
        "archive/<int:year>/<int:month>/<int:day>/<slug:slug>/",
        views.BookDateDetailView.as_view(),
        name="archive-detail",
    ),
    # async variants of the display views
    path("async/books/", views.AsyncBookListView.as_view(), name="async-book-list"),
    path("async/protected/", views.ProtectedAsyncBookListView.as_view(), name="async-protected"),
    path("async/books/<slug:slug>/", views.AsyncBookDetailView.as_view(), name="async-book-detail"),
]

<!doctype html>
<html lang="en">
<head><meta charset="utf-8"><title>{% block title %}Bookshelf{% endblock %}</title></head>
<body>
<nav><a href="{% url 'catalog:book-list' %}">Books</a> | <a href="{% url 'catalog:archive' %}">Archive</a></nav>
{% for message in messages %}<p class="message">{{ message }}</p>{% endfor %}
{% block content %}{% endblock %}
</body>
</html>

class BookListView(ListView):
    model = Book

class BookListView(ListView):
    queryset = PUBLISHED  # a class attribute: get_queryset() clones it for every request
    paginate_by = 3
    context_object_name = "books"  # in addition to the default object_list

    def get_queryset(self):
        queryset = super().get_queryset()
        q = self.request.GET.get("q", "").strip()
        if q:
            queryset = queryset.filter(
                Q(title__icontains=q) | Q(author__name__icontains=q)
            )
        return queryset

    def get_context_data(self, **kwargs):
        context = super().get_context_data(**kwargs)
        context["q"] = self.request.GET.get("q", "").strip()
        return context

{% extends "catalog/base.html" %}
{% block content %}
<h1>Books</h1>
<form method="get"><input name="q" value="{{ q }}"><button>Search</button></form>
<ul>
  {% for book in books %}
    <li><a href="{{ book.get_absolute_url }}">{{ book.title }}</a> by {{ book.author }} ({{ book.published|date:"Y-m-d" }})</li>
  {% empty %}
    <li>No books found.</li>
  {% endfor %}
</ul>
{% include "catalog/pagination.html" %}
{% endblock %}

{% if is_paginated %}
<p class="pager">
  {% if page_obj.has_previous %}<a href="{% querystring page=page_obj.previous_page_number %}">previous</a>{% endif %}
  Page {{ page_obj.number }} of {{ paginator.num_pages }}
  {% if page_obj.has_next %}<a href="{% querystring page=page_obj.next_page_number %}">next</a>{% endif %}
</p>
{% endif %}

class OwnReviewsMixin(LoginRequiredMixin):
    """Restrict every lookup to the reviews written by the current user."""

    def get_queryset(self):
        return super().get_queryset().filter(reviewer=self.request.user)


class MyReviewListView(OwnReviewsMixin, ListView):
    model = Review
    context_object_name = "reviews"
    paginate_by = 10

    def get_queryset(self):
        return super().get_queryset().select_related("book__author")


class ReviewUpdateView(OwnReviewsMixin, SuccessMessageMixin, UpdateView):
    model = Review
    form_class = ReviewForm
    success_message = "Your review was updated."

    def get_form_kwargs(self):
        kwargs = super().get_form_kwargs()
        kwargs.update(book=self.object.book, reviewer=self.request.user)
        return kwargs


class ReviewDeleteView(OwnReviewsMixin, SuccessMessageMixin, DeleteView):
    model = Review
    form_class = ConfirmDeleteForm
    success_url = reverse_lazy("catalog:my-reviews")
    success_message = "Your review was deleted."

{% extends "catalog/base.html" %}
{% block content %}
<h1>My reviews</h1>
<ul>
  {% for review in reviews %}
    <li>{{ review.book }}: {{ review.rating }}/5
      <a href="{% url 'catalog:review-edit' review.pk %}">edit</a>
      <a href="{% url 'catalog:review-delete' review.pk %}">delete</a></li>
  {% empty %}<li>You have not written any reviews.</li>{% endfor %}
</ul>
{% include "catalog/pagination.html" %}
{% endblock %}

class OwnerScopingTests(BookshelfTestCase):
    def test_list_shows_only_my_reviews(self):
        self.client.force_login(self.alice)
        response = self.client.get(reverse("catalog:my-reviews"))
        self.assertEqual(list(response.context["reviews"]), [self.review_a])

    def test_other_users_review_is_404_for_update_and_delete(self):
        self.client.force_login(self.bob)
        for name in ("catalog:review-edit", "catalog:review-delete"):
            url = reverse(name, kwargs={"pk": self.review_a.pk})
            self.assertEqual(self.client.get(url).status_code, 404, name)
            self.assertEqual(self.client.post(url, {"rating": 1, "confirm": "on"}).status_code, 404, name)
        self.review_a.refresh_from_db()
        self.assertEqual(self.review_a.rating, 5)

    def test_update_own_review(self):
        self.client.force_login(self.alice)
        url = reverse("catalog:review-edit", kwargs={"pk": self.review_a.pk})
        response = self.client.post(url, {"rating": 2, "body": "Changed my mind"}, follow=True)
        self.review_a.refresh_from_db()
        self.assertEqual((self.review_a.rating, self.review_a.body), (2, "Changed my mind"))
        self.assertContains(response, "Your review was updated.")

    def test_delete_needs_the_confirmation_checkbox(self):
        self.client.force_login(self.alice)
        url = reverse("catalog:review-delete", kwargs={"pk": self.review_a.pk})
        self.assertContains(self.client.get(url), "Yes, delete this review")
        self.client.post(url, {})  # checkbox missing: form invalid, nothing deleted
        self.assertTrue(Review.objects.filter(pk=self.review_a.pk).exists())
        response = self.client.post(url, {"confirm": "on"}, follow=True)
        self.assertFalse(Review.objects.filter(pk=self.review_a.pk).exists())
        self.assertRedirects(response, reverse("catalog:my-reviews"))
        self.assertContains(response, "Your review was deleted.")

    def test_anonymous_never_reaches_get_queryset(self):
        url = reverse("catalog:review-delete", kwargs={"pk": self.review_a.pk})
        self.assertEqual(self.client.post(url, {"confirm": "on"}).status_code, 302)
        self.assertTrue(Review.objects.filter(pk=self.review_a.pk).exists())

class BookArchiveIndexView(ArchiveIndexView):
    queryset = PUBLISHED
    date_field = "published"
    date_list_period = "year"  # the default; "month" and "day" are the alternatives
    paginate_by = 5


class BookYearArchiveView(YearArchiveView):
    queryset = PUBLISHED
    date_field = "published"
    make_object_list = True  # also put the year's books in object_list


class BookMonthArchiveView(MonthArchiveView):
    queryset = PUBLISHED
    date_field = "published"
    month_format = "%m"  # URL captures 05, not "may"


class BookWeekArchiveView(WeekArchiveView):
    queryset = PUBLISHED
    date_field = "published"
    week_format = "%V"  # ISO 8601 week number...
    year_format = "%G"  # ...which requires the ISO year


class BookDayArchiveView(DayArchiveView):
    queryset = PUBLISHED
    date_field = "published"
    month_format = "%m"


class BookTodayArchiveView(TodayArchiveView):
    queryset = PUBLISHED
    date_field = "published"


class BookDateDetailView(DateDetailView):
    queryset = PUBLISHED
    date_field = "published"
    month_format = "%m"

{% extends "catalog/base.html" %}
{% block content %}
<h1>Latest books</h1>
<ul>{% for year in date_list %}<li><a href="{% url 'catalog:archive-year' year.year %}">{{ year.year }}</a></li>{% endfor %}</ul>
<ul>{% for book in latest %}<li>{{ book.published|date:"Y-m-d" }}: {{ book.title }}</li>{% endfor %}</ul>
{% include "catalog/pagination.html" %}
{% endblock %}

{% extends "catalog/base.html" %}
{% block content %}
<h1>Books of {{ year|date:"Y" }}</h1>
<ul>{% for month in date_list %}<li><a href="{% url 'catalog:archive-month' month.year month.month %}">{{ month|date:"F" }}</a></li>{% endfor %}</ul>
<ul>{% for book in object_list %}<li>{{ book.published|date:"Y-m-d" }}: {{ book.title }}</li>{% endfor %}</ul>
<p>
  {% if previous_year %}<a href="{% url 'catalog:archive-year' previous_year.year %}">{{ previous_year|date:"Y" }}</a>{% endif %}
  {% if next_year %}<a href="{% url 'catalog:archive-year' next_year.year %}">{{ next_year|date:"Y" }}</a>{% endif %}
</p>
{% endblock %}

{% extends "catalog/base.html" %}
{% block content %}
<h1>Books of {{ month|date:"F Y" }}</h1>
<ul>{% for day in date_list %}<li><a href="{% url 'catalog:archive-day' day.year day.month day.day %}">{{ day|date:"j" }}</a></li>{% endfor %}</ul>
<ul>{% for book in object_list %}<li>{{ book.published|date:"Y-m-d" }}: {{ book.title }}</li>{% endfor %}</ul>
<p>
  {% if previous_month %}Previous: {{ previous_month|date:"F Y" }}{% endif %}
  {% if next_month %}Next: {{ next_month|date:"F Y" }}{% endif %}
</p>
{% endblock %}

{% extends "catalog/base.html" %}
{% block content %}
<h1>Week starting {{ week|date:"Y-m-d" }}</h1>
<ul>{% for book in object_list %}<li>{{ book.published|date:"Y-m-d" }}: {{ book.title }}</li>{% endfor %}</ul>
<p>
  {% if previous_week %}Previous week starts {{ previous_week|date:"Y-m-d" }}{% endif %}
  {% if next_week %}Next week starts {{ next_week|date:"Y-m-d" }}{% endif %}
</p>
{% endblock %}

{% extends "catalog/base.html" %}
{% block content %}
<h1>{{ day|date:"Y-m-d" }}</h1>
<ul>{% for book in object_list %}<li><a href="{% url 'catalog:archive-detail' book.published.year book.published.month book.published.day book.slug %}">{{ book.title }}</a></li>{% endfor %}</ul>
<p>
  {% if previous_day %}Previous: {{ previous_day|date:"Y-m-d" }}{% endif %}
  {% if next_day %}Next: {{ next_day|date:"Y-m-d" }}{% endif %}
</p>
{% endblock %}

class AsyncBookListView(ListView):
    queryset = PUBLISHED
    context_object_name = "books"
    template_name = "catalog/book_list.html"

    async def get(self, request, *args, **kwargs):
        # Evaluate the queryset asynchronously; template rendering is done later by the
        # handler (in a worker thread), so the template can still touch the ORM.
        self.object_list = [book async for book in self.get_queryset()]
        return self.render_to_response(self.get_context_data())


class AsyncBookDetailView(DetailView):
    queryset = PUBLISHED

    async def get(self, request, *args, **kwargs):
        self.object = await aget_object_or_404(self.get_queryset(), slug=kwargs["slug"])
        return self.render_to_response(self.get_context_data(object=self.object))

class PaginatingAsyncList(ListView):
    model = Book
    paginate_by = 3

    async def get(self, request, *args, **kwargs):
        self.object_list = self.get_queryset()
        self.paginate_queryset(self.object_list, 3)  # runs COUNT(*) synchronously
        return None


class SyncLookupAsyncDetail(DetailView):
    model = Book

    async def get(self, request, *args, **kwargs):
        self.get_object()  # runs a SELECT synchronously
        return None

PaginatingAsyncList: SynchronousOnlyOperation: You cannot call this from an async context - use a thread or sync_to_async.
SyncLookupAsyncDetail: SynchronousOnlyOperation: You cannot call this from an async context - use a thread or sync_to_async.

from django.contrib.auth.mixins import LoginRequiredMixin
from django.urls import path

from catalog.views import AsyncBookListView


class ProtectedAsyncList(LoginRequiredMixin, AsyncBookListView):
    pass


urlpatterns = [path("protected/", ProtectedAsyncList.as_view())]

import asyncio

from django.contrib.auth import get_user_model
from django.test import AsyncClient, override_settings


async def attempt(label, client):
    try:
        response = await client.get("/protected/")
        print(f"{label}: HTTP {response.status_code}")
    except Exception as exc:
        print(f"{label}: {type(exc).__name__}: {exc}")


async def main():
    client = AsyncClient(raise_request_exception=True)
    with override_settings(ROOT_URLCONF="ex.urls_async", ALLOWED_HOSTS=["*"]):
        await attempt("anonymous", client)
        await client.aforce_login(await get_user_model().objects.aget(username="alice"))
        await attempt("logged in", client)


asyncio.run(main())

anonymous: TypeError: object HttpResponseRedirect can't be used in 'await' expression
logged in: SynchronousOnlyOperation: You cannot call this from an async context - use a thread or sync_to_async.

class AsyncLoginRequiredMixin:
    """LoginRequiredMixin is sync-only; this is the async-handler equivalent."""

    async def dispatch(self, request, *args, **kwargs):
        user = await request.auser()  # request.user would hit the database synchronously
        if not user.is_authenticated:
            return redirect_to_login(request.get_full_path())
        return await super().dispatch(request, *args, **kwargs)


class ProtectedAsyncBookListView(AsyncLoginRequiredMixin, AsyncBookListView):
    pass

class AsyncViewTests(BookshelfTestCase):
    async def test_async_list_and_detail(self):
        response = await self.async_client.get(reverse("catalog:async-book-list"))
        self.assertEqual(response.status_code, 200)
        self.assertContains(response, "Alpha")
        detail = await self.async_client.get(reverse("catalog:async-book-detail", kwargs={"slug": "alpha"}))
        self.assertContains(detail, "Average rating")
        missing = await self.async_client.get(reverse("catalog:async-book-detail", kwargs={"slug": "nope"}))
        self.assertEqual(missing.status_code, 404)

    async def test_async_login_check_with_auser(self):
        url = reverse("catalog:async-protected")
        anonymous = await self.async_client.get(url)
        self.assertEqual(anonymous.status_code, 302)
        self.assertEqual(anonymous["Location"], "/accounts/login/?next=/catalog/async/protected/")
        await self.async_client.aforce_login(self.alice)
        self.assertEqual((await self.async_client.get(url)).status_code, 200)

    def test_generic_views_are_sync_and_mixing_sync_and_async_handlers_fails(self):
        from django.core.exceptions import ImproperlyConfigured
        from django.views.generic import CreateView, ListView

        from .views import AsyncBookListView, BookListView

        self.assertFalse(BookListView.view_is_async)
        self.assertTrue(AsyncBookListView.view_is_async)

        class Mixed(CreateView):
            model = Author
            fields = ["name"]

            async def get(self, request, *args, **kwargs):  # post() stays sync
                ...

        with self.assertRaises(ImproperlyConfigured):
            Mixed.as_view()

Found 38 test(s).
test_async_login_check_with_auser ... ok
test_generic_views_are_sync_and_mixing_sync_and_async_handlers_fails ... ok
test_archive_index_lists_years_and_latest_without_future_or_hidden ... ok
test_date_detail_matches_date_and_slug ... ok
test_date_list_period_changes_the_granularity ... ok
test_empty_period_is_404_because_allow_empty_is_false ... ok
test_future_is_hidden_unless_allow_future ... ok
test_invalid_date_is_404 ... ok
test_iso_week_format_needs_the_iso_year_format ... ok
test_today_view_template_and_content ... ok
test_year_month_day_week ... ok
test_detail_404_for_unpublished ... ok
test_detail_by_slug_counts_views ... ok
test_dynamic_filtering_from_url ... ok
test_list_is_paginated_and_hides_unpublished ... ok
test_page_last_and_bad_page ... ok
test_search_filters_by_title_or_author ... ok
test_anonymous_is_redirected_to_login ... ok
test_create_review_sets_reviewer_and_book ... ok
test_duplicate_review_is_a_form_error_not_a_500 ... ok
test_json_negotiation ... ok
test_permission_required_distinguishes_anonymous_and_denied ... ok
test_posted_reviewer_field_is_ignored ... ok
test_rating_range_comes_from_the_model ... ok
test_invalid_post_redisplays_form_with_errors ... ok
test_login_required_then_valid_post_sends_mail_and_redirects ... ok
test_anonymous_never_reaches_get_queryset ... ok
test_delete_needs_the_confirmation_checkbox ... ok
test_list_shows_only_my_reviews ... ok
test_other_users_review_is_404_for_update_and_delete ... ok
test_update_own_review ... ok
test_head_and_options ... ok
test_http_delete_skips_the_confirmation_form_but_not_the_scoping ... ok
test_list_mixin_reused_without_templates ... ok
test_per_page_is_clamped ... ok
test_restricting_http_method_names_rejects_delete ... ok
test_paginating_an_unordered_queryset_warns ... ok
Ran 38 tests in 1.970s
OK
System check identified no issues (0 silenced).

B=http://127.0.0.1:8124/catalog
curl -s "$B/" | grep '<li>' | sed 's/^ *//'
curl -s -o /dev/null -w "page=99 %{http_code}\n" "$B/?page=99"
curl -s "$B/books/alpha/" | grep "<h1>\|Average"
curl -s -o /dev/null -w "unknown book %{http_code}\n" "$B/books/nope/"
curl -s "$B/archive/2024/" | grep '<h1>\|<li>'
curl -s -o /dev/null -w "archive/2020 %{http_code}\n" "$B/archive/2020/"
curl -s "$B/archive/2024/week/2/" | grep '<h1>\|<li>'
curl -s -D - -o /dev/null -X OPTIONS "$B/" | grep -i '^allow'
curl -s -D - -o /dev/null "$B/my-reviews/" | grep -i '^location'
curl -s "$B/books.json?page=2"

<li><a href="/catalog/books/golf/">Golf</a> by Ada Writer (2025-12-31)</li>
<li><a href="/catalog/books/foxtrot/">Foxtrot</a> by Bo Novelist (2025-03-04)</li>
<li><a href="/catalog/books/echo/">Echo</a> by Ada Writer (2025-03-03)</li>
page=99 404
<h1>Alpha</h1>
<p>Average rating: 5.0</p>
unknown book 404
<h1>Books of 2024</h1>
<ul><li><a href="/catalog/archive/2024/1/">January</a></li><li><a href="/catalog/archive/2024/5/">May</a></li></ul>
<ul><li>2024-05-21: Delta</li><li>2024-05-20: Charlie</li><li>2024-01-11: Bravo</li><li>2024-01-10: Alpha</li></ul>
archive/2020 404
<h1>Week starting 2024-01-08</h1>
<ul><li>2024-01-11: Bravo</li><li>2024-01-10: Alpha</li></ul>
Allow: GET, HEAD, OPTIONS
Location: /accounts/login/?next=/catalog/my-reviews/
{"page": 2, "pages": 3, "results": [{"title": "Delta", "author": "Bo Novelist"}, {"title": "Charlie", "author": "Bo Novelist"}, {"title": "Bravo", "author": "Ada Writer"}]}

class UnorderedWarningTests(BookshelfTestCase):
    def test_paginating_an_unordered_queryset_warns(self):
        from django.views.generic import ListView

        class AuthorList(ListView):
            model = Author
            paginate_by = 1
            template_name = "catalog/author_books.html"

        request = self.client.get("/").wsgi_request
        with warnings.catch_warnings(record=True) as caught:
            warnings.simplefilter("always")
            view = AuthorList()
            view.setup(request)
            view.object_list = view.get_queryset()
            view.get_context_data()
        self.assertTrue(any(issubclass(w.category, UnorderedObjectListWarning) for w in caught))

attempt("CreateView without fields", CreateView.as_view(model=Author), rf.get("/"))
attempt("fields and form_class", CreateView.as_view(model=Author, fields=["name"], form_class=ReviewForm), rf.get("/"))
attempt("FormView without success_url",
        FormView.as_view(form_class=SuggestionForm, template_name="catalog/suggestion_form.html"),
        rf.post("/", {"title": "Dune", "author_name": "F. Herbert"}))
attempt("ListView without model, queryset or get_queryset", ListView.as_view(), rf.get("/"))
attempt("DetailView without pk or slug in the URL", DetailView.as_view(model=Book), rf.get("/"))
attempt("FormView without template_name", FormView.as_view(form_class=SuggestionForm), rf.get("/"))
attempt("ListView allow_empty=False on an empty queryset",
        ListView.as_view(queryset=Book.objects.none(), allow_empty=False, template_name="catalog/book_list.html"), rf.get("/"))
print("template names:")
print("  ListView   ", ListView(model=Book, object_list=Book.objects.all()).get_template_names())
print("  CreateView ", CreateView(model=Book, object=None).get_template_names())
print("  DeleteView ", DeleteView(model=Book, object=Book()).get_template_names())
print("  UpdateView suffix override:", UpdateView(model=Book, object=Book(), template_name_suffix="_edit").get_template_names())

CreateView without fields: ImproperlyConfigured: Using ModelFormMixin (base class of CreateView) without the 'fields' attribute is prohibited.
fields and form_class: ImproperlyConfigured: Specifying both 'fields' and 'form_class' is not permitted.
FormView without success_url: ImproperlyConfigured: No URL to redirect to. Provide a success_url.
ListView without model, queryset or get_queryset: ImproperlyConfigured: ListView is missing a QuerySet. Define ListView.model, ListView.queryset, or override ListView.get_queryset().
DetailView without pk or slug in the URL: AttributeError: Generic detail view DetailView must be called with either an object pk or a slug in the URLconf.
FormView without template_name: ImproperlyConfigured: TemplateResponseMixin requires either a definition of 'template_name' or an implementation of 'get_template_names()'
ListView allow_empty=False on an empty queryset: Http404: Empty list and “ListView.allow_empty” is False.
template names:
  ListView    ['catalog/book_list.html']
  CreateView  ['catalog/book_form.html']
  DeleteView  ['catalog/book_confirm_delete.html']
  UpdateView suffix override: ['catalog/book_edit.html']