Source code for bugzoo.core.coverage

__all__ = ['CoverageInstructions', 'TestCoverage', 'TestSuiteCoverage']

from typing import (Dict, List, Set, Iterator, Any, Iterable, FrozenSet, Type,
                    Optional, Mapping)
from collections import OrderedDict
import logging

import yaml
import attr

from .language import Language
from .fileline import FileLine, FileLineSet
from .test import TestSuite, TestOutcome
from ..util import indent
from .. import exceptions

logger = logging.getLogger(__name__)  # type: logging.Logger

_NAME_TO_INSTRUCTIONS = {}  # type: Dict[str, Type[CoverageInstructions]]
_INSTRUCTIONS_TO_NAME = {}  # type: Dict[Type[CoverageInstructions], str]
    {}  # type: Dict[Language, Type[CoverageInstructions]]

def _convert_files_to_instrument(files: Iterable[str]) -> FrozenSet[str]:
    return frozenset(files)

class CoverageInstructions:
    """Instructions for computing coverage."""
    def registered_under_name(cls) -> str:
        """Returns the name that was used to register this class."""
        return _INSTRUCTIONS_TO_NAME[cls]

    def language_default(language: Language
                         ) -> Optional[Type['CoverageInstructions']]:
        Returns the default coverage instructions class for a given language,
        if such a class has been registered for that language.
        return _LANGUAGE_TO_DEFAULT_INSTRUCTIONS.get(language)

    def find(name: str) -> Type['CoverageInstructions']:
        Retrieves the coverage instructions class registered for a given name.
        return _NAME_TO_INSTRUCTIONS[name]

    def register(cls, name: str) -> None:
        logger.debug("registering coverage instructions [%s] under name [%s]",
                     cls, name)
        if name in _NAME_TO_INSTRUCTIONS:
            raise exceptions.NameInUseError(name)
        if cls in _INSTRUCTIONS_TO_NAME:
            m = "coverage instructions already registered under name: {}"
            m = m.format(_INSTRUCTIONS_TO_NAME[cls])
            raise Exception(m)  # FIXME add new error class
        _NAME_TO_INSTRUCTIONS[name] = cls
        _INSTRUCTIONS_TO_NAME[cls] = name
        logger.debug("registered coverage instructions [%s] under name [%s]",
                     cls, name)

    def register_as_default(cls, language: Language) -> None:
        logger.debug("registering coverage instructions [%s] as default for %s",  # noqa: pycodestyle
                     cls, language)

            m = "language [{}] already has a default coverage instructions: {}"
            m = m.format(,
            raise Exception(m)

        if cls not in _INSTRUCTIONS_TO_NAME:
            m = "coverage instructions [{}] have not been registered"
            m = m.format(cls)
            raise Exception(m)
        name = _INSTRUCTIONS_TO_NAME[cls]

        logger.debug("registered coverage instructions [%s] as default for %s",
                     name, language)

    def from_dict(d: Dict[str, Any]) -> 'CoverageInstructions':
        Loads a set of coverage instructions from a given dictionary.

            BadCoverageInstructions: if the given coverage instructions are
        name_type = d['type']
        cls = _NAME_TO_INSTRUCTIONS[name_type]
        return cls.from_dict(d)

    def to_dict(self) -> Dict[str, Any]:
        raise NotImplementedError

[docs]class TestCoverage: """ Provides complete line coverage information for all files and across all tests within a given project. """ @staticmethod def from_dict(d: dict) -> 'TestCoverage': """ Example Input: { "test": "p1", "outcome": { }, "coverage": { "foo.c": [1, 2, 6, 10] } } """ assert 'test' in d assert 'outcome' in d assert 'coverage' in d test = d['test'] outcome = TestOutcome.from_dict(d['outcome']) coverage = FileLineSet.from_dict(d['coverage']) return TestCoverage(test, outcome, coverage) def __init__(self, test: str, outcome: TestOutcome, coverage: FileLineSet ) -> None: self.__test = test self.__outcome = outcome self.__coverage = coverage def __repr__(self) -> str: coverage = repr(self.__coverage) coverage = indent(coverage, 2) status = 'PASSED' if self.__outcome.passed else 'FAILED' s = "[{}: {}]\n{}".format(self.__test, status, coverage) return s def __contains__(self, fileline: FileLine) -> bool: return fileline in self.__coverage @property def test(self) -> str: """Name of the test case used to generate this coverage.""" return self.__test @property def outcome(self) -> TestOutcome: """Outcome of the test associated with this coverage.""" return self.__outcome @property def lines(self) -> FileLineSet: """Set of file-lines that were covered.""" return self.__coverage coverage = lines def restricted_to_files(self, filenames: List[str]) -> 'TestCoverage': """ Returns a variant of this coverage that is restricted to a given list of files. """ return TestCoverage(self.__test, self.__outcome, self.__coverage.restricted_to_files(filenames)) def to_dict(self) -> dict: return {'test': self.__test, 'outcome': self.__outcome.to_dict(), 'coverage': self.__coverage.to_dict()}
[docs]class TestSuiteCoverage(Mapping[str, TestCoverage]): """ Holds coverage information for all tests belonging to a particular program version. """ @staticmethod def from_dict(d: dict) -> 'TestSuiteCoverage': coverage_by_test = {} for test_coverage_dict in d.values(): test_coverage = TestCoverage.from_dict(test_coverage_dict) coverage_by_test[test_coverage.test] = test_coverage return TestSuiteCoverage(coverage_by_test) @staticmethod def from_file(fn: str) -> 'TestSuiteCoverage': with open(fn, 'r') as f: d = yaml.safe_load(f) return TestSuiteCoverage.from_dict(d) def __init__(self, test_coverage: Mapping[str, TestCoverage]) -> None: self.__test_coverage = \ OrderedDict() # type: OrderedDict[str, TestCoverage] for test_name in sorted(test_coverage): self.__test_coverage[test_name] = test_coverage[test_name] def __repr__(self) -> str: output = [repr(self[name_test]) for name_test in self] return '\n'.join(output) def covering_tests(self, line: FileLine) -> Set[str]: """Returns the names of all test cases that cover a given line.""" return set(test for (test, cov) in self.__test_coverage.items() \ if line in cov) def __iter__(self) -> Iterator[str]: """ Returns an iterator over the names of the test cases that are represented by this coverage report. """ return self.__test_coverage.keys().__iter__()
[docs] def __getitem__(self, name: str) -> TestCoverage: """Retrieves coverage information for a given test case. Parameters: name: the name of the test case. Raises: KeyError: if there is no coverage information for the given test case. """ return self.__test_coverage[name]
def to_dict(self) -> dict: return {test: cov.to_dict() \ for (test, cov) in self.__test_coverage.items()} def restricted_to_files(self, filenames: List[str] ) -> 'TestSuiteCoverage': """ Returns a variant of this coverage that is restricted to a given list of files. """ cov_suite = {} for test in self: cov_suite[test] = self[test].restricted_to_files(filenames) return TestSuiteCoverage(cov_suite) @property def failing(self) -> 'TestSuiteCoverage': """ Returns a variant of this coverage report that only contains coverage for failing test executions. """ return TestSuiteCoverage({t: cov \ for (t, cov) in self.__test_coverage.items() \ if not cov.outcome.passed}) @property def passing(self) -> 'TestSuiteCoverage': """ Returns a variant of this coverage report that only contains coverage for failing test executions. """ return TestSuiteCoverage({t: cov \ for (t, cov) in self.__test_coverage.items() \ if cov.outcome.passed}) def __len__(self) -> int: """ Returns a count of the number of test executions that are included within this coverage report. """ return len(self.__test_coverage) @property def lines(self) -> Set[FileLine]: """Returns the set of all file lines that were covered.""" assert len(self) > 0 output = FileLineSet() # type: Set[FileLine] for coverage in self.__test_coverage.values(): output = output.union(coverage.lines) return output