← Back to branch summary

~ubuntu-branches/debian/stretch/fuel-agent/stretch

« back to all changes in this revision

Viewing changes to .pc/do-not-restrict-install-to-trusty.patch/fuel_agent/tests/test_nailgun_build_image.py

  • Committer: Package Import Robot
  • Author(s): Thomas Goirand
  • Date: 2016-03-16 17:12:17 UTC
  • mfrom: (1.1.1)
  • Revision ID: package-import@ubuntu.com-20160316171217-p5b360dfuxm5yidy
Tags: 9.0~0+2016.03.09.git.b1ba4b7747+dfsg1-1
* New upstream release based on commit b1ba4b7747.
* Uploading to unstable.
* Lots of tweaks to make Debian provisionning works.
* Standards-Version: 3.9.7 (no change).

Show diffs side-by-side

added added

removed removed

Lines of Context:
.pc/do-not-restrict-install-to-trusty.patch/fuel_agent/tests/test_nailgun_build_image.py
 
1
# Copyright 2015 Mirantis, Inc.
 
2
#
 
3
# Licensed under the Apache License, Version 2.0 (the "License");
 
4
# you may not use this file except in compliance with the License.
 
5
# You may obtain a copy of the License at
 
6
#
 
7
#    http://www.apache.org/licenses/LICENSE-2.0
 
8
#
 
9
# Unless required by applicable law or agreed to in writing, software
 
10
# distributed under the License is distributed on an "AS IS" BASIS,
 
11
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 
12
# See the License for the specific language governing permissions and
 
13
# limitations under the License.
 
14
 
 
15
import os
 
16
 
 
17
import mock
 
18
import six
 
19
from six.moves.urllib.parse import urlsplit
 
20
import unittest2
 
21
 
 
22
from fuel_agent.drivers.nailgun import NailgunBuildImage
 
23
from fuel_agent import errors
 
24
from fuel_agent import objects
 
25
 
 
26
DEFAULT_TRUSTY_PACKAGES = [
 
27
    "acl",
 
28
    "anacron",
 
29
    "bash-completion",
 
30
    "bridge-utils",
 
31
    "bsdmainutils",
 
32
    "build-essential",
 
33
    "cloud-init",
 
34
    "curl",
 
35
    "daemonize",
 
36
    "debconf-utils",
 
37
    "gdisk",
 
38
    "grub-pc",
 
39
    "hpsa-dkms",
 
40
    "i40e-dkms",
 
41
    "linux-firmware",
 
42
    "linux-firmware-nonfree",
 
43
    "linux-headers-generic-lts-trusty",
 
44
    "linux-image-generic-lts-trusty",
 
45
    "lvm2",
 
46
    "mcollective",
 
47
    "mdadm",
 
48
    "nailgun-agent",
 
49
    "nailgun-mcagents",
 
50
    "network-checker",
 
51
    "ntp",
 
52
    "openssh-client",
 
53
    "openssh-server",
 
54
    "puppet",
 
55
    "python-amqp",
 
56
    "ruby-augeas",
 
57
    "ruby-ipaddress",
 
58
    "ruby-json",
 
59
    "ruby-netaddr",
 
60
    "ruby-openstack",
 
61
    "ruby-shadow",
 
62
    "ruby-stomp",
 
63
    "telnet",
 
64
    "ubuntu-minimal",
 
65
    "ubuntu-standard",
 
66
    "uuid-runtime",
 
67
    "vim",
 
68
    "virt-what",
 
69
    "vlan",
 
70
]
 
71
 
 
72
REPOS_SAMPLE = [
 
73
    {
 
74
        "name": "ubuntu",
 
75
        "section": "main universe multiverse",
 
76
        "uri": "http://archive.ubuntu.com/ubuntu/",
 
77
        "priority": None,
 
78
        "suite": "trusty",
 
79
        "type": "deb"
 
80
    },
 
81
    {
 
82
        "name": "mos",
 
83
        "section": "main restricted",
 
84
        "uri": "http://10.20.0.2:8080/2014.2-6.1/ubuntu/x86_64",
 
85
        "priority": 1050,
 
86
        "suite": "mos6.1",
 
87
        "type": "deb"
 
88
    }
 
89
]
 
