Use cached testbedInfo and host_vars in inventory in dut selection fixtures

tests/common/helpers/dut_utils.py

@@ -11,8 +11,8 @@ def is_supervisor_node(inv_files, hostname):
           the inventory, and it is 'supervisor', then return True, else return False. In future, we can change this
           logic if possible to derive it from the DUT.
     """
-    node_type = get_host_visible_vars(inv_files, hostname, variable='type')
-    if node_type and node_type == 'supervisor':
+    dut_vars = get_host_visible_vars(inv_files, hostname)
+    if 'type' in dut_vars and dut_vars['type'] == 'supervisor':
         return True
     return False
 

tests/conftest.py

@@ -204,9 +204,7 @@ def duthost(duthosts, request):
 def rand_one_dut_hostname(request):
     """
     """
-    tbname, testbedinfo = get_tbinfo(request)
-    duts_in_testbed = testbedinfo["duts"]
-    dut_hostnames = generate_params_dut_hostname(duts_in_testbed, tbname)
+    dut_hostnames = generate_params_dut_hostname(request)
     if len(dut_hostnames) > 1:
         dut_hostnames = random.sample(dut_hostnames, 1)
     return dut_hostnames[0]
@@ -225,16 +223,6 @@ def rand_one_dut_lossless_prio(request):
         lossless_prio_list = random.sample(lossless_prio_list, 1)
     return lossless_prio_list[0]
 
-@pytest.fixture(scope="module")
-def rand_one_frontend_dut_hostname(request):
-    """
-    """
-    tbname, testbedinfo = get_tbinfo(request)
-    duts_in_testbed = testbedinfo["duts"]
-    frontend_dut_hostnames = generate_params_frontend_hostname(request, duts_in_testbed, tbname)
-    dut_hostnames = random.sample(frontend_dut_hostnames, 1)
-    return dut_hostnames[0]
-
 @pytest.fixture(scope="module", autouse=True)
 def reset_critical_services_list(duthosts):
     """
@@ -610,28 +598,37 @@ def get_host_data(request, dut):
     return get_host_vars(inv_files, dut)
 
 
-def generate_params_frontend_hostname(request, duts_in_testbed, tbname):
+def generate_params_frontend_hostname(request):
     frontend_duts = []
+    tbname, tbinfo = get_tbinfo(request)
+    duts = tbinfo['duts']
     inv_files = get_inventory_files(request)
-    for dut in duts_in_testbed:
+    for dut in duts:
         if is_frontend_node(inv_files, dut):
             frontend_duts.append(dut)
     assert len(frontend_duts) > 0, \
         "Test selected require at-least one frontend node, " \
-        "none of the DUTs '{}' in testbed '{}' are a supervisor node".format(duts_in_testbed, tbname)
+        "none of the DUTs '{}' in testbed '{}' are a supervisor node".format(duts, tbname)
     return frontend_duts
 
 
-def generate_params_frontend_hostname_rand_per_hwsku(request, duts_in_testbed, tbname):
-    frontend_hosts = generate_params_frontend_hostname(request, duts_in_testbed, tbname)
+def generate_params_hostname_rand_per_hwsku(request, frontend_only=False):
+    tbname, tbinfo = get_tbinfo(request)
+    hosts = tbinfo['duts']
+    if frontend_only:
+        hosts = generate_params_frontend_hostname(request)
     inv_files = get_inventory_files(request)
     # Create a list of hosts per hwsku
     host_hwskus = {}
-    for a_host in frontend_hosts:
-        a_host_hwsku = get_host_visible_vars(inv_files, a_host, variable='hwsku')
-        if not a_host_hwsku:
+    for a_host in hosts:
+        host_vars = get_host_visible_vars(inv_files, a_host)
+        a_host_hwsku = None
+        if 'hwsku' in host_vars:
+            a_host_hwsku = host_vars['hwsku']
+        else:
             # Lets try 'sonic_hwsku' as well
-            a_host_hwsku = get_host_visible_vars(inv_files, a_host, variable='sonic_hwsku')
+            if 'sonic_hwsku' in host_vars:
+                a_host_hwsku = host_vars['sonic_hwsku']
         if a_host_hwsku:
             if a_host_hwsku not in host_hwskus:
                 host_hwskus[a_host_hwsku] = [a_host]
