1
=== modified file 'quickstart/__init__.py'
2
--- quickstart/__init__.py	2013-11-06 10:17:08 +0000
3
+++ quickstart/__init__.py	2013-11-18 16:54:22 +0000
4
@@ -19,7 +19,7 @@
5
19
that it can be managed using a Web interface (the Juju GUI).
19
that it can be managed using a Web interface (the Juju GUI).
6
20
"""
20
"""
7
21
21
9
22
VERSION = (0, 3, 0)
22
VERSION = (0, 4, 0)
10
23
23
11
24
24
12
25
def get_version():
25
def get_version():
13
26
26
14
=== modified file 'quickstart/app.py'
15
--- quickstart/app.py	2013-11-13 12:23:36 +0000
16
+++ quickstart/app.py	2013-11-18 16:54:22 +0000
17
@@ -47,17 +47,41 @@
18
47
def bootstrap(env_name, debug=False):
47
def bootstrap(env_name, debug=False):
19
48
    """Bootstrap the Juju environment with the given name.
48
    """Bootstrap the Juju environment with the given name.
20
49
49
24
50
    If debug is True, bootstrap the environment passing the --debug flag.
50
    Do not bootstrap the environment if already bootstrapped.
25
51
51
26
52
    Return when the bootstrap node is ready.
52
    Return True without errors if the environment is already bootstrapped.
27
53
    Return False otherwise. Only return when the bootstrap node is ready.
28
54
29
55
    If debug is True and the environment not bootstrapped, execute the
30
56
    bootstrap command passing the --debug flag.
31
57
32
53
    Raise a ProgramExit if any error occurs in the bootstrap process.
58
    Raise a ProgramExit if any error occurs in the bootstrap process.
33
54
    """
59
    """
34
60
    already_bootstrapped = False
35
55
    cmd = ['juju', 'bootstrap', '-e', env_name]
61
    cmd = ['juju', 'bootstrap', '-e', env_name]
36
56
    if debug:
62
    if debug:
37
57
        cmd.append('--debug')
63
        cmd.append('--debug')
38
58
    retcode, _, error = utils.call(*cmd)
64
    retcode, _, error = utils.call(*cmd)
39
59
    if retcode:
65
    if retcode:
41
60
        raise ProgramExit(error)
66
        # XXX frankban 2013-11-13 bug 1252322: the check below is weak. We are
42
67
        # relying on an error message in order to decide if the environment is
43
68
        # already bootstrapped. Other possibilities include checking if the
44
69
        # jenv file is present (in ~/.juju/environments/) and, if so, check the
45
70
        # juju status. Unfortunately this is also prone to errors, because a
46
71
        # jenv file can be there but the environment not really bootstrapped or
47
72
        # functional (e.g. sync-tools was used, or a previous bootstrap failed,
48
73
        # or the user terminated machines from the ec2 panel, etc.). Moreover
49
74
        # jenv files seems to be an internal juju-core detail. Definitely we
50
75
        # need to find a better way, but for now the "asking forgiveness"
51
76
        # approach feels like the best compromise we have. Also note that,
52
77
        # rather than comparing the expected error with the obtained one, we
53
78
        # search in the error in order to support bootstrap --debug.
54
79
        if 'environment is already bootstrapped' not in error:
55
80
            # We exit if the error is not "already bootstrapped".
56
81
            raise ProgramExit(error)
57
82
        # Juju is bootstrapped, but we don't know if it is ready yet. Fall
58
83
        # through to the next block for that check.
59
84
        already_bootstrapped = True
60
61
    # Call "juju status" multiple times until the bootstrap node is ready.
85
    # Call "juju status" multiple times until the bootstrap node is ready.
61
62
    for _ in range(5):
86
    for _ in range(5):
