1
=== modified file 'quickstart/models/envs.py'
2
--- quickstart/models/envs.py	2013-12-11 10:47:00 +0000
3
+++ quickstart/models/envs.py	2013-12-16 12:11:28 +0000
4
@@ -75,12 +75,6 @@
5
75
of the environment being modified. If None is passed, that means we are adding
75
of the environment being modified. If None is passed, that means we are adding
6
76
a new environment.
76
a new environment.
7
77
77
8
78
XXX frankban 13-12-08: implement the missing functions:
9
79
    - get_env_type_db()
10
80
    - get_env_metadata(env_type_db, env_data)
11
81
    - map_fields_to_env_data(env_metadata, env_data)
12
82
    - validate(env_metadata, env_data)
13
83
    - normalize(env_metadata, env_data)
14
84
XXX frankban 13-12-08: remove the parse_env_file function: this can be done
78
XXX frankban 13-12-08: remove the parse_env_file function: this can be done
15
85
    when activating models code in manage.py.
79
    when activating models code in manage.py.
16
86
"""
80
"""
17
@@ -96,8 +90,10 @@
18
96
90
19
97
from quickstart import (
91
from quickstart import (
20
98
    serializers,
92
    serializers,
21
93
    settings,
22
99
    utils,
94
    utils,
23
100
)
95
)
24
96
from quickstart.models import fields
25
101
97
26
102
98
27
103
# Compile the regular expression used to parse the "juju switch" output.
99
# Compile the regular expression used to parse the "juju switch" output.
28
@@ -300,6 +296,219 @@
29
300
        del env_db['default']
296
        del env_db['default']
30
301
297
31
302
298
32
299
def get_env_type_db():
33
300
    """Return the environments meta information based on provider types.
34
301
35
302
    The env_type_db describes Juju environments based on their provider type.
36
303
37
304
    The returned data is a dictionary mapping provider type names to meta
38
305
    information. A provider named "__fallback__" is also included and can be
39
306
    used to minimally handle environments whose type is not currently supported
40
307
    by quickstart.
41
308
    """
42
309
    # Define a collection of fields shared by many environment types.
43
310
    provider_field = fields.StringField(
44
311
        'type', label='provider type', required=True, readonly=True,
45
312
        help='the provider type enabled for this environment')
46
313
    name_field = fields.StringField(
47
314
        'name', label='environment name', required=True,
48
315
        help='the environment name to use with Juju (arbitrary string)')
49
316
    admin_secret_field = fields.AutoGeneratedPasswordField(
50
317
        'admin-secret', label='admin secret', required=True,
51
318
        help='the password used to authenticate to the environment')
52
319
    default_series_field = fields.ChoiceField(
53
320
        'default-series', choices=settings.JUJU_DEFAULT_SERIES,
54
321
        label='default series', required=False,
55
322
        help='the default Ubuntu series to use for the bootstrap node')
56
323
    is_default_field = fields.BoolField(
57
324
        'is-default', help='make this the default environment', required=True)
58
325
    # Define data structures used as part of the metadata below.
59
326
    ec2_regions = (
60
327
        'ap-northeast-1', 'ap-southeast-1', 'ap-southeast-2',
61
328
        'eu-west-1', 'sa-east-1',
62
329
        'us-east-1', 'us-west-1', 'us-west-2',
63
330
    )
64
331
    # Define the env_type_db dictionary: this is done inside this function in
65
332
    # order to avoid instantiating fields at import time.
66
333
    env_type_db = {
67
334
        'ec2': {
68
335
            'description': (
69
336
                'The ec2 provider enable you to run Juju on the EC2 cloud. '
70
337
                'This process requires you to have an Amazon Web Services '
71
338
                '(AWS) account. If you have not signed up for one yet, it '
72
339
                'can obtained at http://aws.amazon.com. '
73
340
                'See https://juju.ubuntu.com/docs/config-aws.html for more '
74
341
                'details on the ec2 provider configuration.'
75
342
            ),
76
343
            'fields': (
77
344
                provider_field,
78
345
                name_field,
79
346
                admin_secret_field,
80
347
                default_series_field,
81
348
                fields.PasswordField(
82
349
                    'access-key', label='access key', required=True,
83
350
                    help='the access key to use to authenticate to AWS'),
84
351
                fields.PasswordField(
85
352
                    'secret-key', label='secret key', required=True,
86
353
                    help='the secret key to use to authenticate to AWS'),
87
354
                fields.AutoGeneratedStringField(
88
355
                    'control-bucket', label='control bucket', required=True,
89
356
                    help='the globally unique S3 bucket name'),
90
357
                fields.ChoiceField(
91
358
                    'region', choices=ec2_regions, default='us-east-1',
92
359
                    label='region', required=False,
93
360
                    help='the ec2 region to use'),
94
361
                is_default_field,
95
362
            ),
96
363
        },
97
364
        'local': {
98
365
            'description': (
99
366
                'The LXC local provider enables you to run Juju on a single '
100
367
                'system like your local computer or a single server. '
101
368
                'See https://juju.ubuntu.com/docs/config-LXC.html for more '
102
369
                'details on the local provider configuration.'
103
370
            ),
104
371
            'fields': (
105
372
                provider_field,
106
373
                name_field,
107
374
                admin_secret_field,
108
375
                default_series_field,
109
376
                fields.StringField(
110
377
                    'root-dir', label='root dir', required=False,
111
378
                    default='~/.juju/local',
112
379
                    help='the directory that is used for the storage files'),
113
380
                fields.IntField(
114
381
                    'storage-port', min_value=1, max_value=65535,
115
382
                    label='storage port', required=False, default=8040,
116
383
                    help='override if you have multiple local providers, '
117
384
                         'or if the default port is used by another program'),
118
385
                fields.IntField(
119
386
                    'shared-storage-port', min_value=1, max_value=65535,
120
387
                    label='shared storage port', required=False, default=8041,
121
388
                    help='override if you have multiple local providers, '
122
389
                         'or if the default port is used by another program'),
123
390
                fields.StringField(
124
391
                    'network-bridge', label='network bridge', required=False,
125
392
                    default='lxcbr0', help='the LXC bridge interface to use'),
126
393
                is_default_field,
127
394
            ),
128
395
        },
129
396
        '__fallback__': {
130
397
            'description': (
131
398
                'This provider type is not supported by quickstart. '
132
399
                'See https://juju.ubuntu.com/docs/getting-started.html for '
133
400
                'a description of how to get started with Juju.'
134
401
            ),
135
402
            'fields': (
136
403
                provider_field,
137
404
                name_field,
138
405
                admin_secret_field,
139
406
                default_series_field,
140
407
                is_default_field,
141
408
            ),
142
409
        }
143
410
    }
