Merge "Prox standalone test case changes:"
[yardstick.git] / yardstick / tests / unit / test_ssh.py
1 # Copyright 2013: Mirantis Inc.
2 # All Rights Reserved.
3 #
4 #    Licensed under the Apache License, Version 2.0 (the "License"); you may
5 #    not use this file except in compliance with the License. You may obtain
6 #    a copy of the License at
7 #
8 #         http://www.apache.org/licenses/LICENSE-2.0
9 #
10 #    Unless required by applicable law or agreed to in writing, software
11 #    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
12 #    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
13 #    License for the specific language governing permissions and limitations
14 #    under the License.
15
16 import os
17 import socket
18 import unittest
19 from io import StringIO
20 from itertools import count
21
22 import mock
23 from oslo_utils import encodeutils
24
25 from yardstick.common import exceptions
26 from yardstick import ssh
27 from yardstick.ssh import SSH
28 from yardstick.ssh import AutoConnectSSH
29
30
31 class FakeParamikoException(Exception):
32     pass
33
34
35 class SSHTestCase(unittest.TestCase):
36     """Test all small SSH methods."""
37
38     def setUp(self):
39         super(SSHTestCase, self).setUp()
40         self.test_client = ssh.SSH("root", "example.net")
41
42     @mock.patch("yardstick.ssh.SSH._get_pkey")
43     def test_construct(self, mock_ssh__get_pkey):
44         mock_ssh__get_pkey.return_value = "pkey"
45         test_ssh = ssh.SSH("root", "example.net", port=33, pkey="key",
46                            key_filename="kf", password="secret")
47         mock_ssh__get_pkey.assert_called_once_with("key")
48         self.assertEqual("root", test_ssh.user)
49         self.assertEqual("example.net", test_ssh.host)
50         self.assertEqual(33, test_ssh.port)
51         self.assertEqual("pkey", test_ssh.pkey)
52         self.assertEqual("kf", test_ssh.key_filename)
53         self.assertEqual("secret", test_ssh.password)
54
55     @mock.patch("yardstick.ssh.SSH._get_pkey")
56     def test_ssh_from_node(self, mock_ssh__get_pkey):
57         mock_ssh__get_pkey.return_value = "pkey"
58         node = {
59             "user": "root", "ip": "example.net", "ssh_port": 33,
60             "key_filename": "kf", "password": "secret"
61         }
62         test_ssh = ssh.SSH.from_node(node)
63         self.assertEqual("root", test_ssh.user)
64         self.assertEqual("example.net", test_ssh.host)
65         self.assertEqual(33, test_ssh.port)
66         self.assertEqual("kf", test_ssh.key_filename)
67         self.assertEqual("secret", test_ssh.password)
68
69     @mock.patch("yardstick.ssh.SSH._get_pkey")
70     def test_ssh_from_node_password_default(self, mock_ssh__get_pkey):
71         mock_ssh__get_pkey.return_value = "pkey"
72         node = {
73             "user": "root", "ip": "example.net", "ssh_port": 33,
74             "key_filename": "kf"
75         }
76         test_ssh = ssh.SSH.from_node(node)
77         self.assertEqual("root", test_ssh.user)
78         self.assertEqual("example.net", test_ssh.host)
79         self.assertEqual(33, test_ssh.port)
80         self.assertEqual("kf", test_ssh.key_filename)
81         self.assertIsNone(test_ssh.password)
82
83     @mock.patch("yardstick.ssh.SSH._get_pkey")
84     def test_ssh_from_node_ssh_port_default(self, mock_ssh__get_pkey):
85         mock_ssh__get_pkey.return_value = "pkey"
86         node = {
87             "user": "root", "ip": "example.net",
88             "key_filename": "kf", "password": "secret"
89         }
90         test_ssh = ssh.SSH.from_node(node)
91         self.assertEqual("root", test_ssh.user)
92         self.assertEqual("example.net", test_ssh.host)
93         self.assertEqual(ssh.SSH.SSH_PORT, test_ssh.port)
94         self.assertEqual("kf", test_ssh.key_filename)
95         self.assertEqual("secret", test_ssh.password)
96
97     @mock.patch("yardstick.ssh.SSH._get_pkey")
98     def test_ssh_from_node_key_filename_default(self, mock_ssh__get_pkey):
99         mock_ssh__get_pkey.return_value = "pkey"
100         node = {
101             "user": "root", "ip": "example.net", "ssh_port": 33,
102             "password": "secret"
103         }
104         test_ssh = ssh.SSH.from_node(node)
105         self.assertEqual("root", test_ssh.user)
106         self.assertEqual("example.net", test_ssh.host)
107         self.assertEqual(33, test_ssh.port)
108         self.assertIsNone(test_ssh.key_filename)
109         self.assertEqual("secret", test_ssh.password)
110
111     def test_construct_default(self):
112         self.assertEqual("root", self.test_client.user)
113         self.assertEqual("example.net", self.test_client.host)
114         self.assertEqual(22, self.test_client.port)
115         self.assertIsNone(self.test_client.pkey)
116         self.assertIsNone(self.test_client.key_filename)
117         self.assertIsNone(self.test_client.password)
118
119     @mock.patch("yardstick.ssh.paramiko")
120     def test__get_pkey_invalid(self, mock_paramiko):
121         mock_paramiko.SSHException = FakeParamikoException
122         rsa = mock_paramiko.rsakey.RSAKey
123         dss = mock_paramiko.dsskey.DSSKey
124         rsa.from_private_key.side_effect = mock_paramiko.SSHException
125         dss.from_private_key.side_effect = mock_paramiko.SSHException
126         self.assertRaises(exceptions.SSHError, self.test_client._get_pkey, "key")
127
128     @mock.patch("yardstick.ssh.six.moves.StringIO")
129     @mock.patch("yardstick.ssh.paramiko")
130     def test__get_pkey_dss(self, mock_paramiko, mock_string_io):
131         mock_paramiko.SSHException = FakeParamikoException
132         mock_string_io.return_value = "string_key"
133         mock_paramiko.dsskey.DSSKey.from_private_key.return_value = "dss_key"
134         rsa = mock_paramiko.rsakey.RSAKey
135         rsa.from_private_key.side_effect = mock_paramiko.SSHException
136         key = self.test_client._get_pkey("key")
137         dss_calls = mock_paramiko.dsskey.DSSKey.from_private_key.mock_calls
138         self.assertEqual([mock.call("string_key")], dss_calls)
139         self.assertEqual(key, "dss_key")
140         mock_string_io.assert_called_once_with("key")
141
142     @mock.patch("yardstick.ssh.six.moves.StringIO")
143     @mock.patch("yardstick.ssh.paramiko")
144     def test__get_pkey_rsa(self, mock_paramiko, mock_string_io):
145         mock_paramiko.SSHException = FakeParamikoException
146         mock_string_io.return_value = "string_key"
147         mock_paramiko.rsakey.RSAKey.from_private_key.return_value = "rsa_key"
148         dss = mock_paramiko.dsskey.DSSKey
149         dss.from_private_key.side_effect = mock_paramiko.SSHException
150         key = self.test_client._get_pkey("key")
151         rsa_calls = mock_paramiko.rsakey.RSAKey.from_private_key.mock_calls
152         self.assertEqual([mock.call("string_key")], rsa_calls)
153         self.assertEqual(key, "rsa_key")
154         mock_string_io.assert_called_once_with("key")
155
156     @mock.patch("yardstick.ssh.SSH._get_pkey")
157     @mock.patch("yardstick.ssh.paramiko")
158     def test__get_client(self, mock_paramiko, mock_ssh__get_pkey):
159         mock_ssh__get_pkey.return_value = "key"
160         fake_client = mock.Mock()
161         mock_paramiko.SSHClient.return_value = fake_client
162         mock_paramiko.AutoAddPolicy.return_value = "autoadd"
163
164         test_ssh = ssh.SSH("admin", "example.net", pkey="key")
165         client = test_ssh._get_client()
166
167         self.assertEqual(fake_client, client)
168         client_calls = [
169             mock.call.set_missing_host_key_policy("autoadd"),
170             mock.call.connect("example.net", username="admin",
171                               port=22, pkey="key", key_filename=None,
172                               password=None,
173                               allow_agent=False, look_for_keys=False,
174                               timeout=1),
175         ]
176         self.assertEqual(client_calls, client.mock_calls)
177
178     @mock.patch("yardstick.ssh.SSH._get_pkey")
179     @mock.patch("yardstick.ssh.paramiko")
180     def test__get_client_with_exception(self, mock_paramiko, mock_ssh__get_pkey):
181         class MyError(Exception):
182             pass
183
184         mock_ssh__get_pkey.return_value = "pkey"
185         fake_client = mock.Mock()
186         fake_client.connect.side_effect = MyError
187         fake_client.set_missing_host_key_policy.return_value = None
188         mock_paramiko.SSHClient.return_value = fake_client
189         mock_paramiko.AutoAddPolicy.return_value = "autoadd"
190
191         test_ssh = ssh.SSH("admin", "example.net", pkey="key")
192
193         with self.assertRaises(exceptions.SSHError) as raised:
194             test_ssh._get_client()
195
196         mock_paramiko.SSHClient.assert_called_once()
197         mock_paramiko.AutoAddPolicy.assert_called_once()
198         fake_client.set_missing_host_key_policy.assert_called_once()
199         fake_client.connect.assert_called_once()
200         exc_str = str(raised.exception)
201         self.assertIn('raised during connect', exc_str)
202         self.assertIn('MyError', exc_str)
203
204     @mock.patch("yardstick.ssh.SSH._get_pkey")
205     @mock.patch("yardstick.ssh.paramiko")
206     def test_copy(self, mock_paramiko, mock_ssh__get_pkey):
207         mock_ssh__get_pkey.return_value = "pkey"
208         fake_client = mock.Mock()
209         fake_client.connect.side_effect = IOError
210         mock_paramiko.SSHClient.return_value = fake_client
211         mock_paramiko.AutoAddPolicy.return_value = "autoadd"
212
213         test_ssh = ssh.SSH("admin", "example.net", pkey="key")
214         result = test_ssh.copy()
215         self.assertIsNot(test_ssh, result)
216
217     def test_close(self):
218         with mock.patch.object(self.test_client, "_client") as m_client:
219             self.test_client.close()
220         m_client.close.assert_called_once_with()
221         self.assertFalse(self.test_client._client)
222
223     @mock.patch("yardstick.ssh.six.moves.StringIO")
224     def test_execute(self, mock_string_io):
225         mock_string_io.side_effect = stdio = [mock.Mock(), mock.Mock()]
226         stdio[0].read.return_value = "stdout fake data"
227         stdio[1].read.return_value = "stderr fake data"
228         with mock.patch.object(self.test_client, "run", return_value=0)\
229                 as mock_run:
230             status, stdout, stderr = self.test_client.execute(
231                 "cmd",
232                 stdin="fake_stdin",
233                 timeout=43)
234         mock_run.assert_called_once_with(
235             "cmd", stdin="fake_stdin", stdout=stdio[0],
236             stderr=stdio[1], timeout=43, raise_on_error=False)
237         self.assertEqual(0, status)
238         self.assertEqual("stdout fake data", stdout)
239         self.assertEqual("stderr fake data", stderr)
240
241     @mock.patch("yardstick.ssh.six.moves.StringIO")
242     def test_execute_raise_on_error_passed(self, mock_string_io):
243         mock_string_io.side_effect = stdio = [mock.Mock(), mock.Mock()]
244         stdio[0].read.return_value = "stdout fake data"
245         stdio[1].read.return_value = "stderr fake data"
246         with mock.patch.object(self.test_client, "run", return_value=0) \
247                 as mock_run:
248             status, stdout, stderr = self.test_client.execute(
249                 "cmd",
250                 stdin="fake_stdin",
251                 timeout=43,
252                 raise_on_error=True)
253         mock_run.assert_called_once_with(
254             "cmd", stdin="fake_stdin", stdout=stdio[0],
255             stderr=stdio[1], timeout=43, raise_on_error=True)
256         self.assertEqual(0, status)
257         self.assertEqual("stdout fake data", stdout)
258         self.assertEqual("stderr fake data", stderr)
259
260     @mock.patch("yardstick.ssh.time")
261     def test_wait_timeout(self, mock_time):
262         mock_time.time.side_effect = [1, 50, 150]
263         self.test_client.execute = mock.Mock(side_effect=[exceptions.SSHError,
264                                                           exceptions.SSHError,
265                                                           0])
266         self.assertRaises(exceptions.SSHTimeout, self.test_client.wait)
267         self.assertEqual([mock.call("uname")] * 2,
268                          self.test_client.execute.mock_calls)
269
270     @mock.patch("yardstick.ssh.time")
271     def test_wait(self, mock_time):
272         mock_time.time.side_effect = [1, 50, 100]
273         self.test_client.execute = mock.Mock(side_effect=[exceptions.SSHError,
274                                                           exceptions.SSHError,
275                                                           0])
276         self.test_client.wait()
277         self.assertEqual([mock.call("uname")] * 3,
278                          self.test_client.execute.mock_calls)
279
280     @mock.patch("yardstick.ssh.paramiko")
281     def test_send_command(self, _):
282         paramiko_sshclient = self.test_client._get_client()
283         with mock.patch.object(paramiko_sshclient, "exec_command") \
284                 as mock_paramiko_exec_command:
285             self.test_client.send_command('cmd')
286         mock_paramiko_exec_command.assert_called_once_with('cmd',
287                                                            get_pty=True)
288
289
290 class SSHRunTestCase(unittest.TestCase):
291     """Test SSH.run method in different aspects.
292
293     Also tested method "execute".
294     """
295
296     def setUp(self):
297         super(SSHRunTestCase, self).setUp()
298
299         self.fake_client = mock.Mock()
300         self.fake_session = mock.Mock()
301         self.fake_transport = mock.Mock()
302
303         self.fake_transport.open_session.return_value = self.fake_session
304         self.fake_client.get_transport.return_value = self.fake_transport
305
306         self.fake_session.recv_ready.return_value = False
307         self.fake_session.recv_stderr_ready.return_value = False
308         self.fake_session.send_ready.return_value = False
309         self.fake_session.exit_status_ready.return_value = True
310         self.fake_session.recv_exit_status.return_value = 0
311
312         self.test_client = ssh.SSH("admin", "example.net")
313         self.test_client._get_client = mock.Mock(return_value=self.fake_client)
314
315     @mock.patch("yardstick.ssh.select")
316     def test_execute(self, mock_select):
317         mock_select.select.return_value = ([], [], [])
318         self.fake_session.recv_ready.side_effect = [1, 0, 0]
319         self.fake_session.recv_stderr_ready.side_effect = [1, 0]
320         self.fake_session.recv.return_value = "ok"
321         self.fake_session.recv_stderr.return_value = "error"
322         self.fake_session.exit_status_ready.return_value = 1
323         self.fake_session.recv_exit_status.return_value = 127
324         self.assertEqual((127, "ok", "error"), self.test_client.execute("cmd"))
325         self.fake_session.exec_command.assert_called_once_with("cmd")
326
327     @mock.patch("yardstick.ssh.select")
328     def test_execute_args(self, mock_select):
329         mock_select.select.return_value = ([], [], [])
330         self.fake_session.recv_ready.side_effect = [1, 0, 0]
331         self.fake_session.recv_stderr_ready.side_effect = [1, 0]
332         self.fake_session.recv.return_value = "ok"
333         self.fake_session.recv_stderr.return_value = "error"
334         self.fake_session.exit_status_ready.return_value = 1
335         self.fake_session.recv_exit_status.return_value = 127
336
337         result = self.test_client.execute("cmd arg1 'arg2 with space'")
338         self.assertEqual((127, "ok", "error"), result)
339         self.fake_session.exec_command.assert_called_once_with(
340             "cmd arg1 'arg2 with space'")
341
342     @mock.patch("yardstick.ssh.select")
343     def test_run(self, mock_select):
344         mock_select.select.return_value = ([], [], [])
345         self.assertEqual(0, self.test_client.run("cmd"))
346
347     @mock.patch("yardstick.ssh.select")
348     def test_run_nonzero_status(self, mock_select):
349         mock_select.select.return_value = ([], [], [])
350         self.fake_session.recv_exit_status.return_value = 1
351         self.assertRaises(exceptions.SSHError, self.test_client.run, "cmd")
352         self.assertEqual(1, self.test_client.run("cmd", raise_on_error=False))
353
354     @mock.patch("yardstick.ssh.select")
355     def test_run_stdout(self, mock_select):
356         mock_select.select.return_value = ([], [], [])
357         self.fake_session.recv_ready.side_effect = [True, True, False]
358         self.fake_session.recv.side_effect = ["ok1", "ok2"]
359         stdout = mock.Mock()
360         self.test_client.run("cmd", stdout=stdout)
361         self.assertEqual([mock.call("ok1"), mock.call("ok2")],
362                          stdout.write.mock_calls)
363
364     @mock.patch("yardstick.ssh.select")
365     def test_run_stderr(self, mock_select):
366         mock_select.select.return_value = ([], [], [])
367         self.fake_session.recv_stderr_ready.side_effect = [True, False]
368         self.fake_session.recv_stderr.return_value = "error"
369         stderr = mock.Mock()
370         self.test_client.run("cmd", stderr=stderr)
371         stderr.write.assert_called_once_with("error")
372
373     @mock.patch("yardstick.ssh.select")
374     def test_run_stdin(self, mock_select):
375         """Test run method with stdin.
376
377         Third send call was called with "e2" because only 3 bytes was sent
378         by second call. So remainig 2 bytes of "line2" was sent by third call.
379         """
380         mock_select.select.return_value = ([], [], [])
381         self.fake_session.exit_status_ready.side_effect = [0, 0, 0, True]
382         self.fake_session.send_ready.return_value = True
383         self.fake_session.send.side_effect = [5, 3, 2]
384         fake_stdin = mock.Mock()
385         fake_stdin.read.side_effect = ["line1", "line2", ""]
386         fake_stdin.closed = False
387
388         def close():
389             fake_stdin.closed = True
390         fake_stdin.close = mock.Mock(side_effect=close)
391         self.test_client.run("cmd", stdin=fake_stdin)
392         call = mock.call
393         send_calls = [call(encodeutils.safe_encode("line1", "utf-8")),
394                       call(encodeutils.safe_encode("line2", "utf-8")),
395                       call(encodeutils.safe_encode("e2", "utf-8"))]
396         self.assertEqual(send_calls, self.fake_session.send.mock_calls)
397
398     @mock.patch("yardstick.ssh.select")
399     def test_run_stdin_keep_open(self, mock_select):
400         """Test run method with stdin.
401
402         Third send call was called with "e2" because only 3 bytes was sent
403         by second call. So remainig 2 bytes of "line2" was sent by third call.
404         """
405         mock_select.select.return_value = ([], [], [])
406         self.fake_session.exit_status_ready.side_effect = [0, 0, 0, True]
407         self.fake_session.send_ready.return_value = True
408         self.fake_session.send.side_effect = len
409         fake_stdin = StringIO(u"line1\nline2\n")
410         self.test_client.run("cmd", stdin=fake_stdin, keep_stdin_open=True)
411         call = mock.call
412         send_calls = [call(encodeutils.safe_encode("line1\nline2\n", "utf-8"))]
413         self.assertEqual(send_calls, self.fake_session.send.mock_calls)
414
415     @mock.patch("yardstick.ssh.select")
416     def test_run_select_error(self, mock_select):
417         self.fake_session.exit_status_ready.return_value = False
418         mock_select.select.return_value = ([], [], [True])
419         self.assertRaises(exceptions.SSHError, self.test_client.run, "cmd")
420
421     @mock.patch("yardstick.ssh.time")
422     @mock.patch("yardstick.ssh.select")
423     def test_run_timemout(self, mock_select, mock_time):
424         mock_time.time.side_effect = [1, 3700]
425         mock_select.select.return_value = ([], [], [])
426         self.fake_session.exit_status_ready.return_value = False
427         self.assertRaises(exceptions.SSHTimeout, self.test_client.run, "cmd")
428
429     @mock.patch("yardstick.ssh.open", create=True)
430     def test__put_file_shell(self, mock_open):
431         with mock.patch.object(self.test_client, "run") as run_mock:
432             self.test_client._put_file_shell("localfile", "remotefile", 0o42)
433             run_mock.assert_called_once_with(
434                 'cat > "remotefile"&& chmod -- 042 "remotefile"',
435                 stdin=mock_open.return_value.__enter__.return_value)
436
437     @mock.patch("yardstick.ssh.open", create=True)
438     def test__put_file_shell_space(self, mock_open):
439         with mock.patch.object(self.test_client, "run") as run_mock:
440             self.test_client._put_file_shell("localfile",
441                                              "filename with space", 0o42)
442             run_mock.assert_called_once_with(
443                 'cat > "filename with space"&& chmod -- 042 "filename with '
444                 'space"',
445                 stdin=mock_open.return_value.__enter__.return_value)
446
447     @mock.patch("yardstick.ssh.open", create=True)
448     def test__put_file_shell_tilde(self, mock_open):
449         with mock.patch.object(self.test_client, "run") as run_mock:
450             self.test_client._put_file_shell("localfile", "~/remotefile", 0o42)
451             run_mock.assert_called_once_with(
452                 'cat > ~/"remotefile"&& chmod -- 042 ~/"remotefile"',
453                 stdin=mock_open.return_value.__enter__.return_value)
454
455     @mock.patch("yardstick.ssh.open", create=True)
456     def test__put_file_shell_tilde_spaces(self, mock_open):
457         with mock.patch.object(self.test_client, "run") as run_mock:
458             self.test_client._put_file_shell("localfile", "~/file with space",
459                                              0o42)
460             run_mock.assert_called_once_with(
461                 'cat > ~/"file with space"&& chmod -- 042 ~/"file with space"',
462                 stdin=mock_open.return_value.__enter__.return_value)
463
464     @mock.patch("yardstick.ssh.os.stat")
465     def test__put_file_sftp(self, mock_stat):
466         sftp = self.fake_client.open_sftp.return_value = mock.MagicMock()
467         sftp.__enter__.return_value = sftp
468
469         mock_stat.return_value = os.stat_result([0o753] + [0] * 9)
470
471         self.test_client._put_file_sftp("localfile", "remotefile")
472
473         sftp.put.assert_called_once_with("localfile", "remotefile")
474         mock_stat.assert_any_call("localfile")
475         sftp.chmod.assert_any_call("remotefile", 0o753)
476         sftp.__exit__.assert_called_once_with(None, None, None)
477
478     def test__put_file_sftp_mode(self):
479         sftp = self.fake_client.open_sftp.return_value = mock.MagicMock()
480         sftp.__enter__.return_value = sftp
481
482         self.test_client._put_file_sftp("localfile", "remotefile", mode=0o753)
483
484         sftp.put.assert_called_once_with("localfile", "remotefile")
485         sftp.chmod.assert_called_once_with("remotefile", 0o753)
486         sftp.__exit__.assert_called_once_with(None, None, None)
487
488     def test_put_file_SSHException(self):
489         exc = ssh.paramiko.SSHException
490         self.test_client._put_file_sftp = mock.Mock(side_effect=exc())
491         self.test_client._put_file_shell = mock.Mock()
492
493         self.test_client.put_file("foo", "bar", 42)
494         self.test_client._put_file_sftp.assert_called_once_with("foo", "bar",
495                                                                 mode=42)
496         self.test_client._put_file_shell.assert_called_once_with("foo", "bar",
497                                                                  mode=42)
498
499     def test_put_file_socket_error(self):
500         exc = socket.error
501         self.test_client._put_file_sftp = mock.Mock(side_effect=exc())
502         self.test_client._put_file_shell = mock.Mock()
503
504         self.test_client.put_file("foo", "bar", 42)
505         self.test_client._put_file_sftp.assert_called_once_with("foo", "bar",
506                                                                 mode=42)
507         self.test_client._put_file_shell.assert_called_once_with("foo", "bar",
508                                                                  mode=42)
509
510     @mock.patch("yardstick.ssh.os.stat")
511     def test_put_file_obj_with_mode(self, mock_stat):
512         sftp = self.fake_client.open_sftp.return_value = mock.MagicMock()
513         sftp.__enter__.return_value = sftp
514
515         mock_stat.return_value = os.stat_result([0o753] + [0] * 9)
516
517         self.test_client.put_file_obj("localfile", "remotefile", 'my_mode')
518
519         sftp.__enter__.assert_called_once()
520         sftp.putfo.assert_called_once_with("localfile", "remotefile")
521         sftp.chmod.assert_called_once_with("remotefile", 'my_mode')
522         sftp.__exit__.assert_called_once_with(None, None, None)
523
524
525 class TestAutoConnectSSH(unittest.TestCase):
526
527     def test__connect_loop(self):
528         auto_connect_ssh = AutoConnectSSH('user1', 'host1', wait=0)
529         auto_connect_ssh._get_client = mock__get_client = mock.Mock()
530
531         auto_connect_ssh._connect()
532         mock__get_client.assert_called_once()
533
534     def test___init___negative(self):
535         with self.assertRaises(TypeError):
536             AutoConnectSSH('user1', 'host1', wait=['wait'])
537
538         with self.assertRaises(ValueError):
539             AutoConnectSSH('user1', 'host1', wait='wait')
540
541     @mock.patch('yardstick.ssh.time')
542     def test__connect_loop_ssh_error(self, mock_time):
543         mock_time.time.side_effect = count()
544
545         auto_connect_ssh = AutoConnectSSH('user1', 'host1', wait=10)
546         auto_connect_ssh._get_client = mock__get_client = mock.Mock()
547         mock__get_client.side_effect = exceptions.SSHError
548
549         with self.assertRaises(exceptions.SSHTimeout):
550             auto_connect_ssh._connect()
551
552         self.assertEqual(mock_time.time.call_count, 12)
553
554     def test_get_file_obj(self):
555         auto_connect_ssh = AutoConnectSSH('user1', 'host1', wait=10)
556         auto_connect_ssh._get_client = mock__get_client = mock.Mock()
557         mock_client = mock__get_client()
558         mock_open_sftp = mock_client.open_sftp()
559         mock_sftp = mock.Mock()
560         mock_open_sftp.__enter__ = mock.Mock(return_value=mock_sftp)
561         mock_open_sftp.__exit__ = mock.Mock()
562
563         auto_connect_ssh.get_file_obj('remote/path', mock.Mock())
564
565         mock_sftp.getfo.assert_called_once()
566
567     def test__make_dict(self):
568         auto_connect_ssh = AutoConnectSSH('user1', 'host1')
569
570         expected = {
571             'user': 'user1',
572             'host': 'host1',
573             'port': SSH.SSH_PORT,
574             'pkey': None,
575             'key_filename': None,
576             'password': None,
577             'name': None,
578             'wait': AutoConnectSSH.DEFAULT_WAIT_TIMEOUT,
579         }
580         result = auto_connect_ssh._make_dict()
581         self.assertDictEqual(result, expected)
582
583     def test_get_class(self):
584         auto_connect_ssh = AutoConnectSSH('user1', 'host1')
585
586         self.assertEqual(auto_connect_ssh.get_class(), AutoConnectSSH)
587
588     def test_drop_connection(self):
589         auto_connect_ssh = AutoConnectSSH('user1', 'host1')
590         self.assertFalse(auto_connect_ssh._client)
591         auto_connect_ssh._client = True
592         auto_connect_ssh.drop_connection()
593         self.assertFalse(auto_connect_ssh._client)
594
595     @mock.patch('yardstick.ssh.SCPClient')
596     def test_put(self, mock_scp_client_type):
597         auto_connect_ssh = AutoConnectSSH('user1', 'host1')
598         auto_connect_ssh._client = mock.Mock()
599
600         auto_connect_ssh.put('a', 'z')
601         with mock_scp_client_type() as mock_scp_client:
602             mock_scp_client.put.assert_called_once()
603
604     @mock.patch('yardstick.ssh.SCPClient')
605     def test_get(self, mock_scp_client_type):
606         auto_connect_ssh = AutoConnectSSH('user1', 'host1')
607         auto_connect_ssh._client = mock.Mock()
608
609         auto_connect_ssh.get('a', 'z')
610         with mock_scp_client_type() as mock_scp_client:
611             mock_scp_client.get.assert_called_once()
612
613     def test_put_file(self):
614         auto_connect_ssh = AutoConnectSSH('user1', 'host1')
615         auto_connect_ssh._client = mock.Mock()
616         auto_connect_ssh._put_file_sftp = mock_put_sftp = mock.Mock()
617
618         auto_connect_ssh.put_file('a', 'b')
619         mock_put_sftp.assert_called_once()
620
621     def test_execute(self):
622         auto_connect_ssh = AutoConnectSSH('user1', 'host1')
623         auto_connect_ssh._client = mock.Mock()
624         auto_connect_ssh.run = mock.Mock(return_value=0)
625         exit_code, _, _ = auto_connect_ssh.execute('')
626         self.assertEqual(exit_code, 0)
627
628     def _mock_run(self, *args, **kwargs):
629         if args[0] == 'ls':
630             if kwargs.get('raise_on_error'):
631                 raise exceptions.SSHError(error_msg='Command error')
632             return 1
633         return 0
634
635     def test_execute_command_error(self):
636         auto_connect_ssh = AutoConnectSSH('user1', 'host1')
637         auto_connect_ssh._client = mock.Mock()
638         auto_connect_ssh.run = mock.Mock(side_effect=self._mock_run)
639         self.assertRaises(exceptions.SSHError, auto_connect_ssh.execute, 'ls',
640                           raise_on_error=True)
641         exit_code, _, _ = auto_connect_ssh.execute('ls')
642         self.assertNotEqual(exit_code, 0)