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);
        }
Exemplo n.º 2
0
 public static RequestBuilder WithFormContent(this RequestBuilder request, Dictionary <string, string> obj)
 {
     return(request.And(req =>
     {
         req.Content = new FormUrlEncodedContent(obj);
     }));
 }
Exemplo n.º 3
0
        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);
        }
Exemplo n.º 4
0
        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));
        }
Exemplo n.º 5
0
 public static RequestBuilder Json(this RequestBuilder builder, object content)
 {
     return(builder.And(m =>
     {
         m.Content = new StringContent(JsonConvert.SerializeObject(content), Encoding.UTF8, "application/json");
     }));
 }
Exemplo n.º 6
0
 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");
     }));
 }
Exemplo n.º 7
0
        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);
        }
Exemplo n.º 8
0
        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);
            }));
        }
Exemplo n.º 9
0
        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);
        }
Exemplo n.º 10
0
        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()));
        }
Exemplo n.º 11
0
        /// <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());
                }
            }
        }
Exemplo n.º 12
0
 public static RequestBuilder WithJsonBody(this RequestBuilder builder, object value) =>
 builder.And(req => req.Content = new StringContent(
                 JsonConvert.SerializeObject(value),
                 Encoding.UTF8,
                 "application/json"));
Exemplo n.º 13
0
 internal static RequestBuilder AddBody(this RequestBuilder builder, int size)
 {
     return(builder.And(m => m.AddBody(size)));
 }
Exemplo n.º 14
0
 internal static RequestBuilder AddBody(this RequestBuilder builder, string contentType)
 {
     return(builder.And(m => m.AddBody(contentType)));
 }
Exemplo n.º 15
0
        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")));
        }
Exemplo n.º 16
0
 public static byte[] PostAndGetByteArray(this RequestBuilder builder, StringKeyValuePairCollection nameValueCollection)
 {
     return(builder.And(x => x.Content = new FormUrlEncodedContent(nameValueCollection))
            .PostAsync().Result.EnsureSuccessStatusCode().Content.ReadAsByteArrayAsync().Result);
 }
Exemplo n.º 17
0
 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"));
 }