tests.test_errors.InvalidArgumentTestCase.test_raise_with_function() - Code Metrics - Inspection of "Merge pull request #134 from bjoernricks/finalize-..." - greenbone/python-gvm - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( db2bdb...4880db )

unknown

created 2019-06-19 07:54 UTC

InvalidArgumentTestCase.test_raise_with_function() A

↳ Parent: tests.test_errors

Complexity

Conditions

Size

Total Lines	7
Code Lines	6

Duplication

Lines	7
Ratio	100 %

Importance

Changes

Metric	Value
cc	2
eloc	6
nop	1
dl	7
loc	7
rs	10
c	0
b	0
f	0

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

import unittest

from gvm.errors import InvalidArgument, RequiredArgument, GvmError


class InvalidArgumentTestCase(unittest.TestCase):

    def test_raise_with_message(self):
        with self.assertRaisesRegex(InvalidArgument, '^foo bar$'):
            raise InvalidArgument('foo bar')

    def test_message_precedence(self):
        with self.assertRaisesRegex(InvalidArgument, '^foo bar$') as cm:
            raise InvalidArgument('foo bar', argument='foo', function='bar')

        ex = cm.exception
        self.assertEqual(ex.argument, 'foo')
        self.assertEqual(ex.function, 'bar')

        self.assertEqual(str(ex), 'foo bar')

    def test_raise_with_argument(self):
        with self.assertRaises(InvalidArgument) as cm:
            raise InvalidArgument(argument='foo')

        ex = cm.exception
        self.assertEqual(ex.argument, 'foo')
        self.assertIsNone(ex.function)

    def test_raise_with_function(self):
        with self.assertRaises(InvalidArgument) as cm:
            raise InvalidArgument(function='foo')

        ex = cm.exception
        self.assertEqual(ex.function, 'foo')
        self.assertIsNone(ex.argument)

    def test_raise_with_argument_and_function(self):
        with self.assertRaises(InvalidArgument) as cm:
            raise InvalidArgument(argument='foo', function='bar')

        ex = cm.exception
        self.assertEqual(ex.argument, 'foo')
        self.assertEqual(ex.function, 'bar')

    def test_string_conversion(self):
        with self.assertRaises(InvalidArgument) as cm:
            raise InvalidArgument('foo bar', argument='foo')

        ex = cm.exception
        self.assertEqual(str(ex), 'foo bar')

        with self.assertRaises(InvalidArgument) as cm:
            raise InvalidArgument(argument='foo')

        ex = cm.exception
        self.assertEqual(str(ex), 'Invalid argument foo')

        with self.assertRaises(InvalidArgument) as cm:
            raise InvalidArgument(function='foo')

        ex = cm.exception
        self.assertEqual(str(ex), 'Invalid argument for foo')

        with self.assertRaises(InvalidArgument) as cm:
            raise InvalidArgument(argument='foo', function='bar')

        ex = cm.exception
        self.assertEqual(str(ex), 'Invalid argument foo for bar')

    def test_is_gvm_error(self):
        with self.assertRaises(GvmError):
            raise InvalidArgument('foo bar')


