sonic-mgmt/tests/common/plugins/test_completeness/__init__.py at e64bf79721d776433ece89a987f353dd14e228f4 · vaibhavhd/sonic-mgmt · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
import sys
import enum
import logging
import warnings

class CompletenessLevel(enum.IntEnum):
    diagnose = 0
    debug = 1 # Minimum execution
    basic = 2
    confident = 3
    thorough = 4 # Maximum execution

    @classmethod
    def get_normalized_level(cls, request):
        """Takes a request instance and returns normalized completeness level in string format.
        For example, if a testcase supports "CompletenessLevel.basic, CompletenessLevel.thorough", and specified level
        during test execution is "confident", this method will make use of normalization logic during
        pytest_runtest_setup and returns the normalized level as "basic" (str type of CompletenessLevel.basic)
        """
        all_supported_levels = [mark.args for mark in request.node.iter_markers(name="supported_completeness_level")]
        logging.info("All supported completeness levels of the test: {}".format(str(all_supported_levels)))
        normalized_level = all_supported_levels[0][0]
        normalized_level_name = CompletenessLevel.get_level_name(normalized_level)
        logging.info("Normalized completeness level set to: {}".format(normalized_level_name))
        return normalized_level_name

    @classmethod
    def get_level_name(cls, level):
        """Converts a type CompletenessLevel to type str.
        For example, if input is CompletenessLevel.basic, this method will return "basic"
        Arguments:
        level - An enum value of type CompletenessLevel
        """
        if type(level) is not CompletenessLevel:
            logging.error("Invalid completeness type. Expected: {}. Format {}".format(str(CompletenessLevel), type(level)))
        level_name = level.name.lower()
        return level_name

def set_default(specified_level):
    if not specified_level: # Case 1
        logging.info("Completeness level not set during test execution. Setting to default level: {}".format(str(CompletenessLevel.basic)))
        specified_level = CompletenessLevel.basic # - every testcase should run BASIC by default
    else:
        specified_level = specified_level.lower()
        if specified_level not in CompletenessLevel._member_names_:
            specified_level = CompletenessLevel.basic
            warnings.warn("Unidentified completeness level specified. Specified: {}. Allowed: {}"\
                .format(str(CompletenessLevel(specified_level)), str(CompletenessLevel._member_names_)))
            logging.info("Unidentified completeness level specified. Setting to default level: {}".format(CompletenessLevel.basic))
        else:
            specified_level = CompletenessLevel[specified_level]

    return specified_level

def normalize_levels(specified_level, defined_levels):
    logging.info("Setting test completeness level. Specified: {}. Defined: {}".\
        format(str(CompletenessLevel(specified_level)), str(defined_levels)))

    if specified_level not in defined_levels:
        # if specified_level is diagnose and the testcase does not support it, default level is basic.
        if specified_level == CompletenessLevel.diagnose:
            specified_level = CompletenessLevel.basic

    if specified_level not in defined_levels:
        if specified_level > max(defined_levels): # Case 3.1
            completeness_level = max(defined_levels)
        elif specified_level < min(defined_levels): # Case 3.2
            completeness_level = min(defined_levels)
        else: # Case 3.3
            # Find the maximum defined level less than specified_level
            lesser_defined_level_dist = sys.maxsize
            for level in defined_levels:
                if level <= specified_level and lesser_defined_level_dist > (specified_level - level):
                    completeness_level = level
                    lesser_defined_level_dist = lesser_defined_level_dist - level
        logging.info("Specified level ({}) not found in defined levels. Setting level to {}".\
            format(str(CompletenessLevel(specified_level)), str(completeness_level)))
    else: # Case 4
        completeness_level = specified_level
        logging.info("Setting the completeness level to {}".format(str(CompletenessLevel(completeness_level))))

    return completeness_level