← Back to branch summary

~andrewjbeach/juju-ci-tools/get-juju-dict

« back to all changes in this revision

Viewing changes to tests/test_assess_constraints.py

  • Committer: Andrew Beach
  • Date: 2016-09-20 17:27:55 UTC
  • mfrom: (1587.1.23 constraints)
  • Revision ID: andrew.beach@canonical.com-20160920172755-7hg708o8px4o6qw7
Merged in new instance-type constraint test.

Show diffs side-by-side

added added

removed removed

Lines of Context:
tests/test_assess_constraints.py
2
2
 
3
3
from contextlib import contextmanager
4
4
import logging
5
 
from mock import Mock, patch
 
5
from mock import call, Mock, patch
6
6
import os
7
7
import StringIO
8
8
 
12
12
    Constraints,
13
13
    deploy_constraint,
14
14
    deploy_charm_constraint,
 
15
    juju_show_machine_hardware,
15
16
    parse_args,
16
17
    main,
 
18
    mem_to_int,
17
19
    INSTANCE_TYPES,
18
20
    )
19
21
from tests import (
22
24
    )
23
25
from tests.test_jujupy import fake_juju_client
24
26
from utility import (
 
27
    JujuAssertionError,
25
28
    temp_dir,
26
29
    )
27
30
 
46
49
 
47
50
class TestConstraints(TestCase):
48
51
 
 
52
    def test_mem_to_int(self):
 
53
        self.assertEqual(1, mem_to_int('1'))
 
54
        self.assertEqual(1, mem_to_int('1M'))
 
55
        self.assertEqual(1024, mem_to_int('1G'))
 
56
        self.assertEqual(4096, mem_to_int('4G'))
 
57
        with self.assertRaises(JujuAssertionError):
 
58
            mem_to_int('40XB')
 
59
 
49
60
    def test_str_operator(self):
50
61
        constraints = Constraints(mem='2G', root_disk='4G', virt_type='lxd')
