~abentley/juju-ci-tools/client-from-config-4

« back to all changes in this revision

Viewing changes to assess_block.py

  • Committer: Aaron Bentley
  • Date: 2016-03-18 14:47:06 UTC
  • mto: This revision was merged to the branch mainline in revision 1324.
  • Revision ID: aaron.bentley@canonical.com-20160318144706-z7wy9c21m3psi6g5
Introduce set_model_name, update tests, check controller on bootstrap.

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
 
#!/usr/bin/env python
2
 
"""Assess juju blocks prevent users from making changes and models"""
3
 
 
4
 
from __future__ import print_function
5
 
 
6
 
import argparse
7
 
import logging
8
 
import sys
9
 
 
10
 
import yaml
11
 
 
12
 
from assess_min_version import (
13
 
    JujuAssertionError
14
 
)
15
 
from deploy_stack import (
16
 
    BootstrapManager,
17
 
    deploy_dummy_stack,
18
 
)
19
 
from utility import (
20
 
    add_basic_testing_arguments,
21
 
    configure_logging,
22
 
    wait_for_removed_services,
23
 
)
24
 
 
25
 
 
26
 
__metaclass__ = type
27
 
 
28
 
 
29
 
log = logging.getLogger("assess_block")
30
 
 
31
 
 
32
 
def get_block_list(client):
33
 
    """Return a list of blocks and their status."""
34
 
    return yaml.safe_load(client.get_juju_output(
35
 
        'block list', '--format', 'yaml'))
36
 
 
37
 
 
38
 
def make_block_list(client, des_env, rm_obj, all_changes):
39
 
    """Return a manually made list of blocks and their status"""
40
 
    block_list = [
41
 
        {'block': client.destroy_model_command, 'enabled': des_env},
42
 
        {'block': 'remove-object', 'enabled': rm_obj},
43
 
        {'block': 'all-changes', 'enabled': all_changes}]
44
 
    for block in block_list:
45
 
        if block['enabled']:
46
 
            block['message'] = ''
47
 
    return block_list
48
 
 
49
 
 
50
 
def test_blocked(client, command, args, include_e=True):
51
 
    """Test if a command is blocked as expected"""
52
 
    try:
53
 
        if command == 'deploy':
54
 
            client.deploy(args)
55
 
        elif command == 'remove-service':
56
 
            client.remove_service(args)
57
 
        else:
58
 
            client.juju(command, args, include_e=include_e)
59
 
        raise JujuAssertionError()
60
 
    except Exception:
61
 
        pass
62
 
 
63
 
 
64
 
def assess_block_destroy_model(client, charm_series):
65
 
    """Test block destroy-model
66
 
 
67
 
    When "block destroy-model" is set,
68
 
    the model cannot be destroyed, but objects
69
 
    can be added, related, and removed.
70
 
    """
71
 
    client.juju('block ' + client.destroy_model_command, ())
72
 
    block_list = get_block_list(client)
73
 
    if block_list != make_block_list(client, True, False, False):
74
 
        raise JujuAssertionError(block_list)
75
 
    test_blocked(client, client.destroy_model_command,
76
 
                 ('-y', client.env.environment), include_e=False)
77
 
    # Adding, relating, and removing are not blocked.
78
 
    deploy_dummy_stack(client, charm_series)
79
 
 
80
 
 
81
 
def assess_block_remove_object(client, charm_series):
82
 
    """Test block remove-object
83
 
 
84
 
    When "block remove-object" is set,
85
 
    objects can be added and related, but they
86
 
    cannot be removed or the model/environment deleted.
87
 
    """
88
 
    client.juju('block remove-object', ())
89
 
    block_list = get_block_list(client)
90
 
    if block_list != make_block_list(client, False, True, False):
91
 
        raise JujuAssertionError(block_list)
92
 
    test_blocked(client, client.destroy_model_command,
93
 
                 ('-y', client.env.environment), include_e=False)
94
 
    # Adding and relating are not blocked.
