| 1 |
from django import forms |
| 2 |
from django.core.exceptions import ImproperlyConfigured |
| 3 |
from django.test import SimpleTestCase, TestCase, override_settings |
| 4 |
from django.test.client import RequestFactory |
| 5 |
from django.urls import reverse |
| 6 |
from django.views.generic.base import View |
| 7 |
from django.views.generic.edit import CreateView, FormMixin, ModelFormMixin |
| 8 |
|
| 9 |
from . import views |
| 10 |
from .forms import AuthorForm |
| 11 |
from .models import Artist, Author |
| 12 |
|
| 13 |
|
| 14 |
class FormMixinTests(SimpleTestCase): |
| 15 |
request_factory = RequestFactory() |
| 16 |
|
| 17 |
def test_initial_data(self): |
| 18 |
"""Test instance independence of initial data dict (see #16138)""" |
| 19 |
initial_1 = FormMixin().get_initial() |
| 20 |
initial_1["foo"] = "bar" |
| 21 |
initial_2 = FormMixin().get_initial() |
| 22 |
self.assertNotEqual(initial_1, initial_2) |
| 23 |
|
| 24 |
def test_get_prefix(self): |
| 25 |
"""Test prefix can be set (see #18872)""" |
| 26 |
test_string = "test" |
| 27 |
|
| 28 |
get_request = self.request_factory.get("/") |
| 29 |
|
| 30 |
class TestFormMixin(FormMixin): |
| 31 |
request = get_request |
| 32 |
|
| 33 |
default_kwargs = TestFormMixin().get_form_kwargs() |
| 34 |
self.assertIsNone(default_kwargs.get("prefix")) |
| 35 |
|
| 36 |
set_mixin = TestFormMixin() |
| 37 |
set_mixin.prefix = test_string |
| 38 |
set_kwargs = set_mixin.get_form_kwargs() |
| 39 |
self.assertEqual(test_string, set_kwargs.get("prefix")) |
| 40 |
|
| 41 |
def test_get_form(self): |
| 42 |
class TestFormMixin(FormMixin): |
| 43 |
request = self.request_factory.get("/") |
| 44 |
|
| 45 |
self.assertIsInstance( |
| 46 |
TestFormMixin().get_form(forms.Form), |
| 47 |
forms.Form, |
| 48 |
"get_form() should use provided form class.", |
| 49 |
) |
| 50 |
|
| 51 |
class FormClassTestFormMixin(TestFormMixin): |
| 52 |
form_class = forms.Form |
| 53 |
|
| 54 |
self.assertIsInstance( |
| 55 |
FormClassTestFormMixin().get_form(), |
| 56 |
forms.Form, |
| 57 |
"get_form() should fallback to get_form_class() if none is provided.", |
| 58 |
) |
| 59 |
|
| 60 |
def test_get_context_data(self): |
| 61 |
class FormContext(FormMixin): |
| 62 |
request = self.request_factory.get("/") |
| 63 |
form_class = forms.Form |
| 64 |
|
| 65 |
self.assertIsInstance(FormContext().get_context_data()["form"], forms.Form) |
| 66 |
|
| 67 |
|
| 68 |
@override_settings(ROOT_URLCONF="generic_views.urls") |
| 69 |
class BasicFormTests(TestCase): |
| 70 |
def test_post_data(self): |
| 71 |
res = self.client.post("/contact/", {"name": "Me", "message": "Hello"}) |
| 72 |
self.assertRedirects(res, "/list/authors/") |
| 73 |
|
| 74 |
def test_late_form_validation(self): |
| 75 |
""" |
| 76 |
A form can be marked invalid in the form_valid() method (#25548). |
| 77 |
""" |
| 78 |
res = self.client.post("/late-validation/", {"name": "Me", "message": "Hello"}) |
| 79 |
self.assertFalse(res.context["form"].is_valid()) |
| 80 |
|
| 81 |
|
| 82 |
class ModelFormMixinTests(SimpleTestCase): |
| 83 |
def test_get_form(self): |
| 84 |
form_class = views.AuthorGetQuerySetFormView().get_form_class() |
| 85 |
self.assertEqual(form_class._meta.model, Author) |
| 86 |
|
| 87 |
def test_get_form_checks_for_object(self): |
| 88 |
mixin = ModelFormMixin() |
| 89 |
mixin.request = RequestFactory().get("/") |
| 90 |
self.assertEqual({"initial": {}, "prefix": None}, mixin.get_form_kwargs()) |
| 91 |
|
| 92 |
|
| 93 |
@override_settings(ROOT_URLCONF="generic_views.urls") |
| 94 |
class CreateViewTests(TestCase): |
| 95 |
def test_create(self): |
| 96 |
res = self.client.get("/edit/authors/create/") |
| 97 |
self.assertEqual(res.status_code, 200) |
| 98 |
self.assertIsInstance(res.context["form"], forms.ModelForm) |
| 99 |
self.assertIsInstance(res.context["view"], View) |
| 100 |
self.assertNotIn("object", res.context) |
| 101 |
self.assertNotIn("author", res.context) |
| 102 |
self.assertTemplateUsed(res, "generic_views/author_form.html") |
| 103 |
|
| 104 |
res = self.client.post( |
| 105 |
"/edit/authors/create/", |
| 106 |
{"name": "Randall Munroe", "slug": "randall-munroe"}, |
| 107 |
) |
| 108 |
self.assertEqual(res.status_code, 302) |
| 109 |
self.assertRedirects(res, "/list/authors/") |
| 110 |
self.assertQuerySetEqual( |
| 111 |
Author.objects.values_list("name", flat=True), ["Randall Munroe"] |
| 112 |
) |
| 113 |
|
| 114 |
def test_create_invalid(self): |
| 115 |
res = self.client.post( |
| 116 |
"/edit/authors/create/", {"name": "A" * 101, "slug": "randall-munroe"} |
| 117 |
) |
| 118 |
self.assertEqual(res.status_code, 200) |
| 119 |
self.assertTemplateUsed(res, "generic_views/author_form.html") |
| 120 |
self.assertEqual(len(res.context["form"].errors), 1) |
| 121 |
self.assertEqual(Author.objects.count(), 0) |
| 122 |
|
| 123 |
def test_create_with_object_url(self): |
| 124 |
res = self.client.post("/edit/artists/create/", {"name": "Rene Magritte"}) |
| 125 |
self.assertEqual(res.status_code, 302) |
| 126 |
artist = Artist.objects.get(name="Rene Magritte") |
| 127 |
self.assertRedirects(res, "/detail/artist/%d/" % artist.pk) |
| 128 |
self.assertQuerySetEqual(Artist.objects.all(), [artist]) |
| 129 |
|
| 130 |
def test_create_with_redirect(self): |
| 131 |
res = self.client.post( |
| 132 |
"/edit/authors/create/redirect/", |
| 133 |
{"name": "Randall Munroe", "slug": "randall-munroe"}, |
| 134 |
) |
| 135 |
self.assertEqual(res.status_code, 302) |
| 136 |
self.assertRedirects(res, "/edit/authors/create/") |
| 137 |
self.assertQuerySetEqual( |
| 138 |
Author.objects.values_list("name", flat=True), ["Randall Munroe"] |
| 139 |
) |
| 140 |
|
| 141 |
def test_create_with_interpolated_redirect(self): |
| 142 |
res = self.client.post( |
| 143 |
"/edit/authors/create/interpolate_redirect/", |
| 144 |
{"name": "Randall Munroe", "slug": "randall-munroe"}, |
| 145 |
) |
| 146 |
self.assertQuerySetEqual( |
| 147 |
Author.objects.values_list("name", flat=True), ["Randall Munroe"] |
| 148 |
) |
| 149 |
self.assertEqual(res.status_code, 302) |
| 150 |
pk = Author.objects.first().pk |
| 151 |
self.assertRedirects(res, "/edit/author/%d/update/" % pk) |
| 152 |
# Also test with escaped chars in URL |
| 153 |
res = self.client.post( |
| 154 |
"/edit/authors/create/interpolate_redirect_nonascii/", |
| 155 |
{"name": "John Doe", "slug": "john-doe"}, |
| 156 |
) |
| 157 |
self.assertEqual(res.status_code, 302) |
| 158 |
pk = Author.objects.get(name="John Doe").pk |
| 159 |
self.assertRedirects(res, "/%C3%A9dit/author/{}/update/".format(pk)) |
| 160 |
|
| 161 |
def test_create_with_special_properties(self): |
| 162 |
res = self.client.get("/edit/authors/create/special/") |
| 163 |
self.assertEqual(res.status_code, 200) |
| 164 |
self.assertIsInstance(res.context["form"], views.AuthorForm) |
| 165 |
self.assertNotIn("object", res.context) |
| 166 |
self.assertNotIn("author", res.context) |
| 167 |
self.assertTemplateUsed(res, "generic_views/form.html") |
| 168 |
|
| 169 |
res = self.client.post( |
| 170 |
"/edit/authors/create/special/", |
| 171 |
{"name": "Randall Munroe", "slug": "randall-munroe"}, |
| 172 |
) |
| 173 |
self.assertEqual(res.status_code, 302) |
| 174 |
obj = Author.objects.get(slug="randall-munroe") |
| 175 |
self.assertRedirects(res, reverse("author_detail", kwargs={"pk": obj.pk})) |
| 176 |
self.assertQuerySetEqual(Author.objects.all(), [obj]) |
| 177 |
|
| 178 |
def test_create_without_redirect(self): |
| 179 |
msg = ( |
| 180 |
"No URL to redirect to. Either provide a url or define a " |
| 181 |
"get_absolute_url method on the Model." |
| 182 |
) |
| 183 |
with self.assertRaisesMessage(ImproperlyConfigured, msg): |
| 184 |
self.client.post( |
| 185 |
"/edit/authors/create/naive/", |
| 186 |
{"name": "Randall Munroe", "slug": "randall-munroe"}, |
| 187 |
) |
| 188 |
|
| 189 |
def test_create_restricted(self): |
| 190 |
res = self.client.post( |
| 191 |
"/edit/authors/create/restricted/", |
| 192 |
{"name": "Randall Munroe", "slug": "randall-munroe"}, |
| 193 |
) |
| 194 |
self.assertEqual(res.status_code, 302) |
| 195 |
self.assertRedirects( |
| 196 |
res, "/accounts/login/?next=/edit/authors/create/restricted/" |
| 197 |
) |
| 198 |
|
| 199 |
def test_create_view_with_restricted_fields(self): |
| 200 |
class MyCreateView(CreateView): |
| 201 |
model = Author |
| 202 |
fields = ["name"] |
| 203 |
|
| 204 |
self.assertEqual(list(MyCreateView().get_form_class().base_fields), ["name"]) |
| 205 |
|
| 206 |
def test_create_view_all_fields(self): |
| 207 |
class MyCreateView(CreateView): |
| 208 |
model = Author |
| 209 |
fields = "__all__" |
| 210 |
|
| 211 |
self.assertEqual( |
| 212 |
list(MyCreateView().get_form_class().base_fields), ["name", "slug"] |
| 213 |
) |
| 214 |
|
| 215 |
def test_create_view_without_explicit_fields(self): |
| 216 |
class MyCreateView(CreateView): |
| 217 |
model = Author |
| 218 |
|
| 219 |
message = ( |
| 220 |
"Using ModelFormMixin (base class of MyCreateView) without the " |
| 221 |
"'fields' attribute is prohibited." |
| 222 |
) |
| 223 |
with self.assertRaisesMessage(ImproperlyConfigured, message): |
| 224 |
MyCreateView().get_form_class() |
| 225 |
|
| 226 |
def test_define_both_fields_and_form_class(self): |
| 227 |
class MyCreateView(CreateView): |
| 228 |
model = Author |
| 229 |
form_class = AuthorForm |
| 230 |
fields = ["name"] |
| 231 |
|
| 232 |
message = "Specifying both 'fields' and 'form_class' is not permitted." |
| 233 |
with self.assertRaisesMessage(ImproperlyConfigured, message): |
| 234 |
MyCreateView().get_form_class() |
| 235 |
|
| 236 |
|
| 237 |
@override_settings(ROOT_URLCONF="generic_views.urls") |
| 238 |
class UpdateViewTests(TestCase): |
| 239 |
@classmethod |
| 240 |
def setUpTestData(cls): |
| 241 |
cls.author = Author.objects.create( |
| 242 |
pk=1, # Required for OneAuthorUpdate. |
| 243 |
name="Randall Munroe", |
| 244 |
slug="randall-munroe", |
| 245 |
) |
| 246 |
|
| 247 |
def test_update_post(self): |
| 248 |
res = self.client.get("/edit/author/%d/update/" % self.author.pk) |
| 249 |
self.assertEqual(res.status_code, 200) |
| 250 |
self.assertIsInstance(res.context["form"], forms.ModelForm) |
| 251 |
self.assertEqual(res.context["object"], self.author) |
| 252 |
self.assertEqual(res.context["author"], self.author) |
| 253 |
self.assertTemplateUsed(res, "generic_views/author_form.html") |
| 254 |
self.assertEqual(res.context["view"].get_form_called_count, 1) |
| 255 |
|
| 256 |
# Modification with both POST and PUT (browser compatible) |
| 257 |
res = self.client.post( |
| 258 |
"/edit/author/%d/update/" % self.author.pk, |
| 259 |
{"name": "Randall Munroe (xkcd)", "slug": "randall-munroe"}, |
| 260 |
) |
| 261 |
self.assertEqual(res.status_code, 302) |
| 262 |
self.assertRedirects(res, "/list/authors/") |
| 263 |
self.assertQuerySetEqual( |
| 264 |
Author.objects.values_list("name", flat=True), ["Randall Munroe (xkcd)"] |
| 265 |
) |
| 266 |
|
| 267 |
def test_update_invalid(self): |
| 268 |
res = self.client.post( |
| 269 |
"/edit/author/%d/update/" % self.author.pk, |
| 270 |
{"name": "A" * 101, "slug": "randall-munroe"}, |
| 271 |
) |
| 272 |
self.assertEqual(res.status_code, 200) |
| 273 |
self.assertTemplateUsed(res, "generic_views/author_form.html") |
| 274 |
self.assertEqual(len(res.context["form"].errors), 1) |
| 275 |
self.assertQuerySetEqual(Author.objects.all(), [self.author]) |
| 276 |
self.assertEqual(res.context["view"].get_form_called_count, 1) |
| 277 |
|
| 278 |
def test_update_with_object_url(self): |
| 279 |
a = Artist.objects.create(name="Rene Magritte") |
| 280 |
res = self.client.post( |
| 281 |
"/edit/artists/%d/update/" % a.pk, {"name": "Rene Magritte"} |
| 282 |
) |
| 283 |
self.assertEqual(res.status_code, 302) |
| 284 |
self.assertRedirects(res, "/detail/artist/%d/" % a.pk) |
| 285 |
self.assertQuerySetEqual(Artist.objects.all(), [a]) |
| 286 |
|
| 287 |
def test_update_with_redirect(self): |
| 288 |
res = self.client.post( |
| 289 |
"/edit/author/%d/update/redirect/" % self.author.pk, |
| 290 |
{"name": "Randall Munroe (author of xkcd)", "slug": "randall-munroe"}, |
| 291 |
) |
| 292 |
self.assertEqual(res.status_code, 302) |
| 293 |
self.assertRedirects(res, "/edit/authors/create/") |
| 294 |
self.assertQuerySetEqual( |
| 295 |
Author.objects.values_list("name", flat=True), |
| 296 |
["Randall Munroe (author of xkcd)"], |
| 297 |
) |
| 298 |
|
| 299 |
def test_update_with_interpolated_redirect(self): |
| 300 |
res = self.client.post( |
| 301 |
"/edit/author/%d/update/interpolate_redirect/" % self.author.pk, |
| 302 |
{"name": "Randall Munroe (author of xkcd)", "slug": "randall-munroe"}, |
| 303 |
) |
| 304 |
self.assertQuerySetEqual( |
| 305 |
Author.objects.values_list("name", flat=True), |
| 306 |
["Randall Munroe (author of xkcd)"], |
| 307 |
) |
| 308 |
self.assertEqual(res.status_code, 302) |
| 309 |
pk = Author.objects.first().pk |
| 310 |
self.assertRedirects(res, "/edit/author/%d/update/" % pk) |
| 311 |
# Also test with escaped chars in URL |
| 312 |
res = self.client.post( |
| 313 |
"/edit/author/%d/update/interpolate_redirect_nonascii/" % self.author.pk, |
| 314 |
{"name": "John Doe", "slug": "john-doe"}, |
| 315 |
) |
| 316 |
self.assertEqual(res.status_code, 302) |
| 317 |
pk = Author.objects.get(name="John Doe").pk |
| 318 |
self.assertRedirects(res, "/%C3%A9dit/author/{}/update/".format(pk)) |
| 319 |
|
| 320 |
def test_update_with_special_properties(self): |
| 321 |
res = self.client.get("/edit/author/%d/update/special/" % self.author.pk) |
| 322 |
self.assertEqual(res.status_code, 200) |
| 323 |
self.assertIsInstance(res.context["form"], views.AuthorForm) |
| 324 |
self.assertEqual(res.context["object"], self.author) |
| 325 |
self.assertEqual(res.context["thingy"], self.author) |
| 326 |
self.assertNotIn("author", res.context) |
| 327 |
self.assertTemplateUsed(res, "generic_views/form.html") |
| 328 |
|
| 329 |
res = self.client.post( |
| 330 |
"/edit/author/%d/update/special/" % self.author.pk, |
| 331 |
{"name": "Randall Munroe (author of xkcd)", "slug": "randall-munroe"}, |
| 332 |
) |
| 333 |
self.assertEqual(res.status_code, 302) |
| 334 |
self.assertRedirects(res, "/detail/author/%d/" % self.author.pk) |
| 335 |
self.assertQuerySetEqual( |
| 336 |
Author.objects.values_list("name", flat=True), |
| 337 |
["Randall Munroe (author of xkcd)"], |
| 338 |
) |
| 339 |
|
| 340 |
def test_update_without_redirect(self): |
| 341 |
msg = ( |
| 342 |
"No URL to redirect to. Either provide a url or define a " |
| 343 |
"get_absolute_url method on the Model." |
| 344 |
) |
| 345 |
with self.assertRaisesMessage(ImproperlyConfigured, msg): |
| 346 |
self.client.post( |
| 347 |
"/edit/author/%d/update/naive/" % self.author.pk, |
| 348 |
{"name": "Randall Munroe (author of xkcd)", "slug": "randall-munroe"}, |
| 349 |
) |
| 350 |
|
| 351 |
def test_update_get_object(self): |
| 352 |
res = self.client.get("/edit/author/update/") |
| 353 |
self.assertEqual(res.status_code, 200) |
| 354 |
self.assertIsInstance(res.context["form"], forms.ModelForm) |
| 355 |
self.assertIsInstance(res.context["view"], View) |
| 356 |
self.assertEqual(res.context["object"], self.author) |
| 357 |
self.assertEqual(res.context["author"], self.author) |
| 358 |
self.assertTemplateUsed(res, "generic_views/author_form.html") |
| 359 |
|
| 360 |
# Modification with both POST and PUT (browser compatible) |
| 361 |
res = self.client.post( |
| 362 |
"/edit/author/update/", |
| 363 |
{"name": "Randall Munroe (xkcd)", "slug": "randall-munroe"}, |
| 364 |
) |
| 365 |
self.assertEqual(res.status_code, 302) |
| 366 |
self.assertRedirects(res, "/list/authors/") |
| 367 |
self.assertQuerySetEqual( |
| 368 |
Author.objects.values_list("name", flat=True), ["Randall Munroe (xkcd)"] |
| 369 |
) |
| 370 |
|
| 371 |
|
| 372 |
@override_settings(ROOT_URLCONF="generic_views.urls") |
| 373 |
class DeleteViewTests(TestCase): |
| 374 |
@classmethod |
| 375 |
def setUpTestData(cls): |
| 376 |
cls.author = Author.objects.create( |
| 377 |
name="Randall Munroe", |
| 378 |
slug="randall-munroe", |
| 379 |
) |
| 380 |
|
| 381 |
def test_delete_by_post(self): |
| 382 |
res = self.client.get("/edit/author/%d/delete/" % self.author.pk) |
| 383 |
self.assertEqual(res.status_code, 200) |
| 384 |
self.assertEqual(res.context["object"], self.author) |
| 385 |
self.assertEqual(res.context["author"], self.author) |
| 386 |
self.assertTemplateUsed(res, "generic_views/author_confirm_delete.html") |
| 387 |
|
| 388 |
# Deletion with POST |
| 389 |
res = self.client.post("/edit/author/%d/delete/" % self.author.pk) |
| 390 |
self.assertEqual(res.status_code, 302) |
| 391 |
self.assertRedirects(res, "/list/authors/") |
| 392 |
self.assertQuerySetEqual(Author.objects.all(), []) |
| 393 |
|
| 394 |
def test_delete_by_delete(self): |
| 395 |
# Deletion with browser compatible DELETE method |
| 396 |
res = self.client.delete("/edit/author/%d/delete/" % self.author.pk) |
| 397 |
self.assertEqual(res.status_code, 302) |
| 398 |
self.assertRedirects(res, "/list/authors/") |
| 399 |
self.assertQuerySetEqual(Author.objects.all(), []) |
| 400 |
|
| 401 |
def test_delete_with_redirect(self): |
| 402 |
res = self.client.post("/edit/author/%d/delete/redirect/" % self.author.pk) |
| 403 |
self.assertEqual(res.status_code, 302) |
| 404 |
self.assertRedirects(res, "/edit/authors/create/") |
| 405 |
self.assertQuerySetEqual(Author.objects.all(), []) |
| 406 |
|
| 407 |
def test_delete_with_interpolated_redirect(self): |
| 408 |
res = self.client.post( |
| 409 |
"/edit/author/%d/delete/interpolate_redirect/" % self.author.pk |
| 410 |
) |
| 411 |
self.assertEqual(res.status_code, 302) |
| 412 |
self.assertRedirects(res, "/edit/authors/create/?deleted=%d" % self.author.pk) |
| 413 |
self.assertQuerySetEqual(Author.objects.all(), []) |
| 414 |
# Also test with escaped chars in URL |
| 415 |
a = Author.objects.create( |
| 416 |
**{"name": "Randall Munroe", "slug": "randall-munroe"} |
| 417 |
) |
| 418 |
res = self.client.post( |
| 419 |
"/edit/author/{}/delete/interpolate_redirect_nonascii/".format(a.pk) |
| 420 |
) |
| 421 |
self.assertEqual(res.status_code, 302) |
| 422 |
self.assertRedirects(res, "/%C3%A9dit/authors/create/?deleted={}".format(a.pk)) |
| 423 |
|
| 424 |
def test_delete_with_special_properties(self): |
| 425 |
res = self.client.get("/edit/author/%d/delete/special/" % self.author.pk) |
| 426 |
self.assertEqual(res.status_code, 200) |
| 427 |
self.assertEqual(res.context["object"], self.author) |
| 428 |
self.assertEqual(res.context["thingy"], self.author) |
| 429 |
self.assertNotIn("author", res.context) |
| 430 |
self.assertTemplateUsed(res, "generic_views/confirm_delete.html") |
| 431 |
|
| 432 |
res = self.client.post("/edit/author/%d/delete/special/" % self.author.pk) |
| 433 |
self.assertEqual(res.status_code, 302) |
| 434 |
self.assertRedirects(res, "/list/authors/") |
| 435 |
self.assertQuerySetEqual(Author.objects.all(), []) |
| 436 |
|
| 437 |
def test_delete_without_redirect(self): |
| 438 |
msg = "No URL to redirect to. Provide a success_url." |
| 439 |
with self.assertRaisesMessage(ImproperlyConfigured, msg): |
| 440 |
self.client.post("/edit/author/%d/delete/naive/" % self.author.pk) |
| 441 |
|
| 442 |
def test_delete_with_form_as_post(self): |
| 443 |
res = self.client.get("/edit/author/%d/delete/form/" % self.author.pk) |
| 444 |
self.assertEqual(res.status_code, 200) |
| 445 |
self.assertEqual(res.context["object"], self.author) |
| 446 |
self.assertEqual(res.context["author"], self.author) |
| 447 |
self.assertTemplateUsed(res, "generic_views/author_confirm_delete.html") |
| 448 |
res = self.client.post( |
| 449 |
"/edit/author/%d/delete/form/" % self.author.pk, data={"confirm": True} |
| 450 |
) |
| 451 |
self.assertEqual(res.status_code, 302) |
| 452 |
self.assertRedirects(res, "/list/authors/") |
| 453 |
self.assertSequenceEqual(Author.objects.all(), []) |
| 454 |
|
| 455 |
def test_delete_with_form_as_post_with_validation_error(self): |
| 456 |
res = self.client.get("/edit/author/%d/delete/form/" % self.author.pk) |
| 457 |
self.assertEqual(res.status_code, 200) |
| 458 |
self.assertEqual(res.context["object"], self.author) |
| 459 |
self.assertEqual(res.context["author"], self.author) |
| 460 |
self.assertTemplateUsed(res, "generic_views/author_confirm_delete.html") |
| 461 |
|
| 462 |
res = self.client.post("/edit/author/%d/delete/form/" % self.author.pk) |
| 463 |
self.assertEqual(res.status_code, 200) |
| 464 |
self.assertEqual(len(res.context_data["form"].errors), 2) |
| 465 |
self.assertEqual( |
| 466 |
res.context_data["form"].errors["__all__"], |
| 467 |
["You must confirm the delete."], |
| 468 |
) |
| 469 |
self.assertEqual( |
| 470 |
res.context_data["form"].errors["confirm"], |
| 471 |
["This field is required."], |
| 472 |
) |