...

2 files changed, 207 insertions, 113 deletions

diff --git a/Timeline.Tests/Controllers/UserControllerTest.cs b/Timeline.Tests/Controllers/UserControllerTest.cs
index 9fec477f..ddbc3fbc 100644
--- a/Timeline.Tests/Controllers/UserControllerTest.cs
+++ b/Timeline.Tests/Controllers/UserControllerTest.cs
@@ -1,9 +1,11 @@
 using FluentAssertions;

+using Microsoft.AspNetCore.Http;

 using Microsoft.AspNetCore.Mvc;

 using Microsoft.Extensions.Logging.Abstractions;

 using Moq;

 using System;

 using System.Linq;

+using System.Security.Claims;

 using System.Threading.Tasks;

 using Timeline.Controllers;

 using Timeline.Models;

@@ -104,6 +106,134 @@ namespace Timeline.Tests.Controllers
                 .Which.Code.Should().Be(Put.BadUsername);

         }

 

-        //TODO! Complete this.

+        [Fact]

+        public async Task Patch_Success()

+        {

+            const string username = "aaa";

+            const string password = "ppp";

+            const bool administrator = true;

+            _mockUserService.Setup(s => s.PatchUser(username, password, administrator)).Returns(Task.CompletedTask);

+            var action = await _controller.Patch(new UserPatchRequest

+            {

+                Password = password,

+                Administrator = administrator

+            }, username);

+            action.Should().BeAssignableTo<OkResult>();

+        }

+

+        [Fact]

+        public async Task Patch_NotExist()

+        {

+            const string username = "aaa";

+            const string password = "ppp";

+            const bool administrator = true;

+            _mockUserService.Setup(s => s.PatchUser(username, password, administrator)).ThrowsAsync(new UserNotExistException());

+            var action = await _controller.Patch(new UserPatchRequest

+            {

+                Password = password,

+                Administrator = administrator

+            }, username);

+            action.Should().BeAssignableTo<NotFoundObjectResult>()

+                .Which.Value.Should().BeAssignableTo<CommonResponse>()

+                .Which.Code.Should().Be(Patch.NotExist);

+        }

+

+        [Fact]

+        public async Task Delete_Delete()

+        {

+            const string username = "aaa";

+            _mockUserService.Setup(s => s.DeleteUser(username)).Returns(Task.CompletedTask);

+            var action = await _controller.Delete(username);

+            var body = action.Result.Should().BeAssignableTo<OkObjectResult>()

+                .Which.Value.Should().BeAssignableTo<CommonDeleteResponse>()

+                .Which;

+            body.Code.Should().Be(0);

+            body.Data.Delete.Should().BeTrue();

+        }

+

+        [Fact]

+        public async Task Delete_NotExist()

+        {

+            const string username = "aaa";

+            _mockUserService.Setup(s => s.DeleteUser(username)).ThrowsAsync(new UserNotExistException());

+            var action = await _controller.Delete(username);

+            var body = action.Result.Should().BeAssignableTo<OkObjectResult>()

+                .Which.Value.Should().BeAssignableTo<CommonDeleteResponse>()

+                .Which;

+            body.Code.Should().Be(0);

+            body.Data.Delete.Should().BeFalse();

+        }

+

+        [Fact]

+        public async Task Op_ChangeUsername_Success()

+        {

+            const string oldUsername = "aaa";

+            const string newUsername = "bbb";

+            _mockUserService.Setup(s => s.ChangeUsername(oldUsername, newUsername)).Returns(Task.CompletedTask);

+            var action = await _controller.ChangeUsername(new ChangeUsernameRequest { OldUsername = oldUsername, NewUsername = newUsername });

+            action.Should().BeAssignableTo<OkResult>();

+        }

+

+        [Theory]

+        [InlineData(typeof(UserNotExistException), Op.ChangeUsername.NotExist)]

+        [InlineData(typeof(UserAlreadyExistException), Op.ChangeUsername.AlreadyExist)]

