pom.xml

 	<parent>
 		<groupId>org.springframework.boot</groupId>
 		<artifactId>spring-boot-starter-parent</artifactId>
-		<version>1.5.2.RELEASE</version>
-		<relativePath/> <!-- lookup parent from repository -->
+		<version>1.5.18.RELEASE</version>
 	</parent>
 
 	<properties>
 		</dependency>
 
 		<dependency>
-			<groupId>com.h2database</groupId>
-			<artifactId>h2</artifactId>
-            <scope>compile</scope>
+			<groupId>mysql</groupId>
+			<artifactId>mysql-connector-java</artifactId>
 		</dependency>
+
 		<dependency>
 			<groupId>org.springframework.boot</groupId>
 			<artifactId>spring-boot-starter-test</artifactId>
 			<artifactId>spring-boot-starter-data-jpa</artifactId>
 			<!--<version>1.3.5.RELEASE</version>-->
 		</dependency>
+        <dependency>
+            <groupId>org.mockito</groupId>
+            <artifactId>mockito-core</artifactId>
+            <version>1.10.19</version>
+            <exclusions>
+                <exclusion>
+                    <groupId>org.hamcrest</groupId>
+                    <artifactId>hamcrest-core</artifactId>
+                </exclusion>
+            </exclusions>
+            <scope>test</scope>
+        </dependency>
+
     </dependencies>
 
 	<build>

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

 package io.zipcoder.crudapp;
 
-import org.h2.server.web.WebServlet;
 import org.springframework.boot.SpringApplication;
 import org.springframework.boot.autoconfigure.SpringBootApplication;
-import org.springframework.boot.web.servlet.ServletRegistrationBean;
-import org.springframework.context.annotation.Bean;
 
 @SpringBootApplication
 public class CRUDApplication {
 		SpringApplication.run(CRUDApplication.class, args);
 	}
 
-	@Bean
-	ServletRegistrationBean h2servletRegistration(){
-		ServletRegistrationBean registrationBean = new ServletRegistrationBean( new WebServlet());
-		registrationBean.addUrlMappings("/console/*");
-		return registrationBean;
-	}
+//	@Bean
+//	ServletRegistrationBean h2servletRegistration(){
+//		ServletRegistrationBean registrationBean = new ServletRegistrationBean( new WebServlet());
+//		registrationBean.addUrlMappings("/console/*");
+//		return registrationBean;
+//	}
 }

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

+package io.zipcoder.crudapp.controllers;
+
+import io.zipcoder.crudapp.models.Person;
+import io.zipcoder.crudapp.services.PersonService;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.*;
+
+@RestController
+public class PersonController {
+
+    @Autowired
+    PersonService personService;
+
+    @RequestMapping(value = "/people", method = RequestMethod.GET)
+    public ResponseEntity<Iterable<Person>> getPersonList(){
+        Iterable<Person> people = personService.getPersonList();
+        return new ResponseEntity<>(people, HttpStatus.OK);
+    }
+
+    @RequestMapping(value = "/people/{id}", method = RequestMethod.GET)
+    public ResponseEntity<?> getPersonById(@PathVariable Long id){
+        Person p = personService.getPersonById(id);
+        if (p != null) return new ResponseEntity<>(p,HttpStatus.OK);
+        return new ResponseEntity<>(HttpStatus.NOT_FOUND);
+    }
+
+    @RequestMapping(value = "/people", method = RequestMethod.POST)
+    public ResponseEntity<?> createPerson(@RequestBody Person person){
+        Person p = personService.savePerson(person);
+        return new ResponseEntity<>(p, HttpStatus.CREATED);
+    }
+
+    @RequestMapping(value = "/people/{id}", method = RequestMethod.PUT)
+    public ResponseEntity<?> updatePerson(@PathVariable Long id, @RequestBody Person person){
+        Person p = personService.savePerson(person);
+        return new ResponseEntity<>(p,HttpStatus.OK);
+    }
+
+    @RequestMapping(value = "/people/{id}", method = RequestMethod.DELETE)
+    public ResponseEntity<Void> deletePerson(@PathVariable Long id){
+        personService.deletePerson(id);
+        return new ResponseEntity(HttpStatus.NO_CONTENT);
+    }
+}

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