62
63
        retcode, output, error = utils.call(
87
        retcode, output, error = utils.call(
63
@@ -70,7 +94,7 @@
64
70
        except ValueError:
94
        except ValueError:
65
71
            continue
95
            continue
66
72
        if agent_state == 'started':
96
        if agent_state == 'started':
68
73
            return
97
            return already_bootstrapped
69
74
    details = ''.join(filter(None, [output, error])).strip()
98
    details = ''.join(filter(None, [output, error])).strip()
70
75
    raise ProgramExit('the state server is not ready:\n{}'.format(details))
99
    raise ProgramExit('the state server is not ready:\n{}'.format(details))
71
76
100
72
@@ -112,34 +136,88 @@
73
112
    return env
136
    return env
74
113
137
75
114
138
77
115
def deploy_gui(env, service_name, charm_url=None):
139
def deploy_gui(
78
140
        env, service_name, machine, charm_url=None, check_preexisting=False):
79
116
    """Deploy and expose the given service, reusing the bootstrap node.
141
    """Deploy and expose the given service, reusing the bootstrap node.
80
117
142
87
118
    Receive an authenticated Juju Environment instance, the name of the service
143
    Only deploy the service if not already present in the environment.
88
119
    and the optional Juju GUI charm URL, e.g. cs:~juju-gui/precise/juju-gui-42.
144
    Do not add a unit to the service if the unit is already there.
89
120
    If the charm URL is not provided, the function tries to retrieve it from
145
90
121
    charmworld. In this case a default charm URL is used if charmworld is not
146
    Receive an authenticated Juju Environment instance, the name of the
91
122
    available.
147
    service, the machine where to deploy to (or None for a new machine),
92
123
148
    the optional Juju GUI charm URL (e.g. cs:~juju-gui/precise/juju-gui-42),
93
149
    and a flag (check_preexisting) that can be set to True in order to make
94
150
    the function check for a pre-existing service and/or unit.
95
151
96
152
    If the charm URL is not provided, and the service is not already deployed,
97
153
    the function tries to retrieve it from charmworld. In this case a default
98
154
    charm URL is used if charmworld is not available.
99
155
100
156
    Return the name of the first running unit belonging to the given service.
101
124
    Raise a ProgramExit if the API server returns an error response.
157
    Raise a ProgramExit if the API server returns an error response.
102
125
    """
158
    """
120
126
    if charm_url is None:
159
    service_data, unit_data = None, None
121
127
        try:
160
    if check_preexisting:
122
128
            charm_url = utils.get_charm_url()
161
        # The service and/or the unit can be already in the environment.
123
129
        except (IOError, ValueError) as err:
162
        try:
124
130
            msg = 'unable to retrieve the Juju GUI charm URL from the API: {}'
163
            status = env.get_status()
125
131
            logging.warn(msg.format(err))
164
        except jujuclient.EnvError as err:
126
132
            charm_url = settings.DEFAULT_CHARM_URL
165
            raise ProgramExit('bad API response: {}'.format(err.message))
127
133
    print('charm URL: {}'.format(charm_url))
166
        service_data, unit_data = utils.get_service_info(status, service_name)
128
134
    try:
167
    if service_data is None:
129
135
        env.deploy(service_name, charm_url, to=0)
168
        # The service does not exist in the environment.
130
136
        env.expose(service_name)
169
        print('requesting {} deployment'.format(service_name))
131
137
    except jujuclient.EnvError as err:
170
        if charm_url is None:
132
138
        raise ProgramExit('bad API server response: {}'.format(err.message))
171
            try:
133
139
172
                charm_url = utils.get_charm_url()
134
140
173
            except (IOError, ValueError) as err:
135
141
def watch(env, service_name):
174
                msg = 'unable to retrieve the {} charm URL from the API: {}'
136
142
    """Start watching the first unit belonging to the given service.
175
                logging.warn(msg.format(service_name, err))
137
176
                charm_url = settings.DEFAULT_CHARM_URL
138
177
        print('charm URL: {}'.format(charm_url))
139
178
        # Deploy the service without units.
140
179
        try:
141
180
            env.deploy(service_name, charm_url, num_units=0)
142
181
        except jujuclient.EnvError as err:
143
182
            raise ProgramExit('bad API response: {}'.format(err.message))
144
183
        print('{} deployment request accepted'.format(service_name))
145
184
        service_exposed = False
146
185
    else:
147
186
        # We already have the service in the environment.
148
187
        print('service {} already deployed'.format(service_name))
149
188
        charm_url = service_data['CharmURL']
150
189
        print('charm URL: {}'.format(charm_url))
151
190
        # XXX frankban: warn the user if the actual charm_url != the given
152
191
        # charm_url, and warn louder if the charm URL does not match
153
192
        # /\/juju-gui-\d+$/.
154
193
        service_exposed = service_data.get('Exposed', False)
155
194
    # At this point the service is surely deployed in the environment: expose
156
195
    # it if necessary and add a unit if it is missing.
157
196
    if not service_exposed:
158
197
        print('exposing service {}'.format(service_name))
159
198
        try:
160
199
            env.expose(service_name)
161
200
        except jujuclient.EnvError as err:
162
201
            raise ProgramExit('bad API response: {}'.format(err.message))
163
202
    if unit_data is None:
164
203
        # Add a unit to the service.
165
204
        print('requesting new unit deployment')
166
205
        try:
167
206
            response = env.add_unit(service_name, machine_spec=machine)
168
207
        except jujuclient.EnvError as err:
169
208
            raise ProgramExit('bad API response: {}'.format(err.message))
170
209
        unit_name = response['Units'][0]
171
210
        print('{} deployment request accepted'.format(unit_name))
172
211
    else:
173
212
        # A service unit is already present in the environment. Go ahead
174
213
        # and try to reuse that unit.
175
214
        unit_name = unit_data['Name']
176
215
        print('reusing unit {}'.format(unit_name))
177
216
    return unit_name
178
217
179
218
180
219
def watch(env, unit_name):
181
220
    """Start watching the given unit.
182
143
221
183
144
    Output a human readable messages from each time a relevant change is found.
222
    Output a human readable messages from each time a relevant change is found.
184
145
223
185
@@ -153,7 +231,6 @@
186
153
    Raise a ProgramExit if the API server returns an error response, or if
231
    Raise a ProgramExit if the API server returns an error response, or if
187
154
    the service unit is removed or in error.
232
    the service unit is removed or in error.
188
155
    """
233
    """
189
156
    unit_name = '{}/0'.format(service_name)
190
157
    processor = functools.partial(utils.unit_changes, unit_name)
234
    processor = functools.partial(utils.unit_changes, unit_name)
191
158
    watcher = env.watch_changes(processor)
235
    watcher = env.watch_changes(processor)
192
159
    address = current_status = ''
236
    address = current_status = ''
193
@@ -176,7 +253,7 @@
194
176
        if not address:
253
        if not address:
195
177
            address = data['PublicAddress']
254
            address = data['PublicAddress']
196
178
            if address:
255
            if address:
198
179
                print('installing {} on {}'.format(unit_name, address))
256
                print('setting up {} on {}'.format(unit_name, address))
199
180
        # Notify status changes.
257
        # Notify status changes.
200
181
        if status != current_status:
258
        if status != current_status:
201
182
            if status == 'pending':
259
            if status == 'pending':
202
@@ -185,7 +262,8 @@
203
185
                print('{} is installed'.format(unit_name))
262
                print('{} is installed'.format(unit_name))
204
186
            elif address and status == 'started':
263
            elif address and status == 'started':
205
187
                # We can exit this loop.
264
                # We can exit this loop.
207
188
                print('{} is ready'.format(unit_name))
265
                print('{} is ready on machine {}'.format(
208
266
                    unit_name, data['MachineId']))
209
189
                return address
267
                return address
210
190
            current_status = status
268
            current_status = status
211
191
269
212
192
270
213
=== modified file 'quickstart/juju.py'
214
--- quickstart/juju.py	2013-10-30 11:44:35 +0000
215
+++ quickstart/juju.py	2013-11-18 16:54:22 +0000
216
@@ -41,35 +41,25 @@
217
41
    deployments to specific machines.
41
    deployments to specific machines.
218
42
    """
42
    """
219
43
43
224
44
    def deploy(
44
    def add_unit(self, service_name, machine_spec=None):
225
45
            self, service_name, charm_url, num_units=1, config=None,
45
        """Add a unit to the given service and machine.
222
46
            constraints=None, to=None):
223
47
        """Deploy a charm. Local charms are not supported.
226
48
46
229
49
        This method is overridden to add the ability to deploy to a specific
47
        This method is present in newer versions of python-jujuclient and can
230
50
        machine (i.e. support the ToMachineSpec API parameter).
48
        be safely deleted when upgrading to the new releases.
231
51
        """
49
        """
238
52
        service_config = {}
50
        # XXX frankban 2013-11-15: remove this method when upgrading to
239
53
        if config is not None:
51
        # python-jujuclient >= 0.15.
234
54
            service_config = self._prepare_strparams(config)
235
55
        service_constraints = {}
236
56
        if constraints is not None:
237
57
            service_constraints = self._prepare_constraints(constraints)
240
58
        params = {
52
        params = {
241
59
            'ServiceName': service_name,
53
            'ServiceName': service_name,
246
60
            'CharmURL': charm_url,
54
            'NumUnits': 1,
243
61
            'NumUnits': num_units,
244
62
            'Config': service_config,
245
63
            'Constraints': service_constraints,
247
64
        }
55
        }
251
65
        if to is not None:
56
        if machine_spec is not None:
252
66
            params['ToMachineSpec'] = str(to)
57
            params['ToMachineSpec'] = machine_spec
253
67
        request = {
58
        return self._rpc({
254
68
            'Type': 'Client',
59
            'Type': 'Client',
256
69
            'Request': 'ServiceDeploy',
60
            'Request': 'AddServiceUnits',
257
70
            'Params': params,
61
            'Params': params,
260
71
        }
62
        })
259
72
        return self._rpc(request)
261
73
63
262
74
    def deploy_bundle(self, yaml, name=None):
64
    def deploy_bundle(self, yaml, name=None):
263
75
        """Deploy a bundle."""
65
        """Deploy a bundle."""
264
@@ -83,13 +73,28 @@
265
83
        }
73
        }
266
84
        return self._rpc(request)
74
        return self._rpc(request)
267
85
75
268
76
    def get_status(self):
269
77
        """Return the current status of the environment.
270
78
271
79
        The status is represented by a single mega-watcher changeset.
272
80
        Each change in the changeset is a tuple (entity, action, data) where:
273
81
            - entity is a string representing the changed content type
274
82
              (e.g. "service" or "unit");
275
83
            - action is a string representing the event which generated the
276
84
              change (i.e. "change" or "remove");
277
85
            - data is a dict containing information about the releated entity.
278
86
        """
279
87
        with self.get_watch() as watcher:
280
88
            changeset = watcher.next()
281
89
        return changeset
282
90
283
86
    def watch_changes(self, processor):
91
    def watch_changes(self, processor):
284
87
        """Start watching the changes occurring in the Juju environment.
92
        """Start watching the changes occurring in the Juju environment.
285
88
93
286
89
        For each changeset, call the given processor callable, and yield
94
        For each changeset, call the given processor callable, and yield
287
90
        the values returned by the processor.
95
        the values returned by the processor.
288
91
        """
96
        """
290
92
        with jujuclient.Watcher(self.conn) as watcher:
97
        with self.get_watch() as watcher:
291
93
            # The watcher closes when the context manager exit hook is called.
98
            # The watcher closes when the context manager exit hook is called.
292
94
            for changeset in watcher:
99
            for changeset in watcher:
293
95
                changes = processor(changeset)
100
                changes = processor(changeset)
294
96
101
295
=== modified file 'quickstart/manage.py'
296
--- quickstart/manage.py	2013-11-13 12:23:36 +0000
297
+++ quickstart/manage.py	2013-11-18 16:54:22 +0000
298
@@ -187,7 +187,8 @@
299
187
        help='The Juju GUI charm URL to deploy in the environment. If not '
187
        help='The Juju GUI charm URL to deploy in the environment. If not '
300
188
             'provided, the last release of the GUI will be deployed. The '
188
             'provided, the last release of the GUI will be deployed. The '
301
189
             'charm URL must include the charm version, e.g. '
189
             'charm URL must include the charm version, e.g. '
303
190
             'cs:~juju-gui/precise/juju-gui-116')
190
             'cs:~juju-gui/precise/juju-gui-116. This option is ignored if '
304
191
             'Juju GUI is already present in the environment')
305
191
    parser.add_argument(
192
    parser.add_argument(
306
192
        '--no-browser', action='store_false', dest='open_browser',
193
        '--no-browser', action='store_false', dest='open_browser',
307
193
        help='Avoid opening the browser to the GUI at the end of the process')
194
        help='Avoid opening the browser to the GUI at the end of the process')
308
@@ -218,15 +219,23 @@
309
218
    print('juju quickstart v{}'.format(version))
219
    print('juju quickstart v{}'.format(version))
310
219
    print('bootstrapping the {} environment (type: {})'.format(
220
    print('bootstrapping the {} environment (type: {})'.format(
311
220
        options.env_name, options.env_type))
221
        options.env_name, options.env_type))
313
221
    app.bootstrap(options.env_name, debug=options.debug)
222
    already_bootstrapped = app.bootstrap(options.env_name, debug=options.debug)
314
223
    if already_bootstrapped:
315
224
        print('reusing the already bootstrapped {} environment'.format(
316
225
            options.env_name))
