Merge branch 'testing/house' into 'milestone-2'

    repository = houseRepository;

  }

  public Object foo(){

	  return null;

  }

}

package cz.muni.fi.pa165.core.house;

import com.fasterxml.jackson.databind.ObjectMapper;

import cz.muni.fi.pa165.model.dto.house.HouseCreateDto;

import cz.muni.fi.pa165.model.dto.house.HouseDto;

import org.junit.jupiter.api.BeforeEach;

import org.junit.jupiter.api.Test;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.boot.test.autoconfigure.web.servlet.AutoConfigureMockMvc;

import org.springframework.boot.test.context.SpringBootTest;

import org.springframework.test.context.TestPropertySource;

import org.springframework.test.web.servlet.MockMvc;

import static org.assertj.core.api.AssertionsForClassTypes.assertThat;

import static org.junit.jupiter.api.Assertions.assertNull;

import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.post;

import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;

@SpringBootTest

@AutoConfigureMockMvc

@TestPropertySource(locations = "classpath:application-test.properties")

public class HouseControllerTest {

    @Autowired

    private MockMvc mockMvc;

    @Autowired

    private ObjectMapper objectMapper;

    @Autowired

    private HouseFacade houseFacade;

    @Autowired

    private HouseService houseService;

    private final static String URL = "/api/house";

    private final static String CONTENT_TYPE =  "application/json";

    @BeforeEach

    void setUp() {

        HouseCreateDto h1 = new HouseCreateDto();

        h1.setCity("Sarajevo");

        h1.setAddress("Titova 9");

        houseFacade.create(h1);

        HouseCreateDto h2 = new HouseCreateDto();

        h2.setCity("Brno");

        h2.setAddress("Chrvatska 2");

        houseFacade.create(h1);

    }

    @Test

    void createHouseTest() throws Exception {

        HouseCreateDto h2 = new HouseCreateDto();

        h2.setCity("Brno");

        h2.setAddress("Chrvatska 2");

        String response = mockMvc.perform(post(URL)

                        .contentType(CONTENT_TYPE)

                        .content(objectMapper.writeValueAsString(h2)))

                .andExpect(status().isOk())

                .andReturn()

                .getResponse()

                .getContentAsString();

        HouseDto houseDto = objectMapper.readValue(response, HouseDto.class);

        assertThat(houseDto.getId()).isNotNull();

        assertThat(houseDto.getAddress()).isEqualTo(houseDto.getAddress());

    }

}

package cz.muni.fi.pa165.core.house;

import cz.muni.fi.pa165.core.smartmeter.SmartMeter;

import org.junit.jupiter.api.BeforeEach;

import org.junit.jupiter.api.Test;

import org.mockito.InjectMocks;

import org.mockito.Mock;

import org.springframework.data.domain.Page;

import org.springframework.data.domain.PageImpl;

import org.springframework.data.domain.PageRequest;

import org.springframework.data.domain.Pageable;

import java.util.ArrayList;

import java.util.List;

import java.util.Optional;

import static org.assertj.core.api.Assertions.assertThat;

import static org.junit.jupiter.api.Assertions.assertEquals;

import static org.mockito.Mockito.verify;

import static org.mockito.Mockito.when;

import static org.mockito.MockitoAnnotations.openMocks;

public class HouseServiceTest {

    @InjectMocks

    private HouseService houseService;

    @Mock

    private HouseRepository houseRepository;

    @BeforeEach

    void init() {

        openMocks(this);

    }

    public House helperNewHouse() {

        List<SmartMeter> list = List.of(new SmartMeter(), new SmartMeter(), new SmartMeter());

        return new House("Titova 6", "Sarajevo", "Bosnia and Herzegovina", "71000", list, new ArrayList<>());

    }

    @Test

    public void shouldFindHouseById() {

        House house = House

                .builder()

                .city("Sarajevo")

                .state("Bosnia and Herzegovina")

                .zipcode("71000")

                .ownerList(new ArrayList<>())

                .address("Titova 6")

                .build();

        when(houseRepository.findById(house.getId())).thenReturn(Optional.of(house));

        House result = houseService.findById(house.getId());

        verify(houseRepository).findById(house.getId());

        assertEquals(house, result);

    }

    @Test

    public void shouldCreateNewHouse() {

        House house = helperNewHouse();

        when(houseRepository.save(house)).thenReturn(house);

        House house1 = houseService.create(house);

        verify(houseRepository).save(house);

        assertThat(house1).isEqualTo(house);

    }

    @Test

    void shouldFindAllHousesPageableInt() {

        House h1 = helperNewHouse();

        House h2 = helperNewHouse();

        Page<House> page = new PageImpl<>(List.of(h1, h2));

        int pageNumber = 0;

        int pageSize = 10;

        when(houseRepository.findAll(PageRequest.of(pageNumber, pageSize))).thenReturn(page);

        Page<House> result = houseService.findAllPageableInt(pageNumber);

        verify(houseRepository).findAll(PageRequest.of(pageNumber, pageSize));

        assertThat(result).containsExactlyInAnyOrder(h1, h2);

    }

    @Test

    void shouldUpdateHouse() {

        House h1 = helperNewHouse();

        House h2 = helperNewHouse();

        when(houseRepository.findById(h1.getId())).thenReturn(Optional.of(h1));

        when(houseRepository.save(h2)).thenReturn(h2);

        House result = houseService.update(h2, h1.getId());

        verify(houseRepository).findById(h1.getId());

        verify(houseRepository).save(h2);

        assertEquals(h1.getId(), result.getId());

        assertEquals(h2.getAddress(), result.getAddress());

    }

    @Test

    void shouldDeleteAllHouses() {

        var data = List.of(

                helperNewHouse(), helperNewHouse(), helperNewHouse()

        );

        when(houseRepository.findAll()).thenReturn(data);

        houseService.deleteAll();

        verify(houseRepository).findAll();

        verify(houseRepository).saveAll(data);

    }

    @Test

    void shouldDeleteAllCompaniesByIds() {

        House h1 = helperNewHouse();

        House h2 = helperNewHouse();

        String[] ids = {h1.getId(), h2.getId()};

        when(houseRepository.findById(h1.getId())).thenReturn(Optional.of(h1));

        when(houseRepository.findById(h2.getId())).thenReturn(Optional.of(h2));

        houseService.deleteAllById(ids);

        verify(houseRepository).save(h1);

        verify(houseRepository).save(h2);

    }

    @Test

    void shouldFindAllHouses() {

        List<House> houses = List.of(

                helperNewHouse(), helperNewHouse(), helperNewHouse()

        );

        when(houseRepository.findAll()).thenReturn(houses);

        List<House> result = houseService.findAll();

        verify(houseRepository).findAll();

        assertEquals(houses, result);

    }

    @Test

    void shouldFindAllHousesPageable() {

        int pageNumber = 0;

        int pageSize = 10;

        Pageable pageable = PageRequest.of(pageNumber, pageSize);

        List<House> houses = List.of(

                helperNewHouse(), helperNewHouse(), helperNewHouse()

        );

        Page<House> pageResult = new PageImpl<>(houses, pageable, houses.size());

        when(houseRepository.findAll(pageable)).thenReturn(pageResult);

        Page<House> result = houseService.findAllPageable(pageable);

        verify(houseRepository).findAll(pageable);

        assertEquals(pageResult, result);

    }

}