Solving the Tire Pressure Monitoring System exercise (I)

1. Introduction.

Last week I facilitated a guided kata for a Gran Canaria Ágil event in Aplicaciones Informáticas Domingo Alonso (thanks to both for inviting me) in which I explained a possible way to solve Luca Minudel's Tire Pressure Monitoring System exercise.

This exercise is part of his TDD with Mock Objects: Design Principles and Emergent Properties exercises.

I like these exercises very much because they contain clear violations of the SOLID principles but they are sill small enough to be able to finish the refactoring in a short session at a slow pace. This makes possible to explain, answer questions and debate about design principles, dependency-breaking techniques and refactoring techniques as you apply them.

I'd like to thank Luca Minudel for creating and sharing these great exercises.

I co-facilitated this exercise with Álvaro García several month ago in a Software Craftsmanship Barcelona event and we received a lot of positive feedback.

That time, many people couldn't attend due to space limits, so I'd like to make a summary of the exercise here for them.

2. The initial code.

The initial code has two classes: Alarm and Sensor.

	package tddmicroexercises.tirepressuremonitoringsystem;
	public class Alarm {
	private final double LowPressureThreshold = 17;
	private final double HighPressureThreshold = 21;
	private Sensor sensor = new Sensor();
	private boolean alarmOn = false;
	public void check() {
	double psiPressureValue = sensor.popNextPressurePsiValue();
	if (psiPressureValue < LowPressureThreshold || HighPressureThreshold < psiPressureValue) {
	alarmOn = true;
	}
	}
	public boolean isAlarmOn() {
	return alarmOn;
	}
	}

view raw initial_Alarm.java hosted with ❤ by GitHub

	package tddmicroexercises.tirepressuremonitoringsystem;
	import java.util.Random;
	public class Sensor {
	public static final double OFFSET = 16;
	public double popNextPressurePsiValue() {
	double pressureTelemetryValue;
	pressureTelemetryValue = samplePressure();
	return OFFSET + pressureTelemetryValue;
	}
	private static double samplePressure() {
	// placeholder implementation that simulate a real sensor in a real tire
	Random basicRandomNumbersGenerator = new Random();
	double pressureTelemetryValue = 6 * basicRandomNumbersGenerator.nextDouble() * basicRandomNumbersGenerator.nextDouble();
	return pressureTelemetryValue;
	}
	}

view raw initial_Sensor.java hosted with ❤ by GitHub

The exercise focuses on refactoring the Alarm class.

3. SOLID violations, hidden dependencies.

All the logic of the Alarm class is in the check method.

Alarm's main problem is that it depends on a concrete class, the sensor that measures pressure values.

This is a clear violation of the Dependency Inversion principle (DIP) which states that:

Abstractions should not depend on details.

Details should depend on abstractions.

To make things worse this dependency is hidden inside Alarm's check method (see J. B. Rainsberger's The Pain of Implicit Dependencies post).

The violation of the DIP and the implicit dependency makes also impossible to fulfill the Open Closed Principle (OCP).

Fulfilling those two principles will be one of the main goals of this refactoring.

This is the first 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)