+package io.zipcoder.crudapp.models;
+
+import javax.persistence.*;
+
+@Entity
+public class Person {
+
+    @Id
+    @GeneratedValue(strategy = GenerationType.AUTO)
+    @Column(name = "ID")
+    Long id;
+
+    @Column(name = "FIRST_NAME")
+    String firstName;
+
+    @Column(name = "LAST_NAME")
+    String lastName;
+
+    public Person() {
+    }
+
+    public Person(String firstName, String lastName) {
+        this.firstName = firstName;
+        this.lastName = lastName;
+    }
+
+    public Long getId() {
+        return id;
+    }
+
+    public String getFirstName() {
+        return firstName;
+    }
+
+    public void setFirstName(String firstName) {
+        this.firstName = firstName;
+    }
+
+    public String getLastName() {
+        return lastName;
+    }
+
+    public void setLastName(String lastName) {
+        this.lastName = lastName;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        return toString().equals(o.toString());
+    }
+
+    @Override
+    public String toString() {
+        return "Person{" +
+                "id=" + id +
+                ", firstName='" + firstName + '\'' +
+                ", lastName='" + lastName + '\'' +
+                '}';
+    }
+}

src/main/java/io/zipcoder/crudapp/repositories/PersonRepository.java

+package io.zipcoder.crudapp.repositories;
+
+import io.zipcoder.crudapp.models.Person;
+import org.springframework.data.repository.CrudRepository;
+import org.springframework.stereotype.Repository;
+
+@Repository
+public interface PersonRepository extends CrudRepository<Person, Long> {
+
+}

src/main/java/io/zipcoder/crudapp/services/PersonService.java

+package io.zipcoder.crudapp.services;
+
+import io.zipcoder.crudapp.models.Person;
+import io.zipcoder.crudapp.repositories.PersonRepository;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+
+@Service
+public class PersonService {
+
+    @Autowired
+    PersonRepository personRepository;
+
+    public Iterable<Person> getPersonList(){
+        return personRepository.findAll();
+    }
+
+    public Person getPersonById(Long id){
+        return personRepository.findOne(id);
+    }
+
+    public Person savePerson(Person person){
+        return personRepository.save(person);
+    }
+
+    public void deletePerson(Long id){
+        personRepository.delete(id);
+    }
+}

src/main/resources/application-h2.properties

-spring.datasource.url=jdbc:h2:mem:testdb;Mode=Oracle
-spring.datasource.platform=h2
-spring.jpa.hibernate.ddl-auto=none
-spring.datasource.continue-on-error=true

src/main/resources/application.properties

-spring.profiles.active=h2
-
-spring.jpa.database-platform=org.hibernate.dialect.Oracle10gDialect
+spring.datasource.url=jdbc:mysql://localhost:3306/person?useSSL=false
+spring.datasource.username=root
+spring.datasource.password=qwerty
+spring.jpa.hibernate.ddl-auto=create

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

