|
1 import json |
|
2 |
|
3 from django.contrib.auth import get_user_model |
|
4 from django.core.urlresolvers import reverse |
|
5 from renkanmanager.models import Renkan, Revision |
|
6 from rest_framework import status |
|
7 from rest_framework.test import APITestCase |
|
8 |
|
9 |
|
10 User = get_user_model() |
|
11 |
|
12 class RenkanTests(APITestCase): |
|
13 |
|
14 def setUp(self): |
|
15 User.objects.create_superuser("blop", "blop@blop.com", "blop") |
|
16 self.user = User.objects.get(username="blop") |
|
17 _ = self.client.login(username="blop", password="blop") |
|
18 User.objects.create_user("blip", "blip@blip.com", "blip") |
|
19 self.unauthorized_user = User.objects.get(username="blip") |
|
20 |
|
21 # POSTing test workspace |
|
22 post_url = reverse("v1.0:workspace_list") |
|
23 test_title = "bleh_title" |
|
24 data = {"title": test_title} |
|
25 post_response = self.client.post(post_url, data, format="json") |
|
26 self.test_workspace_guid = json.loads(post_response.content.decode()).get("id") |
|
27 self.first_test_title = "test_title_1" |
|
28 self.first_test_content = json.dumps({ |
|
29 "id": "", |
|
30 "title": "test_title_1", |
|
31 "description": "test_description_1", |
|
32 "created": "", |
|
33 "updated": "", |
|
34 "edges": [], |
|
35 "nodes": [], |
|
36 "users": [], |
|
37 "space_id": "", |
|
38 "views": [] |
|
39 }) |
|
40 self.second_test_title = "test_title_1" |
|
41 self.second_test_content = json.dumps({ |
|
42 "id": "", |
|
43 "title": "test_title_2", |
|
44 "description": "test_description_2", |
|
45 "created": "", |
|
46 "updated": "", |
|
47 "edges": [], |
|
48 "nodes": [], |
|
49 "users": [], |
|
50 "space_id": "", |
|
51 "views": [] |
|
52 }) |
|
53 self.third_test_title = "test_title_1" |
|
54 self.third_test_content = json.dumps({ |
|
55 "id": "", |
|
56 "title": "test_title_3", |
|
57 "description": "test_description_3", |
|
58 "created": "", |
|
59 "updated": "", |
|
60 "edges": [], |
|
61 "nodes": [], |
|
62 "users": [], |
|
63 "space_id": "", |
|
64 "views": [] |
|
65 }) |
|
66 |
|
67 def test_create_renkan(self): |
|
68 |
|
69 ################################################### |
|
70 # POSTing new Renkan |
|
71 ################################################### |
|
72 |
|
73 post_url = reverse("v1.0:renkan_list") |
|
74 data = {"title": self.first_test_title, "content": self.first_test_content} |
|
75 |
|
76 post_response = self.client.post(post_url, data, format="json") |
|
77 self.assertEqual(post_response.status_code, status.HTTP_201_CREATED) |
|
78 self.assertEqual(Renkan.objects.count(), 1) |
|
79 self.assertEqual(Revision.objects.count(), 1) |
|
80 |
|
81 # Checking POSTed Renkan data |
|
82 post_response_dict = json.loads(post_response.content.decode()) |
|
83 new_renkan_guid = post_response_dict.get("id", "") |
|
84 new_renkan = Renkan.objects.get(renkan_guid=new_renkan_guid) |
|
85 # GUIDs and username |
|
86 self.assertEqual(self.user.username, post_response_dict.get("created_by", "")) |
|
87 self.assertEqual(self.user.username, post_response_dict.get("last_updated_by", "")) |
|
88 self.assertEqual(self.user.username, new_renkan.creator.username) |
|
89 # Content and title extracted from revision |
|
90 self.assertEqual(new_renkan.title, self.first_test_title) |
|
91 self.assertEqual(new_renkan.content, self.first_test_content) |
|
92 # Revision count |
|
93 self.assertEqual(new_renkan.revision_count, 1) |
|
94 self.assertEqual(post_response_dict.get("revision_count", ""), 1) |
|
95 |
|
96 # Checking POSTed Renkan revision data |
|
97 new_renkan_revision_guid = post_response_dict.get("current_revision_id", "") |
|
98 new_renkan_revision = Revision.objects.get(revision_guid = new_renkan_revision_guid) |
|
99 # GUIDs and username |
|
100 self.assertEqual(self.user.username, new_renkan_revision.creator.username) |
|
101 self.assertEqual(self.user.username, new_renkan_revision.last_updated_by.username) |
|
102 # Title and content |
|
103 # in the response |
|
104 self.assertEqual(post_response_dict.get("title", ""), self.first_test_title) |
|
105 self.assertEqual(post_response_dict.get("content", ""), self.first_test_content) |
|
106 # in the database |
|
107 self.assertEqual(new_renkan_revision.title, self.first_test_title) |
|
108 self.assertEqual(new_renkan_revision.content, self.first_test_content) |
|
109 |
|
110 # Checking permission |
|
111 self.assertTrue(self.user.has_perm("view_renkan", new_renkan)) |
|
112 |
|
113 ################################################### |
|
114 # POSTing new Renkan into workspace |
|
115 ################################################### |
|
116 |
|
117 post_url = reverse("v1.0:renkan_list_workspace", kwargs={"workspace_guid": self.test_workspace_guid}) |
|
118 data = {"title": self.second_test_title, "content": self.second_test_content} |
|
119 |
|
120 post_response = self.client.post(post_url, data, format="json") |
|
121 self.assertEqual(post_response.status_code, status.HTTP_201_CREATED) |
|
122 self.assertEqual(Renkan.objects.count(), 2) |
|
123 self.assertEqual(Revision.objects.count(), 2) |
|
124 |
|
125 # Checking POSTed Renkan data |
|
126 post_response_dict = json.loads(post_response.content.decode()) |
|
127 new_renkan_guid = post_response_dict.get("id", "") |
|
128 new_renkan = Renkan.objects.get(renkan_guid=new_renkan_guid) |
|
129 # GUIDs and username |
|
130 self.assertEqual(self.test_workspace_guid, post_response_dict.get("workspace_id", "")) |
|
131 self.assertEqual(self.test_workspace_guid, new_renkan.workspace_guid) |
|
132 self.assertEqual(self.user.username, post_response_dict.get("created_by", "")) |
|
133 self.assertEqual(self.user.username, post_response_dict.get("last_updated_by", "")) |
|
134 self.assertEqual(self.user.username, new_renkan.creator.username) |
|
135 # Content and title extracted from revision |
|
136 self.assertEqual(new_renkan.title, self.second_test_title) |
|
137 self.assertEqual(new_renkan.content, self.second_test_content) |
|
138 # Revision count |
|
139 self.assertEqual(new_renkan.revision_count, 1) |
|
140 self.assertEqual(post_response_dict.get("revision_count", ""), 1) |
|
141 |
|
142 ################################################### |
|
143 # POSTing new Renkan with no content |
|
144 ################################################### |
|
145 post_url = reverse("v1.0:renkan_list_workspace", kwargs={"workspace_guid": self.test_workspace_guid}) |
|
146 test_title = "bleh_title_2" |
|
147 data = {"title": test_title} |
|
148 post_response = self.client.post(post_url, data, format="json") |
|
149 self.assertEqual(post_response.status_code, status.HTTP_201_CREATED) |
|
150 self.assertEqual(Renkan.objects.count(), 3) |
|
151 self.assertEqual(Revision.objects.count(), 3) |
|
152 |
|
153 ################################################### |
|
154 # POSTing with wrong workspace_guid |
|
155 ################################################### |
|
156 |
|
157 post_url = reverse("v1.0:renkan_list_workspace", kwargs={"workspace_guid": "bleh-bad-workspace-guid"}) |
|
158 data = {"title": self.third_test_title, "content": self.third_test_content} |
|
159 |
|
160 post_response = self.client.post(post_url, data, format="json") |
|
161 self.assertEqual(post_response.status_code, status.HTTP_404_NOT_FOUND) |
|
162 |
|
163 ################################################### |
|
164 # try POSTing with unauthorized user |
|
165 ################################################### |
|
166 |
|
167 _ = self.client.login(username="blip", password="blip") |
|
168 post_url = reverse("v1.0:renkan_list_workspace", kwargs={"workspace_guid": self.test_workspace_guid}) |
|
169 data = {"title": self.third_test_title, "content": self.third_test_content} |
|
170 post_response = self.client.post(post_url, data, format="json") |
|
171 self.assertEqual(post_response.status_code, status.HTTP_403_FORBIDDEN) |
|
172 |
|
173 def test_get_renkan(self): |
|
174 |
|
175 ################################################### |
|
176 # POSTing new Renkan |
|
177 ################################################### |
|
178 |
|
179 post_url = reverse("v1.0:renkan_list") |
|
180 data = {} |
|
181 post_response = self.client.post(post_url, data, format="json") |
|
182 post_response_dict = json.loads(post_response.content.decode()) |
|
183 new_renkan_guid = post_response_dict.get("id", "") |
|
184 new_revision_guid = post_response_dict.get("current_revision_id", "") |
|
185 |
|
186 ################################################### |
|
187 # GETting posted Renkan |
|
188 ################################################### |
|
189 |
|
190 get_url = reverse("v1.0:renkan_detail", kwargs={"renkan_guid":new_renkan_guid}) |
|
191 get_response = self.client.get(get_url, format="json") |
|
192 self.assertEqual(get_response.status_code, status.HTTP_200_OK) |
|
193 |
|
194 # Checking GET data |
|
195 get_response_dict = json.loads(get_response.content.decode()) |
|
196 self.assertEqual(new_renkan_guid, get_response_dict.get("id", "")) |
|
197 self.assertEqual(new_revision_guid, get_response_dict.get("current_revision_id", "")) |
|
198 self.assertEqual(self.user.username, get_response_dict.get("created_by", "")) |
|
199 self.assertEqual(self.user.username, get_response_dict.get("last_updated_by", "")) |
|
200 |
|
201 ################################################### |
|
202 # GETting with wrong guid |
|
203 ################################################### |
|
204 |
|
205 get_url = reverse("v1.0:renkan_detail", kwargs={"renkan_guid": "bad-id"}) |
|
206 get_response = self.client.get(get_url, format="json") |
|
207 self.assertEqual(get_response.status_code, status.HTTP_404_NOT_FOUND) |
|
208 |
|
209 ################################################### |
|
210 # try GETting with unauthorized user |
|
211 ################################################### |
|
212 |
|
213 _ = self.client.login(username="blip", password="blip") |
|
214 get_url = reverse("v1.0:renkan_detail", kwargs={"renkan_guid": new_renkan_guid}) |
|
215 get_response = self.client.get(get_url, format="json") |
|
216 self.assertEqual(get_response.status_code, status.HTTP_403_FORBIDDEN) |
|
217 |
|
218 def test_get_renkan_list(self): |
|
219 |
|
220 ################################################### |
|
221 # POSTing new Renkans |
|
222 ################################################### |
|
223 |
|
224 post_url = reverse("v1.0:renkan_list") |
|
225 first_data = {"title": self.first_test_title, "content": self.first_test_content} |
|
226 second_data = {"title": self.second_test_title, "content": self.second_test_content} |
|
227 self.client.post(post_url, first_data, format="json") |
|
228 self.client.post(post_url, second_data, format="json") |
|
229 |
|
230 ################################################### |
|
231 # GETting posted Renkans |
|
232 ################################################### |
|
233 |
|
234 get_url = post_url |
|
235 get_response = self.client.get(get_url, format="json") |
|
236 self.assertEqual(get_response.status_code, status.HTTP_200_OK) |
|
237 |
|
238 get_response_content = json.loads(get_response.content.decode()) # Should be a list |
|
239 self.assertTrue(isinstance(get_response_content, list)) |
|
240 self.assertEqual(len(get_response_content), 2) |
|
241 |
|
242 ################################################### |
|
243 # POSTing new Renkan into workspace |
|
244 ################################################### |
|
245 |
|
246 post_url = reverse("v1.0:renkan_list_workspace", kwargs={"workspace_guid": self.test_workspace_guid}) |
|
247 third_data = {"title": self.third_test_title, "content": self.third_test_content} |
|
248 self.client.post(post_url, third_data, format="json") |
|
249 |
|
250 ################################################### |
|
251 # GETting posted Renkans |
|
252 ################################################### |
|
253 |
|
254 get_url = post_url |
|
255 get_response = self.client.get(get_url, format="json") |
|
256 self.assertEqual(get_response.status_code, status.HTTP_200_OK) |
|
257 |
|
258 get_response_content = json.loads(get_response.content.decode()) # Should be a list |
|
259 self.assertTrue(isinstance(get_response_content, list)) |
|
260 self.assertEqual(len(get_response_content), 1) |
|
261 |
|
262 |
|
263 def test_update_renkan(self): |
|
264 |
|
265 ################################################### |
|
266 # POSTing new Renkan |
|
267 ################################################### |
|
268 |
|
269 post_url = reverse("v1.0:renkan_list") |
|
270 data = {} |
|
271 post_response = self.client.post(post_url, data, format="json") |
|
272 post_response_dict = json.loads(post_response.content.decode()) |
|
273 renkan_guid = post_response_dict.get("id", "") |
|
274 revision_guid = post_response_dict.get("current_revision_id", "") |
|
275 |
|
276 ################################################### |
|
277 # PUTting by updating current revision |
|
278 ################################################### |
|
279 |
|
280 put_url = reverse("v1.0:renkan_detail", kwargs={"renkan_guid": renkan_guid}) |
|
281 put_data = { |
|
282 "title" : self.first_test_title, |
|
283 "content" : self.first_test_content, |
|
284 "create_new_revision": False |
|
285 } |
|
286 put_response = self.client.put(put_url, put_data, format="json") |
|
287 self.assertEqual(put_response.status_code, status.HTTP_200_OK) |
|
288 put_response_dict = json.loads(put_response.content.decode()) |
|
289 # checking we"re still on the same revision as the initial one |
|
290 updated_project = Renkan.objects.get(renkan_guid=renkan_guid) |
|
291 self.assertEqual(revision_guid, put_response_dict.get("current_revision_id", "")) |
|
292 self.assertEqual(put_response_dict.get("revision_count", ""), 1) |
|
293 self.assertEqual(updated_project.revision_count, 1) |
|
294 |
|
295 self.assertEqual(revision_guid, updated_project.current_revision_guid) |
|
296 # checking data was updated |
|
297 # in the reponse |
|
298 self.assertEqual(put_response_dict.get("title", ""), self.first_test_title) |
|
299 self.assertEqual(put_response_dict.get("content", ""), self.first_test_content) |
|
300 # in the database |
|
301 updated_revision = Revision.objects.get(revision_guid=revision_guid) |
|
302 self.assertEqual(updated_revision.title, self.first_test_title) |
|
303 self.assertEqual(updated_revision.content, self.first_test_content) |
|
304 |
|
305 ################################################### |
|
306 # PUTting by creating a new revision |
|
307 ################################################### |
|
308 |
|
309 put_data = { |
|
310 "title" : self.second_test_title, |
|
311 "content" : self.second_test_content, |
|
312 "create_new_revision": True |
|
313 } |
|
314 put_response = self.client.put(put_url, put_data, format="json") |
|
315 self.assertEqual(put_response.status_code, status.HTTP_200_OK) |
|
316 put_response_dict = json.loads(put_response.content.decode()) |
|
317 |
|
318 # checking we created a new revision |
|
319 updated_project = Renkan.objects.get(renkan_guid=renkan_guid) |
|
320 created_revision_guid = put_response_dict.get("current_revision_id", "") |
|
321 self.assertNotEqual(created_revision_guid, revision_guid) |
|
322 self.assertEqual(Renkan.objects.count(), 1) |
|
323 self.assertEqual(Revision.objects.count(), 2) |
|
324 self.assertEqual(put_response_dict.get("revision_count", ""), 2) |
|
325 self.assertEqual(updated_project.revision_count, 2) |
|
326 |
|
327 # checking project now points towards new revision |
|
328 self.assertEqual(updated_project.current_revision_guid, created_revision_guid) |
|
329 # checking data was updated |
|
330 # in the reponse |
|
331 self.assertEqual(put_response_dict.get("title", ""), self.second_test_title) |
|
332 self.assertEqual(put_response_dict.get("content", ""), self.second_test_content) |
|
333 # in the database |
|
334 updated_revision = Revision.objects.get(revision_guid=created_revision_guid) |
|
335 self.assertEqual(updated_revision.title, self.second_test_title) |
|
336 self.assertEqual(updated_revision.content, self.second_test_content) |
|
337 |
|
338 ################################################### |
|
339 # try to update source_revision_guid or workspace_guid |
|
340 ################################################### |
|
341 |
|
342 put_data = { |
|
343 "title" : self.third_test_title, |
|
344 "content" : self.third_test_content, |
|
345 "workspace_id": "bleh-workspace-guid" # should fail without even checking the id |
|
346 } |
|
347 put_response = self.client.put(put_url, put_data, format="json") |
|
348 self.assertEqual(put_response.status_code, status.HTTP_400_BAD_REQUEST) |
|
349 |
|
350 put_data = { |
|
351 "title" : self.third_test_title, |
|
352 "content" : self.third_test_content, |
|
353 "source_revision_id" : "bleh-revision-guid" # should fail without even checking the id |
|
354 } |
|
355 put_response = self.client.put(put_url, put_data, format="json") |
|
356 self.assertEqual(put_response.status_code, status.HTTP_400_BAD_REQUEST) |
|
357 |
|
358 ################################################### |
|
359 # PUTting with wrong guid |
|
360 ################################################### |
|
361 |
|
362 put_url = reverse("v1.0:renkan_detail", kwargs={"renkan_guid": "bad-id"}) |
|
363 put_response = self.client.put(put_url, {}, format="json") |
|
364 self.assertEqual(put_response.status_code, status.HTTP_404_NOT_FOUND) |
|
365 |
|
366 ################################################### |
|
367 # try PUTting with unauthorized user |
|
368 ################################################### |
|
369 |
|
370 _ = self.client.login(username="blip", password="blip") |
|
371 put_url = reverse("v1.0:renkan_detail", kwargs={"renkan_guid": renkan_guid}) |
|
372 put_data = { |
|
373 "title" : self.third_test_title, |
|
374 "content" : self.third_test_content, |
|
375 "create_new_revision": False |
|
376 } |
|
377 put_response = self.client.put(put_url, put_data, format="json") |
|
378 self.assertEqual(put_response.status_code, status.HTTP_403_FORBIDDEN) |
|
379 |
|
380 def test_copy_renkan(self): |
|
381 |
|
382 ################################################### |
|
383 # POSTing new Renkan |
|
384 ################################################### |
|
385 |
|
386 post_url = reverse("v1.0:renkan_list") |
|
387 data = {"title": self.first_test_title, "content": self.first_test_content} |
|
388 post_response = self.client.post(post_url, data, format="json") |
|
389 post_response_dict = json.loads(post_response.content.decode()) |
|
390 source_renkan_guid = post_response_dict.get("id", "") |
|
391 source_revision_guid = post_response_dict.get("current_revision_id", "") |
|
392 |
|
393 ################################################### |
|
394 # POSTing copy with query arg for RENKAN guid |
|
395 ################################################### |
|
396 |
|
397 first_copy_data = {"title": "new_title_copy_1"} |
|
398 first_copy_url = post_url+"?source_renkan_id="+source_renkan_guid |
|
399 first_copy_response = self.client.post(first_copy_url, first_copy_data, format="json") |
|
400 first_copy_response_dict = json.loads(first_copy_response.content.decode()) |
|
401 self.assertEqual(first_copy_response.status_code, status.HTTP_201_CREATED) |
|
402 self.assertEqual(Renkan.objects.count(), 2) |
|
403 # Checking data |
|
404 # in the response |
|
405 self.assertNotEqual(first_copy_response_dict.get("id"), source_renkan_guid) |
|
406 self.assertEqual(first_copy_response_dict.get("source_revision_id"), source_revision_guid) |
|
407 self.assertEqual(first_copy_response_dict.get("title", ""), "new_title_copy_1") |
|
408 self.assertEqual(first_copy_response_dict.get("content", ""), self.first_test_content) |
|
409 self.assertEqual(first_copy_response_dict.get("created_by", ""), self.user.username) |
|
410 self.assertEqual(first_copy_response_dict.get("last_updated_by", ""), self.user.username) |
|
411 # in the database |
|
412 first_copy = Renkan.objects.get(renkan_guid=first_copy_response_dict.get("id", "")) |
|
413 first_copy_revision = Revision.objects.get(revision_guid=first_copy_response_dict.get("current_revision_id", "")) |
|
414 self.assertEqual(first_copy.title, "new_title_copy_1") |
|
415 self.assertEqual(first_copy.content, self.first_test_content) |
|
416 self.assertEqual(first_copy_revision.title, "new_title_copy_1") |
|
417 self.assertEqual(first_copy_revision.content, self.first_test_content) |
|
418 self.assertEqual(first_copy.creator.username, self.user.username) |
|
419 self.assertEqual(first_copy_revision.creator.username, self.user.username) |
|
420 self.assertEqual(first_copy_revision.last_updated_by.username, self.user.username) |
|
421 |
|
422 ################################################### |
|
423 # POSTing copy with source_renkan_guid in data |
|
424 ################################################### |
|
425 |
|
426 second_copy_data = {"source_renkan_id": source_renkan_guid, "title": "new_title_copy_2"} |
|
427 second_copy_url = post_url |
|
428 second_copy_response = self.client.post(second_copy_url, second_copy_data, format="json") |
|
429 second_copy_response_dict = json.loads(second_copy_response.content.decode()) |
|
430 self.assertEqual(second_copy_response.status_code, status.HTTP_201_CREATED) |
|
431 self.assertEqual(Renkan.objects.count(), 3) |
|
432 # Checking data |
|
433 # in the response |
|
434 self.assertNotEqual(second_copy_response_dict.get("id"), source_renkan_guid) |
|
435 self.assertEqual(second_copy_response_dict.get("source_revision_id"), source_revision_guid) |
|
436 self.assertEqual(second_copy_response_dict.get("title", ""), "new_title_copy_2") |
|
437 self.assertEqual(second_copy_response_dict.get("content", ""), self.first_test_content) |
|
438 self.assertEqual(second_copy_response_dict.get("created_by", ""), self.user.username) |
|
439 self.assertEqual(second_copy_response_dict.get("last_updated_by", ""), self.user.username) |
|
440 # in the database |
|
441 second_copy = Renkan.objects.get(renkan_guid=second_copy_response_dict.get("id", "")) |
|
442 second_copy_revision = Revision.objects.get(revision_guid=second_copy_response_dict.get("current_revision_id", "")) |
|
443 self.assertEqual(second_copy.title, "new_title_copy_2") |
|
444 self.assertEqual(second_copy.content, self.first_test_content) |
|
445 self.assertEqual(second_copy_revision.title, "new_title_copy_2") |
|
446 self.assertEqual(second_copy_revision.content, self.first_test_content) |
|
447 self.assertEqual(second_copy.creator.username, self.user.username) |
|
448 self.assertEqual(second_copy_revision.creator.username, self.user.username) |
|
449 self.assertEqual(second_copy_revision.last_updated_by.username, self.user.username) |
|
450 |
|
451 ################################################### |
|
452 # POSTing copy with query arg for REVISION guid |
|
453 ################################################### |
|
454 |
|
455 third_copy_data = {"title": "new_title_copy_3"} |
|
456 third_copy_url = post_url+"?source_revision_id="+source_revision_guid |
|
457 third_copy_response = self.client.post(third_copy_url, third_copy_data, format="json") |
|
458 third_copy_response_dict = json.loads(third_copy_response.content.decode()) |
|
459 self.assertEqual(third_copy_response.status_code, status.HTTP_201_CREATED) |
|
460 self.assertEqual(Renkan.objects.count(), 4) |
|
461 # Checking data |
|
462 # in the response |
|
463 self.assertNotEqual(third_copy_response_dict.get("id"), source_renkan_guid) |
|
464 self.assertEqual(third_copy_response_dict.get("source_revision_id"), source_revision_guid) |
|
465 self.assertEqual(third_copy_response_dict.get("title", ""), "new_title_copy_3") |
|
466 self.assertEqual(third_copy_response_dict.get("content", ""), self.first_test_content) |
|
467 self.assertEqual(third_copy_response_dict.get("created_by", ""), self.user.username) |
|
468 self.assertEqual(third_copy_response_dict.get("last_updated_by", ""), self.user.username) |
|
469 # in the database |
|
470 third_copy = Renkan.objects.get(renkan_guid=third_copy_response_dict.get("id", "")) |
|
471 third_copy_revision = Revision.objects.get(revision_guid=third_copy_response_dict.get("current_revision_id", "")) |
|
472 self.assertEqual(third_copy.title, "new_title_copy_3") |
|
473 self.assertEqual(third_copy.content, self.first_test_content) |
|
474 self.assertEqual(third_copy_revision.title, "new_title_copy_3") |
|
475 self.assertEqual(third_copy_revision.content, self.first_test_content) |
|
476 self.assertEqual(third_copy.creator.username, self.user.username) |
|
477 self.assertEqual(third_copy_revision.creator.username, self.user.username) |
|
478 self.assertEqual(third_copy_revision.last_updated_by.username, self.user.username) |
|
479 |
|
480 ################################################### |
|
481 # POSTing copy with source_revision_guid in data |
|
482 ################################################### |
|
483 |
|
484 fourth_copy_data = {"source_revision_id": source_revision_guid} |
|
485 fourth_copy_url = post_url |
|
486 fourth_copy_response = self.client.post(fourth_copy_url, fourth_copy_data, format="json") |
|
487 fourth_copy_response_dict = json.loads(fourth_copy_response.content.decode()) |
|
488 self.assertEqual(fourth_copy_response.status_code, status.HTTP_201_CREATED) |
|
489 self.assertEqual(Renkan.objects.count(), 5) |
|
490 # Checking data |
|
491 # in the response |
|
492 self.assertNotEqual(fourth_copy_response_dict.get("id"), source_renkan_guid) |
|
493 self.assertEqual(fourth_copy_response_dict.get("source_revision_id"), source_revision_guid) |
|
494 self.assertEqual(fourth_copy_response_dict.get("title", ""), self.first_test_title) |
|
495 self.assertEqual(fourth_copy_response_dict.get("content", ""), self.first_test_content) |
|
496 self.assertEqual(fourth_copy_response_dict.get("created_by", ""), self.user.username) |
|
497 self.assertEqual(fourth_copy_response_dict.get("last_updated_by", ""), self.user.username) |
|
498 # in the database |
|
499 fourth_copy = Renkan.objects.get(renkan_guid=fourth_copy_response_dict.get("id", "")) |
|
500 fourth_copy_revision = Revision.objects.get(revision_guid=fourth_copy_response_dict.get("current_revision_id", "")) |
|
501 self.assertEqual(fourth_copy.title, self.first_test_title) |
|
502 self.assertEqual(fourth_copy.content, self.first_test_content) |
|
503 self.assertEqual(fourth_copy_revision.title, self.first_test_title) |
|
504 self.assertEqual(fourth_copy_revision.content, self.first_test_content) |
|
505 self.assertEqual(fourth_copy.creator.username, self.user.username) |
|
506 self.assertEqual(fourth_copy_revision.creator.username, self.user.username) |
|
507 self.assertEqual(fourth_copy_revision.last_updated_by.username, self.user.username) |
|
508 |
|
509 |
|
510 ################################################### |
|
511 # try POSTing copy with bad query arg guid and with bad data guid |
|
512 ################################################### |
|
513 |
|
514 bad_copy_data = {"source_revision_id": "bleh_bad_id"} |
|
515 # with query arg |
|
516 qarg_bad_copy_url = post_url+"?source_revision_id=bleh_bad_id" |
|
517 qarg_bad_copy_response = self.client.post(qarg_bad_copy_url, {}, format="json") |
|
518 self.assertEqual(qarg_bad_copy_response.status_code, status.HTTP_404_NOT_FOUND) |
|
519 # with data |
|
520 data_bad_copy_url = post_url |
|
521 data_bad_copy_response = self.client.post(data_bad_copy_url, bad_copy_data, format="json") |
|
522 self.assertEqual(data_bad_copy_response.status_code, status.HTTP_404_NOT_FOUND) |
|
523 |
|
524 ################################################### |
|
525 # try POSTing with unauthorized user |
|
526 ################################################### |
|
527 |
|
528 _ = self.client.login(username="blip", password="blip") |
|
529 post_url = reverse("v1.0:renkan_list")+"?source_revision_id="+source_revision_guid |
|
530 post_response = self.client.post(post_url, {}, format="json") |
|
531 self.assertEqual(post_response.status_code, status.HTTP_403_FORBIDDEN) |
|
532 |
|
533 def test_delete_renkan(self): |
|
534 |
|
535 ################################################### |
|
536 # POSTing new Renkan |
|
537 ################################################### |
|
538 |
|
539 post_url = reverse("v1.0:renkan_list") |
|
540 data = {"title": self.first_test_title, "content": self.first_test_content} |
|
541 post_response = self.client.post(post_url, data, format="json") |
|
542 post_response_dict = json.loads(post_response.content.decode()) |
|
543 to_delete_renkan_guid = post_response_dict.get("id", "") |
|
544 to_delete_revision_guid = post_response_dict.get("current_revision_id", "") |
|
545 |
|
546 ################################################### |
|
547 # POSTing copy |
|
548 ################################################### |
|
549 data = {} |
|
550 post_response = self.client.post(post_url+"?source="+to_delete_renkan_guid, data, format="json") |
|
551 post_response_dict = json.loads(post_response.content.decode()) |
|
552 copy_renkan_guid = post_response_dict.get("id", "") |
|
553 |
|
554 # Adding another revision |
|
555 put_data = {"title": self.first_test_title+"_edited!", "create_new_revision": True} |
|
556 put_url = reverse("v1.0:renkan_detail", kwargs={"renkan_guid":to_delete_renkan_guid}) |
|
557 put_response = self.client.put(put_url, put_data, format="json") |
|
558 self.assertEqual(Renkan.objects.count(), 2) |
|
559 self.assertEqual(Revision.objects.count(), 3) |
|
560 |
|
561 ################################################### |
|
562 # try to DELETE with unauthorized user |
|
563 ################################################### |
|
564 |
|
565 _ = self.client.login(username="blip", password="blip") |
|
566 delete_url = reverse("v1.0:renkan_detail", kwargs={"renkan_guid":to_delete_renkan_guid}) |
|
567 delete_response = self.client.delete(delete_url, format="json") |
|
568 self.assertEqual(delete_response.status_code, status.HTTP_403_FORBIDDEN) |
|
569 |
|
570 # Restoring rightful user |
|
571 _ = self.client.login(username="blop", password="blop") |
|
572 |
|
573 ################################################### |
|
574 # DELETE initial renkan |
|
575 ################################################### |
|
576 |
|
577 delete_url = reverse("v1.0:renkan_detail", kwargs={"renkan_guid":to_delete_renkan_guid}) |
|
578 delete_response = self.client.delete(delete_url, format="json") |
|
579 self.assertEqual(delete_response.status_code, status.HTTP_204_NO_CONTENT) |
|
580 self.assertEqual(Renkan.objects.count(), 1) # Only the copy remains |
|
581 self.assertEqual(Revision.objects.count(), 1) # Only the copy initial revision remains |
|
582 |
|
583 ################################################### |
|
584 # Try to GET deleted renkan |
|
585 ################################################### |
|
586 |
|
587 get_url = reverse("v1.0:renkan_detail", kwargs={"renkan_guid":to_delete_renkan_guid}) |
|
588 get_response = self.client.get(get_url, format="json") |
|
589 self.assertEqual(get_response.status_code, status.HTTP_404_NOT_FOUND) |
|
590 |
|
591 ################################################### |
|
592 # Check that remaining renkan doesn"t have reference to deleted renkan |
|
593 ################################################### |
|
594 copy_renkan = Renkan.objects.get(renkan_guid=copy_renkan_guid) |
|
595 self.assertEqual(copy_renkan.source_revision_guid, "") |
|
596 |
|
597 ################################################### |
|
598 # Try to DELETE renkan with wrong guid |
|
599 ################################################### |
|
600 |
|
601 delete_url = reverse("v1.0:renkan_detail", kwargs={"renkan_guid": "bad-id"}) |
|
602 delete_response = self.client.delete(delete_url, format="json") |
|
603 self.assertEqual(delete_response.status_code, status.HTTP_404_NOT_FOUND) |
|
604 |