public async Task HandleAsync_ChallengeSynchronizedIntegrationEventIsValid_ShouldBeCompletedTask()
        {
            // Arrange
            var challengeId = new ChallengeId();

            var factory  = new ChallengePayoutFactory();
            var strategy = factory.CreateInstance();
            var payout   = strategy.GetChallengePayout(ChallengePayoutEntries.Five, MoneyEntryFee.Fifty);

            var challenge = new Challenge(challengeId, payout);

            var mockLogger = new MockLogger <ChallengeSynchronizedIntegrationEventHandler>();

            TestMock.ChallengeService.Setup(challengeService => challengeService.ChallengeExistsAsync(It.IsAny <ChallengeId>())).ReturnsAsync(true).Verifiable();

            TestMock.ChallengeService.Setup(challengeService => challengeService.FindChallengeAsync(It.IsAny <ChallengeId>()))
            .ReturnsAsync(challenge)
            .Verifiable();

            TestMock.ChallengeService
            .Setup(
                challengeService => challengeService.CloseChallengeAsync(
                    It.IsAny <IChallenge>(),
                    It.IsAny <Dictionary <UserId, decimal?> >(),
                    It.IsAny <CancellationToken>()))
            .Returns(Task.CompletedTask)
            .Verifiable();

            var handler = new ChallengeSynchronizedIntegrationEventHandler(TestMock.ChallengeService.Object, mockLogger.Object);

            var integrationEvent = new ChallengeSynchronizedIntegrationEvent
            {
                ChallengeId = new ChallengeId()
            };

            // Act
            await handler.HandleAsync(integrationEvent);

            // Assert
            TestMock.ChallengeService.Verify(challengeService => challengeService.ChallengeExistsAsync(It.IsAny <ChallengeId>()), Times.Once);

            TestMock.ChallengeService.Verify(challengeService => challengeService.FindChallengeAsync(It.IsAny <ChallengeId>()), Times.Once);

            TestMock.ChallengeService.Verify(
                challengeService => challengeService.CloseChallengeAsync(
                    It.IsAny <IChallenge>(),
                    It.IsAny <Dictionary <UserId, decimal?> >(),
                    It.IsAny <CancellationToken>()),
                Times.Once);

            mockLogger.Verify(Times.Once());
        }
        public static async Task PublishChallengeSynchronizedIntegrationEventAsync(this IServiceBusPublisher publisher, IChallenge challenge)
        {
            var integrationEvent = new ChallengeSynchronizedIntegrationEvent
            {
                ChallengeId = challenge.Id,
                Scoreboard  =
                {
                    challenge.Participants.Select(participant => ChallengeProfile.Map(challenge, participant))
                }
            };

            await publisher.PublishAsync(integrationEvent);
        }