tests.protocols.gmpv9.test_create_audit.GmpCreateAuditCommandTestCase.test_create_audit_with_comment() - Code Metrics - Inspection of "Adding GMPv9 functionality to python-gvm" - greenbone/python-gvm - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Pull Request — master (#157)

unknown

created 2019-09-25 11:46 UTC

GmpCreateAuditCommandTestCase.test_create_audit_with_comment() A

↳ Parent: tests.protocols.gmpv9.test_create_audit

Complexity

Conditions

Size

Total Lines	11
Code Lines	9

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	1
eloc	9
nop	1
dl	0
loc	11
rs	9.95
c	0
b	0
f	0

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

from gvm.protocols.gmpv9 import HostsOrdering

from . import Gmpv9TestCase


class GmpCreateAuditCommandTestCase(Gmpv9TestCase):
    def test_create_task(self):
        self.gmp.create_audit(
            name='foo', audit_id='c1', target_id='t1', scanner_id='s1'
        )

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

    def test_create_audit_missing_name(self):
        with self.assertRaises(RequiredArgument):
            self.gmp.create_audit(
                name=None, audit_id='c1', target_id='t1', scanner_id='s1'
            )

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

    def test_create_audit_missing_audit_id(self):
        with self.assertRaises(RequiredArgument):
            self.gmp.create_audit(
                name='foo', audit_id=None, target_id='t1', scanner_id='s1'
            )

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

    def test_create_audit_missing_target_id(self):
        with self.assertRaises(RequiredArgument):
            self.gmp.create_audit(
                name='foo', audit_id='c1', target_id=None, scanner_id='s1'
            )

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

    def test_create_audit_missing_scanner_id(self):
        with self.assertRaises(RequiredArgument):
            self.gmp.create_audit(
                name='foo', audit_id='c1', target_id='t1', scanner_id=None
            )

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

    def test_create_audit_with_comment(self):
        self.gmp.create_audit(
            name='foo',
            audit_id='c1',
            target_id='t1',
            scanner_id='s1',
            comment='bar',
        )

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

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

            self.gmp.create_audit(
                name='foo',
                audit_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>audit</usage_type>'
            '<config id="c1"/>'
            '<target id="t1"/>'
            '<scanner id="s1"/>'
            '<alert id="a1"/>'
            '</create_task>'
        )

        self.gmp.create_audit(
            name='foo',
            audit_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>audit</usage_type>'
            '<config id="c1"/>'
            '<target id="t1"/>'
            '<scanner id="s1"/>'
            '<alert id="a1"/>'
            '</create_task>'
        )

    def test_create_audit_multiple_alerts(self):
        self.gmp.create_audit(
            name='foo',
            audit_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>audit</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_audit_with_alterable(self):
        self.gmp.create_audit(
            name='foo',
            audit_id='c1',
            target_id='t1',
            scanner_id='s1',
            alterable=True,
        )

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

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

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

    def test_create_audit_with_hosts_ordering(self):
        self.gmp.create_audit(
            name='foo',
            audit_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>audit</usage_type>'
            '<config id="c1"/>'
            '<target id="t1"/>'
            '<scanner id="s1"/>'
            '<hosts_ordering>reverse</hosts_ordering>'
            '</create_task>'
        )

    def test_create_audit_invalid_hosts_ordering(self):
        with self.assertRaises(InvalidArgument):
            self.gmp.create_audit(
                name='foo',
                audit_id='c1',
                target_id='t1',
                scanner_id='s1',
                hosts_ordering='foo',
            )

    def test_create_audit_with_schedule(self):
        self.gmp.create_audit(
            name='foo',
            audit_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>audit</usage_type>'
            '<config id="c1"/>'
            '<target id="t1"/>'
            '<scanner id="s1"/>'
            '<schedule id="s1"/>'
            '</create_task>'
        )

    def test_create_audit_with_schedule_and_schedule_periods(self):
        self.gmp.create_audit(
            name='foo',
            audit_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>audit</usage_type>'
            '<config id="c1"/>'
            '<target id="t1"/>'
            '<scanner id="s1"/>'
            '<schedule id="s1"/>'
            '<schedule_periods>0</schedule_periods>'
            '</create_task>'
        )

        self.gmp.create_audit(
            name='foo',
            audit_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>audit</usage_type>'
            '<config id="c1"/>'
            '<target id="t1"/>'
            '<scanner id="s1"/>'
            '<schedule id="s1"/>'
            '<schedule_periods>5</schedule_periods>'
            '</create_task>'
        )

    def test_create_audit_with_schedule_and_invalid_schedule_periods(self):
        with self.assertRaises(InvalidArgument):
            self.gmp.create_audit(
                name='foo',
                audit_id='c1',
                target_id='t1',
                scanner_id='s1',
                schedule_id='s1',
                schedule_periods='foo',
            )

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

    def test_create_audit_with_observers(self):
        self.gmp.create_audit(
            name='foo',
            audit_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>audit</usage_type>'
            '<config id="c1"/>'
            '<target id="t1"/>'
            '<scanner id="s1"/>'
            '<observers>u1,u2</observers>'
            '</create_task>'
        )

    def test_create_audit_invalid_observers(self):
        with self.assertRaises(InvalidArgument):
            self.gmp.create_audit(
                name='foo',
                audit_id='c1',
                target_id='t1',
                scanner_id='s1',
                observers='',
            )

        with self.assertRaises(InvalidArgument):
            self.gmp.create_audit(
                name='foo',
                audit_id='c1',
                target_id='t1',
                scanner_id='s1',
                observers='foo',
            )

    def test_create_audit_with_preferences(self):
        self.gmp.create_audit(
            name='foo',
            audit_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>audit</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_audit_invalid_preferences(self):
        with self.assertRaises(InvalidArgument):
            self.gmp.create_audit(
                name='foo',
                audit_id='c1',
                target_id='t1',
                scanner_id='s1',
                preferences='',
            )

        with self.assertRaises(InvalidArgument):
            self.gmp.create_audit(
                name='foo',
                audit_id='c1',
                target_id='t1',
                scanner_id='s1',
                preferences=['foo', 'bar'],
            )

    def test_create_audit_don_t_allow_container_task(self):
        with self.assertRaises(InvalidArgument):
            self.gmp.create_audit(
                name='foo',
                audit_id='c1',
                target_id='0',
                scanner_id='s1',
                observers='',
            )

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


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


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

greenbone / python-gvm

Pull Request — master (#157)

GmpCreateAuditCommandTestCase.test_create_audit_with_comment() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like