144
411
    return env_type_db
145
412
146
413
147
414
def get_supported_env_types(env_type_db):
148
415
    """Return a list of supported provider type names."""
149
416
    return [env_type for env_type in env_type_db if env_type != '__fallback__']
150
417
151
418
152
419
def get_env_metadata(env_type_db, env_data):
153
420
    """Return the meta information (fields, description) suitable for env_data.
154
421
155
422
    Use the given env_type_db to retrieve the metadata corresponding to the
156
423
    environment type included in env_data.
157
424
158
425
    The resulting metadata can be used to parse/validate environments or to
159
426
    enrich the user experience e.g. by providing additional information about
160
427
    the fields composing a specific environment type, or about the environment
161
428
    type itself.
162
429
    """
163
430
    env_type = env_data.get('type', '__fallback__')
164
431
    return env_type_db.get(env_type, env_type_db['__fallback__'])
165
432
166
433
167
434
def map_fields_to_env_data(env_metadata, env_data):
168
435
    """Return a list of (field, value) tuples.
169
436
170
437
    Each tuple stores a field (instance of fields.Field or its subclasses)
171
438
    describing a specific environment key in env_data, and the corresponding
172
439
    value in env_data.
173
440
174
441
    If extraneous keys (not described by env_metadata) are found in env_data,
175
442
    then those keys are assigned a generic default field (fields.Field).
176
443
    """
177
444
    data = copy.deepcopy(env_data)
178
445
    # Start building a list of (field, value) pairs preserving fields order.
179
446
    field_value_pairs = [
180
447
        (field, data.pop(field.name, None))
181
448
        for field in env_metadata['fields']
182
449
    ]
183
450
    # Add the remaining (unexpected) pairs using the base field type.
184
451
    help = 'this field is unrecognized and can be safely removed'
185
452
    field_value_pairs.extend(
186
453
        (fields.Field(key, help=help, required=False), value)
187
454
        for key, value in data.items()
188
455
    )
189
456
    return field_value_pairs
190
457
191
458
192
459
def validate(env_metadata, env_data):
193
460
    """Validate values in env_data.
194
461
195
462
    Return a dictionary of errors mapping field names to error messages.
196
463
    If the environment is valid, return an empty dictionary.
197
464
    """
198
465
    errors = {}
199
466
    for field, value in map_fields_to_env_data(env_metadata, env_data):
200
467
        try:
201
468
            field.validate(value)
202
469
        except ValueError as err:
203
470
            errors[field.name] = bytes(err).decode('utf-8')
204
471
    return errors
205
472
206
473
207
474
def normalize(env_metadata, env_data):
208
475
    """Normalize the values in env_data.
209
476
210
477
    Return a new env_data containing the normalized values.
211
478
    This function assumes env_data contains valid values.
212
479
    """
213
480
    normalized_env_data = {}
214
481
    for field, value in map_fields_to_env_data(env_metadata, env_data):
215
482
        value = field.normalize(value)
216
483
        # Only include the key/value pair if the corresponding field is
217
484
        # required or the value is set.
218
485
        if field.required or value is not None:
219
486
            normalized_env_data[field.name] = value
220
487
    return normalized_env_data
221
488
222
489
223
490
def get_env_short_description(env_data):
224
491
    """Return a short description of the given env_data.
225
492
226
493
    The given env_data must include at least the "name" and "is-default" keys.
227
494
228
495
    The description is like the following:
229
496
        "aws (type: ec2, default)"  # Default ec2 environment.
230
497
        "lxc (type: local)"  # Non-default local environment.
231
498
        "unknown"  # An environment with no type set.
232
499
    """
233
500
    info_parts = []
234
501
    env_type = env_data.get('type')
235
502
    if env_type is not None:
236
503
        info_parts.append('type: {}'.format(env_type))
237
504
    if env_data['is-default']:
238
505
        info_parts.append('default')
239
506
    info = ''
240
507
    if info_parts:
241
508
        info = ' ({})'.format(', '.join(info_parts))
242
509
    return env_data['name'] + info
243
510
244
511
245
303
def parse_env_file(env_file, env_name):
512
def parse_env_file(env_file, env_name):
246
304
    """Parse the provided Juju environments.yaml file.
513
    """Parse the provided Juju environments.yaml file.
247
305
514
248
306
515
249
=== modified file 'quickstart/models/fields.py'
250
--- quickstart/models/fields.py	2013-12-11 17:55:31 +0000
251
+++ quickstart/models/fields.py	2013-12-16 12:11:28 +0000
252
@@ -26,8 +26,6 @@
253
26
validate the whole environment on a per-field basis.
26
validate the whole environment on a per-field basis.
254
27
27
255
28
See quickstart.models.envs.get_env_type_db for an example of how this works.
28
See quickstart.models.envs.get_env_type_db for an example of how this works.
256
29
XXX frankban 13-12-11:
257
30
    the function above will be implemented in the next branch.
258
31
"""
29
"""
259
32
30
260
33
from __future__ import unicode_literals
31
from __future__ import unicode_literals
261
@@ -57,6 +55,9 @@
262
57
          (e.g. "Admin Secret");
55
          (e.g. "Admin Secret");
263
58
        - help: help text associated with this field
56
        - help: help text associated with this field
264
59
          (e.g. "the password you use for authenticating");
57
          (e.g. "the password you use for authenticating");
265
58
        - default: the default value if the value is not set (None). This is
266
59
          used only in the validation process, and can be used by view code
267
60
          to display the default value for a field;
268
60
        - required: True if this is a required field, False otherwise;
61
        - required: True if this is a required field, False otherwise;
269
61
        - readonly: True if the associated value must be considered immutable.
62
        - readonly: True if the associated value must be considered immutable.
270
62
63
271
@@ -64,7 +65,8 @@
272
64
        - display(value): how the value should be displayed by views
65
        - display(value): how the value should be displayed by views
273
65
          (usually just the value itself as a unicode string is returned);
66
          (usually just the value itself as a unicode string is returned);
274
66
        - normalize(value): return the normalized value, e.g. a string field
67
        - normalize(value): return the normalized value, e.g. a string field
276
67
          might return a stripped version of the input value;
68
          might return a stripped version of the input value. Returning None
277
69
          means the value for that field is unset;
278
68
        - validate(value): validate the given value, raising a ValueError if
70
        - validate(value): validate the given value, raising a ValueError if
279
69
          the input value is not valid, returning None otherwise;
71
          the input value is not valid, returning None otherwise;
280
70
        - generate(): this optional method indicates the value associated with
72
        - generate(): this optional method indicates the value associated with
281
@@ -79,11 +81,13 @@
282
79
    field_type = None
