tests.test_nvti_cache.TestNVTICache.test_get_nvti_cache_name() - Code Metrics - Inspection of "Extend script_xref logging on unexpected data / in..." - greenbone/ospd-openvas - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Pull Request — master (#374)

unknown

created 2021-01-25 08:30 UTC

TestNVTICache.test_get_nvti_cache_name() A

↳ Parent: tests.test_nvti_cache

Complexity

Conditions

Size

Total Lines	14
Code Lines	10

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	1
eloc	10
nop	3
dl	0
loc	14
rs	9.9
c	0
b	0
f	0

# -*- coding: utf-8 -*-
# Copyright (C) 2014-2021 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.8'
        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.8'

        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.8')

    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.8'
        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.8', 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_pre_release(self, mock_version, MockOpenvasDB):
        self.assertIsNone(self.nvti._nvti_cache_name)

        # Beta version from sources
        mock_version.return_value = '20.8+beta1~git-1234-hosfix'
        self.nvti._set_nvti_cache_name()

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

        # Stable version from sources (no beta)
        mock_version.reset_mock()
        mock_version.return_value = '20.8.0~git-1234-hosfix'
        self.nvti._set_nvti_cache_name()

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

        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.8'

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

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

        self.assertEqual(self.nvti._get_nvti_cache_name(), 'nvticache20.8')
        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.8"))
        self.assertTrue(self.nvti._is_compatible_version("20.8.2"))
        self.assertTrue(self.nvti._is_compatible_version("20.08"))
        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-2021 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.8'
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.8'
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.8')
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.8'
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.8', 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 = (
90			NVTICache._parse_metadata_tags( # pylint: disable=protected-access
91			tags, '1.2.3'
92			)
93			)
94
95			self.assertEqual(ret, {})
96			assert_called(logging.Logger.error)
97
98			def test_parse_metadata_tag(self, MockOpenvasDB):
99			tags = 'tag1=value1'
100			ret = (
101			NVTICache._parse_metadata_tags( # pylint: disable=protected-access
102			tags, '1.2.3'
103			)
104			)
105
106			self.assertEqual(ret, {'tag1': 'value1'})
107
108			def test_parse_metadata_tags(self, MockOpenvasDB):
109			tags = 'tag1=value1\|foo=bar'
110			ret = (
111			NVTICache._parse_metadata_tags( # pylint: disable=protected-access
112			tags, '1.2.3'
113			)
114			)
115
116			self.assertEqual(ret, {'tag1': 'value1', 'foo': 'bar'})
117
118			def test_get_nvt_params(self, MockOpenvasDB):
119			prefs1 = ['1\|\|\|dns-fuzz.timelimit\|\|\|entry\|\|\|default']
120			prefs2 = ['1\|\|\|dns-fuzz.timelimit\|\|\|entry\|\|\|']
121			prefs3 = ['1\|\|\|dns-fuzz.timelimit\|\|\|entry']
122
123			out_dict1 = {
124			'1': {
125			'id': '1',
126			'type': 'entry',
127			'default': 'default',
128			'name': 'dns-fuzz.timelimit',
129			'description': 'Description',
130			},
131			}
132
133			out_dict2 = {
134			'1': {
135			'id': '1',
136			'type': 'entry',
137			'default': '',
138			'name': 'dns-fuzz.timelimit',
139			'description': 'Description',
140			},
141			}
142
143			MockOpenvasDB.get_list_item.return_value = prefs1
144
145			resp = self.nvti.get_nvt_params('1.2.3.4')
146			self.assertEqual(resp, out_dict1)
147
148			MockOpenvasDB.get_list_item.return_value = prefs2
149
150			resp = self.nvti.get_nvt_params('1.2.3.4')
151			self.assertEqual(resp, out_dict2)
152
153			MockOpenvasDB.get_list_item.return_value = prefs3
154
155			resp = self.nvti.get_nvt_params('1.2.3.4')
156			self.assertEqual(resp, out_dict2)
157
158			def test_get_nvt_metadata(self, MockOpenvasDB):
159			metadata = [
160			'mantis_detect.nasl',
161			'',
162			'',
163			'Settings/disable_cgi_scanning',
164			'',
165			'Services/www, 80',
166			'find_service.nasl, http_version.nasl',
167			'cvss_base_vector=AV:N/AC:L/Au:N/C:N/I:N'
168			'/A:N\|last_modification=1533906565'
169			'\|creation_date=1237458156'
170			'\|summary=Detects the ins'
171			'talled version of\n Mantis a free popular web-based '
172			'bugtracking system.\n\n This script sends HTTP GET r'
173			'equest and try to get the version from the\n respons'
174			'e, and sets the result in KB.\|qod_type=remote_banner',
175			'',
176			'',
177			'URL:http://www.mantisbt.org/',
178			'3',
179			'10',
180			'Product detection',
181			'Mantis Detection',
182			]
183
184			custom = {
185			'category': '3',
186			'creation_date': '1237458156',
187			'cvss_base_vector': 'AV:N/AC:L/Au:N/C:N/I:N/A:N',
188			'dependencies': 'find_service.nasl, http_version.nasl',
189			'excluded_keys': 'Settings/disable_cgi_scanning',
190			'family': 'Product detection',
191			'filename': 'mantis_detect.nasl',
192			'last_modification': ('1533906565'),
193			'name': 'Mantis Detection',
194			'qod_type': 'remote_banner',
195			'refs': {'xref': ['URL:http://www.mantisbt.org/']},
196			'required_ports': 'Services/www, 80',
197			'summary': (
198			'Detects the installed version of\n Mantis a '
199			'free popular web-based bugtracking system.\n'
200			'\n This script sends HTTP GET request and t'
201			'ry to get the version from the\n response, '
202			'and sets the result in KB.'
203			),
204			'vt_params': {
205			'0': {
206			'id': '0',
207			'type': 'entry',
208			'name': 'timeout',
209			'description': 'Script Timeout',
210			'default': '10',
211			},
212			'1': {
213			'id': '1',
214			'type': 'entry',
215			'name': 'dns-fuzz.timelimit',
216			'description': 'Description',
217			'default': 'default',
218			},
219			},
220			}
221
222			prefs1 = ['1\|\|\|dns-fuzz.timelimit\|\|\|entry\|\|\|default']
223
224			MockOpenvasDB.get_list_item.side_effect = [metadata, prefs1]
225			resp = self.nvti.get_nvt_metadata('1.2.3.4')
226			self.maxDiff = None
227			self.assertEqual(resp, custom)
228
229			def test_get_nvt_metadata_fail(self, MockOpenvasDB):
230			MockOpenvasDB.get_list_item.return_value = []
231
232			resp = self.nvti.get_nvt_metadata('1.2.3.4')
233
234			self.assertIsNone(resp)
235
236			def test_get_nvt_refs(self, MockOpenvasDB):
237			refs = ['', '', 'URL:http://www.mantisbt.org/']
238			out_dict = {
239			'cve': [''],
240			'bid': [''],
241			'xref': ['URL:http://www.mantisbt.org/'],
242			}
243
244			MockOpenvasDB.get_list_item.return_value = refs
245
246			resp = self.nvti.get_nvt_refs('1.2.3.4')
247
248			self.assertEqual(resp, out_dict)
249
250			def test_get_nvt_refs_fail(self, MockOpenvasDB):
251			MockOpenvasDB.get_list_item.return_value = []
252
253			resp = self.nvti.get_nvt_refs('1.2.3.4')
254
255			self.assertIsNone(resp)
256
257			def test_get_nvt_prefs(self, MockOpenvasDB):
258			prefs = ['dns-fuzz.timelimit\|\|\|entry\|\|\|default']
259
260			MockOpenvasDB.get_list_item.return_value = prefs
261
262			resp = self.nvti.get_nvt_prefs('1.2.3.4')
263
264			self.assertEqual(resp, prefs)
265
266			def test_get_nvt_timeout(self, MockOpenvasDB):
267			MockOpenvasDB.get_single_item.return_value = '300'
268
269			resp = self.nvti.get_nvt_timeout('1.2.3.4')
270
271			self.assertEqual(resp, '300')
272
273			def test_get_nvt_tags(self, MockOpenvasDB):
274			tag = (
275			'last_modification=1533906565'
276			'\|creation_date=1517443741\|cvss_bas'
277			'e_vector=AV:N/AC:L/Au:N/C:P/I:P/A:P\|solution_type=V'
278			'endorFix\|qod_type=package\|affected=rubygems on Debi'
279			'an Linux\|solution_method=DebianAPTUpgrade'
280			)
281
282			out_dict = {
283			'last_modification': '1533906565',
284			'creation_date': '1517443741',
285			'cvss_base_vector': 'AV:N/AC:L/Au:N/C:P/I:P/A:P',
286			'solution_type': 'VendorFix',
287			'qod_type': 'package',
288			'affected': 'rubygems on Debian Linux',
289			'solution_method': 'DebianAPTUpgrade',
290			}
291
292			MockOpenvasDB.get_single_item.return_value = tag
293
294			resp = self.nvti.get_nvt_tags('1.2.3.4')
295
296			self.assertEqual(out_dict, resp)
297
298			@patch('ospd_openvas.nvticache.Openvas.get_gvm_libs_version')
299			def test_set_nvti_cache_name(self, mock_version, MockOpenvasDB):
300			self.assertIsNone(self.nvti._nvti_cache_name)
301
302			mock_version.return_value = '20.10'
303			self.nvti._set_nvti_cache_name()
304
305			self.assertTrue(mock_version.called)
306			self.assertEqual(self.nvti._nvti_cache_name, 'nvticache20.10')
307
308			mock_version.reset_mock()
309			mock_version.return_value = '10.0.1'
310
311			with self.assertRaises(OspdOpenvasError):
312			self.nvti._set_nvti_cache_name()
313
314			self.assertTrue(mock_version.called)
315
316			@patch('ospd_openvas.nvticache.Openvas.get_gvm_libs_version')
317			def test_set_nvti_cache_name_pre_release(self, mock_version, MockOpenvasDB):
318			self.assertIsNone(self.nvti._nvti_cache_name)
319
320			# Beta version from sources
321			mock_version.return_value = '20.8+beta1~git-1234-hosfix'
322			self.nvti._set_nvti_cache_name()
323
324			self.assertTrue(mock_version.called)
325			self.assertEqual(self.nvti._nvti_cache_name, 'nvticache20.8')
326
327			# Stable version from sources (no beta)
328			mock_version.reset_mock()
329			mock_version.return_value = '20.8.0~git-1234-hosfix'
330			self.nvti._set_nvti_cache_name()
331
332			self.assertTrue(mock_version.called)
333			self.assertEqual(self.nvti._nvti_cache_name, 'nvticache20.8.0')
334
335			mock_version.reset_mock()
336			mock_version.return_value = '10.0.1'
337
338			with self.assertRaises(OspdOpenvasError):
339			self.nvti._set_nvti_cache_name()
340
341			self.assertTrue(mock_version.called)
342
343			@patch('ospd_openvas.nvticache.Openvas.get_gvm_libs_version')
344			def test_set_nvti_cache_name_raise_error(
345			self, mock_version: Mock, MockOpenvasDB: Mock
346			):
347			mock_version.return_value = None
348
349			with self.assertRaises(OspdOpenvasError):
350			self.nvti._set_nvti_cache_name()
351
352			@patch('ospd_openvas.nvticache.Openvas.get_gvm_libs_version')
353			def test_set_nvti_cache_name_old_version(
354			self, mock_version: Mock, MockOpenvasDB: Mock
355			):
356			mock_version.return_value = '7.0.0'
357
358			with self.assertRaises(OspdOpenvasError):
359			self.nvti._set_nvti_cache_name()
360
361			@patch('ospd_openvas.nvticache.Openvas.get_gvm_libs_version')
362			def test_get_nvti_cache_name(self, mock_version, MockOpenvasDB):
363			self.assertIsNone(self.nvti._nvti_cache_name)
364
365			mock_version.return_value = '20.8'
366
367			self.assertEqual(self.nvti._get_nvti_cache_name(), 'nvticache20.8')
368			self.assertTrue(mock_version.called)
369
370			mock_version.reset_mock()
371			mock_version.return_value = '20.10'
372
373			self.assertEqual(self.nvti._get_nvti_cache_name(), 'nvticache20.8')
374			self.assertFalse(mock_version.called)
375
376			def test_is_compatible_version(self, MockOpenvasDB):
377			self.assertFalse(self.nvti._is_compatible_version("1.0.0"))
378			self.assertFalse(self.nvti._is_compatible_version("10.0.0"))
379			self.assertTrue(self.nvti._is_compatible_version("11.0.1"))
380			self.assertTrue(self.nvti._is_compatible_version("20.4"))
381			self.assertTrue(self.nvti._is_compatible_version("20.4.2"))
382			self.assertTrue(self.nvti._is_compatible_version("20.8"))
383			self.assertTrue(self.nvti._is_compatible_version("20.8.2"))
384			self.assertTrue(self.nvti._is_compatible_version("20.08"))
385			self.assertTrue(self.nvti._is_compatible_version("20.04"))
386			self.assertTrue(self.nvti._is_compatible_version("20.10"))
387
388			def test_get_nvt_files_count(self, MockOpenvasDB):
389			MockOpenvasDB.get_key_count.return_value = 20
390
391			self.assertEqual(self.nvti.get_nvt_files_count(), 20)
392			MockOpenvasDB.get_key_count.assert_called_with('foo', 'filename:*')
393
394			def test_get_nvt_count(self, MockOpenvasDB):
395			MockOpenvasDB.get_key_count.return_value = 20
396
397			self.assertEqual(self.nvti.get_nvt_count(), 20)
398			MockOpenvasDB.get_key_count.assert_called_with('foo', 'nvt:*')
399
400			def test_force_reload(self, _MockOpenvasDB):
401			self.nvti.force_reload()
402
403			self.db.release_database.assert_called_with(self.nvti)
404
405			def test_flush(self, _MockOpenvasDB):
406			self.nvti._ctx = Mock()
407
408			self.nvti.flush()
409
410			self.nvti._ctx.flushdb.assert_called_with()
411

greenbone / ospd-openvas

Pull Request — master (#374)

TestNVTICache.test_get_nvti_cache_name() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like