tests.test_parser.ConfigParserTestCase.test_socket_defaults_from_config() - Code Metrics - Inspection of "Suppressing output in tests" - greenbone/gvm-tools - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Pull Request — master (#227)

by Jaspar

created 2019-10-30 11:29 UTC

ConfigParserTestCase.test_socket_defaults_from_config() A

↳ Parent: tests.test_parser

Complexity

Conditions

Size

Total Lines	10
Code Lines	8

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
eloc	8
dl	0
loc	10
rs	10
c	0
b	0
f	0
cc	1
nop	1

# -*- coding: utf-8 -*-
# Copyright (C) 2019 Greenbone Networks GmbH
#
# SPDX-License-Identifier: GPL-3.0-or-later
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program.  If not, see <http://www.gnu.org/licenses/>.

import unittest

from pathlib import Path

from gvm.connections import DEFAULT_UNIX_SOCKET_PATH, DEFAULT_TIMEOUT

from gvmtools.parser import CliParser

from . import SuppressOutput

__here__ = Path(__file__).parent.resolve()


class ConfigParserTestCase(unittest.TestCase):
    def setUp(self):
        self.test_config_path = __here__ / 'test.cfg'

        self.assertTrue(self.test_config_path.is_file())

        self.parser = CliParser('TestParser', 'test.log')

    def test_socket_defaults_from_config(self):
        args = self.parser.parse_args(
            ['--config', str(self.test_config_path), 'socket']
        )

        self.assertEqual(args.foo, 'bar')
        self.assertEqual(args.timeout, 1000)
        self.assertEqual(args.gmp_password, 'bar')
        self.assertEqual(args.gmp_username, 'bar')
        self.assertEqual(args.socketpath, '/foo/bar.sock')

    def test_ssh_defaults_from_config(self):
        args = self.parser.parse_args(
            ['--config', str(self.test_config_path), 'ssh', '--hostname', 'foo']
        )

        self.assertEqual(args.foo, 'bar')
        self.assertEqual(args.timeout, 1000)
        self.assertEqual(args.gmp_password, 'bar')
        self.assertEqual(args.gmp_username, 'bar')
        self.assertEqual(args.ssh_password, 'lorem')
        self.assertEqual(args.ssh_username, 'ipsum')
        self.assertEqual(args.port, 123)

    def test_tls_defaults_from_config(self):
        args = self.parser.parse_args(
            ['--config', str(self.test_config_path), 'tls', '--hostname', 'foo']
        )

        self.assertEqual(args.foo, 'bar')
        self.assertEqual(args.timeout, 1000)
        self.assertEqual(args.gmp_password, 'bar')
        self.assertEqual(args.gmp_username, 'bar')
        self.assertEqual(args.certfile, 'foo.cert')
        self.assertEqual(args.keyfile, 'foo.key')
        self.assertEqual(args.cafile, 'foo.ca')
        self.assertEqual(args.port, 123)


class IgnoreConfigParserTestCase(unittest.TestCase):
    def test_unkown_config_file(self):
        test_config_path = __here__ / 'foo.cfg'

        self.assertFalse(test_config_path.is_file())

        self.parser = CliParser('TestParser', 'test.log')

        args = self.parser.parse_args(
            ['--config', str(test_config_path), 'socket']
        )

        self.assertEqual(args.timeout, DEFAULT_TIMEOUT)
        self.assertEqual(args.gmp_password, '')
        self.assertEqual(args.gmp_username, '')
        self.assertEqual(args.socketpath, DEFAULT_UNIX_SOCKET_PATH)

    def test_unkown_config_file_in_unkown_dir(self):
        test_config_path = __here__ / 'foo' / 'foo.cfg'

        self.assertFalse(test_config_path.is_file())

        self.parser = CliParser('TestParser', 'test.log')

        args = self.parser.parse_args(
            ['--config', str(test_config_path), 'socket']
        )

        self.assertEqual(args.timeout, DEFAULT_TIMEOUT)
        self.assertEqual(args.gmp_password, '')
        self.assertEqual(args.gmp_username, '')
        self.assertEqual(args.socketpath, DEFAULT_UNIX_SOCKET_PATH)


class ParserTestCase(unittest.TestCase):
    def setUp(self):
        self.parser = CliParser(
            'TestParser', 'test.log', ignore_config=True, prog='gvm-test-cli'
        )


class RootArgumentsParserTest(ParserTestCase):
    def test_config(self):
        args = self.parser.parse_args(['--config', 'foo.cfg', 'socket'])
        self.assertEqual(args.config, 'foo.cfg')

    def test_defaults(self):
        args = self.parser.parse_args(['socket'])
        self.assertEqual(args.config, '~/.config/gvm-tools.conf')
        self.assertEqual(args.gmp_password, '')
        self.assertEqual(args.gmp_username, '')
        self.assertEqual(args.timeout, 60)
        self.assertIsNone(args.loglevel)

    def test_loglevel(self):
        args = self.parser.parse_args(['--log', 'ERROR', 'socket'])
        self.assertEqual(args.loglevel, 'ERROR')

    def test_loglevel_after_subparser(self):
        with SuppressOutput(suppress_stderr=True):
            with self.assertRaises(SystemExit):
                self.parser.parse_args(['socket', '--log', 'ERROR'])

    def test_timeout(self):
        args = self.parser.parse_args(['--timeout', '1000', 'socket'])
        self.assertEqual(args.timeout, 1000)

    def test_timeout_after_subparser(self):
        with SuppressOutput(suppress_stderr=True):
            with self.assertRaises(SystemExit):
                self.parser.parse_args(['socket', '--timeout', '1000'])

    def test_gmp_username(self):
        args = self.parser.parse_args(['--gmp-username', 'foo', 'socket'])
        self.assertEqual(args.gmp_username, 'foo')

    def test_gmp_username_after_subparser(self):
        with SuppressOutput(suppress_stderr=True):
            with self.assertRaises(SystemExit):
                self.parser.parse_args(['socket', '--gmp-username', 'foo'])

    def test_gmp_password(self):
        args = self.parser.parse_args(['--gmp-password', 'foo', 'socket'])
        self.assertEqual(args.gmp_password, 'foo')

    def test_gmp_password_after_subparser(self):
        with SuppressOutput(suppress_stderr=True):
            with self.assertRaises(SystemExit):
                self.parser.parse_args(['socket', '--gmp-password', 'foo'])

    def test_with_unknown_args(self):
        args, script_args = self.parser.parse_known_args(
            ['--gmp-password', 'foo', 'socket', '--bar', '--bar2']
        )
        self.assertEqual(args.gmp_password, 'foo')
        self.assertEqual(script_args, ['--bar', '--bar2'])


class SocketParserTestCase(ParserTestCase):
    def test_defaults(self):
        args = self.parser.parse_args(['socket'])
        self.assertEqual(args.socketpath, DEFAULT_UNIX_SOCKET_PATH)

    def test_connection_type(self):
        args = self.parser.parse_args(['socket'])
        self.assertEqual(args.connection_type, 'socket')

    def test_sockpath(self):
        args = self.parser.parse_args(['socket', '--sockpath', 'foo.sock'])
        self.assertEqual(args.socketpath, 'foo.sock')

    def test_socketpath(self):
        args = self.parser.parse_args(['socket', '--socketpath', 'foo.sock'])
        self.assertEqual(args.socketpath, 'foo.sock')


class SshParserTestCase(ParserTestCase):
    def test_defaults(self):
        args = self.parser.parse_args(['ssh', '--hostname=foo'])
        self.assertEqual(args.port, 22)
        self.assertEqual(args.ssh_username, 'gmp')
        self.assertEqual(args.ssh_password, 'gmp')

    def test_connection_type(self):
        args = self.parser.parse_args(['ssh', '--hostname=foo'])
        self.assertEqual(args.connection_type, 'ssh')

    def test_hostname(self):
        args = self.parser.parse_args(['ssh', '--hostname', 'foo'])
        self.assertEqual(args.hostname, 'foo')

    def test_port(self):
        args = self.parser.parse_args(
            ['ssh', '--hostname', 'foo', '--port', '123']
        )
        self.assertEqual(args.port, 123)

    def test_ssh_username(self):
        args = self.parser.parse_args(
            ['ssh', '--hostname', 'foo', '--ssh-username', 'foo']
        )
        self.assertEqual(args.ssh_username, 'foo')

    def test_ssh_password(self):
        args = self.parser.parse_args(
            ['ssh', '--hostname', 'foo', '--ssh-password', 'foo']
        )
        self.assertEqual(args.ssh_password, 'foo')


class TlsParserTestCase(ParserTestCase):
    def test_defaults(self):
        args = self.parser.parse_args(['tls', '--hostname=foo'])
        self.assertIsNone(args.certfile)
        self.assertIsNone(args.keyfile)
        self.assertIsNone(args.cafile)
        self.assertEqual(args.port, 9390)

    def test_connection_type(self):
        args = self.parser.parse_args(['tls', '--hostname=foo'])
        self.assertEqual(args.connection_type, 'tls')

    def test_hostname(self):
        args = self.parser.parse_args(['tls', '--hostname', 'foo'])
        self.assertEqual(args.hostname, 'foo')

    def test_port(self):
        args = self.parser.parse_args(
            ['tls', '--hostname', 'foo', '--port', '123']
        )
        self.assertEqual(args.port, 123)

    def test_certfile(self):
        args = self.parser.parse_args(
            ['tls', '--hostname', 'foo', '--certfile', 'foo.cert']
        )
        self.assertEqual(args.certfile, 'foo.cert')

    def test_keyfile(self):
        args = self.parser.parse_args(
            ['tls', '--hostname', 'foo', '--keyfile', 'foo.key']
        )
        self.assertEqual(args.keyfile, 'foo.key')

    def test_cafile(self):
        args = self.parser.parse_args(
            ['tls', '--hostname', 'foo', '--cafile', 'foo.ca']
        )
        self.assertEqual(args.cafile, 'foo.ca')

    def test_no_credentials(self):
        args = self.parser.parse_args(
            ['tls', '--hostname', 'foo', '--no-credentials']
        )
        self.assertTrue(args.no_credentials)


class CustomizeParserTestCase(ParserTestCase):
    def test_add_optional_argument(self):
        self.parser.add_argument('--foo', type=int)

        args = self.parser.parse_args(['socket', '--foo', '123'])
        self.assertEqual(args.foo, 123)

        args = self.parser.parse_args(
            ['ssh', '--hostname', 'bar', '--foo', '123']
        )
        self.assertEqual(args.foo, 123)

        args = self.parser.parse_args(
            ['tls', '--hostname', 'bar', '--foo', '123']
        )
        self.assertEqual(args.foo, 123)

    def test_add_positional_argument(self):
        self.parser.add_argument('foo', type=int)
        args = self.parser.parse_args(['socket', '123'])

        self.assertEqual(args.foo, 123)

    def test_add_protocol_argument(self):
        self.parser.add_protocol_argument()

        args = self.parser.parse_args(['socket'])
        self.assertEqual(args.protocol, 'GMP')

        args = self.parser.parse_args(['--protocol', 'OSP', 'socket'])

        self.assertEqual(args.protocol, 'OSP')


class HelpFormattingParserTestCase(ParserTestCase):
    # pylint: disable=protected-access
    maxDiff = None

    def _snapshot_path(self, name):
        return __here__ / '{}.snap'.format(name)

    def _load_snapshot(self, path):
        return path.read_text()

    def _write_snapshot(self, path, output):
        path.write_text(output)

    def assert_snapshot(self, name, output):
        path = self._snapshot_path(name)

        if not path.exists():
            path.write_text(output)

        content = path.read_text()
        self.assertEqual(content, output, 'Snapshot differs from output')

    def test_root_help(self):
        help_output = self.parser._parser.format_help()
        self.assert_snapshot('root_help', help_output)

    def test_socket_help(self):
        help_output = self.parser._parser_socket.format_help()
        self.assert_snapshot('socket_help', help_output)

    def test_ssh_help(self):
        help_output = self.parser._parser_ssh.format_help()
        self.assert_snapshot('ssh_help', help_output)

    def test_tls_help(self):
        help_output = self.parser._parser_tls.format_help()
        self.assert_snapshot('tls_help', help_output)


1			# -- coding: utf-8 --
2			# Copyright (C) 2019 Greenbone Networks GmbH
3			#
4			# SPDX-License-Identifier: GPL-3.0-or-later
5			#
6			# This program is free software: you can redistribute it and/or modify
7			# it under the terms of the GNU General Public License as published by
8			# the Free Software Foundation, either version 3 of the License, or
9			# (at your option) any later version.
10			#
11			# This program is distributed in the hope that it will be useful,
12			# but WITHOUT ANY WARRANTY; without even the implied warranty of
13			# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14			# GNU General Public License for more details.
15			#
16			# You should have received a copy of the GNU General Public License
17			# along with this program. If not, see <http://www.gnu.org/licenses/>.
18
19			import unittest
20
21			from pathlib import Path
22
23			from gvm.connections import DEFAULT_UNIX_SOCKET_PATH, DEFAULT_TIMEOUT
24
25			from gvmtools.parser import CliParser
26
27			from . import SuppressOutput
28
29			__here__ = Path(__file__).parent.resolve()
30
31
32			class ConfigParserTestCase(unittest.TestCase):
33			def setUp(self):
34			self.test_config_path = __here__ / 'test.cfg'
35
36			self.assertTrue(self.test_config_path.is_file())
37
38			self.parser = CliParser('TestParser', 'test.log')
39
40			def test_socket_defaults_from_config(self):
41			args = self.parser.parse_args(
42			['--config', str(self.test_config_path), 'socket']
43			)
44
45			self.assertEqual(args.foo, 'bar')
46			self.assertEqual(args.timeout, 1000)
47			self.assertEqual(args.gmp_password, 'bar')
48			self.assertEqual(args.gmp_username, 'bar')
49			self.assertEqual(args.socketpath, '/foo/bar.sock')
50
51			def test_ssh_defaults_from_config(self):
52			args = self.parser.parse_args(
53			['--config', str(self.test_config_path), 'ssh', '--hostname', 'foo']
54			)
55
56			self.assertEqual(args.foo, 'bar')
57			self.assertEqual(args.timeout, 1000)
58			self.assertEqual(args.gmp_password, 'bar')
59			self.assertEqual(args.gmp_username, 'bar')
60			self.assertEqual(args.ssh_password, 'lorem')
61			self.assertEqual(args.ssh_username, 'ipsum')
62			self.assertEqual(args.port, 123)
63
64			def test_tls_defaults_from_config(self):
65			args = self.parser.parse_args(
66			['--config', str(self.test_config_path), 'tls', '--hostname', 'foo']
67			)
68
69			self.assertEqual(args.foo, 'bar')
70			self.assertEqual(args.timeout, 1000)
71			self.assertEqual(args.gmp_password, 'bar')
72			self.assertEqual(args.gmp_username, 'bar')
73			self.assertEqual(args.certfile, 'foo.cert')
74			self.assertEqual(args.keyfile, 'foo.key')
75			self.assertEqual(args.cafile, 'foo.ca')
76			self.assertEqual(args.port, 123)
77
78
79			class IgnoreConfigParserTestCase(unittest.TestCase):
80			def test_unkown_config_file(self):
81			test_config_path = __here__ / 'foo.cfg'
82
83			self.assertFalse(test_config_path.is_file())
84
85			self.parser = CliParser('TestParser', 'test.log')
86
87			args = self.parser.parse_args(
88			['--config', str(test_config_path), 'socket']
89			)
90
91			self.assertEqual(args.timeout, DEFAULT_TIMEOUT)
92			self.assertEqual(args.gmp_password, '')
93			self.assertEqual(args.gmp_username, '')
94			self.assertEqual(args.socketpath, DEFAULT_UNIX_SOCKET_PATH)
95
96			def test_unkown_config_file_in_unkown_dir(self):
97			test_config_path = __here__ / 'foo' / 'foo.cfg'
98
99			self.assertFalse(test_config_path.is_file())
100
101			self.parser = CliParser('TestParser', 'test.log')
102
103			args = self.parser.parse_args(
104			['--config', str(test_config_path), 'socket']
105			)
106
107			self.assertEqual(args.timeout, DEFAULT_TIMEOUT)
108			self.assertEqual(args.gmp_password, '')
109			self.assertEqual(args.gmp_username, '')
110			self.assertEqual(args.socketpath, DEFAULT_UNIX_SOCKET_PATH)
111
112
113			class ParserTestCase(unittest.TestCase):
114			def setUp(self):
115			self.parser = CliParser(
116			'TestParser', 'test.log', ignore_config=True, prog='gvm-test-cli'
117			)
118
119
120			class RootArgumentsParserTest(ParserTestCase):
121			def test_config(self):
122			args = self.parser.parse_args(['--config', 'foo.cfg', 'socket'])
123			self.assertEqual(args.config, 'foo.cfg')
124
125			def test_defaults(self):
126			args = self.parser.parse_args(['socket'])
127			self.assertEqual(args.config, '~/.config/gvm-tools.conf')
128			self.assertEqual(args.gmp_password, '')
129			self.assertEqual(args.gmp_username, '')
130			self.assertEqual(args.timeout, 60)
131			self.assertIsNone(args.loglevel)
132
133			def test_loglevel(self):
134			args = self.parser.parse_args(['--log', 'ERROR', 'socket'])
135			self.assertEqual(args.loglevel, 'ERROR')
136
137			def test_loglevel_after_subparser(self):
138			with SuppressOutput(suppress_stderr=True):
139			with self.assertRaises(SystemExit):
140			self.parser.parse_args(['socket', '--log', 'ERROR'])
141
142			def test_timeout(self):
143			args = self.parser.parse_args(['--timeout', '1000', 'socket'])
144			self.assertEqual(args.timeout, 1000)
145
146			def test_timeout_after_subparser(self):
147			with SuppressOutput(suppress_stderr=True):
148			with self.assertRaises(SystemExit):
149			self.parser.parse_args(['socket', '--timeout', '1000'])
150
151			def test_gmp_username(self):
152			args = self.parser.parse_args(['--gmp-username', 'foo', 'socket'])
153			self.assertEqual(args.gmp_username, 'foo')
154
155			def test_gmp_username_after_subparser(self):
156			with SuppressOutput(suppress_stderr=True):
157			with self.assertRaises(SystemExit):
158			self.parser.parse_args(['socket', '--gmp-username', 'foo'])
159
160			def test_gmp_password(self):
161			args = self.parser.parse_args(['--gmp-password', 'foo', 'socket'])
162			self.assertEqual(args.gmp_password, 'foo')
163
164			def test_gmp_password_after_subparser(self):
165			with SuppressOutput(suppress_stderr=True):
166			with self.assertRaises(SystemExit):
167			self.parser.parse_args(['socket', '--gmp-password', 'foo'])
168
169			def test_with_unknown_args(self):
170			args, script_args = self.parser.parse_known_args(
171			['--gmp-password', 'foo', 'socket', '--bar', '--bar2']
172			)
173			self.assertEqual(args.gmp_password, 'foo')
174			self.assertEqual(script_args, ['--bar', '--bar2'])
175
176
177			class SocketParserTestCase(ParserTestCase):
178			def test_defaults(self):
179			args = self.parser.parse_args(['socket'])
180			self.assertEqual(args.socketpath, DEFAULT_UNIX_SOCKET_PATH)
181
182			def test_connection_type(self):
183			args = self.parser.parse_args(['socket'])
184			self.assertEqual(args.connection_type, 'socket')
185
186			def test_sockpath(self):
187			args = self.parser.parse_args(['socket', '--sockpath', 'foo.sock'])
188			self.assertEqual(args.socketpath, 'foo.sock')
189
190			def test_socketpath(self):
191			args = self.parser.parse_args(['socket', '--socketpath', 'foo.sock'])
192			self.assertEqual(args.socketpath, 'foo.sock')
193
194
195			class SshParserTestCase(ParserTestCase):
196			def test_defaults(self):
197			args = self.parser.parse_args(['ssh', '--hostname=foo'])
198			self.assertEqual(args.port, 22)
199			self.assertEqual(args.ssh_username, 'gmp')
200			self.assertEqual(args.ssh_password, 'gmp')
201
202			def test_connection_type(self):
203			args = self.parser.parse_args(['ssh', '--hostname=foo'])
204			self.assertEqual(args.connection_type, 'ssh')
205
206			def test_hostname(self):
207			args = self.parser.parse_args(['ssh', '--hostname', 'foo'])
208			self.assertEqual(args.hostname, 'foo')
209
210			def test_port(self):
211			args = self.parser.parse_args(
212			['ssh', '--hostname', 'foo', '--port', '123']
213			)
214			self.assertEqual(args.port, 123)
215
216			def test_ssh_username(self):
217			args = self.parser.parse_args(
218			['ssh', '--hostname', 'foo', '--ssh-username', 'foo']
219			)
220			self.assertEqual(args.ssh_username, 'foo')
221
222			def test_ssh_password(self):
223			args = self.parser.parse_args(
224			['ssh', '--hostname', 'foo', '--ssh-password', 'foo']
225			)
226			self.assertEqual(args.ssh_password, 'foo')
227
228
229			class TlsParserTestCase(ParserTestCase):
230			def test_defaults(self):
231			args = self.parser.parse_args(['tls', '--hostname=foo'])
232			self.assertIsNone(args.certfile)
233			self.assertIsNone(args.keyfile)
234			self.assertIsNone(args.cafile)
235			self.assertEqual(args.port, 9390)
236
237			def test_connection_type(self):
238			args = self.parser.parse_args(['tls', '--hostname=foo'])
239			self.assertEqual(args.connection_type, 'tls')
240
241			def test_hostname(self):
242			args = self.parser.parse_args(['tls', '--hostname', 'foo'])
243			self.assertEqual(args.hostname, 'foo')
244
245			def test_port(self):
246			args = self.parser.parse_args(
247			['tls', '--hostname', 'foo', '--port', '123']
248			)
249			self.assertEqual(args.port, 123)
250
251			def test_certfile(self):
252			args = self.parser.parse_args(
253			['tls', '--hostname', 'foo', '--certfile', 'foo.cert']
254			)
255			self.assertEqual(args.certfile, 'foo.cert')
256
257			def test_keyfile(self):
258			args = self.parser.parse_args(
259			['tls', '--hostname', 'foo', '--keyfile', 'foo.key']
260			)
261			self.assertEqual(args.keyfile, 'foo.key')
262
263			def test_cafile(self):
264			args = self.parser.parse_args(
265			['tls', '--hostname', 'foo', '--cafile', 'foo.ca']
266			)
267			self.assertEqual(args.cafile, 'foo.ca')
268
269			def test_no_credentials(self):
270			args = self.parser.parse_args(
271			['tls', '--hostname', 'foo', '--no-credentials']
272			)
273			self.assertTrue(args.no_credentials)
274
275
276			class CustomizeParserTestCase(ParserTestCase):
277			def test_add_optional_argument(self):
278			self.parser.add_argument('--foo', type=int)
279
280			args = self.parser.parse_args(['socket', '--foo', '123'])
281			self.assertEqual(args.foo, 123)
282
283			args = self.parser.parse_args(
284			['ssh', '--hostname', 'bar', '--foo', '123']
285			)
286			self.assertEqual(args.foo, 123)
287
288			args = self.parser.parse_args(
289			['tls', '--hostname', 'bar', '--foo', '123']
290			)
291			self.assertEqual(args.foo, 123)
292
293			def test_add_positional_argument(self):
294			self.parser.add_argument('foo', type=int)
295			args = self.parser.parse_args(['socket', '123'])
296
297			self.assertEqual(args.foo, 123)
298
299			def test_add_protocol_argument(self):
300			self.parser.add_protocol_argument()
301
302			args = self.parser.parse_args(['socket'])
303			self.assertEqual(args.protocol, 'GMP')
304
305			args = self.parser.parse_args(['--protocol', 'OSP', 'socket'])
306
307			self.assertEqual(args.protocol, 'OSP')
308
309
310			class HelpFormattingParserTestCase(ParserTestCase):
311			# pylint: disable=protected-access
312			maxDiff = None
313
314			def _snapshot_path(self, name):
315			return __here__ / '{}.snap'.format(name)
316
317			def _load_snapshot(self, path):
318			return path.read_text()
319
320			def _write_snapshot(self, path, output):
321			path.write_text(output)
322
323			def assert_snapshot(self, name, output):
324			path = self._snapshot_path(name)
325
326			if not path.exists():
327			path.write_text(output)
328
329			content = path.read_text()
330			self.assertEqual(content, output, 'Snapshot differs from output')
331
332			def test_root_help(self):
333			help_output = self.parser._parser.format_help()
334			self.assert_snapshot('root_help', help_output)
335
336			def test_socket_help(self):
337			help_output = self.parser._parser_socket.format_help()
338			self.assert_snapshot('socket_help', help_output)
339
340			def test_ssh_help(self):
341			help_output = self.parser._parser_ssh.format_help()
342			self.assert_snapshot('ssh_help', help_output)
343
344			def test_tls_help(self):
345			help_output = self.parser._parser_tls.format_help()
346			self.assert_snapshot('tls_help', help_output)
347

greenbone / gvm-tools

Pull Request — master (#227)

ConfigParserTestCase.test_socket_defaults_from_config() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like