Merge pull request #215 from Honny1/fix-details-tests

Fix details

Author: Honny1

oval_graph/arf_xml_parser/_comments.py

@@ -1,7 +1,7 @@
 from .global_namespaces import namespaces
 
 
-class _Comments:
+class _Comments:  # pylint: disable=R0903
     def __init__(self, oval_definitions):
         self.oval_definitions = oval_definitions
 

oval_graph/arf_xml_parser/_oval_scan_definitions.py

@@ -5,7 +5,7 @@
 STR_NEGATE_BOOL = {'true': 'false', 'false': 'true'}
 
 
-class _OVALScanDefinitions:
+class _OVALScanDefinitions:  # pylint: disable=R0903
     def __init__(self, definitions, oval_definitions, report_data):
         self.definitions = definitions
         self.comments_parser = _Comments(oval_definitions)

oval_graph/arf_xml_parser/_test_info.py

@@ -5,7 +5,7 @@
 MAX_MESSAGE_LEN = 99
 
 
-class _TestInfo:
+class _TestInfo:  # pylint: disable=R0903
     def __init__(self, report_data):
         self.report_data = report_data
         self.oval_definitions = self._get_oval_definitions()
@@ -124,7 +124,7 @@ def _get_ref_var(self, element, collected_object):
     @staticmethod
     def _complete_message(item, var_id):
         if len(item.text) == MAX_MESSAGE_LEN and var_id[:item.text.find('(')] in var_id:
-            return "{}{})".format(item.text[:item.text.find('(') + 1], var_id)
+            return f"{item.text[:item.text.find('(') + 1]}{var_id})"
         return item.text
 
     @staticmethod

oval_graph/arf_xml_parser/arf_xml_parser.py

@@ -24,9 +24,8 @@ def __init__(self, src):
         if not self.validate(self.arf_schemas_path):
             start_red_color = '\033[91m'
             end_red_color = '\033[0m'
-            message = "{}Warning: This file is not valid arf report.{}".format(
-                start_red_color, end_red_color)
-            print(message, file=sys.stderr)
+            message = "Warning: This file is not valid arf report."
+            print(f"{start_red_color}{message}{end_red_color}", file=sys.stderr)
         try:
             self.used_rules, self.not_tested_rules = self._get_rules_in_profile()
             self.report_data_href = list(self.used_rules.values())[0]['href']
@@ -37,8 +36,8 @@ def __init__(self, src):
                 self.definitions, self.oval_definitions, self.report_data).get_scan()
         except BaseException as error:
             raise ValueError(
-                'This file "{}" is not arf report file or there are no results'.format(
-                    self.src)) from error
+                f'This file "{self.src}" is not arf report file or there are no results'
+            ) from error
 
     def validate(self, xsd_path):
         xsd_path = str(LOCAL_DATA_DIR / xsd_path)
