← Back to branch summary

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

« back to all changes in this revision

Viewing changes to src/maasserver/models/tests/test_bootresourceset.py

merged upstream

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/maasserver/models/tests/test_bootresourceset.py
38
38
                resource_set, filename=filetype, filetype=filetype)
39
39
 
40
40
    def test_commissionable_returns_true_when_all_filetypes_present(self):
41
 
        resource = factory.make_boot_resource()
42
 
        resource_set = factory.make_boot_resource_set(resource)
 
41
        resource = factory.make_BootResource()
 
42
        resource_set = factory.make_BootResourceSet(resource)
43
43
        self.make_all_boot_resource_files(resource_set, COMMISSIONABLE_SET)
44
44
        self.assertTrue(resource_set.commissionable)
45
45
 
46
46
    def test_commissionable_returns_false_when_missing_filetypes(self):
47
 
        resource = factory.make_boot_resource()
48
 
        resource_set = factory.make_boot_resource_set(resource)
 
47
        resource = factory.make_BootResource()
 
48
        resource_set = factory.make_BootResourceSet(resource)
49
49
        types = COMMISSIONABLE_SET.copy()
50
50
        types.pop()
51
51
        self.make_all_boot_resource_files(resource_set, types)
52
52
        self.assertFalse(resource_set.commissionable)
53
53
 
54
54
    def test_installable_returns_true_when_all_filetypes_present(self):
55
 
        resource = factory.make_boot_resource()
56
 
        resource_set = factory.make_boot_resource_set(resource)
 
55
        resource = factory.make_BootResource()
 
56
        resource_set = factory.make_BootResourceSet(resource)
57
57
        self.make_all_boot_resource_files(resource_set, INSTALL_SET)
58
58
        self.assertTrue(resource_set.installable)
59
59
 
60
60
    def test_installable_returns_false_when_missing_filetypes(self):
61
 
        resource = factory.make_boot_resource()
62
 
        resource_set = factory.make_boot_resource_set(resource)
 
61
        resource = factory.make_BootResource()
 
62
        resource_set = factory.make_BootResourceSet(resource)
63
63
        types = INSTALL_SET.copy()
64
64
        types.pop()
65
65
        self.make_all_boot_resource_files(resource_set, types)
66
66
        self.assertFalse(resource_set.installable)
67
67
 
68
68
    def test_xinstallable_returns_true_when_filetype_present(self):
69
 
        resource = factory.make_boot_resource()
70
 
        resource_set = factory.make_boot_resource_set(resource)
 
69
        resource = factory.make_BootResource()
 
70
        resource_set = factory.make_BootResourceSet(resource)
71
71
        filetype = random.choice(XINSTALL_TYPES)
72
72
        factory.make_boot_resource_file_with_content(
73
73
            resource_set, filename=filetype, filetype=filetype)
74
74
        self.assertTrue(resource_set.xinstallable)
75
75
 
76
76
    def test_xinstallable_returns_false_when_missing_filetypes(self):
77
 
        resource = factory.make_boot_resource()
78
 
        resource_set = factory.make_boot_resource_set(resource)
 
77
        resource = factory.make_BootResource()
 
78
        resource_set = factory.make_BootResourceSet(resource)
79
79
        filetype = random.choice(list(INSTALL_SET))
80
80
        factory.make_boot_resource_file_with_content(
81
81
            resource_set, filename=filetype, filetype=filetype)
82
82
        self.assertFalse(resource_set.xinstallable)
83
83
 
84
84
    def test_total_size(self):
85
 
        resource = factory.make_boot_resource()
86
 
        resource_set = factory.make_boot_resource_set(resource)
 
85
        resource = factory.make_BootResource()
 
86
        resource_set = factory.make_BootResourceSet(resource)
87
87
        total_size = 0
88
88
        sizes = [random.randint(512, 1024) for _ in range(3)]
