1
=== modified file 'quickstart/__init__.py'
2
--- quickstart/__init__.py	2015-02-27 09:25:33 +0000
3
+++ quickstart/__init__.py	2015-03-10 10:19:09 +0000
4
@@ -45,7 +45,7 @@
5
45
Once Juju has been installed, the command can also be run as a juju plugin,
45
Once Juju has been installed, the command can also be run as a juju plugin,
6
46
without the hyphen ("juju quickstart").
46
without the hyphen ("juju quickstart").
7
47
"""
47
"""
9
48
VERSION = (2, 0, 0)
48
VERSION = (2, 0, 1)
10
49
49
11
50
50
12
51
def get_version():
51
def get_version():
13
52
52
14
=== modified file 'quickstart/app.py'
15
--- quickstart/app.py	2015-02-26 11:02:57 +0000
16
+++ quickstart/app.py	2015-03-10 10:19:09 +0000
17
@@ -29,6 +29,7 @@
18
29
import jujuclient
29
import jujuclient
19
30
30
20
31
from quickstart import (
31
from quickstart import (
21
32
    charmstore,
22
32
    juju,
33
    juju,
23
33
    jujutools,
34
    jujutools,
24
34
    netutils,
35
    netutils,
25
@@ -440,8 +441,9 @@
26
440
                series = settings.JUJU_GUI_SUPPORTED_SERIES[-1]
441
                series = settings.JUJU_GUI_SUPPORTED_SERIES[-1]
27
441
            try:
442
            try:
28
442
                # Try to get the charm URL from the charm store API.
443
                # Try to get the charm URL from the charm store API.
31
443
                charm_url = netutils.get_charm_url(series)
444
                charm_url = charmstore.resolve(
32
444
            except (IOError, ValueError) as err:
445
                    settings.JUJU_GUI_CHARM_NAME, series=series)
33
446
            except (charmstore.NotFoundError, IOError, ValueError) as err:
34
445
                # Fall back to the default URL for the current series.
447
                # Fall back to the default URL for the current series.
35
446
                msg = 'unable to retrieve the {} charm URL from the API: {}'
448
                msg = 'unable to retrieve the {} charm URL from the API: {}'
36
447
                logging.warn(msg.format(service_name, err))
449
                logging.warn(msg.format(service_name, err))
37
448
450
38
=== added file 'quickstart/charmstore.py'
39
--- quickstart/charmstore.py	1970-01-01 00:00:00 +0000
40
+++ quickstart/charmstore.py	2015-03-10 10:19:09 +0000
41
@@ -0,0 +1,161 @@
42
1
# This file is part of the Juju Quickstart Plugin, which lets users set up a
43
2
# Juju environment in very few steps (https://launchpad.net/juju-quickstart).
44
3
# Copyright (C) 2015 Canonical Ltd.
45
4
#
46
5
# This program is free software: you can redistribute it and/or modify it under
47
6
# the terms of the GNU Affero General Public License version 3, as published by
48
7
# the Free Software Foundation.
49
8
#
50
9
# This program is distributed in the hope that it will be useful, but WITHOUT
51
10
# ANY WARRANTY; without even the implied warranties of MERCHANTABILITY,
52
11
# SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
53
12
# Affero General Public License for more details.
54
13
#
55
14
# You should have received a copy of the GNU Affero General Public License
56
15
# along with this program.  If not, see <http://www.gnu.org/licenses/>.
57
16
58
17
"""Juju Quickstart utilities for communicating with the Juju charm store."""
59
18
60
19
from __future__ import unicode_literals
61
20
62
21
import json
63
22
64
23
from quickstart import (
65
24
    netutils,
66
25
    serializers,
67
26
    settings,
68
27
)
69
28
70
29
71
30
class NotFoundError(Exception):
72
31
    """Represent a not found HTTP error while communicating with the store."""
73
32
74
33
75
34
def get(path):
76
35
    """Send a GET request to the charm store at the given path.
77
36
78
37
    The path must not include the charm store API version identifier. In
79
38
    essence, the path must exclude the "/v4/" fragment.
80
39
81
40
    Return the string content returned by the charm store.
82
41
    Raise a NotFoundError if a 404 not found response is returned.
83
42
    Raise an IOError if any other problems occur while communicating with the
84
43
    charm store.
85
44
    """
86
45
    url = settings.CHARMSTORE_API + path.lstrip('/')
87
46
    try:
88
47
        return netutils.urlread(url)
89
48
    except netutils.NotFoundError as err:
90
49
        msg = b'charm store resource not found at {}: {}'.format(
91
50
            url.encode('utf-8'), err)
92
51
        raise NotFoundError(msg)
93
52
    except IOError as err:
94
53
        msg = b'cannot communicate with the charm store at {}: {}'.format(
95
54
            url.encode('utf-8'), err)
96
55
        raise IOError(msg)
97
56
98
57
99
58
def get_reference(reference, path):
100
59
    """Retrieve the charm store contents for the given reference and path.
101
60
102
61
    The reference argument identifies a charm or bundle entity and must be an
103
62
    instance of "quickstart.models.references.Reference".
104
63
105
64
    For instance, to retrieve the hash of a charm reference, use the following:
106
65
107
66
        hash = get_reference(reference, '/meta/hash')
108
67
109
68
    Raise a NotFoundError if an entity with the given reference cannot be
110
69
    found in the charm store.
111
70
    Raise an IOError if any other problems occur while communicating with the
112
71
    charm store.
113
72
    """
114
73
    if not path.startswith('/'):
115
74
        path = '/' + path
116
75
    return get(reference.path() + path)
117
76
118
77
119
78
def resolve(name, series=None):
120
79
    """Return the fully qualified id of the entity with the given name.
121
80
122
81
    If the optional series is provided, resolve the entity of the given series.
123
82
124
83
    Raise a NotFoundError if an entity with the given name and optional series
125
84
    cannot be found in the charm store.
126
85
    Raise an IOError if any other problems occur while communicating with the
127
86
    charm store.
128
87
    Raise a ValueError if the API returns invalid data.
129
88
    """
130
89
    series_part = '' if series is None else '{}/'.format(series)
131
90
    content = get(series_part + name + '/meta/id')
132
91
    data = json.loads(content)
133
92
    entity_id = data.get('Id')
134
93
    if entity_id is None:
135
94
        msg = 'unable to resolve entity id {}{}'.format(series_part, name)
136
95
        raise ValueError(msg.encode('utf-8'))
137
96
    return entity_id
138
97
139
98
140
99
def get_bundle_data(reference):
141
100
    """Retrieve and return the bundle data for the given bundle reference.
142
101
143
102
    The bundle data is returned as a YAML decoded value.
144
103
    The reference argument identifies a bundle entity and must be an instance
145
104
    of "quickstart.models.references.Reference".
146
105
147
106
    Raise a ValueError if the returned content is not a valid YAML, or if the
148
107
    given reference does not represent a bundle.
149
108
    Raise a NotFoundError if a bundle with the given reference cannot be found
150
109
    in the charm store.
151
110
    Raise an IOError if any other problems occur while communicating with the
152
111
    charm store.
153
112
    """
154
113
    return _retrieve_and_parse_bundle_data(reference, '/archive/bundle.yaml')
155
114
156
115
157
116
def get_legacy_bundle_data(reference):
158
117
    """Retrieve and return the bundle legacy data for the given reference.
159
118
160
119
    The bundle data is returned as a YAML decoded value and represents the
161
120
    legacy bundle with a top level bundle name node.
162
121
    The reference argument identifies a bundle entity and must be an instance
163
122
    of "quickstart.models.references.Reference".
164
123
165
124
    Raise a ValueError if the returned content is not a valid YAML, or if the
166
125
    given reference does not represent a bundle.
167
126
    Raise a NotFoundError if a bundle with the given reference cannot be found
168
127
    in the charm store.
169
128
    Raise an IOError if any other problems occur while communicating with the
170
129
    charm store.
171
130
    """
172
131
    return _retrieve_and_parse_bundle_data(
173
132
        reference, '/archive/bundles.yaml.orig')
174
133
175
134
176
135
def _retrieve_and_parse_bundle_data(reference, path):
177
136
    """Retrieve and parse the bundle YAML for the given reference and path.
178
137
179
138
    Raise a ValueError if the returned content is not a valid YAML, or if the
180
139
    given reference does not represent a bundle.
181
140
    Raise a NotFoundError if a bundle with the given reference cannot be found
182
141
    in the charm store.
183
142
    Raise an IOError if any other problems occur while communicating with the
184
143
    charm store.
185
144
    """
186
145
    if not reference.is_bundle():
187
146
        raise ValueError(
188
147
            b'expected a bundle, provided charm {}'.format(reference))
189
148
    content = get_reference(reference, path)
190
149
    return load_bundle_yaml(content)
191
150
192
151
193
152
def load_bundle_yaml(content):
194
153
    """Deserialize the given YAML encoded bundle content.
195
154
196
155
    Raise a ValueError if the content is not valid.
197
156
    """
198
157
    try:
199
158
        return serializers.yaml_load(content)
200
159
    except Exception as err:
201
160
        msg = b'unable to parse the bundle content: {}'.format(err)
202
161
        raise ValueError(msg)
203
0
162
204
=== modified file 'quickstart/manage.py'
205
--- quickstart/manage.py	2015-02-26 12:42:34 +0000
206
+++ quickstart/manage.py	2015-03-10 10:19:09 +0000
207
@@ -294,7 +294,7 @@
208
294
        level=level,
294
        level=level,
209
295
        format=(
295
        format=(
210
296
            '%(asctime)s %(levelname)s '
296
            '%(asctime)s %(levelname)s '
212
297
            '%(module)s@%(funcName)s:%(lineno)d '
297
            '%(module)s:%(lineno)d '
213
298
            '%(message)s'
298
            '%(message)s'
214
299
        ),
299
        ),
215
300
        datefmt='%H:%M:%S',
300
        datefmt='%H:%M:%S',
216
@@ -459,9 +459,11 @@
217
459
    # Parse the provided arguments.
459
    # Parse the provided arguments.
218
460
    options = parser.parse_args()
460
    options = parser.parse_args()
219
461
461
220
462
    # Set up logging.
221
463
    _configure_logging(logging.DEBUG if options.debug else logging.INFO)
222
464
223
465
    # Validate and add in the platform for convenience.
224
462
    _validate_platform(parser, platform)
466
    _validate_platform(parser, platform)
225
463
226
464
    # Add in the platform for convenience.
227
465
    options.platform = platform
467
    options.platform = platform
228
466
468
229
467
    # Convert the provided string arguments to unicode.
469
    # Convert the provided string arguments to unicode.
230
@@ -472,8 +474,6 @@
231
472
        _validate_bundle(options, parser)
474
        _validate_bundle(options, parser)
232
473
    if options.charm_url is not None:
475
    if options.charm_url is not None:
233
474
        _validate_charm_url(options, parser)
476
        _validate_charm_url(options, parser)
234
475
    # Set up logging.
235
476
    _configure_logging(logging.DEBUG if options.debug else logging.INFO)
236
477
    return options
477
    return options
237
478
478
238
479
479
239
480
480
240
=== modified file 'quickstart/models/bundles.py'
241
--- quickstart/models/bundles.py	2015-02-26 19:46:48 +0000
242
+++ quickstart/models/bundles.py	2015-03-10 10:19:09 +0000
243
@@ -44,8 +44,10 @@
244
44
import collections
44
import collections
245
45
import logging
45
import logging
246
46
import os
46
import os
247
47
import re
248
47
48
249
48
from quickstart import (
49
from quickstart import (
250
50
    charmstore,
251
49
    netutils,
51
    netutils,
252
50
    serializers,
52
    serializers,
253
51
    settings,
53
    settings,
254
@@ -140,11 +142,7 @@
255
140
    """
142
    """
256
141
    if source.startswith('bundle:'):
143
    if source.startswith('bundle:'):
257
142
        # The source refers to an old style bundle URL.
144
        # The source refers to an old style bundle URL.
263
143
        reference = references.Reference.from_charmworld_url(source)
145
        return _bundle_from_charmworld_url(source)
259
144
        logging.warn(
260
145
            'this bundle URL is deprecated: please use the new format: '
261
146
            '{}'.format(reference.jujucharms_id()))
262
147
        return _bundle_from_reference(reference)
264
148
146
265
149
    has_extension = source.endswith('.yaml') or source.endswith('.json')
147
    has_extension = source.endswith('.yaml') or source.endswith('.json')
266
150
    is_remote = source.startswith('http://') or source.startswith('https://')
148
    is_remote = source.startswith('http://') or source.startswith('https://')
267
@@ -163,30 +161,84 @@
268
163
        # No other options are available.
161
        # No other options are available.
269
164
        raise
162
        raise
270
165
163
271
166
    if not reference.is_bundle():
272
167
        raise ValueError(
273
168
            b'expected a bundle, provided charm {}'.format(reference))
274
169
275
170
    # The source refers to a bundle URL in jujucharms.com.
164
    # The source refers to a bundle URL in jujucharms.com.
288
171
    return _bundle_from_reference(reference)
165
    try:
289
172
166
        data = charmstore.get_bundle_data(reference)
290
173
167
    except charmstore.NotFoundError as err:
291
174
def _bundle_from_reference(reference):
168
        raise IOError(bytes(err))
292
175
    """Retrieve bundle YAML contents from its reference in the charm store.
169
    validate(data)
293
176
170
    return Bundle(data, reference=reference)
294
177
    The path of an entity in the charm store is the fully qualified URL without
171
295
178
    the schema. The schema is implicitly set to "cs" (charm store entity), e.g.
172
296
179
    "vivid/django" or "~who/trusty/mediawiki-42".
173
# Compile the regular expression used to parse charmworld bundle URLs.
297
180
174
_charmworld_url_expression = re.compile(r"""
298
181
    Return a Bundle instance which includes the retrieved data and the given
175
    ^  # Beginning of the line.
299
182
    reference.
176
    (?:bundle:)  # Bundle schema.
300
177
    (?:~({user_pattern})/)?  # Optional user name.
301
178
    ({name_pattern})/  # Basket name.
302
179
    (?:(\d+)/)?  # Optional bundle revision number.
303
180
    ({name_pattern})  # Bundle name.
304
181
    /?  # Optional trailing slash.
305
182
    $  # End of the line.
306
183
""".format(
307
184
    name_pattern=references.NAME_PATTERN,
308
185
    user_pattern=references.USER_PATTERN,
309
186
), re.VERBOSE)
310
187
311
188
312
189
def _bundle_from_charmworld_url(url):
313
190
    """Retrieve bundle YAML contents from the given charmworld URL.
314
191
315
192
    These kind of "bundle:basket/name" URLs were used before the release
316
193
    of the new charm store (API version 4). Possible examples are
317
194
    "bundle:mediawiki/single" or "bundle:~who/wordpress/42/scalable".
318
195
    Note that charmworld URLs always represent a bundle.
319
196
320
197
    Return a Bundle instance which includes the retrieved data and the bundle
321
198
    reference corresponding to the given charmworld URL.
322
199
    Raise a ValueError if the provided URL is not valid, or if the bundle
323
200
    content is not valid.
324
183
    Raise a IOError if a problem is encountered while fetching the YAML
201
    Raise a IOError if a problem is encountered while fetching the YAML
325
184
    content from the charm store.
202
    content from the charm store.
326
185
    Raise a ValueError if the bundle content is not valid.
327
186
    """
203
    """
331
187
    url = settings.CHARMSTORE_API + reference.path() + '/archive/bundle.yaml'
204
    match = _charmworld_url_expression.match(url)
332
188
    content = _retrieve_from_url(url)
205
    if match is None:
333
189
    data = parse_yaml(content)
206
        msg = 'invalid bundle URL: {}'.format(url)
334
207
        raise ValueError(msg.encode('utf-8'))
335
208
    user, basket, revision, name = match.groups()
336
209
    # The legacy bundle ingestion works like the following:
337
210
    # - if a basket includes multiple bundles, the resulting v4 bundle name is
338
211
    #   "{basket-name}-{bundle-name}". In this case, a separate bundle is
339
212
    #   created for each top level name found in the YAML;
340
213
    # - if a basket only includes one bundle, the v4 bundle just uses the
341
214
    #   basket name, because no disambiguation is required.
342
215
    # For this reason, we cannot infer the new bundle identifier from a
343
216
    # charmworld URL: we instead need to try to fetch both references.
344
217
    fullname = '{}-{}'.format(basket, name)
345
218
    reference = references.Reference('cs', user, 'bundle', fullname, revision)
346
219
    try:
347
220
        data = charmstore.get_bundle_data(reference)
348
221
    except charmstore.NotFoundError:
349
222
        # Also try the case in which a single bundle was included in the
350
223
        # legacy YAML. In this case, validating that the name was included
351
224
        # in the original YAML is also required.
352
225
        reference = references.Reference(
353
226
            'cs', user, 'bundle', basket, revision)
354
227
        try:
355
228
            data = charmstore.get_legacy_bundle_data(reference)
356
229
        except charmstore.NotFoundError as err:
357
230
            raise IOError(bytes(err))
358
231
        data = _flatten_data(data, name)
359
232
360
233
    validate(data)
361
234
    # XXX frankban 2015-02-26: remove this when switching to the new bundle
362
235
    # format. Note that this is monkey patched on purpose: we don't want the
363
236
    # legacy bundle id to be part of the Reference class contract, and we don't
364
237
    # want to keep track of obsolete concepts such as "basket" there.
365
238
    reference.charmworld_id = url[len('bundle:'):]
366
239
    logging.warn(
367
240
        'this bundle URL is deprecated: please use the new format: '
368
241
        '{}'.format(reference.jujucharms_id()))
369
190
    return Bundle(data, reference=reference)
242
    return Bundle(data, reference=reference)
370
191
243
371
192
244
372
@@ -198,7 +250,7 @@
373
198
    """
250
    """
374
199
    try:
251
    try:
375
200
        return netutils.urlread(url)
252
        return netutils.urlread(url)
377
201
    except IOError as err:
253
    except (netutils.NotFoundError, IOError) as err:
378
202
        msg = b'cannot retrieve bundle from remote URL {}: {}'.format(
254
        msg = b'cannot retrieve bundle from remote URL {}: {}'.format(
379
203
            url.encode('utf-8'), err)
255
            url.encode('utf-8'), err)
380
204
        raise IOError(msg)
256
        raise IOError(msg)
381
@@ -233,12 +285,28 @@
382
233
        - the YAML contents are not properly structured;
285
        - the YAML contents are not properly structured;
383
234
        - the bundle does not include services.
286
        - the bundle does not include services.
384
235
    """
287
    """
386
236
    data = _open_yaml(content)
288
    data = charmstore.load_bundle_yaml(content)
387
237
    # Validate the bundle data.
289
    # Validate the bundle data.
388
238
    validate(data)
290
    validate(data)
389
239
    return data
291
    return data
390
240
292
391
241
293
392
294
def is_legacy_bundle(data):
393
295
    """Report whether the given bundle data represents a legacy bundle.
394
296
395
297
    Assume the given data is a dictionary like object.
396
298
    """
397
299
    services = data.get('services')
398
300
    # The internal structure of a bundle in the API version 4 does not include
399
301
    # a wrapping namespace with the bundle name. That's why the check below,
400
302
    # despite its ugliness, is quite effective.
401
303
    if (not services):
402
304
        return True
403
305
    if isinstance(services, collections.Mapping) and ('services' in services):
404
306
        return True
405
307
    return False
406
308
407
309
408
242
def _parse_and_flatten_yaml(content, name):
310
def _parse_and_flatten_yaml(content, name):
409
243
    """Parse and validate the given bundle content.
311
    """Parse and validate the given bundle content.
410
244
312
411
@@ -255,15 +323,29 @@
412
255
          than one bundle;
323
          than one bundle;
413
256
        - the bundle does not include services.
324
        - the bundle does not include services.
414
257
    """
325
    """
424
258
    data = _open_yaml(content)
326
    data = charmstore.load_bundle_yaml(content)
425
259
    services = data.get('services')
327
    _ensure_is_dict(data)
426
260
    # The internal structure of a bundle in the API version 4 does not include
328
    if is_legacy_bundle(data):
427
261
    # a wrapping namespace with the bundle name. That's why the check below,
329
        data = _flatten_data(data, name)
428
262
    # despite its ugliness, is quite effective.
330
    validate(data)
429
263
    if services and 'services' not in services:
331
    return data
430
264
        # This is an API version 4 bundle.
332
431
265
        validate(data)
333
432
266
        return data
334
def _flatten_data(data, name):
433
335
    """Retrieve the bundle content from data for a specific bundle name.
434
336
435
337
    The returned YAML decoded data represents a new style bundle
436
338
    (API version 4).
437
339
438
340
    Raise a ValueError if:
439
341
        - the YAML data is not properly structured;
440
342
        - the YAML data does not include any bundles;
441
343
        - the bundle name is specified but not included in the bundle file;
442
344
        - the bundle name is not specified and the bundle file includes more
443
345
          than one bundle;
444
346
        - the bundle does not include services.
445
347
    """
446
348
    _ensure_is_dict(data)
447
267
    num_bundles = len(data)
349
    num_bundles = len(data)
448
268
    if not num_bundles:
350
    if not num_bundles:
449
269
        raise ValueError(b'no bundles found in the provided list of bundles')
351
        raise ValueError(b'no bundles found in the provided list of bundles')
450
@@ -272,30 +354,14 @@
451
272
        if num_bundles > 1:
354
        if num_bundles > 1:
452
273
            msg = 'multiple bundles found ({}) but no bundle name specified'
355
            msg = 'multiple bundles found ({}) but no bundle name specified'
453
274
            raise ValueError(msg.format(names).encode('utf-8'))
356
            raise ValueError(msg.format(names).encode('utf-8'))
458
275
        data = data.values()[0]
357
        return data.values()[0]
459
276
    else:
358
    data = data.get(name)
460
277
        data = data.get(name)
359
    if data is None:
461
278
        if data is None:
360
        if num_bundles == 1:
462
361
            msg = 'bundle {} not found, did you mean {}?'
463
362
        else:
464
279
            msg = 'bundle {} not found in the provided list of bundles ({})'
363
            msg = 'bundle {} not found in the provided list of bundles ({})'
484
280
            raise ValueError(msg.format(name, names).encode('utf-8'))
364
        raise ValueError(msg.format(name, names).encode('utf-8'))
466
281
    validate(data)
467
282
    return data
468
283
469
284
470
285
def _open_yaml(content):
471
286
    """Deserialize the given content, that must be a YAML encoded dictionary.
472
287
473
288
    Raise a ValueError if the content is not valid.
474
289
    """
475
290
    try:
476
291
        data = serializers.yaml_load(content)
477
292
    except Exception as err:
478
293
        msg = b'unable to parse the bundle content: {}'.format(err)
479
294
        raise ValueError(msg)
480
295
    # Ensure the bundle content is well formed.
481
296
    if not isinstance(data, collections.Mapping):
482
297
        msg = 'invalid YAML content: {}'.format(data)
483
298
        raise ValueError(msg.encode('utf-8'))
485
299
    return data
365
    return data
486
300
366
487
301
367
488
@@ -312,6 +378,7 @@
489
312
        - the YAML contents are not properly structured;
378
        - the YAML contents are not properly structured;
490
313
        - the bundle does not include services.
379
        - the bundle does not include services.
491
314
    """
380
    """
492
381
    _ensure_is_dict(data)
493
315
    # Retrieve the bundle services.
382
    # Retrieve the bundle services.
494
316
    try:
383
    try:
495
317
        services = data['services'].keys()
384
        services = data['services'].keys()
496
@@ -328,3 +395,13 @@
497
328
            b'the provided bundle contains an instance of juju-gui. Juju '
395
            b'the provided bundle contains an instance of juju-gui. Juju '
498
329
            b'Quickstart will install the latest version of the Juju GUI '
396
            b'Quickstart will install the latest version of the Juju GUI '
499
330
            b'automatically; please remove juju-gui from the bundle')
397
            b'automatically; please remove juju-gui from the bundle')
500
398
501
399
502
400
def _ensure_is_dict(data):
503
401
    """Ensure that the given bundle data is a dictionary like object.
504
402
505
403
    Raise a ValueError otherwise.
506
404
    """
507
405
    if not isinstance(data, collections.Mapping):
508
406
        msg = 'invalid YAML content: {}'.format(data)
509
407
        raise ValueError(msg.encode('utf-8'))
510
331
408
511
=== modified file 'quickstart/models/references.py'
512
--- quickstart/models/references.py	2015-02-27 09:25:33 +0000
513
+++ quickstart/models/references.py	2015-03-10 10:19:09 +0000
514
@@ -25,29 +25,15 @@
515
25
25
516
26
# The following regular expressions are the same used in juju-core: see
26
# The following regular expressions are the same used in juju-core: see
517
27
# http://bazaar.launchpad.net/~go-bot/juju-core/trunk/view/head:/charm/url.go.
27
# http://bazaar.launchpad.net/~go-bot/juju-core/trunk/view/head:/charm/url.go.
521
28
_USER_PATTERN = r'[a-z0-9][a-zA-Z0-9+.-]+'
28
USER_PATTERN = r'[a-z0-9][a-zA-Z0-9+.-]+'
522
29
_SERIES_PATTERN = r'[a-z]+(?:[a-z-]+[a-z])?'
29
SERIES_PATTERN = r'[a-z]+(?:[a-z-]+[a-z])?'
523
30
_NAME_PATTERN = r'[a-z][a-z0-9]*(?:-[a-z0-9]*[a-z][a-z0-9]*)*'
30
NAME_PATTERN = r'[a-z][a-z0-9]*(?:-[a-z0-9]*[a-z][a-z0-9]*)*'
524
31
31
525
32
# Define the callables used to check if entity reference components are valid.
32
# Define the callables used to check if entity reference components are valid.
529
33
_valid_user = re.compile(r'^{}$'.format(_USER_PATTERN)).match
33
_valid_user = re.compile(r'^{}$'.format(USER_PATTERN)).match
530
34
_valid_series = re.compile(r'^{}$'.format(_SERIES_PATTERN)).match
34
_valid_series = re.compile(r'^{}$'.format(SERIES_PATTERN)).match
531
35
_valid_name = re.compile(r'^{}$'.format(_NAME_PATTERN)).match
35
_valid_name = re.compile(r'^{}$'.format(NAME_PATTERN)).match
532
36
36
533
37
# Compile the regular expression used to parse charmworld bundle URLs.
534
38
_charmworld_url_expression = re.compile(r"""
535
39
    ^  # Beginning of the line.
536
40
    (?:bundle:)  # Bundle schema.
537
41
    (?:~({user_pattern})/)?  # Optional user name.
538
42
    ({name_pattern})/  # Basket name.
539
43
    (?:(\d+)/)?  # Optional bundle revision number.
540
44
    ({name_pattern})  # Bundle name.
541
45
    /?  # Optional trailing slash.
542
46
    $  # End of the line.
543
47
""".format(
544
48
    name_pattern=_NAME_PATTERN,
545
49
    user_pattern=_USER_PATTERN,
546
50
), re.VERBOSE)
547
51
# Compile the regular expression used to parse new jujucharms entity URLs.
37
# Compile the regular expression used to parse new jujucharms entity URLs.
548
52
_jujucharms_url_expression = re.compile(r"""
38
_jujucharms_url_expression = re.compile(r"""
549
53
    ^  # Beginning of the line.
39
    ^  # Beginning of the line.
550
@@ -64,9 +50,9 @@
551
64
    $  # End of the line.
50
    $  # End of the line.
552
65
""".format(
51
""".format(
553
66
    jujucharms=settings.JUJUCHARMS_URL,
52
    jujucharms=settings.JUJUCHARMS_URL,
557
67
    name_pattern=_NAME_PATTERN,
53
    name_pattern=NAME_PATTERN,
558
68
    series_pattern=_SERIES_PATTERN,
54
    series_pattern=SERIES_PATTERN,
559
69
    user_pattern=_USER_PATTERN,
55
    user_pattern=USER_PATTERN,
560
70
), re.VERBOSE)
56
), re.VERBOSE)
561
71
57
562
72
58
563
@@ -101,31 +87,6 @@
564
101
        return cls(*_parse_fully_qualified_url(url))