95
 
    deploy_dummy_stack(client, charm_series)
96
 
    test_blocked(client, 'remove-service', 'dummy-source')
97
 
    test_blocked(client, 'remove-unit', ('dummy-source/1',))
98
 
    test_blocked(client, 'remove-relation', ('dummy-source', 'dummy-sink'))
99
 
 
100
 
 
101
 
def assess_block_all_changes(client, charm_series):
102
 
    """Test Block Functionality: block all-changes"""
103
 
    client.juju('remove-relation', ('dummy-source', 'dummy-sink'))
104
 
    client.juju('block all-changes', ())
105
 
    block_list = get_block_list(client)
106
 
    if block_list != make_block_list(client, False, False, True):
107
 
        raise JujuAssertionError(block_list)
108
 
    test_blocked(client, 'add-relation', ('dummy-source', 'dummy-sink'))
109
 
    test_blocked(client, 'unexpose', ('dummy-sink',))
110
 
    test_blocked(client, 'remove-service', 'dummy-sink')
111
 
    client.juju('unblock all-changes', ())
112
 
    client.juju('unexpose', ('dummy-sink',))
113
 
    client.juju('block all-changes', ())
114
 
    test_blocked(client, 'expose', ('dummy-sink',))
115
 
    client.juju('unblock all-changes', ())
116
 
    client.remove_service('dummy-sink')
117
 
    wait_for_removed_services(client, 'dummy-sink')
118
 
    client.juju('block all-changes', ())
119
 
    test_blocked(client, 'deploy', ('dummy-sink',))
120
 
    test_blocked(client, client.destroy_model_command,
121
 
                 ('-y', client.env.environment), include_e=False)
122
 
 
123
 
 
124
 
def assess_unblock(client, type):
125
 
    """Test Block Functionality
126
 
    unblock destroy-model/remove-object/all-changes."""
127
 
    client.juju('unblock ' + type, ())
128
 
    block_list = get_block_list(client)
129
 
    if block_list != make_block_list(client, False, False, False):
130
 
        raise JujuAssertionError(block_list)
131
 
    if type == client.destroy_model_command:
132
 
        client.remove_service('dummy-source')
133
 
        wait_for_removed_services(client, 'dummy-source')
134
 
        client.remove_service('dummy-sink')
135
 
        wait_for_removed_services(client, 'dummy-sink')
136
 
 
137
 
 
138
 
def assess_block(client, charm_series):
139
 
    """Test Block Functionality:
140
 
    block/unblock destroy-model/remove-object/all-changes.
141
 
    """
142
 
    block_list = get_block_list(client)
143
 
    client.wait_for_started()
144
 
    expected_none_blocked = make_block_list(client, False, False, False)
145
 
    if block_list != expected_none_blocked:
146
 
        raise JujuAssertionError(block_list)
147
 
    assess_block_destroy_model(client, charm_series)
148
 
    assess_unblock(client, client.destroy_model_command)
149
 
    assess_block_remove_object(client, charm_series)
150
 
    assess_unblock(client, 'remove-object')
151
 
    assess_block_all_changes(client, charm_series)
152
 
    assess_unblock(client, 'all-changes')
153
 
 
154
 
 
155
 
def parse_args(argv):
156
 
    """Parse all arguments."""
157
 
    parser = argparse.ArgumentParser(description="Test Block Functionality")
158
 
    add_basic_testing_arguments(parser)
159
 
    parser.set_defaults(series='trusty')
160
 
    return parser.parse_args(argv)
161
 
 
162
 
 
163
 
def main(argv=None):
164
 
    args = parse_args(argv)
165
 
    configure_logging(args.verbose)
166
 
    bs_manager = BootstrapManager.from_args(args)
167
 
    with bs_manager.booted_context(args.upload_tools):
168
 
        assess_block(bs_manager.client, bs_manager.series)
169
 
    return 0
170
 
 
171
 
 
172
 
if __name__ == '__main__':
173
 
    sys.exit(main())