1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
|
using System;
using System.Net.Http;
using System.Threading.Tasks;
using Microsoft.AspNetCore.TestHost;
using Microsoft.Extensions.DependencyInjection;
using Timeline.Models.Http;
using Timeline.Services.User;
using Timeline.Tests.Helpers;
using Xunit;
using Xunit.Abstractions;
namespace Timeline.Tests.IntegratedTests2
{
public abstract class IntegratedTestBase : IAsyncLifetime
{
protected TestApplication TestApp { get; }
protected int TestUserCount { get; }
protected string NormalUserToken { get; set; } = default!;
protected string AdminUserToken { get; set; } = default!;
protected HttpClient DefaultClient { get; set; } = default!;
protected HttpClient UserClient { get; set; } = default!;
protected HttpClient AdminClient { get; set; } = default!;
public IntegratedTestBase(ITestOutputHelper testOutputHelper) : this(1, testOutputHelper)
{
}
public IntegratedTestBase(int userCount, ITestOutputHelper testOutputHelper)
{
if (userCount < 0)
throw new ArgumentOutOfRangeException(nameof(userCount), userCount, "User count can't be negative.");
TestUserCount = userCount;
TestApp = new TestApplication(testOutputHelper);
}
protected virtual Task OnInitializeAsync()
{
return Task.CompletedTask;
}
protected virtual Task OnDisposeAsync()
{
return Task.CompletedTask;
}
protected virtual void OnInitialize()
{
}
protected virtual void OnDispose()
{
}
private async Task CreateInitUsersAsync()
{
using var scope = TestApp.Host.Services.CreateScope();
var userService = scope.ServiceProvider.GetRequiredService<IUserService>();
var userPermissionService = scope.ServiceProvider.GetRequiredService<IUserPermissionService>();
var admin = await userService.CreateUserAsync(new CreateUserParams("admin", "adminpw"));
foreach (var permission in Enum.GetValues<UserPermission>())
{
await userPermissionService.AddPermissionToUserAsync(admin.Id, permission);
}
await userService.CreateUserAsync(new CreateUserParams("user", "userpw"));
}
public async Task CreateUserAsync(string username, string password)
{
using var scope = TestApp.Host.Services.CreateScope();
var userService = scope.ServiceProvider.GetRequiredService<IUserService>();
await userService.CreateUserAsync(new CreateUserParams(username, password));
}
public async Task InitializeAsync()
{
await TestApp.InitializeAsync();
await CreateInitUsersAsync();
NormalUserToken = await CreateTokenWithCredentialAsync("user", "userpw");
AdminUserToken = await CreateTokenWithCredentialAsync("admin", "adminpw");
DefaultClient = CreateDefaultClient();
UserClient = CreateClientAsUser();
AdminClient = CreateClientAsAdmin();
await OnInitializeAsync();
OnInitialize();
}
public async Task DisposeAsync()
{
await OnDisposeAsync();
OnDispose();
DefaultClient.Dispose();
UserClient.Dispose();
AdminClient.Dispose();
await TestApp.DisposeAsync();
}
public HttpClient CreateDefaultClient(bool setApiBase = true)
{
var client = TestApp.Host.GetTestServer().CreateClient();
if (setApiBase)
{
client.BaseAddress = new Uri(client.BaseAddress!, "api/");
}
return client;
}
public async Task<string> CreateTokenWithCredentialAsync(string username, string password)
{
var client = CreateDefaultClient();
var res = await client.TestJsonSendAsync<HttpCreateTokenResponse>(HttpMethod.Post, "token/create",
new HttpCreateTokenRequest { Username = username, Password = password });
return res.Token;
}
public HttpClient CreateClientWithToken(string token, bool setApiBase = true)
{
var client = CreateDefaultClient(setApiBase);
client.DefaultRequestHeaders.Add("Authorization", "Bearer " + token);
return client;
}
public HttpClient CreateClientAsAdmin()
{
return CreateClientWithToken(AdminUserToken);
}
public HttpClient CreateClientAsUser()
{
return CreateClientWithToken(NormalUserToken);
}
}
}
|
