Testing

To enable testing, add the following dependency in pom.xml:

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-test</artifactId>
</dependency>

To test the RestaurantController, the following files have been added:

• RestaurantControllerIntegrationTests, which uses the @SpringApplicationConfiguration annotation to pick the same configuration that Spring Boot uses:

  @RunWith(SpringJUnit4ClassRunner.class)
  @SpringApplicationConfiguration(classes = RestaurantApp.class)
  public class RestaurantControllerIntegrationTests extends
          AbstractRestaurantControllerTests {
  
  }

• An abstract class to write our tests:

  public abstract class AbstractRestaurantControllerTests {
  
      protected static final String RESTAURANT = "1";
      protected static final String RESTAURANT_NAME = "Big-O Restaurant";
  
      @Autowired
      RestaurantController restaurantController;
  
      @Test
      public void validResturantById() {
          Logger.getGlobal().info("Start validResturantById test");
          ResponseEntity<Entity> restaurant = restaurantController.findById(RESTAURANT);
  
          Assert.assertEquals(HttpStatus.OK, restaurant.getStatusCode());
          Assert.assertTrue(restaurant.hasBody());
          Assert.assertNotNull(restaurant.getBody());
          Assert.assertEquals(RESTAURANT, restaurant.getBody().getId());
          Assert.assertEquals(RESTAURANT_NAME, restaurant.getBody().getName());
          Logger.getGlobal().info("End validResturantById test");
      }
  
      @Test
      public void validResturantByName() {
          Logger.getGlobal().info("Start validResturantByName test");
          ResponseEntity<Collection<Restaurant>> restaurants = restaurantController.findByName(RESTAURANT_NAME);
          Logger.getGlobal().info("In validAccount test");
  
          Assert.assertEquals(HttpStatus.OK, restaurants.getStatusCode());
          Assert.assertTrue(restaurants.hasBody());
          Assert.assertNotNull(restaurants.getBody());
          Assert.assertFalse(restaurants.getBody().isEmpty());
          Restaurant restaurant = (Restaurant) restaurants.getBody().toArray()[0];
          Assert.assertEquals(RESTAURANT, restaurant.getId());
          Assert.assertEquals(RESTAURANT_NAME, restaurant.getName());
          Logger.getGlobal().info("End validResturantByName test");
      }
  
      @Test
      public void validAdd() {
          Logger.getGlobal().info("Start validAdd test");
          RestaurantVO restaurant = new RestaurantVO();
          restaurant.setId("999");
          restaurant.setName("Test Restaurant");
  
          ResponseEntity<Restaurant> restaurants = restaurantController.add(restaurant);
          Assert.assertEquals(HttpStatus.CREATED, restaurants.getStatusCode());
          Logger.getGlobal().info("End validAdd test");
      }
  }

• Finally, RestaurantControllerTests, which extends the previously created abstract class and also creates the RestaurantService and RestaurantRepository implementations:

  public class RestaurantControllerTests extends AbstractRestaurantControllerTests {
  
      protected static final Restaurant restaurantStaticInstance = new Restaurant(RESTAURANT,
              RESTAURANT_NAME, null);
  
      protected static class TestRestaurantRepository implements RestaurantRepository<Restaurant, String> {
  
          private Map<String, Restaurant> entities;
  
          public TestRestaurantRepository() {
              entities = new HashMap();
              Restaurant restaurant = new Restaurant("Big-O Restaurant", "1", null);
              entities.put("1", restaurant);
              restaurant = new Restaurant("O Restaurant", "2", null);
              entities.put("2", restaurant);
          }
  
          @Override
          public boolean containsName(String name) {
              try {
                  return this.findByName(name).size() > 0;
              } catch (Exception ex) {
                  //Exception Handler
              }
              return false;
          }
  
          @Override
          public void add(Restaurant entity) {
              entities.put(entity.getId(), entity);
          }
  
          @Override
          public void remove(String id) {
              if (entities.containsKey(id)) {
                  entities.remove(id);
              }
          }
  
          @Override
          public void update(Restaurant entity) {
              if (entities.containsKey(entity.getId())) {
                  entities.put(entity.getId(), entity);
              }
          }
  
          @Override
          public Collection<Restaurant> findByName(String name) throws Exception {
              Collection<Restaurant> restaurants = new ArrayList();
              int noOfChars = name.length();
              entities.forEach((k, v) -> {
                  if (v.getName().toLowerCase().contains(name.subSequence(0, noOfChars))) {
                      restaurants.add(v);
                  }
              });
              return restaurants;
          }
  
          @Override
          public boolean contains(String id) {
              throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
          }
  
          @Override
          public Entity get(String id) {
              return entities.get(id);
          }
          @Override
          public Collection<Restaurant> getAll() {
              return entities.values();
          }
      }
  
      protected TestRestaurantRepository testRestaurantRepository = new TestRestaurantRepository();
      protected RestaurantService restaurantService = new RestaurantServiceImpl(testRestaurantRepository);
  
      @Before
      public void setup() {
          restaurantController = new RestaurantController(restaurantService);
  
      }
  }