Changed the trigger API to allow it to work with run times in the past

9 files changed, 108 insertions, 116 deletions

diff --git a/apscheduler/job.py b/apscheduler/job.py
index b1f8d6e..a65cde6 100644
--- a/apscheduler/job.py
+++ b/apscheduler/job.py
@@ -94,18 +94,17 @@ class Job(object):
 
     def _get_run_times(self, now):
         """
-        Computes the scheduled run times between ``next_run_time`` and ``now``.
+        Computes the scheduled run times between ``next_run_time`` and ``now`` (inclusive).
 
         :type now: datetime
         :rtype: list[datetime]
         """
 
         run_times = []
-        run_time = self.next_run_time
-        increment = timedelta(microseconds=1)
-        while run_time and run_time <= now:
-            run_times.append(run_time)
-            run_time = self.trigger.get_next_fire_time(run_time + increment)
+        next_run_time = self.next_run_time
+        while next_run_time and next_run_time <= now:
+            run_times.append(next_run_time)
+            next_run_time = self.trigger.get_next_fire_time(next_run_time, now)
 
         return run_times
 
diff --git a/apscheduler/schedulers/base.py b/apscheduler/schedulers/base.py
index fefae2e..af0b57c 100644
--- a/apscheduler/schedulers/base.py
+++ b/apscheduler/schedulers/base.py
@@ -340,7 +340,7 @@ class BaseScheduler(six.with_metaclass(ABCMeta)):
 
         trigger = self._create_trigger(trigger, trigger_args)
         now = datetime.now(self.timezone)
-        next_run_time = trigger.get_next_fire_time(now)
+        next_run_time = trigger.get_next_fire_time(None, now)
         self.modify_job(job_id, jobstore, trigger=trigger, next_run_time=next_run_time)
 
     def pause_job(self, job_id, jobstore=None):
@@ -364,7 +364,7 @@ class BaseScheduler(six.with_metaclass(ABCMeta)):
         with self._jobstores_lock:
             job, jobstore = self._lookup_job(job_id, jobstore)
             now = datetime.now(self.timezone)
-            next_run_time = job.trigger.get_next_fire_time(now)
+            next_run_time = job.trigger.get_next_fire_time(None, now)
             if next_run_time:
                 self.modify_job(job_id, jobstore, next_run_time=next_run_time)
             else:
@@ -623,7 +623,7 @@ class BaseScheduler(six.with_metaclass(ABCMeta)):
 
         # Calculate the next run time
         now = datetime.now(self.timezone)
-        job.next_run_time = job.trigger.get_next_fire_time(now)
+        job.next_run_time = job.trigger.get_next_fire_time(None, now)
 
         # Add the job to the given job store
         store = self._lookup_jobstore(jobstore_alias)
@@ -716,9 +716,8 @@ class BaseScheduler(six.with_metaclass(ABCMeta)):
                             self._logger.exception('Error submitting job "%s" to executor "%s"', job, job.executor)
                             continue
 
-                        # Update the job if it has a next execution time and the number of runs has not reached maximum,
-                        # otherwise remove it from the job store
-                        job_next_run = job.trigger.get_next_fire_time(now + timedelta(microseconds=1))
+                        # Update the job if it has a next execution time. Otherwise remove it from the job store
+                        job_next_run = job.trigger.get_next_fire_time(run_times[-1], now)
                         if job_next_run:
                             job._modify(next_run_time=job_next_run)
                             jobstore.update_job(job)
diff --git a/apscheduler/triggers/base.py b/apscheduler/triggers/base.py
index 63a9929..ec8118d 100644
--- a/apscheduler/triggers/base.py
+++ b/apscheduler/triggers/base.py
@@ -5,10 +5,10 @@ import six
 
 class BaseTrigger(six.with_metaclass(ABCMeta)):
     @abstractmethod
-    def get_next_fire_time(self, start_date):
+    def get_next_fire_time(self, previous_fire_time, now):
         """
-        Returns the next datetime, equal to or greater than ``start_date``, when this trigger will fire.
-        If no such datetime can be calculated, returns ``None``.
+        Returns the next datetime to fire on, If no such datetime can be calculated, returns ``None``.
 
-        :type start_date: datetime.datetime
+        :param datetime.datetime previous_fire_time: the previous time the trigger was fired
+        :param datetime.datetime now: current datetime
         """
