← Back to branch summary

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

« back to all changes in this revision

Viewing changes to tests/test_assess_jes_deploy.py

  • Committer: Martin Packman
  • Date: 2015-11-17 14:19:06 UTC
  • mto: This revision was merged to the branch mainline in revision 1155.
  • Revision ID: martin.packman@canonical.com-20151117141906-a4zmuqre72s7fyf1
Sample script for generating image streams for rackspace

Show diffs side-by-side

added added

removed removed

Lines of Context:
tests/test_assess_jes_deploy.py
1
1
from argparse import Namespace
 
2
import unittest
2
3
from mock import (
 
4
    Mock,
3
5
    patch,
4
6
    )
5
 
import os
6
 
 
7
7
from assess_jes_deploy import (
8
8
    check_services,
9
9
    env_token,
10
 
    hosted_environment,
11
10
    jes_setup,
 
11
    make_hosted_env_client,
12
12
)
13
13
from jujupy import (
 
14
    EnvJujuClient,
14
15
    EnvJujuClient25,
15
16
    JUJU_DEV_FEATURE_FLAGS,
16
17
    SimpleEnvironment,
17
18
)
18
 
import tests
19
 
from tests.test_jujupy import fake_juju_client
20
 
 
21
 
 
22
 
class TestJES(tests.FakeHomeTestCase):
 
19
 
 
20
 
 
21
class TestJES(unittest.TestCase):
23
22
 
24
23
    client_class = EnvJujuClient25
25
24
 
26
25
    @patch('assess_jes_deploy.get_random_string', autospec=True)
27
 
    @patch('jujupy.SimpleEnvironment.from_config')
 
26
    @patch('assess_jes_deploy.SimpleEnvironment.from_config')
28
27
    def mock_client(self, from_config_func, get_random_string_func):
29
28
        from_config_func.return_value = SimpleEnvironment('baz', {})
30
29
        get_random_string_func.return_value = 'fakeran'
31
30
        client = self.client_class(
32
31
            SimpleEnvironment.from_config('baz'),
33
32
            '1.25-foobar', 'path')
34
 
        client.enable_feature('jes')
 
33
        client._use_jes = True
35
34
        return client
36
35
 
37
36
    @patch('assess_jes_deploy.get_random_string', autospec=True)
46
45
 
47
46
    @patch('assess_jes_deploy.print_now', autospec=True)
48
47
    @patch('assess_jes_deploy.get_random_string', autospec=True)
49
 
    @patch('jujupy.EnvJujuClient.juju', autospec=True)
 
48
    @patch('assess_jes_deploy.EnvJujuClient.juju', autospec=True)
50
49
    @patch('assess_jes_deploy.check_token', autospec=True)
51
50
    def test_check_services(
52
51
            self,
65
64
        check_token_func.assert_called_once_with(client, 'tokenfakeran')
66
65
        print_now_func.assert_called_once_with('checking services in token')
67
66
 
68
 
    @patch('jujupy.EnvJujuClient.get_full_path')
69
 
    @patch('jujupy.EnvJujuClient.add_ssh_machines', autospec=True)
 
67
    @patch('assess_jes_deploy.EnvJujuClient.get_full_path')
 
68
    @patch('assess_jes_deploy.EnvJujuClient.add_ssh_machines', autospec=True)
70
69
    @patch('assess_jes_deploy.boot_context', autospec=True)
71
70
    @patch('assess_jes_deploy.configure_logging', autospec=True)
72
 
    @patch('assess_jes_deploy.client_from_config')
 
71
    @patch('assess_jes_deploy.SimpleEnvironment.from_config')
 
72
    @patch('assess_jes_deploy.EnvJujuClient.by_version')
73
73
    def test_jes_setup(
74
74
            self,
75
75
            by_version_func,
 
76
            from_config_func,
76
77
            configure_logging_func,
77
78
            boot_context_func,
78
79
            add_ssh_machines_func,
79
80
            get_full_path_func):
80
81
        # patch helper funcs
81
82
        expected_client = self.mock_client()
 
83
        expected_env = SimpleEnvironment('baz', {})
 
84
        from_config_func.return_value = expected_env
82
85
        by_version_func.return_value = expected_client
83
86
        configure_logging_func.return_value = None
84
87
        get_full_path_func.return_value = '/path/to/juju'
94
97
        with patch.object(expected_client, 'enable_jes'):
95
98
            with patch.object(expected_client, 'is_jes_enabled',
96
99
                              return_value=True):
97
 
                with jes_setup(setup_args) as (client, charm_series, base_env):
 
100
                with jes_setup(setup_args) as (client, charm_previx, base_env):
98
101
                    self.assertEqual(1, client.is_jes_enabled.call_count)
99
102
                    self.assertEqual(0, client.enable_jes.call_count)
100
103
 
101
104
        # assert that jes_setup provides expected values
102
105
        self.assertIs(client, expected_client)
103
 
        self.assertEqual(charm_series, 'trusty')
 
106
        self.assertEqual(charm_previx, 'local:trusty/')
104
107
        self.assertEqual(base_env, 'baz')
105
108
 
106
109
        # assert that helper funcs were called with expected args.
107
110
        by_version_func.assert_called_once_with(
108
 
            'baz', '/path/to/bin/juju', True)
 
111
            expected_env, '/path/to/bin/juju', True)