+        public async Task Op_ChangeUsername_Failure(Type exceptionType, int code)

+        {

+            const string oldUsername = "aaa";

+            const string newUsername = "bbb";

+            _mockUserService.Setup(s => s.ChangeUsername(oldUsername, newUsername)).ThrowsAsync(Activator.CreateInstance(exceptionType) as Exception);

+            var action = await _controller.ChangeUsername(new ChangeUsernameRequest { OldUsername = oldUsername, NewUsername = newUsername });

+            action.Should().BeAssignableTo<BadRequestObjectResult>()

+                .Which.Value.Should().BeAssignableTo<CommonResponse>()

+                .Which.Code.Should().Be(code);

+        }

+

+        [Fact]

+        public async Task Op_ChangePassword_Success()

+        {

+            const string username = "aaa";

+            const string oldPassword = "aaa";

+            const string newPassword = "bbb";

+            _mockUserService.Setup(s => s.ChangePassword(username, oldPassword, newPassword)).Returns(Task.CompletedTask);

+

+            _controller.ControllerContext = new ControllerContext()

+            {

+                HttpContext = new DefaultHttpContext()

+                {

+                    User = new ClaimsPrincipal(new ClaimsIdentity(new Claim[]

+                    {

+                        new Claim(ClaimTypes.Name, username)

+                    }, "TestAuthType"))

+                }

+            };

+

+            var action = await _controller.ChangePassword(new ChangePasswordRequest { OldPassword = oldPassword, NewPassword = newPassword });

+            action.Should().BeAssignableTo<OkResult>();

+        }

+

+        [Fact]

+        public async Task Op_ChangePassword_BadPassword()

+        {

+            const string username = "aaa";

+            const string oldPassword = "aaa";

+            const string newPassword = "bbb";

+            _mockUserService.Setup(s => s.ChangePassword(username, oldPassword, newPassword)).ThrowsAsync(new BadPasswordException());

+

+            _controller.ControllerContext = new ControllerContext()

+            {

+                HttpContext = new DefaultHttpContext()

+                {

+                    User = new ClaimsPrincipal(new ClaimsIdentity(new Claim[]

+                    {

+                        new Claim(ClaimTypes.Name, username)

+                    }, "TestAuthType"))

+                }

+            };

+

+            var action = await _controller.ChangePassword(new ChangePasswordRequest { OldPassword = oldPassword, NewPassword = newPassword });

+            action.Should().BeAssignableTo<BadRequestObjectResult>()

+                .Which.Value.Should().BeAssignableTo<CommonResponse>()

+                .Which.Code.Should().Be(Op.ChangePassword.BadOldPassword);

+        }

     }

 }

diff --git a/Timeline.Tests/IntegratedTests/UserUnitTest.cs b/Timeline.Tests/IntegratedTests/UserUnitTest.cs
index 47a8699c..b00648de 100644
--- a/Timeline.Tests/IntegratedTests/UserUnitTest.cs
+++ b/Timeline.Tests/IntegratedTests/UserUnitTest.cs
@@ -170,131 +170,95 @@ namespace Timeline.Tests.IntegratedTests
             res.Should().BeDelete(false);

         }

 

+        private const string changeUsernameUrl = "userop/changeusername";

 

-        public class ChangeUsernameUnitTest : IClassFixture<WebApplicationFactory<Startup>>, IDisposable

