diff --git a/.gitignore b/.gitignore index 0c4ca8e..046a0aa 100644 --- a/.gitignore +++ b/.gitignore @@ -28,3 +28,4 @@ target # virtual machine crash logs, see http://www.java.com/en/download/help/error_hotspot.xml hs_err_pid* +*.idea diff --git a/MigrateToLatestJunit.md b/MigrateToLatestJunit.md new file mode 100644 index 0000000..5fab860 --- /dev/null +++ b/MigrateToLatestJunit.md @@ -0,0 +1,817 @@ +# Steps for Upgrading to Junit5 + +## Step1: Replace the following with Junit5 and `mockito-all` with `mockito-inline` + +**AS-IS** + +```xml + + + junit + junit + 4.12 + test + + + org.mockito + mockito-all + 1.10.19 + test + + +``` +**TO-BE** + +```xml + + + org.junit.jupiter + junit-jupiter + 5.10.2 + test + + + org.junit.jupiter + junit-jupiter-api + 5.10.2 + test + + + org.junit.platform + junit-platform-suite-engine + 1.10.2 + + + org.mockito + mockito-inline + 3.6.0 + test + + + org.hamcrest + hamcrest + 2.2 + test + + + org.mockito + mockito-core + 5.4.0 + test + + + org.mockito + mockito-junit-jupiter + 4.5.1 + test + + +``` +## Step2: Upgrade Java Compiler Version with the latest one under build section + +**AS-IS** +```xml + + + + org.apache.maven.plugins + maven-compiler-plugin + + 1.8 + 1.8 + + + + +``` +> `` and `` has been replaced with `` tag + +**TO-BE** +```xml + + + + org.apache.maven.plugins + maven-compiler-plugin + + 21 + + + + +``` + +## Step3: Changes in `ArraysCompareTest` class +Qualified PackageName has been changed + +**AS-IS** + +```java +import static org.junit.Assert.*; + +import org.junit.Test; +``` + +**TO-BE** +```java +import static org.junit.jupiter.api.Assertions.assertThrows; +import static org.junit.jupiter.api.Assertions.assertArrayEquals; + +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.Timeout; +``` + +### MethodName : testArraySort_NullArray + +**AS-IS** + +```java +@Test(expected=NullPointerException.class) +public void testArraySort_NullArray() { + int[] numbers = null; + Arrays.sort(numbers); +} +``` +###### Refactored using `assertThrows` and functional approach +**TO-BE** +```java +@Test +public void testArraySort_NullArray() { + assertThrows(NullPointerException.class, () -> { + int[] numbers = null; + Arrays.sort(numbers); + }); +} +``` + +### MethodName : testSort_Performance + +**AS-IS** + +```java +@Test(timeout=100) +``` +**TO-BE** +##### Added using `@TimeOut` annotation +```java +@Test +@Timeout(value = 100) +``` + +## Step4: Changes in `ArraysTest` class +Qualified PackageName has been changed + +**AS-IS** + +```java +import org.junit.Test; +``` +**TO-BE** + +```java +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.Timeout; +``` +### MethodName : testPerformance + +**AS-IS** + +```java +@Test(timeout=100) +``` +**TO-BE** +##### Added using `@TimeOut` annotation +```java +@Test +@Timeout(value = 100) +``` + +## Step4: Changes in `ClientBOTest` class +Qualified PackageName has been changed + +**AS-IS** +```java +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.fail; + +import org.junit.Test; +``` +**TO-BE** + +```java +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertThrows; + +import org.junit.jupiter.api.Test; +``` + +### MethodName : testClientProductSum1 + +**AS-IS** + +```java +@Test(expected = DifferentCurrenciesException.class) +public void testClientProductSum1() throws DifferentCurrenciesException { + + List products = new ArrayList(); + + products.add(new ProductImpl(100, "Product 15", + ProductType.BANK_GUARANTEE, new AmountImpl( + new BigDecimal("5.0"), Currency.INDIAN_RUPEE))); + + products.add(new ProductImpl(120, "Product 20", + ProductType.BANK_GUARANTEE, new AmountImpl( + new BigDecimal("6.0"), Currency.EURO))); + + @SuppressWarnings("unused") + Amount temp = null; + + temp = clientBO.getClientProductsSum(products); +} +``` +**TO-BE** +###### Refactored using `assertThrows` and functional approach + +```java +@Test +public void testClientProductSum1() throws DifferentCurrenciesException { + assertThrows(DifferentCurrenciesException.class, () -> { + + List products = new ArrayList(); + + products.add(new ProductImpl(100, "Product 15", + ProductType.BANK_GUARANTEE, new AmountImpl( + new BigDecimal("5.0"), Currency.INDIAN_RUPEE))); + + products.add(new ProductImpl(120, "Product 20", + ProductType.BANK_GUARANTEE, new AmountImpl( + new BigDecimal("6.0"), Currency.EURO))); + + @SuppressWarnings("unused") + Amount temp = null; + + temp = clientBO.getClientProductsSum(products); + }); +} +``` + +## Step5: Changes in `ClientBOTestRefactored` class +Qualified PackageName has been changed + +**AS-IS** +```java +import static org.junit.Assert.assertEquals; +``` +**TO-BE** +```java +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertThrows; // Newly Added + +import org.junit.jupiter.api.Test; +``` + +### MethodName : `testClientProductSum_DifferentCurrencies_ThrowsException` + +**AS-IS** + +```java +@Test(expected = DifferentCurrenciesException.class) +public void testClientProductSum_DifferentCurrencies_ThrowsException() + throws DifferentCurrenciesException { + + Amount[] amounts = { + new AmountImpl(new BigDecimal("5.0"), Currency.EURO), + new AmountImpl(new BigDecimal("6.0"), Currency.INDIAN_RUPEE) }; + + List products = createProductListWithAmounts(amounts); + + @SuppressWarnings("unused") + Amount actual = clientBO.getClientProductsSum(products); + +} +``` +**TO-BE** +###### Refactored using `assertThrows` and functional approach + +```java +@Test +public void testClientProductSum_DifferentCurrencies_ThrowsException() + throws DifferentCurrenciesException { + assertThrows(DifferentCurrenciesException.class, () -> { + + Amount[] amounts = { + new AmountImpl(new BigDecimal("5.0"), Currency.EURO), + new AmountImpl(new BigDecimal("6.0"), Currency.INDIAN_RUPEE)}; + + List products = createProductListWithAmounts(amounts); + + @SuppressWarnings("unused") + Amount actual = clientBO.getClientProductsSum(products); + + }); + +} +``` + +## Step6: Changes in `DummyTestSuite` class +Qualified PackageName has been changed + +**AS-IS** + +```java +import org.junit.runner.RunWith; +import org.junit.runners.Suite; +import org.junit.runners.Suite.SuiteClasses; +``` +**TO-BE** + +```java +import org.junit.platform.suite.api.SelectClasses; +import org.junit.platform.suite.api.Suite; +``` + +**AS-IS** + +```java +@RunWith(Suite.class) +@SuiteClasses({ArraysTest.class,StringHelperTest.class}) +``` +**TO-BE** + +```java +@Suite +@SelectClasses({ArraysTest.class,StringHelperTest.class}) +``` + +## Step6: Changes in `FirstMockitoTest` class +Qualified PackageName has been changed + +**AS-IS** + +```java +import static org.junit.Assert.assertTrue; + +import org.junit.Test; +``` +**TO-BE** + +```java +import static org.junit.jupiter.api.Assertions.assertTrue; + +import org.junit.jupiter.api.Test; +``` + +## Step7: Changes in `HamcrestMatcherTest` class +Qualified PackageName has been changed + +**AS-IS** + +```java +import org.junit.Test; +``` +**TO-BE** + +```java +import org.junit.jupiter.api.Test; +``` + +## Step8: Changes in `ListTest` class +Qualified PackageName has been changed + +**AS-IS** + +```java +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertNull; +import static org.junit.Assert.assertThat; + +import org.junit.Test; +``` +**TO-BE** + +```java +import static org.hamcrest.MatcherAssert.assertThat; +import static org.junit.jupiter.api.Assertions.*; + +import org.junit.jupiter.api.Test; +``` + +### MethodName : `letsMockListGetToThrowException` + +**AS-IS** + +```java +@Test(expected = RuntimeException.class) +public void letsMockListGetToThrowException() { + List list = mock(List.class); + when(list.get(Mockito.anyInt())).thenThrow( + new RuntimeException("Something went wrong")); + list.get(0); +} +``` +**TO-BE** +###### Refactored using `assertThrows` and functional approach + +```java +@Test +public void letsMockListGetToThrowException() { + assertThrows(RuntimeException.class, () -> { + List list = mock(List.class); + when(list.get(Mockito.anyInt())).thenThrow( + new RuntimeException("Something went wrong")); + list.get(0); + }); +} +``` + +## Step9: Changes in `PowerMockitoMockingStaticMethodTest` class +#### Class Name `PowerMockitoMockingStaticMethodTest` has been changed to `MockitoMockingStaticMethodTest` + +Qualified PackageName has been changed + +**AS-IS** + +```java +import static org.junit.Assert.assertEquals; +import static org.mockito.Matchers.anyLong; +import static org.mockito.Mockito.when; + +import org.junit.Test; +import org.junit.runner.RunWith; + +import org.powermock.api.mockito.PowerMockito; +import org.powermock.core.classloader.annotations.PrepareForTest; +import org.powermock.modules.junit4.PowerMockRunner; +``` +**TO-BE** + +```java +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.mockito.ArgumentMatchers.anyLong; +import static org.mockito.Mockito.*; + +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.extension.ExtendWith; + +import org.mockito.MockedStatic; +import org.mockito.junit.jupiter.MockitoExtension; +``` + +**AS-IS** +```java +@RunWith(PowerMockRunner.class) +@PrepareForTest({ UtilityClass.class /*The class with static method to be mocked*/}) +``` +**TO-BE** + +```java +@ExtendWith(MockitoExtension.class) +``` +### MethodName : `powerMockito_MockingAStaticMethodCall` + +**AS-IS** + +```java +@Test +public void powerMockito_MockingAStaticMethodCall() { + + when(dependencyMock.retrieveAllStats()).thenReturn( + Arrays.asList(1, 2, 3)); + + PowerMockito.mockStatic(UtilityClass.class); + + when(UtilityClass.staticMethod(anyLong())).thenReturn(150); + + assertEquals(150, systemUnderTest.methodCallingAStaticMethod()); + + //To verify a specific method call + //First : Call PowerMockito.verifyStatic() + //Second : Call the method to be verified + PowerMockito.verifyStatic(); + UtilityClass.staticMethod(1 + 2 + 3); + + // verify exact number of calls + //PowerMockito.verifyStatic(Mockito.times(1)); + +} +``` +**TO-BE** +###### Refactored using `mockStatic` and functional approach + +```java +@Test +public void powerMockito_MockingAStaticMethodCall() { + when(dependencyMock.retrieveAllStats()).thenReturn(Arrays.asList(1, 2, 3)); + + MockedStatic mockedStatic = mockStatic(UtilityClass.class); + + mockedStatic.when(() -> UtilityClass.staticMethod(anyLong())).thenReturn(150); + + assertEquals(150, systemUnderTest.methodCallingAStaticMethod()); + + mockedStatic.verify(() -> UtilityClass.staticMethod(1 + 2 + 3), times(1)); +} +``` +## Step10: Changes in `PowerMockitoTestingPrivateMethodTest` class +Qualified PackageName has been changed + +**AS-IS** + +```java +import static org.junit.Assert.assertEquals; + +import org.junit.Test; +import org.junit.runner.RunWith; + +import org.powermock.modules.junit4.PowerMockRunner; +import org.powermock.reflect.Whitebox; +``` +**TO-BE** + +```java +import static org.junit.jupiter.api.Assertions.assertEquals; + +import java.lang.reflect.Method; // Added + +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.extension.ExtendWith; + +import org.mockito.junit.jupiter.MockitoExtension; +``` + +**AS-IS** +```java +@RunWith(PowerMockRunner.class) +``` +**TO-BE** + +```java +@ExtendWith(MockitoExtension.class) +``` + +### MethodName : `powerMockito_MockingAStaticMethodCall` + +**AS-IS** +```java +when(dependencyMock.retrieveAllStats()).thenReturn( + Arrays.asList(1, 2, 3)); +long value = (Long) Whitebox.invokeMethod(systemUnderTest, + "privateMethodUnderTest"); +assertEquals(6, value); +``` +**TO-BE** + +```java +Method method = systemUnderTest.getClass().getDeclaredMethod("privateMethodUnderTest"); +method.setAccessible(true); +when(dependencyMock.retrieveAllStats()).thenReturn(Arrays.asList(1, 2, 3)); +long value = (Long) method.invoke(systemUnderTest); +assertEquals(6, value); +``` +## Step11: Changes in `QuickBeforeAfterTest` class +Qualified PackageName has been changed + +**AS-IS** + +```java +import static org.junit.Assert.*; + +import org.junit.After; +import org.junit.AfterClass; +import org.junit.Before; +import org.junit.BeforeClass; +import org.junit.Test; +``` +**TO-BE** + +```java +import org.junit.jupiter.api.AfterAll; +import org.junit.jupiter.api.AfterEach; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +``` + +### Annotations used in this class has been changed from + +* @BeforeClass > @BeforeAll +* @Before > @BeforeEach +* @After > @AfterEach +* @AfterClass > @AfterAll + +## Step12: Changes in `SpyTest` class +Qualified PackageName has been changed + +**AS-IS** + +```java +import static org.junit.Assert.assertEquals; + +import static org.mockito.Mockito.stub; // Removed + +import org.junit.Test; + +``` +**TO-BE** + +```java +import static org.junit.jupiter.api.Assertions.assertEquals; + +import org.junit.jupiter.api.Test; +``` + +### Removed method name `creatingASpyOnArrayList_overridingSpecificMethods` + + +## Step13: Changes in `StringHelperParameterizedTest` class +Qualified PackageName has been changed + +**AS-IS** + +```java +import static org.junit.Assert.*; + +import org.junit.Before; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.junit.runners.Parameterized; +import org.junit.runners.Parameterized.Parameters; + +``` +**TO-BE** + +```java +import static org.junit.jupiter.api.Assertions.assertEquals; + +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.MethodSource; +``` + +2. Removed `@RunWith(Parameterized.class)` in the class level +3. Change in the constructor + +**AS-IS** +```java +public StringHelperParameterizedTest(String input, String expectedOutput) { + this.input = input; + this.expectedOutput = expectedOutput; +} +``` +**TO-BE** + +```java +public void initStringHelperParameterizedTest(String input, String expectedOutput) { + this.input = input; + this.expectedOutput = expectedOutput; +} +``` +4. Remove `@Parameters` in `testConditions` method +5. Refactor `testTruncateAInFirst2Positions` method + +**AS-IS** + +```java +@Test +public void testTruncateAInFirst2Positions() { + assertEquals(expectedOutput, + helper.truncateAInFirst2Positions(input)); +} +``` +**TO_BE** + +```java +@MethodSource("testConditions") +@ParameterizedTest +public void truncateAInFirst2Positions(String input, String expectedOutput) { + initStringHelperParameterizedTest(input, expectedOutput); + assertEquals(expectedOutput, helper.truncateAInFirst2Positions(input)); +} +``` + +## Step14: Changes in `StringHelperTest` class +Qualified PackageName has been changed + +**AS-IS** + +```java +import static org.junit.Assert.*; + +import org.junit.Before; +import org.junit.Test; + +``` +**TO-BE** + +```java +import static org.junit.jupiter.api.Assertions.*; + +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +``` + +### Annotations used in this class has been changed from + +* @Before > @BeforeEach + +## Step15: Changes in `TodoBusinessImplMockitoInjectMocksTest` class +Qualified PackageName has been changed + +**AS-IS** + +```java +import org.junit.Test; +import org.junit.runner.RunWith; + +import org.mockito.runners.MockitoJUnitRunner; +``` +**TO-BE** + +```java +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.extension.ExtendWith; + +import org.mockito.junit.jupiter.MockitoExtension; +``` +**AS-IS** +```java +@RunWith(PowerMockRunner.class) +``` +**TO-BE** + +```java +@ExtendWith(MockitoExtension.class) +``` + +## Step16: Changes in `TodoBusinessImplMockitoRulesTest` class +Qualified PackageName has been changed + +**AS-IS** + +```java +import org.junit.Rule; // Removed +import org.junit.Test; + +import org.mockito.junit.MockitoJUnit; // Removed +import org.mockito.junit.MockitoRule; // Removed +``` +**TO-BE** + +```java +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.extension.ExtendWith; + +import org.mockito.junit.jupiter.MockitoExtension; +``` + +**AS-IS** +```java +@RunWith(PowerMockRunner.class) +``` +**TO-BE** + +```java +@ExtendWith(MockitoExtension.class) +``` + +### Removed this +```java +@Rule +public MockitoRule mockitoRule = MockitoJUnit.rule(); +``` + +## Step17: Changes in `TodoBusinessImplMockitoTest` class +Qualified PackageName has been changed + +**AS-IS** + +```java +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertThat; + +import org.junit.Test; +``` +**TO-BE** +```java +import static org.hamcrest.MatcherAssert.assertThat; +import static org.junit.jupiter.api.Assertions.assertEquals; + +import org.junit.jupiter.api.Test; +``` + +## Step18: Changes in `TodoBusinessImplStubTest` class +Qualified PackageName has been changed + +**AS-IS** +```java +import static org.junit.Assert.assertEquals; + +import org.junit.Test; +``` +**TO-BE** +```java +import static org.junit.jupiter.api.Assertions.assertEquals; + +import org.junit.jupiter.api.Test; +``` + +### Happy Learning @in28minutes \ No newline at end of file diff --git a/Step01.md b/Step01.md index 2fa52d4..96adb01 100644 --- a/Step01.md +++ b/Step01.md @@ -10,17 +10,28 @@ ``` - junit - junit - 4.12 - test - - - org.mockito - mockito-all - 1.10.19 - test - + org.junit.jupiter + junit-jupiter + 5.10.2 + test + + + org.junit.jupiter + junit-jupiter-api + 5.10.2 + test + + + org.junit.platform + junit-platform-suite-engine + 1.10.2 + + + org.mockito + mockito-inline + 3.6.0 + test + ``` ## Files List @@ -34,15 +45,26 @@ 0.0.1-SNAPSHOT - junit - junit - 4.12 + org.junit.jupiter + junit-jupiter + 5.10.2 + test + + + org.junit.jupiter + junit-jupiter-api + 5.10.2 test + + org.junit.platform + junit-platform-suite-engine + 1.10.2 + org.mockito - mockito-all - 1.10.19 + mockito-inline + 3.6.0 test @@ -52,9 +74,9 @@ ``` package com.in28minutes.mockito; -import static org.junit.Assert.assertTrue; +import static org.junit.jupiter.api.Assertions.assertTrue; -import org.junit.Test; +import org.junit.jupiter.api.Test; public class FirstMockitoTest { diff --git a/Step02.md b/Step02.md index 6f1816d..56908e5 100644 --- a/Step02.md +++ b/Step02.md @@ -14,15 +14,26 @@ 0.0.1-SNAPSHOT - junit - junit - 4.12 + org.junit.jupiter + junit-jupiter + 5.10.2 test + + org.junit.jupiter + junit-jupiter-api + 5.10.2 + test + + + org.junit.platform + junit-platform-suite-engine + 1.10.2 + org.mockito - mockito-all - 1.10.19 + mockito-inline + 3.6.0 test @@ -71,9 +82,9 @@ public interface TodoService { ``` package com.in28minutes.mockito; -import static org.junit.Assert.assertTrue; +import static org.junit.jupiter.api.Assertions.assertTrue; -import org.junit.Test; +import org.junit.jupiter.api.Test; public class FirstMockitoTest { diff --git a/Step03.md b/Step03.md index 01ffe38..0cfcc5a 100644 --- a/Step03.md +++ b/Step03.md @@ -17,15 +17,26 @@ 0.0.1-SNAPSHOT - junit - junit - 4.12 + org.junit.jupiter + junit-jupiter + 5.10.2 test + + org.junit.jupiter + junit-jupiter-api + 5.10.2 + test + + + org.junit.platform + junit-platform-suite-engine + 1.10.2 + org.mockito - mockito-all - 1.10.19 + mockito-inline + 3.6.0 test @@ -74,13 +85,13 @@ public interface TodoService { ``` package com.in28minutes.business; -import static org.junit.Assert.assertEquals; +import static org.junit.jupiter.api.Assertions.assertEquals; import java.util.List; -import org.junit.Test; - import com.in28minutes.data.api.TodoService; + +import org.junit.jupiter.api.Test; import com.in28minutes.data.stub.TodoServiceStub; public class TodoBusinessImplStubTest { @@ -94,6 +105,7 @@ public class TodoBusinessImplStubTest { assertEquals(2, todos.size()); } } + ``` ### /src/test/java/com/in28minutes/data/stub/TodoServiceStub.java ``` @@ -115,9 +127,9 @@ public class TodoServiceStub implements TodoService { ``` package com.in28minutes.mockito; -import static org.junit.Assert.assertTrue; +import static org.junit.jupiter.api.Assertions.assertTrue; -import org.junit.Test; +import org.junit.jupiter.api.Test; public class FirstMockitoTest { diff --git a/Step04.md b/Step04.md index b228cc7..e7fa6ec 100644 --- a/Step04.md +++ b/Step04.md @@ -28,15 +28,26 @@ org.hamcrest.CoreMatchers 0.0.1-SNAPSHOT - junit - junit - 4.12 + org.junit.jupiter + junit-jupiter + 5.10.2 test + + org.junit.jupiter + junit-jupiter-api + 5.10.2 + test + + + org.junit.platform + junit-platform-suite-engine + 1.10.2 + org.mockito - mockito-all - 1.10.19 + mockito-inline + 3.6.0 test @@ -85,14 +96,18 @@ public interface TodoService { ``` package com.in28minutes.business; -import static org.junit.Assert.assertEquals; +import static org.hamcrest.CoreMatchers.is; +import static org.hamcrest.MatcherAssert.assertThat; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.mockito.BDDMockito.given; import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.verify; import static org.mockito.Mockito.when; import java.util.Arrays; import java.util.List; -import org.junit.Test; +import org.junit.jupiter.api.Test; import com.in28minutes.data.api.TodoService; @@ -115,13 +130,13 @@ public class TodoBusinessImplMockitoTest { ``` package com.in28minutes.business; -import static org.junit.Assert.assertEquals; +import static org.junit.jupiter.api.Assertions.assertEquals; import java.util.List; -import org.junit.Test; - import com.in28minutes.data.api.TodoService; + +import org.junit.jupiter.api.Test; import com.in28minutes.data.stub.TodoServiceStub; public class TodoBusinessImplStubTest { @@ -156,9 +171,9 @@ public class TodoServiceStub implements TodoService { ``` package com.in28minutes.mockito; -import static org.junit.Assert.assertTrue; +import static org.junit.jupiter.api.Assertions.assertTrue; -import org.junit.Test; +import org.junit.jupiter.api.Test; public class FirstMockitoTest { diff --git a/Step05.md b/Step05.md index 36ddaf5..05e13a1 100644 --- a/Step05.md +++ b/Step05.md @@ -22,15 +22,26 @@ 0.0.1-SNAPSHOT - junit - junit - 4.12 + org.junit.jupiter + junit-jupiter + 5.10.2 test + + org.junit.jupiter + junit-jupiter-api + 5.10.2 + test + + + org.junit.platform + junit-platform-suite-engine + 1.10.2 + org.mockito - mockito-all - 1.10.19 + mockito-inline + 3.6.0 test @@ -79,14 +90,18 @@ public interface TodoService { ``` package com.in28minutes.business; -import static org.junit.Assert.assertEquals; +import static org.hamcrest.CoreMatchers.is; +import static org.hamcrest.MatcherAssert.assertThat; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.mockito.BDDMockito.given; import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.verify; import static org.mockito.Mockito.when; import java.util.Arrays; import java.util.List; -import org.junit.Test; +import org.junit.jupiter.api.Test; import com.in28minutes.data.api.TodoService; @@ -109,13 +124,13 @@ public class TodoBusinessImplMockitoTest { ``` package com.in28minutes.business; -import static org.junit.Assert.assertEquals; +import static org.junit.jupiter.api.Assertions.assertEquals; import java.util.List; -import org.junit.Test; - import com.in28minutes.data.api.TodoService; + +import org.junit.jupiter.api.Test; import com.in28minutes.data.stub.TodoServiceStub; public class TodoBusinessImplStubTest { @@ -150,9 +165,9 @@ public class TodoServiceStub implements TodoService { ``` package com.in28minutes.mockito; -import static org.junit.Assert.assertTrue; +import static org.junit.jupiter.api.Assertions.assertTrue; -import org.junit.Test; +import org.junit.jupiter.api.Test; public class FirstMockitoTest { @@ -167,13 +182,16 @@ public class FirstMockitoTest { ``` package com.in28minutes.mockito; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertNull; +import static org.hamcrest.CoreMatchers.is; +import static org.hamcrest.MatcherAssert.assertThat; +import static org.junit.jupiter.api.Assertions.*; +import static org.mockito.BDDMockito.given; import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.when; import java.util.List; -import org.junit.Test; +import org.junit.jupiter.api.Test; import org.mockito.Mockito; public class ListTest { @@ -181,14 +199,14 @@ public class ListTest { @Test public void letsMockListSize() { List list = mock(List.class); - Mockito.when(list.size()).thenReturn(10); + when(list.size()).thenReturn(10); assertEquals(10, list.size()); } @Test public void letsMockListSizeWithMultipleReturnValues() { List list = mock(List.class); - Mockito.when(list.size()).thenReturn(10).thenReturn(20); + when(list.size()).thenReturn(10).thenReturn(20); assertEquals(10, list.size()); // First Call assertEquals(20, list.size()); // Second Call } @@ -196,11 +214,21 @@ public class ListTest { @Test public void letsMockListGet() { List list = mock(List.class); - Mockito.when(list.get(0)).thenReturn("in28Minutes"); + when(list.get(0)).thenReturn("in28Minutes"); assertEquals("in28Minutes", list.get(0)); assertNull(list.get(1)); } + @Test + public void letsMockListGetToThrowException() { + assertThrows(RuntimeException.class, () -> { + List list = mock(List.class); + when(list.get(Mockito.anyInt())).thenThrow( + new RuntimeException("Something went wrong")); + list.get(0); + }); + } + @Test public void letsMockListGetWithAny() { List list = mock(List.class); diff --git a/Step06.md b/Step06.md index b95711d..3bdf653 100644 --- a/Step06.md +++ b/Step06.md @@ -20,15 +20,26 @@ BDD : [BDD Reference](http://en.wikipedia.org/wiki/Behavior_Driven_Development) 0.0.1-SNAPSHOT - junit - junit - 4.12 + org.junit.jupiter + junit-jupiter + 5.10.2 test + + org.junit.jupiter + junit-jupiter-api + 5.10.2 + test + + + org.junit.platform + junit-platform-suite-engine + 1.10.2 + org.mockito - mockito-all - 1.10.19 + mockito-inline + 3.6.0 test @@ -78,16 +89,17 @@ public interface TodoService { package com.in28minutes.business; import static org.hamcrest.CoreMatchers.is; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertThat; +import static org.hamcrest.MatcherAssert.assertThat; +import static org.junit.jupiter.api.Assertions.assertEquals; import static org.mockito.BDDMockito.given; import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.verify; import static org.mockito.Mockito.when; import java.util.Arrays; import java.util.List; -import org.junit.Test; +import org.junit.jupiter.api.Test; import com.in28minutes.data.api.TodoService; @@ -104,7 +116,7 @@ public class TodoBusinessImplMockitoTest { .retrieveTodosRelatedToSpring("Ranga"); assertEquals(2, todos.size()); } - + @Test public void usingMockito_UsingBDD() { TodoService todoService = mock(TodoService.class); @@ -122,20 +134,19 @@ public class TodoBusinessImplMockitoTest { //then assertThat(todos.size(), is(2)); } - } ``` ### /src/test/java/com/in28minutes/business/TodoBusinessImplStubTest.java ``` package com.in28minutes.business; -import static org.junit.Assert.assertEquals; +import static org.junit.jupiter.api.Assertions.assertEquals; import java.util.List; -import org.junit.Test; - import com.in28minutes.data.api.TodoService; + +import org.junit.jupiter.api.Test; import com.in28minutes.data.stub.TodoServiceStub; public class TodoBusinessImplStubTest { @@ -170,9 +181,9 @@ public class TodoServiceStub implements TodoService { ``` package com.in28minutes.mockito; -import static org.junit.Assert.assertTrue; +import static org.junit.jupiter.api.Assertions.assertTrue; -import org.junit.Test; +import org.junit.jupiter.api.Test; public class FirstMockitoTest { @@ -188,15 +199,15 @@ public class FirstMockitoTest { package com.in28minutes.mockito; import static org.hamcrest.CoreMatchers.is; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertNull; -import static org.junit.Assert.assertThat; +import static org.hamcrest.MatcherAssert.assertThat; +import static org.junit.jupiter.api.Assertions.*; import static org.mockito.BDDMockito.given; import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.when; import java.util.List; -import org.junit.Test; +import org.junit.jupiter.api.Test; import org.mockito.Mockito; public class ListTest { @@ -204,14 +215,14 @@ public class ListTest { @Test public void letsMockListSize() { List list = mock(List.class); - Mockito.when(list.size()).thenReturn(10); + when(list.size()).thenReturn(10); assertEquals(10, list.size()); } @Test public void letsMockListSizeWithMultipleReturnValues() { List list = mock(List.class); - Mockito.when(list.size()).thenReturn(10).thenReturn(20); + when(list.size()).thenReturn(10).thenReturn(20); assertEquals(10, list.size()); // First Call assertEquals(20, list.size()); // Second Call } @@ -219,11 +230,21 @@ public class ListTest { @Test public void letsMockListGet() { List list = mock(List.class); - Mockito.when(list.get(0)).thenReturn("in28Minutes"); + when(list.get(0)).thenReturn("in28Minutes"); assertEquals("in28Minutes", list.get(0)); assertNull(list.get(1)); } + @Test + public void letsMockListGetToThrowException() { + assertThrows(RuntimeException.class, () -> { + List list = mock(List.class); + when(list.get(Mockito.anyInt())).thenThrow( + new RuntimeException("Something went wrong")); + list.get(0); + }); + } + @Test public void letsMockListGetWithAny() { List list = mock(List.class); diff --git a/Step07.md b/Step07.md index be63357..41bddd9 100644 --- a/Step07.md +++ b/Step07.md @@ -20,15 +20,26 @@ verify(todoService, Mockito.never()).deleteTodo("Learn Spring MVC"); 0.0.1-SNAPSHOT - junit - junit - 4.12 + org.junit.jupiter + junit-jupiter + 5.10.2 test + + org.junit.jupiter + junit-jupiter-api + 5.10.2 + test + + + org.junit.platform + junit-platform-suite-engine + 1.10.2 + org.mockito - mockito-all - 1.10.19 + mockito-inline + 3.6.0 test @@ -91,8 +102,8 @@ public interface TodoService { package com.in28minutes.business; import static org.hamcrest.CoreMatchers.is; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertThat; +import static org.hamcrest.MatcherAssert.assertThat; +import static org.junit.jupiter.api.Assertions.assertEquals; import static org.mockito.BDDMockito.given; import static org.mockito.Mockito.mock; import static org.mockito.Mockito.verify; @@ -101,8 +112,7 @@ import static org.mockito.Mockito.when; import java.util.Arrays; import java.util.List; -import org.junit.Test; -import org.mockito.Mockito; +import org.junit.jupiter.api.Test; import com.in28minutes.data.api.TodoService; @@ -119,7 +129,7 @@ public class TodoBusinessImplMockitoTest { .retrieveTodosRelatedToSpring("Ranga"); assertEquals(2, todos.size()); } - + @Test public void usingMockito_UsingBDD() { TodoService todoService = mock(TodoService.class); @@ -137,7 +147,7 @@ public class TodoBusinessImplMockitoTest { //then assertThat(todos.size(), is(2)); } - + @Test public void letsTestDeleteNow() { @@ -168,13 +178,13 @@ public class TodoBusinessImplMockitoTest { ``` package com.in28minutes.business; -import static org.junit.Assert.assertEquals; +import static org.junit.jupiter.api.Assertions.assertEquals; import java.util.List; -import org.junit.Test; - import com.in28minutes.data.api.TodoService; + +import org.junit.jupiter.api.Test; import com.in28minutes.data.stub.TodoServiceStub; public class TodoBusinessImplStubTest { @@ -213,9 +223,9 @@ public class TodoServiceStub implements TodoService { ``` package com.in28minutes.mockito; -import static org.junit.Assert.assertTrue; +import static org.junit.jupiter.api.Assertions.assertTrue; -import org.junit.Test; +import org.junit.jupiter.api.Test; public class FirstMockitoTest { @@ -231,16 +241,15 @@ public class FirstMockitoTest { package com.in28minutes.mockito; import static org.hamcrest.CoreMatchers.is; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertNull; -import static org.junit.Assert.assertThat; +import static org.hamcrest.MatcherAssert.assertThat; +import static org.junit.jupiter.api.Assertions.*; import static org.mockito.BDDMockito.given; import static org.mockito.Mockito.mock; import static org.mockito.Mockito.when; import java.util.List; -import org.junit.Test; +import org.junit.jupiter.api.Test; import org.mockito.Mockito; public class ListTest { @@ -268,12 +277,14 @@ public class ListTest { assertNull(list.get(1)); } - @Test(expected = RuntimeException.class) + @Test public void letsMockListGetToThrowException() { - List list = mock(List.class); - when(list.get(Mockito.anyInt())).thenThrow( - new RuntimeException("Something went wrong")); - list.get(0); + assertThrows(RuntimeException.class, () -> { + List list = mock(List.class); + when(list.get(Mockito.anyInt())).thenThrow( + new RuntimeException("Something went wrong")); + list.get(0); + }); } @Test diff --git a/Step08.md b/Step08.md index 6d7f188..641a5c1 100644 --- a/Step08.md +++ b/Step08.md @@ -6,18 +6,20 @@ First Snippet ``` @Test public void captureArgument() { - ArgumentCaptor argumentCaptor = ArgumentCaptor.forClass(String.class); + ArgumentCaptor argumentCaptor = ArgumentCaptor + .forClass(String.class); - TodoService todoService = mock(TodoService.class); + TodoService todoService = mock(TodoService.class); - List allTodos = Arrays.asList("Learn Spring MVC", "Learn Spring", "Learn to Dance"); - Mockito.when(todoService.retrieveTodos("Ranga")).thenReturn(allTodos); + List allTodos = Arrays.asList("Learn Spring MVC", + "Learn Spring", "Learn to Dance"); + Mockito.when(todoService.retrieveTodos("Ranga")).thenReturn(allTodos); - TodoBusinessImpl todoBusinessImpl = new TodoBusinessImpl(todoService); - todoBusinessImpl.deleteTodosNotRelatedToSpring("Ranga"); - Mockito.verify(todoService).deleteTodo(argumentCaptor.capture()); + TodoBusinessImpl todoBusinessImpl = new TodoBusinessImpl(todoService); + todoBusinessImpl.deleteTodosNotRelatedToSpring("Ranga"); + Mockito.verify(todoService).deleteTodo(argumentCaptor.capture()); - assertEquals("Learn to Dance", argumentCaptor.getValue()); + assertEquals("Learn to Dance", argumentCaptor.getValue()); } ``` ## Files List @@ -31,15 +33,26 @@ First Snippet 0.0.1-SNAPSHOT - junit - junit - 4.12 + org.junit.jupiter + junit-jupiter + 5.10.2 test + + org.junit.jupiter + junit-jupiter-api + 5.10.2 + test + + + org.junit.platform + junit-platform-suite-engine + 1.10.2 + org.mockito - mockito-all - 1.10.19 + mockito-inline + 3.6.0 test @@ -102,8 +115,8 @@ public interface TodoService { package com.in28minutes.business; import static org.hamcrest.CoreMatchers.is; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertThat; +import static org.hamcrest.MatcherAssert.assertThat; +import static org.junit.jupiter.api.Assertions.assertEquals; import static org.mockito.BDDMockito.given; import static org.mockito.Mockito.mock; import static org.mockito.Mockito.verify; @@ -112,9 +125,7 @@ import static org.mockito.Mockito.when; import java.util.Arrays; import java.util.List; -import org.junit.Test; -import org.mockito.ArgumentCaptor; -import org.mockito.Mockito; +import org.junit.jupiter.api.Test; import com.in28minutes.data.api.TodoService; @@ -131,7 +142,7 @@ public class TodoBusinessImplMockitoTest { .retrieveTodosRelatedToSpring("Ranga"); assertEquals(2, todos.size()); } - + @Test public void usingMockito_UsingBDD() { TodoService todoService = mock(TodoService.class); @@ -149,7 +160,7 @@ public class TodoBusinessImplMockitoTest { //then assertThat(todos.size(), is(2)); } - + @Test public void letsTestDeleteNow() { @@ -174,37 +185,19 @@ public class TodoBusinessImplMockitoTest { // atLeastOnce, atLeast } - - @Test - public void captureArgument() { - ArgumentCaptor argumentCaptor = ArgumentCaptor - .forClass(String.class); - - TodoService todoService = mock(TodoService.class); - - List allTodos = Arrays.asList("Learn Spring MVC", - "Learn Spring", "Learn to Dance"); - Mockito.when(todoService.retrieveTodos("Ranga")).thenReturn(allTodos); - - TodoBusinessImpl todoBusinessImpl = new TodoBusinessImpl(todoService); - todoBusinessImpl.deleteTodosNotRelatedToSpring("Ranga"); - Mockito.verify(todoService).deleteTodo(argumentCaptor.capture()); - - assertEquals("Learn to Dance", argumentCaptor.getValue()); - } } ``` ### /src/test/java/com/in28minutes/business/TodoBusinessImplStubTest.java ``` package com.in28minutes.business; -import static org.junit.Assert.assertEquals; +import static org.junit.jupiter.api.Assertions.assertEquals; import java.util.List; -import org.junit.Test; - import com.in28minutes.data.api.TodoService; + +import org.junit.jupiter.api.Test; import com.in28minutes.data.stub.TodoServiceStub; public class TodoBusinessImplStubTest { @@ -218,6 +211,7 @@ public class TodoBusinessImplStubTest { assertEquals(2, todos.size()); } } + ``` ### /src/test/java/com/in28minutes/data/stub/TodoServiceStub.java ``` @@ -243,9 +237,9 @@ public class TodoServiceStub implements TodoService { ``` package com.in28minutes.mockito; -import static org.junit.Assert.assertTrue; +import static org.junit.jupiter.api.Assertions.assertTrue; -import org.junit.Test; +import org.junit.jupiter.api.Test; public class FirstMockitoTest { @@ -261,16 +255,15 @@ public class FirstMockitoTest { package com.in28minutes.mockito; import static org.hamcrest.CoreMatchers.is; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertNull; -import static org.junit.Assert.assertThat; +import static org.hamcrest.MatcherAssert.assertThat; +import static org.junit.jupiter.api.Assertions.*; import static org.mockito.BDDMockito.given; import static org.mockito.Mockito.mock; import static org.mockito.Mockito.when; import java.util.List; -import org.junit.Test; +import org.junit.jupiter.api.Test; import org.mockito.Mockito; public class ListTest { @@ -298,12 +291,14 @@ public class ListTest { assertNull(list.get(1)); } - @Test(expected = RuntimeException.class) + @Test public void letsMockListGetToThrowException() { - List list = mock(List.class); - when(list.get(Mockito.anyInt())).thenThrow( - new RuntimeException("Something went wrong")); - list.get(0); + assertThrows(RuntimeException.class, () -> { + List list = mock(List.class); + when(list.get(Mockito.anyInt())).thenThrow( + new RuntimeException("Something went wrong")); + list.get(0); + }); } @Test diff --git a/Step09.md b/Step09.md index b60fd23..d35ab4d 100644 --- a/Step09.md +++ b/Step09.md @@ -10,11 +10,29 @@ import static org.hamcrest.CoreMatchers.hasItems; - First Snippet ``` - org.hamcrest - hamcrest-library - 1.3 - test - + org.hamcrest + hamcrest + 2.2 + test + + + org.mockito + mockito-core + 5.4.0 + test + + + org.mockito + mockito-junit-jupiter + 4.5.1 + test + + + org.hamcrest + hamcrest-library + 1.3 + test + ``` - Code Snippets @@ -40,23 +58,52 @@ import static org.hamcrest.CoreMatchers.hasItems; 0.0.1-SNAPSHOT - junit - junit - 4.12 + org.junit.jupiter + junit-jupiter + 5.10.2 + test + + + org.junit.jupiter + junit-jupiter-api + 5.10.2 test + + org.junit.platform + junit-platform-suite-engine + 1.10.2 + org.mockito - mockito-all - 1.10.19 + mockito-inline + 3.6.0 test - - org.hamcrest - hamcrest-library - 1.3 - test - + + org.hamcrest + hamcrest + 2.2 + test + + + org.mockito + mockito-core + 5.4.0 + test + + + org.mockito + mockito-junit-jupiter + 4.5.1 + test + + + org.hamcrest + hamcrest-library + 1.3 + test + ``` @@ -117,8 +164,8 @@ public interface TodoService { package com.in28minutes.business; import static org.hamcrest.CoreMatchers.is; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertThat; +import static org.hamcrest.MatcherAssert.assertThat; +import static org.junit.jupiter.api.Assertions.assertEquals; import static org.mockito.BDDMockito.given; import static org.mockito.Mockito.mock; import static org.mockito.Mockito.verify; @@ -127,7 +174,7 @@ import static org.mockito.Mockito.when; import java.util.Arrays; import java.util.List; -import org.junit.Test; +import org.junit.jupiter.api.Test; import org.mockito.ArgumentCaptor; import org.mockito.Mockito; @@ -213,13 +260,13 @@ public class TodoBusinessImplMockitoTest { ``` package com.in28minutes.business; -import static org.junit.Assert.assertEquals; +import static org.junit.jupiter.api.Assertions.assertEquals; import java.util.List; -import org.junit.Test; - import com.in28minutes.data.api.TodoService; + +import org.junit.jupiter.api.Test; import com.in28minutes.data.stub.TodoServiceStub; public class TodoBusinessImplStubTest { @@ -233,6 +280,7 @@ public class TodoBusinessImplStubTest { assertEquals(2, todos.size()); } } + ``` ### /src/test/java/com/in28minutes/data/stub/TodoServiceStub.java ``` @@ -258,9 +306,9 @@ public class TodoServiceStub implements TodoService { ``` package com.in28minutes.mockito; -import static org.junit.Assert.assertTrue; +import static org.junit.jupiter.api.Assertions.assertTrue; -import org.junit.Test; +import org.junit.jupiter.api.Test; public class FirstMockitoTest { @@ -289,7 +337,7 @@ import static org.hamcrest.core.Every.everyItem; import java.util.Arrays; import java.util.List; -import org.junit.Test; +import org.junit.jupiter.api.Test; public class HamcrestMatcherTest { @@ -319,16 +367,15 @@ public class HamcrestMatcherTest { package com.in28minutes.mockito; import static org.hamcrest.CoreMatchers.is; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertNull; -import static org.junit.Assert.assertThat; +import static org.hamcrest.MatcherAssert.assertThat; +import static org.junit.jupiter.api.Assertions.*; import static org.mockito.BDDMockito.given; import static org.mockito.Mockito.mock; import static org.mockito.Mockito.when; import java.util.List; -import org.junit.Test; +import org.junit.jupiter.api.Test; import org.mockito.Mockito; public class ListTest { @@ -356,12 +403,14 @@ public class ListTest { assertNull(list.get(1)); } - @Test(expected = RuntimeException.class) + @Test public void letsMockListGetToThrowException() { - List list = mock(List.class); - when(list.get(Mockito.anyInt())).thenThrow( - new RuntimeException("Something went wrong")); - list.get(0); + assertThrows(RuntimeException.class, () -> { + List list = mock(List.class); + when(list.get(Mockito.anyInt())).thenThrow( + new RuntimeException("Something went wrong")); + list.get(0); + }); } @Test diff --git a/Step10.md b/Step10.md index 3b2a5d9..7dc18d4 100644 --- a/Step10.md +++ b/Step10.md @@ -16,23 +16,52 @@ 0.0.1-SNAPSHOT - junit - junit - 4.12 + org.junit.jupiter + junit-jupiter + 5.10.2 test + + org.junit.jupiter + junit-jupiter-api + 5.10.2 + test + + + org.junit.platform + junit-platform-suite-engine + 1.10.2 + org.mockito - mockito-all - 1.10.19 + mockito-inline + 3.6.0 test - - org.hamcrest - hamcrest-library - 1.3 - test - + + org.hamcrest + hamcrest + 2.2 + test + + + org.mockito + mockito-core + 5.4.0 + test + + + org.mockito + mockito-junit-jupiter + 4.5.1 + test + + + org.hamcrest + hamcrest-library + 1.3 + test + ``` @@ -93,8 +122,8 @@ public interface TodoService { package com.in28minutes.business; import static org.hamcrest.CoreMatchers.is; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertThat; +import static org.hamcrest.MatcherAssert.assertThat; +import static org.junit.jupiter.api.Assertions.assertEquals; import static org.mockito.BDDMockito.given; import static org.mockito.Mockito.verify; import static org.mockito.Mockito.when; @@ -102,18 +131,18 @@ import static org.mockito.Mockito.when; import java.util.Arrays; import java.util.List; -import org.junit.Test; -import org.junit.runner.RunWith; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.extension.ExtendWith; import org.mockito.ArgumentCaptor; import org.mockito.Captor; import org.mockito.InjectMocks; import org.mockito.Mock; import org.mockito.Mockito; -import org.mockito.runners.MockitoJUnitRunner; +import org.mockito.junit.jupiter.MockitoExtension; import com.in28minutes.data.api.TodoService; -@RunWith(MockitoJUnitRunner.class) +@ExtendWith(MockitoExtension.class) public class TodoBusinessImplMockitoInjectMocksTest { @Mock TodoService todoService; @@ -191,8 +220,8 @@ public class TodoBusinessImplMockitoInjectMocksTest { package com.in28minutes.business; import static org.hamcrest.CoreMatchers.is; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertThat; +import static org.hamcrest.MatcherAssert.assertThat; +import static org.junit.jupiter.api.Assertions.assertEquals; import static org.mockito.BDDMockito.given; import static org.mockito.Mockito.mock; import static org.mockito.Mockito.verify; @@ -201,7 +230,7 @@ import static org.mockito.Mockito.when; import java.util.Arrays; import java.util.List; -import org.junit.Test; +import org.junit.jupiter.api.Test; import org.mockito.ArgumentCaptor; import org.mockito.Mockito; @@ -287,13 +316,13 @@ public class TodoBusinessImplMockitoTest { ``` package com.in28minutes.business; -import static org.junit.Assert.assertEquals; +import static org.junit.jupiter.api.Assertions.assertEquals; import java.util.List; -import org.junit.Test; - import com.in28minutes.data.api.TodoService; + +import org.junit.jupiter.api.Test; import com.in28minutes.data.stub.TodoServiceStub; public class TodoBusinessImplStubTest { @@ -332,9 +361,9 @@ public class TodoServiceStub implements TodoService { ``` package com.in28minutes.mockito; -import static org.junit.Assert.assertTrue; +import static org.junit.jupiter.api.Assertions.assertTrue; -import org.junit.Test; +import org.junit.jupiter.api.Test; public class FirstMockitoTest { @@ -363,7 +392,7 @@ import static org.hamcrest.core.Every.everyItem; import java.util.Arrays; import java.util.List; -import org.junit.Test; +import org.junit.jupiter.api.Test; public class HamcrestMatcherTest { @@ -393,16 +422,15 @@ public class HamcrestMatcherTest { package com.in28minutes.mockito; import static org.hamcrest.CoreMatchers.is; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertNull; -import static org.junit.Assert.assertThat; +import static org.hamcrest.MatcherAssert.assertThat; +import static org.junit.jupiter.api.Assertions.*; import static org.mockito.BDDMockito.given; import static org.mockito.Mockito.mock; import static org.mockito.Mockito.when; import java.util.List; -import org.junit.Test; +import org.junit.jupiter.api.Test; import org.mockito.Mockito; public class ListTest { @@ -430,12 +458,14 @@ public class ListTest { assertNull(list.get(1)); } - @Test(expected = RuntimeException.class) + @Test public void letsMockListGetToThrowException() { - List list = mock(List.class); - when(list.get(Mockito.anyInt())).thenThrow( - new RuntimeException("Something went wrong")); - list.get(0); + assertThrows(RuntimeException.class, () -> { + List list = mock(List.class); + when(list.get(Mockito.anyInt())).thenThrow( + new RuntimeException("Something went wrong")); + list.get(0); + }); } @Test diff --git a/Step11.md b/Step11.md index 6c19326..b828564 100644 --- a/Step11.md +++ b/Step11.md @@ -1,15 +1,4 @@ -## What You Will Learn during this Step: -- JUnit Rules. Using MockitoJUnit.rule() instead of @RunWith(MockitoJUnitRunner.class). - ## Useful Snippets and References -First Snippet -``` -@Rule - public MockitoRule mockitoRule = MockitoJUnit.rule(); -``` -Second Snippet -``` -``` ## Files List ### /pom.xml @@ -22,23 +11,52 @@ Second Snippet 0.0.1-SNAPSHOT - junit - junit - 4.12 + org.junit.jupiter + junit-jupiter + 5.10.2 + test + + + org.junit.jupiter + junit-jupiter-api + 5.10.2 + test + + + org.junit.platform + junit-platform-suite-engine + 1.10.2 + + + org.mockito + mockito-inline + 3.6.0 + test + + + org.hamcrest + hamcrest + 2.2 + test + + + org.mockito + mockito-core + 5.4.0 test org.mockito - mockito-all - 1.10.19 + mockito-junit-jupiter + 4.5.1 test - - org.hamcrest - hamcrest-library - 1.3 - test - + + org.hamcrest + hamcrest-library + 1.3 + test + ``` @@ -100,8 +118,8 @@ public interface TodoService { package com.in28minutes.business; import static org.hamcrest.CoreMatchers.is; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertThat; +import static org.hamcrest.MatcherAssert.assertThat; +import static org.junit.jupiter.api.Assertions.assertEquals; import static org.mockito.BDDMockito.given; import static org.mockito.Mockito.verify; import static org.mockito.Mockito.when; @@ -109,18 +127,18 @@ import static org.mockito.Mockito.when; import java.util.Arrays; import java.util.List; -import org.junit.Test; -import org.junit.runner.RunWith; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.extension.ExtendWith; import org.mockito.ArgumentCaptor; import org.mockito.Captor; import org.mockito.InjectMocks; import org.mockito.Mock; import org.mockito.Mockito; -import org.mockito.runners.MockitoJUnitRunner; +import org.mockito.junit.jupiter.MockitoExtension; import com.in28minutes.data.api.TodoService; -@RunWith(MockitoJUnitRunner.class) +@ExtendWith(MockitoExtension.class) public class TodoBusinessImplMockitoInjectMocksTest { @Mock TodoService todoService; @@ -198,8 +216,8 @@ public class TodoBusinessImplMockitoInjectMocksTest { package com.in28minutes.business; import static org.hamcrest.CoreMatchers.is; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertThat; +import static org.hamcrest.MatcherAssert.assertThat; +import static org.junit.jupiter.api.Assertions.assertEquals; import static org.mockito.BDDMockito.given; import static org.mockito.Mockito.verify; import static org.mockito.Mockito.when; @@ -207,23 +225,20 @@ import static org.mockito.Mockito.when; import java.util.Arrays; import java.util.List; -import org.junit.Rule; -import org.junit.Test; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.extension.ExtendWith; import org.mockito.ArgumentCaptor; import org.mockito.Captor; import org.mockito.InjectMocks; import org.mockito.Mock; import org.mockito.Mockito; -import org.mockito.junit.MockitoJUnit; -import org.mockito.junit.MockitoRule; +import org.mockito.junit.jupiter.MockitoExtension; import com.in28minutes.data.api.TodoService; +@ExtendWith(MockitoExtension.class) public class TodoBusinessImplMockitoRulesTest { - @Rule - public MockitoRule mockitoRule = MockitoJUnit.rule(); - @Mock TodoService todoService; @@ -300,8 +315,8 @@ public class TodoBusinessImplMockitoRulesTest { package com.in28minutes.business; import static org.hamcrest.CoreMatchers.is; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertThat; +import static org.hamcrest.MatcherAssert.assertThat; +import static org.junit.jupiter.api.Assertions.assertEquals; import static org.mockito.BDDMockito.given; import static org.mockito.Mockito.mock; import static org.mockito.Mockito.verify; @@ -310,7 +325,7 @@ import static org.mockito.Mockito.when; import java.util.Arrays; import java.util.List; -import org.junit.Test; +import org.junit.jupiter.api.Test; import org.mockito.ArgumentCaptor; import org.mockito.Mockito; @@ -396,13 +411,13 @@ public class TodoBusinessImplMockitoTest { ``` package com.in28minutes.business; -import static org.junit.Assert.assertEquals; +import static org.junit.jupiter.api.Assertions.assertEquals; import java.util.List; -import org.junit.Test; - import com.in28minutes.data.api.TodoService; + +import org.junit.jupiter.api.Test; import com.in28minutes.data.stub.TodoServiceStub; public class TodoBusinessImplStubTest { @@ -441,9 +456,9 @@ public class TodoServiceStub implements TodoService { ``` package com.in28minutes.mockito; -import static org.junit.Assert.assertTrue; +import static org.junit.jupiter.api.Assertions.assertTrue; -import org.junit.Test; +import org.junit.jupiter.api.Test; public class FirstMockitoTest { @@ -472,7 +487,7 @@ import static org.hamcrest.core.Every.everyItem; import java.util.Arrays; import java.util.List; -import org.junit.Test; +import org.junit.jupiter.api.Test; public class HamcrestMatcherTest { @@ -502,16 +517,15 @@ public class HamcrestMatcherTest { package com.in28minutes.mockito; import static org.hamcrest.CoreMatchers.is; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertNull; -import static org.junit.Assert.assertThat; +import static org.hamcrest.MatcherAssert.assertThat; +import static org.junit.jupiter.api.Assertions.*; import static org.mockito.BDDMockito.given; import static org.mockito.Mockito.mock; import static org.mockito.Mockito.when; import java.util.List; -import org.junit.Test; +import org.junit.jupiter.api.Test; import org.mockito.Mockito; public class ListTest { @@ -539,12 +553,14 @@ public class ListTest { assertNull(list.get(1)); } - @Test(expected = RuntimeException.class) + @Test public void letsMockListGetToThrowException() { - List list = mock(List.class); - when(list.get(Mockito.anyInt())).thenThrow( - new RuntimeException("Something went wrong")); - list.get(0); + assertThrows(RuntimeException.class, () -> { + List list = mock(List.class); + when(list.get(Mockito.anyInt())).thenThrow( + new RuntimeException("Something went wrong")); + list.get(0); + }); } @Test diff --git a/Step13.md b/Step13.md index 64bf2bd..7f403af 100644 --- a/Step13.md +++ b/Step13.md @@ -14,23 +14,52 @@ 0.0.1-SNAPSHOT - junit - junit - 4.12 + org.junit.jupiter + junit-jupiter + 5.10.2 + test + + + org.junit.jupiter + junit-jupiter-api + 5.10.2 + test + + + org.junit.platform + junit-platform-suite-engine + 1.10.2 + + + org.mockito + mockito-inline + 3.6.0 + test + + + org.hamcrest + hamcrest + 2.2 + test + + + org.mockito + mockito-core + 5.4.0 test org.mockito - mockito-all - 1.10.19 + mockito-junit-jupiter + 4.5.1 + test + + + org.hamcrest + hamcrest-library + 1.3 test - - org.hamcrest - hamcrest-library - 1.3 - test - ``` @@ -92,8 +121,8 @@ public interface TodoService { package com.in28minutes.business; import static org.hamcrest.CoreMatchers.is; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertThat; +import static org.hamcrest.MatcherAssert.assertThat; +import static org.junit.jupiter.api.Assertions.assertEquals; import static org.mockito.BDDMockito.given; import static org.mockito.Mockito.verify; import static org.mockito.Mockito.when; @@ -101,18 +130,18 @@ import static org.mockito.Mockito.when; import java.util.Arrays; import java.util.List; -import org.junit.Test; -import org.junit.runner.RunWith; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.extension.ExtendWith; import org.mockito.ArgumentCaptor; import org.mockito.Captor; import org.mockito.InjectMocks; import org.mockito.Mock; import org.mockito.Mockito; -import org.mockito.runners.MockitoJUnitRunner; +import org.mockito.junit.jupiter.MockitoExtension; import com.in28minutes.data.api.TodoService; -@RunWith(MockitoJUnitRunner.class) +@ExtendWith(MockitoExtension.class) public class TodoBusinessImplMockitoInjectMocksTest { @Mock TodoService todoService; @@ -190,8 +219,8 @@ public class TodoBusinessImplMockitoInjectMocksTest { package com.in28minutes.business; import static org.hamcrest.CoreMatchers.is; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertThat; +import static org.hamcrest.MatcherAssert.assertThat; +import static org.junit.jupiter.api.Assertions.assertEquals; import static org.mockito.BDDMockito.given; import static org.mockito.Mockito.verify; import static org.mockito.Mockito.when; @@ -199,23 +228,20 @@ import static org.mockito.Mockito.when; import java.util.Arrays; import java.util.List; -import org.junit.Rule; -import org.junit.Test; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.extension.ExtendWith; import org.mockito.ArgumentCaptor; import org.mockito.Captor; import org.mockito.InjectMocks; import org.mockito.Mock; import org.mockito.Mockito; -import org.mockito.junit.MockitoJUnit; -import org.mockito.junit.MockitoRule; +import org.mockito.junit.jupiter.MockitoExtension; import com.in28minutes.data.api.TodoService; +@ExtendWith(MockitoExtension.class) public class TodoBusinessImplMockitoRulesTest { - @Rule - public MockitoRule mockitoRule = MockitoJUnit.rule(); - @Mock TodoService todoService; @@ -292,8 +318,8 @@ public class TodoBusinessImplMockitoRulesTest { package com.in28minutes.business; import static org.hamcrest.CoreMatchers.is; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertThat; +import static org.hamcrest.MatcherAssert.assertThat; +import static org.junit.jupiter.api.Assertions.assertEquals; import static org.mockito.BDDMockito.given; import static org.mockito.Mockito.mock; import static org.mockito.Mockito.verify; @@ -302,7 +328,7 @@ import static org.mockito.Mockito.when; import java.util.Arrays; import java.util.List; -import org.junit.Test; +import org.junit.jupiter.api.Test; import org.mockito.ArgumentCaptor; import org.mockito.Mockito; @@ -388,13 +414,13 @@ public class TodoBusinessImplMockitoTest { ``` package com.in28minutes.business; -import static org.junit.Assert.assertEquals; +import static org.junit.jupiter.api.Assertions.assertEquals; import java.util.List; -import org.junit.Test; - import com.in28minutes.data.api.TodoService; + +import org.junit.jupiter.api.Test; import com.in28minutes.data.stub.TodoServiceStub; public class TodoBusinessImplStubTest { @@ -433,9 +459,9 @@ public class TodoServiceStub implements TodoService { ``` package com.in28minutes.mockito; -import static org.junit.Assert.assertTrue; +import static org.junit.jupiter.api.Assertions.assertTrue; -import org.junit.Test; +import org.junit.jupiter.api.Test; public class FirstMockitoTest { @@ -464,7 +490,7 @@ import static org.hamcrest.core.Every.everyItem; import java.util.Arrays; import java.util.List; -import org.junit.Test; +import org.junit.jupiter.api.Test; public class HamcrestMatcherTest { @@ -494,16 +520,15 @@ public class HamcrestMatcherTest { package com.in28minutes.mockito; import static org.hamcrest.CoreMatchers.is; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertNull; -import static org.junit.Assert.assertThat; +import static org.hamcrest.MatcherAssert.assertThat; +import static org.junit.jupiter.api.Assertions.*; import static org.mockito.BDDMockito.given; import static org.mockito.Mockito.mock; import static org.mockito.Mockito.when; import java.util.List; -import org.junit.Test; +import org.junit.jupiter.api.Test; import org.mockito.Mockito; public class ListTest { @@ -531,12 +556,14 @@ public class ListTest { assertNull(list.get(1)); } - @Test(expected = RuntimeException.class) + @Test public void letsMockListGetToThrowException() { - List list = mock(List.class); - when(list.get(Mockito.anyInt())).thenThrow( - new RuntimeException("Something went wrong")); - list.get(0); + assertThrows(RuntimeException.class, () -> { + List list = mock(List.class); + when(list.get(Mockito.anyInt())).thenThrow( + new RuntimeException("Something went wrong")); + list.get(0); + }); } @Test @@ -566,15 +593,14 @@ public class ListTest { ``` package com.in28minutes.mockito; -import static org.junit.Assert.assertEquals; +import static org.junit.jupiter.api.Assertions.assertEquals; import static org.mockito.Mockito.spy; -import static org.mockito.Mockito.stub; import static org.mockito.Mockito.verify; import java.util.ArrayList; import java.util.List; -import org.junit.Test; +import org.junit.jupiter.api.Test; public class SpyTest { @@ -590,20 +616,5 @@ public class SpyTest { assertEquals(2, listSpy.size()); assertEquals("Ranga", listSpy.get(0)); } - - @Test - public void creatingASpyOnArrayList_overridingSpecificMethods() { - List listSpy = spy(ArrayList.class); - listSpy.add("Ranga"); - listSpy.add("in28Minutes"); - - stub(listSpy.size()).toReturn(-1); - - assertEquals(-1, listSpy.size()); - assertEquals("Ranga", listSpy.get(0)); - - // @Spy Annotation - } - } ``` diff --git a/Step15.md b/Step15.md index 3af559e..6e5c30d 100644 --- a/Step15.md +++ b/Step15.md @@ -1,37 +1,4 @@ ## What You Will Learn during this Step: -- Add dependency on PowerMock. -- Using PowerMock and Mockito to mock a Static Method. -- PowerMockitoMockingStaticMethodTest - -## Useful Snippets and References -pom.xml -``` - - org.powermock - powermock-api-mockito - 1.6.4 - test - - - org.powermock - powermock-module-junit4 - 1.6.4 - test - - -``` -Other Useful Snippets -``` -@RunWith(PowerMockRunner.class) -@PrepareForTest({ UtilityClass.class}) - -PowerMockito.mockStatic(UtilityClass.class); -when(UtilityClass.staticMethod(anyLong())).thenReturn(150); - -PowerMockito.verifyStatic(); -UtilityClass.staticMethod(1 + 2 + 3); -``` -## Files List ## Files List ### /pom.xml ``` @@ -43,33 +10,50 @@ UtilityClass.staticMethod(1 + 2 + 3); 0.0.1-SNAPSHOT - junit - junit - 4.12 + org.junit.jupiter + junit-jupiter + 5.10.2 test + + org.junit.jupiter + junit-jupiter-api + 5.10.2 + test + + + org.junit.platform + junit-platform-suite-engine + 1.10.2 + org.mockito - mockito-all - 1.10.19 + mockito-inline + 3.6.0 test org.hamcrest - hamcrest-library - 1.3 + hamcrest + 2.2 + test + + + org.mockito + mockito-core + 5.4.0 test - org.powermock - powermock-api-mockito - 1.6.4 + org.mockito + mockito-junit-jupiter + 4.5.1 test - org.powermock - powermock-module-junit4 - 1.6.4 + org.hamcrest + hamcrest-library + 1.3 test @@ -79,8 +63,7 @@ UtilityClass.staticMethod(1 + 2 + 3); org.apache.maven.plugins maven-compiler-plugin - 1.8 - 1.8 + 21 @@ -744,16 +727,16 @@ public class UtilityClass { ``` package com.clarity.business; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.fail; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertThrows; import java.math.BigDecimal; import java.util.ArrayList; import java.util.List; -import org.junit.Test; - import com.in28minutes.junit.business.ClientBO; + +import org.junit.jupiter.api.Test; import com.in28minutes.junit.business.ClientBOImpl; import com.in28minutes.junit.business.exception.DifferentCurrenciesException; import com.in28minutes.junit.model.Amount; @@ -786,23 +769,25 @@ public class ClientBOTest { assertEquals(new BigDecimal("11.0"), temp.getValue()); } - @Test(expected = DifferentCurrenciesException.class) + @Test public void testClientProductSum1() throws DifferentCurrenciesException { + assertThrows(DifferentCurrenciesException.class, () -> { - List products = new ArrayList(); + List products = new ArrayList(); - products.add(new ProductImpl(100, "Product 15", - ProductType.BANK_GUARANTEE, new AmountImpl( - new BigDecimal("5.0"), Currency.INDIAN_RUPEE))); + products.add(new ProductImpl(100, "Product 15", + ProductType.BANK_GUARANTEE, new AmountImpl( + new BigDecimal("5.0"), Currency.INDIAN_RUPEE))); - products.add(new ProductImpl(120, "Product 20", - ProductType.BANK_GUARANTEE, new AmountImpl( - new BigDecimal("6.0"), Currency.EURO))); + products.add(new ProductImpl(120, "Product 20", + ProductType.BANK_GUARANTEE, new AmountImpl( + new BigDecimal("6.0"), Currency.EURO))); - @SuppressWarnings("unused") - Amount temp = null; + @SuppressWarnings("unused") + Amount temp = null; - temp = clientBO.getClientProductsSum(products); + temp = clientBO.getClientProductsSum(products); + }); } @Test @@ -826,15 +811,16 @@ public class ClientBOTest { ``` package com.clarity.business; -import static org.junit.Assert.assertEquals; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertThrows; import java.math.BigDecimal; import java.util.ArrayList; import java.util.List; -import org.junit.Test; - import com.in28minutes.junit.business.ClientBO; + +import org.junit.jupiter.api.Test; import com.in28minutes.junit.business.ClientBOImpl; import com.in28minutes.junit.business.exception.DifferentCurrenciesException; import com.in28minutes.junit.model.Amount; @@ -865,18 +851,21 @@ public class ClientBOTestRefactored { assertAmount(actual, expected); } - @Test(expected = DifferentCurrenciesException.class) + @Test public void testClientProductSum_DifferentCurrencies_ThrowsException() throws DifferentCurrenciesException { + assertThrows(DifferentCurrenciesException.class, () -> { - Amount[] amounts = { - new AmountImpl(new BigDecimal("5.0"), Currency.EURO), - new AmountImpl(new BigDecimal("6.0"), Currency.INDIAN_RUPEE) }; + Amount[] amounts = { + new AmountImpl(new BigDecimal("5.0"), Currency.EURO), + new AmountImpl(new BigDecimal("6.0"), Currency.INDIAN_RUPEE)}; - List products = createProductListWithAmounts(amounts); + List products = createProductListWithAmounts(amounts); - @SuppressWarnings("unused") - Amount actual = clientBO.getClientProductsSum(products); + @SuppressWarnings("unused") + Amount actual = clientBO.getClientProductsSum(products); + + }); } @@ -916,8 +905,8 @@ public class ClientBOTestRefactored { package com.in28minutes.business; import static org.hamcrest.CoreMatchers.is; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertThat; +import static org.hamcrest.MatcherAssert.assertThat; +import static org.junit.jupiter.api.Assertions.assertEquals; import static org.mockito.BDDMockito.given; import static org.mockito.Mockito.verify; import static org.mockito.Mockito.when; @@ -925,18 +914,18 @@ import static org.mockito.Mockito.when; import java.util.Arrays; import java.util.List; -import org.junit.Test; -import org.junit.runner.RunWith; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.extension.ExtendWith; import org.mockito.ArgumentCaptor; import org.mockito.Captor; import org.mockito.InjectMocks; import org.mockito.Mock; import org.mockito.Mockito; -import org.mockito.runners.MockitoJUnitRunner; +import org.mockito.junit.jupiter.MockitoExtension; import com.in28minutes.data.api.TodoService; -@RunWith(MockitoJUnitRunner.class) +@ExtendWith(MockitoExtension.class) public class TodoBusinessImplMockitoInjectMocksTest { @Mock TodoService todoService; @@ -1008,14 +997,15 @@ public class TodoBusinessImplMockitoInjectMocksTest { assertEquals("Learn to Dance", stringArgumentCaptor.getValue()); } } + ``` ### /src/test/java/com/in28minutes/business/TodoBusinessImplMockitoRulesTest.java ``` package com.in28minutes.business; import static org.hamcrest.CoreMatchers.is; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertThat; +import static org.hamcrest.MatcherAssert.assertThat; +import static org.junit.jupiter.api.Assertions.assertEquals; import static org.mockito.BDDMockito.given; import static org.mockito.Mockito.verify; import static org.mockito.Mockito.when; @@ -1023,23 +1013,20 @@ import static org.mockito.Mockito.when; import java.util.Arrays; import java.util.List; -import org.junit.Rule; -import org.junit.Test; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.extension.ExtendWith; import org.mockito.ArgumentCaptor; import org.mockito.Captor; import org.mockito.InjectMocks; import org.mockito.Mock; import org.mockito.Mockito; -import org.mockito.junit.MockitoJUnit; -import org.mockito.junit.MockitoRule; +import org.mockito.junit.jupiter.MockitoExtension; import com.in28minutes.data.api.TodoService; +@ExtendWith(MockitoExtension.class) public class TodoBusinessImplMockitoRulesTest { - @Rule - public MockitoRule mockitoRule = MockitoJUnit.rule(); - @Mock TodoService todoService; @@ -1116,8 +1103,8 @@ public class TodoBusinessImplMockitoRulesTest { package com.in28minutes.business; import static org.hamcrest.CoreMatchers.is; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertThat; +import static org.hamcrest.MatcherAssert.assertThat; +import static org.junit.jupiter.api.Assertions.assertEquals; import static org.mockito.BDDMockito.given; import static org.mockito.Mockito.mock; import static org.mockito.Mockito.verify; @@ -1126,7 +1113,7 @@ import static org.mockito.Mockito.when; import java.util.Arrays; import java.util.List; -import org.junit.Test; +import org.junit.jupiter.api.Test; import org.mockito.ArgumentCaptor; import org.mockito.Mockito; @@ -1212,13 +1199,13 @@ public class TodoBusinessImplMockitoTest { ``` package com.in28minutes.business; -import static org.junit.Assert.assertEquals; +import static org.junit.jupiter.api.Assertions.assertEquals; import java.util.List; -import org.junit.Test; - import com.in28minutes.data.api.TodoService; + +import org.junit.jupiter.api.Test; import com.in28minutes.data.stub.TodoServiceStub; public class TodoBusinessImplStubTest { @@ -1257,11 +1244,13 @@ public class TodoServiceStub implements TodoService { ``` package com.in28minutes.junit.helper; -import static org.junit.Assert.*; +import static org.junit.jupiter.api.Assertions.assertThrows; +import static org.junit.jupiter.api.Assertions.assertArrayEquals; import java.util.Arrays; -import org.junit.Test; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.Timeout; public class ArraysCompareTest { @@ -1273,14 +1262,17 @@ public class ArraysCompareTest { assertArrayEquals(expected, numbers); } - @Test(expected=NullPointerException.class) + @Test public void testArraySort_NullArray() { - int[] numbers = null; - Arrays.sort(numbers); + assertThrows(NullPointerException.class, () -> { + int[] numbers = null; + Arrays.sort(numbers); + }); } - - @Test(timeout=100) - public void testSort_Performance(){ + + @Test + @Timeout(value = 100) + public void testSort_Performance() { int array[] = {12,23,4}; for(int i=1;i<=1000000;i++) { @@ -1290,21 +1282,21 @@ public class ArraysCompareTest { } } + ``` ### /src/test/java/com/in28minutes/junit/helper/ArraysTest.java ``` package com.in28minutes.junit.helper; -import static org.junit.Assert.*; - - import java.util.Arrays; -import org.junit.Test; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.Timeout; public class ArraysTest { - @Test(timeout=100) - public void testPerformance() { + @Test + @Timeout(value = 100) + public void performance() { for(int i=0;i<1000000;i++){ Arrays.sort(new int[]{i,i-1,i+1}); } @@ -1315,22 +1307,20 @@ public class ArraysTest { ``` package com.in28minutes.junit.helper; -import static org.junit.Assert.*; - -import org.junit.After; -import org.junit.AfterClass; -import org.junit.Before; -import org.junit.BeforeClass; -import org.junit.Test; +import org.junit.jupiter.api.AfterAll; +import org.junit.jupiter.api.AfterEach; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; public class QuickBeforeAfterTest { - - @BeforeClass + + @BeforeAll public static void beforeClass(){ System.out.println("Before Class"); } - - @Before + + @BeforeEach public void setup(){ System.out.println("Before Test"); } @@ -1344,13 +1334,13 @@ public class QuickBeforeAfterTest { public void test2() { System.out.println("test2 executed"); } - - @After + + @AfterEach public void teardown() { System.out.println("After test"); } - - @AfterClass + + @AfterAll public static void afterClass(){ System.out.println("After Class"); } @@ -1361,18 +1351,14 @@ public class QuickBeforeAfterTest { ``` package com.in28minutes.junit.helper; -import static org.junit.Assert.*; +import static org.junit.jupiter.api.Assertions.assertEquals; import java.util.Arrays; import java.util.Collection; -import org.junit.Before; -import org.junit.Test; -import org.junit.runner.RunWith; -import org.junit.runners.Parameterized; -import org.junit.runners.Parameterized.Parameters; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.MethodSource; -@RunWith(Parameterized.class) public class StringHelperParameterizedTest { // AACD => CD ACD => CD CDEF=>CDEF CDAA => CDAA @@ -1381,13 +1367,12 @@ public class StringHelperParameterizedTest { private String input; private String expectedOutput; - - public StringHelperParameterizedTest(String input, String expectedOutput) { + + public void initStringHelperParameterizedTest(String input, String expectedOutput) { this.input = input; this.expectedOutput = expectedOutput; } - @Parameters public static Collection testConditions() { String expectedOutputs[][] = { { "AACD", "CD" }, @@ -1395,8 +1380,10 @@ public class StringHelperParameterizedTest { return Arrays.asList(expectedOutputs); } - @Test - public void testTruncateAInFirst2Positions() { + @MethodSource("testConditions") + @ParameterizedTest + public void truncateAInFirst2Positions(String input, String expectedOutput) { + initStringHelperParameterizedTest(input, expectedOutput); assertEquals(expectedOutput, helper.truncateAInFirst2Positions(input)); } @@ -1406,22 +1393,22 @@ public class StringHelperParameterizedTest { ``` package com.in28minutes.junit.helper; -import static org.junit.Assert.*; +import static org.junit.jupiter.api.Assertions.*; -import org.junit.Before; -import org.junit.Test; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; public class StringHelperTest { // AACD => CD ACD => CD CDEF=>CDEF CDAA => CDAA StringHelper helper; - - @Before + + @BeforeEach public void before(){ helper = new StringHelper(); } - + @Test public void testTruncateAInFirst2Positions_AinFirst2Positions() { @@ -1448,31 +1435,31 @@ public class StringHelperTest { } + ``` ### /src/test/java/com/in28minutes/junit/suite/DummyTestSuite.java ``` package com.in28minutes.junit.suite; -import org.junit.runner.RunWith; -import org.junit.runners.Suite; -import org.junit.runners.Suite.SuiteClasses; - import com.in28minutes.junit.helper.ArraysTest; import com.in28minutes.junit.helper.StringHelperTest; +import org.junit.platform.suite.api.SelectClasses; +import org.junit.platform.suite.api.Suite; -@RunWith(Suite.class) -@SuiteClasses({ArraysTest.class,StringHelperTest.class}) +@Suite +@SelectClasses({ArraysTest.class,StringHelperTest.class}) public class DummyTestSuite { } + ``` ### /src/test/java/com/in28minutes/mockito/FirstMockitoTest.java ``` package com.in28minutes.mockito; -import static org.junit.Assert.assertTrue; +import static org.junit.jupiter.api.Assertions.assertTrue; -import org.junit.Test; +import org.junit.jupiter.api.Test; public class FirstMockitoTest { @@ -1501,7 +1488,7 @@ import static org.hamcrest.core.Every.everyItem; import java.util.Arrays; import java.util.List; -import org.junit.Test; +import org.junit.jupiter.api.Test; public class HamcrestMatcherTest { @@ -1531,16 +1518,15 @@ public class HamcrestMatcherTest { package com.in28minutes.mockito; import static org.hamcrest.CoreMatchers.is; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertNull; -import static org.junit.Assert.assertThat; +import static org.hamcrest.MatcherAssert.assertThat; +import static org.junit.jupiter.api.Assertions.*; import static org.mockito.BDDMockito.given; import static org.mockito.Mockito.mock; import static org.mockito.Mockito.when; import java.util.List; -import org.junit.Test; +import org.junit.jupiter.api.Test; import org.mockito.Mockito; public class ListTest { @@ -1568,12 +1554,14 @@ public class ListTest { assertNull(list.get(1)); } - @Test(expected = RuntimeException.class) + @Test public void letsMockListGetToThrowException() { - List list = mock(List.class); - when(list.get(Mockito.anyInt())).thenThrow( - new RuntimeException("Something went wrong")); - list.get(0); + assertThrows(RuntimeException.class, () -> { + List list = mock(List.class); + when(list.get(Mockito.anyInt())).thenThrow( + new RuntimeException("Something went wrong")); + list.get(0); + }); } @Test @@ -1598,20 +1586,20 @@ public class ListTest { assertThat("in28Minutes", is(list.get(0))); } } + ``` ### /src/test/java/com/in28minutes/mockito/SpyTest.java ``` package com.in28minutes.mockito; -import static org.junit.Assert.assertEquals; +import static org.junit.jupiter.api.Assertions.assertEquals; import static org.mockito.Mockito.spy; -import static org.mockito.Mockito.stub; import static org.mockito.Mockito.verify; import java.util.ArrayList; import java.util.List; -import org.junit.Test; +import org.junit.jupiter.api.Test; public class SpyTest { @@ -1627,44 +1615,27 @@ public class SpyTest { assertEquals(2, listSpy.size()); assertEquals("Ranga", listSpy.get(0)); } - - @Test - public void creatingASpyOnArrayList_overridingSpecificMethods() { - List listSpy = spy(ArrayList.class); - listSpy.add("Ranga"); - listSpy.add("in28Minutes"); - - stub(listSpy.size()).toReturn(-1); - - assertEquals(-1, listSpy.size()); - assertEquals("Ranga", listSpy.get(0)); - - // @Spy Annotation - } - } ``` ### /src/test/java/com/in28minutes/powermock/PowerMockitoMockingStaticMethodTest.java ``` package com.in28minutes.powermock; -import static org.junit.Assert.assertEquals; -import static org.mockito.Matchers.anyLong; -import static org.mockito.Mockito.when; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.mockito.ArgumentMatchers.anyLong; +import static org.mockito.Mockito.*; import java.util.Arrays; -import org.junit.Test; -import org.junit.runner.RunWith; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.extension.ExtendWith; import org.mockito.InjectMocks; import org.mockito.Mock; -import org.powermock.api.mockito.PowerMockito; -import org.powermock.core.classloader.annotations.PrepareForTest; -import org.powermock.modules.junit4.PowerMockRunner; +import org.mockito.MockedStatic; +import org.mockito.junit.jupiter.MockitoExtension; -@RunWith(PowerMockRunner.class) -@PrepareForTest({ UtilityClass.class}) -public class PowerMockitoMockingStaticMethodTest { +@ExtendWith(MockitoExtension.class) +public class MockitoMockingStaticMethodTest { @Mock Dependency dependencyMock; @@ -1674,25 +1645,15 @@ public class PowerMockitoMockingStaticMethodTest { @Test public void powerMockito_MockingAStaticMethodCall() { + when(dependencyMock.retrieveAllStats()).thenReturn(Arrays.asList(1, 2, 3)); - when(dependencyMock.retrieveAllStats()).thenReturn( - Arrays.asList(1, 2, 3)); + MockedStatic mockedStatic = mockStatic(UtilityClass.class); - PowerMockito.mockStatic(UtilityClass.class); - - when(UtilityClass.staticMethod(anyLong())).thenReturn(150); + mockedStatic.when(() -> UtilityClass.staticMethod(anyLong())).thenReturn(150); assertEquals(150, systemUnderTest.methodCallingAStaticMethod()); - //To verify a specific method call - //First : Call PowerMockito.verifyStatic() - //Second : Call the method to be verified - PowerMockito.verifyStatic(); - UtilityClass.staticMethod(1 + 2 + 3); - - // verify exact number of calls - //PowerMockito.verifyStatic(Mockito.times(1)); - + mockedStatic.verify(() -> UtilityClass.staticMethod(1 + 2 + 3), times(1)); } } ``` diff --git a/Step16.md b/Step16.md index 1e3800b..b06aead 100644 --- a/Step16.md +++ b/Step16.md @@ -18,33 +18,50 @@ long value = (Long) Whitebox.invokeMethod(systemUnderTest, 0.0.1-SNAPSHOT - junit - junit - 4.12 + org.junit.jupiter + junit-jupiter + 5.10.2 test + + org.junit.jupiter + junit-jupiter-api + 5.10.2 + test + + + org.junit.platform + junit-platform-suite-engine + 1.10.2 + org.mockito - mockito-all - 1.10.19 + mockito-inline + 3.6.0 test org.hamcrest - hamcrest-library - 1.3 + hamcrest + 2.2 test - org.powermock - powermock-api-mockito - 1.6.4 + org.mockito + mockito-core + 5.4.0 test - org.powermock - powermock-module-junit4 - 1.6.4 + org.mockito + mockito-junit-jupiter + 4.5.1 + test + + + org.hamcrest + hamcrest-library + 1.3 test @@ -54,8 +71,7 @@ long value = (Long) Whitebox.invokeMethod(systemUnderTest, org.apache.maven.plugins maven-compiler-plugin - 1.8 - 1.8 + 21 @@ -719,16 +735,16 @@ public class UtilityClass { ``` package com.clarity.business; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.fail; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertThrows; import java.math.BigDecimal; import java.util.ArrayList; import java.util.List; -import org.junit.Test; - import com.in28minutes.junit.business.ClientBO; + +import org.junit.jupiter.api.Test; import com.in28minutes.junit.business.ClientBOImpl; import com.in28minutes.junit.business.exception.DifferentCurrenciesException; import com.in28minutes.junit.model.Amount; @@ -761,23 +777,25 @@ public class ClientBOTest { assertEquals(new BigDecimal("11.0"), temp.getValue()); } - @Test(expected = DifferentCurrenciesException.class) + @Test public void testClientProductSum1() throws DifferentCurrenciesException { + assertThrows(DifferentCurrenciesException.class, () -> { - List products = new ArrayList(); + List products = new ArrayList(); - products.add(new ProductImpl(100, "Product 15", - ProductType.BANK_GUARANTEE, new AmountImpl( - new BigDecimal("5.0"), Currency.INDIAN_RUPEE))); + products.add(new ProductImpl(100, "Product 15", + ProductType.BANK_GUARANTEE, new AmountImpl( + new BigDecimal("5.0"), Currency.INDIAN_RUPEE))); - products.add(new ProductImpl(120, "Product 20", - ProductType.BANK_GUARANTEE, new AmountImpl( - new BigDecimal("6.0"), Currency.EURO))); + products.add(new ProductImpl(120, "Product 20", + ProductType.BANK_GUARANTEE, new AmountImpl( + new BigDecimal("6.0"), Currency.EURO))); - @SuppressWarnings("unused") - Amount temp = null; + @SuppressWarnings("unused") + Amount temp = null; - temp = clientBO.getClientProductsSum(products); + temp = clientBO.getClientProductsSum(products); + }); } @Test @@ -801,15 +819,16 @@ public class ClientBOTest { ``` package com.clarity.business; -import static org.junit.Assert.assertEquals; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertThrows; import java.math.BigDecimal; import java.util.ArrayList; import java.util.List; -import org.junit.Test; - import com.in28minutes.junit.business.ClientBO; + +import org.junit.jupiter.api.Test; import com.in28minutes.junit.business.ClientBOImpl; import com.in28minutes.junit.business.exception.DifferentCurrenciesException; import com.in28minutes.junit.model.Amount; @@ -840,18 +859,21 @@ public class ClientBOTestRefactored { assertAmount(actual, expected); } - @Test(expected = DifferentCurrenciesException.class) + @Test public void testClientProductSum_DifferentCurrencies_ThrowsException() throws DifferentCurrenciesException { + assertThrows(DifferentCurrenciesException.class, () -> { - Amount[] amounts = { - new AmountImpl(new BigDecimal("5.0"), Currency.EURO), - new AmountImpl(new BigDecimal("6.0"), Currency.INDIAN_RUPEE) }; + Amount[] amounts = { + new AmountImpl(new BigDecimal("5.0"), Currency.EURO), + new AmountImpl(new BigDecimal("6.0"), Currency.INDIAN_RUPEE)}; - List products = createProductListWithAmounts(amounts); + List products = createProductListWithAmounts(amounts); - @SuppressWarnings("unused") - Amount actual = clientBO.getClientProductsSum(products); + @SuppressWarnings("unused") + Amount actual = clientBO.getClientProductsSum(products); + + }); } @@ -891,8 +913,8 @@ public class ClientBOTestRefactored { package com.in28minutes.business; import static org.hamcrest.CoreMatchers.is; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertThat; +import static org.hamcrest.MatcherAssert.assertThat; +import static org.junit.jupiter.api.Assertions.assertEquals; import static org.mockito.BDDMockito.given; import static org.mockito.Mockito.verify; import static org.mockito.Mockito.when; @@ -900,18 +922,18 @@ import static org.mockito.Mockito.when; import java.util.Arrays; import java.util.List; -import org.junit.Test; -import org.junit.runner.RunWith; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.extension.ExtendWith; import org.mockito.ArgumentCaptor; import org.mockito.Captor; import org.mockito.InjectMocks; import org.mockito.Mock; import org.mockito.Mockito; -import org.mockito.runners.MockitoJUnitRunner; +import org.mockito.junit.jupiter.MockitoExtension; import com.in28minutes.data.api.TodoService; -@RunWith(MockitoJUnitRunner.class) +@ExtendWith(MockitoExtension.class) public class TodoBusinessImplMockitoInjectMocksTest { @Mock TodoService todoService; @@ -983,14 +1005,15 @@ public class TodoBusinessImplMockitoInjectMocksTest { assertEquals("Learn to Dance", stringArgumentCaptor.getValue()); } } + ``` ### /src/test/java/com/in28minutes/business/TodoBusinessImplMockitoRulesTest.java ``` package com.in28minutes.business; import static org.hamcrest.CoreMatchers.is; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertThat; +import static org.hamcrest.MatcherAssert.assertThat; +import static org.junit.jupiter.api.Assertions.assertEquals; import static org.mockito.BDDMockito.given; import static org.mockito.Mockito.verify; import static org.mockito.Mockito.when; @@ -998,23 +1021,20 @@ import static org.mockito.Mockito.when; import java.util.Arrays; import java.util.List; -import org.junit.Rule; -import org.junit.Test; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.extension.ExtendWith; import org.mockito.ArgumentCaptor; import org.mockito.Captor; import org.mockito.InjectMocks; import org.mockito.Mock; import org.mockito.Mockito; -import org.mockito.junit.MockitoJUnit; -import org.mockito.junit.MockitoRule; +import org.mockito.junit.jupiter.MockitoExtension; import com.in28minutes.data.api.TodoService; +@ExtendWith(MockitoExtension.class) public class TodoBusinessImplMockitoRulesTest { - @Rule - public MockitoRule mockitoRule = MockitoJUnit.rule(); - @Mock TodoService todoService; @@ -1091,8 +1111,8 @@ public class TodoBusinessImplMockitoRulesTest { package com.in28minutes.business; import static org.hamcrest.CoreMatchers.is; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertThat; +import static org.hamcrest.MatcherAssert.assertThat; +import static org.junit.jupiter.api.Assertions.assertEquals; import static org.mockito.BDDMockito.given; import static org.mockito.Mockito.mock; import static org.mockito.Mockito.verify; @@ -1101,7 +1121,7 @@ import static org.mockito.Mockito.when; import java.util.Arrays; import java.util.List; -import org.junit.Test; +import org.junit.jupiter.api.Test; import org.mockito.ArgumentCaptor; import org.mockito.Mockito; @@ -1187,13 +1207,13 @@ public class TodoBusinessImplMockitoTest { ``` package com.in28minutes.business; -import static org.junit.Assert.assertEquals; +import static org.junit.jupiter.api.Assertions.assertEquals; import java.util.List; -import org.junit.Test; - import com.in28minutes.data.api.TodoService; + +import org.junit.jupiter.api.Test; import com.in28minutes.data.stub.TodoServiceStub; public class TodoBusinessImplStubTest { @@ -1232,11 +1252,13 @@ public class TodoServiceStub implements TodoService { ``` package com.in28minutes.junit.helper; -import static org.junit.Assert.*; +import static org.junit.jupiter.api.Assertions.assertThrows; +import static org.junit.jupiter.api.Assertions.assertArrayEquals; import java.util.Arrays; -import org.junit.Test; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.Timeout; public class ArraysCompareTest { @@ -1248,14 +1270,17 @@ public class ArraysCompareTest { assertArrayEquals(expected, numbers); } - @Test(expected=NullPointerException.class) + @Test public void testArraySort_NullArray() { - int[] numbers = null; - Arrays.sort(numbers); + assertThrows(NullPointerException.class, () -> { + int[] numbers = null; + Arrays.sort(numbers); + }); } - - @Test(timeout=100) - public void testSort_Performance(){ + + @Test + @Timeout(value = 100) + public void testSort_Performance() { int array[] = {12,23,4}; for(int i=1;i<=1000000;i++) { @@ -1265,21 +1290,21 @@ public class ArraysCompareTest { } } + ``` ### /src/test/java/com/in28minutes/junit/helper/ArraysTest.java ``` package com.in28minutes.junit.helper; -import static org.junit.Assert.*; - - import java.util.Arrays; -import org.junit.Test; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.Timeout; public class ArraysTest { - @Test(timeout=100) - public void testPerformance() { + @Test + @Timeout(value = 100) + public void performance() { for(int i=0;i<1000000;i++){ Arrays.sort(new int[]{i,i-1,i+1}); } @@ -1290,22 +1315,20 @@ public class ArraysTest { ``` package com.in28minutes.junit.helper; -import static org.junit.Assert.*; - -import org.junit.After; -import org.junit.AfterClass; -import org.junit.Before; -import org.junit.BeforeClass; -import org.junit.Test; +import org.junit.jupiter.api.AfterAll; +import org.junit.jupiter.api.AfterEach; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; public class QuickBeforeAfterTest { - - @BeforeClass + + @BeforeAll public static void beforeClass(){ System.out.println("Before Class"); } - - @Before + + @BeforeEach public void setup(){ System.out.println("Before Test"); } @@ -1319,35 +1342,32 @@ public class QuickBeforeAfterTest { public void test2() { System.out.println("test2 executed"); } - - @After + + @AfterEach public void teardown() { System.out.println("After test"); } - - @AfterClass + + @AfterAll public static void afterClass(){ System.out.println("After Class"); } } + ``` ### /src/test/java/com/in28minutes/junit/helper/StringHelperParameterizedTest.java ``` package com.in28minutes.junit.helper; -import static org.junit.Assert.*; +import static org.junit.jupiter.api.Assertions.assertEquals; import java.util.Arrays; import java.util.Collection; -import org.junit.Before; -import org.junit.Test; -import org.junit.runner.RunWith; -import org.junit.runners.Parameterized; -import org.junit.runners.Parameterized.Parameters; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.MethodSource; -@RunWith(Parameterized.class) public class StringHelperParameterizedTest { // AACD => CD ACD => CD CDEF=>CDEF CDAA => CDAA @@ -1356,13 +1376,12 @@ public class StringHelperParameterizedTest { private String input; private String expectedOutput; - - public StringHelperParameterizedTest(String input, String expectedOutput) { + + public void initStringHelperParameterizedTest(String input, String expectedOutput) { this.input = input; this.expectedOutput = expectedOutput; } - @Parameters public static Collection testConditions() { String expectedOutputs[][] = { { "AACD", "CD" }, @@ -1370,8 +1389,10 @@ public class StringHelperParameterizedTest { return Arrays.asList(expectedOutputs); } - @Test - public void testTruncateAInFirst2Positions() { + @MethodSource("testConditions") + @ParameterizedTest + public void truncateAInFirst2Positions(String input, String expectedOutput) { + initStringHelperParameterizedTest(input, expectedOutput); assertEquals(expectedOutput, helper.truncateAInFirst2Positions(input)); } @@ -1381,22 +1402,22 @@ public class StringHelperParameterizedTest { ``` package com.in28minutes.junit.helper; -import static org.junit.Assert.*; +import static org.junit.jupiter.api.Assertions.*; -import org.junit.Before; -import org.junit.Test; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; public class StringHelperTest { // AACD => CD ACD => CD CDEF=>CDEF CDAA => CDAA StringHelper helper; - - @Before + + @BeforeEach public void before(){ helper = new StringHelper(); } - + @Test public void testTruncateAInFirst2Positions_AinFirst2Positions() { @@ -1423,20 +1444,19 @@ public class StringHelperTest { } + ``` ### /src/test/java/com/in28minutes/junit/suite/DummyTestSuite.java ``` package com.in28minutes.junit.suite; -import org.junit.runner.RunWith; -import org.junit.runners.Suite; -import org.junit.runners.Suite.SuiteClasses; - import com.in28minutes.junit.helper.ArraysTest; import com.in28minutes.junit.helper.StringHelperTest; +import org.junit.platform.suite.api.SelectClasses; +import org.junit.platform.suite.api.Suite; -@RunWith(Suite.class) -@SuiteClasses({ArraysTest.class,StringHelperTest.class}) +@Suite +@SelectClasses({ArraysTest.class,StringHelperTest.class}) public class DummyTestSuite { } @@ -1445,9 +1465,9 @@ public class DummyTestSuite { ``` package com.in28minutes.mockito; -import static org.junit.Assert.assertTrue; +import static org.junit.jupiter.api.Assertions.assertTrue; -import org.junit.Test; +import org.junit.jupiter.api.Test; public class FirstMockitoTest { @@ -1457,6 +1477,7 @@ public class FirstMockitoTest { } } + ``` ### /src/test/java/com/in28minutes/mockito/HamcrestMatcherTest.java ``` @@ -1476,7 +1497,7 @@ import static org.hamcrest.core.Every.everyItem; import java.util.Arrays; import java.util.List; -import org.junit.Test; +import org.junit.jupiter.api.Test; public class HamcrestMatcherTest { @@ -1506,16 +1527,15 @@ public class HamcrestMatcherTest { package com.in28minutes.mockito; import static org.hamcrest.CoreMatchers.is; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertNull; -import static org.junit.Assert.assertThat; +import static org.hamcrest.MatcherAssert.assertThat; +import static org.junit.jupiter.api.Assertions.*; import static org.mockito.BDDMockito.given; import static org.mockito.Mockito.mock; import static org.mockito.Mockito.when; import java.util.List; -import org.junit.Test; +import org.junit.jupiter.api.Test; import org.mockito.Mockito; public class ListTest { @@ -1543,12 +1563,14 @@ public class ListTest { assertNull(list.get(1)); } - @Test(expected = RuntimeException.class) + @Test public void letsMockListGetToThrowException() { - List list = mock(List.class); - when(list.get(Mockito.anyInt())).thenThrow( - new RuntimeException("Something went wrong")); - list.get(0); + assertThrows(RuntimeException.class, () -> { + List list = mock(List.class); + when(list.get(Mockito.anyInt())).thenThrow( + new RuntimeException("Something went wrong")); + list.get(0); + }); } @Test @@ -1578,15 +1600,14 @@ public class ListTest { ``` package com.in28minutes.mockito; -import static org.junit.Assert.assertEquals; +import static org.junit.jupiter.api.Assertions.assertEquals; import static org.mockito.Mockito.spy; -import static org.mockito.Mockito.stub; import static org.mockito.Mockito.verify; import java.util.ArrayList; import java.util.List; -import org.junit.Test; +import org.junit.jupiter.api.Test; public class SpyTest { @@ -1602,44 +1623,27 @@ public class SpyTest { assertEquals(2, listSpy.size()); assertEquals("Ranga", listSpy.get(0)); } - - @Test - public void creatingASpyOnArrayList_overridingSpecificMethods() { - List listSpy = spy(ArrayList.class); - listSpy.add("Ranga"); - listSpy.add("in28Minutes"); - - stub(listSpy.size()).toReturn(-1); - - assertEquals(-1, listSpy.size()); - assertEquals("Ranga", listSpy.get(0)); - - // @Spy Annotation - } - } ``` -### /src/test/java/com/in28minutes/powermock/PowerMockitoMockingStaticMethodTest.java +### /src/test/java/com/in28minutes/powermock/MockitoMockingStaticMethodTest.java ``` package com.in28minutes.powermock; -import static org.junit.Assert.assertEquals; -import static org.mockito.Matchers.anyLong; -import static org.mockito.Mockito.when; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.mockito.ArgumentMatchers.anyLong; +import static org.mockito.Mockito.*; import java.util.Arrays; -import org.junit.Test; -import org.junit.runner.RunWith; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.extension.ExtendWith; import org.mockito.InjectMocks; import org.mockito.Mock; -import org.powermock.api.mockito.PowerMockito; -import org.powermock.core.classloader.annotations.PrepareForTest; -import org.powermock.modules.junit4.PowerMockRunner; +import org.mockito.MockedStatic; +import org.mockito.junit.jupiter.MockitoExtension; -@RunWith(PowerMockRunner.class) -@PrepareForTest({ UtilityClass.class /*The class with static method to be mocked*/}) -public class PowerMockitoMockingStaticMethodTest { +@ExtendWith(MockitoExtension.class) +public class MockitoMockingStaticMethodTest { @Mock Dependency dependencyMock; @@ -1649,25 +1653,15 @@ public class PowerMockitoMockingStaticMethodTest { @Test public void powerMockito_MockingAStaticMethodCall() { + when(dependencyMock.retrieveAllStats()).thenReturn(Arrays.asList(1, 2, 3)); - when(dependencyMock.retrieveAllStats()).thenReturn( - Arrays.asList(1, 2, 3)); - - PowerMockito.mockStatic(UtilityClass.class); + MockedStatic mockedStatic = mockStatic(UtilityClass.class); - when(UtilityClass.staticMethod(anyLong())).thenReturn(150); + mockedStatic.when(() -> UtilityClass.staticMethod(anyLong())).thenReturn(150); assertEquals(150, systemUnderTest.methodCallingAStaticMethod()); - //To verify a specific method call - //First : Call PowerMockito.verifyStatic() - //Second : Call the method to be verified - PowerMockito.verifyStatic(); - UtilityClass.staticMethod(1 + 2 + 3); - - // verify exact number of calls - //PowerMockito.verifyStatic(Mockito.times(1)); - + mockedStatic.verify(() -> UtilityClass.staticMethod(1 + 2 + 3), times(1)); } } ``` @@ -1675,19 +1669,19 @@ public class PowerMockitoMockingStaticMethodTest { ``` package com.in28minutes.powermock; -import static org.junit.Assert.assertEquals; +import static org.junit.jupiter.api.Assertions.assertEquals; import static org.mockito.Mockito.when; +import java.lang.reflect.Method; import java.util.Arrays; -import org.junit.Test; -import org.junit.runner.RunWith; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.extension.ExtendWith; import org.mockito.InjectMocks; import org.mockito.Mock; -import org.powermock.modules.junit4.PowerMockRunner; -import org.powermock.reflect.Whitebox; +import org.mockito.junit.jupiter.MockitoExtension; -@RunWith(PowerMockRunner.class) +@ExtendWith(MockitoExtension.class) public class PowerMockitoTestingPrivateMethodTest { @Mock @@ -1698,10 +1692,10 @@ public class PowerMockitoTestingPrivateMethodTest { @Test public void powerMockito_CallingAPrivateMethod() throws Exception { - when(dependencyMock.retrieveAllStats()).thenReturn( - Arrays.asList(1, 2, 3)); - long value = (Long) Whitebox.invokeMethod(systemUnderTest, - "privateMethodUnderTest"); + Method method = systemUnderTest.getClass().getDeclaredMethod("privateMethodUnderTest"); + method.setAccessible(true); + when(dependencyMock.retrieveAllStats()).thenReturn(Arrays.asList(1, 2, 3)); + long value = (Long) method.invoke(systemUnderTest); assertEquals(6, value); } } diff --git a/Step17.md b/Step17.md index 80fd744..0c206f4 100644 --- a/Step17.md +++ b/Step17.md @@ -14,34 +14,51 @@ mockito-tutorial 0.0.1-SNAPSHOT + + org.junit.jupiter + junit-jupiter + 5.10.2 + test + - junit - junit - 4.12 + org.junit.jupiter + junit-jupiter-api + 5.10.2 test + + org.junit.platform + junit-platform-suite-engine + 1.10.2 + org.mockito - mockito-all - 1.10.19 + mockito-inline + 3.6.0 test org.hamcrest - hamcrest-library - 1.3 + hamcrest + 2.2 + test + + + org.mockito + mockito-core + 5.4.0 test - org.powermock - powermock-api-mockito - 1.6.4 + org.mockito + mockito-junit-jupiter + 4.5.1 test - org.powermock - powermock-module-junit4 - 1.6.4 + org.hamcrest + hamcrest-library + 1.3 test @@ -51,8 +68,7 @@ org.apache.maven.plugins maven-compiler-plugin - 1.8 - 1.8 + 21 @@ -716,16 +732,16 @@ public class UtilityClass { ``` package com.clarity.business; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.fail; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertThrows; import java.math.BigDecimal; import java.util.ArrayList; import java.util.List; -import org.junit.Test; - import com.in28minutes.junit.business.ClientBO; + +import org.junit.jupiter.api.Test; import com.in28minutes.junit.business.ClientBOImpl; import com.in28minutes.junit.business.exception.DifferentCurrenciesException; import com.in28minutes.junit.model.Amount; @@ -758,23 +774,25 @@ public class ClientBOTest { assertEquals(new BigDecimal("11.0"), temp.getValue()); } - @Test(expected = DifferentCurrenciesException.class) + @Test public void testClientProductSum1() throws DifferentCurrenciesException { + assertThrows(DifferentCurrenciesException.class, () -> { - List products = new ArrayList(); + List products = new ArrayList(); - products.add(new ProductImpl(100, "Product 15", - ProductType.BANK_GUARANTEE, new AmountImpl( - new BigDecimal("5.0"), Currency.INDIAN_RUPEE))); + products.add(new ProductImpl(100, "Product 15", + ProductType.BANK_GUARANTEE, new AmountImpl( + new BigDecimal("5.0"), Currency.INDIAN_RUPEE))); - products.add(new ProductImpl(120, "Product 20", - ProductType.BANK_GUARANTEE, new AmountImpl( - new BigDecimal("6.0"), Currency.EURO))); + products.add(new ProductImpl(120, "Product 20", + ProductType.BANK_GUARANTEE, new AmountImpl( + new BigDecimal("6.0"), Currency.EURO))); - @SuppressWarnings("unused") - Amount temp = null; + @SuppressWarnings("unused") + Amount temp = null; - temp = clientBO.getClientProductsSum(products); + temp = clientBO.getClientProductsSum(products); + }); } @Test @@ -798,15 +816,16 @@ public class ClientBOTest { ``` package com.clarity.business; -import static org.junit.Assert.assertEquals; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertThrows; import java.math.BigDecimal; import java.util.ArrayList; import java.util.List; -import org.junit.Test; - import com.in28minutes.junit.business.ClientBO; + +import org.junit.jupiter.api.Test; import com.in28minutes.junit.business.ClientBOImpl; import com.in28minutes.junit.business.exception.DifferentCurrenciesException; import com.in28minutes.junit.model.Amount; @@ -837,18 +856,21 @@ public class ClientBOTestRefactored { assertAmount(actual, expected); } - @Test(expected = DifferentCurrenciesException.class) + @Test public void testClientProductSum_DifferentCurrencies_ThrowsException() throws DifferentCurrenciesException { + assertThrows(DifferentCurrenciesException.class, () -> { - Amount[] amounts = { - new AmountImpl(new BigDecimal("5.0"), Currency.EURO), - new AmountImpl(new BigDecimal("6.0"), Currency.INDIAN_RUPEE) }; + Amount[] amounts = { + new AmountImpl(new BigDecimal("5.0"), Currency.EURO), + new AmountImpl(new BigDecimal("6.0"), Currency.INDIAN_RUPEE)}; - List products = createProductListWithAmounts(amounts); + List products = createProductListWithAmounts(amounts); - @SuppressWarnings("unused") - Amount actual = clientBO.getClientProductsSum(products); + @SuppressWarnings("unused") + Amount actual = clientBO.getClientProductsSum(products); + + }); } @@ -888,8 +910,8 @@ public class ClientBOTestRefactored { package com.in28minutes.business; import static org.hamcrest.CoreMatchers.is; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertThat; +import static org.hamcrest.MatcherAssert.assertThat; +import static org.junit.jupiter.api.Assertions.assertEquals; import static org.mockito.BDDMockito.given; import static org.mockito.Mockito.verify; import static org.mockito.Mockito.when; @@ -897,18 +919,18 @@ import static org.mockito.Mockito.when; import java.util.Arrays; import java.util.List; -import org.junit.Test; -import org.junit.runner.RunWith; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.extension.ExtendWith; import org.mockito.ArgumentCaptor; import org.mockito.Captor; import org.mockito.InjectMocks; import org.mockito.Mock; import org.mockito.Mockito; -import org.mockito.runners.MockitoJUnitRunner; +import org.mockito.junit.jupiter.MockitoExtension; import com.in28minutes.data.api.TodoService; -@RunWith(MockitoJUnitRunner.class) +@ExtendWith(MockitoExtension.class) public class TodoBusinessImplMockitoInjectMocksTest { @Mock TodoService todoService; @@ -986,8 +1008,8 @@ public class TodoBusinessImplMockitoInjectMocksTest { package com.in28minutes.business; import static org.hamcrest.CoreMatchers.is; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertThat; +import static org.hamcrest.MatcherAssert.assertThat; +import static org.junit.jupiter.api.Assertions.assertEquals; import static org.mockito.BDDMockito.given; import static org.mockito.Mockito.verify; import static org.mockito.Mockito.when; @@ -995,23 +1017,20 @@ import static org.mockito.Mockito.when; import java.util.Arrays; import java.util.List; -import org.junit.Rule; -import org.junit.Test; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.extension.ExtendWith; import org.mockito.ArgumentCaptor; import org.mockito.Captor; import org.mockito.InjectMocks; import org.mockito.Mock; import org.mockito.Mockito; -import org.mockito.junit.MockitoJUnit; -import org.mockito.junit.MockitoRule; +import org.mockito.junit.jupiter.MockitoExtension; import com.in28minutes.data.api.TodoService; +@ExtendWith(MockitoExtension.class) public class TodoBusinessImplMockitoRulesTest { - @Rule - public MockitoRule mockitoRule = MockitoJUnit.rule(); - @Mock TodoService todoService; @@ -1088,8 +1107,8 @@ public class TodoBusinessImplMockitoRulesTest { package com.in28minutes.business; import static org.hamcrest.CoreMatchers.is; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertThat; +import static org.hamcrest.MatcherAssert.assertThat; +import static org.junit.jupiter.api.Assertions.assertEquals; import static org.mockito.BDDMockito.given; import static org.mockito.Mockito.mock; import static org.mockito.Mockito.verify; @@ -1098,7 +1117,7 @@ import static org.mockito.Mockito.when; import java.util.Arrays; import java.util.List; -import org.junit.Test; +import org.junit.jupiter.api.Test; import org.mockito.ArgumentCaptor; import org.mockito.Mockito; @@ -1184,13 +1203,13 @@ public class TodoBusinessImplMockitoTest { ``` package com.in28minutes.business; -import static org.junit.Assert.assertEquals; +import static org.junit.jupiter.api.Assertions.assertEquals; import java.util.List; -import org.junit.Test; - import com.in28minutes.data.api.TodoService; + +import org.junit.jupiter.api.Test; import com.in28minutes.data.stub.TodoServiceStub; public class TodoBusinessImplStubTest { @@ -1229,11 +1248,13 @@ public class TodoServiceStub implements TodoService { ``` package com.in28minutes.junit.helper; -import static org.junit.Assert.*; +import static org.junit.jupiter.api.Assertions.assertThrows; +import static org.junit.jupiter.api.Assertions.assertArrayEquals; import java.util.Arrays; -import org.junit.Test; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.Timeout; public class ArraysCompareTest { @@ -1245,14 +1266,17 @@ public class ArraysCompareTest { assertArrayEquals(expected, numbers); } - @Test(expected=NullPointerException.class) + @Test public void testArraySort_NullArray() { - int[] numbers = null; - Arrays.sort(numbers); + assertThrows(NullPointerException.class, () -> { + int[] numbers = null; + Arrays.sort(numbers); + }); } - - @Test(timeout=100) - public void testSort_Performance(){ + + @Test + @Timeout(value = 100) + public void testSort_Performance() { int array[] = {12,23,4}; for(int i=1;i<=1000000;i++) { @@ -1267,16 +1291,15 @@ public class ArraysCompareTest { ``` package com.in28minutes.junit.helper; -import static org.junit.Assert.*; - - import java.util.Arrays; -import org.junit.Test; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.Timeout; public class ArraysTest { - @Test(timeout=100) - public void testPerformance() { + @Test + @Timeout(value = 100) + public void performance() { for(int i=0;i<1000000;i++){ Arrays.sort(new int[]{i,i-1,i+1}); } @@ -1287,22 +1310,20 @@ public class ArraysTest { ``` package com.in28minutes.junit.helper; -import static org.junit.Assert.*; - -import org.junit.After; -import org.junit.AfterClass; -import org.junit.Before; -import org.junit.BeforeClass; -import org.junit.Test; +import org.junit.jupiter.api.AfterAll; +import org.junit.jupiter.api.AfterEach; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; public class QuickBeforeAfterTest { - - @BeforeClass + + @BeforeAll public static void beforeClass(){ System.out.println("Before Class"); } - - @Before + + @BeforeEach public void setup(){ System.out.println("Before Test"); } @@ -1316,35 +1337,32 @@ public class QuickBeforeAfterTest { public void test2() { System.out.println("test2 executed"); } - - @After + + @AfterEach public void teardown() { System.out.println("After test"); } - - @AfterClass + + @AfterAll public static void afterClass(){ System.out.println("After Class"); } } + ``` ### /src/test/java/com/in28minutes/junit/helper/StringHelperParameterizedTest.java ``` package com.in28minutes.junit.helper; -import static org.junit.Assert.*; +import static org.junit.jupiter.api.Assertions.assertEquals; import java.util.Arrays; import java.util.Collection; -import org.junit.Before; -import org.junit.Test; -import org.junit.runner.RunWith; -import org.junit.runners.Parameterized; -import org.junit.runners.Parameterized.Parameters; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.MethodSource; -@RunWith(Parameterized.class) public class StringHelperParameterizedTest { // AACD => CD ACD => CD CDEF=>CDEF CDAA => CDAA @@ -1353,13 +1371,12 @@ public class StringHelperParameterizedTest { private String input; private String expectedOutput; - - public StringHelperParameterizedTest(String input, String expectedOutput) { + + public void initStringHelperParameterizedTest(String input, String expectedOutput) { this.input = input; this.expectedOutput = expectedOutput; } - @Parameters public static Collection testConditions() { String expectedOutputs[][] = { { "AACD", "CD" }, @@ -1367,33 +1384,36 @@ public class StringHelperParameterizedTest { return Arrays.asList(expectedOutputs); } - @Test - public void testTruncateAInFirst2Positions() { + @MethodSource("testConditions") + @ParameterizedTest + public void truncateAInFirst2Positions(String input, String expectedOutput) { + initStringHelperParameterizedTest(input, expectedOutput); assertEquals(expectedOutput, helper.truncateAInFirst2Positions(input)); } } + ``` ### /src/test/java/com/in28minutes/junit/helper/StringHelperTest.java ``` package com.in28minutes.junit.helper; -import static org.junit.Assert.*; +import static org.junit.jupiter.api.Assertions.*; -import org.junit.Before; -import org.junit.Test; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; public class StringHelperTest { // AACD => CD ACD => CD CDEF=>CDEF CDAA => CDAA StringHelper helper; - - @Before + + @BeforeEach public void before(){ helper = new StringHelper(); } - + @Test public void testTruncateAInFirst2Positions_AinFirst2Positions() { @@ -1425,15 +1445,13 @@ public class StringHelperTest { ``` package com.in28minutes.junit.suite; -import org.junit.runner.RunWith; -import org.junit.runners.Suite; -import org.junit.runners.Suite.SuiteClasses; - import com.in28minutes.junit.helper.ArraysTest; import com.in28minutes.junit.helper.StringHelperTest; +import org.junit.platform.suite.api.SelectClasses; +import org.junit.platform.suite.api.Suite; -@RunWith(Suite.class) -@SuiteClasses({ArraysTest.class,StringHelperTest.class}) +@Suite +@SelectClasses({ArraysTest.class,StringHelperTest.class}) public class DummyTestSuite { } @@ -1442,9 +1460,9 @@ public class DummyTestSuite { ``` package com.in28minutes.mockito; -import static org.junit.Assert.assertTrue; +import static org.junit.jupiter.api.Assertions.assertTrue; -import org.junit.Test; +import org.junit.jupiter.api.Test; public class FirstMockitoTest { @@ -1473,7 +1491,7 @@ import static org.hamcrest.core.Every.everyItem; import java.util.Arrays; import java.util.List; -import org.junit.Test; +import org.junit.jupiter.api.Test; public class HamcrestMatcherTest { @@ -1503,16 +1521,15 @@ public class HamcrestMatcherTest { package com.in28minutes.mockito; import static org.hamcrest.CoreMatchers.is; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertNull; -import static org.junit.Assert.assertThat; +import static org.hamcrest.MatcherAssert.assertThat; +import static org.junit.jupiter.api.Assertions.*; import static org.mockito.BDDMockito.given; import static org.mockito.Mockito.mock; import static org.mockito.Mockito.when; import java.util.List; -import org.junit.Test; +import org.junit.jupiter.api.Test; import org.mockito.Mockito; public class ListTest { @@ -1540,12 +1557,14 @@ public class ListTest { assertNull(list.get(1)); } - @Test(expected = RuntimeException.class) + @Test public void letsMockListGetToThrowException() { - List list = mock(List.class); - when(list.get(Mockito.anyInt())).thenThrow( - new RuntimeException("Something went wrong")); - list.get(0); + assertThrows(RuntimeException.class, () -> { + List list = mock(List.class); + when(list.get(Mockito.anyInt())).thenThrow( + new RuntimeException("Something went wrong")); + list.get(0); + }); } @Test @@ -1575,15 +1594,14 @@ public class ListTest { ``` package com.in28minutes.mockito; -import static org.junit.Assert.assertEquals; +import static org.junit.jupiter.api.Assertions.assertEquals; import static org.mockito.Mockito.spy; -import static org.mockito.Mockito.stub; import static org.mockito.Mockito.verify; import java.util.ArrayList; import java.util.List; -import org.junit.Test; +import org.junit.jupiter.api.Test; public class SpyTest { @@ -1599,90 +1617,28 @@ public class SpyTest { assertEquals(2, listSpy.size()); assertEquals("Ranga", listSpy.get(0)); } - - @Test - public void creatingASpyOnArrayList_overridingSpecificMethods() { - List listSpy = spy(ArrayList.class); - listSpy.add("Ranga"); - listSpy.add("in28Minutes"); - - stub(listSpy.size()).toReturn(-1); - - assertEquals(-1, listSpy.size()); - assertEquals("Ranga", listSpy.get(0)); - - // @Spy Annotation - } - } ``` -### /src/test/java/com/in28minutes/powermock/PowerMockitoMockingConstructorTest.java -``` -package com.in28minutes.powermock; - -import static org.junit.Assert.assertEquals; -import static org.mockito.Mockito.mock; -import static org.mockito.Mockito.stub; - -import java.util.ArrayList; - -import org.junit.Test; -import org.junit.runner.RunWith; -import org.mockito.InjectMocks; -import org.mockito.Mock; -import org.powermock.api.mockito.PowerMockito; -import org.powermock.core.classloader.annotations.PrepareForTest; -import org.powermock.modules.junit4.PowerMockRunner; - -@RunWith(PowerMockRunner.class) -@PrepareForTest({ SystemUnderTest.class /*To be able to mock the Constructor, we need to add in the Class that creates the new object*/}) -public class PowerMockitoMockingConstructorTest { - - private static final int SOME_DUMMY_SIZE = 100; - - @Mock - Dependency dependencyMock; - - @InjectMocks - SystemUnderTest systemUnderTest; - @Test - public void powerMockito_MockingAConstructor() throws Exception { - - ArrayList mockList = mock(ArrayList.class); - - stub(mockList.size()).toReturn(SOME_DUMMY_SIZE); - - PowerMockito.whenNew(ArrayList.class).withAnyArguments().thenReturn( - mockList); - - int size = systemUnderTest.methodUsingAnArrayListConstructor(); - - assertEquals(SOME_DUMMY_SIZE, size); - } -} -``` -### /src/test/java/com/in28minutes/powermock/PowerMockitoMockingStaticMethodTest.java +### /src/test/java/com/in28minutes/powermock/MockitoMockingStaticMethodTest.java ``` package com.in28minutes.powermock; -import static org.junit.Assert.assertEquals; -import static org.mockito.Matchers.anyLong; -import static org.mockito.Mockito.when; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.mockito.ArgumentMatchers.anyLong; +import static org.mockito.Mockito.*; import java.util.Arrays; -import org.junit.Test; -import org.junit.runner.RunWith; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.extension.ExtendWith; import org.mockito.InjectMocks; import org.mockito.Mock; -import org.powermock.api.mockito.PowerMockito; -import org.powermock.core.classloader.annotations.PrepareForTest; -import org.powermock.modules.junit4.PowerMockRunner; +import org.mockito.MockedStatic; +import org.mockito.junit.jupiter.MockitoExtension; -@RunWith(PowerMockRunner.class) -@PrepareForTest({ UtilityClass.class /*The class with static method to be mocked*/}) -public class PowerMockitoMockingStaticMethodTest { +@ExtendWith(MockitoExtension.class) +public class MockitoMockingStaticMethodTest { @Mock Dependency dependencyMock; @@ -1692,25 +1648,15 @@ public class PowerMockitoMockingStaticMethodTest { @Test public void powerMockito_MockingAStaticMethodCall() { + when(dependencyMock.retrieveAllStats()).thenReturn(Arrays.asList(1, 2, 3)); - when(dependencyMock.retrieveAllStats()).thenReturn( - Arrays.asList(1, 2, 3)); + MockedStatic mockedStatic = mockStatic(UtilityClass.class); - PowerMockito.mockStatic(UtilityClass.class); - - when(UtilityClass.staticMethod(anyLong())).thenReturn(150); + mockedStatic.when(() -> UtilityClass.staticMethod(anyLong())).thenReturn(150); assertEquals(150, systemUnderTest.methodCallingAStaticMethod()); - //To verify a specific method call - //First : Call PowerMockito.verifyStatic() - //Second : Call the method to be verified - PowerMockito.verifyStatic(); - UtilityClass.staticMethod(1 + 2 + 3); - - // verify exact number of calls - //PowerMockito.verifyStatic(Mockito.times(1)); - + mockedStatic.verify(() -> UtilityClass.staticMethod(1 + 2 + 3), times(1)); } } ``` @@ -1718,19 +1664,19 @@ public class PowerMockitoMockingStaticMethodTest { ``` package com.in28minutes.powermock; -import static org.junit.Assert.assertEquals; +import static org.junit.jupiter.api.Assertions.assertEquals; import static org.mockito.Mockito.when; +import java.lang.reflect.Method; import java.util.Arrays; -import org.junit.Test; -import org.junit.runner.RunWith; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.extension.ExtendWith; import org.mockito.InjectMocks; import org.mockito.Mock; -import org.powermock.modules.junit4.PowerMockRunner; -import org.powermock.reflect.Whitebox; +import org.mockito.junit.jupiter.MockitoExtension; -@RunWith(PowerMockRunner.class) +@ExtendWith(MockitoExtension.class) public class PowerMockitoTestingPrivateMethodTest { @Mock @@ -1741,10 +1687,10 @@ public class PowerMockitoTestingPrivateMethodTest { @Test public void powerMockito_CallingAPrivateMethod() throws Exception { - when(dependencyMock.retrieveAllStats()).thenReturn( - Arrays.asList(1, 2, 3)); - long value = (Long) Whitebox.invokeMethod(systemUnderTest, - "privateMethodUnderTest"); + Method method = systemUnderTest.getClass().getDeclaredMethod("privateMethodUnderTest"); + method.setAccessible(true); + when(dependencyMock.retrieveAllStats()).thenReturn(Arrays.asList(1, 2, 3)); + long value = (Long) method.invoke(systemUnderTest); assertEquals(6, value); } } diff --git a/pom.xml b/pom.xml index 704018b..92f1a9e 100644 --- a/pom.xml +++ b/pom.xml @@ -6,33 +6,50 @@ 0.0.1-SNAPSHOT - junit - junit - 4.12 + org.junit.jupiter + junit-jupiter + 5.10.2 test + + org.junit.jupiter + junit-jupiter-api + 5.10.2 + test + + + org.junit.platform + junit-platform-suite-engine + 1.10.2 + org.mockito - mockito-all - 1.10.19 + mockito-inline + 3.6.0 test org.hamcrest - hamcrest-library - 1.3 + hamcrest + 2.2 test - org.powermock - powermock-api-mockito - 1.6.4 + org.mockito + mockito-core + 5.4.0 test - org.powermock - powermock-module-junit4 - 1.6.4 + org.mockito + mockito-junit-jupiter + 4.5.1 + test + + + org.hamcrest + hamcrest-library + 1.3 test @@ -42,8 +59,7 @@ org.apache.maven.plugins maven-compiler-plugin - 1.8 - 1.8 + 21 diff --git a/src/test/java/com/clarity/business/ClientBOTest.java b/src/test/java/com/clarity/business/ClientBOTest.java index ddd6e55..0803cc5 100644 --- a/src/test/java/com/clarity/business/ClientBOTest.java +++ b/src/test/java/com/clarity/business/ClientBOTest.java @@ -1,15 +1,15 @@ package com.clarity.business; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.fail; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertThrows; import java.math.BigDecimal; import java.util.ArrayList; import java.util.List; -import org.junit.Test; - import com.in28minutes.junit.business.ClientBO; + +import org.junit.jupiter.api.Test; import com.in28minutes.junit.business.ClientBOImpl; import com.in28minutes.junit.business.exception.DifferentCurrenciesException; import com.in28minutes.junit.model.Amount; @@ -42,23 +42,25 @@ ProductType.BANK_GUARANTEE, new AmountImpl( assertEquals(new BigDecimal("11.0"), temp.getValue()); } - @Test(expected = DifferentCurrenciesException.class) + @Test public void testClientProductSum1() throws DifferentCurrenciesException { + assertThrows(DifferentCurrenciesException.class, () -> { - List products = new ArrayList(); + List products = new ArrayList(); - products.add(new ProductImpl(100, "Product 15", - ProductType.BANK_GUARANTEE, new AmountImpl( - new BigDecimal("5.0"), Currency.INDIAN_RUPEE))); + products.add(new ProductImpl(100, "Product 15", + ProductType.BANK_GUARANTEE, new AmountImpl( + new BigDecimal("5.0"), Currency.INDIAN_RUPEE))); - products.add(new ProductImpl(120, "Product 20", - ProductType.BANK_GUARANTEE, new AmountImpl( - new BigDecimal("6.0"), Currency.EURO))); + products.add(new ProductImpl(120, "Product 20", + ProductType.BANK_GUARANTEE, new AmountImpl( + new BigDecimal("6.0"), Currency.EURO))); - @SuppressWarnings("unused") - Amount temp = null; + @SuppressWarnings("unused") + Amount temp = null; - temp = clientBO.getClientProductsSum(products); + temp = clientBO.getClientProductsSum(products); + }); } @Test diff --git a/src/test/java/com/clarity/business/ClientBOTestRefactored.java b/src/test/java/com/clarity/business/ClientBOTestRefactored.java index e7a324c..1eb04e5 100644 --- a/src/test/java/com/clarity/business/ClientBOTestRefactored.java +++ b/src/test/java/com/clarity/business/ClientBOTestRefactored.java @@ -1,14 +1,15 @@ package com.clarity.business; -import static org.junit.Assert.assertEquals; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertThrows; import java.math.BigDecimal; import java.util.ArrayList; import java.util.List; -import org.junit.Test; - import com.in28minutes.junit.business.ClientBO; + +import org.junit.jupiter.api.Test; import com.in28minutes.junit.business.ClientBOImpl; import com.in28minutes.junit.business.exception.DifferentCurrenciesException; import com.in28minutes.junit.model.Amount; @@ -39,18 +40,21 @@ public void testClientProductSum_AllProductsSameCurrency() assertAmount(actual, expected); } - @Test(expected = DifferentCurrenciesException.class) + @Test public void testClientProductSum_DifferentCurrencies_ThrowsException() throws DifferentCurrenciesException { + assertThrows(DifferentCurrenciesException.class, () -> { - Amount[] amounts = { - new AmountImpl(new BigDecimal("5.0"), Currency.EURO), - new AmountImpl(new BigDecimal("6.0"), Currency.INDIAN_RUPEE) }; + Amount[] amounts = { + new AmountImpl(new BigDecimal("5.0"), Currency.EURO), + new AmountImpl(new BigDecimal("6.0"), Currency.INDIAN_RUPEE)}; - List products = createProductListWithAmounts(amounts); + List products = createProductListWithAmounts(amounts); - @SuppressWarnings("unused") - Amount actual = clientBO.getClientProductsSum(products); + @SuppressWarnings("unused") + Amount actual = clientBO.getClientProductsSum(products); + + }); } diff --git a/src/test/java/com/in28minutes/business/TodoBusinessImplMockitoInjectMocksTest.java b/src/test/java/com/in28minutes/business/TodoBusinessImplMockitoInjectMocksTest.java index 4308550..4fcf96b 100644 --- a/src/test/java/com/in28minutes/business/TodoBusinessImplMockitoInjectMocksTest.java +++ b/src/test/java/com/in28minutes/business/TodoBusinessImplMockitoInjectMocksTest.java @@ -1,8 +1,8 @@ package com.in28minutes.business; import static org.hamcrest.CoreMatchers.is; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertThat; +import static org.hamcrest.MatcherAssert.assertThat; +import static org.junit.jupiter.api.Assertions.assertEquals; import static org.mockito.BDDMockito.given; import static org.mockito.Mockito.verify; import static org.mockito.Mockito.when; @@ -10,18 +10,18 @@ import java.util.Arrays; import java.util.List; -import org.junit.Test; -import org.junit.runner.RunWith; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.extension.ExtendWith; import org.mockito.ArgumentCaptor; import org.mockito.Captor; import org.mockito.InjectMocks; import org.mockito.Mock; import org.mockito.Mockito; -import org.mockito.runners.MockitoJUnitRunner; +import org.mockito.junit.jupiter.MockitoExtension; import com.in28minutes.data.api.TodoService; -@RunWith(MockitoJUnitRunner.class) +@ExtendWith(MockitoExtension.class) public class TodoBusinessImplMockitoInjectMocksTest { @Mock TodoService todoService; diff --git a/src/test/java/com/in28minutes/business/TodoBusinessImplMockitoRulesTest.java b/src/test/java/com/in28minutes/business/TodoBusinessImplMockitoRulesTest.java index 942292a..88403bd 100644 --- a/src/test/java/com/in28minutes/business/TodoBusinessImplMockitoRulesTest.java +++ b/src/test/java/com/in28minutes/business/TodoBusinessImplMockitoRulesTest.java @@ -1,8 +1,8 @@ package com.in28minutes.business; import static org.hamcrest.CoreMatchers.is; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertThat; +import static org.hamcrest.MatcherAssert.assertThat; +import static org.junit.jupiter.api.Assertions.assertEquals; import static org.mockito.BDDMockito.given; import static org.mockito.Mockito.verify; import static org.mockito.Mockito.when; @@ -10,23 +10,20 @@ import java.util.Arrays; import java.util.List; -import org.junit.Rule; -import org.junit.Test; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.extension.ExtendWith; import org.mockito.ArgumentCaptor; import org.mockito.Captor; import org.mockito.InjectMocks; import org.mockito.Mock; import org.mockito.Mockito; -import org.mockito.junit.MockitoJUnit; -import org.mockito.junit.MockitoRule; +import org.mockito.junit.jupiter.MockitoExtension; import com.in28minutes.data.api.TodoService; +@ExtendWith(MockitoExtension.class) public class TodoBusinessImplMockitoRulesTest { - @Rule - public MockitoRule mockitoRule = MockitoJUnit.rule(); - @Mock TodoService todoService; diff --git a/src/test/java/com/in28minutes/business/TodoBusinessImplMockitoTest.java b/src/test/java/com/in28minutes/business/TodoBusinessImplMockitoTest.java index f4b9ef4..002e180 100644 --- a/src/test/java/com/in28minutes/business/TodoBusinessImplMockitoTest.java +++ b/src/test/java/com/in28minutes/business/TodoBusinessImplMockitoTest.java @@ -1,8 +1,8 @@ package com.in28minutes.business; import static org.hamcrest.CoreMatchers.is; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertThat; +import static org.hamcrest.MatcherAssert.assertThat; +import static org.junit.jupiter.api.Assertions.assertEquals; import static org.mockito.BDDMockito.given; import static org.mockito.Mockito.mock; import static org.mockito.Mockito.verify; @@ -11,7 +11,7 @@ import java.util.Arrays; import java.util.List; -import org.junit.Test; +import org.junit.jupiter.api.Test; import org.mockito.ArgumentCaptor; import org.mockito.Mockito; diff --git a/src/test/java/com/in28minutes/business/TodoBusinessImplStubTest.java b/src/test/java/com/in28minutes/business/TodoBusinessImplStubTest.java index 8e7b33a..432f977 100644 --- a/src/test/java/com/in28minutes/business/TodoBusinessImplStubTest.java +++ b/src/test/java/com/in28minutes/business/TodoBusinessImplStubTest.java @@ -1,12 +1,12 @@ package com.in28minutes.business; -import static org.junit.Assert.assertEquals; +import static org.junit.jupiter.api.Assertions.assertEquals; import java.util.List; -import org.junit.Test; - import com.in28minutes.data.api.TodoService; + +import org.junit.jupiter.api.Test; import com.in28minutes.data.stub.TodoServiceStub; public class TodoBusinessImplStubTest { diff --git a/src/test/java/com/in28minutes/junit/helper/ArraysCompareTest.java b/src/test/java/com/in28minutes/junit/helper/ArraysCompareTest.java index da54df7..fa60ad0 100644 --- a/src/test/java/com/in28minutes/junit/helper/ArraysCompareTest.java +++ b/src/test/java/com/in28minutes/junit/helper/ArraysCompareTest.java @@ -1,10 +1,12 @@ package com.in28minutes.junit.helper; -import static org.junit.Assert.*; +import static org.junit.jupiter.api.Assertions.assertThrows; +import static org.junit.jupiter.api.Assertions.assertArrayEquals; import java.util.Arrays; -import org.junit.Test; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.Timeout; public class ArraysCompareTest { @@ -16,14 +18,17 @@ public void testArraySort_RandomArray() { assertArrayEquals(expected, numbers); } - @Test(expected=NullPointerException.class) + @Test public void testArraySort_NullArray() { - int[] numbers = null; - Arrays.sort(numbers); + assertThrows(NullPointerException.class, () -> { + int[] numbers = null; + Arrays.sort(numbers); + }); } - - @Test(timeout=100) - public void testSort_Performance(){ + + @Test + @Timeout(value = 100) + public void testSort_Performance() { int array[] = {12,23,4}; for(int i=1;i<=1000000;i++) { diff --git a/src/test/java/com/in28minutes/junit/helper/ArraysTest.java b/src/test/java/com/in28minutes/junit/helper/ArraysTest.java index 757963e..94e3029 100644 --- a/src/test/java/com/in28minutes/junit/helper/ArraysTest.java +++ b/src/test/java/com/in28minutes/junit/helper/ArraysTest.java @@ -1,15 +1,14 @@ package com.in28minutes.junit.helper; -import static org.junit.Assert.*; - - import java.util.Arrays; -import org.junit.Test; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.Timeout; public class ArraysTest { - @Test(timeout=100) - public void testPerformance() { + @Test + @Timeout(value = 100) + public void performance() { for(int i=0;i<1000000;i++){ Arrays.sort(new int[]{i,i-1,i+1}); } diff --git a/src/test/java/com/in28minutes/junit/helper/QuickBeforeAfterTest.java b/src/test/java/com/in28minutes/junit/helper/QuickBeforeAfterTest.java index 379cfb5..da805dc 100644 --- a/src/test/java/com/in28minutes/junit/helper/QuickBeforeAfterTest.java +++ b/src/test/java/com/in28minutes/junit/helper/QuickBeforeAfterTest.java @@ -1,21 +1,19 @@ package com.in28minutes.junit.helper; -import static org.junit.Assert.*; - -import org.junit.After; -import org.junit.AfterClass; -import org.junit.Before; -import org.junit.BeforeClass; -import org.junit.Test; +import org.junit.jupiter.api.AfterAll; +import org.junit.jupiter.api.AfterEach; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; public class QuickBeforeAfterTest { - - @BeforeClass + + @BeforeAll public static void beforeClass(){ System.out.println("Before Class"); } - - @Before + + @BeforeEach public void setup(){ System.out.println("Before Test"); } @@ -29,13 +27,13 @@ public void test1() { public void test2() { System.out.println("test2 executed"); } - - @After + + @AfterEach public void teardown() { System.out.println("After test"); } - - @AfterClass + + @AfterAll public static void afterClass(){ System.out.println("After Class"); } diff --git a/src/test/java/com/in28minutes/junit/helper/StringHelperParameterizedTest.java b/src/test/java/com/in28minutes/junit/helper/StringHelperParameterizedTest.java index b996db3..8bd02b2 100644 --- a/src/test/java/com/in28minutes/junit/helper/StringHelperParameterizedTest.java +++ b/src/test/java/com/in28minutes/junit/helper/StringHelperParameterizedTest.java @@ -1,17 +1,13 @@ package com.in28minutes.junit.helper; -import static org.junit.Assert.*; +import static org.junit.jupiter.api.Assertions.assertEquals; import java.util.Arrays; import java.util.Collection; -import org.junit.Before; -import org.junit.Test; -import org.junit.runner.RunWith; -import org.junit.runners.Parameterized; -import org.junit.runners.Parameterized.Parameters; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.MethodSource; -@RunWith(Parameterized.class) public class StringHelperParameterizedTest { // AACD => CD ACD => CD CDEF=>CDEF CDAA => CDAA @@ -20,13 +16,12 @@ public class StringHelperParameterizedTest { private String input; private String expectedOutput; - - public StringHelperParameterizedTest(String input, String expectedOutput) { + + public void initStringHelperParameterizedTest(String input, String expectedOutput) { this.input = input; this.expectedOutput = expectedOutput; } - @Parameters public static Collection testConditions() { String expectedOutputs[][] = { { "AACD", "CD" }, @@ -34,8 +29,10 @@ public static Collection testConditions() { return Arrays.asList(expectedOutputs); } - @Test - public void testTruncateAInFirst2Positions() { + @MethodSource("testConditions") + @ParameterizedTest + public void truncateAInFirst2Positions(String input, String expectedOutput) { + initStringHelperParameterizedTest(input, expectedOutput); assertEquals(expectedOutput, helper.truncateAInFirst2Positions(input)); } diff --git a/src/test/java/com/in28minutes/junit/helper/StringHelperTest.java b/src/test/java/com/in28minutes/junit/helper/StringHelperTest.java index 6ca2f96..ad080f9 100644 --- a/src/test/java/com/in28minutes/junit/helper/StringHelperTest.java +++ b/src/test/java/com/in28minutes/junit/helper/StringHelperTest.java @@ -1,21 +1,21 @@ package com.in28minutes.junit.helper; -import static org.junit.Assert.*; +import static org.junit.jupiter.api.Assertions.*; -import org.junit.Before; -import org.junit.Test; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; public class StringHelperTest { // AACD => CD ACD => CD CDEF=>CDEF CDAA => CDAA StringHelper helper; - - @Before + + @BeforeEach public void before(){ helper = new StringHelper(); } - + @Test public void testTruncateAInFirst2Positions_AinFirst2Positions() { diff --git a/src/test/java/com/in28minutes/junit/suite/DummyTestSuite.java b/src/test/java/com/in28minutes/junit/suite/DummyTestSuite.java index 40dd944..06e3d1b 100644 --- a/src/test/java/com/in28minutes/junit/suite/DummyTestSuite.java +++ b/src/test/java/com/in28minutes/junit/suite/DummyTestSuite.java @@ -1,14 +1,12 @@ package com.in28minutes.junit.suite; -import org.junit.runner.RunWith; -import org.junit.runners.Suite; -import org.junit.runners.Suite.SuiteClasses; - import com.in28minutes.junit.helper.ArraysTest; import com.in28minutes.junit.helper.StringHelperTest; +import org.junit.platform.suite.api.SelectClasses; +import org.junit.platform.suite.api.Suite; -@RunWith(Suite.class) -@SuiteClasses({ArraysTest.class,StringHelperTest.class}) +@Suite +@SelectClasses({ArraysTest.class,StringHelperTest.class}) public class DummyTestSuite { } diff --git a/src/test/java/com/in28minutes/mockito/FirstMockitoTest.java b/src/test/java/com/in28minutes/mockito/FirstMockitoTest.java index f263491..d14b255 100644 --- a/src/test/java/com/in28minutes/mockito/FirstMockitoTest.java +++ b/src/test/java/com/in28minutes/mockito/FirstMockitoTest.java @@ -1,8 +1,8 @@ package com.in28minutes.mockito; -import static org.junit.Assert.assertTrue; +import static org.junit.jupiter.api.Assertions.assertTrue; -import org.junit.Test; +import org.junit.jupiter.api.Test; public class FirstMockitoTest { diff --git a/src/test/java/com/in28minutes/mockito/HamcrestMatcherTest.java b/src/test/java/com/in28minutes/mockito/HamcrestMatcherTest.java index 792da4d..7c308bc 100644 --- a/src/test/java/com/in28minutes/mockito/HamcrestMatcherTest.java +++ b/src/test/java/com/in28minutes/mockito/HamcrestMatcherTest.java @@ -14,7 +14,7 @@ import java.util.Arrays; import java.util.List; -import org.junit.Test; +import org.junit.jupiter.api.Test; public class HamcrestMatcherTest { diff --git a/src/test/java/com/in28minutes/mockito/ListTest.java b/src/test/java/com/in28minutes/mockito/ListTest.java index e035381..b0408f3 100644 --- a/src/test/java/com/in28minutes/mockito/ListTest.java +++ b/src/test/java/com/in28minutes/mockito/ListTest.java @@ -1,16 +1,15 @@ package com.in28minutes.mockito; import static org.hamcrest.CoreMatchers.is; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertNull; -import static org.junit.Assert.assertThat; +import static org.hamcrest.MatcherAssert.assertThat; +import static org.junit.jupiter.api.Assertions.*; import static org.mockito.BDDMockito.given; import static org.mockito.Mockito.mock; import static org.mockito.Mockito.when; import java.util.List; -import org.junit.Test; +import org.junit.jupiter.api.Test; import org.mockito.Mockito; public class ListTest { @@ -38,12 +37,14 @@ public void letsMockListGet() { assertNull(list.get(1)); } - @Test(expected = RuntimeException.class) + @Test public void letsMockListGetToThrowException() { - List list = mock(List.class); - when(list.get(Mockito.anyInt())).thenThrow( - new RuntimeException("Something went wrong")); - list.get(0); + assertThrows(RuntimeException.class, () -> { + List list = mock(List.class); + when(list.get(Mockito.anyInt())).thenThrow( + new RuntimeException("Something went wrong")); + list.get(0); + }); } @Test diff --git a/src/test/java/com/in28minutes/mockito/SpyTest.java b/src/test/java/com/in28minutes/mockito/SpyTest.java index e15ddc7..81ef0b3 100644 --- a/src/test/java/com/in28minutes/mockito/SpyTest.java +++ b/src/test/java/com/in28minutes/mockito/SpyTest.java @@ -1,14 +1,13 @@ package com.in28minutes.mockito; -import static org.junit.Assert.assertEquals; +import static org.junit.jupiter.api.Assertions.assertEquals; import static org.mockito.Mockito.spy; -import static org.mockito.Mockito.stub; import static org.mockito.Mockito.verify; import java.util.ArrayList; import java.util.List; -import org.junit.Test; +import org.junit.jupiter.api.Test; public class SpyTest { @@ -24,19 +23,4 @@ public void creatingASpyOnArrayList() { assertEquals(2, listSpy.size()); assertEquals("Ranga", listSpy.get(0)); } - - @Test - public void creatingASpyOnArrayList_overridingSpecificMethods() { - List listSpy = spy(ArrayList.class); - listSpy.add("Ranga"); - listSpy.add("in28Minutes"); - - stub(listSpy.size()).toReturn(-1); - - assertEquals(-1, listSpy.size()); - assertEquals("Ranga", listSpy.get(0)); - - // @Spy Annotation - } - } \ No newline at end of file diff --git a/src/test/java/com/in28minutes/powermock/MockitoMockingStaticMethodTest.java b/src/test/java/com/in28minutes/powermock/MockitoMockingStaticMethodTest.java new file mode 100644 index 0000000..1d938f7 --- /dev/null +++ b/src/test/java/com/in28minutes/powermock/MockitoMockingStaticMethodTest.java @@ -0,0 +1,37 @@ +package com.in28minutes.powermock; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.mockito.ArgumentMatchers.anyLong; +import static org.mockito.Mockito.*; + +import java.util.Arrays; + +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.extension.ExtendWith; +import org.mockito.InjectMocks; +import org.mockito.Mock; +import org.mockito.MockedStatic; +import org.mockito.junit.jupiter.MockitoExtension; + +@ExtendWith(MockitoExtension.class) +public class MockitoMockingStaticMethodTest { + + @Mock + Dependency dependencyMock; + + @InjectMocks + SystemUnderTest systemUnderTest; + + @Test + public void powerMockito_MockingAStaticMethodCall() { + when(dependencyMock.retrieveAllStats()).thenReturn(Arrays.asList(1, 2, 3)); + + MockedStatic mockedStatic = mockStatic(UtilityClass.class); + + mockedStatic.when(() -> UtilityClass.staticMethod(anyLong())).thenReturn(150); + + assertEquals(150, systemUnderTest.methodCallingAStaticMethod()); + + mockedStatic.verify(() -> UtilityClass.staticMethod(1 + 2 + 3), times(1)); + } +} \ No newline at end of file diff --git a/src/test/java/com/in28minutes/powermock/PowerMockitoMockingConstructorTest.java b/src/test/java/com/in28minutes/powermock/PowerMockitoMockingConstructorTest.java deleted file mode 100644 index 549f8d1..0000000 --- a/src/test/java/com/in28minutes/powermock/PowerMockitoMockingConstructorTest.java +++ /dev/null @@ -1,43 +0,0 @@ -package com.in28minutes.powermock; - -import static org.junit.Assert.assertEquals; -import static org.mockito.Mockito.mock; -import static org.mockito.Mockito.stub; - -import java.util.ArrayList; - -import org.junit.Test; -import org.junit.runner.RunWith; -import org.mockito.InjectMocks; -import org.mockito.Mock; -import org.powermock.api.mockito.PowerMockito; -import org.powermock.core.classloader.annotations.PrepareForTest; -import org.powermock.modules.junit4.PowerMockRunner; - -@RunWith(PowerMockRunner.class) -@PrepareForTest({ SystemUnderTest.class /*To be able to mock the Constructor, we need to add in the Class that creates the new object*/}) -public class PowerMockitoMockingConstructorTest { - - private static final int SOME_DUMMY_SIZE = 100; - - @Mock - Dependency dependencyMock; - - @InjectMocks - SystemUnderTest systemUnderTest; - - @Test - public void powerMockito_MockingAConstructor() throws Exception { - - ArrayList mockList = mock(ArrayList.class); - - stub(mockList.size()).toReturn(SOME_DUMMY_SIZE); - - PowerMockito.whenNew(ArrayList.class).withAnyArguments().thenReturn( - mockList); - - int size = systemUnderTest.methodUsingAnArrayListConstructor(); - - assertEquals(SOME_DUMMY_SIZE, size); - } -} \ No newline at end of file diff --git a/src/test/java/com/in28minutes/powermock/PowerMockitoMockingStaticMethodTest.java b/src/test/java/com/in28minutes/powermock/PowerMockitoMockingStaticMethodTest.java deleted file mode 100644 index 54423c4..0000000 --- a/src/test/java/com/in28minutes/powermock/PowerMockitoMockingStaticMethodTest.java +++ /dev/null @@ -1,49 +0,0 @@ -package com.in28minutes.powermock; - -import static org.junit.Assert.assertEquals; -import static org.mockito.Matchers.anyLong; -import static org.mockito.Mockito.when; - -import java.util.Arrays; - -import org.junit.Test; -import org.junit.runner.RunWith; -import org.mockito.InjectMocks; -import org.mockito.Mock; -import org.powermock.api.mockito.PowerMockito; -import org.powermock.core.classloader.annotations.PrepareForTest; -import org.powermock.modules.junit4.PowerMockRunner; - -@RunWith(PowerMockRunner.class) -@PrepareForTest({ UtilityClass.class /*The class with static method to be mocked*/}) -public class PowerMockitoMockingStaticMethodTest { - - @Mock - Dependency dependencyMock; - - @InjectMocks - SystemUnderTest systemUnderTest; - - @Test - public void powerMockito_MockingAStaticMethodCall() { - - when(dependencyMock.retrieveAllStats()).thenReturn( - Arrays.asList(1, 2, 3)); - - PowerMockito.mockStatic(UtilityClass.class); - - when(UtilityClass.staticMethod(anyLong())).thenReturn(150); - - assertEquals(150, systemUnderTest.methodCallingAStaticMethod()); - - //To verify a specific method call - //First : Call PowerMockito.verifyStatic() - //Second : Call the method to be verified - PowerMockito.verifyStatic(); - UtilityClass.staticMethod(1 + 2 + 3); - - // verify exact number of calls - //PowerMockito.verifyStatic(Mockito.times(1)); - - } -} \ No newline at end of file diff --git a/src/test/java/com/in28minutes/powermock/PowerMockitoTestingPrivateMethodTest.java b/src/test/java/com/in28minutes/powermock/PowerMockitoTestingPrivateMethodTest.java index f6ba741..80244c8 100644 --- a/src/test/java/com/in28minutes/powermock/PowerMockitoTestingPrivateMethodTest.java +++ b/src/test/java/com/in28minutes/powermock/PowerMockitoTestingPrivateMethodTest.java @@ -1,18 +1,18 @@ package com.in28minutes.powermock; -import static org.junit.Assert.assertEquals; +import static org.junit.jupiter.api.Assertions.assertEquals; import static org.mockito.Mockito.when; +import java.lang.reflect.Method; import java.util.Arrays; -import org.junit.Test; -import org.junit.runner.RunWith; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.extension.ExtendWith; import org.mockito.InjectMocks; import org.mockito.Mock; -import org.powermock.modules.junit4.PowerMockRunner; -import org.powermock.reflect.Whitebox; +import org.mockito.junit.jupiter.MockitoExtension; -@RunWith(PowerMockRunner.class) +@ExtendWith(MockitoExtension.class) public class PowerMockitoTestingPrivateMethodTest { @Mock @@ -23,10 +23,10 @@ public class PowerMockitoTestingPrivateMethodTest { @Test public void powerMockito_CallingAPrivateMethod() throws Exception { - when(dependencyMock.retrieveAllStats()).thenReturn( - Arrays.asList(1, 2, 3)); - long value = (Long) Whitebox.invokeMethod(systemUnderTest, - "privateMethodUnderTest"); + Method method = systemUnderTest.getClass().getDeclaredMethod("privateMethodUnderTest"); + method.setAccessible(true); + when(dependencyMock.retrieveAllStats()).thenReturn(Arrays.asList(1, 2, 3)); + long value = (Long) method.invoke(systemUnderTest); assertEquals(6, value); } } \ No newline at end of file