11 files changed, 628 insertions, 0 deletions
diff --git a/BackEnd/Timeline.Tests/Helpers/AsyncFunctionAssertionsExtensions.cs b/BackEnd/Timeline.Tests/Helpers/AsyncFunctionAssertionsExtensions.cs
new file mode 100644
index 00000000..b78309c0
--- /dev/null
+++ b/BackEnd/Timeline.Tests/Helpers/AsyncFunctionAssertionsExtensions.cs
@@ -0,0 +1,16 @@
+using FluentAssertions;
+using FluentAssertions.Primitives;
+using FluentAssertions.Specialized;
+using System;
+using System.Threading.Tasks;
+
+namespace Timeline.Tests.Helpers
+{
+    public static class AsyncFunctionAssertionsExtensions
+    {
+        public static async Task<AndConstraint<ObjectAssertions>> ThrowAsync(this AsyncFunctionAssertions assertions, Type exceptionType, string because = "", params object[] becauseArgs)
+        {
+            return (await assertions.ThrowAsync<Exception>(because, becauseArgs)).Which.Should().BeAssignableTo(exceptionType);
+        }
+    }
+}
diff --git a/BackEnd/Timeline.Tests/Helpers/CacheTestHelper.cs b/BackEnd/Timeline.Tests/Helpers/CacheTestHelper.cs
new file mode 100644
index 00000000..b3709a28
--- /dev/null
+++ b/BackEnd/Timeline.Tests/Helpers/CacheTestHelper.cs
@@ -0,0 +1,64 @@
+using FluentAssertions;
+using System;
+using System.Net;
+using System.Net.Http;
+using System.Net.Http.Headers;
+using System.Threading.Tasks;
+using Timeline.Models.Http;
+
+namespace Timeline.Tests.Helpers
+{
+    public static class CacheTestHelper
+    {
+        public static async Task TestCache(HttpClient client, string getUrl)
+        {
+            EntityTagHeaderValue eTag;
+            {
+                var res = await client.GetAsync(getUrl);
+                res.Should().HaveStatusCode(200);
+                var cacheControlHeader = res.Headers.CacheControl;
+                cacheControlHeader.NoCache.Should().BeTrue();
+                cacheControlHeader.NoStore.Should().BeFalse();
+                cacheControlHeader.Private.Should().BeTrue();
+                cacheControlHeader.Public.Should().BeFalse();
+                cacheControlHeader.MustRevalidate.Should().BeTrue();
+                cacheControlHeader.MaxAge.Should().NotBeNull().And.Be(TimeSpan.FromDays(14));
+                eTag = res.Headers.ETag;
+            }
+
+            {
+                using var request = new HttpRequestMessage()
+                {
+                    RequestUri = new Uri(client.BaseAddress, getUrl),
+                    Method = HttpMethod.Get,
+                };
+                request.Headers.TryAddWithoutValidation("If-None-Match", "\"dsdfd");
+                var res = await client.SendAsync(request);
+                res.Should().HaveStatusCode(HttpStatusCode.BadRequest)
+                    .And.HaveCommonBody(ErrorCodes.Common.Header.IfNonMatch_BadFormat);
+            }
+
+            {
+                using var request = new HttpRequestMessage()
+                {
+                    RequestUri = new Uri(client.BaseAddress, getUrl),
+                    Method = HttpMethod.Get,
+                };
+                request.Headers.TryAddWithoutValidation("If-None-Match", "\"aaa\"");
+                var res = await client.SendAsync(request);
+                res.Should().HaveStatusCode(HttpStatusCode.OK);
+            }
+
+            {
+                using var request = new HttpRequestMessage()
+                {
+                    RequestUri = new Uri(client.BaseAddress, getUrl),
+                    Method = HttpMethod.Get,
+                };
+                request.Headers.Add("If-None-Match", eTag.ToString());
+                var res = await client.SendAsync(request);
+                res.Should().HaveStatusCode(HttpStatusCode.NotModified);
+            }
+        }
+    }
+}
diff --git a/BackEnd/Timeline.Tests/Helpers/HttpClientExtensions.cs b/BackEnd/Timeline.Tests/Helpers/HttpClientExtensions.cs
new file mode 100644
index 00000000..6513bbe7
--- /dev/null
+++ b/BackEnd/Timeline.Tests/Helpers/HttpClientExtensions.cs
@@ -0,0 +1,51 @@
+using Newtonsoft.Json;
+using System;
+using System.Net.Http;
+using System.Net.Http.Headers;
+using System.Net.Mime;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace Timeline.Tests.Helpers
+{
+    public static class HttpClientExtensions
+    {
+        public static Task<HttpResponseMessage> PatchAsJsonAsync<T>(this HttpClient client, string url, T body)
+        {
+            return client.PatchAsJsonAsync(new Uri(url, UriKind.RelativeOrAbsolute), body);
+        }
+
+        [System.Diagnostics.CodeAnalysis.SuppressMessage("Reliability", "CA2000:Dispose objects before losing scope")]
+        public static Task<HttpResponseMessage> PatchAsJsonAsync<T>(this HttpClient client, Uri url, T body)
+        {
+            return client.PatchAsync(url, new StringContent(
+                JsonConvert.SerializeObject(body), Encoding.UTF8, MediaTypeNames.Application.Json));
+        }
+
+        public static Task<HttpResponseMessage> PutByteArrayAsync(this HttpClient client, string url, byte[] body, string mimeType)
+        {
+            return client.PutByteArrayAsync(new Uri(url, UriKind.RelativeOrAbsolute), body, mimeType);
+        }
+
+        [System.Diagnostics.CodeAnalysis.SuppressMessage("Reliability", "CA2000:Dispose objects before losing scope")]
+        public static Task<HttpResponseMessage> PutByteArrayAsync(this HttpClient client, Uri 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);
+        }
+
+        public static Task<HttpResponseMessage> PutStringAsync(this HttpClient client, string url, string body, string mimeType = null)
+        {
+            return client.PutStringAsync(new Uri(url, UriKind.RelativeOrAbsolute), body, mimeType);
+        }
+
+        [System.Diagnostics.CodeAnalysis.SuppressMessage("Reliability", "CA2000:Dispose objects before losing scope")]
+        public static Task<HttpResponseMessage> PutStringAsync(this HttpClient client, Uri url, string body, string mimeType = null)
+        {
+            var content = new StringContent(body, Encoding.UTF8, mimeType ?? MediaTypeNames.Text.Plain);
+            return client.PutAsync(url, content);
+        }
+    }
+}
diff --git a/BackEnd/Timeline.Tests/Helpers/HttpResponseExtensions.cs b/BackEnd/Timeline.Tests/Helpers/HttpResponseExtensions.cs
new file mode 100644
index 00000000..2bd497f1
--- /dev/null
+++ b/BackEnd/Timeline.Tests/Helpers/HttpResponseExtensions.cs
@@ -0,0 +1,35 @@
+using System.Net.Http;
+using System.Text.Json;
+using System.Text.Json.Serialization;
+using System.Threading.Tasks;
+using Timeline.Models.Converters;
+using Timeline.Models.Http;
+
+namespace Timeline.Tests.Helpers
+{
+    public static class HttpResponseExtensions
+    {
+        public static JsonSerializerOptions JsonSerializerOptions { get; }
+
+        static HttpResponseExtensions()
+        {
+            JsonSerializerOptions = new JsonSerializerOptions
+            {
+                PropertyNamingPolicy = JsonNamingPolicy.CamelCase
+            };
+            JsonSerializerOptions.Converters.Add(new JsonStringEnumConverter());
+            JsonSerializerOptions.Converters.Add(new JsonDateTimeConverter());
+        }
+
+        public static async Task<T> ReadBodyAsJsonAsync<T>(this HttpResponseMessage response)
+        {
+            var stream = await response.Content.ReadAsStreamAsync();
+            return await JsonSerializer.DeserializeAsync<T>(stream, JsonSerializerOptions);
+        }
+
+        public static Task<CommonResponse> ReadBodyAsCommonResponseAsync(this HttpResponseMessage response)
+        {
+            return response.ReadBodyAsJsonAsync<CommonResponse>();
+        }
+    }
+}
diff --git a/BackEnd/Timeline.Tests/Helpers/ImageHelper.cs b/BackEnd/Timeline.Tests/Helpers/ImageHelper.cs
new file mode 100644
index 00000000..9bed0917
--- /dev/null
+++ b/BackEnd/Timeline.Tests/Helpers/ImageHelper.cs
@@ -0,0 +1,26 @@
+using SixLabors.ImageSharp;
+using SixLabors.ImageSharp.Formats;
+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();
+        }
+
+        public static byte[] CreateImageWithSize(int width, int height, IImageFormat format)
+        {
+            using var image = new Image<Rgba32>(width, height);
+            using var stream = new MemoryStream();
+            image.Save(stream, format);
+            return stream.ToArray();
+        }
+    }
+}
diff --git a/BackEnd/Timeline.Tests/Helpers/ParameterInfoAssertions.cs b/BackEnd/Timeline.Tests/Helpers/ParameterInfoAssertions.cs
new file mode 100644
index 00000000..d3e5a41e
--- /dev/null
+++ b/BackEnd/Timeline.Tests/Helpers/ParameterInfoAssertions.cs
@@ -0,0 +1,60 @@
+using FluentAssertions;
+using FluentAssertions.Execution;
+using FluentAssertions.Formatting;
+using FluentAssertions.Primitives;
+using System;
+using System.Reflection;
+
+namespace Timeline.Tests.Helpers
+{
+    public class ParameterInfoValueFormatter : IValueFormatter
+    {
+        public bool CanHandle(object value)
+        {
+            return value is ParameterInfo;
+        }
+
+        public string Format(object value, FormattingContext context, FormatChild formatChild)
+        {
+            var param = (ParameterInfo)value;
+            return $"{param.Member.DeclaringType.FullName}.{param.Member.Name}#{param.Name}";
+        }
+    }
+
+    public class ParameterInfoAssertions : ReferenceTypeAssertions<ParameterInfo, ParameterInfoAssertions>
+    {
+        static ParameterInfoAssertions()
+        {
+            Formatter.AddFormatter(new ParameterInfoValueFormatter());
+        }
+
+        public ParameterInfoAssertions(ParameterInfo parameterInfo)
+        {
+            Subject = parameterInfo;
+        }
+
+        protected override string Identifier => "parameter";
+
+        public AndWhichConstraint<ParameterInfoAssertions, TAttribute> BeDecoratedWith<TAttribute>(string because = "", params object[] becauseArgs)
+            where TAttribute : Attribute
+        {
+            var attribute = Subject.GetCustomAttribute<TAttribute>(false);
+
+            Execute.Assertion
+                .BecauseOf(because, becauseArgs)
+                .ForCondition(attribute != null)
+                .FailWith("Expected {0} {1} to be decorated with {2}{reason}, but that attribute was not found.",
+                Identifier, Subject, typeof(TAttribute).FullName);
+
+            return new AndWhichConstraint<ParameterInfoAssertions, TAttribute>(this, attribute);
+        }
+    }
+
+    public static class ParameterInfoAssertionExtensions
+    {
+        public static ParameterInfoAssertions Should(this ParameterInfo parameterInfo)
+        {
+            return new ParameterInfoAssertions(parameterInfo);
+        }
+    }
+}
diff --git a/BackEnd/Timeline.Tests/Helpers/ReflectionHelper.cs b/BackEnd/Timeline.Tests/Helpers/ReflectionHelper.cs
new file mode 100644
index 00000000..3f6036e3
--- /dev/null
+++ b/BackEnd/Timeline.Tests/Helpers/ReflectionHelper.cs
@@ -0,0 +1,13 @@
+using System.Linq;
+using System.Reflection;
+
+namespace Timeline.Tests.Helpers
+{
+    public static class ReflectionHelper
+    {
+        public static ParameterInfo GetParameter(this MethodInfo methodInfo, string name)
+        {
+            return methodInfo.GetParameters().Where(p => p.Name == name).Single();
+        }
+    }
+}
diff --git a/BackEnd/Timeline.Tests/Helpers/ResponseAssertions.cs b/BackEnd/Timeline.Tests/Helpers/ResponseAssertions.cs
new file mode 100644
index 00000000..024732f5
--- /dev/null
+++ b/BackEnd/Timeline.Tests/Helpers/ResponseAssertions.cs
@@ -0,0 +1,172 @@
+using FluentAssertions;
+using FluentAssertions.Execution;
+using FluentAssertions.Formatting;
+using FluentAssertions.Primitives;
+using System;
+using System.Globalization;
+using System.Net;
+using System.Net.Http;
+using System.Text;
+using System.Text.Json;
+using System.Text.Json.Serialization;
+using Timeline.Models.Converters;
+using Timeline.Models.Http;
+
+namespace Timeline.Tests.Helpers
+{
+    public class HttpResponseMessageValueFormatter : IValueFormatter
+    {
+        public bool CanHandle(object value)
+        {
+            return value is HttpResponseMessage;
+        }
+
+        public string Format(object value, FormattingContext context, FormatChild formatChild)
+        {
+            string newline = context.UseLineBreaks ? Environment.NewLine : "";
+            string padding = new string('\t', context.Depth);
+
+            var res = (HttpResponseMessage)value;
+
+            var builder = new StringBuilder();
+            builder.Append($"{newline}{padding} Status Code: {res.StatusCode} ; Body: ");
+
+            try
+            {
+                var task = res.Content.ReadAsStringAsync();
+                task.Wait();
+                var body = task.Result;
+                if (body.Length > 40)
+                {
+                    body = body[0..40] + " ...";
+                }
+                builder.Append(body);
+            }
+            catch (AggregateException)
+            {
+                builder.Append("NOT A STRING.");
+            }
+
+            return builder.ToString();
+        }
+    }
+
+    public class HttpResponseMessageAssertions
+            : ReferenceTypeAssertions<HttpResponseMessage, HttpResponseMessageAssertions>
+    {
+        static HttpResponseMessageAssertions()
+        {
+            Formatter.AddFormatter(new HttpResponseMessageValueFormatter());
+        }
+
+        public HttpResponseMessageAssertions(HttpResponseMessage instance)
+        {
+            Subject = instance;
+        }
+
+        protected override string Identifier => "HttpResponseMessage";
+
+        public AndConstraint<HttpResponseMessageAssertions> HaveStatusCode(int expected, string because = "", params object[] becauseArgs)
+        {
+            return HaveStatusCode((HttpStatusCode)expected, because, becauseArgs);
+        }
+
+        public AndConstraint<HttpResponseMessageAssertions> HaveStatusCode(HttpStatusCode expected, string because = "", params object[] becauseArgs)
+        {
+            Execute.Assertion.BecauseOf(because, becauseArgs)
+                .ForCondition(Subject.StatusCode == expected)
+                .FailWith("Expected status code of {context:HttpResponseMessage} to be {0}{reason}, but found {1}.", expected, Subject.StatusCode);
+            return new AndConstraint<HttpResponseMessageAssertions>(this);
+        }
+
+        public AndWhichConstraint<HttpResponseMessageAssertions, T> HaveJsonBody<T>(string because = "", params object[] becauseArgs)
+        {
+            var a = Execute.Assertion.BecauseOf(because, becauseArgs);
+            string body;
+            try
+            {
+                var task = Subject.Content.ReadAsStringAsync();
+                task.Wait();
+                body = task.Result;
+            }
+            catch (AggregateException e)
+            {
+                a.FailWith("Expected response body of {context:HttpResponseMessage} to be json string{reason}, but failed to read it or it was not a string. Exception is {0}.", e.InnerExceptions);
+                return new AndWhichConstraint<HttpResponseMessageAssertions, T>(this, null);
+            }
+
+
+            try
+            {
+                var options = new JsonSerializerOptions
+                {
+                    PropertyNamingPolicy = JsonNamingPolicy.CamelCase
+                };
+                options.Converters.Add(new JsonStringEnumConverter());
+                options.Converters.Add(new JsonDateTimeConverter());
+
+                var result = JsonSerializer.Deserialize<T>(body, options);
+
+                return new AndWhichConstraint<HttpResponseMessageAssertions, T>(this, result);
+            }
+            catch (JsonException e)
+            {
+                a.FailWith("Expected response body of {context:HttpResponseMessage} to be json string{reason}, but failed to deserialize it. Exception is {0}.", e);
+                return new AndWhichConstraint<HttpResponseMessageAssertions, T>(this, null);
+            }
+        }
+    }
+
+    public static class AssertionResponseExtensions
+    {
+        public static HttpResponseMessageAssertions Should(this HttpResponseMessage instance)
+        {
+            return new HttpResponseMessageAssertions(instance);
+        }
+
+        public static AndWhichConstraint<HttpResponseMessageAssertions, CommonResponse> HaveCommonBody(this HttpResponseMessageAssertions assertions, string because = "", params object[] becauseArgs)
+        {
+            return assertions.HaveJsonBody<CommonResponse>(because, becauseArgs);
+        }
+
+        public static void HaveCommonBody(this HttpResponseMessageAssertions assertions, int code, string message = null, params object[] messageArgs)
+        {
+            message = string.IsNullOrEmpty(message) ? "" : ", " + string.Format(CultureInfo.CurrentCulture, message, messageArgs);
+            var body = assertions.HaveCommonBody("Response body should be CommonResponse{0}", message).Which;
+            body.Code.Should().Be(code, "Response body code is not the specified one{0}", message);
+        }
+
+        public static AndWhichConstraint<HttpResponseMessageAssertions, CommonDataResponse<TData>> HaveCommonDataBody<TData>(this HttpResponseMessageAssertions assertions, string because = "", params object[] becauseArgs)
+        {
+            return assertions.HaveJsonBody<CommonDataResponse<TData>>(because, becauseArgs);
+        }
+
+        public static void BePut(this HttpResponseMessageAssertions assertions, bool create, string because = "", params object[] becauseArgs)
+        {
+            var body = assertions.HaveStatusCode(create ? 201 : 200, because, becauseArgs)
+                .And.HaveJsonBody<CommonPutResponse>(because, becauseArgs)
+                .Which;
+            body.Code.Should().Be(0);
+            body.Data.Create.Should().Be(create);
+        }
+
+        public static void BeDelete(this HttpResponseMessageAssertions assertions, bool delete, string because = "", params object[] becauseArgs)
+        {
+            var body = assertions.HaveStatusCode(200, because, becauseArgs)
+                .And.HaveJsonBody<CommonDeleteResponse>(because, becauseArgs)
+                .Which;
+            body.Code.Should().Be(0);
+            body.Data.Delete.Should().Be(delete);
+        }
+
+        public static void BeInvalidModel(this HttpResponseMessageAssertions assertions, string message = null)
+        {
+            message = string.IsNullOrEmpty(message) ? "" : ", " + message;
+            assertions.HaveStatusCode(400, "Invalid Model Error must have 400 status code{0}", message)
+                .And.HaveCommonBody("Invalid Model Error must have CommonResponse body{0}", message)
+                .Which.Code.Should().Be(ErrorCodes.Common.InvalidModel,
+                "Invalid Model Error must have code {0} in body{1}",
+                ErrorCodes.Common.InvalidModel, message);
+        }
+    }
+}
diff --git a/BackEnd/Timeline.Tests/Helpers/TestApplication.cs b/BackEnd/Timeline.Tests/Helpers/TestApplication.cs
new file mode 100644
index 00000000..684ffe2c
--- /dev/null
+++ b/BackEnd/Timeline.Tests/Helpers/TestApplication.cs
@@ -0,0 +1,72 @@
+using Microsoft.AspNetCore.Hosting;
+using Microsoft.AspNetCore.TestHost;
+using Microsoft.Data.Sqlite;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.Extensions.Configuration;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Hosting;
+using System.Collections.Generic;
+using System.IO;
+using System.Threading.Tasks;
+using Timeline.Configs;
+using Timeline.Entities;
+using Xunit;
+
+namespace Timeline.Tests.Helpers
+{
+    public class TestApplication : IAsyncLifetime
+    {
+        public TestDatabase Database { get; }
+
+        public IHost Host { get; private set; }
+
+        public string WorkDir { get; private set; }
+
+        public TestApplication()
+        {
+            Database = new TestDatabase(false);
+        }
+
+        public async Task InitializeAsync()
+        {
+            await Database.InitializeAsync();
+
+            WorkDir = Path.Combine(Path.GetTempPath(), Path.GetRandomFileName());
+            Directory.CreateDirectory(WorkDir);
+
+            Host = await Microsoft.Extensions.Hosting.Host.CreateDefaultBuilder()
+                .ConfigureAppConfiguration((context, config) =>
+                {
+                    config.AddInMemoryCollection(new Dictionary<string, string>
+                    {
+                        [ApplicationConfiguration.UseMockFrontEndKey] = "true",
+                        ["WorkDir"] = WorkDir
+                    });
+                })
+                .ConfigureServices(services =>
+                {
+                    services.AddDbContext<DatabaseContext>(options =>
+                    {
+                        options.UseSqlite(Database.Connection);
+                    });
+                })
+                .ConfigureWebHost(webBuilder =>
+                {
+                    webBuilder
+                        .UseTestServer()
+                        .UseStartup<Startup>();
+                })
+                .StartAsync();
+        }
+
+        public async Task DisposeAsync()
+        {
+            await Host.StopAsync();
+            Host.Dispose();
+
+            Directory.Delete(WorkDir, true);
+
+            await Database.DisposeAsync();
+        }
+    }
+}
diff --git a/BackEnd/Timeline.Tests/Helpers/TestClock.cs b/BackEnd/Timeline.Tests/Helpers/TestClock.cs
new file mode 100644
index 00000000..34adb245
--- /dev/null
+++ b/BackEnd/Timeline.Tests/Helpers/TestClock.cs
@@ -0,0 +1,43 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using Timeline.Services;
+
+namespace Timeline.Tests.Helpers
+{
+    public class TestClock : IClock
+    {
+        private DateTime? _currentTime;
+
+        public DateTime GetCurrentTime()
+        {
+            return _currentTime ?? DateTime.UtcNow;
+        }
+
+        public void SetCurrentTime(DateTime? mockTime)
+        {
+            _currentTime = mockTime;
+        }
+
+        public DateTime SetMockCurrentTime()
+        {
+            var time = new DateTime(3000, 1, 1, 1, 1, 1, DateTimeKind.Utc);
+            _currentTime = time;
+            return time;
+        }
+
+        public DateTime ForwardCurrentTime()
+        {
+            return ForwardCurrentTime(TimeSpan.FromDays(1));
+        }
+
+        public DateTime ForwardCurrentTime(TimeSpan timeSpan)
+        {
+            if (_currentTime == null)
+                return SetMockCurrentTime();
+            _currentTime += timeSpan;
+            return _currentTime.Value;
+        }
+    }
+}
diff --git a/BackEnd/Timeline.Tests/Helpers/TestDatabase.cs b/BackEnd/Timeline.Tests/Helpers/TestDatabase.cs
new file mode 100644
index 00000000..f0c26180
--- /dev/null
+++ b/BackEnd/Timeline.Tests/Helpers/TestDatabase.cs
@@ -0,0 +1,76 @@
+using Microsoft.Data.Sqlite;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.Extensions.Logging.Abstractions;
+using System.Threading.Tasks;
+using Timeline.Entities;
+using Timeline.Migrations;
+using Timeline.Models;
+using Timeline.Services;
+using Xunit;
+
+namespace Timeline.Tests.Helpers
+{
+    public class TestDatabase : IAsyncLifetime
+    {
+        private readonly bool _createUser;
+
+        public TestDatabase(bool createUser = true)
+        {
+            _createUser = createUser;
+            Connection = new SqliteConnection("Data Source=:memory:;");
+        }
+
+        public async Task InitializeAsync()
+        {
+            await Connection.OpenAsync();
+
+            using (var context = CreateContext())
+            {
+                await context.Database.EnsureCreatedAsync();
+                context.JwtToken.Add(new JwtTokenEntity
+                {
+                    Key = JwtTokenGenerateHelper.GenerateKey()
+                });
+                await context.SaveChangesAsync();
+
+                if (_createUser)
+                {
+                    var passwordService = new PasswordService();
+                    var userService = new UserService(NullLogger<UserService>.Instance, context, passwordService, new Clock());
+
+                    await userService.CreateUser(new User
+                    {
+                        Username = "admin",
+                        Password = "adminpw",
+                        Administrator = true,
+                        Nickname = "administrator"
+                    });
+
+                    await userService.CreateUser(new User
+                    {
+                        Username = "user",
+                        Password = "userpw",
+                        Administrator = false,
+                        Nickname = "imuser"
+                    });
+                }
+            }
+        }
+
+        public async Task DisposeAsync()
+        {
+            await Connection.CloseAsync();
+            await Connection.DisposeAsync();
+        }
+
+        public SqliteConnection Connection { get; }
+
+        public DatabaseContext CreateContext()
+        {
+            var options = new DbContextOptionsBuilder<DatabaseContext>()
+                .UseSqlite(Connection).Options;
+
+            return new DatabaseContext(options);
+        }
+    }
+}