diff --git a/apscheduler/triggers/cron/__init__.py b/apscheduler/triggers/cron/__init__.py
index 27362b8..c3dca9d 100644
--- a/apscheduler/triggers/cron/__init__.py
+++ b/apscheduler/triggers/cron/__init__.py
@@ -1,4 +1,4 @@
-from datetime import datetime
+from datetime import datetime, timedelta
 
 from tzlocal import get_localzone
 import six
@@ -129,12 +129,14 @@ class CronTrigger(BaseTrigger):
         difference = datetime(**values) - dateval.replace(tzinfo=None)
         return self.timezone.normalize(dateval + difference)
 
-    def get_next_fire_time(self, start_date):
-        if self.start_date:
-            start_date = max(start_date, self.start_date)
-        next_date = datetime_ceil(start_date).astimezone(self.timezone)
+    def get_next_fire_time(self, previous_fire_time, now):
+        if previous_fire_time:
+            start_date = max(now, previous_fire_time + timedelta(microseconds=1))
+        else:
+            start_date = max(now, self.start_date) if self.start_date else now
 
         fieldnum = 0
+        next_date = datetime_ceil(start_date).astimezone(self.timezone)
         while 0 <= fieldnum < len(self.fields):
             field = self.fields[fieldnum]
             curr_value = field.get_value(next_date)
diff --git a/apscheduler/triggers/date.py b/apscheduler/triggers/date.py
index b07c2ca..b5b153f 100644
--- a/apscheduler/triggers/date.py
+++ b/apscheduler/triggers/date.py
@@ -18,9 +18,8 @@ class DateTrigger(BaseTrigger):
         timezone = astimezone(timezone) or get_localzone()
         self.run_date = convert_to_datetime(run_date or datetime.now(), timezone, 'run_date')
 
-    def get_next_fire_time(self, start_date):
-        if self.run_date >= start_date:
-            return self.run_date
+    def get_next_fire_time(self, previous_fire_time, now):
+        return self.run_date if previous_fire_time is None else None
 
     def __str__(self):
         return 'date[%s]' % datetime_repr(self.run_date)
diff --git a/apscheduler/triggers/interval.py b/apscheduler/triggers/interval.py
index ee9ce82..0f7c836 100644
--- a/apscheduler/triggers/interval.py
+++ b/apscheduler/triggers/interval.py
@@ -42,16 +42,18 @@ class IntervalTrigger(BaseTrigger):
         self.start_date = convert_to_datetime(start_date, self.timezone, 'start_date')
         self.end_date = convert_to_datetime(end_date, self.timezone, 'end_date')
 
-    def get_next_fire_time(self, start_date):
-        if start_date < self.start_date:
-            return self.start_date
-
-        timediff_seconds = timedelta_seconds(start_date - self.start_date)
-        next_interval_num = int(ceil(timediff_seconds / self.interval_length))
-        next_date = self.timezone.normalize(self.start_date + self.interval * next_interval_num)
-        if self.end_date and next_date > self.end_date:
-            return None
-        return next_date
+    def get_next_fire_time(self, previous_fire_time, now):
+        if previous_fire_time:
+            next_fire_time = previous_fire_time + self.interval
+        elif self.start_date > now:
+            next_fire_time = self.start_date
+        else:
+            timediff_seconds = timedelta_seconds(now - self.start_date)
+            next_interval_num = int(ceil(timediff_seconds / self.interval_length))
+            next_fire_time = self.start_date + self.interval * next_interval_num
+
+        if not self.end_date or next_fire_time <= self.end_date:
+            return self.timezone.normalize(next_fire_time)
 
     def __str__(self):
         return 'interval[%s]' % str(self.interval)
diff --git a/tests/test_jobstores.py b/tests/test_jobstores.py
index 7d6f282..64a0ed7 100644
--- a/tests/test_jobstores.py
+++ b/tests/test_jobstores.py
@@ -78,7 +78,7 @@ def create_add_job(timezone, create_job):
     def create(jobstore, func=dummy_job, run_date=datetime(2999, 1, 1), id=None, **kwargs):
         run_date = timezone.localize(run_date)
         job = create_job(func=func, trigger='date', trigger_args={'run_date': run_date}, id=id, **kwargs)