317
226
318
222
    print('retrieving the Juju API address')
227
    print('retrieving the Juju API address')
319
223
    api_url = app.get_api_url(options.env_name)
228
    api_url = app.get_api_url(options.env_name)
320
224
    print('connecting to {}'.format(api_url))
229
    print('connecting to {}'.format(api_url))
321
225
    env = app.connect(api_url, options.admin_secret)
230
    env = app.connect(api_url, options.admin_secret)
326
226
    print('requesting Juju GUI deployment')
231
327
227
    app.deploy_gui(env, settings.JUJU_GUI_NAME, charm_url=options.charm_url)
232
    # It is not possible to deploy on the bootstrap node if we are using the
328
228
    print('Juju GUI deployment request accepted')
233
    # local provider.
329
229
    address = app.watch(env, settings.JUJU_GUI_NAME)
234
    machine = None if options.env_type == 'local' else '0'
330
235
    unit_name = app.deploy_gui(
331
236
        env, settings.JUJU_GUI_NAME, machine, charm_url=options.charm_url,
332
237
        check_preexisting=already_bootstrapped)
333
238
    address = app.watch(env, unit_name)
334
230
    url = 'https://{}'.format(address)
239
    url = 'https://{}'.format(address)
335
231
    print('url: {}\npassword: {}'.format(url, options.admin_secret))
240
    print('url: {}\npassword: {}'.format(url, options.admin_secret))
336
232
241
337
233
242
338
=== modified file 'quickstart/tests/helpers.py'
339
--- quickstart/tests/helpers.py	2013-11-06 14:55:30 +0000
340
+++ quickstart/tests/helpers.py	2013-11-18 16:54:22 +0000
341
@@ -150,3 +150,33 @@
342
150
        with self.assertRaises(ValueError) as context_manager:
150
        with self.assertRaises(ValueError) as context_manager:
343
151
            yield
151
            yield
344
152
        self.assertEqual(error, str(context_manager.exception))
152
        self.assertEqual(error, str(context_manager.exception))
345
153
346
154
347
155
class WatcherDataTestsMixin(object):
348
156
    """Shared methods for testing Juju mega-watcher data."""
349
157
350
158
    def _make_change(self, entity, action, default_data, data):
351
159
        if data is not None:
352
160
            default_data.update(data)
353
161
        return entity, action, default_data
354
162
355
163
    def make_service_change(self, action='change', data=None):
356
164
        """Create and return a change on a service.
357
165
358
166
        The passed data can be used to override default values.
359
167
        """
360
168
        default_data = {
361
169
            'CharmURL': 'cs:precise/juju-gui-47',
362
170
            'Exposed': True,
363
171
            'Life': 'alive',
364
172
            'Name': 'my-gui',
365
173
        }
366
174
        return self._make_change('service', action, default_data, data)
367
175
368
176
    def make_unit_change(self, action='change', data=None):
369
177
        """Create and return a change on a unit.
370
178
371
179
        The passed data can be used to override default values.
372
180
        """
373
181
        default_data = {'Name': 'my-gui/47', 'Service': 'my-gui'}
374
182
        return self._make_change('unit', action, default_data, data)
375
153
183
376
=== modified file 'quickstart/tests/test_app.py'
377
--- quickstart/tests/test_app.py	2013-11-13 12:23:36 +0000
378
+++ quickstart/tests/test_app.py	2013-11-18 16:54:22 +0000
379
@@ -99,7 +99,8 @@
380
99
    def test_success(self):
99
    def test_success(self):
381
100
        # The environment is successfully bootstrapped.
100
        # The environment is successfully bootstrapped.
382
101
        with self.patch_multiple_calls(self.make_side_effects()) as mock_call:
101
        with self.patch_multiple_calls(self.make_side_effects()) as mock_call:
384
102
            app.bootstrap(self.env_name)
102
            already_bootstrapped = app.bootstrap(self.env_name)
385
103
        self.assertFalse(already_bootstrapped)
386
103
        mock_call.assert_has_calls([
104
        mock_call.assert_has_calls([
387
104
            mock.call('juju', 'bootstrap', '-e', self.env_name),
105
            mock.call('juju', 'bootstrap', '-e', self.env_name),
388
105
        ] + self.make_status_calls(1))
106
        ] + self.make_status_calls(1))
389
@@ -107,11 +108,26 @@
390
107
    def test_success_debug(self):
108
    def test_success_debug(self):
391
108
        # The environment is successfully bootstrapped in debug mode.
109
        # The environment is successfully bootstrapped in debug mode.
392
109
        with self.patch_multiple_calls(self.make_side_effects()) as mock_call:
110
        with self.patch_multiple_calls(self.make_side_effects()) as mock_call:
394
110
            app.bootstrap(self.env_name, debug=True)
111
            already_bootstrapped = app.bootstrap(self.env_name, debug=True)
395
112
        self.assertFalse(already_bootstrapped)
396
111
        mock_call.assert_has_calls([
113
        mock_call.assert_has_calls([
397
112
            mock.call('juju', 'bootstrap', '-e', self.env_name, '--debug'),
114
            mock.call('juju', 'bootstrap', '-e', self.env_name, '--debug'),
398
113
        ] + self.make_status_calls(1))
115
        ] + self.make_status_calls(1))
399
114
116
400
117
    def test_already_bootstrapped(self):
401
118
        # The function succeeds and returns True if the environment is already
402
119
        # bootstrapped.
403
120
        side_effects = [
404
121
            (1, '', '***environment is already bootstrapped**'),
405
122
            (0, self.make_status_output('started'), ''),
406
123
        ]
407
124
        with self.patch_multiple_calls(side_effects) as mock_call:
408
125
            already_bootstrapped = app.bootstrap(self.env_name)
409
126
        self.assertTrue(already_bootstrapped)
410
127
        mock_call.assert_has_calls([
411
128
            mock.call('juju', 'bootstrap', '-e', self.env_name),
412
129
        ] + self.make_status_calls(1))
413
130
414
115
    def test_bootstrap_failure(self):
131
    def test_bootstrap_failure(self):
415
116
        # A ProgramExit is raised if an error occurs while bootstrapping.
132
        # A ProgramExit is raised if an error occurs while bootstrapping.
416
117
        with self.patch_call(1, error='bad wolf') as mock_call:
133
        with self.patch_call(1, error='bad wolf') as mock_call:
417
@@ -251,10 +267,32 @@
418
251
267
419
252
268
420
253
@mock_print
269
@mock_print
422
254
class TestDeployGui(ProgramExitTestsMixin, unittest.TestCase):
270
class TestDeployGui(
423
271
        ProgramExitTestsMixin, helpers.WatcherDataTestsMixin,
424
272
        unittest.TestCase):
425
255
273
426
256
    charm_url = 'cs:precise/juju-gui-42'
274
    charm_url = 'cs:precise/juju-gui-42'
427
257
275
428
276
    def make_env(self, unit_name=None, service_data=None, unit_data=None):
429
277
        """Create and return a mock environment object.
430
278
431
279
        Set up the object so that a call to add_unit returns the given
432
280
        unit_name, and a call to status returns a status object containing the
433
281
        service and unit described by the given service_data and unit_data.
434
282
        """
435
283
        env = mock.Mock()
436
284
        # Set up the add_unit return value.
437
285
        if unit_name is not None:
438
286
            env.add_unit.return_value = {'Units': [unit_name]}
439
287
        #Set up the get_status return value.
440
288
        status = []
441
289
        if service_data is not None:
442
290
            status.append(self.make_service_change(data=service_data))
443
291
        if unit_data is not None:
444
292
            status.append(self.make_unit_change(data=unit_data))
445
293
        env.get_status.return_value = status
446
294
        return env
447
295
448
258
    def patch_get_charm_url(self, side_effect=None):
296
    def patch_get_charm_url(self, side_effect=None):
449
259
        """Patch the get_charm_url helper function."""
297
        """Patch the get_charm_url helper function."""
450
260
        if side_effect is None:
298
        if side_effect is None:
451
@@ -265,65 +303,198 @@
452
265
    def test_deployment(self, mock_print):
303
    def test_deployment(self, mock_print):
453
266
        # The function correctly deploys and exposes the service, retrieving
304
        # The function correctly deploys and exposes the service, retrieving
454
267
        # the charm URL from the charmworld API.
305
        # the charm URL from the charmworld API.
466
268
        env = mock.Mock()
306
        env = self.make_env(unit_name='my-gui/42')
467
269
        with self.patch_get_charm_url():
307
        with self.patch_get_charm_url():
468
270
            app.deploy_gui(env, 'my-gui')
