Code Duplication - greenbone/python-gvm - Measure and Improve Code Quality continuously with Scrutinizer

Code Duplication Length = 393-406 lines in 2 locations

tests/protocols/gmpv9/test_create_task.py 1 location


from . import Gmpv9TestCase


class GmpCreateTaskCommandTestCase(Gmpv9TestCase):
    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(InvalidArgument):
            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(InvalidArgument):
            self.gmp.create_task(
                name='foo',
                config_id='c1',
                target_id='t1',
                scanner_id='s1',
                observers='',
            )

        with self.assertRaises(InvalidArgument):
            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(InvalidArgument):
            self.gmp.create_task(
                name='foo',
                config_id='c1',
                target_id='t1',
                scanner_id='s1',
                preferences='',
            )

        with self.assertRaises(InvalidArgument):
            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='',
            )



tests/protocols/gmpv7/test_create_task.py 1 location


from . import Gmpv7TestCase


class GmpCreateTaskCommandTestCase(Gmpv7TestCase):
    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>'
            '<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>'
            '<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>'
            '<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>'
            '<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>'
            '<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>'
            '<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>'
            '<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>'
            '<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(InvalidArgument):
            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>'
            '<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>'
            '<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>'
            '<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>'
            '<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(InvalidArgument):
            self.gmp.create_task(
                name='foo',
                config_id='c1',
                target_id='t1',
                scanner_id='s1',
                observers='',
            )

        with self.assertRaises(InvalidArgument):
            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>'
            '<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(InvalidArgument):
            self.gmp.create_task(
                name='foo',
                config_id='c1',
                target_id='t1',
                scanner_id='s1',
                preferences='',
            )

        with self.assertRaises(InvalidArgument):
            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='',
            )



		@@ 31-436 (lines=406) @@
