mockito testing

src/main/java/com/mockitotutorial/happyhotel/booking/PaymentService.java

@@ -8,7 +8,7 @@ public class PaymentService {
 
 	public String pay(BookingRequest bookingRequest, double price) {
 		if (price > 200.0 && bookingRequest.getGuestCount() < 3) {
-			throw new UnsupportedOperationException("Only small payments are supported.");
+			throw new BusinessException();
 		}
 		String id = UUID.randomUUID().toString();
 		payments.put(id, price);

src/test/java/com/mockitotutorial/happyhotel/booking/Test01FirstMocks.java

@@ -0,0 +1,40 @@
+package com.mockitotutorial.happyhotel.booking;
+
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+import java.time.LocalDate;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.mockito.Mockito.*;
+
+class Test01FirstMocks {
+
+	private BookingService bookingService;
+	private PaymentService paymentServiceMock;
+	private RoomService roomServiceMock;
+	private BookingDAO bookingDAOMock;
+	private MailSender mailSenderMock;
+
+	@BeforeEach
+	void setup(){
+		paymentServiceMock = mock(PaymentService.class);
+		roomServiceMock = mock(RoomService.class);
+		bookingDAOMock = mock(BookingDAO.class);
+		mailSenderMock = mock(MailSender.class);
+		bookingService = new BookingService(paymentServiceMock, roomServiceMock, bookingDAOMock, mailSenderMock);
+	}
+	@Test
+	void should_CalculateCorrectPrice_When_CorrectInput() {
+		//given
+		BookingRequest bookingRequest = new BookingRequest("1", LocalDate.of(2021, 7, 8),
+				LocalDate.of(2021, 7, 18), 2, false);
+		double expected = 10 * 2 * 50;
+
+		//when
+		double actual = bookingService.calculatePrice(bookingRequest);
+		//then
+		assertEquals(expected, actual);
+	}
+
+}

src/test/java/com/mockitotutorial/happyhotel/booking/Test02DefaultReturnValues.java

@@ -0,0 +1,37 @@
+package com.mockitotutorial.happyhotel.booking;
+
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+import java.time.LocalDate;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.mockito.Mockito.mock;
+
+class Test02DefaultReturnValues {
+
+	private BookingService bookingService;
+	private PaymentService paymentServiceMock;
+	private RoomService roomServiceMock;
+	private BookingDAO bookingDAOMock;
+	private MailSender mailSenderMock;
+
+	@BeforeEach
+	void setup(){
+		paymentServiceMock = mock(PaymentService.class);
+		roomServiceMock = mock(RoomService.class);
+		bookingDAOMock = mock(BookingDAO.class);
+		mailSenderMock = mock(MailSender.class);
+		bookingService = new BookingService(paymentServiceMock, roomServiceMock, bookingDAOMock, mailSenderMock);
+	}
+	@Test
+	void should_CountAvailablePlaces() {
+		//given
+		int expected = 0;
+		//when
+		int actual = bookingService.getAvailablePlaceCount();
+		//then
+	assertEquals(expected, actual);
+	}
+
+}

src/test/java/com/mockitotutorial/happyhotel/booking/Test03ReturnCustomValues.java

@@ -0,0 +1,52 @@
+package com.mockitotutorial.happyhotel.booking;
+
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.mockito.Mockito.*;
+
+class Test03ReturnCustomValues {
+
+	private BookingService bookingService;
+	private PaymentService paymentServiceMock;
+	private RoomService roomServiceMock;
+	private BookingDAO bookingDAOMock;
+	private MailSender mailSenderMock;
+
+	@BeforeEach
+	void setup(){
+		paymentServiceMock = mock(PaymentService.class);
+		roomServiceMock = mock(RoomService.class);
+		bookingDAOMock = mock(BookingDAO.class);
+		mailSenderMock = mock(MailSender.class);
+		bookingService = new BookingService(paymentServiceMock, roomServiceMock, bookingDAOMock, mailSenderMock);
+	}
+
+	@Test
+	void should_CountAvailablePlaces_When_OneRoomAvailable() {
+		//given
+		when(roomServiceMock.getAvailableRooms()).thenReturn(Collections.singletonList(new Room("Room2", 2)));
+		int expected = 2;
+		//when
+		int actual = bookingService.getAvailablePlaceCount();
+		//then
+		assertEquals(expected, actual);
+	}
+	@Test
+	void should_CountAvailablePlaces_When_MultipleRoomsAvailable() {
+		//given
+		List<Room> rooms = Arrays.asList(new Room("Room 1", 2), new Room("Room 2", 5));
+		when(roomServiceMock.getAvailableRooms()).thenReturn(rooms);
+		int expected = 7;
+		//when
+		int actual = bookingService.getAvailablePlaceCount();
+		//then
+		assertEquals(expected, actual);
+	}
+
+}

src/test/java/com/mockitotutorial/happyhotel/booking/Test04MultipleThenReturnCalls.java

@@ -0,0 +1,50 @@
+package com.mockitotutorial.happyhotel.booking;
+
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+
+import static org.junit.jupiter.api.Assertions.*;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+class Test04MultipleThenReturnCalls {
+
+	private BookingService bookingService;
+	private PaymentService paymentServiceMock;
+	private RoomService roomServiceMock;
+	private BookingDAO bookingDAOMock;
+	private MailSender mailSenderMock;
+
+	@BeforeEach
+	void setup(){
+		paymentServiceMock = mock(PaymentService.class);
+		roomServiceMock = mock(RoomService.class);
+		bookingDAOMock = mock(BookingDAO.class);
+		mailSenderMock = mock(MailSender.class);
+		bookingService = new BookingService(paymentServiceMock, roomServiceMock, bookingDAOMock, mailSenderMock);
+	}
+
+	@Test
+	void should_CountAvailablePlaces_When_OneRoomAvailable() {
+		//given
+		when(roomServiceMock.getAvailableRooms())
+				.thenReturn(Collections.singletonList(new Room("Room2", 2)))
+				.thenReturn(Collections.emptyList());
+		int expectedFirst = 2;
+		int expectedSecond = 0;
+		//when
+		int actualFirst = bookingService.getAvailablePlaceCount();
+		int actualSecond = bookingService.getAvailablePlaceCount();
+		//then
+		assertAll(
+				() -> assertEquals(expectedFirst, actualFirst),
+				() -> assertEquals(expectedSecond, actualSecond));
+
+	}
+
+
+}

src/test/java/com/mockitotutorial/happyhotel/booking/Test05ThrowingExceptions.java

@@ -0,0 +1,48 @@
+package com.mockitotutorial.happyhotel.booking;
+
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.function.Executable;
+
+import java.time.LocalDate;
+import java.util.Collections;
+
+import static org.junit.jupiter.api.Assertions.*;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+class Test05ThrowingExceptions {
+
+	private BookingService bookingService;
+	private PaymentService paymentServiceMock;
+	private RoomService roomServiceMock;
+	private BookingDAO bookingDAOMock;
+	private MailSender mailSenderMock;
+
+	@BeforeEach
+	void setup(){
+		paymentServiceMock = mock(PaymentService.class);
+		roomServiceMock = mock(RoomService.class);
+		bookingDAOMock = mock(BookingDAO.class);
+		mailSenderMock = mock(MailSender.class);
+		bookingService = new BookingService(paymentServiceMock, roomServiceMock, bookingDAOMock, mailSenderMock);
+	}
+
+	@Test
+	void should_CountAvailablePlaces_When_OneRoomAvailable() {
+		//given
+		BookingRequest bookingRequest = new BookingRequest("1", LocalDate.of(2021, 7, 8),
+				LocalDate.of(2021, 7, 18), 2, false);
+		BookingRequest bookingRequest2 = new BookingRequest("1", LocalDate.of(2021, 7, 8),
+				LocalDate.of(2021, 7, 18), 2, true);
+		when(roomServiceMock.findAvailableRoomId(bookingRequest))
+				.thenThrow(BusinessException.class);
+		//when
+		Executable executable = () -> bookingService.makeBooking(bookingRequest);
+		//then
+		assertThrows(BusinessException.class, executable);
+
+	}
+
+
+}

src/test/java/com/mockitotutorial/happyhotel/booking/Test06Matches.java

@@ -0,0 +1,48 @@
+package com.mockitotutorial.happyhotel.booking;
+
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.function.Executable;
+
+import java.time.LocalDate;
+
+import static org.junit.jupiter.api.Assertions.*;
+import static org.mockito.ArgumentMatchers.*;
+import static org.mockito.Mockito.*;
+
+
+class Test06Matches {
+
+	private BookingService bookingService;
+	private PaymentService paymentServiceMock;
+	private RoomService roomServiceMock;
+	private BookingDAO bookingDAOMock;
+	private MailSender mailSenderMock;
+
+	@BeforeEach
+	void setup(){
+		paymentServiceMock = mock(PaymentService.class);
+		roomServiceMock = mock(RoomService.class);
+		bookingDAOMock = mock(BookingDAO.class);
+		mailSenderMock = mock(MailSender.class);
+		bookingService = new BookingService(paymentServiceMock, roomServiceMock, bookingDAOMock, mailSenderMock);
+	}
+
+	@Test
+	void should_CountAvailablePlaces_When_OneRoomAvailable() {
+		//given
+		BookingRequest bookingRequest = new BookingRequest("1", LocalDate.of(2021, 7, 8),
+				LocalDate.of(2021, 7, 18), 2, true);
+		BookingRequest bookingRequest2 = new BookingRequest("1", LocalDate.of(2021, 7, 8),
+				LocalDate.of(2021, 7, 18), 2, true);
+		when(paymentServiceMock.pay(any(), anyDouble()))
+				.thenThrow(BusinessException.class);
+		//when
+		Executable executable = () -> bookingService.makeBooking(bookingRequest2);
+		//then
+		assertThrows(BusinessException.class, executable);
+
+	}
+
+
+}

src/test/java/com/mockitotutorial/happyhotel/booking/Test07VerifyBehaviour.java

@@ -0,0 +1,58 @@
+package com.mockitotutorial.happyhotel.booking;
+
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+import java.time.LocalDate;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.mockito.Mockito.*;
+
+class Test07VerifyBehaviour {
+
+	private BookingService bookingService;
+	private PaymentService paymentServiceMock;
+	private RoomService roomServiceMock;
+	private BookingDAO bookingDAOMock;
+	private MailSender mailSenderMock;
+
+	@BeforeEach
+	void setup(){
+		paymentServiceMock = mock(PaymentService.class);
+		roomServiceMock = mock(RoomService.class);
+		bookingDAOMock = mock(BookingDAO.class);
+		mailSenderMock = mock(MailSender.class);
+		bookingService = new BookingService(paymentServiceMock, roomServiceMock, bookingDAOMock, mailSenderMock);
+	}
+	@Test
+	void should_CalculateCorrectPrice_When_CorrectInput() {
+		//given
+		BookingRequest bookingRequest = new BookingRequest("1", LocalDate.of(2021, 7, 1),
+				LocalDate.of(2021, 7, 5), 2, true);
+
+		//when
+		bookingService.makeBooking(bookingRequest);
+		//then
+//		verify(paymentServiceMock).pay(bookingRequest, 400); //gaat verifieren of die methode wordt aangeroepen.
+//		verify(paymentServiceMock, times(1)).pay(bookingRequest, 400);
+//		verify(paymentServiceMock, times(1)).pay(any(), anyDouble());
+		verify(paymentServiceMock, times(1)).pay(any(), eq(400));
+
+		verifyNoMoreInteractions(paymentServiceMock);
+	}
+
+	@Test
+	void should_NotInvokePayment_When_Not_Prepaid() {
+		//given
+		BookingRequest bookingRequest = new BookingRequest("1", LocalDate.of(2021, 7, 1),
+				LocalDate.of(2021, 7, 5), 2, false);
+
+		//when
+		bookingService.makeBooking(bookingRequest);
+		//then
+		verify(paymentServiceMock, never()).pay(any(), anyDouble());
+	}
+
+
+
+}

src/test/java/com/mockitotutorial/happyhotel/booking/Test08Spies.java

@@ -0,0 +1,42 @@
+package com.mockitotutorial.happyhotel.booking;
+
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+import java.time.LocalDate;
+
+import static org.mockito.Mockito.*;
+
+class Test08Spies {
+
+	private BookingService bookingService;
+	private PaymentService paymentServiceMock;
+	private RoomService roomServiceMock;
+	private BookingDAO bookingDAOMock;
+	private MailSender mailSenderMock;
+
+	@BeforeEach
+	void setup(){
+		paymentServiceMock = mock(PaymentService.class);
+		roomServiceMock = mock(RoomService.class);
+		bookingDAOMock = spy(BookingDAO.class); //verschil tussen Mock en Spy; Door daar een spy van te maken (nog steeds mock) maar ipv leeg te maken, is de functionaliteit overgenomen
+		mailSenderMock = mock(MailSender.class);
+		bookingService = new BookingService(paymentServiceMock, roomServiceMock, bookingDAOMock, mailSenderMock);
+	}
+	@Test
+	void should_CancelBooking_When_CorrectInput() {
+		//given
+		BookingRequest bookingRequest = new BookingRequest("1", LocalDate.of(2021, 7, 1),
+				LocalDate.of(2021, 7, 5), 2, true);
+
+		bookingRequest.setRoomId("1.3");
+		String bookingId = "1";
+
+		doReturn(bookingRequest).when(bookingDAOMock).get(bookingId);
+		//when
+		bookingService.cancelBooking(bookingId);
+		//then
+		verify(bookingDAOMock).delete(bookingId);
+	}
+
+}

src/test/java/com/mockitotutorial/happyhotel/booking/Test09TestingVoidMethods.java

@@ -0,0 +1,51 @@
+package com.mockitotutorial.happyhotel.booking;
+
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.function.Executable;
+
+import java.time.LocalDate;
+
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.mockito.Mockito.*;
+import static org.mockito.Mockito.when;
+
+class Test09TestingVoidMethods {
+
+	private BookingService bookingService;
+	private PaymentService paymentServiceMock;
+	private RoomService roomServiceMock;
+	private BookingDAO bookingDAOMock;
+	private MailSender mailSenderMock;
+
+	@BeforeEach
+	void setup(){
+		paymentServiceMock = mock(PaymentService.class);
+		roomServiceMock = mock(RoomService.class);
+		bookingDAOMock = mock(BookingDAO.class);
+		mailSenderMock = mock(MailSender.class);
+		bookingService = new BookingService(paymentServiceMock, roomServiceMock, bookingDAOMock, mailSenderMock);
+	}
+
+	@Test
+	void should_CountAvailablePlaces_When_OneRoomAvailable() {
+		//given
+		BookingRequest bookingRequest = new BookingRequest("1", LocalDate.of(2021, 7, 8),
+				LocalDate.of(2021, 7, 18), 2, false);
+
+//		when(roomServiceMock.findAvailableRoomId(any()))
+//				.thenThrow(BusinessException.class);
+//		when(mailSenderMock.sendBookingConfirmation(any())) //when-thenThrow werkt enkel als er een return value is.
+//				.thenThrow(BusinessException.class);
+
+		doThrow(new BusinessException()).when(mailSenderMock).sendBookingConfirmation(any()); //dit werkt wel bij een void methode
+
+		//when
+		Executable executable = () -> bookingService.makeBooking(bookingRequest);
+		//then
+		assertThrows(BusinessException.class, executable);
+
+	}
+
+
+}

src/test/java/com/mockitotutorial/happyhotel/booking/Test10ArgumentCaptors.java

@@ -0,0 +1,46 @@
+package com.mockitotutorial.happyhotel.booking;
+
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.mockito.ArgumentCaptor;
+
+import java.time.LocalDate;
+
+import static org.mockito.Mockito.*;
+
+class Test10ArgumentCaptors {
+
+	private BookingService bookingService;
+	private PaymentService paymentServiceMock;
+	private RoomService roomServiceMock;
+	private BookingDAO bookingDAOMock;
+	private MailSender mailSenderMock;
+	private ArgumentCaptor<Double> doubleCaptor;
+//	private ArgumentCaptor<BookingRequest> bookingRequestArgumentCaptor;
+
+
+	@BeforeEach
+	void setup(){
+		paymentServiceMock = mock(PaymentService.class);
+		roomServiceMock = mock(RoomService.class);
+		bookingDAOMock = mock(BookingDAO.class);
+		mailSenderMock = mock(MailSender.class);
+		bookingService = new BookingService(paymentServiceMock, roomServiceMock, bookingDAOMock, mailSenderMock);
+
+		this.doubleCaptor = ArgumentCaptor.forClass(Double.class);
+	}
+	@Test
+	void should_CalculateCorrectPrice_When_CorrectInput() {
+		//given
+		BookingRequest bookingRequest = new BookingRequest("1", LocalDate.of(2021, 7, 1),
+				LocalDate.of(2021, 7, 5), 2, true);
+
+		//when
+		bookingService.makeBooking(bookingRequest);
+		//then
+
+		verify(paymentServiceMock, times(1)).pay(any(), doubleCaptor.capture());
+		double captureArgument = doubleCaptor.getValue();
+		verifyNoMoreInteractions(paymentServiceMock);
+	}
+}