81
    field_type = None
283
80
82
284
81
    def __init__(
83
    def __init__(
286
82
            self, name, label=None, help='', required=False, readonly=False):
84
            self, name, label=None, help='', default=None, required=False,
287
85
            readonly=False):
288
83
        """Initialize a field. Only the name identifier is required."""
86
        """Initialize a field. Only the name identifier is required."""
289
84
        self.name = name
87
        self.name = name
290
85
        self.label = name if label is None else label
88
        self.label = name if label is None else label
291
86
        self.help = help
89
        self.help = help
292
90
        self.default = default
293
87
        self.required = required
91
        self.required = required
294
88
        self.readonly = readonly
92
        self.readonly = readonly
295
89
93
296
@@ -105,10 +109,10 @@
297
105
    def validate(self, value):
109
    def validate(self, value):
298
106
        """Validate the given value.
110
        """Validate the given value.
299
107
111
302
108
        Return a possibly normalized version of the value.
112
        Raise a ValueError if the given value is required, it is not set and
303
109
        Raise a ValueError if the given value is not valid.
113
        no default is provided.
304
110
        """
114
        """
306
111
        if self.required and not value:
115
        if self.required and (value is None) and (self.default is None):
307
112
            msg = 'a value is required for the {} field'.format(self.label)
116
            msg = 'a value is required for the {} field'.format(self.label)
308
113
            raise ValueError(msg.encode('utf-8'))
117
            raise ValueError(msg.encode('utf-8'))
309
114
118
310
@@ -117,10 +121,10 @@
311
117
    """Values associated with this field must be strings."""
121
    """Values associated with this field must be strings."""
312
118
122
313
119
    def normalize(self, value):
123
    def normalize(self, value):
315
120
        """Strip the string."""
124
        """Strip the string. Return None if the value is not set."""
316
121
        if value is None:
125
        if value is None:
319
122
            return ''
126
            return None
320
123
        return value.strip()
127
        return value.strip() or None
321
124
128
322
125
    def validate(self, value):
129
    def validate(self, value):
323
126
        """Check that the value is a string."""
130
        """Check that the value is a string."""
324
@@ -128,9 +132,7 @@
325
128
            # Assume view code always works with unicode strings.
132
            # Assume view code always works with unicode strings.
326
129
            msg = 'the {} field requires a string value'.format(self.label)
133
            msg = 'the {} field requires a string value'.format(self.label)
327
130
            raise ValueError(msg.encode('utf-8'))
134
            raise ValueError(msg.encode('utf-8'))
331
131
        value = self.normalize(value)
135
        super(StringField, self).validate(self.normalize(value))
329
132
        # The parent field ensures the value is set if required.
330
133
        super(StringField, self).validate(value)
332
134
136
333
135
137
334
136
class IntField(Field):
138
class IntField(Field):
335
@@ -178,11 +180,9 @@
336
178
        except (TypeError, ValueError):
180
        except (TypeError, ValueError):
337
179
            raise ValueError(msg.encode('utf-8'))
181
            raise ValueError(msg.encode('utf-8'))
338
180
        # Ensure the value is set if required.
182
        # Ensure the value is set if required.
339
183
        super(IntField, self).validate(value)
340
181
        if value is None:
184
        if value is None:
345
182
            if self.required:
185
            return
342
183
                msg = 'a value is required for the {} field'.format(self.label)
343
184
                raise ValueError(msg.encode('utf-8'))
344
185
            return value
346
186
        # Ensure the value is in the given range.
186
        # Ensure the value is in the given range.
347
187
        min_value = self.min_value
187
        min_value = self.min_value
348
188
        max_value = self.max_value
188
        max_value = self.max_value
349
@@ -206,41 +206,23 @@
350
206
206
351
207
    field_type = 'bool'
207
    field_type = 'bool'
352
208
208
355
209
    def __init__(self, name, default=False, **kwargs):
209
    def __init__(self, name, allow_mixed=True, **kwargs):
356
210
        """Initialize the boolean field.
210
        """Add the allow_mixed keyword argument.
357
211
211
360
212
        It is possible to pass a "default" keyword argument in order to specify
212
        By default allow_mixed is True, and that means the field can be in a
361
213
        the default value (True or False) to use if the value is unset (None).
213
        "not set" state (None). This is relevant for validation and view code.
362
214
        """
214
        """
363
215
        super(BoolField, self).__init__(name, **kwargs)
215
        super(BoolField, self).__init__(name, **kwargs)
372
216
        self.default = default
216
        self.allow_mixed = allow_mixed
365
217
366
218
    def normalize(self, value):
367
219
        """Return the default value if the given one is None (unset)."""
368
220
        if value is None:
369
221
            self.validate(self.default)
370
222
            value = self.default
371
223
        return value
373
224
217
374
225
    def validate(self, value):
218
    def validate(self, value):
378
226
        """Check that the value is a boolean."""
219
        """Check that the value, if set, is a boolean."""
379
227
        value = self.normalize(value)
220
        types = (bool, type(None)) if self.allow_mixed else (bool,)
380
228
        if not isinstance(value, bool):
221
        if not isinstance(value, types):
381
229
            msg = 'the {} field requires a boolean value'.format(self.label)
222
            msg = 'the {} field requires a boolean value'.format(self.label)
382
230
            raise ValueError(msg.encode('utf-8'))
223
            raise ValueError(msg.encode('utf-8'))
383
231
224
384
232
225
385
233
class AutoGeneratedStringField(StringField):
386
234
    """Can automatically generate string values if they are not provided.
387
235
388
236
    Subclasses can override the generate method to return customized values.
389
237
    """
390
238
391
239
    def generate(self):
392
240
        """Generate a uuid valid value."""
393
241
        return '{}-{}'.format(self.name[:3], uuid.uuid4().hex)
394
242
395
243
396
244
class ChoiceField(StringField):
226
class ChoiceField(StringField):
397
245
    """A string field whose value must be included in the given choices."""
227
    """A string field whose value must be included in the given choices."""
398
246
228
399
@@ -258,8 +240,11 @@
400
258
        super(ChoiceField, self).validate(value)
240
        super(ChoiceField, self).validate(value)
401
259
        value = self.normalize(value)
241
        value = self.normalize(value)
402
260
        choices = list(self.choices)
242
        choices = list(self.choices)
405
261
        if not self.required:
243
        # If the field is not required, or if a default value is set, None is
406
262
            choices.append('')
244
        # added to the list of valid choices, so that a "not set" value is
407
245
        # accepted.
408
246
        if (not self.required) or (self.default is not None):
409
247
            choices.append(None)
410
263
        if value not in choices:
248
        if value not in choices:
