← Back to branch summary

~maas-committers/maas/trunk

« back to all changes in this revision

Viewing changes to src/provisioningserver/import_images/tests/test_boot_resources.py

  • Committer: MaaS Lander
  • Author(s): jtv at canonical
  • Date: 2014-04-07 15:31:33 UTC
  • mfrom: (2230.4.2 boot-image-dict)
  • Revision ID: maas_lander-20140407153133-ie6yxpg370ol7muq
[r=gmb][bug=][author=jtv] Turn the “hierarchical dicts” in the new import code into a proper class, BootImageDict.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/provisioningserver/import_images/tests/test_boot_resources.py
46
46
        )
47
47
 
48
48
 
49
 
class TestIterateBootResources(MAASTestCase):
50
 
    """Tests for `iterate_boot_resources`."""
51
 
 
52
 
    def test_empty_hierarchy_yields_nothing(self):
53
 
        self.assertItemsEqual(
54
 
            [],
55
 
            boot_resources.iterate_boot_resources(
56
 
                boot_resources.create_empty_hierarchy()))
57
 
 
58
 
    def test_finds_boot_resource(self):
59
 
        image_spec = make_image_spec()
60
 
        arch, subarch, release, label = image_spec
61
 
        self.assertItemsEqual(
62
 
            [image_spec],
63
 
            boot_resources.iterate_boot_resources(
64
 
                {arch: {subarch: {release: {label: factory.make_name()}}}}))
 
49
class TestBootImageMapping(MAASTestCase):
 
50
    """Tests for `BootImageMapping`."""
 
51
 
 
52
    def test_initially_empty(self):
 
53
        self.assertItemsEqual([], boot_resources.BootImageMapping().items())
 
54
 
 
55
    def test_items_returns_items(self):
 
56
        image = make_image_spec()
 
57
        resource = factory.make_name('resource')
 
58
        image_dict = set_resource(image_spec=image, resource=resource)
 
59
        self.assertItemsEqual([(image, resource)], image_dict.items())
 
60
 
 
61
    def test_setdefault_sets_unset_item(self):
 
62
        image_dict = boot_resources.BootImageMapping()
 
63
        image = make_image_spec()
 
64
        resource = factory.make_name('resource')
 
65
        image_dict.setdefault(image, resource)
 
66
        self.assertItemsEqual([(image, resource)], image_dict.items())
 
67
 
 
68
    def test_setdefault_leaves_set_item_unchanged(self):
 
69
        image = make_image_spec()
 
70
        old_resource = factory.make_name('resource')
 
71
        image_dict = set_resource(image_spec=image, resource=old_resource)
 
72
        image_dict.setdefault(image, factory.make_name('newresource'))
 
73
        self.assertItemsEqual([(image, old_resource)], image_dict.items())
 
74
 
 
75
    def test_dump_json_is_consistent(self):
 
76
        image = make_image_spec()
 
77
        resource = factory.make_name('resource')
 
78
        image_dict_1 = set_resource(image_spec=image, resource=resource)
 
79
        image_dict_2 = set_resource(image_spec=image, resource=resource)
 
80
        self.assertEqual(image_dict_1.dump_json(), image_dict_2.dump_json())
 
81
 
 
82
    def test_dump_json_represents_empty_dict_as_empty_object(self):
 
83
        self.assertEqual('{}', boot_resources.BootImageMapping().dump_json())
 
84
 
 
85
    def test_dump_json_represents_entry(self):
 
86
        image = make_image_spec()
 
87
        resource = factory.make_name('resource')
 
88
        image_dict = set_resource(image_spec=image, resource=resource)
 
89
        self.assertEqual(
 
90
            {
 
91
                image.arch: {
 
92
                    image.subarch: {
 
93
                        image.release: {image.label: resource},
 
94
                    },
 
95
                },
 
96
            },
 
97
            json.loads(image_dict.dump_json()))
 
98
 
 
99
    def test_dump_json_combines_similar_entries(self):
 
100
        image = make_image_spec()
 
101
        other_release = factory.make_name('other-release')
 
