private static async Task<User> GetUserEntityAsync(ApiController controller)
        {
            ClaimsPrincipal principal = (ClaimsPrincipal)controller.User;
            string provider = principal.FindFirst("http://schemas.microsoft.com/identity/claims/identityprovider").Value;

            ProviderCredentials creds;

            if (string.Equals(provider, "microsoftaccount", StringComparison.OrdinalIgnoreCase))
            {
                creds = await controller.User.GetAppServiceIdentityAsync<MicrosoftAccountCredentials>(controller.Request);
            }
            //else if (string.Equals(provider, "facebook", StringComparison.OrdinalIgnoreCase))
            //{
            //    creds = await controller.User.GetAppServiceIdentityAsync<FacebookCredentials>(controller.Request);
            //}
            //else if (string.Equals(provider, "google", StringComparison.OrdinalIgnoreCase))
            //{
            //    creds = await controller.User.GetAppServiceIdentityAsync<GoogleCredentials>(controller.Request);
            //}
            //else if (string.Equals(provider, "twitter", StringComparison.OrdinalIgnoreCase))
            //{
            //    creds = await controller.User.GetAppServiceIdentityAsync<TwitterCredentials>(controller.Request);
            //}
            else
            {
                throw new NotImplementedException();
            }
            
            return GetUserEntity(creds);
        }

 public DefaultControllerBehaviorConfig(ApiController controller)
 {
     var request = new HttpRequestMessage();
     var cfg = new HttpConfiguration();
     request.Properties[HttpPropertyKeys.HttpConfigurationKey] = cfg;
     controller.Request = request;
 }

 /// <summary>
 /// Initializes a new instance of the <see cref="BaseTestBuilder" /> class.
 /// </summary>
 /// <param name="controller">Controller on which will be tested.</param>
 /// <param name="controllerAttributes">Collected attributes from the tested controller.</param>
 protected BaseTestBuilder(
     ApiController controller,
     IEnumerable<object> controllerAttributes = null)
 {
     this.Controller = controller;
     this.ControllerLevelAttributes = controllerAttributes;
 }

 public void LocationIsCorrectlyInitialized(Uri location, ApiController controller)
 {
     // Exercise system
     var result = new JSendRedirectResult(location, controller);
     // Verify outcome
     result.Location.Should().Be(location);
 }

        public ApiControllerExtensionsTests()
        {
            HttpConfiguration config = new HttpConfiguration();
            IWebHookUser user = new WebHookUser();

            _managerMock = new Mock<IWebHookManager>();
            _resolverMock = new Mock<IDependencyResolver>();
            _resolverMock.Setup(r => r.GetService(typeof(IWebHookManager)))
                .Returns(_managerMock.Object)
                .Verifiable();
            _resolverMock.Setup(r => r.GetService(typeof(IWebHookUser)))
                .Returns(user)
                .Verifiable();

            config.DependencyResolver = _resolverMock.Object;

            ClaimsIdentity identity = new ClaimsIdentity();
            Claim claim = new Claim(ClaimTypes.Name, "TestUser");
            identity.AddClaim(claim);
            _principal = new ClaimsPrincipal(identity);

            _context = new HttpRequestContext()
            {
                Configuration = config,
                Principal = _principal
            };
            _controller = new TestController()
            {
                RequestContext = _context
            };
        }

 public void ContentIsCorrectlyInitialized(Uri location, Model content, ApiController controller)
 {
     // Exercise system
     var result = new JSendCreatedResult<Model>(location, content, controller);
     // Verify outcome
     result.Content.Should().Be(content);
 }

        private void SetupControllerForTesting(ApiController controller, string controllerName)
        {
            string serverUrl = "http://sample-url.com";

            // Setup the Request object of the controller
            var request = new HttpRequestMessage()
            {
                RequestUri = new Uri(serverUrl)
            };

            controller.Request = request;

            // Setup the configuration of the controller
            var config = new HttpConfiguration();
            config.Routes.MapHttpRoute(
                name: "DefaultApi",
                routeTemplate: "api/{controller}/{id}",
                defaults: new { id = RouteParameter.Optional });
            controller.Configuration = config;

            // Apply the routes to the controller
            controller.RequestContext.RouteData = new HttpRouteData(
                route: new HttpRoute(),
                values: new HttpRouteValueDictionary
                {
                    { "controller", controllerName }
                });
        }

 public void ReasonIsCorrectlyInitialized(string reason, ApiController controller)
 {
     // Exercise system
     var result = new JSendBadRequestResult(reason, controller);
     // Verify outcome
     result.Reason.Should().Be(reason);
 }

 public void ConstructorThrowsWhenRouteNameIsNull(
     Dictionary<string, object> routeValues, Model content, ApiController controller)
 {
     // Exercise system and verify outcome
     Action ctor = () => new JSendCreatedAtRouteResult<Model>(null, routeValues, content, controller);
     ctor.ShouldThrow<ArgumentNullException>();
 }

        public static IHttpActionResult GetErrorResult(this IdentityResult result, ApiController controller)
        {
            if (result == null)
            {
                return new System.Web.Http.Results.InternalServerErrorResult(controller);
            }

            if (!result.Succeeded)
            {
                if (result.Errors != null)
                {
                    foreach (string error in result.Errors)
                    {
                        controller.ModelState.AddModelError("", error);
                    }
                }

                if (controller.ModelState.IsValid)
                {
                    // No ModelState errors are available to send, so just return an empty BadRequest.
                    return new System.Web.Http.Results.BadRequestResult(controller);
                }

                return new System.Web.Http.Results.BadRequestResult(controller);
            }

            return new System.Web.Http.Results.OkResult(controller);
        }

 public void ConstructorThrowsWhenReasonIsWhiteSpace(ApiController controller)
 {
     // Exercise system and verify outcome
     Action ctor = () => new JSendBadRequestResult("  ", controller);
     ctor.ShouldThrow<ArgumentException>()
         .And.Message.Should().StartWith(StringResources.BadRequest_WhiteSpaceReason);
 }

        public async static Task<dynamic> CopyMulipartContent(ApiController controller)
        {
            if (!controller.Request.Content.IsMimeMultipartContent())
            {
                throw new HttpResponseException(HttpStatusCode.UnsupportedMediaType);
            }

            var root = HttpContext.Current.Server.MapPath("~/App_Data");
            var provider = new MultipartFormDataStreamProvider(root);
            var tempPath = HttpContext.Current.Server.MapPath("~/Content/Temp/");
            var fileNames = new List<string>();

            await controller.Request.Content.ReadAsMultipartAsync(provider);

            foreach (MultipartFileData file in provider.FileData)
            {
                _fileId++;
                if (_fileId + 1 > Int32.MaxValue)
                    _fileId = 0;
                var filename = tempPath + _fileId + "_" + file.Headers.ContentDisposition.FileName.Replace("\"", "").Replace("\\", "");
                fileNames.Add(filename);
                File.Copy(file.LocalFileName, filename);
                FileHelper.WaitFileUnlockedAsync(() => File.Delete(file.LocalFileName), file.LocalFileName, 30, 800);
            }

            return new { formData = provider.FormData, fileNames };
        }

 public OAuthImplicitAccessTokenResult(string redirectUrl, OAuthImplicitAccessTokenResponse response,
     ApiController controller)
 {
     RedirectUrl = redirectUrl;
     Response = response;
     Request = controller.Request;
 }

        public OkFileDownloadResult(string localPath, string contentType, string downloadFileName,
            ApiController controller)
        {
            if (localPath == null)
            {
                throw new ArgumentNullException("localPath");
            }

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

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

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

            LocalPath = localPath;
            ContentType = contentType;
            DownloadFileName = downloadFileName;
            _controller = controller;
        }

 public void RequestIsCorrectlyInitializedUsingController(ApiController controller)
 {
     // Exercise system
     var result = new JSendOkResult(controller);
     // Verify outcome
     result.Request.Should().Be(controller.Request);
 }

        /// <summary>
        /// Validates the access token for any OAuth connector.
        /// </summary>
        /// <param name="authController">The connector controller which uses access token based authentication</param>
        /// <param name="connectorName">The name of the connector for which the validation will be done.</param>
        /// <param name="getAccessTokenVerificationRequest">Callback that computes the request object that will be used to do access token verification.</param>
        /// <param name="webResponseProcessor">Callback that processes the web response from 3rd party service.</param>
        /// <returns>A status check record indiciating the outcome of access token check.</returns>
        public static async Task<StatusCheckEntry> ValidateAccessToken(ApiController authController, string connectorName, Func<Task<HttpWebRequest>> getAccessTokenVerificationRequest = null, Func<WebResponse, StatusCheckEntry> webResponseProcessor = null)
        {
            Logger.LogMessage(authController.Request, false, "Retrieving {0} connector status", connectorName);
            if (getAccessTokenVerificationRequest == null)
            {
                throw new ArgumentNullException("getAccessTokenVerificationRequest", "getAccessTokenVerificationRequest cannot be null");
            }

            return await Task.Factory.StartNew(() =>
                {
                    var accessTokenStatusCheck = new StatusCheckEntry();
                    try
                    {
                        // Constructing the outgoing request object
                        HttpWebRequest outgoingRequest = null;
                        Logger.LogMessage(authController.Request, false, "Constructing outgoing request object");
                        outgoingRequest = getAccessTokenVerificationRequest().Result;
                        outgoingRequest.ReadWriteTimeout = -1;
                        outgoingRequest.Timeout = -1;
                        outgoingRequest.KeepAlive = false;
                        Logger.LogMessage(authController.Request, false, "Calling {0} API with Request URI: {1}", connectorName, outgoingRequest.RequestUri.ToString());

                        // Make the call and check the response code
                        WebResponse webResponse = outgoingRequest.GetResponse();
                        HttpStatusCode statusCode = ((HttpWebResponse)webResponse).StatusCode;
                        Logger.LogMessage(authController.Request, false, "Status returning , {0}", statusCode);

                        if (webResponseProcessor != null)
                        {
                            accessTokenStatusCheck = webResponseProcessor(webResponse);
                        }
                        else
                        {
                            accessTokenStatusCheck = ProcessStatusCheckResponse(authController, webResponse);
                        }
                    }
                    catch (Exception ex)
                    {
                        if (ex.Message.Equals("The remote server returned an error: (401) Unauthorized."))
                        {
                            Logger.LogMessage(authController.Request, ex.Message);
                            accessTokenStatusCheck = GetInvalidAccessTokenStatusCheckEntry();
                        }
                        else
                        {
                            // Log the exception stack
                            Logger.LogException(authController.Request, ex);

                            // Construct a status check entry mentioning that status check failed
                            accessTokenStatusCheck.Level = StatusLevel.Error;
                            accessTokenStatusCheck.Message = string.Format(CommonResource.StatusCheckFailed, connectorName);
                            accessTokenStatusCheck.Name = StatusMessages.StatusCheckFailed;
                        }
                    }

                    return accessTokenStatusCheck;
                }
            );
        }

 public void RequestIsCorrectlyInitializedUsingController(
     string message, int? code, Exception data, ApiController controller)
 {
     // Exercise system
     var result = new JSendInternalServerErrorResult(message, code, data, controller);
     // Verify outcome
     result.Request.Should().Be(controller.Request);
 }

 public void RequestIsCorrectlyInitializedUsingController(
     string routeName, Dictionary<string, object> routeValues, Model content, ApiController controller)
 {
     // Exercise system
     var result = new JSendCreatedAtRouteResult<Model>(routeName, routeValues, content, controller);
     // Verify outcome
     result.Request.Should().Be(controller.Request);
 }

 public void UrlFactoryIsCorrectlyInitialized(string routeName, Dictionary<string, object> routeValues,
     ApiController controller)
 {
     // Exercise system
     var result = new JSendRedirectToRouteResult(routeName, routeValues, controller);
     // Verify outcome
     result.UrlFactory.Should().BeSameAs(controller.Url);
 }

 /// <summary>
 /// Initializes a new instance of the <see cref="VoidActionResultTestBuilder" /> class.
 /// </summary>
 /// <param name="controller">Controller on which the action will be tested.</param>
 /// <param name="actionName">Name of the tested action.</param>
 /// <param name="caughtException">Caught exception during the action execution.</param>
 /// <param name="actionAttributes">Collected action attributes from the method call.</param>
 public VoidActionResultTestBuilder(
     ApiController controller,
     string actionName,
     Exception caughtException,
     IEnumerable<object> actionAttributes)
     : base(controller, actionName, caughtException, actionAttributes)
 {
 }