411
264
            msg = 'the {} requires the value to be one of the following: {}'
249
            msg = 'the {} requires the value to be one of the following: {}'
412
265
            raise ValueError(
250
            raise ValueError(
413
@@ -267,6 +252,17 @@
414
267
            )
252
            )
415
268
253
416
269
254
417
255
class AutoGeneratedStringField(StringField):
418
256
    """Can automatically generate string values if they are not provided.
419
257
420
258
    Subclasses can override the generate method to return customized values.
421
259
    """
422
260
423
261
    def generate(self):
424
262
        """Generate a uuid valid value."""
425
263
        return '{}-{}'.format(self.name[:3], uuid.uuid4().hex)
426
264
427
265
428
270
class PasswordField(StringField):
266
class PasswordField(StringField):
429
271
    """Assume values associated with this field represent sensible data."""
267
    """Assume values associated with this field represent sensible data."""
430
272
268
431
273
269
432
=== modified file 'quickstart/tests/models/test_envs.py'
433
--- quickstart/tests/models/test_envs.py	2013-12-10 14:37:58 +0000
434
+++ quickstart/tests/models/test_envs.py	2013-12-16 12:11:28 +0000
435
@@ -18,14 +18,19 @@
436
18
18
437
19
from __future__ import unicode_literals
19
from __future__ import unicode_literals
438
20
20
439
21
import collections
440
21
import copy
22
import copy
441
23
import functools
442
22
import os
24
import os
443
23
import unittest
25
import unittest
444
24
26
445
25
import mock
27
import mock
446
26
import yaml
28
import yaml
447
27
29
449
28
from quickstart.models import envs
30
from quickstart.models import (
450
31
    envs,
451
32
    fields,
452
33
)
453
29
from quickstart.tests import helpers
34
from quickstart.tests import helpers
454
30
35
455
31
36
456
@@ -464,6 +469,385 @@
457
464
        self.assertNotIn('default', self.env_db)
469
        self.assertNotIn('default', self.env_db)
458
465
470
459
466
471
460
472
class TestGetEnvTypeDb(unittest.TestCase):
461
473
462
474
    def setUp(self):
463
475
        self.env_type_db = envs.get_env_type_db()
464
476
465
477
    def assert_fields(self, expected, env_metadata):
466
478
        """Ensure the expected fields are defined as part of env_metadata."""
467
479
        obtained = [field.name for field in env_metadata['fields']]
468
480
        self.assertEqual(expected, obtained)
469
481
470
482
    def assert_required_fields(self, expected, env_metadata):
471
483
        """Ensure the expected required fields are included in env_metadata."""
472
484
        obtained = [
473
485
            field.name for field in env_metadata['fields'] if field.required
474
486
        ]
475
487
        self.assertEqual(expected, obtained)
476
488
477
489
    def test_required_metadata(self):
478
490
        # The returned data includes the required env_metadata for each
479
491
        # provider type key.
480
492
        self.assertNotEqual(0, len(self.env_type_db))
481
493
        for provider_type, env_metadata in self.env_type_db.items():
482
494
            # Check the description metadata.
483
495
            self.assertIn('description', env_metadata, provider_type)
484
496
            self.assertIsInstance(
485
497
                env_metadata['description'], unicode, provider_type)
486
498
            # Check the fields metadata.
487
499
            self.assertIn('fields', env_metadata)
488
500
            self.assertIsInstance(
489
501
                env_metadata['fields'], collections.Iterable, provider_type)
490
502
491
503
    def test_fallback(self):
492
504
        # A fallback provider type is included.
493
505
        self.assertIn('__fallback__', self.env_type_db)
494
506
        env_metadata = self.env_type_db['__fallback__']
495
507
        expected = [
496
508
            'type', 'name', 'admin-secret', 'default-series', 'is-default']
497
509
        expected_required = ['type', 'name', 'admin-secret', 'is-default']
498
510
        self.assert_fields(expected, env_metadata)
499
511
        self.assert_required_fields(expected_required, env_metadata)
500
512
501
513
    def test_local_environment(self):
502
514
        # The local environment metadata includes the expected fields.
503
515
        self.assertIn('local', self.env_type_db)
504
516
        env_metadata = self.env_type_db['local']
505
517
        expected = [
506
518
            'type', 'name', 'admin-secret', 'default-series', 'root-dir',
507
519
            'storage-port', 'shared-storage-port', 'network-bridge',
508
520
            'is-default']
509
521
        expected_required = ['type', 'name', 'admin-secret', 'is-default']
510
522
        self.assert_fields(expected, env_metadata)
511
523
        self.assert_required_fields(expected_required, env_metadata)
512
524
513
525
    def test_ec2_environment(self):
514
526
        # The ec2 environment metadata includes the expected fields.
515
527
        self.assertIn('ec2', self.env_type_db)
516
528
        env_metadata = self.env_type_db['ec2']
517
529
        expected = [
518
530
            'type', 'name', 'admin-secret', 'default-series', 'access-key',
519
531
            'secret-key', 'control-bucket', 'region', 'is-default']
520
532
        expected_required = [
521
533
            'type', 'name', 'admin-secret', 'access-key', 'secret-key',
522
534
            'control-bucket', 'is-default']
523
535
        self.assert_fields(expected, env_metadata)
524
536
        self.assert_required_fields(expected_required, env_metadata)
525
537
526
538
527
539
class TestGetSupportedEnvTypes(unittest.TestCase):
528
540
529
541
    def test_env_types(self):
530
542
        # All the supported env_types but the fallback one are returned.
531
543
        env_type_db = envs.get_env_type_db()
532
544
        expected = set(env_type_db)
533
545
        expected.remove('__fallback__')
534
546
        supported_env_types = envs.get_supported_env_types(env_type_db)
535
547
        obtained = set(supported_env_types)
536
548
        self.assertEqual(len(obtained), len(supported_env_types))
537
549
        self.assertEqual(expected, obtained)
538
550
539
551
540
552
class TestGetEnvMetadata(unittest.TestCase):
541
553
542
554
    def setUp(self):
543
555
        self.env_type_db = envs.get_env_type_db()
544
556
545
557
    def test_supported_environment(self):
546
558
        # The metadata for a supported environment is properly returned.
547
559
        env_data = {'type': 'local'}
548
560
        env_metadata = envs.get_env_metadata(self.env_type_db, env_data)
549
561
        self.assertEqual(self.env_type_db['local'], env_metadata)
550
562
551
563
    def test_unsupported_environment(self):
552
564
        # The metadata for an unsupported environment is properly returned.
553
565
        env_data = {'type': 'no-such'}
554
566
        env_metadata = envs.get_env_metadata(self.env_type_db, env_data)
