[FIXED] JUnit - How to test duplicate instruction in same method with different parameter?

Issue

I have an update method but I'm having trouble doing the unit test. In the method, I need to validate if the object to be changed exists in the database and I also need to check if the new data that the user is inserting will not cause record duplication. For this, I do a search in the database at two different times using a findById():

    public void update(Form form, Long storeCode, Long productCode, Long purchaseQuantity) {

    var id = new PrimaryKeyBuilder(DiscountPK.builder().build()).build(storeCode,productCode, purchaseQuantity);
    var targetToUpdate = repository.findById(id).orElseThrow(NotFoundException::new);

    var dataToInsert = SerializationUtils.clone(id);
    dataToInsert.setPurchaseQuantity(form.getPurchaseQuantity());

    var newPk = repository.findById(dataToInsert);
    throwExceptionIf(newPk.isPresent(), new DuplicatedPkException());

    targetToUpdate.getId().setPurchaseQuantity(form.getPurchaseQuantity());
    targetToUpdate.setDiscountPercentage(form.getDiscountPercentage());

    repository.save(targetToUpdate);

}

The problem is: I'm not able to differentiate these two findById() instructions in my unit test. Instead of passing it successfully, throws NotFoundException of my first validation. It is as if the first given() statement is being ignored and only the second statement is considered

    @Test
    public void update_successfully() {

        var targetToUpdate = ObjectFactory.createMain();
        var form = FormFactory.createUpdateForm();
        var id = ObjectFactory.createFirstAux();
        var dataToInsert = ObjectFactory.createSecondAux();

        given(repository.findById(id)).willReturn(Optional.of(targetToUpdate));
        given(repository.findById(dataToInsert)).willReturn(Optional.empty());

        given(repository.save(any())).willReturn(targetToUpdate);

        service.update(form, STORE_CODE, PRODUCT_CODE, PURCHASE_QUANTITY);
        verify(repository).save(targetToUpdate);
    }

Bonus code: Class that builds the object passed in findById()

 public class PrimaryKeyBuilder {

    private final DiscountPK id;

    public PrimaryKeyBuilder(DiscountPK id) {
        this.id = id;
    }

    public DiscountPK build(Long storeCode, Long productCode, Long purchaseQuantity) {

        id.setPurchaseBoxQuantity(purchaseBoxQuantity);
        id.setProduct(Product.builder().id(ProductPK
                .builder().productCode(productCode).store(Store.builder().code(storeCode).build()).build()).build());

        return id;
    }

}

Solution

When defining mock behavior using given or when, you need to provide arguments that match the arguments that the code being tested will provide. The Mockito documentation explains: "Mockito verifies argument values in natural java style: by using an equals() method."

If the DiscountPK class does not override the equals method, the default implementation in java.lang.Object will be used. This compares object identity, and only returns true when both objects are the same instance.

The most straightforward solution, if you can modify the DiscountPK class, would be to override the equals and hashCode methods in this class, to define equality based on the values it contains. Assuming that the DiscountPK class contains only two fields, named purchaseBoxQuantity and product, you could use the java.util.Objects class to define these this way:

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        DiscountPK that = (DiscountPK) o;
        return Objects.equals(purchaseBoxQuantity, that.purchaseBoxQuantity) && product.equals(that.product);
    }

    @Override
    public int hashCode() {
        return Objects.hash(purchaseBoxQuantity, product);
    }

This also assumes that the Product class defines equals and hashCode.

Note that although Mockito only uses the equals method, and not hashCode, it is always recommended to override hashCode whenever overriding equals, to ensure that equal objects also have equal hash codes.

I would also recommend making the primary key classes immutable. This makes them easier to reason about, as the contents of an entity's primary key should never change. It also ensures that the return value of hashCode will not change over the lifetime of the object, which can lead to bugs.

Answered By - Tim Moore
Answer Checked By - Mildred Charles (JavaFixing Admin)