308
            unit_name = app.deploy_gui(env, 'my-gui', '0')
469
271
        env.assert_has_calls([
309
        self.assertEqual('my-gui/42', unit_name)
470
272
            mock.call.deploy('my-gui', self.charm_url, to=0),
310
        env.assert_has_calls([
471
273
            mock.call.expose('my-gui')
311
            mock.call.deploy('my-gui', self.charm_url, num_units=0),
472
274
        ])
312
            mock.call.expose('my-gui'),
473
275
        mock_print.assert_called_once_with(
313
            mock.call.add_unit('my-gui', machine_spec='0'),
474
276
            'charm URL: {}'.format(self.charm_url))
314
        ])
475
277
315
        # There is no need to call status if the environment was just created.
476
278
    def test_deployment_default_charm_url(self, mock_print):
316
        self.assertFalse(env.get_status.called)
477
317
        mock_print.assert_has_calls([
478
318
            mock.call('requesting my-gui deployment'),
479
319
            mock.call('charm URL: {}'.format(self.charm_url)),
480
320
            mock.call('my-gui deployment request accepted'),
481
321
            mock.call('exposing service my-gui'),
482
322
            mock.call('requesting new unit deployment'),
483
323
            mock.call('my-gui/42 deployment request accepted'),
484
324
        ])
485
325
486
326
    def test_existing_environment_without_entities(self, mock_print):
487
327
        # The deployment is processed in an already bootstrapped environment
488
328
        # with no relevant entities in it.
489
329
        env = self.make_env(unit_name='my-gui/42')
490
330
        with self.patch_get_charm_url():
491
331
            unit_name = app.deploy_gui(
492
332
                env, 'my-gui', '0', check_preexisting=True)
493
333
        self.assertEqual('my-gui/42', unit_name)
494
334
        env.assert_has_calls([
495
335
            mock.call.get_status(),
496
336
            mock.call.deploy('my-gui', self.charm_url, num_units=0),
497
337
            mock.call.expose('my-gui'),
498
338
            mock.call.add_unit('my-gui', machine_spec='0'),
499
339
        ])
500
340
501
341
    def test_default_charm_url(self, mock_print):
502
279
        # The function correctly deploys and exposes the service, even if it is
342
        # The function correctly deploys and exposes the service, even if it is
503
280
        # not able to retrieve the charm URL from the charmworld API.
343
        # not able to retrieve the charm URL from the charmworld API.
506
281
        env = mock.Mock()
344
        env = self.make_env(unit_name='my-gui/42')
507
282
        log = 'unable to retrieve the Juju GUI charm URL from the API: boo!'
345
        log = 'unable to retrieve the my-gui charm URL from the API: boo!'
508
283
        with self.patch_get_charm_url(side_effect=IOError('boo!')):
346
        with self.patch_get_charm_url(side_effect=IOError('boo!')):
509
284
            # A warning is logged which notifies we are using the default URL.
347
            # A warning is logged which notifies we are using the default URL.
510
285
            with helpers.assert_logs([log], level='warn'):
348
            with helpers.assert_logs([log], level='warn'):
512
286
                app.deploy_gui(env, 'my-gui')
349
                app.deploy_gui(env, 'my-gui', '0')
513
287
        env.assert_has_calls([
350
        env.assert_has_calls([
519
288
            mock.call.deploy('my-gui', settings.DEFAULT_CHARM_URL, to=0),
351
            mock.call.deploy(
520
289
            mock.call.expose('my-gui')
352
                'my-gui', settings.DEFAULT_CHARM_URL, num_units=0),
521
290
        ])
353
            mock.call.expose('my-gui'),
522
291
        mock_print.assert_called_once_with(
354
            mock.call.add_unit('my-gui', machine_spec='0'),
523
292
            'charm URL: {}'.format(settings.DEFAULT_CHARM_URL))
355
        ])
524
356
        mock_print.assert_has_calls([
525
357
            mock.call('requesting my-gui deployment'),
526
358
            mock.call('charm URL: {}'.format(settings.DEFAULT_CHARM_URL)),
527
359
        ])
528
293
360
530
294
    def test_deployment_provided_charm_url(self, mock_print):
361
    def test_provided_charm_url(self, mock_print):
531
295
        # The function correctly deploys and exposes the service using a user
362
        # The function correctly deploys and exposes the service using a user
532
296
        # provided Juju GUI charm URL.
363
        # provided Juju GUI charm URL.
534
297
        env = mock.Mock()
364
        env = self.make_env(unit_name='my-gui/42')
535
298
        charm_url = 'cs:~juju-gui/precise/juju-gui-116'
365
        charm_url = 'cs:~juju-gui/precise/juju-gui-116'
551
299
        app.deploy_gui(env, 'my-gui', charm_url=charm_url)
366
        app.deploy_gui(env, 'my-gui', '0', charm_url=charm_url)
552
300
        env.assert_has_calls([
367
        env.assert_has_calls([
553
301
            mock.call.deploy('my-gui', charm_url, to=0),
368
            mock.call.deploy('my-gui', charm_url, num_units=0),
554
302
            mock.call.expose('my-gui')
369
            mock.call.expose('my-gui'),
555
303
        ])
370
            mock.call.add_unit('my-gui', machine_spec='0'),
556
304
        mock_print.assert_called_once_with('charm URL: {}'.format(charm_url))
371
        ])
557
305
372
        mock_print.assert_has_calls([
558
306
    def test_api_error(self, mock_print):
373
            mock.call('requesting my-gui deployment'),
559
307
        # A ProgramExit is raised if an error occurs in one of the API calls.
374
            mock.call('charm URL: {}'.format(charm_url)),
560
308
        env = mock.Mock()
375
        ])
561
309
        env.deploy.side_effect = self.make_env_error('service already exists')
376
562
310
        expected = 'bad API server response: service already exists'
377
    def test_existing_service(self, mock_print):
563
311
        with self.patch_get_charm_url():
378
        # The deployment is executed reusing an already deployed service.
564
312
            with self.assert_program_exit(expected):
379
        env = self.make_env(unit_name='my-gui/42', service_data={})
565
313
                app.deploy_gui(env, 'another-gui')
380
        unit_name = app.deploy_gui(
566
381
            env, 'my-gui', '0', check_preexisting=True)
567
382
        self.assertEqual('my-gui/42', unit_name)
568
383
        env.assert_has_calls([
569
384
            mock.call.get_status(),
570
385
            mock.call.add_unit('my-gui', machine_spec='0'),
571
386
        ])
572
387
        # The service is not re-deployed.
573
388
        self.assertFalse(env.deploy.called)
574
389
        # The service is not re-exposed.
575
390
        self.assertFalse(env.expose.called)
576
391
        mock_print.assert_has_calls([
577
392
            mock.call('service my-gui already deployed'),
578
393
            mock.call('charm URL: cs:precise/juju-gui-47'),
579
394
            mock.call('requesting new unit deployment'),
580
395
            mock.call('my-gui/42 deployment request accepted'),
581
396
        ])
582
397
583
398
    def test_existing_service_unexposed(self, mock_print):
584
399
        # The existing service is exposed if required.
585
400
        service_data = {'Exposed': False}
586
401
        env = self.make_env(unit_name='my-gui/42', service_data=service_data)
587
402
        unit_name = app.deploy_gui(
588
403
            env, 'my-gui', '1', check_preexisting=True)
589
404
        self.assertEqual('my-gui/42', unit_name)
590
405
        env.assert_has_calls([
591
406
            mock.call.get_status(),
592
407
            mock.call.expose('my-gui'),
593
408
            mock.call.add_unit('my-gui', machine_spec='1'),
594
409
        ])
595
410
        # The service is not re-deployed.
596
411
        self.assertFalse(env.deploy.called)
597
412
        mock_print.assert_has_calls([
598
413
            mock.call('service my-gui already deployed'),
599
414
            mock.call('charm URL: cs:precise/juju-gui-47'),
600
415
            mock.call('exposing service my-gui'),
601
416
            mock.call('requesting new unit deployment'),
602
417
            mock.call('my-gui/42 deployment request accepted'),
603
418
        ])
604
419
605
420
    def test_existing_service_and_unit(self, mock_print):
606
421
        # A unit is reused if a suitable one is already present.
607
422
        env = self.make_env(service_data={}, unit_data={})
608
423
        unit_name = app.deploy_gui(
609
424
            env, 'my-gui', '0', check_preexisting=True)
610
425
        self.assertEqual('my-gui/47', unit_name)
611
426
        env.get_status.assert_called_once_with()
612
427
        # The service is not re-deployed.
613
428
        self.assertFalse(env.deploy.called)
614
429
        # The service is not re-exposed.
