~ubuntu-branches/ubuntu/saucy/cloud-init/saucy

« back to all changes in this revision

Viewing changes to tests/unittests/test_datasource/test_smartos.py

  • Committer: Package Import Robot
  • Author(s): Scott Moser
  • Date: 2013-08-29 04:54:39 UTC
  • mfrom: (1.4.4)
  • Revision ID: package-import@ubuntu.com-20130829045439-lp1xe1nvv462ko11
Tags: 0.7.3~bzr862-0ubuntu1
* New upstream snapshot.
  * support base64 encoded data in the smart os datasource

Show diffs side-by-side

added added

removed removed

Lines of Context:
22
22
#   return responses.
23
23
#
24
24
 
 
25
import base64
25
26
from cloudinit import helpers
26
27
from cloudinit.sources import DataSourceSmartOS
27
28
 
28
29
from mocker import MockerTestCase
29
30
import uuid
30
31
 
31
 
mock_returns = {
 
32
MOCK_RETURNS = {
32
33
    'hostname': 'test-host',
33
34
    'root_authorized_keys': 'ssh-rsa AAAAB3Nz...aC1yc2E= keyname',
34
35
    'disable_iptables_flag': None,
35
36
    'enable_motd_sys_info': None,
36
 
    'system_uuid': str(uuid.uuid4()),
37
 
    'smartdc': 'smartdc',
38
 
    'userdata': """
39
 
#!/bin/sh
40
 
/bin/true
41
 
""",
 
37
    'test-var1': 'some data',
 
38
    'user-data': '\n'.join(['#!/bin/sh', '/bin/true', '']),
42
39
}
43
40
 
 
41
DMI_DATA_RETURN = (str(uuid.uuid4()), 'smartdc')
 
42
 
44
43
 
45
44
class MockSerial(object):
46
45
    """Fake a serial terminal for testing the code that
48
47
 
49
48
    port = None
50
49
 
51
 
    def __init__(self):
 
50
    def __init__(self, mockdata):
52
51
        self.last = None
53
52
        self.last = None
54
53
        self.new = True
55
54
        self.count = 0
56
55
        self.mocked_out = []
 
56
        self.mockdata = mockdata
57
57
 
58
58
    def open(self):
59
59
        return True
71
71
    def readline(self):
72
72
        if self.new:
73
73
            self.new = False
74
 
            if self.last in mock_returns:
 
74
            if self.last in self.mockdata:
75
75
                return 'SUCCESS\n'
76
76
            else:
77
77
                return 'NOTFOUND %s\n' % self.last
78
78
 
79
 
        if self.last in mock_returns:
 
79
        if self.last in self.mockdata:
80
80
            if not self.mocked_out:
81
81
                self.mocked_out = [x for x in self._format_out()]
82
82
                print self.mocked_out
86
86
                return self.mocked_out[self.count - 1]
87
87
 
88
88
    def _format_out(self):
89
 
        if self.last in mock_returns:
 
89
        if self.last in self.mockdata:
 
90
            _mret = self.mockdata[self.last]
90
91
            try:
91
 
                for l in mock_returns[self.last].splitlines():
92
 
                    yield "%s\n" % l
 
92
                for l in _mret.splitlines():
 
93
                    yield "%s\n" % l.rstrip()
93
94
            except:
94
 
                yield "%s\n" % mock_returns[self.last]
 
95
                yield "%s\n" % _mret.rstrip()
95
96
 
 
97
            yield '.'
96
98
            yield '\n'
97
 
            yield '.'
98
99
 
99
100
 
100
101
class TestSmartOSDataSource(MockerTestCase):
116
117
        ret = apply_patches(patches)
117
118
        self.unapply += ret
118
119
 
119
 
    def _get_ds(self):
 
120
    def _get_ds(self, sys_cfg=None, ds_cfg=None, mockdata=None, dmi_data=None):
 
121
        mod = DataSourceSmartOS
 
122
 
 
123
        if mockdata is None:
 
124
            mockdata = MOCK_RETURNS
 
125
 
 
126
        if dmi_data is None:
 
127
            dmi_data = DMI_DATA_RETURN
120
128
 
121
129
        def _get_serial(*_):
122
 
            return MockSerial()
 
130
            return MockSerial(mockdata)
123
131
 
124
132
        def _dmi_data():
125
 
            return mock_returns['system_uuid'], 'smartdc'
126
 
 
127
 
        data = {'sys_cfg': {}}
128
 
        mod = DataSourceSmartOS
 
133
            return dmi_data
 
134
 
 
135
        if sys_cfg is None:
 
136
            sys_cfg = {}
 
137
 
 
138
        if ds_cfg is not None:
 
139
            sys_cfg['datasource'] = sys_cfg.get('datasource', {})
 
140
            sys_cfg['datasource']['SmartOS'] = ds_cfg
 
141
 
129
142
        self.apply_patches([(mod, 'get_serial', _get_serial)])
130
143
        self.apply_patches([(mod, 'dmi_data', _dmi_data)])
131
 
        dsrc = mod.DataSourceSmartOS(
132
 
            data.get('sys_cfg', {}), distro=None, paths=self.paths)
 
144
        dsrc = mod.DataSourceSmartOS(sys_cfg, distro=None,
 
145
                                     paths=self.paths)
133
146
        return dsrc
134
147
 
135
148
    def test_seed(self):
 
149
        # default seed should be /dev/ttyS1
136
150
        dsrc = self._get_ds()
137
151
        ret = dsrc.get_data()
138
152
        self.assertTrue(ret)
144
158
        self.assertTrue(ret)
145
159
        self.assertTrue(dsrc.is_smartdc)
146
160
 
 
161
    def test_no_base64(self):
 
162
        ds_cfg = {'no_base64_decode': ['test_var1'], 'all_base': True}
 
163
        dsrc = self._get_ds(ds_cfg=ds_cfg)
 
164
        ret = dsrc.get_data()
 
165
        self.assertTrue(ret)
 
166
 
147
167
    def test_uuid(self):
148
 
        dsrc = self._get_ds()
 
168
        dsrc = self._get_ds(mockdata=MOCK_RETURNS)
149
169
        ret = dsrc.get_data()
150
170
        self.assertTrue(ret)
151
 
        self.assertEquals(mock_returns['system_uuid'],
152
 
                          dsrc.metadata['instance-id'])
 
171
        self.assertEquals(DMI_DATA_RETURN[0], dsrc.metadata['instance-id'])
153
172
 
154
173
    def test_root_keys(self):
155
 
        dsrc = self._get_ds()
 
174
        dsrc = self._get_ds(mockdata=MOCK_RETURNS)
156
175
        ret = dsrc.get_data()
157
176
        self.assertTrue(ret)
158
 
        self.assertEquals(mock_returns['root_authorized_keys'],
 
177
        self.assertEquals(MOCK_RETURNS['root_authorized_keys'],
159
178
                          dsrc.metadata['public-keys'])
160
179
 
 
180
    def test_hostname_b64(self):
 
181
        dsrc = self._get_ds(mockdata=MOCK_RETURNS)
 
182
        ret = dsrc.get_data()
 
183
        self.assertTrue(ret)
 
184
        self.assertEquals(MOCK_RETURNS['hostname'],
 
185
                          dsrc.metadata['local-hostname'])
 
186
 
161
187
    def test_hostname(self):
162
 
        dsrc = self._get_ds()
163
 
        ret = dsrc.get_data()
164
 
        self.assertTrue(ret)
165
 
        self.assertEquals(mock_returns['hostname'],
166
 
                          dsrc.metadata['local-hostname'])
 
188
        dsrc = self._get_ds(mockdata=MOCK_RETURNS)
 
189
        ret = dsrc.get_data()
 
190
        self.assertTrue(ret)
 
191
        self.assertEquals(MOCK_RETURNS['hostname'],
 
192
                          dsrc.metadata['local-hostname'])
 
193
 
 
194
    def test_base64_all(self):
 
195
        # metadata provided base64_all of true
 
196
        my_returns = MOCK_RETURNS.copy()
 
197
        my_returns['base64_all'] = "true"
 
198
        for k in ('hostname', 'user-data'):
 
199
            my_returns[k] = base64.b64encode(my_returns[k])
 
200
 
 
201
        dsrc = self._get_ds(mockdata=my_returns)
 
202
        ret = dsrc.get_data()
 
203
        self.assertTrue(ret)
 
204
        self.assertEquals(MOCK_RETURNS['hostname'],
 
205
                          dsrc.metadata['local-hostname'])
 
206
        self.assertEquals(MOCK_RETURNS['user-data'],
 
207
                          dsrc.userdata_raw)
 
208
        self.assertEquals(MOCK_RETURNS['root_authorized_keys'],
 
209
                          dsrc.metadata['public-keys'])
 
210
        self.assertEquals(MOCK_RETURNS['disable_iptables_flag'],
 
211
                          dsrc.metadata['iptables_disable'])
 
212
        self.assertEquals(MOCK_RETURNS['enable_motd_sys_info'],
 
213
                          dsrc.metadata['motd_sys_info'])
 
214
 
 
215
    def test_b64_userdata(self):
 
216
        my_returns = MOCK_RETURNS.copy()
 
217
        my_returns['b64-user-data'] = "true"
 
218
        my_returns['b64-hostname'] = "true"
 
219
        for k in ('hostname', 'user-data'):
 
220
            my_returns[k] = base64.b64encode(my_returns[k])
 
221
 
 
222
        dsrc = self._get_ds(mockdata=my_returns)
 
223
        ret = dsrc.get_data()
 
224
        self.assertTrue(ret)
 
225
        self.assertEquals(MOCK_RETURNS['hostname'],
 
226
                          dsrc.metadata['local-hostname'])
 
227
        self.assertEquals(MOCK_RETURNS['user-data'], dsrc.userdata_raw)
 
228
        self.assertEquals(MOCK_RETURNS['root_authorized_keys'],
 
229
                          dsrc.metadata['public-keys'])
 
230
 
 
231
    def test_b64_keys(self):
 
232
        my_returns = MOCK_RETURNS.copy()
 
233
        my_returns['base64_keys'] = 'hostname,ignored'
 
234
        for k in ('hostname',):
 
235
            my_returns[k] = base64.b64encode(my_returns[k])
 
236
 
 
237
        dsrc = self._get_ds(mockdata=my_returns)
 
238
        ret = dsrc.get_data()
 
239
        self.assertTrue(ret)
 
240
        self.assertEquals(MOCK_RETURNS['hostname'],
 
241
                          dsrc.metadata['local-hostname'])
 
242
        self.assertEquals(MOCK_RETURNS['user-data'], dsrc.userdata_raw)
 
243
 
 
244
    def test_userdata(self):
 
245
        dsrc = self._get_ds(mockdata=MOCK_RETURNS)
 
246
        ret = dsrc.get_data()
 
247
        self.assertTrue(ret)
 
248
        self.assertEquals(MOCK_RETURNS['user-data'], dsrc.userdata_raw)
167
249
 
168
250
    def test_disable_iptables_flag(self):
169
 
        dsrc = self._get_ds()
 
251
        dsrc = self._get_ds(mockdata=MOCK_RETURNS)
170
252
        ret = dsrc.get_data()
171
253
        self.assertTrue(ret)
172
 
        self.assertEquals(mock_returns['disable_iptables_flag'],
 
254
        self.assertEquals(MOCK_RETURNS['disable_iptables_flag'],
173
255
                          dsrc.metadata['iptables_disable'])
174
256
 
175
257
    def test_motd_sys_info(self):
176
 
        dsrc = self._get_ds()
 
258
        dsrc = self._get_ds(mockdata=MOCK_RETURNS)
177
259
        ret = dsrc.get_data()
178
260
        self.assertTrue(ret)
179
 
        self.assertEquals(mock_returns['enable_motd_sys_info'],
 
261
        self.assertEquals(MOCK_RETURNS['enable_motd_sys_info'],
180
262
                          dsrc.metadata['motd_sys_info'])
181
263
 
182
264