+        public static IEnumerable<object[]> Op_ChangeUsername_InvalidModel_Data()

         {

-            private const string url = "userop/changeusername";

-

-            private readonly TestApplication _testApp;

-            private readonly WebApplicationFactory<Startup> _factory;

-

-            public ChangeUsernameUnitTest(WebApplicationFactory<Startup> factory)

-            {

-                _testApp = new TestApplication(factory);

-                _factory = _testApp.Factory;

-            }

-

-            public void Dispose()

-            {

-                _testApp.Dispose();

-            }

-

-            public static IEnumerable<object[]> InvalidModel_Data()

-            {

-                yield return new[] { null, "uuu" };

-                yield return new[] { "uuu", null };

-                yield return new[] { "uuu", "???" };

-            }

-

-            [Theory]

-            [MemberData(nameof(InvalidModel_Data))]

-            public async Task InvalidModel(string oldUsername, string newUsername)

-            {

-                using var client = await _factory.CreateClientAsAdmin();

-                (await client.PostAsJsonAsync(url,

-                    new ChangeUsernameRequest { OldUsername = oldUsername, NewUsername = newUsername }))

-                    .Should().BeInvalidModel();

-            }

-

-            [Fact]

-            public async Task UserNotExist()

-            {

-                using var client = await _factory.CreateClientAsAdmin();

-                var res = await client.PostAsJsonAsync(url,

-                    new ChangeUsernameRequest { OldUsername = "usernotexist", NewUsername = "newUsername" });

-                res.Should().HaveStatusCode(400)

-                    .And.Should().HaveCommonBody()

-                    .Which.Code.Should().Be(Op.ChangeUsername.NotExist);

-            }

-

-            [Fact]

-            public async Task UserAlreadyExist()

-            {

-                using var client = await _factory.CreateClientAsAdmin();

-                var res = await client.PostAsJsonAsync(url,

-                    new ChangeUsernameRequest { OldUsername = MockUser.User.Username, NewUsername = MockUser.Admin.Username });

-                res.Should().HaveStatusCode(400)

-                    .And.Should().HaveCommonBody()

-                    .Which.Code.Should().Be(Op.ChangeUsername.AlreadyExist);

-            }

-

-            [Fact]

-            public async Task Success()

-            {

-                using var client = await _factory.CreateClientAsAdmin();

-                const string newUsername = "hahaha";

-                var res = await client.PostAsJsonAsync(url,

-                    new ChangeUsernameRequest { OldUsername = MockUser.User.Username, NewUsername = newUsername });

-                res.Should().HaveStatusCode(200);

-                await client.CreateUserTokenAsync(newUsername, MockUser.User.Password);

-            }

+            yield return new[] { null, "uuu" };

+            yield return new[] { "uuu", null };

+            yield return new[] { "uuu", "???" };

         }

 

+        [Theory]

+        [MemberData(nameof(Op_ChangeUsername_InvalidModel_Data))]

+        public async Task Op_ChangeUsername_InvalidModel(string oldUsername, string newUsername)

+        {

+            using var client = await _factory.CreateClientAsAdmin();

+            (await client.PostAsJsonAsync(changeUsernameUrl,

+                new ChangeUsernameRequest { OldUsername = oldUsername, NewUsername = newUsername }))

+                .Should().BeInvalidModel();

+        }

 

-        public class ChangePasswordUnitTest : IClassFixture<WebApplicationFactory<Startup>>, IDisposable

+        [Fact]

+        public async Task Op_ChangeUsername_UserNotExist()

         {

-            private const string url = "userop/changepassword";

+            using var client = await _factory.CreateClientAsAdmin();

+            var res = await client.PostAsJsonAsync(changeUsernameUrl,

+                new ChangeUsernameRequest { OldUsername = "usernotexist", NewUsername = "newUsername" });

+            res.Should().HaveStatusCode(400)

+                .And.Should().HaveCommonBody()

+                .Which.Code.Should().Be(Op.ChangeUsername.NotExist);

+        }

 

-            private readonly TestApplication _testApp;

-            private readonly WebApplicationFactory<Startup> _factory;

+        [Fact]

+        public async Task Op_ChangeUsername_UserAlreadyExist()

+        {

+            using var client = await _factory.CreateClientAsAdmin();

+            var res = await client.PostAsJsonAsync(changeUsernameUrl,

+                new ChangeUsernameRequest { OldUsername = MockUser.User.Username, NewUsername = MockUser.Admin.Username });

+            res.Should().HaveStatusCode(400)

+                .And.Should().HaveCommonBody()

+                .Which.Code.Should().Be(Op.ChangeUsername.AlreadyExist);

+        }

 