615
430
        self.assertFalse(env.expose.called)
616
431
        # The unit is not re-added.
617
432
        self.assertFalse(env.add_unit.called)
618
433
        mock_print.assert_has_calls([
619
434
            mock.call('service my-gui already deployed'),
620
435
            mock.call('charm URL: cs:precise/juju-gui-47'),
621
436
            mock.call('reusing unit my-gui/47'),
622
437
        ])
623
438
624
439
    def test_new_machine(self, mock_print):
625
440
        # The unit is correctly deployed in a new machine.
626
441
        env = self.make_env(unit_name='my-gui/42')
627
442
        with self.patch_get_charm_url():
628
443
            unit_name = app.deploy_gui(env, 'my-gui', None)
629
444
        self.assertEqual('my-gui/42', unit_name)
630
445
        env.assert_has_calls([
631
446
            mock.call.deploy('my-gui', self.charm_url, num_units=0),
632
447
            mock.call.expose('my-gui'),
633
448
            mock.call.add_unit('my-gui', machine_spec=None),
634
449
        ])
635
450
636
451
    def test_status_error(self, mock_print):
637
452
        # A ProgramExit is raised if an error occurs in the status API call.
638
453
        env = self.make_env()
639
454
        env.get_status.side_effect = self.make_env_error('bad wolf')
640
455
        with self.assert_program_exit('bad API response: bad wolf'):
641
456
            app.deploy_gui(
642
457
                env, 'another-gui', '0', check_preexisting=True)
643
458
        env.get_status.assert_called_once_with()
644
459
645
460
    def test_deploy_error(self, mock_print):
646
461
        # A ProgramExit is raised if an error occurs in the deploy API call.
647
462
        env = self.make_env()
648
463
        env.deploy.side_effect = self.make_env_error('bad wolf')
649
464
        with self.patch_get_charm_url():
650
465
            with self.assert_program_exit('bad API response: bad wolf'):
651
466
                app.deploy_gui(env, 'another-gui', '0')
652
314
        env.deploy.assert_called_once_with(
467
        env.deploy.assert_called_once_with(
654
315
            'another-gui', 'cs:precise/juju-gui-42', to=0)
468
            'another-gui', self.charm_url, num_units=0)
655
469
656
470
    def test_expose_error(self, mock_print):
657
471
        # A ProgramExit is raised if an error occurs in the expose API call.
658
472
        env = self.make_env()
659
473
        env.expose.side_effect = self.make_env_error('bad wolf')
660
474
        with self.patch_get_charm_url():
661
475
            with self.assert_program_exit('bad API response: bad wolf'):
662
476
                app.deploy_gui(env, 'another-gui', '0')
663
477
        env.expose.assert_called_once_with('another-gui')
664
478
665
479
    def test_add_unit_error(self, mock_print):
666
480
        # A ProgramExit is raised if an error occurs in the add_unit API call.
667
481
        env = self.make_env()
668
482
        env.add_unit.side_effect = self.make_env_error('bad wolf')
669
483
        with self.patch_get_charm_url():
670
484
            with self.assert_program_exit('bad API response: bad wolf'):
671
485
                app.deploy_gui(env, 'another-gui', '0')
672
486
        env.add_unit.assert_called_once_with('another-gui', machine_spec='0')
673
316
487
674
317
    def test_other_errors(self, mock_print):
488
    def test_other_errors(self, mock_print):
675
318
        # Any other errors occurred during the process are not trapped.
489
        # Any other errors occurred during the process are not trapped.
676
319
        error = ValueError('explode!')
490
        error = ValueError('explode!')
678
320
        env = mock.Mock()
491
        env = self.make_env(unit_name='my-gui/42')
679
321
        env.expose.side_effect = error
492
        env.expose.side_effect = error
680
322
        with self.patch_get_charm_url():
493
        with self.patch_get_charm_url():
681
323
            with self.assertRaises(ValueError) as context_manager:
494
            with self.assertRaises(ValueError) as context_manager:
683
324
                app.deploy_gui(env, 'juju-gui')
495
                app.deploy_gui(env, 'juju-gui', '0')
684
325
        env.deploy.assert_called_once_with(
496
        env.deploy.assert_called_once_with(
686
326
            'juju-gui', 'cs:precise/juju-gui-42', to=0)
497
            'juju-gui', 'cs:precise/juju-gui-42', num_units=0)
687
327
        env.expose.assert_called_once_with('juju-gui')
498
        env.expose.assert_called_once_with('juju-gui')
688
328
        self.assertIs(error, context_manager.exception)
499
        self.assertIs(error, context_manager.exception)
689
329
500
690
@@ -334,28 +505,29 @@
691
334
    address = 'unit.example.com'
505
    address = 'unit.example.com'
692
335
    change_pending = ('unit', 'change', {
506
    change_pending = ('unit', 'change', {
693
336
        'Name': 'django/42',
507
        'Name': 'django/42',
694
337
        'Status': 'pending',
695
338
        'PublicAddress': '',
508
        'PublicAddress': '',
696
509
        'Status': 'pending',
697
339
    })
510
    })
698
340
    change_reachable = ('unit', 'change', {
511
    change_reachable = ('unit', 'change', {
699
341
        'Name': 'django/42',
512
        'Name': 'django/42',
700
513
        'PublicAddress': address,
701
342
        'Status': 'pending',
514
        'Status': 'pending',
702
343
        'PublicAddress': address,
703
344
    })
515
    })
704
345
    change_installed = ('unit', 'change', {
516
    change_installed = ('unit', 'change', {
705
346
        'Name': 'django/42',
517
        'Name': 'django/42',
706
518
        'PublicAddress': address,
707
347
        'Status': 'installed',
519
        'Status': 'installed',
708
348
        'PublicAddress': address,
709
349
    })
520
    })
710
350
    change_started = ('unit', 'change', {
521
    change_started = ('unit', 'change', {
711
522
        'MachineId': '0',
712
351
        'Name': 'django/42',
523
        'Name': 'django/42',
713
524
        'PublicAddress': address,
714
352
        'Status': 'started',
525
        'Status': 'started',
715
353
        'PublicAddress': address,
716
354
    })
526
    })
721
355
    pending_call = mock.call('django/0 deployment is pending')
527
    pending_call = mock.call('django/42 deployment is pending')
722
356
    reachable_call = mock.call('installing django/0 on {}'.format(address))
528
    reachable_call = mock.call('setting up django/42 on {}'.format(address))
723
357
    installed_call = mock.call('django/0 is installed')
529
    installed_call = mock.call('django/42 is installed')
724
358
    started_call = mock.call('django/0 is ready')
530
    started_call = mock.call('django/42 is ready on machine 0')
725
359
531
726
360
    def make_env(self, changes):
532
    def make_env(self, changes):
727
361
        """Create and return a patched Environment instance.
533
        """Create and return a patched Environment instance.
728
@@ -375,7 +547,7 @@
729
375
            self.change_installed,
547
            self.change_installed,
730
376
            self.change_started,
548
            self.change_started,
731
377
        ])
549
        ])
733
378
        address = app.watch(env, 'django')
550
        address = app.watch(env, 'django/42')
734
379
        self.assertEqual(self.address, address)
551
        self.assertEqual(self.address, address)
735
380
        mock_print.assert_has_calls([
552
        mock_print.assert_has_calls([
736
381
            self.pending_call,
553
            self.pending_call,
737
@@ -392,7 +564,7 @@
738
392
            self.change_installed,
564
            self.change_installed,
739
393
            self.change_started,
565
            self.change_started,
740
394
        ])
566
        ])
742
395
        address = app.watch(env, 'django')
567
        address = app.watch(env, 'django/42')
743
396
        self.assertEqual(self.address, address)
568
        self.assertEqual(self.address, address)
744
397
        mock_print.assert_has_calls([
569
        mock_print.assert_has_calls([
745
398
            self.reachable_call,
570
            self.reachable_call,
746
@@ -404,7 +576,7 @@
747
404
    def test_missing_changes(self, mock_print):
576
    def test_missing_changes(self, mock_print):
748
405
        # Only the started change is strictly required.
577
        # Only the started change is strictly required.
749
406
        env = self.make_env([self.change_started])
578
        env = self.make_env([self.change_started])
751
407
        address = app.watch(env, 'django')
579
        address = app.watch(env, 'django/42')
752
408
        self.assertEqual(self.address, address)
580
        self.assertEqual(self.address, address)
753
409
        mock_print.assert_has_calls([
581
        mock_print.assert_has_calls([
754
410
            self.reachable_call,
582
            self.reachable_call,
755
@@ -432,7 +604,7 @@
756
432
            }),
604
            }),
757
433
            self.change_started,
605
            self.change_started,
758
434
        ])
606
        ])
