tests.protocols.gmpv208.testcmds.test_create_task - Code Metrics - Inspection of "Drop GMP v7, v8 and v9 support." - greenbone/python-gvm - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Pull Request — master (#436)

by Jaspar

created 2021-04-27 11:36 UTC

tests.protocols.gmpv208.testcmds.test_create_task A

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	440
Duplicated Lines	92.27 %

Importance

Changes

Metric	Value
eloc	223
dl	406
loc	440
rs	9.44
c	0
b	0
f	0
wmc	37

19 Methods

Rating	Name	Duplication	Size	Complexity
A	GmpCreateTaskCommandTestCase.test_create_task_with_alterable()	30	30	1
A	GmpCreateTaskCommandTestCase.test_create_task_with_schedule_and_invalid_schedule_periods()	19	19	3
A	GmpCreateTaskCommandTestCase.test_create_task_with_observers()	11	11	1
A	GmpCreateTaskCommandTestCase.test_create_task_with_comment()	11	11	1
A	GmpCreateTaskCommandTestCase.test_create_task()	7	7	1
A	GmpCreateTaskCommandTestCase.test_create_task_with_schedule_and_schedule_periods()	33	33	1
A	GmpCreateTaskCommandTestCase.test_create_task_with_schedule()	11	11	1
A	GmpCreateTaskCommandTestCase.test_create_task_with_preferences()	11	11	1
A	GmpCreateTaskCommandTestCase.test_create_task_single_alert()	37	37	2
A	GmpCreateTaskCommandTestCase.test_create_task_invalid_hosts_ordering()	8	8	2
A	GmpCreateTaskCommandTestCase.test_create_task_invalid_observers()	17	17	3
A	GmpCreateTaskCommandTestCase.test_create_task_missing_name()	9	9	3
A	GmpCreateTaskCommandTestCase.test_create_task_missing_scanner_id()	9	9	3
A	GmpCreateTaskCommandTestCase.test_create_task_multiple_alerts()	11	11	1
A	GmpCreateTaskCommandTestCase.test_create_task_missing_target_id()	9	9	3
A	GmpCreateTaskCommandTestCase.test_create_task_invalid_preferences()	17	17	3
A	GmpCreateTaskCommandTestCase.test_create_task_don_t_allow_container_task()	18	18	3
A	GmpCreateTaskCommandTestCase.test_create_task_missing_config_id()	9	9	3
A	GmpCreateTaskCommandTestCase.test_create_task_with_hosts_ordering()	11	11	1

How to fix Duplicated Code

# -*- coding: utf-8 -*-
# Copyright (C) 2018-2021 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
import warnings

from collections import OrderedDict

from gvm.errors import RequiredArgument, InvalidArgument, InvalidArgumentType

from gvm.protocols.gmpv208 import HostsOrdering


class GmpCreateTaskCommandTestCase:

    def test_create_task(self):
        self.gmp.create_task(
            name='foo', config_id='c1', target_id='t1', scanner_id='s1'
        )

        self.connection.send.has_been_called_with(
            '<create_task>'
            '<name>foo</name>'
            '<usage_type>scan</usage_type>'
            '<config id="c1"/>'
            '<target id="t1"/>'
            '<scanner id="s1"/>'
            '</create_task>'
        )

    def test_create_task_missing_name(self):
        with self.assertRaises(RequiredArgument):
            self.gmp.create_task(
                name=None, config_id='c1', target_id='t1', scanner_id='s1'
            )

        with self.assertRaises(RequiredArgument):
            self.gmp.create_task(
                name='', config_id='c1', target_id='t1', scanner_id='s1'
            )

    def test_create_task_missing_config_id(self):
        with self.assertRaises(RequiredArgument):
            self.gmp.create_task(
                name='foo', config_id=None, target_id='t1', scanner_id='s1'
            )

        with self.assertRaises(RequiredArgument):
            self.gmp.create_task(
                name='foo', config_id='', target_id='t1', scanner_id='s1'
            )

    def test_create_task_missing_target_id(self):
        with self.assertRaises(RequiredArgument):
            self.gmp.create_task(
                name='foo', config_id='c1', target_id=None, scanner_id='s1'
            )

        with self.assertRaises(RequiredArgument):
            self.gmp.create_task(
                name='foo', config_id='c1', target_id='', scanner_id='s1'
            )

    def test_create_task_missing_scanner_id(self):
        with self.assertRaises(RequiredArgument):
            self.gmp.create_task(
                name='foo', config_id='c1', target_id='t1', scanner_id=None
            )

        with self.assertRaises(RequiredArgument):
            self.gmp.create_task(
                name='foo', config_id='c1', target_id='t1', scanner_id=''
            )

    def test_create_task_with_comment(self):
        self.gmp.create_task(
            name='foo',
            config_id='c1',
            target_id='t1',
            scanner_id='s1',
            comment='bar',
        )

        self.connection.send.has_been_called_with(
            '<create_task>'
            '<name>foo</name>'
            '<usage_type>scan</usage_type>'
            '<config id="c1"/>'
            '<target id="t1"/>'
            '<scanner id="s1"/>'
            '<comment>bar</comment>'
            '</create_task>'
        )

    def test_create_task_single_alert(self):
        # pylint: disable=invalid-name
        with warnings.catch_warnings(record=True) as w:
            warnings.simplefilter("always")

            self.gmp.create_task(
                name='foo',
                config_id='c1',
                target_id='t1',
                scanner_id='s1',
                alert_ids='a1',  # will be removed in future
            )

            self.assertEqual(len(w), 1)
            self.assertTrue(issubclass(w[0].category, DeprecationWarning))

        self.connection.send.has_been_called_with(
            '<create_task>'
            '<name>foo</name>'
            '<usage_type>scan</usage_type>'
            '<config id="c1"/>'
            '<target id="t1"/>'
            '<scanner id="s1"/>'
            '<alert id="a1"/>'
            '</create_task>'
        )

        self.gmp.create_task(
            name='foo',
            config_id='c1',
            target_id='t1',
            scanner_id='s1',
            alert_ids=['a1'],
        )

        self.connection.send.has_been_called_with(
            '<create_task>'
            '<name>foo</name>'
            '<usage_type>scan</usage_type>'
            '<config id="c1"/>'
            '<target id="t1"/>'
            '<scanner id="s1"/>'
            '<alert id="a1"/>'
            '</create_task>'
        )

    def test_create_task_multiple_alerts(self):
        self.gmp.create_task(
            name='foo',
            config_id='c1',
            target_id='t1',
            scanner_id='s1',
            alert_ids=['a1', 'a2', 'a3'],
        )

        self.connection.send.has_been_called_with(
            '<create_task>'
            '<name>foo</name>'
            '<usage_type>scan</usage_type>'
            '<config id="c1"/>'
            '<target id="t1"/>'
            '<scanner id="s1"/>'
            '<alert id="a1"/>'
            '<alert id="a2"/>'
            '<alert id="a3"/>'
            '</create_task>'
        )

    def test_create_task_with_alterable(self):
        self.gmp.create_task(
            name='foo',
            config_id='c1',
            target_id='t1',
            scanner_id='s1',
            alterable=True,
        )

        self.connection.send.has_been_called_with(
            '<create_task>'
            '<name>foo</name>'
            '<usage_type>scan</usage_type>'
            '<config id="c1"/>'
            '<target id="t1"/>'
            '<scanner id="s1"/>'
            '<alterable>1</alterable>'
            '</create_task>'
        )

        self.gmp.create_task(
            name='foo',
            config_id='c1',
            target_id='t1',
            scanner_id='s1',
            alterable=False,
        )

        self.connection.send.has_been_called_with(
            '<create_task>'
            '<name>foo</name>'
            '<usage_type>scan</usage_type>'
            '<config id="c1"/>'
            '<target id="t1"/>'
            '<scanner id="s1"/>'
            '<alterable>0</alterable>'
            '</create_task>'
        )

    def test_create_task_with_hosts_ordering(self):
        self.gmp.create_task(
            name='foo',
            config_id='c1',
            target_id='t1',
            scanner_id='s1',
            hosts_ordering=HostsOrdering.REVERSE,
        )

        self.connection.send.has_been_called_with(
            '<create_task>'
            '<name>foo</name>'
            '<usage_type>scan</usage_type>'
            '<config id="c1"/>'
            '<target id="t1"/>'
            '<scanner id="s1"/>'
            '<hosts_ordering>reverse</hosts_ordering>'
            '</create_task>'
        )

    def test_create_task_invalid_hosts_ordering(self):
        with self.assertRaises(InvalidArgumentType):
            self.gmp.create_task(
                name='foo',
                config_id='c1',
                target_id='t1',
                scanner_id='s1',
                hosts_ordering='foo',
            )

    def test_create_task_with_schedule(self):
        self.gmp.create_task(
            name='foo',
            config_id='c1',
            target_id='t1',
            scanner_id='s1',
            schedule_id='s1',
        )

        self.connection.send.has_been_called_with(
            '<create_task>'
            '<name>foo</name>'
            '<usage_type>scan</usage_type>'
            '<config id="c1"/>'
            '<target id="t1"/>'
            '<scanner id="s1"/>'
            '<schedule id="s1"/>'
            '</create_task>'
        )

    def test_create_task_with_schedule_and_schedule_periods(self):
        self.gmp.create_task(
            name='foo',
            config_id='c1',
            target_id='t1',
            scanner_id='s1',
            schedule_id='s1',
            schedule_periods=0,
        )

        self.connection.send.has_been_called_with(
            '<create_task>'
            '<name>foo</name>'
            '<usage_type>scan</usage_type>'
            '<config id="c1"/>'
            '<target id="t1"/>'
            '<scanner id="s1"/>'
            '<schedule id="s1"/>'
            '<schedule_periods>0</schedule_periods>'
            '</create_task>'
        )

        self.gmp.create_task(
            name='foo',
            config_id='c1',
            target_id='t1',
            scanner_id='s1',
            schedule_id='s1',
            schedule_periods=5,
        )

        self.connection.send.has_been_called_with(
            '<create_task>'
            '<name>foo</name>'
            '<usage_type>scan</usage_type>'
            '<config id="c1"/>'
            '<target id="t1"/>'
            '<scanner id="s1"/>'
            '<schedule id="s1"/>'
            '<schedule_periods>5</schedule_periods>'
            '</create_task>'
        )

    def test_create_task_with_schedule_and_invalid_schedule_periods(self):
        with self.assertRaises(InvalidArgument):
            self.gmp.create_task(
                name='foo',
                config_id='c1',
                target_id='t1',
                scanner_id='s1',
                schedule_id='s1',
                schedule_periods='foo',
            )

        with self.assertRaises(InvalidArgument):
            self.gmp.create_task(
                name='foo',
                config_id='c1',
                target_id='t1',
                scanner_id='s1',
                schedule_id='s1',
                schedule_periods=-1,
            )

    def test_create_task_with_observers(self):
        self.gmp.create_task(
            name='foo',
            config_id='c1',
            target_id='t1',
            scanner_id='s1',
            observers=['u1', 'u2'],
        )

        self.connection.send.has_been_called_with(
            '<create_task>'
            '<name>foo</name>'
            '<usage_type>scan</usage_type>'
            '<config id="c1"/>'
            '<target id="t1"/>'
            '<scanner id="s1"/>'
            '<observers>u1,u2</observers>'
            '</create_task>'
        )

    def test_create_task_invalid_observers(self):
        with self.assertRaises(InvalidArgumentType):
            self.gmp.create_task(
                name='foo',
                config_id='c1',
                target_id='t1',
                scanner_id='s1',
                observers='',
            )

        with self.assertRaises(InvalidArgumentType):
            self.gmp.create_task(
                name='foo',
                config_id='c1',
                target_id='t1',
                scanner_id='s1',
                observers='foo',
            )

    def test_create_task_with_preferences(self):
        self.gmp.create_task(
            name='foo',
            config_id='c1',
            target_id='t1',
            scanner_id='s1',
            preferences=OrderedDict([('foo', 'bar'), ('lorem', 'ipsum')]),
        )

        self.connection.send.has_been_called_with(
            '<create_task>'
            '<name>foo</name>'
            '<usage_type>scan</usage_type>'
            '<config id="c1"/>'
            '<target id="t1"/>'
            '<scanner id="s1"/>'
            '<preferences>'
            '<preference>'
            '<scanner_name>foo</scanner_name>'
            '<value>bar</value>'
            '</preference>'
            '<preference>'
            '<scanner_name>lorem</scanner_name>'
            '<value>ipsum</value>'
            '</preference>'
            '</preferences>'
            '</create_task>'
        )

    def test_create_task_invalid_preferences(self):
        with self.assertRaises(InvalidArgumentType):
            self.gmp.create_task(
                name='foo',
                config_id='c1',
                target_id='t1',
                scanner_id='s1',
                preferences='',
            )

        with self.assertRaises(InvalidArgumentType):
            self.gmp.create_task(
                name='foo',
                config_id='c1',
                target_id='t1',
                scanner_id='s1',
                preferences=['foo', 'bar'],
            )

    def test_create_task_don_t_allow_container_task(self):
        with self.assertRaises(InvalidArgument):
            self.gmp.create_task(
                name='foo',
                config_id='c1',
                target_id='0',
                scanner_id='s1',
                observers='',
            )

        # target_id=0 is considered as False
        with self.assertRaises(RequiredArgument):
            self.gmp.create_task(
                name='foo',
                config_id='c1',
                target_id=0,
                scanner_id='s1',
                observers='',
            )


if __name__ == '__main__':
    unittest.main()


1		# -- coding: utf-8 --
2		# Copyright (C) 2018-2021 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		import warnings
21
22		from collections import OrderedDict
23
24		from gvm.errors import RequiredArgument, InvalidArgument, InvalidArgumentType
25
26		from gvm.protocols.gmpv208 import HostsOrdering
27
28
29	View Code Duplication	class GmpCreateTaskCommandTestCase:
		0 ignored issues – show Duplication introduced 2021-04-27 09:51 UTC by Report Bug Copy Issue Report This code seems to be duplicated in your project. Loading history...
30		def test_create_task(self):
31		self.gmp.create_task(
32		name='foo', config_id='c1', target_id='t1', scanner_id='s1'
33		)
34
35		self.connection.send.has_been_called_with(
36		'<create_task>'
37		'<name>foo</name>'
38		'<usage_type>scan</usage_type>'
39		'<config id="c1"/>'
40		'<target id="t1"/>'
41		'<scanner id="s1"/>'
42		'</create_task>'
43		)
44
45		def test_create_task_missing_name(self):
46		with self.assertRaises(RequiredArgument):
47		self.gmp.create_task(
48		name=None, config_id='c1', target_id='t1', scanner_id='s1'
49		)
50
51		with self.assertRaises(RequiredArgument):
52		self.gmp.create_task(
53		name='', config_id='c1', target_id='t1', scanner_id='s1'
54		)
55
56		def test_create_task_missing_config_id(self):
57		with self.assertRaises(RequiredArgument):
58		self.gmp.create_task(
59		name='foo', config_id=None, target_id='t1', scanner_id='s1'
60		)
61
62		with self.assertRaises(RequiredArgument):
63		self.gmp.create_task(
64		name='foo', config_id='', target_id='t1', scanner_id='s1'
65		)
66
67		def test_create_task_missing_target_id(self):
68		with self.assertRaises(RequiredArgument):
69		self.gmp.create_task(
70		name='foo', config_id='c1', target_id=None, scanner_id='s1'
71		)
72
73		with self.assertRaises(RequiredArgument):
74		self.gmp.create_task(
75		name='foo', config_id='c1', target_id='', scanner_id='s1'
76		)
77
78		def test_create_task_missing_scanner_id(self):
79		with self.assertRaises(RequiredArgument):
80		self.gmp.create_task(
81		name='foo', config_id='c1', target_id='t1', scanner_id=None
82		)
83
84		with self.assertRaises(RequiredArgument):
85		self.gmp.create_task(
86		name='foo', config_id='c1', target_id='t1', scanner_id=''
87		)
88
89		def test_create_task_with_comment(self):
90		self.gmp.create_task(
91		name='foo',
92		config_id='c1',
93		target_id='t1',
94		scanner_id='s1',
95		comment='bar',
96		)
97
98		self.connection.send.has_been_called_with(
99		'<create_task>'
100		'<name>foo</name>'
101		'<usage_type>scan</usage_type>'
102		'<config id="c1"/>'
103		'<target id="t1"/>'
104		'<scanner id="s1"/>'
105		'<comment>bar</comment>'
106		'</create_task>'
107		)
108
109		def test_create_task_single_alert(self):
110		# pylint: disable=invalid-name
111		with warnings.catch_warnings(record=True) as w:
112		warnings.simplefilter("always")
113
114		self.gmp.create_task(
115		name='foo',
116		config_id='c1',
117		target_id='t1',
118		scanner_id='s1',
119		alert_ids='a1', # will be removed in future
120		)
121
122		self.assertEqual(len(w), 1)
123		self.assertTrue(issubclass(w[0].category, DeprecationWarning))
124
125		self.connection.send.has_been_called_with(
126		'<create_task>'
127		'<name>foo</name>'
128		'<usage_type>scan</usage_type>'
129		'<config id="c1"/>'
130		'<target id="t1"/>'
131		'<scanner id="s1"/>'
132		'<alert id="a1"/>'
133		'</create_task>'
134		)
135
136		self.gmp.create_task(
137		name='foo',
138		config_id='c1',
139		target_id='t1',
140		scanner_id='s1',
141		alert_ids=['a1'],
142		)
143
144		self.connection.send.has_been_called_with(
145		'<create_task>'
146		'<name>foo</name>'
147		'<usage_type>scan</usage_type>'
148		'<config id="c1"/>'
149		'<target id="t1"/>'
150		'<scanner id="s1"/>'
151		'<alert id="a1"/>'
152		'</create_task>'
153		)
154
155		def test_create_task_multiple_alerts(self):
156		self.gmp.create_task(
157		name='foo',
158		config_id='c1',
159		target_id='t1',
160		scanner_id='s1',
161		alert_ids=['a1', 'a2', 'a3'],
162		)
163
164		self.connection.send.has_been_called_with(
165		'<create_task>'
166		'<name>foo</name>'
167		'<usage_type>scan</usage_type>'
168		'<config id="c1"/>'
169		'<target id="t1"/>'
170		'<scanner id="s1"/>'
171		'<alert id="a1"/>'
172		'<alert id="a2"/>'
173		'<alert id="a3"/>'
174		'</create_task>'
175		)
176
177		def test_create_task_with_alterable(self):
178		self.gmp.create_task(
179		name='foo',
180		config_id='c1',
181		target_id='t1',
182		scanner_id='s1',
183		alterable=True,
184		)
185
186		self.connection.send.has_been_called_with(
187		'<create_task>'
188		'<name>foo</name>'
189		'<usage_type>scan</usage_type>'
190		'<config id="c1"/>'
191		'<target id="t1"/>'
192		'<scanner id="s1"/>'
193		'<alterable>1</alterable>'
194		'</create_task>'
195		)
196
197		self.gmp.create_task(
198		name='foo',
199		config_id='c1',
200		target_id='t1',
201		scanner_id='s1',
202		alterable=False,
203		)
204
205		self.connection.send.has_been_called_with(
206		'<create_task>'
207		'<name>foo</name>'
208		'<usage_type>scan</usage_type>'
209		'<config id="c1"/>'
210		'<target id="t1"/>'
211		'<scanner id="s1"/>'
212		'<alterable>0</alterable>'
213		'</create_task>'
214		)
215
216		def test_create_task_with_hosts_ordering(self):
217		self.gmp.create_task(
218		name='foo',
219		config_id='c1',
220		target_id='t1',
221		scanner_id='s1',
222		hosts_ordering=HostsOrdering.REVERSE,
223		)
224
225		self.connection.send.has_been_called_with(
226		'<create_task>'
227		'<name>foo</name>'
228		'<usage_type>scan</usage_type>'
229		'<config id="c1"/>'
230		'<target id="t1"/>'
231		'<scanner id="s1"/>'
232		'<hosts_ordering>reverse</hosts_ordering>'
233		'</create_task>'
234		)
235
236		def test_create_task_invalid_hosts_ordering(self):
237		with self.assertRaises(InvalidArgumentType):
238		self.gmp.create_task(
239		name='foo',
240		config_id='c1',
241		target_id='t1',
242		scanner_id='s1',
243		hosts_ordering='foo',
244		)
245
246		def test_create_task_with_schedule(self):
247		self.gmp.create_task(
248		name='foo',
249		config_id='c1',
250		target_id='t1',
251		scanner_id='s1',
252		schedule_id='s1',
253		)
254
255		self.connection.send.has_been_called_with(
256		'<create_task>'
257		'<name>foo</name>'
258		'<usage_type>scan</usage_type>'
259		'<config id="c1"/>'
260		'<target id="t1"/>'
261		'<scanner id="s1"/>'
262		'<schedule id="s1"/>'
263		'</create_task>'
264		)
265
266		def test_create_task_with_schedule_and_schedule_periods(self):
267		self.gmp.create_task(
268		name='foo',
269		config_id='c1',
270		target_id='t1',
271		scanner_id='s1',
272		schedule_id='s1',
273		schedule_periods=0,
274		)
275
276		self.connection.send.has_been_called_with(
277		'<create_task>'
278		'<name>foo</name>'
279		'<usage_type>scan</usage_type>'
280		'<config id="c1"/>'
281		'<target id="t1"/>'
282		'<scanner id="s1"/>'
283		'<schedule id="s1"/>'
284		'<schedule_periods>0</schedule_periods>'
285		'</create_task>'
286		)
287
288		self.gmp.create_task(
289		name='foo',
290		config_id='c1',
291		target_id='t1',
292		scanner_id='s1',
293		schedule_id='s1',
294		schedule_periods=5,
295		)
296
297		self.connection.send.has_been_called_with(
298		'<create_task>'
299		'<name>foo</name>'
300		'<usage_type>scan</usage_type>'
301		'<config id="c1"/>'
302		'<target id="t1"/>'
303		'<scanner id="s1"/>'
304		'<schedule id="s1"/>'
305		'<schedule_periods>5</schedule_periods>'
306		'</create_task>'
307		)
308
309		def test_create_task_with_schedule_and_invalid_schedule_periods(self):
310		with self.assertRaises(InvalidArgument):
311		self.gmp.create_task(
312		name='foo',
313		config_id='c1',
314		target_id='t1',
315		scanner_id='s1',
316		schedule_id='s1',
317		schedule_periods='foo',
318		)
319
320		with self.assertRaises(InvalidArgument):
321		self.gmp.create_task(
322		name='foo',
323		config_id='c1',
324		target_id='t1',
325		scanner_id='s1',
326		schedule_id='s1',
327		schedule_periods=-1,
328		)
329
330		def test_create_task_with_observers(self):
331		self.gmp.create_task(
332		name='foo',
333		config_id='c1',
334		target_id='t1',
335		scanner_id='s1',
336		observers=['u1', 'u2'],
337		)
338
339		self.connection.send.has_been_called_with(
340		'<create_task>'
341		'<name>foo</name>'
342		'<usage_type>scan</usage_type>'
343		'<config id="c1"/>'
344		'<target id="t1"/>'
345		'<scanner id="s1"/>'
346		'<observers>u1,u2</observers>'
347		'</create_task>'
348		)
349
350		def test_create_task_invalid_observers(self):
351		with self.assertRaises(InvalidArgumentType):
352		self.gmp.create_task(
353		name='foo',
354		config_id='c1',
355		target_id='t1',
356		scanner_id='s1',
357		observers='',
358		)
359
360		with self.assertRaises(InvalidArgumentType):
361		self.gmp.create_task(
362		name='foo',
363		config_id='c1',
364		target_id='t1',
365		scanner_id='s1',
366		observers='foo',
367		)
368
369		def test_create_task_with_preferences(self):
370		self.gmp.create_task(
371		name='foo',
372		config_id='c1',
373		target_id='t1',
374		scanner_id='s1',
375		preferences=OrderedDict([('foo', 'bar'), ('lorem', 'ipsum')]),
376		)
377
378		self.connection.send.has_been_called_with(
379		'<create_task>'
380		'<name>foo</name>'
381		'<usage_type>scan</usage_type>'
382		'<config id="c1"/>'
383		'<target id="t1"/>'
384		'<scanner id="s1"/>'
385		'<preferences>'
386		'<preference>'
387		'<scanner_name>foo</scanner_name>'
388		'<value>bar</value>'
389		'</preference>'
390		'<preference>'
391		'<scanner_name>lorem</scanner_name>'
392		'<value>ipsum</value>'
393		'</preference>'
394		'</preferences>'
395		'</create_task>'
396		)
397
398		def test_create_task_invalid_preferences(self):
399		with self.assertRaises(InvalidArgumentType):
400		self.gmp.create_task(
401		name='foo',
402		config_id='c1',
403		target_id='t1',
404		scanner_id='s1',
405		preferences='',
406		)
407
408		with self.assertRaises(InvalidArgumentType):
409		self.gmp.create_task(
410		name='foo',
411		config_id='c1',
412		target_id='t1',
413		scanner_id='s1',
414		preferences=['foo', 'bar'],
415		)
416
417		def test_create_task_don_t_allow_container_task(self):
418		with self.assertRaises(InvalidArgument):
419		self.gmp.create_task(
420		name='foo',
421		config_id='c1',
422		target_id='0',
423		scanner_id='s1',
424		observers='',
425		)
426
427		# target_id=0 is considered as False
428		with self.assertRaises(RequiredArgument):
429		self.gmp.create_task(
430		name='foo',
431		config_id='c1',
432		target_id=0,
433		scanner_id='s1',
434		observers='',
435		)
436
437
438		if __name__ == '__main__':
439		unittest.main()
440

greenbone / python-gvm

Pull Request — master (#436)

tests.protocols.gmpv208.testcmds.test_create_task A

Complexity

Size/Duplication

Importance

19 Methods

How to fix Duplicated Code

Duplicated Code

Duplication Side-by-Side

Filter issues like