+package io.zipcoder.crudapp;
+
+import io.zipcoder.crudapp.controllers.PersonController;
+import io.zipcoder.crudapp.models.Person;
+import io.zipcoder.crudapp.services.PersonService;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.boot.test.mock.mockito.MockBean;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
+import org.springframework.test.context.junit4.SpringRunner;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import static org.assertj.core.api.Java6Assertions.assertThat;
+import static org.mockito.BDDMockito.given;
+
+@SpringBootTest
+@RunWith(SpringRunner.class)
+public class PersonControllerTest {
+    List<Person> list;
+    Person testPerson = new Person("Test", "Person");
+
+    @Before
+    public void setup(){
+        list = new ArrayList<>();
+        list.add(testPerson);
+    }
+
+    @Autowired
+    PersonController personController;
+
+    @MockBean
+    PersonService personService;
+
+    @Test
+    public void testGetPersonList(){
+        given(
+                this.personService.getPersonList()
+        ).willReturn(
+                list
+        );
+        ResponseEntity<Iterable<Person>> actual = personController.getPersonList();
+        assertThat(actual)
+                .isEqualTo(new ResponseEntity<>(list, HttpStatus.OK));
+    }
+
+    @Test
+    public void testGetPersonById(){
+        given(this.personService.getPersonById(1L)
+        ).willReturn(testPerson);
+
+        ResponseEntity<?> actual = personController.getPersonById(1L);
+        assertThat(actual).isEqualTo(new ResponseEntity<>(testPerson, HttpStatus.OK));
+    }
+
+    @Test
+    public void testGetPersonById_null(){
+        given(this.personService.getPersonById(2L)
+        ).willReturn(null);
+
+        ResponseEntity<?> actual = personController.getPersonById(2L);
+        assertThat(actual).isEqualTo(new ResponseEntity<>(null, HttpStatus.NOT_FOUND));
+    }
+
+    @Test
+    public void testCreatePerson(){
+        given(this.personService.savePerson(testPerson)
+        ).willReturn(testPerson);
+
+        ResponseEntity<?> actual = personController.createPerson(testPerson);
+        assertThat(actual).isEqualTo(new ResponseEntity<>(testPerson,HttpStatus.CREATED));
+    }
+
+    @Test
+    public void testUpdatePerson(){
+        testPerson.setFirstName("Bill");
+        given(this.personService.savePerson(testPerson)
+        ).willReturn(testPerson);
+
+        ResponseEntity<?> actual = personController.updatePerson(1L, testPerson);
+        assertThat(actual).isEqualTo(new ResponseEntity<>(testPerson,HttpStatus.OK));
+    }
+
+    @Test
+    public void testDelete(){
+        ResponseEntity<?> actual = personController.deletePerson(1L);
+        assertThat(actual).isEqualTo(new ResponseEntity(HttpStatus.NO_CONTENT));
+    }
+}

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

+package io.zipcoder.crudapp;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import io.zipcoder.crudapp.controllers.PersonController;
+import io.zipcoder.crudapp.models.Person;
+import io.zipcoder.crudapp.services.PersonService;
+import org.apache.catalina.filters.CorsFilter;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.MockitoAnnotations;
+import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.http.MediaType;
+import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
+import org.springframework.test.context.web.WebAppConfiguration;
+import org.springframework.test.web.servlet.MockMvc;
+import org.springframework.test.web.servlet.setup.MockMvcBuilders;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import static org.hamcrest.Matchers.hasSize;
+import static org.hamcrest.Matchers.is;
+import static org.mockito.Mockito.*;
+import static org.mockito.Mockito.verifyNoMoreInteractions;
+import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.*;
+import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.delete;
+import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.get;
+import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.*;
+import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;
+
+
+// ========== Looked further into the readme. Testing Controller the 'right' way now =========//
+
+@WebAppConfiguration
+@SpringBootTest
+@RunWith(SpringJUnit4ClassRunner.class)
+public class PersonControllerTestMVC {
+    List<Person> list;
+    Person testPerson = new Person("Test", "Person");
+    private MockMvc mockMvc;
+
+    @Mock
+    private PersonService personService;
+
+    @InjectMocks
+    private PersonController personController;
+
+    @Before
+    public void init(){
+        list = new ArrayList<>();
+        list.add(testPerson);
+
+        MockitoAnnotations.initMocks(this);
+        mockMvc = MockMvcBuilders
+                .standaloneSetup(personController)
+                .build();
+    }
+
+    // =================== Get All Users =================== //
+
+    @Test
+    public void testGetPersonList() throws Exception {
+        when(personService.getPersonList()).thenReturn(list);
+
+        mockMvc.perform(get("/people"))
+                .andExpect(status().isOk())
+                .andExpect(content().contentType(MediaType.APPLICATION_JSON_UTF8_VALUE))
+                .andExpect(jsonPath("$", hasSize(1)))
+                .andExpect(jsonPath("$[0].firstName", is("Test")))
+                .andExpect(jsonPath("$[0].lastName",is("Person")));
+
+        verify(personService,times(1)).getPersonList();
+        verifyNoMoreInteractions(personService);
+    }
+
+    // ======================== Get User By ID ======================== //
+
+    @Test
+    public void testGetPersonById() throws Exception {
+        when(personService.getPersonById(1L)).thenReturn(testPerson);
+
+        mockMvc.perform(get("/people/{id}",1))
+                .andExpect(status().isOk())
+                .andExpect(content().contentType(MediaType.APPLICATION_JSON_UTF8_VALUE))
+                .andExpect(jsonPath("$.firstName",is("Test")))
+                .andExpect(jsonPath("$.lastName",is("Person")));
+
+        verify(personService,times(1)).getPersonById(1L);
+        verifyNoMoreInteractions(personService);
+    }
+
+    @Test
+    public void testGetPersonById_fail_404_notFound() throws Exception {
+        when(personService.getPersonById(2L)).thenReturn(null);
+
+        mockMvc.perform(get("/people/{id}",2))
+                .andExpect(status().isNotFound());
+
+        verify(personService, times(1)).getPersonById(2L);
+        verifyNoMoreInteractions(personService);
+    }
+
+    // ======================== Create Person ======================== //
+
+    @Test
+    public void testCreatePerson() throws Exception {
+        when(personService.savePerson(testPerson)).thenReturn(testPerson);
+
+        mockMvc.perform(post("/people")
+                    .contentType(MediaType.APPLICATION_JSON)
+                    .content(asJsonString(testPerson)))
+                .andExpect(status().isCreated());
+
+        verify(personService,times(1)).savePerson(testPerson);
+        verifyNoMoreInteractions(personService);
+    }
+
+    // ======================== Update Person ======================== //
+
+    @Test
+    public void testUpdatePerson() throws Exception {
+        when(personService.savePerson(testPerson)).thenReturn(testPerson);
+
+        mockMvc.perform(put("/people/{id}",1)
+                .contentType(MediaType.APPLICATION_JSON)
+                .content(asJsonString(testPerson)))
+                .andExpect(status().isOk());
+
+        verify(personService, times(1)).savePerson(testPerson);
+        verifyNoMoreInteractions(personService);
+    }
+
+    // ======================== Delete Person ======================== //
+
+    @Test
+    public void testDeletePerson() throws Exception {
+        doNothing().when(personService).deletePerson(1L);
+
+        mockMvc.perform(delete("/people/{id}",1))
+                .andExpect(status().isNoContent());
+
+        verify(personService, times(1)).deletePerson(1L);
+        verifyNoMoreInteractions(personService);
+    }
+
+
+    public static String asJsonString(final Object obj) {
+        try {
+            final ObjectMapper mapper = new ObjectMapper();
+            return mapper.writeValueAsString(obj);
+        } catch (Exception e) {
+            throw new RuntimeException(e);
+        }
+    }
+}

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

