redfish-interop-validator 2.2.5__tar.gz → 2.2.7__tar.gz

{redfish_interop_validator-2.2.5/redfish_interop_validator.egg-info → redfish_interop_validator-2.2.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: redfish_interop_validator
-Version: 2.2.5
+Version: 2.2.7
 Summary: Redfish Interop Validator
 Home-page: https://github.com/DMTF/Redfish-Interop-Validator
 Author: DMTF, https://www.dmtf.org/standards/feedback

{redfish_interop_validator-2.2.5 → redfish_interop_validator-2.2.7}/redfish_interop_validator/RedfishInteropValidator.py

@@ -17,7 +17,7 @@ import redfish_interop_validator.traverseInterop as traverseInterop
 from redfish_interop_validator.profile import getProfiles, checkProfileAgainstSchema, hashProfile
 from redfish_interop_validator.validateResource import validateSingleURI, validateURITree
 
-tool_version = '2.2.5'
+tool_version = '2.2.7'
 
 # Set up the custom debug levels
 VERBOSE1 = logging.INFO - 1

{redfish_interop_validator-2.2.5 → redfish_interop_validator-2.2.7}/redfish_interop_validator/interop.py

@@ -767,6 +767,15 @@ def checkInteropURI(r_obj, profile_entry):
     my_id, my_uri = r_obj.jsondata.get('Id'), r_obj.uri
     return compareRedfishURI(profile_entry, my_uri)
 
+# Expected Type, Key
+entry_type_table = {
+    'ChassisType': ("Chassis", "ChassisType"),
+    'DriveProtocol': ("Drive", "Protocol"),
+    'MemoryType': ("Memory", "MemoryType"),
+    'PortProtocol': ("Port", "PortProtocol"),
+    'ProcessorType': ("Processor", "ProcessorType"),
+}
+
 
 def validateInteropResource(propResourceObj, interop_profile, rf_payload):
     """
@@ -783,11 +792,12 @@ def validateInteropResource(propResourceObj, interop_profile, rf_payload):
         for use_case in interop_profile['UseCases']:
             entry_title = use_case.get("UseCaseTitle", "NoName").replace(' ', '_')
             entry_type = use_case.get("UseCaseType", "Normal")
+            my_parent = propResourceObj.parent
             my_logger.debug('UseCase {} {}'.format(entry_title, entry_type))
 
             # Check if we have a valid UseCase
-            if 'URIs' not in use_case and 'UseCaseKeyProperty' not in use_case and entry_type != 'AbsentResource':
-                my_logger.error('UseCase does not have URIs or UseCaseKeyProperty...')
+            if ('URIs' not in use_case) and ('UseCaseKeyProperty' not in use_case) and (entry_type not in ['AbsentResource'] + list(entry_type_table.keys())):
+                my_logger.error('UseCase does not have URIs or valid UseCase...')
 
             if entry_type == 'AbsentResource':
                 my_status = rf_payload.get('Status')
@@ -797,6 +807,28 @@ def validateInteropResource(propResourceObj, interop_profile, rf_payload):
                     use_case_applies = False
                 if 'URIs' in use_case:
                     use_case_applies = use_case_applies and checkInteropURI(propResourceObj, use_case['URIs'])
+            
+            elif entry_type in entry_type_table:
+                target_type_found = False
+                target_type, entry_key = entry_type_table[entry_type]
+                entry_comparison, entry_values = use_case['UseCaseComparison'], use_case['UseCaseKeyValues']
+
+                # Iterate until we find our target type, if not found then use case cannot apply
+                while my_parent is not None and not target_type_found:
+                    parent_type = getType(my_parent.jsondata.get('@odata.type', 'NoType'))
+                    target_type_found = parent_type == target_type
+                    if not target_type_found:
+                        my_parent = my_parent.parent
+
+                if target_type_found:
+                    target_payload = my_parent.jsondata
+                    target_value = target_payload.get(entry_key)
+
+                    _, use_case_applies = checkComparison(target_payload.get(entry_key, REDFISH_ABSENT), entry_comparison, entry_values)
+                else:
+                    my_logger.verbose1('Type {} was not found in parent typechain'.format(target_type))
+                    use_case_applies = False
+
 
             elif 'UseCaseKeyProperty' in use_case:
                 entry_key, entry_comparison, entry_values = use_case['UseCaseKeyProperty'], use_case['UseCaseComparison'], use_case['UseCaseKeyValues']

{redfish_interop_validator-2.2.5 → redfish_interop_validator-2.2.7}/redfish_interop_validator/tohtml.py

@@ -158,20 +158,25 @@ def renderHtml(results, finalCounts, tool_version, startTick, nowTick, config):
     for cnt, item in enumerate(results):
         entry = []
         val = results[item]
-        rtime = '(response time: {})'.format(val['rtime'])
+        response_time = val.get('rtime')
+        if isinstance(response_time, float) and response_time >= 0:
+            rtime = '(response time: {})'.format(response_time)
+        else:
+            rtime = ''
 
         if len(val['messages']) == 0 and len(val['errors']) == 0 and len(val['warns']) == 0:
             continue
 
         # uri block
-        prop_type = val['fulltype']
+        prop_type, type_name = val['fulltype'], ''
         if prop_type is not None:
-            namespace = getNamespace(prop_type)
             type_name = getType(prop_type)
 
-        infos_a = [str(val.get(x)) for x in ['uri', 'samplemapped'] if val.get(x) not in ['',None]]
-        infos_a.append(rtime)
-        infos_a.append(type_name)
+        infos_a = [str(val.get(x)) for x in ['uri', 'samplemapped'] if val.get(x) not in ['', None]]
+        if rtime != '':
+            infos_a.append(rtime)
+        if type_name:
+            infos_a.append(type_name)
         uriTag = tag.tr(tag.th(infoBlock(infos_a, ' '), 'class="titlerow bluebg"'))
         entry.append(uriTag)
 

{redfish_interop_validator-2.2.5 → redfish_interop_validator-2.2.7}/redfish_interop_validator/traverseInterop.py

@@ -336,13 +336,13 @@ def createResourceObject(name, uri, jsondata=None, typename=None, context=None,
     """    # Create json from service or from given
 
     if jsondata is None and not isComplex:
-        success, jsondata, status, _, response = callResourceURI(uri)
+        success, jsondata, status, response_time, response = callResourceURI(uri)
         traverseLogger.debug('{}, {}, {}'.format(success, jsondata, status))
         if not success:
             my_logger.error('{}:  URI could not be acquired: {}'.format(uri, status))
             return None, status
     else:
-        success, jsondata, status, _, response = True, jsondata, -1, 0, None
+        success, jsondata, status, response_time, response = True, jsondata, -1, 0, None
 
     # Collect our resource header
     if response:
@@ -354,6 +354,8 @@ def createResourceObject(name, uri, jsondata=None, typename=None, context=None,
     
     newResource = ResourceObj(name, uri, jsondata, typename, context, parent, isComplex, headers=my_header)
 
+    newResource.rtime = response_time
+
     return newResource, status
 
 

{redfish_interop_validator-2.2.5 → redfish_interop_validator-2.2.7}/redfish_interop_validator/validateResource.py

@@ -66,7 +66,7 @@ def validateSingleURI(URI, profile, uriName='', expectedType=None, expectedSchem
                         'messages': messages,
                         'errors': '',
                         'warns': '',
-                        'rtime': '',
+                        'rtime': 'n/a',
                         'context': '',
                         'fulltype': '',
                         'rcode': 0,
@@ -168,7 +168,7 @@ def validateSingleURI(URI, profile, uriName='', expectedType=None, expectedSchem
     profile_resources = profile_resources.get(SchemaType)
     try:
         propMessages, propCounts = interop.validateInteropResource(resource_obj, profile_resources, jsondata)
-        messages = messages.extend(propMessages)
+        messages.extend(propMessages)
         counts.update(propCounts)
         my_logger.info('{} of {} tests passed.'.format(counts['pass'] + counts['warn'], counts['totaltests']))
     except Exception:
@@ -312,8 +312,7 @@ def validateURITree(URI, profile, uriName, expectedType=None, expectedSchema=Non
                 allLinks.add(link.rstrip('/'))
 
                 results.update(linkResults)
-                counts.update(linkCounts)
-
+            
                 if not linkSuccess:
                     continue
 
@@ -465,7 +464,7 @@ def validateURITree(URI, profile, uriName, expectedType=None, expectedSchema=Non
     finalResults['n/a'] = {'uri': "Service Level Requirements", 'success': message_counts.get('fail', 0) == 0,
                            'counts': message_counts,
                            'messages': message_list, 'errors': error_messages.getvalue(), 'warns': '',
-                           'rtime': '', 'context': '', 'fulltype': ''}
+                           'rtime': None, 'context': '', 'fulltype': ''}
     finalResults.update(results)
     error_messages.close()
 

{redfish_interop_validator-2.2.5 → redfish_interop_validator-2.2.7/redfish_interop_validator.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: redfish_interop_validator
-Version: 2.2.5
+Version: 2.2.7
 Summary: Redfish Interop Validator
 Home-page: https://github.com/DMTF/Redfish-Interop-Validator
 Author: DMTF, https://www.dmtf.org/standards/feedback

{redfish_interop_validator-2.2.5 → redfish_interop_validator-2.2.7}/setup.py

@@ -11,7 +11,7 @@ with open("README.md", "r", "utf-8") as f:
 
 setup(
     name="redfish_interop_validator",
-    version="2.2.5",
+    version="2.2.7",
     description="Redfish Interop Validator",
     long_description=long_description,
     long_description_content_type="text/markdown",