def test_fans(self, duthosts, enum_rand_one_per_hwsku_hostname, localhost, platform_api_conn): ''' PSU fan test ''' for psu_id in range(self.num_psus): try: num_fans = int(psu.get_num_fans(platform_api_conn, psu_id)) except: pytest.fail("num_fans is not an integer!") fan_list = psu.get_all_fans(platform_api_conn, psu_id) if self.expect(fan_list is not None, "Failed to retrieve fans of PSU {}".format(psu_id)): self.expect( isinstance(fan_list, list) and len(fan_list) == num_fans, "Fans of PSU {} appear to be incorrect".format(psu_id)) for i in range(num_fans): fan = psu.get_fan(platform_api_conn, psu_id, i) if self.expect( fan is not None, "Failed to retrieve fan {} of PSU {}".format( i, psu_id)): self.expect( fan and fan == fan_list[i], "Fan {} of PSU {} is incorrect".format(i, psu_id)) self.assert_expectations()
def test_get_speed(self, duthosts, enum_rand_one_per_hwsku_hostname, localhost, platform_api_conn): duthost = duthosts[enum_rand_one_per_hwsku_hostname] for j in range(self.num_psus): num_fans = psu.get_num_fans(platform_api_conn, j) for i in range(num_fans): # Ensure the fan speed is sane speed_controllable = self.get_fan_facts( duthost, j, i, True, "speed", "controllable") if not speed_controllable: logger.info( "test_get_speed: Skipping PSU {} fan {} (speed not controllable)" .format(j, i)) continue speed = psu_fan.get_speed(platform_api_conn, j, i) if self.expect( speed is not None, "Unable to retrieve psu {} fan {} speed".format(j, i)): if self.expect( isinstance(speed, int), "psu {} fan {} speed appears incorrect".format( j, i)): self.expect( speed > 0 and speed <= 100, "psu {} fan {} speed {} reading is not within range" .format(j, i, speed)) self.assert_expectations()
def test_get_fans_speed_tolerance(self, duthosts, enum_rand_one_per_hwsku_hostname, localhost, platform_api_conn): duthost = duthosts[enum_rand_one_per_hwsku_hostname] for j in range(self.num_psus): num_fans = psu.get_num_fans(platform_api_conn, j) for i in range(num_fans): speed_controllable = self.get_fan_facts( duthost, j, i, True, "speed", "controllable") if not speed_controllable: logger.info( "test_get_fans_speed_tolerance: Skipping PSU {} fan {} (speed not controllable)" .format(j, i)) continue speed_tolerance = psu_fan.get_speed_tolerance( platform_api_conn, j, i) if self.expect( speed_tolerance is not None, "Unable to retrieve psu {} fan {} speed tolerance". format(j, i)): if self.expect( isinstance(speed_tolerance, int), "psu {} fan {} speed tolerance appears incorrect". format(j, i)): self.expect( speed_tolerance > 0 and speed_tolerance <= 100, "psu {} fan {} speed tolerance {} reading does not make sense" .format(j, i, speed_tolerance)) self.assert_expectations()
def test_get_fans_target_speed(self, duthosts, enum_rand_one_per_hwsku_hostname, localhost, platform_api_conn): for j in range(self.num_psus): num_fans = psu.get_num_fans(platform_api_conn, j) for i in range(num_fans): speed_target_val = 25 speed_set = psu_fan.set_speed(platform_api_conn, j, i, speed_target_val) target_speed = psu_fan.get_target_speed( platform_api_conn, j, i) if self.expect( target_speed is not None, "Unable to retrieve psu {} fan {} target speed".format( j, i)): if self.expect( isinstance(target_speed, int), "psu {} fan {} target speed appears incorrect". format(j, i)): self.expect( target_speed == speed_target_val, "psu {} fan {} target speed setting is not correct, speed_target_val {} target_speed = {}" .format(j, i, speed_target_val, target_speed)) self.assert_expectations()
def test_set_fans_led(self, duthosts, enum_rand_one_per_hwsku_hostname, localhost, platform_api_conn): LED_COLOR_LIST = [ "off", "red", "amber", "green", ] duthost = duthosts[enum_rand_one_per_hwsku_hostname] psus_skipped = 0 for j in range(self.num_psus): num_fans = psu.get_num_fans(platform_api_conn, j) fans_skipped = 0 for i in range(num_fans): led_controllable = self.get_fan_facts(duthost, j, i, True, "status_led", "controllable") if not led_controllable: logger.info( "test_set_fans_led: Skipping PSU {} fan {} (LED not controllable)" .format(j, i)) fans_skipped += 1 continue LED_COLOR_LIST = self.get_fan_facts(duthost, j, i, LED_COLOR_LIST, "status_led", "colors") for color in LED_COLOR_LIST: result = psu_fan.set_status_led(platform_api_conn, j, i, color) if self.expect(result is not None, "Failed to perform set_status_led"): self.expect( result is True, "Failed to set status_led for psu {} fan {} to {}". format(j, i, color)) color_actual = psu_fan.get_status_led( platform_api_conn, j, i) if self.expect(color_actual is not None, "Failed to retrieve status_led"): if self.expect(isinstance(color_actual, STRING_TYPE), "Status LED color appears incorrect"): self.expect( color == color_actual, "Status LED color incorrect (expected: {}, actual: {} for fan {})" .format(color, color_actual, i)) if num_fans != 0 and fans_skipped == num_fans: psus_skipped += 1 if psus_skipped == self.num_psus: pytest.skip("skipped as all PSU fans' LED is not controllable") self.assert_expectations()
def test_get_fans_target_speed(self, duthosts, enum_rand_one_per_hwsku_hostname, localhost, platform_api_conn): duthost = duthosts[enum_rand_one_per_hwsku_hostname] psus_skipped = 0 for j in range(self.num_psus): num_fans = psu.get_num_fans(platform_api_conn, j) fans_skipped = 0 for i in range(num_fans): speed_target_val = 25 speed_controllable = self.get_fan_facts( duthost, j, i, True, "speed", "controllable") if not speed_controllable: logger.info( "test_get_fans_target_speed: Skipping PSU {} fan {} (speed not controllable)" .format(j, i)) fans_skipped += 1 continue speed_minimum = self.get_fan_facts(duthost, j, i, 25, "speed", "minimum") speed_maximum = self.get_fan_facts(duthost, j, i, 100, "speed", "maximum") if speed_minimum > speed_target_val or speed_maximum < speed_target_val: speed_target_val = random.randint(speed_minimum, speed_maximum) speed_set = psu_fan.set_speed(platform_api_conn, j, i, speed_target_val) target_speed = psu_fan.get_target_speed( platform_api_conn, j, i) if self.expect( target_speed is not None, "Unable to retrieve psu {} fan {} target speed".format( j, i)): if self.expect( isinstance(target_speed, int), "psu {} fan {} target speed appears incorrect". format(j, i)): self.expect( target_speed == speed_target_val, "psu {} fan {} target speed setting is not correct, speed_target_val {} target_speed = {}" .format(j, i, speed_target_val, target_speed)) if num_fans != 0 and fans_skipped == num_fans: psus_skipped += 1 if psus_skipped == self.num_psus: pytest.skip("skipped as all PSU fans' speed is not controllable") self.assert_expectations()
def test_set_fans_speed(self, duthosts, enum_rand_one_per_hwsku_hostname, localhost, platform_api_conn): duthost = duthosts[enum_rand_one_per_hwsku_hostname] psus_skipped = 0 for j in range(self.num_psus): target_speed = random.randint(1, 100) num_fans = psu.get_num_fans(platform_api_conn, j) fans_skipped = 0 for i in range(num_fans): speed_controllable = self.get_fan_facts( duthost, j, i, True, "speed", "controllable") if not speed_controllable: logger.info( "test_set_fans_speed: Skipping PSU {} fan {} (speed not controllable)" .format(j, i)) fans_skipped += 1 continue speed_minimum = self.get_fan_facts(duthost, j, i, 1, "speed", "minimum") speed_maximum = self.get_fan_facts(duthost, j, i, 100, "speed", "maximum") if speed_minimum > target_speed or speed_maximum < target_speed: target_speed = random.randint(speed_minimum, speed_maximum) speed = psu_fan.get_speed(platform_api_conn, j, i) speed_tol = psu_fan.get_speed_tolerance( platform_api_conn, j, i) speed_set = psu_fan.set_speed(platform_api_conn, j, i, target_speed) time.sleep(5) act_speed = psu_fan.get_speed(platform_api_conn, j, i) self.expect( abs(act_speed - target_speed) <= speed_tol, "psu {} fan {} speed change from {} to {} is not within tolerance, actual speed {}" .format(j, i, speed, target_speed, act_speed)) if num_fans != 0 and fans_skipped == num_fans: psus_skipped += 1 if psus_skipped == self.num_psus: pytest.skip("skipped as all PSU fans' speed is not controllable") self.assert_expectations()
def test_get_position_in_parent(self, platform_api_conn): for j in range(self.num_psus): num_fans = psu.get_num_fans(platform_api_conn, j) for i in range(num_fans): position = psu_fan.get_position_in_parent( platform_api_conn, j, i) if self.expect( position is not None, "Failed to perform get_position_in_parent for PSU {} fan {}" .format(j, i)): self.expect( isinstance(position, int), "Position value must be an integer value for PSU {} fan {}" .format(j, i)) self.assert_expectations()
def test_is_replaceable(self, platform_api_conn): for j in range(self.num_psus): num_fans = psu.get_num_fans(platform_api_conn, j) for i in range(num_fans): replaceable = psu_fan.is_replaceable(platform_api_conn, j, i) if self.expect( replaceable is not None, "Failed to perform is_replaceable for PSU {} fan {}". format(j, i)): self.expect( isinstance(replaceable, bool), "Replaceable value must be a bool value for PSU {} fan {}" .format(j, i)) self.assert_expectations()
def test_get_name(self, duthosts, enum_rand_one_per_hwsku_hostname, localhost, platform_api_conn): duthost = duthosts[enum_rand_one_per_hwsku_hostname] for j in range(self.num_psus): num_fans = psu.get_num_fans(platform_api_conn, j) for i in range(num_fans): name = psu_fan.get_name(platform_api_conn, j, i) if self.expect( name is not None, "Unable to retrieve psu {} fan {} name".format(j, i)): self.expect( isinstance(name, STRING_TYPE), "psu {} fan {} name appears incorrect".format(j, i)) self.expect( duthost._facts.get("platform") is not None, "Unable to retrieve platform name") # # Check whether platform.json file exists for this specific platform. If yes compare names. # If not, skip comparison. # platform_file_path = os.path.join( "/usr/share/sonic/device", duthost._facts.get("platform"), "platform.json") platform_file_check = {} try: # # Check if the JSON file exists in the specific path. Return 0 if it DOES exist. # The command function throws exception if rc is non-zero, so handle it. # platform_file_check = duthost.command( "[ -f {} ]".format(platform_file_path)) except: # The JSON file does not exist, so set rc to 1. platform_file_check['rc'] = 1 if platform_file_check.get('rc') == 0: logging.info( "{} has a platform.json file. Running comparison with platform facts." .format(duthost._facts.get("platform"))) self.compare_value_with_platform_facts( duthost, 'name', name, j, i) else: logging.info( "{} does not have a platform.json file. Skipping comparison with platform facts." .format(duthost._facts.get("platform"))) self.assert_expectations()
def test_get_model(self, duthost, localhost, platform_api_conn): for j in range(self.num_psus): num_fans = psu.get_num_fans(platform_api_conn, j) for i in range(num_fans): model = psu_fan.get_model(platform_api_conn, j, i) if self.expect( model is not None, "Unable to retrieve psu {} fan {} model".format(j, i)): self.expect( isinstance(model, STRING_TYPE), "psu {} fan {} model appears incorrect".format(j, i)) self.assert_expectations()
def test_get_status(self, duthost, localhost, platform_api_conn): for j in range(self.num_psus): num_fans = psu.get_num_fans(platform_api_conn, j) for i in range(num_fans): status = psu_fan.get_status(platform_api_conn, j, i) if self.expect( status is not None, "Unable to retrieve psu {} fan {} status".format(j, i)): self.expect( isinstance(status, bool), "psu {} fan {} status appears incorrect".format(j, i)) self.assert_expectations()
def test_get_name(self, duthost, localhost, platform_api_conn): for j in range(self.num_psus): num_fans = psu.get_num_fans(platform_api_conn, j) for i in range(num_fans): name = psu_fan.get_name(platform_api_conn, j, i) if self.expect( name is not None, "Unable to retrieve psu {} fan {} name".format(j, i)): self.expect( isinstance(name, STRING_TYPE), "psu {} fan {} name appears incorrect".format(j, i)) self.compare_value_with_platform_facts('name', name, j, i) self.assert_expectations()
def test_get_serial(self, duthosts, enum_rand_one_per_hwsku_hostname, localhost, platform_api_conn): for j in range(self.num_psus): num_fans = psu.get_num_fans(platform_api_conn, j) for i in range(num_fans): serial = psu_fan.get_serial(platform_api_conn, j, i) if self.expect( serial is not None, "Unable to retrieve psu {} fan {} serial number". format(j, i)): self.expect( isinstance(serial, STRING_TYPE), "psu {} fan {}serial number appears incorrect".format( j, i)) self.assert_expectations()
def test_get_speed(self, duthost, localhost, platform_api_conn): for j in range(self.num_psus): num_fans = psu.get_num_fans(platform_api_conn, j) for i in range(num_fans): # Ensure the fan speed is sane speed = psu_fan.get_speed(platform_api_conn, j, i) if self.expect( speed is not None, "Unable to retrieve psu {} fan {} speed".format(j, i)): if self.expect( isinstance(speed, int), "psu {} fan {} speed appears incorrect".format( j, i)): self.expect( speed > 0 and speed <= 100, "psu {} fan {} speed {} reading is not within range" .format(j, i, speed)) self.assert_expectations()
def test_get_presence(self, duthost, localhost, platform_api_conn): for j in range(self.num_psus): num_fans = psu.get_num_fans(platform_api_conn, j) for i in range(num_fans): name = psu_fan.get_name(platform_api_conn, j, i) presence = psu_fan.get_presence(platform_api_conn, j, i) if self.expect( presence is not None, "Unable to retrieve psu {} fan {} presence".format( j, i)): if self.expect( isinstance(presence, bool), "psu {} fan {} presence appears incorrect".format( j, i)): self.expect(presence is True, "Fan {} is not present".format(j, i)) self.assert_expectations()
def test_set_fans_led(self, duthosts, enum_rand_one_per_hwsku_hostname, localhost, platform_api_conn): LED_COLOR_LIST = [ "off", "red", "amber", "green", ] for j in range(self.num_psus): num_fans = psu.get_num_fans(platform_api_conn, j) for i in range(num_fans): for color in LED_COLOR_LIST: result = psu_fan.set_status_led(platform_api_conn, j, i, color) if self.expect(result is not None, "Failed to perform set_status_led"): self.expect( result is True, "Failed to set status_led for psu {} fan {} to {}". format(j, i, color)) color_actual = psu_fan.get_status_led( platform_api_conn, j, i) if self.expect(color_actual is not None, "Failed to retrieve status_led"): if self.expect(isinstance(color_actual, STRING_TYPE), "Status LED color appears incorrect"): self.expect( color == color_actual, "Status LED color incorrect (expected: {}, actual: {} for fan {})" .format(color, color_actual, i)) self.assert_expectations()
def test_get_direction(self, duthost, localhost, platform_api_conn): # Ensure the fan speed is sane FAN_DIRECTION_LIST = [ "intake", "exhaust", "N/A", ] for j in range(self.num_psus): num_fans = psu.get_num_fans(platform_api_conn, j) for i in range(num_fans): direction = psu_fan.get_direction(platform_api_conn, j, i) if self.expect( direction is not None, "Unable to retrieve psu {} fan {} direction".format( j, i)): self.expect( direction in FAN_DIRECTION_LIST, "psu {} fan {} direction is not one of predefined directions" .format(j, i)) self.assert_expectations()
def test_set_fans_speed(self, duthost, localhost, platform_api_conn): for j in range(self.num_psus): num_fans = psu.get_num_fans(platform_api_conn, j) target_speed = random.randint(1, 100) for i in range(num_fans): speed = psu_fan.get_speed(platform_api_conn, j, i) speed_tol = psu_fan.get_speed_tolerance( platform_api_conn, j, i) speed_set = psu_fan.set_speed(platform_api_conn, j, i, target_speed) time.sleep(5) act_speed = psu_fan.get_speed(platform_api_conn, j, i) self.expect( abs(act_speed - target_speed) <= speed_tol, "psu {} fan {} speed change from {} to {} is not within tolerance, actual speed {}" .format(j, i, speed, target_speed, act_speed)) self.assert_expectations()
def test_get_fans_speed_tolerance(self, duthost, localhost, platform_api_conn): for j in range(self.num_psus): num_fans = psu.get_num_fans(platform_api_conn, j) for i in range(num_fans): speed_tolerance = psu_fan.get_speed_tolerance( platform_api_conn, j, i) if self.expect( speed_tolerance is not None, "Unable to retrieve psu {} fan {} speed tolerance". format(j, i)): if self.expect( isinstance(speed_tolerance, int), "psu {} fan {} speed tolerance appears incorrect". format(j, i)): self.expect( speed_tolerance > 0 and speed_tolerance <= 100, "psu {} fan {} speed tolerance {} reading does not make sense" .format(j, i, speed_tolerance)) self.assert_expectations()