diff options
Diffstat (limited to 'Timeline.Tests')
| -rw-r--r-- | Timeline.Tests/Helpers/HttpClientExtensions.cs | 9 | ||||
| -rw-r--r-- | Timeline.Tests/Helpers/ImageHelper.cs | 21 | ||||
| -rw-r--r-- | Timeline.Tests/Helpers/MyTestLoggerFactory.cs | 14 | ||||
| -rw-r--r-- | Timeline.Tests/Helpers/MyWebApplicationFactory.cs | 5 | ||||
| -rw-r--r-- | Timeline.Tests/IntegratedTests/UserAvatarTests.cs | 154 | ||||
| -rw-r--r-- | Timeline.Tests/Mock/Data/TestDatabase.cs | 46 | ||||
| -rw-r--r-- | Timeline.Tests/UserAvatarServiceTest.cs | 232 |
7 files changed, 481 insertions, 0 deletions
diff --git a/Timeline.Tests/Helpers/HttpClientExtensions.cs b/Timeline.Tests/Helpers/HttpClientExtensions.cs index cd40d91e..b9204fcc 100644 --- a/Timeline.Tests/Helpers/HttpClientExtensions.cs +++ b/Timeline.Tests/Helpers/HttpClientExtensions.cs @@ -1,5 +1,6 @@ using Newtonsoft.Json;
using System.Net.Http;
+using System.Net.Http.Headers;
using System.Text;
using System.Threading.Tasks;
@@ -11,5 +12,13 @@ namespace Timeline.Tests.Helpers {
return client.PatchAsync(url, new StringContent(JsonConvert.SerializeObject(body), Encoding.UTF8, "application/json"));
}
+
+ public static Task<HttpResponseMessage> PutByteArrayAsync(this HttpClient client, string url, byte[] body, string mimeType)
+ {
+ var content = new ByteArrayContent(body);
+ content.Headers.ContentLength = body.Length;
+ content.Headers.ContentType = new MediaTypeHeaderValue(mimeType);
+ return client.PutAsync(url, content);
+ }
}
}
diff --git a/Timeline.Tests/Helpers/ImageHelper.cs b/Timeline.Tests/Helpers/ImageHelper.cs new file mode 100644 index 00000000..c5a9cf17 --- /dev/null +++ b/Timeline.Tests/Helpers/ImageHelper.cs @@ -0,0 +1,21 @@ +using SixLabors.ImageSharp;
+using SixLabors.ImageSharp.PixelFormats;
+using System.IO;
+
+namespace Timeline.Tests.Helpers
+{
+ public static class ImageHelper
+ {
+ public static byte[] CreatePngWithSize(int width, int height)
+ {
+ using (var image = new Image<Rgba32>(width, height))
+ {
+ using (var stream = new MemoryStream())
+ {
+ image.SaveAsPng(stream);
+ return stream.ToArray();
+ }
+ }
+ }
+ }
+}
diff --git a/Timeline.Tests/Helpers/MyTestLoggerFactory.cs b/Timeline.Tests/Helpers/MyTestLoggerFactory.cs new file mode 100644 index 00000000..40c6a77e --- /dev/null +++ b/Timeline.Tests/Helpers/MyTestLoggerFactory.cs @@ -0,0 +1,14 @@ +using Microsoft.Extensions.Logging;
+using Microsoft.Extensions.Logging.Testing;
+using Xunit.Abstractions;
+
+namespace Timeline.Tests.Helpers
+{
+ public static class MyTestLoggerFactory
+ {
+ public static LoggerFactory Create(ITestOutputHelper outputHelper)
+ {
+ return new LoggerFactory(new[] { new XunitLoggerProvider(outputHelper) });
+ }
+ }
+}
diff --git a/Timeline.Tests/Helpers/MyWebApplicationFactory.cs b/Timeline.Tests/Helpers/MyWebApplicationFactory.cs index dfadd1ae..e96d11fe 100644 --- a/Timeline.Tests/Helpers/MyWebApplicationFactory.cs +++ b/Timeline.Tests/Helpers/MyWebApplicationFactory.cs @@ -3,6 +3,7 @@ using Microsoft.AspNetCore.Mvc.Testing; using Microsoft.AspNetCore.TestHost;
using Microsoft.Data.Sqlite;
using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Diagnostics;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Logging;
using System;
@@ -37,6 +38,10 @@ namespace Timeline.Tests.Helpers {
var options = new DbContextOptionsBuilder<DatabaseContext>()
.UseSqlite(_databaseConnection)
+ .ConfigureWarnings(builder =>
+ {
+ builder.Throw(RelationalEventId.QueryClientEvaluationWarning);
+ })
.Options;
using (var context = new DatabaseContext(options))
diff --git a/Timeline.Tests/IntegratedTests/UserAvatarTests.cs b/Timeline.Tests/IntegratedTests/UserAvatarTests.cs new file mode 100644 index 00000000..e282da1b --- /dev/null +++ b/Timeline.Tests/IntegratedTests/UserAvatarTests.cs @@ -0,0 +1,154 @@ +using FluentAssertions;
+using Microsoft.AspNetCore.Hosting;
+using Microsoft.AspNetCore.Mvc.Testing;
+using Microsoft.Extensions.DependencyInjection;
+using SixLabors.ImageSharp.Formats.Png;
+using System;
+using System.IO;
+using System.Net;
+using System.Net.Http;
+using System.Net.Http.Headers;
+using System.Threading.Tasks;
+using Timeline.Controllers;
+using Timeline.Services;
+using Timeline.Tests.Helpers;
+using Timeline.Tests.Helpers.Authentication;
+using Xunit;
+using Xunit.Abstractions;
+
+namespace Timeline.Tests.IntegratedTests
+{
+ public class UserAvatarUnitTest : IClassFixture<MyWebApplicationFactory<Startup>>, IDisposable
+ {
+ private readonly WebApplicationFactory<Startup> _factory;
+ private readonly Action _disposeAction;
+
+ public UserAvatarUnitTest(MyWebApplicationFactory<Startup> factory, ITestOutputHelper outputHelper)
+ {
+ _factory = factory.WithTestConfig(outputHelper, out _disposeAction);
+ }
+
+ public void Dispose()
+ {
+ _disposeAction();
+ }
+
+ [Fact]
+ public async Task Test()
+ {
+ Avatar mockAvatar = new Avatar
+ {
+ Data = ImageHelper.CreatePngWithSize(100, 100),
+ Type = PngFormat.Instance.DefaultMimeType
+ };
+
+ using (var client = await _factory.CreateClientAsUser())
+ {
+ {
+ var res = await client.GetAsync("users/usernotexist/avatar");
+ res.Should().HaveStatusCodeNotFound()
+ .And.Should().HaveBodyAsCommonResponseWithCode(UserAvatarController.ErrorCodes.Get_UserNotExist);
+ }
+
+ var env = _factory.Server.Host.Services.GetRequiredService<IHostingEnvironment>();
+ var defaultAvatarData = await File.ReadAllBytesAsync(Path.Combine(env.ContentRootPath, "default-avatar.png"));
+
+ async Task GetReturnDefault(string username = "user")
+ {
+ var res = await client.GetAsync($"users/{username}/avatar");
+ res.Should().HaveStatusCodeOk();
+ res.Content.Headers.ContentType.MediaType.Should().Be("image/png");
+ var body = await res.Content.ReadAsByteArrayAsync();
+ body.Should().Equal(defaultAvatarData);
+ }
+
+ await GetReturnDefault();
+ await GetReturnDefault("admin");
+
+ {
+ var res = await client.PutByteArrayAsync("users/user/avatar", new[] { (byte)0x00 }, "image/notaccept");
+ res.Should().HaveStatusCode(HttpStatusCode.UnsupportedMediaType);
+ }
+
+ {
+ var res = await client.PutByteArrayAsync("users/user/avatar", new[] { (byte)0x00 }, "image/notaccept");
+ res.Should().HaveStatusCode(HttpStatusCode.UnsupportedMediaType);
+ }
+
+ {
+ var res = await client.PutByteArrayAsync("users/user/avatar", new[] { (byte)0x00 }, "image/png");
+ res.Should().HaveStatusCode(HttpStatusCode.BadRequest)
+ .And.Should().HaveBodyAsCommonResponseWithCode(UserAvatarController.ErrorCodes.Put_BadFormat_CantDecode);
+ }
+
+ {
+ var res = await client.PutByteArrayAsync("users/user/avatar", mockAvatar.Data, "image/jpeg");
+ res.Should().HaveStatusCode(HttpStatusCode.BadRequest)
+ .And.Should().HaveBodyAsCommonResponseWithCode(UserAvatarController.ErrorCodes.Put_BadFormat_UnmatchedFormat);
+ }
+
+ {
+ var res = await client.PutByteArrayAsync("users/user/avatar", ImageHelper.CreatePngWithSize(100, 200), "image/png");
+ res.Should().HaveStatusCode(HttpStatusCode.BadRequest)
+ .And.Should().HaveBodyAsCommonResponseWithCode(UserAvatarController.ErrorCodes.Put_BadFormat_BadSize);
+ }
+
+ {
+ var res = await client.PutByteArrayAsync("users/user/avatar", mockAvatar.Data, mockAvatar.Type);
+ res.Should().HaveStatusCode(HttpStatusCode.OK);
+
+ var res2 = await client.GetAsync("users/user/avatar");
+ res2.Should().HaveStatusCodeOk();
+ res2.Content.Headers.ContentType.MediaType.Should().Be(mockAvatar.Type);
+ var body = await res2.Content.ReadAsByteArrayAsync();
+ body.Should().Equal(mockAvatar.Data);
+ }
+
+ {
+ var res = await client.PutByteArrayAsync("users/admin/avatar", new[] { (byte)0x00 }, "image/png");
+ res.Should().HaveStatusCode(HttpStatusCode.Forbidden)
+ .And.Should().HaveBodyAsCommonResponseWithCode(UserAvatarController.ErrorCodes.Put_Forbid);
+ }
+
+ {
+ var res = await client.DeleteAsync("users/admin/avatar");
+ res.Should().HaveStatusCode(HttpStatusCode.Forbidden)
+ .And.Should().HaveBodyAsCommonResponseWithCode(UserAvatarController.ErrorCodes.Delete_Forbid);
+ }
+
+ for (int i = 0; i < 2; i++) // double delete should work.
+ {
+ var res = await client.DeleteAsync("users/user/avatar");
+ res.Should().HaveStatusCodeOk();
+ await GetReturnDefault();
+ }
+ }
+
+ // Authorization check.
+ using (var client = await _factory.CreateClientAsAdmin())
+ {
+ {
+ var res = await client.PutByteArrayAsync("users/user/avatar", mockAvatar.Data, mockAvatar.Type);
+ res.Should().HaveStatusCode(HttpStatusCode.OK);
+ }
+
+ {
+ var res = await client.DeleteAsync("users/user/avatar");
+ res.Should().HaveStatusCode(HttpStatusCode.OK);
+ }
+
+ {
+ var res = await client.PutByteArrayAsync("users/usernotexist/avatar", new[] { (byte)0x00 }, "image/png");
+ res.Should().HaveStatusCodeBadRequest()
+ .And.Should().HaveBodyAsCommonResponseWithCode(UserAvatarController.ErrorCodes.Put_UserNotExist);
+ }
+
+ {
+ var res = await client.DeleteAsync("users/usernotexist/avatar");
+ res.Should().HaveStatusCodeBadRequest()
+ .And.Should().HaveBodyAsCommonResponseWithCode(UserAvatarController.ErrorCodes.Delete_UserNotExist);
+ }
+ }
+ }
+ }
+}
\ No newline at end of file diff --git a/Timeline.Tests/Mock/Data/TestDatabase.cs b/Timeline.Tests/Mock/Data/TestDatabase.cs new file mode 100644 index 00000000..09c77dce --- /dev/null +++ b/Timeline.Tests/Mock/Data/TestDatabase.cs @@ -0,0 +1,46 @@ +using Microsoft.Data.Sqlite;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Diagnostics;
+using System;
+using Timeline.Entities;
+
+namespace Timeline.Tests.Mock.Data
+{
+ public class TestDatabase : IDisposable
+ {
+ private readonly SqliteConnection _databaseConnection;
+ private readonly DatabaseContext _databaseContext;
+
+ public TestDatabase()
+ {
+ _databaseConnection = new SqliteConnection("Data Source=:memory:;");
+ _databaseConnection.Open();
+
+ var options = new DbContextOptionsBuilder<DatabaseContext>()
+ .UseSqlite(_databaseConnection)
+ .ConfigureWarnings(builder =>
+ {
+ builder.Throw(RelationalEventId.QueryClientEvaluationWarning);
+ })
+ .Options;
+
+ _databaseContext = new DatabaseContext(options);
+
+ // init with mock data
+ _databaseContext.Database.EnsureCreated();
+ _databaseContext.Users.AddRange(MockUsers.Users);
+ _databaseContext.SaveChanges();
+ }
+
+ public void Dispose()
+ {
+ _databaseContext.Dispose();
+
+ _databaseConnection.Close();
+ _databaseConnection.Dispose();
+ }
+
+ public SqliteConnection DatabaseConnection => _databaseConnection;
+ public DatabaseContext DatabaseContext => _databaseContext;
+ }
+}
diff --git a/Timeline.Tests/UserAvatarServiceTest.cs b/Timeline.Tests/UserAvatarServiceTest.cs new file mode 100644 index 00000000..69d6b61c --- /dev/null +++ b/Timeline.Tests/UserAvatarServiceTest.cs @@ -0,0 +1,232 @@ +using FluentAssertions;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.Extensions.Logging;
+using SixLabors.ImageSharp;
+using SixLabors.ImageSharp.PixelFormats;
+using SixLabors.ImageSharp.Formats.Png;
+using System;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Timeline.Entities;
+using Timeline.Services;
+using Timeline.Tests.Helpers;
+using Timeline.Tests.Mock.Data;
+using Xunit;
+using Xunit.Abstractions;
+
+namespace Timeline.Tests
+{
+ public class MockDefaultUserAvatarProvider : IDefaultUserAvatarProvider
+ {
+ public static Avatar Avatar { get; } = new Avatar { Type = "image/test", Data = Encoding.ASCII.GetBytes("test") };
+
+ public Task<Avatar> GetDefaultAvatar()
+ {
+ return Task.FromResult(Avatar);
+ }
+ }
+
+ public class MockUserAvatarValidator : IUserAvatarValidator
+ {
+ public Task Validate(Avatar avatar)
+ {
+ return Task.CompletedTask;
+ }
+ }
+
+ public class UserAvatarValidatorTest : IClassFixture<UserAvatarValidator>
+ {
+ private readonly UserAvatarValidator _validator;
+
+ public UserAvatarValidatorTest(UserAvatarValidator validator)
+ {
+ _validator = validator;
+ }
+
+ [Fact]
+ public void CantDecode()
+ {
+ Avatar avatar = new Avatar
+ {
+ Data = Encoding.ASCII.GetBytes("This is not a image."),
+ Type = "image/png"
+ };
+ _validator.Awaiting(v => v.Validate(avatar))
+ .Should().Throw<AvatarDataException>()
+ .Where(e => e.Avatar == avatar && e.Error == AvatarDataException.ErrorReason.CantDecode);
+ }
+
+ [Fact]
+ public void UnmatchedFormat()
+ {
+ Avatar avatar = new Avatar
+ {
+ Data = ImageHelper.CreatePngWithSize(100, 100),
+ Type = "image/jpeg"
+ };
+ _validator.Awaiting(v => v.Validate(avatar))
+ .Should().Throw<AvatarDataException>()
+ .Where(e => e.Avatar == avatar && e.Error == AvatarDataException.ErrorReason.UnmatchedFormat);
+ }
+
+ [Fact]
+ public void BadSize()
+ {
+ Avatar avatar = new Avatar
+ {
+ Data = ImageHelper.CreatePngWithSize(100, 200),
+ Type = PngFormat.Instance.DefaultMimeType
+ };
+ _validator.Awaiting(v => v.Validate(avatar))
+ .Should().Throw<AvatarDataException>()
+ .Where(e => e.Avatar == avatar && e.Error == AvatarDataException.ErrorReason.BadSize);
+ }
+
+ [Fact]
+ public void Success()
+ {
+ Avatar avatar = new Avatar
+ {
+ Data = ImageHelper.CreatePngWithSize(100, 100),
+ Type = PngFormat.Instance.DefaultMimeType
+ };
+ _validator.Awaiting(v => v.Validate(avatar))
+ .Should().NotThrow();
+ }
+ }
+
+ public class UserAvatarServiceTest : IDisposable, IClassFixture<MockDefaultUserAvatarProvider>, IClassFixture<MockUserAvatarValidator>
+ {
+ private static Avatar MockAvatar { get; } = new Avatar
+ {
+ Type = "image/testaaa",
+ Data = Encoding.ASCII.GetBytes("amock")
+ };
+
+ private static Avatar MockAvatar2 { get; } = new Avatar
+ {
+ Type = "image/testbbb",
+ Data = Encoding.ASCII.GetBytes("bmock")
+ };
+
+ private readonly MockDefaultUserAvatarProvider _mockDefaultUserAvatarProvider;
+
+ private readonly LoggerFactory _loggerFactory;
+ private readonly TestDatabase _database;
+
+ private readonly UserAvatarService _service;
+
+ public UserAvatarServiceTest(ITestOutputHelper outputHelper, MockDefaultUserAvatarProvider mockDefaultUserAvatarProvider, MockUserAvatarValidator mockUserAvatarValidator)
+ {
+ _mockDefaultUserAvatarProvider = mockDefaultUserAvatarProvider;
+
+ _loggerFactory = MyTestLoggerFactory.Create(outputHelper);
+ _database = new TestDatabase();
+
+ _service = new UserAvatarService(_loggerFactory.CreateLogger<UserAvatarService>(), _database.DatabaseContext, _mockDefaultUserAvatarProvider, mockUserAvatarValidator);
+ }
+
+ public void Dispose()
+ {
+ _loggerFactory.Dispose();
+ _database.Dispose();
+ }
+
+ [Fact]
+ public void GetAvatar_ShouldThrow_ArgumentException()
+ {
+ // no need to await because arguments are checked syncronizedly.
+ _service.Invoking(s => s.GetAvatar(null)).Should().Throw<ArgumentException>()
+ .Where(e => e.ParamName == "username" && e.Message.Contains("null", StringComparison.OrdinalIgnoreCase));
+ _service.Invoking(s => s.GetAvatar("")).Should().Throw<ArgumentException>()
+ .Where(e => e.ParamName == "username" && e.Message.Contains("empty", StringComparison.OrdinalIgnoreCase));
+ }
+
+ [Fact]
+ public void GetAvatar_ShouldThrow_UserNotExistException()
+ {
+ const string username = "usernotexist";
+ _service.Awaiting(s => s.GetAvatar(username)).Should().Throw<UserNotExistException>()
+ .Where(e => e.Username == username);
+ }
+
+ [Fact]
+ public async Task GetAvatar_ShouldReturn_Default()
+ {
+ const string username = MockUsers.UserUsername;
+ (await _service.GetAvatar(username)).Should().BeEquivalentTo(await _mockDefaultUserAvatarProvider.GetDefaultAvatar());
+ }
+
+ [Fact]
+ public async Task GetAvatar_ShouldReturn_Data()
+ {
+ const string username = MockUsers.UserUsername;
+
+ {
+ // create mock data
+ var context = _database.DatabaseContext;
+ var user = await context.Users.Where(u => u.Name == username).Include(u => u.Avatar).SingleAsync();
+ user.Avatar = new UserAvatar
+ {
+ Type = MockAvatar.Type,
+ Data = MockAvatar.Data
+ };
+ await context.SaveChangesAsync();
+ }
+
+ (await _service.GetAvatar(username)).Should().BeEquivalentTo(MockAvatar);
+ }
+
+ [Fact]
+ public void SetAvatar_ShouldThrow_ArgumentException()
+ {
+ // no need to await because arguments are checked syncronizedly.
+ _service.Invoking(s => s.SetAvatar(null, MockAvatar)).Should().Throw<ArgumentException>()
+ .Where(e => e.ParamName == "username" && e.Message.Contains("null", StringComparison.OrdinalIgnoreCase));
+ _service.Invoking(s => s.SetAvatar("", MockAvatar)).Should().Throw<ArgumentException>()
+ .Where(e => e.ParamName == "username" && e.Message.Contains("empty", StringComparison.OrdinalIgnoreCase));
+
+ _service.Invoking(s => s.SetAvatar("aaa", new Avatar { Type = null, Data = new[] { (byte)0x00 } })).Should().Throw<ArgumentException>()
+ .Where(e => e.ParamName == "avatar" && e.Message.Contains("null", StringComparison.OrdinalIgnoreCase));
+ _service.Invoking(s => s.SetAvatar("aaa", new Avatar { Type = "", Data = new[] { (byte)0x00 } })).Should().Throw<ArgumentException>()
+ .Where(e => e.ParamName == "avatar" && e.Message.Contains("empty", StringComparison.OrdinalIgnoreCase));
+
+ _service.Invoking(s => s.SetAvatar("aaa", new Avatar { Type = "aaa", Data = null })).Should().Throw<ArgumentException>()
+ .Where(e => e.ParamName == "avatar" && e.Message.Contains("null", StringComparison.OrdinalIgnoreCase));
+ }
+
+ [Fact]
+ public void SetAvatar_ShouldThrow_UserNotExistException()
+ {
+ const string username = "usernotexist";
+ _service.Awaiting(s => s.SetAvatar(username, MockAvatar)).Should().Throw<UserNotExistException>()
+ .Where(e => e.Username == username);
+ }
+
+ [Fact]
+ public async Task SetAvatar_Should_Work()
+ {
+ const string username = MockUsers.UserUsername;
+
+ var user = await _database.DatabaseContext.Users.Where(u => u.Name == username).Include(u => u.Avatar).SingleAsync();
+
+ // create
+ await _service.SetAvatar(username, MockAvatar);
+ user.Avatar.Should().NotBeNull();
+ user.Avatar.Type.Should().Be(MockAvatar.Type);
+ user.Avatar.Data.Should().Equal(MockAvatar.Data);
+
+ // modify
+ await _service.SetAvatar(username, MockAvatar2);
+ user.Avatar.Should().NotBeNull();
+ user.Avatar.Type.Should().Be(MockAvatar2.Type);
+ user.Avatar.Data.Should().Equal(MockAvatar2.Data);
+
+ // delete
+ await _service.SetAvatar(username, null);
+ user.Avatar.Should().BeNull();
+ }
+ }
+}
|