51
62
        self.assertEqual('mem=2G virt-type=lxd root-disk=4G',
55
66
        self.assertEqual('', str(Constraints()))
56
67
        self.assertEqual('', str(Constraints(arch=None)))
57
68
 
 
69
    def test__meets_string(self):
 
70
        meets_string = Constraints._meets_string
 
71
        self.assertTrue(meets_string(None, 'amd64'))
 
72
        self.assertTrue(meets_string('amd64', 'amd64'))
 
73
        self.assertFalse(meets_string('i32', 'amd64'))
 
74
 
 
75
    def test__meets_min_int(self):
 
76
        meets_min_int = Constraints._meets_min_int
 
77
        self.assertTrue(meets_min_int(None, '2'))
 
78
        self.assertFalse(meets_min_int('2', '1'))
 
79
        self.assertTrue(meets_min_int('2', '2'))
 
80
        self.assertTrue(meets_min_int('2', '3'))
 
81
 
 
82
    def test__meets_min_mem(self):
 
83
        meets_min_mem = Constraints._meets_min_mem
 
84
        self.assertTrue(meets_min_mem(None, '64'))
 
85
        self.assertFalse(meets_min_mem('1G', '512M'))
 
86
        self.assertTrue(meets_min_mem('1G', '1024'))
 
87
        self.assertTrue(meets_min_mem('1G', '1G'))
 
88
        self.assertTrue(meets_min_mem('1G', '2G'))
 
89
 
 
90
    def test_meets_instance_type(self):
 
91
        constraints = Constraints(instance_type='t2.micro')
 
92
        data1 = {'root-disk': '1G', 'cpu-power': '10', 'cores': '1'}
 
93
        self.assertTrue(constraints.meets_instance_type(data1))
 
94
        data2 = {'root-disk': '8G', 'cpu-power': '20', 'cores': '1'}
 
95
        self.assertFalse(constraints.meets_instance_type(data2))
 
96
        data3 = dict(data1, arch='amd64')
 
97
        self.assertTrue(constraints.meets_instance_type(data3))
 
98
        data4 = {'cpu-power': '10', 'cores': '1'}
 
99
        with self.assertRaises(JujuAssertionError):
 
100
            constraints.meets_instance_type(data4)
 
101
 
 
102
    def test_meets_instance_type_fix(self):
 
103
        constraints = Constraints(instance_type='t2.micro')
 
104
        data = {'root-disk': '1G', 'cpu-power': '10', 'cpu-cores': '1'}
 
105
        self.assertTrue(constraints.meets_instance_type(data))
 
106
 
58
107
 
59
108
class TestMain(TestCase):
60
109
 
111
160
        constraints_calls = self.gather_constraint_args(deploy_mock)
112
161
        self.assertEqual(constraints_calls, assert_constraints_calls)
113
162
 
 
163
    @contextmanager
 
164
    def patch_instance_spec(self):
 
165
        bar_data = {'cpu-power': '20'}
 
166
 
 
167
        def mock_get_instance_spec(instance_type):
 
168
            if 'bar' == instance_type:
 
169
                return bar_data
 
170
            else:
 
171
                raise ValueError('instance-type not in mock.')
 
172
        with patch('assess_constraints.get_instance_spec', autospec=True,
 
173
                   side_effect=mock_get_instance_spec) as spec_mock:
 
174
            with patch('assess_constraints.juju_show_machine_hardware',
 
175
                       autospec=True, return_value=bar_data):
 
176
                yield spec_mock
 
177
 
114
178
    def test_instance_type_constraints(self):
115
 
        assert_constraints_calls = ['instance-type=bar', 'instance-type=baz']
116
 
        fake_instance_types = ['bar', 'baz']
 
179
        assert_constraints_calls = ['instance-type=bar']
 
180
        fake_instance_types = ['bar']
117
181
        with self.prepare_deploy_mock() as (fake_client, deploy_mock):
118
182
            fake_provider = fake_client.env.config.get('type')
119
183
            with patch.dict(INSTANCE_TYPES,
120
184
                            {fake_provider: fake_instance_types}):
121
 
                assess_instance_type_constraints(fake_client)
 
185
                with self.patch_instance_spec() as spec_mock:
 
186
                    assess_instance_type_constraints(fake_client)
122
187
        constraints_calls = self.gather_constraint_args(deploy_mock)
123
188
        self.assertEqual(constraints_calls, assert_constraints_calls)
 
189
        self.assertEqual(spec_mock.call_args_list, [call('bar')])
124
190
 
125
191
    def test_instance_type_constraints_missing(self):
126
192
        fake_client = Mock(wraps=fake_juju_client())
160
226
        charm = os.path.join(charm_dir, charm_series, charm_name)
161
227
        deploy_mock.assert_called_once_with(fake_client, constraints, charm,
162
228
                                            charm_series, charm_dir)
 
229
 
 
230
 
 
231
class TestJujuWrappers(TestCase):
 
232
 
 
233
    SAMPLE_JUJU_SHOW_MACHINE_OUTPUT = """\
 
234
model:
 
235
  name: controller
 
236
  controller: assessconstraints-20160914122952-temp-env
 
237
  cloud: lxd
 
238
  region: localhost
 
239
  version: 2.0-beta18
 
240
machines:
 
241
  "0":
 
242
    juju-status:
 
243
      current: started
 
244
      since: 14 Sep 2016 12:32:17-04:00
 
245
      version: 2.0-beta18
 
246
    dns-name: 10.252.22.39
 
247
    instance-id: juju-7d249e-0
 
248
    machine-status:
 
249
      current: pending
 
250
      since: 14 Sep 2016 12:32:07-04:00
 
251
    series: xenial
 
252
    hardware: arch=amd64 cpu-cores=0 mem=0M
 
253
    controller-member-status: has-vote
 
254
applications: {}"""
 
255
 
 
256
    def test_juju_show_machine_hardware(self):
 
257
        """Check the juju_show_machine_hardware data translation."""
 
258
        output_mock = Mock(
 
259
            return_value=self.SAMPLE_JUJU_SHOW_MACHINE_OUTPUT)
 
260
        fake_client = Mock(get_juju_output=output_mock)
 
261
        data = juju_show_machine_hardware(fake_client, '0')
 
262
        output_mock.assert_called_once_with('show-machine', '0',
 
263
                                            '--format', 'yaml')
 
264
        self.assertEqual({'arch': 'amd64', 'cpu-cores': '0', 'mem': '0M'},
 
265
                         data)