diff options
Diffstat (limited to 'Timeline.Tests')
| -rw-r--r-- | Timeline.Tests/DatabaseTest.cs | 17 | ||||
| -rw-r--r-- | Timeline.Tests/IntegratedTests/UserDetailTest.cs | 146 | ||||
| -rw-r--r-- | Timeline.Tests/UserDetailServiceTest.cs | 275 | ||||
| -rw-r--r-- | Timeline.Tests/UserDetailValidatorTest.cs | 97 | ||||
| -rw-r--r-- | Timeline.Tests/UsernameValidatorUnitTest.cs | 1 |
5 files changed, 534 insertions, 2 deletions
diff --git a/Timeline.Tests/DatabaseTest.cs b/Timeline.Tests/DatabaseTest.cs index e280637c..f75ab71b 100644 --- a/Timeline.Tests/DatabaseTest.cs +++ b/Timeline.Tests/DatabaseTest.cs @@ -1,5 +1,4 @@ using FluentAssertions;
-using Microsoft.EntityFrameworkCore;
using System;
using System.Linq;
using Timeline.Entities;
@@ -33,5 +32,21 @@ namespace Timeline.Tests _context.SaveChanges();
_context.UserAvatars.Count().Should().Be(1);
}
+
+ [Fact]
+ public void DeleteUserShouldAlsoDeleteDetail()
+ {
+ var user = _context.Users.First();
+ _context.UserDetails.Add(new UserDetailEntity
+ {
+ UserId = user.Id
+ });
+ _context.SaveChanges();
+ _context.UserDetails.Count().Should().Be(1);
+
+ _context.Users.Remove(user);
+ _context.SaveChanges();
+ _context.UserDetails.Count().Should().Be(0);
+ }
}
}
diff --git a/Timeline.Tests/IntegratedTests/UserDetailTest.cs b/Timeline.Tests/IntegratedTests/UserDetailTest.cs new file mode 100644 index 00000000..4923cd06 --- /dev/null +++ b/Timeline.Tests/IntegratedTests/UserDetailTest.cs @@ -0,0 +1,146 @@ +using FluentAssertions;
+using Microsoft.AspNetCore.Mvc.Testing;
+using System;
+using System.Net;
+using System.Threading.Tasks;
+using Timeline.Controllers;
+using Timeline.Models;
+using Timeline.Models.Http;
+using Timeline.Tests.Helpers;
+using Timeline.Tests.Helpers.Authentication;
+using Timeline.Tests.Mock.Data;
+using Xunit;
+using Xunit.Abstractions;
+
+namespace Timeline.Tests.IntegratedTests
+{
+ public class UserDetailTest : IClassFixture<MyWebApplicationFactory<Startup>>, IDisposable
+ {
+ private readonly WebApplicationFactory<Startup> _factory;
+ private readonly Action _disposeAction;
+
+ public UserDetailTest(MyWebApplicationFactory<Startup> factory, ITestOutputHelper outputHelper)
+ {
+ _factory = factory.WithTestConfig(outputHelper, out _disposeAction);
+ }
+
+ public void Dispose()
+ {
+ _disposeAction();
+ }
+
+ [Fact]
+ public async Task TestAsUser()
+ {
+ using (var client = await _factory.CreateClientAsUser())
+ {
+ {
+ var res = await client.GetAsync($"users/usernotexist/nickname");
+ res.Should().HaveStatusCodeNotFound()
+ .And.Should().HaveBodyAsCommonResponseWithCode(UserDetailController.ErrorCodes.GetNickname_UserNotExist);
+ }
+
+ {
+ var res = await client.GetAsync($"users/usernotexist/details");
+ res.Should().HaveStatusCodeNotFound()
+ .And.Should().HaveBodyAsCommonResponseWithCode(UserDetailController.ErrorCodes.Get_UserNotExist);
+ }
+
+ async Task GetAndTest(UserDetail d)
+ {
+ var res = await client.GetAsync($"users/{MockUsers.UserUsername}/details");
+ res.Should().HaveStatusCodeOk()
+ .And.Should().HaveBodyAsJson<UserDetail>()
+ .Which.Should().BeEquivalentTo(d);
+ }
+
+ await GetAndTest(new UserDetail());
+
+ {
+ var res = await client.PatchAsJsonAsync($"users/{MockUsers.AdminUsername}/details", new UserDetail());
+ res.Should().HaveStatusCode(HttpStatusCode.Forbidden)
+ .And.Should().HaveBodyAsCommonResponseWithCode(UserDetailController.ErrorCodes.Patch_Forbid);
+ }
+
+ {
+ var res = await client.PatchAsJsonAsync($"users/{MockUsers.UserUsername}/details", new UserDetail
+ {
+ Nickname = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
+ QQ = "aaaaaaa",
+ EMail = "aaaaaa",
+ PhoneNumber = "aaaaaaaa"
+ });
+ var body = res.Should().HaveStatusCode(HttpStatusCode.BadRequest)
+ .And.Should().HaveBodyAsCommonResponse().Which;
+ body.Code.Should().Be(CommonResponse.ErrorCodes.InvalidModel);
+ foreach (var key in new string[] { "nickname", "qq", "email", "phonenumber" })
+ {
+ body.Message.Should().ContainEquivalentOf(key);
+ }
+ }
+
+
+ var detail = new UserDetail
+ {
+ Nickname = "aaa",
+ QQ = "1234567",
+ EMail = "aaaa@aaa.net",
+ Description = "aaaaaaaaa"
+ };
+
+ {
+ var res = await client.PatchAsJsonAsync($"users/{MockUsers.UserUsername}/details", detail);
+ res.Should().HaveStatusCodeOk();
+ await GetAndTest(detail);
+ }
+
+ {
+ var res = await client.GetAsync($"users/{MockUsers.UserUsername}/nickname");
+ res.Should().HaveStatusCodeOk().And.Should().HaveBodyAsJson<UserDetail>()
+ .Which.Should().BeEquivalentTo(new UserDetail
+ {
+ Nickname = detail.Nickname
+ });
+ }
+
+ var detail2 = new UserDetail
+ {
+ QQ = "",
+ PhoneNumber = "12345678910",
+ Description = "bbbbbbbb"
+ };
+
+ {
+ var res = await client.PatchAsJsonAsync($"users/{MockUsers.UserUsername}/details", detail2);
+ res.Should().HaveStatusCodeOk();
+ await GetAndTest(new UserDetail
+ {
+ Nickname = detail.Nickname,
+ QQ = null,
+ EMail = detail.EMail,
+ PhoneNumber = detail2.PhoneNumber,
+ Description = detail2.Description
+ });
+ }
+ }
+ }
+
+ [Fact]
+ public async Task TestAsAdmin()
+ {
+ using (var client = await _factory.CreateClientAsAdmin())
+ {
+ {
+ var res = await client.PatchAsJsonAsync($"users/{MockUsers.UserUsername}/details", new UserDetail());
+ res.Should().HaveStatusCodeOk();
+ }
+
+ {
+ var res = await client.PatchAsJsonAsync($"users/usernotexist/details", new UserDetail());
+ res.Should().HaveStatusCodeNotFound()
+ .And.Should().HaveBodyAsCommonResponseWithCode(UserDetailController.ErrorCodes.Patch_UserNotExist);
+ }
+ }
+ }
+ }
+}
\ No newline at end of file diff --git a/Timeline.Tests/UserDetailServiceTest.cs b/Timeline.Tests/UserDetailServiceTest.cs new file mode 100644 index 00000000..f9170c42 --- /dev/null +++ b/Timeline.Tests/UserDetailServiceTest.cs @@ -0,0 +1,275 @@ +using FluentAssertions;
+using Microsoft.Extensions.Logging;
+using System;
+using System.Linq;
+using System.Threading.Tasks;
+using Timeline.Entities;
+using Timeline.Models;
+using Timeline.Services;
+using Timeline.Tests.Helpers;
+using Timeline.Tests.Mock.Data;
+using Xunit;
+using Xunit.Abstractions;
+
+namespace Timeline.Tests
+{
+ public class UserDetailServiceTest : IDisposable
+ {
+ private readonly LoggerFactory _loggerFactory;
+ private readonly TestDatabase _database;
+
+ private readonly UserDetailService _service;
+
+ public UserDetailServiceTest(ITestOutputHelper outputHelper)
+ {
+ _loggerFactory = MyTestLoggerFactory.Create(outputHelper);
+ _database = new TestDatabase();
+
+ _service = new UserDetailService(_loggerFactory.CreateLogger<UserDetailService>(), _database.DatabaseContext);
+ }
+
+ public void Dispose()
+ {
+ _loggerFactory.Dispose();
+ _database.Dispose();
+ }
+
+ [Fact]
+ public void GetNickname_ShouldThrow_ArgumentException()
+ {
+ // no need to await because arguments are checked syncronizedly.
+ _service.Invoking(s => s.GetUserNickname(null)).Should().Throw<ArgumentException>()
+ .Where(e => e.ParamName == "username" && e.Message.Contains("null", StringComparison.OrdinalIgnoreCase));
+ _service.Invoking(s => s.GetUserNickname("")).Should().Throw<ArgumentException>()
+ .Where(e => e.ParamName == "username" && e.Message.Contains("empty", StringComparison.OrdinalIgnoreCase));
+ }
+
+ [Fact]
+ public void GetNickname_ShouldThrow_UserNotExistException()
+ {
+ const string username = "usernotexist";
+ _service.Awaiting(s => s.GetUserNickname(username)).Should().Throw<UserNotExistException>()
+ .Where(e => e.Username == username);
+ }
+
+ [Fact]
+ public async Task GetNickname_Should_Create_And_ReturnDefault()
+ {
+ {
+ var nickname = await _service.GetUserNickname(MockUsers.UserUsername);
+ nickname.Should().BeNull();
+ }
+
+ {
+ var context = _database.DatabaseContext;
+ var userId = await DatabaseExtensions.CheckAndGetUser(context.Users, MockUsers.UserUsername);
+ var detail = context.UserDetails.Where(e => e.UserId == userId).Single();
+ detail.Nickname.Should().BeNullOrEmpty();
+ detail.QQ.Should().BeNullOrEmpty();
+ detail.EMail.Should().BeNullOrEmpty();
+ detail.PhoneNumber.Should().BeNullOrEmpty();
+ detail.Description.Should().BeNullOrEmpty();
+ }
+ }
+
+ [Theory]
+ [InlineData(null)]
+ [InlineData("")]
+ [InlineData("nickname")]
+ public async Task GetNickname_Should_ReturnData(string nickname)
+ {
+ {
+ var context = _database.DatabaseContext;
+ var userId = await DatabaseExtensions.CheckAndGetUser(context.Users, MockUsers.UserUsername);
+ var entity = new UserDetailEntity
+ {
+ Nickname = nickname,
+ UserId = userId
+ };
+ context.Add(entity);
+ await context.SaveChangesAsync();
+ }
+
+ {
+ var n = await _service.GetUserNickname(MockUsers.UserUsername);
+ n.Should().Equals(string.IsNullOrEmpty(nickname) ? null : nickname);
+ }
+ }
+
+ [Fact]
+ public void GetDetail_ShouldThrow_ArgumentException()
+ {
+ // no need to await because arguments are checked syncronizedly.
+ _service.Invoking(s => s.GetUserDetail(null)).Should().Throw<ArgumentException>()
+ .Where(e => e.ParamName == "username" && e.Message.Contains("null", StringComparison.OrdinalIgnoreCase));
+ _service.Invoking(s => s.GetUserDetail("")).Should().Throw<ArgumentException>()
+ .Where(e => e.ParamName == "username" && e.Message.Contains("empty", StringComparison.OrdinalIgnoreCase));
+ }
+
+ [Fact]
+ public void GetDetail_ShouldThrow_UserNotExistException()
+ {
+ const string username = "usernotexist";
+ _service.Awaiting(s => s.GetUserDetail(username)).Should().Throw<UserNotExistException>()
+ .Where(e => e.Username == username);
+ }
+
+ [Fact]
+ public async Task GetDetail_Should_Create_And_ReturnDefault()
+ {
+ {
+ var detail = await _service.GetUserDetail(MockUsers.UserUsername);
+ detail.Should().BeEquivalentTo(new UserDetail());
+ }
+
+ {
+ var context = _database.DatabaseContext;
+ var userId = await DatabaseExtensions.CheckAndGetUser(context.Users, MockUsers.UserUsername);
+ var detail = context.UserDetails.Where(e => e.UserId == userId).Single();
+ detail.Nickname.Should().BeNullOrEmpty();
+ detail.QQ.Should().BeNullOrEmpty();
+ detail.EMail.Should().BeNullOrEmpty();
+ detail.PhoneNumber.Should().BeNullOrEmpty();
+ detail.Description.Should().BeNullOrEmpty();
+ }
+ }
+
+ [Fact]
+ public async Task GetDetail_Should_ReturnData()
+ {
+ const string email = "ha@aaa.net";
+ const string description = "hahaha";
+
+
+ {
+ var context = _database.DatabaseContext;
+ var userId = await DatabaseExtensions.CheckAndGetUser(context.Users, MockUsers.UserUsername);
+ var entity = new UserDetailEntity
+ {
+ EMail = email,
+ Description = description,
+ UserId = userId
+ };
+ context.Add(entity);
+ await context.SaveChangesAsync();
+ }
+
+ {
+ var detail = await _service.GetUserDetail(MockUsers.UserUsername);
+ detail.Should().BeEquivalentTo(new UserDetail
+ {
+ EMail = email,
+ Description = description
+ });
+ }
+ }
+
+ [Fact]
+ public void UpdateDetail_ShouldThrow_ArgumentException()
+ {
+ // no need to await because arguments are checked syncronizedly.
+ _service.Invoking(s => s.UpdateUserDetail(null, new UserDetail())).Should().Throw<ArgumentException>()
+ .Where(e => e.ParamName == "username" && e.Message.Contains("null", StringComparison.OrdinalIgnoreCase));
+ _service.Invoking(s => s.UpdateUserDetail("", new UserDetail())).Should().Throw<ArgumentException>()
+ .Where(e => e.ParamName == "username" && e.Message.Contains("empty", StringComparison.OrdinalIgnoreCase));
+ _service.Invoking(s => s.UpdateUserDetail("aaa", null)).Should().Throw<ArgumentException>()
+ .Where(e => e.ParamName == "detail");
+ }
+
+ [Fact]
+ public void UpdateDetail_ShouldThrow_UserNotExistException()
+ {
+ const string username = "usernotexist";
+ _service.Awaiting(s => s.UpdateUserDetail(username, new UserDetail())).Should().Throw<UserNotExistException>()
+ .Where(e => e.Username == username);
+ }
+
+ [Fact]
+ public async Task UpdateDetail_Empty_Should_Work()
+ {
+ await _service.UpdateUserDetail(MockUsers.UserUsername, new UserDetail());
+
+ var context = _database.DatabaseContext;
+ var userId = await DatabaseExtensions.CheckAndGetUser(context.Users, MockUsers.UserUsername);
+ var entity = context.UserDetails.Where(e => e.UserId == userId).Single();
+ entity.Nickname.Should().BeNullOrEmpty();
+ entity.QQ.Should().BeNullOrEmpty();
+ entity.EMail.Should().BeNullOrEmpty();
+ entity.PhoneNumber.Should().BeNullOrEmpty();
+ entity.Description.Should().BeNullOrEmpty();
+ }
+
+ [Theory]
+ [InlineData(nameof(UserDetail.Nickname), nameof(UserDetailEntity.Nickname), "aaaa", "bbbb")]
+ [InlineData(nameof(UserDetail.QQ), nameof(UserDetailEntity.QQ), "12345678910", "987654321")]
+ [InlineData(nameof(UserDetail.EMail), nameof(UserDetailEntity.EMail), "aaa@aaa.aaa", "bbb@bbb.bbb")]
+ [InlineData(nameof(UserDetail.PhoneNumber), nameof(UserDetailEntity.PhoneNumber), "12345678910", "987654321")]
+ [InlineData(nameof(UserDetail.Description), nameof(UserDetailEntity.Description), "descriptionA", "descriptionB")]
+ public async Task UpdateDetail_Single_Should_Work(string propertyName, string entityPropertyName, string mockData1, string mockData2)
+ {
+
+ UserDetail CreateWith(string propertyValue)
+ {
+ var detail = new UserDetail();
+ typeof(UserDetail).GetProperty(propertyName).SetValue(detail, propertyValue);
+ return detail;
+ }
+
+ await _service.UpdateUserDetail(MockUsers.UserUsername, CreateWith(mockData1));
+
+ var context = _database.DatabaseContext;
+ var userId = await DatabaseExtensions.CheckAndGetUser(context.Users, MockUsers.UserUsername);
+ var entity = context.UserDetails.Where(e => e.UserId == userId).Single();
+
+ void TestWith(string propertyValue)
+ {
+ typeof(UserDetailEntity).GetProperty(entityPropertyName).GetValue(entity).Should().Equals(propertyValue);
+ foreach (var p in typeof(UserDetailEntity).GetProperties().Where(p => p.Name != entityPropertyName))
+ (p.GetValue(entity) as string).Should().BeNullOrEmpty();
+ }
+
+ TestWith(mockData1);
+
+ await _service.UpdateUserDetail(MockUsers.UserUsername, CreateWith(mockData2));
+ TestWith(mockData2);
+ await _service.UpdateUserDetail(MockUsers.UserUsername, CreateWith(""));
+ TestWith("");
+ }
+
+ [Fact]
+ public async Task UpdateDetail_Multiple_Should_Work()
+ {
+ var detail = new UserDetail
+ {
+ QQ = "12345678",
+ EMail = "aaa@aaa.aaa",
+ PhoneNumber = "11111111111",
+ Description = "aaaaaaaaaa"
+ };
+
+ await _service.UpdateUserDetail(MockUsers.UserUsername, detail);
+
+ var context = _database.DatabaseContext;
+ var userId = await DatabaseExtensions.CheckAndGetUser(context.Users, MockUsers.UserUsername);
+ var entity = context.UserDetails.Where(e => e.UserId == userId).Single();
+ entity.QQ.Should().Equals(detail.QQ);
+ entity.EMail.Should().Equals(detail.EMail);
+ entity.PhoneNumber.Should().Equals(detail.PhoneNumber);
+ entity.Description.Should().Equals(detail.Description);
+
+ var detail2 = new UserDetail
+ {
+ QQ = null,
+ EMail = "bbb@bbb.bbb",
+ PhoneNumber = "",
+ Description = "bbbbbbbbb"
+ };
+
+ await _service.UpdateUserDetail(MockUsers.UserUsername, detail2);
+ entity.QQ.Should().Equals(detail.QQ);
+ entity.EMail.Should().Equals(detail2.EMail);
+ entity.PhoneNumber.Should().BeNullOrEmpty();
+ entity.Description.Should().Equals(detail2.Description);
+ }
+ }
+}
diff --git a/Timeline.Tests/UserDetailValidatorTest.cs b/Timeline.Tests/UserDetailValidatorTest.cs new file mode 100644 index 00000000..9b112946 --- /dev/null +++ b/Timeline.Tests/UserDetailValidatorTest.cs @@ -0,0 +1,97 @@ +using FluentAssertions;
+using System.Collections.Generic;
+using Timeline.Models.Validation;
+using Xunit;
+
+namespace Timeline.Tests
+{
+ public static class UserDetailValidatorsTest
+ {
+ private static void SucceedWith<TValidator>(object value) where TValidator : class, IValidator, new()
+ {
+ var result = new TValidator().Validate(value, out var message);
+ result.Should().BeTrue();
+ message.Should().Equals(ValidationConstants.SuccessMessage);
+ }
+
+ private static void FailWith<TValidator>(object value, params string[] messageContains) where TValidator : class, IValidator, new()
+ {
+ var result = new TValidator().Validate(value, out var message);
+ result.Should().BeFalse();
+
+ foreach (var m in messageContains)
+ {
+ message.Should().ContainEquivalentOf(m);
+ }
+ }
+
+ public class QQ
+ {
+ [Theory]
+ [InlineData(null)]
+ [InlineData("")]
+ [InlineData("12345678")]
+ public void Success(object qq)
+ {
+ SucceedWith<UserDetailValidators.QQValidator>(qq);
+ }
+
+ [Theory]
+ [InlineData(123, "type")]
+ [InlineData("123", "short")]
+ [InlineData("111111111111111111111111111111111111", "long")]
+ [InlineData("aaaaaaaa", "digit")]
+ public void Fail(object qq, string messageContains)
+ {
+ FailWith<UserDetailValidators.QQValidator>(qq, messageContains);
+ }
+ }
+
+ public class EMail
+ {
+ [Theory]
+ [InlineData(null)]
+ [InlineData("")]
+ [InlineData("aaa@aaa.net")]
+ public void Success(object email)
+ {
+ SucceedWith<UserDetailValidators.EMailValidator>(email);
+ }
+
+ public static IEnumerable<object[]> FailTestData()
+ {
+ yield return new object[] { 123, "type" };
+ yield return new object[] { new string('a', 100), "long" };
+ yield return new object[] { "aaaaaaaa", "format" };
+ }
+
+ [Theory]
+ [MemberData(nameof(FailTestData))]
+ public void Fail(object email, string messageContains)
+ {
+ FailWith<UserDetailValidators.EMailValidator>(email, messageContains);
+ }
+ }
+
+ public class PhoneNumber
+ {
+ [Theory]
+ [InlineData(null)]
+ [InlineData("")]
+ [InlineData("12345678910")]
+ public void Success(object phoneNumber)
+ {
+ SucceedWith<UserDetailValidators.PhoneNumberValidator>(phoneNumber);
+ }
+
+ [Theory]
+ [InlineData(123, "type")]
+ [InlineData("111111111111111111111111111111111111", "long")]
+ [InlineData("aaaaaaaa", "digit")]
+ public void Fail(object phoneNumber, string messageContains)
+ {
+ FailWith<UserDetailValidators.PhoneNumberValidator>(phoneNumber, messageContains);
+ }
+ }
+ }
+}
diff --git a/Timeline.Tests/UsernameValidatorUnitTest.cs b/Timeline.Tests/UsernameValidatorUnitTest.cs index 20558d0e..6a635ba1 100644 --- a/Timeline.Tests/UsernameValidatorUnitTest.cs +++ b/Timeline.Tests/UsernameValidatorUnitTest.cs @@ -1,5 +1,4 @@ using FluentAssertions;
-using System;
using Timeline.Models.Validation;
using Xunit;
|