← Back to branch summary

~andrewjbeach/juju-ci-tools/make-local-patcher

« back to all changes in this revision

Viewing changes to tests/test_generate_perfscale_results.py

  • Committer: Christopher Lee
  • Date: 2016-10-26 04:29:27 UTC
  • mto: This revision was merged to the branch mainline in revision 1698.
  • Revision ID: chris.lee@canonical.com-20161026042927-j3wf3tt7pjpr1ok6
Add handling of HA perfscale reporting.

Show diffs side-by-side

added added

removed removed

Lines of Context:
tests/test_generate_perfscale_results.py
1
1
"""Tests for assess_perf_test_simple module."""
2
2
 
 
3
import argparse
3
4
from contextlib import contextmanager
4
5
from collections import OrderedDict
5
6
from datetime import (
14
15
from fakejuju import fake_juju_client
15
16
import generate_perfscale_results as gpr
16
17
import perf_graphing
17
 
from test_perfscale_deployment import get_default_args
18
18
from test_quickstart_deploy import make_bootstrap_manager
19
19
from tests import TestCase
20
20
from utility import temp_dir
21
21
 
22
22
 
 
23
def get_default_args(**kwargs):
 
24
    default_args = dict(
 
25
        env='an-env',
 
26
        juju_bin='/bin/juju',
 
27
        logs='/tmp/logs',
 
28
        temp_env_name='an-env-mod',
 
29
        enable_ha=False,
 
30
        debug=False,
 
31
        agent_stream=None,
 
32
        agent_url=None,
 
33
        bootstrap_host=None,
 
34
        keep_env=False,
 
35
        machine=[],
 
36
        region=None,
 
37
        series=None,
 
38
        upload_tools=False,
 
39
        verbose=20,
 
40
        deadline=None)
 
41
    default_args.update(kwargs)
 
42
 
 
43
    return argparse.Namespace(**default_args)
 
44
 
 
45
 
 
46
class TestAddBasicPerfscaleArguments(TestCase):
 
47
 
 
48
    def test_adds_perfscale_arguments(self):
 
49
        parser = argparse.ArgumentParser()
 
50
        gpr.add_basic_perfscale_arguments(parser)
 
51
        parsed_args = parser.parse_args()
 
52
        self.assertEqual(parsed_args.enable_ha, False)
 
53
 
 
54
        parsed_args = parser.parse_args(['--enable-ha'])
 
55
        self.assertEqual(parsed_args.enable_ha, True)
 
56
 
 
57
    def test_includes_basic_default_arguments(self):
 
58
        parser = argparse.ArgumentParser()
 
59
        gpr.add_basic_perfscale_arguments(parser)
 
60
        parsed_args = parser.parse_args([
 
61
            'an-env',
 
62
            '/bin/juju',
 
63
            '/tmp/logs',
 
64
            'an-env-mod'])
 
65
 
 
66
        self.assertEqual(parsed_args, get_default_args())
 
67
 
 
68
 
 
69
class TestMaybeEnableHA(TestCase):
 
70
 
 
71
    def test_must_not_be_enabled_by_default(self):
 
72
        parser = argparse.ArgumentParser()
 
73
        gpr.add_basic_perfscale_arguments(parser)
 
74
        args = parser.parse_args([])
 
75
 
 
76
        client = Mock()
 
77
        gpr.maybe_enable_ha(client, args)
 
78
 
 
79
        self.assertEqual(0, client.enable_ha.call_count)
 
80
        self.assertEqual(0, client.wait_for_ha.call_count)
 
81
 
 
82
    def test_must_be_enabled_when_requested(self):
 
83
        parser = argparse.ArgumentParser()
 
84
        gpr.add_basic_perfscale_arguments(parser)
 
85
        args = parser.parse_args(['--enable-ha'])
 
86
 
 
87
        client = Mock()
 
88
        gpr.maybe_enable_ha(client, args)
 
89
 
 
90
        client.enable_ha.assert_called_once_with()
 
91
        client.wait_for_ha.assert_called_once_with()
 
92
 
 
93
 
23
94
class TestRunPerfscaleTest(TestCase):
24
95
 
25
96
    def test_calls_provided_test(self):
43
114
            noop_test.assert_called_once_with(client, get_default_args())
44
115
 
45
116
 
 
117
class TestGetControllerMachines(TestCase):
 
118
 
 
119
    def test_returns_machine_id_for_non_ha(self):
 
120
        client = fake_juju_client()
 
121
        client.bootstrap()
 
122
        self.assertListEqual(
 
123
            ['0'],
 
124
            gpr.get_controller_machines(client.get_controller_client()))
 
125
 
 
126
    def test_returns_machine_id_for_ha_enabled(self):
 
127
        client = fake_juju_client()
 
128
        client.bootstrap()
 
129
        client.enable_ha()
 
130
        self.assertListEqual(
 
131
            ['0', '1', '2'],
 
132
            gpr.get_controller_machines(client.get_controller_client()))
 
133
 
 
134
 
 
135
class TestSetupSystemMonitoring(TestCase):
 
136
 
 
137
    def test_setup_for_non_ha(self):
 
138
        client = fake_juju_client()
 
139
        client.bootstrap()
 
140
        admin_client = client.get_controller_client()
 
141
 
 
142
        with patch.object(
 
143
                gpr, '_setup_system_monitoring', autospec=True) as m_ssm:
 
144
            with patch.object(
 
145
                    gpr, '_enable_monitoring', autospec=True) as m_em:
 
146
                self.assertListEqual(
 
147
                    ['0'],
 
148
                    gpr.setup_system_monitoring(admin_client))
 
149
        m_ssm.assert_called_once_with(admin_client, '0')
 
150
        m_em.assert_called_once_with(admin_client, '0')
 
151
 
 
152
    def test_setup_for_ha_enabled(self):
 
153
        client = fake_juju_client()
 
154
        client.bootstrap()
 
155
        client.enable_ha()
 
156
        admin_client = client.get_controller_client()
 
157
 
 
158
        with patch.object(
 
159
                gpr, '_setup_system_monitoring', autospec=True) as m_ssm:
 
160
            with patch.object(
 
161
                    gpr, '_enable_monitoring', autospec=True) as m_em:
 
162
                self.assertListEqual(
 
163
                    ['0', '1', '2'],
 
164
                    gpr.setup_system_monitoring(admin_client))
 
165
        self.assertListEqual(
 
166
            m_ssm.call_args_list,
 
167
            [
 
168
                call(admin_client, '0'),
 
169
                call(admin_client, '1'),
 
170
                call(admin_client, '2')])
 
171
        self.assertListEqual(
 
172
            m_em.call_args_list,
 
173
            [
 
174
                call(admin_client, '0'),
 
175
                call(admin_client, '1'),
 
176
                call(admin_client, '2')])
 
177
 
 
178
    def test__system_monitoring_installs_on_requested_machine(self):
 
179
        admin_client = Mock()
 
180
        static_setup_path = '/foo/bar/setup'
 
181
        static_config_path = '/baz/bang/config'
 
182
 
 
183
        expected_calls = [
 
184
            call('scp', (static_config_path, '2:/tmp/collectd.config')),
 
185
            call('scp', (static_setup_path, '2:/tmp/installer.sh')),
 
186
            call('ssh', ('2', 'chmod +x /tmp/installer.sh')),
 
187
        ]
 
188
 
 
189
        with patch.object(gpr, 'SetupPaths', autospec=True) as m_sp:
 
190
            m_sp.installer_script_path = static_setup_path
 
191
            m_sp.collectd_config_path = static_config_path
 
192
            m_sp.collectd_config_dest_file = '/tmp/collectd.config'
 
193
            m_sp.installer_script_dest_path = '/tmp/installer.sh'
 
194
            gpr._setup_system_monitoring(admin_client, '2')
 
195
 
 
196
        self.assertListEqual(
 
197
            admin_client.juju.call_args_list,
 
198
            expected_calls)
 
199
 
 
200
    def test__enable_monitoring_enables_script_on_controller_machine(self):
 
201
        admin_client = Mock()
 
202
        gpr._enable_monitoring(admin_client, '3')
 
203
        expected_calls = [
 
204
            call(
 
205
                'ssh',
 
206
                ('3',
 
207
                 '/tmp/installer.sh /tmp/collectd.config /tmp/runner.sh')),
 
208
            call(
 
209
                'ssh', ('3', '--', 'daemon --respawn /tmp/runner.sh'))]
 
210
        self.assertListEqual(
 
211
            admin_client.juju.call_args_list,
 
212
            expected_calls
 
213
        )
 
214
 
 
215
 
46
216
class TestDumpPerformanceMetricsLogs(TestCase):
47
217
 
48
 
    def test_pulls_rrd_and_mongostats_logs(self):
 
218
    def test_pulls_rrd_and_mongostats_logs_with_single_controller(self):
49
219
        client = Mock()
50
220
        res_dir = '/foo/performance_results/'
 
221
        expected_dir = '{}machine-0'.format(res_dir)
 
222
        machine_ids = ['0']
51
223
 
52
224
        with patch.object(gpr.os, 'makedirs', autospec=True) as m_makedirs:
53
225
            self.assertEqual(
54
226
                res_dir,
55
 
                gpr.dump_performance_metrics_logs('/foo', client))
56
 
        m_makedirs.assert_called_once_with(res_dir)
 
227
                gpr.dump_performance_metrics_logs('/foo', client, machine_ids))
 