760
435
        address = app.watch(env, 'django')
607
        address = app.watch(env, 'django/42')
761
436
        self.assertEqual(self.address, address)
608
        self.assertEqual(self.address, address)
762
437
        mock_print.assert_has_calls([
609
        mock_print.assert_has_calls([
763
438
            self.pending_call,
610
            self.pending_call,
764
@@ -449,7 +621,7 @@
765
449
        ])
621
        ])
766
450
        expected = 'bad API server response: next returned an error'
622
        expected = 'bad API server response: next returned an error'
767
451
        with self.assert_program_exit(expected):
623
        with self.assert_program_exit(expected):
769
452
            app.watch(env, 'django')
624
            app.watch(env, 'django/42')
770
453
        mock_print.assert_has_calls([self.pending_call])
625
        mock_print.assert_has_calls([self.pending_call])
771
454
626
772
455
    def test_other_errors(self, mock_print):
627
    def test_other_errors(self, mock_print):
773
@@ -457,7 +629,7 @@
774
457
        error = ValueError('explode!')
629
        error = ValueError('explode!')
775
458
        env = self.make_env([self.change_installed, error])
630
        env = self.make_env([self.change_installed, error])
776
459
        with self.assertRaises(ValueError) as context_manager:
631
        with self.assertRaises(ValueError) as context_manager:
778
460
            app.watch(env, 'django')
632
            app.watch(env, 'django/42')
779
461
        mock_print.assert_has_calls([self.reachable_call, self.installed_call])
633
        mock_print.assert_has_calls([self.reachable_call, self.installed_call])
780
462
        self.assertIs(error, context_manager.exception)
634
        self.assertIs(error, context_manager.exception)
781
463
635
782
@@ -472,8 +644,8 @@
783
472
            }),
644
            }),
784
473
            self.change_reachable,
645
            self.change_reachable,
785
474
        ])
646
        ])
788
475
        with self.assert_program_exit('django/0 unexpectedly removed'):
647
        with self.assert_program_exit('django/42 unexpectedly removed'):
789
476
            app.watch(env, 'django')
648
            app.watch(env, 'django/42')
790
477
        mock_print.assert_has_calls([self.pending_call])
649
        mock_print.assert_has_calls([self.pending_call])
791
478
650
792
479
    def test_status_error(self, mock_print):
651
    def test_status_error(self, mock_print):
793
@@ -483,14 +655,14 @@
794
483
            ('unit', 'change', {
655
            ('unit', 'change', {
795
484
                'Name': 'django/42',
656
                'Name': 'django/42',
796
485
                'Status': 'error',
657
                'Status': 'error',
798
486
                'StatusInfo': 'install hook failure',
658
                'StatusInfo': 'install failure',
799
487
                'PublicAddress': '',
659
                'PublicAddress': '',
800
488
            }),
660
            }),
801
489
            self.change_reachable,
661
            self.change_reachable,
802
490
        ])
662
        ])
804
491
        expected = 'django/0 is in an error state: error: install hook failure'
663
        expected = 'django/42 is in an error state: error: install failure'
805
492
        with self.assert_program_exit(expected):
664
        with self.assert_program_exit(expected):
807
493
            app.watch(env, 'django')
665
            app.watch(env, 'django/42')
808
494
        mock_print.assert_has_calls([self.pending_call])
666
        mock_print.assert_has_calls([self.pending_call])
809
495
667
810
496
668
811
497
669
812
=== modified file 'quickstart/tests/test_juju.py'
813
--- quickstart/tests/test_juju.py	2013-10-30 10:16:36 +0000
814
+++ quickstart/tests/test_juju.py	2013-11-18 16:54:22 +0000
815
@@ -25,6 +25,9 @@
816
25
from quickstart.tests import helpers
25
from quickstart.tests import helpers
817
26
26
818
27
27
819
28
patch_rpc = mock.patch('quickstart.juju.Environment._rpc')
820
29
821
30
822
28
class TestConnect(unittest.TestCase):
31
class TestConnect(unittest.TestCase):
823
29
32
824
30
    api_url = 'wss://api.example.com:17070'
33
    api_url = 'wss://api.example.com:17070'
825
@@ -45,6 +48,9 @@
826
45
48
827
46
49
828
47
class TestEnvironment(unittest.TestCase):
50
class TestEnvironment(unittest.TestCase):
829
51
    # Note that in some of the tests below, rather than exercising quickstart
830
52
    # code, we are actually testing the external jujuclient methods. This is so
831
53
    # by design, and will help us when upgrading the python-jujuclient library.
832
48
54
833
49
    api_url = 'wss://api.example.com:17070'
55
    api_url = 'wss://api.example.com:17070'
834
50
    charm_url = 'cs:precise/juju-gui-77'
56
    charm_url = 'cs:precise/juju-gui-77'
835
@@ -59,8 +65,24 @@
836
59
        # Keep track of watcher changes in the changesets list.
65
        # Keep track of watcher changes in the changesets list.
837
60
        self.changesets = []
66
        self.changesets = []
838
61
67
839
68
    def make_add_unit_request(self, **kwargs):
840
69
        """Create and return an "add unit" request.
841
70
842
71
        Use kwargs to add or override request parameters.
843
72
        """
844
73
        params = {
845
74
            'ServiceName': self.service_name,
846
75
            'NumUnits': 1,
847
76
        }
848
77
        params.update(kwargs)
849
78
        return {
850
79
            'Type': 'Client',
851
80
            'Request': 'AddServiceUnits',
852
81
            'Params': params,
853
82
        }
854
83
855
62
    def make_deploy_request(self, **kwargs):
84
    def make_deploy_request(self, **kwargs):
857
63
        """Create and return a deploy request.
85
        """Create and return a "deploy" request.
858
64
86
859
65
        Use kwargs to add or override request parameters.
87
        Use kwargs to add or override request parameters.
860
66
        """
88
        """
861
@@ -78,17 +100,43 @@
862
78
            'Params': params,
100
            'Params': params,
863
79
        }
101
        }
864
80
102
865
103
    def patch_get_watch(self, return_value):
866
104
        """Patch the Environment.get_watch method.
867
105
868
106
        When the resulting mock is used as a context manager, the given return
869
107
        value is returned.
870
108
        """
871
109
        get_watch_path = 'quickstart.juju.jujuclient.Environment.get_watch'
872
110
        mock_get_watch = mock.MagicMock()
873
111
        mock_get_watch().__enter__.return_value = iter(return_value)
874
112
        mock_get_watch.reset_mock()
875
113
        return mock.patch(get_watch_path, mock_get_watch)
876
114
877
81
    def processor(self, changeset):
115
    def processor(self, changeset):
878
82
        self.changesets.append(changeset)
116
        self.changesets.append(changeset)
879
83
        return changeset
117
        return changeset
880
84
118
882
85
    @mock.patch('quickstart.juju.Environment._rpc')
119
    @patch_rpc
883
120
    def test_add_unit(self, mock_rpc):
884
121
        # The AddServiceUnits API call is properly generated.
885
122
        self.env.add_unit(self.service_name)
886
123
        mock_rpc.assert_called_once_with(self.make_add_unit_request())
887
124
888
125
    @patch_rpc
889
126
    def test_add_unit_to_machine(self, mock_rpc):
890
127
        # The AddServiceUnits API call is properly generated when deploying a
891
128
        # unit in a specific machine.
892
129
        self.env.add_unit(self.service_name, machine_spec='0')
893
130
        expected = self.make_add_unit_request(ToMachineSpec='0')
894
131
        mock_rpc.assert_called_once_with(expected)
895
132
896
133
    @patch_rpc
897
86
    def test_deploy(self, mock_rpc):
134
    def test_deploy(self, mock_rpc):
898
87
        # The deploy API call is properly generated.
135
        # The deploy API call is properly generated.
899
88
        self.env.deploy(self.service_name, self.charm_url)
136
        self.env.deploy(self.service_name, self.charm_url)
900
89
        mock_rpc.assert_called_once_with(self.make_deploy_request())
137
        mock_rpc.assert_called_once_with(self.make_deploy_request())
901
90
138
903
91
    @mock.patch('quickstart.juju.Environment._rpc')
139
    @patch_rpc
904
92
    def test_deploy_config(self, mock_rpc):
140
    def test_deploy_config(self, mock_rpc):
905
93
        # The deploy API call is properly generated when passing settings.
141
        # The deploy API call is properly generated when passing settings.
906
94
        self.env.deploy(
142
        self.env.deploy(
907
@@ -98,7 +146,7 @@
908
98
            Config={'key1': 'value1', 'key2': '42'})
146
            Config={'key1': 'value1', 'key2': '42'})
