Merge remote-tracking branch 'origin/82-securitycameracontrollertests' into 82-securitycameracontrollertests

src/main/java/ch/usi/inf/sa4/sanmarinoes/smarthut/controller/ButtonDimmerController.java

@@ -21,8 +21,8 @@ import org.springframework.web.bind.annotation.*;
 public class ButtonDimmerController
         extends InputDeviceConnectionController<ButtonDimmer, Dimmable> {
 
-    private DeviceService deviceService;
+    private final DeviceService deviceService;
-    private ButtonDimmerRepository buttonDimmerRepository;
+    private final ButtonDimmerRepository buttonDimmerRepository;
 
     @Autowired
     protected ButtonDimmerController(

src/main/java/ch/usi/inf/sa4/sanmarinoes/smarthut/controller/UserAccountController.java

@@ -126,11 +126,8 @@ public class UserAccountController {
             throw new UserNotFoundException();
         }
 
-        ConfirmationToken token;
+        ConfirmationToken token = new ConfirmationToken(toReset);
-        do {
+        token.setResetPassword(true);
-            token = new ConfirmationToken(toReset);
-            token.setResetPassword(true);
-        } while (confirmationTokenRepository.findByConfirmToken(token.getConfirmToken()) != null);
 
         // Delete existing email password reset tokens
         confirmationTokenRepository.deleteByUserAndResetPassword(toReset, true);

src/main/java/ch/usi/inf/sa4/sanmarinoes/smarthut/dto/InitPasswordResetRequest.java

@@ -3,10 +3,14 @@ package ch.usi.inf.sa4.sanmarinoes.smarthut.dto;
 import javax.validation.constraints.Email;
 import javax.validation.constraints.NotEmpty;
 import javax.validation.constraints.Pattern;
+import lombok.AllArgsConstructor;
 import lombok.Data;
+import lombok.NoArgsConstructor;
 
 /** DTO for password reset request */
 @Data
+@AllArgsConstructor
+@NoArgsConstructor
 public class InitPasswordResetRequest {
     /**
      * The user's email (validated according to criteria used in <code>&gt;input type="email"&lt;>

src/main/java/ch/usi/inf/sa4/sanmarinoes/smarthut/dto/PasswordResetRequest.java

@@ -3,10 +3,14 @@ package ch.usi.inf.sa4.sanmarinoes.smarthut.dto;
 import javax.validation.constraints.NotEmpty;
 import javax.validation.constraints.NotNull;
 import javax.validation.constraints.Size;
+import lombok.AllArgsConstructor;
 import lombok.Data;
+import lombok.NoArgsConstructor;
 
 /** DTO for password reset request */
 @Data
+@NoArgsConstructor
+@AllArgsConstructor
 public class PasswordResetRequest {
 
     @NotNull private String confirmationToken;

src/main/java/ch/usi/inf/sa4/sanmarinoes/smarthut/service/ThermostatService.java

@@ -14,13 +14,25 @@ import org.springframework.stereotype.Component;
 @Component
 public class ThermostatService {
 
-    @Autowired private SensorSocketEndpoint endpoint;
+    private final SensorSocketEndpoint endpoint;
 
-    @Autowired private DeviceService deviceService;
+    private final DeviceService deviceService;
 
-    @Autowired private ThermostatPopulationService thermostatPopulationService;
+    private final ThermostatPopulationService thermostatPopulationService;
 
-    @Autowired private ThermostatRepository thermostatRepository;
+    private final ThermostatRepository thermostatRepository;
+
+    @Autowired
+    public ThermostatService(
+            SensorSocketEndpoint endpoint,
+            DeviceService deviceService,
+            ThermostatPopulationService thermostatPopulationService,
+            ThermostatRepository thermostatRepository) {
+        this.endpoint = endpoint;
+        this.deviceService = deviceService;
+        this.thermostatPopulationService = thermostatPopulationService;
+        this.thermostatRepository = thermostatRepository;
+    }
 
     private void randomJitter(Thermostat thermostat) {
         updateValueForThermostat(

src/test/java/ch/usi/inf/sa4/sanmarinoes/smarthut/controller/GuestControllerTests.java

@@ -0,0 +1,92 @@
+package ch.usi.inf.sa4.sanmarinoes.smarthut.controller;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.mockito.Mockito.when;
+
+import ch.usi.inf.sa4.sanmarinoes.smarthut.dto.UserResponse;
+import ch.usi.inf.sa4.sanmarinoes.smarthut.models.EagerUserRepository;
+import ch.usi.inf.sa4.sanmarinoes.smarthut.models.User;
+import java.security.Principal;
+import java.util.List;
+import java.util.stream.Collectors;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.junit.jupiter.MockitoExtension;
+import org.springframework.security.test.context.support.WithMockUser;
+
+@ExtendWith(MockitoExtension.class)
+@WithMockUser(username = "user")
+public class GuestControllerTests {
+    @InjectMocks private GuestController guestController;
+
+    @Mock private Principal mockPrincipal;
+    @Mock private EagerUserRepository userRepository;
+
+    private final User user;
+
+    public GuestControllerTests() {
+        user = new User();
+        user.setName("user");
+        user.setId(12L);
+    }
+
+    @DisplayName("Check that the list is empty when we have no hosts/guests")
+    @Test
+    public void findAllEmptyTest() {
+        List<UserResponse> l = guestController.findAll();
+        assertThat(l.isEmpty());
+    }
+
+    @DisplayName(
+            "Check that the list contains the elements added and that hosts and guests are returned properly")
+    @Test
+    public void findAllTest() {
+        User host1 = new User();
+        host1.setId(2L);
+        User host2 = new User();
+        host2.setId(3L);
+        User guest1 = new User();
+        guest1.setId(4L);
+        User guest2 = new User();
+        guest2.setId(5L);
+
+        user.addHost(host1);
+        user.addHost(host2);
+        user.addGuest(guest1);
+        user.addGuest(guest2);
+
+        when(mockPrincipal.getName()).thenReturn("user");
+        when(userRepository.findByUsername(mockPrincipal.getName())).thenReturn(this.user);
+        when(userRepository.findAll()).thenReturn(List.of(host1, host2, guest1, guest2));
+        assertThat(guestController.findAll())
+                .containsAll(
+                        List.of(host1, host2, guest1, guest2)
+                                .stream()
+                                .map(UserResponse::fromUser)
+                                .collect(Collectors.toList()));
+
+        assertThat(guestController.findHosts(mockPrincipal))
+                .containsExactly(UserResponse.fromUser(host1), UserResponse.fromUser(host2));
+        assertThat(guestController.findGuests(mockPrincipal))
+                .containsExactly(UserResponse.fromUser(guest1), UserResponse.fromUser(guest2));
+    }
+
+    @DisplayName("Check that the host list is empty")
+    @Test
+    public void findHostsEmptyTest() {
+        when(mockPrincipal.getName()).thenReturn("user");
+        when(userRepository.findByUsername("user")).thenReturn(user);
+        assertThat(guestController.findHosts(mockPrincipal).isEmpty());
+    }
+
+    @DisplayName("Check that the guest list is empty")
+    @Test
+    public void findGuestsEmptyTest() {
+        when(mockPrincipal.getName()).thenReturn("user");
+        when(userRepository.findByUsername("user")).thenReturn(user);
+        assertThat(guestController.findGuests(mockPrincipal).isEmpty());
+    }
+}

src/test/java/ch/usi/inf/sa4/sanmarinoes/smarthut/controller/SceneControllerTests.java

@@ -9,6 +9,7 @@ import static org.mockito.Mockito.when;
 import ch.usi.inf.sa4.sanmarinoes.smarthut.dto.SceneSaveRequest;
 import ch.usi.inf.sa4.sanmarinoes.smarthut.error.NotFoundException;
 import ch.usi.inf.sa4.sanmarinoes.smarthut.models.*;
+import ch.usi.inf.sa4.sanmarinoes.smarthut.service.SceneService;
 import java.security.Principal;
 import java.util.List;
 import java.util.Optional;
@@ -33,12 +34,72 @@ public class SceneControllerTests {
 
     @Mock private StateRepository<State> stateStateRepository;
 
+    @Mock private SceneService sceneService;
+
     private final User u;
 
+    private final User h;
+
     public SceneControllerTests() {
         u = new User();
         u.setName("user");
         u.setId(1L);
+
+        h = new User();
+        h.setId(2L);
+        h.setUsername("host");
+
+        u.getHosts().add(h);
+        h.getGuests().add(u);
+    }
+
+    @Test
+    public void testCopy() throws NotFoundException {
+        final Scene scene = new Scene();
+        final Scene copyFrom = new Scene();
+
+        when(mockPrincipal.getName()).thenReturn("user");
+        when(sceneRepository.findByIdAndUsername(1L, "user")).thenReturn(Optional.of(scene));
+        when(sceneRepository.findByIdAndUsername(2L, "user")).thenReturn(Optional.empty());
+
+        when(sceneRepository.findByIdAndUsername(10L, "user")).thenReturn(Optional.of(copyFrom));
+        when(sceneRepository.findByIdAndUsername(20L, "user")).thenReturn(Optional.empty());
+
+        assertThatThrownBy(() -> sceneController.copy(2L, 10L, mockPrincipal))
+                .isInstanceOf(NotFoundException.class);
+        assertThatThrownBy(() -> sceneController.copy(1L, 20L, mockPrincipal))
+                .isInstanceOf(NotFoundException.class);
+
+        when(sceneService.copyStates(scene, copyFrom)).thenReturn(List.of());
+
+        assertThat(sceneController.copy(1L, 10L, mockPrincipal)).isEmpty();
+    }
+
+    @Test
+    public void testApply() throws NotFoundException {
+        final Scene s = new Scene();
+        when(mockPrincipal.getName()).thenReturn("user");
+        when(sceneRepository.findByIdAndUsername(1L, "user")).thenReturn(Optional.of(s));
+        when(sceneRepository.findByIdAndUsername(2L, "user")).thenReturn(Optional.empty());
+        when(sceneService.apply(s, "user", false)).thenReturn(List.of());
+
+        assertThatThrownBy(() -> sceneController.apply(2L, mockPrincipal, null))
+                .isInstanceOf(NotFoundException.class);
+        assertThat(sceneController.apply(1L, mockPrincipal, null)).isEmpty();
+
+        when(userRepository.findByUsername("user")).thenReturn(u);
+        when(userRepository.findById(2L)).thenReturn(Optional.of(h));
+
+        when(sceneRepository.findByIdAndUserIdAndGuestAccessEnabled(1L, 2L, true))
+                .thenReturn(Optional.of(s));
+        when(sceneRepository.findByIdAndUserIdAndGuestAccessEnabled(2L, 2L, true))
+                .thenReturn(Optional.empty());
+
+        when(sceneService.applyAsGuest(s, "user", 2L)).thenReturn(List.of());
+
+        assertThatThrownBy(() -> sceneController.apply(2L, mockPrincipal, 2L))
+                .isInstanceOf(NotFoundException.class);
+        assertThat(sceneController.apply(1L, mockPrincipal, 2L)).isEmpty();
     }
 
     @Test
@@ -46,10 +107,14 @@ public class SceneControllerTests {
         when(mockPrincipal.getName()).thenReturn("user");
         when(sceneRepository.findByUsername("user")).thenReturn(List.of());
         assertThat(sceneController.findAll(mockPrincipal, null)).isEmpty();
+
+        when(userRepository.findByUsername("user")).thenReturn(u);
+        when(userRepository.findById(2L)).thenReturn(Optional.of(h));
+        assertThat(sceneController.findAll(mockPrincipal, 2L)).isEmpty();
     }
 
     private void equalToRequest(Scene created, SceneSaveRequest a) {
-        assertThat(created.getName()).isEqualTo(a.getName());
+        if (a.getName() != null) assertThat(created.getName()).isEqualTo(a.getName());
         assertThat(created.getUserId()).isEqualTo(1L);
         assertThat(created.getIcon()).isEqualTo(a.getIcon());
         assertThat(created.isGuestAccessEnabled()).isEqualTo(a.isGuestAccessEnabled());
@@ -85,6 +150,11 @@ public class SceneControllerTests {
         assertThat(created.getId()).isEqualTo(42L);
         equalToRequest(created, a);
 
+        a.setName(null);
+        created = sceneController.update(a.getId(), a, mockPrincipal);
+        assertThat(created.getId()).isEqualTo(42L);
+        equalToRequest(created, a);
+
         a.setId(43L);
         assertThatThrownBy(() -> sceneController.update(a.getId(), a, mockPrincipal))
                 .isInstanceOf(NotFoundException.class);
@@ -96,4 +166,10 @@ public class SceneControllerTests {
         doNothing().when(sceneRepository).deleteById(42L);
         Assertions.assertDoesNotThrow(() -> sceneController.deleteById(42L));
     }
+
+    @Test
+    public void testGetStates() {
+        when(stateStateRepository.findBySceneId(1L)).thenReturn(List.of());
+        assertThat(sceneController.getStates(1L)).isEmpty();
+    }
 }

src/test/java/ch/usi/inf/sa4/sanmarinoes/smarthut/controller/UserAccountControllerTests.java

@@ -1,17 +1,33 @@
 package ch.usi.inf.sa4.sanmarinoes.smarthut.controller;
 
-import static org.mockito.Mockito.when;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.*;
 
+import ch.usi.inf.sa4.sanmarinoes.smarthut.config.EmailConfigurationService;
+import ch.usi.inf.sa4.sanmarinoes.smarthut.dto.InitPasswordResetRequest;
+import ch.usi.inf.sa4.sanmarinoes.smarthut.dto.PasswordResetRequest;
 import ch.usi.inf.sa4.sanmarinoes.smarthut.dto.UserRegistrationRequest;
 import ch.usi.inf.sa4.sanmarinoes.smarthut.error.DuplicateRegistrationException;
+import ch.usi.inf.sa4.sanmarinoes.smarthut.error.EmailTokenNotFoundException;
+import ch.usi.inf.sa4.sanmarinoes.smarthut.error.UserNotFoundException;
+import ch.usi.inf.sa4.sanmarinoes.smarthut.models.ConfirmationToken;
+import ch.usi.inf.sa4.sanmarinoes.smarthut.models.ConfirmationTokenRepository;
 import ch.usi.inf.sa4.sanmarinoes.smarthut.models.User;
 import ch.usi.inf.sa4.sanmarinoes.smarthut.models.UserRepository;
+import ch.usi.inf.sa4.sanmarinoes.smarthut.service.EmailSenderService;
+import java.io.IOException;
+import javax.servlet.http.HttpServletResponse;
 import org.assertj.core.api.Assertions;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.extension.ExtendWith;
 import org.mockito.InjectMocks;
 import org.mockito.Mock;
 import org.mockito.junit.jupiter.MockitoExtension;
+import org.springframework.mail.SimpleMailMessage;
+import org.springframework.mock.web.MockHttpServletResponse;
+import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
 import org.springframework.security.test.context.support.WithMockUser;
 
 @ExtendWith(MockitoExtension.class)
@@ -22,6 +38,14 @@ public class UserAccountControllerTests {
 
     @Mock private UserRepository userRepository;
 
+    @Mock private EmailSenderService emailSenderService;
+
+    @Mock private EmailConfigurationService emailConfigurationService;
+
+    @Mock private ConfirmationTokenRepository confirmationTokenRepository;
+
+    @Mock private BCryptPasswordEncoder passwordEncoder;
+
     @Test
     public void testRegisterUser() {
         final UserRegistrationRequest registrationRequest = new UserRegistrationRequest();
@@ -42,4 +66,98 @@ public class UserAccountControllerTests {
         Assertions.assertThatThrownBy(() -> userAccountController.registerUser(registrationRequest))
                 .isInstanceOf(DuplicateRegistrationException.class);
     }
+
+    @Test
+    public void testResetPassword() throws EmailTokenNotFoundException {
+        final User u = new User();
+        final ConfirmationToken c = new ConfirmationToken(u);
+        c.setResetPassword(false);
+
+        when(userRepository.save(u)).thenReturn(u);
+
+        when(confirmationTokenRepository.findByConfirmToken("token")).thenReturn(c);
+        when(confirmationTokenRepository.findByConfirmToken("token2")).thenReturn(null);
+        doNothing().when(confirmationTokenRepository).delete(c);
+        when(passwordEncoder.encode("password")).thenReturn("encoded");
+
+        assertThatThrownBy(
+                        () ->
+                                userAccountController.resetPassword(
+                                        new PasswordResetRequest("token2", "password")))
+                .isInstanceOf(EmailTokenNotFoundException.class);
+
+        assertThatThrownBy(
+                        () ->
+                                userAccountController.resetPassword(
+                                        new PasswordResetRequest("token", "password")))
+                .isInstanceOf(EmailTokenNotFoundException.class);
+
+        c.setResetPassword(true);
+
+        userAccountController.resetPassword(new PasswordResetRequest("token", "password"));
+
+        assertThat(u.getPassword()).isEqualTo("encoded");
+    }
+
+    @Test
+    public void testInitResetPassword() throws UserNotFoundException {
+        when(emailConfigurationService.getResetPasswordSubject()).thenReturn("password reset");
+        when(emailConfigurationService.getResetPassword()).thenReturn("reset-password");
+        when(emailConfigurationService.getResetPasswordPath()).thenReturn("path");
+
+        final User u = new User();
+        u.setEmail("info@theshell.com");
+
+        boolean[] done = new boolean[1];
+
+        doAnswer(
+                        i -> {
+                            final SimpleMailMessage m = i.getArgument(0);
+                            assertThat(m.getSubject()).isEqualTo("password reset");
+                            assertThat(m.getText()).startsWith("reset-password path");
+                            done[0] = true;
+                            return null;
+                        })
+                .when(emailSenderService)
+                .sendEmail(any());
+
+        doNothing().when(confirmationTokenRepository).deleteByUserAndResetPassword(u, true);
+        when(confirmationTokenRepository.save(any())).thenAnswer(i -> i.getArgument(0));
+
+        when(userRepository.findByEmailIgnoreCase("info@theshell.ch")).thenReturn(u);
+        when(userRepository.findByEmailIgnoreCase("info@vimtok.com")).thenReturn(null);
+
+        assertThatThrownBy(
+                        () ->
+                                userAccountController.initResetPassword(
+                                        new InitPasswordResetRequest("info@vimtok.com")))
+                .isInstanceOf(UserNotFoundException.class);
+        userAccountController.initResetPassword(new InitPasswordResetRequest("info@theshell.ch"));
+
+        assertThat(done[0]).isTrue();
+    }
+
+    @Test
+    public void testConfirmUserAccount() throws EmailTokenNotFoundException, IOException {
+        final User u = new User();
+        final ConfirmationToken c = new ConfirmationToken(u);
+        c.setResetPassword(true);
+
+        when(confirmationTokenRepository.findByConfirmToken("token")).thenReturn(null);
+        when(confirmationTokenRepository.findByConfirmToken(c.getConfirmToken())).thenReturn(c);
+        when(userRepository.save(u)).thenReturn(u);
+        final HttpServletResponse r = new MockHttpServletResponse();
+
+        assertThatThrownBy(() -> userAccountController.confirmUserAccount("token", r))
+                .isInstanceOf(EmailTokenNotFoundException.class);
+        assertThatThrownBy(() -> userAccountController.confirmUserAccount(c.getConfirmToken(), r))
+                .isInstanceOf(EmailTokenNotFoundException.class);
+
+        c.setResetPassword(false);
+
+        when(emailConfigurationService.getRegistrationRedirect()).thenReturn("malusa.html");
+
+        userAccountController.confirmUserAccount(c.getConfirmToken(), r);
+        assertThat(u.isEnabled()).isTrue();
+    }
 }

src/test/java/ch/usi/inf/sa4/sanmarinoes/smarthut/service/ThermostatServiceTests.java

@@ -0,0 +1,66 @@
+package ch.usi.inf.sa4.sanmarinoes.smarthut.service;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.*;
+
+import ch.usi.inf.sa4.sanmarinoes.smarthut.models.Thermostat;
+import ch.usi.inf.sa4.sanmarinoes.smarthut.models.ThermostatRepository;
+import ch.usi.inf.sa4.sanmarinoes.smarthut.models.User;
+import ch.usi.inf.sa4.sanmarinoes.smarthut.socket.SensorSocketEndpoint;
+import java.math.BigDecimal;
+import java.util.List;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.junit.jupiter.MockitoExtension;
+
+@ExtendWith(MockitoExtension.class)
+public class ThermostatServiceTests {
+
+    @InjectMocks private ThermostatService thermostatService;
+
+    @Mock private ThermostatRepository thermostatRepository;
+
+    @Mock private DeviceService deviceService;
+
+    @Mock private ThermostatPopulationService thermostatPopulationService;
+
+    @Mock private SensorSocketEndpoint endpoint;
+
+    @Test
+    public void testFakeUpdateAll() {
+        when(deviceService.saveAsOwner(any(), any())).thenAnswer(i -> i.getArgument(0));
+        when(thermostatRepository.findUser(1L)).thenReturn(new User());
+
+        Thermostat t = new Thermostat();
+        t.setOn(true);
+        t.setId(1L);
+        t.setTargetTemperature(BigDecimal.valueOf(17.0));
+
+        when(thermostatRepository.findAll()).thenReturn(List.of(t));
+        doAnswer(
+                        i -> {
+                            ((Thermostat) i.getArgument(0))
+                                    .setMeasuredTemperature(BigDecimal.valueOf(18.0));
+                            return null;
+                        })
+                .when(thermostatPopulationService)
+                .populateMeasuredTemperature(t);
+
+        doNothing().when(endpoint).queueDeviceUpdate(any(), any(), eq(false), eq(null), eq(false));
+
+        Assertions.assertDoesNotThrow(() -> thermostatService.fakeUpdateAll());
+        assertThat(t.getMode()).isNotEqualTo(Thermostat.Mode.OFF);
+    }
+
+    @Test
+    public void testFindAll() {
+        final Thermostat t = new Thermostat();
+        doNothing().when(thermostatPopulationService).populateMeasuredTemperature(t);
+        when(thermostatRepository.findAllByUsername("user")).thenReturn(List.of(t));
+        assertThat(thermostatService.findAll("user")).containsExactly(t);
+    }
+}