public async Task AppConfigSyncFunction_NoMessagesInQueue_NoCallsBetweenAppConfigurations()
        {
            var appConfigSyncServiceMock = new Mock <IAppConfigurationSyncService>();
            var queueServiceMock         = new Mock <IEventsService>();
            var configurationMock        = new Mock <IConfiguration>();
            var loggerMock = new Mock <IMSLogger>();

            var timeInfo = TestUtility.GenerateTimerInfo();

            queueServiceMock
            .Setup(e => e.ReceiveEventsAsync(It.IsAny <int>()))
            .ReturnsAsync(new List <Event>())
            .Verifiable();

            appConfigSyncServiceMock
            .Setup(e => e.Connect(null, null))
            .Verifiable();

            var target = new AppConfigSync(appConfigSyncServiceMock.Object,
                                           queueServiceMock.Object,
                                           configurationMock.Object);

            await target.AppConfigSyncFunction(timeInfo, loggerMock.Object);

            queueServiceMock
            .Verify(e => e.ReceiveEventsAsync(It.IsAny <int>()), Times.Once);

            appConfigSyncServiceMock
            .Verify(e => e.Connect(null, null), Times.Never());
        }
        public void ctor_AllArgumentsNotNull_CreateInstance()
        {
            var appConfigSyncServiceMock = new Mock <IAppConfigurationSyncService>();
            var queueServiceMock         = new Mock <IEventsService>();
            var configurationMock        = new Mock <IConfiguration>();

            var target = new AppConfigSync(appConfigSyncServiceMock.Object,
                                           queueServiceMock.Object,
                                           configurationMock.Object);

            Assert.NotNull(target);
        }
        public void ctor_ConfigurationNull_ThrowException()
        {
            var            appConfigSyncServiceMock = new Mock <IAppConfigurationSyncService>();
            var            queueServiceMock         = new Mock <IEventsService>();
            IConfiguration configuration            = null;

            Assert.Throws <ArgumentNullException>(() =>
            {
                var target = new AppConfigSync(appConfigSyncServiceMock.Object,
                                               queueServiceMock.Object,
                                               configuration);
            });
        }
        public async Task AppConfigSyncFunction_OneMessageInQueue_DeleteMessage_DeleteFromPrimaryToSecondary()
        {
            var appConfigSyncServiceMock = new Mock <IAppConfigurationSyncService>();
            var queueServiceMock         = new Mock <IEventsService>();
            var configurationMock        = new Mock <IConfiguration>();
            var loggerMock = new Mock <IMSLogger>();

            var timeInfo = TestUtility.GenerateTimerInfo();

            var deletedEvent = TestUtility.CreateKeyValueDeletedEvent();

            queueServiceMock
            .SetupSequence(e => e.ReceiveEventsAsync(It.IsAny <int>()))
            .ReturnsAsync(new List <Event>()
            {
                deletedEvent
            })
            .ReturnsAsync(new List <Event>());

            queueServiceMock
            .Setup(e => e.DeleteEventAsync(deletedEvent))
            .Verifiable();

            appConfigSyncServiceMock
            .Setup(e => e.Connect(null, null))
            .Verifiable();

            appConfigSyncServiceMock
            .Setup(e => e.DeleteFromSecondary(deletedEvent, default))
            .ReturnsAsync(true)
            .Verifiable();

            var target = new AppConfigSync(appConfigSyncServiceMock.Object,
                                           queueServiceMock.Object,
                                           configurationMock.Object);

            await target.AppConfigSyncFunction(timeInfo, loggerMock.Object);

            queueServiceMock
            .Verify(e => e.ReceiveEventsAsync(It.IsAny <int>()), Times.Exactly(2));

            queueServiceMock
            .Verify(e => e.DeleteEventAsync(deletedEvent), Times.Once);

            appConfigSyncServiceMock
            .Verify(e => e.Connect(null, null), Times.Once);

            appConfigSyncServiceMock
            .Verify(e => e.DeleteFromSecondary(deletedEvent, default), Times.Once);
        }
        public async Task AppConfigSyncFunction_TwoMessagesInQueue_DeleteAndModifiedMessages_DeleteFromPrimaryToSecondaryThenUpdateFromPrimaryToSecondary()
        {
            var appConfigServiceMethodsOrder = string.Empty;

            var appConfigSyncServiceMock = new Mock <IAppConfigurationSyncService>();
            var queueServiceMock         = new Mock <IEventsService>();
            var configurationMock        = new Mock <IConfiguration>();
            var loggerMock = new Mock <IMSLogger>();

            var timeInfo = TestUtility.GenerateTimerInfo();

            var deletedEvent  = TestUtility.CreateKeyValueDeletedEvent();
            var modifiedEvent = TestUtility.CreateKeyValueModifiedEvent();

            queueServiceMock
            .SetupSequence(e => e.ReceiveEventsAsync(It.IsAny <int>()))
            .ReturnsAsync(new List <Event>()
            {
                deletedEvent, modifiedEvent
            })
            .ReturnsAsync(new List <Event>());

            queueServiceMock
            .Setup(e => e.DeleteEventAsync(deletedEvent))
            .Verifiable();
            queueServiceMock
            .Setup(e => e.DeleteEventAsync(modifiedEvent))
            .Verifiable();

            appConfigSyncServiceMock
            .Setup(e => e.Connect(null, null))
            .Verifiable();

            appConfigSyncServiceMock
            .Setup(e => e.DeleteFromSecondary(deletedEvent, default))
            .ReturnsAsync(true)
            .Callback(() => appConfigServiceMethodsOrder += "Delete")
            .Verifiable();
            appConfigSyncServiceMock
            .Setup(e => e.UpsertToSecondary(modifiedEvent, default))
            .ReturnsAsync(true)
            .Callback(() => appConfigServiceMethodsOrder += "Upsert")
            .Verifiable();

            var target = new AppConfigSync(appConfigSyncServiceMock.Object,
                                           queueServiceMock.Object,
                                           configurationMock.Object);

            await target.AppConfigSyncFunction(timeInfo, loggerMock.Object);

            queueServiceMock
            .Verify(e => e.ReceiveEventsAsync(It.IsAny <int>()), Times.Exactly(2));

            queueServiceMock
            .Verify(e => e.DeleteEventAsync(deletedEvent), Times.Once);
            queueServiceMock
            .Verify(e => e.DeleteEventAsync(modifiedEvent), Times.Once);

            appConfigSyncServiceMock
            .Verify(e => e.Connect(null, null), Times.Once);

            appConfigSyncServiceMock
            .Verify(e => e.DeleteFromSecondary(deletedEvent, default), Times.Once);
            appConfigSyncServiceMock
            .Verify(e => e.UpsertToSecondary(modifiedEvent, default), Times.Once);

            Assert.Equal("DeleteUpsert", appConfigServiceMethodsOrder);
            Assert.Equal("DeleteUpsert", appConfigServiceMethodsOrder);
        }