Solving the Tire Pressure Monitoring System exercise (III)

6. Improving the semantics inside Alarm and adding a new concept to enrich the domain.

Now we turn our attention to the code inside the Alarm class.

We first rename a local variable inside the check method and the method we are calling on Sensor so that we have new names that have less to do with the implementation of Sensor.

Next, we extract the condition inside the check method to an explanatory helper: isNotWithinSafetyRange.

This is the resulting code:

	package tddmicroexercises.tirepressuremonitoringsystem;
	public class Alarm {
	private final double LowPressureThreshold = 17;
	private final double HighPressureThreshold = 21;
	private Sensor sensor;
	private boolean alarmOn;
	public Alarm(Sensor sensor) {
	this.sensor = sensor;
	this.alarmOn = false;
	}
	public void check() {
	double pressureValue = sensor.probePressureValue();
	if (isNotWithinSafetyRange(pressureValue)) {
	alarmOn = true;
	}
	}
	protected boolean isNotWithinSafetyRange(double value) {
	return return value < LowPressureThreshold || HighPressureThreshold < value;
	}
	public boolean isAlarmOn() {
	return alarmOn;
	}
	}

view raw after_renamings_and_extracting_explanatory_helper_Alarm.java hosted with ❤ by GitHub

Notice that the Alarm class contains a data clump.

The constants LowPressureThreshold and HighPressureThreshold don't make any sense the one without the other. They together define a range, to which we have already referred both in production and test code as a safety range.

We remove the data clump by creating a new concept, the SafetyRange value object:

	package tddmicroexercises.tirepressuremonitoringsystem;
	public class Alarm {
	private final double LowPressureThreshold = 17;
	private final double HighPressureThreshold = 21;
	private final SafetyRange safetyRange;
	private Sensor sensor;
	private boolean alarmOn;
	public Alarm(Sensor sensor) {
	this.sensor = sensor;
	this.alarmOn = false;
	this.safetyRange = new SafetyRange(LowPressureThreshold, HighPressureThreshold);
	}
	public void check() {
	double pressureValue = sensor.probePressureValue();
	if (isNotWithinSafetyRange(pressureValue)) {
	alarmOn = true;
	}
	}
	protected boolean isNotWithinSafetyRange(double pressureValue) {
	return safetyRange.isNotWithin(pressureValue);
	}
	public boolean isAlarmOn() {
	return alarmOn;
	}
	private class SafetyRange {
	private final double lowerThreshold;
	private final double higherThreshold;
	public SafetyRange(double lowerThreshold, double higherThreshold) {
	this.lowerThreshold = lowerThreshold;
	this.higherThreshold = higherThreshold;
	}
	public boolean isNotWithin(double value) {
	return value < lowerThreshold || higherThreshold < value;
	}
	}
	}

view raw after_extracting_value_object_Alarm.java hosted with ❤ by GitHub

7. Moving Specificity Towards the Tests.

If you check the tests in AlarmShould class, you'll see that it's difficult to understand the tests at a glance.
Why is the alarm on in some cases and off in some other cases?

To understand why, we have to check Alarm's constructor in which a SafetyRange object is created. This SafetyRange is an implicit configuration of Alarm.

We can make the code clearer and more reusable by moving this configuration details towards the tests.

J. B. Rainsberger explains this concept of moving specificity towards the tests in this video which is embedded in his Demystifying the Dependency Inversion Principle post.

So we change the signature of the Alarm constructor so that the SafetyRange is injected through it.

	package tddmicroexercises.tirepressuremonitoringsystem;
	public class Alarm {
	private final SafetyRange safetyRange;
	private Sensor sensor;
	private boolean alarmOn;
	public Alarm(Sensor sensor, SafetyRange safetyRange) {
	this.sensor = sensor;
	this.safetyRange = safetyRange;
	this.alarmOn = false;
	}
	public void check() {
	double pressureValue = sensor.probePressureValue();
	if (isNotWithinSafetyRange(pressureValue)) {
	alarmOn = true;
	}
	}
	protected boolean isNotWithinSafetyRange(double pressureValue) {
	return safetyRange.isNotWithin(pressureValue);
	}
	public boolean isAlarmOn() {
	return alarmOn;
	}
	}

view raw after_pushing_details_up_call_stack_Alarm.java hosted with ❤ by GitHub

	import org.junit.Test;
	import tddmicroexercises.tirepressuremonitoringsystem.Alarm;
	import tddmicroexercises.tirepressuremonitoringsystem.SafetyRange;
	import tddmicroexercises.tirepressuremonitoringsystem.Sensor;
	import static org.hamcrest.MatcherAssert.assertThat;
	import static org.hamcrest.Matchers.is;
	import static org.mockito.Mockito.doReturn;
	import static org.mockito.Mockito.mock;
	public class AlarmShould {
	private SafetyRange safetyRange;
	@Before
	public void setUp() throws Exception {
	safetyRange = new SafetyRange(17, 21);
	}
	@Test
	public void be_on_when_pressure_value_is_too_low() {
	Alarm alarm = new Alarm(
	sensorThatProbes(5.0), safetyRange
	);
	alarm.check();
	assertThat(alarm.isAlarmOn(), is(true));
	}
	@Test
	public void be_on_when_pressure_value_is_too_high() {
	Alarm alarm = new Alarm(
	sensorThatProbes(25.0), safetyRange
	);
	alarm.check();
	assertThat(alarm.isAlarmOn(), is(true));
	}
	@Test
	public void be_off_when_pressure_value_is_within_safety_range() {
	Alarm alarm = new Alarm(
	sensorThatProbes(20.0), safetyRange
	);
	alarm.check();
	assertThat(alarm.isAlarmOn(), is(false));
	}
	protected Sensor sensorThatProbes(double value) {
	Sensor sensor = mock(Sensor.class);
	doReturn(value).when(sensor).probePressureValue();
	return sensor;
	}
	}

view raw after_pushing_details_up_call_stack_AlarmShould.java hosted with ❤ by GitHub

Now the configuration detail is explicit and it's easier to understand at a glance why any test pass or not.

Moreover this change makes Alarm more reusable.

This is the third post in a series of posts about solving the Tire Pressure Monitoring System exercise in Java:

1. Solving the Tire Pressure Monitoring System exercise (I)
2. Solving the Tire Pressure Monitoring System exercise (II)
3. Solving the Tire Pressure Monitoring System exercise (III)
4. Solving the Tire Pressure Monitoring System exercise (IV)