28		from . import Gmpv9TestCase
29
30
31		class GmpCreateTaskCommandTestCase(Gmpv9TestCase):
32		def test_create_task(self):
33		self.gmp.create_task(
34		name='foo', config_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>scan</usage_type>'
41		'<config id="c1"/>'
42		'<target id="t1"/>'
43		'<scanner id="s1"/>'
44		'</create_task>'
45		)
46
47		def test_create_task_missing_name(self):
48		with self.assertRaises(RequiredArgument):
49		self.gmp.create_task(
50		name=None, config_id='c1', target_id='t1', scanner_id='s1'
51		)
52
53		with self.assertRaises(RequiredArgument):
54		self.gmp.create_task(
55		name='', config_id='c1', target_id='t1', scanner_id='s1'
56		)
57
58		def test_create_task_missing_config_id(self):
59		with self.assertRaises(RequiredArgument):
60		self.gmp.create_task(
61		name='foo', config_id=None, target_id='t1', scanner_id='s1'
62		)
63
64		with self.assertRaises(RequiredArgument):
65		self.gmp.create_task(
66		name='foo', config_id='', target_id='t1', scanner_id='s1'
67		)
68
69		def test_create_task_missing_target_id(self):
70		with self.assertRaises(RequiredArgument):
71		self.gmp.create_task(
72		name='foo', config_id='c1', target_id=None, scanner_id='s1'
73		)
74
75		with self.assertRaises(RequiredArgument):
76		self.gmp.create_task(
77		name='foo', config_id='c1', target_id='', scanner_id='s1'
78		)
79
80		def test_create_task_missing_scanner_id(self):
81		with self.assertRaises(RequiredArgument):
82		self.gmp.create_task(
83		name='foo', config_id='c1', target_id='t1', scanner_id=None
84		)
85
86		with self.assertRaises(RequiredArgument):
87		self.gmp.create_task(
88		name='foo', config_id='c1', target_id='t1', scanner_id=''
89		)
90
91		def test_create_task_with_comment(self):
92		self.gmp.create_task(
93		name='foo',
94		config_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>scan</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_task_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_task(
117		name='foo',
118		config_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>scan</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_task(
139		name='foo',
140		config_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>scan</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_task_multiple_alerts(self):
158		self.gmp.create_task(
159		name='foo',
160		config_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>scan</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_task_with_alterable(self):
180		self.gmp.create_task(
181		name='foo',
182		config_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>scan</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_task(
200		name='foo',
201		config_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>scan</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_task_with_hosts_ordering(self):
219		self.gmp.create_task(
220		name='foo',
221		config_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>scan</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_task_invalid_hosts_ordering(self):
239		with self.assertRaises(InvalidArgument):
240		self.gmp.create_task(
241		name='foo',
242		config_id='c1',
243		target_id='t1',
244		scanner_id='s1',
245		hosts_ordering='foo',
246		)
247
248		def test_create_task_with_schedule(self):
249		self.gmp.create_task(
250		name='foo',
251		config_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>scan</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_task_with_schedule_and_schedule_periods(self):
269		self.gmp.create_task(
270		name='foo',
271		config_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>scan</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_task(
291		name='foo',
292		config_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>scan</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_task_with_schedule_and_invalid_schedule_periods(self):
312		with self.assertRaises(InvalidArgument):
313		self.gmp.create_task(
314		name='foo',
315		config_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_task(
324		name='foo',
325		config_id='c1',
326		target_id='t1',
327		scanner_id='s1',
328		schedule_id='s1',
329		schedule_periods=-1,
330		)
331
332		def test_create_task_with_observers(self):
333		self.gmp.create_task(
334		name='foo',
335		config_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>scan</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_task_invalid_observers(self):
353		with self.assertRaises(InvalidArgument):
354		self.gmp.create_task(
355		name='foo',
356		config_id='c1',
357		target_id='t1',
358		scanner_id='s1',
359		observers='',
360		)
361
362		with self.assertRaises(InvalidArgument):
363		self.gmp.create_task(
364		name='foo',
365		config_id='c1',
366		target_id='t1',
367		scanner_id='s1',
368		observers='foo',
369		)
370
371		def test_create_task_with_preferences(self):
372		self.gmp.create_task(
373		name='foo',
374		config_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>scan</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_task_invalid_preferences(self):
401		with self.assertRaises(InvalidArgument):
402		self.gmp.create_task(
403		name='foo',
404		config_id='c1',
405		target_id='t1',
406		scanner_id='s1',
407		preferences='',
408		)
409
410		with self.assertRaises(InvalidArgument):
411		self.gmp.create_task(
412		name='foo',
413		config_id='c1',
414		target_id='t1',
415		scanner_id='s1',
416		preferences=['foo', 'bar'],
417		)
418
419		def test_create_task_don_t_allow_container_task(self):
420		with self.assertRaises(InvalidArgument):
421		self.gmp.create_task(
422		name='foo',
423		config_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_task(
432		name='foo',
433		config_id='c1',
434		target_id=0,
435		scanner_id='s1',
436		observers='',
437		)
438
439

		@@ 31-423 (lines=393) @@
28		from . import Gmpv7TestCase
29
30
31		class GmpCreateTaskCommandTestCase(Gmpv7TestCase):
32		def test_create_task(self):
33		self.gmp.create_task(
34		name='foo', config_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		'<config id="c1"/>'
41		'<target id="t1"/>'
42		'<scanner id="s1"/>'
43		'</create_task>'
44		)
45
46		def test_create_task_missing_name(self):
47		with self.assertRaises(RequiredArgument):
48		self.gmp.create_task(
49		name=None, config_id='c1', target_id='t1', scanner_id='s1'
50		)
51
52		with self.assertRaises(RequiredArgument):
53		self.gmp.create_task(
54		name='', config_id='c1', target_id='t1', scanner_id='s1'
55		)
56
57		def test_create_task_missing_config_id(self):
58		with self.assertRaises(RequiredArgument):
59		self.gmp.create_task(
60		name='foo', config_id=None, target_id='t1', scanner_id='s1'
61		)
62
63		with self.assertRaises(RequiredArgument):
64		self.gmp.create_task(
65		name='foo', config_id='', target_id='t1', scanner_id='s1'
66		)
67
68		def test_create_task_missing_target_id(self):
69		with self.assertRaises(RequiredArgument):
70		self.gmp.create_task(
71		name='foo', config_id='c1', target_id=None, scanner_id='s1'
72		)
73
74		with self.assertRaises(RequiredArgument):
75		self.gmp.create_task(
76		name='foo', config_id='c1', target_id='', scanner_id='s1'
77		)
78
79		def test_create_task_missing_scanner_id(self):
80		with self.assertRaises(RequiredArgument):
81		self.gmp.create_task(
82		name='foo', config_id='c1', target_id='t1', scanner_id=None
83		)
84
85		with self.assertRaises(RequiredArgument):
86		self.gmp.create_task(
87		name='foo', config_id='c1', target_id='t1', scanner_id=''
88		)
89
90		def test_create_task_with_comment(self):
91		self.gmp.create_task(
92		name='foo',
93		config_id='c1',
94		target_id='t1',
95		scanner_id='s1',
96		comment='bar',
97		)
98
99		self.connection.send.has_been_called_with(
100		'<create_task>'
101		'<name>foo</name>'
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		'<config id="c1"/>'
129		'<target id="t1"/>'
130		'<scanner id="s1"/>'
131		'<alert id="a1"/>'
132		'</create_task>'
133		)
134
135		self.gmp.create_task(
136		name='foo',
137		config_id='c1',
138		target_id='t1',
139		scanner_id='s1',
140		alert_ids=['a1'],
141		)
142
143		self.connection.send.has_been_called_with(
144		'<create_task>'
145		'<name>foo</name>'
146		'<config id="c1"/>'
147		'<target id="t1"/>'
148		'<scanner id="s1"/>'
149		'<alert id="a1"/>'
150		'</create_task>'
151		)
152
153		def test_create_task_multiple_alerts(self):
154		self.gmp.create_task(
155		name='foo',
156		config_id='c1',
157		target_id='t1',
158		scanner_id='s1',
159		alert_ids=['a1', 'a2', 'a3'],
160		)
161
162		self.connection.send.has_been_called_with(
163		'<create_task>'
164		'<name>foo</name>'
165		'<config id="c1"/>'
166		'<target id="t1"/>'
167		'<scanner id="s1"/>'
168		'<alert id="a1"/>'
169		'<alert id="a2"/>'
170		'<alert id="a3"/>'
171		'</create_task>'
172		)
173
174		def test_create_task_with_alterable(self):
175		self.gmp.create_task(
176		name='foo',
177		config_id='c1',
178		target_id='t1',
179		scanner_id='s1',
180		alterable=True,
181		)
182
183		self.connection.send.has_been_called_with(
184		'<create_task>'
185		'<name>foo</name>'
186		'<config id="c1"/>'
187		'<target id="t1"/>'
188		'<scanner id="s1"/>'
189		'<alterable>1</alterable>'
190		'</create_task>'
191		)
192
193		self.gmp.create_task(
194		name='foo',
195		config_id='c1',
196		target_id='t1',
197		scanner_id='s1',
198		alterable=False,
199		)
200
201		self.connection.send.has_been_called_with(
202		'<create_task>'
203		'<name>foo</name>'
204		'<config id="c1"/>'
205		'<target id="t1"/>'
206		'<scanner id="s1"/>'
207		'<alterable>0</alterable>'
208		'</create_task>'
209		)
210
211		def test_create_task_with_hosts_ordering(self):
212		self.gmp.create_task(
213		name='foo',
214		config_id='c1',
215		target_id='t1',
216		scanner_id='s1',
217		hosts_ordering=HostsOrdering.REVERSE,
218		)
219
220		self.connection.send.has_been_called_with(
221		'<create_task>'
222		'<name>foo</name>'
223		'<config id="c1"/>'
224		'<target id="t1"/>'
225		'<scanner id="s1"/>'
226		'<hosts_ordering>reverse</hosts_ordering>'
227		'</create_task>'
228		)
229
230		def test_create_task_invalid_hosts_ordering(self):
231		with self.assertRaises(InvalidArgument):
232		self.gmp.create_task(
233		name='foo',
234		config_id='c1',
235		target_id='t1',
236		scanner_id='s1',
237		hosts_ordering='foo',
238		)
239
240		def test_create_task_with_schedule(self):
241		self.gmp.create_task(
242		name='foo',
243		config_id='c1',
244		target_id='t1',
245		scanner_id='s1',
246		schedule_id='s1',
247		)
248
249		self.connection.send.has_been_called_with(
250		'<create_task>'
251		'<name>foo</name>'
252		'<config id="c1"/>'
253		'<target id="t1"/>'
254		'<scanner id="s1"/>'
255		'<schedule id="s1"/>'
256		'</create_task>'
257		)
258
259		def test_create_task_with_schedule_and_schedule_periods(self):
260		self.gmp.create_task(
261		name='foo',
262		config_id='c1',
263		target_id='t1',
264		scanner_id='s1',
265		schedule_id='s1',
266		schedule_periods=0,
267		)
268
269		self.connection.send.has_been_called_with(
270		'<create_task>'
271		'<name>foo</name>'
272		'<config id="c1"/>'
273		'<target id="t1"/>'
274		'<scanner id="s1"/>'
275		'<schedule id="s1"/>'
276		'<schedule_periods>0</schedule_periods>'
277		'</create_task>'
278		)
279
280		self.gmp.create_task(
281		name='foo',
282		config_id='c1',
283		target_id='t1',
284		scanner_id='s1',
285		schedule_id='s1',
286		schedule_periods=5,
287		)
288
289		self.connection.send.has_been_called_with(
290		'<create_task>'
291		'<name>foo</name>'
292		'<config id="c1"/>'
293		'<target id="t1"/>'
294		'<scanner id="s1"/>'
295		'<schedule id="s1"/>'
296		'<schedule_periods>5</schedule_periods>'
297		'</create_task>'
298		)
299
300		def test_create_task_with_schedule_and_invalid_schedule_periods(self):
301		with self.assertRaises(InvalidArgument):
302		self.gmp.create_task(
303		name='foo',
304		config_id='c1',
305		target_id='t1',
306		scanner_id='s1',
307		schedule_id='s1',
308		schedule_periods='foo',
309		)
310
311		with self.assertRaises(InvalidArgument):
312		self.gmp.create_task(
313		name='foo',
314		config_id='c1',
315		target_id='t1',
316		scanner_id='s1',
317		schedule_id='s1',
318		schedule_periods=-1,
319		)
320
321		def test_create_task_with_observers(self):
322		self.gmp.create_task(
323		name='foo',
324		config_id='c1',
325		target_id='t1',
326		scanner_id='s1',
327		observers=['u1', 'u2'],
328		)
329
330		self.connection.send.has_been_called_with(
331		'<create_task>'
332		'<name>foo</name>'
333		'<config id="c1"/>'
334		'<target id="t1"/>'
335		'<scanner id="s1"/>'
336		'<observers>u1,u2</observers>'
337		'</create_task>'
338		)
339
340		def test_create_task_invalid_observers(self):
341		with self.assertRaises(InvalidArgument):
342		self.gmp.create_task(
343		name='foo',
344		config_id='c1',
345		target_id='t1',
346		scanner_id='s1',
347		observers='',
348		)
349
350		with self.assertRaises(InvalidArgument):
351		self.gmp.create_task(
352		name='foo',
353		config_id='c1',
354		target_id='t1',
355		scanner_id='s1',
356		observers='foo',
357		)
358
359		def test_create_task_with_preferences(self):
360		self.gmp.create_task(
361		name='foo',
362		config_id='c1',
363		target_id='t1',
364		scanner_id='s1',
365		preferences=OrderedDict([('foo', 'bar'), ('lorem', 'ipsum')]),
366		)
367
368		self.connection.send.has_been_called_with(
369		'<create_task>'
370		'<name>foo</name>'
371		'<config id="c1"/>'
372		'<target id="t1"/>'
373		'<scanner id="s1"/>'
374		'<preferences>'
375		'<preference>'
376		'<scanner_name>foo</scanner_name>'
377		'<value>bar</value>'
378		'</preference>'
379		'<preference>'
380		'<scanner_name>lorem</scanner_name>'
381		'<value>ipsum</value>'
382		'</preference>'
383		'</preferences>'
384		'</create_task>'
385		)
386
387		def test_create_task_invalid_preferences(self):
388		with self.assertRaises(InvalidArgument):
389		self.gmp.create_task(
390		name='foo',
391		config_id='c1',
392		target_id='t1',
393		scanner_id='s1',
394		preferences='',
395		)
396
397		with self.assertRaises(InvalidArgument):
398		self.gmp.create_task(
399		name='foo',
400		config_id='c1',
401		target_id='t1',
402		scanner_id='s1',
403		preferences=['foo', 'bar'],
404		)
405
406		def test_create_task_don_t_allow_container_task(self):
407		with self.assertRaises(InvalidArgument):
408		self.gmp.create_task(
409		name='foo',
410		config_id='c1',
411		target_id='0',
412		scanner_id='s1',
413		observers='',
414		)
415
416		# target_id=0 is considered as False
417		with self.assertRaises(RequiredArgument):
418		self.gmp.create_task(
419		name='foo',
420		config_id='c1',
421		target_id=0,
422		scanner_id='s1',
423		observers='',
424		)
425
426

greenbone / python-gvm

Code Duplication Length = 393-406 lines in 2 locations

tests/protocols/gmpv9/test_create_task.py 1 location

tests/protocols/gmpv7/test_create_task.py 1 location