← Back to branch summary

~ursinha/ubuntu-ci-services-itself/private-only-is-env-variable

« back to all changes in this revision

Viewing changes to ticket_system/ticket/tests/test_write_api.py

  • Committer: Ursula Junque (Ursinha)
  • Date: 2014-03-14 21:40:47 UTC
  • Revision ID: ursinha@canonical.com-20140314214047-oxu080435bqw0mor
Fixing tests to use right variable; Making it explicit the user choice for privacy

Show diffs side-by-side

added added

removed removed

Lines of Context:
ticket_system/ticket/tests/test_write_api.py
14
14
# along with this program.  If not, see <http://www.gnu.org/licenses/>.
15
15
 
16
16
from model_mommy import mommy
 
17
from model_mommy.recipe import Recipe, seq
17
18
from ci_utils.tastypie.test import TastypieTestCase
18
 
from ticket.models import (Artifact, SourcePackageUpload, SubTicket,
 
19
from project.models import SourcePackage
 
20
from ticket.models import (TicketArtifact, SourcePackageUpload, SubTicket,
19
21
                           SubTicketWorkflowStep, SubTicketWorkflowStepStatus,
20
 
                           Ticket, TicketWorkflowStep,
 
22
                           Ticket, TicketWorkflowStep, SubTicketArtifact,
21
23
                           TicketWorkflowStepStatus)
 
24
from project.models import BinaryPackage
 
25
 
 
26
 
 
27
def create_ticket(added=None, removed=None):
 
28
    return mommy.make('Ticket', removed_binaries=removed, added_binaries=added)
 
29
 
 
30
 
 
31
sourcepackage_recipe = Recipe(SourcePackage, name=seq('foobar'))
22
32
 
23
33
 
24
34
class APICreateTicketResourceTest(TastypieTestCase):
25
35
 
26
36
    def setUp(self):
27
37
        super(APICreateTicketResourceTest, self).setUp('/api/v1')
28
 
        self.ticket = mommy.make('Ticket')
 
38
        self.ticket = create_ticket()
29
39
        self.resource = 'ticket/'
30
40
        self.detail_url = self.resource + '{0}/'.format(self.ticket.pk)
31
41
        self.post_ticket_data = {
68
78
 
69
79
    def setUp(self):
70
80
        super(APICreateSPUResourceTest, self).setUp('/api/v1')
71
 
        self.sourcepackage = mommy.make('SourcePackage')
 
81
        self.sourcepackage = sourcepackage_recipe.make()
72
82
        self.spu = mommy.make('SourcePackageUpload',
73
83
                              sourcepackage=self.sourcepackage)
74
84
        self.resource = 'spu/'
112
122
    def setUp(self):
113
123
        super(APICreateSubTicketResourceTest, self).setUp('/api/v1')
114
124
        self.ticket = mommy.make('Ticket')
115
 
        self.spu = mommy.make('SourcePackageUpload')
 
125
        self.sourcepackage = sourcepackage_recipe.make()
 
126
        self.spu = mommy.make('SourcePackageUpload',
 
127
                              sourcepackage=self.sourcepackage)
116
128
        self.subticket = mommy.make('SubTicket', ticket=self.ticket,
117
129
                                    source_package_upload=self.spu)
118
130
        self.resource = 'subticket/'
119
131
        self.detail_url = self.resource + '{0}/'.format(self.subticket.pk)
120
 
        self.ticket_uri = '/api/v1/spu/{0}/'.format(self.ticket.pk)
 
132
        self.ticket_uri = '/api/v1/ticket/{0}/'.format(self.ticket.pk)
121
133
        self.spu_uri = '/api/v1/spu/{0}/'.format(self.spu.pk)
122
134
        self.post_subticket_data = {
123
135
            'source_package_upload': self.spu_uri,
125
137
            'assignee': 'test@example.com',
126
138
        }
127
139
 
128
 
    def test_post_subticket(self):
 
140
    def test_post_subticket_subticket(self):
129
141
        # Check how many are there first.
130
142
        self.assertEqual(SubTicket.objects.count(), 1)
131
143
        self.post(resource=self.resource, params=self.post_subticket_data)
152
164
        self.assertHttpMethodNotAllowed(resp)
153
165
 
154
166
 
155
 
class APICreateArtifactResourceTest(TastypieTestCase):
156
 
 
157
 
    def setUp(self):
158
 
        super(APICreateArtifactResourceTest, self).setUp('/api/v1')
159
 
        self.subticket = mommy.make('SubTicket')
160
 
        self.artifact = mommy.make('Artifact', subticket=self.subticket)
161
 
        self.resource = 'artifact/'
 
167
class APICreateTicketArtifactResourceTest(TastypieTestCase):
 
168
 
 
169
    def setUp(self):
 
170
        super(APICreateTicketArtifactResourceTest, self).setUp('/api/v1')
 
171
        self.ticket = mommy.make('Ticket')
 
172
        self.artifact = mommy.make('TicketArtifact',
 
173
                                   ticket=self.ticket)
 
174
        self.resource = 'ticketartifact/'
 
175
        self.detail_url = self.resource + '{0}/'.format(self.artifact.pk)
 
176
        self.ticket_uri = '/api/v1/ticket/{0}/'.format(self.ticket.pk)
 
177
        self.post_artifact_data_ticket = {
 
178
            'type': 'LOGS',
 
179
            'name': 'my_artifact',
 
180
            'ticket': self.ticket_uri,
 
181
            'reference': 'http://www.example.com/m1CTLg5FHY',
 
182
        }
 
183
 
 
184
    def test_post_artifact_ticket(self):
 
185
        """
 
186
        Test creating an artifact for a ticket via the API
 
187
        """
 
188
        # Check how many are there first.
 
189
        self.assertEqual(TicketArtifact.objects.count(), 1)
 
190
        self.post(resource=self.resource,
 
191
                  params=self.post_artifact_data_ticket)
 
192
        # Verify a new one has been added.
 
193
        self.assertEqual(TicketArtifact.objects.count(), 2)
 
194
 
 
195
    def test_patch_detail(self):
 
196
        # Grab the current data & modify it slightly.
 
197
        original_data = self.getResource(self.detail_url)
 
198
        new_data = original_data.copy()
 
199
        new_data['name'] = 'my_upload'
 
200
 
 
201
        self.assertEqual(TicketArtifact.objects.count(), 1)
 
202
        resp = self.client.patch('/api/v1/' + self.detail_url, data=new_data)
 
203
        self.assertHttpMethodNotAllowed(resp)
 
204
        # Make sure the count hasn't changed & we did an update.
 
205
        self.assertEqual(TicketArtifact.objects.count(), 1)
 
206
        # Check for updated data.
 
207
        self.assertEqual(TicketArtifact.objects.get(
 
208
                         pk=self.artifact.pk).name, self.artifact.name)
 
209
 
 
210
    def test_delete_artifact_not_allowed(self):
 
211
        resp = self.delete(resource=self.detail_url)
 
212
        self.assertHttpMethodNotAllowed(resp)
 
213
 
 
214
 
 
215
class APICreateSubTicketArtifactResourceTest(TastypieTestCase):
 
216
 
 
217
    def setUp(self):
 
218
        super(APICreateSubTicketArtifactResourceTest, self).setUp('/api/v1')
 
219
        self.sourcepackage = sourcepackage_recipe.make()
 
220
        self.spu = mommy.make('SourcePackageUpload',
 
221
                              sourcepackage=self.sourcepackage)
 
222
        self.ticket = mommy.make('Ticket')
 
223
        self.subticket = mommy.make('SubTicket', ticket=self.ticket,
 
224
                                    source_package_upload=self.spu)
 
225
        self.artifact = mommy.make('SubTicketArtifact',
 
226
                                   subticket=self.subticket)
 
227
        self.resource = 'subticketartifact/'
162
228
        self.detail_url = self.resource + '{0}/'.format(self.artifact.pk)
163
229
        self.subticket_uri = '/api/v1/subticket/{0}/'.format(self.subticket.pk)
164
 
        self.post_artifact_data = {
 
230
        self.post_artifact_data_subticket = {
165
231
            'type': 'SPU',
166
232
            'name': 'my_artifact',
167
233
            'subticket': self.subticket_uri,
168
 
            'reference': 'm1CTLg5FHY',
 
234
            'reference': 'http://www.example.com/m1CTLg5FHY',
169
235
        }
170
236
 
171
 
    def test_post_artifact(self):
 
237
    def test_post_artifact_subticket(self):
 
238
        """
 
239
        Test creating an artifact for a subticket via the API
 
240
        """
172
241
        # Check how many are there first.
173
 
        self.assertEqual(Artifact.objects.count(), 1)
174
 
        self.post(resource=self.resource, params=self.post_artifact_data)
 
242
        self.assertEqual(SubTicketArtifact.objects.count(), 1)
 
243
        self.post(resource=self.resource,
 
244
                  params=self.post_artifact_data_subticket)
175
245
        # Verify a new one has been added.
176
 
        self.assertEqual(Artifact.objects.count(), 2)
 
246
        self.assertEqual(SubTicketArtifact.objects.count(), 2)
177
247
 
178
248
    def test_patch_detail(self):
179
249
        # Grab the current data & modify it slightly.
181
251
        new_data = original_data.copy()
182
252
        new_data['name'] = 'my_upload'
183
253
 
184
 
        self.assertEqual(Artifact.objects.count(), 1)
 
254
        self.assertEqual(SubTicketArtifact.objects.count(), 1)
185
255
        resp = self.client.patch('/api/v1/' + self.detail_url, data=new_data)
186
256
        self.assertHttpMethodNotAllowed(resp)
187
257
        # Make sure the count hasn't changed & we did an update.
188
 
        self.assertEqual(Artifact.objects.count(), 1)
 
258
        self.assertEqual(SubTicketArtifact.objects.count(), 1)
189
259
        # Check for updated data.
190
 
        self.assertEqual(Artifact.objects.get(pk=self.artifact.pk).name,
191
 
                         self.artifact.name)
 
260
        self.assertEqual(SubTicketArtifact.objects.get(
 
261
                         pk=self.artifact.pk).name, self.artifact.name)
192
262
 
193
263
    def test_delete_artifact_not_allowed(self):
194
264
        resp = self.delete(resource=self.detail_url)
199
269
 
200
270
    def setUp(self):
201
271
        super(APIUpdateTicketStatuses, self).setUp('/api/v1')
202
 
        self.ticket = mommy.make('Ticket')
203
 
        self.ticket_detail_url = 'updateticketstatus/{0}/'.format(self.ticket.pk)
 
272
        mommy.make('BinaryPackage', name='binary3')
 
273
        mommy.make('BinaryPackage', name='binary4')
 
274
        mommy.make('BinaryPackage', name='binary5')
 
275
        self.ticket = create_ticket(added='binary1,binary2,binary6',
 
276
                                    removed='binary3,binary4')
 
277
        self.ticket_detail_url = 'updateticketstatus/{0}/'.format(
 
278
            self.ticket.pk)
204
279
 
205
280
    def test_patch_ticket_status(self):
206
281
        new_data = {
207
 
            'current_workflow_step': int(TicketWorkflowStep.IMAGE_BUILDING),
208
 
            'status': int(TicketWorkflowStepStatus.IMAGE_BUILDING_COMPLETED),
 
282
            'current_workflow_step': str(
 
283
                TicketWorkflowStep.IMAGE_BUILDING.value),
 
284
            'status': str(
 
285
                TicketWorkflowStepStatus.IMAGE_BUILDING_COMPLETED.value),
209
286
        }
210
287
        self.assertEqual(Ticket.objects.count(), 1)
211
 
        self.patch('/api/v1/' + self.ticket_detail_url,
212
 
                   new_data)
 
288
        self.assertEqual(BinaryPackage.objects.count(), 3)
 
289
        binaries = BinaryPackage.objects.all()
 
290
        self.assertQuerysetEqual(binaries,
 
291
                                 ["<BinaryPackage: binary3>",
 
292
                                  "<BinaryPackage: binary4>",
 
293
                                  "<BinaryPackage: binary5>"], ordered=False)
 
294
        self.patch('/api/v1/' + self.ticket_detail_url, new_data)
213
295
        # Make sure the count hasn't changed & we did an update.
214
296
        self.assertEqual(Ticket.objects.count(), 1)
215
297
        # Check for updated data.
 
298
        self.assertEqual(BinaryPackage.objects.count(), 3)
 
299
        binaries = BinaryPackage.objects.all()
 
300
        self.assertQuerysetEqual(binaries,
 
301
                                 ["<BinaryPackage: binary3>",
 
302
                                  "<BinaryPackage: binary4>",
 
303
                                  "<BinaryPackage: binary5>"], ordered=False)
216
304
        self.assertEqual(Ticket.objects.get(
217
305
            pk=self.ticket.pk).current_workflow_step,
218
306
            int(TicketWorkflowStep.IMAGE_BUILDING))
220
308
            Ticket.objects.get(pk=self.ticket.pk).status,
221
309
            int(TicketWorkflowStepStatus.IMAGE_BUILDING_COMPLETED))
222
310
 
 
311
    def test_update_ticket_status_complete(self):
 
312
        new_data = {
 
313
            "current_workflow_step": TicketWorkflowStep.COMPLETED.value,
 
314
            "status": TicketWorkflowStepStatus.COMPLETED.value,
 
315
        }
 
316
        self.assertEqual(Ticket.objects.count(), 1)
 
317
        self.assertEqual(BinaryPackage.objects.count(), 3)
 
318
        binaries = BinaryPackage.objects.all()
 
319
        self.assertQuerysetEqual(binaries,
 
320
                                 ["<BinaryPackage: binary3>",
 
321
                                  "<BinaryPackage: binary4>",
 
322
                                  "<BinaryPackage: binary5>"], ordered=False)
 
323
        self.assertEqual(Ticket.objects.get(
 
324
            pk=self.ticket.pk).current_workflow_step,
 
325
            self.ticket.current_workflow_step)
 
326
        self.assertEqual(Ticket.objects.get(
 
327
            pk=self.ticket.pk).status,
 
328
            self.ticket.status)
 
329
        self.patch('/api/v1/' + self.ticket_detail_url, new_data)
 
330
        self.assertEqual(Ticket.objects.count(), 1)
 
331
        self.assertEqual(BinaryPackage.objects.count(), 4)
 
332
        binaries = BinaryPackage.objects.all()
 
333
        self.assertQuerysetEqual(binaries,
 
334
                                 ["<BinaryPackage: binary1>",
 
335
                                  "<BinaryPackage: binary2>",
 
336
                                  "<BinaryPackage: binary5>",
 
337
                                  "<BinaryPackage: binary6>"], ordered=False)
 
338
        self.assertEqual(Ticket.objects.get(
 
339
            pk=self.ticket.pk).current_workflow_step,
 
340
            int(TicketWorkflowStep.COMPLETED))
 
341
        self.assertEqual(Ticket.objects.get(
 
342
            pk=self.ticket.pk).status,
 
343
            int(TicketWorkflowStepStatus.COMPLETED))
 
344
 
 
345
    def test_update_ticket_status_failed(self):
 
346
        '''Ensure we fail a ticket properly
 
347
 
 
348
        Let's not assume users of this API will update the ticket-status to
 
349
        failed when a workflow step fails. Ensure the API corrects this for
 
350
        the user.
 
351
        '''
 
352
        new_data = {
 
353
            "current_workflow_step": str(TicketWorkflowStep.COMPLETED.value),
 
354
            "status": TicketWorkflowStepStatus.PKG_BUILDING_FAILED.value,
 
355
        }
 
356
        self.assertEqual(Ticket.objects.count(), 1)
 
357
        self.assertEqual(Ticket.objects.get(
 
358
            pk=self.ticket.pk).current_workflow_step,
 
359
            self.ticket.current_workflow_step)
 
360
        self.assertEqual(Ticket.objects.get(
 
361
            pk=self.ticket.pk).status,
 
362
            self.ticket.status)
 
363
        self.patch('/api/v1/' + self.ticket_detail_url, new_data)
 
364
        self.assertEqual(Ticket.objects.count(), 1)
 
365
        self.assertEqual(Ticket.objects.get(
 
366
            pk=self.ticket.pk).current_workflow_step,
 
367
            int(TicketWorkflowStep.FAILED))
 
368
        self.assertEqual(Ticket.objects.get(
 
369
            pk=self.ticket.pk).status,
 
370
            int(TicketWorkflowStepStatus.PKG_BUILDING_FAILED))
 
371
 
 
372
    def test_try_adding_binary_already_in_list(self):
 
373
        """
 
374
        Test what happens when a ticket attempts to add a binary to the master
 
375
        list that is already in the master list
 
376
        """
 
377
        new_data = {
 
378
            "current_workflow_step": TicketWorkflowStep.COMPLETED.value,
 
379
            "status": TicketWorkflowStepStatus.COMPLETED.value,
 
380
        }
 
381
        self.ticket_2 = create_ticket(added='binary1,binary2,binary3')
 
382
        self.assertEqual(Ticket.objects.count(), 2)
 
383
        self.assertEqual(BinaryPackage.objects.count(), 3)
 
384
        binaries = BinaryPackage.objects.all()
 
385
        self.assertQuerysetEqual(binaries,
 
386
                                 ["<BinaryPackage: binary3>",
 
387
                                  "<BinaryPackage: binary4>",
 
388
                                  "<BinaryPackage: binary5>"], ordered=False)
 
389
        self.client.patch('/api/v1/updateticketstatus/{0}/'.format(
 
390
                          self.ticket_2.pk), data=new_data)
 
391
        self.assertEqual(BinaryPackage.objects.count(), 5)
 
392
        binaries = BinaryPackage.objects.all()
 
393
        self.assertQuerysetEqual(binaries,
 
394
                                 ["<BinaryPackage: binary1>",
 
395
                                  "<BinaryPackage: binary2>",
 
396
                                  "<BinaryPackage: binary3>",
 
397
                                  "<BinaryPackage: binary4>",
 
398
                                  "<BinaryPackage: binary5>"], ordered=False)
 
399
 
 
400
    def test_try_removing_binary_not_in_list(self):
 
401
        """
 
402
        Test what happens when a ticket attempts to remove a binary from the
 
403
        master list when it isn't in the master list
 
404
        """
 
405
        new_data = {
 
406
            "current_workflow_step": TicketWorkflowStep.COMPLETED.value,
 
407
            "status": TicketWorkflowStepStatus.COMPLETED.value,
 
408
        }
 
409
        self.ticket_2 = create_ticket(removed='binary2,binary3')
 
410
        self.assertEqual(Ticket.objects.count(), 2)
 
411
        self.assertEqual(BinaryPackage.objects.count(), 3)
 
412
        binaries = BinaryPackage.objects.all()
 
413
        self.assertQuerysetEqual(binaries,
 
414
                                 ["<BinaryPackage: binary3>",
 
415
                                  "<BinaryPackage: binary4>",
 
416
                                  "<BinaryPackage: binary5>"], ordered=False)
 
417
        self.client.patch('/api/v1/updateticketstatus/{0}/'.format(
 
418
                          self.ticket_2.pk), data=new_data)
 
419
        binaries = BinaryPackage.objects.all()
 
420
        self.assertEqual(BinaryPackage.objects.count(), 2)
 
421
        self.assertQuerysetEqual(binaries,
 
422
                                 ["<BinaryPackage: binary4>",
 
423
                                  "<BinaryPackage: binary5>"], ordered=False)
 
424
 
 
425
    def test_update_ticket_status_complete_404(self):
 
426
        """
 
427
        Test trying to complete the status of a ticket that doesn't exist
 
428
        """
 
429
        new_data = {
 
430
            "current_workflow_step": str(TicketWorkflowStep.COMPLETED.value),
 
431
            "status": str(TicketWorkflowStepStatus.COMPLETED.value),
 
432
        }
 
433
        self.assertEqual(Ticket.objects.count(), 1)
 
434
        self.assertEqual(BinaryPackage.objects.count(), 3)
 
435
        binaries = BinaryPackage.objects.all()
 
436
        self.assertQuerysetEqual(binaries,
 
437
                                 ["<BinaryPackage: binary3>",
 
438
                                  "<BinaryPackage: binary4>",
 
439
                                  "<BinaryPackage: binary5>"], ordered=False)
 
440
        self.assertEqual(Ticket.objects.get(
 
441
            pk=self.ticket.pk).current_workflow_step,
 
442
            self.ticket.current_workflow_step)
 
443
        self.assertEqual(Ticket.objects.get(
 
444
            pk=self.ticket.pk).status,
 
445
            self.ticket.status)
 
446
        resp = self.client.patch('updateticketstatus/17394/', data=new_data)
 
447
        self.assertEqual(Ticket.objects.count(), 1)
 
448
        self.assertEqual(BinaryPackage.objects.count(), 3)
 
449
        binaries = BinaryPackage.objects.all()
 
450
        self.assertQuerysetEqual(binaries,
 
451
                                 ["<BinaryPackage: binary3>",
 
452
                                  "<BinaryPackage: binary4>",
 
453
                                  "<BinaryPackage: binary5>"], ordered=False)
 
454
        self.assertEqual(resp.status_code, 404)
 
455
 
 
456
    def test_delete_ticket_not_allowed(self):
 
457
        resp = self.delete(resource=self.ticket_detail_url)
 
458
        self.assertHttpMethodNotAllowed(resp)
 
459
 
223
460
 
224
461
class APIUpdateSubTicketStatuses(TastypieTestCase):
225
462
 
226
463
    def setUp(self):
227
464
        super(APIUpdateSubTicketStatuses, self).setUp('/api/v1')
228
 
        self.subticket = mommy.make('SubTicket')
 
465
        self.sourcepackage = sourcepackage_recipe.make()
 
466
        self.spu = mommy.make('SourcePackageUpload',
 
467
                              sourcepackage=self.sourcepackage)
 
468
        self.subticket = mommy.make('SubTicket',
 
469
                                    source_package_upload=self.spu)
229
470
        self.subticket_detail_url = (
230
471
            'updatesubticketstatus/{0}/'.format(self.subticket.pk))
231
472
 
246
487
                         int(SubTicketWorkflowStep.PKG_BUILDING))
247
488
        self.assertEqual(SubTicket.objects.get(pk=self.subticket.pk).status,
248
489
                         int(SubTicketWorkflowStepStatus.PKG_BUILDING_WAITING))
 
490
 
 
491
    def test_delete_subticket_not_allowed(self):
 
492
        resp = self.delete(resource=self.subticket_detail_url)
 
493
        self.assertHttpMethodNotAllowed(resp)