-            public ChangePasswordUnitTest(WebApplicationFactory<Startup> factory)

-            {

-                _testApp = new TestApplication(factory);

-                _factory = _testApp.Factory;

-            }

+        [Fact]

+        public async Task Op_ChangeUsername_Success()

+        {

+            using var client = await _factory.CreateClientAsAdmin();

+            const string newUsername = "hahaha";

+            var res = await client.PostAsJsonAsync(changeUsernameUrl,

+                new ChangeUsernameRequest { OldUsername = MockUser.User.Username, NewUsername = newUsername });

+            res.Should().HaveStatusCode(200);

+            await client.CreateUserTokenAsync(newUsername, MockUser.User.Password);

+        }

 

-            public void Dispose()

-            {

-                _testApp.Dispose();

-            }

+        private const string changePasswordUrl = "userop/changepassword";

 

-            public static IEnumerable<object[]> InvalidModel_Data()

-            {

-                yield return new[] { null, "ppp" };

-                yield return new[] { "ppp", null };

-            }

+        public static IEnumerable<object[]> Op_ChangePassword_InvalidModel_Data()

+        {

+            yield return new[] { null, "ppp" };

+            yield return new[] { "ppp", null };

+        }

 

-            [Theory]

-            [MemberData(nameof(InvalidModel_Data))]

-            public async Task InvalidModel(string oldPassword, string newPassword)

-            {

-                using var client = await _factory.CreateClientAsUser();

-                (await client.PostAsJsonAsync(url,

-                    new ChangePasswordRequest { OldPassword = oldPassword, NewPassword = newPassword }))

-                    .Should().BeInvalidModel();

-            }

+        [Theory]

+        [MemberData(nameof(Op_ChangePassword_InvalidModel_Data))]

+        public async Task Op_ChangePassword_InvalidModel(string oldPassword, string newPassword)

+        {

+            using var client = await _factory.CreateClientAsUser();

+            (await client.PostAsJsonAsync(changePasswordUrl,

+                new ChangePasswordRequest { OldPassword = oldPassword, NewPassword = newPassword }))

+                .Should().BeInvalidModel();

+        }

 

-            [Fact]

-            public async Task BadOldPassword()

-            {

-                using var client = await _factory.CreateClientAsUser();

-                var res = await client.PostAsJsonAsync(url, new ChangePasswordRequest { OldPassword = "???", NewPassword = "???" });

-                res.Should().HaveStatusCode(400)

-                    .And.Should().HaveCommonBody()

-                    .Which.Code.Should().Be(Op.ChangePassword.BadOldPassword);

-            }

+        [Fact]

+        public async Task Op_ChangePassword_BadOldPassword()

+        {

+            using var client = await _factory.CreateClientAsUser();

+            var res = await client.PostAsJsonAsync(changePasswordUrl, new ChangePasswordRequest { OldPassword = "???", NewPassword = "???" });

+            res.Should().HaveStatusCode(400)

+                .And.Should().HaveCommonBody()

+                .Which.Code.Should().Be(Op.ChangePassword.BadOldPassword);

+        }

 

-            [Fact]

-            public async Task Success()

-            {

-                using var client = await _factory.CreateClientAsUser();

-                const string newPassword = "new";

-                var res = await client.PostAsJsonAsync(url,

-                    new ChangePasswordRequest { OldPassword = MockUser.User.Password, NewPassword = newPassword });

-                res.Should().HaveStatusCode(200);

-                await client.CreateUserTokenAsync(MockUser.User.Username, newPassword);

-            }

+        [Fact]

+        public async Task Op_ChangePassword_Success()

+        {

+            using var client = await _factory.CreateClientAsUser();

+            const string newPassword = "new";

+            var res = await client.PostAsJsonAsync(changePasswordUrl,

+                new ChangePasswordRequest { OldPassword = MockUser.User.Password, NewPassword = newPassword });

+            res.Should().HaveStatusCode(200);

+            await client.CreateUserTokenAsync(MockUser.User.Username, newPassword);

         }

     }

 }