private string ExecuteContentPage(string path)
{
var mockReq = new MockHttpRequest
{
OperationName = "Razor_PageResolver",
PathInfo = path,
};
var mockRes = new MockHttpResponse(mockReq);
RazorFormat.ProcessContentPageRequest(mockReq, mockRes);
return(mockRes.ReadAsString());
}
public void WhenPreAuthenticateAndNoSignature_ThenCreatesNoSession()
{
var request = new MockHttpRequest();
var response = new MockHttpResponse(request);
provider.PreAuthenticate(request, response);
var session = request.GetSession();
Assert.That(session.Id, Is.Not.Null);
Assert.That(session.IsAuthenticated, Is.False);
}
public void GetFileForUrl_BeastSaber_Curator()
{
var testUrl = new Uri(@"https://bsaber.com/wp-json/bsaber-api/songs/?bookmarked_by=curatorrecommended&page=1&count=50");
string fileMatch = "bookmarked_by_curator1.json";
var file = new FileInfo(MockHttpResponse.GetFileForUrl(testUrl));
Assert.AreEqual(file.Name, fileMatch);
testUrl = new Uri(@"https://bsaber.com/wp-json/bsaber-api/songs/?bookmarked_by=curatorrecommended&page=4");
fileMatch = "bookmarked_by_curator4_partial.json";
file = new FileInfo(MockHttpResponse.GetFileForUrl(testUrl));
Assert.AreEqual(file.Name, fileMatch);
}
public void GetFileForUrl_BeastSaber_Followings()
{
var testUrl = new Uri(@"https://bsaber.com/members/zingabopp/wall/followings/feed/?acpage=1&count=20");
string fileMatch = "followings1.xml";
var file = new FileInfo(MockHttpResponse.GetFileForUrl(testUrl));
Assert.AreEqual(file.Name, fileMatch);
testUrl = new Uri(@"https://bsaber.com/members/zingabopp/wall/followings/feed/?acpage=8");
fileMatch = "followings8_partial.xml";
file = new FileInfo(MockHttpResponse.GetFileForUrl(testUrl));
Assert.AreEqual(file.Name, fileMatch);
}
public void GetFileForUrl_BeastSaber_Bookmarked()
{
var testUrl = new Uri(@"https://bsaber.com/wp-json/bsaber-api/songs/?bookmarked_by=Zingabopp&page=2&count=15");
string fileMatch = "bookmarked_by_zingabopp2.json";
var file = new FileInfo(MockHttpResponse.GetFileForUrl(testUrl));
Assert.AreEqual(file.Name, fileMatch);
testUrl = new Uri(@"https://bsaber.com/wp-json/bsaber-api/songs/?bookmarked_by=Zingabopp&page=3&count=15");
fileMatch = "bookmarked_by_zingabopp3_empty.json";
file = new FileInfo(MockHttpResponse.GetFileForUrl(testUrl));
Assert.AreEqual(file.Name, fileMatch);
}
public void WhenAuthorizeSubscriptionServiceRequestsAndForSubscriptionServiceAndUnauthenticated_ThenThrowsUnauthorized()
{
var feature = new WebhookFeature();
feature.Register(appHost);
var request = new MockHttpRequest
{
Dto = new GetSubscription()
};
var response = new MockHttpResponse(request);
Assert.That(() => feature.AuthorizeSubscriptionServiceRequests(request, response, new TestDto()), ThrowsHttpError.WithStatusCode(HttpStatusCode.Unauthorized));
}
private static JiraClientStatusKeeper LoginWithHeaders(Dictionary <string, string> headers)
{
IHttpResponse response = new MockHttpResponse <TogglEntry[]>()
{
FakeHeaders = headers
};
MockHttpDataSource source = new MockHttpDataSource();
JiraClient client = new JiraClient(FakeUsername, FakePassword, FakeServerUrl, source);
JiraClientStatusKeeper statusKeeper = new JiraClientStatusKeeper(client);
source.SetResponse(SessionUrl, "POST", response);
client.LogIn();
return(statusKeeper);
}
protected void InitMocks()
{
var mockHttpContext = new Mock <HttpContextBase>();
Context = mockHttpContext.Object;
Session = new MockHttpSession();
Request = new MockHttpRequest(new MockHttpFilesCollection(null));
Response = new MockHttpResponse();
mockHttpContext.Setup(ctx => ctx.Session).Returns(() => Session);
mockHttpContext.Setup(ctx => ctx.Request).Returns(() => Request);
mockHttpContext.Setup(ctx => ctx.Response).Returns(() => Response);
mockHttpContext.Setup(ctx => ctx.Cache).Returns(() => HttpRuntime.Cache);
}
public void Can_handle_null_HttpResult_StatusDescription()
{
var mockResponse = new MockHttpResponse();
var httpResult = new HttpResult {
StatusDescription = null
};
var responseWasAutoHandled = mockResponse.WriteToResponse(httpResult, MimeTypes.Html);
Assert.That(responseWasAutoHandled.Result, Is.True);
Assert.IsNotNull(mockResponse.StatusDescription);
}
private string ExecuteViewPage <TRequest>() where TRequest : new()
{
var responseDtoType = typeof(TRequest).Assembly.GetType(typeof(TRequest).FullName + "Response");
var responseDto = Activator.CreateInstance(responseDtoType);
var mockReq = new MockHttpRequest {
OperationName = typeof(TRequest).Name, Dto = new TRequest()
};
var mockRes = new MockHttpResponse {
Dto = responseDto
};
RazorFormat.ProcessRequest(mockReq, mockRes, responseDto);
return(mockRes.ReadAsString());
}
private static ToggleClientStatusKeeper LoginWithHeaders(Dictionary <string, string> headers)
{
IHttpResponse response = new MockHttpResponse <TogglEntry[]>()
{
FakeHeaders = headers
};
MockHttpDataSource source = new MockHttpDataSource();
TogglClient client = new TogglClient(FakeToken, source);
ToggleClientStatusKeeper statusKeeper = new ToggleClientStatusKeeper(client);
source.SetResponse(SessionUrl, "POST", response);
client.LogIn();
return(statusKeeper);
}
protected async override Task <HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
{
HttpResponseMessage response = await base.SendAsync(request, cancellationToken);
MockHttpResponse mockResponse = new MockHttpResponse()
{
Url = request.RequestUri.AbsoluteUri,
Body = request.Content != null?request.Content.ReadAsStringAsync().Result : "",
Content = response.Content != null?response.Content.ReadAsStringAsync().Result : ""
};
var responses = JsonConvert.DeserializeObject <List <MockHttpResponse> >(File.Exists(MockFilePath) ? File.ReadAllText(MockFilePath): "[]");
responses.Add(mockResponse);
File.WriteAllText(MockFilePath, JsonConvert.SerializeObject(responses, MockResponseEntry.SerializerSettings));
return(response);
}
private static string GetRazorInstanceHtml()
{
var razorFormat = RazorFormat.Instance;
var mockReq = new MockHttpRequest {
OperationName = "RazorInstance"
};
var mockRes = new MockHttpResponse();
var dto = new RockstarsResponse {
Results = Rockstar.SeedData.ToList()
};
razorFormat.ProcessRequest(mockReq, mockRes, dto);
var html = mockRes.ReadAsString();
return(html);
}
public void ProcessRequest_Returns429_IfLimitBreached()
{
var client = A.Fake <IRedisClient>();
A.CallTo(() => client.ExecLuaSha(A <string> .Ignored, A <string[]> .Ignored, A <string[]> .Ignored))
.Returns(new RedisText {
Text = new RateLimitResult {
Access = false
}.ToJson()
});
var feature = GetSut();
var response = new MockHttpResponse();
feature.ProcessRequest(new MockHttpRequest(), response, null);
response.StatusCode.Should().Be(429);
}
public void Does_process_Markdown_pages()
{
var markdownHandler = new MarkdownHandler("/AppData/NoTemplate/Static")
{
MarkdownFormat = markdownFormat,
};
var httpReq = new MockHttpRequest {
QueryString = new NameValueCollection()
};
var httpRes = new MockHttpResponse();
markdownHandler.ProcessRequest(httpReq, httpRes, "Static");
var expectedHtml = markdownFormat.Transform(
File.ReadAllText("~/AppData/NoTemplate/Static.md".MapProjectPath()));
httpRes.Close();
Assert.That(httpRes.Contents, Is.EqualTo(expectedHtml));
}
public void Benchmark_Razor_vs_Markdown()
{
var iterations = 10000;
var razorFormat = RazorFormat.Instance;
var markdownFmt = MarkdownFormat.Instance;
var dto = new RockstarsResponse {
Results = Rockstar.SeedData.ToList()
};
"Warm up MVC Razor...".Print();
var mockReq = new MockHttpRequest {
OperationName = "RockstarsRazor"
};
var mockRes = new MockHttpResponse();
razorFormat.ProcessRequest(mockReq, mockRes, dto);
mockRes.ReadAsString().Print();
"Warm up Markdown Razor...".Print();
mockReq = new MockHttpRequest {
OperationName = "RockstarsMark"
};
mockRes = new MockHttpResponse();
markdownFmt.ProcessRequest(mockReq, mockRes, dto);
mockRes.ReadAsString().Print();
"\n\nRunning for {0} times...".Fmt(iterations).Print();
CompareRuns(iterations,
"MVC Razor", () => {
mockReq = new MockHttpRequest {
OperationName = "RockstarsRazor"
};
mockRes = new MockHttpResponse();
razorFormat.ProcessRequest(mockReq, mockRes, dto);
},
"Markdown Razor", () => {
mockReq = new MockHttpRequest {
OperationName = "RockstarsMark"
};
mockRes = new MockHttpResponse();
markdownFmt.ProcessRequest(mockReq, mockRes, dto);
});
}
public void Can_change_serialization_options()
{
var mockResponse = new MockHttpResponse();
var dto = new Poco();
Assert.That(dto.ToJson(), Is.EqualTo("{}"));
var httpResult = new HttpResult(dto)
{
ResultScope = () => JsConfig.With(includeNullValues: true)
};
var reponseWasAutoHandled = mockResponse.WriteToResponse(httpResult, MimeTypes.Html);
Assert.That(reponseWasAutoHandled.Result, Is.True);
Assert.That(mockResponse.ReadAsString(), Is.EqualTo("{\"Text\":null}").Or.EqualTo("{\"text\":null}"));
}
public void Test_response_with_html_result()
{
var mockResponse = new MockHttpResponse();
const string url = "http://www.servicestack.net";
var htmlResult = Html.RedirectTo(url);
var reponseWasAutoHandled = mockResponse.WriteToResponse(htmlResult, "text/xml");
Assert.That(reponseWasAutoHandled.Result, Is.True);
var expectedOutput = string.Format(
"<html><head><meta http-equiv=\"refresh\" content=\"0;url={0}\"></head></html>", url);
var writtenString = mockResponse.ReadAsString();
Assert.That(writtenString, Is.EqualTo(expectedOutput));
Assert.That(mockResponse.Headers["Location"], Is.EqualTo(url));
}
public void ProcessRequest_ExecutesLuaScript(string sha1, RateLimitResult rateLimitResult)
{
var client = A.Fake <IRedisClient>();
A.CallTo(() => redisManager.GetClient()).Returns(client);
A.CallTo(() => limitProvider.GetRateLimitScriptId()).Returns(sha1);
A.CallTo(() => client.ExecLuaSha(A <string> .Ignored, A <string[]> .Ignored, A <string[]> .Ignored))
.Returns(new RedisText {
Text = rateLimitResult.ToJson()
});
var feature = GetSut();
var mockHttpResponse = new MockHttpResponse();
feature.ProcessRequest(new MockHttpRequest(), mockHttpResponse, null);
mockHttpResponse.Headers[Redis.Headers.HttpHeaders.RateLimitUser].Should().NotBeNullOrWhiteSpace();
mockHttpResponse.Headers[Redis.Headers.HttpHeaders.RateLimitRequest].Should().NotBeNullOrWhiteSpace();
}
public void WhenAuthorizeSubscriptionServiceRequestsAndForUpdateHistorySubscriptionAndAuthenticatedAndNoRelayRoles_ThenAuthorized()
{
var feature = new WebhookFeature {
SecureRelayRoles = null
};
feature.Register(appHost);
var request = new MockHttpRequest
{
PathInfo = new UpdateSubscriptionHistory().ToPutUrl(),
Dto = new UpdateSubscriptionHistory()
};
request.Items.Add(Keywords.Session, new AuthUserSession
{
IsAuthenticated = true
});
var response = new MockHttpResponse(request);
feature.AuthorizeSubscriptionServiceRequests(request, response, new TestDto());
}
public void WhenAuthorizeSubscriptionServiceRequestsAndForSearchSubscriptionAndAuthenticatedInRelayRole_ThenAuthorized()
{
var feature = new WebhookFeature();
feature.Register(appHost);
var request = new MockHttpRequest
{
PathInfo = new SearchSubscriptions().ToGetUrl(),
Dto = new SearchSubscriptions()
};
request.Items.Add(Keywords.Session, new AuthUserSession
{
IsAuthenticated = true,
UserAuthId = "auserid",
Roles = new List <string>(feature.SecureRelayRoles.SafeSplit(","))
});
var response = new MockHttpResponse(request);
feature.AuthorizeSubscriptionServiceRequests(request, response, new TestDto());
}
public void Test_response_with_CompressedResult()
{
using (new BasicAppHost(typeof(CompressionTests).GetAssembly()).Init())
{
var mockResponse = new MockHttpResponse();
var simpleDto = new TestCompress(1, "name");
var simpleDtoXml = DataContractSerializer.Instance.SerializeToString(simpleDto);
const string expectedXml = "<TestCompress xmlns:i=\"http://www.w3.org/2001/XMLSchema-instance\" xmlns=\"http://schemas.ddnglobal.com/types/\"><Id>1</Id><Name>name</Name></TestCompress>";
const string expectedXmlNetCore = "<TestCompress xmlns=\"http://schemas.ddnglobal.com/types/\" xmlns:i=\"http://www.w3.org/2001/XMLSchema-instance\"><Id>1</Id><Name>name</Name></TestCompress>";
Assert.That(simpleDtoXml, Is.EqualTo(expectedXml).Or.EqualTo(expectedXmlNetCore));
var simpleDtoZip = simpleDtoXml.Deflate();
Assert.That(simpleDtoZip.Length, Is.GreaterThan(0));
var compressedResult = new CompressedResult(simpleDtoZip);
var reponseWasAutoHandled = mockResponse.WriteToResponse(
compressedResult, CompressionTypes.Deflate);
Assert.That(reponseWasAutoHandled.Result, Is.True);
//var bytesToWriteToResponseStream = new byte[simpleDtoZip.Length - 4];
//Array.Copy(simpleDtoZip, CompressedResult.Adler32ChecksumLength, bytesToWriteToResponseStream, 0, bytesToWriteToResponseStream.Length);
var bytesToWriteToResponseStream = simpleDtoZip;
var writtenBytes = mockResponse.ReadAsBytes();
Assert.That(writtenBytes, Is.EqualTo(bytesToWriteToResponseStream));
Assert.That(mockResponse.ContentType, Is.EqualTo(MimeTypes.Xml));
Assert.That(mockResponse.Headers[HttpHeaders.ContentEncoding], Is.EqualTo(CompressionTypes.Deflate));
Log.Debug("Content-length: " + writtenBytes.Length);
Log.Debug(BitConverter.ToString(writtenBytes));
}
}
private void ThrowIfError <TResponse>(MockHttpResponse httpRes)
{
if (httpRes.StatusCode >= 400)
{
var webEx = new WebServiceException("WebServiceException, StatusCode: " + httpRes.StatusCode)
{
StatusCode = httpRes.StatusCode,
StatusDescription = httpRes.StatusDescription,
};
try
{
var deserializer = HostContext.ContentTypes.GetStreamDeserializer(httpReq.ResponseContentType);
webEx.ResponseDto = deserializer(typeof(TResponse), new MemoryStream(httpRes.ReadAsBytes()));
}
catch (Exception ex)
{
Console.WriteLine(ex);
}
throw webEx;
}
}
public void Can_send_ResponseText_test_with_Custom_Header()
{
var mockResponse = new MockHttpResponse();
var customText = "<h1>Custom Text</h1>";
var httpResult = new HttpResult(customText, MimeTypes.Html)
{
Headers =
{
{ "X-Custom", "Header" }
}
};
var responseWasAutoHandled = mockResponse.WriteToResponse(httpResult, MimeTypes.Html);
Assert.That(responseWasAutoHandled.Result, Is.True);
var writtenString = mockResponse.ReadAsString();
Assert.That(writtenString, Is.EqualTo(customText));
Assert.That(mockResponse.Headers["X-Custom"], Is.EqualTo("Header"));
}
public void WhenAuthorizeSubscriptionServiceRequestsAndForUpdateHistorySubscriptionAndAuthenticatedInWrongRole_ThenThrowsForbidden()
{
var feature = new WebhookFeature();
feature.Register(appHost);
var request = new MockHttpRequest
{
PathInfo = new UpdateSubscriptionHistory().ToPutUrl(),
Dto = new UpdateSubscriptionHistory()
};
request.Items.Add(Keywords.Session, new AuthUserSession
{
IsAuthenticated = true,
UserAuthId = "auserid",
Roles = new List <string> {
"anotherrole"
}
});
var response = new MockHttpResponse(request);
Assert.That(() => feature.AuthorizeSubscriptionServiceRequests(request, response, new TestDto()), ThrowsHttpError.WithStatusCode(HttpStatusCode.Forbidden));
}
public MockController(IControllerPackage <T> controllerPackage) : base(controllerPackage)
{
TextWriter = new StreamWriter(new MemoryStream());
var routeData = new RouteData();
routeData.Values.Add("controller", "PersonsController");
var view = new Mock <IView>();
var engine = new Mock <IViewEngine>();
var viewEngineResult = new ViewEngineResult(view.Object, engine.Object);
MockControllerContext.SetupGet(_ => _.HttpContext.User.Identity.Name)
.Returns("admin");
MockControllerContext.SetupGet(_ => _.HttpContext.Request.IsAuthenticated)
.Returns(true);
MockControllerContext.SetupGet(_ => _.HttpContext.Request.QueryString)
.Returns(new NameValueCollection
{
{ "fkName", "UserId" },
{ "fkValue", $"{FilteredUserId}" }
});
MockControllerContext.SetupGet(_ => _.HttpContext.User.Identity.IsAuthenticated)
.Returns(true);
MockControllerContext.SetupGet(m => m.RouteData)
.Returns(routeData);
MockControllerContext.SetupGet(_ => _.HttpContext.Response)
.Returns(MockHttpResponse.Object);
MockHttpResponse.SetupSet(_ => _.StatusCode = It.IsAny <int>())
.Callback <int>(value => _statusCode = value);
engine.Setup(e => e.FindPartialView(It.IsAny <ControllerContext>(), It.IsAny <string>(), It.IsAny <bool>()))
.Returns(viewEngineResult);
ViewEngines.Engines.Clear();
ViewEngines.Engines.Add(engine.Object);
ViewData = new ViewDataDictionary();
ControllerContext = MockControllerContext.Object;
}
protected override Task <HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
{
string url = request.RequestUri.AbsoluteUri;
if (!CallToTheAPIIndex.ContainsKey(url))
{
CallToTheAPIIndex.Add(url, 0);
}
else
{
CallToTheAPIIndex[url]++;
}
MockHttpResponse response = Responses.Where(resp => resp.Url == url).ToList()[CallToTheAPIIndex[url]];
if (response != null)
{
#pragma warning disable CA2000 // Dispose objects before losing scope
HttpResponseMessage result = new HttpResponseMessage(System.Net.HttpStatusCode.OK);
#pragma warning restore CA2000 // Dispose objects before losing scope
result.Content = new StringContent(response.Content);
return(Task.FromResult(result));
}
return(Task.FromResult(new HttpResponseMessage(System.Net.HttpStatusCode.NotFound)));
}
public void WhenAuthorizeSubscriptionServiceRequestsAndForGetSubscriptionAndAuthenticatedAndNoSubscriberRoles_ThenAuthorized()
{
var feature = new WebhookFeature {
SecureSubscriberRoles = null
};
feature.Register(appHost);
var request = new MockHttpRequest
{
PathInfo = new GetSubscription
{
Id = "asubscriptionid"
}.ToGetUrl(),
Dto = new GetSubscription()
};
request.Items.Add(Keywords.Session, new AuthUserSession
{
IsAuthenticated = true
});
var response = new MockHttpResponse(request);
feature.AuthorizeSubscriptionServiceRequests(request, response, new TestDto());
}
public IEnumerator SendRequest(IHttpRequest request, Action <IHttpResponse> responseCallback)
{
string requestBody = System.Text.Encoding.UTF8.GetString(request.BodyBytes);
MockHttpResponse response = null;
string responseTemplate =
@"{{
""access_token"": ""{0}"",
""bans"":
[
{{
""Ban"": """",
""EndDate"": ""2019-07-05T01:59:45.046Z""
}}
],
""display_name"": ""string"",
""expires_in"": 3,
""jflgs"": 0,
""namespace"": ""string"",
""permissions"":
[
{{
""Action"": 0,
""Resource"": ""string"",
""SchedAction"": 0,
""SchedCron"": ""string"",
""SchedRange"": [ ""string"" ]
}}
],
""platform_id"": ""string"",
""platform_user_id"": ""string"",
""refresh_token"": ""{1}"",
""roles"": [ ""string"" ],
""token_type"": ""string"",
""user_id"": ""string""
}}";
if (requestBody.Contains("device_id"))
{
response = new MockHttpResponse
{
Url = request.Url,
Code = 200,
Body = string.Format(responseTemplate, "first_access_token", "first_refresh_token")
};
}
else if (requestBody.Contains("refresh_token"))
{
response = new MockHttpResponse
{
Url = request.Url,
Code = 200
};
switch (requestBody.Substring(requestBody.IndexOf("refresh_token=") + 14))
{
case "first_refresh_token":
response.Body = string.Format(
responseTemplate,
"second_access_token",
"second_refresh_token");
break;
case "second_refresh_token":
response.Body = string.Format(
responseTemplate,
"third_access_token",
"third_refresh_token");
break;
default:
response.Body = string.Format(responseTemplate, "last_access_token", "last_refresh_token");
break;
}
}
responseCallback(response);
yield break;
}
public void ProcessRequest_ReturnsCustomCode_IfSetAndLimitBreached()
{
const int statusCode = 503;
var client = A.Fake<IRedisClient>();
A.CallTo(() => client.ExecLuaSha(A<string>.Ignored, A<string[]>.Ignored, A<string[]>.Ignored))
.Returns(new RedisText { Text = new RateLimitResult { Access = false }.ToJson() });
var feature = GetSut();
feature.LimitStatusCode = statusCode;
var response = new MockHttpResponse();
feature.ProcessRequest(new MockHttpRequest(), response, null);
response.StatusCode.Should().Be(statusCode);
}
public DirectServiceClient(ServiceController serviceController)
{
this.ServiceController = serviceController;
httpReq = new MockHttpRequest();
httpRes = new MockHttpResponse(httpReq);
}
public void ProcessRequest_ExecutesLuaScript(string sha1, RateLimitResult rateLimitResult)
{
var client = A.Fake<IRedisClient>();
A.CallTo(() => redisManager.GetClient()).Returns(client);
A.CallTo(() => limitProvider.GetRateLimitScriptId()).Returns(sha1);
A.CallTo(() => client.ExecLuaSha(A<string>.Ignored, A<string[]>.Ignored, A<string[]>.Ignored))
.Returns(new RedisText { Text = rateLimitResult.ToJson() });
var feature = GetSut();
var mockHttpResponse = new MockHttpResponse();
feature.ProcessRequest(new MockHttpRequest(), mockHttpResponse, null);
mockHttpResponse.Headers[Redis.Headers.HttpHeaders.RateLimitUser].Should().NotBeNullOrWhiteSpace();
mockHttpResponse.Headers[Redis.Headers.HttpHeaders.RateLimitRequest].Should().NotBeNullOrWhiteSpace();
}