909
99
        mock_rpc.assert_called_once_with(expected)
147
        mock_rpc.assert_called_once_with(expected)
910
100
148
912
101
    @mock.patch('quickstart.juju.Environment._rpc')
149
    @patch_rpc
913
102
    def test_deploy_constraints(self, mock_rpc):
150
    def test_deploy_constraints(self, mock_rpc):
914
103
        # The deploy API call is properly generated when passing constraints.
151
        # The deploy API call is properly generated when passing constraints.
915
104
        constraints = {'cpu-cores': 8, 'mem': 16}
152
        constraints = {'cpu-cores': 8, 'mem': 16}
916
@@ -107,15 +155,14 @@
917
107
        expected = self.make_deploy_request(Constraints=constraints)
155
        expected = self.make_deploy_request(Constraints=constraints)
918
108
        mock_rpc.assert_called_once_with(expected)
156
        mock_rpc.assert_called_once_with(expected)
919
109
157
926
110
    @mock.patch('quickstart.juju.Environment._rpc')
158
    @patch_rpc
927
111
    def test_deploy_to(self, mock_rpc):
159
    def test_deploy_no_units(self, mock_rpc):
928
112
        # The deploy API call is properly generated when passing a machine
160
        # The deploy API call is properly generated when passing zero units.
929
113
        # specification.
161
        self.env.deploy(self.service_name, self.charm_url, num_units=0)
930
114
        self.env.deploy(self.service_name, self.charm_url, to=0)
162
        expected = self.make_deploy_request(NumUnits=0)
925
115
        expected = self.make_deploy_request(ToMachineSpec='0')
931
116
        mock_rpc.assert_called_once_with(expected)
163
        mock_rpc.assert_called_once_with(expected)
932
117
164
934
118
    @mock.patch('quickstart.juju.Environment._rpc')
165
    @patch_rpc
935
119
    def test_deploy_bundle(self, mock_rpc):
166
    def test_deploy_bundle(self, mock_rpc):
936
120
        # The deploy bundle call is properly generated.
167
        # The deploy bundle call is properly generated.
937
121
        self.env.deploy_bundle('name: contents')
168
        self.env.deploy_bundle('name: contents')
938
@@ -126,7 +173,7 @@
939
126
        }
173
        }
940
127
        mock_rpc.assert_called_once_with(expected)
174
        mock_rpc.assert_called_once_with(expected)
941
128
175
943
129
    @mock.patch('quickstart.juju.Environment._rpc')
176
    @patch_rpc
944
130
    def test_deploy_bundle_with_name(self, mock_rpc):
177
    def test_deploy_bundle_with_name(self, mock_rpc):
945
131
        # The deploy bundle call is properly generated when passing a name.
178
        # The deploy bundle call is properly generated when passing a name.
946
132
        self.env.deploy_bundle('name: contents', name='name')
179
        self.env.deploy_bundle('name: contents', name='name')
947
@@ -137,58 +184,75 @@
948
137
        }
184
        }
949
138
        mock_rpc.assert_called_once_with(expected)
185
        mock_rpc.assert_called_once_with(expected)
950
139
186
953
140
    @mock.patch('quickstart.juju.jujuclient.Watcher._rpc')
187
    @patch_rpc
954
141
    def test_watch_changes(self, mock_rpc):
188
    def test_expose(self, mock_rpc):
955
189
        # The expose API call is properly generated.
956
190
        self.env.expose(self.service_name)
957
191
        expected = {
958
192
            'Type': 'Client',
959
193
            'Request': 'ServiceExpose',
960
194
            'Params': {'ServiceName': self.service_name},
961
195
        }
962
196
        mock_rpc.assert_called_once_with(expected)
963
197
964
198
    def test_get_status(self):
965
199
        # The current status of the Juju environment is properly returned.
966
200
        changeset1 = ['change1', 'change2']
967
201
        changeset2 = ['change3']
968
202
        with self.patch_get_watch([changeset1, changeset2]) as mock_get_watch:
969
203
            status = self.env.get_status()
970
204
        # The get_status call only waits for the first changeset.
971
205
        self.assertEqual(changeset1, status)
972
206
        # The watcher is correctly closed.
973
207
        self.assertEqual(1, mock_get_watch().__exit__.call_count)
974
208
975
209
    def test_watch_changes(self):
976
142
        # It is possible to watch for changes using a processor callable.
210
        # It is possible to watch for changes using a processor callable.
977
143
        changeset1 = ['change1', 'change2']
211
        changeset1 = ['change1', 'change2']
978
144
        changeset2 = ['change3']
212
        changeset2 = ['change3']
995
145
        mock_rpc.side_effect = [
213
        with self.patch_get_watch([changeset1, changeset2]) as mock_get_watch:
996
146
            # Define the response to the watcher's start call.
214
            watcher = self.env.watch_changes(self.processor)
997
147
            {'Response': {}, 'AllWatcherId': 42},
215
            # The first set of changes is correctly returned.
998
148
            # Define two responses to the two subsequent next calls.
216
            changeset = watcher.next()
999
149
            {'Response': {}, 'Deltas': changeset1},
217
            self.assertEqual(changeset1, changeset)
1000
150
            {'Response': {}, 'Deltas': changeset2},
218
            # The second set of changes is correctly returned.
1001
151
            # Define the response to the watcher's stop call.
219
            changeset = watcher.next()
1002
152
            {'Response': {}},
220
            self.assertEqual(changeset2, changeset)
987
153
        ]
988
154
        watcher = self.env.watch_changes(self.processor)
989
155
        # The first set of changes is correctly returned.
990
156
        changeset = watcher.next()
991
157
        self.assertEqual(changeset1, changeset)
992
158
        # The second set of changes is correctly returned.
993
159
        changeset = watcher.next()
994
160
        self.assertEqual(changeset2, changeset)
1003
161
        # All the changes have been processed.
221
        # All the changes have been processed.
1004
162
        self.assertEqual([changeset1, changeset2], self.changesets)
222
        self.assertEqual([changeset1, changeset2], self.changesets)
1005
163
        # Ensure the API has been used properly.
223
        # Ensure the API has been used properly.
1014
164
        mock_rpc.assert_has_calls([
224
        mock_get_watch().__enter__.assert_called_once_with()
1015
165
            mock.call({'Type': 'Client', 'Request': 'WatchAll', 'Params': {}}),
225
1016
166
            mock.call({'Type': 'AllWatcher', 'Request': 'Next', 'Id': 42}),
226
    def test_watch_changes_map(self):
1017
167
            mock.call({'Type': 'AllWatcher', 'Request': 'Next', 'Id': 42}),
227
        # The processor callable can be used to modify changes.
1018
168
        ])
228
        changeset1 = ['change1', 'change2']
1019
169
229
        changeset2 = ['change3']
1020
170
    @mock.patch('quickstart.juju.jujuclient.Watcher._rpc')
230
        with self.patch_get_watch([changeset1, changeset2]):
1021
171
    def test_watch_closed(self, mock_rpc):
231
            watcher = self.env.watch_changes(len)
1022
232
            changesets = list(watcher)
1023
233
        self.assertEqual([len(changeset1), len(changeset2)], changesets)
1024
234
1025
235
    def test_watch_changes_filter(self):
1026
236
        # The processor callable can be used to filter changes.
1027
237
        changeset1 = ['change1', 'change2']
1028
238
        changeset2 = ['change3']
1029
239
        processor = lambda changes: None if len(changes) == 1 else changes
1030
240
        with self.patch_get_watch([changeset1, changeset2]):
1031
241
            watcher = self.env.watch_changes(processor)
1032
242
            changesets = list(watcher)
1033
243
        self.assertEqual([changeset1], changesets)
1034
244
1035
245
    def test_watch_closed(self):
1036
172
        # A stop API call on the AllWatcher is performed when the watcher is
246
        # A stop API call on the AllWatcher is performed when the watcher is
1037
173
        # garbage collected.
247
        # garbage collected.
1050
174
        mock_rpc.side_effect = [
248
        changeset = ['change1', 'change2']
1051
175
            # Define the response to the watcher's start call.
249
        with self.patch_get_watch([changeset]) as mock_get_watch:
1052
176
            {'Response': {}, 'AllWatcherId': 42},
250
            watcher = self.env.watch_changes(self.processor)
1053
177
            # Define a response to a next call.
251
            # The first set of changes is correctly returned.
1054
178
            {'Response': {}, 'Deltas': ['change1', 'change2']},
252
            watcher.next()
1055
179
            # Define the response to the watcher's stop call.
253
            del watcher
1044
180
            {'Response': {}},
1045
181
        ]