87
        return cls(*_parse_fully_qualified_url(url))
565
102
88
566
103
    @classmethod
89
    @classmethod
567
104
    def from_charmworld_url(cls, url):
568
105
        """Create and return a Reference from the given charmworld URL.
569
106
570
107
        These kind of "bundle:basket/name" URLs were used before the release
571
108
        of the new charm store (API version 4). Possible examples are
572
109
        "bundle:mediawiki/single" or "bundle:~who/wordpress/42/scalable".
573
110
        Note that charmworld URLs always represent a bundle.
574
111
575
112
        Raise a ValueError if the provided URL is not valid.
576
113
        """
577
114
        match = _charmworld_url_expression.match(url)
578
115
        if match is None:
579
116
            msg = 'invalid bundle URL: {}'.format(url)
580
117
            raise ValueError(msg.encode('utf-8'))
581
118
        user, basket, revision, name = match.groups()
582
119
        name = '{}-{}'.format(basket, name)
583
120
        self = cls('cs', user, 'bundle', name, revision)
584
121
        # XXX frankban 2015-02-26: remove this when switching to the new bundle
585
122
        # format. Note that this is monkey patched on purpose: we don't want
586
123
        # the legacy bundle id to be part of this class contract, and we don't
587
124
        # want to keep track of obsolete concepts such as "basket" here.
