public void SetUp()
 {
     request = MockRepository.GenerateStub<IRequest>();
     response = MockRepository.GenerateStub<IResponse>();
     engine = MockRepository.GenerateStub<ILessEngine>();
     lessSource = MockRepository.GenerateStub<ILessSource>();
 }

 /// <summary>
 /// Evaluates the response.
 /// </summary>
 /// <param name="response">The response to parse.</param>
 /// <param name="options">The options to consider.</param>
 public void Evaluate(IResponse response, ScriptOptions options)
 {
     var reader = new StreamReader(response.Content, options.Encoding ?? Encoding.UTF8, true);
     var content = reader.ReadToEnd();
     reader.Close();
     Evaluate(content, options);
 }

        public override void ProcessRequest(IRequest httpReq, IResponse httpRes, string operationName)
        {
            HostContext.ApplyCustomHandlerRequestFilters(httpReq, httpRes);
            if (httpRes.IsClosed) return;

            httpRes.ContentType = MimeTypes.Html;
            if (RazorFormat == null)
                RazorFormat = RazorFormat.Instance;

            var contentPage = RazorPage ?? RazorFormat.FindByPathInfo(PathInfo);
            if (contentPage == null)
            {
                httpRes.StatusCode = (int)HttpStatusCode.NotFound;
                httpRes.EndHttpHandlerRequest();
                return;
            }

            var model = Model;
            if (model == null)
                httpReq.Items.TryGetValue("Model", out model);
            if (model == null)
            {
                var modelType = RazorPage != null ? RazorPage.ModelType : null;
                model = modelType == null || modelType == typeof(DynamicRequestObject)
                    ? null
                    : DeserializeHttpRequest(modelType, httpReq, httpReq.ContentType);
            }

            RazorFormat.ProcessRazorPage(httpReq, contentPage, model, httpRes);
        }

        public override void Execute(IRequest req, IResponse res, object requestDto)
        {
            var authErrorMessage = "";
            try
            {
                // Perform security check
                if (CanExecute(req))
                    return;
            }
            catch (System.Exception ex)
            {
                authErrorMessage = ex.Message;
                var message = string.Format("Blocked unauthorized request: {0} {1} by ip = {2} due to {3}",
                    req.Verb,
                    req.AbsoluteUri,
                    req.UserHostAddress ?? "unknown",
                    authErrorMessage);
                Log.Error(message);
            }

            // Security failed!
            var responseMessage = "You are not authorized. " + authErrorMessage;

            res.StatusCode = (int)HttpStatusCode.Unauthorized;
            res.StatusDescription = responseMessage;
            res.AddHeader(HttpHeaders.WwwAuthenticate, string.Format("{0} realm=\"{1}\"", "", "custom api"));
            res.ContentType = "text/plain";
            res.Write(responseMessage);
            res.Close();
        }

		public override void ProcessRequest(IRequest httpReq, IResponse httpRes, string operationName)
    	{
            if (!AssertAccess(httpReq, httpRes, httpReq.QueryString["op"])) return;

			var operationTypes = HostContext.Metadata.GetAllTypes();

    		if (httpReq.QueryString["xsd"] != null)
    		{
				var xsdNo = Convert.ToInt32(httpReq.QueryString["xsd"]);
                var schemaSet = XsdUtils.GetXmlSchemaSet(operationTypes);
    			var schemas = schemaSet.Schemas();
    			var i = 0; 
    			if (xsdNo >= schemas.Count)
    			{
    				throw new ArgumentOutOfRangeException("xsd");
    			}
    			httpRes.ContentType = "text/xml";
    			foreach (XmlSchema schema in schemaSet.Schemas())
    			{
    				if (xsdNo != i++) continue;
    				schema.Write(httpRes.OutputStream);
    				break;
    			}
    			return;
    		}

			using (var sw = new StreamWriter(httpRes.OutputStream))
			{
				var writer = new HtmlTextWriter(sw);
				httpRes.ContentType = "text/html";
				ProcessOperations(writer, httpReq, httpRes);
			}
    	}

        public override async Task Execute(string[] parameters, IResponse response)
        {
            string sourceRepo;
            string issueNumberString;
            if (!RepoParser.ParseRepoAndIssueNumber(parameters[1], out sourceRepo, out issueNumberString))
            {
                await response.Send($"I could not parse the source repository and issue number from '{parameters[1]}'. Are you using the correct syntax?");
                return;
            }

            string targetRepo;
            if (!RepoParser.ParseRepo(parameters[2], out targetRepo))
            {
                await response.Send($"I could not parse the target repository from '{parameters[2]}'. Are you using the correct syntax?");
                return;
            }

            int issueNumber;
            if (!int.TryParse(issueNumberString, out issueNumber))
            {
                await response.Send("Issue number should be a valid number dude!");
                return;
            }

            var owner = "Particular";

            await response.Send($"Copying issue https://github.com/{owner}/{sourceRepo}/issues/{issueNumber}").IgnoreWaitContext();

            var newIssue = await IssueUtility.Transfer(owner, sourceRepo, issueNumber, owner, targetRepo, false).IgnoreWaitContext();

            await response.Send($"Issue copied to https://github.com/{owner}/{targetRepo}/issues/{newIssue.Number}").IgnoreWaitContext();
        }

        public void Assert(IResponse response)
        {
            // when there are no assertions it is a success
            bool success = (this.assertions.Count == 0);

            // when the response was timedout, there is no data to test/assert
            if (!response.IsTimedOut())
            {
                foreach (AbstractAssertion assertion in this.assertions)
                {
                    success = assertion.Assert(response);
                    LOG.DebugFormat("Assert: {0} result: {1}", assertion.GetType().Name, success);

                    if (!success)
                    {
                        break;
                    }
                }

            }

            // record results
            this.result.Executed = true;
            this.result.ExecutionTime = response.GetExecutionTime();
            this.result.Success = success;
            this.result.TimedOut = response.IsTimedOut();
            this.result.StatusCode = response.GetStatusCode();
            this.result.StatusDescription = response.GetStatusDescription();
            this.result.ResponseText = response.GetResponseText();
        }

        /// <summary>
        /// This is called by the hosting environment via CatchAll usually for content pages.
        /// </summary>
        public override void ProcessRequest(IRequest httpReq, IResponse httpRes, string operationName)
        {
            httpRes.ContentType = MimeTypes.Html;

            ResolveAndExecuteRazorPage(httpReq, httpRes, null);
            httpRes.EndRequest(skipHeaders: true);
        }

 public void Respond(IRequest request, IResponse response)
 {
     response.StatusCode = HttpStatusCode.NotFound;
     response.StatusMessage = "Resource not found";
     response.Output.WriteLine("<h1>404: The resource <i>{0}</i> could not be found.</h1>",
                               request.VirtualPath);
 }

        /// <summary>
        /// Handles rendering a previous MiniProfiler session, identified by its "?id=GUID" on the query.
        /// </summary>
        private static string Results(IRequest httpReq, IResponse httpRes)
        {
            // this guid is the MiniProfiler.Id property
            var id = new Guid();
            if (!Guid.TryParse(httpReq.QueryString["id"], out id))
            {
                return NotFound(httpRes, "text/plain", "No Guid id specified on the query string");
            }

            // load profiler
            var profiler = Profiler.Settings.Storage.Load(id);
            if (profiler == null)
            {
                return NotFound(httpRes, "text/plain", "No MiniProfiler results found with Id=" + id.ToString());
            }

            // ensure that callers have access to these results
            var authorize = Profiler.Settings.Results_Authorize;
            if (authorize != null && !authorize(httpReq, profiler))
            {
                httpRes.StatusCode = 401;
                httpRes.ContentType = "text/plain";
                return "Unauthorized";
            }

            // Only manage full page
            return ResultsFullPage(httpRes, profiler);
        }

        /// <summary>
        /// The request filter is executed before the service.
        /// </summary>
        /// <param name="request">The http request wrapper</param>
        /// <param name="response">The http response wrapper</param>
        /// <param name="requestDto">The request DTO</param>
        public void RequestFilter(IRequest request, IResponse response, object requestDto)
        {
            var serviceRequest = new ServiceStackServiceRequest(request);
            
            //This code is executed before the service
            var auth = AuthorizationContext.GetAuthorizationInfo(serviceRequest);

            if (auth != null)
            {
                User user = null;

                if (!string.IsNullOrWhiteSpace(auth.UserId))
                {
                    var userId = auth.UserId;

                    user = UserManager.GetUserById(userId);
                }

                string deviceId = auth.DeviceId;
                string device = auth.Device;
                string client = auth.Client;
                string version = auth.Version;

                if (!string.IsNullOrEmpty(client) && !string.IsNullOrEmpty(deviceId) && !string.IsNullOrEmpty(device) && !string.IsNullOrEmpty(version))
                {
                    var remoteEndPoint = request.RemoteIp;

                    SessionManager.LogSessionActivity(client, version, deviceId, device, remoteEndPoint, user);
                }
            }
        }

        public HostContext(IRequest request, IResponse response)
        {
            Request = request;
            Response = response;

            Environment = new Dictionary<string, object>();
        }

        public static string GetResponseText(IResponse response)
        {
            StringBuilder builder = new StringBuilder();

            // Status
            builder.AppendFormat("Status: {0}\n", response.Status);

            // Headers
            foreach (KeyValuePair<string,IEnumerable<string>> header in response.Headers)
                foreach (string value in header.Value)
                builder.AppendFormat("{0}: {1}\n", header.Key, value);

            builder.Append("\n");

            // Body ... just supports a string body for now ... next up: FileInfo support?
            foreach (object bodyPart in response.GetBody())
                if (bodyPart is string)
                    builder.Append(bodyPart as string);
                else if (bodyPart is byte[])
                    throw new NotImplementedException("TODO test CGI byte[] body output"); //builder.Append(Encoding.UTF8.GetString(bodyPart)); // assume UTF8 encoding for now ...
                else if (bodyPart is ArraySegment<byte>)
                    throw new NotImplementedException("TODO test CGI ArraySegment<byte> body output");
                else if (bodyPart is FileInfo)
                    throw new NotImplementedException("TODO test CGI FileInfo body output");
                else
                    throw new FormatException("Unknown object returned by IResponse.GetBody(): " + bodyPart.GetType().Name);

            return builder.ToString();
        }

        public override void ProcessRequest(IRequest httpReq, IResponse httpRes, string operationName)
        {
            if (HostContext.ApplyCustomHandlerRequestFilters(httpReq, httpRes))
                return;

            Action(httpReq, httpRes);
        }

 protected override async Task ProcessResponseAsync(IResponse response)
 {
     var context = new BrowsingContext(_parentDocument.Context, Sandboxes.None);
     var options = new CreateDocumentOptions(response, _configuration, _parentDocument);
     var factory = _configuration.GetFactory<IDocumentFactory>();
     ChildDocument = await factory.CreateAsync(context, options, CancellationToken.None).ConfigureAwait(false);
 }

 public HostContext(IRequest request, IResponse response, IPrincipal user)
 {
     Request = request;
     Response = response;
     User = user;
     Items = new Dictionary<string, object>(StringComparer.OrdinalIgnoreCase);
 }

        public override async Task Execute(string[] parameters, IResponse response)
        {
            var username = parameters[1];
            var repoName = parameters[3];

            var activeRepositories = Brain.Get<AvailableRepositories>();

            var repo = activeRepositories.SingleOrDefault(r => r.Name == repoName);

            if (repo == null)
            {
                await response.Send("Repository not found, please add it using: mmbot add repo " + repoName).IgnoreWaitContext();
                return;
            }

            if (username.ToLower() == "my self")
            {
                repo.Caretaker = CurrentUser.Name;
            }
            else
            {
                repo.Caretaker = username;
            }

            Brain.Set(activeRepositories);

            await response.Send(username + " is now caretaker for " + repo.Name);
        }

        public override void Execute(IRequest req, IResponse res, object requestDto)
        {
            if (HostContext.HasValidAuthSecret(req))
                return;

            base.Execute(req, res, requestDto); //first check if session is authenticated
            if (res.IsClosed) return; //AuthenticateAttribute already closed the request (ie auth failed)

            var session = req.GetSession();

            var authRepo = HostContext.AppHost.GetAuthRepository(req);
            using (authRepo as IDisposable)
            {
                if (session != null && session.HasRole(RoleNames.Admin, authRepo))
                    return;

                if (HasAnyPermissions(req, session, authRepo)) return;
            }

            if (DoHtmlRedirectIfConfigured(req, res)) return;

            res.StatusCode = (int)HttpStatusCode.Forbidden;
            res.StatusDescription = ErrorMessages.InvalidPermission;
            res.EndRequest();
        }

        public virtual int Serialize(IResponse response, byte[] buffer)
        {
            var stream = new MemoryStream(buffer);
            var writer = new StreamWriter(stream, Encoding.ASCII);
            writer.Write(response.SipVersion);
            writer.Write(" ");
            writer.Write((int) response.StatusCode);
            writer.Write(" ");
            writer.WriteLine(response.ReasonPhrase);

            WriteHeader(writer, "To", response.To);
            WriteHeader(writer, "From", response.From);
            WriteHeader(writer, "Contact", response.Contact);
            WriteHeader(writer, "Via", response.Via);
            WriteHeader(writer, "CSeq", response.CSeq);
            //WriteHeader(writer, "Call-Id", response.CallId);
            foreach (var header in response.Headers)
                WriteHeader(writer, header.Key, header.Value.ToString());
            if (response.Body != null && response.Body.Length > 0)
                WriteHeader(writer, "Content-Length", response.Body.Length);
            else
                WriteHeader(writer, "Content-Length", "0");
            writer.WriteLine();

            if (response.Body != null)
            {
                var ms = (MemoryStream) response.Body;
                ms.WriteTo(stream);
            }

            writer.Flush();

            string temp = Encoding.ASCII.GetString(buffer, 0, (int) stream.Length);
            return (int) stream.Position;
        }

        public static void RequestFilter(IRequest req, IResponse res, object requestDto)
        {
            var validator = ValidatorCache.GetValidator(req, requestDto.GetType());
            if (validator == null) return;

            var validatorWithHttpRequest = validator as IRequiresRequest;
            if (validatorWithHttpRequest != null)
                validatorWithHttpRequest.Request = req;

            var ruleSet = req.Verb;
            var validationResult = validator.Validate(
                new ValidationContext(requestDto, null, new MultiRuleSetValidatorSelector(ruleSet)));

            if (validationResult.IsValid) return;

            var errorResponse = DtoUtils.CreateErrorResponse(
                requestDto, validationResult.ToErrorResult());

            var validationFeature = HostContext.GetPlugin<ValidationFeature>();
            if (validationFeature != null && validationFeature.ErrorResponseFilter != null)
            {
                errorResponse = validationFeature.ErrorResponseFilter(validationResult, errorResponse);
            }

            res.WriteToResponse(req, errorResponse);
        }