Implementing a general scheduled task subsystem... Main top level actors include IScheduledTaskManager and SchedulingBackgroundTask. Specific needs of interfaces into subsystem expected to evolve as used from modules.

--HG--
extra : convert_revision : svn%3A5ff7c347-ad56-4c35-b696-ccb81de16e03/trunk%4045364

src/Orchard.Core.Tests/Orchard.Core.Tests.csproj

@@ -58,6 +58,7 @@
     <Reference Include="System.Data.SQLite, Version=1.0.65.0, Culture=neutral, PublicKeyToken=db937bc2d44ff139, processorArchitecture=x86">
       <SpecificVersion>False</SpecificVersion>
       <HintPath>..\..\lib\sqlite\System.Data.SQLite.DLL</HintPath>
+      <Private>True</Private>
     </Reference>
     <Reference Include="System.Xml.Linq">
       <RequiredTargetFramework>3.5</RequiredTargetFramework>
@@ -71,6 +72,7 @@
   <ItemGroup>
     <Compile Include="Common\Providers\CommonAspectProviderTests.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
+    <Compile Include="Scheduling\ScheduledTaskExecutorTests.cs" />
   </ItemGroup>
   <ItemGroup>
     <ProjectReference Include="..\Orchard.Tests.Packages\Orchard.Tests.Packages.csproj">

src/Orchard.Core.Tests/Scheduling/ScheduledTaskExecutorTests.cs

@@ -0,0 +1,109 @@
+using System;
+using System.Collections.Generic;
+using Autofac.Builder;
+using Moq;
+using NUnit.Framework;
+using Orchard.ContentManagement;
+using Orchard.ContentManagement.Records;
+using Orchard.Core.Scheduling;
+using Orchard.Core.Scheduling.Models;
+using Orchard.Core.Scheduling.Services;
+using Orchard.Data;
+using Orchard.Services;
+using Orchard.Tasks;
+using Orchard.Tests.Packages;
+using Orchard.Tests.Stubs;
+
+namespace Orchard.Core.Tests.Scheduling {
+    [TestFixture]
+    public class ScheduledTaskExecutorTests : DatabaseEnabledTestsBase {
+        private StubTaskHandler _handler;
+        private IBackgroundTask _executor;
+        private IRepository<ScheduledTaskRecord> _repository;
+
+        public override void Init() {
+            base.Init();
+            _repository = _container.Resolve<IRepository<ScheduledTaskRecord>>();
+            _executor = _container.Resolve<IBackgroundTask>("ScheduledBackgroundTask");
+        }
+        public override void Register(ContainerBuilder builder) {
+            _handler = new StubTaskHandler();
+            builder.Register(new Mock<IOrchardServices>().Object);
+            builder.Register<DefaultContentManager>().As<IContentManager>();
+            builder.Register<SchedulingBackgroundTask>().As<IBackgroundTask>().Named("ScheduledBackgroundTask");
+            builder.Register(_handler).As<IScheduledTaskHandler>();
+        }
+
+        public class StubTaskHandler : IScheduledTaskHandler {
+            public void Process(ScheduledTaskContext context) {
+                TaskContext = context;
+            }
+
+            public ScheduledTaskContext TaskContext { get; private set; }
+        }
+
+        protected override IEnumerable<Type> DatabaseTypes {
+            get {
+                return new[] {
+                                 typeof(ContentTypeRecord), 
+                                 typeof(ContentItemRecord), 
+                                 typeof(ContentItemVersionRecord), 
+                                 typeof(ScheduledAspectRecord),
+                                 typeof(ScheduledTaskRecord),
+                             };
+            }
+        }
+
+        [Test]
+        public void SweepShouldBeCallable() {
+            _executor.Sweep();
+        }
+
+        [Test]
+        public void RecordsForTheFutureShouldBeIgnored() {
+            _repository.Create(new ScheduledTaskRecord { ScheduledUtc = _clock.UtcNow.Add(TimeSpan.FromHours(2)) });
+            _repository.Flush();
+            _executor.Sweep();
+            _repository.Flush();
+            Assert.That(_repository.Count(x => true), Is.EqualTo(1));
+        }
+
+
+        [Test]
+        public void RecordsWhenTheyAreExecutedShouldBeDeleted() {
+            var task = new ScheduledTaskRecord { Action = "Ignore", ScheduledUtc = _clock.UtcNow.Add(TimeSpan.FromHours(2)) };
+            _repository.Create(task);
+
+            _repository.Flush();
+            _executor.Sweep();
+
+            _repository.Flush();
+            Assert.That(_repository.Count(x => x.Action == "Ignore"), Is.EqualTo(1));
+
+            _clock.Advance(TimeSpan.FromHours(3));
+
+            _repository.Flush();
+            _executor.Sweep();
+
+            _repository.Flush();
+            Assert.That(_repository.Count(x => x.Action == "Ignore"), Is.EqualTo(0));
+        }
+
+        [Test]
+        public void ScheduledTaskHandlersShouldBeCalledWhenTasksAreExecuted() {
+            var task = new ScheduledTaskRecord { Action = "Ignore", ScheduledUtc = _clock.UtcNow.Add(TimeSpan.FromHours(2)) };
+            _repository.Create(task);
+
+            _repository.Flush();
+            _clock.Advance(TimeSpan.FromHours(3));
+
+            Assert.That(_handler.TaskContext, Is.Null);
+            _executor.Sweep();
+            Assert.That(_handler.TaskContext, Is.Not.Null);
+            
+            Assert.That(_handler.TaskContext.ScheduledTaskRecord.Action, Is.EqualTo("Ignore"));
+            Assert.That(_handler.TaskContext.ContentItem, Is.Null);
+        }
+    }
+}
+