Use snapshot_platform helper in advantage_air climate tests (#181815)

This commit is contained in:
epenet
2026-09-10 08:47:10 +02:00
committed by GitHub
parent b171bb8c80
commit 83d4514233
2 changed files with 878 additions and 162 deletions
@@ -1,24 +1,65 @@
# serializer version: 1
# name: test_climate_myauto_main[climate.myauto-fanmode]
dict({
'ac3': dict({
'info': dict({
'fan': 'autoAA',
}),
# name: test_all_entities[climate.myauto-entry]
EntityRegistryEntrySnapshot({
'aliases': list([
None,
]),
'area_id': None,
'capabilities': dict({
<ClimateEntityCapabilityAttribute.FAN_MODES: 'fan_modes'>: list([
'low',
'medium',
'high',
'auto',
]),
<ClimateEntityCapabilityAttribute.HVAC_MODES: 'hvac_modes'>: list([
<HVACMode.OFF: 'off'>,
<HVACMode.COOL: 'cool'>,
<HVACMode.HEAT: 'heat'>,
<HVACMode.FAN_ONLY: 'fan_only'>,
<HVACMode.DRY: 'dry'>,
<HVACMode.HEAT_COOL: 'heat_cool'>,
]),
<ClimateEntityCapabilityAttribute.MAX_TEMP: 'max_temp'>: 32,
<ClimateEntityCapabilityAttribute.MIN_TEMP: 'min_temp'>: 16,
<ClimateEntityCapabilityAttribute.PRESET_MODES: 'preset_modes'>: list([
'MyZone',
'MyTemp',
'MyAuto',
]),
<ClimateEntityCapabilityAttribute.TARGET_TEMP_STEP: 'target_temp_step'>: 1,
}),
'config_entry_id': <ANY>,
'config_subentry_id': <ANY>,
'device_class': None,
'device_id': <ANY>,
'disabled_by': None,
'domain': 'climate',
'entity_category': None,
'entity_id': 'climate.myauto',
'has_entity_name': True,
'hidden_by': None,
'icon': None,
'id': <ANY>,
'labels': set({
}),
'name': None,
'object_id_base': None,
'options': dict({
}),
'original_device_class': None,
'original_icon': None,
'original_name': None,
'platform': 'advantage_air',
'previous_unique_id': None,
'suggested_object_id': None,
'supported_features': <ClimateEntityFeature: 410>,
'translation_key': None,
'unique_id': 'uniqueid-ac3',
'unit_of_measurement': None,
})
# ---
# name: test_climate_myauto_main[climate.myauto-settemp]
dict({
'ac3': dict({
'info': dict({
'myAutoCoolTargetTemp': 23.0,
'myAutoHeatTargetTemp': 21.0,
}),
}),
})
# ---
# name: test_climate_myauto_main[climate.myauto]
# name: test_all_entities[climate.myauto-state]
StateSnapshot({
'attributes': ReadOnlyDict({
<ClimateEntityStateAttribute.CURRENT_TEMPERATURE: 'current_temperature'>: None,
@@ -60,7 +101,706 @@
'state': 'heat_cool',
})
# ---
# name: test_climate_myzone_main[climate.myzone-preset]
# name: test_all_entities[climate.mytemp-entry]
EntityRegistryEntrySnapshot({
'aliases': list([
None,
]),
'area_id': None,
'capabilities': dict({
<ClimateEntityCapabilityAttribute.FAN_MODES: 'fan_modes'>: list([
'low',
'medium',
'high',
'auto',
]),
<ClimateEntityCapabilityAttribute.HVAC_MODES: 'hvac_modes'>: list([
<HVACMode.OFF: 'off'>,
<HVACMode.COOL: 'cool'>,
<HVACMode.HEAT: 'heat'>,
<HVACMode.FAN_ONLY: 'fan_only'>,
<HVACMode.DRY: 'dry'>,
]),
<ClimateEntityCapabilityAttribute.MAX_TEMP: 'max_temp'>: 32,
<ClimateEntityCapabilityAttribute.MIN_TEMP: 'min_temp'>: 16,
<ClimateEntityCapabilityAttribute.PRESET_MODES: 'preset_modes'>: list([
'MyZone',
'MyTemp',
'MyAuto',
]),
<ClimateEntityCapabilityAttribute.TARGET_TEMP_STEP: 'target_temp_step'>: 1,
}),
'config_entry_id': <ANY>,
'config_subentry_id': <ANY>,
'device_class': None,
'device_id': <ANY>,
'disabled_by': None,
'domain': 'climate',
'entity_category': None,
'entity_id': 'climate.mytemp',
'has_entity_name': True,
'hidden_by': None,
'icon': None,
'id': <ANY>,
'labels': set({
}),
'name': None,
'object_id_base': None,
'options': dict({
}),
'original_device_class': None,
'original_icon': None,
'original_name': None,
'platform': 'advantage_air',
'previous_unique_id': None,
'suggested_object_id': None,
'supported_features': <ClimateEntityFeature: 408>,
'translation_key': None,
'unique_id': 'uniqueid-ac2',
'unit_of_measurement': None,
})
# ---
# name: test_all_entities[climate.mytemp-state]
StateSnapshot({
'attributes': ReadOnlyDict({
<ClimateEntityStateAttribute.CURRENT_TEMPERATURE: 'current_temperature'>: 25,
<ClimateEntityStateAttribute.FAN_MODE: 'fan_mode'>: 'auto',
<ClimateEntityCapabilityAttribute.FAN_MODES: 'fan_modes'>: list([
'low',
'medium',
'high',
'auto',
]),
<EntityStateAttribute.FRIENDLY_NAME: 'friendly_name'>: 'mytemp',
<ClimateEntityStateAttribute.HVAC_ACTION: 'hvac_action'>: <HVACAction.OFF: 'off'>,
<ClimateEntityCapabilityAttribute.HVAC_MODES: 'hvac_modes'>: list([
<HVACMode.OFF: 'off'>,
<HVACMode.COOL: 'cool'>,
<HVACMode.HEAT: 'heat'>,
<HVACMode.FAN_ONLY: 'fan_only'>,
<HVACMode.DRY: 'dry'>,
]),
<ClimateEntityCapabilityAttribute.MAX_TEMP: 'max_temp'>: 32,
<ClimateEntityCapabilityAttribute.MIN_TEMP: 'min_temp'>: 16,
<ClimateEntityStateAttribute.PRESET_MODE: 'preset_mode'>: 'MyTemp',
<ClimateEntityCapabilityAttribute.PRESET_MODES: 'preset_modes'>: list([
'MyZone',
'MyTemp',
'MyAuto',
]),
<EntityStateAttribute.SUPPORTED_FEATURES: 'supported_features'>: <ClimateEntityFeature: 408>,
<ClimateEntityCapabilityAttribute.TARGET_TEMP_STEP: 'target_temp_step'>: 1,
}),
'context': <ANY>,
'entity_id': 'climate.mytemp',
'last_changed': <ANY>,
'last_reported': <ANY>,
'last_updated': <ANY>,
'state': 'off',
})
# ---
# name: test_all_entities[climate.mytemp_zone_a-entry]
EntityRegistryEntrySnapshot({
'aliases': list([
None,
]),
'area_id': None,
'capabilities': dict({
<ClimateEntityCapabilityAttribute.HVAC_MODES: 'hvac_modes'>: list([
<HVACMode.OFF: 'off'>,
<HVACMode.HEAT_COOL: 'heat_cool'>,
]),
<ClimateEntityCapabilityAttribute.MAX_TEMP: 'max_temp'>: 32,
<ClimateEntityCapabilityAttribute.MIN_TEMP: 'min_temp'>: 16,
<ClimateEntityCapabilityAttribute.TARGET_TEMP_STEP: 'target_temp_step'>: 1,
}),
'config_entry_id': <ANY>,
'config_subentry_id': <ANY>,
'device_class': None,
'device_id': <ANY>,
'disabled_by': None,
'domain': 'climate',
'entity_category': None,
'entity_id': 'climate.mytemp_zone_a',
'has_entity_name': True,
'hidden_by': None,
'icon': None,
'id': <ANY>,
'labels': set({
}),
'name': None,
'object_id_base': 'Zone A',
'options': dict({
}),
'original_device_class': None,
'original_icon': None,
'original_name': 'Zone A',
'platform': 'advantage_air',
'previous_unique_id': None,
'suggested_object_id': None,
'supported_features': <ClimateEntityFeature: 385>,
'translation_key': None,
'unique_id': 'uniqueid-ac2-z01',
'unit_of_measurement': None,
})
# ---
# name: test_all_entities[climate.mytemp_zone_a-state]
StateSnapshot({
'attributes': ReadOnlyDict({
<ClimateEntityStateAttribute.CURRENT_TEMPERATURE: 'current_temperature'>: 25,
<EntityStateAttribute.FRIENDLY_NAME: 'friendly_name'>: 'mytemp Zone A',
<ClimateEntityStateAttribute.HVAC_ACTION: 'hvac_action'>: <HVACAction.OFF: 'off'>,
<ClimateEntityCapabilityAttribute.HVAC_MODES: 'hvac_modes'>: list([
<HVACMode.OFF: 'off'>,
<HVACMode.HEAT_COOL: 'heat_cool'>,
]),
<ClimateEntityCapabilityAttribute.MAX_TEMP: 'max_temp'>: 32,
<ClimateEntityCapabilityAttribute.MIN_TEMP: 'min_temp'>: 16,
<EntityStateAttribute.SUPPORTED_FEATURES: 'supported_features'>: <ClimateEntityFeature: 385>,
<ClimateEntityCapabilityAttribute.TARGET_TEMP_STEP: 'target_temp_step'>: 1,
<ClimateEntityStateAttribute.TARGET_TEMPERATURE: 'temperature'>: 24,
}),
'context': <ANY>,
'entity_id': 'climate.mytemp_zone_a',
'last_changed': <ANY>,
'last_reported': <ANY>,
'last_updated': <ANY>,
'state': 'heat_cool',
})
# ---
# name: test_all_entities[climate.mytemp_zone_b-entry]
EntityRegistryEntrySnapshot({
'aliases': list([
None,
]),
'area_id': None,
'capabilities': dict({
<ClimateEntityCapabilityAttribute.HVAC_MODES: 'hvac_modes'>: list([
<HVACMode.OFF: 'off'>,
<HVACMode.HEAT_COOL: 'heat_cool'>,
]),
<ClimateEntityCapabilityAttribute.MAX_TEMP: 'max_temp'>: 32,
<ClimateEntityCapabilityAttribute.MIN_TEMP: 'min_temp'>: 16,
<ClimateEntityCapabilityAttribute.TARGET_TEMP_STEP: 'target_temp_step'>: 1,
}),
'config_entry_id': <ANY>,
'config_subentry_id': <ANY>,
'device_class': None,
'device_id': <ANY>,
'disabled_by': None,
'domain': 'climate',
'entity_category': None,
'entity_id': 'climate.mytemp_zone_b',
'has_entity_name': True,
'hidden_by': None,
'icon': None,
'id': <ANY>,
'labels': set({
}),
'name': None,
'object_id_base': 'Zone B',
'options': dict({
}),
'original_device_class': None,
'original_icon': None,
'original_name': 'Zone B',
'platform': 'advantage_air',
'previous_unique_id': None,
'suggested_object_id': None,
'supported_features': <ClimateEntityFeature: 385>,
'translation_key': None,
'unique_id': 'uniqueid-ac2-z02',
'unit_of_measurement': None,
})
# ---
# name: test_all_entities[climate.mytemp_zone_b-state]
StateSnapshot({
'attributes': ReadOnlyDict({
<ClimateEntityStateAttribute.CURRENT_TEMPERATURE: 'current_temperature'>: 26,
<EntityStateAttribute.FRIENDLY_NAME: 'friendly_name'>: 'mytemp Zone B',
<ClimateEntityStateAttribute.HVAC_ACTION: 'hvac_action'>: <HVACAction.OFF: 'off'>,
<ClimateEntityCapabilityAttribute.HVAC_MODES: 'hvac_modes'>: list([
<HVACMode.OFF: 'off'>,
<HVACMode.HEAT_COOL: 'heat_cool'>,
]),
<ClimateEntityCapabilityAttribute.MAX_TEMP: 'max_temp'>: 32,
<ClimateEntityCapabilityAttribute.MIN_TEMP: 'min_temp'>: 16,
<EntityStateAttribute.SUPPORTED_FEATURES: 'supported_features'>: <ClimateEntityFeature: 385>,
<ClimateEntityCapabilityAttribute.TARGET_TEMP_STEP: 'target_temp_step'>: 1,
<ClimateEntityStateAttribute.TARGET_TEMPERATURE: 'temperature'>: 23,
}),
'context': <ANY>,
'entity_id': 'climate.mytemp_zone_b',
'last_changed': <ANY>,
'last_reported': <ANY>,
'last_updated': <ANY>,
'state': 'heat_cool',
})
# ---
# name: test_all_entities[climate.myzone-entry]
EntityRegistryEntrySnapshot({
'aliases': list([
None,
]),
'area_id': None,
'capabilities': dict({
<ClimateEntityCapabilityAttribute.FAN_MODES: 'fan_modes'>: list([
'low',
'medium',
'high',
'auto',
]),
<ClimateEntityCapabilityAttribute.HVAC_MODES: 'hvac_modes'>: list([
<HVACMode.OFF: 'off'>,
<HVACMode.COOL: 'cool'>,
<HVACMode.HEAT: 'heat'>,
<HVACMode.FAN_ONLY: 'fan_only'>,
<HVACMode.DRY: 'dry'>,
]),
<ClimateEntityCapabilityAttribute.MAX_TEMP: 'max_temp'>: 32,
<ClimateEntityCapabilityAttribute.MIN_TEMP: 'min_temp'>: 16,
<ClimateEntityCapabilityAttribute.PRESET_MODES: 'preset_modes'>: list([
'MyZone',
'MyTemp',
'MyAuto',
]),
<ClimateEntityCapabilityAttribute.TARGET_TEMP_STEP: 'target_temp_step'>: 1,
}),
'config_entry_id': <ANY>,
'config_subentry_id': <ANY>,
'device_class': None,
'device_id': <ANY>,
'disabled_by': None,
'domain': 'climate',
'entity_category': None,
'entity_id': 'climate.myzone',
'has_entity_name': True,
'hidden_by': None,
'icon': None,
'id': <ANY>,
'labels': set({
}),
'name': None,
'object_id_base': None,
'options': dict({
}),
'original_device_class': None,
'original_icon': None,
'original_name': None,
'platform': 'advantage_air',
'previous_unique_id': None,
'suggested_object_id': None,
'supported_features': <ClimateEntityFeature: 409>,
'translation_key': None,
'unique_id': 'uniqueid-ac1',
'unit_of_measurement': None,
})
# ---
# name: test_all_entities[climate.myzone-state]
StateSnapshot({
'attributes': ReadOnlyDict({
<ClimateEntityStateAttribute.CURRENT_TEMPERATURE: 'current_temperature'>: 25,
<ClimateEntityStateAttribute.FAN_MODE: 'fan_mode'>: 'high',
<ClimateEntityCapabilityAttribute.FAN_MODES: 'fan_modes'>: list([
'low',
'medium',
'high',
'auto',
]),
<EntityStateAttribute.FRIENDLY_NAME: 'friendly_name'>: 'myzone',
<ClimateEntityStateAttribute.HVAC_ACTION: 'hvac_action'>: <HVACAction.FAN: 'fan'>,
<ClimateEntityCapabilityAttribute.HVAC_MODES: 'hvac_modes'>: list([
<HVACMode.OFF: 'off'>,
<HVACMode.COOL: 'cool'>,
<HVACMode.HEAT: 'heat'>,
<HVACMode.FAN_ONLY: 'fan_only'>,
<HVACMode.DRY: 'dry'>,
]),
<ClimateEntityCapabilityAttribute.MAX_TEMP: 'max_temp'>: 32,
<ClimateEntityCapabilityAttribute.MIN_TEMP: 'min_temp'>: 16,
<ClimateEntityStateAttribute.PRESET_MODE: 'preset_mode'>: 'MyZone',
<ClimateEntityCapabilityAttribute.PRESET_MODES: 'preset_modes'>: list([
'MyZone',
'MyTemp',
'MyAuto',
]),
<EntityStateAttribute.SUPPORTED_FEATURES: 'supported_features'>: <ClimateEntityFeature: 409>,
<ClimateEntityCapabilityAttribute.TARGET_TEMP_STEP: 'target_temp_step'>: 1,
<ClimateEntityStateAttribute.TARGET_TEMPERATURE: 'temperature'>: 24,
}),
'context': <ANY>,
'entity_id': 'climate.myzone',
'last_changed': <ANY>,
'last_reported': <ANY>,
'last_updated': <ANY>,
'state': 'fan_only',
})
# ---
# name: test_all_entities[climate.myzone_zone_3-entry]
EntityRegistryEntrySnapshot({
'aliases': list([
None,
]),
'area_id': None,
'capabilities': dict({
<ClimateEntityCapabilityAttribute.HVAC_MODES: 'hvac_modes'>: list([
<HVACMode.OFF: 'off'>,
<HVACMode.HEAT_COOL: 'heat_cool'>,
]),
<ClimateEntityCapabilityAttribute.MAX_TEMP: 'max_temp'>: 32,
<ClimateEntityCapabilityAttribute.MIN_TEMP: 'min_temp'>: 16,
<ClimateEntityCapabilityAttribute.TARGET_TEMP_STEP: 'target_temp_step'>: 1,
}),
'config_entry_id': <ANY>,
'config_subentry_id': <ANY>,
'device_class': None,
'device_id': <ANY>,
'disabled_by': None,
'domain': 'climate',
'entity_category': None,
'entity_id': 'climate.myzone_zone_3',
'has_entity_name': True,
'hidden_by': None,
'icon': None,
'id': <ANY>,
'labels': set({
}),
'name': None,
'object_id_base': 'Zone 3',
'options': dict({
}),
'original_device_class': None,
'original_icon': None,
'original_name': 'Zone 3',
'platform': 'advantage_air',
'previous_unique_id': None,
'suggested_object_id': None,
'supported_features': <ClimateEntityFeature: 385>,
'translation_key': None,
'unique_id': 'uniqueid-ac1-z03',
'unit_of_measurement': None,
})
# ---
# name: test_all_entities[climate.myzone_zone_3-state]
StateSnapshot({
'attributes': ReadOnlyDict({
<ClimateEntityStateAttribute.CURRENT_TEMPERATURE: 'current_temperature'>: 25,
<EntityStateAttribute.FRIENDLY_NAME: 'friendly_name'>: 'myzone Zone 3',
<ClimateEntityStateAttribute.HVAC_ACTION: 'hvac_action'>: <HVACAction.OFF: 'off'>,
<ClimateEntityCapabilityAttribute.HVAC_MODES: 'hvac_modes'>: list([
<HVACMode.OFF: 'off'>,
<HVACMode.HEAT_COOL: 'heat_cool'>,
]),
<ClimateEntityCapabilityAttribute.MAX_TEMP: 'max_temp'>: 32,
<ClimateEntityCapabilityAttribute.MIN_TEMP: 'min_temp'>: 16,
<EntityStateAttribute.SUPPORTED_FEATURES: 'supported_features'>: <ClimateEntityFeature: 385>,
<ClimateEntityCapabilityAttribute.TARGET_TEMP_STEP: 'target_temp_step'>: 1,
<ClimateEntityStateAttribute.TARGET_TEMPERATURE: 'temperature'>: 24,
}),
'context': <ANY>,
'entity_id': 'climate.myzone_zone_3',
'last_changed': <ANY>,
'last_reported': <ANY>,
'last_updated': <ANY>,
'state': 'off',
})
# ---
# name: test_all_entities[climate.myzone_zone_4-entry]
EntityRegistryEntrySnapshot({
'aliases': list([
None,
]),
'area_id': None,
'capabilities': dict({
<ClimateEntityCapabilityAttribute.HVAC_MODES: 'hvac_modes'>: list([
<HVACMode.OFF: 'off'>,
<HVACMode.HEAT_COOL: 'heat_cool'>,
]),
<ClimateEntityCapabilityAttribute.MAX_TEMP: 'max_temp'>: 32,
<ClimateEntityCapabilityAttribute.MIN_TEMP: 'min_temp'>: 16,
<ClimateEntityCapabilityAttribute.TARGET_TEMP_STEP: 'target_temp_step'>: 1,
}),
'config_entry_id': <ANY>,
'config_subentry_id': <ANY>,
'device_class': None,
'device_id': <ANY>,
'disabled_by': None,
'domain': 'climate',
'entity_category': None,
'entity_id': 'climate.myzone_zone_4',
'has_entity_name': True,
'hidden_by': None,
'icon': None,
'id': <ANY>,
'labels': set({
}),
'name': None,
'object_id_base': 'Zone 4',
'options': dict({
}),
'original_device_class': None,
'original_icon': None,
'original_name': 'Zone 4',
'platform': 'advantage_air',
'previous_unique_id': None,
'suggested_object_id': None,
'supported_features': <ClimateEntityFeature: 385>,
'translation_key': None,
'unique_id': 'uniqueid-ac1-z04',
'unit_of_measurement': None,
})
# ---
# name: test_all_entities[climate.myzone_zone_4-state]
StateSnapshot({
'attributes': ReadOnlyDict({
<ClimateEntityStateAttribute.CURRENT_TEMPERATURE: 'current_temperature'>: 25,
<EntityStateAttribute.FRIENDLY_NAME: 'friendly_name'>: 'myzone Zone 4',
<ClimateEntityStateAttribute.HVAC_ACTION: 'hvac_action'>: <HVACAction.OFF: 'off'>,
<ClimateEntityCapabilityAttribute.HVAC_MODES: 'hvac_modes'>: list([
<HVACMode.OFF: 'off'>,
<HVACMode.HEAT_COOL: 'heat_cool'>,
]),
<ClimateEntityCapabilityAttribute.MAX_TEMP: 'max_temp'>: 32,
<ClimateEntityCapabilityAttribute.MIN_TEMP: 'min_temp'>: 16,
<EntityStateAttribute.SUPPORTED_FEATURES: 'supported_features'>: <ClimateEntityFeature: 385>,
<ClimateEntityCapabilityAttribute.TARGET_TEMP_STEP: 'target_temp_step'>: 1,
<ClimateEntityStateAttribute.TARGET_TEMPERATURE: 'temperature'>: 24,
}),
'context': <ANY>,
'entity_id': 'climate.myzone_zone_4',
'last_changed': <ANY>,
'last_reported': <ANY>,
'last_updated': <ANY>,
'state': 'off',
})
# ---
# name: test_all_entities[climate.myzone_zone_5-entry]
EntityRegistryEntrySnapshot({
'aliases': list([
None,
]),
'area_id': None,
'capabilities': dict({
<ClimateEntityCapabilityAttribute.HVAC_MODES: 'hvac_modes'>: list([
<HVACMode.OFF: 'off'>,
<HVACMode.HEAT_COOL: 'heat_cool'>,
]),
<ClimateEntityCapabilityAttribute.MAX_TEMP: 'max_temp'>: 32,
<ClimateEntityCapabilityAttribute.MIN_TEMP: 'min_temp'>: 16,
<ClimateEntityCapabilityAttribute.TARGET_TEMP_STEP: 'target_temp_step'>: 1,
}),
'config_entry_id': <ANY>,
'config_subentry_id': <ANY>,
'device_class': None,
'device_id': <ANY>,
'disabled_by': None,
'domain': 'climate',
'entity_category': None,
'entity_id': 'climate.myzone_zone_5',
'has_entity_name': True,
'hidden_by': None,
'icon': None,
'id': <ANY>,
'labels': set({
}),
'name': None,
'object_id_base': 'Zone 5',
'options': dict({
}),
'original_device_class': None,
'original_icon': None,
'original_name': 'Zone 5',
'platform': 'advantage_air',
'previous_unique_id': None,
'suggested_object_id': None,
'supported_features': <ClimateEntityFeature: 385>,
'translation_key': None,
'unique_id': 'uniqueid-ac1-z05',
'unit_of_measurement': None,
})
# ---
# name: test_all_entities[climate.myzone_zone_5-state]
StateSnapshot({
'attributes': ReadOnlyDict({
<ClimateEntityStateAttribute.CURRENT_TEMPERATURE: 'current_temperature'>: 25,
<EntityStateAttribute.FRIENDLY_NAME: 'friendly_name'>: 'myzone Zone 5',
<ClimateEntityStateAttribute.HVAC_ACTION: 'hvac_action'>: <HVACAction.OFF: 'off'>,
<ClimateEntityCapabilityAttribute.HVAC_MODES: 'hvac_modes'>: list([
<HVACMode.OFF: 'off'>,
<HVACMode.HEAT_COOL: 'heat_cool'>,
]),
<ClimateEntityCapabilityAttribute.MAX_TEMP: 'max_temp'>: 32,
<ClimateEntityCapabilityAttribute.MIN_TEMP: 'min_temp'>: 16,
<EntityStateAttribute.SUPPORTED_FEATURES: 'supported_features'>: <ClimateEntityFeature: 385>,
<ClimateEntityCapabilityAttribute.TARGET_TEMP_STEP: 'target_temp_step'>: 1,
<ClimateEntityStateAttribute.TARGET_TEMPERATURE: 'temperature'>: 24,
}),
'context': <ANY>,
'entity_id': 'climate.myzone_zone_5',
'last_changed': <ANY>,
'last_reported': <ANY>,
'last_updated': <ANY>,
'state': 'off',
})
# ---
# name: test_all_entities[climate.myzone_zone_closed_with_sensor-entry]
EntityRegistryEntrySnapshot({
'aliases': list([
None,
]),
'area_id': None,
'capabilities': dict({
<ClimateEntityCapabilityAttribute.HVAC_MODES: 'hvac_modes'>: list([
<HVACMode.OFF: 'off'>,
<HVACMode.HEAT_COOL: 'heat_cool'>,
]),
<ClimateEntityCapabilityAttribute.MAX_TEMP: 'max_temp'>: 32,
<ClimateEntityCapabilityAttribute.MIN_TEMP: 'min_temp'>: 16,
<ClimateEntityCapabilityAttribute.TARGET_TEMP_STEP: 'target_temp_step'>: 1,
}),
'config_entry_id': <ANY>,
'config_subentry_id': <ANY>,
'device_class': None,
'device_id': <ANY>,
'disabled_by': None,
'domain': 'climate',
'entity_category': None,
'entity_id': 'climate.myzone_zone_closed_with_sensor',
'has_entity_name': True,
'hidden_by': None,
'icon': None,
'id': <ANY>,
'labels': set({
}),
'name': None,
'object_id_base': 'Zone closed with Sensor',
'options': dict({
}),
'original_device_class': None,
'original_icon': None,
'original_name': 'Zone closed with Sensor',
'platform': 'advantage_air',
'previous_unique_id': None,
'suggested_object_id': None,
'supported_features': <ClimateEntityFeature: 385>,
'translation_key': None,
'unique_id': 'uniqueid-ac1-z02',
'unit_of_measurement': None,
})
# ---
# name: test_all_entities[climate.myzone_zone_closed_with_sensor-state]
StateSnapshot({
'attributes': ReadOnlyDict({
<ClimateEntityStateAttribute.CURRENT_TEMPERATURE: 'current_temperature'>: 25,
<EntityStateAttribute.FRIENDLY_NAME: 'friendly_name'>: 'myzone Zone closed with Sensor',
<ClimateEntityStateAttribute.HVAC_ACTION: 'hvac_action'>: <HVACAction.OFF: 'off'>,
<ClimateEntityCapabilityAttribute.HVAC_MODES: 'hvac_modes'>: list([
<HVACMode.OFF: 'off'>,
<HVACMode.HEAT_COOL: 'heat_cool'>,
]),
<ClimateEntityCapabilityAttribute.MAX_TEMP: 'max_temp'>: 32,
<ClimateEntityCapabilityAttribute.MIN_TEMP: 'min_temp'>: 16,
<EntityStateAttribute.SUPPORTED_FEATURES: 'supported_features'>: <ClimateEntityFeature: 385>,
<ClimateEntityCapabilityAttribute.TARGET_TEMP_STEP: 'target_temp_step'>: 1,
<ClimateEntityStateAttribute.TARGET_TEMPERATURE: 'temperature'>: 24,
}),
'context': <ANY>,
'entity_id': 'climate.myzone_zone_closed_with_sensor',
'last_changed': <ANY>,
'last_reported': <ANY>,
'last_updated': <ANY>,
'state': 'off',
})
# ---
# name: test_all_entities[climate.myzone_zone_open_with_sensor-entry]
EntityRegistryEntrySnapshot({
'aliases': list([
None,
]),
'area_id': None,
'capabilities': dict({
<ClimateEntityCapabilityAttribute.HVAC_MODES: 'hvac_modes'>: list([
<HVACMode.OFF: 'off'>,
<HVACMode.HEAT_COOL: 'heat_cool'>,
]),
<ClimateEntityCapabilityAttribute.MAX_TEMP: 'max_temp'>: 32,
<ClimateEntityCapabilityAttribute.MIN_TEMP: 'min_temp'>: 16,
<ClimateEntityCapabilityAttribute.TARGET_TEMP_STEP: 'target_temp_step'>: 1,
}),
'config_entry_id': <ANY>,
'config_subentry_id': <ANY>,
'device_class': None,
'device_id': <ANY>,
'disabled_by': None,
'domain': 'climate',
'entity_category': None,
'entity_id': 'climate.myzone_zone_open_with_sensor',
'has_entity_name': True,
'hidden_by': None,
'icon': None,
'id': <ANY>,
'labels': set({
}),
'name': None,
'object_id_base': 'Zone open with Sensor',
'options': dict({
}),
'original_device_class': None,
'original_icon': None,
'original_name': 'Zone open with Sensor',
'platform': 'advantage_air',
'previous_unique_id': None,
'suggested_object_id': None,
'supported_features': <ClimateEntityFeature: 385>,
'translation_key': None,
'unique_id': 'uniqueid-ac1-z01',
'unit_of_measurement': None,
})
# ---
# name: test_all_entities[climate.myzone_zone_open_with_sensor-state]
StateSnapshot({
'attributes': ReadOnlyDict({
<ClimateEntityStateAttribute.CURRENT_TEMPERATURE: 'current_temperature'>: 25,
<EntityStateAttribute.FRIENDLY_NAME: 'friendly_name'>: 'myzone Zone open with Sensor',
<ClimateEntityStateAttribute.HVAC_ACTION: 'hvac_action'>: <HVACAction.FAN: 'fan'>,
<ClimateEntityCapabilityAttribute.HVAC_MODES: 'hvac_modes'>: list([
<HVACMode.OFF: 'off'>,
<HVACMode.HEAT_COOL: 'heat_cool'>,
]),
<ClimateEntityCapabilityAttribute.MAX_TEMP: 'max_temp'>: 32,
<ClimateEntityCapabilityAttribute.MIN_TEMP: 'min_temp'>: 16,
<EntityStateAttribute.SUPPORTED_FEATURES: 'supported_features'>: <ClimateEntityFeature: 385>,
<ClimateEntityCapabilityAttribute.TARGET_TEMP_STEP: 'target_temp_step'>: 1,
<ClimateEntityStateAttribute.TARGET_TEMPERATURE: 'temperature'>: 24,
}),
'context': <ANY>,
'entity_id': 'climate.myzone_zone_open_with_sensor',
'last_changed': <ANY>,
'last_reported': <ANY>,
'last_updated': <ANY>,
'state': 'heat_cool',
})
# ---
# name: test_myauto_set_fan_mode
dict({
'ac3': dict({
'info': dict({
'fan': 'autoAA',
}),
}),
})
# ---
# name: test_myauto_set_temperature_range
dict({
'ac3': dict({
'info': dict({
'myAutoCoolTargetTemp': 23.0,
'myAutoHeatTargetTemp': 21.0,
}),
}),
})
# ---
# name: test_set_preset_mode
dict({
'ac1': dict({
'info': dict({
+120 -144
View File
@@ -1,6 +1,7 @@
"""Test the Advantage Air Climate Platform."""
from unittest.mock import AsyncMock
from collections.abc import Generator
from unittest.mock import AsyncMock, patch
from advantage_air import ApiError
import pytest
@@ -8,11 +9,8 @@ from syrupy.assertion import SnapshotAssertion
from homeassistant.components.advantage_air.climate import ADVANTAGE_AIR_MYAUTO
from homeassistant.components.climate import (
ATTR_CURRENT_TEMPERATURE,
ATTR_FAN_MODE,
ATTR_HVAC_MODE,
ATTR_MAX_TEMP,
ATTR_MIN_TEMP,
ATTR_PRESET_MODE,
ATTR_TARGET_TEMP_HIGH,
ATTR_TARGET_TEMP_LOW,
@@ -27,229 +25,207 @@ from homeassistant.components.climate import (
SERVICE_TURN_ON,
HVACMode,
)
from homeassistant.const import ATTR_ENTITY_ID, ATTR_TEMPERATURE
from homeassistant.const import ATTR_ENTITY_ID, ATTR_TEMPERATURE, Platform
from homeassistant.core import HomeAssistant
from homeassistant.exceptions import HomeAssistantError, ServiceValidationError
from homeassistant.helpers import entity_registry as er
from . import add_mock_config
from tests.common import snapshot_platform
async def test_climate_myzone_main(
@pytest.fixture(autouse=True)
def override_platforms() -> Generator[None]:
"""Override PLATFORMS."""
with patch("homeassistant.components.advantage_air.PLATFORMS", [Platform.CLIMATE]):
yield
@pytest.mark.usefixtures("mock_get")
async def test_all_entities(
hass: HomeAssistant,
entity_registry: er.EntityRegistry,
mock_get: AsyncMock,
mock_update: AsyncMock,
snapshot: SnapshotAssertion,
) -> None:
"""Test climate platform main entity."""
"""Test all entities."""
config_entry = await add_mock_config(hass)
await snapshot_platform(hass, entity_registry, snapshot, config_entry.entry_id)
@pytest.mark.usefixtures("mock_get")
@pytest.mark.parametrize(
("entity_id", "hvac_mode"),
[
pytest.param("climate.myzone", HVACMode.COOL, id="main-cool"),
pytest.param("climate.myzone", HVACMode.FAN_ONLY, id="main-fan_only"),
pytest.param("climate.myzone", HVACMode.OFF, id="main-off"),
pytest.param(
"climate.myzone_zone_open_with_sensor",
HVACMode.HEAT_COOL,
id="zone-heat_cool",
),
pytest.param(
"climate.myzone_zone_open_with_sensor", HVACMode.OFF, id="zone-off"
),
],
)
async def test_set_hvac_mode(
hass: HomeAssistant,
mock_update: AsyncMock,
entity_id: str,
hvac_mode: HVACMode,
) -> None:
"""Test setting the HVAC mode."""
await add_mock_config(hass)
# Test MyZone main climate entity
entity_id = "climate.myzone"
state = hass.states.get(entity_id)
assert state
assert state.state == HVACMode.FAN_ONLY
assert state.attributes.get(ATTR_MIN_TEMP) == 16
assert state.attributes.get(ATTR_MAX_TEMP) == 32
assert state.attributes.get(ATTR_TEMPERATURE) == 24
assert state.attributes.get(ATTR_CURRENT_TEMPERATURE) == 25
entry = entity_registry.async_get(entity_id)
assert entry
assert entry.unique_id == "uniqueid-ac1"
# Test setting HVAC Mode
await hass.services.async_call(
CLIMATE_DOMAIN,
SERVICE_SET_HVAC_MODE,
{ATTR_ENTITY_ID: [entity_id], ATTR_HVAC_MODE: HVACMode.COOL},
{ATTR_ENTITY_ID: [entity_id], ATTR_HVAC_MODE: hvac_mode},
blocking=True,
)
mock_update.assert_called_once()
mock_update.reset_mock()
@pytest.mark.usefixtures("mock_get")
@pytest.mark.parametrize(
"entity_id", ["climate.myzone", "climate.myzone_zone_open_with_sensor"]
)
async def test_set_temperature(
hass: HomeAssistant,
mock_update: AsyncMock,
entity_id: str,
) -> None:
"""Test setting the target temperature."""
await add_mock_config(hass)
await hass.services.async_call(
CLIMATE_DOMAIN,
SERVICE_SET_HVAC_MODE,
{ATTR_ENTITY_ID: [entity_id], ATTR_HVAC_MODE: HVACMode.FAN_ONLY},
SERVICE_SET_TEMPERATURE,
{ATTR_ENTITY_ID: [entity_id], ATTR_TEMPERATURE: 25},
blocking=True,
)
mock_update.assert_called_once()
mock_update.reset_mock()
# Test Turning Off with HVAC Mode
@pytest.mark.usefixtures("mock_get")
@pytest.mark.parametrize("service", [SERVICE_TURN_ON, SERVICE_TURN_OFF])
async def test_turn_on_off(
hass: HomeAssistant,
mock_update: AsyncMock,
service: str,
) -> None:
"""Test turning the main entity on and off."""
await add_mock_config(hass)
await hass.services.async_call(
CLIMATE_DOMAIN,
SERVICE_SET_HVAC_MODE,
{ATTR_ENTITY_ID: [entity_id], ATTR_HVAC_MODE: HVACMode.OFF},
service,
{ATTR_ENTITY_ID: ["climate.myzone"]},
blocking=True,
)
mock_update.assert_called_once()
mock_update.reset_mock()
@pytest.mark.usefixtures("mock_get")
async def test_set_fan_mode(hass: HomeAssistant, mock_update: AsyncMock) -> None:
"""Test setting the fan mode."""
await add_mock_config(hass)
await hass.services.async_call(
CLIMATE_DOMAIN,
SERVICE_SET_FAN_MODE,
{ATTR_ENTITY_ID: [entity_id], ATTR_FAN_MODE: FAN_LOW},
{ATTR_ENTITY_ID: ["climate.myzone"], ATTR_FAN_MODE: FAN_LOW},
blocking=True,
)
mock_update.assert_called_once()
mock_update.reset_mock()
# Test changing Temperature
await hass.services.async_call(
CLIMATE_DOMAIN,
SERVICE_SET_TEMPERATURE,
{ATTR_ENTITY_ID: [entity_id], ATTR_TEMPERATURE: 25},
blocking=True,
)
mock_update.assert_called_once()
mock_update.reset_mock()
# Test Turning On
await hass.services.async_call(
CLIMATE_DOMAIN,
SERVICE_TURN_OFF,
{ATTR_ENTITY_ID: [entity_id]},
blocking=True,
)
mock_update.assert_called_once()
mock_update.reset_mock()
@pytest.mark.usefixtures("mock_get")
async def test_set_preset_mode(
hass: HomeAssistant, mock_update: AsyncMock, snapshot: SnapshotAssertion
) -> None:
"""Test setting the preset mode."""
# Test Turning Off
await hass.services.async_call(
CLIMATE_DOMAIN,
SERVICE_TURN_ON,
{ATTR_ENTITY_ID: [entity_id]},
blocking=True,
)
mock_update.assert_called_once()
mock_update.reset_mock()
await add_mock_config(hass)
# Change Preset
await hass.services.async_call(
CLIMATE_DOMAIN,
SERVICE_SET_PRESET_MODE,
{ATTR_ENTITY_ID: [entity_id], ATTR_PRESET_MODE: ADVANTAGE_AIR_MYAUTO},
{ATTR_ENTITY_ID: ["climate.myzone"], ATTR_PRESET_MODE: ADVANTAGE_AIR_MYAUTO},
blocking=True,
)
mock_update.assert_called_once()
assert mock_update.call_args[0][0] == snapshot(name=f"{entity_id}-preset")
mock_update.reset_mock()
assert mock_update.call_args[0][0] == snapshot
@pytest.mark.usefixtures("mock_get")
async def test_set_hvac_mode_unsupported(
hass: HomeAssistant, mock_update: AsyncMock
) -> None:
"""Test setting an HVAC mode the main entity does not support."""
await add_mock_config(hass)
# Test setting HEAT COOL when its not supported
with pytest.raises(ServiceValidationError):
await hass.services.async_call(
CLIMATE_DOMAIN,
SERVICE_SET_HVAC_MODE,
{ATTR_ENTITY_ID: [entity_id], ATTR_HVAC_MODE: HVACMode.HEAT_COOL},
{ATTR_ENTITY_ID: ["climate.myzone"], ATTR_HVAC_MODE: HVACMode.HEAT_COOL},
blocking=True,
)
async def test_climate_myzone_zone(
hass: HomeAssistant,
entity_registry: er.EntityRegistry,
mock_get: AsyncMock,
mock_update: AsyncMock,
@pytest.mark.usefixtures("mock_get")
async def test_myauto_set_temperature_range(
hass: HomeAssistant, mock_update: AsyncMock, snapshot: SnapshotAssertion
) -> None:
"""Test climate platform myzone zone entity."""
"""Test setting the target temperature range on a MyAuto entity."""
await add_mock_config(hass)
# Test Climate Zone Entity
entity_id = "climate.myzone_zone_open_with_sensor"
state = hass.states.get(entity_id)
assert state
assert state.attributes.get(ATTR_MIN_TEMP) == 16
assert state.attributes.get(ATTR_MAX_TEMP) == 32
assert state.attributes.get(ATTR_TEMPERATURE) == 24
assert state.attributes.get(ATTR_CURRENT_TEMPERATURE) == 25
entry = entity_registry.async_get(entity_id)
assert entry
assert entry.unique_id == "uniqueid-ac1-z01"
# Test Climate Zone On
await hass.services.async_call(
CLIMATE_DOMAIN,
SERVICE_SET_HVAC_MODE,
{ATTR_ENTITY_ID: [entity_id], ATTR_HVAC_MODE: HVACMode.HEAT_COOL},
blocking=True,
)
mock_update.assert_called_once()
mock_update.reset_mock()
# Test Climate Zone Off
await hass.services.async_call(
CLIMATE_DOMAIN,
SERVICE_SET_HVAC_MODE,
{ATTR_ENTITY_ID: [entity_id], ATTR_HVAC_MODE: HVACMode.OFF},
blocking=True,
)
mock_update.assert_called_once()
mock_update.reset_mock()
await hass.services.async_call(
CLIMATE_DOMAIN,
SERVICE_SET_TEMPERATURE,
{ATTR_ENTITY_ID: [entity_id], ATTR_TEMPERATURE: 25},
blocking=True,
)
mock_update.assert_called_once()
mock_update.reset_mock()
async def test_climate_myauto_main(
hass: HomeAssistant,
entity_registry: er.EntityRegistry,
mock_get: AsyncMock,
mock_update: AsyncMock,
snapshot: SnapshotAssertion,
) -> None:
"""Test climate platform zone entity."""
await add_mock_config(hass)
# Test MyAuto Climate Entity
entity_id = "climate.myauto"
assert hass.states.get(entity_id) == snapshot(name=entity_id)
entry = entity_registry.async_get(entity_id)
assert entry
assert entry.unique_id == "uniqueid-ac3"
await hass.services.async_call(
CLIMATE_DOMAIN,
SERVICE_SET_TEMPERATURE,
{
ATTR_ENTITY_ID: [entity_id],
ATTR_ENTITY_ID: ["climate.myauto"],
ATTR_TARGET_TEMP_LOW: 21,
ATTR_TARGET_TEMP_HIGH: 23,
},
blocking=True,
)
mock_update.assert_called_once()
assert mock_update.call_args[0][0] == snapshot(name=f"{entity_id}-settemp")
mock_update.reset_mock()
assert mock_update.call_args[0][0] == snapshot
@pytest.mark.usefixtures("mock_get")
async def test_myauto_set_fan_mode(
hass: HomeAssistant, mock_update: AsyncMock, snapshot: SnapshotAssertion
) -> None:
"""Test setting the fan mode on a MyAuto entity."""
await add_mock_config(hass)
# Test AutoFanMode
await hass.services.async_call(
CLIMATE_DOMAIN,
SERVICE_SET_FAN_MODE,
{ATTR_ENTITY_ID: [entity_id], ATTR_FAN_MODE: FAN_AUTO},
{ATTR_ENTITY_ID: ["climate.myauto"], ATTR_FAN_MODE: FAN_AUTO},
blocking=True,
)
mock_update.assert_called_once()
assert mock_update.call_args[0][0] == snapshot(name=f"{entity_id}-fanmode")
assert mock_update.call_args[0][0] == snapshot
@pytest.mark.usefixtures("mock_get")
async def test_climate_async_failed_update(
hass: HomeAssistant,
mock_get: AsyncMock,
mock_update: AsyncMock,
) -> None:
"""Test climate change failure."""