Squashed 'backend/' content from commit c76a37a
git-subtree-dir: backend git-subtree-split: c76a37a8556de7ec3597f8f1d61bcce740752404
This commit is contained in:
commit
312bd747ce
35 changed files with 2409 additions and 0 deletions
|
|
@ -0,0 +1,14 @@
|
|||
package fr.vincent.ramiere.mangerautourdesimplonback;
|
||||
|
||||
import org.junit.jupiter.api.Test;
|
||||
import org.springframework.boot.test.context.SpringBootTest;
|
||||
|
||||
@SpringBootTest
|
||||
class MangerAutourDeSimplonBackApplicationTests {
|
||||
|
||||
@Test
|
||||
void contextLoads() {
|
||||
// Ce test garantit que le contexte de l'application Spring peut démarrer avec
|
||||
// succès.
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,72 @@
|
|||
package fr.vincent.ramiere.mangerautourdesimplonback.controller;
|
||||
|
||||
import fr.vincent.ramiere.mangerautourdesimplonback.models.Preference;
|
||||
import fr.vincent.ramiere.mangerautourdesimplonback.service.PreferenceService;
|
||||
import org.junit.jupiter.api.BeforeEach;
|
||||
import org.junit.jupiter.api.Test;
|
||||
import org.mockito.Mockito;
|
||||
import org.springframework.http.MediaType;
|
||||
import org.springframework.test.web.servlet.MockMvc;
|
||||
import org.springframework.test.web.servlet.setup.MockMvcBuilders;
|
||||
import java.util.Collections;
|
||||
import java.util.Optional;
|
||||
import static org.mockito.Mockito.times;
|
||||
import static org.mockito.Mockito.verify;
|
||||
import static org.mockito.Mockito.when;
|
||||
import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.get;
|
||||
import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.put;
|
||||
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;
|
||||
|
||||
class PreferenceControllerTest {
|
||||
|
||||
private PreferenceService preferenceService;
|
||||
private MockMvc mockMvc;
|
||||
|
||||
@BeforeEach
|
||||
void setup() {
|
||||
preferenceService = Mockito.mock(PreferenceService.class);
|
||||
PreferenceController controller = new PreferenceController(preferenceService);
|
||||
mockMvc = MockMvcBuilders.standaloneSetup(controller).build();
|
||||
}
|
||||
|
||||
@Test
|
||||
void getPreferencesByPersonneId_shouldReturnOkAndCallService() throws Exception {
|
||||
when(preferenceService.getPreferencesByPersonneId(42)).thenReturn(Collections.emptyList());
|
||||
|
||||
mockMvc.perform(get("/api/v1/preferences/user/42"))
|
||||
.andExpect(status().isOk());
|
||||
|
||||
verify(preferenceService, times(1)).getPreferencesByPersonneId(42);
|
||||
}
|
||||
|
||||
@Test
|
||||
void saveOrUpdatePreference_shouldReturnNotFound_whenServiceReturnsEmpty() throws Exception {
|
||||
when(preferenceService.saveOrUpdatePreference(1, 2, 5, true))
|
||||
.thenReturn(Optional.empty());
|
||||
|
||||
String json = "{\"personneId\":1,\"restaurantId\":2,\"note\":5,\"favori\":true}";
|
||||
|
||||
mockMvc.perform(put("/api/v1/preferences")
|
||||
.contentType(MediaType.APPLICATION_JSON)
|
||||
.content(json))
|
||||
.andExpect(status().isNotFound());
|
||||
|
||||
verify(preferenceService, times(1)).saveOrUpdatePreference(1, 2, 5, true);
|
||||
}
|
||||
|
||||
@Test
|
||||
void saveOrUpdatePreference_shouldReturnOk_whenServiceReturnsPreference() throws Exception {
|
||||
Preference prefMock = Mockito.mock(Preference.class);
|
||||
when(preferenceService.saveOrUpdatePreference(7, 8, 3, false))
|
||||
.thenReturn(Optional.of(prefMock));
|
||||
|
||||
String json = "{\"personneId\":7,\"restaurantId\":8,\"note\":3,\"favori\":false}";
|
||||
|
||||
mockMvc.perform(put("/api/v1/preferences")
|
||||
.contentType(MediaType.APPLICATION_JSON)
|
||||
.content(json))
|
||||
.andExpect(status().isOk());
|
||||
|
||||
verify(preferenceService, times(1)).saveOrUpdatePreference(7, 8, 3, false);
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,120 @@
|
|||
package fr.vincent.ramiere.mangerautourdesimplonback.controller;
|
||||
|
||||
import fr.vincent.ramiere.mangerautourdesimplonback.models.Restaurant;
|
||||
import fr.vincent.ramiere.mangerautourdesimplonback.service.RestaurantService;
|
||||
import org.junit.jupiter.api.BeforeEach;
|
||||
import org.junit.jupiter.api.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.Arrays;
|
||||
import java.util.List;
|
||||
import java.util.Optional;
|
||||
import static org.junit.jupiter.api.Assertions.*;
|
||||
import static org.mockito.Mockito.*;
|
||||
|
||||
class RestaurantControllerTest {
|
||||
|
||||
@Mock
|
||||
private RestaurantService restaurantService;
|
||||
|
||||
@InjectMocks
|
||||
private RestaurantController restaurantController;
|
||||
|
||||
@BeforeEach
|
||||
void setUp() {
|
||||
MockitoAnnotations.openMocks(this);
|
||||
}
|
||||
|
||||
@Test
|
||||
void getAllRestaurants_shouldReturnListOfRestaurants() {
|
||||
Restaurant r1 = new Restaurant();
|
||||
Restaurant r2 = new Restaurant();
|
||||
List<Restaurant> restaurants = Arrays.asList(r1, r2);
|
||||
|
||||
when(restaurantService.getAllRestaurants()).thenReturn(restaurants);
|
||||
|
||||
ResponseEntity<List<Restaurant>> response = restaurantController.getAllRestaurants();
|
||||
|
||||
assertEquals(HttpStatus.OK, response.getStatusCode());
|
||||
assertEquals(restaurants, response.getBody());
|
||||
}
|
||||
|
||||
@Test
|
||||
void getRestaurantById_found_shouldReturnRestaurant() {
|
||||
Restaurant restaurant = new Restaurant();
|
||||
when(restaurantService.getRestaurantById(1)).thenReturn(Optional.of(restaurant));
|
||||
|
||||
ResponseEntity<Restaurant> response = restaurantController.getRestaurantById(1);
|
||||
|
||||
assertEquals(HttpStatus.OK, response.getStatusCode());
|
||||
assertEquals(restaurant, response.getBody());
|
||||
}
|
||||
|
||||
@Test
|
||||
void getRestaurantById_notFound_shouldReturnNotFound() {
|
||||
when(restaurantService.getRestaurantById(1)).thenReturn(Optional.empty());
|
||||
|
||||
ResponseEntity<Restaurant> response = restaurantController.getRestaurantById(1);
|
||||
|
||||
assertEquals(HttpStatus.NOT_FOUND, response.getStatusCode());
|
||||
assertNull(response.getBody());
|
||||
}
|
||||
|
||||
@Test
|
||||
void createRestaurant_shouldReturnCreatedRestaurant() {
|
||||
Restaurant restaurant = new Restaurant();
|
||||
Restaurant savedRestaurant = new Restaurant();
|
||||
when(restaurantService.saveRestaurant(restaurant)).thenReturn(savedRestaurant);
|
||||
|
||||
ResponseEntity<Restaurant> response = restaurantController.createRestaurant(restaurant);
|
||||
|
||||
assertEquals(HttpStatus.CREATED, response.getStatusCode());
|
||||
assertEquals(savedRestaurant, response.getBody());
|
||||
}
|
||||
|
||||
@Test
|
||||
void updateRestaurant_found_shouldReturnUpdatedRestaurant() {
|
||||
Restaurant details = new Restaurant();
|
||||
Restaurant updated = new Restaurant();
|
||||
when(restaurantService.updateRestaurant(eq(1), any(Restaurant.class))).thenReturn(Optional.of(updated));
|
||||
|
||||
ResponseEntity<Restaurant> response = restaurantController.updateRestaurant(1, details);
|
||||
|
||||
assertEquals(HttpStatus.OK, response.getStatusCode());
|
||||
assertEquals(updated, response.getBody());
|
||||
}
|
||||
|
||||
@Test
|
||||
void updateRestaurant_notFound_shouldReturnNotFound() {
|
||||
Restaurant details = new Restaurant();
|
||||
when(restaurantService.updateRestaurant(eq(1), any(Restaurant.class))).thenReturn(Optional.empty());
|
||||
|
||||
ResponseEntity<Restaurant> response = restaurantController.updateRestaurant(1, details);
|
||||
|
||||
assertEquals(HttpStatus.NOT_FOUND, response.getStatusCode());
|
||||
assertNull(response.getBody());
|
||||
}
|
||||
|
||||
@Test
|
||||
void deleteRestaurant_found_shouldReturnNoContent() {
|
||||
when(restaurantService.getRestaurantById(1)).thenReturn(Optional.of(new Restaurant()));
|
||||
|
||||
ResponseEntity<Void> response = restaurantController.deleteRestaurant(1);
|
||||
|
||||
assertEquals(HttpStatus.NO_CONTENT, response.getStatusCode());
|
||||
verify(restaurantService, times(1)).deleteRestaurant(1);
|
||||
}
|
||||
|
||||
@Test
|
||||
void deleteRestaurant_notFound_shouldReturnNotFound() {
|
||||
when(restaurantService.getRestaurantById(1)).thenReturn(Optional.empty());
|
||||
|
||||
ResponseEntity<Void> response = restaurantController.deleteRestaurant(1);
|
||||
|
||||
assertEquals(HttpStatus.NOT_FOUND, response.getStatusCode());
|
||||
verify(restaurantService, never()).deleteRestaurant(anyInt());
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,16 @@
|
|||
package fr.vincent.ramiere.mangerautourdesimplonback.models;
|
||||
|
||||
import static org.junit.jupiter.api.Assertions.assertEquals;
|
||||
|
||||
import org.junit.jupiter.api.Test;
|
||||
|
||||
class PersonneTest {
|
||||
@Test
|
||||
void testBuilder() {
|
||||
Personne p = Personne.builder().nom("Test").prenom("Test").email("t@t.fr").password("1234").build();
|
||||
assertEquals("Test", p.getNom());
|
||||
assertEquals("Test", p.getPrenom());
|
||||
assertEquals("t@t.fr", p.getEmail());
|
||||
assertEquals("1234", p.getPassword());
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,48 @@
|
|||
package fr.vincent.ramiere.mangerautourdesimplonback.models;
|
||||
|
||||
import static org.junit.jupiter.api.Assertions.*;
|
||||
import org.junit.jupiter.api.Test;
|
||||
|
||||
class PreferencePKTest {
|
||||
|
||||
@Test
|
||||
void noArgsConstructor_settersAndGetters_handleNulls() {
|
||||
PreferencePK pk = new PreferencePK();
|
||||
// initially null
|
||||
assertNull(pk.getPersonne());
|
||||
assertNull(pk.getRestau());
|
||||
|
||||
// set to null explicitly and verify
|
||||
pk.setPersonne(null);
|
||||
pk.setRestau(null);
|
||||
assertNull(pk.getPersonne());
|
||||
assertNull(pk.getRestau());
|
||||
}
|
||||
|
||||
@Test
|
||||
void equals_and_hashCode_withBothFieldsNull_areEqual() {
|
||||
PreferencePK a = new PreferencePK();
|
||||
PreferencePK b = new PreferencePK();
|
||||
|
||||
// Both have null personne and restau -> should be equal and have same hashCode
|
||||
assertEquals(a, b);
|
||||
assertEquals(b, a);
|
||||
assertEquals(a.hashCode(), b.hashCode());
|
||||
|
||||
// reflexive
|
||||
assertEquals(a, a);
|
||||
}
|
||||
|
||||
@Test
|
||||
void equals_withSameReference_isTrue_and_hashCodeStable() {
|
||||
PreferencePK original = new PreferencePK();
|
||||
PreferencePK sameRef = original;
|
||||
|
||||
assertEquals(original, sameRef);
|
||||
assertEquals(original.hashCode(), sameRef.hashCode());
|
||||
|
||||
int firstHash = original.hashCode();
|
||||
int secondHash = original.hashCode();
|
||||
assertEquals(firstHash, secondHash, "hashCode should be stable across invocations");
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,65 @@
|
|||
|
||||
package fr.vincent.ramiere.mangerautourdesimplonback.models;
|
||||
|
||||
import org.junit.jupiter.api.Test;
|
||||
import java.io.*;
|
||||
import static org.junit.jupiter.api.Assertions.*;
|
||||
|
||||
class PreferenceTest {
|
||||
|
||||
@Test
|
||||
void defaultConstructor_and_setters_getters() {
|
||||
Preference p = new Preference();
|
||||
assertNull(p.getPreferencePK());
|
||||
assertNull(p.getNote());
|
||||
assertNull(p.getFavori());
|
||||
|
||||
p.setNote(5);
|
||||
p.setFavori(Boolean.TRUE);
|
||||
|
||||
assertEquals(5, p.getNote());
|
||||
assertTrue(p.getFavori());
|
||||
}
|
||||
|
||||
@Test
|
||||
void allArgsConstructor_setsFieldsInOrder() {
|
||||
// AllArgsConstructor order is (PreferencePK preferencePK, Integer note, Boolean
|
||||
// favori)
|
||||
Preference p = new Preference(null, 3, Boolean.FALSE);
|
||||
|
||||
assertNull(p.getPreferencePK());
|
||||
assertEquals(3, p.getNote());
|
||||
assertFalse(p.getFavori());
|
||||
}
|
||||
|
||||
@Test
|
||||
void singleArgConstructor_setsOnlyPreferencePK() {
|
||||
Preference p = new Preference((PreferencePK) null);
|
||||
|
||||
assertNull(p.getPreferencePK());
|
||||
// other fields remain null when not provided
|
||||
assertNull(p.getNote());
|
||||
assertNull(p.getFavori());
|
||||
}
|
||||
|
||||
@Test
|
||||
void implementsSerializable_and_canBeSerialized() throws Exception {
|
||||
Preference original = new Preference(null, 4, Boolean.TRUE);
|
||||
|
||||
ByteArrayOutputStream bos = new ByteArrayOutputStream();
|
||||
try (ObjectOutputStream oos = new ObjectOutputStream(bos)) {
|
||||
oos.writeObject(original);
|
||||
}
|
||||
|
||||
byte[] bytes = bos.toByteArray();
|
||||
try (ObjectInputStream ois = new ObjectInputStream(new ByteArrayInputStream(bytes))) {
|
||||
Object obj = ois.readObject();
|
||||
assertTrue(obj instanceof Preference);
|
||||
Preference deserialized = (Preference) obj;
|
||||
|
||||
assertEquals(original.getPreferencePK(), deserialized.getPreferencePK());
|
||||
assertEquals(original.getNote(), deserialized.getNote());
|
||||
assertEquals(original.getFavori(), deserialized.getFavori());
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,26 @@
|
|||
package fr.vincent.ramiere.mangerautourdesimplonback.models;
|
||||
|
||||
import static org.junit.jupiter.api.Assertions.assertEquals;
|
||||
import static org.junit.jupiter.api.Assertions.assertFalse;
|
||||
import static org.junit.jupiter.api.Assertions.assertTrue;
|
||||
|
||||
import org.junit.jupiter.api.Test;
|
||||
|
||||
class RestaurantTest {
|
||||
@Test
|
||||
void testBuilder() {
|
||||
Restaurant r = Restaurant.builder().nom("Test").adresse("Adresse Test").telephone("0123456789").accesPMR(true)
|
||||
.aEmporter(true)
|
||||
.surPlace(false).prix(10).latitude("1.0").longitude("2.0").website("site-test.com").build();
|
||||
assertEquals("Test", r.getNom());
|
||||
assertEquals("Adresse Test", r.getAdresse());
|
||||
assertEquals("0123456789", r.getTelephone());
|
||||
assertTrue(r.getAccesPMR());
|
||||
assertTrue(r.getAEmporter());
|
||||
assertFalse(r.getSurPlace());
|
||||
assertEquals(10, r.getPrix());
|
||||
assertEquals("1.0", r.getLatitude());
|
||||
assertEquals("2.0", r.getLongitude());
|
||||
assertEquals("site-test.com", r.getWebsite());
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,116 @@
|
|||
package fr.vincent.ramiere.mangerautourdesimplonback.services;
|
||||
|
||||
import fr.vincent.ramiere.mangerautourdesimplonback.models.Personne;
|
||||
import fr.vincent.ramiere.mangerautourdesimplonback.models.Preference;
|
||||
import fr.vincent.ramiere.mangerautourdesimplonback.models.PreferencePK;
|
||||
import fr.vincent.ramiere.mangerautourdesimplonback.models.Restaurant;
|
||||
import fr.vincent.ramiere.mangerautourdesimplonback.repository.PersonneRepository;
|
||||
import fr.vincent.ramiere.mangerautourdesimplonback.repository.PreferenceRepository;
|
||||
import fr.vincent.ramiere.mangerautourdesimplonback.repository.RestaurantRepository;
|
||||
import fr.vincent.ramiere.mangerautourdesimplonback.service.PreferenceService;
|
||||
|
||||
import org.junit.jupiter.api.Test;
|
||||
import org.junit.jupiter.api.extension.ExtendWith;
|
||||
import org.mockito.ArgumentCaptor;
|
||||
import org.mockito.InjectMocks;
|
||||
import org.mockito.Mock;
|
||||
import org.mockito.junit.jupiter.MockitoExtension;
|
||||
import java.util.List;
|
||||
import java.util.Optional;
|
||||
import static org.junit.jupiter.api.Assertions.*;
|
||||
import static org.mockito.Mockito.*;
|
||||
|
||||
/**
|
||||
* Unit tests for PreferenceService.
|
||||
*/
|
||||
@ExtendWith(MockitoExtension.class)
|
||||
class PreferenceServiceTest {
|
||||
|
||||
@Mock
|
||||
private PreferenceRepository preferenceRepository;
|
||||
|
||||
@Mock
|
||||
private PersonneRepository personneRepository;
|
||||
|
||||
@Mock
|
||||
private RestaurantRepository restaurantRepository;
|
||||
|
||||
@InjectMocks
|
||||
private PreferenceService preferenceService;
|
||||
|
||||
@Test
|
||||
void getPreferencesByPersonneId_returnsListFromRepository() {
|
||||
Personne p = mock(Personne.class);
|
||||
Restaurant r = mock(Restaurant.class);
|
||||
Preference pref = new Preference(new PreferencePK(p, r));
|
||||
List<Preference> expected = List.of(pref);
|
||||
|
||||
when(preferenceRepository.findByPreferencePK_Personne_Id(1)).thenReturn(expected);
|
||||
|
||||
List<Preference> result = preferenceService.getPreferencesByPersonneId(1);
|
||||
|
||||
assertSame(expected, result);
|
||||
verify(preferenceRepository, times(1)).findByPreferencePK_Personne_Id(1);
|
||||
}
|
||||
|
||||
@Test
|
||||
void saveOrUpdatePreference_whenPersonMissing_returnsEmpty() {
|
||||
when(personneRepository.findById(1)).thenReturn(Optional.empty());
|
||||
// restaurant repo may or may not be called; service checks person first
|
||||
Optional<Preference> result = preferenceService.saveOrUpdatePreference(1, 2, 5, true);
|
||||
|
||||
assertTrue(result.isEmpty());
|
||||
verify(personneRepository, times(1)).findById(1);
|
||||
verifyNoInteractions(preferenceRepository);
|
||||
}
|
||||
|
||||
@Test
|
||||
void saveOrUpdatePreference_createsNewPreference_andSavesIt() {
|
||||
Personne personne = new Personne();
|
||||
Restaurant restaurant = new Restaurant();
|
||||
|
||||
when(personneRepository.findById(10)).thenReturn(Optional.of(personne));
|
||||
when(restaurantRepository.findById(20)).thenReturn(Optional.of(restaurant));
|
||||
when(preferenceRepository.findById(any(PreferencePK.class))).thenReturn(Optional.empty());
|
||||
when(preferenceRepository.save(any(Preference.class))).thenAnswer(invocation -> invocation.getArgument(0));
|
||||
|
||||
Optional<Preference> result = preferenceService.saveOrUpdatePreference(10, 20, 4, Boolean.TRUE);
|
||||
|
||||
assertTrue(result.isPresent());
|
||||
Preference saved = result.get();
|
||||
// assume typical getter names getNote/getFavori exist on Preference
|
||||
assertEquals(4, saved.getNote());
|
||||
assertEquals(Boolean.TRUE, saved.getFavori());
|
||||
|
||||
ArgumentCaptor<Preference> captor = ArgumentCaptor.forClass(Preference.class);
|
||||
verify(preferenceRepository, times(1)).save(captor.capture());
|
||||
Preference captured = captor.getValue();
|
||||
assertEquals(4, captured.getNote());
|
||||
assertEquals(Boolean.TRUE, captured.getFavori());
|
||||
}
|
||||
|
||||
@Test
|
||||
void saveOrUpdatePreference_updatesExistingPreference_andSavesIt() {
|
||||
Personne personne = new Personne();
|
||||
Restaurant restaurant = new Restaurant();
|
||||
PreferencePK pk = new PreferencePK(personne, restaurant);
|
||||
Preference existing = new Preference(pk);
|
||||
existing.setNote(1);
|
||||
existing.setFavori(false);
|
||||
|
||||
when(personneRepository.findById(7)).thenReturn(Optional.of(personne));
|
||||
when(restaurantRepository.findById(8)).thenReturn(Optional.of(restaurant));
|
||||
when(preferenceRepository.findById(any(PreferencePK.class))).thenReturn(Optional.of(existing));
|
||||
when(preferenceRepository.save(any(Preference.class))).thenAnswer(invocation -> invocation.getArgument(0));
|
||||
|
||||
Optional<Preference> result = preferenceService.saveOrUpdatePreference(7, 8, 10, Boolean.TRUE);
|
||||
|
||||
assertTrue(result.isPresent());
|
||||
Preference updated = result.get();
|
||||
assertSame(existing, updated);
|
||||
assertEquals(10, updated.getNote());
|
||||
assertEquals(Boolean.TRUE, updated.getFavori());
|
||||
|
||||
verify(preferenceRepository, times(1)).save(existing);
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,131 @@
|
|||
package fr.vincent.ramiere.mangerautourdesimplonback.services;
|
||||
|
||||
import fr.vincent.ramiere.mangerautourdesimplonback.models.Restaurant;
|
||||
import fr.vincent.ramiere.mangerautourdesimplonback.repository.RestaurantRepository;
|
||||
import fr.vincent.ramiere.mangerautourdesimplonback.service.RestaurantService;
|
||||
|
||||
import org.junit.jupiter.api.BeforeEach;
|
||||
import org.junit.jupiter.api.Test;
|
||||
import org.mockito.InjectMocks;
|
||||
import org.mockito.Mock;
|
||||
import org.mockito.MockitoAnnotations;
|
||||
|
||||
import java.util.Arrays;
|
||||
import java.util.List;
|
||||
import java.util.Optional;
|
||||
import static org.mockito.Mockito.*;
|
||||
import static org.junit.jupiter.api.Assertions.*;
|
||||
|
||||
class RestaurantServiceTest {
|
||||
@Mock
|
||||
private RestaurantRepository restaurantRepository;
|
||||
@InjectMocks
|
||||
private RestaurantService restaurantService;
|
||||
|
||||
@BeforeEach
|
||||
void setUp() {
|
||||
MockitoAnnotations.openMocks(this);
|
||||
}
|
||||
|
||||
@Test
|
||||
void testGetAllRestaurants() {
|
||||
Restaurant r1 = new Restaurant();
|
||||
Restaurant r2 = new Restaurant();
|
||||
when(restaurantRepository.findAll()).thenReturn(Arrays.asList(r1, r2));
|
||||
|
||||
List<Restaurant> result = restaurantService.getAllRestaurants();
|
||||
|
||||
assertEquals(2, result.size());
|
||||
verify(restaurantRepository).findAll();
|
||||
}
|
||||
|
||||
@Test
|
||||
void testGetRestaurantById_Found() {
|
||||
Restaurant r = new Restaurant();
|
||||
r.setNom("Test");
|
||||
when(restaurantRepository.findById(1)).thenReturn(Optional.of(r));
|
||||
|
||||
Optional<Restaurant> result = restaurantService.getRestaurantById(1);
|
||||
|
||||
assertTrue(result.isPresent());
|
||||
assertEquals("Test", result.get().getNom());
|
||||
verify(restaurantRepository).findById(1);
|
||||
}
|
||||
|
||||
@Test
|
||||
void testGetRestaurantById_NotFound() {
|
||||
when(restaurantRepository.findById(2)).thenReturn(Optional.empty());
|
||||
|
||||
Optional<Restaurant> result = restaurantService.getRestaurantById(2);
|
||||
|
||||
assertFalse(result.isPresent());
|
||||
verify(restaurantRepository).findById(2);
|
||||
}
|
||||
|
||||
@Test
|
||||
void testSaveRestaurant() {
|
||||
Restaurant r = new Restaurant();
|
||||
r.setNom("SaveTest");
|
||||
when(restaurantRepository.save(r)).thenReturn(r);
|
||||
|
||||
Restaurant result = restaurantService.saveRestaurant(r);
|
||||
|
||||
assertEquals("SaveTest", result.getNom());
|
||||
verify(restaurantRepository).save(r);
|
||||
}
|
||||
|
||||
@Test
|
||||
void testUpdateRestaurant_Found() {
|
||||
Restaurant existing = new Restaurant();
|
||||
existing.setNom("Old");
|
||||
Restaurant details = new Restaurant();
|
||||
details.setNom("New");
|
||||
details.setAdresse("Adresse");
|
||||
details.setTelephone("123");
|
||||
details.setAccesPMR(true);
|
||||
details.setAEmporter(true);
|
||||
details.setSurPlace(false);
|
||||
details.setPrix(10);
|
||||
details.setLatitude("1.0");
|
||||
details.setLongitude("2.0");
|
||||
details.setWebsite("site");
|
||||
|
||||
when(restaurantRepository.findById(1)).thenReturn(Optional.of(existing));
|
||||
when(restaurantRepository.save(any(Restaurant.class))).thenAnswer(invocation -> invocation.getArgument(0));
|
||||
|
||||
Optional<Restaurant> result = restaurantService.updateRestaurant(1, details);
|
||||
|
||||
assertTrue(result.isPresent());
|
||||
Restaurant updatedRestaurant = result.get();
|
||||
assertEquals("New", updatedRestaurant.getNom());
|
||||
assertEquals("Adresse", updatedRestaurant.getAdresse());
|
||||
assertEquals("123", updatedRestaurant.getTelephone());
|
||||
assertTrue(updatedRestaurant.getAccesPMR());
|
||||
assertTrue(updatedRestaurant.getAEmporter());
|
||||
assertFalse(updatedRestaurant.getSurPlace());
|
||||
assertEquals(10, updatedRestaurant.getPrix());
|
||||
assertEquals("1.0", updatedRestaurant.getLatitude());
|
||||
assertEquals("2.0", updatedRestaurant.getLongitude());
|
||||
assertEquals("site", updatedRestaurant.getWebsite());
|
||||
verify(restaurantRepository).findById(1);
|
||||
verify(restaurantRepository).save(existing);
|
||||
}
|
||||
|
||||
@Test
|
||||
void testUpdateRestaurant_NotFound() {
|
||||
Restaurant details = new Restaurant();
|
||||
when(restaurantRepository.findById(99)).thenReturn(Optional.empty());
|
||||
|
||||
Optional<Restaurant> result = restaurantService.updateRestaurant(99, details);
|
||||
|
||||
assertFalse(result.isPresent());
|
||||
verify(restaurantRepository).findById(99);
|
||||
verify(restaurantRepository, never()).save(any());
|
||||
}
|
||||
|
||||
@Test
|
||||
void testDeleteRestaurant() {
|
||||
restaurantService.deleteRestaurant(5);
|
||||
verify(restaurantRepository).deleteById(5);
|
||||
}
|
||||
}
|
||||
Loading…
Add table
Add a link
Reference in a new issue