-        job.next_run_time = job.trigger.get_next_fire_time(run_date)
+        job.next_run_time = job.trigger.get_next_fire_time(None, run_date)
         if jobstore:
             jobstore.add_job(job)
         return job
diff --git a/tests/test_schedulers.py b/tests/test_schedulers.py
index e9ad7c2..d0c1af8 100644
--- a/tests/test_schedulers.py
+++ b/tests/test_schedulers.py
@@ -274,7 +274,8 @@ class TestRunningScheduler(object):
         it.
         """
 
-        job = create_job(func=lambda: None, trigger_args={'run_date': datetime(2000, 1, 1), 'timezone': timezone})
+        job = create_job(func=lambda: None, trigger='interval',
+                         trigger_args={'minutes': 2, 'end_date': datetime(2000, 1, 1), 'timezone': timezone})
         assert job.next_run_time is None
         jobstore = MagicMock(BaseJobStore, lookup_job=lambda job_id: job)
         scheduler._wakeup = MagicMock()
@@ -320,9 +321,8 @@ class TestRunningScheduler(object):
 
     def test_job_finished(self, scheduler, freeze_time):
         vals = [0]
-        job = scheduler.add_job(increment, 'interval', args=(vals,), end_date=freeze_time.current)
-        freeze_time.set(job.next_run_time)
-        scheduler._process_jobs()
+        job = scheduler.add_job(increment, 'interval', args=(vals,), start_date=freeze_time.current,
+                                end_date=freeze_time.current)
         assert vals == [1]
         assert job not in scheduler.get_jobs()
 
diff --git a/tests/test_triggers.py b/tests/test_triggers.py
index ddf793e..b707152 100644
--- a/tests/test_triggers.py
+++ b/tests/test_triggers.py
@@ -15,27 +15,27 @@ class TestCronTrigger(object):
         assert str(trigger) == "cron[year='2009/2', month='1/3', day='5-13']"
         start_date = timezone.localize(datetime(2008, 12, 1))
         correct_next_date = timezone.localize(datetime(2009, 1, 5))
-        assert trigger.get_next_fire_time(start_date) == correct_next_date
+        assert trigger.get_next_fire_time(None, start_date) == correct_next_date
 
     def test_cron_trigger_2(self, timezone):
         trigger = CronTrigger(year='2009/2', month='1/3', day='5-13', timezone=timezone)
         start_date = timezone.localize(datetime(2009, 10, 14))
         correct_next_date = timezone.localize(datetime(2011, 1, 5))
-        assert trigger.get_next_fire_time(start_date) == correct_next_date
+        assert trigger.get_next_fire_time(None, start_date) == correct_next_date
 
     def test_cron_trigger_3(self, timezone):
         trigger = CronTrigger(year='2009', month='2', hour='8-10', timezone=timezone)
         assert repr(trigger) == "<CronTrigger (year='2009', month='2', hour='8-10')>"
         start_date = timezone.localize(datetime(2009, 1, 1))
         correct_next_date = timezone.localize(datetime(2009, 2, 1, 8))
-        assert trigger.get_next_fire_time(start_date) == correct_next_date
+        assert trigger.get_next_fire_time(None, start_date) == correct_next_date
 
     def test_cron_trigger_4(self, timezone):
         trigger = CronTrigger(year='2012', month='2', day='last', timezone=timezone)
         assert repr(trigger) == "<CronTrigger (year='2012', month='2', day='last')>"
         start_date = timezone.localize(datetime(2012, 2, 1))
         correct_next_date = timezone.localize(datetime(2012, 2, 29))
-        assert trigger.get_next_fire_time(start_date) == correct_next_date
+        assert trigger.get_next_fire_time(None, start_date) == correct_next_date
 
     def test_cron_zero_value(self, timezone):
         trigger = CronTrigger(year=2009, month=2, hour=0, timezone=timezone)
@@ -47,7 +47,7 @@ class TestCronTrigger(object):
         assert str(trigger) == "cron[year='2009,2008']"
         start_date = timezone.localize(datetime(2009, 1, 1))
         correct_next_date = timezone.localize(datetime(2009, 1, 1))
-        assert trigger.get_next_fire_time(start_date) == correct_next_date
+        assert trigger.get_next_fire_time(None, start_date) == correct_next_date
 
     def test_cron_start_date(self, timezone):
         trigger = CronTrigger(year='2009', month='2', hour='8-10', start_date='2009-02-03 11:00:00', timezone=timezone)
@@ -56,7 +56,7 @@ class TestCronTrigger(object):
         assert str(trigger) == "cron[year='2009', month='2', hour='8-10']"
         start_date = timezone.localize(datetime(2009, 1, 1))
         correct_next_date = timezone.localize(datetime(2009, 2, 4, 8))
-        assert trigger.get_next_fire_time(start_date) == correct_next_date
+        assert trigger.get_next_fire_time(None, start_date) == correct_next_date
 
     def test_cron_weekday_overlap(self, timezone):
         trigger = CronTrigger(year=2009, month=1, day='6-10', day_of_week='2-4', timezone=timezone)
@@ -64,7 +64,7 @@ class TestCronTrigger(object):
         assert str(trigger) == "cron[year='2009', month='1', day='6-10', day_of_week='2-4']"
         start_date = timezone.localize(datetime(2009, 1, 1))
         correct_next_date = timezone.localize(datetime(2009, 1, 7))
-        assert trigger.get_next_fire_time(start_date) == correct_next_date
+        assert trigger.get_next_fire_time(None, start_date) == correct_next_date
 
     def test_cron_weekday_nomatch(self, timezone):
         trigger = CronTrigger(year=2009, month=1, day='6-10', day_of_week='0,6', timezone=timezone)
@@ -72,7 +72,7 @@ class TestCronTrigger(object):
         assert str(trigger) == "cron[year='2009', month='1', day='6-10', day_of_week='0,6']"
         start_date = timezone.localize(datetime(2009, 1, 1))
         correct_next_date = None
-        assert trigger.get_next_fire_time(start_date) == correct_next_date
+        assert trigger.get_next_fire_time(None, start_date) == correct_next_date
 
     def test_cron_weekday_positional(self, timezone):
         trigger = CronTrigger(year=2009, month=1, day='4th wed', timezone=timezone)
@@ -80,7 +80,7 @@ class TestCronTrigger(object):
         assert str(trigger) == "cron[year='2009', month='1', day='4th wed']"
         start_date = timezone.localize(datetime(2009, 1, 1))
         correct_next_date = timezone.localize(datetime(2009, 1, 28))
-        assert trigger.get_next_fire_time(start_date) == correct_next_date
+        assert trigger.get_next_fire_time(None, start_date) == correct_next_date
 
     def test_week_1(self, timezone):
         trigger = CronTrigger(year=2009, month=2, week=8, timezone=timezone)
@@ -88,7 +88,7 @@ class TestCronTrigger(object):
         assert str(trigger) == "cron[year='2009', month='2', week='8']"
         start_date = timezone.localize(datetime(2009, 1, 1))
         correct_next_date = timezone.localize(datetime(2009, 2, 16))
-        assert trigger.get_next_fire_time(start_date) == correct_next_date
+        assert trigger.get_next_fire_time(None, start_date) == correct_next_date
 
     def test_week_2(self, timezone):
         trigger = CronTrigger(year=2009, week=15, day_of_week=2, timezone=timezone)
@@ -96,7 +96,7 @@ class TestCronTrigger(object):
         assert str(trigger) == "cron[year='2009', week='15', day_of_week='2']"
         start_date = timezone.localize(datetime(2009, 1, 1))
         correct_next_date = timezone.localize(datetime(2009, 4, 8))
-        assert trigger.get_next_fire_time(start_date) == correct_next_date
+        assert trigger.get_next_fire_time(None, start_date) == correct_next_date
 
     def test_cron_extra_coverage(self, timezone):
         # This test has no value other than patching holes in test coverage
@@ -105,7 +105,7 @@ class TestCronTrigger(object):
         assert str(trigger) == "cron[day='6,8']"
         start_date = timezone.localize(datetime(2009, 12, 31))
         correct_next_date = timezone.localize(datetime(2010, 1, 6))
-        assert trigger.get_next_fire_time(start_date) == correct_next_date
+        assert trigger.get_next_fire_time(None, start_date) == correct_next_date
 
     def test_cron_faulty_expr(self, timezone):
         pytest.raises(ValueError, CronTrigger, year='2009-fault', timezone=timezone)
@@ -121,7 +121,7 @@ class TestCronTrigger(object):
         assert str(trigger) == "cron[hour='5-6']"
         start_date = timezone.localize(datetime(2009, 9, 25, 7))
         correct_next_date = timezone.localize(datetime(2009, 9, 26, 5))
-        assert trigger.get_next_fire_time(start_date) == correct_next_date
+        assert trigger.get_next_fire_time(None, start_date) == correct_next_date
 
     def test_cron_bad_kwarg(self, timezone):
         pytest.raises(TypeError, CronTrigger, second=0, third=1, timezone=timezone)
@@ -138,8 +138,8 @@ class TestCronTrigger(object):
         trigger = CronTrigger(year=2014, hour=4, end_date=end_date)
 
         start_date = timezone.localize(datetime(2014, 4, 13, 2, 30))
-        assert trigger.get_next_fire_time(start_date - timedelta(1)) == start_date.replace(day=12, hour=4, minute=0)
-        assert trigger.get_next_fire_time(start_date) is None
+        assert trigger.get_next_fire_time(None, start_date - timedelta(1)) == start_date.replace(day=12, hour=4, minute=0)
+        assert trigger.get_next_fire_time(None, start_date) is None
 
     def test_different_tz(self, timezone):
         alter_tz = pytz.FixedOffset(-600)
@@ -148,7 +148,7 @@ class TestCronTrigger(object):
         assert str(trigger) == "cron[year='2009', week='15', day_of_week='2']"
         start_date = alter_tz.localize(datetime(2008, 12, 31, 22))
         correct_next_date = timezone.localize(datetime(2009, 4, 8))
-        assert trigger.get_next_fire_time(start_date) == correct_next_date
+        assert trigger.get_next_fire_time(None, start_date) == correct_next_date
 
     def test_dst_change(self):
         """
