Merge pull request #173 from DMTF/interop-usecases

mraineri · web-flow · commit e6ac80243bf5 · 2023-07-20T09:48:10.000-04:00
Implement UseCases for top-level resources
diff --git a/common/interop.py b/common/interop.py
@@ -3,7 +3,7 @@
 # Copyright 2016 DMTF. All rights reserved.
 # License: BSD 3-Clause License. For full text see link: https://github.com/DMTF/Redfish-Interop-Validator/blob/master/LICENSE.md
 
-import re
+import re, copy
 from enum import Enum
 from collections import Counter
 
@@ -37,6 +37,7 @@ def __init__(self, name, profile_entry, expected, actual, success):
             self.success = success
         self.parent_results = None
 
+
 def validateComparisonAnyOfAllOf(profile_entry, property_path="Unspecified"):
     """
     Gather comparison information after processing all Resources on system
@@ -335,7 +336,7 @@ def validateMinVersion(version, profile_entry):
 
     # use string comparison, given version numbering is accurate to regex
     my_logger.debug('\tpass ' + str(paramPass))
-    return msgInterop('MinVersion', '{} ({})'.format(profile_entry, payload_split), '<=', version, paramPass),\
+    return msgInterop('MinVersion', profile_entry, '<=', version, paramPass),\
         paramPass
 
 
@@ -680,6 +681,54 @@ def validateInteropResource(propResourceObj, interop_profile, rf_payload):
     counts = Counter()
     # rf_payload_tuple provides the chain of dicts containing dicts, needed for CompareProperty
     rf_payload_tuple = (rf_payload, None)
+
+    if "UseCases" in interop_profile:
+        for use_case in interop_profile['UseCases']:
+            entry_title = use_case.get("UseCaseTitle", "NoName").replace(' ','_')
+            my_logger.debug('UseCase {}'.format(entry_title))
+
+            # Check if we have a valid UseCase
+            if 'URIs' not in use_case and 'UseCaseKeyProperty' not in use_case:
+                my_logger.error('UseCase does not have URIs or UseCaseKeyProperty...')
+
+            if 'UseCaseKeyProperty' in use_case:
+                entry_key, entry_comparison, entry_values = use_case['UseCaseKeyProperty'], use_case['UseCaseComparison'], use_case['UseCaseKeyValues']
+
+                _, use_case_applies = checkComparison(rf_payload.get(entry_key), entry_comparison, entry_values)
+
+                # Check if URI applies to this usecase as well
+                if 'URIs' in use_case:
+                    use_case_applies = checkInteropURI(propResourceObj, use_case['URIs']) and use_case_applies
+
+            elif 'URIs' in use_case:
+                use_case_applies = checkInteropURI(propResourceObj, use_case['URIs'])
+            
+            else:
+                use_case_applies = False
+
+            if use_case_applies:
+                my_msg = msgInterop("UseCase.{}".format(entry_title), '-', '-', '-', sEnum.OK)
+
+                msgs.append(my_msg)
+
+                my_logger.info('Validating using UseCase {}'.format(entry_title))
+
+                # Remove URIs
+                new_case = {key: val for key, val in use_case.items() if key not in ['URIs']}
+
+                new_msgs, new_counts = validateInteropResource(propResourceObj, new_case, rf_payload)
+
+                if any([msg.success == sEnum.FAIL for msg in new_msgs]):
+                    my_msg.success = sEnum.FAIL
+
+                msgs.extend(new_msgs)
+                counts.update(new_counts)
+
+            else:
+                my_logger.info('UseCase {} does not apply'.format(entry_title))
+
+        return msgs, counts
+
     if "URIs" in interop_profile:
         # Check if the profile requirements apply to this particular instance
         if not checkInteropURI(propResourceObj, interop_profile['URIs']):
diff --git a/tests/interoptests.py b/tests/interoptests.py
@@ -10,6 +10,11 @@
 
 import common.interop as riv
 
+import logging
+
+logging.Logger.verbose1 = logging.Logger.debug
+logging.Logger.verbose2 = logging.Logger.debug
+
 class ValidatorTest(TestCase):
 
     # can we test writeable, find_prop, conditional
@@ -20,7 +25,7 @@ def test_no_test(self):
 
     def test_requirement(self):
         entries = ['Mandatory', 'Recommended', 'Mandatory', 'Recommended']
-        vals = ['Ok', 'DNE', 'DNE', 'Ok']
+        vals = ['Ok', riv.REDFISH_ABSENT, rif.REDFISH_ABSENT, 'Ok']
         boolist = [True, True, False, True]
         for e, v, b in zip(entries, vals, boolist):
             self.assertTrue(riv.validateRequirement(e, v)[1] == b, str(e + ' ' + v))
@@ -70,7 +75,7 @@ def test_action(self):
                     "ResetType@Redfish.AllowableValues": ["On", "ForceOff"],
                     "target": "/redfish/v1/Chassis/System.Embedded.1/Actions/Chassis.Reset"}
         vals = [interopdict,
-                'DNE', 'DNE', interopdict, {}]
+                riv.REDFISH_ABSENT, riv.REDFISH_ABSENT, interopdict, {}]
         entries = [{
                     "ReadRequirement": "Mandatory",
                     "Parameters": {
diff --git a/validateResource.py b/validateResource.py
@@ -9,6 +9,7 @@
 import traverseInterop
 import common.interop as interop
 from common.redfish import getType, getNamespace
+from common.interop import REDFISH_ABSENT
 
 my_logger = logging.getLogger()
 my_logger.setLevel(logging.DEBUG)
@@ -245,6 +246,7 @@ def validateURITree(URI, profile, uriName, expectedType=None, expectedSchema=Non
             "Writeable": False,
             "URIsFound": [URI.rstrip('/')],
             "SubordinateTo": set(),
+            "UseCasesFound": set()
         }
 
     # parent first, then child execution
@@ -299,25 +301,33 @@ def validateURITree(URI, profile, uriName, expectedType=None, expectedSchema=Non
                     subordinate_tree.append(parentType)
                     current_parent = current_parent.parent
 
+                # Search for UseCase.USECASENAME
+                usecases_found = [msg.name.split('.')[-1] for msg in linkResults[linkName]['messages'] if 'UseCase' == msg.name.split('.')[0]]
+
                 if resource_stats.get(SchemaType) is None:
                     resource_stats[SchemaType] = {
                         "Exists": True,
                         "Writeable": False,
                         "URIsFound": [link.rstrip('/')],
                         "SubordinateTo": set([tuple(reversed(subordinate_tree))]),
+                        "UseCasesFound": set(usecases_found),
                     }
                 else:
                     resource_stats[SchemaType]['Exists'] = True
                     resource_stats[SchemaType]['URIsFound'].append(link.rstrip('/'))
                     resource_stats[SchemaType]['SubordinateTo'].add(tuple(reversed(subordinate_tree)))
-
+                    resource_stats[SchemaType]['UseCasesFound'].union(usecases_found)
 
             if refLinks is not currentLinks and len(newLinks) == 0 and len(refLinks) > 0:
                 currentLinks = refLinks
             else:
                 currentLinks = newLinks
+
+        my_logger.info('Service Level Checks')
+        # NOTE: readrequirements will likely be errors when using --payload outside of root
         
         # For every resource check ReadRequirement
+        # TODO: verify if IfImplemented should report a fail if any fails exist.  Also verify the same for Recommended
         resources_in_profile = profile.get('Resources', [])
         for resource_type in resources_in_profile:
             profile_entry = resources_in_profile[resource_type]
@@ -326,68 +336,90 @@ def validateURITree(URI, profile, uriName, expectedType=None, expectedSchema=Non
                 msgs = interop.validateComparisonAnyOfAllOf(profile_entry['PropertyRequirements'], resource_type)
                 message_list.extend(msgs)
 
-            apply_requirement, expected_requirement = False, None
+            does_resource_exist, expected_requirement = False, None
+
+            resource_exists, uris_found, subs_found = False, [], []
 
             # If exist and for what URIs...
             if resource_type in resource_stats:
                 resource_exists = resource_stats[resource_type]['Exists']
                 uris_found = resource_stats[resource_type]['URIsFound']
                 subs_found = resource_stats[resource_type]['SubordinateTo']
-            else:
-                resource_exists = False
-                uris_found = []
-                subs_found = []
+                usecases_found = resource_stats[resource_type]['UseCasesFound']
+
+            # Before all else, UseCases takes priority
+            if 'UseCases' in profile_entry:
+                # For each use case, apply the Requirement
+                for use_case in profile_entry['UseCases']:
+                    entry_title = use_case.get("UseCaseTitle", "NoName").replace(' ', '_')
+                    expected_requirement = use_case.get("ReadRequirement", "Mandatory")
+                    uris_applied = use_case.get("URIs")
+
+                    if uris_applied:
+                        does_resource_exist = any([interop.compareRedfishURI(uris_applied, uri) for uri in uris_found])
+                    else:
+                        does_resource_exist = resource_exists
+
+                    does_resource_exist = does_resource_exist and entry_title in usecases_found
+
+                    my_logger.info('Validating UseCase {} of {} ReadRequirement'.format(entry_title, resource_type))
+
+                    my_msg, _ = interop.validateRequirement(expected_requirement, 'Exists' if does_resource_exist else REDFISH_ABSENT)
+                    my_msg.name = 'UseCase.{}.{}'.format(entry_title, my_msg.name)
+                    if uris_applied:
+                        my_msg.expected = "{} at {}".format(my_msg.expected, ", ".join(uris_applied))
+                    message_list.append(my_msg)
+                continue  
 
             # Check conditionals, if it applies, get its requirement
-            if "ConditionalRequirements" in profile_entry:
+            elif "ConditionalRequirements" in profile_entry:
                 for condition in profile_entry['ConditionalRequirements']:
                     uris_applied = condition.get("URIs")
                     subordinate_condition = condition.get("SubordinateToResource")
+                    # Check if we have valid URIs for this conditional
                     if uris_applied:
-                        apply_requirement = any([interop.compareRedfishURI(uris_applied, uri) for uri in uris_found])
-                        my_logger.info('Checking if any {} in {}: {}'.format(uris_found, uris_applied, apply_requirement))
+                        does_resource_exist = any([interop.compareRedfishURI(uris_applied, uri) for uri in uris_found])
+                        my_logger.info('Checking if any {} in {}: {}'.format(uris_found, uris_applied, does_resource_exist))
+                    # Or check if we are underneath the correct resource chain
                     elif subordinate_condition:
-                        apply_requirement = any([(tuple((subordinate_condition))) == chain[-len(subordinate_condition):] for chain in subs_found])
-                        my_logger.info('Checking if any {} matches {}: {}'.format([x for x in subs_found], subordinate_condition, apply_requirement))
+                        does_resource_exist = any([(tuple((subordinate_condition))) == chain[-len(subordinate_condition):] for chain in subs_found])
+                        my_logger.info('Checking if any {} matches {}: {}'.format([x for x in subs_found], subordinate_condition, does_resource_exist))
+                    # warn user if Conditional has no appropriate conditions to use
                     else:
-                        apply_requirement = resource_exists
+                        does_resource_exist = resource_exists
                         my_logger.warn('This resource {} has no valid Conditional in ConditionalRequirements'.format(resource_type))
 
+                    # if we have a ReadRequirement...
                     expected_requirement = condition.get("ReadRequirement")
                     if expected_requirement:
                         my_logger.info('Validating {} Conditional ReadRequirement'.format(resource_type))
-                        my_msg, _ = interop.validateRequirement(expected_requirement, 'Exists' if apply_requirement else 'DNE')
+                        my_msg, _ = interop.validateRequirement(expected_requirement, 'Exists' if does_resource_exist else REDFISH_ABSENT)
                         my_msg.name = '{}.Conditional.{}'.format(resource_type, my_msg.name)
                         if uris_applied:
                             my_msg.expected = "{} at {}".format(my_msg.expected, ", ".join(uris_applied))
                         if subordinate_condition:
                             my_msg.expected = "{} under {}".format(my_msg.expected, ", ".join(subordinate_condition))
                         message_list.append(my_msg)
 
+            # Outside of ConditionalRequirements, check just for URIs
+            # TODO: Verify if this should run if ConditionalRequirements exists
             expected_requirement = profile_entry.get("ReadRequirement", "Mandatory")
             uris_applied = profile_entry.get("URIs")
 
             if uris_applied:
-                apply_requirement = any([interop.compareRedfishURI(uris_applied, uri) for uri in uris_found])
+                does_resource_exist = any([interop.compareRedfishURI(uris_applied, uri) for uri in uris_found])
             else:
-                apply_requirement = resource_exists
+                does_resource_exist = resource_exists
 
             my_logger.info('Validating {} ReadRequirement'.format(resource_type))
-            my_msg, _ = interop.validateRequirement(expected_requirement, 'Exists' if apply_requirement else 'DNE')
+            my_msg, _ = interop.validateRequirement(expected_requirement, 'Exists' if does_resource_exist else REDFISH_ABSENT)
             my_msg.name = '{}.{}'.format(resource_type, my_msg.name)
             if uris_applied:
                 my_msg.expected = "{} at {}".format(my_msg.expected, ", ".join(uris_applied))
             message_list.append(my_msg)
-
-
+            
     # interop service level checks
     finalResults = {}
-    my_logger.info('Service Level Checks')
-    if URI not in ["/redfish/v1", "/redfish/v1/"]:
-        resultEnum = interop.sEnum.WARN
-        my_logger.info("We are not validating root, warn only")
-    else:
-        resultEnum = interop.sEnum.FAIL
 
     for item in message_list:
         if item.success == interop.sEnum.WARN:
