InMemory implementation of IPersistanceStore
Inheritance: IPersistanceStore
        public void TestScheduleTriggerWithNoJobDataMapSavesEmptyDataOnTrigger()
        {
            // Arrange
            Scheduler.Shutdown();
            Scheduler.Initialize((config =>
            {
                config.EnableWebApiSelfHost = false;
                config.EnableAuditHistory = false;
            }));
            IPersistanceStore persistanceStore = new InMemoryStore();
            _schedulerCore = new SchedulerCore(Scheduler.Instance(), persistanceStore);

            const string jobName = "Job1";
            const string jobGroup = "Group1";
            const string triggerName = "Trigger1";

            _schedulerCore.CreateJob(jobName, jobGroup, typeof(NoOpJob), new Dictionary<string, object>(), string.Empty);

            var simpleTrigger = new SimpleTrigger
            {
                RepeatCount = 1,
                RepeatInterval = new TimeSpan(0, 1, 0, 0),
                JobName = jobName,
                JobGroup = jobGroup,
                Name = triggerName
            };

            // Act
            var result = _schedulerCore.ScheduleTrigger(simpleTrigger);

            // Assert
            Assert.Equal(triggerName, Scheduler.Instance().GetTrigger(new TriggerKey(triggerName)).Key.Name);
            Assert.Equal(0, Scheduler.Instance().GetTrigger(new TriggerKey(triggerName)).JobDataMap.Count);
        }
        public void TestCreateJobWithInMemoryPersistance()
        {
            // Arrange
            IPersistanceStore persistanceStore = new InMemoryStore();
            _schedulerCore = new SchedulerCore(_mockScheduler.Object, persistanceStore);

            const string jobName = "Job1";
            const string jobGroup = "Group1";

            // Act
            var result = _schedulerCore.CreateJob(jobName, jobGroup, typeof(NoOpJob), new Dictionary<string, object>(), string.Empty);

            // Assert
            Assert.Equal(jobName, persistanceStore.GetJobKey(result).Name);
            Assert.Equal(jobGroup, persistanceStore.GetJobKey(result).Group);
        }
        public AnalyticsTests()
        {
            Scheduler.Shutdown();

            Scheduler.Initialize((config =>
            {
                config.EnableWebApiSelfHost = false;
                config.EnableAuditHistory = false;
                config.PersistanceStoreType = PersistanceStoreType.InMemory;
                config.AutoStart = false;
            }));

            IPersistanceStore persistanceStore = new InMemoryStore();
            _analytics = new Analytics(Scheduler.Instance(), persistanceStore);
            _schedulerCore = new SchedulerCore(Scheduler.Instance(), persistanceStore);
        }
        public object Process(object target, IContext context)
        {
            IPersistanceStore retval = null;

            if (target.GetType().GetInterfaces().Contains(typeof(IPersistanceStore)))
            {
                switch (_config.PersistanceStoreType)
                {
                    case PersistanceStoreType.Postgre:
                        retval = new PostgreStore(_config.ConnectionString);
                        break;
                    case PersistanceStoreType.SqlServer:
                        retval = new SqlServerStore(_config.ConnectionString);
                        break;
                    case PersistanceStoreType.InMemory:
                        retval = new InMemoryStore();
                        break;
                }
            }

            return retval;
        }
        public void TestPauseTriggerSetsTriggerIntoPausedStateAndResumeTriggersSetsTriggerBackToNormalState()
        {
            // Arrange
            Scheduler.Shutdown();
            Scheduler.Initialize((config =>
            {
                config.EnableWebApiSelfHost = false;
                config.EnableAuditHistory = false;
            }));
            IPersistanceStore persistanceStore = new InMemoryStore();
            _schedulerCore = new SchedulerCore(Scheduler.Instance(), persistanceStore);

            const string jobName = "Job1";
            const string jobGroup = "Group1";
            const string triggerName = "Trigger1";

            _schedulerCore.CreateJob(jobName, jobGroup, typeof(NoOpJob), new Dictionary<string, object>(), string.Empty);

            var simpleTrigger = new SimpleTrigger
            {
                RepeatCount = 1,
                RepeatInterval = new TimeSpan(0, 1, 0, 0),
                JobName = jobName,
                JobGroup = jobGroup,
                Name = triggerName
            };

            var triggerId = _schedulerCore.ScheduleTrigger(simpleTrigger);


            // Act / Assert
            _schedulerCore.PauseTrigger(triggerId);
            Assert.Equal(TriggerState.Paused, Scheduler.Instance().GetTriggerState(new TriggerKey(triggerName)));

            _schedulerCore.ResumeTrigger(triggerId);
            Assert.Equal(TriggerState.Normal, Scheduler.Instance().GetTriggerState(new TriggerKey(triggerName)));
        }