Mock thenReturn on New object not working if can't use Abstract class?

Question

originally had the code below

public class Sender {
    public void printLine() {
        System.out.println("print line");
    }
}


public class BSending {
    protected final Sender aSender;
    private final RandomNumGen randomNumGen;

    @Autowired
    public BSending(Sender sender, int thresh) {
        this.aSender = sender;
        this.randomNumGen = new RandomNumGen(thresh);
        //also injects other beans
    }

    public void sendTask() {
        if (this.randomNumGen.isChosen()) {
            aSender.printLine();
        }
    }
}

public class BSendingTest {
    @Mock private Sender aSender;
    @Mock private RandomNumGen randomNumGen;


    @Test
    void test() {
        when(randomNumGen.isChosen()).thenReturn(true);
        BSending bSending = new BSending(aSender, 25);
        bSending.sendTask();
        verify(aSender, times(1)).printLine();
    }
}


end2endTest {
    ..

    @SpringBootTest(
       classes = {
            BSending.class
       })

   ..

}

where randomNumGen.isChosen() uses a random-number generator to determine if it should return true or false, but it depends on the value thresh that is passed into BSending. This value is read from an input text file

Here, I expected aSender.printLine() to be hit, but its not. Its because the mocked randomNumGen isn't being used due to the new RandomNumGen(thresh)

EDIT:

If I then create an abstract class Conf so the now becomes

@Component
public abstract class Conf {
    public int thresh;
    public abstract RandomNumGen newRandomNumGen();

}

public class BSending {
    protected final Sender aSender;
    private final Conf conf;

    @Autowired
    public BSending(Sender sender, int thresh, Conf conf) {
        this.aSender = sender;
        this.conf = conf;
        this.conf.thresh = thresh;
    }

    public void sendTask() {
        if (conf.randomNumGen.isChosen()) {
            aSender.printLine();
        }
    }
}

public class BSendingTest {
    @Mock private Sender aSender;
    @Mock private RandomNumGen randomNumGen;
    @Mock private Conf conf;


    @Test
    void test() {
        when(conf.newRandomNumGen()).thenReturn(randomNumGen);
        when(randomNumGen.isChosen()).thenReturn(true);
        BSending bSending = new BSending(aSender, 25, conf);
        bSending.sendTask();
        verify(aSender, times(1)).printLine();
    }
}

where randomNumGen.isChosen() uses a random-number generator to determine if it should return true or false

Before, I expected aSender.printLine() to be hit, but its not. But with this new code with the abstract class Conf, now it works.

The problem now is that because Conf is an abstract class (I made it abstract because it has the thresh member and newRandomGen() method), the end2end test now fails with BeanInstantiationException is it an abstract class as it has

 @SpringBootTest(
   classes = {
        BSending.class, Conf.class
   })

Is there a way I can replicate the above without having to make Conf an abstract class?

EDIT2:

public class RandomNumGen {
    private final thresh;
    public RandomNumGen(int thresh) {
        this.thresh = thresh;
    }
    public boolean isChosen() {
        return isChosenX(this.thresh, new Random())
    }
    public boolean isChosenX(int thresh, Random random) {
        //determine if chosen using random number generator and thresh
    }
    
        
}

Answer 1

yes you are correct.

In your test, you are mocking the behavior of the RandomNumGen class using

when(randomNumGen.isChosen()).thenReturn(true);

This means that whenever randomNumGen.isChosen(); is called in the test, it should return true.

However, when you create a new instance of RandomNumGen using new RandomNumGen() inside the BSending class, it creates a different instance that is not aware of the mocking behavior set up in the test.

To fix this one way you can do is:

public class BSending {
    protected final Sender aSender;
    private final RandomNumGen randomNumGen;

    @Autowired
    public BSending(Sender sender, RandomNumGen randomNumGen) {
        this.aSender = sender;
        this.randomNumGen = randomNumGen;
    }

    public void sendTask() {
        if (randomNumGen.isChosen()) {
            aSender.printLine();
        }
    }
}

and then you can run your test.

Answer 2

newing up instances in your class couples them to a single implementation. There are ways around it, which usually involves using PowerMockito or similar tools to intercept constructor calls and return a different implementation.

