Mockito Essentials

package com.packt.testdoubles.dummy;

public enum Grades {
   Excellent, VeryGood, Good, Average, Poor;
}

public class Student {

  private final String roleNumber;
  private final String name;

  public Student(String roleNumber, String name) {
    this.roleNumber = roleNumber;
    this.name = name;
  }

  //setters are ignored

}

public class Marks {

  private final Student student;
  private final String subjectId;
  private final BigDecimal marks;

  public Marks(Student student, String subjectId, BigDecimal marks) {
    this.student = student;
    this.subjectId = subjectId;
    this.marks = marks;
  }
  //getters methods go here 
}

public class Teacher {

  public Grades generateGrade(List<Marks> marksList) {

    BigDecimal aggregate = BigDecimal.ZERO;

    for (Marks mark : marksList) {
    aggregate = aggregate.add(mark.getMarks());
  }

  BigDecimal percentage = calculatePercent(aggregate, marksList.size());

  if (percentage.compareTo(new BigDecimal("90.00")) > 0) {
    return Grades.Excellent;
  }

  if (percentage.compareTo(new BigDecimal("75.00")) > 0) {
    return Grades.VeryGood;
  }

  if (percentage.compareTo(new BigDecimal("60.00")) > 0) {
    return Grades.Good;
  }

  if (percentage.compareTo(new BigDecimal("40.00")) > 0) {
    return Grades.Average;
  }

  return Grades.Poor;
}

private BigDecimal calculatePercent(BigDecimal aggregate,int numberOfSubjects) {
  BigDecimal percent = new BigDecimal(aggregate.doubleValue()/ numberOfSubjects);
  return percent;
}

public class DummyStudent extends Student {

  protected DummyStudent() {
    super(null, null);
  }

  public String getRoleNumber() {
    throw new RuntimeException("Dummy student");
  }

  public String getName() {
    throw new RuntimeException("Dummy student");
  }

}

public class TeacherTest {

  @Test public void when_marks_above_seventy_five_percent_returns_very_good() {
  DummyStudent dummyStudent = new  DummyStudent();

  Marks inEnglish = new Marks(dummyStudent, "English002", new BigDecimal("81.00"));

  Marks inMath = new Marks(dummyStudent, "Math005", new BigDecimal("97.00"));

  Marks inHistory = new Marks(dummyStudent, "History007, new BigDecimal("79.00"));
  List<Marks> marks = Arrays.asList(inHistory, inMaths, inEnglish);

  Grades grade = new Teacher().generateGrade(marks);
  assertEquals(Grades.VeryGood, grade);
  }
}

  public class CreateStudentResponse {
    private final String errorMessage;
    private final Student student;

    public CreateStudentResponse(String errorMessage, Student student) {
      this.errorMessage = errorMessage;
      this.student = student;
    }
    public boolean isSuccess(){
      return null == errorMessage;
    }

    public String getErrorMessage() {
      return errorMessage;
    }
     public Student getStudent() {
     return student;
    }
  }

public interface StudentDAO {
  public String create(String name, String className)
  throws SQLException;
}

public interface StudentService {
  CreateStudentResponse create(String name, String studentOfclass);
}

public class StudentServiceImpl implements StudentService {
  private final StudentDAO studentDAO;

  public StudentServiceImpl(StudentDAO studentDAO) {
    this.studentDAO = studentDAO;
  }

  @Override public CreateStudentResponse create(String name, String studentOfclass) {
    CreateStudentResponse response = null;
    try{
      String roleNum= studentDAO.create (name, studentOfclass);
      response = new CreateStudentResponse(null, new Student(roleNum, name));
    }catch(SQLException e) {){
      response = new CreateStudentResponse
      ("SQLException"+e.getMessage(),  null);
    }catch (Exception e) {
      response = new CreateStudentResponse(e.getMessage(), null);
    }
    return response;
  }
}

package com.packt.testdoubles.stub;
import java.sql.SQLException;

public class ConnectionTimedOutStudentDAOStub implements StudentDAO {
  public String create(String name, String className)
  throws SQLException {
    throw new SQLException("DB connection timed out");
  }
}

public class StudentServiceTest {
  private StudentService studentService;
  @Test
  public void when_connection_times_out_then_the_student_is_not_saved() {
    studentService = new StudentServiceImpl(new ConnectionTimedOutStudentDAOStub());
    String classNine = "IX";
    String johnSmith = "john Smith";
    CreateStudentResponse resp = studentService.create(johnSmith, classNine);
    assertFalse(resp.isSuccss());
  }
}

public class StudentService {

  private Map<String, List<Student>> studentCouseMap = new HashMap<>();

  public void enrollToCourse(String courseName,Student student){
    List<Student> list = studentCouseMap.get(courseName);
    if (list == null) {
      list = new ArrayList<>();
    }

    if (!list.contains(student)) {
      list.add(student);
    }
    studentCouseMap.put(courseName, list);
  }

}

class MethodInvocation {