@@ -640,56 +637,65 @@ def generate_params_frontend_hostname_rand_per_hwsku(request, duts_in_testbed, t
         else:
             pytest.fail("Test selected require a node per hwsku, but 'hwsku' for '{}' not defined in the inventory".format(a_host))
 
-    frontend_hosts_per_hwsku = []
+    hosts_per_hwsku = []
     for hosts in host_hwskus.values():
         if len(hosts) == 1:
-            frontend_hosts_per_hwsku.append(hosts[0])
+            hosts_per_hwsku.append(hosts[0])
         else:
-            frontend_hosts_per_hwsku.extend(random.sample(hosts, 1))
+            hosts_per_hwsku.extend(random.sample(hosts, 1))
 
-    return frontend_hosts_per_hwsku
+    return hosts_per_hwsku
 
 
-def generate_params_supervisor_hostname(request, duts_in_testbed, tbname):
-    if len(duts_in_testbed) == 1:
+def generate_params_supervisor_hostname(request):
+    tbname, tbinfo = get_tbinfo(request)
+    duts = tbinfo['duts']
+    if len(duts) == 1:
         # We have a single node - dealing with pizza box, return it
-        return [duts_in_testbed[0]]
+        return [duts[0]]
     inv_files = get_inventory_files(request)
-    for dut in duts_in_testbed:
+    for dut in duts:
         # Expecting only a single supervisor node
         if is_supervisor_node(inv_files, dut):
             return [dut]
     pytest.fail("Test selected require a supervisor node, " +
-                "none of the DUTs '{}' in testbed '{}' are a supervisor node".format(duts_in_testbed, tbname))
-
+                "none of the DUTs '{}' in testbed '{}' are a supervisor node".format(duts, tbname))
 
-def generate_param_asic_index(request, duts_in_testbed, dut_indices, param_type):
-    logging.info("generating {} asic indices for  DUT [{}] in ".format(param_type, dut_indices))
+def generate_param_asic_index(request, dut_indices, param_type):
+    _, tbinfo = get_tbinfo(request)
+    inv_files = get_inventory_files(request)
+    logging.info("generating {} asic indicies for  DUT [{}] in ".format(param_type, dut_indices))
     #if the params are not present treat the device as a single asic device
     asic_index_params = [DEFAULT_ASIC_ID]
 
     for dut_id in dut_indices:
-        dut = duts_in_testbed[dut_id]
-        inv_data = get_host_data(request, dut)
+        dut = tbinfo['duts'][dut_id]
+        inv_data = get_host_visible_vars(inv_files, dut)
         if inv_data is not None:
             if param_type == ASIC_PARAM_TYPE_ALL and ASIC_PARAM_TYPE_ALL in inv_data:
-                asic_index_params = range(int(inv_data[ASIC_PARAM_TYPE_ALL]))
+                if int(inv_data[ASIC_PARAM_TYPE_ALL]) == 1:
+                    asic_index_params = [DEFAULT_ASIC_ID]
+                else:
+                    asic_index_params = range(int(inv_data[ASIC_PARAM_TYPE_ALL]))
             elif param_type == ASIC_PARAM_TYPE_FRONTEND and ASIC_PARAM_TYPE_FRONTEND in inv_data:
                 asic_index_params = inv_data[ASIC_PARAM_TYPE_FRONTEND]
             logging.info("dut_index {} dut name {}  asics params = {}".format(
                 dut_id, dut, asic_index_params))
     return asic_index_params
 
 
-def generate_params_dut_index(duts_in_testbeds, tbname):
-    num_duts = len(duts_in_testbeds)
+def generate_params_dut_index(request):
+    tbname, tbinfo = get_tbinfo(request)
+    num_duts = len(tbinfo['duts'])
     logging.info("Num of duts in testbed '{}' is {}".format(tbname, num_duts))
     return range(num_duts)
 
 
-def generate_params_dut_hostname(duts_in_testbed, tbname):
-    logging.info("DUTs in testbed '{}' are: {}".format(tbname, str(duts_in_testbed)))
-    return duts_in_testbed
+def generate_params_dut_hostname(request):
+    tbname, tbinfo = get_tbinfo(request)
+    duts = tbinfo["duts"]
+    logging.info("DUTs in testbed '{}' are: {}".format(tbname, str(duts)))
+    return duts
 
 
 def generate_port_lists(request, port_scope):
@@ -796,38 +802,41 @@ def generate_priority_lists(request, prio_scope):
     return ret if ret else empty
 
 _frontend_hosts_per_hwsku_per_module = {}