90
 
 
91
IMAGE_DATA_SAMPLE = {
 
92
    "/boot": {
 
93
        "container": "gzip",
 
94
        "uri": "http://10.20.0.2:8080/path/to/img-boot.img.gz",
 
95
        "format": "ext2"
 
96
    },
 
97
    "/": {
 
98
        "container": "gzip",
 
99
        "uri": "http://10.20.0.2:8080/path/to/img.img.gz",
 
100
        "format": "ext4"
 
101
    }
 
102
}
 
103
 
 
104
 
 
105
class TestNailgunBuildImage(unittest2.TestCase):
 
106
 
 
107
    def test_default_trusty_packages(self):
 
108
        self.assertEqual(NailgunBuildImage.DEFAULT_TRUSTY_PACKAGES,
 
109
                         DEFAULT_TRUSTY_PACKAGES)
 
110
 
 
111
    @mock.patch.object(NailgunBuildImage, 'parse_schemes')
 
112
    def test_parse_operating_system_error_bad_codename(self,
 
113
                                                       mock_parse_schemes):
 
114
        with self.assertRaises(errors.WrongInputDataError):
 
115
            data = {'codename': 'not-trusty'}
 
116
            NailgunBuildImage(data)
 
117
 
 
118
    @mock.patch('fuel_agent.objects.RepoProxies')
 
119
    @mock.patch('fuel_agent.objects.Ubuntu')
 
120
    @mock.patch.object(NailgunBuildImage, 'parse_schemes')
 
121
    def test_parse_operating_system_packages_given(self, mock_parse_schemes,
 
122
                                                   mock_ub, mock_proxies):
 
123
        data = {
 
124
            'repos': [],
 
125
            'codename': 'trusty',
 
126
            'packages': ['pack']
 
127
        }
 
128
        mock_ub_instance = mock_ub.return_value
 
129
        mock_ub_instance.packages = data['packages']
 
130
        driver = NailgunBuildImage(data)
 
131
        mock_ub.assert_called_once_with(repos=[], packages=data['packages'],
 
132
                                        major=14, minor=4,
 
133
                                        proxies=mock_proxies.return_value)
 
134
        self.assertEqual(driver.operating_system.packages, data['packages'])
 
135
 
 
136
    @mock.patch('fuel_agent.objects.RepoProxies')
 
137
    @mock.patch('fuel_agent.objects.Ubuntu')
 
138
    @mock.patch.object(NailgunBuildImage, 'parse_schemes')
 
139
    def test_parse_operating_system_packages_not_given(
 
140
            self, mock_parse_schemes, mock_ub, mock_proxies):
 
141
        data = {
 
142
            'repos': [],
 
143
            'codename': 'trusty'
 
144
        }
 
145
        mock_ub_instance = mock_ub.return_value
 
146
        mock_ub_instance.packages = NailgunBuildImage.DEFAULT_TRUSTY_PACKAGES
 
147
        driver = NailgunBuildImage(data)
 
148
        mock_ub.assert_called_once_with(
 
149
            repos=[], packages=NailgunBuildImage.DEFAULT_TRUSTY_PACKAGES,
 
150
            major=14, minor=4, proxies=mock_proxies.return_value)
 
151
        self.assertEqual(driver.operating_system.packages,
 
152
                         NailgunBuildImage.DEFAULT_TRUSTY_PACKAGES)
 
153
 
 
154
    @mock.patch('fuel_agent.objects.RepoProxies')
 
155
    @mock.patch('fuel_agent.objects.DEBRepo')
 
156
    @mock.patch('fuel_agent.objects.Ubuntu')
 
157
    @mock.patch.object(NailgunBuildImage, 'parse_schemes')
 
158
    def test_parse_operating_system_repos(self, mock_parse_schemes, mock_ub,
 
159
                                          mock_deb, mock_proxies):
 
160
        data = {
 
161
            'repos': REPOS_SAMPLE,
 
162
            'codename': 'trusty'
 
163
        }
 
