public async void Get_Unauthorized(string url)
{
var client = _factory.CreateClient();
var response = await client.GetAsync(url);
Assert.True(response.StatusCode == HttpStatusCode.Unauthorized);
}
public async Task Test_Get_Events()
{
var client = _factory.CreateClient();
var response = await client.GetAsync("cmaapi/1/resources/school-messenger.events");
response.EnsureSuccessStatusCode();
Assert.Equal(HttpStatusCode.NoContent, response.StatusCode);
}
public async Task WhenUserValid_OK()
{
using var app = _webApplicationFactory.CreateApp();
using var client = _webApplicationFactory.CreateClient();
await client.ImpersonateUserAsync(app.SeededEntities.TestUserArea2.RoleA.User);
var result = await client.GetAsync(GetRoute("user-area"));
result.StatusCode.Should().Be(HttpStatusCode.OK);
}
public async Task Get_Couriers_Empty()
{
var client = _webApplicationFactory.CreateClient();
var response = await client.GetAsync(COURIER_URL);
response.EnsureSuccessStatusCode();
Expect.Equal("application/json; charset=utf-8", response.Content.Headers.ContentType.ToString());
var responseString = await response.Content.ReadAsStringAsync();
Expect.Equal("[]", responseString);
}
public async Task Find_Success()
{
// Arrange
var client = _factory.CreateClient();
// Act
var response = await client.GetAsync(Uri);
// Assert
response.StatusCode.Should().Be(HttpStatusCode.OK);
var result = await response.Content.ReadAsAsync <OffsetPaged <CategoryDto> >();
result.Data.Should().NotBeNullOrEmpty();
}
public BaseIntegrationTest()
{
var factory = new TestWebApplicationFactory <Startup>();
Client = factory.CreateClient();
DataContext = factory.DataContext ?? throw new Exception("Failed to initialise the test data context");
}
public async Task DecodeRelaxedWhenEncodingIsSupported()
{
await using var factory = new TestWebApplicationFactory <TestWebApplicationStartup>()
.WithWebHostBuilder(builder =>
{
builder.ConfigureTestServices(services =>
{
services.AddRequestDecompression();
});
});
using var client = factory.CreateClient();
var requestString = "Hello World!";
var requestContent = new ByteArrayContent(AsBrotliEncodedByteArray(requestString));
requestContent.Headers.ContentEncoding.Add("br");
var responseMessage = await client.PostAsync("/", requestContent);
var responseString = await responseMessage.Content.ReadAsStringAsync();
responseMessage.Headers.TryGetValues(HeaderNames.AcceptEncoding, out var acceptEncoding);
Assert.AreEqual(HttpStatusCode.OK, responseMessage.StatusCode);
Assert.AreEqual(requestString, responseString);
Assert.IsNull(acceptEncoding);
}
private HttpClient GetClient(Boolean redirects = true)
{
return(_factory.CreateClient(new WebApplicationFactoryClientOptions
{
AllowAutoRedirect = redirects
}));
}
protected async Task <HttpResponseMessage> DoRequestAsync(
string url,
string method = "Get",
string requestBody = null,
string requestContentType = "application/json",
dynamic requestHeaders = null)
{
var client = Factory.CreateClient();
var httpMethod = new HttpMethod(method);
var request = new HttpRequestMessage(httpMethod, url);
if (!string.IsNullOrEmpty(requestBody))
{
request.Content = new StringContent(requestBody, Encoding.UTF8, requestContentType);
}
if (requestHeaders != null)
{
foreach (var header in requestHeaders)
{
request.Headers.Add(header.Key, header.Value);
}
}
return(await client.SendAsync(request));
}
private HttpClient GetDefaultClient()
{
var client = TestWebApplicationFactory
.CreateClient();
return(client);
}
public async Task CreateAsync_UsingNoJsonWebToken_ReturnsUnauthorizedHttpStatusCode()
{
// Arrange
using HttpClient httpClient = webApplicationFactory.CreateClient();
var newTodoItemModel = new NewTodoItemModel();
// Act
HttpResponseMessage response = await httpClient.PostAsJsonAsync(BaseUrl, newTodoItemModel);
// Assert
using (new AssertionScope())
{
response.IsSuccessStatusCode.Should().BeFalse(BecauseCurrentRequestHasNoJwt);
response.StatusCode.Should().Be(HttpStatusCode.Unauthorized, BecauseCurrentRequestHasNoJwt);
}
}
public async Task DecodeRelaxedWhenEncodingIsNotSupportedAndAdvertized()
{
await using var factory = new TestWebApplicationFactory <TestWebApplicationStartup>()
.WithWebHostBuilder(builder =>
{
builder.ConfigureTestServices(services =>
{
services.AddRequestDecompression(options =>
{
Assert.IsTrue(options.AllowUnsupportedEncodings);
Assert.IsFalse(options.AdvertiseSupportedEncodings);
options.AdvertiseSupportedEncodings = true;
});
});
});
using var client = factory.CreateClient();
var requestString = "Hello World!";
var requestContent = new StringContent(requestString);
requestContent.Headers.ContentEncoding.Add("deflate");
var responseMessage = await client.PostAsync("/", requestContent);
var responseString = await responseMessage.Content.ReadAsStringAsync();
responseMessage.Headers.TryGetValues(HeaderNames.AcceptEncoding, out var acceptEncoding);
Assert.AreEqual(HttpStatusCode.OK, responseMessage.StatusCode);
Assert.IsNull(acceptEncoding);
}
public async Task PermissionOnAnonymousRole_WhenNotSignedIn_OK()
{
using var app = _webApplicationFactory.CreateApp();
using var client = _webApplicationFactory.CreateClient();
var result = await client.GetAsync(GetRoute("permission-on-anonymous-role"));
result.StatusCode.Should().Be(HttpStatusCode.OK);
}
protected CRUDClient(TestWebApplicationFactory <Startup> factory, string relativeUrl)
{
_client = factory.CreateClient(new WebApplicationFactoryClientOptions
{
AllowAutoRedirect = false
});
absoluteUri = new Uri(_client.BaseAddress, relativeUrl);
}
public WidgetTest(TestWebApplicationFactory <Startup> fixture, ITestOutputHelper testOutputHelper)
{
this.fixture = fixture;
this.testOutputHelper = testOutputHelper;
testServerClient = fixture.CreateClient(new WebApplicationFactoryClientOptions {
AllowAutoRedirect = false
});
}
public async Task Get_Valid_Diff()
{
double difference = await _sensorService.GetDifferenceAsync("000D6F0003141E14");
var expectedResult = new DiffResponse("Success", difference);
var client = _webApplicationFactory.CreateClient();
var response = await client.GetAsync(@"https://localhost:44338/api/diff/000D6F0003141E14");
response.EnsureSuccessStatusCode();
Expect.Equal("application/json; charset=utf-8", response.Content.Headers.ContentType.ToString());
var responseString = await response.Content.ReadAsStringAsync();
Expect.DeepEqualLowerCaseFields(expectedResult, responseString);
}
public async Task Test_Health_Checker()
{
var client = _factory.CreateClient();
var response = await client.GetAsync("api/health/ping");
response.EnsureSuccessStatusCode();
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
}
public async Task Test_Channel_Get()
{
var client = _factory.CreateClient();
var response = await client.GetAsync("cmaapi/1/channels");
response.EnsureSuccessStatusCode();
Assert.Equal(HttpStatusCode.NoContent, response.StatusCode);
}
public async Task Test_ChannelToGroup()
{
var client = _factory.CreateClient();
var response = await client.GetAsync("cmaapi/1/shoutem/integration/5/groups?baseurl=http://localhost/");
response.EnsureSuccessStatusCode();
Assert.Equal(HttpStatusCode.NoContent, response.StatusCode);
}
public EstimateTaskControllerTest(TestWebApplicationFactory <DocumentsKM.Startup> factory)
{
_httpClient = factory.WithWebHostBuilder(builder =>
{
builder.ConfigureTestServices(services =>
{
services.AddSingleton <IPolicyEvaluator, FakePolicyEvaluator>();
});
}).CreateClient();
_authHttpClient = factory.CreateClient();
}
public void Scenario_Combat_0001_MagnetoVsWolverine_MagnetoWins(HttpResponseMessage response)
{
$"When combat between Magneto and Wolverine"
.x(async() => response = await factory.CreateClient().GetAsync("api/combat?attacker=Magneto&defender=Wolverine"));
"Then winner is Magneto".x(async() =>
{
response.EnsureSuccessStatusCode();
var result = await response.Content.ReadAsAsync <CombatResult>();
Assert.Equal("Magneto", result.Winner);
});
}
public async Task Combat_0002_AnyMutant_ReturnsCopiright()
{
// arrange
var client = factory.CreateClient();
// act
var response = await client.GetAsync("api/combat?attacker=Magneto&defender=Xavier");
// assert
response.EnsureSuccessStatusCode();
var result = await response.Content.ReadAsAsync <CombatResult>();
Assert.Equal("Aleksandr Kugushev 42", result.Copyright);
}
public async Task Create_NoAuthentication_Unauthorized()
{
// Arrange
var client = _factory.CreateClient();
var command = new CreateReviewCommand {
Title = "Test no authentication"
};
// Act
var response = await client.PostAsJsonAsync(Uri, command);
// Assert
response.StatusCode.Should().Be(HttpStatusCode.Unauthorized);
}
public async Task Get_Sensors()
{
var client = _webApplicationFactory.CreateClient();
var response = await client.GetAsync("https://localhost:44338/api/summary");
var expectedResult = new SummaryResponse("Success", await _sensorService.GetSummaryAsync());
response.EnsureSuccessStatusCode();
Expect.Equal("application/json; charset=utf-8", response.Content.Headers.ContentType.ToString());
var responseString = await response.Content.ReadAsStringAsync();
Expect.DeepEqualLowerCaseFields(expectedResult, responseString);
}
// NOTE this is not an established Fact; it fails
// [Fact]
public async Task TestWatchFunctionSuccess()
{
// Arrange
var client = _factory.CreateClient();
var request = new HttpRequestMessage();
var queryString = QueryString.Create("model", "any");
request.RequestUri = new Uri("/" + queryString);
// Act
var response = await client.SendAsync(request);
// Assert
Assert.True(response.IsSuccessStatusCode);
}
public FileControllerTests(TestWebApplicationFactory <Startup> factory)
{
_authenticationContext = new AuthenticationContext
{
EmailKey = "Input.Email",
EmailValue = "*****@*****.**",
PasswordKey = "Input.Password",
PasswordValue = "demo",
LoginUri = "Account/login?returnUrl=/admin"
};
_factory = factory;
_client = _factory.CreateClient(new WebApplicationFactoryClientOptions {
AllowAutoRedirect = false
});
}
// Define your mocks here so you can access them in your test classes
// fe: public readonly Mock<IMocked> MockedMock;
public TestBaseFixture()
{
this.factory = new TestWebApplicationFactory <StarterKit.Startup.Startup>();
// Transaction scope is running into issues in .net core 3.1
// https://github.com/dotnet/aspnetcore/issues/18001
factory.Server.PreserveExecutionContext = true;
this.Client = factory.CreateClient();
using var scope = factory.Server.Host.Services.CreateScope();
this.serviceProvider = factory.Server.Host.Services;
// Initialize your mock in scope. Helper method AddMock will get the required mock from the service.
// this.MockedMock = AddMock<IMocked>(scope);
}
internal TokenResponse GetToken(string username, string password, string clientId, string clientSecret)
{
var client = Factory.CreateClient();
using (var response = client.PostAsync("Token",
new TokenRequest(username, password, clientId, clientSecret).ToFormUrlContent())
.Result)
{
var responseContent = response.Content?.ReadAsStringAsync().Result;
var responseJToken = responseContent != "" ? JToken.Parse(responseContent) : null;
if (!response.IsSuccessStatusCode)
{
throw new Exception($"{response.StatusCode},未能获取数据", null);
}
var result = responseJToken?.ToObject <TokenResponse>();
return(result);
}
}
public void Setup()
{
_factory = new TestWebApplicationFactory();
_client = _factory.CreateClient(new WebApplicationFactoryClientOptions
{
// here some sample options like security tokens etc...
});
var services = _factory.Server.Host.Services;
_context = services.GetRequiredService <ApplicationDbContext>();
_mapper = services.GetRequiredService <IMapper>();
var databaseInitializer = services.GetRequiredService <IDatabaseInitializer>();
databaseInitializer.SeedAsync().Wait();
JsonConvert.DefaultSettings = () => new JsonSerializerSettings
{
ReferenceLoopHandling = ReferenceLoopHandling.Ignore
};
}
public DefaultApiBehaviorTests(TestWebApplicationFactory <DefaultApiBehaviorStartup> factory)
{
_ = factory ?? throw new ArgumentNullException(nameof(factory));
_client = factory.CreateClient();
}
