src/main/java/io/zipcoder/crudapp/Person.java

@@ -6,6 +6,7 @@ import javax.persistence.Entity;
 import javax.persistence.GeneratedValue;
 import javax.persistence.GenerationType;
 import javax.persistence.Id;
+import java.util.Objects;
 
 @Entity
 public class Person {
@@ -48,4 +49,18 @@ public class Person {
         this.lastName = lastName;
     }
 
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (!(o instanceof Person)) return false;
+        Person person = (Person) o;
+        return Objects.equals(getId(), person.getId()) &&
+                Objects.equals(getFirstName(), person.getFirstName()) &&
+                Objects.equals(getLastName(), person.getLastName());
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(getId(), getFirstName(), getLastName());
+    }
 }

src/main/java/io/zipcoder/crudapp/PersonController.java

@@ -17,11 +17,10 @@ public class PersonController {
 
     @RequestMapping(value = "/people", method = RequestMethod.POST)
     public ResponseEntity<Person> createPerson(@RequestBody Person p){
-        personRepository.save(p);
-        return new ResponseEntity<>(p,HttpStatus.CREATED);
+        Person savedPerson = personRepository.save(p);
+        return new ResponseEntity<>(savedPerson, HttpStatus.CREATED);
     }
 
-
     @RequestMapping(value = "/people/{id}", method = RequestMethod.GET)
     public ResponseEntity<Person> getPerson(@PathVariable("id")int id){
        Person p = personRepository.findOne((long)id);
@@ -36,8 +35,8 @@ public class PersonController {
 
     @RequestMapping(value = "/people/{id}", method = RequestMethod.PUT)
     public ResponseEntity<Person> updatePerson(@RequestBody Person p){
-        personRepository.save(p);
-        return new ResponseEntity<>(p, HttpStatus.OK);
+        Person person = personRepository.save(p);
+        return new ResponseEntity<>(person, HttpStatus.OK);
     }
 
     @RequestMapping(value = "/people/{id}", method = RequestMethod.DELETE)

src/test/java/io/zipcoder/crudapp/PersonControllerTest.java

@@ -3,17 +3,28 @@ package io.zipcoder.crudapp;
 import org.junit.Assert;
 import org.junit.Before;
 import org.junit.Test;
+import org.mockito.InjectMocks;
 import org.mockito.Mock;
 import org.mockito.MockitoAnnotations;
+import org.mockito.invocation.InvocationOnMock;
+import org.mockito.stubbing.Answer;
 import org.springframework.http.HttpStatus;
 import org.springframework.http.ResponseEntity;
+
+import java.util.ArrayList;
+
 import static org.mockito.Matchers.any;
+import static org.mockito.Mockito.doAnswer;
 import static org.mockito.Mockito.when;
 
 public class PersonControllerTest {
 
     @Mock
-    private PersonController controller;
+    private PersonRepository repository;
+
+    @InjectMocks
+    private PersonController controller = new PersonController();
+
 
     @Before
     public void setUp() throws Exception {
@@ -23,46 +34,72 @@ public class PersonControllerTest {
 
     @Test
     public void createPersonTest(){
-        when(controller.createPerson(any(Person.class))).thenReturn(new ResponseEntity<>( HttpStatus.CREATED));
+        Person person = new Person("a", "b");
+        Person savedPerson = new Person();
+        when(repository.save(person)).thenReturn(savedPerson);
 
-        Person p = new Person();
-        ResponseEntity<Person> actual = controller.createPerson(p);
-        ResponseEntity<Person> expected = new ResponseEntity<>(HttpStatus.CREATED);
+        ResponseEntity<Person> actual = controller.createPerson(person);
 
-        Assert.assertEquals(expected, actual);
+        Assert.assertEquals(actual.getStatusCode(), HttpStatus.CREATED);
+        Assert.assertEquals(actual.getBody(), savedPerson);
     }
 
     @Test
     public void getPersonTest(){
-        when(controller.getPerson(1)).thenReturn(new ResponseEntity<>( HttpStatus.OK));
+        Person person = new Person();
+        person.setId(88L);
+        when(repository.findOne(88L)).thenReturn(person);
+
+        ResponseEntity<Person> actual = controller.getPerson(88);
+
+        Assert.assertEquals(actual.getStatusCode(), HttpStatus.OK);
+        Assert.assertEquals(actual.getBody(), person);
+    }
+
+    @Test
+    public void getPersonListTest(){
+        Iterable<Person> personList = new ArrayList<>();
+        when(repository.findAll()).thenReturn(personList);
 
-        Person p = new Person();
-        p.setId(1L);
-        ResponseEntity<Person> actual = controller.getPerson(1);
-        ResponseEntity<Person> expected = new ResponseEntity<>(HttpStatus.OK);
+        ResponseEntity<Iterable<Person>> actual = controller.getPersonList();
 
-        Assert.assertEquals(expected, actual);
+        Assert.assertEquals(actual.getStatusCode(), HttpStatus.OK);
+        Assert.assertEquals(actual.getBody(), personList);
     }
 
     @Test
     public void updatePersonTest(){
-        when(controller.updatePerson(any(Person.class))).thenReturn(new ResponseEntity<>( HttpStatus.OK));
+        Person p = new Person("a", "b");
+        Person update = new Person("a","b");
+        when(repository.save(p)).thenReturn(update);
 
-        Person p = new Person();
-        p.setId(1L);
-        ResponseEntity<Person> actual = controller.updatePerson(any(Person.class));
-        ResponseEntity<Person> expected = new ResponseEntity<>(HttpStatus.OK);
+        ResponseEntity<Person> actual = controller.updatePerson(p);
 
-        Assert.assertEquals(expected, actual);
+        Assert.assertEquals(actual.getStatusCode(), HttpStatus.OK);
+        Assert.assertEquals(actual.getBody(), update);
     }
 
     @Test
-    public void deletePerson(){
-        when(controller.deletePerson(1)).thenReturn(new ResponseEntity<>( HttpStatus.NO_CONTENT));
+    public void deletePersonTest(){
+        Person p = new Person("a", "b");
+        p.setId(8783L);
+        doAnswer(new Answer<Void>() {
+
+            @Override
+            public Void answer(InvocationOnMock invocation) throws Throwable {
+                Object[] arguments = invocation.getArguments();
+                if (arguments != null && arguments.length > 1 && arguments[0] != null && arguments[1] != null) {
+
+                    controller.deletePerson(8783);
+
+                }
+                return null;
+            }
+        }).when(repository).delete(8783L);
 
-        ResponseEntity<Person> actual = controller.deletePerson(1);
-        ResponseEntity<Person> expected = new ResponseEntity<>( HttpStatus.NO_CONTENT);
+        ResponseEntity<Person> actual = controller.deletePerson(8783);
 
-        Assert.assertEquals(expected, actual);
+        Assert.assertEquals(actual.getStatusCode(), HttpStatus.NO_CONTENT);
+        Assert.assertEquals(actual.getBody(), null);
     }
 }