+_hosts_per_hwsku_per_module = {}
 def pytest_generate_tests(metafunc):
     # The topology always has atleast 1 dut
     dut_indices = [0]
-    tbname, testbedinfo = get_tbinfo(metafunc)
-    duts_in_testbed = testbedinfo["duts"]
+    global _frontend_hosts_per_hwsku_per_module, _hosts_per_hwsku_per_module
     # Enumerators ("enum_dut_index", "enum_dut_hostname", "rand_one_dut_hostname") are mutually exclusive
     if "enum_dut_index" in metafunc.fixturenames:
-        dut_indices = generate_params_dut_index(duts_in_testbed, tbname)
+        dut_indices = generate_params_dut_index(metafunc)
         metafunc.parametrize("enum_dut_index", dut_indices, scope="module")
     elif "enum_dut_hostname" in metafunc.fixturenames:
-        dut_hostnames = generate_params_dut_hostname(duts_in_testbed, tbname)
+        dut_hostnames = generate_params_dut_hostname(metafunc)
         metafunc.parametrize("enum_dut_hostname", dut_hostnames, scope="module")
     elif "enum_supervisor_dut_hostname" in metafunc.fixturenames:
-        supervisor_hosts = generate_params_supervisor_hostname(metafunc, duts_in_testbed, tbname)
+        supervisor_hosts = generate_params_supervisor_hostname(metafunc)
         metafunc.parametrize("enum_supervisor_dut_hostname", supervisor_hosts, scope="module")
     elif "enum_frontend_dut_hostname" in metafunc.fixturenames:
-        frontend_hosts = generate_params_frontend_hostname(metafunc, duts_in_testbed, tbname)
+        frontend_hosts = generate_params_frontend_hostname(metafunc)
         metafunc.parametrize("enum_frontend_dut_hostname", frontend_hosts, scope="module")
+    elif "enum_rand_one_per_hwsku_hostname" in metafunc.fixturenames:
+        if metafunc.module not in _hosts_per_hwsku_per_module:
+            hosts_per_hwsku = generate_params_hostname_rand_per_hwsku(metafunc)
+            _hosts_per_hwsku_per_module[metafunc.module] = hosts_per_hwsku
+        hosts = _hosts_per_hwsku_per_module[metafunc.module]
+        metafunc.parametrize("enum_rand_one_per_hwsku_hostname", hosts, scope="module")
     elif "enum_rand_one_per_hwsku_frontend_hostname" in metafunc.fixturenames:
         if metafunc.module not in _frontend_hosts_per_hwsku_per_module:
-            frontend_hosts_per_hwsku = generate_params_frontend_hostname_rand_per_hwsku(metafunc, duts_in_testbed, tbname)
-            _frontend_hosts_per_hwsku_per_module[metafunc.module] = frontend_hosts_per_hwsku
-        frontend_hosts = _frontend_hosts_per_hwsku_per_module[metafunc.module]
-        metafunc.parametrize("enum_rand_one_per_hwsku_frontend_hostname", frontend_hosts, scope="module")
-
+            hosts_per_hwsku = generate_params_hostname_rand_per_hwsku(metafunc, frontend_only=True)
+            _frontend_hosts_per_hwsku_per_module[metafunc.module] = hosts_per_hwsku
+        hosts = _frontend_hosts_per_hwsku_per_module[metafunc.module]
+        metafunc.parametrize("enum_rand_one_per_hwsku_frontend_hostname", hosts, scope="module")
 
     if "enum_asic_index" in metafunc.fixturenames:
-        metafunc.parametrize("enum_asic_index",
-                             generate_param_asic_index(metafunc, duts_in_testbed, dut_indices, ASIC_PARAM_TYPE_ALL))
+        metafunc.parametrize("enum_asic_index", generate_param_asic_index(metafunc, dut_indices, ASIC_PARAM_TYPE_ALL))
     if "enum_frontend_asic_index" in metafunc.fixturenames:
-        metafunc.parametrize("enum_frontend_asic_index",
-                             generate_param_asic_index(metafunc, duts_in_testbed, dut_indices, ASIC_PARAM_TYPE_FRONTEND))
+        metafunc.parametrize("enum_frontend_asic_index",generate_param_asic_index(metafunc, dut_indices, ASIC_PARAM_TYPE_FRONTEND))
 
     if "enum_dut_portname" in metafunc.fixturenames:
         metafunc.parametrize("enum_dut_portname", generate_port_lists(metafunc, "all_ports"))