228
        m_makedirs.assert_called_once_with(expected_dir)
57
229
        expected_calls = [
58
230
            call(
59
231
                'scp',
60
 
                ('--', '-r', '0:/var/lib/collectd/rrd/localhost/*', res_dir)),
 
232
                ('--', '-r',
 
233
                 '0:/var/lib/collectd/rrd/localhost/*', expected_dir)),
61
234
            call(
62
235
                'scp',
63
 
                ('0:/tmp/mongodb-stats.log', res_dir)
 
236
                ('0:/tmp/mongodb-stats.log', expected_dir)
64
237
                )]
65
238
        self.assertEqual(
66
239
            client.juju.call_args_list,
67
240
            expected_calls)
68
241
 
 
242
    def test_pulls_rrd_and_mongostats_logs_when_ha_enabled(self):
 
243
        client = Mock()
 
244
        res_dir = '/foo/performance_results/'
 
245
        machine_ids = ['0', '1', '2']
 
246
 
 
247
        with patch.object(gpr.os, 'makedirs', autospec=True) as m_makedirs:
 
248
            self.assertEqual(
 
249
                res_dir,
 
250
                gpr.dump_performance_metrics_logs('/foo', client, machine_ids))
 
251
 
 
252
        makedir_calls = [
 
253
            call('/foo/performance_results/machine-0'),
 
254
            call('/foo/performance_results/machine-1'),
 
255
            call('/foo/performance_results/machine-2')]
 