  private List<Object> params = new ArrayList<>();
  private Object returnedValue = null;
  private String method;

  public List<Object> getParams() {
    return params;
  }

  public MethodInvocation addParam(Object parm){
    getParams().add(parm);
    return this;
  }

  public Object getReturnedValue() {
    return returnedValue;
  }

  public MethodInvocation setReturnedValue(Object returnedValue) {
    this.returnedValue = returnedValue;
    return this;
  }

  public String getMethod() {
    return method;
  }

  public MethodInvocation setMethod(String method) {
   this.method = method;
    return this;
  }
}

public class StudentServiceSpy {
  private Map<String, List<MethodInvocation>> invocationMap = new HashMap<>();

  void registerCall(MethodInvocation invocation) {
    List<MethodInvocation> list = invocationMap.get(invocation.getMethod());
    if (list == null) {
      list = new ArrayList<>();
    }
    if (!list.contains(invocation)) {
      list.add(invocation);
    }

    invocationMap.put(invocation.getMethod(), list);
  }

  public int invocation(String methodName){
    List<MethodInvocation> list = invocationMap.get(methodName);
    if(list == null){
      return 0;
    }

    return list.size();
  }

  public MethodInvocation arguments(String methodName, int invocationIndex){
    List<MethodInvocation> list = invocationMap.get(methodName);
    if(list == null || (invocationIndex > list.size())){
      return null;
    }
    return list.get(invocationIndex-1);
  }
}

  private StudentServiceSpy spy;
  public void setSpy(StudentServiceSpy spy) {
    this.spy = spy;
  }
  public void enrollToCourse(String courseName, Student student) {
    MethodInvocation invocation = new MethodInvocation();
    invocation.addParam(courseName).addParam(student).setMethod("enrollToCourse");
    spy.registerCall(invocation);

    List<Student> list = studentCouseMap.get(courseName);
    if (list == null) {
      list = new ArrayList<>();
    }
    if (!list.contains(student)) {
      list.add(student);
    }

    studentCouseMap.put(courseName, list);
  }

public class StudentServiceTest {
  StudentService service = new StudentService();
  StudentServiceSpy spy = new StudentServiceSpy();

  @Test
  public void enrolls_students() throws Exception {
    //create student objects
    Student bob = new Student("001", "Robert Anthony");
    Student roy = new Student("002", "Roy Noon");
    //set spy
    service.setSpy(spy);

    //enroll Bob and Roy
    service.enrollToCourse("english", bob);
    service.enrollToCourse("history", roy);
    //assert that the method was invoked twice
    assertEquals(2, spy.invocation("enrollToCourse"));

    //get the method arguments for the first call
    List<Object> methodArguments = spy.arguments
("enrollToCourse", 1).getParams();

    //get the method arguments for the 2nd call
    List<Object> methodArguments2 = spy.arguments
("enrollToCourse", 2).getParams();

    //verify that Bob was enrolled to English first
    assertEquals("english", methodArguments.get(0));
    assertEquals(bob, methodArguments.get(1));

    //verify that Roy was enrolled to history
    assertEquals("history", methodArguments2.get(0));
   assertEquals(roy, methodArguments2.get(1));

  }

}

public class StudentService {

  private Map<String, List<Student>> studentCouseMap = new HashMap<>();

  public void enrollToCourse(String courseName,Student student){
    List<Student> list = studentCouseMap.get(courseName);
    if (list == null) {
      list = new ArrayList<>();
    }

    if (!list.contains(student)) {
      list.add(student);
    }

    studentCouseMap.put(courseName, list);
  }
}

public void verify(String methodName, int numberOfInvocation){
  int actual = invocation(methodName);
  if(actual != numberOfInvocation){
    throw new IllegalStateException(methodName+" was expected ["+numberOfInvocation+"] times but actuallyactaully invoked["+actual+"] times");
  }
}

private StudentServiceMockObject mock;

public void setMock(StudentServiceMockObject mock) {
  this.mock = mock;
}
public void enrollToCourse(String courseName,Student student){
  MethodInvocation invocation = new MethodInvocation();

  invocation.addParam(courseName).addParam(student).setMethod("enrollToCourse");

  mock.registerCall(invocation);
  …//existing code
}

public class StudentServiceTest {
  StudentService service = new StudentService();
  StudentServiceMockObject mockObject = new StudentServiceMockObject();

  @Test
  public void enrolls_students() throws Exception {
    //create 2 students
    Student bob = new Student("001", "Robert Anthony");
    Student roy = new Student("002", "Roy Noon");

    //set mock/spy
    service.setMock(mockObject);

    //invoke method twice
    service.enrollToCourse("english", bob);
    service.enrollToCourse("history", roy);

    //assert that the method was invoked twice
    assertEquals(2, 
    mockObject.invocation("enrollToCourse"));

    //verify wrong information, that enrollToCourse was //invoked once, but actually it is invoked twice
    mockObject.verify("enrollToCourse", 1);

  }

}

public class JdbcSupport {
  public int[] batchUpdate(String sql, List<Map<String, Object>> params){
    //original db access code is hidden
    return null;
  }
}

public interface StudentDao {
  public void batchUpdate(List<Student> students);
}

public class StudentDaoImpl implements StudentDao {

