fixes #433 RAMJobStore fails to resume when paused without triggers

src/Quartz.Tests.Integration/Quartz.Tests.Integration.csproj

@@ -74,6 +74,7 @@
   </ItemGroup>
   <ItemGroup>
     <Compile Include="AdoSchedulerTest.cs" />
+    <Compile Include="QuartzMemoryPauseAndResumeTest.cs" />
     <Compile Include="Core\MissSchedulingChangeSignalTest.cs" />
     <Compile Include="ExceptionPolicy\ExceptionJob.cs" />
     <Compile Include="ExceptionPolicy\ExceptionJobTest.cs" />

src/Quartz.Tests.Integration/QuartzMemoryPauseAndResumeTest.cs

@@ -0,0 +1,151 @@
+using System.Threading.Tasks;
+
+using NUnit.Framework;
+
+using Quartz.Impl;
+using Quartz.Impl.Matchers;
+using Quartz.Job;
+
+namespace Quartz.Tests.Integration
+{
+    [TestFixture]
+    public class QuartzMemoryPauseAndResumeTest
+    {
+        private IScheduler scheduler;
+
+        [SetUp]
+        public async Task SetUp()
+        {
+            ISchedulerFactory sf = new StdSchedulerFactory();
+            scheduler = await sf.GetScheduler();
+        }
+
+        [TearDown]
+        public async Task TearDown()
+        {
+            await scheduler.Shutdown(true);
+        }
+
+        [Test]
+        public async Task TestPauseAndResumeTriggers()
+        {
+            IJobDetail jobDetail = JobBuilder.Create<NoOpJob>()
+                .WithIdentity("test")
+                .Build();
+
+            ITrigger trigger = TriggerBuilder.Create()
+                .WithIdentity("test", "abc")
+                .WithCronSchedule("* * * * * ?")
+                .Build();
+
+            await scheduler.ScheduleJob(jobDetail, trigger);
+
+            TriggerState state = await scheduler.GetTriggerState(new TriggerKey("test", "abc"));
+            Assert.That(state, Is.EqualTo(TriggerState.Normal));
+            Assert.That(state, Is.Not.EqualTo(TriggerState.Paused));
+
+            await scheduler.PauseTriggers(GroupMatcher<TriggerKey>.GroupEquals("abc"));
+            state = await scheduler.GetTriggerState(new TriggerKey("test", "abc"));
+            Assert.That(state, Is.EqualTo(TriggerState.Paused));
+            Assert.That(state, Is.Not.EqualTo(TriggerState.Normal));
+
+            await scheduler.ResumeTriggers(GroupMatcher<TriggerKey>.GroupEquals("abc"));
+            state = await scheduler.GetTriggerState(new TriggerKey("test", "abc"));
+            Assert.That(state, Is.EqualTo(TriggerState.Normal));
+            Assert.That(state, Is.Not.EqualTo(TriggerState.Paused));
+        }
+
+        [Test]
+        public async Task TestResumeTriggersBeforeAddJob()
+        {
+            await scheduler.PauseTriggers(GroupMatcher<TriggerKey>.GroupEquals("abc"));
+            await scheduler.ResumeTriggers(GroupMatcher<TriggerKey>.GroupEquals("abc"));
+
+            IJobDetail jobDetail = JobBuilder.Create<NoOpJob>()
+                .WithIdentity("test")
+                .Build();
+
+            ITrigger trigger = TriggerBuilder.Create()
+                .WithIdentity("test", "abc")
+                .WithCronSchedule("* * * * * ?")
+                .Build();
+
+            await scheduler.ScheduleJob(jobDetail, trigger);
+
+            TriggerState state = await scheduler.GetTriggerState(new TriggerKey("test", "abc"));
+            Assert.That(state, Is.EqualTo(TriggerState.Normal));
+            Assert.That(state, Is.Not.EqualTo(TriggerState.Paused));
+
+            await scheduler.PauseTriggers(GroupMatcher<TriggerKey>.GroupEquals("abc"));
+            state = await scheduler.GetTriggerState(new TriggerKey("test", "abc"));
+            Assert.That(state, Is.EqualTo(TriggerState.Paused));
+            Assert.That(state, Is.Not.EqualTo(TriggerState.Normal));
+
+            await scheduler.ResumeTriggers(GroupMatcher<TriggerKey>.GroupEquals("abc"));
+            state = await scheduler.GetTriggerState(new TriggerKey("test", "abc"));
+            Assert.That(state, Is.EqualTo(TriggerState.Normal));
+            Assert.That(state, Is.Not.EqualTo(TriggerState.Paused));
+        }
+
+        [Test]
+        public async Task TestPauseAndResumeJobs()
+        {
+            IJobDetail jobDetail = JobBuilder.Create<NoOpJob>()
+                .WithIdentity("test", "abc")
+                .Build();
+
+            ITrigger trigger = TriggerBuilder.Create()
+                .WithIdentity("test", "abc")
+                .WithCronSchedule("* * * * * ?")
+                .Build();
+
+            await scheduler.ScheduleJob(jobDetail, trigger);
+
+            TriggerState state = await scheduler.GetTriggerState(new TriggerKey("test", "abc"));
+            Assert.That(state, Is.EqualTo(TriggerState.Normal));
+            Assert.That(state, Is.Not.EqualTo(TriggerState.Paused));
+
+            await scheduler.PauseJobs(GroupMatcher<JobKey>.GroupEquals("abc"));
+            state = await scheduler.GetTriggerState(new TriggerKey("test", "abc"));
+            Assert.That(state, Is.EqualTo(TriggerState.Paused));
+            Assert.That(state, Is.Not.EqualTo(TriggerState.Normal));
+
+            await scheduler.ResumeJobs(GroupMatcher<JobKey>.GroupEquals("abc"));
+            state = await scheduler.GetTriggerState(new TriggerKey("test", "abc"));
+            Assert.That(state, Is.EqualTo(TriggerState.Normal));
+            Assert.That(state, Is.Not.EqualTo(TriggerState.Paused));
+        }
+
+        [Test]
+        public async Task TestResumeJobsBeforeAddJobs()
+        {
+            await scheduler.PauseJobs(GroupMatcher<JobKey>.GroupEquals("abc"));
+            await scheduler.ResumeJobs(GroupMatcher<JobKey>.GroupEquals("abc"));
+
+            IJobDetail jobDetail = JobBuilder.Create<NoOpJob>()
+                .WithIdentity("test", "abc")
+                .Build();
+
+            ITrigger trigger = TriggerBuilder.Create()
+                .WithIdentity("test", "abc")
+                .WithCronSchedule("* * * * * ?")
+                .Build();
+
+            await scheduler.ScheduleJob(jobDetail, trigger);
+
+            TriggerState state = await scheduler.GetTriggerState(new TriggerKey("test", "abc"));
+            Assert.That(state, Is.EqualTo(TriggerState.Normal));
+            Assert.That(state, Is.Not.EqualTo(TriggerState.Paused));
+
+            await scheduler.PauseJobs(GroupMatcher<JobKey>.GroupEquals("abc"));
+            state = await scheduler.GetTriggerState(new TriggerKey("test", "abc"));
+            Assert.That(state, Is.EqualTo(TriggerState.Paused));
+            Assert.That(state, Is.Not.EqualTo(TriggerState.Normal));
+
+            await scheduler.ResumeJobs(GroupMatcher<JobKey>.GroupEquals("abc"));
+            state = await scheduler.GetTriggerState(new TriggerKey("test", "abc"));
+            Assert.That(state, Is.EqualTo(TriggerState.Normal));
+            Assert.That(state, Is.Not.EqualTo(TriggerState.Paused));
+        }
+    }
+}

src/Quartz/Simpl/RAMJobStore.cs

@@ -1325,13 +1325,33 @@ private ISet<string> ResumeTriggersInternal(GroupMatcher<TriggerKey> matcher)
                     }
                     ResumeTriggerInternal(triggerKey);
                 }
-                foreach (string group in groups)
+                // Find all matching paused trigger groups, and then remove them.
+                StringOperator op = matcher.CompareWithOperator;
+                var pausedGroups = new List<string>();
+                var matcherGroup = matcher.CompareToValue;
+                if (op.Equals(StringOperator.Equality))
                 {
-                    pausedTriggerGroups.Remove(@group);
+                    if (pausedTriggerGroups.Contains(matcherGroup))
+                    {
+                        pausedGroups.Add(matcher.CompareToValue);
+                    }
+                    else
+                    {
+                        foreach (string group in pausedTriggerGroups)
+                        {
+                            if (op.Evaluate(group, matcherGroup))
+                            {
+                                pausedGroups.Add(group);
+                            }
+                        }
+                    }
+                    foreach (string pausedGroup in pausedGroups)
+                    {
+                        pausedTriggerGroups.Remove(pausedGroup);
+                    }
                 }
-
                 return groups;
-        }
+            }
         }
 
         /// <summary>