588
125
        self.charmworld_id = url[len('bundle:'):]
589
126
        return self
590
127
591
128
    @classmethod
592
129
    def from_jujucharms_url(cls, url):
90
    def from_jujucharms_url(cls, url):
593
130
        """Create and return a Reference from the given jujucharms.com URL.
91
        """Create and return a Reference from the given jujucharms.com URL.
594
131
92
595
132
93
596
=== modified file 'quickstart/netutils.py'
597
--- quickstart/netutils.py	2015-02-25 15:28:56 +0000
598
+++ quickstart/netutils.py	2015-03-10 10:19:09 +0000
599
@@ -18,14 +18,11 @@
600
18
18
601
19
from __future__ import unicode_literals
19
from __future__ import unicode_literals
602
20
20
603
21
import json
604
22
import httplib
21
import httplib
605
23
import logging
22
import logging
606
24
import socket
23
import socket
607
25
import urllib2
24
import urllib2
608
26
25
609
27
from quickstart import settings
610
28
611
29
26
612
30
def check_resolvable(hostname):
27
def check_resolvable(hostname):
613
31
    """Check that the hostname can be resolved to a numeric IP address.
28
    """Check that the hostname can be resolved to a numeric IP address.
614
@@ -63,31 +60,25 @@
615
63
    return None
60
    return None
616
64
61
617
65
62
631
66
def get_charm_url(series):
63
class NotFoundError(Exception):
632
67
    """Return the charm URL of the latest Juju GUI charm revision.
64
    """Represent a 404 not found HTTP error."""
620
68
621
69
    Raise an IOError if any problems occur connecting to the API endpoint.
622
70
    Raise a ValueError if the API returns invalid data.
623
71
    """
624
72
    url = '{}{}/{}/meta/id'.format(
625
73
        settings.CHARMSTORE_API, series, settings.JUJU_GUI_CHARM_NAME)
626
74
    data = json.loads(urlread(url))
627
75
    charm_url = data.get('Id')
628
76
    if charm_url is None:
629
77
        raise ValueError(b'unable to find the charm URL')
630
78
    return charm_url
633
79
65
634
80
66
635
81
def urlread(url):
67
def urlread(url):
636
82
    """Open the given URL and return the page contents.
68
    """Open the given URL and return the page contents.
637
83
69
639
84
    Raise an IOError if any problems occur.
70
    Raise a NotFoundError if the request returns a 404 not found response.
640
71
    Raise an IOError if any other problems occur.
641
85
    """
72
    """
642
73
    logging.debug('sending HTTP GET request to {}'.format(url))
643
86
    try:
74
    try:
644
87
        response = urllib2.urlopen(url)
75
        response = urllib2.urlopen(url)
645
76
    except urllib2.HTTPError as err:
646
77
        exception = NotFoundError if err.code == 404 else IOError
647
78
        raise exception(bytes(err))
648
88
    except urllib2.URLError as err:
79
    except urllib2.URLError as err:
649
89
        raise IOError(err.reason)
80
        raise IOError(err.reason)
651
90
    except (httplib.HTTPException, socket.error, urllib2.HTTPError) as err:
81
    except (httplib.HTTPException, socket.error) as err:
652
91
        raise IOError(bytes(err))
82
        raise IOError(bytes(err))
653
92
    contents = response.read()
83
    contents = response.read()
654
93
    content_type = response.headers['content-type']
84
    content_type = response.headers['content-type']
655
94
85
656
=== modified file 'quickstart/settings.py'
657
--- quickstart/settings.py	2015-02-25 19:26:02 +0000
658
+++ quickstart/settings.py	2015-03-10 10:19:09 +0000
659
@@ -37,8 +37,8 @@
660
37
# temporary connection/charm store errors.
37
# temporary connection/charm store errors.
661
38
# Keep this list sorted by release date (older first).
38
# Keep this list sorted by release date (older first).
662
39
DEFAULT_CHARM_URLS = collections.OrderedDict((
39
DEFAULT_CHARM_URLS = collections.OrderedDict((
665
40
    ('precise', 'cs:precise/juju-gui-106'),
40
    ('precise', 'cs:precise/juju-gui-108'),
666
41
    ('trusty', 'cs:trusty/juju-gui-18'),
41
    ('trusty', 'cs:trusty/juju-gui-21'),
667
42
))
42
))
668
43
43
669
44
# The quickstart app short description.
44
# The quickstart app short description.
670
45
45
671
=== modified file 'quickstart/tests/helpers.py'
672
--- quickstart/tests/helpers.py	2015-02-26 19:46:48 +0000
673
+++ quickstart/tests/helpers.py	2015-03-10 10:19:09 +0000
674
@@ -299,17 +299,18 @@
675
299
class UrlReadTestsMixin(object):
299
class UrlReadTestsMixin(object):
676
300
    """Helpers to mock the quickstart.netutils.urlread helper function."""
300
    """Helpers to mock the quickstart.netutils.urlread helper function."""
677
301
301
679
302
    def patch_urlread(self, contents=None, error=False):
302
    def patch_urlread(self, contents=None, error=None):
680
303
        """Patch the quickstart.netutils.urlread helper function.
303
        """Patch the quickstart.netutils.urlread helper function.
681
304
304
682
305
        If contents is not None, urlread() will return the provided contents.
305
        If contents is not None, urlread() will return the provided contents.
684
306
        If error is set to True, an IOError will be simulated.
306
        Otherwise, if error is not None, the given exception or list of side
685
307
        effects will be simulated.
686
307
        """
308
        """
687
308
        mock_urlread = mock.Mock()
309
        mock_urlread = mock.Mock()
688
309
        if contents is not None:
310
        if contents is not None:
689
310
            mock_urlread.return_value = contents
311
            mock_urlread.return_value = contents
692
311
        if error:
312
        elif error is not None:
693
312
            mock_urlread.side_effect = IOError('bad wolf')
313
            mock_urlread.side_effect = error
694
313
        return mock.patch('quickstart.netutils.urlread', mock_urlread)
314
        return mock.patch('quickstart.netutils.urlread', mock_urlread)
