public void SetsContentNullIfBodyValueIsNull()
 {
     var requestInfo = new RequestInfo(HttpMethod.Get, "foo");
     requestInfo.SetBodyParameterInfo<object>(BodySerializationMethod.Serialized, null);
     var content = this.requester.ConstructContent(requestInfo);
     Assert.Null(content);
 }

 public void ConstructsUriWithEscapedGivenParams()
 {
     var requestInfo = new RequestInfo(HttpMethod.Get, null);
     requestInfo.AddQueryParameter(QuerySerializationMethod.ToString, "b ar", "b az");
     var uri = this.requester.ConstructUri("/foo", requestInfo);
     Assert.Equal(new Uri("http://api.example.com/base/foo?b+ar=b+az"), uri);
 }

        public override void Request(RequestLocalOptions opt, Message req, Action<Message> on_rpy)
        {
            string id;
            string is_closed;
            lock (state_lock) {
                id = (nextid++).ToString ();
                is_closed = closed_err;
                if (is_closed == null) {
                    pending [id] = new RequestInfo {
                        cb = on_rpy,
                        timeout = new Timer ((s) => {
                            RequestTimedOut (id);
                        }, null, (opt.Timeout + 5) * 1000, Timeout.Infinite),
                    };
                }
            }

            if (is_closed != null) {
                req.Discard ();
                Message.StreamToCallback (on_rpy, new RPCException ("transport", "Connection is closed", RPCException.DispatchFailure ()).AsHeader ());
            } else {
                req.Header ["request_id"] = id;
                req.Header ["type"] = "request";
                p.SendMessage (req);
            }
        }

        public void HeadersFromPropertiesCombineWithHeadersFromClass()
        {
            var requestInfo = new RequestInfo(HttpMethod.Get, "foo");
            requestInfo.ClassHeaders = new List<KeyValuePair<string, string>>()
            {
                new KeyValuePair<string, string>("This-Will-Stay", "YesIWill"),
                new KeyValuePair<string, string>("Something", "SomethingElse"),
                new KeyValuePair<string, string>("User-Agent", "RestEase"),
                new KeyValuePair<string, string>("X-API-Key", "Foo"),
            };

            requestInfo.AddPropertyHeader<string>("Something", null, null);
            requestInfo.AddPropertyHeader("User-Agent", String.Empty, null);
            requestInfo.AddPropertyHeader("X-API-Key", "Bar", null);
            requestInfo.AddPropertyHeader("This-Is-New", "YesIAm", null);

            var message = new HttpRequestMessage();
            this.requester.ApplyHeaders(requestInfo, message);

            Assert.Equal(new[] { "YesIWill" }, message.Headers.GetValues("This-Will-Stay"));
            Assert.Equal(new[] { "SomethingElse" }, message.Headers.GetValues("Something"));
            Assert.Equal(new[] { "RestEase", "" }, message.Headers.GetValues("User-Agent"));
            Assert.Equal(new[] { "Foo", "Bar" }, message.Headers.GetValues("X-API-Key"));
            Assert.Equal(new[] { "YesIAm" }, message.Headers.GetValues("This-Is-New"));
        }

        public void RequestAsyncSendsRequest()
        {
            var requester = new RequesterWithStubbedSendRequestAsync(null);
            var responseMessage = new HttpResponseMessage()
            {
                Content = new StringContent("content"),
            };
            requester.ResponseMessage = Task.FromResult(responseMessage);
            var responseDeserializer = new Mock<IResponseDeserializer>();
            requester.ResponseDeserializer = responseDeserializer.Object;
            var cancellationToken = new CancellationToken();

            responseDeserializer.Setup(x => x.Deserialize<string>("content", responseMessage))
                .Returns("hello")
                .Verifiable();

            var requestInfo = new RequestInfo(HttpMethod.Get, "foo");
            requestInfo.CancellationToken = cancellationToken;
            var result = requester.RequestAsync<string>(requestInfo).Result;

            responseDeserializer.Verify();

            Assert.Equal(requestInfo, requester.RequestInfo);
            Assert.Equal("hello", result);
        }

 public HttpResponseMessage Get()
 {
     string dsName = (string)Request.Properties[Constants.ODataDataSource];
     var ds = DataSourceProvider.GetDataSource(dsName);
     var options = BuildQueryOptions();
     EdmEntityObjectCollection rtv = null;
     if (DynamicOData.BeforeExcute != null)
     {
         var ri = new RequestInfo(dsName)
         {
             Method = MethodType.Get,
             QueryOptions = options,
             Target = options.Context.Path.Segments[0].ToString()
         };
         DynamicOData.BeforeExcute(ri);
         if (!ri.Result)
             return Request.CreateResponse(ri.StatusCode, ri.Message);
     }
     try
     {
         rtv = ds.Get(options);
         if (options.SelectExpand != null)
             Request.ODataProperties().SelectExpandClause = options.SelectExpand.SelectExpandClause;
         return Request.CreateResponse(HttpStatusCode.OK, rtv);
     }
     catch (UnauthorizedAccessException ex)
     {
         return Request.CreateErrorResponse(HttpStatusCode.Unauthorized, ex);
     }
     catch (Exception err)
     {
         return Request.CreateErrorResponse(HttpStatusCode.InternalServerError, err);
     }
 }

 public void GNTPParserTest()
 {
     var pw = new PasswordManager();
     var info = new RequestInfo();
     var parser = new GNTPParser(pw, false, true, true, true, info);
     var items = new List<IGNTPRequest>();
     parser.MessageParsed += (req) =>
     {
         items.Add(req);
     };
     parser.Error += (error) =>
     {
         Assert.Fail("ErrorCode={0}, Description={1}", error.ErrorCode, error.ErrorDescription);
     };
     ParseAll(parser);
     Assert.IsTrue(items.Count > 0);
     foreach (var item in items) {
         if (item.Directive == RequestType.NOTIFY) {
             var nLog = NeithNotificationRec.FromHeaders(item.Headers);
         }
         if (item.Directive == RequestType.REGISTER) {
             var app = Application.FromHeaders(item.Headers);
             Assert.AreEqual("SurfWriter", app.Name);
         }
     }
 }

 public void EncodesPathParams()
 {
     var requestInfo = new RequestInfo(HttpMethod.Get, "/foo/{bar}/baz");
     requestInfo.AddPathParameter<string>("bar", "a/b/c");
     var uri = this.requester.SubstitutePathParameters(requestInfo);
     Assert.Equal("/foo/a%2fb%2fc/baz", uri);
 }

 public HttpResponseMessage Delete(string key)
 {
     var path = Request.ODataProperties().Path;
     var edmType = path.Segments[0].GetEdmType(path.EdmType);
     string dsName = (string)Request.Properties[Constants.ODataDataSource];
     var ds = DataSourceProvider.GetDataSource(dsName);
     if (DynamicOData.BeforeExcute != null)
     {
         var ri = new RequestInfo(dsName)
         {
             Method = MethodType.Delete,
             Target = (edmType as EdmEntityType).Name
         };
         DynamicOData.BeforeExcute(ri);
         if (!ri.Result)
             return Request.CreateResponse(ri.StatusCode, ri.Message);
     }
     try
     {
         var count = ds.Delete(key, edmType);
         return Request.CreateResponse(HttpStatusCode.OK, count);
     }
     catch (UnauthorizedAccessException ex)
     {
         return Request.CreateErrorResponse(HttpStatusCode.Unauthorized, ex);
     }
     catch (Exception err)
     {
         return Request.CreateErrorResponse(HttpStatusCode.InternalServerError, err);
     }
 }

        internal ArgumentBindingContext(RequestInfo request, RequestMapping requestMapping, ParameterInfo parameter, int index, IDictionary<RequestInfo, RequestInfo[]> multipartBodies)
        {
            if (request == null)
            {
                throw new ArgumentNullException("request");
            }

            if (requestMapping == null)
            {
                throw new ArgumentNullException("requestMapping");
            }

            if (parameter == null)
            {
                throw new ArgumentNullException("parameter");
            }

            if (multipartBodies == null)
            {
                throw new ArgumentNullException("multipartBodies");
            }

            Request = request;
            RequestMapping = requestMapping;
            Parameter = parameter;
            Index = index;
            MultipartBodies = multipartBodies;
        }

        public void Cache(RequestInfo requestInfo, string answer)
        {
            HashAnswer hashAnswer = new HashAnswer();
            hashAnswer.Answer = answer;
            hashAnswer.QuestionText = requestInfo.Data;

            var firstOrDefault = work.HandlerTypes.GetAll().FirstOrDefault(
                x => x.Name == requestInfo.HandlerName);

            if (firstOrDefault != null)
            {
                hashAnswer.HandlerTypeId = firstOrDefault.Id;
            }
            else
            {
                // Create handler type if note exists
                HandlerType handler = new HandlerType()
                {
                    Name = requestInfo.HandlerName
                };
                work.HandlerTypes.Create(handler);
                work.Save();
                hashAnswer.HandlerTypeId =
                    work.HandlerTypes.GetAll().First(x => x.Name == requestInfo.HandlerName).Id;
            }

            work.HashAnswers.Create(hashAnswer);
            work.Save();
        }

 public void IgnoresNullQueryParamArrayValuesWhenUsingToString()
 {
     var requestInfo = new RequestInfo(HttpMethod.Get, null);
     requestInfo.AddQueryCollectionParameter<object>(QuerySerializationMethod.ToString, "foo", new[] { "bar", null, "baz" });
     var uri = this.requester.ConstructUri("/foo", requestInfo);
     Assert.Equal(new Uri("http://api.example.com/base/foo?foo=bar&foo=baz"), uri);
 }

 public HttpResponse Execute(RequestInfo req)
 {
     var o = Activator.CreateInstance(_mi.DeclaringType);
     var prms = new object[_binders.Length];
     for(var i = 0 ; i<_binders.Length ; ++i)
     {
         prms[i] = _binders[i](req);
     }
     try
     {
         return _mi.Invoke(o, prms) as HttpResponse;
     }
     catch (TargetInvocationException e)
     {
         throw e.InnerException;
     }
     catch(ArgumentException e)
     {
         return new HttpResponse(HttpStatusCode.BadRequest, new TextContent(e.Message));
     }
     catch(InvalidOperationException e)
     {
         return new HttpResponse(HttpStatusCode.InternalServerError, new TextContent(e.Message));
     }
 }

 public void SetsContentNullIfBodyParameterInfoNull()
 {
     var requestInfo = new RequestInfo(HttpMethod.Get, "foo");
     // Not calling SetBodyParameterInfo
     var content = this.requester.ConstructContent(requestInfo);
     Assert.Null(content);
 }

        /// <summary>
        /// Adds the request info to the event.
        /// </summary>
        public static void AddRequestInfo(this Event ev, RequestInfo request)
        {
            if (request == null)
                return;

            ev.Data[Event.KnownDataKeys.RequestInfo] = request;
        }

        internal ChannelHandler(MessageVersion messageVersion, IChannelBinder binder, ServiceChannel channel)
        {
            ClientRuntime clientRuntime = channel.ClientRuntime;

            _messageVersion = messageVersion;
            _isManualAddressing = clientRuntime.ManualAddressing;
            _binder = binder;
            _channel = channel;

            _isConcurrent = true;
            _duplexBinder = binder as DuplexChannelBinder;
            _hasSession = binder.HasSession;
            _isCallback = true;

            DispatchRuntime dispatchRuntime = clientRuntime.DispatchRuntime;
            if (dispatchRuntime == null)
            {
                _receiver = new ErrorHandlingReceiver(binder, null);
            }
            else
            {
                _receiver = new ErrorHandlingReceiver(binder, dispatchRuntime.ChannelDispatcher);
            }
            _requestInfo = new RequestInfo(this);
        }

 public void TreatsNullPathParamsAsEmpty()
 {
     var requestInfo = new RequestInfo(HttpMethod.Get, "/foo/{bar}/baz");
     requestInfo.AddPathParameter<int?>("bar", null);
     var uri = this.requester.SubstitutePathParameters(requestInfo);
     Assert.Equal("/foo//baz", uri);
 }

 public void SubstitutesMultiplePathParametersOfTheSameType()
 {
     var requestInfo = new RequestInfo(HttpMethod.Get, "/foo/{bar}/{bar}");
     requestInfo.AddPathParameter("bar", "yay");
     var uri = this.requester.SubstitutePathParameters(requestInfo);
     Assert.Equal("/foo/yay/yay", uri);
 }

 public HttpResponse Process(RequestInfo requestInfo)
 {
     var ctx = requestInfo.Context;
     Trace.TraceInformation("[LogFilter]: Request for URI '{0}'", ctx.Request.Url);
     var resp = _nextFilter.Process(requestInfo);
     Trace.TraceInformation("[LogFilter]: User '{0}'", requestInfo.User != null ? requestInfo.User.Identity.Name : String.Empty);
     return resp;
 }

        public void SetsContentAsStringContentIfBodyIsString()
        {
            var requestInfo = new RequestInfo(HttpMethod.Get, "foo");
            requestInfo.SetBodyParameterInfo(BodySerializationMethod.Serialized, "hello");
            var content = this.requester.ConstructContent(requestInfo);

            Assert.IsType<StringContent>(content);
        }