  public StudentDaoImpl() {
  }

  @Override
  public void batchUpdate(List<Student> students) {

    List<Student> insertList = new ArrayList<>();
    List<Student> updateList = new ArrayList<>();

    for (Student student : students) {
      if (student.getRoleNumber() == null) {
        insertList.add(student);
      } else {
        updateList.add(student);
      }
    }

    int rowsInserted = 0;
    int rowsUpdated = 0;

    if (!insertList.isEmpty()) {
      List<Map<String, Object>> paramList = new ArrayList<>();
      for (Student std : insertList) {
        Map<String, Object> param = new HashMap<>();
        param.put("name", std.getName());
        paramList.add(param);
      }

      int[] rowCount = update("insert", paramList);
      rowsInserted = sum(rowCount);
    }

    if (!updateList.isEmpty()) {
      List<Map<String, Object>> paramList = new ArrayList<>();
      for (Student std : updateList) {
        Map<String, Object> param = new HashMap<>();
        param.put("roleId", std.getRoleNumber());
        param.put("name", std.getName());
        paramList.add(param);
      }

      int[] rowCount = update("update", paramList);
      rowsUpdated = sum(rowCount);
    }

    if (students.size() != (rowsInserted + rowsUpdated)) {
      throw new IllegalStateException("Database update error, expected "   + students.size() + " updates but actual " + (rowsInserted + rowsUpdated));
      }
    }

    public int[] update(String sql, List<Map<String, Object>> params) {
      return new JdbcSupport().batchUpdate(sql, params);
    }

    private int sum(int[] rows) {
      int sum = 0;
       for (int val : rows) {
         sum += val;
       }
       return sum;
    }

  }

public class StudentDaoTest {
  class TestableStudentDao extends StudentDaoImpl{
    int[] valuesToReturn;
    int[] update(String sql, List<Map<String, Object>> params) {
      Integer count = sqlCount.get(sql);
      if(count == null){
        sqlCount.put(sql, params.size());
      }else{
        sqlCount.put(sql, count+params.size());
      }

      if (valuesToReturn != null) {
        return valuesToReturn;
      }


      return valuesToReturn;
    }
  }
}

public class StudentDaoTest {

  private TestableStudentDao dao;
  private Map<String, Integer> sqlCount = null;
  @Before
  public void setup() {
    dao = new TestableStudentDao();
    sqlCount = new HashMap<String, Integer>();
  }

  @Test(expected=IllegalStateException.class)
  public void when_row_count_does_not_match_then_rollbacks_tarnsaction(){
  List<Student>  students = new ArrayList<>();
  students.add(new Student(null, "Gautam Kohli"));

  int[] expect_update_fails_count = {0};
  dao.valuesToReturn = expect_update_fails_count;
  dao.batchUpdate(students);

}

@Test
public void when_new_student_then_creates_student(){
  List<Student>  students = new ArrayList<>();
  students.add(new Student(null, "Gautam Kohli"));

  int[] expect_update_success = {1};
  dao.valuesToReturn = expect_update_success;
  dao.batchUpdate(students);

  int actualInsertCount = sqlCount.get("insert");
  int expectedInsertCount = 1;
  assertEquals(expectedInsertCount, actualInsertCount);
}

  @Test
  public void when_existing_student_then_updates_student_successfully(){
    List<Student> students = new ArrayList<>();
    students.add(new Student("001", "Mark Leo"));
    int[] expect_update_success = {1};
    dao.valuesToReturn = expect_update_success;

    dao.batchUpdate(students);
    int actualUpdateCount = sqlCount.get("update");
    int expectedUpdate = 1;
    assertEquals(expectedUpdate, actualUpdateCount);
  }

class TestableStudentDao extends StudentDaoImpl {
  int[] valuesToReturn;
  int[] update(String sql, List<Map<String, Object>> params) {

    Integer count = sqlCount.get(sql);
    if(count == null){
      sqlCount.put(sql, params.size());
    }else{
      sqlCount.put(sql, count+params.size());
    }


    if (valuesToReturn != null) {
      return valuesToReturn;
    }

    int[] val = new int[params.size()];
    for (int i = 0; i < params.size(); i++) {
      val[i] = 1;
    }

    return val;
  }
}

@Test
public void when_new_and_existing_students_then_creates_and_updates_students() {
  List<Student> students = new ArrayList<>();
  students.add(new Student("001", "Mark Joffe"));
  students.add(new Student(null, "John Villare"));
  students.add(new Student("002", "Maria Rubinho"));

  dao.batchUpdate(students);

}