256
        self.assertListEqual(
 
257
            m_makedirs.call_args_list,
 
258
            makedir_calls)
 
259
 
 
260
        expected_calls = []
 
261
        for m_id in machine_ids:
 
262
            expected_dir = '{}machine-{}'.format(res_dir, m_id)
 
263
            expected_calls.append(
 
264
                call(
 
265
                    'scp',
 
266
                    ('--', '-r',
 
267
                     '{}:/var/lib/collectd/rrd/localhost/*'.format(m_id),
 
268
                     expected_dir)))
 
269
            expected_calls.append(
 
270
                call(
 
271
                    'scp',
 
272
                    ('{}:/tmp/mongodb-stats.log'.format(m_id), expected_dir)))
 
273
 
 
274
        self.assertEqual(
 
275
            client.juju.call_args_list,
 
276
            expected_calls)
 
277
 
 
278
 
 
279
class TestGetControllerLogMessageChunks(TestCase):
 
280
 
 
281
    def test_retains_backwards_compatiable_naming(self):
 
282
        # Previous to the HA addtions the stored data was expected to have a
 
283
        # single machines log under the name 'log_message_chunks'.
 
284
        log_dir = '/foo/logs'
 
285
        machine_ids = ['0']
 
286
        deployments = dict(
 
287
            bootstrap='bootstrap', cleanup='cleanup', deploys='deploys')
 
288
 
 
289
        with patch.object(
 
290
                gpr, 'breakdown_log_by_events_timeframe',
 
291
                autospec=True) as m_blbet:
 
292
            results = gpr._get_controller_log_message_chunks(
 
293
                log_dir, machine_ids, deployments)
 
294
 
 
295
        self.assertListEqual(
 
296
            results.keys(),
 
297
            ['log_message_chunks']
 
298
        )
 
299
 
 
300
        source_log = '/foo/logs/controller/machine-0/machine-0.log.gz'
 
301
        m_blbet.assert_called_once_with(
 
302
            source_log, 'bootstrap', 'cleanup', 'deploys')
 
303
 
 
304
    def test_creates_log_chunks_for_each_controller(self):
 
305
        # Must chunk logs for each controller.
 
306
        log_dir = '/foo/logs'
 
307
        machine_ids = ['0', '1', '2']
 
308
        deployments = dict(
 
309
            bootstrap='bootstrap', cleanup='cleanup', deploys='deploys')
 
310
 
 
311
        with patch.object(
 
312
                gpr, 'breakdown_log_by_events_timeframe',
 
313
                autospec=True) as m_blbet:
 
314
            results = gpr._get_controller_log_message_chunks(
 
315
                log_dir, machine_ids, deployments)
 
316
 
 
317
        self.assertListEqual(
 
318
            sorted(results.keys()),
 
319
            ['log_message_chunks',
 
320
             'log_message_chunks_1',
 
321
             'log_message_chunks_2']
 
322
        )
 
323
 
 
324
        expected_calls = [
 
325
            call('/foo/logs/controller/machine-0/machine-0.log.gz',
 
326
                 'bootstrap', 'cleanup', 'deploys'),
 
327
            call('/foo/logs/controller/machine-1/machine-1.log.gz',
 
328
                 'bootstrap', 'cleanup', 'deploys'),
 
329
            call('/foo/logs/controller/machine-2/machine-2.log.gz',
 
330
                 'bootstrap', 'cleanup', 'deploys')]
 
331
        self.assertListEqual(
 
332
            m_blbet.call_args_list,
 
333
            expected_calls)
 
334
 
69
335
 
70
336
class TestJsonSerialisation(TestCase):
71
337
 
112
378
                gpr.generate_graph_image(
113
379
                    base_dir, results_dir, name, generator))
114
380
        m_crg.assert_called_once_with(
115
 
            '/foo/test/results', '/foo/test/testing_name.png', generator)
 
381
            '/foo/test/results', '/foo/test/test-testing_name.png', generator)
116
382
 
117
383
    def test_generate_cpu_graph(self):
118
384
        image = Mock()