| /* |
| * 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 <b>//given //when //then</b> comments as fundamental parts of your test methods. |
| * This is exactly how we write our tests and we warmly encourage you to do so! |
| * <p> |
| * Start learning about BDD here: <a href="http://en.wikipedia.org/wiki/Behavior_Driven_Development">http://en.wikipedia.org/wiki/Behavior_Driven_Development</a> |
| * <p> |
| * The problem is that current stubbing api with canonical role of <b>when</b> word does not integrate nicely with <b>//given //when //then</b> comments. |
| * It's because stubbing belongs to <b>given</b> component of the test and not to the <b>when</b> 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 <b>given</b> component of a BDD style test! |
| * <p> |
| * Here is how the test might look like: |
| * <pre class="code"><code class="java"> |
| * 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()); |
| * } |
| * </code></pre> |
| * |
| * Stubbing voids with throwables: |
| * <pre class="code"><code class="java"> |
| * //given |
| * willThrow(new RuntimeException("boo")).given(mock).foo(); |
| * |
| * //when |
| * Result result = systemUnderTest.perform(); |
| * |
| * //then |
| * assertEquals(failure, result); |
| * </code></pre> |
| * <p> |
| * For BDD style mock verification take a look at {@link Then} in action: |
| * <pre class="code"><code class="java"> |
| * person.ride(bike); |
| * person.ride(bike); |
| * |
| * then(person).should(times(2)).ride(bike); |
| * then(person).shouldHaveNoMoreInteractions(); |
| * then(police).shouldHaveZeroInteractions(); |
| * </code></pre> |
| * <p> |
| * It is also possible to do BDD style {@link InOrder} verification: |
| * <pre class="code"><code class="java"> |
| * 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); |
| * </code></pre> |
| * <p> |
| * 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<T> { |
| |
| /** |
| * See original {@link OngoingStubbing#thenAnswer(Answer)} |
| * @since 1.8.0 |
| */ |
| BDDMyOngoingStubbing<T> willAnswer(Answer<?> answer); |
| |
| /** |
| * See original {@link OngoingStubbing#then(Answer)} |
| * @since 1.9.0 |
| */ |
| BDDMyOngoingStubbing<T> will(Answer<?> answer); |
| |
| /** |
| * See original {@link OngoingStubbing#thenReturn(Object)} |
| * @since 1.8.0 |
| */ |
| BDDMyOngoingStubbing<T> willReturn(T value); |
| |
| /** |
| * See original {@link OngoingStubbing#thenReturn(Object, Object[])} |
| * @since 1.8.0 |
| */ |
| @SuppressWarnings({"unchecked", "varargs"}) |
| BDDMyOngoingStubbing<T> willReturn(T value, T... values); |
| |
| /** |
| * See original {@link OngoingStubbing#thenThrow(Throwable...)} |
| * @since 1.8.0 |
| */ |
| BDDMyOngoingStubbing<T> willThrow(Throwable... throwables); |
| |
| /** |
| * See original {@link OngoingStubbing#thenThrow(Class)} |
| * @since 2.1.0 |
| */ |
| BDDMyOngoingStubbing<T> willThrow(Class<? extends Throwable> 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<T> willThrow(Class<? extends Throwable> throwableType, Class<? extends Throwable>... throwableTypes); |
| |
| /** |
| * See original {@link OngoingStubbing#thenCallRealMethod()} |
| * @since 1.9.0 |
| */ |
| BDDMyOngoingStubbing<T> willCallRealMethod(); |
| |
| /** |
| * See original {@link OngoingStubbing#getMock()} |
| * @since 1.9.0 |
| */ |
| <M> M getMock(); |
| } |
| |
| private static class BDDOngoingStubbingImpl<T> implements BDDMyOngoingStubbing<T> { |
| |
| private final OngoingStubbing<T> mockitoOngoingStubbing; |
| |
| public BDDOngoingStubbingImpl(OngoingStubbing<T> ongoingStubbing) { |
| this.mockitoOngoingStubbing = ongoingStubbing; |
| } |
| |
| public BDDMyOngoingStubbing<T> willAnswer(Answer<?> answer) { |
| return new BDDOngoingStubbingImpl<T>(mockitoOngoingStubbing.thenAnswer(answer)); |
| } |
| |
| public BDDMyOngoingStubbing<T> will(Answer<?> answer) { |
| return new BDDOngoingStubbingImpl<T>(mockitoOngoingStubbing.then(answer)); |
| } |
| |
| public BDDMyOngoingStubbing<T> willReturn(T value) { |
| return new BDDOngoingStubbingImpl<T>(mockitoOngoingStubbing.thenReturn(value)); |
| } |
| |
| public BDDMyOngoingStubbing<T> willReturn(T value, T... values) { |
| return new BDDOngoingStubbingImpl<T>(mockitoOngoingStubbing.thenReturn(value, values)); |
| } |
| |
| public BDDMyOngoingStubbing<T> willThrow(Throwable... throwables) { |
| return new BDDOngoingStubbingImpl<T>(mockitoOngoingStubbing.thenThrow(throwables)); |
| } |
| |
| public BDDMyOngoingStubbing<T> willThrow(Class<? extends Throwable> throwableType) { |
| return new BDDOngoingStubbingImpl<T>(mockitoOngoingStubbing.thenThrow(throwableType)); |
| } |
| |
| public BDDMyOngoingStubbing<T> willThrow(Class<? extends Throwable> throwableType, Class<? extends Throwable>... throwableTypes) { |
| return new BDDOngoingStubbingImpl<T>(mockitoOngoingStubbing.thenThrow(throwableType, throwableTypes)); |
| } |
| |
| public BDDMyOngoingStubbing<T> willCallRealMethod() { |
| return new BDDOngoingStubbingImpl<T>(mockitoOngoingStubbing.thenCallRealMethod()); |
| } |
| |
| public <M> M getMock() { |
| return (M) mockitoOngoingStubbing.getMock(); |
| } |
| } |
| |
| /** |
| * see original {@link Mockito#when(Object)} |
| * @since 1.8.0 |
| */ |
| public static <T> BDDMyOngoingStubbing<T> given(T methodCall) { |
| return new BDDOngoingStubbingImpl<T>(Mockito.when(methodCall)); |
| } |
| |
| /** |
| * Bdd style verification of mock behavior. |
| * |
| * <pre class="code"><code class="java"> |
| * person.ride(bike); |
| * person.ride(bike); |
| * |
| * then(person).should(times(2)).ride(bike); |
| * </code></pre> |
| * |
| * @see #verify(Object) |
| * @see #verify(Object, VerificationMode) |
| * @since 1.10.0 |
| */ |
| public static <T> Then<T> then(T mock) { |
| return new ThenImpl<T>(mock); |
| } |
| |
| /** |
| * Provides fluent way of mock verification. |
| * |
| * @param <T> type of the mock |
| * |
| * @since 1.10.5 |
| */ |
| public interface Then<T> { |
| |
| /** |
| * @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 #verifyZeroInteractions(Object...) |
| * @since 2.1.0 |
| */ |
| void shouldHaveZeroInteractions(); |
| |
| /** |
| * @see #verifyNoMoreInteractions(Object...) |
| * @since 2.1.0 |
| */ |
| void shouldHaveNoMoreInteractions(); |
| } |
| |
| private static class ThenImpl<T> implements Then<T> { |
| |
| 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 #verifyZeroInteractions(Object...) |
| * @since 2.1.0 |
| */ |
| public void shouldHaveZeroInteractions() { |
| verifyZeroInteractions(mock); |
| } |
| |
| /** |
| * @see #verifyNoMoreInteractions(Object...) |
| * @since 2.1.0 |
| */ |
| public void shouldHaveNoMoreInteractions() { |
| verifyNoMoreInteractions(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()}. |
| * |
| * This method will be removed in version 3.0.0 |
| * |
| * @since 1.8.0 |
| * @deprecated as of 2.1.0 please use {@link #willDoNothing()} instead |
| */ |
| @Deprecated |
| BDDStubber willNothing(); |
| |
| /** |
| * 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<? extends Throwable> toBeThrown); |
| |
| /** |
| * See original {@link Stubber#doThrow(Class, Class[])} |
| * @since 2.1.0 |
| */ |
| @SuppressWarnings ({"unchecked", "varargs"}) |
| BDDStubber willThrow(Class<? extends Throwable> toBeThrown, Class<? extends Throwable>... nextToBeThrown); |
| |
| /** |
| * See original {@link Stubber#doCallRealMethod()} |
| * @since 1.9.0 |
| */ |
| BDDStubber willCallRealMethod(); |
| |
| /** |
| * See original {@link Stubber#when(Object)} |
| * @since 1.8.0 |
| */ |
| <T> T given(T mock); |
| } |
| |
| private static class BDDStubberImpl implements BDDStubber { |
| |
| private final Stubber mockitoStubber; |
| |
| public BDDStubberImpl(Stubber mockitoStubber) { |
| this.mockitoStubber = mockitoStubber; |
| } |
| |
| public <T> 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)); |
| } |
| |
| /** |
| * @deprecated please use {@link #willDoNothing()} instead |
| */ |
| @Deprecated |
| public BDDStubber willNothing() { |
| return willDoNothing(); |
| } |
| |
| 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<? extends Throwable> toBeThrown) { |
| return new BDDStubberImpl(mockitoStubber.doThrow(toBeThrown)); |
| } |
| |
| public BDDStubber willThrow(Class<? extends Throwable> toBeThrown, Class<? extends Throwable>... 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<? extends Throwable> toBeThrown) { |
| return new BDDStubberImpl(Mockito.doThrow(toBeThrown)); |
| } |
| |
| /** |
| * see original {@link Mockito#doThrow(Class)} |
| * @since 1.9.0 |
| */ |
| public static BDDStubber willThrow(Class<? extends Throwable> toBeThrown, Class<? extends Throwable>... 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()); |
| } |
| } |