public WebhooksControllerTests()
        {
            _payloadQueue = new Mock <IQueue <string> >();

            var logger            = new Mock <ILogger <WebhooksController> >();
            var signatureVerifier = new Mock <ISignatureVerifier>();

            signatureVerifier.Setup(a => a.VerifySignature(It.IsAny <string>(), It.Is <string>(b => b.Equals("ValidSignature")))).Returns(true);
            signatureVerifier.Setup(a => a.VerifySignature(It.IsAny <string>(), It.Is <string>(b => b.Equals("InvalidSignature")))).Returns(false);

            var requestMock = new Mock <HttpRequest>();

            requestMock.SetupGet(it => it.Body).Returns(_payloadStream);
            requestMock.SetupGet(it => it.Headers).Returns(_headers);

            var contextMock = new Mock <HttpContext>();

            contextMock.SetupGet(it => it.Request).Returns(requestMock.Object);

            _controller = new WebhooksController(_payloadQueue.Object, signatureVerifier.Object, logger.Object)
            {
                ControllerContext = new ControllerContext
                {
                    HttpContext = contextMock.Object
                }
            };
        }
        public async Task ReturnsOkWheneverPossible(PayloadType payloadType, string artefactType, string dataType, string operation)
        {
            Item[]     items      = null;
            Taxonomy[] taxonomies = null;

            switch (payloadType)
            {
            case PayloadType.Items:
                items = new[] { new Item {
                                    Codename = "Test", Type = dataType
                                } };
                break;

            case PayloadType.Taxonomies:
                taxonomies = new[] { new Taxonomy {
                                         Codename = "Test"
                                     } };
                break;
            }

            var model = new WebhookModel
            {
                Data = new Data {
                    Items = items, Taxonomies = taxonomies
                },
                Message = new Message {
                    Type = artefactType, Operation = operation
                }
            };

            var controller = new WebhooksController(new DeliveryCacheManager(new MemoryCache(Options.Create(new MemoryCacheOptions())), Options.Create(new DeliveryCacheOptions())));
            var result     = (StatusCodeResult)await Task.Run(() => controller.Index(model));

            Assert.InRange(result.StatusCode, 200, 299);
        }
Exemple #3
0
        public void SetUp()
        {
            mockWebhooksRepository   = new Mock <IWebhooksRepository>();
            mockEventTypesRepository = new Mock <IEventTypesRepository>();
            mockTenant = new Mock <ITenant>();

            sut = new WebhooksController
                  (
                mockWebhooksRepository.Object,
                mockEventTypesRepository.Object,
                mockTenant.Object
                  );
        }
Exemple #4
0
        private static void FakeOutAuthenticResponse(WebhooksController webhooksController)
        {
            var httpContext = new DefaultHttpContext();

            httpContext.Request.Headers.Add("X-Hub-Signature", "sha1=b2c5a0cc23f36c7d7031e6c8d544c22ca8f9fc6a");
            httpContext.Request.Body = new MemoryStream(
                Encoding.UTF8.GetBytes("{}"));

            webhooksController.ControllerContext = new ControllerContext(
                new ActionContext(
                    httpContext,
                    new RouteData(),
                    new ControllerActionDescriptor()));
        }
        private WebhooksController BuildWebhooksController(string mediaTypeName)
        {
            var objectValidator = A.Fake <IObjectModelValidator>();
            var httpContext     = new DefaultHttpContext();

            httpContext.Request.Headers[HeaderNames.Accept] = mediaTypeName;

            var controller = new WebhooksController(logger, fakeWebhooksService)
            {
                ControllerContext = new ControllerContext()
                {
                    HttpContext = httpContext,
                },
                ObjectValidator = objectValidator,
            };

            A.CallTo(() => controller.ObjectValidator.Validate(A <ActionContext> .Ignored, A <ValidationStateDictionary> .Ignored, A <string> .Ignored, A <object> .Ignored));

            return(controller);
        }