oval_graph.command_line_client.client.Client.get_questions() - Code Metrics - Inspection of "[WIP] Rework tests for command line client" - OpenSCAP/oval-graph - Measure and Improve Code Quality continuously with Scrutinizer

Test Failed

Pull Request — master (#203)

by Jan

created 2021-08-02 09:53 UTC

Client.get_questions() A

↳ Parent: oval_graph.command_line_client.client

Complexity

Conditions

Size

Total Lines	13
Code Lines	10

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	5
CRAP Score	1

Importance

Changes

Metric	Value
cc	1
eloc	10
nop	1
dl	0
loc	13
ccs	5
cts	5
cp	1
crap	1
rs	9.9
c	0
b	0
f	0

import argparse
import re
import sys
from datetime import datetime

from .. import __version__


class Client():
    def __init__(self, args):
        self.arg = self.parse_arguments(args)

        self.source_filename = self.arg.source_filename
        self.rule_name = self.arg.rule_id

        self.isatty = sys.stdout.isatty()

        self.all_rules = self.arg.all
        self.show_failed_rules = False
        self.show_not_selected_rules = False

    @staticmethod
    def _get_message():
        return {
            'description': '',
            'source_filename': '',
        }

    @staticmethod
    def _get_date():
        return str(datetime.now().strftime("-%d_%m_%Y-%H_%M_%S"))

    # Functions for selection of rules

    def search_rules_id(self):
        """
        Function retunes array of all matched IDs of rules in selected file.
        """
        raise NotImplementedError

    def get_only_fail_rule(self, rules):
        """
        Function processes array of matched IDs of rules in selected file.
        Function retunes array of failed matched IDs of rules in selected file.
        """
        raise NotImplementedError

    def _get_rows_of_unselected_rules(self):
        """
        Function retunes array of rows where is not selected IDs of rules in selected file.
        """
        raise NotImplementedError

    def run_gui_and_return_answers(self):
        if self.isatty:
            if self.all_rules:
                return self._get_rules()

            try:
                import inquirer

                return inquirer.prompt(self.get_questions())
            except ImportError:
                print(self.get_selection_rules())
            return None
        return self._get_rules()

    def _get_rules(self):
        if self.show_failed_rules:
            return {'rules': self.get_only_fail_rule(self.search_rules_id())}
        return {'rules': self.search_rules_id()}

    def _get_list_of_matched_rules(self):
        if self.show_failed_rules:
            return self.get_only_fail_rule(self.search_rules_id())
        return self.search_rules_id()

    def _get_list_of_lines(self):
        lines = ['== The Rule ID regular expressions ==']
        for rule in self._get_list_of_matched_rules():
            lines.append("^" + rule + "$")
        if self.show_not_selected_rules:
            for line in self._get_rows_of_unselected_rules():
                lines.append(line)
        lines.append(
            "Interactive rule selection is not available,"
            " because inquirer is not installed."
            " Copy id of the rule you want to visualize and"
            " paste it into a command with regular"
            " expression characters(^$).\n"
            "Alternatively, use the --all or --all-in-one arguments.")
        return lines

    def get_selection_rules(self):
        return "\n".join(self._get_list_of_lines())

    def _get_choices(self):
        if self.show_not_selected_rules:
            print("\n".join(self._get_rows_of_unselected_rules()))
        return self._get_list_of_matched_rules()

    def get_questions(self):
        from inquirer.questions import Checkbox as checkbox

        choices = self._get_choices()
        questions = [
            checkbox(
                'rules',
                message=(
                    "= The Rules IDs = (move - UP and DOWN arrows,"
                    " select - SPACE or LEFT and RIGHT arrows, submit - ENTER)"),
                choices=choices,
            ),
        ]
        return questions

    def _get_wanted_rules(self, rules):
        return [
            x for x in rules if re.search(
                self.rule_name, x)]

    def _check_rules_id(self, rules, notselected_rules):
        if notselected_rules and not rules:
            raise ValueError(
                ('Rule(s) "{}" was not selected, '
                 "so there are no results. The rule is"
                 ' "notselected" because it'
                 " wasn't a part of the executed profile"
                 " and therefore it wasn't evaluated "
                 "during the scan.")
                .format(notselected_rules))
        if not notselected_rules and not rules:
            raise ValueError('404 rule "{}" not found!'.format(self.rule_name))
        return rules

    # Function for setting arguments

    def parse_arguments(self, args):
        parser = argparse.ArgumentParser(
            prog='oval-graph',
            description=self._get_message().get('description'))
        self.prepare_parser(parser)
        if args is None:
            return parser.parse_args()
        return parser.parse_args(args)

    @staticmethod
    def prepare_args_when_user_can_list_in_rules(parser):
        parser.add_argument(
            '--show-failed-rules',
            action="store_true",
            default=False,
            help="Show only FAILED rules")
        parser.add_argument(
            '--show-not-selected-rules',
            action="store_true",
            default=False,
            help="Show notselected rules. These rules will not be visualized.")

    def prepare_parser(self, parser):
        parser.add_argument(
            '--version',
            action='version',
            version='%(prog)s ' + __version__)
        parser.add_argument(
            '-a',
            '--all',
            action="store_true",
            default=False,
            help="Process all matched rules.")
        parser.add_argument(
            '--hide-passing-tests',
            action="store_true",
            default=False,
            help=(
                "Do not display passing tests for better orientation in"
                " graphs that contain a large amount of nodes."))
        parser.add_argument(
            '-v',
            '--verbose',
            action="store_true",
            default=False,
            help="Displays details about the results of the running command.")
        parser.add_argument(
            '-o',
            '--output',
            action="store",
            default=None,
            help='The file where to save output.')
        parser.add_argument(
            "source_filename",
            help=self._get_message().get('source_filename'))
        parser.add_argument(
            "rule_id", help=(
                "Rule ID to be visualized. A part from the full rule ID"
                " a part of the ID or a regular expression can be used."
                " If brackets are used in the regular expression "
                "the regular expression must be quoted."))


1	1	import argparse
2	1	import re
3	1	import sys
4	1	from datetime import datetime
5
6	1	from .. import __version__
7
8
9	1	class Client():
10	1	def __init__(self, args):
11	1	self.arg = self.parse_arguments(args)
12
13	1	self.source_filename = self.arg.source_filename
14	1	self.rule_name = self.arg.rule_id
15
16	1	self.isatty = sys.stdout.isatty()
17
18	1	self.all_rules = self.arg.all
19	1	self.show_failed_rules = False
20	1	self.show_not_selected_rules = False
21
22	1	@staticmethod
23		def _get_message():
24	1	return {
25		'description': '',
26		'source_filename': '',
27		}
28
29	1	@staticmethod
30		def _get_date():
31	1	return str(datetime.now().strftime("-%d_%m_%Y-%H_%M_%S"))
32
33		# Functions for selection of rules
34
35	1	def search_rules_id(self):
36		"""
37		Function retunes array of all matched IDs of rules in selected file.
38		"""
39	1	raise NotImplementedError
40
41	1	def get_only_fail_rule(self, rules):
42		"""
43		Function processes array of matched IDs of rules in selected file.
44		Function retunes array of failed matched IDs of rules in selected file.
45		"""
46	1	raise NotImplementedError
47
48	1	def _get_rows_of_unselected_rules(self):
49		"""
50		Function retunes array of rows where is not selected IDs of rules in selected file.
51		"""
52		raise NotImplementedError
53
54	1	def run_gui_and_return_answers(self):
55	1	if self.isatty:
56	1	if self.all_rules:
57		return self._get_rules()
58
59	1	try:
60	1	import inquirer
		0 ignored issues – show introduced 2020-12-17 11:40 UTC by Report Bug Copy Issue Report Import outside toplevel (inquirer) Loading history...
61	1	return inquirer.prompt(self.get_questions())
62		except ImportError:
63		print(self.get_selection_rules())
64		return None
65	1	return self._get_rules()
66
67	1	def _get_rules(self):
68	1	if self.show_failed_rules:
69	1	return {'rules': self.get_only_fail_rule(self.search_rules_id())}
70	1	return {'rules': self.search_rules_id()}
71
72	1	def _get_list_of_matched_rules(self):
73	1	if self.show_failed_rules:
74		return self.get_only_fail_rule(self.search_rules_id())
75	1	return self.search_rules_id()
76
77	1	def _get_list_of_lines(self):
78		lines = ['== The Rule ID regular expressions ==']
79		for rule in self._get_list_of_matched_rules():
80		lines.append("^" + rule + "$")
81		if self.show_not_selected_rules:
82		for line in self._get_rows_of_unselected_rules():
83		lines.append(line)
84		lines.append(
85		"Interactive rule selection is not available,"
86		" because inquirer is not installed."
87		" Copy id of the rule you want to visualize and"
88		" paste it into a command with regular"
89		" expression characters(^$).\n"
90		"Alternatively, use the --all or --all-in-one arguments.")
91		return lines
92
93	1	def get_selection_rules(self):
94		return "\n".join(self._get_list_of_lines())
95
96	1	def _get_choices(self):
97	1	if self.show_not_selected_rules:
98		print("\n".join(self._get_rows_of_unselected_rules()))
99	1	return self._get_list_of_matched_rules()
100
101	1	def get_questions(self):
102	1	from inquirer.questions import Checkbox as checkbox
		0 ignored issues – show introduced 2020-12-17 11:40 UTC by Report Bug Copy Issue Report Import outside toplevel (inquirer.questions.Checkbox) Loading history...
103	1	choices = self._get_choices()
104	1	questions = [
105		checkbox(
106		'rules',
107		message=(
108		"= The Rules IDs = (move - UP and DOWN arrows,"
109		" select - SPACE or LEFT and RIGHT arrows, submit - ENTER)"),
110		choices=choices,
111		),
112		]
113	1	return questions
114
115	1	def _get_wanted_rules(self, rules):
116	1	return [
117		x for x in rules if re.search(
118		self.rule_name, x)]
119
120	1	def _check_rules_id(self, rules, notselected_rules):
121	1	if notselected_rules and not rules:
122		raise ValueError(
123		('Rule(s) "{}" was not selected, '
124		"so there are no results. The rule is"
125		' "notselected" because it'
126		" wasn't a part of the executed profile"
127		" and therefore it wasn't evaluated "
128		"during the scan.")
129		.format(notselected_rules))
130	1	if not notselected_rules and not rules:
131		raise ValueError('404 rule "{}" not found!'.format(self.rule_name))
132	1	return rules
133
134		# Function for setting arguments
135
136	1	def parse_arguments(self, args):
137	1	parser = argparse.ArgumentParser(
138		prog='oval-graph',
139		description=self._get_message().get('description'))
140	1	self.prepare_parser(parser)
141	1	if args is None:
142		return parser.parse_args()
143	1	return parser.parse_args(args)
144
145	1	@staticmethod
146		def prepare_args_when_user_can_list_in_rules(parser):
147	1	parser.add_argument(
148		'--show-failed-rules',
149		action="store_true",
150		default=False,
151		help="Show only FAILED rules")
152	1	parser.add_argument(
153		'--show-not-selected-rules',
154		action="store_true",
155		default=False,
156		help="Show notselected rules. These rules will not be visualized.")
157
158	1	def prepare_parser(self, parser):
159	1	parser.add_argument(
160		'--version',
161		action='version',
162		version='%(prog)s ' + __version__)
163	1	parser.add_argument(
164		'-a',
165		'--all',
166		action="store_true",
167		default=False,
168		help="Process all matched rules.")
169	1	parser.add_argument(
170		'--hide-passing-tests',
171		action="store_true",
172		default=False,
173		help=(
174		"Do not display passing tests for better orientation in"
175		" graphs that contain a large amount of nodes."))
176	1	parser.add_argument(
177		'-v',
178		'--verbose',
179		action="store_true",
180		default=False,
181		help="Displays details about the results of the running command.")
182	1	parser.add_argument(
183		'-o',
184		'--output',
185		action="store",
186		default=None,
187		help='The file where to save output.')
188	1	parser.add_argument(
189		"source_filename",
190		help=self._get_message().get('source_filename'))
191	1	parser.add_argument(
192		"rule_id", help=(
193		"Rule ID to be visualized. A part from the full rule ID"
194		" a part of the ID or a regular expression can be used."
195		" If brackets are used in the regular expression "
196		"the regular expression must be quoted."))
197

OpenSCAP / oval-graph

Pull Request — master (#203)

Client.get_questions() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like