+package io.zipcoder.crudapp;
+
+import io.zipcoder.crudapp.models.Person;
+import io.zipcoder.crudapp.repositories.PersonRepository;
+import io.zipcoder.crudapp.services.PersonService;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.autoconfigure.web.servlet.WebMvcTest;
+import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.boot.test.mock.mockito.MockBean;
+import org.springframework.test.context.junit4.SpringRunner;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import static org.assertj.core.api.Java6Assertions.assertThat;
+import static org.mockito.BDDMockito.given;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+@SpringBootTest
+@RunWith(SpringRunner.class)
+public class PersonServiceTest {
+    List<Person> list;
+    Person testPerson = new Person("Test", "Person");
+    @Before
+    public void setup(){
+        list = new ArrayList<>();
+        list.add(testPerson);
+    }
+
+    @MockBean
+    PersonRepository personRepository;
+
+    @Autowired
+    PersonService personService;
+
+    @Test
+    public void testGetPersonList(){
+        given(
+            this.personRepository.findAll()
+        ).willReturn(
+            list
+        );
+        Iterable<Person> actual = personService.getPersonList();
+        assertThat(actual)
+            .isEqualTo(list);
+    }
+
+    @Test
+    public void testGetPersonById(){
+        given(this.personRepository.findOne(1L)
+        ).willReturn(testPerson);
+
+        Person actual = personService.getPersonById(1L);
+        assertThat(actual).isEqualTo(testPerson);
+    }
+
+    @Test
+    public void testSavePerson(){
+        given(this.personRepository.save(testPerson)
+        ).willReturn(testPerson);
+
+        Person actual = personService.savePerson(testPerson);
+        assertThat(actual).isEqualTo(testPerson);
+    }
+
+    @Test
+    public void testDelete(){
+        personService.deletePerson(1L);
+        verify(personRepository).delete(1L);
+    }
+}