mclimate-payload-helper 1.2.19 → 1.2.21

package/src/encoders/FanCoilThermostatCommands.test.ts

@@ -0,0 +1,204 @@
+import { BaseCommand, CommandBuilder } from '@/encoders'
+import { CustomError } from '@/utils'
+
+describe('FanCoilThermostatCommands payload encoder', () => {
+	const commandBuilder = new CommandBuilder('fan_coil_thermostat')
+
+	test('SetTargetTemperatureStep encodes step *10', () => {
+		expect(commandBuilder.build('SetTargetTemperatureStep', { value: 0.5 })).toStrictEqual(
+			new BaseCommand('SetTargetTemperatureStep', 0x03, '05'),
+		)
+	})
+
+	test('SetKeysLock encodes lock value', () => {
+		expect(commandBuilder.build('SetKeysLock', { value: 3 })).toStrictEqual(new BaseCommand('SetKeysLock', 0x07, '03'))
+	})
+
+	test('SetTargetTemperature encodes temperature *10 as 2 bytes', () => {
+		expect(commandBuilder.build('SetTargetTemperature', { targetTemperature: 20 })).toStrictEqual(
+			new BaseCommand('SetTargetTemperature', 0x2e, '00C8'),
+		)
+	})
+
+	test('SetFctOperationalMode encodes mode', () => {
+		expect(commandBuilder.build('SetFctOperationalMode', { value: 2 })).toStrictEqual(
+			new BaseCommand('SetFctOperationalMode', 0x52, '02'),
+		)
+	})
+
+	test('SetValveOpenCloseTime encodes time', () => {
+		expect(commandBuilder.build('SetValveOpenCloseTime', { value: 15 })).toStrictEqual(
+			new BaseCommand('SetValveOpenCloseTime', 0x31, '0F'),
+		)
+	})
+
+	test('SetExtAutomaticTemperatureControl encodes toggle', () => {
+		expect(commandBuilder.build('SetExtAutomaticTemperatureControl', { value: 1 })).toStrictEqual(
+			new BaseCommand('SetExtAutomaticTemperatureControl', 0x35, '01'),
+		)
+	})
+
+	test('SetFanSpeed encodes speed', () => {
+		expect(commandBuilder.build('SetFanSpeed', { value: 4 })).toStrictEqual(new BaseCommand('SetFanSpeed', 0x44, '04'))
+	})
+
+	test('SetFanSpeedLimit encodes limit', () => {
+		expect(commandBuilder.build('SetFanSpeedLimit', { value: 2 })).toStrictEqual(
+			new BaseCommand('SetFanSpeedLimit', 0x46, '02'),
+		)
+	})
+
+	test('SetEcmVoltageRange encodes min/max *10', () => {
+		expect(commandBuilder.build('SetEcmVoltageRange', { min: 5, max: 8 })).toStrictEqual(
+			new BaseCommand('SetEcmVoltageRange', 0x48, '32', '50'),
+		)
+	})
+
+	test('SetEcmStartUpTime encodes start-up time', () => {
+		expect(commandBuilder.build('SetEcmStartUpTime', { value: 7 })).toStrictEqual(
+			new BaseCommand('SetEcmStartUpTime', 0x4a, '07'),
+		)
+	})
+
+	test('SetEcmRelay encodes relay toggle', () => {
+		expect(commandBuilder.build('SetEcmRelay', { value: 1 })).toStrictEqual(new BaseCommand('SetEcmRelay', 0x4c, '01'))
+	})
+
+	test('SetFrostProtection encodes protection toggle', () => {
+		expect(commandBuilder.build('SetFrostProtection', { value: 1 })).toStrictEqual(
+			new BaseCommand('SetFrostProtection', 0x4e, '01'),
+		)
+	})
+
+	test('SetFrostProtectionSettings encodes threshold and setpoint', () => {
+		expect(commandBuilder.build('SetFrostProtectionSettings', { threshold: 6, setpoint: 8 })).toStrictEqual(
+			new BaseCommand('SetFrostProtectionSettings', 0x50, '06', '08'),
+		)
+	})
+
+	test('SetAllowedOperationalModes encodes allowed modes', () => {
+		expect(commandBuilder.build('SetAllowedOperationalModes', { value: 1 })).toStrictEqual(
+			new BaseCommand('SetAllowedOperationalModes', 0x54, '01'),
+		)
+	})
+
+	test('SetCoolingSetpointNotOccupied encodes setpoint', () => {
+		expect(commandBuilder.build('SetCoolingSetpointNotOccupied', { value: 18 })).toStrictEqual(
+			new BaseCommand('SetCoolingSetpointNotOccupied', 0x56, '12'),
+		)
+	})
+
+	test('SetHeatingSetpointNotOccupied encodes setpoint', () => {
+		expect(commandBuilder.build('SetHeatingSetpointNotOccupied', { value: 19 })).toStrictEqual(
+			new BaseCommand('SetHeatingSetpointNotOccupied', 0x58, '13'),
+		)
+	})
+
+	test('SetTempSensorCompensation encodes compensation and absolute temperature *10', () => {
+		expect(commandBuilder.build('SetTempSensorCompensation', { compensation: 1, temperature: -1.5 })).toStrictEqual(
+			new BaseCommand('SetTempSensorCompensation', 0x5a, '01', '0F'),
+		)
+	})
+
+	test('SetFanSpeedNotOccupied encodes speed option', () => {
+		expect(commandBuilder.build('SetFanSpeedNotOccupied', { value: 2 })).toStrictEqual(
+			new BaseCommand('SetFanSpeedNotOccupied', 0x5c, '02'),
+		)
+	})
+
+	test('SetAutomaticChangeover encodes toggle', () => {
+		expect(commandBuilder.build('SetAutomaticChangeover', { value: 1 })).toStrictEqual(
+			new BaseCommand('SetAutomaticChangeover', 0x5e, '01'),
+		)
+	})
+
+	test('SetWiringDiagram encodes diagram value', () => {
+		expect(commandBuilder.build('SetWiringDiagram', { value: 3 })).toStrictEqual(
+			new BaseCommand('SetWiringDiagram', 0x60, '03'),
+		)
+	})
+
+	test('SetOccFunction encodes occupancy function', () => {
+		expect(commandBuilder.build('SetOccFunction', { value: 5 })).toStrictEqual(
+			new BaseCommand('SetOccFunction', 0x62, '05'),
+		)
+	})
+
+	test('SetAutomaticChangeoverThreshold encodes cooling/heating thresholds', () => {
+		expect(
+			commandBuilder.build('SetAutomaticChangeoverThreshold', { coolingThreshold: 10, heatingThreshold: 40 }),
+		).toStrictEqual(new BaseCommand('SetAutomaticChangeoverThreshold', 0x64, '0A', '28'))
+	})
+
+	test('SetDeviceStatus encodes on/off', () => {
+		expect(commandBuilder.build('SetDeviceStatus', { value: 1 })).toStrictEqual(
+			new BaseCommand('SetDeviceStatus', 0x66, '01'),
+		)
+	})
+
+	test('SetReturnOfPowerOperation encodes behavior', () => {
+		expect(commandBuilder.build('SetReturnOfPowerOperation', { value: 2 })).toStrictEqual(
+			new BaseCommand('SetReturnOfPowerOperation', 0x68, '02'),
+		)
+	})
+
+	test('SetDeltaTemperature1 encodes delta *10', () => {
+		expect(commandBuilder.build('SetDeltaTemperature1', { value: 1.5 })).toStrictEqual(
+			new BaseCommand('SetDeltaTemperature1', 0x6a, '0F'),
+		)
+	})
+
+	test('SetDeltaTemperature2and3 encodes both deltas *10', () => {
+		expect(
+			commandBuilder.build('SetDeltaTemperature2and3', { deltaTemperature2: 2, deltaTemperature3: 2.5 }),
+		).toStrictEqual(new BaseCommand('SetDeltaTemperature2and3', 0x6c, '14', '19'))
+	})
+
+	test('SetHeatingCoolingTargetTempRanges encodes min/max values', () => {
+		expect(
+			commandBuilder.build('SetHeatingCoolingTargetTempRanges', {
+				heatingTempMin: 10,
+				heatingTempMax: 20,
+				coolingTempMin: 15,
+				coolingTempMax: 25,
+			}),
+		).toStrictEqual(new BaseCommand('SetHeatingCoolingTargetTempRanges', 0x16, '0A', '14', '0F', '19'))
+	})
+
+	test('SetHeatingCoolingTargetTempRangesUnoccupied encodes min/max values', () => {
+		expect(
+			commandBuilder.build('SetHeatingCoolingTargetTempRangesUnoccupied', {
+				heatingTempMin: 11,
+				heatingTempMax: 21,
+				coolingTempMin: 16,
+				coolingTempMax: 22,
+			}),
+		).toStrictEqual(new BaseCommand('SetHeatingCoolingTargetTempRangesUnoccupied', 0x76, '0B', '15', '10', '16'))
+	})
+
+	test('SetFanOffDelayTime encodes delay time', () => {
+		expect(commandBuilder.build('SetFanOffDelayTime', { time: 30 })).toStrictEqual(
+			new BaseCommand('SetFanOffDelayTime', 0x78, '1E'),
+		)
+	})
+
+	test('SetAdditionalFanMode encodes mode', () => {
+		expect(commandBuilder.build('SetAdditionalFanMode', { mode: 2 })).toStrictEqual(
+			new BaseCommand('SetAdditionalFanMode', 0x7a, '02'),
+		)
+	})
+
+	test('SetUserInterfaceLanguage encodes language option', () => {
+		expect(commandBuilder.build('SetUserInterfaceLanguage', { value: 3 })).toStrictEqual(
+			new BaseCommand('SetUserInterfaceLanguage', 0x9a, '03'),
+		)
+	})
+
+	test('RestartDevice emits restart command', () => {
+		expect(commandBuilder.build('RestartDevice')).toStrictEqual(new BaseCommand('RestartDevice', 0xa5))
+	})
+
+	test('Invalid SetTargetTemperatureStep throws validation error', () => {
+		expect(() => commandBuilder.build('SetTargetTemperatureStep', { value: 0 })).toThrow(CustomError)
+	})
+})

package/src/encoders/GeneralCommands.test.ts

@@ -0,0 +1,38 @@
+import { BaseCommand, CommandBuilder } from '@/encoders'
+import { CustomError } from '@/utils'
+
+describe('GeneralCommands payload encoder', () => {
+	const commandBuilder = new CommandBuilder('vicki')
+
+	test('SendCustomHexCommand forwards raw hex', () => {
+		expect(commandBuilder.build('SendCustomHexCommand', { command: '0412' })).toStrictEqual(
+			new BaseCommand('SendCustomHexCommand', '0412'),
+		)
+	})
+
+	test('SetKeepAlive encodes keepalive time', () => {
+		expect(commandBuilder.build('SetKeepAlive', { time: 5 })).toStrictEqual(new BaseCommand('SetKeepAlive', 0x02, '05'))
+	})
+
+	test('SetJoinRetryPeriod scales minutes before encoding', () => {
+		expect(commandBuilder.build('SetJoinRetryPeriod', { period: 10 })).toStrictEqual(
+			new BaseCommand('SetJoinRetryPeriod', 0x10, '78'),
+		)
+	})
+
+	test('SetUplinkType passes uplink type', () => {
+		expect(commandBuilder.build('SetUplinkType', { type: '01' })).toStrictEqual(
+			new BaseCommand('SetUplinkType', 0x11, '01'),
+		)
+	})
+
+	test('SetWatchDogParams encodes confirmed/unconfirmed uplinks', () => {
+		expect(commandBuilder.build('SetWatchDogParams', { confirmedUplinks: 2, unconfirmedUplinks: 3 })).toStrictEqual(
+			new BaseCommand('SetWatchDogParams', 0x1c, '02', '03'),
+		)
+	})
+
+	test('Invalid SendCustomHexCommand params throw validation error', () => {
+		expect(() => commandBuilder.build('SendCustomHexCommand', { command: 'ZZZ' })).toThrow(CustomError)
+	})
+})

package/src/encoders/HTDisplayLiteCommands.test.ts

@@ -0,0 +1,28 @@
+import { BaseCommand, CommandBuilder } from '@/encoders'
+import { CustomError } from '@/utils'
+
+describe('HTDisplayLiteCommands payload encoder', () => {
+	const commandBuilder = new CommandBuilder('ht_display_lite')
+
+	test('SetDisplayRefreshPeriod encodes period', () => {
+		expect(commandBuilder.build('SetDisplayRefreshPeriod', { period: 4 })).toStrictEqual(
+			new BaseCommand('SetDisplayRefreshPeriod', 0x33, '04'),
+		)
+	})
+
+	test('SetHumidityVisibility encodes toggle', () => {
+		expect(commandBuilder.build('SetHumidityVisibility', { state: 1 })).toStrictEqual(
+			new BaseCommand('SetHumidityVisibility', 0x42, '01'),
+		)
+	})
+
+	test('SetCurrentTemperatureVisibility encodes toggle', () => {
+		expect(commandBuilder.build('SetCurrentTemperatureVisibility', { state: 0 })).toStrictEqual(
+			new BaseCommand('SetCurrentTemperatureVisibility', 0x40, '00'),
+		)
+	})
+
+	test('Invalid SetDisplayRefreshPeriod throws validation error', () => {
+		expect(() => commandBuilder.build('SetDisplayRefreshPeriod', { period: 0 })).toThrow(CustomError)
+	})
+})

package/src/encoders/HTPirLiteCommands.test.ts

@@ -0,0 +1,32 @@
+import { BaseCommand, CommandBuilder } from '@/encoders'
+import { CustomError } from '@/utils'
+
+describe('HTPirLiteCommands payload encoder', () => {
+	const commandBuilder = new CommandBuilder('ht_pir_lite')
+
+	test('SetPIRSensorState encodes enabled flag', () => {
+		expect(commandBuilder.build('SetPIRSensorState', { state: 1 })).toStrictEqual(
+			new BaseCommand('SetPIRSensorState', 0x36, '01'),
+		)
+	})
+
+	test('SetPIRSensorSensitivity encodes sensitivity value', () => {
+		expect(commandBuilder.build('SetPIRSensorSensitivity', { sensitivity: 64 })).toStrictEqual(
+			new BaseCommand('SetPIRSensorSensitivity', 0x3e, '40'),
+		)
+	})
+
+	test('SetOccupancyTimeout encodes timeout into two bytes', () => {
+		expect(commandBuilder.build('SetOccupancyTimeout', { timeout: 120 })).toStrictEqual(
+			new BaseCommand('SetOccupancyTimeout', 0x38, '0078'),
+		)
+	})
+
+	test('RestartDevice emits restart command', () => {
+		expect(commandBuilder.build('RestartDevice')).toStrictEqual(new BaseCommand('RestartDevice', 0xa5))
+	})
+
+	test('Invalid SetPIRSensorState throws validation error', () => {
+		expect(() => commandBuilder.build('SetPIRSensorState', { state: 2 })).toThrow(CustomError)
+	})
+})

package/src/encoders/HTSensorCommands.test.ts

@@ -0,0 +1,24 @@
+import { BaseCommand, CommandBuilder } from '@/encoders'
+import { CustomError } from '@/utils'
+
+describe('HTSensorCommands payload encoder', () => {
+	const commandBuilder = new CommandBuilder('ht_sensor')
+
+	test('SetTemperatureCompensation encodes sign flag and compensation *10', () => {
+		expect(
+			commandBuilder.build('SetTemperatureCompensation', { negativeCompensation: true, compensation: 0.3 }),
+		).toStrictEqual(new BaseCommand('SetTemperatureCompensation', 0x31, '01', '03'))
+	})
+
+	test('SetHumidityCompensation encodes sign flag and compensation', () => {
+		expect(
+			commandBuilder.build('SetHumidityCompensation', { negativeCompensation: false, compensation: 3 }),
+		).toStrictEqual(new BaseCommand('SetHumidityCompensation', 0x33, '00', '03'))
+	})
+
+	test('Invalid SetTemperatureCompensation throws validation error', () => {
+		expect(() =>
+			commandBuilder.build('SetTemperatureCompensation', { negativeCompensation: true, compensation: -1 }),
+		).toThrow(CustomError)
+	})
+})

package/src/encoders/MelissaCommands.test.ts

@@ -0,0 +1,16 @@
+import { BaseCommand, CommandBuilder } from '@/encoders'
+import { CustomError } from '@/utils'
+
+describe('MelissaCommands payload encoder', () => {
+	const commandBuilder = new CommandBuilder('melissa_lorawan')
+
+	test('SetIrCodeRecording encodes time and position', () => {
+		expect(commandBuilder.build('SetIrCodeRecording', { time: 10, position: 2 })).toStrictEqual(
+			new BaseCommand('SetIrCodeRecording', 0x09, '0A', '02'),
+		)
+	})
+
+	test('Invalid SetIrCodeRecording throws validation error', () => {
+		expect(() => commandBuilder.build('SetIrCodeRecording', { time: -1, position: 1 })).toThrow(CustomError)
+	})
+})

package/src/encoders/MultiSensorCommands.test.ts

@@ -0,0 +1,68 @@
+import { BaseCommand, CommandBuilder } from '@/encoders'
+import { CustomError } from '@/utils'
+
+describe('MultiSensorCommands payload encoder', () => {
+	const commandBuilder = new CommandBuilder('multisensor')
+
+	test('SetLightState encodes boolean to flag', () => {
+		expect(commandBuilder.build('SetLightState', { enabled: true })).toStrictEqual(
+			new BaseCommand('SetLightState', 0x1e, '01'),
+		)
+	})
+
+	test('SetHallState encodes boolean to flag', () => {
+		expect(commandBuilder.build('SetHallState', { enabled: false })).toStrictEqual(
+			new BaseCommand('SetHallState', 0x20, '00'),
+		)
+	})
+
+	test('SetHallBlindPeriod encodes period as 2 bytes', () => {
+		expect(commandBuilder.build('SetHallBlindPeriod', { period: 300 })).toStrictEqual(
+			new BaseCommand('SetHallBlindPeriod', 0x22, '012C'),
+		)
+	})
+
+	test('SetMicrophoneState encodes boolean to flag', () => {
+		expect(commandBuilder.build('SetMicrophoneState', { enabled: true })).toStrictEqual(
+			new BaseCommand('SetMicrophoneState', 0x24, '01'),
+		)
+	})
+
+	test('SetMicrophoneSamplingPeriod encodes period as 2 bytes', () => {
+		expect(commandBuilder.build('SetMicrophoneSamplingPeriod', { period: 120 })).toStrictEqual(
+			new BaseCommand('SetMicrophoneSamplingPeriod', 0x26, '0078'),
+		)
+	})
+
+	test('SetGasState encodes boolean to flag', () => {
+		expect(commandBuilder.build('SetGasState', { enabled: true })).toStrictEqual(
+			new BaseCommand('SetGasState', 0x28, '01'),
+		)
+	})
+
+	test('SetGasMeasurementPeriod encodes minutes', () => {
+		expect(commandBuilder.build('SetGasMeasurementPeriod', { minutes: 15 })).toStrictEqual(
+			new BaseCommand('SetGasMeasurementPeriod', 0x2a, '0F'),
+		)
+	})
+
+	test('SetPirState encodes boolean to flag', () => {
+		expect(commandBuilder.build('SetPirState', { enabled: true })).toStrictEqual(
+			new BaseCommand('SetPirState', 0x2c, '01'),
+		)
+	})
+
+	test('SetPirActiveReportingPeriod encodes time as 2 bytes', () => {
+		expect(commandBuilder.build('SetPirActiveReportingPeriod', { time: 45 })).toStrictEqual(
+			new BaseCommand('SetPirActiveReportingPeriod', 0x2e, '002D'),
+		)
+	})
+
+	test('Restart emits restart command', () => {
+		expect(commandBuilder.build('Restart')).toStrictEqual(new BaseCommand('Restart', 0xa5))
+	})
+
+	test('Invalid SetHallBlindPeriod throws validation error', () => {
+		expect(() => commandBuilder.build('SetHallBlindPeriod', { period: -1 })).toThrow(CustomError)
+	})
+})

package/src/encoders/OpenCloseSensorCommands.test.ts

@@ -0,0 +1,16 @@
+import { BaseCommand, CommandBuilder } from '@/encoders'
+import { CustomError } from '@/utils'
+
+describe('OpenCloseSensorCommands payload encoder', () => {
+	const commandBuilder = new CommandBuilder('open_close_sensor')
+
+	test('SetNotificationBlindTime encodes time', () => {
+		expect(commandBuilder.build('SetNotificationBlindTime', { time: 10 })).toStrictEqual(
+			new BaseCommand('SetNotificationBlindTime', 0x1e, '0A'),
+		)
+	})
+
+	test('Invalid SetNotificationBlindTime throws validation error', () => {
+		expect(() => commandBuilder.build('SetNotificationBlindTime', { time: -1 })).toThrow(CustomError)
+	})
+})

package/src/encoders/PIRCommands.test.ts

@@ -0,0 +1,46 @@
+import { BaseCommand, CommandBuilder } from '@/encoders'
+import { CustomError } from '@/utils'
+
+describe('PIRCommands payload encoder', () => {
+	const commandBuilder = new CommandBuilder('co2_display')
+
+	test('SetPIRSensorStatus encodes state', () => {
+		expect(commandBuilder.build('SetPIRSensorStatus', { state: 1 })).toStrictEqual(
+			new BaseCommand('SetPIRSensorStatus', 0x3c, '01'),
+		)
+	})
+
+	test('SetPIRSensorSensitivity encodes sensitivity', () => {
+		expect(commandBuilder.build('SetPIRSensorSensitivity', { sensitivity: 12 })).toStrictEqual(
+			new BaseCommand('SetPIRSensorSensitivity', 0x3e, '0C'),
+		)
+	})
+
+	test('SetPIRInitPeriod encodes time', () => {
+		expect(commandBuilder.build('SetPIRInitPeriod', { time: 5 })).toStrictEqual(
+			new BaseCommand('SetPIRInitPeriod', 0x46, '05'),
+		)
+	})
+
+	test('SetPIRMeasurementPeriod encodes time', () => {
+		expect(commandBuilder.build('SetPIRMeasurementPeriod', { time: 15 })).toStrictEqual(
+			new BaseCommand('SetPIRMeasurementPeriod', 0x48, '0F'),
+		)
+	})
+
+	test('SetPIRCheckPeriod encodes 2-byte time', () => {
+		expect(commandBuilder.build('SetPIRCheckPeriod', { time: 500 })).toStrictEqual(
+			new BaseCommand('SetPIRCheckPeriod', 0x4a, '01F4'),
+		)
+	})
+
+	test('SetPIRBlindPeriod encodes 2-byte time', () => {
+		expect(commandBuilder.build('SetPIRBlindPeriod', { time: 300 })).toStrictEqual(
+			new BaseCommand('SetPIRBlindPeriod', 0x4c, '012C'),
+		)
+	})
+
+	test('Invalid SetPIRSensorStatus throws validation error', () => {
+		expect(() => commandBuilder.build('SetPIRSensorStatus', { state: 2 })).toThrow(CustomError)
+	})
+})

package/src/encoders/Relay16Commands.test.ts

@@ -0,0 +1,76 @@
+import { BaseCommand, CommandBuilder } from '@/encoders'
+import { CustomError } from '@/utils'
+
+describe('Relay16Commands payload encoder', () => {
+	const commandBuilder = new CommandBuilder('relay_16')
+
+	test('SetOverheatingThresholds encodes trigger and recovery', () => {
+		expect(commandBuilder.build('SetOverheatingThresholds', { trigger: 45, recovery: 60 })).toStrictEqual(
+			new BaseCommand('SetOverheatingThresholds', 0x1e, '2D', '3C'),
+		)
+	})
+
+	test('SetOverheatingThresholds matches doc example values', () => {
+		expect(commandBuilder.build('SetOverheatingThresholds', { trigger: 90, recovery: 60 })).toStrictEqual(
+			new BaseCommand('SetOverheatingThresholds', 0x1e, '5A', '3C'),
+		)
+	})
+
+	test('SetOvervoltageThresholds encodes trigger and recovery', () => {
+		expect(commandBuilder.build('SetOvervoltageThresholds', { trigger: 230, recovery: 150 })).toStrictEqual(
+			new BaseCommand('SetOvervoltageThresholds', 0x20, '00E6', '96'),
+		)
+	})
+
+	test('SetOvercurrentThreshold encodes current value', () => {
+		expect(commandBuilder.build('SetOvercurrentThreshold', { current: 12 })).toStrictEqual(
+			new BaseCommand('SetOvercurrentThreshold', 0x22, '0C'),
+		)
+	})
+
+	test('SetOverpowerThreshold encodes power value', () => {
+		expect(commandBuilder.build('SetOverpowerThreshold', { power: 1500 })).toStrictEqual(
+			new BaseCommand('SetOverpowerThreshold', 0x24, '05DC'),
+		)
+	})
+
+	test('SetAfterOverheatingProtectionRecovery encodes state flag', () => {
+		expect(commandBuilder.build('SetAfterOverheatingProtectionRecovery', { state: 1 })).toStrictEqual(
+			new BaseCommand('SetAfterOverheatingProtectionRecovery', 0x59, '01'),
+		)
+	})
+
+	test('SetLedIndicationMode encodes mode flag', () => {
+		expect(commandBuilder.build('SetLedIndicationMode', { mode: 1 })).toStrictEqual(
+			new BaseCommand('SetLedIndicationMode', 0x5b, '01'),
+		)
+	})
+
+	test('SetRelayRecoveryState encodes relay recovery state', () => {
+		expect(commandBuilder.build('SetRelayRecoveryState', { state: 2 })).toStrictEqual(
+			new BaseCommand('SetRelayRecoveryState', 0x5e, '02'),
+		)
+	})
+
+	test('SetRelayState maps boolean to relay flag', () => {
+		expect(commandBuilder.build('SetRelayState', { state: false })).toStrictEqual(
+			new BaseCommand('SetRelayState', 0xc1, '00'),
+		)
+	})
+
+	test('SetRelayTimerInMilliseconds encodes state and time', () => {
+		expect(commandBuilder.build('SetRelayTimerInMilliseconds', { state: 1, time: 1200 })).toStrictEqual(
+			new BaseCommand('SetRelayTimerInMilliseconds', 0x55, '01', '04B0'),
+		)
+	})
+
+	test('SetRelayTimerInSeconds encodes state and time', () => {
+		expect(commandBuilder.build('SetRelayTimerInSeconds', { state: 0, time: 90 })).toStrictEqual(
+			new BaseCommand('SetRelayTimerInSeconds', 0x57, '00', '005A'),
+		)
+	})
+
+	test('Invalid parameter triggers validation error', () => {
+		expect(() => commandBuilder.build('SetOverpowerThreshold', { power: 4000 })).toThrow(CustomError)
+	})
+})

package/src/encoders/Relay16DryCommands.test.ts