@@ -162,11 +162,11 @@ class TestCronTrigger(object):
 
         datetime_edt = eastern.localize(datetime(2013, 11, 3, 1, 5), is_dst=True)
         correct_next_date = eastern.localize(datetime(2013, 11, 3, 1, 30), is_dst=True)
-        assert str(trigger.get_next_fire_time(datetime_edt)) == str(correct_next_date)
+        assert str(trigger.get_next_fire_time(None, datetime_edt)) == str(correct_next_date)
 
         datetime_edt = eastern.localize(datetime(2013, 11, 3, 1, 35), is_dst=True)
         correct_next_date = eastern.localize(datetime(2013, 11, 3, 1), is_dst=False)
-        assert str(trigger.get_next_fire_time(datetime_edt)) == str(correct_next_date)
+        assert str(trigger.get_next_fire_time(None, datetime_edt)) == str(correct_next_date)
 
     def test_timezone_change(self, timezone):
         """
@@ -179,43 +179,27 @@ class TestCronTrigger(object):
         trigger = CronTrigger(hour=11, minute='*/5', timezone=est)
         start_date = cst.localize(datetime(2009, 9, 26, 10, 16))
         correct_next_date = est.localize(datetime(2009, 9, 26, 11, 20))
-        assert str(trigger.get_next_fire_time(start_date)) == str(correct_next_date)
+        assert str(trigger.get_next_fire_time(None, start_date)) == str(correct_next_date)
 
 
 class TestDateTrigger(object):
-    def test_date_trigger_earlier(self, timezone):
-        fire_date = datetime(2009, 7, 6)
-        trigger = DateTrigger(fire_date, timezone)
-        assert repr(trigger) == "<DateTrigger (run_date='2009-07-06 00:00:00 CEST')>"
-        assert str(trigger) == "date[2009-07-06 00:00:00 CEST]"
-        start_date = timezone.localize(datetime(2008, 12, 1))
-        assert trigger.get_next_fire_time(start_date) == timezone.localize(fire_date)
-
-    def test_date_trigger_exact(self, timezone):
-        fire_date = timezone.localize(datetime(2009, 7, 6))
-        trigger = DateTrigger(fire_date, timezone)
-        start_date = timezone.localize(datetime(2009, 7, 6))
-        assert trigger.get_next_fire_time(start_date) == fire_date
-
-    def test_date_trigger_later(self, timezone):
-        fire_date = timezone.localize(datetime(2009, 7, 6))
-        trigger = DateTrigger(fire_date, timezone)
-        start_date = timezone.localize(datetime(2009, 7, 7))
-        assert trigger.get_next_fire_time(start_date) is None
-
-    def test_date_trigger_text(self, timezone):
-        trigger = DateTrigger('2009-7-6', timezone)
-        start_date = timezone.localize(datetime(2009, 7, 6))
-        assert trigger.get_next_fire_time(start_date) == timezone.localize(datetime(2009, 7, 6))
-
-    def test_different_tz(self, timezone):
-        alter_tz = pytz.FixedOffset(-60)
-        fire_date = alter_tz.localize(datetime(2009, 7, 5, 22))
-        trigger = DateTrigger(fire_date, timezone)
-        start_date = timezone.localize(datetime(2009, 7, 6))
-        assert trigger.get_next_fire_time(start_date) == fire_date
-
-    def test_dst_change(self):
+    @pytest.mark.parametrize('run_date,alter_tz,previous,now,expected', [
+        (datetime(2009, 7, 6), None, None, datetime(2008, 5, 4), datetime(2009, 7, 6)),
+        (datetime(2009, 7, 6), None, None, datetime(2009, 7, 6), datetime(2009, 7, 6)),
+        (datetime(2009, 7, 6), None, None, datetime(2009, 9, 2), datetime(2009, 7, 6)),
+        ('2009-7-6', None, None, datetime(2009, 9, 2), datetime(2009, 7, 6)),
+        (datetime(2009, 7, 6), None, datetime(2009, 7, 6), datetime(2009, 9, 2), None),
+        (datetime(2009, 7, 5, 22), pytz.FixedOffset(-60), datetime(2009, 7, 6),  datetime(2009, 7, 6), None)
+    ], ids=['earlier', 'exact', 'later', 'as text', 'previously fired', 'alternate timezone'])
+    def test_get_next_fire_time(self, run_date, alter_tz, previous, now, expected, timezone):
+        trigger = DateTrigger(run_date, alter_tz or timezone)
+        previous = timezone.localize(previous) if previous else None
+        now = timezone.localize(now)
+        expected = timezone.localize(expected) if expected else None
+        assert trigger.get_next_fire_time(previous, now) == expected
+
+    @pytest.mark.parametrize('is_dst', [True, False], ids=['daylight saving', 'standard time'])
+    def test_dst_change(self, is_dst):
         """
         Making sure that DateTrigger works during the ambiguous "fall-back" DST period.
         Note that you should explicitly compare datetimes as strings to avoid the internal datetime comparison which