class RequiredArgumentTestCase(unittest.TestCase):

    def test_raise_with_message(self):
        with self.assertRaisesRegex(RequiredArgument, '^foo bar$'):
            raise RequiredArgument('foo bar')

    def test_message_precedence(self):
        with self.assertRaisesRegex(RequiredArgument, '^foo bar$') as cm:
            raise RequiredArgument('foo bar', argument='foo', function='bar')

        ex = cm.exception
        self.assertEqual(ex.argument, 'foo')
        self.assertEqual(ex.function, 'bar')

        self.assertEqual(str(ex), 'foo bar')

    def test_raise_with_argument(self):
        with self.assertRaises(RequiredArgument) as cm:
            raise RequiredArgument(argument='foo')

        ex = cm.exception
        self.assertEqual(ex.argument, 'foo')
        self.assertIsNone(ex.function)

    def test_raise_with_function(self):
        with self.assertRaises(RequiredArgument) as cm:
            raise RequiredArgument(function='foo')

        ex = cm.exception
        self.assertEqual(ex.function, 'foo')
        self.assertIsNone(ex.argument)

    def test_raise_with_argument_and_function(self):
        with self.assertRaises(RequiredArgument) as cm:
            raise RequiredArgument(argument='foo', function='bar')

        ex = cm.exception
        self.assertEqual(ex.argument, 'foo')
        self.assertEqual(ex.function, 'bar')

    def test_string_conversion(self):
        with self.assertRaises(RequiredArgument) as cm:
            raise RequiredArgument('foo bar')

        ex = cm.exception
        self.assertEqual(str(ex), 'foo bar')

        with self.assertRaises(RequiredArgument) as cm:
            raise RequiredArgument(argument='foo')

        ex = cm.exception
        self.assertEqual(str(ex), 'Required argument foo')

        with self.assertRaises(RequiredArgument) as cm:
            raise RequiredArgument(function='foo')

        ex = cm.exception
        self.assertEqual(str(ex), 'Required argument missing for foo')

        with self.assertRaises(RequiredArgument) as cm:
            raise RequiredArgument(argument='foo', function='bar')

        ex = cm.exception
        self.assertEqual(str(ex), 'bar requires a foo argument')

    def test_is_gvm_error(self):
        with self.assertRaises(GvmError):
            raise RequiredArgument('foo bar')


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


1		# -- coding: utf-8 --
2		# Copyright (C) 2019 Greenbone Networks GmbH
3		#
4		# SPDX-License-Identifier: GPL-3.0-or-later
5		#
6		# This program is free software: you can redistribute it and/or modify
7		# it under the terms of the GNU General Public License as published by
8		# the Free Software Foundation, either version 3 of the License, or
9		# (at your option) any later version.
10		#
11		# This program is distributed in the hope that it will be useful,
12		# but WITHOUT ANY WARRANTY; without even the implied warranty of
13		# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14		# GNU General Public License for more details.
15		#
16		# You should have received a copy of the GNU General Public License
17		# along with this program. If not, see <http://www.gnu.org/licenses/>.
18
19		import unittest
20
21		from gvm.errors import InvalidArgument, RequiredArgument, GvmError
22
23
24	View Code Duplication	class InvalidArgumentTestCase(unittest.TestCase):
		0 ignored issues – show Duplication introduced 2019-06-19 06:38 UTC by Report Bug Copy Issue Report This code seems to be duplicated in your project. Loading history...
25		def test_raise_with_message(self):
26		with self.assertRaisesRegex(InvalidArgument, '^foo bar$'):
27		raise InvalidArgument('foo bar')
28
29		def test_message_precedence(self):
30		with self.assertRaisesRegex(InvalidArgument, '^foo bar$') as cm:
31		raise InvalidArgument('foo bar', argument='foo', function='bar')
32
33		ex = cm.exception
34		self.assertEqual(ex.argument, 'foo')
35		self.assertEqual(ex.function, 'bar')
36
37		self.assertEqual(str(ex), 'foo bar')
38
39		def test_raise_with_argument(self):
40		with self.assertRaises(InvalidArgument) as cm:
41		raise InvalidArgument(argument='foo')
42
43		ex = cm.exception
44		self.assertEqual(ex.argument, 'foo')
45		self.assertIsNone(ex.function)
46
47		def test_raise_with_function(self):
48		with self.assertRaises(InvalidArgument) as cm:
49		raise InvalidArgument(function='foo')
50
51		ex = cm.exception
52		self.assertEqual(ex.function, 'foo')
53		self.assertIsNone(ex.argument)
54
55		def test_raise_with_argument_and_function(self):
56		with self.assertRaises(InvalidArgument) as cm:
57		raise InvalidArgument(argument='foo', function='bar')
58
59		ex = cm.exception
60		self.assertEqual(ex.argument, 'foo')
61		self.assertEqual(ex.function, 'bar')
62
63		def test_string_conversion(self):
64		with self.assertRaises(InvalidArgument) as cm:
65		raise InvalidArgument('foo bar', argument='foo')
66
67		ex = cm.exception
68		self.assertEqual(str(ex), 'foo bar')
69
70		with self.assertRaises(InvalidArgument) as cm:
71		raise InvalidArgument(argument='foo')
72
73		ex = cm.exception
74		self.assertEqual(str(ex), 'Invalid argument foo')
75
76		with self.assertRaises(InvalidArgument) as cm:
77		raise InvalidArgument(function='foo')
78
79		ex = cm.exception
80		self.assertEqual(str(ex), 'Invalid argument for foo')
81
82		with self.assertRaises(InvalidArgument) as cm:
83		raise InvalidArgument(argument='foo', function='bar')
84
85		ex = cm.exception
86		self.assertEqual(str(ex), 'Invalid argument foo for bar')
87
88		def test_is_gvm_error(self):
89		with self.assertRaises(GvmError):
90		raise InvalidArgument('foo bar')
91
92
93	View Code Duplication	class RequiredArgumentTestCase(unittest.TestCase):
		0 ignored issues – show Duplication introduced 2019-06-19 06:38 UTC by Report Bug Copy Issue Report This code seems to be duplicated in your project. Loading history...
