← Back to branch summary

~rvb/maas/transaction-1.7-bug-1409852

« back to all changes in this revision

Viewing changes to src/maasserver/api/tests/test_boot_resources.py

merged upstream

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/maasserver/api/tests/test_boot_resources.py
59
59
        size = random.randint(512, 1023)
60
60
        total_size = random.randint(1024, 2048)
61
61
        content = factory.make_string(size)
62
 
        largefile = factory.make_large_file(content=content, size=total_size)
63
 
        resource = factory.make_boot_resource(
 
62
        largefile = factory.make_LargeFile(content=content, size=total_size)
 
63
        resource = factory.make_BootResource(
64
64
            rtype=BOOT_RESOURCE_TYPE.UPLOADED)
65
 
        resource_set = factory.make_boot_resource_set(resource)
66
 
        rfile = factory.make_boot_resource_file(resource_set, largefile)
 
65
        resource_set = factory.make_BootResourceSet(resource)
 
66
        rfile = factory.make_BootResourceFile(resource_set, largefile)
67
67
        dict_representation = boot_resource_file_to_dict(rfile)
68
68
        self.assertEqual(rfile.filename, dict_representation['filename'])
69
69
        self.assertEqual(rfile.filetype, dict_representation['filetype'])
79
79
            dict_representation['upload_uri'])
80
80
 
81
81
    def test_boot_resource_set_to_dict(self):
82
 
        resource = factory.make_boot_resource()
83
 
        resource_set = factory.make_boot_resource_set(resource)
 
82
        resource = factory.make_BootResource()
 
83
        resource_set = factory.make_BootResourceSet(resource)
84
84
        total_size = random.randint(1024, 2048)
85
85
        content = factory.make_string(random.randint(512, 1023))
86
 
        largefile = factory.make_large_file(content=content, size=total_size)
87
 
        rfile = factory.make_boot_resource_file(resource_set, largefile)
 
86
        largefile = factory.make_LargeFile(content=content, size=total_size)
 
87
        rfile = factory.make_BootResourceFile(resource_set, largefile)
88
88
        dict_representation = boot_resource_set_to_dict(resource_set)
89
89
        self.assertEqual(resource_set.version, dict_representation['version'])
90
90
        self.assertEqual(resource_set.label, dict_representation['label'])
97
97
            dict_representation['files'][rfile.filename])
98
98
 
99
99
    def test_boot_resource_to_dict_without_sets(self):
100
 
        resource = factory.make_boot_resource()
101
 
        factory.make_boot_resource_set(resource)
 
100
        resource = factory.make_BootResource()
 
101
        factory.make_BootResourceSet(resource)
102
102
        dict_representation = boot_resource_to_dict(resource, with_sets=False)
103
103
        self.assertEqual(resource.id, dict_representation['id'])
104
104
        self.assertEqual(
113
113
        self.assertFalse('sets' in dict_representation)
114
114
 
115
115
    def test_boot_resource_to_dict_with_sets(self):
116
 
        resource = factory.make_boot_resource()
117
 
        resource_set = factory.make_boot_resource_set(resource)
 
116
        resource = factory.make_BootResource()
 
117
        resource_set = factory.make_BootResourceSet(resource)
118
118
        dict_representation = boot_resource_to_dict(resource, with_sets=True)
119
119
        self.assertItemsEqual(
120
120
            boot_resource_set_to_dict(resource_set),
131
131
 
132
132
    def test_GET_returns_boot_resources_list(self):
133
133
        resources = [
134
 
            factory.make_boot_resource() for _ in range(3)]
 
134
            factory.make_BootResource() for _ in range(3)]
135
135
        response = self.client.get(
136
136
            reverse('boot_resources_handler'))
137
137
        self.assertEqual(httplib.OK, response.status_code, response.content)
142
142
 
143
143
    def test_GET_synced_returns_synced_boot_resources(self):
144
144
        resources = [
145
 
            factory.make_boot_resource(rtype=BOOT_RESOURCE_TYPE.SYNCED)
 
145
            factory.make_BootResource(rtype=BOOT_RESOURCE_TYPE.SYNCED)
146
146
            for _ in range(3)
147
147
            ]
148
 
        factory.make_boot_resource(rtype=BOOT_RESOURCE_TYPE.GENERATED)
149
 
        factory.make_boot_resource(rtype=BOOT_RESOURCE_TYPE.UPLOADED)
 
148
        factory.make_BootResource(rtype=BOOT_RESOURCE_TYPE.GENERATED)
 
149
        factory.make_BootResource(rtype=BOOT_RESOURCE_TYPE.UPLOADED)
150
150
        response = self.client.get(
151
151
            reverse('boot_resources_handler'), {'type': 'synced'})
152
152
        self.assertEqual(httplib.OK, response.status_code, response.content)
157
157
 
158
158
    def test_GET_generated_returns_generated_boot_resources(self):
159
159
        resources = [
160
 
            factory.make_boot_resource(rtype=BOOT_RESOURCE_TYPE.GENERATED)
 
160
            factory.make_BootResource(rtype=BOOT_RESOURCE_TYPE.GENERATED)
161
161
            for _ in range(3)
162
162
            ]
163
 
        factory.make_boot_resource(rtype=BOOT_RESOURCE_TYPE.SYNCED)
164
 
        factory.make_boot_resource(rtype=BOOT_RESOURCE_TYPE.UPLOADED)
 
163
        factory.make_BootResource(rtype=BOOT_RESOURCE_TYPE.SYNCED)
 
164
        factory.make_BootResource(rtype=BOOT_RESOURCE_TYPE.UPLOADED)
165
165
        response = self.client.get(
166
166
            reverse('boot_resources_handler'), {'type': 'generated'})
167
167
        self.assertEqual(httplib.OK, response.status_code, response.content)
172
172
 
173
173
    def test_GET_uploaded_returns_uploaded_boot_resources(self):
174
174
        resources = [
175
 
            factory.make_boot_resource(rtype=BOOT_RESOURCE_TYPE.UPLOADED)
 
175
            factory.make_BootResource(rtype=BOOT_RESOURCE_TYPE.UPLOADED)
176
176
            for _ in range(3)
177
177
            ]
178
 
        factory.make_boot_resource(rtype=BOOT_RESOURCE_TYPE.SYNCED)
179
 
        factory.make_boot_resource(rtype=BOOT_RESOURCE_TYPE.GENERATED)
 
178
        factory.make_BootResource(rtype=BOOT_RESOURCE_TYPE.SYNCED)
 
179
        factory.make_BootResource(rtype=BOOT_RESOURCE_TYPE.GENERATED)
180
180
        response = self.client.get(
181
181
            reverse('boot_resources_handler'), {'type': 'uploaded'})
182
182
        self.assertEqual(httplib.OK, response.status_code, response.content)
186
186
            [resource.get('id') for resource in parsed_result])
