Mockito：模拟具有多个构造函数的对象？

Question

是否可以模拟一个可能在被测类中实例化的对象，该对象不使用依赖注入，并且将根据用于被测类的c-tor使用不同的构造函数实例化？

Answer 1

Your mocks don't actually invoke the constructor. They invoke a proxy object of sorts, which will resolve to that object type but is injected with a lot of runtime utilities to allow you to inspect it.

If you want to test your constructors, then you would want to actually instantiate it without a mock.

Answer 2

Think of constructor invocations as the static calls that they are: If you call new Foo(...) in your code, Mockito will not be able to provide a replacement or mock Foo (at least without rewriting your system-under-test, which is what Powermock can do ). This is true regardless of how many constructors Foo has.

If you aren't allowed to change your system-under-test, you're stuck: It's just not a flexible system as it is. This isn't necessarily a bad thing: If your system's dependency is lightweight and resilient, you might instead just make sure the dependency is well-tested and treat it as an unchangeable implementation detail of your system-under-test.

If you want to replace your instance with a mock, you will probably need to insert a testing seam where you can get in and replace the instance, which is a sort of dependency injection. You might choose to do so with a factory, which can be kept as a field or passed in as a constructor argument:

class YourSystemUnderTest {
  interface FooFactory {
    Foo create(Bar bar);           // one-arg constructor
    Foo create(Bar bar, Baz baz);  // two-arg constructor
  }

  class DefaultFooFactory implements FooFactory {
    @Override public Foo create(Bar bar) { return new Foo(bar); }
    @Override public Foo create(Bar bar, Baz baz) { return new Foo(bar, baz); }
  }

  /** Visible and non-final for testing. */
  FooFactory fooFactory = new DefaultFooFactory();  // replace this in tests

  // ...
}

Or, as a slightly more-hacky way to do this, delegate to an overridable method call in your system-under-test, and override that in your test.

class YourSystemUnderTest {
  /** Visible and non-final for overriding. */
  Foo createFoo(Bar bar) { return new Foo(bar); }
  /** Visible and non-final for overriding. */
  Foo createFoo(Bar bar, Baz baz) { return new Foo(bar, baz); }
}

class YourSystemUnderTest_Test {
  @Mock Foo mockFoo;

  @Before void createSystemUnderTest() {
    yourSystemUnderTest = new YourSystemUnderTest() {
      @Override Foo createFoo(Bar bar) { return mockFoo; }
      @Override Foo createFoo(Bar bar, Baz baz) { return mockFoo; }
    };
  }

  // ...
}

Note that in both cases, you are accurately representing that YourSystemUnderTest is no longer to locked to only using a real Foo instance, but rather that it is allowed to use other implementations of Foo including test-double implementations. Outside of tests, this may come in handy if you ever upgrade or change your system-under-test's dependencies.