555
567
        self.assertEqual(self.env_type_db['__fallback__'], env_metadata)
556
568
557
569
    def test_without_type(self):
558
570
        # The fallback metadata is also used when the env_data does not include
559
571
        # the provider type.
560
572
        env_metadata = envs.get_env_metadata(self.env_type_db, {})
561
573
        self.assertEqual(self.env_type_db['__fallback__'], env_metadata)
562
574
563
575
564
576
class TestMapFieldsToEnvData(unittest.TestCase):
565
577
566
578
    def setUp(self):
567
579
        env_type_db = envs.get_env_type_db()
568
580
        self.get_meta = functools.partial(envs.get_env_metadata, env_type_db)
569
581
570
582
    def assert_name_value_pairs(self, expected, env_data):
571
583
        """Ensure the expected field name/value pairs are included in env_data.
572
584
        """
573
585
        pairs = envs.map_fields_to_env_data(self.get_meta(env_data), env_data)
574
586
        obtained = [(field.name, value) for field, value in pairs]
575
587
        self.assertEqual(expected, obtained)
576
588
577
589
    def make_valid_pairs(self):
578
590
        """Create and return a list of valid (field name, value) pairs."""
579
591
        return [
580
592
            ('type', 'local'),
581
593
            ('name', 'lxc'),
582
594
            ('admin-secret', 'Secret!'),
583
595
            ('default-series', 'saucy'),
584
596
            ('root-dir', '/my/juju/local/'),
585
597
            ('storage-port', 4242),
586
598
            ('shared-storage-port', 4747),
587
599
            ('network-bridge', 'lxcbr1'),
588
600
            ('is-default', True),
589
601
        ]
590
602
591
603
    def test_valid_env_data(self):
592
604
        # The field/value pairs are correctly returned.
593
605
        expected = self.make_valid_pairs()
594
606
        env_data = dict(expected)
595
607
        self.assert_name_value_pairs(expected, env_data)
596
608
597
609
    def test_missing_pairs(self):
598
610
        # None values are returned if a defined field is missing in env_data.
599
611
        expected = [
600
612
            ('type', 'local'),
601
613
            ('name', 'lxc'),
602
614
            ('admin-secret', None),
603
615
            ('default-series', None),
604
616
            ('root-dir', None),
605
617
            ('storage-port', None),
606
618
            ('shared-storage-port', None),
607
619
            ('network-bridge', None),
608
620
            ('is-default', None),
609
621
        ]
610
622
        env_data = {'type': 'local', 'name': 'lxc'}
611
623
        self.assert_name_value_pairs(expected, env_data)
612
624
613
625
    def test_unexpected_pairs(self):
614
626
        # Additional unexpected field/value pairs are returned as well.
615
627
        expected_pairs = self.make_valid_pairs()
616
628
        unexpected_pairs = [
617
629
            ('registry', 'USS Enterprise (NCC-1701-D)'),
618
630
            ('class', 'Galaxy'),
619
631
            ('years-of-service', 8),
620
632
            ('crashed', True),
621
633
            ('cloaking-device', None),
622
634
        ]
623
635
        env_data = dict(expected_pairs + unexpected_pairs)
624
636
        pairs = envs.map_fields_to_env_data(self.get_meta(env_data), env_data)
625
637
        # The expected fields are correctly returned.
626
638
        mapped_pairs = [
627
639
            (field.name, value) for field, value in pairs[:len(expected_pairs)]
628
640
        ]
629
641
        self.assertEqual(expected_pairs, mapped_pairs)
630
642
        # Pairs also include the unexpected fields.
631
643
        unexpected_dict = dict(unexpected_pairs)
632
644
        remaining_pairs = pairs[len(expected_pairs):]
633
645
        self.assertEqual(len(unexpected_dict), len(remaining_pairs))
634
646
        help = 'this field is unrecognized and can be safely removed'
635
647
        for field, value in remaining_pairs:
636
648
            self.assertEqual(unexpected_dict[field.name], value, field.name)
637
649
            self.assertFalse(field.required, field.name)
638
650
            self.assertEqual(help, field.help, field.name)
639
651
640
652
641
653
class ValidateNormalizeTestsMixin(object):
642
654
    """Shared utilities for tests exercising "validate" and "normalize"."""
643
655
644
656
    def setUp(self):
645
657
        # Set up metadata to work with.
646
658
        choices = ('trick', 'treat')
647
659
        self.env_metadata = {
648
660
            'fields': (
649
661
                fields.StringField('string-required', required=True),
650
662
                fields.StringField('string-default', default='boo!'),
651
663
                fields.IntField('int-optional'),
652
664
                fields.IntField('int-range', min_value=42, max_value=47),
653
665
                fields.BoolField('bool-true', default=True),
654
666
                fields.ChoiceField('choice-optional', choices=choices)
655
667
            )
656
668
        }
657
669
        super(ValidateNormalizeTestsMixin, self).setUp()
658
670
659
671
660
672
class TestValidate(ValidateNormalizeTestsMixin, unittest.TestCase):
661
673
662
674
    def test_valid(self):
663
675
        # An empty errors dict is returned if the env_data is valid.
664
676
        env_data = {
665
677
            'string-required': 'a string',
666
678
            'string-default': 'another string',
667
679
            'int-optional': -42,
668
680
            'int-range': 42,
669
681
            'bool-true': False,
670
682
            'choice-optional': 'treat',
671
683
        }
672
684
        self.assertEqual({}, envs.validate(self.env_metadata, env_data))
673
685
674
686
    def test_valid_only_required(self):
675
687
        # To be valid, env_data must at least include the required values.
676
688
        env_data = {'string-required': 'a string'}
677
689
        validation_errors = envs.validate(self.env_metadata, env_data)
678
690
        # No validation errors were found.
679
691
        self.assertEqual(validation_errors, {})
680
692
681
693
    def test_not_valid(self):
682
694
        # An errors dict is returned if the env_data is not valid.
683
695
        env_data = {
684
696
            'string-required': ' ',
685
697
            'string-default': 42,
686
698
            'int-optional': 'not-an-int',
687
699
            'int-range': 1000,
688
700
            'bool-true': [],
689
701
            'choice-optional': 'toy',
690
702
        }
691
703
        expected = {
692
704
            'string-required': (
693
705
                'a value is required for the string-required field'),
694
706
            'string-default': (
695
707
                'the string-default field requires a string value'),
696
708
            'int-optional': 'the int-optional field requires an integer value',
697
709
            'int-range': 'the int-range value must be in the 42-47 range',
698
710
            'bool-true': 'the bool-true field requires a boolean value',
699
711
            'choice-optional': ('the choice-optional requires the value to be '
700
712
                                'one of the following: trick, treat'),
701
713
        }