@@ -223,16 +207,19 @@ class TestDateTrigger(object):
         """
 
         eastern = pytz.timezone('US/Eastern')
-        datetime_edt = eastern.localize(datetime(2013, 11, 3, 1, 5), is_dst=True)
-        datetime_est = eastern.localize(datetime(2013, 11, 3, 1, 5), is_dst=False)
+        run_date = eastern.localize(datetime(2013, 11, 3, 1, 5), is_dst=is_dst)
 
-        fire_date = eastern.normalize(datetime_edt + timedelta(minutes=55))
+        fire_date = eastern.normalize(run_date + timedelta(minutes=55))
         trigger = DateTrigger(run_date=fire_date, timezone=eastern)
-        assert str(trigger.get_next_fire_time(datetime_edt)) == str(fire_date)
+        assert str(trigger.get_next_fire_time(None, fire_date)) == str(fire_date)
 
-        fire_date = eastern.normalize(datetime_est + timedelta(minutes=55))
-        trigger = DateTrigger(run_date=fire_date, timezone=eastern)
-        assert str(trigger.get_next_fire_time(datetime_est)) == str(fire_date)
+    def test_repr(self, timezone):
+        trigger = DateTrigger(datetime(2009, 7, 6), timezone)
+        assert repr(trigger) == "<DateTrigger (run_date='2009-07-06 00:00:00 CEST')>"
+
+    def test_str(self, timezone):
+        trigger = DateTrigger(datetime(2009, 7, 6), timezone)
+        assert str(trigger) == "date[2009-07-06 00:00:00 CEST]"
 
 
 class TestIntervalTrigger(object):
@@ -240,29 +227,26 @@ class TestIntervalTrigger(object):
     def trigger(self, timezone):
         return IntervalTrigger(seconds=1, start_date=datetime(2009, 8, 4, second=2), timezone=timezone)
 
-    def test_interval_invalid_interval(self, timezone):
+    def test_invalid_interval(self, timezone):
         pytest.raises(TypeError, IntervalTrigger, '1-6', timezone=timezone)
 
-    def test_interval_repr(self, trigger):
-        assert repr(trigger) == \
-            "<IntervalTrigger (interval=datetime.timedelta(0, 1), start_date='2009-08-04 00:00:02 CEST')>"
-        assert str(trigger) == "interval[0:00:01]"
+    def test_before(self, trigger, timezone):
+        """Tests that if "start_date" is later than "now", it will return start_date."""
 
-    def test_interval_before(self, trigger, timezone):
-        start_date = timezone.localize(datetime(2009, 8, 4))
-        correct_next_date = timezone.localize(datetime(2009, 8, 4, second=2))
-        assert trigger.get_next_fire_time(start_date) == correct_next_date
+        now = trigger.start_date - timedelta(seconds=2)
+        assert trigger.get_next_fire_time(None, now) == trigger.start_date
 
-    def test_interval_within(self, trigger, timezone):
-        start_date = timezone.localize(datetime(2009, 8, 4, second=2, microsecond=1000))
-        correct_next_date = timezone.localize(datetime(2009, 8, 4, second=3))
-        assert trigger.get_next_fire_time(start_date) == correct_next_date
+    def test_within(self, trigger, timezone):
+        """Tests that if "now" is between "start_date" and the next interval, it will return the next interval."""
+
+        now = trigger.start_date + timedelta(microseconds=1000)
+        assert trigger.get_next_fire_time(None, now) == trigger.start_date + trigger.interval
 
     def test_different_tz(self, trigger, timezone):
         alter_tz = pytz.FixedOffset(-60)
         start_date = alter_tz.localize(datetime(2009, 8, 3, 22, second=2, microsecond=1000))
         correct_next_date = timezone.localize(datetime(2009, 8, 4, 1, second=3))
-        assert trigger.get_next_fire_time(start_date) == correct_next_date
+        assert trigger.get_next_fire_time(None, start_date) == correct_next_date
 
     def test_end_date(self, timezone):
         """Tests that the interval trigger won't return any datetimes past the set end time."""
