@Test
  public void testVoteError() {
    try {
      Vote wrongVote = new Vote();
      wrongVote.setRestaurantId(Long.MAX_VALUE);
      when(restaurantRepository.findOne(Long.MAX_VALUE)).thenReturn(null);
      MvcResult wrongIdVoteRes =
          mockMvc
              .perform(
                  post("/vote")
                      .contentType(MediaType.APPLICATION_JSON)
                      .content(mapper.writeValueAsString(wrongVote)))
              .andExpect(status().isOk())
              .andReturn();
      String wrongIdVoteResponseString = wrongIdVoteRes.getResponse().getContentAsString();
      assertTrue(wrongIdVoteResponseString.contains(Status.FAILED.getStatusValue()));
      assertTrue(wrongIdVoteResponseString.contains(RestaurantController.WRONG_RESTAURANT_MSG));

      LocalTime currentTime = LocalTime.now();
      if (currentTime.isAfter(RestaurantController.DEADLINE)) {

        Vote correctVote = new Vote();
        correctVote.setRestaurantId(Long.MIN_VALUE);
        Restaurant restaurant = new Restaurant();
        restaurant.setRestaurantId(Long.MIN_VALUE);

        when(restaurantRepository.findOne(Long.MIN_VALUE)).thenReturn(restaurant);

        Restaurant votingRestaurant = new Restaurant();
        votingRestaurant.setRestaurantId(Long.MAX_VALUE);
        Voting outdatedVoting = new Voting();
        outdatedVoting.setRestaurant(votingRestaurant);

        when(votingRepository.findByUser("admin")).thenReturn(outdatedVoting);

        MvcResult outdatedVoteRes =
            mockMvc
                .perform(
                    post("/vote")
                        .contentType(MediaType.APPLICATION_JSON)
                        .content(mapper.writeValueAsString(correctVote)))
                .andExpect(status().isOk())
                .andReturn();
        String outdatedVoteResString = outdatedVoteRes.getResponse().getContentAsString();
        assertTrue(outdatedVoteResString.contains(Status.FAILED.getStatusValue()));
      }
    } catch (Exception e) {
      fail();
    }
  }
  @Test
  public void testVoteNone() {

    Vote correctVote = new Vote();
    correctVote.setRestaurantId(Long.MIN_VALUE);
    Restaurant restaurant = new Restaurant();
    restaurant.setRestaurantId(Long.MIN_VALUE);

    when(restaurantRepository.findOne(Long.MIN_VALUE)).thenReturn(restaurant);

    Restaurant votingRestaurant = new Restaurant();
    votingRestaurant.setRestaurantId(Long.MIN_VALUE);
    Voting identicalVoting = new Voting();
    identicalVoting.setRestaurant(votingRestaurant);
    when(votingRepository.findByUser("admin")).thenReturn(identicalVoting);

    try {
      MvcResult outdatedVoteRes =
          mockMvc
              .perform(
                  post("/vote")
                      .contentType(MediaType.APPLICATION_JSON)
                      .content(mapper.writeValueAsString(correctVote)))
              .andExpect(status().isOk())
              .andReturn();

      String outdatedVoteResString = outdatedVoteRes.getResponse().getContentAsString();
      assertTrue(outdatedVoteResString.contains(Status.IGNORED.getStatusValue()));
    } catch (Exception e) {
      fail();
    }
  }
  @Test
  public void testTopVotedSuccess() {
    Long exoticRestaurantId = new Random().nextLong();
    Restaurant exoticRestaurant = createExoticRestaurant();
    exoticRestaurant.setRestaurantId(exoticRestaurantId);

    Long traditionalRestaurantId = new Random().nextLong();
    Restaurant traditionalRestaurant = createTraditionalRestaurant();
    traditionalRestaurant.setRestaurantId(traditionalRestaurantId);

    Voting voting1 = new Voting();
    voting1.setRestaurant(traditionalRestaurant);
    voting1.setUser("user1");

    Voting voting2 = new Voting();
    voting2.setRestaurant(traditionalRestaurant);
    voting2.setUser("user2");
    traditionalRestaurant.setVotings(Arrays.asList(voting1, voting2));

    Voting voting3 = new Voting();
    voting3.setRestaurant(exoticRestaurant);
    voting3.setUser("user3");
    exoticRestaurant.setVotings(Arrays.asList(voting3));
    when(votingRepository.findAll()).thenReturn(Arrays.asList(voting1, voting2, voting3));

    when(restaurantRepository.findOne(exoticRestaurantId)).thenReturn(exoticRestaurant);
    when(restaurantRepository.findOne(traditionalRestaurantId)).thenReturn(traditionalRestaurant);

    try {
      MvcResult topVotedRestaurantResponse =
          mockMvc.perform(get("/top")).andExpect(status().isOk()).andReturn();
      String responseContent = topVotedRestaurantResponse.getResponse().getContentAsString();
      assertTrue(responseContent.contains(Status.SUCCESS.getStatusValue()));
      assertTrue(responseContent.contains(traditionalRestaurant.getName()));
      assertTrue(responseContent.contains(voting1.getUser()));
      assertTrue(responseContent.contains(voting2.getUser()));
      assertFalse(responseContent.contains(exoticRestaurant.getName()));
      assertFalse(responseContent.contains(voting3.getUser()));
    } catch (Exception e) {
      fail();
    }
  }
 @Test
 public void testListSuccess() {
   try {
     Restaurant exoticRestaurant = createExoticRestaurant();
     Restaurant traditionalRestaurant = createTraditionalRestaurant();
     when(restaurantRepository.findAll())
         .thenReturn(Arrays.asList(exoticRestaurant, traditionalRestaurant));
     mockMvc.perform(get("/list")).andExpect(status().isOk());
   } catch (Exception e) {
     fail();
   }
 }
  @Test
  public void testVoteSuccess() {

    Vote correctVote = new Vote();
    correctVote.setRestaurantId(Long.MIN_VALUE);
    Restaurant restaurant = new Restaurant();
    restaurant.setRestaurantId(Long.MIN_VALUE);

    when(restaurantRepository.findOne(Long.MIN_VALUE)).thenReturn(restaurant);

    when(votingRepository.findByUser("admin")).thenReturn(null);

    try {
      MvcResult successVoteRes =
          mockMvc
              .perform(
                  post("/vote")
                      .contentType(MediaType.APPLICATION_JSON)
                      .content(mapper.writeValueAsString(correctVote)))
              .andExpect(status().isOk())
              .andReturn();

      String outdatedVoteResString = successVoteRes.getResponse().getContentAsString();
      assertTrue(outdatedVoteResString.contains(Status.SUCCESS.getStatusValue()));
    } catch (Exception e) {
      fail();
    }

    LocalTime currentTime = LocalTime.now();
    if (currentTime.isBefore(RestaurantController.DEADLINE)) {
      Restaurant votingRestaurant = new Restaurant();
      votingRestaurant.setRestaurantId(Long.MAX_VALUE);
      Voting identicalVoting = new Voting();
      identicalVoting.setRestaurant(votingRestaurant);
      when(votingRepository.findByUser("admin")).thenReturn(identicalVoting);

      try {
        MvcResult actualVoteRes =
            mockMvc
                .perform(
                    post("/vote")
                        .contentType(MediaType.APPLICATION_JSON)
                        .content(mapper.writeValueAsString(correctVote)))
                .andExpect(status().isOk())
                .andReturn();

        String outdatedVoteResString = actualVoteRes.getResponse().getContentAsString();
        assertTrue(outdatedVoteResString.contains(Status.SUCCESS.getStatusValue()));
      } catch (Exception e) {
        fail();
      }
    }
  }
  @Test
  public void testUpdateRestaurantFail() {

    Restaurant restaurant = createExoticRestaurant();
    when(restaurantRepository.exists(Mockito.anyLong())).thenReturn(false);
    try {
      MvcResult updateRestaurantResponse =
          mockMvc
              .perform(
                  post("/restaurant/delete")
                      .contentType(MediaType.APPLICATION_JSON)
                      .content(mapper.writeValueAsString(restaurant)))
              .andExpect(status().isOk())
              .andReturn();

      String responseContent = updateRestaurantResponse.getResponse().getContentAsString();
      assertTrue(responseContent.contains(Status.FAILED.getStatusValue()));
    } catch (Exception e) {
      fail();
    }
  }
  @Test
  public void testAddRestaurantAlreadyExists() {
    Restaurant restaurant = createExoticRestaurant();
    when(restaurantRepository.findByName(Mockito.anyString())).thenReturn(restaurant);

    try {
      MvcResult addRestaurantResponse =
          mockMvc
              .perform(
                  post("/restaurant/add")
                      .contentType(MediaType.APPLICATION_JSON)
                      .content(mapper.writeValueAsString(restaurant)))
              .andExpect(status().isOk())
              .andReturn();

      String responseContent = addRestaurantResponse.getResponse().getContentAsString();
      assertTrue(responseContent.contains(Status.IGNORED.getStatusValue()));
    } catch (Exception e) {
      fail();
    }
  }
  @Test
  public void testDeleteRestaurantFail() {

    when(restaurantRepository.exists(Mockito.anyLong())).thenReturn(false);
    Vote vote = new Vote();
    vote.setRestaurantId(Long.MAX_VALUE);
    try {
      MvcResult deleteRestaurantResponse =
          mockMvc
              .perform(
                  post("/restaurant/delete")
                      .contentType(MediaType.APPLICATION_JSON)
                      .content(mapper.writeValueAsString(vote)))
              .andExpect(status().isOk())
              .andReturn();

      String responseContent = deleteRestaurantResponse.getResponse().getContentAsString();
      assertTrue(responseContent.contains(Status.FAILED.getStatusValue()));
    } catch (Exception e) {
      fail();
    }
  }
 @Override
 public void cleanupRepositories() {
   restaurantRepository.deleteAll();
 }