public static async Task <TResponse> InvokeAndGetResponseAs <TResponse>(this ResultProcessingFunction function, Action <HttpRequest> configureRequest)
            where TResponse : IActionResult
        {
            var result = await function.Invoke(configureRequest);

            Assert.IsInstanceOfType(result, typeof(TResponse));
            return((TResponse)result);
        }
        public static Task <IActionResult> Invoke(this ResultProcessingFunction function, Action <HttpRequest> configureRequest)
        {
            var req = new DefaultHttpRequest(new DefaultHttpContext());

            req.Scheme = "https";
            req.Method = "POST";
            req.Host   = new HostString("api.something.com");
            req.Path   = "/api/path-to-something";
            configureRequest(req);

            return(function.Run(req, Microsoft.Extensions.Logging.Abstractions.NullLogger.Instance));
        }
Exemple #3
0
        public async Task PayloadNotJsonReturnsError()
        {
            var data = SampleCallbackData.InvalidPayload;

            var procService = new Mock <IResultProcessor>();

            procService.Setup(s => s.GetSecretForToken(data.Token)).ReturnsAsync(data.Secret);

            var dtMock = new Mock <IDateTimeProvider>();

            dtMock.Setup(s => s.GetUtcNow()).Returns(new DateTime(2021, 9, 13, 12, 34, 23, DateTimeKind.Utc));

            var func = new ResultProcessingFunction(procService.Object, dtMock.Object);

            var resp = await func.InvokeWithContentAndGetResponseAs <ObjectResult>(data, dtMock.Object);

            Assert.AreEqual(StatusCodes.Status400BadRequest, resp.StatusCode);
            procService.Verify(s => s.GetSecretForToken(data.Token), Times.Once());
            procService.Verify(s => s.ProcessResult(It.IsAny <ResultProcessing.Dto.AhkProcessResult>(), It.IsAny <DateTime>()), Times.Never());
        }
Exemple #4
0
        private static async Task callWebhookAssertIsRejected(Action <HttpRequest> configureRequest, Action <Mock <IResultProcessor> > configureProcessorMock = null)
        {
            var procService = new Mock <IResultProcessor>();

            configureProcessorMock?.Invoke(procService);

            var func = new ResultProcessingFunction(procService.Object, new DateTimeProvider());

            var resp = await func.InvokeAndGetResponseAs <ObjectResult>(configureRequest);

            Assert.AreEqual(StatusCodes.Status400BadRequest, resp.StatusCode);
            procService.Verify(s => s.ProcessResult(It.IsAny <ResultProcessing.Dto.AhkProcessResult>(), It.IsAny <DateTime>()), Times.Never());


            if (configureProcessorMock == null)
            {
                procService.Verify(s => s.GetSecretForToken(It.IsAny <string>()), Times.Never());
            }
            else
            {
                procService.Verify();
            }
        }
        public static async Task <TResponse> InvokeWithContentAndGetResponseAs <TResponse>(this ResultProcessingFunction function, SampleCallbackData data, IDateTimeProvider dateTimeProvider)
            where TResponse : IActionResult
        {
            var result = await function.Invoke(req => configureRequest(req, data, dateTimeProvider));

            Assert.IsInstanceOfType(result, typeof(TResponse));
            return((TResponse)result);
        }