But you don't have to use such tools or libraries if you are willing to restructure your classes a little bit. If you do that, standard Java has got you covered.

For a proper discussion, let's look at the original code:

public class Sender {
    public void printLine() { System.out.println("print line"); }
}

public class BSending {
    protected final Sender aSender;
    private final RandomNumGen randomNumGen;

    @Autowired
    public BSending(Sender sender, int thresh) {
        this.aSender = sender;
        this.randomNumGen = new RandomNumGen(thresh);
        //also injects other beans
    }

    public void sendTask() {
        if (this.randomNumGen.isChosen()) aSender.printLine();
    }
}

public class BSendingTest {
    @Mock private Sender aSender;
    @Mock private RandomNumGen randomNumGen;

    @Test void test() {
        when(randomNumGen.isChosen()).thenReturn(true);
        BSending bSending = new BSending(aSender, 25);
        bSending.sendTask();
        verify(aSender, times(1)).printLine();
    }
}

As written above, this.randomNumGen = new RandomNumGen(thresh) tightly couples your class to this single random number generator implementation. Your @Mock RandomNumGen randomNumGen is never used by your class – how would it, you never pass it to the class and the class instantiates its own instance. While not the source of the problem, it is also worth pointing out that passing thresh to the BSending class is a bit odd too. BSending shouldn't know about the threshold for the number generator; the generator implementation should (and a different implementation might not even use a threshold).

You mention that RandomNumGen is a third-party class and you cannot change it. That requires a bit more work on our part, but this is mostly writing a bit of boilerplate.

First, let's start by introducing our own "random number" contract, which we'll consume in the service:

interface RandomChooser {
  boolean isChosen();
}

and a "production implementation", which wraps the third-party generator:

@Component // create bean elligible for autowiring
class RandomNumGenChooser implements RandomChooser {
  private final RandomNumGen random;
  public RandomNumGenChooser(final int thresh) {
    this.random = new RandomNumGen(thresh);
  }
  @Override public boolean isChosen() { return random.isChosen(); }
}

Once we have that, migrate the service to consume the new interface:

public class BSending {
    protected final Sender aSender;
    private final RandomChooser random;

    @Autowired
    public BSending(final Sender sender, final int thresh) {
        this.aSender = sender;
        this.random = new RandomNumGenChooser(thresh);
        //also injects other beans
    }

    public void sendTask() {
        if (random.isChosen()) aSender.printLine();
    }
}

In the next step, move instantiation of the dependency out of the constructor. Since the implementation was already marked with @Component, it is added as bean to the application context and will be picked up by the autowiring mechanism:

public class BSending {
    protected final Sender aSender;
    private final RandomChooser random;

    @Autowired
    public BSending(final Sender sender, final RandomChooser random) {
        this.aSender = sender;
        this.random = random;
        //also injects other beans
    }

    public void sendTask() {
        if (random.isChosen()) aSender.printLine();
    }
}

But there's a problem! Spring cannot create an instance of the bean, because Spring does not know the value of thresh. You have 2 options:

1. Annotate the constructor parameter with @Value to read it from a config file or the environment
2. Implement a factory which creates the correct instance for you:

The factory could look like this:

@Component
class RandomChooserFactory {
  RandomChooser randomChooser() {
    final int thresh = // obtain threshold
    return new RandomNumGenChooser(thresh);
  }
}

Okay, but how does that solve your problem? So far, we have only introduced additional interfaces, classes, and indirection. Correct, but all of that allows us to easily swap the RandomNumGenChooser with any implementation we desire in the tests.

One such possible implementation could look like this:

class StaticRandomChooser implements RandomChooser {
  private final boolean chosen;
  public StaticRandomChooser(final boolean chosen) { this.chosen = chosen; }
  @Override public boolean isChosen() { return chosen; }
}

and it doesn't even have to be a bean.

Using it in your test becomes trivial now:

public class BSendingTest {
    @Mock private Sender aSender;

    @Test void test() {
        final BSending bSending = new BSending(
            aSender,
            new StaticRandomChooser(true));
        bSending.sendTask();
        verify(aSender).printLine();
    }
}

This solution and variants for similar problems are explained in Why are my mocked methods not called when executing a unit test?