public async Task ValidCasesAsync(WebHook validWebHook)
{
var schema = new OpenApiSchema
{
Properties = new Dictionary <string, OpenApiSchema>
{
["param1"] = new OpenApiSchema {
Type = "integer"
},
["param2"] = new OpenApiSchema {
Type = "string"
},
}
};
var triggersById = new Dictionary <string, WebHookTrigger>
{
["valid"] = new WebHookTrigger {
Id = "valid", Schema = schema
},
};
var triggers = new Mock <IWebHookTriggerProvider>();
triggers.Setup(s => s.GetAvailableTriggers()).Returns(triggersById);
var logger = new Mock <ILogger <DefaultWebHookValidator> >();
var client = HttpClientMocker.ReturnQueryParam("echo");
var service = new DefaultWebHookValidator(triggers.Object, logger.Object, client);
await service.ValidateAsync(validWebHook);
Assert.NotEqual(default, validWebHook.Id);
public void ArgNullEfSender()
{
var logger = new Mock <ILogger <EFWebHookSender <TestContext1> > >();
var httpClient = HttpClientMocker.Static(System.Net.HttpStatusCode.OK, "");
var signature = new Mock <ISignatureService>();
Assert.Throws <ArgumentNullException>(() => new EFWebHookSender <TestContext1>(httpClient, signature.Object, logger.Object, null));
}
public async Task Delete_WhenNoRequestContentIsSent_RequestContentShouldBeNull()
{
var mocker = HttpClientMocker.Create();
var client = mocker.Build();
await client.DeleteAsync("https://path.to.url");
Assert.Null(mocker.RequestContent);
}
public async Task Patch_WhenRequestContentIsSent_GetsResponse()
{
var requestContent = "request content";
var mocker = HttpClientMocker.Create();
var client = mocker.Build();
await client.PatchAsync("https://path.to.url", new StringContent(requestContent));
Assert.Equal(requestContent, mocker.RequestContent);
}
public async Task RetrievesAbsoluteUri()
{
var expectedUrl = "https://path.to.url/";
var mocker = HttpClientMocker.Create();
var client = mocker.Build();
await client.PostAsync(expectedUrl, new ByteArrayContent(new byte[] {}));
Assert.Equal(expectedUrl, mocker.AbsoluteRequestUri);
}
public async Task RetrievesRequestContent()
{
var expectedRequestContent = "request content";
var mocker = HttpClientMocker.Create();
var client = mocker.Build();
await client.PostAsync("https://path.to.url/", new StringContent(expectedRequestContent));
Assert.Equal(expectedRequestContent, mocker.RequestContent);
}
public async Task ArgNullAsync()
{
var logger = new Mock <ILogger <DefaultWebHookSender> >();
var httpClient = HttpClientMocker.Static(System.Net.HttpStatusCode.OK, "");
var signature = new Mock <ISignatureService>();
Assert.Throws <ArgumentNullException>(() => new DefaultWebHookSender(null, signature.Object, logger.Object));
Assert.Throws <ArgumentNullException>(() => new DefaultWebHookSender(httpClient, null, logger.Object));
Assert.Throws <ArgumentNullException>(() => new DefaultWebHookSender(httpClient, signature.Object, null));
var service = new DefaultWebHookSender(httpClient, signature.Object, logger.Object);
await Assert.ThrowsAsync <ArgumentNullException>(() => service.SendAsync(null, CancellationToken.None));
}
public async Task SetBaseUrl()
{
var requestContent = "request content";
var mocker = HttpClientMocker.Create();
mocker.SetBaseRequestUri("http://www.path.to");
var client = mocker.Build();
await client.PatchAsync("endpoint", new StringContent(requestContent));
Assert.Equal("http://www.path.to/endpoint", mocker.AbsoluteRequestUri);
}
public async Task SetsResponseStatusCode()
{
var mocker = HttpClientMocker.Create();
mocker.When.RequestMessageStringIs("request content")
.Then.ResponseShouldBe(null, HttpStatusCode.Accepted);
var client = mocker.Build();
var response = await client.PostAsync("https://path.to.url/", new StringContent("request content"));
Assert.Equal(HttpStatusCode.Accepted, response.StatusCode);
}
public async Task WhenExpectedRequestContentIsNotSent_ShouldNotReturnExpectedResponse()
{
var responseContent = "response content";
var mocker = HttpClientMocker.Create();
mocker.When.RequestMessageStringIs(responseContent)
.Then.ResponseShouldBe("response content");
var client = mocker.Build();
var response = await client.PostAsync("https://path.to.url/", new StringContent("other request content"));
Assert.NotEqual(responseContent, await response.Content.ReadAsStringAsync());
}
public async Task TaxAssessmentServiceShouldReturnData()
{
_mockedService = new TaxAssessmentServiceMocked();
_httpClient =
HttpClientMocker.SetupHttpClientMock(Url,
await CreateTaxAssessmentAsString().ConfigureAwait(false));
_service = new TaxAssessmentService(_httpClient);
var result = _service.GetTaxAssessment();
Assert.NotNull(result);
}
public async Task PopulationInNorwayServiceShouldReturnData()
{
_mockedService = new PopulationInNorwayServiceMocked();
_httpClient =
HttpClientMocker.SetupHttpClientMock(Url,
await CreatePopulationInNorwayAsString().ConfigureAwait(false));
_service = new PopulationInNorwayService(_httpClient);
var result = _service.GetPopulationsInNorway();
Assert.NotNull(result);
}
public async Task HttpGet_WhenExpectationFails_NoContentBodyIsReturned()
{
var requestUrl = "https://path.to.url";
var responseContent = "response content";
var mocker = HttpClientMocker.Create();
mocker.When.AbsoluteUrlIs(requestUrl)
.Then.ResponseShouldBe(responseContent);
var client = mocker.Build();
var response = await client.GetAsync("https://path.to.otherurl/");
Assert.NotEqual(responseContent, await response.Content.ReadAsStringAsync());
}
public async Task WhenNotExpectedRequestUriIsCalled_DoNotReturnExpectedContentasAResponse()
{
var responseContent = "content";
var mocker = HttpClientMocker.Create();
mocker.When.AbsoluteUrlIs("https://path.to.url/")
.Then.ResponseShouldBe(responseContent);
var client = mocker.Build();
var response = await client.GetAsync("https://path.to.anotherurl/");
Assert.NotEqual(responseContent, await response.Content.ReadAsStringAsync());
}
public async Task ShouldReturnEmptyResponse()
{
var mocker = HttpClientMocker.Create();
mocker.When.RequestMessageStringIs("request content")
.Then.ResponseShouldBe(null);
var client = mocker.Build();
var response = await client.PostAsync("https://path.to.url/", new StringContent("request content"));
var content = Assert.IsType <ByteArrayContent>(response.Content);
Assert.Empty(await content.ReadAsByteArrayAsync());
}
public async Task WhenUriIsSet_ExpectUri()
{
var responseContent = "content";
var requestUrl = "https://path.to.url/";
var mocker = HttpClientMocker.Create();
mocker.When.AbsoluteUrlIs(requestUrl)
.Then.ResponseShouldBe(responseContent);
var client = mocker.Build();
var response = await client.GetAsync(requestUrl);
Assert.Equal(responseContent, await response.Content.ReadAsStringAsync());
}
public async Task NormalScenarioAsync(Dictionary <string, object> payload)
{
var logger = new Mock <ILogger <DefaultWebHookSender> >();
var signature = "FIXED_SIGNATURE";
var signatureService = new Mock <ISignatureService>();
signatureService.Setup(s => s.GetSignature(It.IsAny <string>(), It.IsAny <string>())).Returns(signature);
var webHook = new WebHook {
Callback = new Uri("http://www.example.com")
};
var notif = new WebHookNotification {
TriggerId = "noun.verb", Payload = payload
};
var callbackHasBeenCalled = false;
var httpClient = HttpClientMocker.Callback(async m =>
{
callbackHasBeenCalled = true;
Assert.Equal(HttpMethod.Post, m.Method);
Assert.Equal(webHook.Callback, m.RequestUri);
var content = JsonConvert.DeserializeObject <Dictionary <string, string> >(await m.Content.ReadAsStringAsync());
Assert.NotNull(content);
Assert.Contains(DefaultWebHookSender.TriggerKey, content.Keys);
Assert.Equal(notif.TriggerId, content[DefaultWebHookSender.TriggerKey]);
Assert.Contains(DefaultWebHookSender.TimestampKey, content.Keys);
Assert.Contains(DefaultWebHookSender.UniqueIdKey, content.Keys);
if (notif.Payload != null)
{
foreach (var kvp in notif.Payload)
{
Assert.Contains(kvp.Key, content.Keys);
Assert.Equal(kvp.Value, content[kvp.Key]);
}
}
Assert.Contains(DefaultWebHookSender.SignatureHeader, m.Headers.Select(kvp => kvp.Key));
Assert.Equal(signature, m.Headers.GetValues(DefaultWebHookSender.SignatureHeader).First());
});
var service = new CounterDefaultWebHookSender(httpClient, signatureService.Object, logger.Object);
await service.SendAsync(new WebHookWorkItem(notif, webHook), CancellationToken.None);
Assert.True(callbackHasBeenCalled);
Assert.Equal(1, service.Successes);
}
public async Task ValidCasesAsync(WebHook validWebHook)
{
var triggersById = new Dictionary <string, WebHookTrigger>
{
["valid"] = new WebHookTrigger("valid"),
};
var triggers = new Mock <IWebHookTriggerProvider>();
triggers.Setup(s => s.GetAvailableTriggers()).Returns(triggersById);
var logger = new Mock <ILogger <DefaultWebHookValidator> >();
var client = HttpClientMocker.ReturnQueryParam("echo");
var service = new DefaultWebHookValidator(triggers.Object, logger.Object, client);
await service.ValidateAsync(validWebHook);
Assert.NotEqual(default, validWebHook.Id);
public async Task CanSetTwoExpectations()
{
var expectedUrl = "https://path.to.url/";
var expectedRequestContent = "request content";
var mocker = HttpClientMocker.Create();
mocker.When.AbsoluteUrlIs(expectedUrl)
.And.RequestMessageStringIs(expectedRequestContent)
.Then.ResponseShouldBe("response content");
var client = mocker.Build();
await client.PostAsync(expectedUrl, new StringContent(expectedRequestContent));
Assert.Equal(expectedUrl, mocker.AbsoluteRequestUri);
Assert.Equal(expectedRequestContent, mocker.RequestContent);
}
public async Task CanSetTwoExpectations_WhenSomeExpectationsAreNotMet_ExpectedResponseShouldNotBeReturned()
{
var requestUrl = "https://path.to.url/";
var expectedRequestContent = "request content";
var responseContent = "response content";
var mocker = HttpClientMocker.Create();
mocker.When.AbsoluteUrlIs(requestUrl)
.And.RequestMessageStringIs(expectedRequestContent)
.Then.ResponseShouldBe(responseContent);
var client = mocker.Build();
var response = await client.PostAsync("https://path.to.otherurl/", new StringContent(expectedRequestContent));
Assert.NotEqual(responseContent, await response.Content.ReadAsStringAsync());
}
public async Task ErrorScenarioAsync()
{
var logger = new Mock <ILogger <DefaultWebHookSender> >();
var signature = new Mock <ISignatureService>();
var webHook = new WebHook {
Callback = new Uri("http://www.example.com")
};
var notif = new WebHookNotification {
TriggerId = "noun.verb"
};
var httpClient = HttpClientMocker.AlwaysFail(new Exception());
var service = new CounterDefaultWebHookSender(httpClient, signature.Object, logger.Object);
await service.SendAsync(new WebHookWorkItem(notif, webHook), CancellationToken.None);
Assert.Equal(1, service.Failures);
}
public async Task NotFoundScenarioAsync(System.Net.HttpStatusCode code)
{
var logger = new Mock <ILogger <DefaultWebHookSender> >();
var signature = new Mock <ISignatureService>();
var webHook = new WebHook {
Callback = new Uri("http://www.example.com")
};
var notif = new WebHookNotification {
TriggerId = "noun.verb"
};
var httpClient = HttpClientMocker.Static(code, "");
var service = new CounterDefaultWebHookSender(httpClient, signature.Object, logger.Object);
await service.SendAsync(new WebHookWorkItem(notif, webHook), CancellationToken.None);
Assert.Equal(1, service.NotFounds);
}
public async Task NotFoundScenarioAsync(System.Net.HttpStatusCode code)
{
var logger = new Mock <ILogger <EFWebHookSender <TestContext1> > >();
var signature = new Mock <ISignatureService>();
var context = _fixture.Provider.GetRequiredService <TestContext1>();
var webHook = AddWebHook(context, Guid.NewGuid(), "myPrincipalxxx", "noun.verb", false, null);
webHook.Callback = new Uri("http://example.org");
await context.SaveChangesAsync();
var notif = new WebHookNotification {
TriggerId = "noun.verb"
};
var httpClient = HttpClientMocker.Static(code, "");
var service = new EFWebHookSender <TestContext1>(httpClient, signature.Object, logger.Object, context);
await service.SendAsync(new WebHookWorkItem(notif, webHook), CancellationToken.None);
Assert.True((await context.WebHooks.FirstAsync(w => w.Id == webHook.Id)).IsPaused);
}
public async Task InvalidCasesAsync()
{
var triggersById = new Dictionary <string, WebHookTrigger>
{
["valid"] = new WebHookTrigger("valid")
};
var triggers = new Mock <IWebHookTriggerProvider>();
triggers.Setup(s => s.GetAvailableTriggers()).Returns(triggersById);
var logger = new Mock <ILogger <DefaultWebHookValidator> >();
var client = HttpClientMocker.Static(System.Net.HttpStatusCode.NotFound, "fail");
var service = new DefaultWebHookValidator(triggers.Object, logger.Object, client);
await Assert.ThrowsAsync <ArgumentException>(() => service.ValidateAsync(new WebHook {
Secret = "too short"
}));
await Assert.ThrowsAsync <ArgumentException>(() => service.ValidateAsync(new WebHook {
Secret = "toolong_toolong_toolong_toolong_toolong_toolong_toolong_toolong_toolong_toolong_toolong_toolong_toolong_toolong_toolong_toolong_toolong_toolong_toolong_toolong_"
}));
await Assert.ThrowsAsync <ArgumentException>(() => service.ValidateAsync(new WebHook()));
await Assert.ThrowsAsync <ArgumentException>(() => service.ValidateAsync(new WebHook {
Filters = new List <WebHookFilter>()
}));
await Assert.ThrowsAsync <ArgumentException>(() => service.ValidateAsync(new WebHook {
Filters = new List <WebHookFilter> {
new WebHookFilter {
Trigger = "invalid"
}
}
}));
await Assert.ThrowsAsync <ArgumentException>(() => service.ValidateAsync(new WebHook {
Filters = new List <WebHookFilter> {
new WebHookFilter {
Trigger = "valid"
}
}
}));
await Assert.ThrowsAsync <ArgumentException>(() => service.ValidateAsync(new WebHook {
Filters = new List <WebHookFilter> {
new WebHookFilter {
Trigger = "valid"
}
}, Callback = "c:/data"
}));
await Assert.ThrowsAsync <ArgumentException>(() => service.ValidateAsync(new WebHook {
Filters = new List <WebHookFilter> {
new WebHookFilter {
Trigger = "valid"
}
}, Callback = "ftp://data"
}));
await Assert.ThrowsAsync <ArgumentException>(() => service.ValidateAsync(new WebHook {
Filters = new List <WebHookFilter> {
new WebHookFilter {
Trigger = "valid"
}
}, Callback = "http://www.example.com"
}));
service = new DefaultWebHookValidator(triggers.Object, logger.Object, HttpClientMocker.AlwaysFail(new Exception()));
await Assert.ThrowsAsync <ArgumentException>(() => service.ValidateAsync(new WebHook {
Filters = new List <WebHookFilter> {
new WebHookFilter {
Trigger = "valid"
}
}, Callback = "http://www.example.com"
}));
}
public async Task InvalidCasesAsync()
{
var schema = new OpenApiSchema
{
Properties = new Dictionary <string, OpenApiSchema>
{
["param1"] = new OpenApiSchema {
Type = "integer"
},
["param2"] = new OpenApiSchema {
Type = "string"
},
["param3"] = new OpenApiSchema {
Type = "array", Items = new OpenApiSchema {
Type = "integer"
}
},
["param4"] = new OpenApiSchema {
Type = "array", Reference = new OpenApiReference()
},
["number"] = new OpenApiSchema {
Type = "number"
},
["integer"] = new OpenApiSchema {
Type = "integer"
},
["bool"] = new OpenApiSchema {
Type = "boolean"
},
["object"] = new OpenApiSchema {
Type = "object"
},
}
};
var triggersById = new Dictionary <string, WebHookTrigger>
{
["valid"] = new WebHookTrigger {
Id = "valid", Schema = schema
},
};
var triggers = new Mock <IWebHookTriggerProvider>();
triggers.Setup(s => s.GetAvailableTriggers()).Returns(triggersById);
var logger = new Mock <ILogger <DefaultWebHookValidator> >();
var client = HttpClientMocker.Static(System.Net.HttpStatusCode.NotFound, "fail");
var service = new DefaultWebHookValidator(triggers.Object, logger.Object, client);
await Assert.ThrowsAsync <ArgumentException>(() => service.ValidateAsync(new WebHook {
Secret = "tooshort"
}));
await Assert.ThrowsAsync <ArgumentException>(() => service.ValidateAsync(new WebHook {
Secret = "toolong_toolong_toolong_toolong_toolong_toolong_toolong_toolong_toolong_toolong_toolong_toolong_toolong_toolong_toolong_toolong_toolong_toolong_toolong_toolong_"
}));
await Assert.ThrowsAsync <ArgumentException>(() => service.ValidateAsync(new WebHook()));
await Assert.ThrowsAsync <ArgumentException>(() => service.ValidateAsync(new WebHook {
Filters = new List <WebHookFilter>()
}));
await Assert.ThrowsAsync <ArgumentException>(() => service.ValidateAsync(new WebHook {
Filters = new List <WebHookFilter> {
new WebHookFilter {
Trigger = "invalid"
}
}
}));
await Assert.ThrowsAsync <ArgumentException>(() => service.ValidateAsync(new WebHook {
Filters = new List <WebHookFilter> {
new WebHookFilter {
Trigger = "valid", Parameters = new Dictionary <string, object> {
[""] = ""
}
}
}
}));
await Assert.ThrowsAsync <ArgumentException>(() => service.ValidateAsync(new WebHook {
Filters = new List <WebHookFilter> {
new WebHookFilter {
Trigger = "valid", Parameters = new Dictionary <string, object> {
["invalid"] = ""
}
}
}
}));
await Assert.ThrowsAsync <ArgumentException>(() => service.ValidateAsync(new WebHook {
Filters = new List <WebHookFilter> {
new WebHookFilter {
Trigger = "valid", Parameters = new Dictionary <string, object> {
["param3"] = ""
}
}
}
}));
await Assert.ThrowsAsync <ArgumentException>(() => service.ValidateAsync(new WebHook {
Filters = new List <WebHookFilter> {
new WebHookFilter {
Trigger = "valid", Parameters = new Dictionary <string, object> {
["param4.next"] = ""
}
}
}
}));
await Assert.ThrowsAsync <ArgumentException>(() => service.ValidateAsync(new WebHook {
Filters = new List <WebHookFilter> {
new WebHookFilter {
Trigger = "valid", Parameters = new Dictionary <string, object> {
["param1"] = "string"
}
}
}
}));
await Assert.ThrowsAsync <ArgumentException>(() => service.ValidateAsync(new WebHook {
Filters = new List <WebHookFilter> {
new WebHookFilter {
Trigger = "valid", Parameters = new Dictionary <string, object> {
["param1"] = null
}
}
}
}));
await Assert.ThrowsAsync <ArgumentException>(() => service.ValidateAsync(new WebHook {
Filters = new List <WebHookFilter> {
new WebHookFilter {
Trigger = "valid", Parameters = new Dictionary <string, object> {
["number"] = true
}
}
}
}));
await Assert.ThrowsAsync <ArgumentException>(() => service.ValidateAsync(new WebHook {
Filters = new List <WebHookFilter> {
new WebHookFilter {
Trigger = "valid", Parameters = new Dictionary <string, object> {
["integer"] = 2.3
}
}
}
}));
await Assert.ThrowsAsync <ArgumentException>(() => service.ValidateAsync(new WebHook {
Filters = new List <WebHookFilter> {
new WebHookFilter {
Trigger = "valid", Parameters = new Dictionary <string, object> {
["boolean"] = 345
}
}
}
}));
await Assert.ThrowsAsync <ArgumentException>(() => service.ValidateAsync(new WebHook {
Filters = new List <WebHookFilter> {
new WebHookFilter {
Trigger = "valid", Parameters = new Dictionary <string, object> {
["object"] = 23
}
}
}
}));
await Assert.ThrowsAsync <ArgumentException>(() => service.ValidateAsync(new WebHook {
Filters = new List <WebHookFilter> {
new WebHookFilter {
Trigger = "valid"
}
}
}));
await Assert.ThrowsAsync <ArgumentException>(() => service.ValidateAsync(new WebHook {
Filters = new List <WebHookFilter> {
new WebHookFilter {
Trigger = "valid"
}
}, Callback = new Uri("c:/data")
}));
await Assert.ThrowsAsync <ArgumentException>(() => service.ValidateAsync(new WebHook {
Filters = new List <WebHookFilter> {
new WebHookFilter {
Trigger = "valid"
}
}, Callback = new Uri("ftp://data")
}));
await Assert.ThrowsAsync <ArgumentException>(() => service.ValidateAsync(new WebHook {
Filters = new List <WebHookFilter> {
new WebHookFilter {
Trigger = "valid"
}
}, Callback = new Uri("http://www.example.com")
}));
service = new DefaultWebHookValidator(triggers.Object, logger.Object, HttpClientMocker.AlwaysFail(new Exception()));
await Assert.ThrowsAsync <ArgumentException>(() => service.ValidateAsync(new WebHook {
Filters = new List <WebHookFilter> {
new WebHookFilter {
Trigger = "valid"
}
}, Callback = new Uri("http://www.example.com")
}));
}