@@ -105,9 +104,9 @@ def _get_definition_of_rule(self, rule_id):
 
         if rule_id in self.not_tested_rules:
             raise NotTestedRule(
-                'Rule "{}" is {}, so there are no results.'
-                .format(rule_id, self.not_tested_rules[rule_id]))
-        raise ValueError('404 rule "{}" not found!'.format(rule_id))
+                f'Rule "{rule_id}" is {self.not_tested_rules[rule_id]}, so there are no results.'
+            )
+        raise ValueError(f'404 rule "{rule_id}" not found!')
 
     def get_oval_tree(self, rule_id):
         return Builder.dict_of_rule_to_oval_tree(

oval_graph/command_line.py

@@ -33,7 +33,7 @@ def catch_errors(client_class, params):
     except ERRORS as error:
         if client.verbose:
             traceback.print_exc()
-        print('{}Error: {}{}'.format(C_RED, error, C_END))
+        print(f'{C_RED}Error: {error}{C_END}')
 
 
 def main(client):

oval_graph/command_line_client/arf_to_json.py

@@ -29,10 +29,10 @@ def file_is_empty(path):
 
     def save_dict_as_json(self, dict_, src):
         if os.path.isfile(src) and not self.file_is_empty(src):
-            with open(src, "r") as file_:
+            with open(src, "r", encoding="utf-8") as file_:
                 data = json.load(file_)
                 dict_.update(data)
-        with open(src, "w+") as file_:
+        with open(src, "w+", encoding="utf-8") as file_:
             json.dump(dict_, file_)
 
     def _get_rule_key(self, rule):
@@ -41,7 +41,7 @@ def _get_rule_key(self, rule):
     def prepare_data(self, rules):
         out = []
         rule = None
-        out_oval_tree_dict = dict()
+        out_oval_tree_dict = {}
         for rule in rules['rules']:
             try:
                 out_oval_tree_dict[self._get_rule_key(rule)] = self.create_dict_of_rule(rule)

oval_graph/command_line_client/client_arf_input.py

@@ -53,9 +53,10 @@ def search_rules_id(self):
         wanted_rules = self._get_wanted_rules(self.arf_xml_parser.used_rules.keys())
         not_tested_rule = self.get_matched_not_tested_rules()
         if not wanted_rules and not not_tested_rule:
-            raise ValueError('404 rule "{}" not found!'.format(self.rule_name))
+            raise ValueError(f'404 rule "{self.rule_name}" not found!')
         if self.rule_name in not_tested_rule:
-            raise NotTestedRule(
-                'Rule "{}" is {}, so there are no results.'
-                .format(self.rule_name, self.arf_xml_parser.not_tested_rules[self.rule_name]))
+            raise NotTestedRule((
+                f'Rule "{self.rule_name}" '
+                f'is {self.arf_xml_parser.not_tested_rules[self.rule_name]},'
+                ' so there are no results.'))
         return wanted_rules

oval_graph/command_line_client/client_html_output.py

@@ -35,7 +35,7 @@ def _put_to_dict_oval_trees(self, dict_oval_trees, rule):
         raise NotImplementedError
 
     def _prepare_data(self, rules):
-        dict_oval_trees = dict()
+        dict_oval_trees = {}
         paths_to_generated_rules = []
         if len(rules['rules']) == 1:
             self.selected_only_one_rule = True
@@ -50,7 +50,7 @@ def _prepare_data(self, rules):
             except NotTestedRule as error:
                 start_red_color = '\033[91m'
                 end_red_color = '\033[0m'
-                message = '{}{}{}'.format(start_red_color, str(error), end_red_color)
+                message = f'{start_red_color}{str(error)}{end_red_color}'
                 raise NotTestedRule(message) from error
         if self.all_in_one:
             path = self.get_save_src('rules' + self._get_date())
@@ -63,7 +63,7 @@ def _get_src_for_one_graph(self, rule):
 
     @staticmethod
     def get_file_name(rule):
-        return "{}{}.html".format(START_OF_FILE_NAME, rule)
+        return f"{START_OF_FILE_NAME}{rule}.html"
 
     def get_save_src(self, rule):
         if self.out is not None:
@@ -103,12 +103,14 @@ def _open_web_browser(self, path_to_result):
         is_firefox_installed = self._is_firefox_installed()
         if is_firefox_installed:
             command = ["firefox", path_to_result]
+            # pylint: disable=bad-option-value,R1732
             browser = Popen(command, stdout=PIPE, stderr=PIPE)
             self.web_browsers.append(browser)
             time.sleep(0.2)
         else:
             default_web_browser_name = webbrowser.get().name
             command = [default_web_browser_name, path_to_result]
+            # pylint: disable=bad-option-value,R1732
             browser = Popen(command, stdout=PIPE, stderr=PIPE)
             self.web_browsers.append(browser)
             time.sleep(0.2)

oval_graph/command_line_client/client_json_input.py

@@ -25,16 +25,15 @@ def _get_rows_of_unselected_rules(self):
         raise NotImplementedError
 
     def get_json_data_file(self):
-        with open(self.source_filename, 'r') as file_:
+        with open(self.source_filename, 'r', encoding="utf-8") as file_:
             try:
                 return json.load(file_)
             except json.JSONDecodeError as error:
                 raise ValueError(
-                    'Used file "{}" is not valid json.'.format(
-                        self.source_filename)) from error
+                    f'Used file "{self.source_filename}" is not valid json.') from error
 
     def search_rules_id(self):
         rules = self._get_wanted_rules(self.json_data_file.keys())
         if not rules:
-            raise ValueError('404 rule "{}" not found!'.format(self.rule_name))
+            raise ValueError(f'404 rule "{self.rule_name}" not found!')
         return rules

oval_graph/html_builder/graph.py

@@ -90,7 +90,7 @@ def _get_data_of_graphs_in_js(self, dict_of_rules):
         json_of_graphs = {self._remove_unfit_chars(key): value
                           for key, value in dict_of_rules.items()}
         data = str(json.dumps(json_of_graphs))
-        return "var data_of_tree = {};".format(data)
+        return f"var data_of_tree = {data};"
 
     def _get_titles_and_places_for_graph(self, dict_of_rules):
         rules_html = E.div({'id': 'graphs'})
@@ -104,15 +104,15 @@ def _get_titles_and_places_for_graph(self, dict_of_rules):
     @staticmethod
     def _get_part(part):
         out = ''
-        with open(LOCAL_DATA_DIR / part, "r") as data_file:
+        with open(LOCAL_DATA_DIR / part, "r", encoding="utf-8") as data_file:
             out = ''.join(data_file.readlines())
         return out
 
     @staticmethod
     def print_output_message(src, rules):
         if len(rules) > 1:
             rule_names = "\n" + "\n".join(rules)
-            print('Rules "{}" done!'.format(rule_names), file=sys.stderr)
+            print(f'Rules "{rule_names}" done!', file=sys.stderr)
         else:
-            print('Rule "{}" done!'.format(rules.pop()), file=sys.stderr)
-        print('Result is saved:"{}"'.format(src), file=sys.stderr)
+            print(f'Rule "{rules.pop()}" done!', file=sys.stderr)
+        print(f'Result is saved:"{src}"', file=sys.stderr)