TestSwaggerCoverage

Complexity

Total Complexity

18

Size/Duplication

Total Lines	90
Duplicated Lines	0 %

Importance

Changes	1
Bugs	0	Features	0

8 Methods

Rating	Name	Duplication	Size	Complexity
A	filter_rules()	0	6	4
A	retrieve_swagger_specs()	0	11	2
A	color_print()	0	11	1
A	filter_methods()	0	7	3
A	test_swagger_coverage()	0	15	2
A	format_rule()	0	8	1
A	setUpClass()	0	5	1
A	retrieve_covered_methods_number()	0	17	4

import json
import unittest
import warnings

from server import server


class TestSwaggerCoverage(unittest.TestCase):
    @classmethod
    def setUpClass(cls):
        cls.client = server.test_client()
        cls.BANNED_RULES = ['/routes', '/status', '/spec', '/ping', '/specs', '/apidocs', '/static']
        cls.THRESHOLD = 100

    def test_swagger_coverage(self):
        """ The swagger coverage should be 100% """

        self.color_print('yellow', '\n##### SWAGGER COVERAGE #####')

        swagger_specs = self.retrieve_swagger_specs()
        rules = self.filter_rules(self.client.application.url_map.iter_rules())

        covered_methods, methods_total = self.retrieve_covered_methods_number(rules, swagger_specs)
        coverage = int(100 * covered_methods / methods_total)

        end_color = 'green' if coverage == 100 else 'yellow'
        self.color_print(end_color, str(covered_methods) + ' of ' + str(methods_total) + ' routes are swagged')

        self.assertTrue(coverage >= self.THRESHOLD)

    def retrieve_swagger_specs(self):
        """ Fetch the swagger specs """

        # suppress flasgger unclosed file warnings
        with warnings.catch_warnings():
            warnings.filterwarnings("ignore", message="unclosed file")
            response = self.client.get('application/spec')
        response_json = json.loads(response.data.decode('utf-8'))
        swagger_specs = response_json['paths']

        return swagger_specs

    def retrieve_covered_methods_number(self, rules, swagger_specs):
        """ Return the number of covered methods and the number of methods """
        methods_total = 0
        covered_methods = 0
        for rule in rules:
            methods = self.filter_methods(rule.methods)
            parsed_rule = self.format_rule(rule)
            for method in methods:
                methods_total += 1
                try:
                    swagger_specs[parsed_rule][method.lower()]
                    covered_methods += 1
                except KeyError:
                    self.color_print('red', 'Uncovered: ' + method + ' of route ' + parsed_rule)
                    continue

        return (covered_methods, methods_total)

    @staticmethod
    def filter_methods(methods):
        """ Filter methods OPTIONS and HEAD """
        return [
            method
            for method in methods
            if method not in ['OPTIONS', 'HEAD']
        ]

    @staticmethod
    def format_rule(rule):
        """
        Format the rule for swagger
        Replace '<' with '{' and '>' with '}'
        Remove arguments type
        """
        return str(rule).replace('<', '{').replace('>', '}').replace('string:', '').replace('int:', '')

    def filter_rules(self, rules):
        """ Filter rules that do not need to be documented """
        return [
            rule
            for rule in rules
            if not any(banned_rule in str(rule) for banned_rule in self.BANNED_RULES)
        ]

    @staticmethod
    def color_print(color, message):
        """ Print message with some nice color """
        colors = {
            'green': '\033[92m',
            'yellow': '\033[93m',
            'red': '\033[91m',
            'endc': '\033[0m',
        }

        print(colors[color] + message + colors['endc'])


if __name__ == '__main__':
    unittest.main()