702
714
        self.assertEqual(expected, envs.validate(self.env_metadata, env_data))
703
715
704
716
    def test_required_field_not_found(self):
705
717
        # An error is returned if required fields are not included in env_data.
706
718
        expected = {
707
719
            'string-required': (
708
720
                'a value is required for the string-required field'),
709
721
        }
710
722
        self.assertEqual(expected, envs.validate(self.env_metadata, {}))
711
723
712
724
    def test_optional_invalid_field(self):
713
725
        # Even if there is just one invalid field, and even if that field is
714
726
        # optional, the error is still reported in the errors dict.
715
727
        env_data = {
716
728
            'string-required': 'a string',
717
729
            'int-optional': False,
718
730
        }
719
731
        expected = {
720
732
            'int-optional': 'the int-optional field requires an integer value',
721
733
        }
722
734
        self.assertEqual(expected, envs.validate(self.env_metadata, env_data))
723
735
724
736
725
737
class TestNormalize(ValidateNormalizeTestsMixin, unittest.TestCase):
726
738
727
739
    def test_normalized_data(self):
728
740
        # The given env_data is properly normalized.
729
741
        env_data = {
730
742
            'string-required': ' a string\n',
731
743
            'string-default': '\t another one',
732
744
            'int-optional': '-42',
733
745
            'int-range': 42.2,
734
746
            'bool-true': False,
735
747
            'choice-optional': ' trick ',
736
748
        }
737
749
        expected = {
738
750
            'string-required': 'a string',
739
751
            'string-default': 'another one',
740
752
            'int-optional': -42,
741
753
            'int-range': 42,
742
754
            'bool-true': False,
743
755
            'choice-optional': 'trick',
744
756
        }
745
757
        self.assertEqual(expected, envs.normalize(self.env_metadata, env_data))
746
758
747
759
    def test_already_normalized(self):
748
760
        # The normalization process produces the same env_data if the input
749
761
        # data is already normalized.
750
762
        env_data = {
751
763
            'string-required': 'a string',
752
764
            'int-optional': 42,
753
765
        }
754
766
        normalized_data = envs.normalize(self.env_metadata, env_data)
755
767
        # The same data is returned.
756
768
        self.assertEqual(env_data, normalized_data)
757
769
        # However, the returned data is a different object.
758
770
        self.assertIsNot(env_data, normalized_data)
759
771
760
772
    def test_multiline_values_preserved(self):
761
773
        # The normalization process preserves multi-line values.
762
774
        env_data = {'string-required': 'first line\nsecond line'}
763
775
        normalized_data = envs.normalize(self.env_metadata, env_data)
764
776
        self.assertEqual(env_data, normalized_data)
765
777
766
778
    def test_exclude_fields(self):
767
779
        # The normalization process excludes fields if they are not required
768
780
        # and the corresponding values are not set or not changed.
769
781
        env_data = {
770
782
            # Since this field is required, it is included even if not set.
771
783
            'string-required': '',
772
784
            # Even if this value is the default one, it is included because
773
785
            # it is explicitly set by the user.
774
786
            'string-default': 'boo!',
775
787
            # Since this field has a value, it is included even if optional.
776
788
            'int-optional': 42,
777
789
            # Since the value is unset and the field optional, it is excluded.
778
790
            'int-range': None,
779
791
            # False is a valid set value for boolean fields. For this reason,
780
792
            # it is included.
781
793
            'bool-true': False,
782
794
            # The choice optional field is not in the input data. For this
783
795
            # reason the field is excluded.
784
796
        }
785
797
        expected = {
786
798
            'string-required': None,
787
799
            'string-default': 'boo!',
788
800
            'int-optional': 42,
789
801
            'bool-true': False,
790
802
        }
791
803
        normalized_data = envs.normalize(self.env_metadata, env_data)
792
804
        self.assertEqual(expected, normalized_data)
793
805
794
806
    def test_original_not_mutated(self):
795
807
        # The original env_data is not modified in the process.
796
808
        env_data = {
797
809
            'string-required': ' a string\n',
798
810
            'string-default': None,
799
811
            'bool-true': None,
800
812
            'choice-optional': ' trick ',
801
813
        }
802
814
        original = env_data.copy()
803
815
        expected = {
804
816
            'string-required': 'a string',
805
817
            'choice-optional': 'trick',
806
818
        }
807
819
        normalized_data = envs.normalize(self.env_metadata, env_data)
808
820
        self.assertEqual(expected, normalized_data)
809
821
        self.assertEqual(original, env_data)
810
822
811
823
812
824
class TestGetEnvShortDescription(unittest.TestCase):
813
825
814
826
    def test_env(self):
815
827
        # The env description includes the environment name and type.
816
828
        env_data = {'name': 'lxc', 'type': 'local', 'is-default': False}
817
829
        description = envs.get_env_short_description(env_data)
818
830
        self.assertEqual('lxc (type: local)', description)
819
831
820
832
    def test_default_env(self):
821
833
        # A default environment is properly described.
822
834
        env_data = {'name': 'lxc', 'type': 'local', 'is-default': True}
823
835
        description = envs.get_env_short_description(env_data)
824
836
        self.assertEqual('lxc (type: local, default)', description)
825
837
826
838
    def test_env_without_type(self):
827
839
        # Without the type we can only show the environment name.
828
840
        env_data = {'name': 'lxc', 'is-default': False}
829
841
        description = envs.get_env_short_description(env_data)
830
842
        self.assertEqual('lxc', description)
831
843
832
844
    def test_default_env_without_type(self):
833
845
        # This would be embarrassing.
834
846
        env_data = {'name': 'lxc', 'type': None, 'is-default': True}
835
847
        description = envs.get_env_short_description(env_data)
836
848
        self.assertEqual('lxc (default)', description)
837
849
838
850
839
467
class TestParseEnvFile(
851
class TestParseEnvFile(
840
468
        helpers.EnvFileTestsMixin, helpers.ValueErrorTestsMixin,
852
        helpers.EnvFileTestsMixin, helpers.ValueErrorTestsMixin,
841
469
        unittest.TestCase):
853
        unittest.TestCase):
842
470
854
843
=== modified file 'quickstart/tests/models/test_fields.py'
844
--- quickstart/tests/models/test_fields.py	2013-12-11 17:45:06 +0000
845
+++ quickstart/tests/models/test_fields.py	2013-12-16 12:11:28 +0000
846
@@ -46,10 +46,11 @@
847
46
        # The field attributes are properly stored in the field instance.
46
        # The field attributes are properly stored in the field instance.