94		def test_raise_with_message(self):
95		with self.assertRaisesRegex(RequiredArgument, '^foo bar$'):
96		raise RequiredArgument('foo bar')
97
98		def test_message_precedence(self):
99		with self.assertRaisesRegex(RequiredArgument, '^foo bar$') as cm:
100		raise RequiredArgument('foo bar', argument='foo', function='bar')
101
102		ex = cm.exception
103		self.assertEqual(ex.argument, 'foo')
104		self.assertEqual(ex.function, 'bar')
105
106		self.assertEqual(str(ex), 'foo bar')
107
108		def test_raise_with_argument(self):
109		with self.assertRaises(RequiredArgument) as cm:
110		raise RequiredArgument(argument='foo')
111
112		ex = cm.exception
113		self.assertEqual(ex.argument, 'foo')
114		self.assertIsNone(ex.function)
115
116		def test_raise_with_function(self):
117		with self.assertRaises(RequiredArgument) as cm:
118		raise RequiredArgument(function='foo')
119
120		ex = cm.exception
121		self.assertEqual(ex.function, 'foo')
122		self.assertIsNone(ex.argument)
123
124		def test_raise_with_argument_and_function(self):
125		with self.assertRaises(RequiredArgument) as cm:
126		raise RequiredArgument(argument='foo', function='bar')
127
128		ex = cm.exception
129		self.assertEqual(ex.argument, 'foo')
130		self.assertEqual(ex.function, 'bar')
131
132		def test_string_conversion(self):
133		with self.assertRaises(RequiredArgument) as cm:
134		raise RequiredArgument('foo bar')
135
136		ex = cm.exception
137		self.assertEqual(str(ex), 'foo bar')
138
139		with self.assertRaises(RequiredArgument) as cm:
140		raise RequiredArgument(argument='foo')
141
142		ex = cm.exception
143		self.assertEqual(str(ex), 'Required argument foo')
144
145		with self.assertRaises(RequiredArgument) as cm:
146		raise RequiredArgument(function='foo')
147
148		ex = cm.exception
149		self.assertEqual(str(ex), 'Required argument missing for foo')
150
151		with self.assertRaises(RequiredArgument) as cm:
152		raise RequiredArgument(argument='foo', function='bar')
153
154		ex = cm.exception
155		self.assertEqual(str(ex), 'bar requires a foo argument')
156
157		def test_is_gvm_error(self):
158		with self.assertRaises(GvmError):
159		raise RequiredArgument('foo bar')
160
161
162		if __name__ == '__main__':
163		unittest.main()
164

greenbone / python-gvm

Push — master ( db2bdb...4880db )

InvalidArgumentTestCase.test_raise_with_function() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like