187
187
 
188
188
    def test_GET_doesnt_include_full_definition_of_boot_resource(self):
189
 
        factory.make_boot_resource()
 
189
        factory.make_BootResource()
190
190
        response = self.client.get(
191
191
            reverse('boot_resources_handler'))
192
192
        self.assertEqual(httplib.OK, response.status_code, response.content)
267
267
    def test_POST_creates_boot_resource_with_already_existing_largefile(self):
268
268
        self.become_admin()
269
269
 
270
 
        largefile = factory.make_large_file()
 
270
        largefile = factory.make_LargeFile()
271
271
        name = factory.make_name('name')
272
272
        architecture = make_usable_architecture(self)
273
273
        params = {
291
291
 
292
292
        # Create a largefile to get a random sha256 and size. We delete it
293
293
        # immediately so the new resource does not pick it up.
294
 
        largefile = factory.make_large_file()
 
294
        largefile = factory.make_LargeFile()
295
295
        largefile.delete()
296
296
 
297
297
        name = factory.make_name('name')
318
318
    def test_POST_validates_size_matches_total_size_for_largefile(self):
319
319
        self.become_admin()
320
320
 
321
 
        largefile = factory.make_large_file()
 
321
        largefile = factory.make_LargeFile()
322
322
        name = factory.make_name('name')
323
323
        architecture = make_usable_architecture(self)
324
324
        params = {
410
410
 
411
411
    def test_DELETE_deletes_boot_resource(self):
412
412
        self.become_admin()
413
 
        resource = factory.make_boot_resource()
 
413
        resource = factory.make_BootResource()
414
414
        response = self.client.delete(get_boot_resource_uri(resource))
415
415
        self.assertEqual(httplib.NO_CONTENT, response.status_code)
416
416
        self.assertIsNone(reload_object(resource))
417
417
 
418
418
    def test_DELETE_requires_admin(self):
419
 
        resource = factory.make_boot_resource()
 
419
        resource = factory.make_BootResource()
420
420
        response = self.client.delete(get_boot_resource_uri(resource))
421
421
        self.assertEqual(httplib.FORBIDDEN, response.status_code)
422
422
 
435
435
        if content is None:
436
436
            content = factory.make_bytes(1024)
437
437
        total_size = len(content)
438
 
        largefile = factory.make_large_file(content=content, size=total_size)
 
438
        largefile = factory.make_LargeFile(content=content, size=total_size)
439
439
        sha256 = largefile.sha256
440
440
        with largefile.content.open('rb') as stream:
441
441
            content = stream.read()
449
449
 
450
450
        if rtype is None:
451
451
            rtype = BOOT_RESOURCE_TYPE.UPLOADED
452
 
        resource = factory.make_boot_resource(rtype=rtype)
453
 
        resource_set = factory.make_boot_resource_set(resource)
454
 
        rfile = factory.make_boot_resource_file(resource_set, largefile)
 
452
        resource = factory.make_BootResource(rtype=rtype)
 
453
        resource_set = factory.make_BootResourceSet(resource)
 
454
        rfile = factory.make_BootResourceFile(resource_set, largefile)
455
455
        return rfile, content
456
456
 
457
457
    def read_content(self, rfile):