848
47
        field = self.field_class(
47
        field = self.field_class(
849
48
            'first-name', label='first name', help='your first name',
48
            'first-name', label='first name', help='your first name',
851
49
            required=True, readonly=False)
49
            default='default', required=True, readonly=False)
852
50
        self.assertEqual('first-name', field.name)
50
        self.assertEqual('first-name', field.name)
853
51
        self.assertEqual('first name', field.label)
51
        self.assertEqual('first name', field.label)
854
52
        self.assertEqual('your first name', field.help)
52
        self.assertEqual('your first name', field.help)
855
53
        self.assertEqual('default', field.default)
856
53
        self.assertTrue(field.required)
54
        self.assertTrue(field.required)
857
54
        self.assertFalse(field.readonly)
55
        self.assertFalse(field.readonly)
858
55
56
859
@@ -59,6 +60,7 @@
860
59
        self.assertEqual('last-name', field.name)
60
        self.assertEqual('last-name', field.name)
861
60
        self.assertEqual('last-name', field.label)
61
        self.assertEqual('last-name', field.label)
862
61
        self.assertEqual('', field.help)
62
        self.assertEqual('', field.help)
863
63
        self.assertIsNone(field.default)
864
62
        self.assertFalse(field.required)
64
        self.assertFalse(field.required)
865
63
        self.assertFalse(field.readonly)
65
        self.assertFalse(field.readonly)
866
64
66
867
@@ -81,7 +83,7 @@
868
81
    field_class = fields.Field
83
    field_class = fields.Field
869
82
84
870
83
    def test_normalization(self):
85
    def test_normalization(self):
872
84
        # The base field normalization is a no-op.
86
        # The base field normalization is a no-op if the value is set.
873
85
        field = self.field_class('email')
87
        field = self.field_class('email')
874
86
        for value in (None, 42, True, 'a unicode string'):
88
        for value in (None, 42, True, 'a unicode string'):
875
87
            self.assertEqual(value, field.normalize(value), value)
89
            self.assertEqual(value, field.normalize(value), value)
876
@@ -93,7 +95,7 @@
877
93
            self.assertIsNone(field.validate(value), value)
95
            self.assertIsNone(field.validate(value), value)
878
94
96
879
95
    def test_validation_not_required(self):
97
    def test_validation_not_required(self):
881
96
        # If the field is not required no errors are raised.
98
        # If the field is not required, no errors are raised.
882
97
        field = self.field_class('email', required=False)
99
        field = self.field_class('email', required=False)
883
98
        for value in ('', False, None):
100
        for value in ('', False, None):
884
99
            with self.assert_not_raises(ValueError, value):
101
            with self.assert_not_raises(ValueError, value):
885
@@ -103,9 +105,15 @@
886
103
        # A ValueError is raised by required fields if the value is not set.
105
        # A ValueError is raised by required fields if the value is not set.
887
104
        field = self.field_class('email', label='email address', required=True)
106
        field = self.field_class('email', label='email address', required=True)
888
105
        expected = 'a value is required for the email address field'
107
        expected = 'a value is required for the email address field'
892
106
        for value in ('', False, None):
108
        with self.assert_value_error(expected):
893
107
            with self.assert_value_error(expected):
109
            field.validate(None)
894
108
                field.validate(value)
110
895
111
    def test_validation_with_default(self):
896
112
        # The validation succeeds if the value is unset but a default one is
897
113
        # available.
898
114
        field = self.field_class('answer', default=42, required=True)
899
115
        with self.assert_not_raises(ValueError):
900
116
            field.validate(None)