109
112
 
110
113
        configure_logging_func.assert_called_once_with(True)
111
114
        boot_context_func.assert_called_once_with(
112
115
            'jesjob', expected_client, 'localhost', ['0'], 'trusty',
113
 
            'some_url', 'devel', 'log/dir', True, upload_tools=False,
 
116
            'some_url', 'devel', 'log/dir', True, False, permanent=True,
114
117
            region='region-foo')
115
118
 
 
119
        add_ssh_machines_func.assert_called_once_with(client, ['0'])
 
120
 
116
121
        # Setup jes with a client that requires a call to enable_jes.
117
122
        with patch.object(expected_client, 'enable_jes'):
118
123
            with patch.object(expected_client, 'is_jes_enabled',
121
126
                    self.assertEqual(1, client.is_jes_enabled.call_count)
122
127
                    self.assertEqual(1, client.enable_jes.call_count)
123
128
 
124
 
 
125
 
class TestHostedEnvironment(tests.FakeHomeTestCase):
126
 
 
127
 
    def test_hosted_environment(self):
128
 
        hosting_client = fake_juju_client()
129
 
        log_dir = os.path.join(self.home_dir, 'logs')
130
 
        os.mkdir(log_dir)
131
 
        with hosted_environment(hosting_client, log_dir, 'bar') as client:
132
 
            models = client._backend.controller_state.models
133
 
            model_state = models[client.model_name]
134
 
            self.assertEqual({'name-bar': model_state},
135
 
                             hosting_client._backend.controller_state.models)
136
 
            self.assertEqual('created', model_state.state)
137
 
        self.assertEqual('model-destroyed', model_state.state)
138
 
        self.assertTrue(os.path.isdir(os.path.join(log_dir, 'bar')))
139
 
 
140
 
    def test_gathers_machine_logs(self):
141
 
        hosting_client = fake_juju_client()
142
 
        log_dir = os.path.join(self.home_dir, 'logs')
143
 
        os.mkdir(log_dir)
144
 
        with patch("deploy_stack.copy_remote_logs", autospec=True) as mock_crl:
145
 
            with hosted_environment(hosting_client, log_dir, 'bar') as client:
146
 
                client.juju("deploy", ["cs:a-application"])
147
 
                status = client.get_status()
148
 
                unit_machine = status.get_unit("a-application/0")["machine"]
149
 
                addr = status.status["machines"][unit_machine]["dns-name"]
150
 
        hosted_dir = os.path.join(log_dir, "bar")
151
 
        machine_dir = os.path.join(hosted_dir, "machine-0")
152
 
        self.assertTrue(os.path.isdir(hosted_dir))
153
 
        self.assertTrue(os.path.isdir(machine_dir))
154
 
        self.assertEqual(mock_crl.call_count, 1)
155
 
        self.assertEqual(mock_crl.call_args[0][0].address, addr)
156
 
        self.assertEqual(mock_crl.call_args[0][1], machine_dir)
 
129
    @patch('assess_jes_deploy.EnvJujuClient.by_version')
 
130
    def test_make_hosted_env_client(
 
131
            self,
 
132
            by_version_func):
 
133
        client = Mock()
 
134
        by_version_func.return_value = client
 
135
 
 
136
        env = SimpleEnvironment('env', {'type': 'any'})
 
137
        old_client = EnvJujuClient(env, None, '/a/path')
 
138
        make_hosted_env_client(old_client, 'test')
 
139
 
 
140
        self.assertEqual(by_version_func.call_count, 1)
 
141
        call_args = by_version_func.call_args[0]
 
142
        self.assertIsInstance(call_args[0], SimpleEnvironment)
 
143
        self.assertEqual(call_args[0].environment, 'env-test')
 
144
        self.assertEqual(call_args[0].config, {'type': 'any'})
 
145
        self.assertEqual(call_args[1:], ('/a/path', False))
 
146
 
 
147
        client.enable_jes.assert_called_once_with()