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