public void EncodesSpecialCharactersInFormBody()
{
var port = new AwaitedPort(new TestPort()).Value();
string body = "";
using (var server =
new HttpMock(port,
new FkWire(req =>
{
body = new TextBody.Of(req).AsString();
})
).Value()
)
{
new Verified(
new AspNetCoreWire(
new AspNetCoreClients(),
new TimeSpan(0, 1, 0)
),
new ExpectedStatus(200)
).Response(
new Get(
new Scheme("http"),
new Host("localhost"),
new Port(server.Port),
new FormParam("key-name", "test&+=xyz"),
new BearerTokenAuth("Bearer sdfnhiausihfnksajn")
)
);
}
Assert.Equal(
"key-name=test%26%2B%3Dxyz",
body
);
}
public void SendsHeaders()
{
var port = new AwaitedPort(new TestPort()).Value();
var header = "";
using (var server =
new HttpMock(port,
new FkWire(req =>
{
header = new FirstOf <string>(new Authorization.Of(req)).Value();
return(new Response.Of(200, "OK"));
})
).Value()
)
{
new AspNetCoreWire(
new AspNetCoreClients(),
new TimeSpan(0, 1, 0)
).Response(
new Get(
new Scheme("http"),
new Host("localhost"),
new Port(server.Port),
new Header("Authorization", "Basic dXNlcjpwYXNzd29yZA==")
)
).Wait(30000);
}
Assert.Equal(
"Basic dXNlcjpwYXNzd29yZA==",
header
);
}
public void ReturnsBody()
{
var port = new AwaitedPort(new TestPort()).Value();
using (var server =
new HttpMock(port,
new FkWire(
new TextOf("very important content")
)
).Value()
)
{
Assert.Equal(
"very important content",
new TextOf(
new Body.Of(
new AspNetCoreWire(
new AspNetCoreClients(),
new TimeSpan(0, 1, 0)
).Response(
new Get(
new Scheme("http"),
new Host("localhost"),
new Port(server.Port)
)
)
)
).AsString()
);
}
}
public void Returns200()
{
var port = new AwaitedPort(new TestPort()).Value();
using (var server =
new HttpMock(port,
new FkWire()
).Value()
)
{
Assert.Equal(
200,
new Status.Of(
new AspNetCoreWire(
new AspNetCoreClients(),
new TimeSpan(0, 1, 0)
).Response(
new Get(
new Scheme("http"),
new Host("localhost"),
new Port(server.Port),
new Path("test/asdf")
)
)
).AsInt()
);
}
}
public void DeliversXmlResponse()
{
var port = new AwaitedPort(new TestPort()).Value();
using (var server =
new HttpMock(port,
new FkWire(req =>
{
return(new Response.Of(new Body(new XMLCursor(new InputOf("<test/>")))));
})
).Value()
)
{
var response =
AsyncContext.Run(() =>
new AspNetCoreWire(
new AspNetCoreClients(),
new TimeSpan(0, 1, 0)
).Response(
new Get($"http://localhost:{port}?importantQueryParam=importantValue")
)
);
Assert.True(
response.ContainsKey("body")
);
}
}
public async Task rename_via_ContentDisposition()
{
var test_file_base64 = "dGVzdA==";
var test_plaintext = "test";
var expectedFilename = "file.aax";
try
{
var response = new HttpResponseMessage
{
Content = new ByteArrayContent(Convert.FromBase64String(test_file_base64))
};
response.Content.Headers.ContentDisposition = new System.Net.Http.Headers.ContentDispositionHeaderValue("attachment")
{
FileName = "foo_ep6.aax"
};
var client = new HttpClient(HttpMock.GetHandler(response));
var finalFile = await client.DownloadFileAsync("http://t.co.uk/downloadme?a=1", "file.xyz");
await Task.Delay(100);
finalFile.Should().Be(expectedFilename);
File.Exists(expectedFilename).Should().BeTrue();
File.ReadAllText(expectedFilename).Should().Be(test_plaintext);
}
finally
{
File.Delete(expectedFilename);
}
}
public void ListensToAnyPath()
{
var port = new AwaitedPort(new TestPort()).Value();
var clients = new AspNetCoreClients();
var requests = 0;
using (var server =
new HttpMock(port,
new FkWire(req =>
{
requests++;
return(new Response.Of(200, "OK"));
})
).Value()
)
{
Task.WaitAll(
new AspNetCoreWire(clients, new TimeSpan(0, 1, 0)).Response(
new Get($"http://localhost:{port}")
),
new AspNetCoreWire(clients, new TimeSpan(0, 1, 0)).Response(
new Get($"http://localhost:{port}/path")
),
new AspNetCoreWire(clients, new TimeSpan(0, 1, 0)).Response(
new Get($"http://localhost:{port}/another/path")
)
);
}
Assert.Equal(
3,
requests
);
}
public void ConfigureSessionResponseShouldThrowForNonSuccessCode()
{
using (var httpResponseMessage = new HttpResponseMessage
{
StatusCode = HttpStatusCode.BadRequest,
Content = new StringContent("{}")
})
{
SandboxClient docScanSandboxClient;
Mock <HttpMessageHandler> handlerMock = HttpMock.SetupMockMessageHandler(httpResponseMessage);
using var httpClient = new HttpClient(handlerMock.Object);
docScanSandboxClient = SandboxClient.Builder(httpClient)
.WithClientSdkId(_someSdkId)
.WithKeyPair(KeyPair.Get())
.Build();
var exception = Assert.Throws <SandboxException>(() =>
{
docScanSandboxClient.ConfigureSessionResponse(
_someSessionId,
_sandboxResponseConfig);
});
Assert.Contains("Failed validation - Status Code: '400' (BadRequest). Content: '{}'", exception.Message, StringComparison.Ordinal);
};
}
public void SendsBody()
{
var port = new AwaitedPort(new TestPort()).Value();
var body = "";
using (var server =
new HttpMock(port,
new FkWire(req =>
{
body =
new TextOf(
new Body.Of(req)
).AsString();
return(new Response.Of(200, "OK"));
})
).Value()
)
{
new AspNetCoreWire(
new AspNetCoreClients(),
new TimeSpan(0, 1, 0)
).Response(
new Get(
new Scheme("http"),
new Host("localhost"),
new Port(server.Port),
new TextBody("very important content")
)
).Wait(30000);
}
Assert.Equal(
"very important content",
body
);
}
public void ForwardsQueryParams()
{
var port = new AwaitedPort(new TestPort()).Value();
var queryParam = "";
using (var server =
new HttpMock(port,
new FkWire(req =>
{
queryParam = new QueryParam.Of(req, "importantQueryParam").AsString();
return(new Response.Of(200, "OK"));
})
).Value()
)
{
new AspNetCoreWire(
new AspNetCoreClients(),
new TimeSpan(0, 1, 0)
).Response(
new Get($"http://localhost:{port}?importantQueryParam=importantValue")
).Wait(30000);
}
Assert.Equal(
"importantValue",
queryParam
);
}
public async Task DelegatingHandlerMultiTestWithDuplicate()
{
var handler = HttpMock.Mock()
.For("/test1")
.Accepts("request1")
.Returns("response1")
.For("/test2")
.Accepts("request2")
.Returns("response2")
.For("/test2")
.Accepts("request2")
.Returns("response2")
.BuildDelegatingHandler(() => new FakeDelegatingHandler());
var responses = await handler.Invoke();
int counter = 1;
foreach (var response in responses)
{
response.StatusCode.Should().Be(HttpStatusCode.OK);
var data = await response.GetContentAsStringAsync();
data.Should().Be($"response{counter}request{counter}");
counter++;
}
}
public void SetupSharingProfileShouldReturnToken()
{
string tokenValue = "kyHPjq2+Y48cx+9yS/XzmW09jVUylSdhbP+3Q9Tc9p6bCEnyfa8vj38";
using (var httpResponseMessage = new HttpResponseMessage
{
StatusCode = HttpStatusCode.OK,
Content = new StringContent("{\"token\": \"" + tokenValue + "\"}")
})
{
SandboxClient yotiSandboxClient;
Mock <HttpMessageHandler> handlerMock = HttpMock.SetupMockMessageHandler(httpResponseMessage);
using var httpClient = new HttpClient(handlerMock.Object);
yotiSandboxClient = new SandboxClientBuilder(httpClient)
.WithClientSdkId(_someSdkId)
.WithKeyPair(KeyPair.Get())
.Build();
string result = yotiSandboxClient.SetupSharingProfile(
_yotiTokenRequest);
Assert.Equal(tokenValue, result);
};
}
public void Returns404()
{
var port = new AwaitedPort(new TestPort()).Value();
using (var server =
new HttpMock(port,
new KvpOf <IWire>("path",
new FkWire()
)
).Value()
)
{
Assert.Equal(
404,
new Status.Of(
new AspNetCoreWire(
new AspNetCoreClients(),
new TimeSpan(0, 1, 0)
).Response(
new Get($"http://localhost:{port}/unknown/path")
)
).AsInt()
);
}
}
public void SetupSharingProfileShouldThrowForNonSuccessCode()
{
using (var httpResponseMessage = new HttpResponseMessage
{
StatusCode = HttpStatusCode.BadRequest,
Content = new StringContent("{}")
})
{
SandboxClient yotiSandboxClient;
Mock <HttpMessageHandler> handlerMock = HttpMock.SetupMockMessageHandler(httpResponseMessage);
using var httpClient = new HttpClient(handlerMock.Object);
yotiSandboxClient = new SandboxClientBuilder(httpClient)
.WithClientSdkId(_someSdkId)
.WithKeyPair(KeyPair.Get())
.Build();
var exception = Assert.Throws <SandboxException>(() =>
{
yotiSandboxClient.SetupSharingProfile(
_yotiTokenRequest);
});
Assert.Contains("Error when setting up sharing profile", exception.Message, StringComparison.Ordinal);
};
}
public void SetupServer(string baseUrl)
{
if (HttpMock == null)
{
HttpMock = new HttpMock();
HttpMock.Start(baseUrl);
}
}
public void Initialize()
{
httpServiceMock = new HttpMock();
fooResponse = new Foo()
{
UserName = userName, Password = password
};
fakeHttpMessageHandler = new Mock <FakeHttpMessageHandler> {
CallBase = true
};
HttpService.http = new HttpClient(fakeHttpMessageHandler.Object);
}
public void SetUp()
{
HttpMock httpMock = new HttpMock();
HttpContext.Current = httpMock.HttpContext;
service = Substitute.For <IAccountService>();
accountId = HttpContext.Current.User.Identity.Name;
service.AccountExists(accountId).Returns(true);
controller = new HomeController(service);
controller.ControllerContext = new ControllerContext();
controller.ControllerContext.HttpContext = httpMock.HttpContextBase;
}
public void SetUp()
{
HttpMock httpMock = new HttpMock();
Authorization.Provider = Substitute.For <IAuthorizationProvider>();
accountId = httpMock.HttpContextBase.User.Identity.Name;
controller = Substitute.ForPartsOf <BaseControllerProxy>();
controller.Url = new UrlHelper(httpMock.HttpContext.Request.RequestContext);
controller.ControllerContext = new ControllerContext(
httpMock.HttpContextBase,
httpMock.HttpContextBase.Request.RequestContext.RouteData,
controller);
}
public void SetupServer()
{
const string url = "http://localhost:8888/";
_httpMock = new HttpMock();
_httpMock.Start(url);
_httpMock.Add("POST", UrlPath,
(request, response) =>
{
PathWasCalled = true;
CallCount++;
response.StatusCode = (int)HttpStatusCode.OK;
});
}
public async Task HttpClientAnyTest()
{
var client = HttpMock.Mock()
.For()
.AcceptsAny()
.Returns("response")
.BuildClient();
var response = await client.PostAsync(string.Empty, It.IsAny <HttpContent>());
response.StatusCode.Should().Be(HttpStatusCode.OK);
var data = await response.GetContentAsStringAsync();
data.Should().Be("response");
}
public async Task DelegatingHandlerSingleTest()
{
var handler = HttpMock.Mock()
.For()
.Accepts("request")
.Returns("response")
.BuildDelegatingHandler(() => new FakeDelegatingHandler());
var response = await handler.InvokeSingle();
response.StatusCode.Should().Be(HttpStatusCode.OK);
var data = await response.GetContentAsStringAsync();
data.Should().Be("responserequest");
}
public void RoutesToPath()
{
var port = new AwaitedPort(new TestPort()).Value();
var clients = new AspNetCoreClients();
var result = 0;
using (var server =
new HttpMock(port,
new KvpOf <IWire>("",
new FkWire(req =>
{
result += 1;
return(new Response.Of(200, "OK"));
})
),
new KvpOf <IWire>("path",
new FkWire(req =>
{
result += 2;
return(new Response.Of(200, "OK"));
})
),
new KvpOf <IWire>("another/path",
new FkWire(req =>
{
result += 4;
return(new Response.Of(200, "OK"));
})
)
).Value()
)
{
Task.WaitAll(
new AspNetCoreWire(clients, new TimeSpan(0, 1, 0)).Response(
new Get($"http://localhost:{port}")
),
new AspNetCoreWire(clients, new TimeSpan(0, 1, 0)).Response(
new Get($"http://localhost:{port}/path")
),
new AspNetCoreWire(clients, new TimeSpan(0, 1, 0)).Response(
new Get($"http://localhost:{port}/another/path")
)
);
}
Assert.Equal(
7,
result
);
}
public async Task HttpClientFactoryTestWithEmptyName()
{
var factory = HttpMock.Mock()
.For()
.Accepts("request")
.Returns("response")
.BuildFactory();
using (var client = factory.CreateClient())
{
var response = await client.PostAsync(string.Empty, It.IsAny <HttpContent>());
response.StatusCode.Should().Be(HttpStatusCode.OK);
var data = await response.GetContentAsStringAsync();
data.Should().Be("response");
}
}
public void HandleUnauthorizedRequest_RedirectsToLogin()
{
GlobalizedAuthorizeAttributeProxy attribute = new GlobalizedAuthorizeAttributeProxy();
AuthorizationContext context = new AuthorizationContext();
HttpContextBase http = new HttpMock().HttpContextBase;
context.RouteData = http.Request.RequestContext.RouteData;
context.HttpContext = http;
attribute.BaseHandleUnauthorizedRequest(context);
RedirectToRouteResult actual = context.Result as RedirectToRouteResult;
Assert.AreEqual(context.RouteData.Values["language"], actual.RouteValues["language"]);
Assert.AreEqual(context.HttpContext.Request.RawUrl, actual.RouteValues["returnUrl"]);
Assert.AreEqual(String.Empty, actual.RouteValues["area"]);
Assert.AreEqual("Auth", actual.RouteValues["controller"]);
Assert.AreEqual("Login", actual.RouteValues["action"]);
}
public async Task HttpClientTypedModelTest()
{
var client = HttpMock.Mock()
.For()
.Accepts(new FakeInput {
Id = "1"
})
.Returns(new FakeOutput {
Id = "1"
})
.BuildClient();
var response = await client.PostAsync(string.Empty, It.IsAny <HttpContent>());
response.StatusCode.Should().Be(HttpStatusCode.OK);
var data = await response.GetContentAsStringAsync();
var model = JsonConvert.DeserializeObject <FakeOutput>(data);
model.Id.Should().Be("1");
}
public void HttpTriggerTest()
{
_mockLogger.LogInformation("HttpTriggerTest started");
var query = new Dictionary <String, StringValues>();
var header = new Dictionary <String, StringValues>();
string body = "";
var req = HttpMock.HttpRequestSetup(header, query, body);
var HttpTriggerFunc = new AzureFunctions.Api.Functions.HttpTrigger(_configManager);
var result = HttpTriggerFunc.Run(req, _mockLogger).Result;
OkObjectResult res = (OkObjectResult)result;
string outputStr = res.Value.ToString();
Assert.False(string.IsNullOrEmpty(res.Value.ToString()));
Assert.Contains("Success", outputStr);
}
public void ConfigureSessionResponseShouldNotThrowException()
{
using (var httpResponseMessage = new HttpResponseMessage
{
StatusCode = HttpStatusCode.OK
})
{
SandboxClient docScanSandboxClient;
Mock <HttpMessageHandler> handlerMock = HttpMock.SetupMockMessageHandler(httpResponseMessage);
using var httpClient = new HttpClient(handlerMock.Object);
docScanSandboxClient = SandboxClient.Builder(httpClient)
.WithClientSdkId(_someSdkId)
.WithKeyPair(KeyPair.Get())
.Build();
docScanSandboxClient.ConfigureSessionResponse(
_someSessionId,
_sandboxResponseConfig);
};
}
static void Main()
{
HttpMock httpMock = new HttpMock();
httpMock.Start("http://localhost:8000/");
httpMock.Add("GET", "/test", (request, response) =>
{
Thread.Sleep(3000);
response.SetBody($"{request}\r\nFoo!");
});
httpMock.Add("GET", "/", (request, response) => response.SetBody($"{request}\r\nWoah!"));
httpMock.Add((request, response) => response.SetBody($"{request}\r\rMini Wild!"));
httpMock.Add("GET", "/test", (request, response) => response.SetBody($"{request}\r\nBOOO!"));
Console.WriteLine("Enter to exit...");
Console.ReadLine();
}
public void ReturnsMultipleHeaderValues(string expected)
{
var port = new AwaitedPort(new TestPort()).Value();
using (var server =
new HttpMock(port,
new FkWire(req =>
{
return
(new Response.Of(200, "OK",
new ManyOf <IKvp>(
new KvpOf("Allow", "DELETE"),
new KvpOf("Allow", "GET"),
new KvpOf("Allow", "POST"),
new KvpOf("Allow", "PUT")
)
));
})
).Value()
)
{
Assert.Contains(
expected,
new Header.Of(
new AspNetCoreWire(
new AspNetCoreClients(),
new TimeSpan(0, 1, 0)
).Response(
new Get(
new Scheme("http"),
new Host("localhost"),
new Port(server.Port)
)
),
"Allow"
)
);
}
}
public void TransmitsZipFile()
{
var port = new AwaitedPort(new TestPort()).Value();
using (var server =
new HttpMock(port,
new FkWire(req =>
new Response.Of(
new Status(200),
new Reason("OK"),
new Body(
new ResourceOf(
"Assets/test.zip",
this.GetType().Assembly
),
"application/zip"
)
)
)
).Value()
)
{
Assert.Equal(
"this is a test", // content of test.txt in Assets/test.zip
new TextOf(
new UnzippedFile(
new Body.Of(
new AspNetCoreWire(
new AspNetCoreClients()
).Response(
new Get($"http://localhost:{port}/")
)
),
"test.txt"
)
).AsString()
);
}
}