102
        resource1 = factory.make_name('resource')
 
103
        resource2 = factory.make_name('other-resource')
 
104
        image_dict = boot_resources.BootImageMapping()
 
105
        set_resource(image_dict, image, resource1)
 
106
        set_resource(
 
107
            image_dict, image._replace(release=other_release), resource2)
 
108
        self.assertEqual(
 
109
            {
 
110
                image.arch: {
 
111
                    image.subarch: {
 
112
                        image.release: {image.label: resource1},
 
113
                        other_release: {image.label: resource2},
 
114
                    },
 
115
                },
 
116
            },
 
117
            json.loads(image_dict.dump_json()))
65
118
 
66
119
 
67
120
class TestValuePassesFilterList(MAASTestCase):
151
204
        image1 = make_image_spec()
152
205
        image2 = make_image_spec()
153
206
        resource = self.make_boot_resource()
154
 
        boot_dict = {}
 
207
        boot_dict = boot_resources.BootImageMapping()
155
208
        # Create two images in boot_dict, both containing the same resource.
156
209
        for image in [image1, image2]:
157
210
            set_resource(
262
315
 
263
316
 
264
317
def set_resource(boot_dict=None, image_spec=None, resource=None):
265
 
    """Add a boot resource to `boot_dict`, creating it if necessary."""
 
318
    """Add boot resource to a `BootImageMapping`, creating it if necessary."""
266
319
    if boot_dict is None:
267
 
        boot_dict = {}
 
320
        boot_dict = boot_resources.BootImageMapping()
268
321
    if image_spec is None:
269
322
        image_spec = make_image_spec()
270
323
    if resource is None:
271
324
        resource = factory.make_name('boot-resource')
272
 
    arch, subarch, release, label = image_spec
273
 
    # Drill down into the dict; along the way, create any missing levels of
274
 
    # nested dicts.
275
 
    nested_dict = boot_dict
276
 
    for level in (arch, subarch, release):
277
 
        nested_dict.setdefault(level, {})
278
 
        nested_dict = nested_dict[level]
279
 
    # At the bottom level, indexed by "label," insert "resource" as the
280
 
    # value.
281
 
    nested_dict[label] = resource
 
325
    boot_dict.mapping[image_spec] = resource
282
326
    return boot_dict
283
327
 
284
328
 
288
332
    def test_integrates(self):
289
333
        # End-to-end scenario for boot_merge: start with an empty boot
290
334
        # resources dict, and receive one resource from Simplestreams.
291
 
        total_resources = boot_resources.create_empty_hierarchy()
 
335
        total_resources = boot_resources.BootImageMapping()
292
336
        resources_from_repo = set_resource()
293
 
        boot_resources.boot_merge(total_resources, resources_from_repo.copy())
 
337
        boot_resources.boot_merge(total_resources, resources_from_repo)
294
338
        # Since we started with an empty dict, the result contains the same
295
339
        # item that we got from Simplestreams, and nothing else.
296
 
        self.assertEqual(resources_from_repo, total_resources)
 
340
        self.assertEqual(resources_from_repo.mapping, total_resources.mapping)
297
341
 
298
342
    def test_obeys_filters(self):
299
343
        filters = [
312
356
 
313
357
    def test_does_not_overwrite_existing_entry(self):
314
358
        image = make_image_spec()
315
 
        original_resources = set_resource(
 
359
        total_resources = set_resource(
316
360
            resource="Original resource", image_spec=image)
317
 
        total_resources = original_resources.copy()
 
361
        original_resources = total_resources.mapping.copy()
318
362
        resources_from_repo = set_resource(
319
363
            resource="New resource", image_spec=image)
320
 
        boot_resources.boot_merge(total_resources, resources_from_repo.copy())
321
 
        self.assertEqual(original_resources, total_resources)
 
364
        boot_resources.boot_merge(total_resources, resources_from_repo)
 
365
        self.assertEqual(original_resources, total_resources.mapping)
322
366
 
323
367
 
324
368
class TestGetSigningPolicy(MAASTestCase):