1046
182
        watcher = self.env.watch_changes(self.processor)
1047
183
        # The first set of changes is correctly returned.
1048
184
        watcher.next()
1049
185
        del watcher
1056
186
        # Ensure the API has been used properly.
254
        # Ensure the API has been used properly.
1062
187
        mock_rpc.assert_has_calls([
255
        self.assertEqual(1, mock_get_watch().__exit__.call_count)
1058
188
            mock.call({'Type': 'Client', 'Request': 'WatchAll', 'Params': {}}),
1059
189
            mock.call({'Type': 'AllWatcher', 'Request': 'Next', 'Id': 42}),
1060
190
            mock.call({'Type': 'AllWatcher', 'Request': 'Stop', 'Id': 42}),
1061
191
        ])
1063
192
256
1064
193
257
1065
194
class TestWebSocketConnection(unittest.TestCase):
258
class TestWebSocketConnection(unittest.TestCase):
1066
195
259
1067
=== modified file 'quickstart/tests/test_manage.py'
1068
--- quickstart/tests/test_manage.py	2013-11-13 12:23:36 +0000
1069
+++ quickstart/tests/test_manage.py	2013-11-18 16:54:22 +0000
1070
@@ -356,10 +356,11 @@
1071
356
        mock_app.connect.assert_called_once_with(
356
        mock_app.connect.assert_called_once_with(
1072
357
            mock_app.get_api_url(), options.admin_secret)
357
            mock_app.get_api_url(), options.admin_secret)
1073
358
        mock_app.deploy_gui.assert_called_once_with(
358
        mock_app.deploy_gui.assert_called_once_with(
1076
359
            mock_app.connect(), settings.JUJU_GUI_NAME,
359
            mock_app.connect(), settings.JUJU_GUI_NAME, '0',
1077
360
            charm_url=options.charm_url)
360
            charm_url=options.charm_url,
1078
361
            check_preexisting=mock_app.bootstrap())
1079
361
        mock_app.watch.assert_called_once_with(
362
        mock_app.watch.assert_called_once_with(
1081
362
            mock_app.connect(), settings.JUJU_GUI_NAME)
363
            mock_app.connect(), mock_app.deploy_gui())
1082
363
        mock_open.assert_called_once_with(
364
        mock_open.assert_called_once_with(
1083
364
            'https://{}'.format(mock_app.watch()))
365
            'https://{}'.format(mock_app.watch()))
1084
365
        self.assertFalse(mock_app.deploy_bundle.called)
366
        self.assertFalse(mock_app.deploy_bundle.called)
1085
366
367
1086
=== modified file 'quickstart/tests/test_utils.py'
1087
--- quickstart/tests/test_utils.py	2013-11-13 12:23:36 +0000
1088
+++ quickstart/tests/test_utils.py	2013-11-18 16:54:22 +0000
1089
@@ -178,6 +178,79 @@
1090
178
        mock_call.assert_called_once_with('juju', 'switch')
178
        mock_call.assert_called_once_with('juju', 'switch')
1091
179
179
1092
180
180
1093
181
class TestGetServiceInfo(helpers.WatcherDataTestsMixin, unittest.TestCase):
1094
182
1095
183
    def test_service_and_unit(self):
1096
184
        # The data about the given service and unit is correctly returned.
1097
185
        service_change = self.make_service_change()
1098
186
        unit_change = self.make_unit_change()
1099
187
        status = [service_change, unit_change]
1100
188
        expected = (service_change[2], unit_change[2])
1101
189
        self.assertEqual(expected, utils.get_service_info(status, 'my-gui'))
1102
190
1103
191
    def test_service_only(self):
1104
192
        # The data about the given service without units is correctly returned.
1105
193
        service_change = self.make_service_change()
1106
194
        status = [service_change]
1107
195
        expected = (service_change[2], None)
1108
196
        self.assertEqual(expected, utils.get_service_info(status, 'my-gui'))
1109
197
1110
198
    def test_service_removed(self):
1111
199
        # A tuple (None, None) is returned if the service is being removed.
1112
200
        status = [
1113
201
            self.make_service_change(action='remove'),
1114
202
            self.make_unit_change(),
1115
203
        ]
1116
204
        expected = (None, None)
1117
205
        self.assertEqual(expected, utils.get_service_info(status, 'my-gui'))
1118
206
1119
207
    def test_another_service(self):
1120
208
        # A tuple (None, None) is returned if the service is not found.
1121
209
        status = [
1122
210
            self.make_service_change(data={'Name': 'another-service'}),
1123
211
            self.make_unit_change(),
1124
212
        ]
1125
213
        expected = (None, None)
1126
214
        self.assertEqual(expected, utils.get_service_info(status, 'my-gui'))
1127
215
1128
216
    def test_service_not_alive(self):
1129
217
        # A tuple (None, None) is returned if the service is not alive.
1130
218
        status = [
1131
219
            self.make_service_change(data={'Life': 'dying'}),
1132
220
            self.make_unit_change(),
1133
221
        ]
1134
222
        expected = (None, None)
1135
223
        self.assertEqual(expected, utils.get_service_info(status, 'my-gui'))
1136
224
1137
225
    def test_unit_removed(self):
1138
226
        # The unit data is not returned if the unit is being removed.
1139
227
        service_change = self.make_service_change()
1140
228
        status = [service_change, self.make_unit_change(action='remove')]
1141
229
        expected = (service_change[2], None)
1142
230
        self.assertEqual(expected, utils.get_service_info(status, 'my-gui'))
1143
231
1144
232
    def test_another_unit(self):
1145
233
        # The unit data is not returned if the unit belongs to another service.
1146
234
        service_change = self.make_service_change()
1147
235
        status = [
1148
236
            service_change,
1149
237
            self.make_unit_change(data={'Service': 'another-service'}),
1150
238
        ]
1151
239
        expected = (service_change[2], None)
1152
240
        self.assertEqual(expected, utils.get_service_info(status, 'my-gui'))
1153
241
1154
242
    def test_no_services(self):
1155
243
        # A tuple (None, None) is returned no services are found.
1156
244
        status = [self.make_unit_change()]
1157
245
        expected = (None, None)
1158
246
        self.assertEqual(expected, utils.get_service_info(status, 'my-gui'))
1159
247
1160
248
    def test_no_entities(self):
1161
249
        # A tuple (None, None) is returned no entities are found.
1162
250
        expected = (None, None)
1163
251
        self.assertEqual(expected, utils.get_service_info([], 'my-gui'))
1164
252
1165
253
1166
181
class TestParseBundle(
254
class TestParseBundle(
1167
182
        helpers.BundleFileTestsMixin, helpers.ValueErrorTestsMixin,
255
        helpers.BundleFileTestsMixin, helpers.ValueErrorTestsMixin,
1168
183
        unittest.TestCase):
256
        unittest.TestCase):
1169
184
257
1170
=== modified file 'quickstart/utils.py'
1171
--- quickstart/utils.py	2013-11-13 12:23:36 +0000
1172
+++ quickstart/utils.py	2013-11-18 16:54:22 +0000
1173
@@ -111,6 +111,31 @@
1174
111
        return match.groups()[0]
111
        return match.groups()[0]
1175
112
112
1176
113
113
1177
114
def get_service_info(status, service_name):
1178
115
    """Retrieve information on the given service and on its first alive unit.
1179
116
1180
117
    Return a tuple containing two values: (service data, unit data).
1181
118
    Each value can be:
1182
119
        - a dictionary of data about the given entity (service or unit) as
1183
120
          returned by the Juju watcher;
1184
121
        - None, if the entity is not present in the Juju environment.
1185
122
    If the service data is None, the unit data is always None.
1186
123
    """
1187
124
    services = [
1188
125
        data for entity, action, data in status if
1189
126
        (entity == 'service') and (action != 'remove') and
1190
127
        (data['Name'] == service_name) and (data['Life'] == 'alive')
1191
128
    ]
1192
129
    if not services:
1193
130
        return None, None
1194
131
    units = [
1195
132
        data for entity, action, data in status if
1196
133
        entity == 'unit' and action != 'remove' and
1197
134
        data['Service'] == service_name
1198
135
    ]
1199
136
    return services[0], units[0] if units else None
1200
137
1201
138
1202
114
def parse_bundle(bundle_yaml, bundle_name=None):
139
def parse_bundle(bundle_yaml, bundle_name=None):
1203
115
    """Parse the provided bundle YAML encoded contents.
140
    """Parse the provided bundle YAML encoded contents.
1204
116
141
Reviewer	Review Type	Date Requested	Status
Juju GUI Hackers		2013-11-18	Pending
Review via email: mp+195592@code.launchpad.net