public void MultipartFormData_WithParameterAndFile()
        {
            const string baseUrl = "http://localhost:8888/";

            using (SimpleServer.Create(baseUrl, EchoHandler))
            {
                RestClient client = new RestClient(baseUrl);
                RestRequest request = new RestRequest("/", Method.POST)
                                      {
                                          AlwaysMultipartFormData = true
                                      };
                DirectoryInfo directoryInfo = Directory.GetParent(Directory.GetCurrentDirectory())
                                                       .Parent;

                if (directoryInfo != null)
                {
                    string path = Path.Combine(directoryInfo.FullName, "Assets\\TestFile.txt");

                    request.AddFile("fileName", path);
                }

                request.AddParameter("controlName", "test", "application/json", ParameterType.RequestBody);

                IRestResponse response = client.Execute(request);

                Assert.AreEqual(this.expectedFileAndBodyRequestContent, response.Content);
            }
        }

        public RestSession GetSession(
            RestRequest request, 
            out bool newSession)
        {
            Cookie sessionCookie = request.Cookies[SESSION_KEY];
            string sessionId = "";
            RestSession session = null;

            if (sessionCookie != null)
            {
                sessionId = sessionCookie.Value;
                newSession = false;
            }
            else
            {
                sessionId = GenerateNewSessionKey();
                newSession = true;
            }

            if (!m_sessions.TryGetValue(sessionId, out session))
            {
                // TODO: What about expiring old sessions?
                session = new RestSession(sessionId);
                m_sessions.Add(sessionId, session);
            }

            return session;
        }

        public void Cannot_Set_Invalid_Host_Header(string value)
        {
            RestRequest request = new RestRequest();
            ArgumentException exception = Assert.Throws<ArgumentException>(() => request.AddHeader("Host", value));

            Assert.AreEqual("value", exception.ParamName);
        }

        public async Task MultipleRequestsFromSameClientShouldNotFail()
        {
            // Setup
            var client = new RestClient { BaseUrl = BaseAddress };
            var request = new RestRequest("api/books");
            List<Book> response;

            // Execute
            using (WebApp.Start<WebApiStartup>(BaseAddress))
            {
                response = await client.ExecuteAsync<List<Book>>(request);
            }

            // Validate
            response.Should().NotBeNull();
            response.Count().Should().Be(5);

            var request2 = new RestRequest("api/books");
            List<Book> response2;

            // Execute
            using (WebApp.Start<WebApiStartup>(BaseAddress))
            {
                response2 = await client.ExecuteAsync<List<Book>>(request2);
            }

            // Validate
            response2.Should().NotBeNull();
            response2.Count().Should().Be(5);
        }

 public void Can_Handle_Uncompressed_Content()
 {
     var client = new RestClient(BaseUrl);
     var request = new RestRequest("Compression/None");
     var response = client.Execute(request);
     Assert.Equal("This content is uncompressed!", response.Content);
 }

        private async Task<Application> AddApplicationAsyncInternal(string friendlyName, ApplicationOptions options)
		{
			var request = new RestRequest();
            request.Method = Method.POST;
			request.Resource = "Accounts/{AccountSid}/Applications.json";
			
			Require.Argument("FriendlyName", friendlyName);
			Validate.IsValidLength(friendlyName, 64);
			request.AddParameter("FriendlyName", friendlyName);

			// some check for null. in those cases an empty string is a valid value (to remove a URL assignment)
			if (options != null)
			{
				if (options.VoiceUrl != null) request.AddParameter("VoiceUrl", options.VoiceUrl);
				if (options.VoiceMethod.HasValue()) request.AddParameter("VoiceMethod", options.VoiceMethod.ToString());
				if (options.VoiceFallbackUrl != null) request.AddParameter("VoiceFallbackUrl", options.VoiceFallbackUrl);
				if (options.VoiceFallbackMethod.HasValue()) request.AddParameter("VoiceFallbackMethod", options.VoiceFallbackMethod.ToString());
				if (options.VoiceCallerIdLookup.HasValue) request.AddParameter("VoiceCallerIdLookup", options.VoiceCallerIdLookup.Value);
				if (options.StatusCallback.HasValue()) request.AddParameter("StatusCallback", options.StatusCallback);
				if (options.StatusCallbackMethod.HasValue()) request.AddParameter("StatusCallbackMethod", options.StatusCallbackMethod.ToString());
				if (options.SmsUrl != null) request.AddParameter("SmsUrl", options.SmsUrl);
				if (options.SmsMethod.HasValue()) request.AddParameter("SmsMethod", options.SmsMethod.ToString());
				if (options.SmsFallbackUrl != null) request.AddParameter("SmsFallbackUrl", options.SmsFallbackUrl);
				if (options.SmsFallbackMethod.HasValue()) request.AddParameter("SmsFallbackMethod", options.SmsFallbackMethod.ToString());
			}

            var result = await ExecuteAsync(request, typeof(Application));
            return (Application)result;
		}

        public void Handles_Server_Timeout_Error_Async()
        {
            const string baseUrl = "http://localhost:8888/";
            var resetEvent = new ManualResetEvent(false);

            using (SimpleServer.Create(baseUrl, TimeoutHandler))
            {
                var client = new RestClient(baseUrl);
                var request = new RestRequest("404") { Timeout = 500 };
                IRestResponse response = null;

                client.ExecuteAsync(request, responseCb =>
                                             {
                                                 response = responseCb;
                                                 resetEvent.Set();
                                             });

                resetEvent.WaitOne();

                Assert.NotNull(response);
                Assert.Equal(response.ResponseStatus, ResponseStatus.TimedOut);
                Assert.NotNull(response.ErrorException);
                Assert.IsAssignableFrom(typeof(WebException), response.ErrorException);
                Assert.Equal(response.ErrorException.Message, "The request timed-out.");
            }
        }

        public void Task_Handles_Non_Existent_Domain()
        {
            var client = new RestClient("http://192.168.1.200:8001");
            var request = new RestRequest("/")
            {
                RequestFormat = DataFormat.Json,
                Method = Method.GET
            };

            AggregateException agg = Assert.Throws<AggregateException>(
                delegate
                {
                    var response = client.ExecuteTaskAsync<StupidClass>(request);

                    response.Wait();
                });

            Assert.IsType(typeof(WebException), agg.InnerException);
            Assert.Equal("Unable to connect to the remote server", agg.InnerException.Message);

            //var client = new RestClient("http://nonexistantdomainimguessing.org");
            //var request = new RestRequest("foo");
            //var response = client.ExecuteTaskAsync(request);

            //Assert.Equal(ResponseStatus.Error, response.Result.ResponseStatus);
        }

    /// <summary>
    /// Retrieves a new token from Webtrends auth service
    /// </summary>
    public string Execute()
    {
        var builder = new JWTBuilder();
        var header = new JWTHeader
        {
            Type = "JWT",
            Algorithm = "HS256"
        };
        var claimSet = new JWTClaimSet
        {
            Issuer = clientId,
            Principal = clientId,
            Audience = audience,
            Expiration = DateTime.Now.ToUniversalTime().AddSeconds(30),
            Scope = scope
        };

        string assertion = builder.BuildAssertion(header, claimSet, clientSecret);
        var client = new RestClient(authUrl);
        var request = new RestRequest("token/", Method.POST);
        request.AddParameter("client_id", clientId);
        request.AddParameter("client_assertion", assertion);
        request.AddParameter("grant_type", "client_credentials");
        request.AddParameter("client_assertion_type", "urn:ietf:params:oauth:client-assertion-type:jwt-bearer");

        var response = client.Execute(request).Content;
        return (string)JObject.Parse(response)["access_token"];
    }

        public void InvokeAsyncMethodWithGetRequest()
        {
            //Arrange
            RestInvoker target = new RestInvoker();
            StubModule.HaltProcessing = TimeSpan.FromSeconds(0);
            StubModule.GetPerson = false;
            StubModule.TestHarness = new List<Person> { new Person { Id = 1, Email = "[email protected]" } };

            RestRequest request = new RestRequest(HttpMethod.GET, new RestUri(_MyUri, "/Person/{id}").SetParameter("id", "1"));

            //Act
            target.InvokeAsync(request).ContinueWith(task =>
            {
                using (var actual = task.Result)
                {
                    //Assert
                    Assert.True(StubModule.GetPerson);
                    Assert.True(actual.IsSuccessStatusCode);
                    Assert.NotNull(actual);

                    string content = actual.Body.ReadAsString();

                    Assert.Equal("{\"Id\":1,\"UID\":\"00000000-0000-0000-0000-000000000000\",\"Email\":\"[email protected]\",\"NoOfSiblings\":0,\"DOB\":\"\\/Date(-59011459200000)\\/\",\"IsActive\":false,\"Salary\":0}", content);
                }

            }).Wait();

        }

 public void Handles_Non_Existent_Domain()
 {
     var client = new RestClient("http://nonexistantdomainimguessing.org");
     var request = new RestRequest("foo");
     var response = client.Execute(request);
     Assert.Equal(ResponseStatus.Error, response.ResponseStatus);
 }

        public void Can_Handle_Exception_Thrown_By_OnBeforeDeserialization_Handler()
        {
            const string baseUrl = "http://localhost:8080/";
            const string ExceptionMessage = "Thrown from OnBeforeDeserialization";

            using (SimpleServer.Create(baseUrl, Handlers.Generic<ResponseHandler>()))
            {
                var client = new RestClient(baseUrl);
                var request = new RestRequest("success");
                request.OnBeforeDeserialization += response =>
                                                   {
                                                       throw new Exception(ExceptionMessage);
                                                   };

                var task = client.ExecuteTaskAsync<Response>(request);

                try
                {
                    // In the broken version of the code, an exception thrown in OnBeforeDeserialization causes the task to
                    // never complete. In order to test that condition, we'll wait for 5 seconds for the task to complete.
                    // Since we're connecting to a local server, if the task hasn't completed in 5 seconds, it's safe to assume
                    // that it will never complete.
                    Assert.True(task.Wait(TimeSpan.FromSeconds(5)), "It looks like the async task is stuck and is never going to complete.");
                }
                catch (AggregateException e)
                {
                    Assert.Equal(1, e.InnerExceptions.Count);
                    Assert.Equal(ExceptionMessage, e.InnerExceptions.First().Message);
                    return;
                }

                Assert.True(false, "The exception thrown from OnBeforeDeserialization should have bubbled up.");
            }
        }

        public async Task TestMultipleRequests(Type factoryType)
        {
            using (var client = new RestClient("http://httpbin.org/")
            {
                HttpClientFactory = CreateClientFactory(factoryType, false),
            })
            {
                {
                    var request = new RestRequest("post", Method.POST);
                    request.AddParameter("param1", "param1");

                    var response = await client.Execute<HttpBinResponse>(request);
                    Assert.NotNull(response.Data);
                    Assert.NotNull(response.Data.Form);
                    Assert.True(response.Data.Form.ContainsKey("param1"));
                    Assert.Equal("param1", response.Data.Form["param1"]);
                }

                {
                    var request = new RestRequest("post", Method.POST);
                    request.AddParameter("param1", "param1+");

                    var response = await client.Execute<HttpBinResponse>(request);
                    Assert.NotNull(response.Data);
                    Assert.NotNull(response.Data.Form);
                    Assert.True(response.Data.Form.ContainsKey("param1"));
                    Assert.Equal("param1+", response.Data.Form["param1"]);
                }
            }
        }

        public void Cannot_Set_Empty_Host_Header()
        {
            var request = new RestRequest();
            var exception = Assert.Throws<ArgumentException>(() => request.AddHeader("Host", string.Empty));

            Assert.AreEqual("value", exception.ParamName);
        }

        public void Writes_Response_To_Stream()
        {
            const string baseUrl = "http://localhost:8888/";

            using (SimpleServer.Create(baseUrl, Handlers.FileHandler))
            {
                string tempFile = Path.GetTempFileName();

                using (var writer = File.OpenWrite(tempFile))
                {
                    var client = new RestClient(baseUrl);
                    var request = new RestRequest("Assets/Koala.jpg");

                    request.ResponseWriter = (responseStream) => responseStream.CopyTo(writer);

                    var response = client.DownloadData(request);

                    Assert.Null(response);
                }

                var fromTemp = File.ReadAllBytes(tempFile);
                var expected = File.ReadAllBytes(Environment.CurrentDirectory + "\\Assets\\Koala.jpg");

                Assert.Equal(expected, fromTemp);
            }
        }

        public void Can_Perform_GET_Async()
        {
            const string baseUrl = "http://localhost:8084/";
            const string val = "Basic async test";

            var resetEvent = new ManualResetEvent(false);

            using (SimpleServer.Create(baseUrl, Handlers.EchoValue(val)))
            {
                var client = new RestClient(baseUrl);
                var request = new RestRequest("");
                IRestResponse response = null;

                client.ExecuteAsync(request, (resp, asyncHandle) =>
                {
                    response = resp;
                    resetEvent.Set();
                });

                resetEvent.WaitOne();

                Assert.NotNull(response.Content);
                Assert.Equal(val, response.Content);
            }
        }

        public static RestRequest DelegateWith(RestClient client, RestRequest request)
        {
            if(request == null)
            {
                throw new ArgumentNullException("request");
            }

            if(!request.Method.HasValue)
            {
                throw new ArgumentException("Request must specify a web method.");
            }

            var method = request.Method.Value;
            var credentials = (OAuthCredentials)request.Credentials;
            var url = request.BuildEndpoint(client).ToString();
            var workflow = new OAuthWorkflow(credentials);
            var uri = new Uri(client.Authority);
            var realm = uri.Host;
            var enableTrace = client.TraceEnabled || request.TraceEnabled;

            var info = workflow.BuildProtectedResourceInfo(method, request.GetAllHeaders(), url);
            var query = credentials.GetQueryFor(url, request, info, method, enableTrace);
            ((OAuthWebQuery) query).Realm = realm;
            var auth = query.GetAuthorizationContent();

            var echo = new RestRequest();
            echo.AddHeader("X-Auth-Service-Provider", url);
            echo.AddHeader("X-Verify-Credentials-Authorization", auth);
            return echo;
        }

 public void Handles_GET_Request_404_Error()
 {
     var client = new RestClient(BaseUrl);
     var request = new RestRequest("StatusCode/404");
     var response = client.Execute(request);
     Assert.Equal(HttpStatusCode.NotFound, response.StatusCode);
 }

        public void GetAborted()
        {
            //Arrange
            StubModule.HaltProcessing = TimeSpan.FromMilliseconds(1000);
            StubModule.GetPerson = false;
            StubModule.TestHarness = new List<Person> { new Person { Id = 1, Email = "[email protected]" } };

            RestRequest target = new RestRequest(HttpMethod.GET, new RestUri(_MyUri, "/Person/{id}").SetParameter("id", "1"));

            //Act
            RestResponse response = null;
            //A completely synchronous GetResponse cannot be aborted.
            //So, spining off a new thread.. And balancing the times between GetResponse() and Abort() methods.
            var task = Task.Factory.StartNew(() =>
            {
                response = target.GetResponse();
            });
            Thread.Sleep(500);
            target.Abort();
            task.Wait();

            //Assert
            Assert.NotNull(response);
            Assert.NotNull(response.Error);
            Assert.Equal("The request was aborted: The request was canceled.", response.Error.InnerException.Message);
            Assert.Equal(0, (int)response.Error.StatusCode);
        }

        public void Handles_Different_Root_Element_On_Http_Error()
        {
            Uri baseUrl = new Uri("http://localhost:8888/");

            using (SimpleServer.Create(baseUrl.AbsoluteUri, Handlers.Generic<ResponseHandler>()))
            {
                RestClient client = new RestClient(baseUrl);
                RestRequest request = new RestRequest("error")
                                      {
                                          RootElement = "Success"
                                      };

                request.OnBeforeDeserialization = resp =>
                                                  {
                                                      if (resp.StatusCode == HttpStatusCode.BadRequest)
                                                      {
                                                          request.RootElement = "Error";
                                                      }
                                                  };

                IRestResponse<Response> response = client.Execute<Response>(request);

                Assert.AreEqual(HttpStatusCode.BadRequest, response.StatusCode);
                Assert.AreEqual("Not found!", response.Data.Message);
            }
        }