901
109
117
902
110
118
903
111
class TestStringField(
119
class TestStringField(
904
@@ -116,13 +124,14 @@
905
116
    def test_normalization(self):
124
    def test_normalization(self):
906
117
        # The string field normalization returns the stripped string value.
125
        # The string field normalization returns the stripped string value.
907
118
        field = self.field_class('email')
126
        field = self.field_class('email')
909
119
        for value in ('a value', '\t tabs and spaces ', ' ', 'newlines\n\n'):
127
        for value in ('a value', '\t tabs and spaces ', 'newlines\n\n'):
910
120
            self.assertEqual(value.strip(), field.normalize(value), value)
128
            self.assertEqual(value.strip(), field.normalize(value), value)
911
121
129
912
122
    def test_none_normalization(self):
130
    def test_none_normalization(self):
914
123
        # The string field normalization turns None values into empty strings.
131
        # The string field normalization returns None if the value is not set.
915
124
        field = self.field_class('email')
132
        field = self.field_class('email')
917
125
        self.assertEqual('', field.normalize(None))
133
        for value in ('', '  ', '\n', ' \t ', None):
918
134
            self.assertIsNone(field.normalize(value), value)
919
126
135
920
127
    def test_validation_success(self):
136
    def test_validation_success(self):
921
128
        # The validation succeeds if the value is set.
137
        # The validation succeeds if the value is set.
922
@@ -131,7 +140,7 @@
923
131
            self.assertIsNone(field.validate(value), value)
140
            self.assertIsNone(field.validate(value), value)
924
132
141
925
133
    def test_validation_not_required(self):
142
    def test_validation_not_required(self):
927
134
        # If the field is not required no errors are raised.
143
        # If the field is not required, no errors are raised.
928
135
        field = self.field_class('email', required=False)
144
        field = self.field_class('email', required=False)
929
136
        for value in ('', None, ' ', '\t\n'):
145
        for value in ('', None, ' ', '\t\n'):
930
137
            with self.assert_not_raises(ValueError, value):
146
            with self.assert_not_raises(ValueError, value):
931
@@ -153,6 +162,14 @@
932
153
            with self.assert_value_error(expected):
162
            with self.assert_value_error(expected):
933
154
                field.validate(value)
163
                field.validate(value)
934
155
164
935
165
    def test_validation_with_default(self):
936
166
        # The validation succeeds if the value is unset but a default one is
937
167
        # available.
938
168
        field = self.field_class(
939
169
            'email', default='email@example.com', required=True)
940
170
        with self.assert_not_raises(ValueError):
941
171
            field.validate(None)
942
172
943
156
173
944
157
class TestIntField(
174
class TestIntField(
945
158
        FieldTestsMixin, helpers.ValueErrorTestsMixin, unittest.TestCase):
175
        FieldTestsMixin, helpers.ValueErrorTestsMixin, unittest.TestCase):
946
@@ -171,6 +188,11 @@
947
171
        for value in (None, '', ' ', '\t\n'):
188
        for value in (None, '', ' ', '\t\n'):
948
172
            self.assertIsNone(field.normalize(value), value)
189
            self.assertIsNone(field.normalize(value), value)
949
173
190
950
191
    def test_zero_normalization(self):
951
192
        # The zero value is not considered unset.
952
193
        field = self.field_class('tcp-port')
953
194
        self.assertEqual(0, field.normalize(0))
954
195
955
174
    def test_validation_success(self):
196
    def test_validation_success(self):
956
175
        # The value as an integer number is returned if the value is valid.
197
        # The value as an integer number is returned if the value is valid.
957
176
        field = self.field_class('tcp-port')
198
        field = self.field_class('tcp-port')
958
@@ -193,7 +215,7 @@
959
193
                field.validate(value)
215
                field.validate(value)
960
194
216
961
195
    def test_validation_not_required(self):
217
    def test_validation_not_required(self):
963
196
        # If the field is not required no errors are raised.
218
        # If the field is not required, no errors are raised.
964
197
        field = self.field_class('tcp-port', required=False)
219
        field = self.field_class('tcp-port', required=False)
965
198
        for value in ('', None, ' ', '\t\n'):
220
        for value in ('', None, ' ', '\t\n'):
966
199
            with self.assert_not_raises(ValueError, value):
221
            with self.assert_not_raises(ValueError, value):
967
@@ -235,12 +257,29 @@
968
235
        with self.assert_value_error(expected):
257
        with self.assert_value_error(expected):
969
236
            field.validate(27)
258
            field.validate(27)
970
237
259
971
260
    def test_validation_with_default(self):
972
261
        # The validation succeeds if the value is unset but a default one is
973
262
        # available.
974
263
        field = self.field_class('tcp-port', default=8888, required=True)
975
264
        with self.assert_not_raises(ValueError):
976
265
            field.validate(None)
977
266
978
238
267
979
239
class TestBoolField(
268
class TestBoolField(
980
240
        FieldTestsMixin, helpers.ValueErrorTestsMixin, unittest.TestCase):
269
        FieldTestsMixin, helpers.ValueErrorTestsMixin, unittest.TestCase):
981
241
270
982
242
    field_class = fields.BoolField
271
    field_class = fields.BoolField
983
243
272
984
273
    def test_default_attributes(self):
985
274
        # Only the name identifier is required when instantiating a field.
986
275
        field = self.field_class('is-public')
987
276
        self.assertEqual('is-public', field.name)
988
277
        self.assertEqual('is-public', field.label)
989
278
        self.assertEqual('', field.help)
990
279
        self.assertFalse(field.default)
991
280
        self.assertFalse(field.required)
992
281
        self.assertFalse(field.readonly)
993
282
994
244
    def test_normalization(self):
283
    def test_normalization(self):
995
245
        # The bool field normalization returns the value itself.
284
        # The bool field normalization returns the value itself.
996
246
        field = self.field_class('is-public')
285
        field = self.field_class('is-public')
997
@@ -248,11 +287,9 @@
998
248
        self.assertFalse(field.normalize(False))
287
        self.assertFalse(field.normalize(False))
999
249
288
1000
250
    def test_none_normalization(self):
289
    def test_none_normalization(self):
1006
251
        # The string field normalization turns None values into the default.
290
        # The string field normalization returns None if the value is not set.
1007
252
        field_true = self.field_class('is-public', default=True)
291
        field = self.field_class('is-public')
1008
253
        field_false = self.field_class('is-private', default=False)
292
        self.assertIsNone(field.normalize(None))
1004
254
        self.assertTrue(field_true.normalize(None))
1005
255
        self.assertFalse(field_false.normalize(None))
1009
256
293
1010
257
    def test_validation_success(self):
294
    def test_validation_success(self):
1011
258
        # The validation succeeds if the value is boolean.
295
        # The validation succeeds if the value is boolean.
1012
@@ -269,6 +306,34 @@
1013
269
            with self.assert_value_error(expected):
306
            with self.assert_value_error(expected):
1014
270
                field.validate(value)
307
                field.validate(value)
1015
271
308
1016
309
    def test_validation_not_required(self):
1017
310
        # If the field is not required, no errors are raised.
1018
311
        field = self.field_class('is-public', required=False)
1019
312
        with self.assert_not_raises(ValueError):
1020
313
            field.validate(None)
1021
314
1022
315
    def test_validation_error_required(self):
1023
316
        # If the value is not set, the default value will be used.
1024
317
        field = self.field_class(
1025
318
            'is-public', label='is public', default=False, required=True)
1026
319
        with self.assert_not_raises(ValueError):
1027
320
            field.validate(None)
1028
321
1029
322
    def test_validation_allow_mixed(self):
1030
323
        # The validation succeed with a None value if the field allows mixed
1031
324
        # state: True/False or None (unset).
1032
325
        field = self.field_class('is-public', allow_mixed=True)
1033
326
        with self.assert_not_raises(ValueError):
1034
327
            field.validate(None)
1035
328
1036
329
    def test_validation_no_mixed_state(self):
1037
330
        # The boolean field cannot be unset if mixed state is not allowed.
1038
331
        field = self.field_class(
1039
332
            'is-public', label='is public', allow_mixed=False)
1040
333
        expected = 'the is public field requires a boolean value'
1041
334
        with self.assert_value_error(expected):
1042
335
            field.validate(None)
1043
336
1044
272
337
1045
273
class TestAutoGeneratedStringField(TestStringField):
338
class TestAutoGeneratedStringField(TestStringField):
1046
274
339
1047
@@ -311,6 +376,14 @@
1048
311
        with self.assert_value_error(expected):
376
        with self.assert_value_error(expected):
1049
312
            field.validate('resistance is futile')
377
            field.validate('resistance is futile')
1050
313
378
1051
379
    def test_validation_with_default(self):
1052
380
        # The validation succeeds if the value is unset but a default one is
1053
381
        # available.
1054
382
        field = self.field_class(
1055
383
            'word', choices=self.choices, default='voyages', required=True)
1056
384
        with self.assert_not_raises(ValueError):
1057
385
            field.validate(None)
1058
386
1059
314
387
1060
315
class TestPasswordField(TestStringField):
388
class TestPasswordField(TestStringField):
1061
316
389
Status:	Merged
Merged at revision:	34
Proposed branch:	lp:~frankban/juju-quickstart/env-manage-models-meta
Merge into:	lp:juju-quickstart
Diff against target:	1060 lines (+730/-68) 4 files modified quickstart/models/envs.py (+215/-6) quickstart/models/fields.py (+41/-45) quickstart/tests/models/test_envs.py (+385/-1) quickstart/tests/models/test_fields.py (+89/-16)
To merge this branch:	bzr merge lp:~frankban/juju-quickstart/env-manage-models-meta
Related bugs:	Link a bug report
Reviewer	Review Type	Date Requested	Status
Juju GUI Hackers		2013-12-12	Pending
Review via email: mp+198756@code.launchpad.net