Пример #1
0
        public void MustEnforceConfigurations()
        {
            var configuration1 = new Mock <IFeatureConfiguration>();
            var configuration2 = new Mock <IFeatureConfiguration>();
            var configuration3 = new Mock <IFeatureConfiguration>();
            var counter        = 0;
            var limit          = new Random().Next(5, 50);
            var sync           = new AutoResetEvent(false);

            configuration1.Setup(c => c.GetStatus()).Returns(FeatureConfigurationStatus.Disabled);
            configuration2.Setup(c => c.GetStatus()).Returns(FeatureConfigurationStatus.Enabled);
            configuration3.Setup(c => c.GetStatus()).Returns(FeatureConfigurationStatus.Disabled).Callback(() =>
            {
                if (++counter >= limit)
                {
                    sync.Set();
                }
            });

            sut = new FeatureConfigurationMonitor(logger.Object, 2);

            sut.Observe(configuration1.Object, FeatureConfigurationStatus.Enabled);
            sut.Observe(configuration2.Object, FeatureConfigurationStatus.Disabled);
            sut.Observe(configuration3.Object, FeatureConfigurationStatus.Undefined);
            sut.Start();
            sync.WaitOne();
            sut.Reset();

            configuration1.Verify(c => c.EnableFeature(), Times.Exactly(limit));
            configuration2.Verify(c => c.DisableFeature(), Times.Exactly(limit));
            configuration3.Verify(c => c.DisableFeature(), Times.Never);
            configuration3.Verify(c => c.EnableFeature(), Times.Never);
        }
Пример #2
0
        public void MustRespectTimeout()
        {
            const int TIMEOUT = 50;

            var after         = default(DateTime);
            var before        = default(DateTime);
            var configuration = new Mock <IFeatureConfiguration>();
            var counter       = 0;
            var sync          = new AutoResetEvent(false);

            sut = new FeatureConfigurationMonitor(logger.Object, TIMEOUT);

            configuration.Setup(c => c.GetStatus()).Returns(FeatureConfigurationStatus.Undefined).Callback(() =>
            {
                switch (++counter)
                {
                case 1:
                    before = DateTime.Now;
                    break;

                case 2:
                    after = DateTime.Now;
                    sync.Set();
                    break;
                }
            });

            sut.Observe(configuration.Object, FeatureConfigurationStatus.Disabled);
            sut.Start();
            sync.WaitOne();
            sut.Reset();

            Assert.IsTrue(after - before >= new TimeSpan(0, 0, 0, 0, TIMEOUT));
        }
Пример #3
0
        internal void BuildObjectGraph()
        {
            const int ONE_SECOND   = 1000;
            const int FIVE_SECONDS = 5000;

            var backupFilePath = BuildBackupFilePath();

            InitializeLogging();

            var featureBackup             = new FeatureConfigurationBackup(backupFilePath, new ModuleLogger(logger, nameof(FeatureConfigurationBackup)));
            var featureFactory            = new FeatureConfigurationFactory(new ModuleLogger(logger, nameof(FeatureConfigurationFactory)));
            var featureMonitor            = new FeatureConfigurationMonitor(new ModuleLogger(logger, nameof(FeatureConfigurationMonitor)), ONE_SECOND);
            var proxyFactory              = new ProxyFactory(new ProxyObjectFactory(), new ModuleLogger(logger, nameof(ProxyFactory)));
            var serviceHost               = new ServiceHost(AppConfig.SERVICE_ADDRESS, new HostObjectFactory(), new ModuleLogger(logger, nameof(ServiceHost)), FIVE_SECONDS);
            var sessionContext            = new SessionContext();
            var systemConfigurationUpdate = new SystemConfigurationUpdate(new ModuleLogger(logger, nameof(SystemConfigurationUpdate)));

            var bootstrapOperations = new Queue <IOperation>();
            var sessionOperations   = new Queue <IOperation>();

            sessionContext.AutoRestoreMechanism = new AutoRestoreMechanism(featureBackup, new ModuleLogger(logger, nameof(AutoRestoreMechanism)), systemConfigurationUpdate, FIVE_SECONDS);

            bootstrapOperations.Enqueue(new RestoreOperation(featureBackup, logger, sessionContext));
            bootstrapOperations.Enqueue(new CommunicationHostOperation(serviceHost, logger));
            bootstrapOperations.Enqueue(new ServiceEventCleanupOperation(logger, sessionContext));

            sessionOperations.Enqueue(new SessionInitializationOperation(logger, ServiceEventFactory, sessionContext));
            sessionOperations.Enqueue(new LockdownOperation(featureBackup, featureFactory, featureMonitor, logger, sessionContext));
            sessionOperations.Enqueue(new SessionActivationOperation(logger, sessionContext));

            var bootstrapSequence = new OperationSequence(logger, bootstrapOperations);
            var sessionSequence   = new OperationSequence(logger, sessionOperations);

            ServiceController = new ServiceController(logger, LogWriterFactory, bootstrapSequence, sessionSequence, serviceHost, sessionContext, systemConfigurationUpdate);
        }
Пример #4
0
 public void Initialize()
 {
     logger = new Mock <ILogger>();
     sut    = new FeatureConfigurationMonitor(logger.Object, 0);
 }