async Task IUserService.UpdateCurrentUserSettings(UpdateCurrentUserSettingsCommand command)
        {
            Check.NotNull(command, errorMessage: "Command can not be null.");
            await validationService.Validate(command);

            var user = await currentUserResolver.ResolveAsync();

            user.Name = command.Name;
            user.PreferredWorkingHourPerDay = command.PreferredWorkingHourPerDay;

            await userRepository.UpdateUser(user);
        }
Beispiel #2
0
        public async Task <IHttpActionResult> UpdatePreferrences(UpdateCurrentUserSettingsCommand command)
        {
            try
            {
                await userService.UpdateCurrentUserSettings(command);

                return(Ok());
            }
            catch (ValidationException ex)
            {
                return(BadRequest(ex.Message));
            }
        }
Beispiel #3
0
        public async Task UpdateUserSetting_InvalidInput_ThrowException(string name, int preferredWorkingHoursPerDay)
        {
            // Arrange
            var command = new UpdateCurrentUserSettingsCommand()
            {
                Name = name,
                PreferredWorkingHourPerDay = preferredWorkingHoursPerDay
            };
            var userService = InstantiateUserService();

            // Act
            // Assert
            await Assert.ThrowsAsync <ValidationException>(
                () => userService.UpdateCurrentUserSettings(command)
                );
        }
Beispiel #4
0
        public async Task UpdateUserSetting_SaveInPersistence()
        {
            // Arrange
            var command = new UpdateCurrentUserSettingsCommand()
            {
                Name = "Updated name",
                PreferredWorkingHourPerDay = 10
            };

            var currentUser = new User()
            {
                Id = Guid.NewGuid().ToString()
            };
            var currentUserResolverMock = new Mock <ICurrentUserResolver>();

            currentUserResolverMock.Setup(r => r.ResolveAsync())
            .ReturnsAsync(currentUser);

            var  userRepoMock = new Mock <IUserRepository>();
            User passedUser   = null;

            userRepoMock.Setup(r => r.UpdateUser(It.IsAny <User>()))
            .Callback <User>(u => passedUser = u)
            .Returns(Task.FromResult(0));

            var userService = InstantiateUserService(
                new Tuple <Type, object>(typeof(ICurrentUserResolver), currentUserResolverMock.Object),
                new Tuple <Type, object>(typeof(IUserRepository), userRepoMock.Object)
                );

            // Act
            await userService.UpdateCurrentUserSettings(command);

            // Assert
            userRepoMock.Verify(u => u.UpdateUser(passedUser));
            Assert.Equal(command.Name, passedUser.Name);
            Assert.Equal(command.PreferredWorkingHourPerDay, passedUser.PreferredWorkingHourPerDay);
        }