tests.test_nvti_cache.TestNVTICache.test_get_nvt_params() - Code Metrics - Inspection of "Remove the VT cache and get the data directly from..." - greenbone/ospd-openvas - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Pull Request — master (#236)

by Juan José

created 2020-04-23 10:21 UTC

TestNVTICache.test_get_nvt_params() A

↳ Parent: tests.test_nvti_cache

Complexity

Conditions

Size

Total Lines	39
Code Lines	27

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	1
eloc	27
nop	2
dl	0
loc	39
rs	9.232
c	0
b	0
f	0

# -*- coding: utf-8 -*-
# Copyright (C) 2014-2020 Greenbone Networks GmbH
#
# SPDX-License-Identifier: AGPL-3.0-or-later
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU Affero 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 Affero General Public License for more details.
#
# You should have received a copy of the GNU Affero General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.


# pylint: disable=unused-argument, protected-access, invalid-name

""" Unit Test for ospd-openvas """

import logging

from unittest import TestCase
from unittest.mock import patch, Mock, PropertyMock

from ospd_openvas.errors import OspdOpenvasError
from ospd_openvas.nvticache import NVTICache

from tests.helper import assert_called


@patch('ospd_openvas.nvticache.OpenvasDB')
class TestNVTICache(TestCase):
    @patch('ospd_openvas.db.MainDB')
    def setUp(self, MockMainDB):  # pylint: disable=arguments-differ
        self.db = MockMainDB()
        self.nvti = NVTICache(self.db)
        self.nvti._ctx = 'foo'

    def test_set_index(self, MockOpenvasDB):
        self.nvti._nvti_cache_name = '20.4'
        self.nvti._ctx = None

        MockOpenvasDB.find_database_by_pattern.return_value = ('foo', 22)

        ctx = self.nvti.ctx

        self.assertIsNotNone(ctx)
        self.assertEqual(ctx, 'foo')
        self.assertEqual(self.nvti.index, 22)

    def test_get_feed_version(self, MockOpenvasDB):
        self.nvti._nvti_cache_name = '20.4'

        MockOpenvasDB.get_single_item.return_value = '1234'

        resp = self.nvti.get_feed_version()

        self.assertEqual(resp, '1234')
        MockOpenvasDB.get_single_item.assert_called_with('foo', '20.4')

    def test_get_feed_version_not_available(self, MockOpenvasDB):
        pmock = PropertyMock(return_value=123)
        type(self.db).max_database_index = pmock
        self.nvti._nvti_cache_name = '20.4'
        self.nvti._ctx = None

        MockOpenvasDB.find_database_by_pattern.return_value = (None, None)

        resp = self.nvti.get_feed_version()

        self.assertIsNone(resp)
        MockOpenvasDB.find_database_by_pattern.assert_called_with('20.4', 123)

    def test_get_oids(self, MockOpenvasDB):
        MockOpenvasDB.get_filenames_and_oids.return_value = ['oids']

        resp = self.nvti.get_oids()

        self.assertEqual(resp, ['oids'])

    def test_parse_metadata_tag_missing_value(self, MockOpenvasDB):
        logging.Logger.error = Mock()

        tags = 'tag1'
        ret = NVTICache._parse_metadata_tags(  # pylint: disable=protected-access
            tags, '1.2.3'
        )

        self.assertEqual(ret, {})
        assert_called(logging.Logger.error)

    def test_parse_metadata_tag(self, MockOpenvasDB):
        tags = 'tag1=value1'
        ret = NVTICache._parse_metadata_tags(  # pylint: disable=protected-access
            tags, '1.2.3'
        )

        self.assertEqual(ret, {'tag1': 'value1'})

    def test_parse_metadata_tags(self, MockOpenvasDB):
        tags = 'tag1=value1|foo=bar'
        ret = NVTICache._parse_metadata_tags(  # pylint: disable=protected-access
            tags, '1.2.3'
        )

        self.assertEqual(ret, {'tag1': 'value1', 'foo': 'bar'})

    def test_get_nvt_params(self, MockOpenvasDB):
        prefs1 = ['1|||dns-fuzz.timelimit|||entry|||default']
        prefs2 = ['1|||dns-fuzz.timelimit|||entry|||']
        prefs3 = ['1|||dns-fuzz.timelimit|||entry']

        out_dict1 = {
            '1': {
                'id': '1',
                'type': 'entry',
                'default': 'default',
                'name': 'dns-fuzz.timelimit',
                'description': 'Description',
            },
        }

        out_dict2 = {
            '1': {
                'id': '1',
                'type': 'entry',
                'default': '',
                'name': 'dns-fuzz.timelimit',
                'description': 'Description',
            },
        }

        MockOpenvasDB.get_list_item.return_value = prefs1

        resp = self.nvti.get_nvt_params('1.2.3.4')
        self.assertEqual(resp, out_dict1)

        MockOpenvasDB.get_list_item.return_value = prefs2

        resp = self.nvti.get_nvt_params('1.2.3.4')
        self.assertEqual(resp, out_dict2)

        MockOpenvasDB.get_list_item.return_value = prefs3

        resp = self.nvti.get_nvt_params('1.2.3.4')
        self.assertEqual(resp, out_dict2)

    def test_get_nvt_metadata(self, MockOpenvasDB):
        metadata = [
            'mantis_detect.nasl',
            '',
            '',
            'Settings/disable_cgi_scanning',
            '',
            'Services/www, 80',
            'find_service.nasl, http_version.nasl',
            'cvss_base_vector=AV:N/AC:L/Au:N/C:N/I:N'
            '/A:N|last_modification=1533906565'
            '|creation_date=1237458156'
            '|summary=Detects the ins'
            'talled version of\n  Mantis a free popular web-based '
            'bugtracking system.\n\n  This script sends HTTP GET r'
            'equest and try to get the version from the\n  respons'
            'e, and sets the result in KB.|qod_type=remote_banner',
            '',
            '',
            'URL:http://www.mantisbt.org/',
            '3',
            '10',
            'Product detection',
            'Mantis Detection',
        ]

        custom = {
            'category': '3',
            'creation_date': '1237458156',
            'cvss_base_vector': 'AV:N/AC:L/Au:N/C:N/I:N/A:N',
            'dependencies': 'find_service.nasl, http_version.nasl',
            'excluded_keys': 'Settings/disable_cgi_scanning',
            'family': 'Product detection',
            'filename': 'mantis_detect.nasl',
            'last_modification': ('1533906565'),
            'name': 'Mantis Detection',
            'qod_type': 'remote_banner',
            'refs': {'xref': ['URL:http://www.mantisbt.org/']},
            'required_ports': 'Services/www, 80',
            'summary': (
                'Detects the installed version of\n  Mantis a '
                'free popular web-based bugtracking system.\n'
                '\n  This script sends HTTP GET request and t'
                'ry to get the version from the\n  response, '
                'and sets the result in KB.'
            ),
            'vt_params': {
                '0': {
                    'id': '0',
                    'type': 'entry',
                    'name': 'timeout',
                    'description': 'Script Timeout',
                    'default': '10',
                },
                '1': {
                    'id': '1',
                    'type': 'entry',
                    'name': 'dns-fuzz.timelimit',
                    'description': 'Description',
                    'default': 'default',
                },
            },
        }

        prefs1 = ['1|||dns-fuzz.timelimit|||entry|||default']

        MockOpenvasDB.get_list_item.side_effect = [metadata, prefs1]
        resp = self.nvti.get_nvt_metadata('1.2.3.4')
        self.maxDiff = None
        self.assertEqual(resp, custom)

    def test_get_nvt_metadata_fail(self, MockOpenvasDB):
        MockOpenvasDB.get_list_item.return_value = []

        resp = self.nvti.get_nvt_metadata('1.2.3.4')

        self.assertIsNone(resp)

    def test_get_nvt_refs(self, MockOpenvasDB):
        refs = ['', '', 'URL:http://www.mantisbt.org/']
        out_dict = {
            'cve': [''],
            'bid': [''],
            'xref': ['URL:http://www.mantisbt.org/'],
        }

        MockOpenvasDB.get_list_item.return_value = refs

        resp = self.nvti.get_nvt_refs('1.2.3.4')

        self.assertEqual(resp, out_dict)

    def test_get_nvt_refs_fail(self, MockOpenvasDB):
        MockOpenvasDB.get_list_item.return_value = []

        resp = self.nvti.get_nvt_refs('1.2.3.4')

        self.assertIsNone(resp)

    def test_get_nvt_prefs(self, MockOpenvasDB):
        prefs = ['dns-fuzz.timelimit|||entry|||default']

        MockOpenvasDB.get_list_item.return_value = prefs

        resp = self.nvti.get_nvt_prefs('1.2.3.4')

        self.assertEqual(resp, prefs)

    def test_get_nvt_timeout(self, MockOpenvasDB):
        MockOpenvasDB.get_single_item.return_value = '300'

        resp = self.nvti.get_nvt_timeout('1.2.3.4')

        self.assertEqual(resp, '300')

    def test_get_nvt_tags(self, MockOpenvasDB):
        tag = (
            'last_modification=1533906565'
            '|creation_date=1517443741|cvss_bas'
            'e_vector=AV:N/AC:L/Au:N/C:P/I:P/A:P|solution_type=V'
            'endorFix|qod_type=package|affected=rubygems on Debi'
            'an Linux|solution_method=DebianAPTUpgrade'
        )

        out_dict = {
            'last_modification': '1533906565',
            'creation_date': '1517443741',
            'cvss_base_vector': 'AV:N/AC:L/Au:N/C:P/I:P/A:P',
            'solution_type': 'VendorFix',
            'qod_type': 'package',
            'affected': 'rubygems on Debian Linux',
            'solution_method': 'DebianAPTUpgrade',
        }

        MockOpenvasDB.get_single_item.return_value = tag

        resp = self.nvti.get_nvt_tags('1.2.3.4')

        self.assertEqual(out_dict, resp)

    @patch('ospd_openvas.nvticache.Openvas.get_gvm_libs_version')
    def test_set_nvti_cache_name(self, mock_version, MockOpenvasDB):
        self.assertIsNone(self.nvti._nvti_cache_name)

        mock_version.return_value = '20.10'
        self.nvti._set_nvti_cache_name()

        self.assertTrue(mock_version.called)
        self.assertEqual(self.nvti._nvti_cache_name, 'nvticache20.10')

        mock_version.reset_mock()
        mock_version.return_value = '10.0.1'

        with self.assertRaises(OspdOpenvasError):
            self.nvti._set_nvti_cache_name()

        self.assertTrue(mock_version.called)

    @patch('ospd_openvas.nvticache.Openvas.get_gvm_libs_version')
    def test_set_nvti_cache_name_raise_error(
        self, mock_version: Mock, MockOpenvasDB: Mock
    ):
        mock_version.return_value = None

        with self.assertRaises(OspdOpenvasError):
            self.nvti._set_nvti_cache_name()

    @patch('ospd_openvas.nvticache.Openvas.get_gvm_libs_version')
    def test_set_nvti_cache_name_old_version(
        self, mock_version: Mock, MockOpenvasDB: Mock
    ):
        mock_version.return_value = '7.0.0'

        with self.assertRaises(OspdOpenvasError):
            self.nvti._set_nvti_cache_name()

    @patch('ospd_openvas.nvticache.Openvas.get_gvm_libs_version')
    def test_get_nvti_cache_name(self, mock_version, MockOpenvasDB):
        self.assertIsNone(self.nvti._nvti_cache_name)

        mock_version.return_value = '20.4'

        self.assertEqual(self.nvti._get_nvti_cache_name(), 'nvticache20.4')
        self.assertTrue(mock_version.called)

        mock_version.reset_mock()
        mock_version.return_value = '20.10'

        self.assertEqual(self.nvti._get_nvti_cache_name(), 'nvticache20.4')
        self.assertFalse(mock_version.called)

    def test_is_compatible_version(self, MockOpenvasDB):
        self.assertFalse(self.nvti._is_compatible_version("1.0.0"))
        self.assertFalse(self.nvti._is_compatible_version("10.0.0"))
        self.assertTrue(self.nvti._is_compatible_version("11.0.1"))
        self.assertTrue(self.nvti._is_compatible_version("20.4"))
        self.assertTrue(self.nvti._is_compatible_version("20.4.2"))
        self.assertTrue(self.nvti._is_compatible_version("20.04"))
        self.assertTrue(self.nvti._is_compatible_version("20.10"))

    def test_get_nvt_files_count(self, MockOpenvasDB):
        MockOpenvasDB.get_key_count.return_value = 20

        self.assertEqual(self.nvti.get_nvt_files_count(), 20)
        MockOpenvasDB.get_key_count.assert_called_with('foo', 'filename:*')

    def test_get_nvt_count(self, MockOpenvasDB):
        MockOpenvasDB.get_key_count.return_value = 20

        self.assertEqual(self.nvti.get_nvt_count(), 20)
        MockOpenvasDB.get_key_count.assert_called_with('foo', 'nvt:*')

    def test_force_reload(self, _MockOpenvasDB):
        self.nvti.force_reload()

        self.db.release_database.assert_called_with(self.nvti)

    def test_flush(self, _MockOpenvasDB):
        self.nvti._ctx = Mock()

        self.nvti.flush()

        self.nvti._ctx.flushdb.assert_called_with()


1			# -- coding: utf-8 --
2			# Copyright (C) 2014-2020 Greenbone Networks GmbH
3			#
4			# SPDX-License-Identifier: AGPL-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 Affero General Public License as
8			# published by the Free Software Foundation, either version 3 of the
9			# License, or (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 Affero General Public License for more details.
15			#
16			# You should have received a copy of the GNU Affero General Public License
17			# along with this program. If not, see <http://www.gnu.org/licenses/>.
18
19
20			# pylint: disable=unused-argument, protected-access, invalid-name
21
22			""" Unit Test for ospd-openvas """
23
24			import logging
25
26			from unittest import TestCase
27			from unittest.mock import patch, Mock, PropertyMock
28
29			from ospd_openvas.errors import OspdOpenvasError
30			from ospd_openvas.nvticache import NVTICache
31
32			from tests.helper import assert_called
33
34
35			@patch('ospd_openvas.nvticache.OpenvasDB')
36			class TestNVTICache(TestCase):
37			@patch('ospd_openvas.db.MainDB')
38			def setUp(self, MockMainDB): # pylint: disable=arguments-differ
39			self.db = MockMainDB()
40			self.nvti = NVTICache(self.db)
41			self.nvti._ctx = 'foo'
42
43			def test_set_index(self, MockOpenvasDB):
44			self.nvti._nvti_cache_name = '20.4'
45			self.nvti._ctx = None
46
47			MockOpenvasDB.find_database_by_pattern.return_value = ('foo', 22)
48
49			ctx = self.nvti.ctx
50
51			self.assertIsNotNone(ctx)
52			self.assertEqual(ctx, 'foo')
53			self.assertEqual(self.nvti.index, 22)
54
55			def test_get_feed_version(self, MockOpenvasDB):
56			self.nvti._nvti_cache_name = '20.4'
57
58			MockOpenvasDB.get_single_item.return_value = '1234'
59
60			resp = self.nvti.get_feed_version()
61
62			self.assertEqual(resp, '1234')
63			MockOpenvasDB.get_single_item.assert_called_with('foo', '20.4')
64
65			def test_get_feed_version_not_available(self, MockOpenvasDB):
66			pmock = PropertyMock(return_value=123)
67			type(self.db).max_database_index = pmock
68			self.nvti._nvti_cache_name = '20.4'
69			self.nvti._ctx = None
70
71			MockOpenvasDB.find_database_by_pattern.return_value = (None, None)
72
73			resp = self.nvti.get_feed_version()
74
75			self.assertIsNone(resp)
76			MockOpenvasDB.find_database_by_pattern.assert_called_with('20.4', 123)
77
78			def test_get_oids(self, MockOpenvasDB):
79			MockOpenvasDB.get_filenames_and_oids.return_value = ['oids']
80
81			resp = self.nvti.get_oids()
82
83			self.assertEqual(resp, ['oids'])
84
85			def test_parse_metadata_tag_missing_value(self, MockOpenvasDB):
86			logging.Logger.error = Mock()
87
88			tags = 'tag1'
89			ret = NVTICache._parse_metadata_tags( # pylint: disable=protected-access
90			tags, '1.2.3'
91			)
92
93			self.assertEqual(ret, {})
94			assert_called(logging.Logger.error)
95
96			def test_parse_metadata_tag(self, MockOpenvasDB):
97			tags = 'tag1=value1'
98			ret = NVTICache._parse_metadata_tags( # pylint: disable=protected-access
99			tags, '1.2.3'
100			)
101
102			self.assertEqual(ret, {'tag1': 'value1'})
103
104			def test_parse_metadata_tags(self, MockOpenvasDB):
105			tags = 'tag1=value1\|foo=bar'
106			ret = NVTICache._parse_metadata_tags( # pylint: disable=protected-access
107			tags, '1.2.3'
108			)
109
110			self.assertEqual(ret, {'tag1': 'value1', 'foo': 'bar'})
111
112			def test_get_nvt_params(self, MockOpenvasDB):
113			prefs1 = ['1\|\|\|dns-fuzz.timelimit\|\|\|entry\|\|\|default']
114			prefs2 = ['1\|\|\|dns-fuzz.timelimit\|\|\|entry\|\|\|']
115			prefs3 = ['1\|\|\|dns-fuzz.timelimit\|\|\|entry']
116
117			out_dict1 = {
118			'1': {
119			'id': '1',
120			'type': 'entry',
121			'default': 'default',
122			'name': 'dns-fuzz.timelimit',
123			'description': 'Description',
124			},
125			}
126
127			out_dict2 = {
128			'1': {
129			'id': '1',
130			'type': 'entry',
131			'default': '',
132			'name': 'dns-fuzz.timelimit',
133			'description': 'Description',
134			},
135			}
136
137			MockOpenvasDB.get_list_item.return_value = prefs1
138
139			resp = self.nvti.get_nvt_params('1.2.3.4')
140			self.assertEqual(resp, out_dict1)
141
142			MockOpenvasDB.get_list_item.return_value = prefs2
143
144			resp = self.nvti.get_nvt_params('1.2.3.4')
145			self.assertEqual(resp, out_dict2)
146
147			MockOpenvasDB.get_list_item.return_value = prefs3
148
149			resp = self.nvti.get_nvt_params('1.2.3.4')
150			self.assertEqual(resp, out_dict2)
151
152			def test_get_nvt_metadata(self, MockOpenvasDB):
153			metadata = [
154			'mantis_detect.nasl',
155			'',
156			'',
157			'Settings/disable_cgi_scanning',
158			'',
159			'Services/www, 80',
160			'find_service.nasl, http_version.nasl',
161			'cvss_base_vector=AV:N/AC:L/Au:N/C:N/I:N'
162			'/A:N\|last_modification=1533906565'
163			'\|creation_date=1237458156'
164			'\|summary=Detects the ins'
165			'talled version of\n Mantis a free popular web-based '
166			'bugtracking system.\n\n This script sends HTTP GET r'
167			'equest and try to get the version from the\n respons'
168			'e, and sets the result in KB.\|qod_type=remote_banner',
169			'',
170			'',
171			'URL:http://www.mantisbt.org/',
172			'3',
173			'10',
174			'Product detection',
175			'Mantis Detection',
176			]
177
178			custom = {
179			'category': '3',
180			'creation_date': '1237458156',
181			'cvss_base_vector': 'AV:N/AC:L/Au:N/C:N/I:N/A:N',
182			'dependencies': 'find_service.nasl, http_version.nasl',
183			'excluded_keys': 'Settings/disable_cgi_scanning',
184			'family': 'Product detection',
185			'filename': 'mantis_detect.nasl',
186			'last_modification': ('1533906565'),
187			'name': 'Mantis Detection',
188			'qod_type': 'remote_banner',
189			'refs': {'xref': ['URL:http://www.mantisbt.org/']},
190			'required_ports': 'Services/www, 80',
191			'summary': (
192			'Detects the installed version of\n Mantis a '
193			'free popular web-based bugtracking system.\n'
194			'\n This script sends HTTP GET request and t'
195			'ry to get the version from the\n response, '
196			'and sets the result in KB.'
197			),
198			'vt_params': {
199			'0': {
200			'id': '0',
201			'type': 'entry',
202			'name': 'timeout',
203			'description': 'Script Timeout',
204			'default': '10',
205			},
206			'1': {
207			'id': '1',
208			'type': 'entry',
209			'name': 'dns-fuzz.timelimit',
210			'description': 'Description',
211			'default': 'default',
212			},
213			},
214			}
215
216			prefs1 = ['1\|\|\|dns-fuzz.timelimit\|\|\|entry\|\|\|default']
217
218			MockOpenvasDB.get_list_item.side_effect = [metadata, prefs1]
219			resp = self.nvti.get_nvt_metadata('1.2.3.4')
220			self.maxDiff = None
221			self.assertEqual(resp, custom)
222
223			def test_get_nvt_metadata_fail(self, MockOpenvasDB):
224			MockOpenvasDB.get_list_item.return_value = []
225
226			resp = self.nvti.get_nvt_metadata('1.2.3.4')
227
228			self.assertIsNone(resp)
229
230			def test_get_nvt_refs(self, MockOpenvasDB):
231			refs = ['', '', 'URL:http://www.mantisbt.org/']
232			out_dict = {
233			'cve': [''],
234			'bid': [''],
235			'xref': ['URL:http://www.mantisbt.org/'],
236			}
237
238			MockOpenvasDB.get_list_item.return_value = refs
239
240			resp = self.nvti.get_nvt_refs('1.2.3.4')
241
242			self.assertEqual(resp, out_dict)
243
244			def test_get_nvt_refs_fail(self, MockOpenvasDB):
245			MockOpenvasDB.get_list_item.return_value = []
246
247			resp = self.nvti.get_nvt_refs('1.2.3.4')
248
249			self.assertIsNone(resp)
250
251			def test_get_nvt_prefs(self, MockOpenvasDB):
252			prefs = ['dns-fuzz.timelimit\|\|\|entry\|\|\|default']
253
254			MockOpenvasDB.get_list_item.return_value = prefs
255
256			resp = self.nvti.get_nvt_prefs('1.2.3.4')
257
258			self.assertEqual(resp, prefs)
259
260			def test_get_nvt_timeout(self, MockOpenvasDB):
261			MockOpenvasDB.get_single_item.return_value = '300'
262
263			resp = self.nvti.get_nvt_timeout('1.2.3.4')
264
265			self.assertEqual(resp, '300')
266
267			def test_get_nvt_tags(self, MockOpenvasDB):
268			tag = (
269			'last_modification=1533906565'
270			'\|creation_date=1517443741\|cvss_bas'
271			'e_vector=AV:N/AC:L/Au:N/C:P/I:P/A:P\|solution_type=V'
272			'endorFix\|qod_type=package\|affected=rubygems on Debi'
273			'an Linux\|solution_method=DebianAPTUpgrade'
274			)
275
276			out_dict = {
277			'last_modification': '1533906565',
278			'creation_date': '1517443741',
279			'cvss_base_vector': 'AV:N/AC:L/Au:N/C:P/I:P/A:P',
280			'solution_type': 'VendorFix',
281			'qod_type': 'package',
282			'affected': 'rubygems on Debian Linux',
283			'solution_method': 'DebianAPTUpgrade',
284			}
285
286			MockOpenvasDB.get_single_item.return_value = tag
287
288			resp = self.nvti.get_nvt_tags('1.2.3.4')
289
290			self.assertEqual(out_dict, resp)
291
292			@patch('ospd_openvas.nvticache.Openvas.get_gvm_libs_version')
293			def test_set_nvti_cache_name(self, mock_version, MockOpenvasDB):
294			self.assertIsNone(self.nvti._nvti_cache_name)
295
296			mock_version.return_value = '20.10'
297			self.nvti._set_nvti_cache_name()
298
299			self.assertTrue(mock_version.called)
300			self.assertEqual(self.nvti._nvti_cache_name, 'nvticache20.10')
301
302			mock_version.reset_mock()
303			mock_version.return_value = '10.0.1'
304
305			with self.assertRaises(OspdOpenvasError):
306			self.nvti._set_nvti_cache_name()
307
308			self.assertTrue(mock_version.called)
309
310			@patch('ospd_openvas.nvticache.Openvas.get_gvm_libs_version')
311			def test_set_nvti_cache_name_raise_error(
312			self, mock_version: Mock, MockOpenvasDB: Mock
313			):
314			mock_version.return_value = None
315
316			with self.assertRaises(OspdOpenvasError):
317			self.nvti._set_nvti_cache_name()
318
319			@patch('ospd_openvas.nvticache.Openvas.get_gvm_libs_version')
320			def test_set_nvti_cache_name_old_version(
321			self, mock_version: Mock, MockOpenvasDB: Mock
322			):
323			mock_version.return_value = '7.0.0'
324
325			with self.assertRaises(OspdOpenvasError):
326			self.nvti._set_nvti_cache_name()
327
328			@patch('ospd_openvas.nvticache.Openvas.get_gvm_libs_version')
329			def test_get_nvti_cache_name(self, mock_version, MockOpenvasDB):
330			self.assertIsNone(self.nvti._nvti_cache_name)
331
332			mock_version.return_value = '20.4'
333
334			self.assertEqual(self.nvti._get_nvti_cache_name(), 'nvticache20.4')
335			self.assertTrue(mock_version.called)
336
337			mock_version.reset_mock()
338			mock_version.return_value = '20.10'
339
340			self.assertEqual(self.nvti._get_nvti_cache_name(), 'nvticache20.4')
341			self.assertFalse(mock_version.called)
342
343			def test_is_compatible_version(self, MockOpenvasDB):
344			self.assertFalse(self.nvti._is_compatible_version("1.0.0"))
345			self.assertFalse(self.nvti._is_compatible_version("10.0.0"))
346			self.assertTrue(self.nvti._is_compatible_version("11.0.1"))
347			self.assertTrue(self.nvti._is_compatible_version("20.4"))
348			self.assertTrue(self.nvti._is_compatible_version("20.4.2"))
349			self.assertTrue(self.nvti._is_compatible_version("20.04"))
350			self.assertTrue(self.nvti._is_compatible_version("20.10"))
351
352			def test_get_nvt_files_count(self, MockOpenvasDB):
353			MockOpenvasDB.get_key_count.return_value = 20
354
355			self.assertEqual(self.nvti.get_nvt_files_count(), 20)
356			MockOpenvasDB.get_key_count.assert_called_with('foo', 'filename:*')
357
358			def test_get_nvt_count(self, MockOpenvasDB):
359			MockOpenvasDB.get_key_count.return_value = 20
360
361			self.assertEqual(self.nvti.get_nvt_count(), 20)
362			MockOpenvasDB.get_key_count.assert_called_with('foo', 'nvt:*')
363
364			def test_force_reload(self, _MockOpenvasDB):
365			self.nvti.force_reload()
366
367			self.db.release_database.assert_called_with(self.nvti)
368
369			def test_flush(self, _MockOpenvasDB):
370			self.nvti._ctx = Mock()
371
372			self.nvti.flush()
373
374			self.nvti._ctx.flushdb.assert_called_with()
375

greenbone / ospd-openvas

Pull Request — master (#236)

TestNVTICache.test_get_nvt_params() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like