Migrating to JUnit5 and updating some Mockito patterns

unit-of-work/pom.xml

@@ -35,19 +35,10 @@
 
     <artifactId>unit-of-work</artifactId>
     <dependencies>
-        <dependency>
-            <groupId>junit</groupId>
-            <artifactId>junit</artifactId>
-        </dependency>
-        <dependency>
-            <groupId>org.junit.vintage</groupId>
-            <artifactId>junit-vintage-engine</artifactId>
-            <scope>test</scope>
-        </dependency>
         <dependency>
             <groupId>org.junit.jupiter</groupId>
             <artifactId>junit-jupiter-engine</artifactId>
-            <version>5.0.0</version>
+            <version>5.7.1</version>
             <scope>test</scope>
         </dependency>
         <dependency>

unit-of-work/src/test/java/com/iluwatar/unitofwork/AppTest.java

@@ -23,10 +23,11 @@
 
 package com.iluwatar.unitofwork;
 
-import org.junit.Test;
 
 import static org.junit.jupiter.api.Assertions.assertDoesNotThrow;
 
+import org.junit.jupiter.api.Test;
+
 /**
  * AppTest
  */

unit-of-work/src/test/java/com/iluwatar/unitofwork/StudentRepositoryTest.java

@@ -23,43 +23,32 @@
 
 package com.iluwatar.unitofwork;
 
-import static org.junit.Assert.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.never;
 import static org.mockito.Mockito.times;
 import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.verifyNoMoreInteractions;
-import static org.mockito.Mockito.verifyZeroInteractions;
 
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
-import org.junit.Before;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.mockito.Mock;
-import org.mockito.runners.MockitoJUnitRunner;
+import org.junit.jupiter.api.Test;
 
 /**
  * tests {@link StudentRepository}
  */
-@RunWith(MockitoJUnitRunner.class)
-public class StudentRepositoryTest {
+
+class StudentRepositoryTest {
   private final Student student1 = new Student(1, "Ram", "street 9, cupertino");
   private final Student student2 = new Student(1, "Sham", "Z bridge, pune");
 
-  private Map<String, List<Student>> context;
-  @Mock
-  private StudentDatabase studentDatabase;
-  private StudentRepository studentRepository;
-
-  @Before
-  public void setUp() {
-    context = new HashMap<>();
-    studentRepository = new StudentRepository(context, studentDatabase);
-  }
+  private final Map<String, List<Student>> context = new HashMap<>();
+  private final StudentDatabase studentDatabase = mock(StudentDatabase.class);
+  private final StudentRepository studentRepository = new StudentRepository(context, studentDatabase);;
 
   @Test
-  public void shouldSaveNewStudentWithoutWritingToDb() {
+  void shouldSaveNewStudentWithoutWritingToDb() {
     studentRepository.registerNew(student1);
     studentRepository.registerNew(student2);
 
@@ -68,7 +57,7 @@ public void shouldSaveNewStudentWithoutWritingToDb() {
   }
 
   @Test
-  public void shouldSaveDeletedStudentWithoutWritingToDb() {
+  void shouldSaveDeletedStudentWithoutWritingToDb() {
     studentRepository.registerDeleted(student1);
     studentRepository.registerDeleted(student2);
 
@@ -77,7 +66,7 @@ public void shouldSaveDeletedStudentWithoutWritingToDb() {
   }
 
   @Test
-  public void shouldSaveModifiedStudentWithoutWritingToDb() {
+  void shouldSaveModifiedStudentWithoutWritingToDb() {
     studentRepository.registerModified(student1);
     studentRepository.registerModified(student2);
 
@@ -86,7 +75,7 @@ public void shouldSaveModifiedStudentWithoutWritingToDb() {
   }
 
   @Test
-  public void shouldSaveAllLocalChangesToDb() {
+  void shouldSaveAllLocalChangesToDb() {
     context.put(UnitActions.INSERT.getActionValue(), List.of(student1));
     context.put(UnitActions.MODIFY.getActionValue(), List.of(student1));
     context.put(UnitActions.DELETE.getActionValue(), List.of(student1));
@@ -99,7 +88,7 @@ public void shouldSaveAllLocalChangesToDb() {
   }
 
   @Test
-  public void shouldNotWriteToDbIfContextIsNull() {
+  void shouldNotWriteToDbIfContextIsNull() {
     var studentRepository = new StudentRepository(null, studentDatabase);
 
     studentRepository.commit();
@@ -108,16 +97,16 @@ public void shouldNotWriteToDbIfContextIsNull() {
   }
 
   @Test
-  public void shouldNotWriteToDbIfNothingToCommit() {
+  void shouldNotWriteToDbIfNothingToCommit() {
     var studentRepository = new StudentRepository(new HashMap<>(), studentDatabase);
 
     studentRepository.commit();
 
-    verifyZeroInteractions(studentDatabase);
+    verifyNoMoreInteractions(studentDatabase);
   }
 
   @Test
-  public void shouldNotInsertToDbIfNoRegisteredStudentsToBeCommitted() {
+  void shouldNotInsertToDbIfNoRegisteredStudentsToBeCommitted() {
     context.put(UnitActions.MODIFY.getActionValue(), List.of(student1));
     context.put(UnitActions.DELETE.getActionValue(), List.of(student1));
 
@@ -127,7 +116,7 @@ public void shouldNotInsertToDbIfNoRegisteredStudentsToBeCommitted() {
   }
 
   @Test
-  public void shouldNotModifyToDbIfNotRegisteredStudentsToBeCommitted() {
+  void shouldNotModifyToDbIfNotRegisteredStudentsToBeCommitted() {
     context.put(UnitActions.INSERT.getActionValue(), List.of(student1));
     context.put(UnitActions.DELETE.getActionValue(), List.of(student1));
 
@@ -137,12 +126,12 @@ public void shouldNotModifyToDbIfNotRegisteredStudentsToBeCommitted() {
   }
 
   @Test
-  public void shouldNotDeleteFromDbIfNotRegisteredStudentsToBeCommitted() {
+  void shouldNotDeleteFromDbIfNotRegisteredStudentsToBeCommitted() {
     context.put(UnitActions.INSERT.getActionValue(), List.of(student1));
     context.put(UnitActions.MODIFY.getActionValue(), List.of(student1));
 
     studentRepository.commit();
 
     verify(studentDatabase, never()).delete(student1);
   }
-}
+}