Skip to content

Commit 2a2550a

Browse files
penguinologpenguinolog
authored
Reduce places with paramiko logging changes, tests clean from py27 code (#88)
1 parent 2d74136 commit 2a2550a

File tree

8 files changed

+1105
-1912
lines changed

8 files changed

+1105
-1912
lines changed

‎exec_helpers/ssh_client.py‎

Lines changed: 0 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -26,7 +26,6 @@
2626
__all__ = ("SSHClient",)
2727

2828
logger = logging.getLogger(__name__)
29-
logging.getLogger("paramiko").setLevel(logging.WARNING)
3029

3130

3231
class SSHClient(SSHClientBase):

‎setup.cfg‎

Lines changed: 3 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -39,8 +39,10 @@ exclude =
3939
__init__.py,
4040
docs
4141
ignore =
42-
E203
42+
E203,
43+
W503
4344
# whitespace before ':'
45+
# line break before binary operator
4446
show-pep8 = True
4547
show-source = True
4648
count = True

‎test/test_exec_result.py‎

Lines changed: 81 additions & 116 deletions
Original file line numberDiff line numberDiff line change
@@ -14,10 +14,6 @@
1414
# License for the specific language governing permissions and limitations
1515
# under the License.
1616

17-
from __future__ import absolute_import
18-
from __future__ import division
19-
from __future__ import unicode_literals
20-
2117
# pylint: disable=no-self-use
2218

2319
import unittest
@@ -27,197 +23,166 @@
2723
import exec_helpers
2824

2925

30-
cmd = "ls -la | awk \'{print $1}\'"
26+
cmd = "ls -la | awk '{print $1}'"
3127

3228

3329
# noinspection PyTypeChecker
3430
class TestExecResult(unittest.TestCase):
35-
@mock.patch('exec_helpers.exec_result.logger')
31+
@mock.patch("exec_helpers.exec_result.logger")
3632
def test_create_minimal(self, logger):
3733
"""Test defaults"""
3834
result = exec_helpers.ExecResult(cmd=cmd)
3935
self.assertEqual(result.cmd, cmd)
40-
self.assertEqual(result.cmd, result['cmd'])
36+
self.assertEqual(result.cmd, result["cmd"])
4137
self.assertEqual(result.stdout, ())
42-
self.assertEqual(result.stdout, result['stdout'])
38+
self.assertEqual(result.stdout, result["stdout"])
4339
self.assertEqual(result.stderr, ())
44-
self.assertEqual(result.stderr, result['stderr'])
40+
self.assertEqual(result.stderr, result["stderr"])
4541
self.assertEqual(result.stdout_bin, bytearray())
4642
self.assertEqual(result.stderr_bin, bytearray())
47-
self.assertEqual(result.stdout_str, '')
48-
self.assertEqual(result.stdout_str, result['stdout_str'])
49-
self.assertEqual(result.stderr_str, '')
50-
self.assertEqual(result.stderr_str, result['stderr_str'])
51-
self.assertEqual(result.stdout_brief, '')
52-
self.assertEqual(result.stdout_brief, result['stdout_brief'])
53-
self.assertEqual(result.stderr_brief, '')
54-
self.assertEqual(result.stderr_brief, result['stderr_brief'])
43+
self.assertEqual(result.stdout_str, "")
44+
self.assertEqual(result.stdout_str, result["stdout_str"])
45+
self.assertEqual(result.stderr_str, "")
46+
self.assertEqual(result.stderr_str, result["stderr_str"])
47+
self.assertEqual(result.stdout_brief, "")
48+
self.assertEqual(result.stdout_brief, result["stdout_brief"])
49+
self.assertEqual(result.stderr_brief, "")
50+
self.assertEqual(result.stderr_brief, result["stderr_brief"])
5551
self.assertEqual(result.exit_code, exec_helpers.ExitCodes.EX_INVALID)
56-
self.assertEqual(result.exit_code, result['exit_code'])
52+
self.assertEqual(result.exit_code, result["exit_code"])
5753
self.assertEqual(
5854
repr(result),
59-
'{cls}(cmd={cmd!r}, stdout={stdout}, stderr={stderr}, '
60-
'exit_code={exit_code!s})'.format(
55+
"{cls}(cmd={cmd!r}, stdout={stdout}, stderr={stderr}, "
56+
"exit_code={exit_code!s})".format(
6157
cls=exec_helpers.ExecResult.__name__,
6258
cmd=cmd,
6359
stdout=(),
6460
stderr=(),
65-
exit_code=exec_helpers.ExitCodes.EX_INVALID
66-
)
61+
exit_code=exec_helpers.ExitCodes.EX_INVALID,
62+
),
6763
)
6864
self.assertEqual(
6965
str(result),
7066
"{cls}(\n\tcmd={cmd!r},"
7167
"\n\t stdout=\n'{stdout_brief}',"
7268
"\n\tstderr=\n'{stderr_brief}', "
73-
'\n\texit_code={exit_code!s}\n)'.format(
69+
"\n\texit_code={exit_code!s}\n)".format(
7470
cls=exec_helpers.ExecResult.__name__,
7571
cmd=cmd,
76-
stdout_brief='',
77-
stderr_brief='',
78-
exit_code=exec_helpers.ExitCodes.EX_INVALID
79-
)
72+
stdout_brief="",
73+
stderr_brief="",
74+
exit_code=exec_helpers.ExitCodes.EX_INVALID,
75+
),
8076
)
8177

8278
with self.assertRaises(IndexError):
83-
# pylint: disable=pointless-statement
8479
# noinspection PyStatementEffect
85-
result['nonexistent']
86-
# pylint: enable=pointless-statement
80+
result["nonexistent"] # pylint: disable=pointless-statement
8781

8882
with self.assertRaises(exec_helpers.ExecHelperError):
89-
# pylint: disable=pointless-statement
9083
# noinspection PyStatementEffect
91-
result['stdout_json']
92-
# pylint: enable=pointless-statement
93-
logger.assert_has_calls((
94-
mock.call.exception(
95-
"{cmd} stdout is not valid json:\n"
96-
"{stdout_str!r}\n".format(
97-
cmd=cmd,
98-
stdout_str='')),
99-
))
100-
self.assertIsNone(result['stdout_yaml'])
84+
result["stdout_json"] # pylint: disable=pointless-statement
85+
logger.assert_has_calls(
86+
(
87+
mock.call.exception(
88+
"{cmd} stdout is not valid json:\n" "{stdout_str!r}\n".format(cmd=cmd, stdout_str="")
89+
),
90+
)
91+
)
92+
self.assertIsNone(result["stdout_yaml"])
10193

10294
self.assertEqual(
103-
hash(result),
104-
hash(
105-
(
106-
exec_helpers.ExecResult,
107-
cmd,
108-
None,
109-
(),
110-
(),
111-
exec_helpers.ExitCodes.EX_INVALID
112-
)
113-
)
95+
hash(result), hash((exec_helpers.ExecResult, cmd, None, (), (), exec_helpers.ExitCodes.EX_INVALID))
11496
)
11597

116-
@mock.patch('exec_helpers.exec_result.logger', autospec=True)
98+
@mock.patch("exec_helpers.exec_result.logger", autospec=True)
11799
def test_not_implemented(self, logger):
118100
"""Test assertion on non implemented deserializer"""
119101
result = exec_helpers.ExecResult(cmd=cmd)
120-
deserialize = getattr(result, '_ExecResult__deserialize')
102+
deserialize = getattr(result, "_ExecResult__deserialize")
121103
with self.assertRaises(NotImplementedError):
122-
deserialize('tst')
123-
logger.assert_has_calls((
124-
mock.call.error(
125-
'{fmt} deserialize target is not implemented'.format(
126-
fmt='tst')),
127-
))
104+
deserialize("tst")
105+
logger.assert_has_calls((mock.call.error("{fmt} deserialize target is not implemented".format(fmt="tst")),))
128106

129107
def test_setters(self):
130108
result = exec_helpers.ExecResult(cmd=cmd)
131109
self.assertEqual(result.exit_code, exec_helpers.ExitCodes.EX_INVALID)
132110

133-
tst_stdout = [
134-
b'Test\n',
135-
b'long\n',
136-
b'stdout\n',
137-
b'data\n',
138-
b' \n',
139-
b'5\n',
140-
b'6\n',
141-
b'7\n',
142-
b'8\n',
143-
b'end!\n'
144-
]
145-
146-
tst_stderr = [b'test\n'] * 10
147-
148-
with mock.patch('exec_helpers.exec_result.logger', autospec=True):
111+
tst_stdout = [b"Test\n", b"long\n", b"stdout\n", b"data\n", b" \n", b"5\n", b"6\n", b"7\n", b"8\n", b"end!\n"]
112+
113+
tst_stderr = [b"test\n"] * 10
114+
115+
with mock.patch("exec_helpers.exec_result.logger", autospec=True):
149116
result.read_stdout(tst_stdout)
150117
self.assertEqual(result.stdout, tuple(tst_stdout))
151-
self.assertEqual(result.stdout, result['stdout'])
118+
self.assertEqual(result.stdout, result["stdout"])
152119

153-
with mock.patch('exec_helpers.exec_result.logger', autospec=True):
120+
with mock.patch("exec_helpers.exec_result.logger", autospec=True):
154121
result.read_stderr(tst_stderr)
155122
self.assertEqual(result.stderr, tuple(tst_stderr))
156-
self.assertEqual(result.stderr, result['stderr'])
123+
self.assertEqual(result.stderr, result["stderr"])
157124

158125
with self.assertRaises(TypeError):
159-
result.exit_code = 'code'
126+
result.exit_code = "code"
160127

161128
result.exit_code = 0
162129
self.assertEqual(result.exit_code, 0)
163-
self.assertEqual(result.exit_code, result['exit_code'])
130+
self.assertEqual(result.exit_code, result["exit_code"])
164131

165132
with self.assertRaises(RuntimeError):
166133
result.exit_code = 1
167134

168135
self.assertEqual(result.exit_code, 0)
169136

170-
self.assertEqual(result.stdout_bin, bytearray(b''.join(tst_stdout)))
171-
self.assertEqual(result.stderr_bin, bytearray(b''.join(tst_stderr)))
137+
self.assertEqual(result.stdout_bin, bytearray(b"".join(tst_stdout)))
138+
self.assertEqual(result.stderr_bin, bytearray(b"".join(tst_stderr)))
172139

173-
stdout_br = tst_stdout[:3] + [b'...\n'] + tst_stdout[-3:]
174-
stderr_br = tst_stderr[:3] + [b'...\n'] + tst_stderr[-3:]
140+
stdout_br = tst_stdout[:3] + [b"...\n"] + tst_stdout[-3:]
141+
stderr_br = tst_stderr[:3] + [b"...\n"] + tst_stderr[-3:]
175142

176-
stdout_brief = b''.join(stdout_br).strip().decode(encoding='utf-8')
177-
stderr_brief = b''.join(stderr_br).strip().decode(encoding='utf-8')
143+
stdout_brief = b"".join(stdout_br).strip().decode(encoding="utf-8")
144+
stderr_brief = b"".join(stderr_br).strip().decode(encoding="utf-8")
178145

179146
self.assertEqual(result.stdout_brief, stdout_brief)
180147
self.assertEqual(result.stderr_brief, stderr_brief)
181148

182149
def test_json(self):
183-
result = exec_helpers.ExecResult('test', stdout=[b'{"test": true}'])
184-
self.assertEqual(result.stdout_json, {'test': True})
150+
result = exec_helpers.ExecResult("test", stdout=[b'{"test": true}'])
151+
self.assertEqual(result.stdout_json, {"test": True})
185152

186-
@mock.patch('exec_helpers.exec_result.logger', autospec=True)
153+
@mock.patch("exec_helpers.exec_result.logger", autospec=True)
187154
def test_wrong_result(self, logger):
188155
"""Test logging exception if stdout if not a correct json"""
189-
cmd = "ls -la | awk \'{print $1\}\'"
156+
cmd = "ls -la | awk '{print $1\}'"
190157
result = exec_helpers.ExecResult(cmd=cmd)
191158
with self.assertRaises(exec_helpers.ExecHelperError):
192-
# pylint: disable=pointless-statement
193159
# noinspection PyStatementEffect
194-
result.stdout_json
195-
# pylint: enable=pointless-statement
196-
logger.assert_has_calls((
197-
mock.call.exception(
198-
"{cmd} stdout is not valid json:\n"
199-
"{stdout_str!r}\n".format(
200-
cmd=cmd,
201-
stdout_str='')),
202-
))
203-
self.assertIsNone(result['stdout_yaml'])
160+
result.stdout_json # pylint: disable=pointless-statement
161+
logger.assert_has_calls(
162+
(
163+
mock.call.exception(
164+
"{cmd} stdout is not valid json:\n" "{stdout_str!r}\n".format(cmd=cmd, stdout_str="")
165+
),
166+
)
167+
)
168+
self.assertIsNone(result["stdout_yaml"])
204169

205170
def test_not_equal(self):
206171
"""Exec result equality is validated by all fields."""
207-
result1 = exec_helpers.ExecResult('cmd1')
208-
result2 = exec_helpers.ExecResult('cmd2')
172+
result1 = exec_helpers.ExecResult("cmd1")
173+
result2 = exec_helpers.ExecResult("cmd2")
209174
self.assertNotEqual(result1, result2)
210175

211176
result1 = exec_helpers.ExecResult(cmd)
212177
result2 = exec_helpers.ExecResult(cmd)
213-
result1.read_stdout([b'a'])
214-
result2.read_stdout([b'b'])
178+
result1.read_stdout([b"a"])
179+
result2.read_stdout([b"b"])
215180
self.assertNotEqual(result1, result2)
216181

217182
result1 = exec_helpers.ExecResult(cmd)
218183
result2 = exec_helpers.ExecResult(cmd)
219-
result1.read_stderr([b'a'])
220-
result2.read_stderr([b'b'])
184+
result1.read_stderr([b"a"])
185+
result2.read_stderr([b"b"])
221186
self.assertNotEqual(result1, result2)
222187

223188
result1 = exec_helpers.ExecResult(cmd)
@@ -235,23 +200,23 @@ def test_finalize(self):
235200
result.exit_code = 1
236201

237202
with self.assertRaises(RuntimeError):
238-
result.read_stdout([b'out'])
203+
result.read_stdout([b"out"])
239204

240205
with self.assertRaises(RuntimeError):
241-
result.read_stderr([b'err'])
206+
result.read_stderr([b"err"])
242207

243208
def test_stdin_none(self):
244209
result = exec_helpers.ExecResult(cmd, exit_code=0)
245210
self.assertIsNone(result.stdin)
246211

247212
def test_stdin_utf(self):
248-
result = exec_helpers.ExecResult(cmd, stdin=u'STDIN', exit_code=0)
249-
self.assertEqual(result.stdin, u'STDIN')
213+
result = exec_helpers.ExecResult(cmd, stdin="STDIN", exit_code=0)
214+
self.assertEqual(result.stdin, "STDIN")
250215

251216
def test_stdin_bytes(self):
252-
result = exec_helpers.ExecResult(cmd, stdin=b'STDIN', exit_code=0)
253-
self.assertEqual(result.stdin, u'STDIN')
217+
result = exec_helpers.ExecResult(cmd, stdin=b"STDIN", exit_code=0)
218+
self.assertEqual(result.stdin, "STDIN")
254219

255220
def test_stdin_bytearray(self):
256-
result = exec_helpers.ExecResult(cmd, stdin=bytearray(b'STDIN'), exit_code=0)
257-
self.assertEqual(result.stdin, u'STDIN')
221+
result = exec_helpers.ExecResult(cmd, stdin=bytearray(b"STDIN"), exit_code=0)
222+
self.assertEqual(result.stdin, "STDIN")

0 commit comments

Comments
 (0)