testing improvements

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

 import javax.persistence.GeneratedValue;
 import javax.persistence.GenerationType;
 import javax.persistence.Id;
+import java.util.Objects;
 
 @Entity
 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

 
     @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);
 
     @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

 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.springframework.http.HttpStatus;
 import org.springframework.http.ResponseEntity;
+
+import java.util.ArrayList;
+
 import static org.mockito.Matchers.any;
 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 {
 
     @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);
 
-        Person p = new Person();
-        p.setId(1L);
-        ResponseEntity<Person> actual = controller.getPerson(1);
-        ResponseEntity<Person> expected = new ResponseEntity<>(HttpStatus.OK);
+        ResponseEntity<Person> actual = controller.getPerson(88);
 
-        Assert.assertEquals(expected, actual);
+        Assert.assertEquals(actual.getStatusCode(), HttpStatus.OK);
+        Assert.assertEquals(actual.getBody(), person);
     }
 
     @Test
-    public void updatePersonTest(){
-        when(controller.updatePerson(any(Person.class))).thenReturn(new ResponseEntity<>( HttpStatus.OK));
+    public void getPersonList(){
+        Iterable<Person> personList = new ArrayList<>();
+        when(repository.findAll()).thenReturn(personList);
 
-        Person p = new Person();
-        p.setId(1L);
-        ResponseEntity<Person> actual = controller.updatePerson(any(Person.class));
-        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 deletePerson(){
-        when(controller.deletePerson(1)).thenReturn(new ResponseEntity<>( HttpStatus.NO_CONTENT));
+    public void updatePerson(){
+        Person p = new Person("a", "b");
+        Person update = new Person("a","b");
+        when(repository.save(p)).thenReturn(update);
 
-        ResponseEntity<Person> actual = controller.deletePerson(1);
-        ResponseEntity<Person> expected = new ResponseEntity<>( HttpStatus.NO_CONTENT);
+        ResponseEntity<Person> actual = controller.updatePerson(p);
 
-        Assert.assertEquals(expected, actual);
+        Assert.assertEquals(actual.getStatusCode(), HttpStatus.OK);
+        Assert.assertEquals(actual.getBody(), update);
     }
+    
+//    @Test
+//    public void updatePersonTest(){
+//        when(controller.updatePerson(any(Person.class))).thenReturn(new ResponseEntity<>( HttpStatus.OK));
+//
+//        Person p = new Person();
+//        p.setId(1L);
+//        ResponseEntity<Person> actual = controller.updatePerson(any(Person.class));
+//        ResponseEntity<Person> expected = new ResponseEntity<>(HttpStatus.OK);
+//
+//        Assert.assertEquals(expected, actual);
+//    }
+//
+//    @Test
+//    public void deletePerson(){
+//        when(controller.deletePerson(1)).thenReturn(new ResponseEntity<>( HttpStatus.NO_CONTENT));
+//
+//        ResponseEntity<Person> actual = controller.deletePerson(1);
+//        ResponseEntity<Person> expected = new ResponseEntity<>( HttpStatus.NO_CONTENT);
+//
+//        Assert.assertEquals(expected, actual);
+//    }
 }