public async Task StartPath2() { //Arrange var logEntries = new List <LogEntry>(); var log = new StubIFeedback <LogEntry> { ReportAsyncT0CancellationToken = (e, c) => { Console.WriteLine(e.ToString()); logEntries.Add(e); return(Task.FromResult(0)); } }; var cts = new CancellationTokenSource(); var tm = new ScheduledTaskRunner(log, new StubICommandProcessor(), new UnitTestDbConnection(), new CurrentTimeProvider()); //Act await tm.StartAsync(cts.Token); await tm.StartAsync(cts.Token); //Assert Assert.IsTrue(logEntries.Last().Level == LogEntryLevel.Warn); }
public async Task StopPath1() { //Arrange var logEntries = new List <LogEntry>(); var log = new StubIFeedback <LogEntry> { ReportAsyncT0CancellationToken = (e, c) => { Console.WriteLine(e.ToString()); logEntries.Add(e); return(Task.FromResult(0)); } }; var cts = new CancellationTokenSource(); var tm = new ScheduledTaskRunner(log, new StubICommandProcessor(), new UnitTestDbConnection(), new CurrentTimeProvider()); //Act await tm.StartAsync(cts.Token); await tm.StopAsync(cts.Token); //Assert Assert.IsTrue(logEntries.All(o => o.Level == LogEntryLevel.Info), "Expected only info type log entries"); Assert.IsTrue(logEntries.Any(o => o.Message.Contains("stopped")), "Manger not started or word started not in the log."); Assert.IsFalse(tm.IsRunning); }
public void ConstructorPath5() { //arrange, act var tm = new ScheduledTaskRunner(new StubIFeedback<LogEntry>(), new StubICommandProcessor(), new ZvsEntityContextConnection(), new CurrentTimeProvider()); //Assert Assert.IsNotNull(tm); }
public void ConstructorPath5() { //arrange, act var tm = new ScheduledTaskRunner(new StubIFeedback <LogEntry>(), new StubICommandProcessor(), new UnitTestDbConnection(), new CurrentTimeProvider()); //Assert Assert.IsNotNull(tm); }
public static async Task Runs_tasks_that_are_due() { var currentInstant = 30.December(2020).At(12, 07, 26).Utc(); var dueTime = currentInstant; var notDueTime = currentInstant.Plus(1.Seconds()); var dailyNotificationSchedule = new Schedule(ScheduledTaskType.DailyNotification, dueTime); var requestReminderSchedule = new Schedule(ScheduledTaskType.RequestReminder, notDueTime); var softInterruptionUpdaterSchedule = new Schedule(ScheduledTaskType.SoftInterruptionUpdater, notDueTime); var weeklyNotificationSchedule = new Schedule(ScheduledTaskType.WeeklyNotification, dueTime); var schedules = new[] { dailyNotificationSchedule, requestReminderSchedule, softInterruptionUpdaterSchedule, weeklyNotificationSchedule }; var mockScheduleRepository = new Mock <IScheduleRepository>(MockBehavior.Strict); mockScheduleRepository.Setup(r => r.GetSchedules()).ReturnsAsync(schedules); mockScheduleRepository.Setup(r => r.UpdateSchedule(It.IsAny <Schedule>())).Returns(Task.CompletedTask); var mockDateCalculator = new Mock <IDateCalculator>(MockBehavior.Strict); mockDateCalculator.Setup(d => d.ScheduleIsDue(dailyNotificationSchedule, null)).Returns(true); mockDateCalculator.Setup(d => d.ScheduleIsDue(requestReminderSchedule, null)).Returns(false); mockDateCalculator.Setup(d => d.ScheduleIsDue(softInterruptionUpdaterSchedule, null)).Returns(false); mockDateCalculator.Setup(d => d.ScheduleIsDue(weeklyNotificationSchedule, null)).Returns(true); var mockDailyNotification = CreateMockScheduledTask(ScheduledTaskType.DailyNotification); var mockRequestReminder = CreateMockScheduledTask(ScheduledTaskType.RequestReminder); var mockSoftInterruptionUpdater = CreateMockScheduledTask(ScheduledTaskType.SoftInterruptionUpdater); var mockWeeklyNotification = CreateMockScheduledTask(ScheduledTaskType.WeeklyNotification); var scheduledTasks = new[] { mockDailyNotification.Object, mockRequestReminder.Object, mockSoftInterruptionUpdater.Object, mockWeeklyNotification.Object }; var scheduledTaskRunner = new ScheduledTaskRunner( mockDateCalculator.Object, scheduledTasks, mockScheduleRepository.Object); await scheduledTaskRunner.RunScheduledTasks(); mockDailyNotification.Verify(s => s.Run(), Times.Once); mockRequestReminder.Verify(s => s.Run(), Times.Never); mockSoftInterruptionUpdater.Verify(s => s.Run(), Times.Never); mockWeeklyNotification.Verify(s => s.Run(), Times.Once); }
/// <summary> /// Adds a task onto the schedule so it will be checked and run as defined by the schedule /// </summary> /// <param name="task">The task to run</param> /// <param name="schedule">The schedule that determines when the task should run</param> public bool TryAddTask(ITask task, Schedule schedule) { if (task == null) { throw new ArgumentNullException(nameof(task)); } if (schedule == null) { throw new ArgumentNullException(nameof(schedule)); } if (IsRunning) { return(false); } switch (schedule.Type) { case ScheduleType.Periodical: var p = new PeriodicalTaskRunner(task, schedule.Frequency); _taskRunners.Add(p); break; case ScheduleType.Scheduled: var s = new ScheduledTaskRunner(task, schedule.RunAt); _taskRunners.Add(s); break; case ScheduleType.Task: var neverRunner = new OnDemandTaskRunner(task); _taskRunners.Add(neverRunner); break; case ScheduleType.Defered: break; default: throw new Exception(schedule.Type + " is not a supported schedule type."); } return(true); }
public async Task StartAsyncTest() { //arrange var dbConnection = new UnitTestDbConnection(); Database.SetInitializer(new CreateFreshDbInitializer()); var logEntries = new List <LogEntry>(); var log = new StubIFeedback <LogEntry> { ReportAsyncT0CancellationToken = (e, c) => { Console.WriteLine(e.ToString()); logEntries.Add(e); return(Task.FromResult(0)); } }; var isAdapterManagerInitialized = false; var isPluginManagerInitialized = false; var am = new StubIAdapterManager { StartAsyncCancellationToken = async ct => isAdapterManagerInitialized = true }; var pm = new StubIPluginManager { StartAsyncCancellationToken = async ct => isPluginManagerInitialized = true }; var tr = new TriggerRunner(log, new StubICommandProcessor(), dbConnection); var st = new ScheduledTaskRunner(log, new StubICommandProcessor(), dbConnection, new CurrentTimeProvider()); var engine = new ZvsEngine(log, am, pm, dbConnection, tr, st); //Act await engine.StartAsync(CancellationToken.None); //assert Assert.IsNotNull(engine); Assert.IsTrue(isAdapterManagerInitialized, "Adapter manager was not started!"); Assert.IsTrue(isPluginManagerInitialized, "Plugin manager was not started!"); Assert.IsTrue(engine.ScheduledTaskRunner.IsRunning, "Scheduled Task Runner was not started!"); Assert.IsTrue(engine.TriggerRunner.IsRunning, "Trigger Runner was not started!"); }
public async Task <ActionResult> RunTask(string taskType, string instCode) { try { var processor = Utilities.QueryProcessor; processor.InstitutionCode = instCode; ScheduledTask scheduledTask = await processor.ProcessAsync(new GetTaskByTypeQuery { Type = taskType }); if (scheduledTask != null) { var task = new ScheduledTaskRunner(scheduledTask); await task.Execute(); } } catch (System.Exception ex) { Utilities.Logger.Log("ScheduledTaskApi/RunTask: " + ex.GetFullExceptionMessage()); } return(new EmptyResult()); }
public async Task StartPath1() { //Arrange var logEntries = new List<LogEntry>(); var log = new StubIFeedback<LogEntry> { ReportAsyncT0CancellationToken = (e, c) => { Console.WriteLine(e.ToString()); logEntries.Add(e); return Task.FromResult(0); } }; var cts = new CancellationTokenSource(); var tm = new ScheduledTaskRunner(log, new StubICommandProcessor(), new ZvsEntityContextConnection(), new CurrentTimeProvider()); //Act await tm.StartAsync(cts.Token); //Assert Assert.IsTrue(logEntries.All(o => o.Level == LogEntryLevel.Info), "Expected only info type log entries"); Assert.IsTrue(logEntries.Any(o => o.Message.Contains("started")), "Manger not started or word started not in the log."); }
/// <summary> /// Adds a task onto the schedule so it will be checked and run as defined by the schedule /// </summary> /// <param name="task">The task to run</param> /// <param name="schedule">The schedule that determines when the task should run</param> public void AddTask(ITask task, Schedule schedule) { switch (schedule.Type) { case ScheduleType.Periodical: var p = new PeriodicalTaskRunner(task, schedule.Frequency); _taskRunners.Add(p); break; case ScheduleType.Scheduled: var s = new ScheduledTaskRunner(task, schedule.RunAt); _taskRunners.Add(s); break; case ScheduleType.Task: _tasks.Add(task); break; default: throw new Exception(schedule.Type + " is not a supported schedule type."); } }
protected async override void OnStartup(StartupEventArgs e) { var adapterLoader = new AdapterLoader(); var result = await adapterLoader.FindAdaptersAsync("Adapters", Cts.Token); if (result.HasError) { await Log.ReportErrorAsync(result.Message, Cts.Token); } var adapterManager = new Processor.AdapterManager(result.Adapters, EntityContextConnection, new DatabaseFeedback(EntityContextConnection)); var pluginLoader = new PluginLoader(); var pluginFindResult = await pluginLoader.FindPluginsAsync("plugins", Cts.Token); if (pluginFindResult.HasError) { await Log.ReportErrorAsync(pluginFindResult.Message, Cts.Token); } var pluginManager = new Processor.PluginManager(pluginFindResult.Plugins, EntityContextConnection, new DatabaseFeedback(EntityContextConnection), adapterManager); var triggerRunner = new TriggerRunner(new DatabaseFeedback(EntityContextConnection), new CommandProcessor(adapterManager, EntityContextConnection, new DatabaseFeedback(EntityContextConnection)), EntityContextConnection); var scheduledTaskRunner = new ScheduledTaskRunner(new DatabaseFeedback(EntityContextConnection), new CommandProcessor(adapterManager, EntityContextConnection, new DatabaseFeedback(EntityContextConnection)), EntityContextConnection, new CurrentTimeProvider()); ZvsEngine = new ZvsEngine(new DatabaseFeedback(EntityContextConnection), adapterManager, pluginManager, EntityContextConnection, triggerRunner, scheduledTaskRunner); var splashscreen = new SplashScreen(); splashscreen.SetLoadingTextFormat("Starting {0}", Utils.ApplicationNameAndVersion); splashscreen.Show(); await Task.Delay(10); #if DEBUG var sw = new Stopwatch(); sw.Start(); #endif #if (RELEASE) AppDomain.CurrentDomain.UnhandledException += new UnhandledExceptionEventHandler(CurrentDomain_UnhandledException); #endif using (var context = new ZvsContext(new ZvsEntityContextConnection())) { //Install Program Options var option = await context.ProgramOptions.FirstOrDefaultAsync(o => o.UniqueIdentifier == "LOGDIRECTION", Cts.Token); if (option == null) { var registerLogDirectionResult = await ProgramOption.TryAddOrEditAsync(context, new ProgramOption { UniqueIdentifier = "LOGDIRECTION", Value = "Descending" }, Cts.Token); if (registerLogDirectionResult.HasError) { await Log.ReportErrorAsync(registerLogDirectionResult.Message, Cts.Token); } } } //using (var context = new ZvsContext(new ZvsEntityContextConnection())) //{ // var adapter = CreateFakeAdapter(); // context.Devices.Add(new Device // { // Name = "Light Switch", // Location = "Living Room", // Type = new DeviceType // { // Name = "Switch Device Type", // UniqueIdentifier = "Switch", // Adapter = adapter // } // }); // context.Devices.Add(new Device // { // Name = "Main Controller", // Location = "Utility", // Type = new DeviceType // { // Name = "Controller Type", // UniqueIdentifier = "Controller", // Adapter = adapter // } // }); // context.Devices.Add(new Device // { // Name = "Can Lights", // Location = "Kitchen", // Type = new DeviceType // { // Name = "Dimmer Type", // UniqueIdentifier = "Dimmer", // Adapter = adapter // } // }); // context.Devices.Add(new Device // { // Name = "Thermostat", // Location = "Kitchen", // Type = new DeviceType // { // Name = "Thermostat Type", // UniqueIdentifier = "Thermostat", // Adapter = adapter // } // }); // context.Devices.Add(new Device // { // Name = "Front Door", // Location = "Entry", // Type = new DeviceType // { // Name = "Doorlock Type", // UniqueIdentifier = "Doorlock", // Adapter = adapter // } // }); // var sensorDt = new DeviceType // { // Name = "Sensor Type", // UniqueIdentifier = "Sensor", // Adapter = adapter // }; // var device = new Device // { // Name = "Motion Sensor", // Location = "Entry", // Type = sensorDt, // }; // var value = new DeviceValue // { // Name = "Level", // ValueType = DataType.BYTE, // Value = "255" // }; // device.Values.Add(value); // context.Devices.Add(device); // //context.SaveChanges(); //} #region Create Logger await Log.ReportInfoFormatAsync(Cts.Token, "Init Complete ({0})", (Utils.DebugMode ? "Debug Mode" : "Release Mode")); #if DEBUG await Log.ReportInfoAsync("--------------DUMPING ENVIRONMENT--------------", Cts.Token); await Log.ReportInfoFormatAsync(Cts.Token, "AppDataPath:{0}", Utils.AppDataPath); await Log.ReportInfoFormatAsync(Cts.Token, "AppPath:{0}", Utils.AppPath); await Log.ReportInfoFormatAsync(Cts.Token, "ApplicationNameAndVersion:{0}", Utils.ApplicationNameAndVersion); await Log.ReportInfoFormatAsync(Cts.Token, "ApplicationVersionLong:{0}", Utils.ApplicationVersionLong); await Log.ReportInfoFormatAsync(Cts.Token, "HasDotNet45:{0}", Utils.HasDotNet45()); await Log.ReportInfoFormatAsync(Cts.Token, "HasSQLCE4:{0}", Utils.HasSQLCE4()); await Log.ReportInfoFormatAsync(Cts.Token, "CommandLine:{0}", Environment.CommandLine); await Log.ReportInfoFormatAsync(Cts.Token, "CurrentDirectory:{0}", Environment.CurrentDirectory); await Log.ReportInfoFormatAsync(Cts.Token, "Is64BitOperatingSystem:{0}", Environment.Is64BitOperatingSystem); await Log.ReportInfoFormatAsync(Cts.Token, "Is64BitProcess:{0}", Environment.Is64BitProcess); await Log.ReportInfoFormatAsync(Cts.Token, "MachineName:{0}", Environment.MachineName); await Log.ReportInfoFormatAsync(Cts.Token, "OSVersion:{0}", Environment.OSVersion); await Log.ReportInfoFormatAsync(Cts.Token, "ProcessorCount:{0}", Environment.ProcessorCount); await Log.ReportInfoFormatAsync(Cts.Token, "UserDomainName:{0}", Environment.UserDomainName); await Log.ReportInfoFormatAsync(Cts.Token, "UserInteractive:{0}", Environment.UserInteractive); await Log.ReportInfoFormatAsync(Cts.Token, "UserName:{0}", Environment.UserName); await Log.ReportInfoFormatAsync(Cts.Token, "Version:{0}", Environment.Version); await Log.ReportInfoFormatAsync(Cts.Token, "WorkingSet:{0}", Environment.WorkingSet); await Log.ReportInfoAsync("--------------/DUMPING ENVIRONMENT--------------", Cts.Token); #endif AppDomain.CurrentDomain.SetData("DataDirectory", Utils.AppDataPath); #endregion #region Checking for other running instances await Task.Delay(10); splashscreen.SetLoadingTextFormat("Checking for other running instances"); await Task.Delay(10); try { _zvsMutex = Mutex.OpenExisting("zVirtualScenesGUIMutex"); ProgramHasToClosePrompt(Utils.ApplicationName + " can't start because it is already running"); } catch { //the specified mutex doesn't exist, we should create it _zvsMutex = new Mutex(true, "zVirtualScenesGUIMutex"); //these names need to match. } #endregion #region Check for .Net Framework 4.5 await Task.Delay(10); splashscreen.SetLoadingTextFormat("Checking for .Net framework 4.5"); await Task.Delay(10); if (!Utils.HasDotNet45()) { ProgramHasToClosePrompt( $"Microsoft .NET Framework 4.5 Full/Extended is required to run {Utils.ApplicationName}. \r\n\r\nPlease install Microsoft .NET Framework 4.5 and re-launch the application."); } #endregion #region Checking for Microsoft® SQL Server® Compact 4.0 SP1 await Task.Delay(10); splashscreen.SetLoadingTextFormat("Checking for Microsoft® SQL Server® Compact 4.0 SP1"); await Task.Delay(10); if (!Utils.HasSQLCE4()) { ProgramHasToClosePrompt( $"Microsoft® SQL Server® Compact 4.0 SP1 is required to run {Utils.ApplicationName}. \r\n\r\nPlease install Microsoft® SQL Server® Compact 4.0 SP1 and re-launch the application."); } #endregion #region Initializing and upgrading local database await Task.Delay(10); splashscreen.SetLoadingTextFormat("Initializing and migrating database"); await Task.Delay(10); await Task.Run(() => { using (var context = new ZvsContext()) { var configuration = new Configuration(); var migrator = new DbMigrator(configuration); migrator.Update(); context.Database.Initialize(true); } }); #endregion //TODO: Check for VCRedist #region Start zvsEngine Services await Task.Delay(10); splashscreen.SetLoadingTextFormat("Starting zvsEngine services"); await Task.Delay(10); //Initialize the zvsEngine try { await Task.Run(() => ZvsEngine.StartAsync(Cts.Token)); } catch (Exception ex) { ProgramHasToClosePrompt(ex.Message); } #endregion //Create taskbar Icon TaskbarIcon = new ZVSTaskbarIcon(); TaskbarIcon.ShowBalloonTip(Utils.ApplicationName, Utils.ApplicationNameAndVersion + " started", 3000, ToolTipIcon.Info); //close Splash Screen splashscreen.Close(); #if DEBUG sw.Stop(); Debug.WriteLine("App Startup initialized in {0}", sw.Elapsed.ToString() as object); #endif base.OnStartup(e); }
public static async Task Updates_schedules_for_tasks_that_are_run() { var currentInstant = 30.December(2020).At(12, 07, 26).Utc(); var dueTime = currentInstant; var notDueTime = currentInstant.Plus(1.Seconds()); var dailyNotificationSchedule = new Schedule(ScheduledTaskType.DailyNotification, dueTime); var requestReminderSchedule = new Schedule(ScheduledTaskType.RequestReminder, notDueTime); var weeklyNotificationSchedule = new Schedule(ScheduledTaskType.WeeklyNotification, dueTime); var schedules = new[] { dailyNotificationSchedule, requestReminderSchedule, weeklyNotificationSchedule }; var mockScheduleRepository = new Mock <IScheduleRepository>(); mockScheduleRepository.Setup(r => r.GetSchedules()).ReturnsAsync(schedules); var mockDateCalculator = new Mock <IDateCalculator>(MockBehavior.Strict); mockDateCalculator.Setup(d => d.ScheduleIsDue(dailyNotificationSchedule, null)).Returns(true); mockDateCalculator.Setup(d => d.ScheduleIsDue(requestReminderSchedule, null)).Returns(false); mockDateCalculator.Setup(d => d.ScheduleIsDue(weeklyNotificationSchedule, null)).Returns(true); var mockDailyNotification = CreateMockScheduledTask(ScheduledTaskType.DailyNotification); var mockRequestReminder = CreateMockScheduledTask(ScheduledTaskType.RequestReminder); var mockWeeklyNotification = CreateMockScheduledTask(ScheduledTaskType.WeeklyNotification); var dailyNotificationNextRunTime = 31.December(2020).At(11, 0, 0).Utc(); var weeklyNotificationNextRunTime = 31.December(2020).AtMidnight().Utc(); mockDailyNotification.Setup(s => s.GetNextRunTime()).Returns(dailyNotificationNextRunTime); mockWeeklyNotification.Setup(s => s.GetNextRunTime()).Returns(weeklyNotificationNextRunTime); var scheduledTasks = new[] { mockDailyNotification.Object, mockRequestReminder.Object, mockWeeklyNotification.Object }; var scheduledTaskRunner = new ScheduledTaskRunner( mockDateCalculator.Object, scheduledTasks, mockScheduleRepository.Object); await scheduledTaskRunner.RunScheduledTasks(); mockScheduleRepository.Verify(r => r.GetSchedules(), Times.Once); mockScheduleRepository.Verify( r => r.UpdateSchedule(It.Is <Schedule>(s => s.ScheduledTaskType == ScheduledTaskType.DailyNotification && s.NextRunTime == dailyNotificationNextRunTime)), Times.Once); mockScheduleRepository.Verify( r => r.UpdateSchedule(It.Is <Schedule>(s => s.ScheduledTaskType == ScheduledTaskType.WeeklyNotification && s.NextRunTime == weeklyNotificationNextRunTime)), Times.Once); mockScheduleRepository.VerifyNoOtherCalls(); }
public async Task MultipleAsyncRequestsTest() { var dbConnection = new StubIEntityContextConnection { NameOrConnectionStringGet = () => "MultipleAsyncRequestsTest" }; Database.SetInitializer(new CreateFreshDbInitializer()); var logEntries = new List<LogEntry>(); var ranstoredCommands = new List<int>(); //Arrange var log = new StubIFeedback<LogEntry> { ReportAsyncT0CancellationToken = (e, c) => { Console.WriteLine(e.ToString()); logEntries.Add(e); return Task.FromResult(0); } }; var commandProcessor = new StubICommandProcessor { RunCommandAsyncNullableOfInt32StringStringCancellationToken = (commandId, argument, argument2, cancellationToken) => { if (commandId.HasValue) ranstoredCommands.Add(commandId.Value); return Task.FromResult(Result.ReportSuccess()); } }; var currentTime = new StubITimeProvider { TimeGet = () => DateTime.Parse("5/21/14 15:02:20") }; var cts = new CancellationTokenSource(); var taskRunner = new ScheduledTaskRunner(log, commandProcessor, dbConnection, currentTime); await taskRunner.StartAsync(cts.Token); var command = new Command(); var commandScheduledTask = new DataModel.ScheduledTask { IsEnabled = true, Name = "New Command added after start", Command = command }; using (var context = new ZvsContext(dbConnection)) { context.ScheduledTasks.Add(commandScheduledTask); var r2 = await context.TrySaveChangesAsync(cts.Token); Assert.IsFalse(r2.HasError, r2.Message); commandScheduledTask.StartTime = DateTime.Parse("5/20/14 15:02:20"); var r = await context.TrySaveChangesAsync(cts.Token); Assert.IsFalse(r.HasError, r.Message); commandScheduledTask.StartTime = DateTime.Parse("5/20/14 15:02:21"); var r3 = await context.TrySaveChangesAsync(cts.Token); Assert.IsFalse(r3.HasError, r.Message); } //Act await Task.Delay(2000, cts.Token); await taskRunner.StopAsync(cts.Token); //Assert Assert.IsTrue(logEntries.All(o => o.Level == LogEntryLevel.Info), "Expected only info type log entries"); Assert.IsTrue(ranstoredCommands.Count == 0, "Scheduled task runner did not run the correct amount of commands."); }
public void ConstructorPath4() { //arrange, act var tm = new ScheduledTaskRunner(new StubIFeedback <LogEntry>(), new StubICommandProcessor(), new UnitTestDbConnection(), null); //assert - throws exception }
public void ConstructorPath4() { //arrange, act var tm = new ScheduledTaskRunner(new StubIFeedback<LogEntry>(), new StubICommandProcessor(), new ZvsEntityContextConnection(), null); //assert - throws exception }
public async Task NewTaskExecutesTest() { var dbConnection = new UnitTestDbConnection(); Database.SetInitializer(new CreateFreshDbInitializer()); var logEntries = new List <LogEntry>(); var ranstoredCommands = new List <int>(); //Arrange var log = new StubIFeedback <LogEntry> { ReportAsyncT0CancellationToken = (e, c) => { Console.WriteLine(e.ToString()); logEntries.Add(e); return(Task.FromResult(0)); } }; var commandProcessor = new StubICommandProcessor { RunCommandAsyncNullableOfInt32StringStringCancellationToken = (commandId, argument, argument2, cancellationToken) => { if (commandId.HasValue) { ranstoredCommands.Add(commandId.Value); } return(Task.FromResult(Result.ReportSuccess())); } }; var currentTime = new StubITimeProvider { TimeGet = () => DateTime.Parse("5/21/14 15:02:20") }; var cts = new CancellationTokenSource(); var taskRunner = new ScheduledTaskRunner(log, commandProcessor, dbConnection, currentTime); var command = new Command(); var commandScheduledTask = new DataModel.ScheduledTask { IsEnabled = true, Name = "New Command added after start", Command = command }; using (var context = new ZvsContext(dbConnection)) { context.ScheduledTasks.Add(commandScheduledTask); var r2 = await context.TrySaveChangesAsync(cts.Token); Assert.IsFalse(r2.HasError, r2.Message); await taskRunner.StartAsync(cts.Token); await Task.Delay(500, cts.Token); //Act commandScheduledTask.StartTime = DateTime.Parse("5/20/14 15:02:20"); var r = await context.TrySaveChangesAsync(cts.Token); Assert.IsFalse(r.HasError, r.Message); await Task.Delay(1000, cts.Token); await taskRunner.StopAsync(cts.Token); } //Assert Assert.IsTrue(logEntries.All(o => o.Level == LogEntryLevel.Info), "Expected only info type log entries"); Assert.IsTrue(ranstoredCommands.Count == 1, "Scheduled task runner did not run the correct amount of commands."); }
public async Task StartAsyncTest() { //arrange var dbConnection = new StubIEntityContextConnection { NameOrConnectionStringGet = () => "engine-StartAsyncTest" }; Database.SetInitializer(new CreateFreshDbInitializer()); var logEntries = new List<LogEntry>(); var log = new StubIFeedback<LogEntry> { ReportAsyncT0CancellationToken = (e, c) => { Console.WriteLine(e.ToString()); logEntries.Add(e); return Task.FromResult(0); } }; var isAdapterManagerInitialized = false; var isPluginManagerInitialized = false; var am = new StubIAdapterManager { StartAsyncCancellationToken = async (ct) =>isAdapterManagerInitialized = true }; var pm = new StubIPluginManager { StartAsyncCancellationToken = async (ct) => isPluginManagerInitialized = true }; var tr = new TriggerRunner(log, new StubICommandProcessor(), dbConnection); var st = new ScheduledTaskRunner(log, new StubICommandProcessor(), dbConnection,new CurrentTimeProvider()); var engine = new ZvsEngine(log, am, pm, dbConnection, tr, st); //Act await engine.StartAsync(CancellationToken.None); //assert Assert.IsNotNull(engine); Assert.IsTrue(isAdapterManagerInitialized, "Adapter manager was not started!"); Assert.IsTrue(isPluginManagerInitialized, "Plugin manager was not started!"); Assert.IsTrue(engine.ScheduledTaskRunner.IsRunning, "Scheduled Task Runner was not started!"); Assert.IsTrue(engine.TriggerRunner.IsRunning, "Trigger Runner was not started!"); }
public async Task StartPath2() { //Arrange var logEntries = new List<LogEntry>(); var log = new StubIFeedback<LogEntry> { ReportAsyncT0CancellationToken = (e, c) => { Console.WriteLine(e.ToString()); logEntries.Add(e); return Task.FromResult(0); } }; var cts = new CancellationTokenSource(); var tm = new ScheduledTaskRunner(log, new StubICommandProcessor(), new ZvsEntityContextConnection(), new CurrentTimeProvider()); //Act await tm.StartAsync(cts.Token); await tm.StartAsync(cts.Token); //Assert Assert.IsTrue(logEntries.Last().Level == LogEntryLevel.Warn); }