Mutable extension to immutable domain model: an alternative to the Test Data Builder pattern

Nat Pryce recently blogged about an alternative to the Object Mother pattern: creating a builder class for each class in the domain. He's able with this idea to get testing code to look like this:

Invoice invoiceWithNoPostcode = new InvoiceBuilder()
   .withRecipient(new RecipientBuilder()
       .withAddress(new AddressBuilder()
           .withNoPostcode()
           .build())
       .build())
   .build();

I think I can improve on this and achieve code that looks like this:

MutableInvoice invoiceWithNoPostcode = new MutableInvoice()
   .withRecipient(new MutableRecipient()
       .withAddress(new MutableAddress()
           .withNoPostcode()));

Instead of creating a builder for each domain class I've created a mutable extension to each domain class, it is the mutable extension I'm using in the test.

I don't quite like the code above, I think the following looks better:

Invoice invoiceWithNoPostcode = new Invoice()
   .withRecipient(new Recipient()
       .withAddress(new Address()
           .withNoPostcode()));

I've changed the code to use the same name for the mutable extension (with a different package of course) because I figure the tests can just refer to the mutable versions and it saves me having the 'Mutable' prefix on everything. Naturally I only make the mutable extensions available for testing.

Here's how the mutable Invoice extension might look:

package model.mutable;

public Invoice extends model.Invoice {
  public Invoice(Recipient recipient, InvoiceLines invoiceLines) {
      super(recipient, invoiceLines);
  }

  public Invoice() {
      // choose the same defaults here as you would in the InvoiceBuilder
      this(null, null);
  }

  public Invoice withRecipient(Recipient recipient) {
      return new Invoice(recipient, getInvoiceLines());
  }
}

I've had to add protected accessors to the domain model; this bothers me a little as they make it easier to slip towards an anemic data model. It might be worth using some reflective code in the extension class instead:

public class Invoice extends model.Invoice {
 ...

 private InvoiceLines getInvoiceLines() {
     return new ReflectiveAccessor().get(this, "invoiceLines", InvoiceLines.class);
 }
}


public class ReflectiveAccessor {
 public  T get(Object fieldOwner, String fieldName, Class fieldClass) {
    ...
 }
}