oval_graph.arf_xml_parser.xml_parser

Complexity

Total Complexity

20

Size/Duplication

Total Lines	129
Duplicated Lines	0 %

Test Coverage

Coverage

100%

Importance

Changes

0

10 Methods

Rating	Name	Duplication	Size	Complexity
A	XmlParser._get_oval_definitions()	0	6	1
A	XmlParser._get_used_rules()	0	15	3
A	XmlParser.get_src()	0	4	1
A	XmlParser._get_definitions()	0	5	1
A	XmlParser._get_report_data()	0	7	3
A	XmlParser._get_rule_dict()	0	11	3
A	XmlParser.__init__()	0	22	3
A	XmlParser._get_definition_of_rule()	0	13	3
A	XmlParser.get_oval_tree()	0	3	1
A	XmlParser.validate()	0	9	1

"""
    This file contains a class for creating OVAL graph from ARF XML source
"""

import os
import sys

from lxml import etree as ET

from .._builder_oval_tree import _BuilderOvalTree
from ..exceptions import NotTestedRule
from ._xml_parser_oval_scan_definitions import _XmlParserScanDefinitions

ns = {
    'XMLSchema': 'http://oval.mitre.org/XMLSchema/oval-results-5',
    'xccdf': 'http://checklists.nist.gov/xccdf/1.2',
    'arf': 'http://scap.nist.gov/schema/asset-reporting-format/1.1',
    'oval-definitions': 'http://oval.mitre.org/XMLSchema/oval-definitions-5',
    'scap': 'http://scap.nist.gov/schema/scap/source/1.2',
    'oval-characteristics': 'http://oval.mitre.org/XMLSchema/oval-system-characteristics-5',
}


class XmlParser:

Too many instance attributes (11/7)

    def __init__(self, src):
        self.src = src
        self.tree = ET.parse(self.src)
        self.root = self.tree.getroot()
        self.arf_schemas_src = '../schemas/arf/1.1/asset-reporting-format_1.1.0.xsd'
        if not self.validate(self.arf_schemas_src):
            CRED = '\033[91m'

Variable name "CRED" doesn't conform to snake_case naming style ('([^\\W\\dA-Z][^\\WA-Z]2,|_[^\\WA-Z]*|__[^\\WA-Z\\d_][^\\WA-Z]+__)$' pattern)

            CEND = '\033[0m'

Variable name "CEND" doesn't conform to snake_case naming style ('([^\\W\\dA-Z][^\\WA-Z]2,|_[^\\WA-Z]*|__[^\\WA-Z\\d_][^\\WA-Z]+__)$' pattern)

            message = CRED + "Warning: This file is not valid arf report." + CEND
            print(message, file=sys.stderr)
        try:
            self.used_rules, self.not_tested_rules = self._get_used_rules()
            self.report_data_href = list(self.used_rules.values())[0]['href']
            self.report_data = self._get_report_data(self.report_data_href)
            self.definitions = self._get_definitions()
            self.oval_definitions = self._get_oval_definitions()
            self.scan_definitions = _XmlParserScanDefinitions(
                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

    def get_src(self, src):

This method could be written as a function/class method.

        _dir = os.path.dirname(os.path.realpath(__file__))
        FIXTURE_DIR = os.path.join(_dir, src)

Variable name "FIXTURE_DIR" doesn't conform to snake_case naming style ('([^\\W\\dA-Z][^\\WA-Z]2,|_[^\\WA-Z]*|__[^\\WA-Z\\d_][^\\WA-Z]+__)$' pattern)

        return str(FIXTURE_DIR)

    def validate(self, xsd_path):
        xsd_path = self.get_src(xsd_path)
        xmlschema_doc = ET.parse(xsd_path)
        xmlschema = ET.XMLSchema(xmlschema_doc)

        xml_doc = self.tree
        result = xmlschema.validate(xml_doc)

        return result

    def _get_rule_dict(self, rule_result, result, check_content_ref):

This method could be written as a function/class method.

        message = rule_result.find(
            './/xccdf:message', ns)
        rule_dict = {}
        if check_content_ref is not None:
            rule_dict['id_def'] = check_content_ref.attrib.get('name')
            rule_dict['href'] = check_content_ref.attrib.get('href')
            rule_dict['result'] = result.text
        if message is not None:
            rule_dict['message'] = message.text
        return rule_dict

    def _get_used_rules(self):
        rules_results = self.root.findall(
            './/xccdf:TestResult/xccdf:rule-result', ns)
        rules = {}
        not_tested_rules = {}
        for rule_result in rules_results:
            result = rule_result.find('.//xccdf:result', ns)
            check_content_ref = rule_result.find(
                './/xccdf:check/xccdf:check-content-ref', ns)
            if check_content_ref is not None:
                id_ = rule_result.get('idref')
                rules[id_] = self._get_rule_dict(rule_result, result, check_content_ref)
            else:
                not_tested_rules[rule_result.get('idref')] = result.text
        return (rules, not_tested_rules)

    def _get_report_data(self, href):
        report_data = None
        reports = self.root.find('.//arf:reports', ns)
        for report in reports:
            if "#" + str(report.get("id")) == href:
                report_data = report
        return report_data

    def _get_definitions(self):
        data = self.report_data.find(
            ('.//XMLSchema:oval_results/XMLSchema:results/'
             'XMLSchema:system/XMLSchema:definitions'), ns)
        return data

    def _get_oval_definitions(self):
        return self.root.find(
            './/arf:report-requests/arf:report-request/'
            'arf:content/scap:data-stream-collection/'
            'scap:component/oval-definitions:oval_definitions/'
            'oval-definitions:definitions', ns)

    def _get_definition_of_rule(self, rule_id):
        if rule_id in self.used_rules:

Unnecessary "elif" after "return"

            rule_info = self.used_rules[rule_id]
            return dict(rule_id=rule_id,
                        definition_id=rule_info['id_def'],
                        definition=self.scan_definitions[rule_info['id_def']])
        elif 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]))
        else:
            print(self.not_tested_rules)
            raise ValueError('404 rule "{}" not found!'.format(rule_id))

    def get_oval_tree(self, rule_id):
        return _BuilderOvalTree.get_oval_tree_from_dict_of_rule(
            self._get_definition_of_rule(rule_id))