@@ -270,8 +254,8 @@ class TestIntervalTrigger(object):
         start_date = timezone.localize(datetime(2014, 5, 26))
         trigger = IntervalTrigger(minutes=5, start_date=start_date, end_date=datetime(2014, 5, 26, 0, 7),
                                   timezone=timezone)
-        assert trigger.get_next_fire_time(start_date + timedelta(minutes=2)) == start_date.replace(minute=5)
-        assert trigger.get_next_fire_time(start_date + timedelta(minutes=6)) is None
+        assert trigger.get_next_fire_time(None, start_date + timedelta(minutes=2)) == start_date.replace(minute=5)
+        assert trigger.get_next_fire_time(None, start_date + timedelta(minutes=6)) is None
 
     def test_dst_change(self):
         """
@@ -286,8 +270,15 @@ class TestIntervalTrigger(object):
 
         datetime_edt = eastern.localize(datetime(2013, 11, 3, 1, 5), is_dst=True)
         correct_next_date = eastern.normalize(datetime_edt + timedelta(minutes=55))
-        assert str(trigger.get_next_fire_time(datetime_edt)) == str(correct_next_date)
+        assert str(trigger.get_next_fire_time(None, datetime_edt)) == str(correct_next_date)
 
         datetime_est = eastern.localize(datetime(2013, 11, 3, 1, 5), is_dst=False)
         correct_next_date = eastern.normalize(datetime_est + timedelta(minutes=55))
-        assert str(trigger.get_next_fire_time(datetime_est)) == str(correct_next_date)
+        assert str(trigger.get_next_fire_time(None, datetime_est)) == str(correct_next_date)
+
+    def test_repr(self, trigger):
+        assert repr(trigger) == \
+            "<IntervalTrigger (interval=datetime.timedelta(0, 1), start_date='2009-08-04 00:00:02 CEST')>"
+
+    def test_str(self, trigger):
+        assert str(trigger) == "interval[0:00:01]"