@@ -0,0 +1,52 @@
+import { BaseCommand, CommandBuilder } from '@/encoders'
+import { CustomError } from '@/utils'
+
+describe('Relay16DryCommands payload encoder', () => {
+	const commandBuilder = new CommandBuilder('relay_16_dry')
+
+	test('SetRelayState maps boolean to relay flag', () => {
+		expect(commandBuilder.build('SetRelayState', { state: true })).toStrictEqual(
+			new BaseCommand('SetRelayState', 0xc1, '01'),
+		)
+	})
+
+	test('SetRelayTimerInMilliseconds encodes state and time', () => {
+		expect(commandBuilder.build('SetRelayTimerInMilliseconds', { state: 0, time: 500 })).toStrictEqual(
+			new BaseCommand('SetRelayTimerInMilliseconds', 0x55, '00', '01F4'),
+		)
+	})
+
+	test('SetRelayTimerInSeconds encodes state and time', () => {
+		expect(commandBuilder.build('SetRelayTimerInSeconds', { state: 1, time: 3 })).toStrictEqual(
+			new BaseCommand('SetRelayTimerInSeconds', 0x57, '01', '0003'),
+		)
+	})
+
+	test('SetOverheatingThresholds encodes trigger and recovery', () => {
+		expect(commandBuilder.build('SetOverheatingThresholds', { trigger: 40, recovery: 60 })).toStrictEqual(
+			new BaseCommand('SetOverheatingThresholds', 0x1e, '28', '3C'),
+		)
+	})
+
+	test('SetAfterOverheatingProtectionRecovery encodes state', () => {
+		expect(commandBuilder.build('SetAfterOverheatingProtectionRecovery', { state: 1 })).toStrictEqual(
+			new BaseCommand('SetAfterOverheatingProtectionRecovery', 0x59, '01'),
+		)
+	})
+
+	test('SetLedIndicationMode encodes mode', () => {
+		expect(commandBuilder.build('SetLedIndicationMode', { mode: 1 })).toStrictEqual(
+			new BaseCommand('SetLedIndicationMode', 0x5b, '01'),
+		)
+	})
+
+	test('SetRelayRecoveryState encodes state', () => {
+		expect(commandBuilder.build('SetRelayRecoveryState', { state: 2 })).toStrictEqual(
+			new BaseCommand('SetRelayRecoveryState', 0x5e, '02'),
+		)
+	})
+
+	test('Invalid SetRelayTimerInSeconds throws validation error', () => {
+		expect(() => commandBuilder.build('SetRelayTimerInSeconds', { state: 0, time: 70000 })).toThrow(CustomError)
+	})
+})

package/src/encoders/SetAqiLedCommands.test.ts

@@ -0,0 +1,18 @@
+import { BaseCommand } from '@/encoders'
+import { SetAqiLedCommands } from '@/encoders/SetAqiLedCommands'
+
+describe('SetAqiLedCommands payload encoder', () => {
+	test('SetAqiLed encodes behaviors and durations', () => {
+		const command = new SetAqiLedCommands({
+			redBehavior: 1,
+			redDuration: 20,
+			greenBehavior: 2,
+			greenDuration: 30,
+			blueBehavior: 3,
+			blueDuration: 40,
+			commandNumber: '05',
+		})
+		expect(command).toBeInstanceOf(BaseCommand)
+		expect(command.toHex()).toBe('05224364')
+	})
+})

package/src/encoders/TFloodCommands.test.ts

@@ -0,0 +1,34 @@
+import { BaseCommand, CommandBuilder } from '@/encoders'
+import { CustomError } from '@/utils'
+
+describe('TFloodCommands payload encoder', () => {
+	const commandBuilder = new CommandBuilder('t_flood')
+
+	test('SetFloodAlarmTime encodes alarm time', () => {
+		expect(commandBuilder.build('SetFloodAlarmTime', { time: 10 })).toStrictEqual(
+			new BaseCommand('SetFloodAlarmTime', 0x04, 'a'),
+		)
+	})
+
+	test('SetKeepAlive encodes keepalive seconds as 2 bytes', () => {
+		expect(commandBuilder.build('SetKeepAlive', { time: 120 })).toStrictEqual(
+			new BaseCommand('SetKeepAlive', 0x05, '0078'),
+		)
+	})
+
+	test('SetFloodEventSendTime encodes send time', () => {
+		expect(commandBuilder.build('SetFloodEventSendTime', { time: 30 })).toStrictEqual(
+			new BaseCommand('SetFloodEventSendTime', 0x08, '1e'),
+		)
+	})
+
+	test('SetFloodEventUplinkType encodes uplink type', () => {
+		expect(commandBuilder.build('SetFloodEventUplinkType', { type: '01' })).toStrictEqual(
+			new BaseCommand('SetFloodEventUplinkType', 0x13, '01'),
+		)
+	})
+
+	test('Invalid SetFloodAlarmTime throws validation error', () => {
+		expect(() => commandBuilder.build('SetFloodAlarmTime', { time: -1 })).toThrow(CustomError)
+	})
+})