squidex/tests/Squidex.Domain.Apps.Read.Tests/Webhooks/WebhookEnqueuerTests.cs

//// ==========================================================================
////  WebhookEnqueuerTests.cs
////  Squidex Headless CMS
//// ==========================================================================
////  Copyright (c) Squidex Group
////  All rights reserved.
//// ==========================================================================

//using System;
//using System.Collections.Generic;
//using System.Threading.Tasks;
//using FakeItEasy;
//using Newtonsoft.Json;
//using NodaTime;
//using Squidex.Domain.Apps.Events.Contents;
//using Squidex.Domain.Apps.Read.Webhooks.Repositories;
//using Squidex.Infrastructure;
//using Squidex.Infrastructure.CQRS.Events;
//using Xunit;

//// ReSharper disable MethodSupportsCancellation
//// ReSharper disable ImplicitlyCapturedClosure
//// ReSharper disable ConvertToConstant.Local

//namespace Squidex.Domain.Apps.Read.Webhooks
//{
//    public class WebhookEnqueuerTests
//    {
//        private readonly IClock clock = A.Fake<IClock>();
//        private readonly IWebhookRepository webhookRepository = A.Fake<IWebhookRepository>();
//        private readonly IWebhookEventRepository webhookEventRepository = A.Fake<IWebhookEventRepository>();
//        private readonly TypeNameRegistry typeNameRegisty = new TypeNameRegistry();
//        private readonly Instant now = SystemClock.Instance.GetCurrentInstant();
//        private readonly WebhookEnqueuer sut;

//        public WebhookEnqueuerTests()
//        {
//            A.CallTo(() => clock.GetCurrentInstant()).Returns(now);

//            typeNameRegisty.Map(typeof(ContentCreated));

//            sut = new WebhookEnqueuer(
//                typeNameRegisty,
//                webhookEventRepository,
//                webhookRepository,
//                clock, new JsonSerializer());
//        }

//        [Fact]
//        public void Should_return_contents_filter_for_events_filter()
//        {
//            Assert.Equal("^content-", sut.EventsFilter);
//        }

//        [Fact]
//        public void Should_return_type_name_for_name()
//        {
//            Assert.Equal(typeof(WebhookEnqueuer).Name, sut.Name);
//        }

//        [Fact]
//        public Task Should_do_nothing_on_clear()
//        {
//            return sut.ClearAsync();
//        }

//        [Fact]
//        public async Task Should_update_repositories_on_successful_requests()
//        {
//            var appId = new NamedId<Guid>(Guid.NewGuid(), "my-app");

//            var schemaId = new NamedId<Guid>(Guid.NewGuid(), "my-schema");

//            var @event = Envelope.Create(new ContentCreated { AppId = appId, SchemaId = schemaId });

//            var webhook1 = CreateWebhook(1);
//            var webhook2 = CreateWebhook(2);

//            A.CallTo(() => webhookRepository.QueryByAppAsync(appId.Id))
//                .Returns(Task.FromResult<IReadOnlyList<IWebhookEntity>>(new List<IWebhookEntity> { webhook1, webhook2 }));

//            await sut.On(@event);

//            A.CallTo(() => webhookEventRepository.EnqueueAsync(
//                A<WebhookJob>.That.Matches(webhookJob =>
//                    !string.IsNullOrWhiteSpace(webhookJob.RequestSignature)
//                 && !string.IsNullOrWhiteSpace(webhookJob.RequestBody)
//                 && webhookJob.Id != Guid.Empty
//                 && webhookJob.Expires == now.Plus(Duration.FromDays(2))
//                 && webhookJob.AppId == appId.Id
//                 && webhookJob.EventName == "MySchemaCreatedEvent"
//                 && webhookJob.RequestUrl == webhook1.Url
//                 && webhookJob.WebhookId == webhook1.Id), now)).MustHaveHappened();

//            A.CallTo(() => webhookEventRepository.EnqueueAsync(
//                A<WebhookJob>.That.Matches(webhookJob =>
//                    !string.IsNullOrWhiteSpace(webhookJob.RequestSignature)
//                    && !string.IsNullOrWhiteSpace(webhookJob.RequestBody)
//                    && webhookJob.Id != Guid.Empty
//                    && webhookJob.Expires == now.Plus(Duration.FromDays(2))
//                    && webhookJob.AppId == appId.Id
//                    && webhookJob.EventName == "MySchemaCreatedEvent"
//                    && webhookJob.RequestUrl == webhook2.Url
//                    && webhookJob.WebhookId == webhook2.Id), now)).MustHaveHappened();
//        }

//        private static ISchemaWebhookUrlEntity CreateWebhook(int offset)
//        {
//            var webhook = A.Dummy<ISchemaWebhookUrlEntity>();

//            A.CallTo(() => webhook.Id).Returns(Guid.NewGuid());
//            A.CallTo(() => webhook.Url).Returns(new Uri($"http://domain{offset}.com"));
//            A.CallTo(() => webhook.SharedSecret).Returns($"secret{offset}");

//            return webhook;
//        }
//}
//}