164
 
 
165
        mock_deb_expected_calls = []
 
166
        repos = []
 
167
        for r in REPOS_SAMPLE:
 
168
            kwargs = {
 
169
                'name': r['name'],
 
170
                'uri': r['uri'],
 
171
                'suite': r['suite'],
 
172
                'section': r['section'],
 
173
                'priority': r['priority']
 
174
            }
 
175
            mock_deb_expected_calls.append(mock.call(**kwargs))
 
176
            repos.append(objects.DEBRepo(**kwargs))
 
177
        driver = NailgunBuildImage(data)
 
178
        mock_ub_instance = mock_ub.return_value
 
179
        mock_ub_instance.repos = repos
 
180
        mock_ub.assert_called_once_with(
 
181
            repos=repos, packages=NailgunBuildImage.DEFAULT_TRUSTY_PACKAGES,
 
182
            major=14, minor=4, proxies=mock_proxies.return_value)
 
183
        self.assertEqual(mock_deb_expected_calls,
 
184
                         mock_deb.call_args_list[:len(REPOS_SAMPLE)])
 
185
        self.assertEqual(driver.operating_system.repos, repos)
 
186
 
 
187
    @mock.patch('fuel_agent.drivers.nailgun.objects.Loop')
 
188
    @mock.patch('fuel_agent.objects.Image')
 
189
    @mock.patch('fuel_agent.objects.FS')
 
190
    @mock.patch('fuel_agent.objects.PartitionScheme')
 
191
    @mock.patch('fuel_agent.objects.ImageScheme')
 
192
    @mock.patch.object(NailgunBuildImage, 'parse_operating_system')
 
193
    def test_parse_schemes(
 
194
            self, mock_parse_os, mock_imgsch, mock_partsch,
 
195
            mock_fs, mock_img, mock_loop):
 
196
        data = {
 
197
            'image_data': IMAGE_DATA_SAMPLE,
 
198
            'output': '/some/local/path',
 
199
        }
 
200
        driver = NailgunBuildImage(data)
 
201
 
 
202
        mock_fs_expected_calls = []
 
203
        mock_img_expected_calls = []
 
204
        images = []
 
205
        fss = []
 
206
        data_length = len(data['image_data'].keys())
 
207
        for mount, image in six.iteritems(data['image_data']):
 
208
            filename = os.path.basename(urlsplit(image['uri']).path)
 
209
            img_kwargs = {
 
210
                'uri': 'file://' + os.path.join(data['output'], filename),
 
211
                'format': image['format'],
 
212
                'container': image['container'],
 
213
                'target_device': None
 
214
            }
 
215
            mock_img_expected_calls.append(mock.call(**img_kwargs))
 
216
            images.append(objects.Image(**img_kwargs))
 
217
 
 
218
            fs_kwargs = {
 
219
                'device': None,
 
220
                'mount': mount,
 
221
                'fs_type': image['format']
 
222
            }
 
223
            mock_fs_expected_calls.append(mock.call(**fs_kwargs))
 
224
            fss.append(objects.FS(**fs_kwargs))
 
225
 
 
226
            if mount == '/':
 
227
                metadata_filename = filename.split('.', 1)[0] + '.yaml'
 
228
 
 
229
        mock_imgsch_instance = mock_imgsch.return_value
 
230
        mock_imgsch_instance.images = images
 
231
        mock_partsch_instance = mock_partsch.return_value
 
232
        mock_partsch_instance.fss = fss
 
233
 
 
234
        self.assertEqual(
 
235
            driver.metadata_uri, 'file://' + os.path.join(
 
236
                data['output'], metadata_filename))
 
237
        self.assertEqual(mock_img_expected_calls,
 
238
                         mock_img.call_args_list[:data_length])
 
239
        self.assertEqual(mock_fs_expected_calls,
 
240
                         mock_fs.call_args_list[:data_length])
 
241
        self.assertEqual(driver.image_scheme.images, images)
 
242
        self.assertEqual(driver.partition_scheme.fss, fss)