89
89
        types = [
94
94
        for size in sizes:
95
95
            total_size += size
96
96
            filetype = types.pop()
97
 
            largefile = factory.make_large_file(size=size)
98
 
            factory.make_boot_resource_file(
 
97
            largefile = factory.make_LargeFile(size=size)
 
98
            factory.make_BootResourceFile(
99
99
                resource_set, largefile, filename=filetype, filetype=filetype)
100
100
        self.assertEqual(total_size, resource_set.total_size)
101
101
 
102
102
    def test_size(self):
103
 
        resource = factory.make_boot_resource()
104
 
        resource_set = factory.make_boot_resource_set(resource)
 
103
        resource = factory.make_BootResource()
 
104
        resource_set = factory.make_BootResourceSet(resource)
105
105
        final_size = 0
106
106
        sizes = [random.randint(512, 1024) for _ in range(3)]
107
107
        total_sizes = [random.randint(1025, 2048) for _ in range(3)]
114
114
            final_size += size
115
115
            filetype = types.pop()
116
116
            content = factory.make_string(size=size)
117
 
            largefile = factory.make_large_file(
 
117
            largefile = factory.make_LargeFile(
118
118
                content=content, size=total_sizes.pop())
119
 
            factory.make_boot_resource_file(
 
119
            factory.make_BootResourceFile(
120
120
                resource_set, largefile, filename=filetype, filetype=filetype)
121
121
        self.assertEqual(final_size, resource_set.size)
122
122
 
123
123
    def test_progress_handles_zero_division(self):
124
 
        resource = factory.make_boot_resource()
125
 
        resource_set = factory.make_boot_resource_set(resource)
 
124
        resource = factory.make_BootResource()
 
125
        resource_set = factory.make_BootResourceSet(resource)
126
126
        filetype = BOOT_RESOURCE_FILE_TYPE.ROOT_IMAGE
127
127
        total_size = random.randint(1025, 2048)
128
128
        content = ""
129
 
        largefile = factory.make_large_file(
 
129
        largefile = factory.make_LargeFile(
130
130
            content=content, size=total_size)
131
 
        factory.make_boot_resource_file(
 
131
        factory.make_BootResourceFile(
132
132
            resource_set, largefile, filename=filetype, filetype=filetype)
133
133
        self.assertEqual(0, resource_set.progress)
134
134
 
135
135
    def test_progress_increases_from_0_to_1(self):
136
 
        resource = factory.make_boot_resource()
137
 
        resource_set = factory.make_boot_resource_set(resource)
 
136
        resource = factory.make_BootResource()
 
137
        resource_set = factory.make_BootResourceSet(resource)
138
138
        filetype = BOOT_RESOURCE_FILE_TYPE.ROOT_IMAGE
139
139
        total_size = 100
140
140
        current_size = 0
141
 
        largefile = factory.make_large_file(
 
141
        largefile = factory.make_LargeFile(
142
142
            content="", size=total_size)
143
 
        factory.make_boot_resource_file(
 
143
        factory.make_BootResourceFile(
144
144
            resource_set, largefile, filename=filetype, filetype=filetype)
145
145
        stream = largefile.content.open()
146
146
        self.addCleanup(stream.close)
153
153
                resource_set.progress)
154
154
 
155
155
    def test_progress_accumulates_all_files(self):
156
 
        resource = factory.make_boot_resource()
157
 
        resource_set = factory.make_boot_resource_set(resource)
 
156
        resource = factory.make_BootResource()
 
157
        resource_set = factory.make_BootResourceSet(resource)
158
158
        final_size = 0
159
159
        final_total_size = 0
160
160
        sizes = [random.randint(512, 1024) for _ in range(3)]
170
170
            final_total_size += total_size
171
171
            filetype = types.pop()
172
172
            content = factory.make_string(size=size)
173
 
            largefile = factory.make_large_file(
 
173
            largefile = factory.make_LargeFile(
174
174
                content=content, size=total_size)
175
 
            factory.make_boot_resource_file(
 
175
            factory.make_BootResourceFile(
176
176
                resource_set, largefile, filename=filetype, filetype=filetype)
177
177
        progress = final_total_size / float(final_size)
178
178
        self.assertAlmostEqual(progress, resource_set.progress)
179
179
 
180
180
    def test_complete_returns_false_for_no_files(self):
181
 
        resource = factory.make_boot_resource()
182
 
        resource_set = factory.make_boot_resource_set(resource)
 
181
        resource = factory.make_BootResource()
 
182
        resource_set = factory.make_BootResourceSet(resource)
183
183
        self.assertFalse(resource_set.complete)
184
184
 
185
185
    def test_complete_returns_false_for_one_incomplete_file(self):
186
 
        resource = factory.make_boot_resource()
187
 
        resource_set = factory.make_boot_resource_set(resource)
 
186
        resource = factory.make_BootResource()
 
187
        resource_set = factory.make_BootResourceSet(resource)
188
188
        types = [
189
189
            BOOT_RESOURCE_FILE_TYPE.ROOT_IMAGE,
190
190
            BOOT_RESOURCE_FILE_TYPE.BOOT_KERNEL,
198
198
        total_size = random.randint(1025, 2048)
199
199
        filetype = types.pop()
200
200
        content = factory.make_string(size=size)
201
 
        largefile = factory.make_large_file(content=content, size=total_size)
202
 
        factory.make_boot_resource_file(
 
201
        largefile = factory.make_LargeFile(content=content, size=total_size)
 
202
        factory.make_BootResourceFile(
203
203
            resource_set, largefile, filename=filetype, filetype=filetype)
204
204
        self.assertFalse(resource_set.complete)
205
205
 
206
206
    def test_complete_returns_true_for_complete_files(self):
207
 
        resource = factory.make_boot_resource()
208
 
        resource_set = factory.make_boot_resource_set(resource)
 
207
        resource = factory.make_BootResource()
 
208
        resource_set = factory.make_BootResourceSet(resource)
209
209
        types = [
210
210
            BOOT_RESOURCE_FILE_TYPE.ROOT_IMAGE,
211
211
            BOOT_RESOURCE_FILE_TYPE.BOOT_KERNEL,