i write things called “microtests” to do my development. doing this yields me greater success than i’ve had using any other technique in a 40-year career of geekery, so i advocate, wanting to share the technique far & wide.
before we can talk seriously about how or whether this works, we need a strong grasp of what a microtest is and does, from a strictly *technical* perspective, w/o all the trappings of the larger method and its attendant polemic.
a single microtest is a small fast chunk of code that we run, outside of our shipping source but depending on it, to confirm or deny simple statements about how that shipping source works, with a particular, but not exclusive, focus on the branching logic within it.
i want to draw your attention to several points embedded in that very long sentence. it’s easy for folks to let these points slide when they first approach the idea. that’s natural, we always bring our existing context with us when we approach a new idea, but if we underplay their significance, it’s easy to head down both theoretical and practical dead-ends.
first, we have microtest “externality”, the property that says the microtest code runs outside the shipping code.
this is a snap from a running app. the app’s called contentment, and when it runs it draws this diagram, interpolated over time, as if i were drawing it by hand.
this, on the other hand, is a snap from a microtest run against the contentment app:
why do they not resemble each other at all? because the app is the app and the microtests are the microtests. they are two entirely separate programs.
second, and this is a little buried, the connection between these two separate apps exists at the *source* level, not at runtime.
the microtest app does not launch the app and then poke it to see what happens. rather, *both* apps rely on some shared code at the source level. the app relies entirely on the shipping source. the microtests rely on the shipping source and the testing source.
this is very important to grasp very early on. in some testing schemes, our tests have a runtime connection to an instance of our app. they literally drive the app and look at the results.
this is not how microtests work. nearly every modern programming language comes with the ability to use a single source file in two different apps. microtest schemes make heavy reliance on this capability.
third, microtests focus primarily on branchy logic within the shipping source, with secondary attention to some numerical calculations, and sometimes a small interest in the interface points between the shipping source and the platform on which it runs.
here’s a file, SyncTest.
import static org.assertj.core.api.Assertions.assertThat;
public class SyncTest
private SimpleRhythm rhythm;
private Context context;
private Sync sync;
public void before()
context = new Context();
rhythm = new SimpleRhythm();
sync = new Sync(1);
public void continuesIfNotThereYet()
public void finishesIfThere()
This is a microtest file that uses the shipping source’s Sync class.
the Sync object has just one job, to have its interpolate() method called. if the beat is less than the sync’s target, return true (so that interpolate() will be called again). otherwise return false (so the caller will stop asking).
the Sync object’s behavior *branches* logically. there are two branches, and there are two tests, one that selects for each case. (this example is real, if against a rather straightforward responsibility. in the full context, tho, correctly syncing the drawing to the video or audio source is actually the whole *point* of the contentment app.)
microtests mostly focus on just this: places where *our* code changes its behavior, doing one thing in one call and another thing in another call. we also use them for testing calculations. contentment does a lot of coordinate math. the part of contentment that does geometry has lots of mostly non-branchy code & plenty of microtests to make sure it does its basic algebra & trig the way it’s supposed to.
sometimes, though not often, microtests will focus on the interface points between the shipping source and its platform. the contentment app uses javafx’s animation framework. there are a couple of classes that serve this functionality to the rest of the app. the microtests here essentially establish that this interface point works correctly.
a more common example out in the wild: a bit of SQL is richer than just ‘select * from table’, and we write some microtests to satisfy ourselves that that bit of SQL gives us the right response in a variety of data cases.
the fourth aspect of that long sentence above is caught in the phrase “confirm or deny simple statements”. microtests actively assert about what happens in the shipping source.
microtests don’t just run a piece of the shipping source and let the programmer notice whether or not the computer caught on fire. rather, they run that piece with a particular data context and (partially or fully) validate the results of the call.
in the SyncTest file above, the line that says
is calling the interpolate() AND checking that it answers false.
microtests are active, not passive.
Small and Fast
the fifth and final (for now) aspect of microtests is that they are small and fast.
a typical java microtest is well under 10 lines of code beginning to end. it runs in milliseconds. it tests only a single branch. it doesn’t usually assert everything about the results, but usually only one or two things about them.
the SyncTest above seems trivial, because Sync’s responsibility is, however critical to correct functioning of the app, trivial. *but*. the average microtest in contentment is five lines long, longest is 20, most of which is taken up by 12 lines of try/catch java noise.
Industrial Logic’s great app for serving online instructional material is a good case. its 1200 microtests eat under a minute.
These Are Microtests
so there we go. five important properties of microtests are 1) externality, 2) source-only relationship to app, 3) branchy focus, 4) active confirmation, and 5) small size and high speed.
if we’re talking about microtests, we’re talking about tests that have these properties.
there are many questions waiting in the wings from this starting point. among others, “why on earth would i do this?” and “how can i do this when my code doesn’t want me to?”
we can get there. but we can’t get there without remembering these properties.