What do you call an inner class used for testing?

Our team has members who are just ra开发者_如何学Cmping up on unit testing and we're struggling with some terminology. I'd like to determine a name for a particular pattern. I'm hoping there's one that's already embraced by other developers, but if not, I'd like to come up with one that's descriptive and will make talking about test strategies easier.

This pattern is used quite a bit for testing abstract methods, but is also handy when an object creates a new object (for cases where DI doesn't work or isn't desired). The basic pattern is to use an inner class that extends the class under test to expose protected methods.

Consider the following code (which is pseudocode, based on Java, but should translate to most languages):

The class to test:

public class MyClass {
  public void send() {
    //do something
  }
  protected MailMessage createNewMailMessage() {
    return new MailMessage();
  }
}

The test:

public class MyClassTest {
  private MyClass myClass = new TestableMyClass();
  private MailMessage mockMessage = mock(MailMessage.class);

  public void setup() {
    ((TestableMyClass)myClass).setMailMessage(mockMessage);
  }

  // Do some tests //

  private class TestableMyClass extends MyClass {
    private MailMessage mailMessage;

    public void setMailMessage(MailMessage mailMessage) {
      this.mailMessage = mailMessage;
    }

    protected MailMessage createNewMailMessage() {
      return mailMessage;
    }
  }
}

So, what do you call this pattern? TestableMyClass a "Mock" object, but since it's not managed by a mocking framework, it seems like there should be another term to describe this pattern. Any suggestions or ideas?

I'd call it a stub. As you said, it's not a true "mock", since its behavior isn't being controlled by a mocking framework, but is a "true" object.

You don't need to use a mocking framework to call something a Mock/Stub object - your MyClassTest (which I'm assuming is supposed to extend MyClass) is just a Stub.

I don't think there's a particular name for the case where Mocks/Stubs are defined as inner classes of your test class - and in the particular example here, there's no reason for it to be an inner class - it could just be a package protected class (in the same file as MyClassTest or in its separate file..)

Mock contains test assertions.

Stub provides simple hard-coded values to make the test work.

Fake provides complex behavior/answers.

I usually add two underscores prefixing the inner class for testing so it doesn't show up in auto-complete, e.g. '__TestableMyClass'. Also if you are using Mockito you should be stubbing like so

MyClass myClass = mock(MyClass.class);
when(myClass.createNewMailMessage()).thenReturn(mockMessage);