All Downloads are FREE. Search and download functionalities are using the official Maven repository.

org.mockito.BDDMockito Maven / Gradle / Ivy

There is a newer version: 5.13.0
Show newest version
/*
 * Copyright (c) 2007 Mockito contributors
 * This program is made available under the terms of the MIT License.
 */
package org.mockito;

import org.mockito.stubbing.Answer;
import org.mockito.stubbing.OngoingStubbing;
import org.mockito.stubbing.Stubber;
import org.mockito.verification.VerificationMode;

/**
 * Behavior Driven Development style of writing tests uses //given //when //then comments as fundamental parts of your test methods.
 * This is exactly how we write our tests and we warmly encourage you to do so!
 * 

* Start learning about BDD here: https://en.wikipedia.org/wiki/Behavior-driven_development *

* The problem is that current stubbing api with canonical role of when word does not integrate nicely with //given //when //then comments. * It's because stubbing belongs to given component of the test and not to the when component of the test. * Hence {@link BDDMockito} class introduces an alias so that you stub method calls with {@link BDDMockito#given(Object)} method. * Now it really nicely integrates with the given component of a BDD style test! *

* Here is how the test might look like: *


 * import static org.mockito.BDDMockito.*;
 *
 * Seller seller = mock(Seller.class);
 * Shop shop = new Shop(seller);
 *
 * public void shouldBuyBread() throws Exception {
 *   //given
 *   given(seller.askForBread()).willReturn(new Bread());
 *
 *   //when
 *   Goods goods = shop.buyBread();
 *
 *   //then
 *   assertThat(goods, containBread());
 * }
 * 
* * Stubbing voids with throwables: *

 *   //given
 *   willThrow(new RuntimeException("boo")).given(mock).foo();
 *
 *   //when
 *   Result result = systemUnderTest.perform();
 *
 *   //then
 *   assertEquals(failure, result);
 * 
*

* For BDD style mock verification take a look at {@link Then} in action: *


 *   person.ride(bike);
 *   person.ride(bike);
 *
 *   then(person).should(times(2)).ride(bike);
 *   then(person).shouldHaveNoMoreInteractions();
 *   then(police).shouldHaveZeroInteractions();
 * 
*

* It is also possible to do BDD style {@link InOrder} verification: *


 *   InOrder inOrder = inOrder(person);
 *
 *   person.drive(car);
 *   person.ride(bike);
 *   person.ride(bike);
 *
 *   then(person).should(inOrder).drive(car);
 *   then(person).should(inOrder, times(2)).ride(bike);
 * 
*

* One of the purposes of BDDMockito is also to show how to tailor the mocking syntax to a different programming style. * * @since 1.8.0 */ @SuppressWarnings("unchecked") public class BDDMockito extends Mockito { /** * See original {@link OngoingStubbing} * @since 1.8.0 */ public interface BDDMyOngoingStubbing { /** * See original {@link OngoingStubbing#thenAnswer(Answer)} * @since 1.8.0 */ BDDMyOngoingStubbing willAnswer(Answer answer); /** * See original {@link OngoingStubbing#then(Answer)} * @since 1.9.0 */ BDDMyOngoingStubbing will(Answer answer); /** * See original {@link OngoingStubbing#thenReturn(Object)} * @since 1.8.0 */ BDDMyOngoingStubbing willReturn(T value); /** * See original {@link OngoingStubbing#thenReturn(Object, Object[])} * @since 1.8.0 */ @SuppressWarnings({"unchecked", "varargs"}) BDDMyOngoingStubbing willReturn(T value, T... values); /** * See original {@link OngoingStubbing#thenThrow(Throwable...)} * @since 1.8.0 */ BDDMyOngoingStubbing willThrow(Throwable... throwables); /** * See original {@link OngoingStubbing#thenThrow(Class)} * @since 2.1.0 */ BDDMyOngoingStubbing willThrow(Class throwableType); /** * See original {@link OngoingStubbing#thenThrow(Class, Class[])} * @since 2.1.0 */ // Additional method helps users of JDK7+ to hide heap pollution / unchecked generics array // creation @SuppressWarnings({"unchecked", "varargs"}) BDDMyOngoingStubbing willThrow( Class throwableType, Class... throwableTypes); /** * See original {@link OngoingStubbing#thenCallRealMethod()} * @since 1.9.0 */ BDDMyOngoingStubbing willCallRealMethod(); /** * See original {@link OngoingStubbing#getMock()} * @since 1.9.0 */ M getMock(); } private static class BDDOngoingStubbingImpl implements BDDMyOngoingStubbing { private final OngoingStubbing mockitoOngoingStubbing; public BDDOngoingStubbingImpl(OngoingStubbing ongoingStubbing) { this.mockitoOngoingStubbing = ongoingStubbing; } public BDDMyOngoingStubbing willAnswer(Answer answer) { return new BDDOngoingStubbingImpl(mockitoOngoingStubbing.thenAnswer(answer)); } public BDDMyOngoingStubbing will(Answer answer) { return new BDDOngoingStubbingImpl(mockitoOngoingStubbing.then(answer)); } public BDDMyOngoingStubbing willReturn(T value) { return new BDDOngoingStubbingImpl(mockitoOngoingStubbing.thenReturn(value)); } public BDDMyOngoingStubbing willReturn(T value, T... values) { return new BDDOngoingStubbingImpl(mockitoOngoingStubbing.thenReturn(value, values)); } public BDDMyOngoingStubbing willThrow(Throwable... throwables) { return new BDDOngoingStubbingImpl(mockitoOngoingStubbing.thenThrow(throwables)); } public BDDMyOngoingStubbing willThrow(Class throwableType) { return new BDDOngoingStubbingImpl(mockitoOngoingStubbing.thenThrow(throwableType)); } public BDDMyOngoingStubbing willThrow( Class throwableType, Class... throwableTypes) { return new BDDOngoingStubbingImpl( mockitoOngoingStubbing.thenThrow(throwableType, throwableTypes)); } public BDDMyOngoingStubbing willCallRealMethod() { return new BDDOngoingStubbingImpl(mockitoOngoingStubbing.thenCallRealMethod()); } public M getMock() { return (M) mockitoOngoingStubbing.getMock(); } } /** * see original {@link Mockito#when(Object)} * @since 1.8.0 */ public static BDDMyOngoingStubbing given(T methodCall) { return new BDDOngoingStubbingImpl(Mockito.when(methodCall)); } /** * Bdd style verification of mock behavior. * *


     *   person.ride(bike);
     *   person.ride(bike);
     *
     *   then(person).should(times(2)).ride(bike);
     * 
* * @see #verify(Object) * @see #verify(Object, VerificationMode) * @since 1.10.0 */ public static Then then(T mock) { return new ThenImpl(mock); } /** * Provides fluent way of mock verification. * * @param type of the mock * * @since 1.10.5 */ public interface Then { /** * @see #verify(Object) * @since 1.10.5 */ T should(); /** * @see #verify(Object, VerificationMode) * @since 1.10.5 */ T should(VerificationMode mode); /** * @see InOrder#verify(Object) * @since 2.1.0 */ T should(InOrder inOrder); /** * @see InOrder#verify(Object, VerificationMode) * @since 2.1.0 */ T should(InOrder inOrder, VerificationMode mode); /** * @see #verifyNoMoreInteractions(Object...) * @since 2.1.0 */ void shouldHaveNoMoreInteractions(); /** * @see #verifyNoInteractions(Object...) * @since 3.0.1 */ void shouldHaveNoInteractions(); } private static class ThenImpl implements Then { private final T mock; ThenImpl(T mock) { this.mock = mock; } /** * @see #verify(Object) * @since 1.10.5 */ public T should() { return verify(mock); } /** * @see #verify(Object, VerificationMode) * @since 1.10.5 */ public T should(VerificationMode mode) { return verify(mock, mode); } /** * @see InOrder#verify(Object) * @since 2.1.0 */ public T should(InOrder inOrder) { return inOrder.verify(mock); } /** * @see InOrder#verify(Object, VerificationMode) * @since 2.1.0 */ public T should(InOrder inOrder, VerificationMode mode) { return inOrder.verify(mock, mode); } /** * @see #verifyNoMoreInteractions(Object...) * @since 2.1.0 */ public void shouldHaveNoMoreInteractions() { verifyNoMoreInteractions(mock); } /** * @see #verifyNoInteractions(Object...) * @since 3.0.1 */ public void shouldHaveNoInteractions() { verifyNoInteractions(mock); } } /** * See original {@link Stubber} * @since 1.8.0 */ public interface BDDStubber { /** * See original {@link Stubber#doAnswer(Answer)} * @since 1.8.0 */ BDDStubber willAnswer(Answer answer); /** * See original {@link Stubber#doAnswer(Answer)} * @since 1.8.0 */ BDDStubber will(Answer answer); /** * See original {@link Stubber#doNothing()} * @since 1.10.20 */ BDDStubber willDoNothing(); /** * See original {@link Stubber#doReturn(Object)} * @since 2.1.0 */ BDDStubber willReturn(Object toBeReturned); /** * See original {@link Stubber#doReturn(Object)} * @since 2.1.0 */ @SuppressWarnings({"unchecked", "varargs"}) BDDStubber willReturn(Object toBeReturned, Object... nextToBeReturned); /** * See original {@link Stubber#doThrow(Throwable...)} * @since 1.8.0 */ BDDStubber willThrow(Throwable... toBeThrown); /** * See original {@link Stubber#doThrow(Class)} * @since 2.1.0 */ BDDStubber willThrow(Class toBeThrown); /** * See original {@link Stubber#doThrow(Class, Class[])} * @since 2.1.0 */ @SuppressWarnings({"unchecked", "varargs"}) BDDStubber willThrow( Class toBeThrown, Class... nextToBeThrown); /** * See original {@link Stubber#doCallRealMethod()} * @since 1.9.0 */ BDDStubber willCallRealMethod(); /** * See original {@link Stubber#when(Object)} * @since 1.8.0 */ T given(T mock); } private static class BDDStubberImpl implements BDDStubber { private final Stubber mockitoStubber; public BDDStubberImpl(Stubber mockitoStubber) { this.mockitoStubber = mockitoStubber; } public T given(T mock) { return mockitoStubber.when(mock); } public BDDStubber willAnswer(Answer answer) { return new BDDStubberImpl(mockitoStubber.doAnswer(answer)); } public BDDStubber will(Answer answer) { return new BDDStubberImpl(mockitoStubber.doAnswer(answer)); } public BDDStubber willDoNothing() { return new BDDStubberImpl(mockitoStubber.doNothing()); } public BDDStubber willReturn(Object toBeReturned) { return new BDDStubberImpl(mockitoStubber.doReturn(toBeReturned)); } public BDDStubber willReturn(Object toBeReturned, Object... nextToBeReturned) { return new BDDStubberImpl( mockitoStubber.doReturn(toBeReturned).doReturn(nextToBeReturned)); } public BDDStubber willThrow(Throwable... toBeThrown) { return new BDDStubberImpl(mockitoStubber.doThrow(toBeThrown)); } public BDDStubber willThrow(Class toBeThrown) { return new BDDStubberImpl(mockitoStubber.doThrow(toBeThrown)); } public BDDStubber willThrow( Class toBeThrown, Class... nextToBeThrown) { return new BDDStubberImpl(mockitoStubber.doThrow(toBeThrown, nextToBeThrown)); } public BDDStubber willCallRealMethod() { return new BDDStubberImpl(mockitoStubber.doCallRealMethod()); } } /** * see original {@link Mockito#doThrow(Throwable[])} * @since 2.1.0 */ public static BDDStubber willThrow(Throwable... toBeThrown) { return new BDDStubberImpl(Mockito.doThrow(toBeThrown)); } /** * see original {@link Mockito#doThrow(Class)} * @since 1.9.0 */ public static BDDStubber willThrow(Class toBeThrown) { return new BDDStubberImpl(Mockito.doThrow(toBeThrown)); } /** * see original {@link Mockito#doThrow(Class)} * @since 1.9.0 */ public static BDDStubber willThrow( Class toBeThrown, Class... throwableTypes) { return new BDDStubberImpl(Mockito.doThrow(toBeThrown, throwableTypes)); } /** * see original {@link Mockito#doAnswer(Answer)} * @since 1.8.0 */ public static BDDStubber willAnswer(Answer answer) { return new BDDStubberImpl(Mockito.doAnswer(answer)); } /** * see original {@link Mockito#doAnswer(Answer)} * @since 2.1.0 */ public static BDDStubber will(Answer answer) { return new BDDStubberImpl(Mockito.doAnswer(answer)); } /** * see original {@link Mockito#doNothing()} * @since 1.8.0 */ public static BDDStubber willDoNothing() { return new BDDStubberImpl(Mockito.doNothing()); } /** * see original {@link Mockito#doReturn(Object)} * @since 1.8.0 */ public static BDDStubber willReturn(Object toBeReturned) { return new BDDStubberImpl(Mockito.doReturn(toBeReturned)); } /** * see original {@link Mockito#doReturn(Object, Object...)} * @since 2.1.0 */ @SuppressWarnings({"unchecked", "varargs"}) public static BDDStubber willReturn(Object toBeReturned, Object... toBeReturnedNext) { return new BDDStubberImpl(Mockito.doReturn(toBeReturned, toBeReturnedNext)); } /** * see original {@link Mockito#doCallRealMethod()} * @since 1.8.0 */ public static BDDStubber willCallRealMethod() { return new BDDStubberImpl(Mockito.doCallRealMethod()); } }




© 2015 - 2024 Weber Informatics LLC | Privacy Policy