',
152 | output,
153 | )
154 | output = re.sub(r"", r'', output)
155 | output = re.sub(r'', code_label, output)
156 | with open(output_path, "w") as fp:
157 | fp.write(output)
158 |
159 | if preview:
160 | webbrowser.open_new_tab("html/index.html")
161 |
--------------------------------------------------------------------------------
/pyproject.toml:
--------------------------------------------------------------------------------
1 | [build-system]
2 | requires = ["setuptools >= 40.6.0", "wheel"]
3 | build-backend = "setuptools.build_meta"
4 |
5 | [tool.black]
6 | target-version = ['py36']
7 |
8 | [tool.isort]
9 | profile = "black"
10 |
--------------------------------------------------------------------------------
/setup.cfg:
--------------------------------------------------------------------------------
1 | [flake8]
2 | max-line-length = 80
3 | select = E,F,W,B,B950,C,I
4 | ignore = E203,E501,W503
5 |
--------------------------------------------------------------------------------
/setup.py:
--------------------------------------------------------------------------------
1 | #!/usr/bin/env python
2 | import os
3 | import re
4 | import sys
5 |
6 | from setuptools import setup
7 |
8 | name = "django-vanilla-views"
9 | package = "vanilla"
10 | description = "Beautifully simple class based views."
11 | url = "http://django-vanilla-views.org"
12 | author = "Tom Christie"
13 | author_email = "tom@tomchristie.com"
14 | license = "BSD"
15 |
16 | with open("README.md", "r") as fp:
17 | long_description = fp.read()
18 |
19 |
20 | def get_version(package):
21 | """
22 | Return package version as listed in `__version__` in `init.py`.
23 | """
24 | init_py = open(os.path.join(package, "__init__.py")).read()
25 | return re.search(
26 | r"^__version__ = ['\"]([^'\"]+)['\"]",
27 | init_py,
28 | re.MULTILINE,
29 | ).group(1)
30 |
31 |
32 | def get_packages(package):
33 | """
34 | Return root package and all sub-packages.
35 | """
36 | return [
37 | dirpath
38 | for dirpath, dirnames, filenames in os.walk(package)
39 | if os.path.exists(os.path.join(dirpath, "__init__.py"))
40 | ]
41 |
42 |
43 | def get_package_data(package):
44 | """
45 | Return all files under the root package, that are not in a
46 | package themselves.
47 | """
48 | walk = [
49 | (dirpath.replace(package + os.sep, "", 1), filenames)
50 | for dirpath, dirnames, filenames in os.walk(package)
51 | if not os.path.exists(os.path.join(dirpath, "__init__.py"))
52 | ]
53 |
54 | filepaths = []
55 | for base, filenames in walk:
56 | filepaths.extend([os.path.join(base, filename) for filename in filenames])
57 | return {package: filepaths}
58 |
59 |
60 | if sys.argv[-1] == "publish":
61 | os.system("python setup.py sdist bdist_wheel upload")
62 | args = {"version": get_version(package)}
63 | print("You probably want to also tag the version now:")
64 | print(" git tag -a %(version)s -m 'version %(version)s'" % args)
65 | print(" git push --tags")
66 | sys.exit()
67 |
68 |
69 | setup(
70 | name=name,
71 | version=get_version(package),
72 | url=url,
73 | license=license,
74 | description=description,
75 | long_description=long_description,
76 | long_description_content_type="text/markdown",
77 | author=author,
78 | author_email=author_email,
79 | license_file="LICENSE",
80 | packages=get_packages(package),
81 | package_data=get_package_data(package),
82 | project_urls={
83 | "Changelog": "http://django-vanilla-views.org/topics/release-notes",
84 | "Repository": "https://github.com/tomchristie/django-vanilla-views/",
85 | },
86 | python_requires=">=3.6",
87 | install_requires=[],
88 | classifiers=[
89 | "Development Status :: 5 - Production/Stable",
90 | "Environment :: Web Environment",
91 | "Framework :: Django",
92 | "Framework :: Django :: 2.2",
93 | "Framework :: Django :: 3.0",
94 | "Framework :: Django :: 3.1",
95 | "Framework :: Django :: 3.2",
96 | "Intended Audience :: Developers",
97 | "License :: OSI Approved :: BSD License",
98 | "Operating System :: OS Independent",
99 | "Programming Language :: Python",
100 | "Programming Language :: Python :: 3",
101 | "Topic :: Internet :: WWW/HTTP",
102 | ],
103 | )
104 |
--------------------------------------------------------------------------------
/testsettings.py:
--------------------------------------------------------------------------------
1 | import django
2 |
3 | DATABASES = {
4 | "default": {
5 | "ENGINE": "django.db.backends.sqlite3",
6 | "NAME": ":memory:",
7 | },
8 | }
9 |
10 | INSTALLED_APPS = ("vanilla",)
11 |
12 | if django.VERSION >= (1, 10):
13 | MIDDLEWARE = [
14 | "django.middleware.common.CommonMiddleware",
15 | "django.middleware.csrf.CsrfViewMiddleware",
16 | ]
17 | else:
18 | MIDDLEWARE_CLASSES = [
19 | "django.middleware.common.CommonMiddleware",
20 | "django.middleware.csrf.CsrfViewMiddleware",
21 | ]
22 |
23 | SECRET_KEY = "abcde12345"
24 |
25 | if django.VERSION >= (3, 2):
26 | DEFAULT_AUTO_FIELD = "django.db.models.AutoField"
27 |
--------------------------------------------------------------------------------
/tox.ini:
--------------------------------------------------------------------------------
1 | [tox]
2 | isolated_build = True
3 | envlist =
4 | py36-django{22,30,31,32}
5 | py37-django{22,30,31,32}
6 | py38-django{30,31,32}
7 | py39-django{30,31,32}
8 |
9 | [testenv]
10 | commands = python -W error::DeprecationWarning -W error::PendingDeprecationWarning manage.py test
11 | deps =
12 | django22: django>=2.2,<3.0
13 | django30: django>=3.0,<3.1
14 | django31: django>=3.1,<3.2
15 | django32: django>=3.2,<4.0
16 |
--------------------------------------------------------------------------------
/vanilla/__init__.py:
--------------------------------------------------------------------------------
1 | from django.views.generic import RedirectView, View
2 |
3 | from vanilla.model_views import (
4 | CreateView,
5 | DeleteView,
6 | DetailView,
7 | GenericModelView,
8 | ListView,
9 | UpdateView,
10 | )
11 | from vanilla.views import FormView, GenericView, TemplateView
12 |
13 | __version__ = "3.0.0"
14 | __all__ = (
15 | "View",
16 | "GenericView",
17 | "GenericModelView",
18 | "RedirectView",
19 | "TemplateView",
20 | "FormView",
21 | "ListView",
22 | "DetailView",
23 | "CreateView",
24 | "UpdateView",
25 | "DeleteView",
26 | )
27 |
--------------------------------------------------------------------------------
/vanilla/model_views.py:
--------------------------------------------------------------------------------
1 | import django
2 | from django.core.exceptions import ImproperlyConfigured
3 | from django.core.paginator import InvalidPage, Paginator
4 | from django.forms import models as model_forms
5 | from django.http import Http404, HttpResponseRedirect
6 | from django.shortcuts import get_object_or_404
7 | from django.template.response import TemplateResponse
8 | from django.views.generic import View
9 |
10 | # Avoid RemovedInDjango40Warning on Django 3.0+
11 | if django.VERSION >= (3, 0):
12 | from django.utils.translation import gettext as _
13 | else:
14 | from django.utils.translation import ugettext as _
15 |
16 |
17 | class GenericModelView(View):
18 | """
19 | Base class for all model generic views.
20 | """
21 |
22 | model = None
23 | fields = None
24 |
25 | # Object lookup parameters. These are used in the URL kwargs, and when
26 | # performing the model instance lookup.
27 | # Note that if unset then `lookup_url_kwarg` defaults to using the same
28 | # value as `lookup_field`.
29 | lookup_field = "pk"
30 | lookup_url_kwarg = None
31 |
32 | # All the following are optional, and fall back to default values
33 | # based on the 'model' shortcut.
34 | # Each of these has a corresponding `.get_()` method.
35 | queryset = None
36 | form_class = None
37 | template_name = None
38 | context_object_name = None
39 |
40 | # Pagination parameters.
41 | # Set `paginate_by` to an integer value to turn pagination on.
42 | paginate_by = None
43 | page_kwarg = "page"
44 |
45 | # Suffix that should be appended to automatically generated template names.
46 | template_name_suffix = None
47 |
48 | # Queryset and object lookup
49 |
50 | def get_object(self):
51 | """
52 | Returns the object the view is displaying.
53 | """
54 | queryset = self.get_queryset()
55 | lookup_url_kwarg = self.lookup_url_kwarg or self.lookup_field
56 |
57 | try:
58 | lookup = {self.lookup_field: self.kwargs[lookup_url_kwarg]}
59 | except KeyError:
60 | msg = "Lookup field '%s' was not provided in view kwargs to '%s'"
61 | raise ImproperlyConfigured(
62 | msg % (lookup_url_kwarg, self.__class__.__name__)
63 | )
64 |
65 | return get_object_or_404(queryset, **lookup)
66 |
67 | def get_queryset(self):
68 | """
69 | Returns the base queryset for the view.
70 |
71 | Either used as a list of objects to display, or as the queryset
72 | from which to perform the individual object lookup.
73 | """
74 | if self.queryset is not None:
75 | return self.queryset._clone()
76 |
77 | if self.model is not None:
78 | return self.model._default_manager.all()
79 |
80 | msg = (
81 | "'%s' must either define 'queryset' or 'model', or override "
82 | + "'get_queryset()'"
83 | )
84 | raise ImproperlyConfigured(msg % self.__class__.__name__)
85 |
86 | # Form instantiation
87 |
88 | def get_form_class(self):
89 | """
90 | Returns the form class to use in this view.
91 | """
92 | if self.form_class is not None:
93 | return self.form_class
94 |
95 | if self.model is not None and self.fields is not None:
96 | return model_forms.modelform_factory(self.model, fields=self.fields)
97 |
98 | msg = (
99 | "'%s' must either define 'form_class' or both 'model' and "
100 | "'fields', or override 'get_form_class()'"
101 | )
102 | raise ImproperlyConfigured(msg % self.__class__.__name__)
103 |
104 | def get_form(self, data=None, files=None, **kwargs):
105 | """
106 | Returns a form instance.
107 | """
108 | cls = self.get_form_class()
109 | return cls(data=data, files=files, **kwargs)
110 |
111 | # Pagination
112 |
113 | def get_paginate_by(self):
114 | """
115 | Returns the size of pages to use with pagination.
116 | """
117 | return self.paginate_by
118 |
119 | def get_paginator(self, queryset, page_size):
120 | """
121 | Returns a paginator instance.
122 | """
123 | return Paginator(queryset, page_size)
124 |
125 | def paginate_queryset(self, queryset, page_size):
126 | """
127 | Paginates a queryset, and returns a page object.
128 | """
129 | paginator = self.get_paginator(queryset, page_size)
130 | page_kwarg = self.kwargs.get(self.page_kwarg)
131 | page_query_param = self.request.GET.get(self.page_kwarg)
132 | page_number = page_kwarg or page_query_param or 1
133 | try:
134 | page_number = int(page_number)
135 | except ValueError:
136 | if page_number == "last":
137 | page_number = paginator.num_pages
138 | else:
139 | msg = "Page is not 'last', nor can it be converted to an int."
140 | raise Http404(_(msg))
141 |
142 | try:
143 | return paginator.page(page_number)
144 | except InvalidPage as exc:
145 | msg = "Invalid page (%s): %s"
146 | raise Http404(_(msg) % (page_number, str(exc)))
147 |
148 | # Response rendering
149 |
150 | def get_context_object_name(self, is_list=False):
151 | """
152 | Returns a descriptive name to use in the context in addition to the
153 | default 'object'/'object_list'.
154 | """
155 | if self.context_object_name is not None:
156 | return self.context_object_name
157 |
158 | elif self.model is not None:
159 | fmt = "%s_list" if is_list else "%s"
160 | return fmt % self.model._meta.object_name.lower()
161 |
162 | return None
163 |
164 | def get_context_data(self, **kwargs):
165 | """
166 | Returns a dictionary to use as the context of the response.
167 |
168 | Takes a set of keyword arguments to use as the base context,
169 | and adds the following keys:
170 |
171 | * 'view'
172 | * Optionally, 'object' or 'object_list'
173 | * Optionally, '{context_object_name}' or '{context_object_name}_list'
174 | """
175 | kwargs["view"] = self
176 |
177 | if getattr(self, "object", None) is not None:
178 | kwargs["object"] = self.object
179 | context_object_name = self.get_context_object_name()
180 | if context_object_name:
181 | kwargs[context_object_name] = self.object
182 |
183 | if getattr(self, "object_list", None) is not None:
184 | kwargs["object_list"] = self.object_list
185 | context_object_name = self.get_context_object_name(is_list=True)
186 | if context_object_name:
187 | kwargs[context_object_name] = self.object_list
188 |
189 | return kwargs
190 |
191 | def get_template_names(self):
192 | """
193 | Returns a list of template names to use when rendering the response.
194 |
195 | If `.template_name` is not specified, then defaults to the following
196 | pattern: "{app_label}/{model_name}{template_name_suffix}.html"
197 | """
198 | if self.template_name is not None:
199 | return [self.template_name]
200 |
201 | if self.model is not None and self.template_name_suffix is not None:
202 | return [
203 | "%s/%s%s.html"
204 | % (
205 | self.model._meta.app_label,
206 | self.model._meta.object_name.lower(),
207 | self.template_name_suffix,
208 | )
209 | ]
210 |
211 | msg = (
212 | "'%s' must either define 'template_name' or 'model' and "
213 | "'template_name_suffix', or override 'get_template_names()'"
214 | )
215 | raise ImproperlyConfigured(msg % self.__class__.__name__)
216 |
217 | def render_to_response(self, context):
218 | """
219 | Given a context dictionary, returns an HTTP response.
220 | """
221 | return TemplateResponse(
222 | request=self.request, template=self.get_template_names(), context=context
223 | )
224 |
225 |
226 | # The concrete model views
227 |
228 |
229 | class ListView(GenericModelView):
230 | template_name_suffix = "_list"
231 | allow_empty = True
232 |
233 | def get(self, request, *args, **kwargs):
234 | queryset = self.get_queryset()
235 | paginate_by = self.get_paginate_by()
236 |
237 | if not self.allow_empty and not queryset.exists():
238 | raise Http404
239 |
240 | if paginate_by is None:
241 | # Unpaginated response
242 | self.object_list = queryset
243 | context = self.get_context_data(
244 | page_obj=None,
245 | is_paginated=False,
246 | paginator=None,
247 | )
248 | else:
249 | # Paginated response
250 | page = self.paginate_queryset(queryset, paginate_by)
251 | self.object_list = page.object_list
252 | context = self.get_context_data(
253 | page_obj=page,
254 | is_paginated=page.has_other_pages(),
255 | paginator=page.paginator,
256 | )
257 |
258 | return self.render_to_response(context)
259 |
260 |
261 | class DetailView(GenericModelView):
262 | template_name_suffix = "_detail"
263 |
264 | def get(self, request, *args, **kwargs):
265 | self.object = self.get_object()
266 | context = self.get_context_data()
267 | return self.render_to_response(context)
268 |
269 |
270 | class CreateView(GenericModelView):
271 | success_url = None
272 | template_name_suffix = "_form"
273 |
274 | def get(self, request, *args, **kwargs):
275 | form = self.get_form()
276 | context = self.get_context_data(form=form)
277 | return self.render_to_response(context)
278 |
279 | def post(self, request, *args, **kwargs):
280 | form = self.get_form(data=request.POST, files=request.FILES)
281 | if form.is_valid():
282 | return self.form_valid(form)
283 | return self.form_invalid(form)
284 |
285 | def form_valid(self, form):
286 | self.object = form.save()
287 | return HttpResponseRedirect(self.get_success_url())
288 |
289 | def form_invalid(self, form):
290 | context = self.get_context_data(form=form)
291 | return self.render_to_response(context)
292 |
293 | def get_success_url(self):
294 | try:
295 | return self.success_url or self.object.get_absolute_url()
296 | except AttributeError:
297 | msg = (
298 | "No URL to redirect to. '%s' must provide 'success_url' "
299 | "or define a 'get_absolute_url()' method on the Model."
300 | )
301 | raise ImproperlyConfigured(msg % self.__class__.__name__)
302 |
303 |
304 | class UpdateView(GenericModelView):
305 | success_url = None
306 | template_name_suffix = "_form"
307 |
308 | def get(self, request, *args, **kwargs):
309 | self.object = self.get_object()
310 | form = self.get_form(instance=self.object)
311 | context = self.get_context_data(form=form)
312 | return self.render_to_response(context)
313 |
314 | def post(self, request, *args, **kwargs):
315 | self.object = self.get_object()
316 | form = self.get_form(
317 | data=request.POST,
318 | files=request.FILES,
319 | instance=self.object,
320 | )
321 | if form.is_valid():
322 | return self.form_valid(form)
323 | return self.form_invalid(form)
324 |
325 | def form_valid(self, form):
326 | self.object = form.save()
327 | return HttpResponseRedirect(self.get_success_url())
328 |
329 | def form_invalid(self, form):
330 | context = self.get_context_data(form=form)
331 | return self.render_to_response(context)
332 |
333 | def get_success_url(self):
334 | try:
335 | return self.success_url or self.object.get_absolute_url()
336 | except AttributeError:
337 | msg = (
338 | "No URL to redirect to. '%s' must provide 'success_url' "
339 | "or define a 'get_absolute_url()' method on the Model."
340 | )
341 | raise ImproperlyConfigured(msg % self.__class__.__name__)
342 |
343 |
344 | class DeleteView(GenericModelView):
345 | success_url = None
346 | template_name_suffix = "_confirm_delete"
347 |
348 | def get(self, request, *args, **kwargs):
349 | self.object = self.get_object()
350 | context = self.get_context_data()
351 | return self.render_to_response(context)
352 |
353 | def post(self, request, *args, **kwargs):
354 | self.object = self.get_object()
355 | self.object.delete()
356 | return HttpResponseRedirect(self.get_success_url())
357 |
358 | def get_success_url(self):
359 | if self.success_url is None:
360 | msg = "No URL to redirect to. '%s' must define 'success_url'"
361 | raise ImproperlyConfigured(msg % self.__class__.__name__)
362 | return self.success_url
363 |
--------------------------------------------------------------------------------
/vanilla/models.py:
--------------------------------------------------------------------------------
1 | # Just so that 'manage.py test' doesn't complain.
2 |
--------------------------------------------------------------------------------
/vanilla/tests.py:
--------------------------------------------------------------------------------
1 | from django.core.exceptions import ImproperlyConfigured
2 | from django.core.paginator import Page, Paginator
3 | from django.db import models
4 | from django.forms import BaseForm, Form, ModelForm, fields
5 | from django.http import Http404
6 | from django.test import RequestFactory, TestCase
7 |
8 | from vanilla import (
9 | CreateView,
10 | DeleteView,
11 | DetailView,
12 | FormView,
13 | ListView,
14 | TemplateView,
15 | UpdateView,
16 | View,
17 | )
18 |
19 |
20 | class Example(models.Model):
21 | text = models.CharField(max_length=10)
22 |
23 | class Meta:
24 | ordering = ("id",)
25 |
26 |
27 | class ExampleForm(Form):
28 | text = fields.CharField(max_length=10)
29 |
30 |
31 | class InstanceOf(object):
32 | """
33 | We use this sentinel object together with our 'assertContext' helper method.
34 |
35 | Used to ensure that a particular context value is an object of the given
36 | type, without requiring a specific fixed value. Useful for form context,
37 | and other complex instances.
38 | """
39 |
40 | def __init__(self, expected_type):
41 | self.expected_type = expected_type
42 |
43 |
44 | def create_instance(text=None, quantity=1):
45 | for idx in range(quantity):
46 | text = text or ("example %d" % idx)
47 | Example.objects.create(text=text)
48 |
49 |
50 | class BaseTestCase(TestCase):
51 | def setUp(self):
52 | self.factory = RequestFactory()
53 | super(BaseTestCase, self).setUp()
54 |
55 | def assertFormError(self, response, form, field, errors, msg_prefix=""):
56 | # Hack to get around the fact that we're using request factory,
57 | # instead of the full test client.
58 | response.context = response.context_data
59 | return super(BaseTestCase, self).assertFormError(
60 | response, form, field, errors, msg_prefix
61 | )
62 |
63 | def assertContext(self, response, expected):
64 | # Ensure the keys all match.
65 | # Note that this style ensures we get nice descriptive failures.
66 | for key in expected.keys():
67 | self.assertTrue(
68 | key in response.context_data, "context missing key '%s'" % key
69 | )
70 | for key in response.context_data.keys():
71 | self.assertTrue(
72 | key in expected, "context contains unexpected key '%s'" % key
73 | )
74 |
75 | # Ensure all the values match.
76 | for key, val in response.context_data.items():
77 | expected_val = expected[key]
78 | if isinstance(val, (models.query.QuerySet)):
79 | val = list(val)
80 | if isinstance(expected_val, models.query.QuerySet):
81 | expected_val = list(expected_val)
82 |
83 | if isinstance(expected_val, InstanceOf):
84 | self.assertTrue(
85 | isinstance(val, expected_val.expected_type),
86 | "context['%s'] contained type '%s', but expected type '%s'"
87 | % (key, type(val), expected_val.expected_type),
88 | )
89 | else:
90 | self.assertEqual(
91 | val,
92 | expected_val,
93 | "context['%s'] contained '%s', but expected '%s'"
94 | % (key, val, expected_val),
95 | )
96 |
97 | def get(self, view, *args, **kwargs):
98 | request = self.factory.get("/")
99 | return view(request, *args, **kwargs)
100 |
101 | def post(self, view, *args, **kwargs):
102 | data = kwargs.pop("data", {})
103 | request = self.factory.post("/", data=data)
104 | return view(request, *args, **kwargs)
105 |
106 |
107 | class TestDetail(BaseTestCase):
108 | def test_detail(self):
109 | create_instance(quantity=3)
110 | pk = Example.objects.all()[0].pk
111 | view = DetailView.as_view(model=Example)
112 | response = self.get(view, pk=pk)
113 |
114 | self.assertEqual(response.status_code, 200)
115 | self.assertEqual(response.template_name, ["vanilla/example_detail.html"])
116 | self.assertContext(
117 | response,
118 | {
119 | "object": Example.objects.get(pk=pk),
120 | "example": Example.objects.get(pk=pk),
121 | "view": InstanceOf(View),
122 | },
123 | )
124 |
125 | def test_detail_not_found(self):
126 | create_instance(quantity=3)
127 | view = DetailView.as_view(model=Example)
128 | self.assertRaises(Http404, self.get, view, pk=999)
129 |
130 | def test_detail_misconfigured_urlconf(self):
131 | # If we don't provide 'pk' in the URL conf,
132 | # we should expect an ImproperlyConfigured exception.
133 | create_instance(quantity=3)
134 | view = DetailView.as_view(model=Example)
135 | self.assertRaises(ImproperlyConfigured, self.get, view, slug=999)
136 |
137 | def test_detail_misconfigured_template_name(self):
138 | # If don't provide 'model' or 'template_name',
139 | # we should expect an ImproperlyConfigured exception.
140 | create_instance(quantity=3)
141 | pk = Example.objects.all()[0].pk
142 | view = DetailView.as_view(queryset=Example.objects.all())
143 | self.assertRaises(ImproperlyConfigured, self.get, view, pk=pk)
144 |
145 | def test_detail_misconfigured_queryset(self):
146 | # If don't provide 'model' or 'queryset',
147 | # we should expect an ImproperlyConfigured exception.
148 | create_instance(quantity=3)
149 | pk = Example.objects.all()[0].pk
150 | view = DetailView.as_view(template_name="example.html")
151 | self.assertRaises(ImproperlyConfigured, self.get, view, pk=pk)
152 |
153 | def test_detail_missing_context_object_name(self):
154 | # If don't provide 'model' or 'context_object_name',
155 | # then the context will only contain the 'object' key.
156 | create_instance(quantity=3)
157 | pk = Example.objects.all()[0].pk
158 | view = DetailView.as_view(
159 | queryset=Example.objects.all(),
160 | template_name="example.html",
161 | )
162 | response = self.get(view, pk=pk)
163 |
164 | self.assertEqual(response.status_code, 200)
165 | self.assertEqual(response.template_name, ["example.html"])
166 | self.assertContext(
167 | response, {"object": Example.objects.get(pk=pk), "view": InstanceOf(View)}
168 | )
169 |
170 |
171 | class TestList(BaseTestCase):
172 | def test_list(self):
173 | create_instance(quantity=3)
174 | view = ListView.as_view(model=Example)
175 | response = self.get(view)
176 |
177 | self.assertEqual(response.status_code, 200)
178 | self.assertEqual(response.template_name, ["vanilla/example_list.html"])
179 | self.assertContext(
180 | response,
181 | {
182 | "object_list": Example.objects.all(),
183 | "example_list": Example.objects.all(),
184 | "view": InstanceOf(View),
185 | "page_obj": None,
186 | "paginator": None,
187 | "is_paginated": False,
188 | },
189 | )
190 |
191 | def test_empty_list(self):
192 | view = ListView.as_view(model=Example)
193 | response = self.get(view)
194 |
195 | self.assertEqual(response.status_code, 200)
196 | self.assertEqual(response.template_name, ["vanilla/example_list.html"])
197 | self.assertContext(
198 | response,
199 | {
200 | "object_list": [],
201 | "example_list": [],
202 | "view": InstanceOf(View),
203 | "page_obj": None,
204 | "paginator": None,
205 | "is_paginated": False,
206 | },
207 | )
208 |
209 | def test_empty_list_not_found(self):
210 | view = ListView.as_view(model=Example, allow_empty=False)
211 | self.assertRaises(Http404, self.get, view, pk=999)
212 |
213 | def test_paginated_list(self):
214 | create_instance(quantity=30)
215 | view = ListView.as_view(model=Example, paginate_by=10)
216 | response = self.get(view)
217 |
218 | self.assertEqual(response.status_code, 200)
219 | self.assertEqual(response.template_name, ["vanilla/example_list.html"])
220 | self.assertContext(
221 | response,
222 | {
223 | "object_list": Example.objects.all()[:10],
224 | "example_list": Example.objects.all()[:10],
225 | "view": InstanceOf(View),
226 | "page_obj": InstanceOf(Page),
227 | "paginator": InstanceOf(Paginator),
228 | "is_paginated": True,
229 | },
230 | )
231 |
232 | def test_paginated_list_valid_page_specified(self):
233 | create_instance(quantity=30)
234 | view = ListView.as_view(model=Example, paginate_by=10)
235 | response = self.get(view, page=2)
236 |
237 | self.assertEqual(response.status_code, 200)
238 | self.assertEqual(response.template_name, ["vanilla/example_list.html"])
239 | self.assertContext(
240 | response,
241 | {
242 | "object_list": Example.objects.all()[10:20],
243 | "example_list": Example.objects.all()[10:20],
244 | "view": InstanceOf(View),
245 | "page_obj": InstanceOf(Page),
246 | "paginator": InstanceOf(Paginator),
247 | "is_paginated": True,
248 | },
249 | )
250 |
251 | def test_paginated_list_last_page_specified(self):
252 | create_instance(quantity=30)
253 | view = ListView.as_view(model=Example, paginate_by=10)
254 | response = self.get(view, page="last")
255 |
256 | self.assertEqual(response.status_code, 200)
257 | self.assertEqual(response.template_name, ["vanilla/example_list.html"])
258 | self.assertContext(
259 | response,
260 | {
261 | "object_list": Example.objects.all()[20:],
262 | "example_list": Example.objects.all()[20:],
263 | "view": InstanceOf(View),
264 | "page_obj": InstanceOf(Page),
265 | "paginator": InstanceOf(Paginator),
266 | "is_paginated": True,
267 | },
268 | )
269 |
270 | def test_paginated_list_invalid_page_specified(self):
271 | create_instance(quantity=30)
272 | view = ListView.as_view(model=Example, paginate_by=10)
273 | self.assertRaises(Http404, self.get, view, page=999)
274 |
275 | def test_paginated_list_non_integer_page_specified(self):
276 | create_instance(quantity=30)
277 | view = ListView.as_view(model=Example, paginate_by=10)
278 | self.assertRaises(Http404, self.get, view, page="null")
279 |
280 |
281 | class TestCreate(BaseTestCase):
282 | def test_create(self):
283 | view = CreateView.as_view(
284 | model=Example, fields=("text",), success_url="/success/"
285 | )
286 | response = self.post(view, data={"text": "example"})
287 |
288 | self.assertEqual(response.status_code, 302)
289 | self.assertEqual(response["location"], "/success/")
290 | self.assertEqual(Example.objects.count(), 1)
291 | self.assertEqual(Example.objects.get().text, "example")
292 |
293 | def test_create_failed(self):
294 | view = CreateView.as_view(
295 | model=Example,
296 | fields=("text",),
297 | success_url="/success/",
298 | )
299 | response = self.post(view, data={"text": "example" * 100})
300 |
301 | self.assertEqual(response.status_code, 200)
302 | self.assertEqual(response.template_name, ["vanilla/example_form.html"])
303 | self.assertFormError(
304 | response,
305 | "form",
306 | "text",
307 | ["Ensure this value has at most 10 characters (it has 700)."],
308 | )
309 | self.assertContext(
310 | response, {"form": InstanceOf(BaseForm), "view": InstanceOf(View)}
311 | )
312 | self.assertFalse(Example.objects.exists())
313 |
314 | def test_create_preview(self):
315 | view = CreateView.as_view(
316 | model=Example,
317 | fields=("text",),
318 | success_url="/success/",
319 | )
320 | response = self.get(view)
321 |
322 | self.assertEqual(response.status_code, 200)
323 | self.assertEqual(response.template_name, ["vanilla/example_form.html"])
324 | self.assertContext(
325 | response, {"form": InstanceOf(BaseForm), "view": InstanceOf(View)}
326 | )
327 | self.assertFalse(Example.objects.exists())
328 |
329 | def test_create_no_success_url(self):
330 | view = CreateView.as_view(model=Example, fields=("text",))
331 | with self.assertRaises(ImproperlyConfigured):
332 | self.post(view, data={"text": "example"})
333 |
334 | def test_create_misconfigured_form_class(self):
335 | # If don't provide 'model' or 'form_class',
336 | # we should expect an ImproperlyConfigured exception.
337 | view = CreateView.as_view(
338 | queryset=Example.objects.all(),
339 | template_name="example.html",
340 | success_url="/success/",
341 | )
342 | with self.assertRaises(ImproperlyConfigured):
343 | self.post(view, data={"text": "example"})
344 |
345 | def test_create_create_no_fields(self):
346 | # If we don't provide `.fields` then expect a `PendingDeprecation` warning.
347 | view = CreateView.as_view(model=Example, success_url="/success/")
348 | with self.assertRaises(ImproperlyConfigured):
349 | self.post(view, data={"text": "example"})
350 |
351 |
352 | class TestUpdate(BaseTestCase):
353 | def test_update(self):
354 | create_instance(quantity=3)
355 | pk = Example.objects.all()[0].pk
356 | view = UpdateView.as_view(
357 | model=Example,
358 | fields=("text",),
359 | success_url="/success/",
360 | )
361 | response = self.post(view, pk=pk, data={"text": "example"})
362 |
363 | self.assertEqual(response.status_code, 302)
364 | self.assertEqual(response["location"], "/success/")
365 | self.assertEqual(Example.objects.count(), 3)
366 | self.assertEqual(Example.objects.get(pk=pk).text, "example")
367 |
368 | def test_update_failed(self):
369 | create_instance(quantity=3)
370 | pk = Example.objects.all()[0].pk
371 | original_text = Example.objects.all()[0].text
372 | view = UpdateView.as_view(
373 | model=Example,
374 | fields=("text",),
375 | success_url="/success/",
376 | )
377 | response = self.post(view, pk=pk, data={"text": "example" * 100})
378 |
379 | self.assertEqual(response.status_code, 200)
380 | self.assertEqual(response.template_name, ["vanilla/example_form.html"])
381 | self.assertFormError(
382 | response,
383 | "form",
384 | "text",
385 | ["Ensure this value has at most 10 characters (it has 700)."],
386 | )
387 | self.assertContext(
388 | response,
389 | {
390 | "object": Example.objects.get(pk=pk),
391 | "example": Example.objects.get(pk=pk),
392 | "form": InstanceOf(BaseForm),
393 | "view": InstanceOf(View),
394 | },
395 | )
396 | self.assertEqual(Example.objects.count(), 3)
397 | self.assertEqual(Example.objects.get(pk=pk).text, original_text)
398 |
399 | def test_update_preview(self):
400 | create_instance(quantity=3)
401 | pk = Example.objects.all()[0].pk
402 | view = UpdateView.as_view(
403 | model=Example,
404 | fields=("text",),
405 | success_url="/success/",
406 | )
407 | response = self.get(view, pk=pk)
408 |
409 | self.assertEqual(response.status_code, 200)
410 | self.assertEqual(response.template_name, ["vanilla/example_form.html"])
411 | self.assertContext(
412 | response,
413 | {
414 | "object": Example.objects.get(pk=pk),
415 | "example": Example.objects.get(pk=pk),
416 | "form": InstanceOf(BaseForm),
417 | "view": InstanceOf(View),
418 | },
419 | )
420 | self.assertEqual(Example.objects.count(), 3)
421 |
422 | def test_update_no_success_url(self):
423 | create_instance(quantity=3)
424 | pk = Example.objects.all()[0].pk
425 | view = UpdateView.as_view(model=Example, fields=("text",))
426 | with self.assertRaises(ImproperlyConfigured):
427 | self.post(view, pk=pk, data={"text": "example"})
428 |
429 | def test_update_no_fields(self):
430 | # If we don't provide `.fields` then expect a `PendingDeprecation` warning.
431 | create_instance(quantity=3)
432 | pk = Example.objects.all()[0].pk
433 | view = UpdateView.as_view(model=Example, success_url="/success/")
434 | with self.assertRaises(ImproperlyConfigured):
435 | self.post(view, pk=pk, data={"text": "example"})
436 |
437 |
438 | class TestDelete(BaseTestCase):
439 | def test_delete(self):
440 | create_instance(quantity=3)
441 | pk = Example.objects.all()[0].pk
442 | view = DeleteView.as_view(model=Example, success_url="/success/")
443 | response = self.post(view, pk=pk)
444 |
445 | self.assertEqual(response.status_code, 302)
446 | self.assertEqual(response["location"], "/success/")
447 | self.assertEqual(Example.objects.count(), 2)
448 | self.assertFalse(Example.objects.filter(pk=pk).exists())
449 |
450 | def test_delete_not_found(self):
451 | create_instance(quantity=3)
452 | view = DeleteView.as_view(model=Example, success_url="/success/")
453 | self.assertRaises(Http404, self.get, view, pk=999)
454 |
455 | def test_delete_preview(self):
456 | create_instance(quantity=3)
457 | pk = Example.objects.all()[0].pk
458 | view = DeleteView.as_view(model=Example, success_url="/success/")
459 | response = self.get(view, pk=pk)
460 |
461 | self.assertEqual(response.status_code, 200)
462 | self.assertEqual(
463 | response.template_name,
464 | ["vanilla/example_confirm_delete.html"],
465 | )
466 | self.assertContext(
467 | response,
468 | {
469 | "object": Example.objects.get(pk=pk),
470 | "example": Example.objects.get(pk=pk),
471 | "view": InstanceOf(View),
472 | },
473 | )
474 | self.assertEqual(Example.objects.count(), 3)
475 |
476 | def test_delete_no_success_url(self):
477 | create_instance(quantity=3)
478 | pk = Example.objects.all()[0].pk
479 | view = DeleteView.as_view(model=Example)
480 | self.assertRaises(ImproperlyConfigured, self.post, view, pk=pk)
481 |
482 |
483 | class TestAttributeOverrides(BaseTestCase):
484 | def test_template_name_override(self):
485 | create_instance(quantity=3)
486 | pk = Example.objects.all()[0].pk
487 | view = DetailView.as_view(model=Example, template_name="example.html")
488 | response = self.get(view, pk=pk)
489 |
490 | self.assertEqual(response.status_code, 200)
491 | self.assertEqual(response.template_name, ["example.html"])
492 | self.assertContext(
493 | response,
494 | {
495 | "object": Example.objects.get(pk=pk),
496 | "example": Example.objects.get(pk=pk),
497 | "view": InstanceOf(View),
498 | },
499 | )
500 |
501 | def test_template_name_suffix_override(self):
502 | create_instance(quantity=3)
503 | pk = Example.objects.all()[0].pk
504 | view = DetailView.as_view(model=Example, template_name_suffix="_suffix")
505 | response = self.get(view, pk=pk)
506 |
507 | self.assertEqual(response.status_code, 200)
508 | self.assertEqual(response.template_name, ["vanilla/example_suffix.html"])
509 | self.assertContext(
510 | response,
511 | {
512 | "object": Example.objects.get(pk=pk),
513 | "example": Example.objects.get(pk=pk),
514 | "view": InstanceOf(View),
515 | },
516 | )
517 |
518 | def test_context_object_name_override(self):
519 | create_instance(quantity=3)
520 | pk = Example.objects.all()[0].pk
521 | view = DetailView.as_view(model=Example, context_object_name="current")
522 | response = self.get(view, pk=pk)
523 |
524 | self.assertEqual(response.status_code, 200)
525 | self.assertEqual(response.template_name, ["vanilla/example_detail.html"])
526 | self.assertContext(
527 | response,
528 | {
529 | "object": Example.objects.get(pk=pk),
530 | "current": Example.objects.get(pk=pk),
531 | "view": InstanceOf(View),
532 | },
533 | )
534 |
535 | def test_form_class_override(self):
536 | class CustomForm(ModelForm):
537 | class Meta:
538 | fields = ("text",)
539 | model = Example
540 |
541 | view = CreateView.as_view(
542 | model=Example,
543 | success_url="/success/",
544 | form_class=CustomForm,
545 | )
546 | response = self.get(view)
547 |
548 | self.assertEqual(response.status_code, 200)
549 | self.assertEqual(response.template_name, ["vanilla/example_form.html"])
550 | self.assertContext(
551 | response, {"form": InstanceOf(CustomForm), "view": InstanceOf(View)}
552 | )
553 | self.assertFalse(Example.objects.exists())
554 |
555 | def test_queryset_override(self):
556 | create_instance(text="abc", quantity=3)
557 | create_instance(text="def", quantity=3)
558 | view = ListView.as_view(
559 | model=Example,
560 | queryset=Example.objects.filter(text="abc"),
561 | )
562 | response = self.get(view)
563 |
564 | self.assertEqual(response.status_code, 200)
565 | self.assertEqual(response.template_name, ["vanilla/example_list.html"])
566 | self.assertContext(
567 | response,
568 | {
569 | "object_list": Example.objects.filter(text="abc"),
570 | "example_list": Example.objects.filter(text="abc"),
571 | "view": InstanceOf(View),
572 | "page_obj": None,
573 | "paginator": None,
574 | "is_paginated": False,
575 | },
576 | )
577 |
578 |
579 | class TestTemplateView(BaseTestCase):
580 | def test_template_view(self):
581 | view = TemplateView.as_view(template_name="example.html")
582 | response = self.get(view)
583 |
584 | self.assertEqual(response.status_code, 200)
585 | self.assertEqual(response.template_name, ["example.html"])
586 | self.assertContext(response, {"view": InstanceOf(View)})
587 |
588 | def test_misconfigured_template_view(self):
589 | # A template view with no `template_name` is improperly configured.
590 | view = TemplateView.as_view()
591 | self.assertRaises(ImproperlyConfigured, self.get, view)
592 |
593 |
594 | class TestFormView(BaseTestCase):
595 | def test_form_success(self):
596 | view = FormView.as_view(
597 | form_class=ExampleForm,
598 | success_url="/success/",
599 | template_name="example.html",
600 | )
601 | response = self.post(view, data={"text": "example"})
602 |
603 | self.assertEqual(response.status_code, 302)
604 | self.assertEqual(response["location"], "/success/")
605 |
606 | def test_form_failure(self):
607 | view = FormView.as_view(
608 | form_class=ExampleForm,
609 | success_url="/success/",
610 | template_name="example.html",
611 | )
612 | response = self.post(view, data={"text": "example" * 100})
613 |
614 | self.assertEqual(response.status_code, 200)
615 | self.assertEqual(response.template_name, ["example.html"])
616 | self.assertFormError(
617 | response,
618 | "form",
619 | "text",
620 | ["Ensure this value has at most 10 characters (it has 700)."],
621 | )
622 | self.assertContext(
623 | response, {"form": InstanceOf(BaseForm), "view": InstanceOf(View)}
624 | )
625 |
626 | def test_form_preview(self):
627 | view = FormView.as_view(
628 | form_class=ExampleForm,
629 | success_url="/success/",
630 | template_name="example.html",
631 | )
632 | response = self.get(view)
633 |
634 | self.assertEqual(response.status_code, 200)
635 | self.assertEqual(response.template_name, ["example.html"])
636 | self.assertContext(
637 | response, {"form": InstanceOf(BaseForm), "view": InstanceOf(View)}
638 | )
639 |
640 | def test_misconfigured_form_view_no_form_class(self):
641 | # A template view with no `form_class` is improperly configured.
642 | view = FormView.as_view(success_url="/success/", template_name="example.html")
643 | self.assertRaises(ImproperlyConfigured, self.get, view)
644 |
645 | def test_misconfigured_form_view_no_success_url(self):
646 | # A template view with no `success_url` is improperly configured.
647 | view = FormView.as_view(form_class=ExampleForm, template_name="example.html")
648 | with self.assertRaises(ImproperlyConfigured):
649 | self.post(view, data={"text": "example"})
650 |
--------------------------------------------------------------------------------
/vanilla/views.py:
--------------------------------------------------------------------------------
1 | from django.core.exceptions import ImproperlyConfigured
2 | from django.http import HttpResponseRedirect
3 | from django.template.response import TemplateResponse
4 | from django.views.generic import View
5 |
6 |
7 | class GenericView(View):
8 | """
9 | A generic base class for building template and/or form views.
10 | """
11 |
12 | form_class = None
13 | template_name = None
14 |
15 | # Form instantiation
16 |
17 | def get_form_class(self):
18 | """
19 | Returns the form class to use in this view.
20 | """
21 | if self.form_class is not None:
22 | return self.form_class
23 |
24 | msg = "'%s' must either define 'form_class' or override 'get_form_class()'"
25 | raise ImproperlyConfigured(msg % self.__class__.__name__)
26 |
27 | def get_form(self, data=None, files=None, **kwargs):
28 | """
29 | Given `data` and `files` QueryDicts, and optionally other named
30 | arguments, and returns a form.
31 | """
32 | cls = self.get_form_class()
33 | return cls(data=data, files=files, **kwargs)
34 |
35 | # Response rendering
36 |
37 | def get_template_names(self):
38 | """
39 | Returns a set of template names that may be used when rendering
40 | the response.
41 | """
42 | if self.template_name is not None:
43 | return [self.template_name]
44 |
45 | msg = (
46 | "'%s' must either define 'template_name' or override "
47 | + "'get_template_names()'"
48 | )
49 | raise ImproperlyConfigured(msg % self.__class__.__name__)
50 |
51 | def get_context_data(self, **kwargs):
52 | """
53 | Takes a set of keyword arguments to use as the base context, and
54 | returns a context dictionary to use for the view, additionally adding
55 | in 'view'.
56 | """
57 | kwargs["view"] = self
58 | return kwargs
59 |
60 | def render_to_response(self, context):
61 | """
62 | Given a context dictionary, returns an HTTP response.
63 | """
64 | return TemplateResponse(
65 | request=self.request, template=self.get_template_names(), context=context
66 | )
67 |
68 |
69 | class TemplateView(GenericView):
70 | def get(self, request, *args, **kwargs):
71 | context = self.get_context_data()
72 | return self.render_to_response(context)
73 |
74 |
75 | class FormView(GenericView):
76 | success_url = None
77 |
78 | def get(self, request, *args, **kwargs):
79 | form = self.get_form()
80 | context = self.get_context_data(form=form)
81 | return self.render_to_response(context)
82 |
83 | def post(self, request, *args, **kwargs):
84 | form = self.get_form(data=request.POST, files=request.FILES)
85 | if form.is_valid():
86 | return self.form_valid(form)
87 | return self.form_invalid(form)
88 |
89 | def form_valid(self, form):
90 | return HttpResponseRedirect(self.get_success_url())
91 |
92 | def form_invalid(self, form):
93 | context = self.get_context_data(form=form)
94 | return self.render_to_response(context)
95 |
96 | def get_success_url(self):
97 | if self.success_url is None:
98 | msg = "'%s' must define 'success_url' or override 'get_success_url()'"
99 | raise ImproperlyConfigured(msg % self.__class__.__name__)
100 | return self.success_url
101 |
--------------------------------------------------------------------------------