695
314
315
696
315
316
697
316
317
698
=== modified file 'quickstart/tests/models/test_bundles.py'
699
--- quickstart/tests/models/test_bundles.py	2015-02-26 19:46:48 +0000
700
+++ quickstart/tests/models/test_bundles.py	2015-03-10 10:19:09 +0000
701
@@ -21,9 +21,13 @@
702
21
import json
21
import json
703
22
import unittest
22
import unittest
704
23
23
705
24
import mock
706
24
import yaml
25
import yaml
707
25
26
709
26
from quickstart import settings
27
from quickstart import (
710
28
    netutils,
711
29
    settings,
712
30
)
713
27
from quickstart.models import (
31
from quickstart.models import (
714
28
    bundles,
32
    bundles,
715
29
    references,
33
    references,
716
@@ -86,6 +90,10 @@
717
86
            bundle = bundles.from_source('bundle:mediawiki/single')
90
            bundle = bundles.from_source('bundle:mediawiki/single')
718
87
        self.assertEqual(self.bundle_data, bundle.data)
91
        self.assertEqual(self.bundle_data, bundle.data)
719
88
        self.assertEqual('cs:bundle/mediawiki-single', bundle.reference.id())
92
        self.assertEqual('cs:bundle/mediawiki-single', bundle.reference.id())
720
93
        # The charmworld id is properly set when passing charmworld URLs.
721
94
        # XXX frankban 2015-03-09: remove this check once we get rid of the
722
95
        # charmworld id concept.
723
96
        self.assertEqual('mediawiki/single', bundle.reference.charmworld_id)
724
89
        mock_urlread.assert_called_once_with(
97
        mock_urlread.assert_called_once_with(
725
90
            settings.CHARMSTORE_API +
98
            settings.CHARMSTORE_API +
726
91
            'bundle/mediawiki-single/archive/bundle.yaml')
99
            'bundle/mediawiki-single/archive/bundle.yaml')
727
@@ -98,10 +106,45 @@
728
98
        self.assertEqual(self.bundle_data, bundle.data)
106
        self.assertEqual(self.bundle_data, bundle.data)
729
99
        self.assertEqual(
107
        self.assertEqual(
730
100
            'cs:~who/bundle/mediawiki-single-42', bundle.reference.id())
108
            'cs:~who/bundle/mediawiki-single-42', bundle.reference.id())
731
109
        # The charmworld id is properly set when passing charmworld URLs.
732
110
        # XXX frankban 2015-03-09: remove this check once we get rid of the
733
111
        # charmworld id concept.
734
112
        self.assertEqual(
735
113
            '~who/mediawiki/42/single', bundle.reference.charmworld_id)
736
101
        mock_urlread.assert_called_once_with(
114
        mock_urlread.assert_called_once_with(
737
102
            settings.CHARMSTORE_API +
115
            settings.CHARMSTORE_API +
738
103
            '~who/bundle/mediawiki-single-42/archive/bundle.yaml')
116
            '~who/bundle/mediawiki-single-42/archive/bundle.yaml')
739
104
117
740
118
    def test_charmworld_bundle_from_legacy(self):
741
119
        # A bundle instance is properly returned from a charmworld id source
742
120
        # by looking at the legacy YAML stored in the charm store.
743
121
        side_effect = [
744
122
            # A first call urlread returns a not found error.
745
123
            netutils.NotFoundError('boo!'),
746
124
            # A second call succeeds.
747
125
            self.legacy_bundle_content,
748
126
        ]
749
127
        with self.patch_urlread(error=side_effect) as mock_urlread:
750
128
            bundle = bundles.from_source('bundle:mediawiki/bundle1')
751
129
        self.assertEqual(self.bundle_data, bundle.data)
752
130
        self.assertEqual('cs:bundle/mediawiki', bundle.reference.id())
753
131
        # The charmworld id is properly set when passing charmworld URLs.
754
132
        # XXX frankban 2015-03-09: remove this check once we get rid of the
755
133
        # charmworld id concept.
756
134
        self.assertEqual('mediawiki/bundle1', bundle.reference.charmworld_id)
757
135
        # The urlread function has been called two times: the first time
758
136
        # including both the basket and the bundle name, the second time
759
137
        # to retrieve the legacy bundle yaml, only including the basket.
760
138
        self.assertEqual(mock_urlread.call_count, 2)
761
139
        mock_urlread.assert_has_calls([
762
140
            mock.call(
763
141
                settings.CHARMSTORE_API +
764
142
                'bundle/mediawiki-bundle1/archive/bundle.yaml'),
765
143
            mock.call(
766
144
                settings.CHARMSTORE_API +
767
145
                'bundle/mediawiki/archive/bundles.yaml.orig'),
768
146
        ])
769
147
770
105
    def test_charmworld_bundle_deprecation_warning(self):
148
    def test_charmworld_bundle_deprecation_warning(self):
771
106
        # A deprecation warning is printed if the no longer supported
149
        # A deprecation warning is printed if the no longer supported
772
107
        # charmworld bundle identifiers are used.
150
        # charmworld bundle identifiers are used.
773
@@ -119,22 +162,73 @@
774
119
162
775
120
    def test_charmworld_bundle_invalid_content(self):
163
    def test_charmworld_bundle_invalid_content(self):
776
121
        # A ValueError is raised if the content associated with the given
164
        # A ValueError is raised if the content associated with the given
780
122
        # charmworld URL are not valid.
165
        # charmworld URL is not valid.
781
123
        with self.patch_urlread(error=True):
166
        with self.patch_urlread(contents='exterminate!'):
782
124
            with self.assertRaises(IOError) as ctx:
167
            with self.assert_value_error('invalid YAML content: exterminate!'):
783
125
                bundles.from_source('bundle:mediawiki/single')
168
                bundles.from_source('bundle:mediawiki/single')
784
126
        expected_error = (
785
127
            'cannot retrieve bundle from remote URL '
786
128
            '{}bundle/mediawiki-single/archive/bundle.yaml: '
787
129
            'bad wolf'.format(settings.CHARMSTORE_API))
788
130
        self.assertEqual(expected_error, bytes(ctx.exception))
789
131
169
790
132
    def test_charmworld_bundle_connection_error(self):
170
    def test_charmworld_bundle_connection_error(self):
791
133
        # An IOError is raised if a connection problem is encountered while
171
        # An IOError is raised if a connection problem is encountered while
792
134
        # retrieving the charmworld bundle.
172
        # retrieving the charmworld bundle.
796
135
        with self.patch_urlread(contents='exterminate!'):
173
        with self.patch_urlread(error=IOError('bad wolf')):
797
136
            with self.assert_value_error('invalid YAML content: exterminate!'):
174
            with self.assertRaises(IOError) as ctx:
798
137
                bundles.from_source('bundle:mediawiki/single')
175
                bundles.from_source('bundle:mediawiki/single')
799
176
        expected_error = (
800
177
            'cannot communicate with the charm store at '
801
178
            '{}bundle/mediawiki-single/archive/bundle.yaml: '
802
179
            'bad wolf'.format(settings.CHARMSTORE_API))
803
180
        self.assertEqual(expected_error, bytes(ctx.exception))
804
181
805
182
    def test_charmworld_bundle_not_found_error(self):
806
183
        # An IOError is raised if a charmworld bundle is not found.
807
184
        error = netutils.NotFoundError('bad wolf')
808
185
        with self.patch_urlread(error=error) as mock_urlread:
809
186
            with self.assertRaises(IOError) as ctx:
810
187
                bundles.from_source('bundle:mediawiki/single')
811
188
        expected_error = (
812
189
            'charm store resource not found at '
813
190
            '{}bundle/mediawiki/archive/bundles.yaml.orig: '
814
191
            'bad wolf'.format(settings.CHARMSTORE_API))
815
192
        self.assertEqual(expected_error, bytes(ctx.exception))
816
193
        # The urlread function has been called two times: the first time
817
194
        # including both the basket and the bundle name, the second time
818
195
        # to retrieve the legacy bundle yaml, only including the basket.
819
196
        self.assertEqual(mock_urlread.call_count, 2)
820
197
        mock_urlread.assert_has_calls([
821
198
            mock.call(
822
199
                settings.CHARMSTORE_API +
823
200
                'bundle/mediawiki-single/archive/bundle.yaml'),
824
201
            mock.call(
825
202
                settings.CHARMSTORE_API +
826
203
                'bundle/mediawiki/archive/bundles.yaml.orig'),
827
204
        ])
828
205
829
206
    def test_charmworld_bundle_from_legacy_invalid_name(self):
830
207
        # A ValueError is raised if the given bundle name is not found in
831
208
        # the legacy basket.
832
209
        legacy_bundle_content = yaml.safe_dump({'scalable': self.bundle_data})
833
210
        side_effect = [
834
211
            # A first call urlread returns a not found error.
835
212
            netutils.NotFoundError('boo!'),
836
213
            # A second call succeeds.
837
214
            legacy_bundle_content,
838
215
        ]
839
216
        expected_error = 'bundle single not found, did you mean scalable?'
840
217
        with self.patch_urlread(error=side_effect) as mock_urlread:
841
218
            with self.assert_value_error(expected_error):
842
219
                bundles.from_source('bundle:django/single')
843
220
        # The urlread function has been called two times: the first time
844
221
        # including both the basket and the bundle name, the second time
845
222
        # to retrieve the legacy bundle yaml, only including the basket.
846
223
        self.assertEqual(mock_urlread.call_count, 2)
847
224
        mock_urlread.assert_has_calls([
848
225
            mock.call(
849
226
                settings.CHARMSTORE_API +
850
227
                'bundle/django-single/archive/bundle.yaml'),
851
228
            mock.call(
852
229
                settings.CHARMSTORE_API +
853
230
                'bundle/django/archive/bundles.yaml.orig'),
854
231
        ])
855
138
232
856
139
    def test_jujucharms_bundle(self):
233
    def test_jujucharms_bundle(self):
857
140
        # A bundle instance is properly returned from a jujucharms.com id.
234
        # A bundle instance is properly returned from a jujucharms.com id.
858
@@ -173,21 +267,33 @@
859
173
    def test_jujucharms_bundle_invalid_content(self):
267
    def test_jujucharms_bundle_invalid_content(self):
860
174
        # A ValueError is raised if the content associated with the given
268
        # A ValueError is raised if the content associated with the given
861
175
        # jujucharms.com URL are not valid.
269
        # jujucharms.com URL are not valid.
870
176
        with self.patch_urlread(error=True):
270
        with self.patch_urlread(contents='exterminate!'):
871
177
            with self.assertRaises(IOError) as ctx:
271
            with self.assert_value_error('invalid YAML content: exterminate!'):
872
178
                bundles.from_source('django/42')
272
                bundles.from_source('wordpress-scalable')
865
179
        expected_error = (
866
180
            'cannot retrieve bundle from remote URL '
867
181
            '{}bundle/django-42/archive/bundle.yaml: '
868
182
            'bad wolf'.format(settings.CHARMSTORE_API))
869
183
        self.assertEqual(expected_error, bytes(ctx.exception))
873
184
273
874
185
    def test_jujucharms_bundle_connection_error(self):
274
    def test_jujucharms_bundle_connection_error(self):
875
186
        # An IOError is raised if a connection problem is encountered while
275
        # An IOError is raised if a connection problem is encountered while
876
187
        # retrieving the jujucharms.com bundle.
276
        # retrieving the jujucharms.com bundle.
880
188
        with self.patch_urlread(contents='exterminate!'):
277
        with self.patch_urlread(error=IOError('bad wolf')):
881
189
            with self.assert_value_error('invalid YAML content: exterminate!'):
278
            with self.assertRaises(IOError) as ctx:
882
190
                bundles.from_source('wordpress-scalable')
279
                bundles.from_source('django/42')
883
280
        expected_error = (
884
281
            'cannot communicate with the charm store at '
885
282
            '{}bundle/django-42/archive/bundle.yaml: '
886
283
            'bad wolf'.format(settings.CHARMSTORE_API))
887
284
        self.assertEqual(expected_error, bytes(ctx.exception))
888
285
889
286
    def test_jujucharms_bundle_not_found_error(self):
890
287
        # An IOError is raised if a connection problem is encountered while
891
288
        # retrieving the jujucharms.com bundle.
892
289
        with self.patch_urlread(error=netutils.NotFoundError('bad wolf')):
893
290
            with self.assertRaises(IOError) as ctx:
894
291
                bundles.from_source('django/42')
895
292
        expected_error = (
896
293
            'charm store resource not found at '
897
294
            '{}bundle/django-42/archive/bundle.yaml: '
898
295
            'bad wolf'.format(settings.CHARMSTORE_API))
899
296
        self.assertEqual(expected_error, bytes(ctx.exception))
900
191
297
901
192
    def test_local_file(self):
298
    def test_local_file(self):
902
193
        # A bundle instance can be created from a local file source.
299
        # A bundle instance can be created from a local file source.
903
@@ -248,11 +354,20 @@
904
248
        with self.assert_value_error(expected_error):
354
        with self.assert_value_error(expected_error):
905
249
            bundles.from_source(path, 'mybundle')
355
            bundles.from_source(path, 'mybundle')
906
250
356
907
357
    def test_local_file_legacy_bundle_single_bundle_name_not_found(self):
908
358
        # A ValueError is raised if a local file contains a legacy version 3
909
359
        # YAML content with one bundle defined and the provided bundle name
910
360
        # does not match.
911
361
        path = self.make_bundle_file({'scalable': self.bundle_data})
912
362
        expected_error = 'bundle mybundle not found, did you mean scalable?'
913
363
        with self.assert_value_error(expected_error):
914
364
            bundles.from_source(path, 'mybundle')
915
365
916
251
    def test_local_file_legacy_bundle_invalid_bundle_content(self):
366
    def test_local_file_legacy_bundle_invalid_bundle_content(self):
917
252
        # A ValueError is raised if a local file contains an invalid legacy
367
        # A ValueError is raised if a local file contains an invalid legacy
918
253
        # version 3 content.
368
        # version 3 content.
919
254
        path = self.make_bundle_file({'bundle': '42'})
369
        path = self.make_bundle_file({'bundle': '42'})
921
255
        expected_error = "unable to retrieve bundle services: '42'"
370
        expected_error = "invalid YAML content: 42"
922
256
        with self.assert_value_error(expected_error):
371
        with self.assert_value_error(expected_error):
923
257
            bundles.from_source(path, 'bundle')
372
            bundles.from_source(path, 'bundle')
924
258
373
925
@@ -280,7 +395,7 @@
926
280
    def test_remote_url_not_reachable(self):
395
    def test_remote_url_not_reachable(self):
927
281
        # An IOError is raised if a network problem is encountered while
396
        # An IOError is raised if a network problem is encountered while
928
282
        # trying to reach the remote URL.
397
        # trying to reach the remote URL.
930
283
        with self.patch_urlread(error=True):
398
        with self.patch_urlread(error=IOError('bad wolf')):
931
284
            with self.assertRaises(IOError) as ctx:
399
            with self.assertRaises(IOError) as ctx:
932
285
                bundles.from_source('https://1.2.3.4')
400
                bundles.from_source('https://1.2.3.4')
933
286
        expected_error = (
401
        expected_error = (
934
@@ -317,6 +432,16 @@
935
317
            with self.assert_value_error(expected_error):
432
            with self.assert_value_error(expected_error):
936
318
                bundles.from_source('http://1.2.3.4', 'no-such')
433
                bundles.from_source('http://1.2.3.4', 'no-such')
937
319
434
938
435
    def test_remote_url_legacy_bundle_single_bundle_name_not_found(self):
939
436
        # A ValueError is raised if a remote URL contains a legacy version 3
940
437
        # YAML content with one bundle defined and the provided bundle name
941
438
        # does not match.
942
439
        legacy_bundle_content = yaml.safe_dump({'scalable': self.bundle_data})
943
440
        expected_error = 'bundle no-such not found, did you mean scalable?'
944
441
        with self.patch_urlread(contents=legacy_bundle_content):
945
442
            with self.assert_value_error(expected_error):
946
443
                bundles.from_source('http://1.2.3.4', 'no-such')
947
444
948
320
    def test_remote_url_legacy_bundle_invalid_bundle_content(self):
445
    def test_remote_url_legacy_bundle_invalid_bundle_content(self):
949
321
        # A ValueError is raised if a remote URL contains an invalid legacy
446
        # A ValueError is raised if a remote URL contains an invalid legacy
950
322
        # version 3 content.
447
        # version 3 content.
951
@@ -399,6 +524,22 @@
952
399
        self.assertEqual(self.bundle_data, data)
524
        self.assertEqual(self.bundle_data, data)
953
400
525
954
401
526
955
527
class TestIsLegacyBundle(helpers.BundleFileTestsMixin, unittest.TestCase):
956
528
957
529
    def test_v4_bundle(self):
958
530
        # False is returned for new-style version 4 bundles.
959
531
        self.assertFalse(bundles.is_legacy_bundle(self.bundle_data))
960
532
961
533
    def test_legacy_bundle(self):
962
534
        # True is returned for legacy bundles.
963
535
        tests = (
964
536
            self.legacy_bundle_data,
965
537
            {'services': {'services': {}}},
966
538
        )
967
539
        for data in tests:
968
540
            self.assertTrue(bundles.is_legacy_bundle(data))
969
541
970
542
971
402
class TestValidate(
543
class TestValidate(
972
403
        helpers.BundleFileTestsMixin, helpers.ValueErrorTestsMixin,
544
        helpers.BundleFileTestsMixin, helpers.ValueErrorTestsMixin,
973
404
        unittest.TestCase):
545
        unittest.TestCase):
974
405
546
975
=== modified file 'quickstart/tests/models/test_references.py'
976
--- quickstart/tests/models/test_references.py	2015-02-26 19:46:48 +0000
977
+++ quickstart/tests/models/test_references.py	2015-03-10 10:19:09 +0000
978
@@ -318,43 +318,6 @@
979
318
            self.assertEqual(expected_ref, ref)
318
            self.assertEqual(expected_ref, ref)
980
319
319
981
320
320
982
321
class TestReferenceFromCharmworldUrl(
983
322
        helpers.ValueErrorTestsMixin, unittest.TestCase):
984
323
985
324
    def test_invalid_form(self):
986
325
        # A ValueError is raised if the URL is not valid.
987
326
        expected_error = 'invalid bundle URL: bad wolf'
988
327
        with self.assert_value_error(expected_error):
989
328
            references.Reference.from_charmworld_url('bad wolf')
990
329
991
330
    def test_success(self):
992
331
        # A reference is correctly created from a charmworld identifier.
993
332
        tests = (
994
333
            ('bundle:~myuser/wordpress/42/single',
995
334
             make_reference(series='bundle', name='wordpress-single')),
996
335
            ('bundle:~myuser/wordpress/single',
997
336
             make_reference(series='bundle', name='wordpress-single',
998
337
                            revision=None)),
999
338
            ('bundle:wordpress/42/single',
1000
339
             make_reference(user='', series='bundle',
1001
340
                            name='wordpress-single')),
1002
341
            ('bundle:wordpress/single',
1003
342
             make_reference(user='', series='bundle', name='wordpress-single',
1004
343
                            revision=None)),
1005
344
        )
1006
345
        for url, expected_ref in tests:
1007
346
            ref = references.Reference.from_charmworld_url(url)
1008
347
            self.assertEqual(expected_ref, ref)
1009
348
1010
349
    def test_charmworld_id(self):
1011
350
        # The charmworld id is properly set when parsing charmworld URLs.
1012
351
        # XXX frankban 2015-02-26: remove this test once we get rid of the
1013
352
        # charmworld id concept.
1014
353
        ref = references.Reference.from_charmworld_url(
1015
354
            'bundle:wordpress/single')
1016
355
        self.assertEqual('wordpress/single', ref.charmworld_id)
1017
356
1018
357
1019
358
class TestReferenceFromJujucharmsUrl(
321
class TestReferenceFromJujucharmsUrl(
1020
359
        helpers.ValueErrorTestsMixin, unittest.TestCase):
322
        helpers.ValueErrorTestsMixin, unittest.TestCase):
1021
360
323
1022
361
324
1023
=== modified file 'quickstart/tests/test_app.py'
1024
--- quickstart/tests/test_app.py	2015-02-26 19:46:48 +0000
1025
+++ quickstart/tests/test_app.py	2015-03-10 10:19:09 +0000
1026
@@ -930,12 +930,11 @@
1027
930
        env.get_status.side_effect = side_effect
930
        env.get_status.side_effect = side_effect
1028
931
        return env
931
        return env
1029
932
932
1033
933
    def patch_get_charm_url(self, return_value=None, side_effect=None):
933
    def patch_resolve(self, return_value=None, side_effect=None):
1034
934
        """Patch the get_charm_url helper function."""
934
        """Patch the charmstore.resolve function."""
1035
935
        mock_get_charm_url = mock.Mock(
935
        mock_resolve = mock.Mock(
1036
936
            return_value=return_value, side_effect=side_effect)
936
            return_value=return_value, side_effect=side_effect)
1039
937
        return mock.patch(
937
        return mock.patch('quickstart.charmstore.resolve', mock_resolve)
1038
938
            'quickstart.netutils.get_charm_url', mock_get_charm_url)
1040
939
938
1041
940
    def assert_reference_equal(self, expected_url, ref):
939
    def assert_reference_equal(self, expected_url, ref):
1042
941
        """Ensure the given reference points to the expected URL."""
940
        """Ensure the given reference points to the expected URL."""
1043
@@ -954,8 +953,8 @@
1044
954
        env_type = 'ec2'
953
        env_type = 'ec2'
1045
955
        bootstrap_node_series = 'trusty'
954
        bootstrap_node_series = 'trusty'
1046
956
        check_preexisting = False
955
        check_preexisting = False
1049
957
        with self.patch_get_charm_url(
956
        with self.patch_resolve(
1050
958
                return_value='cs:trusty/juju-gui-42') as mock_get_charm_url:
957
                return_value='cs:trusty/juju-gui-42') as mock_resolve:
1051
959
            ref, machine, service_data, unit_data = app.check_environment(
958
            ref, machine, service_data, unit_data = app.check_environment(
1052
960
                env, 'my-gui', charm_url, env_type, bootstrap_node_series,
959
                env, 'my-gui', charm_url, env_type, bootstrap_node_series,
1053
961
                check_preexisting)
960
                check_preexisting)
1054
@@ -964,7 +963,8 @@
1055
964
        # The charm URL has been retrieved from the charm store API based on
963
        # The charm URL has been retrieved from the charm store API based on
1056
965
        # the current bootstrap node series.
964
        # the current bootstrap node series.
1057
966
        self.assert_reference_equal('cs:trusty/juju-gui-42', ref)
965
        self.assert_reference_equal('cs:trusty/juju-gui-42', ref)
1059
967
        mock_get_charm_url.assert_called_once_with(bootstrap_node_series)
966
        mock_resolve.assert_called_once_with(
1060
967
            settings.JUJU_GUI_CHARM_NAME, series=bootstrap_node_series)
1061
968
        # Since the bootstrap node series is supported by the GUI charm, the
968
        # Since the bootstrap node series is supported by the GUI charm, the
1062
969
        # GUI unit can be deployed to machine 0.
969
        # GUI unit can be deployed to machine 0.
1063
970
        self.assertEqual('0', machine)
970
        self.assertEqual('0', machine)
1064
@@ -989,8 +989,8 @@
1065
989
        env_type = 'ec2'
989
        env_type = 'ec2'
1066
990
        bootstrap_node_series = 'precise'
990
        bootstrap_node_series = 'precise'
1067
991
        check_preexisting = True
991
        check_preexisting = True
1070
992
        with self.patch_get_charm_url(
992
        with self.patch_resolve(
1071
993
                return_value='cs:precise/juju-gui-42') as mock_get_charm_url:
993
                return_value='cs:precise/juju-gui-42') as mock_resolve:
1072
994
            ref, machine, service_data, unit_data = app.check_environment(
994
            ref, machine, service_data, unit_data = app.check_environment(
1073
995
                env, 'my-gui', charm_url, env_type, bootstrap_node_series,
995
                env, 'my-gui', charm_url, env_type, bootstrap_node_series,
1074
996
                check_preexisting)
996
                check_preexisting)
1075
@@ -999,7 +999,8 @@
1076
999
        # The charm URL has been retrieved from the charm store API based on
999
        # The charm URL has been retrieved from the charm store API based on
1077
1000
        # the current bootstrap node series.
1000
        # the current bootstrap node series.
1078
1001
        self.assert_reference_equal('cs:precise/juju-gui-42', ref)
1001
        self.assert_reference_equal('cs:precise/juju-gui-42', ref)
1080
1002
        mock_get_charm_url.assert_called_once_with(bootstrap_node_series)
1002
        mock_resolve.assert_called_once_with(
1081
1003
            settings.JUJU_GUI_CHARM_NAME, series=bootstrap_node_series)
1082
1003
        # Since the bootstrap node series is supported by the GUI charm, the
1004
        # Since the bootstrap node series is supported by the GUI charm, the
1083
1004
        # GUI unit can be deployed to machine 0.
1005
        # GUI unit can be deployed to machine 0.
1084
1005
        self.assertEqual('0', machine)
1006
        self.assertEqual('0', machine)
1085
@@ -1022,7 +1023,7 @@
1086
1022
        env_type = 'ec2'
1023
        env_type = 'ec2'
1087
1023
        bootstrap_node_series = 'precise'
1024
        bootstrap_node_series = 'precise'
1088
1024
        check_preexisting = True
1025
        check_preexisting = True
1090
1025
        with self.patch_get_charm_url() as mock_get_charm_url:
1026
        with self.patch_resolve() as mock_resolve:
1091
1026
            ref, machine, service_data, unit_data = app.check_environment(
1027
            ref, machine, service_data, unit_data = app.check_environment(
1092
1027
                env, 'my-gui', charm_url, env_type, bootstrap_node_series,
1028
                env, 'my-gui', charm_url, env_type, bootstrap_node_series,
1093
1028
                check_preexisting)
1029
                check_preexisting)
1094
@@ -1030,7 +1031,7 @@
1095
1030
        env.get_status.assert_called_once_with()
1031
        env.get_status.assert_called_once_with()
1096
1031
        # The charm URL has been retrieved from the environment.
1032
        # The charm URL has been retrieved from the environment.
1097
1032
        self.assert_reference_equal('cs:precise/juju-gui-47', ref)
1033
        self.assert_reference_equal('cs:precise/juju-gui-47', ref)
1099
1033
        self.assertFalse(mock_get_charm_url.called)
1034
        self.assertFalse(mock_resolve.called)
1100
1034
        # Since the bootstrap node series is supported by the GUI charm, the
1035
        # Since the bootstrap node series is supported by the GUI charm, the
1101
1035
        # GUI unit can be safely deployed to machine 0.
1036
        # GUI unit can be safely deployed to machine 0.
1102
1036
        self.assertEqual('0', machine)
1037
        self.assertEqual('0', machine)
1103
@@ -1046,15 +1047,16 @@
1104
1046
        env_type = 'ec2'
1047
        env_type = 'ec2'
1105
1047
        bootstrap_node_series = 'saucy'
1048
        bootstrap_node_series = 'saucy'
1106
1048
        check_preexisting = False
1049
        check_preexisting = False
1109
1049
        with self.patch_get_charm_url(
1050
        with self.patch_resolve(
1110
1050
                return_value='cs:trusty/juju-gui-42') as mock_get_charm_url:
1051
                return_value='cs:trusty/juju-gui-42') as mock_resolve:
1111
1051
            ref, machine, service_data, unit_data = app.check_environment(
1052
            ref, machine, service_data, unit_data = app.check_environment(
1112
1052
                env, 'my-gui', charm_url, env_type, bootstrap_node_series,
1053
                env, 'my-gui', charm_url, env_type, bootstrap_node_series,
1113
1053
                check_preexisting)
1054
                check_preexisting)
1114
1054
        # The charm URL has been retrieved from the charm store API using the
1055
        # The charm URL has been retrieved from the charm store API using the
1115
1055
        # most recent supported series.
1056
        # most recent supported series.
1116
1056
        self.assert_reference_equal('cs:trusty/juju-gui-42', ref)
1057
        self.assert_reference_equal('cs:trusty/juju-gui-42', ref)
1118
1057
        mock_get_charm_url.assert_called_once_with('trusty')
1058
        mock_resolve.assert_called_once_with(
1119
1059
            settings.JUJU_GUI_CHARM_NAME, series='trusty')
1120
1058
        # The Juju GUI unit cannot be deployed to saucy machine 0.
1060
        # The Juju GUI unit cannot be deployed to saucy machine 0.
1121
1059
        self.assertIsNone(machine)
1061
        self.assertIsNone(machine)
1122
1060
        # Ensure the function output makes sense.
1062
        # Ensure the function output makes sense.
1123
@@ -1072,7 +1074,7 @@
1124
1072
        env_type = 'local'
1074
        env_type = 'local'
1125
1073
        bootstrap_node_series = 'trusty'
1075
        bootstrap_node_series = 'trusty'
1126
1074
        check_preexisting = False
1076
        check_preexisting = False
1128
1075
        with self.patch_get_charm_url(return_value='cs:trusty/juju-gui-42'):
1077
        with self.patch_resolve(return_value='cs:trusty/juju-gui-42'):
1129
1076
            ref, machine, service_data, unit_data = app.check_environment(
1078
            ref, machine, service_data, unit_data = app.check_environment(
1130
1077
                env, 'my-gui', charm_url, env_type, bootstrap_node_series,
1079
                env, 'my-gui', charm_url, env_type, bootstrap_node_series,
1131
1078
                check_preexisting)
1080
                check_preexisting)
1132
@@ -1089,7 +1091,7 @@
1133
1089
        env_type = 'azure'
1091
        env_type = 'azure'
1134
1090
        bootstrap_node_series = 'trusty'
1092
        bootstrap_node_series = 'trusty'
1135
1091
        check_preexisting = False
1093
        check_preexisting = False
1137
1092
        with self.patch_get_charm_url(return_value='cs:trusty/juju-gui-42'):
1094
        with self.patch_resolve(return_value='cs:trusty/juju-gui-42'):
1138
1093
            _, machine, _, _ = app.check_environment(
1095
            _, machine, _, _ = app.check_environment(
1139
1094
                env, 'my-gui', charm_url, env_type, bootstrap_node_series,
1096
                env, 'my-gui', charm_url, env_type, bootstrap_node_series,
1140
1095
                check_preexisting)
1097
                check_preexisting)
1141
@@ -1103,7 +1105,7 @@
1142
1103
        env_type = 'ec2'
1105
        env_type = 'ec2'
1143
1104
        bootstrap_node_series = 'precise'
1106
        bootstrap_node_series = 'precise'
1144
1105
        check_preexisting = False
1107
        check_preexisting = False
1146
1106
        with self.patch_get_charm_url(side_effect=IOError('boo!')):
1108
        with self.patch_resolve(side_effect=IOError('boo!')):
1147
1107
            ref, machine, service_data, unit_data = app.check_environment(
1109
            ref, machine, service_data, unit_data = app.check_environment(
1148
1108
                env, 'my-gui', charm_url, env_type, bootstrap_node_series,
1110
                env, 'my-gui', charm_url, env_type, bootstrap_node_series,
1149
1109
                check_preexisting)
1111
                check_preexisting)
1150
@@ -1121,7 +1123,7 @@
1151
1121
        env_type = 'ec2'
1123
        env_type = 'ec2'
1152
1122
        bootstrap_node_series = 'saucy'
1124
        bootstrap_node_series = 'saucy'
1153
1123
        check_preexisting = False
1125
        check_preexisting = False
1155
1124
        with self.patch_get_charm_url(side_effect=IOError('boo!')):
1126
        with self.patch_resolve(side_effect=IOError('boo!')):
1156
1125
            ref, machine, service_data, unit_data = app.check_environment(
1127
            ref, machine, service_data, unit_data = app.check_environment(
1157
1126
                env, 'my-gui', charm_url, env_type, bootstrap_node_series,
1128
                env, 'my-gui', charm_url, env_type, bootstrap_node_series,
1158
1127
                check_preexisting)
1129
                check_preexisting)
1159
@@ -1138,13 +1140,13 @@
1160
1138
        env_type = 'ec2'
1140
        env_type = 'ec2'
1161
1139
        bootstrap_node_series = 'trusty'
1141
        bootstrap_node_series = 'trusty'
1162
1140
        check_preexisting = False
1142
        check_preexisting = False
1164
1141
        with self.patch_get_charm_url() as mock_get_charm_url:
1143
        with self.patch_resolve() as mock_resolve:
1165
1142
            ref, machine, service_data, unit_data = app.check_environment(
1144
            ref, machine, service_data, unit_data = app.check_environment(
1166
1143
                env, 'my-gui', charm_url, env_type, bootstrap_node_series,
1145
                env, 'my-gui', charm_url, env_type, bootstrap_node_series,
1167
1144
                check_preexisting)
1146
                check_preexisting)
1169
1145
        # There is no need to call the charmword API if the charm URL is
1147
        # There is no need to call the charm store API if the charm URL is
1170
1146
        # provided by the user.
1148
        # provided by the user.
1172
1147
        self.assertFalse(mock_get_charm_url.called)
1149
        self.assertFalse(mock_resolve.called)
1173
1148
        # The provided charm URL has been correctly returned.
1150
        # The provided charm URL has been correctly returned.
1174
1149
        self.assert_reference_equal(charm_url, ref)
1151
        self.assert_reference_equal(charm_url, ref)
1175
1150
        # Since the provided charm series is trusty, the charm itself can be
1152
        # Since the provided charm series is trusty, the charm itself can be
1176
@@ -1165,13 +1167,13 @@
1177
1165
        env_type = 'ec2'
1167
        env_type = 'ec2'
1178
1166
        bootstrap_node_series = 'precise'
1168
        bootstrap_node_series = 'precise'
1179
1167
        check_preexisting = False
1169
        check_preexisting = False
1181
1168
        with self.patch_get_charm_url() as mock_get_charm_url:
1170
        with self.patch_resolve() as mock_resolve:
1182
1169
            ref, machine, service_data, unit_data = app.check_environment(
1171
            ref, machine, service_data, unit_data = app.check_environment(
1183
1170
                env, 'my-gui', charm_url, env_type, bootstrap_node_series,
1172
                env, 'my-gui', charm_url, env_type, bootstrap_node_series,
1184
1171
                check_preexisting)
1173
                check_preexisting)
1186
1172
        # There is no need to call the charmword API if the charm URL is
1174
        # There is no need to call the charm store API if the charm URL is
1187
1173
        # provided by the user.
1175
        # provided by the user.
1189
1174
        self.assertFalse(mock_get_charm_url.called)
1176
        self.assertFalse(mock_resolve.called)
1190
1175
        # The provided charm URL has been correctly returned.
1177
        # The provided charm URL has been correctly returned.
1191
1176
        self.assert_reference_equal(charm_url, ref)
1178
        self.assert_reference_equal(charm_url, ref)
1192
1177
        # Since the provided charm series is not precise, the charm must be
1179
        # Since the provided charm series is not precise, the charm must be
1193
@@ -1666,7 +1668,9 @@
1194
1666
        # XXX frankban 2015-02-26: remove this test once we get rid of the
1668
        # XXX frankban 2015-02-26: remove this test once we get rid of the
1195
1667
        # charmworld id concept.
1669
        # charmworld id concept.
1196
1668
        env = mock.Mock()
1670
        env = mock.Mock()
1198
1669
        ref = references.Reference.from_charmworld_url('bundle:django/single')
1671
        ref = references.Reference.from_fully_qualified_url(
1199
1672
            'cs:bundle/django-single-42')
1200
1673
        ref.charmworld_id = 'django/single'
1201
1670
        bundle = bundles.Bundle(self.bundle_data, reference=ref)
1674
        bundle = bundles.Bundle(self.bundle_data, reference=ref)
1202
1671
        app.deploy_bundle(env, bundle)
1675
        app.deploy_bundle(env, bundle)
1203
1672
        env.deploy_bundle.assert_called_once_with(
1676
        env.deploy_bundle.assert_called_once_with(
1204
1673
1677
1205
=== added file 'quickstart/tests/test_charmstore.py'
1206
--- quickstart/tests/test_charmstore.py	1970-01-01 00:00:00 +0000
1207
+++ quickstart/tests/test_charmstore.py	2015-03-10 10:19:09 +0000
1208
@@ -0,0 +1,313 @@
1209
1
# This file is part of the Juju Quickstart Plugin, which lets users set up a
1210
2
# Juju environment in very few steps (https://launchpad.net/juju-quickstart).
1211
3
# Copyright (C) 2015 Canonical Ltd.
1212
4
#
1213
5
# This program is free software: you can redistribute it and/or modify it under
1214
6
# the terms of the GNU Affero General Public License version 3, as published by
1215
7
# the Free Software Foundation.
1216
8
#
1217
9
# This program is distributed in the hope that it will be useful, but WITHOUT
1218
10
# ANY WARRANTY; without even the implied warranties of MERCHANTABILITY,
1219
11
# SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
1220
12
# Affero General Public License for more details.
1221
13
#
1222
14
# You should have received a copy of the GNU Affero General Public License
1223
15
# along with this program.  If not, see <http://www.gnu.org/licenses/>.
1224
16
1225
17
"""Tests for the Juju Quickstart charm store communication utilities."""
1226
18
1227
19
from __future__ import unicode_literals
1228
20
1229
21
import unittest
1230
22
1231
23
import json
1232
24
1233
25
from quickstart import (
1234
26
    charmstore,
1235
27
    netutils,
1236
28
    settings,
1237
29
)
1238
30
from quickstart.models import references
1239
31
from quickstart.tests import helpers
1240
32
1241
33
1242
34
class TestNotFoundError(unittest.TestCase):
1243
35
1244
36
    def test_error_message(self):
1245
37
        # The error message can be properly retrieved.
1246
38
        err = charmstore.NotFoundError(b'bad wolf')
1247
39
        self.assertEqual('bad wolf', bytes(err))
1248
40
1249
41
1250
42
class TestGet(helpers.UrlReadTestsMixin, unittest.TestCase):
1251
43
1252
44
    def test_success(self):
1253
45
        # A GET request to the charm store is correctly performed.
1254
46
        with self.patch_urlread(contents='ok') as mock_urlread:
1255
47
            content = charmstore.get('my/path')
1256
48
        self.assertEqual('ok', content)
1257
49
        mock_urlread.assert_called_once_with(
1258
50
            settings.CHARMSTORE_API + 'my/path')
1259
51
1260
52
    def test_success_leading_slash(self):
1261
53
        # The resulting URL is correctly formatted.
1262
54
        with self.patch_urlread() as mock_urlread:
1263
55
            charmstore.get('/path/')
1264
56
        mock_urlread.assert_called_once_with(settings.CHARMSTORE_API + 'path/')
1265
57
1266
58
    def test_io_error(self):
1267
59
        # An IOError is raised if a problem is encountered while connecting to
1268
60
        # the charm store.
1269
61
        with self.patch_urlread(error=IOError('bad wolf')):
1270
62
            with self.assertRaises(IOError) as ctx:
1271
63
                charmstore.get('/')
1272
64
        expected_error = (
1273
65
            'cannot communicate with the charm store at '
1274
66
            '{}: bad wolf'.format(settings.CHARMSTORE_API))
1275
67
        self.assertEqual(expected_error, bytes(ctx.exception))
1276
68
1277
69
    def test_not_found_error(self):
1278
70
        # A charmstore.NotFoundError is raised if the request returns a 404 not
1279
71
        # found response.
1280
72
        with self.patch_urlread(error=netutils.NotFoundError('bad wolf')):
1281
73
            with self.assertRaises(charmstore.NotFoundError) as ctx:
1282
74
                charmstore.get('/no/such')
1283
75
        expected_error = (
1284
76
            'charm store resource not found at '
1285
77
            '{}no/such: bad wolf'.format(settings.CHARMSTORE_API))
1286
78
        self.assertEqual(expected_error, bytes(ctx.exception))
1287
79
1288
80
1289
81
class TestGetReference(helpers.UrlReadTestsMixin, unittest.TestCase):
1290
82
1291
83
    def test_success(self):
1292
84
        # A GET request to the charm store is correctly performed using the
1293
85
        # given charm or bundle reference.
1294
86
        ref = references.Reference.from_jujucharms_url('mediawiki-single')
1295
87
        with self.patch_urlread(contents='hash') as mock_urlread:
1296
88
            content = charmstore.get_reference(ref, '/meta/hash')
1297
89
        self.assertEqual('hash', content)
1298
90
        mock_urlread.assert_called_once_with(
1299
91
            settings.CHARMSTORE_API + 'bundle/mediawiki-single/meta/hash')
1300
92
1301
93
    def test_success_without_leading_slash(self):
1302
94
        # The resulting URL is correctly formatted when the static path does
1303
95
        # not include a leading slash.
1304
96
        ref = references.Reference.from_jujucharms_url('django/trusty/42')
1305
97
        with self.patch_urlread() as mock_urlread:
1306
98
            charmstore.get_reference(ref, 'expand-id')
1307
99
        mock_urlread.assert_called_once_with(
1308
100
            settings.CHARMSTORE_API + 'trusty/django-42/expand-id')
1309
101
1310
102
    def test_io_error(self):
1311
103
        # An IOError is raised if a problem is encountered while connecting to
1312
104
        # the charm store.
1313
105
        ref = references.Reference.from_jujucharms_url('django/trusty')
1314
106
        with self.patch_urlread(error=IOError('bad wolf')):
1315
107
            with self.assertRaises(IOError) as ctx:
1316
108
                charmstore.get_reference(ref, 'meta/id')
1317
109
        expected_error = (
1318
110
            'cannot communicate with the charm store at '
1319
111
            '{}trusty/django/meta/id: '
1320
112
            'bad wolf'.format(settings.CHARMSTORE_API))
1321
113
        self.assertEqual(expected_error, bytes(ctx.exception))
1322
114
1323
115
    def test_not_found_error(self):
1324
116
        # A charmstore.NotFoundError is raised if the reference is not found
1325
117
        # in the charm store.
1326
118
        ref = references.Reference.from_jujucharms_url('django')
1327
119
        with self.patch_urlread(error=netutils.NotFoundError('bad wolf')):
1328
120
            with self.assertRaises(charmstore.NotFoundError) as ctx:
1329
121
                charmstore.get_reference(ref, '/no/such')
1330
122
        expected_error = (
1331
123
            'charm store resource not found at '
1332
124
            '{}bundle/django/no/such: '
1333
125
            'bad wolf'.format(settings.CHARMSTORE_API))
1334
126
        self.assertEqual(expected_error, bytes(ctx.exception))
1335
127
1336
128
1337
129
class TestResolve(helpers.UrlReadTestsMixin, unittest.TestCase):
1338
130
1339
131
    contents = json.dumps({
1340
132
        'Id': 'cs:trusty/juju-gui-42',
1341
133
        'Series': 'trusty',
1342
134
        'Name': 'juju-gui',
1343
135
        'Revision': 42,
1344
136
    })
1345
137
1346
138
    def test_resolved(self):
1347
139
        # The resolved entity id is correctly returned.
1348
140
        with self.patch_urlread(contents=self.contents) as mock_urlread:
1349
141
            entity_id = charmstore.resolve('juju-gui')
1350
142
        self.assertEqual('cs:trusty/juju-gui-42', entity_id)
1351
143
        mock_urlread.assert_called_once_with(
1352
144
            settings.CHARMSTORE_API + 'juju-gui/meta/id')
1353
145
1354
146
    def test_resolved_with_series(self):
1355
147
        # The resolved entity id is correctly returned when the entity series
1356
148
        # is specified.
1357
149
        with self.patch_urlread(contents=self.contents) as mock_urlread:
1358
150
            entity_id = charmstore.resolve('django', series='vivid')
1359
151
        self.assertEqual('cs:trusty/juju-gui-42', entity_id)
1360
152
        mock_urlread.assert_called_once_with(
1361
153
            settings.CHARMSTORE_API + 'vivid/django/meta/id')
1362
154
1363
155
    def test_io_error(self):
1364
156
        # IOErrors are properly propagated.
1365
157
        with self.patch_urlread(error=IOError('bad wolf')):
1366
158
            with self.assertRaises(IOError) as ctx:
1367
159
                charmstore.resolve('django')
1368
160
        expected_error = (
1369
161
            'cannot communicate with the charm store at '
1370
162
            '{}django/meta/id: bad wolf'.format(settings.CHARMSTORE_API))
1371
163
        self.assertEqual(expected_error, bytes(ctx.exception))
1372
164
1373
165
    def test_not_found_error(self):
1374
166
        # Not found errors are properly propagated.
1375
167
        with self.patch_urlread(error=netutils.NotFoundError('bad wolf')):
1376
168
            with self.assertRaises(charmstore.NotFoundError) as ctx:
1377
169
                charmstore.resolve('django', series='trusty')
1378
170
        expected_error = (
1379
171
            'charm store resource not found at '
1380
172
            '{}trusty/django/meta/id: '
1381
173
            'bad wolf'.format(settings.CHARMSTORE_API))
1382
174
        self.assertEqual(expected_error, bytes(ctx.exception))
1383
175
1384
176
    def test_value_error(self):
1385
177
        # A ValueError is raised if the API response is not valid.
1386
178
        contents = json.dumps({'invalid': {}})
1387
179
        with self.patch_urlread(contents=contents):
1388
180
            with self.assertRaises(ValueError) as ctx:
1389
181
                charmstore.resolve('juju-gui', series='trusty')
1390
182
        self.assertEqual(
1391
183
            'unable to resolve entity id trusty/juju-gui',
1392
184
            bytes(ctx.exception))
1393
185
1394
186
1395
187
class TestGetBundleData(
1396
188
        helpers.BundleFileTestsMixin, helpers.UrlReadTestsMixin,
1397
189
        unittest.TestCase):
1398
190
1399
191
    def test_data_retrieved(self):
1400
192
        # The bundle data is correctly retrieved and parsed.
1401
193
        ref = references.Reference.from_jujucharms_url('django/42')
1402
194
        with self.patch_urlread(contents=self.bundle_content) as mock_urlread:
1403
195
            data = charmstore.get_bundle_data(ref)
1404
196
        self.assertEqual(self.bundle_data, data)
1405
197
        mock_urlread.assert_called_once_with(
1406
198
            settings.CHARMSTORE_API + 'bundle/django-42/archive/bundle.yaml')
1407
199
1408
200
    def test_io_error(self):
1409
201
        # IOErrors are properly propagated.
1410
202
        ref = references.Reference.from_jujucharms_url('mediawiki-single')
1411
203
        with self.patch_urlread(error=IOError('bad wolf')):
1412
204
            with self.assertRaises(IOError) as ctx:
1413
205
                charmstore.get_bundle_data(ref)
1414
206
        expected_error = (
1415
207
            'cannot communicate with the charm store at '
1416
208
            '{}bundle/mediawiki-single/archive/bundle.yaml: '
1417
209
            'bad wolf'.format(settings.CHARMSTORE_API))
1418
210
        self.assertEqual(expected_error, bytes(ctx.exception))
1419
211
1420
212
    def test_not_found_error(self):
1421
213
        # Not found errors are properly propagated.
1422
214
        ref = references.Reference.from_jujucharms_url('no-such')
1423
215
        with self.patch_urlread(error=netutils.NotFoundError('bad wolf')):
1424
216
            with self.assertRaises(charmstore.NotFoundError) as ctx:
1425
217
                charmstore.get_bundle_data(ref)
1426
218
        expected_error = (
1427
219
            'charm store resource not found at '
1428
220
            '{}bundle/no-such/archive/bundle.yaml: '
1429
221
            'bad wolf'.format(settings.CHARMSTORE_API))
1430
222
        self.assertEqual(expected_error, bytes(ctx.exception))
1431
223
1432
224
    def test_value_error_invalid_data(self):
1433
225
        # A ValueError is raised if the API response is not valid.
1434
226
        ref = references.Reference.from_jujucharms_url('u/who/django')
1435
227
        with self.patch_urlread(contents='invalid: data:'):
1436
228
            with self.assertRaises(ValueError) as ctx:
1437
229
                charmstore.get_bundle_data(ref)
1438
230
        self.assertIn(
1439
231
            'unable to parse the bundle content', bytes(ctx.exception))
1440
232
1441
233
    def test_value_error_not_a_bundle(self):
1442
234
        # A ValueError is raised if the API response is not valid.
1443
235
        ref = references.Reference.from_jujucharms_url('django/trusty/47')
1444
236
        with self.assertRaises(ValueError) as ctx:
1445
237
            charmstore.get_bundle_data(ref)
1446
238
        self.assertEqual(
1447
239
            'expected a bundle, provided charm cs:trusty/django-47',
1448
240
            bytes(ctx.exception))
1449
241
1450
242
1451
243
class TestGetLegacyBundleData(
1452
244
        helpers.BundleFileTestsMixin, helpers.UrlReadTestsMixin,
1453
245
        unittest.TestCase):
1454
246
1455
247
    def test_data_retrieved(self):
1456
248
        # The legacy bundle data is correctly retrieved and parsed.
1457
249
        ref = references.Reference.from_jujucharms_url('u/who/django/42')
1458
250
        contents = self.legacy_bundle_content
1459
251
        with self.patch_urlread(contents=contents) as mock_urlread:
1460
252
            data = charmstore.get_legacy_bundle_data(ref)
1461
253
        self.assertEqual(self.legacy_bundle_data, data)
1462
254
        mock_urlread.assert_called_once_with(
1463
255
            settings.CHARMSTORE_API +
1464
256
            '~who/bundle/django-42/archive/bundles.yaml.orig')
1465
257
1466
258
    def test_io_error(self):
1467
259
        # IOErrors are properly propagated.
1468
260
        ref = references.Reference.from_jujucharms_url('mediawiki-single')
1469
261
        with self.patch_urlread(error=IOError('bad wolf')):
1470
262
            with self.assertRaises(IOError) as ctx:
1471
263
                charmstore.get_legacy_bundle_data(ref)
1472
264
        expected_error = (
1473
265
            'cannot communicate with the charm store at '
1474
266
            '{}bundle/mediawiki-single/archive/bundles.yaml.orig: '
1475
267
            'bad wolf'.format(settings.CHARMSTORE_API))
1476
268
        self.assertEqual(expected_error, bytes(ctx.exception))
1477
269
1478
270
    def test_not_found_error(self):
1479
271
        # Not found errors are properly propagated.
1480
272
        ref = references.Reference.from_jujucharms_url('no-such')
1481
273
        with self.patch_urlread(error=netutils.NotFoundError('bad wolf')):
1482
274
            with self.assertRaises(charmstore.NotFoundError) as ctx:
1483
275
                charmstore.get_legacy_bundle_data(ref)
1484
276
        expected_error = (
1485
277
            'charm store resource not found at '
1486
278
            '{}bundle/no-such/archive/bundles.yaml.orig: '
1487
279
            'bad wolf'.format(settings.CHARMSTORE_API))
1488
280
        self.assertEqual(expected_error, bytes(ctx.exception))
1489
281
1490
282
    def test_value_error_invalid_data(self):
1491
283
        # A ValueError is raised if the API response is not valid.
1492
284
        ref = references.Reference.from_jujucharms_url('u/who/django')
1493
285
        with self.patch_urlread(contents='invalid: data:'):
1494
286
            with self.assertRaises(ValueError) as ctx:
1495
287
                charmstore.get_legacy_bundle_data(ref)
1496
288
        self.assertIn(
1497
289
            'unable to parse the bundle content', bytes(ctx.exception))
1498
290
1499
291
    def test_value_error_not_a_bundle(self):
1500
292
        # A ValueError is raised if the API response is not valid.
1501
293
        ref = references.Reference.from_jujucharms_url('django/trusty/47')
1502
294
        with self.assertRaises(ValueError) as ctx:
1503
295
            charmstore.get_legacy_bundle_data(ref)
1504
296
        self.assertEqual(
1505
297
            'expected a bundle, provided charm cs:trusty/django-47',
1506
298
            bytes(ctx.exception))
1507
299
1508
300
1509
301
class TestLoadBundleYaml(helpers.BundleFileTestsMixin, unittest.TestCase):
1510
302
1511
303
    def test_valid_bundle_content(self):
1512
304
        # The bundle content is correctly loaded.
1513
305
        data = charmstore.load_bundle_yaml(self.bundle_content)
1514
306
        self.assertEqual(self.bundle_data, data)
1515
307
1516
308
    def test_invalid_bundle_content(self):
1517
309
        # A ValueError is raised if the bundle content is not valid.
1518
310
        with self.assertRaises(ValueError) as ctx:
1519
311
            charmstore.load_bundle_yaml('invalid: content:')
1520
312
        self.assertIn(
1521
313
            'unable to parse the bundle content', bytes(ctx.exception))
1522
0
314
1523
=== modified file 'quickstart/tests/test_netutils.py'
1524
--- quickstart/tests/test_netutils.py	2015-01-12 15:07:51 +0000
1525
+++ quickstart/tests/test_netutils.py	2015-03-10 10:19:09 +0000
1526
@@ -19,7 +19,6 @@
1527
19
from __future__ import unicode_literals
19
from __future__ import unicode_literals
1528
20
20
1529
21
import httplib
21
import httplib
1530
22
import json
1531
23
import socket
22
import socket
1532
24
import unittest
23
import unittest
1533
25
import urllib2
24
import urllib2
1534
@@ -103,42 +102,12 @@
1535
103
            netutils.check_listening('1.2.3.4:17070')
102
            netutils.check_listening('1.2.3.4:17070')
1536
104
103
1537
105
104
1574
106
class TestGetCharmUrl(helpers.UrlReadTestsMixin, unittest.TestCase):
105
class TestNotFoundError(unittest.TestCase):
1575
107
106
1576
108
    def test_charm_url(self):
107
    def test_error_message(self):
1577
109
        # The Juju GUI charm URL is correctly returned.
108
        # The error message can be properly retrieved.
1578
110
        contents = json.dumps({
109
        err = netutils.NotFoundError(b'bad wolf')
1579
111
            'Id': 'cs:trusty/juju-gui-42',
110
        self.assertEqual('bad wolf', bytes(err))
1544
112
            'Series': 'trusty',
1545
113
            'Name': 'juju-gui',
1546
114
            'Revision': 42,
1547
115
        })
1548
116
        with self.patch_urlread(contents=contents) as mock_urlread:
1549
117
            charm_url = netutils.get_charm_url('trusty')
1550
118
        self.assertEqual('cs:trusty/juju-gui-42', charm_url)
1551
119
        mock_urlread.assert_called_once_with(
1552
120
            'https://api.jujucharms.com/charmstore/v4/trusty/juju-gui/meta/id')
1553
121
1554
122
    def test_io_error(self):
1555
123
        # IOErrors are properly propagated.
1556
124
        with self.patch_urlread(error=True) as mock_urlread:
1557
125
            with self.assertRaises(IOError) as context_manager:
1558
126
                netutils.get_charm_url('precise')
1559
127
        mock_urlread.assert_called_once_with(
1560
128
            'https://api.jujucharms.com/charmstore/v4/precise/juju-gui/meta/id'
1561
129
        )
1562
130
        self.assertEqual('bad wolf', bytes(context_manager.exception))
1563
131
1564
132
    def test_value_error(self):
1565
133
        # A ValueError is raised if the API response is not valid.
1566
134
        contents = json.dumps({'invalid': {}})
1567
135
        with self.patch_urlread(contents=contents) as mock_urlread:
1568
136
            with self.assertRaises(ValueError) as context_manager:
1569
137
                netutils.get_charm_url('trusty')
1570
138
        mock_urlread.assert_called_once_with(
1571
139
            'https://api.jujucharms.com/charmstore/v4/trusty/juju-gui/meta/id')
1572
140
        self.assertEqual(
1573
141
            'unable to find the charm URL', bytes(context_manager.exception))
1580
142
111
1581
143
112
1582
144
class TestUrlread(unittest.TestCase):
113
class TestUrlread(unittest.TestCase):
1583
@@ -191,7 +160,14 @@
1584
191
        self.assertIsInstance(contents, unicode)
160
        self.assertIsInstance(contents, unicode)
1585
192
        mock_urlopen.assert_called_once_with('http://example.com/path/')
161
        mock_urlopen.assert_called_once_with('http://example.com/path/')
1586
193
162
1588
194
    def test_errors(self):
163
    def test_logging(self):
1589
164
        # The request URL is properly logged.
1590
165
        expected_log = 'sending HTTP GET request to http://example.com/path/'
1591
166
        with helpers.assert_logs([expected_log], level='debug'):
1592
167
            with self.patch_urlopen():
1593
168
                netutils.urlread('http://example.com/path/')
1594
169
1595
170
    def test_io_errors(self):
1596
195
        # An IOError is raised if an error occurs connecting to the API.
171
        # An IOError is raised if an error occurs connecting to the API.
1597
196
        errors = {
172
        errors = {
1598
197
            'httplib HTTPException': httplib.HTTPException,
173
            'httplib HTTPException': httplib.HTTPException,
1599
@@ -201,7 +177,16 @@
1600
201
        for message, exception_class in errors.items():
177
        for message, exception_class in errors.items():
1601
202
            exception = exception_class(message)
178
            exception = exception_class(message)
1602
203
            with self.patch_urlopen(error=exception) as mock_urlopen:
179
            with self.patch_urlopen(error=exception) as mock_urlopen:
1604
204
                with self.assertRaises(IOError) as context_manager:
180
                with self.assertRaises(IOError) as ctx:
1605
205
                    netutils.urlread('http://example.com/path/')
181
                    netutils.urlread('http://example.com/path/')
1606
206
            mock_urlopen.assert_called_once_with('http://example.com/path/')
182
            mock_urlopen.assert_called_once_with('http://example.com/path/')
1608
207
            self.assertEqual(message, bytes(context_manager.exception))
183
            self.assertEqual(message, bytes(ctx.exception))
1609
184
1610
185
    def test_not_found_error(self):
1611
186
        # A netutils.NotFoundError is raised if the request returns a 404 not
1612
187
        # found response.
1613
188
        exception = urllib2.HTTPError('url', 404, 'bad wolf', None, None)
1614
189
        with self.patch_urlopen(error=exception):
1615
190
            with self.assertRaises(netutils.NotFoundError) as ctx:
1616
191
                netutils.urlread('http://example.com/path/')
1617
192
        self.assertEqual('HTTP Error 404: bad wolf', bytes(ctx.exception))
1618
208
193
1619
=== modified file 'quickstart/utils.py'
1620
--- quickstart/utils.py	2015-02-09 12:34:33 +0000
1621
+++ quickstart/utils.py	2015-03-10 10:19:09 +0000
1622
@@ -88,7 +88,7 @@
1623
88
    The banner is returned as a string, e.g.:
88
    The banner is returned as a string, e.g.:
1624
89
89
1625
90
        # This file has been generated by juju quickstart v0.42.0
90
        # This file has been generated by juju quickstart v0.42.0
1627
91
        # in date 2013-12-31 23:59:00 UTC.
91
        # at 2013-12-31 23:59:00 UTC.
1628
92
    """
92
    """
1629
93
    now = datetime.datetime.utcnow()
93
    now = datetime.datetime.utcnow()
1630
94
    formatted_date = now.isoformat(sep=b' ').split('.')[0]
94
    formatted_date = now.isoformat(sep=b' ').split('.')[0]
Status:	Merged
Merged at revision:	123
Proposed branch:	lp:~frankban/juju-quickstart/old-style-bundles-regression
Merge into:	lp:juju-quickstart
Diff against target:	1630 lines (+868/-269) 15 files modified quickstart/__init__.py (+1/-1) quickstart/app.py (+4/-2) quickstart/charmstore.py (+161/-0) quickstart/manage.py (+5/-5) quickstart/models/bundles.py (+136/-59) quickstart/models/references.py (+9/-48) quickstart/netutils.py (+9/-18) quickstart/settings.py (+2/-2) quickstart/tests/helpers.py (+5/-4) quickstart/tests/models/test_bundles.py (+166/-25) quickstart/tests/models/test_references.py (+0/-37) quickstart/tests/test_app.py (+31/-27) quickstart/tests/test_charmstore.py (+313/-0) quickstart/tests/test_netutils.py (+25/-40) quickstart/utils.py (+1/-1)
To merge this branch:	bzr merge lp:~frankban/juju-quickstart/old-style-bundles-regression
Related bugs:	Link a bug report
Reviewer	Review Type	Date Requested	Status
Juju GUI Hackers		2015-03-09	Pending
Review via email: mp+252353@code.launchpad.net