private HttpResponseMessage SendRequest()
{
var requestBuilder = new RequestBuilder(_app.Server, _path);
if (_method == HttpMethod.Post)
{
var tokens = AntiForgeryRequestTokens.GetFromApplication(_app);
if (_postForm != null)
{
var dic = new Dictionary <string, string>(_postForm);
requestBuilder.And(req =>
{
dic["__RequestVerificationToken"] = tokens.VerificationToken;
var content = new FormUrlEncodedContent(dic);
content.Headers.ContentType = new MediaTypeHeaderValue(_contentType);
req.Content = content;
})
.WithCookie(tokens.Cookie);
}
else
{
requestBuilder.AddHeader("RequestVerificationToken", tokens.VerificationToken);
if (_postEntity != null)
{
requestBuilder.And(req =>
{
var content = new ByteArrayContent(_postEntity);
content.Headers.ContentType = new MediaTypeHeaderValue(_contentType);
req.Content = content;
});
}
requestBuilder.WithCookie(tokens.Cookie);
}
}
if (_headers.Any())
{
_headers.Keys.ToList().ForEach(key => requestBuilder.AddHeader(key, _headers[key]));
}
if (_cookies.Any())
{
_cookies.ForEach(c => requestBuilder.WithCookie(c.Name.ToString(), c.Value.ToString()));
}
var response = requestBuilder.SendAsync(_method.ToString().ToUpper()).Result;
_app.ResetUser();
return(response);
}
public static RequestBuilder WithFormContent(this RequestBuilder request, Dictionary <string, string> obj)
{
return(request.And(req =>
{
req.Content = new FormUrlEncodedContent(obj);
}));
}
public static RequestBuilder AddAsJson <T>(this RequestBuilder requestBuilder, T value)
{
requestBuilder.AddHeader("Accept", "application/json");
requestBuilder.And(r => r.Content = new ObjectContent <T>(value, new JsonMediaTypeFormatter()));
return(requestBuilder);
}
public static RequestBuilder WithJsonContent <T>(this RequestBuilder requestBuilder, T data)
{
var dataAsString = JsonConvert.SerializeObject(data);
var content = new StringContent(dataAsString, Encoding.UTF8, "application/json");
return(requestBuilder.And(p => p.Content = content));
}
public static RequestBuilder Json(this RequestBuilder builder, object content)
{
return(builder.And(m =>
{
m.Content = new StringContent(JsonConvert.SerializeObject(content), Encoding.UTF8, "application/json");
}));
}
public static RequestBuilder WithJsonContent(this RequestBuilder request, object obj)
{
return(request.And(req =>
{
var json = JsonConvert.SerializeObject(obj);
req.Content = new StringContent(json);
req.Content.Headers.ContentType = new MediaTypeHeaderValue("application/json");
}));
}
public static RequestBuilder WithContent(this RequestBuilder requestBuilder, object data)
{
var serializedData = JsonConvert.SerializeObject(data);
requestBuilder
.And(x => x.Content = new StringContent(serializedData, Encoding.UTF8, "application/json"));
return(requestBuilder);
}
public static RequestBuilder WithJsonBody <TContent>(this RequestBuilder builder, TContent content, string contentType = "application/json")
{
var json = JsonConvert.SerializeObject(content);
return(builder.And(message =>
{
message.Content = new StringContent(json, Encoding.UTF8, contentType);
}));
}
public static RequestBuilder UseJsonBody <TModel>(this RequestBuilder builder, TModel body)
{
string bodyAsString = JsonConvert.SerializeObject(body);
builder.And(req =>
{
req.Content = new StringContent(bodyAsString, Encoding.UTF8, "application/json");
});
return(builder);
}
private async Task <HttpResponseMessage> Send(
HttpMethod method,
string path,
object?model = null)
{
RequestBuilder requestBuilder = this.SetupFixture.Setup.TestServer.CreateRequest(Invariant($"/api/{path}"));
if (model != null)
{
requestBuilder.And(
m => m.Content = new StringContent(model.ToJson(), Encoding.UTF8, "application/json"));
}
return(await requestBuilder.SendAsync(method.ToString()));
}
/// <summary>
/// 2
/// </summary>
/// <param name="props"></param>
/// <param name="requestBuilder"></param>
public static void FillRequestBuilderFromProperties(IBasicProperties props, RequestBuilder requestBuilder)
{
requestBuilder.And(it =>
{
if (props.Headers["AMQP_CONTENTTYPE"] != null)
{
it.Content.Headers.ContentType = MediaTypeHeaderValue.Parse(props.Headers["AMQP_CONTENTTYPE"].UTF8GetString());
it.Content.Headers.ContentLength = (long)props.Headers["AMQP_CONTENTLENGTH"];
}
});
foreach (var header in props.Headers)
{
if (!header.Key.StartsWith("AMQP_"))
{
requestBuilder.AddHeader(header.Key, header.Value.UTF8GetString());
}
}
}
public static RequestBuilder WithJsonBody(this RequestBuilder builder, object value) =>
builder.And(req => req.Content = new StringContent(
JsonConvert.SerializeObject(value),
Encoding.UTF8,
"application/json"));
internal static RequestBuilder AddBody(this RequestBuilder builder, int size)
{
return(builder.And(m => m.AddBody(size)));
}
internal static RequestBuilder AddBody(this RequestBuilder builder, string contentType)
{
return(builder.And(m => m.AddBody(contentType)));
}
public static RequestBuilder AndJsonBody <TBody>(this RequestBuilder source, TBody body)
{
var json = JsonSerializer.Serialize(body);
return(source.And(v => v.Content = new StringContent(json, Encoding.UTF8, "application/json")));
}
public static byte[] PostAndGetByteArray(this RequestBuilder builder, StringKeyValuePairCollection nameValueCollection)
{
return(builder.And(x => x.Content = new FormUrlEncodedContent(nameValueCollection))
.PostAsync().Result.EnsureSuccessStatusCode().Content.ReadAsByteArrayAsync().Result);
}
public static async Task <HttpResponseMessage> PutAsync <TModel>(this RequestBuilder builder, TModel model)
{
return(await builder
.And(request => request.Content = new ObjectContent <TModel>(model, DefaultJsonMediaTypeFormatter))
.SendAsync("PUT"));
}
