From cbc7f39a124092ff12ff8fe585974e14280995b3 Mon Sep 17 00:00:00 2001
From: ConnorSkees <39542938+ConnorSkees@users.noreply.github.com>
Date: Sat, 12 Jan 2019 13:55:17 -0500
Subject: [PATCH 01/29] Add assertion error messages

---
 schedule/__init__.py | 15 ++++++++-------
 1 file changed, 8 insertions(+), 7 deletions(-)

diff --git a/schedule/__init__.py b/schedule/__init__.py
index ee7312d0..d41e5c7c 100644
--- a/schedule/__init__.py
+++ b/schedule/__init__.py
@@ -344,7 +344,8 @@ def at(self, time_str):
             (e.g. `every().hour.at(':30')` vs. `every().minute.at(':30')`).
         :return: The invoked job instance
         """
-        assert self.unit in ('days', 'hours', 'minutes') or self.start_day
+        assert self.unit in ('days', 'hours', 'minutes') or self.start_day, \
+            ValueError('Invalid unit.')
         if not isinstance(time_str, str):
             raise TypeError("at() should be passed a string.")
         if self.unit == 'days' or self.start_day:
@@ -368,16 +369,16 @@ def at(self, time_str):
             second = 0
         if self.unit == 'days' or self.start_day:
             hour = int(hour)
-            assert 0 <= hour <= 23
+            assert 0 <= hour <= 23, ValueError("Invalid number of hours.")
         elif self.unit == 'hours':
             hour = 0
         elif self.unit == 'minutes':
             hour = 0
             minute = 0
         minute = int(minute)
-        assert 0 <= minute <= 59
+        assert 0 <= minute <= 59, ValueError("Invalid number of minutes.")
         second = int(second)
-        assert 0 <= second <= 59
+        assert 0 <= second <= 59, ValueError("Invalid number of seconds.")
         self.at_time = datetime.time(hour, minute, second)
         return self
 
@@ -443,7 +444,7 @@ def _schedule_next_run(self):
         Compute the instant when this job should run next.
         """
         assert self.unit in ('seconds', 'minutes', 'hours', 'days',
-                             'weeks')
+                             'weeks'), ValueError("Invalid unit.")
 
         if self.latest is not None:
             assert self.latest >= self.interval
@@ -454,7 +455,7 @@ def _schedule_next_run(self):
         self.period = datetime.timedelta(**{self.unit: interval})
         self.next_run = datetime.datetime.now() + self.period
         if self.start_day is not None:
-            assert self.unit == 'weeks'
+            assert self.unit == 'weeks', ValueError('`unit` should be \'weeks\' ')
             weekdays = (
                 'monday',
                 'tuesday',
@@ -464,7 +465,7 @@ def _schedule_next_run(self):
                 'saturday',
                 'sunday'
             )
-            assert self.start_day in weekdays
+            assert self.start_day in weekdays, ValueError("Invalid start day.")
             weekday = weekdays.index(self.start_day)
             days_ahead = weekday - self.next_run.weekday()
             if days_ahead <= 0:  # Target day already happened this week

From 903f639bbdab0e11fff5e6b48c3e803d499b508f Mon Sep 17 00:00:00 2001
From: ConnorSkees <39542938+ConnorSkees@users.noreply.github.com>
Date: Sat, 12 Jan 2019 14:10:34 -0500
Subject: [PATCH 02/29] Fix line length to be 79 characters

---
 schedule/__init__.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/schedule/__init__.py b/schedule/__init__.py
index d41e5c7c..39ff27b6 100644
--- a/schedule/__init__.py
+++ b/schedule/__init__.py
@@ -455,7 +455,7 @@ def _schedule_next_run(self):
         self.period = datetime.timedelta(**{self.unit: interval})
         self.next_run = datetime.datetime.now() + self.period
         if self.start_day is not None:
-            assert self.unit == 'weeks', ValueError('`unit` should be \'weeks\' ')
+            assert self.unit == 'weeks', ValueError('unit should be \'weeks\'')
             weekdays = (
                 'monday',
                 'tuesday',

From a14c8151d26f53aa837dc8bf45f6911fbc56f540 Mon Sep 17 00:00:00 2001
From: ConnorSkees <39542938+ConnorSkees@users.noreply.github.com>
Date: Sat, 12 Jan 2019 14:33:28 -0500
Subject: [PATCH 03/29] Add more descriptive exceptions

---
 schedule/__init__.py | 13 ++++++++++---
 1 file changed, 10 insertions(+), 3 deletions(-)

diff --git a/schedule/__init__.py b/schedule/__init__.py
index 39ff27b6..f5a796da 100644
--- a/schedule/__init__.py
+++ b/schedule/__init__.py
@@ -47,13 +47,19 @@
 
 logger = logging.getLogger('schedule')
 
+class ScheduleError(Exception):
+    """Base schedule exception"""
+
+class ScheduleValueError(ScheduleError):
+    """Base schedule value error"""
+
+class IntervalError(ScheduleValueError):
+    """An improper interval was used"""
 
 class CancelJob(object):
     """
     Can be returned from a job to unschedule itself.
     """
-    pass
-
 
 class Scheduler(object):
     """
@@ -228,7 +234,8 @@ def format_time(t):
 
     @property
     def second(self):
-        assert self.interval == 1, 'Use seconds instead of second'
+        if self.interval == 1:
+            raise IntervalError('Use seconds instead of second')
         return self.seconds
 
     @property

From 23caed5d7ac2b66c7883d9b19192d40fce44df91 Mon Sep 17 00:00:00 2001
From: ConnorSkees <39542938+ConnorSkees@users.noreply.github.com>
Date: Sat, 12 Jan 2019 14:38:26 -0500
Subject: [PATCH 04/29] Missed == to !=

---
 schedule/__init__.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/schedule/__init__.py b/schedule/__init__.py
index f5a796da..cabda320 100644
--- a/schedule/__init__.py
+++ b/schedule/__init__.py
@@ -234,7 +234,7 @@ def format_time(t):
 
     @property
     def second(self):
-        if self.interval == 1:
+        if self.interval != 1:
             raise IntervalError('Use seconds instead of second')
         return self.seconds
 

From 21b99d86d5a4b6bec301f5e34d963d324ad87deb Mon Sep 17 00:00:00 2001
From: ConnorSkees <39542938+ConnorSkees@users.noreply.github.com>
Date: Sat, 12 Jan 2019 14:49:58 -0500
Subject: [PATCH 05/29] Change interval assertions to IntervalError

---
 schedule/__init__.py | 33 ++++++++++++++++++++++-----------
 1 file changed, 22 insertions(+), 11 deletions(-)

diff --git a/schedule/__init__.py b/schedule/__init__.py
index cabda320..d24321c7 100644
--- a/schedule/__init__.py
+++ b/schedule/__init__.py
@@ -245,7 +245,8 @@ def seconds(self):
 
     @property
     def minute(self):
-        assert self.interval == 1, 'Use minutes instead of minute'
+        if self.interval != 1:
+            raise IntervalError('Use minutes instead of minute')
         return self.minutes
 
     @property
@@ -255,7 +256,8 @@ def minutes(self):
 
     @property
     def hour(self):
-        assert self.interval == 1, 'Use hours instead of hour'
+        if self.interval != 1:
+            raise IntervalError('Use hours instead of hour')
         return self.hours
 
     @property
@@ -265,7 +267,8 @@ def hours(self):
 
     @property
     def day(self):
-        assert self.interval == 1, 'Use days instead of day'
+        if self.interval != 1:
+            raise IntervalError('Use days instead of day')
         return self.days
 
     @property
@@ -275,7 +278,8 @@ def days(self):
 
     @property
     def week(self):
-        assert self.interval == 1, 'Use weeks instead of week'
+        if self.interval != 1:
+            raise IntervalError('Use weeks instead of week')
         return self.weeks
 
     @property
@@ -285,43 +289,50 @@ def weeks(self):
 
     @property
     def monday(self):
-        assert self.interval == 1, 'Use mondays instead of monday'
+        if self.interval != 1:
+            raise IntervalError('Use mondays instead of monday')
         self.start_day = 'monday'
         return self.weeks
 
     @property
     def tuesday(self):
-        assert self.interval == 1, 'Use tuesdays instead of tuesday'
+        if self.interval != 1:
+            raise IntervalError('Use tuesdays instead of tuesday')
         self.start_day = 'tuesday'
         return self.weeks
 
     @property
     def wednesday(self):
-        assert self.interval == 1, 'Use wednesdays instead of wednesday'
+        if self.interval != 1:
+            raise IntervalError('Use wednesdays instead of wednesday')
         self.start_day = 'wednesday'
         return self.weeks
 
     @property
     def thursday(self):
-        assert self.interval == 1, 'Use thursdays instead of thursday'
+        if self.interval != 1:
+            raise IntervalError('Use thursdays instead of thursday')
         self.start_day = 'thursday'
         return self.weeks
 
     @property
     def friday(self):
-        assert self.interval == 1, 'Use fridays instead of friday'
+        if self.interval != 1:
+            raise IntervalError('Use fridays instead of friday')
         self.start_day = 'friday'
         return self.weeks
 
     @property
     def saturday(self):
-        assert self.interval == 1, 'Use saturdays instead of saturday'
+        if self.interval != 1:
+            raise IntervalError('Use saturdays instead of saturday')
         self.start_day = 'saturday'
         return self.weeks
 
     @property
     def sunday(self):
-        assert self.interval == 1, 'Use sundays instead of sunday'
+        if self.interval == 1:
+            raise IntervalError('Use sundays instead of sunday')
         self.start_day = 'sunday'
         return self.weeks
 

From 4f157462ff08cc4be91ba572f433faae608b07e2 Mon Sep 17 00:00:00 2001
From: ConnorSkees <39542938+ConnorSkees@users.noreply.github.com>
Date: Sat, 12 Jan 2019 14:50:21 -0500
Subject: [PATCH 06/29] 2 lines between classes

---
 schedule/__init__.py | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/schedule/__init__.py b/schedule/__init__.py
index d24321c7..e4a21cec 100644
--- a/schedule/__init__.py
+++ b/schedule/__init__.py
@@ -50,17 +50,21 @@
 class ScheduleError(Exception):
     """Base schedule exception"""
 
+
 class ScheduleValueError(ScheduleError):
     """Base schedule value error"""
 
+
 class IntervalError(ScheduleValueError):
     """An improper interval was used"""
 
+
 class CancelJob(object):
     """
     Can be returned from a job to unschedule itself.
     """
 
+
 class Scheduler(object):
     """
     Objects instantiated by the :class:`Scheduler <Scheduler>` are

From b530b30692fb78a0a51b99b0b4859c20f94c01c9 Mon Sep 17 00:00:00 2001
From: ConnorSkees <39542938+ConnorSkees@users.noreply.github.com>
Date: Sat, 12 Jan 2019 14:58:11 -0500
Subject: [PATCH 07/29] Change ValueError to ScheduleValueError

---
 schedule/__init__.py | 16 ++++++++--------
 1 file changed, 8 insertions(+), 8 deletions(-)

diff --git a/schedule/__init__.py b/schedule/__init__.py
index e4a21cec..b7e424ce 100644
--- a/schedule/__init__.py
+++ b/schedule/__init__.py
@@ -366,19 +366,19 @@ def at(self, time_str):
             (e.g. `every().hour.at(':30')` vs. `every().minute.at(':30')`).
         :return: The invoked job instance
         """
-        assert self.unit in ('days', 'hours', 'minutes') or self.start_day, \
-            ValueError('Invalid unit.')
+        if self.unit not in ('days', 'hours', 'minutes') and not self.start_day:
+            raise ScheduleValueError('Invalid unit.')
         if not isinstance(time_str, str):
             raise TypeError("at() should be passed a string.")
         if self.unit == 'days' or self.start_day:
-            assert re.match(r'^([0-2]\d:)?[0-5]\d:[0-5]\d$', time_str), \
-                ValueError("Invalid time format.")
+            if not re.match(r'^([0-2]\d:)?[0-5]\d:[0-5]\d$', time_str):
+                raise ScheduleValueError("Invalid time format.")
         if self.unit == 'hours':
-            assert re.match(r'^([0-5]\d)?:[0-5]\d$', time_str), \
-                ValueError("Invalid time format for an hourly job.")
+            if not re.match(r'^([0-5]\d)?:[0-5]\d$', time_str):
+                raise ScheduleValueError("Invalid time format for an hourly job.")
         if self.unit == 'minutes':
-            assert re.match(r'^:[0-5]\d$', time_str), \
-                ValueError("Invalid time format for a minutely job.")
+            if not re.match(r'^:[0-5]\d$', time_str):
+                raise ScheduleValueError("Invalid time format for a minutely job.")
         time_values = time_str.split(':')
         if len(time_values) == 3:
             hour, minute, second = time_values

From 2e784e4c715a3ededd8a37a6d82dc5921460249a Mon Sep 17 00:00:00 2001
From: ConnorSkees <39542938+ConnorSkees@users.noreply.github.com>
Date: Sat, 12 Jan 2019 15:04:51 -0500
Subject: [PATCH 08/29] Change time assertions to ScheduleValueError

---
 schedule/__init__.py | 9 ++++++---
 1 file changed, 6 insertions(+), 3 deletions(-)

diff --git a/schedule/__init__.py b/schedule/__init__.py
index b7e424ce..1a8d206d 100644
--- a/schedule/__init__.py
+++ b/schedule/__init__.py
@@ -391,16 +391,19 @@ def at(self, time_str):
             second = 0
         if self.unit == 'days' or self.start_day:
             hour = int(hour)
-            assert 0 <= hour <= 23, ValueError("Invalid number of hours.")
+            if 0 > hour or hour > 24:
+                raise ScheduleValueError("Invalid number of hours.")
         elif self.unit == 'hours':
             hour = 0
         elif self.unit == 'minutes':
             hour = 0
             minute = 0
         minute = int(minute)
-        assert 0 <= minute <= 59, ValueError("Invalid number of minutes.")
+        if 0 > minute or minute > 60:
+            raise ScheduleValueError("Invalid number of minutes.")
         second = int(second)
-        assert 0 <= second <= 59, ValueError("Invalid number of seconds.")
+        if 0 > second or second > 60:
+            raise ScheduleValueError("Invalid number of seconds.")
         self.at_time = datetime.time(hour, minute, second)
         return self
 

From a024be693228497aa8fa71312cddbd16ebd4641f Mon Sep 17 00:00:00 2001
From: ConnorSkees <39542938+ConnorSkees@users.noreply.github.com>
Date: Sat, 12 Jan 2019 15:13:45 -0500
Subject: [PATCH 09/29] ValueError to ScheduleValueError

---
 schedule/__init__.py | 16 +++++++++-------
 1 file changed, 9 insertions(+), 7 deletions(-)

diff --git a/schedule/__init__.py b/schedule/__init__.py
index 1a8d206d..7ef4bd37 100644
--- a/schedule/__init__.py
+++ b/schedule/__init__.py
@@ -335,7 +335,7 @@ def saturday(self):
 
     @property
     def sunday(self):
-        if self.interval == 1:
+        if self.interval != 1:
             raise IntervalError('Use sundays instead of sunday')
         self.start_day = 'sunday'
         return self.weeks
@@ -468,8 +468,8 @@ def _schedule_next_run(self):
         """
         Compute the instant when this job should run next.
         """
-        assert self.unit in ('seconds', 'minutes', 'hours', 'days',
-                             'weeks'), ValueError("Invalid unit.")
+        if self.unit not in ('seconds', 'minutes', 'hours', 'days', 'weeks'):
+            raise ScheduleValueError("Invalid unit.")
 
         if self.latest is not None:
             assert self.latest >= self.interval
@@ -480,7 +480,8 @@ def _schedule_next_run(self):
         self.period = datetime.timedelta(**{self.unit: interval})
         self.next_run = datetime.datetime.now() + self.period
         if self.start_day is not None:
-            assert self.unit == 'weeks', ValueError('unit should be \'weeks\'')
+            if self.unit != 'weeks':
+                raise ScheduleValueError("`unit` should be 'weeks'")
             weekdays = (
                 'monday',
                 'tuesday',
@@ -490,15 +491,16 @@ def _schedule_next_run(self):
                 'saturday',
                 'sunday'
             )
-            assert self.start_day in weekdays, ValueError("Invalid start day.")
+            if self.start_day not in weekdays:
+                raise ScheduleValueError("Invalid start day.")
             weekday = weekdays.index(self.start_day)
             days_ahead = weekday - self.next_run.weekday()
             if days_ahead <= 0:  # Target day already happened this week
                 days_ahead += 7
             self.next_run += datetime.timedelta(days_ahead) - self.period
         if self.at_time is not None:
-            assert self.unit in ('days', 'hours', 'minutes') \
-                   or self.start_day is not None
+            if self.unit not in ('days', 'hours', 'minutes') and self.start_day is None:
+                raise ScheduleValueError("Invalid unit without specifying start day.")
             kwargs = {
                 'second': self.at_time.second,
                 'microsecond': 0

From 8282bb4535f2066ec37dab8eaf64e9f0e362cd3e Mon Sep 17 00:00:00 2001
From: ConnorSkees <39542938+ConnorSkees@users.noreply.github.com>
Date: Sat, 12 Jan 2019 15:14:20 -0500
Subject: [PATCH 10/29] Update unit tests to reflect new exceptions

---
 test_schedule.py | 34 +++++++++++++++++-----------------
 1 file changed, 17 insertions(+), 17 deletions(-)

diff --git a/test_schedule.py b/test_schedule.py
index 856b2c2e..6567bb0b 100644
--- a/test_schedule.py
+++ b/test_schedule.py
@@ -94,12 +94,12 @@ def test_at_time(self):
         assert every().day.at('10:30').do(mock_job).next_run.minute == 30
         assert every().day.at('10:30:50').do(mock_job).next_run.second == 50
 
-        self.assertRaises(AssertionError, every().day.at, '2:30:000001')
-        self.assertRaises(AssertionError, every().day.at, '::2')
-        self.assertRaises(AssertionError, every().day.at, '.2')
-        self.assertRaises(AssertionError, every().day.at, '2')
-        self.assertRaises(AssertionError, every().day.at, ':2')
-        self.assertRaises(AssertionError, every().day.at, ' 2:30:00')
+        self.assertRaises(schedule.ScheduleValueError, every().day.at, '2:30:000001')
+        self.assertRaises(schedule.ScheduleValueError, every().day.at, '::2')
+        self.assertRaises(schedule.ScheduleValueError, every().day.at, '.2')
+        self.assertRaises(schedule.ScheduleValueError, every().day.at, '2')
+        self.assertRaises(schedule.ScheduleValueError, every().day.at, ':2')
+        self.assertRaises(schedule.ScheduleValueError, every().day.at, ' 2:30:00')
         self.assertRaises(TypeError, every().day.at, 2)
 
     def test_at_time_hour(self):
@@ -115,11 +115,11 @@ def test_at_time_hour(self):
             assert every().hour.at(':00').do(mock_job).next_run.minute == 0
             assert every().hour.at(':00').do(mock_job).next_run.second == 0
 
-            self.assertRaises(AssertionError, every().hour.at, '2:30:00')
-            self.assertRaises(AssertionError, every().hour.at, '::2')
-            self.assertRaises(AssertionError, every().hour.at, '.2')
-            self.assertRaises(AssertionError, every().hour.at, '2')
-            self.assertRaises(AssertionError, every().hour.at, ' 2:30')
+            self.assertRaises(schedule.ScheduleValueError, every().hour.at, '2:30:00')
+            self.assertRaises(schedule.ScheduleValueError, every().hour.at, '::2')
+            self.assertRaises(schedule.ScheduleValueError, every().hour.at, '.2')
+            self.assertRaises(schedule.ScheduleValueError, every().hour.at, '2')
+            self.assertRaises(schedule.ScheduleValueError, every().hour.at, ' 2:30')
             self.assertRaises(TypeError, every().hour.at, 2)
 
     def test_at_time_minute(self):
@@ -132,12 +132,12 @@ def test_at_time_minute(self):
             assert every().minute.at(':10').do(mock_job).next_run.minute == 21
             assert every().minute.at(':10').do(mock_job).next_run.second == 10
 
-            self.assertRaises(AssertionError, every().minute.at, '::2')
-            self.assertRaises(AssertionError, every().minute.at, '.2')
-            self.assertRaises(AssertionError, every().minute.at, '2')
-            self.assertRaises(AssertionError, every().minute.at, '2:30:00')
-            self.assertRaises(AssertionError, every().minute.at, '2:30')
-            self.assertRaises(AssertionError, every().minute.at, ' :30')
+            self.assertRaises(schedule.ScheduleValueError, every().minute.at, '::2')
+            self.assertRaises(schedule.ScheduleValueError, every().minute.at, '.2')
+            self.assertRaises(schedule.ScheduleValueError, every().minute.at, '2')
+            self.assertRaises(schedule.ScheduleValueError, every().minute.at, '2:30:00')
+            self.assertRaises(schedule.ScheduleValueError, every().minute.at, '2:30')
+            self.assertRaises(schedule.ScheduleValueError, every().minute.at, ' :30')
             self.assertRaises(TypeError, every().minute.at, 2)
 
     def test_next_run_time(self):

From d4304988c78b7694ec572920427be719d41612ed Mon Sep 17 00:00:00 2001
From: ConnorSkees <39542938+ConnorSkees@users.noreply.github.com>
Date: Sat, 12 Jan 2019 15:18:12 -0500
Subject: [PATCH 11/29] Unit tests under 79 characters

---
 test_schedule.py | 36 ++++++++++++++++++------------------
 1 file changed, 18 insertions(+), 18 deletions(-)

diff --git a/test_schedule.py b/test_schedule.py
index 6567bb0b..1dc76a4c 100644
--- a/test_schedule.py
+++ b/test_schedule.py
@@ -9,7 +9,7 @@
 # pylint: disable-msg=R0201,C0111,E0102,R0904,R0901
 
 import schedule
-from schedule import every
+from schedule import every, ScheduleValueError
 
 
 def make_mock_job(name=None):
@@ -94,12 +94,12 @@ def test_at_time(self):
         assert every().day.at('10:30').do(mock_job).next_run.minute == 30
         assert every().day.at('10:30:50').do(mock_job).next_run.second == 50
 
-        self.assertRaises(schedule.ScheduleValueError, every().day.at, '2:30:000001')
-        self.assertRaises(schedule.ScheduleValueError, every().day.at, '::2')
-        self.assertRaises(schedule.ScheduleValueError, every().day.at, '.2')
-        self.assertRaises(schedule.ScheduleValueError, every().day.at, '2')
-        self.assertRaises(schedule.ScheduleValueError, every().day.at, ':2')
-        self.assertRaises(schedule.ScheduleValueError, every().day.at, ' 2:30:00')
+        self.assertRaises(ScheduleValueError, every().day.at, '2:30:000001')
+        self.assertRaises(ScheduleValueError, every().day.at, '::2')
+        self.assertRaises(ScheduleValueError, every().day.at, '.2')
+        self.assertRaises(ScheduleValueError, every().day.at, '2')
+        self.assertRaises(ScheduleValueError, every().day.at, ':2')
+        self.assertRaises(ScheduleValueError, every().day.at, ' 2:30:00')
         self.assertRaises(TypeError, every().day.at, 2)
 
     def test_at_time_hour(self):
@@ -115,11 +115,11 @@ def test_at_time_hour(self):
             assert every().hour.at(':00').do(mock_job).next_run.minute == 0
             assert every().hour.at(':00').do(mock_job).next_run.second == 0
 
-            self.assertRaises(schedule.ScheduleValueError, every().hour.at, '2:30:00')
-            self.assertRaises(schedule.ScheduleValueError, every().hour.at, '::2')
-            self.assertRaises(schedule.ScheduleValueError, every().hour.at, '.2')
-            self.assertRaises(schedule.ScheduleValueError, every().hour.at, '2')
-            self.assertRaises(schedule.ScheduleValueError, every().hour.at, ' 2:30')
+            self.assertRaises(ScheduleValueError, every().hour.at, '2:30:00')
+            self.assertRaises(ScheduleValueError, every().hour.at, '::2')
+            self.assertRaises(ScheduleValueError, every().hour.at, '.2')
+            self.assertRaises(ScheduleValueError, every().hour.at, '2')
+            self.assertRaises(ScheduleValueError, every().hour.at, ' 2:30')
             self.assertRaises(TypeError, every().hour.at, 2)
 
     def test_at_time_minute(self):
@@ -132,12 +132,12 @@ def test_at_time_minute(self):
             assert every().minute.at(':10').do(mock_job).next_run.minute == 21
             assert every().minute.at(':10').do(mock_job).next_run.second == 10
 
-            self.assertRaises(schedule.ScheduleValueError, every().minute.at, '::2')
-            self.assertRaises(schedule.ScheduleValueError, every().minute.at, '.2')
-            self.assertRaises(schedule.ScheduleValueError, every().minute.at, '2')
-            self.assertRaises(schedule.ScheduleValueError, every().minute.at, '2:30:00')
-            self.assertRaises(schedule.ScheduleValueError, every().minute.at, '2:30')
-            self.assertRaises(schedule.ScheduleValueError, every().minute.at, ' :30')
+            self.assertRaises(ScheduleValueError, every().minute.at, '::2')
+            self.assertRaises(ScheduleValueError, every().minute.at, '.2')
+            self.assertRaises(ScheduleValueError, every().minute.at, '2')
+            self.assertRaises(ScheduleValueError, every().minute.at, '2:30:00')
+            self.assertRaises(ScheduleValueError, every().minute.at, '2:30')
+            self.assertRaises(ScheduleValueError, every().minute.at, ' :30')
             self.assertRaises(TypeError, every().minute.at, 2)
 
     def test_next_run_time(self):

From a51df8898ca1773936bacc57a74653597e47964b Mon Sep 17 00:00:00 2001
From: ConnorSkees <39542938+ConnorSkees@users.noreply.github.com>
Date: Sat, 12 Jan 2019 15:22:21 -0500
Subject: [PATCH 12/29] Line lengths under 80 characters

---
 schedule/__init__.py | 15 ++++++++++-----
 1 file changed, 10 insertions(+), 5 deletions(-)

diff --git a/schedule/__init__.py b/schedule/__init__.py
index 7ef4bd37..01b6b94a 100644
--- a/schedule/__init__.py
+++ b/schedule/__init__.py
@@ -366,7 +366,8 @@ def at(self, time_str):
             (e.g. `every().hour.at(':30')` vs. `every().minute.at(':30')`).
         :return: The invoked job instance
         """
-        if self.unit not in ('days', 'hours', 'minutes') and not self.start_day:
+        if (self.unit not in ('days', 'hours', 'minutes')
+                and not self.start_day):
             raise ScheduleValueError('Invalid unit.')
         if not isinstance(time_str, str):
             raise TypeError("at() should be passed a string.")
@@ -375,10 +376,12 @@ def at(self, time_str):
                 raise ScheduleValueError("Invalid time format.")
         if self.unit == 'hours':
             if not re.match(r'^([0-5]\d)?:[0-5]\d$', time_str):
-                raise ScheduleValueError("Invalid time format for an hourly job.")
+                raise ScheduleValueError(("Invalid time format for"
+                                          " an hourly job."))
         if self.unit == 'minutes':
             if not re.match(r'^:[0-5]\d$', time_str):
-                raise ScheduleValueError("Invalid time format for a minutely job.")
+                raise ScheduleValueError(("Invalid time format for"
+                                          " a minutely job."))
         time_values = time_str.split(':')
         if len(time_values) == 3:
             hour, minute, second = time_values
@@ -499,8 +502,10 @@ def _schedule_next_run(self):
                 days_ahead += 7
             self.next_run += datetime.timedelta(days_ahead) - self.period
         if self.at_time is not None:
-            if self.unit not in ('days', 'hours', 'minutes') and self.start_day is None:
-                raise ScheduleValueError("Invalid unit without specifying start day.")
+            if (self.unit not in ('days', 'hours', 'minutes')
+                    and self.start_day is None):
+                raise ScheduleValueError(("Invalid unit without"
+                                          " specifying start day."))
             kwargs = {
                 'second': self.at_time.second,
                 'microsecond': 0

From dc03aceb004a19c20b2b9e9794f420f4bab29c94 Mon Sep 17 00:00:00 2001
From: ConnorSkees <39542938+ConnorSkees@users.noreply.github.com>
Date: Sat, 12 Jan 2019 15:36:37 -0500
Subject: [PATCH 13/29] Make linter happy :)

2 lines around each class
---
 schedule/__init__.py | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/schedule/__init__.py b/schedule/__init__.py
index 01b6b94a..9e8d157e 100644
--- a/schedule/__init__.py
+++ b/schedule/__init__.py
@@ -47,6 +47,7 @@
 
 logger = logging.getLogger('schedule')
 
+
 class ScheduleError(Exception):
     """Base schedule exception"""
 
@@ -475,7 +476,8 @@ def _schedule_next_run(self):
             raise ScheduleValueError("Invalid unit.")
 
         if self.latest is not None:
-            assert self.latest >= self.interval
+            if not (self.latest >= self.interval):
+                raise ScheduleError
             interval = random.randint(self.interval, self.latest)
         else:
             interval = self.interval

From 0784d77fb3618aa629a678b0bac5f4e1b73ea579 Mon Sep 17 00:00:00 2001
From: ConnorSkees <39542938+ConnorSkees@users.noreply.github.com>
Date: Sun, 13 Jan 2019 09:24:52 -0500
Subject: [PATCH 14/29] Test interval errors

---
 test_schedule.py | 16 +++++++++++++++-
 1 file changed, 15 insertions(+), 1 deletion(-)

diff --git a/test_schedule.py b/test_schedule.py
index 1dc76a4c..2aa8e646 100644
--- a/test_schedule.py
+++ b/test_schedule.py
@@ -9,7 +9,7 @@
 # pylint: disable-msg=R0201,C0111,E0102,R0904,R0901
 
 import schedule
-from schedule import every, ScheduleValueError
+from schedule import every, ScheduleValueError, IntervalError
 
 
 def make_mock_job(name=None):
@@ -102,6 +102,20 @@ def test_at_time(self):
         self.assertRaises(ScheduleValueError, every().day.at, ' 2:30:00')
         self.assertRaises(TypeError, every().day.at, 2)
 
+        with self.assertRaises(IntervalError):
+            every(interval=2).second
+            every(interval=2).minute
+            every(interval=2).hour
+            every(interval=2).day
+            every(interval=2).week
+            every(interval=2).monday
+            every(interval=2).tuesday
+            every(interval=2).wednesday
+            every(interval=2).thursday
+            every(interval=2).friday
+            every(interval=2).saturday
+            every(interval=2).sunday
+
     def test_at_time_hour(self):
         with mock_datetime(2010, 1, 6, 12, 20):
             mock_job = make_mock_job()

From fcd4fcaccd5a963e6aea19bff00acc9a02cfb0cb Mon Sep 17 00:00:00 2001
From: ConnorSkees <39542938+ConnorSkees@users.noreply.github.com>
Date: Sun, 13 Jan 2019 09:28:34 -0500
Subject: [PATCH 15/29] Change exception assertions to context managers

---
 test_schedule.py | 42 +++++++++++++++++++++++++-----------------
 1 file changed, 25 insertions(+), 17 deletions(-)

diff --git a/test_schedule.py b/test_schedule.py
index 2aa8e646..6bde3dfb 100644
--- a/test_schedule.py
+++ b/test_schedule.py
@@ -94,12 +94,16 @@ def test_at_time(self):
         assert every().day.at('10:30').do(mock_job).next_run.minute == 30
         assert every().day.at('10:30:50').do(mock_job).next_run.second == 50
 
-        self.assertRaises(ScheduleValueError, every().day.at, '2:30:000001')
-        self.assertRaises(ScheduleValueError, every().day.at, '::2')
-        self.assertRaises(ScheduleValueError, every().day.at, '.2')
-        self.assertRaises(ScheduleValueError, every().day.at, '2')
-        self.assertRaises(ScheduleValueError, every().day.at, ':2')
-        self.assertRaises(ScheduleValueError, every().day.at, ' 2:30:00')
+        with self.assertRaises(ScheduleValueError):
+            every().day.at('2:30:000001')
+            every().day.at('::2')
+            every().day.at('.2')
+            every().day.at('2')
+            every().day.at(':2')
+            every().day.at(' 2:30:00')
+
+            every().do(lambda: 0)
+
         self.assertRaises(TypeError, every().day.at, 2)
 
         with self.assertRaises(IntervalError):
@@ -129,11 +133,13 @@ def test_at_time_hour(self):
             assert every().hour.at(':00').do(mock_job).next_run.minute == 0
             assert every().hour.at(':00').do(mock_job).next_run.second == 0
 
-            self.assertRaises(ScheduleValueError, every().hour.at, '2:30:00')
-            self.assertRaises(ScheduleValueError, every().hour.at, '::2')
-            self.assertRaises(ScheduleValueError, every().hour.at, '.2')
-            self.assertRaises(ScheduleValueError, every().hour.at, '2')
-            self.assertRaises(ScheduleValueError, every().hour.at, ' 2:30')
+            with self.assertRaises(ScheduleValueError):
+                every().hour.at('2:30:00')
+                every().hour.at('::2')
+                every().hour.at('.2')
+                every().hour.at('2')
+                every().hour.at(' 2:30')
+
             self.assertRaises(TypeError, every().hour.at, 2)
 
     def test_at_time_minute(self):
@@ -146,12 +152,14 @@ def test_at_time_minute(self):
             assert every().minute.at(':10').do(mock_job).next_run.minute == 21
             assert every().minute.at(':10').do(mock_job).next_run.second == 10
 
-            self.assertRaises(ScheduleValueError, every().minute.at, '::2')
-            self.assertRaises(ScheduleValueError, every().minute.at, '.2')
-            self.assertRaises(ScheduleValueError, every().minute.at, '2')
-            self.assertRaises(ScheduleValueError, every().minute.at, '2:30:00')
-            self.assertRaises(ScheduleValueError, every().minute.at, '2:30')
-            self.assertRaises(ScheduleValueError, every().minute.at, ' :30')
+            with self.assertRaises(ScheduleValueError):
+                every().minute.at('::2')
+                every().minute.at('.2')
+                every().minute.at('2')
+                every().minute.at('2:30:00')
+                every().minute.at('2:30')
+                every().minute.at(' :30')
+                
             self.assertRaises(TypeError, every().minute.at, 2)
 
     def test_next_run_time(self):

From c5f73a193d4376b25d139b3664ca1f6ca045041b Mon Sep 17 00:00:00 2001
From: ConnorSkees <39542938+ConnorSkees@users.noreply.github.com>
Date: Sun, 13 Jan 2019 09:46:31 -0500
Subject: [PATCH 16/29] Improve test coverage

Invalid units
---
 test_schedule.py | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

diff --git a/test_schedule.py b/test_schedule.py
index 6bde3dfb..d5e3733d 100644
--- a/test_schedule.py
+++ b/test_schedule.py
@@ -101,6 +101,8 @@ def test_at_time(self):
             every().day.at('2')
             every().day.at(':2')
             every().day.at(' 2:30:00')
+            every().day.at("25:00:00")
+            every().seconds.at("00:00:00")
 
             every().do(lambda: 0)
 
@@ -139,6 +141,9 @@ def test_at_time_hour(self):
                 every().hour.at('.2')
                 every().hour.at('2')
                 every().hour.at(' 2:30')
+                every().hour.at("61:00")
+                every().hour.at("00:61")
+                every().hour.at("01:61")
 
             self.assertRaises(TypeError, every().hour.at, 2)
 
@@ -159,7 +164,7 @@ def test_at_time_minute(self):
                 every().minute.at('2:30:00')
                 every().minute.at('2:30')
                 every().minute.at(' :30')
-                
+
             self.assertRaises(TypeError, every().minute.at, 2)
 
     def test_next_run_time(self):

From d5c7f25c37ef9de8edab41dfaf3a6caea301d5cd Mon Sep 17 00:00:00 2001
From: ConnorSkees <39542938+ConnorSkees@users.noreply.github.com>
Date: Sun, 13 Jan 2019 10:31:48 -0500
Subject: [PATCH 17/29] Test interval errors more comprehensively

---
 test_schedule.py | 15 +++++++++++++++
 1 file changed, 15 insertions(+)

diff --git a/test_schedule.py b/test_schedule.py
index d5e3733d..0d247b42 100644
--- a/test_schedule.py
+++ b/test_schedule.py
@@ -58,6 +58,21 @@ def test_time_units(self):
         assert every().days.unit == 'days'
         assert every().weeks.unit == 'weeks'
 
+        job_instance = schedule.Job(interval=2)
+        with self.assertRaises(IntervalError):
+            job_instance.second
+            job_instance.minute
+            job_instance.hour
+            job_instance.day
+            job_instance.week
+            job_instance.monday
+            job_instance.tuesday
+            job_instance.wednesday
+            job_instance.thursday
+            job_instance.friday
+            job_instance.saturday
+            job_instance.sunday
+
     def test_singular_time_units_match_plural_units(self):
         assert every().second.unit == every().seconds.unit
         assert every().minute.unit == every().minutes.unit

From 9107fce1b3c11e0c06b6ab445bf9926be59738ee Mon Sep 17 00:00:00 2001
From: ConnorSkees <39542938+ConnorSkees@users.noreply.github.com>
Date: Sun, 13 Jan 2019 10:45:00 -0500
Subject: [PATCH 18/29] More descriptive assertions

---
 test_schedule.py | 178 +++++++++++++++++++++++------------------------
 1 file changed, 89 insertions(+), 89 deletions(-)

diff --git a/test_schedule.py b/test_schedule.py
index 0d247b42..a3ed8f18 100644
--- a/test_schedule.py
+++ b/test_schedule.py
@@ -52,11 +52,11 @@ def setUp(self):
         schedule.clear()
 
     def test_time_units(self):
-        assert every().seconds.unit == 'seconds'
-        assert every().minutes.unit == 'minutes'
-        assert every().hours.unit == 'hours'
-        assert every().days.unit == 'days'
-        assert every().weeks.unit == 'weeks'
+        self.assertEqual(every().seconds.unit, 'seconds')
+        self.assertEqual(every().minutes.unit, 'minutes')
+        self.assertEqual(every().hours.unit, 'hours')
+        self.assertEqual(every().days.unit, 'days')
+        self.assertEqual(every().weeks.unit, 'weeks')
 
         job_instance = schedule.Job(interval=2)
         with self.assertRaises(IntervalError):
@@ -74,11 +74,11 @@ def test_time_units(self):
             job_instance.sunday
 
     def test_singular_time_units_match_plural_units(self):
-        assert every().second.unit == every().seconds.unit
-        assert every().minute.unit == every().minutes.unit
-        assert every().hour.unit == every().hours.unit
-        assert every().day.unit == every().days.unit
-        assert every().week.unit == every().weeks.unit
+        self.assertEqual(every().second.unit, every().seconds.unit)
+        self.assertEqual(every().minute.unit, every().minutes.unit)
+        self.assertEqual(every().hour.unit, every().hours.unit)
+        self.assertEqual(every().day.unit, every().days.unit)
+        self.assertEqual(every().week.unit, every().weeks.unit)
 
     def test_time_range(self):
         with mock_datetime(2014, 6, 28, 12, 0):
@@ -90,10 +90,9 @@ def test_time_range(self):
                 every(5).to(30).minutes.do(mock_job).next_run.minute
                 for i in range(100)
             ])
-
-            assert len(minutes) > 1
-            assert min(minutes) >= 5
-            assert max(minutes) <= 30
+            self.assertGreater(len(minutes), 1)
+            self.assertGreaterEqual(min(minutes), 5)
+            self.assertLessEqual(max(minutes), 30)
 
     def test_time_range_repr(self):
         mock_job = make_mock_job()
@@ -105,9 +104,9 @@ def test_time_range_repr(self):
 
     def test_at_time(self):
         mock_job = make_mock_job()
-        assert every().day.at('10:30').do(mock_job).next_run.hour == 10
-        assert every().day.at('10:30').do(mock_job).next_run.minute == 30
-        assert every().day.at('10:30:50').do(mock_job).next_run.second == 50
+        self.assertEqual(every().day.at('10:30').do(mock_job).next_run.hour, 10)
+        self.assertEqual(every().day.at('10:30').do(mock_job).next_run.minute, 30)
+        self.assertEqual(every().day.at('10:30:50').do(mock_job).next_run.second, 50)
 
         with self.assertRaises(ScheduleValueError):
             every().day.at('2:30:000001')
@@ -140,15 +139,15 @@ def test_at_time(self):
     def test_at_time_hour(self):
         with mock_datetime(2010, 1, 6, 12, 20):
             mock_job = make_mock_job()
-            assert every().hour.at(':30').do(mock_job).next_run.hour == 12
-            assert every().hour.at(':30').do(mock_job).next_run.minute == 30
-            assert every().hour.at(':30').do(mock_job).next_run.second == 0
-            assert every().hour.at(':10').do(mock_job).next_run.hour == 13
-            assert every().hour.at(':10').do(mock_job).next_run.minute == 10
-            assert every().hour.at(':10').do(mock_job).next_run.second == 0
-            assert every().hour.at(':00').do(mock_job).next_run.hour == 13
-            assert every().hour.at(':00').do(mock_job).next_run.minute == 0
-            assert every().hour.at(':00').do(mock_job).next_run.second == 0
+            self.assertEqual(every().hour.at(':30').do(mock_job).next_run.hour, 12)
+            self.assertEqual(every().hour.at(':30').do(mock_job).next_run.minute, 30)
+            self.assertEqual(every().hour.at(':30').do(mock_job).next_run.second, 0)
+            self.assertEqual(every().hour.at(':10').do(mock_job).next_run.hour, 13)
+            self.assertEqual(every().hour.at(':10').do(mock_job).next_run.minute, 10)
+            self.assertEqual(every().hour.at(':10').do(mock_job).next_run.second, 0)
+            self.assertEqual(every().hour.at(':00').do(mock_job).next_run.hour, 13)
+            self.assertEqual(every().hour.at(':00').do(mock_job).next_run.minute, 0)
+            self.assertEqual(every().hour.at(':00').do(mock_job).next_run.second, 0)
 
             with self.assertRaises(ScheduleValueError):
                 every().hour.at('2:30:00')
@@ -165,12 +164,12 @@ def test_at_time_hour(self):
     def test_at_time_minute(self):
         with mock_datetime(2010, 1, 6, 12, 20, 30):
             mock_job = make_mock_job()
-            assert every().minute.at(':40').do(mock_job).next_run.hour == 12
-            assert every().minute.at(':40').do(mock_job).next_run.minute == 20
-            assert every().minute.at(':40').do(mock_job).next_run.second == 40
-            assert every().minute.at(':10').do(mock_job).next_run.hour == 12
-            assert every().minute.at(':10').do(mock_job).next_run.minute == 21
-            assert every().minute.at(':10').do(mock_job).next_run.second == 10
+            self.assertEqual(every().minute.at(':40').do(mock_job).next_run.hour, 12)
+            self.assertEqual(every().minute.at(':40').do(mock_job).next_run.minute, 20)
+            self.assertEqual(every().minute.at(':40').do(mock_job).next_run.second, 40)
+            self.assertEqual(every().minute.at(':10').do(mock_job).next_run.hour, 12)
+            self.assertEqual(every().minute.at(':10').do(mock_job).next_run.minute, 21)
+            self.assertEqual(every().minute.at(':10').do(mock_job).next_run.second, 10)
 
             with self.assertRaises(ScheduleValueError):
                 every().minute.at('::2')
@@ -185,21 +184,22 @@ def test_at_time_minute(self):
     def test_next_run_time(self):
         with mock_datetime(2010, 1, 6, 12, 15):
             mock_job = make_mock_job()
-            assert schedule.next_run() is None
-            assert every().minute.do(mock_job).next_run.minute == 16
-            assert every(5).minutes.do(mock_job).next_run.minute == 20
-            assert every().hour.do(mock_job).next_run.hour == 13
-            assert every().day.do(mock_job).next_run.day == 7
-            assert every().day.at('09:00').do(mock_job).next_run.day == 7
-            assert every().day.at('12:30').do(mock_job).next_run.day == 6
-            assert every().week.do(mock_job).next_run.day == 13
-            assert every().monday.do(mock_job).next_run.day == 11
-            assert every().tuesday.do(mock_job).next_run.day == 12
-            assert every().wednesday.do(mock_job).next_run.day == 13
-            assert every().thursday.do(mock_job).next_run.day == 7
-            assert every().friday.do(mock_job).next_run.day == 8
-            assert every().saturday.do(mock_job).next_run.day == 9
-            assert every().sunday.do(mock_job).next_run.day == 10
+            self.assertIsNone(schedule.next_run())
+
+            self.assertEqual(every().minute.do(mock_job).next_run.minute, 16)
+            self.assertEqual(every(5).minutes.do(mock_job).next_run.minute, 20)
+            self.assertEqual(every().hour.do(mock_job).next_run.hour, 13)
+            self.assertEqual(every().day.do(mock_job).next_run.day, 7)
+            self.assertEqual(every().day.at('09:00').do(mock_job).next_run.day, 7)
+            self.assertEqual(every().day.at('12:30').do(mock_job).next_run.day, 6)
+            self.assertEqual(every().week.do(mock_job).next_run.day, 13)
+            self.assertEqual(every().monday.do(mock_job).next_run.day, 11)
+            self.assertEqual(every().tuesday.do(mock_job).next_run.day, 12)
+            self.assertEqual(every().wednesday.do(mock_job).next_run.day, 13)
+            self.assertEqual(every().thursday.do(mock_job).next_run.day, 7)
+            self.assertEqual(every().friday.do(mock_job).next_run.day, 8)
+            self.assertEqual(every().saturday.do(mock_job).next_run.day, 9)
+            self.assertEqual(every().sunday.do(mock_job).next_run.day, 10)
 
     def test_run_all(self):
         mock_job = make_mock_job()
@@ -207,7 +207,7 @@ def test_run_all(self):
         every().hour.do(mock_job)
         every().day.at('11:00').do(mock_job)
         schedule.run_all()
-        assert mock_job.call_count == 3
+        self.assertEqual(mock_job.call_count, 3)
 
     def test_job_func_args_are_passed_on(self):
         mock_job = make_mock_job()
@@ -219,22 +219,22 @@ def test_to_string(self):
         def job_fun():
             pass
         s = str(every().minute.do(job_fun, 'foo', bar=23))
-        assert 'job_fun' in s
-        assert 'foo' in s
-        assert 'bar=23' in s
+        self.assertIn('job_fun', s)
+        self.assertIn('foo', s)
+        self.assertIn('bar=23', s)
 
     def test_to_string_lambda_job_func(self):
-        assert len(str(every().minute.do(lambda: 1))) > 1
-        assert len(str(every().day.at('10:30').do(lambda: 1))) > 1
+        self.assertGreater(len(str(every().minute.do(lambda: 1))), 1)
+        self.assertGreater(len(str(every().day.at('10:30').do(lambda: 1))), 1)
 
     def test_to_string_functools_partial_job_func(self):
         def job_fun(arg):
             pass
         job_fun = functools.partial(job_fun, 'foo')
         job_repr = repr(every().minute.do(job_fun, bar=True, somekey=23))
-        assert 'functools.partial' in job_repr
-        assert 'bar=True' in job_repr
-        assert 'somekey=23' in job_repr
+        self.assertIn('functools.partial', job_repr)
+        self.assertIn('bar=True', job_repr)
+        self.assertIn('somekey=23', job_repr)
 
     def test_run_pending(self):
         """Check that run_pending() runs pending jobs.
@@ -255,79 +255,79 @@ def test_run_pending(self):
             every().day.do(mock_job)
             every().sunday.do(mock_job)
             schedule.run_pending()
-            assert mock_job.call_count == 0
+            self.assertEqual(mock_job.call_count, 0)
 
         with mock_datetime(2010, 1, 6, 12, 16):
             schedule.run_pending()
-            assert mock_job.call_count == 1
+            self.assertEqual(mock_job.call_count, 1)
 
         with mock_datetime(2010, 1, 6, 13, 16):
             mock_job.reset_mock()
             schedule.run_pending()
-            assert mock_job.call_count == 2
+            self.assertEqual(mock_job.call_count, 2)
 
         with mock_datetime(2010, 1, 7, 13, 16):
             mock_job.reset_mock()
             schedule.run_pending()
-            assert mock_job.call_count == 3
+            self.assertEqual(mock_job.call_count, 3)
 
         with mock_datetime(2010, 1, 10, 13, 16):
             mock_job.reset_mock()
             schedule.run_pending()
-            assert mock_job.call_count == 4
+            self.assertEqual(mock_job.call_count, 4)
 
     def test_run_every_weekday_at_specific_time_today(self):
         mock_job = make_mock_job()
         with mock_datetime(2010, 1, 6, 13, 16):
             every().wednesday.at('14:12').do(mock_job)
             schedule.run_pending()
-            assert mock_job.call_count == 0
+            self.assertEqual(mock_job.call_count, 0)
 
         with mock_datetime(2010, 1, 6, 14, 16):
             schedule.run_pending()
-            assert mock_job.call_count == 1
+            self.assertEqual(mock_job.call_count, 1)
 
     def test_run_every_weekday_at_specific_time_past_today(self):
         mock_job = make_mock_job()
         with mock_datetime(2010, 1, 6, 13, 16):
             every().wednesday.at('13:15').do(mock_job)
             schedule.run_pending()
-            assert mock_job.call_count == 0
+            self.assertEqual(mock_job.call_count, 0)
 
         with mock_datetime(2010, 1, 13, 13, 14):
             schedule.run_pending()
-            assert mock_job.call_count == 0
+            self.assertEqual(mock_job.call_count, 0)
 
         with mock_datetime(2010, 1, 13, 13, 16):
             schedule.run_pending()
-            assert mock_job.call_count == 1
+            self.assertEqual(mock_job.call_count, 1)
 
     def test_run_every_n_days_at_specific_time(self):
         mock_job = make_mock_job()
         with mock_datetime(2010, 1, 6, 11, 29):
             every(2).days.at('11:30').do(mock_job)
             schedule.run_pending()
-            assert mock_job.call_count == 0
+            self.assertEqual(mock_job.call_count, 0)
 
         with mock_datetime(2010, 1, 6, 11, 31):
             schedule.run_pending()
-            assert mock_job.call_count == 0
+            self.assertEqual(mock_job.call_count, 0)
 
         with mock_datetime(2010, 1, 7, 11, 31):
             schedule.run_pending()
-            assert mock_job.call_count == 0
+            self.assertEqual(mock_job.call_count, 0)
 
         with mock_datetime(2010, 1, 8, 11, 29):
             schedule.run_pending()
-            assert mock_job.call_count == 0
+            self.assertEqual(mock_job.call_count, 0)
 
         with mock_datetime(2010, 1, 8, 11, 31):
             schedule.run_pending()
-            assert mock_job.call_count == 1
+            self.assertEqual(mock_job.call_count, 1)
 
         with mock_datetime(2010, 1, 10, 11, 31):
             schedule.run_pending()
-            assert mock_job.call_count == 2
+            self.assertEqual(mock_job.call_count, 2)
 
     def test_next_run_property(self):
         original_datetime = datetime.datetime
@@ -336,10 +336,10 @@ def test_next_run_property(self):
             daily_job = make_mock_job('daily')
             every().day.do(daily_job)
             every().hour.do(hourly_job)
-            assert len(schedule.jobs) == 2
+            self.assertEqual(len(schedule.jobs), 2)
             # Make sure the hourly job is first
-            assert schedule.next_run() == original_datetime(2010, 1, 6, 14, 16)
-            assert schedule.idle_seconds() == 60 * 60
+            self.assertEqual(schedule.next_run(), original_datetime(2010, 1, 6, 14, 16))
+            self.assertEqual(schedule.idle_seconds(), 60 * 60)
 
     def test_cancel_job(self):
         def stop_job():
@@ -348,19 +348,19 @@ def stop_job():
 
         every().second.do(stop_job)
         mj = every().second.do(mock_job)
-        assert len(schedule.jobs) == 2
+        self.assertEqual(len(schedule.jobs), 2)
 
         schedule.run_all()
-        assert len(schedule.jobs) == 1
-        assert schedule.jobs[0] == mj
+        self.assertEqual(len(schedule.jobs), 1)
+        self.assertEqual(schedule.jobs[0], mj)
 
         schedule.cancel_job('Not a job')
-        assert len(schedule.jobs) == 1
+        self.assertEqual(len(schedule.jobs), 1)
         schedule.default_scheduler.cancel_job('Not a job')
-        assert len(schedule.jobs) == 1
+        self.assertEqual(len(schedule.jobs), 1)
 
         schedule.cancel_job(mj)
-        assert len(schedule.jobs) == 0
+        self.assertEqual(len(schedule.jobs), 0)
 
     def test_cancel_jobs(self):
         def stop_job():
@@ -369,35 +369,35 @@ def stop_job():
         every().second.do(stop_job)
         every().second.do(stop_job)
         every().second.do(stop_job)
-        assert len(schedule.jobs) == 3
+        self.assertEqual(len(schedule.jobs), 3)
 
         schedule.run_all()
-        assert len(schedule.jobs) == 0
+        self.assertEqual(len(schedule.jobs), 0)
 
     def test_tag_type_enforcement(self):
         job1 = every().second.do(make_mock_job(name='job1'))
         self.assertRaises(TypeError, job1.tag, {})
         self.assertRaises(TypeError, job1.tag, 1, 'a', [])
         job1.tag(0, 'a', True)
-        assert len(job1.tags) == 3
+        self.assertEqual(len(job1.tags), 3)
 
     def test_clear_by_tag(self):
         every().second.do(make_mock_job(name='job1')).tag('tag1')
         every().second.do(make_mock_job(name='job2')).tag('tag1', 'tag2')
         every().second.do(make_mock_job(name='job3')).tag('tag3', 'tag3',
                                                           'tag3', 'tag2')
-        assert len(schedule.jobs) == 3
+        self.assertEqual(len(schedule.jobs), 3)
         schedule.run_all()
-        assert len(schedule.jobs) == 3
+        self.assertEqual(len(schedule.jobs), 3)
         schedule.clear('tag3')
-        assert len(schedule.jobs) == 2
+        self.assertEqual(len(schedule.jobs), 2)
         schedule.clear('tag1')
-        assert len(schedule.jobs) == 0
+        self.assertEqual(len(schedule.jobs), 0)
         every().second.do(make_mock_job(name='job1'))
         every().second.do(make_mock_job(name='job2'))
         every().second.do(make_mock_job(name='job3'))
         schedule.clear()
-        assert len(schedule.jobs) == 0
+        self.assertEqual(len(schedule.jobs), 0)
 
     def test_misconfigured_job_wont_break_scheduler(self):
         """

From 94a6d5bf0e9a3ffd85480775377ec8e3efb73530 Mon Sep 17 00:00:00 2001
From: ConnorSkees <39542938+ConnorSkees@users.noreply.github.com>
Date: Sun, 13 Jan 2019 11:20:45 -0500
Subject: [PATCH 19/29] Properly implement context managers with assertRaises

---
 test_schedule.py | 78 +++++++++++++++++++++++++++++++-----------------
 1 file changed, 50 insertions(+), 28 deletions(-)

diff --git a/test_schedule.py b/test_schedule.py
index a3ed8f18..96904d2c 100644
--- a/test_schedule.py
+++ b/test_schedule.py
@@ -59,20 +59,35 @@ def test_time_units(self):
         self.assertEqual(every().weeks.unit, 'weeks')
 
         job_instance = schedule.Job(interval=2)
+        # without a context manager, it incorrectly raises an error because
+        # it is not callable
         with self.assertRaises(IntervalError):
-            job_instance.second
             job_instance.minute
+        with self.assertRaises(IntervalError):
             job_instance.hour
+        with self.assertRaises(IntervalError):
             job_instance.day
+        with self.assertRaises(IntervalError):
             job_instance.week
+        with self.assertRaises(IntervalError):
             job_instance.monday
+        with self.assertRaises(IntervalError):
             job_instance.tuesday
+        with self.assertRaises(IntervalError):
             job_instance.wednesday
+        with self.assertRaises(IntervalError):
             job_instance.thursday
+        with self.assertRaises(IntervalError):
             job_instance.friday
+        with self.assertRaises(IntervalError):
             job_instance.saturday
+        with self.assertRaises(IntervalError):
             job_instance.sunday
 
+        job_instance.unit = "foo"
+        with self.assertRaises(ScheduleValueError):
+            job_instance.at("1:0:0")
+
     def test_singular_time_units_match_plural_units(self):
         self.assertEqual(every().second.unit, every().seconds.unit)
         self.assertEqual(every().minute.unit, every().minutes.unit)
@@ -108,32 +123,41 @@ def test_at_time(self):
         self.assertEqual(every().day.at('10:30').do(mock_job).next_run.minute, 30)
         self.assertEqual(every().day.at('10:30:50').do(mock_job).next_run.second, 50)
 
-        with self.assertRaises(ScheduleValueError):
-            every().day.at('2:30:000001')
-            every().day.at('::2')
-            every().day.at('.2')
-            every().day.at('2')
-            every().day.at(':2')
-            every().day.at(' 2:30:00')
-            every().day.at("25:00:00")
-            every().seconds.at("00:00:00")
-
-            every().do(lambda: 0)
+        self.assertRaises(ScheduleValueError, every().day.at, '2:30:000001')
+        self.assertRaises(ScheduleValueError, every().day.at, '::2')
+        self.assertRaises(ScheduleValueError, every().day.at, '.2')
+        self.assertRaises(ScheduleValueError, every().day.at, '2')
+        self.assertRaises(ScheduleValueError, every().day.at, ':2')
+        self.assertRaises(ScheduleValueError, every().day.at, ' 2:30:00')
+        self.assertRaises(ScheduleValueError, every().do, lambda: 0)
 
         self.assertRaises(TypeError, every().day.at, 2)
 
+        # without a context manager, it incorrectly raises an error because
+        # it is not callable
         with self.assertRaises(IntervalError):
             every(interval=2).second
+        with self.assertRaises(IntervalError):
             every(interval=2).minute
+        with self.assertRaises(IntervalError):
             every(interval=2).hour
+        with self.assertRaises(IntervalError):
             every(interval=2).day
+        with self.assertRaises(IntervalError):
             every(interval=2).week
+        with self.assertRaises(IntervalError):
             every(interval=2).monday
+        with self.assertRaises(IntervalError):
             every(interval=2).tuesday
+        with self.assertRaises(IntervalError):
             every(interval=2).wednesday
+        with self.assertRaises(IntervalError):
             every(interval=2).thursday
+        with self.assertRaises(IntervalError):
             every(interval=2).friday
+        with self.assertRaises(IntervalError):
             every(interval=2).saturday
+        with self.assertRaises(IntervalError):
             every(interval=2).sunday
 
     def test_at_time_hour(self):
@@ -149,15 +173,14 @@ def test_at_time_hour(self):
             self.assertEqual(every().hour.at(':00').do(mock_job).next_run.minute, 0)
             self.assertEqual(every().hour.at(':00').do(mock_job).next_run.second, 0)
 
-            with self.assertRaises(ScheduleValueError):
-                every().hour.at('2:30:00')
-                every().hour.at('::2')
-                every().hour.at('.2')
-                every().hour.at('2')
-                every().hour.at(' 2:30')
-                every().hour.at("61:00")
-                every().hour.at("00:61")
-                every().hour.at("01:61")
+            self.assertRaises(ScheduleValueError, every().hour.at, '2:30:00')
+            self.assertRaises(ScheduleValueError, every().hour.at, '::2')
+            self.assertRaises(ScheduleValueError, every().hour.at, '.2')
+            self.assertRaises(ScheduleValueError, every().hour.at, '2')
+            self.assertRaises(ScheduleValueError, every().hour.at, ' 2:30')
+            self.assertRaises(ScheduleValueError, every().hour.at, "61:00")
+            self.assertRaises(ScheduleValueError, every().hour.at, "00:61")
+            self.assertRaises(ScheduleValueError, every().hour.at, "01:61")
 
             self.assertRaises(TypeError, every().hour.at, 2)
 
@@ -171,13 +194,12 @@ def test_at_time_minute(self):
             self.assertEqual(every().minute.at(':10').do(mock_job).next_run.minute, 21)
             self.assertEqual(every().minute.at(':10').do(mock_job).next_run.second, 10)
 
-            with self.assertRaises(ScheduleValueError):
-                every().minute.at('::2')
-                every().minute.at('.2')
-                every().minute.at('2')
-                every().minute.at('2:30:00')
-                every().minute.at('2:30')
-                every().minute.at(' :30')
+            self.assertRaises(ScheduleValueError, every().minute.at, '::2')
+            self.assertRaises(ScheduleValueError, every().minute.at, '.2')
+            self.assertRaises(ScheduleValueError, every().minute.at, '2')
+            self.assertRaises(ScheduleValueError, every().minute.at, '2:30:00')
+            self.assertRaises(ScheduleValueError, every().minute.at, '2:30')
+            self.assertRaises(ScheduleValueError, every().minute.at, ' :30')
 
             self.assertRaises(TypeError, every().minute.at, 2)
 

From e6e32eba2fe143cd1f3c11c803bd186d3ab5d17d Mon Sep 17 00:00:00 2001
From: ConnorSkees <39542938+ConnorSkees@users.noreply.github.com>
Date: Sun, 13 Jan 2019 11:53:21 -0500
Subject: [PATCH 20/29] Test more raises

---
 test_schedule.py | 27 +++++++++++++++++++++++++--
 1 file changed, 25 insertions(+), 2 deletions(-)

diff --git a/test_schedule.py b/test_schedule.py
index 96904d2c..3bfa8338 100644
--- a/test_schedule.py
+++ b/test_schedule.py
@@ -84,9 +84,32 @@ def test_time_units(self):
         with self.assertRaises(IntervalError):
             job_instance.sunday
 
+        # test an invalid unit
         job_instance.unit = "foo"
-        with self.assertRaises(ScheduleValueError):
-            job_instance.at("1:0:0")
+        self.assertRaises(ScheduleValueError, job_instance.at, "1:0:0")
+        self.assertRaises(ScheduleValueError, job_instance._schedule_next_run)
+
+        # test start day exists but unit is not 'weeks'
+        job_instance.unit = "days"
+        job_instance.start_day = 1
+        self.assertRaises(ScheduleValueError, job_instance._schedule_next_run)
+
+        # test weeks with an invalid start day
+        job_instance.unit = "weeks"
+        job_instance.start_day = "bar"
+        self.assertRaises(ScheduleValueError, job_instance._schedule_next_run)
+
+        # test a valid unit with invalid hours/minutes/seconds
+        job_instance.unit = "days"
+        self.assertRaises(ScheduleValueError, job_instance.at, "25:0:0")
+        self.assertRaises(ScheduleValueError, job_instance.at, "0:0:0")
+        self.assertRaises(ScheduleValueError, job_instance.at, "0:61:0")
+        self.assertRaises(ScheduleValueError, job_instance.at, "0:0:61")
+
+        job_instance.unit = "foo"
+        job_instance.at_time = "bar"
+        job_instance.start_day = None
+        self.assertRaises(ScheduleValueError, job_instance._schedule_next_run)
 
     def test_singular_time_units_match_plural_units(self):
         self.assertEqual(every().second.unit, every().seconds.unit)

From 8b62d87724be5bae0fdb11e67beff276a98e3125 Mon Sep 17 00:00:00 2001
From: ConnorSkees <39542938+ConnorSkees@users.noreply.github.com>
Date: Sun, 13 Jan 2019 12:03:16 -0500
Subject: [PATCH 21/29] Fix line lengths to be under 80

---
 test_schedule.py | 79 ++++++++++++++++++++++++++++--------------------
 1 file changed, 46 insertions(+), 33 deletions(-)

diff --git a/test_schedule.py b/test_schedule.py
index 3bfa8338..affd9d38 100644
--- a/test_schedule.py
+++ b/test_schedule.py
@@ -142,9 +142,10 @@ def test_time_range_repr(self):
 
     def test_at_time(self):
         mock_job = make_mock_job()
-        self.assertEqual(every().day.at('10:30').do(mock_job).next_run.hour, 10)
-        self.assertEqual(every().day.at('10:30').do(mock_job).next_run.minute, 30)
-        self.assertEqual(every().day.at('10:30:50').do(mock_job).next_run.second, 50)
+        assertEqual = self.assertEqual
+        assertEqual(every().day.at('10:30').do(mock_job).next_run.hour, 10)
+        assertEqual(every().day.at('10:30').do(mock_job).next_run.minute,30)
+        assertEqual(every().day.at('10:30:50').do(mock_job).next_run.second, 50)
 
         self.assertRaises(ScheduleValueError, every().day.at, '2:30:000001')
         self.assertRaises(ScheduleValueError, every().day.at, '::2')
@@ -186,15 +187,18 @@ def test_at_time(self):
     def test_at_time_hour(self):
         with mock_datetime(2010, 1, 6, 12, 20):
             mock_job = make_mock_job()
-            self.assertEqual(every().hour.at(':30').do(mock_job).next_run.hour, 12)
-            self.assertEqual(every().hour.at(':30').do(mock_job).next_run.minute, 30)
-            self.assertEqual(every().hour.at(':30').do(mock_job).next_run.second, 0)
-            self.assertEqual(every().hour.at(':10').do(mock_job).next_run.hour, 13)
-            self.assertEqual(every().hour.at(':10').do(mock_job).next_run.minute, 10)
-            self.assertEqual(every().hour.at(':10').do(mock_job).next_run.second, 0)
-            self.assertEqual(every().hour.at(':00').do(mock_job).next_run.hour, 13)
-            self.assertEqual(every().hour.at(':00').do(mock_job).next_run.minute, 0)
-            self.assertEqual(every().hour.at(':00').do(mock_job).next_run.second, 0)
+            assertEqual = self.assertEqual
+            assertEqual(every().hour.at(':30').do(mock_job).next_run.hour, 12)
+            assertEqual(every().hour.at(':30').do(mock_job).next_run.minute,
+                        30)
+            assertEqual(every().hour.at(':30').do(mock_job).next_run.second, 0)
+            assertEqual(every().hour.at(':10').do(mock_job).next_run.hour, 13)
+            assertEqual(every().hour.at(':10').do(mock_job).next_run.minute,
+                        10)
+            assertEqual(every().hour.at(':10').do(mock_job).next_run.second, 0)
+            assertEqual(every().hour.at(':00').do(mock_job).next_run.hour, 13)
+            assertEqual(every().hour.at(':00').do(mock_job).next_run.minute, 0)
+            assertEqual(every().hour.at(':00').do(mock_job).next_run.second, 0)
 
             self.assertRaises(ScheduleValueError, every().hour.at, '2:30:00')
             self.assertRaises(ScheduleValueError, every().hour.at, '::2')
@@ -210,12 +214,19 @@ def test_at_time_hour(self):
     def test_at_time_minute(self):
         with mock_datetime(2010, 1, 6, 12, 20, 30):
             mock_job = make_mock_job()
-            self.assertEqual(every().minute.at(':40').do(mock_job).next_run.hour, 12)
-            self.assertEqual(every().minute.at(':40').do(mock_job).next_run.minute, 20)
-            self.assertEqual(every().minute.at(':40').do(mock_job).next_run.second, 40)
-            self.assertEqual(every().minute.at(':10').do(mock_job).next_run.hour, 12)
-            self.assertEqual(every().minute.at(':10').do(mock_job).next_run.minute, 21)
-            self.assertEqual(every().minute.at(':10').do(mock_job).next_run.second, 10)
+            assertEqual = self.assertEqual
+            assertEqual(every().minute.at(':40').do(mock_job).next_run.hour,
+                        12)
+            assertEqual(every().minute.at(':40').do(mock_job).next_run.minute,
+                        20)
+            assertEqual(every().minute.at(':40').do(mock_job).next_run.second,
+                        40)
+            assertEqual(every().minute.at(':10').do(mock_job).next_run.hour,
+                        12)
+            assertEqual(every().minute.at(':10').do(mock_job).next_run.minute,
+                        21)
+            assertEqual(every().minute.at(':10').do(mock_job).next_run.second,
+                        10)
 
             self.assertRaises(ScheduleValueError, every().minute.at, '::2')
             self.assertRaises(ScheduleValueError, every().minute.at, '.2')
@@ -231,20 +242,21 @@ def test_next_run_time(self):
             mock_job = make_mock_job()
             self.assertIsNone(schedule.next_run())
 
-            self.assertEqual(every().minute.do(mock_job).next_run.minute, 16)
-            self.assertEqual(every(5).minutes.do(mock_job).next_run.minute, 20)
-            self.assertEqual(every().hour.do(mock_job).next_run.hour, 13)
-            self.assertEqual(every().day.do(mock_job).next_run.day, 7)
-            self.assertEqual(every().day.at('09:00').do(mock_job).next_run.day, 7)
-            self.assertEqual(every().day.at('12:30').do(mock_job).next_run.day, 6)
-            self.assertEqual(every().week.do(mock_job).next_run.day, 13)
-            self.assertEqual(every().monday.do(mock_job).next_run.day, 11)
-            self.assertEqual(every().tuesday.do(mock_job).next_run.day, 12)
-            self.assertEqual(every().wednesday.do(mock_job).next_run.day, 13)
-            self.assertEqual(every().thursday.do(mock_job).next_run.day, 7)
-            self.assertEqual(every().friday.do(mock_job).next_run.day, 8)
-            self.assertEqual(every().saturday.do(mock_job).next_run.day, 9)
-            self.assertEqual(every().sunday.do(mock_job).next_run.day, 10)
+            assertEqual = self.assertEqual
+            assertEqual(every().minute.do(mock_job).next_run.minute, 16)
+            assertEqual(every(5).minutes.do(mock_job).next_run.minute, 20)
+            assertEqual(every().hour.do(mock_job).next_run.hour, 13)
+            assertEqual(every().day.do(mock_job).next_run.day, 7)
+            assertEqual(every().day.at('09:00').do(mock_job).next_run.day, 7)
+            assertEqual(every().day.at('12:30').do(mock_job).next_run.day, 6)
+            assertEqual(every().week.do(mock_job).next_run.day, 13)
+            assertEqual(every().monday.do(mock_job).next_run.day, 11)
+            assertEqual(every().tuesday.do(mock_job).next_run.day, 12)
+            assertEqual(every().wednesday.do(mock_job).next_run.day, 13)
+            assertEqual(every().thursday.do(mock_job).next_run.day, 7)
+            assertEqual(every().friday.do(mock_job).next_run.day, 8)
+            assertEqual(every().saturday.do(mock_job).next_run.day, 9)
+            assertEqual(every().sunday.do(mock_job).next_run.day, 10)
 
     def test_run_all(self):
         mock_job = make_mock_job()
@@ -383,7 +395,8 @@ def test_next_run_property(self):
             every().hour.do(hourly_job)
             self.assertEqual(len(schedule.jobs), 2)
             # Make sure the hourly job is first
-            self.assertEqual(schedule.next_run(), original_datetime(2010, 1, 6, 14, 16))
+            self.assertEqual(schedule.next_run(),
+                             original_datetime(2010, 1, 6, 14, 16))
             self.assertEqual(schedule.idle_seconds(), 60 * 60)
 
     def test_cancel_job(self):

From a8d017b35b50b0119827744bcf30094e7f8053f4 Mon Sep 17 00:00:00 2001
From: ConnorSkees <39542938+ConnorSkees@users.noreply.github.com>
Date: Sun, 13 Jan 2019 12:06:04 -0500
Subject: [PATCH 22/29] Missed a line

---
 test_schedule.py | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/test_schedule.py b/test_schedule.py
index affd9d38..ab8f5cb5 100644
--- a/test_schedule.py
+++ b/test_schedule.py
@@ -144,8 +144,9 @@ def test_at_time(self):
         mock_job = make_mock_job()
         assertEqual = self.assertEqual
         assertEqual(every().day.at('10:30').do(mock_job).next_run.hour, 10)
-        assertEqual(every().day.at('10:30').do(mock_job).next_run.minute,30)
-        assertEqual(every().day.at('10:30:50').do(mock_job).next_run.second, 50)
+        assertEqual(every().day.at('10:30').do(mock_job).next_run.minute, 30)
+        assertEqual(every().day.at('10:30:50').do(mock_job).next_run.second,
+                    50)
 
         self.assertRaises(ScheduleValueError, every().day.at, '2:30:000001')
         self.assertRaises(ScheduleValueError, every().day.at, '::2')

From c9461bb752200a757ed8b59831d547fac5a8bf14 Mon Sep 17 00:00:00 2001
From: ConnorSkees <39542938+ConnorSkees@users.noreply.github.com>
Date: Sun, 13 Jan 2019 12:19:29 -0500
Subject: [PATCH 23/29] Properly test invalid hours/minutes/seconds

---
 test_schedule.py | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/test_schedule.py b/test_schedule.py
index ab8f5cb5..e8d03e2d 100644
--- a/test_schedule.py
+++ b/test_schedule.py
@@ -101,8 +101,12 @@ def test_time_units(self):
 
         # test a valid unit with invalid hours/minutes/seconds
         job_instance.unit = "days"
+        self.assertRaises(ScheduleValueError, job_instance.at, "25:00:00")
+        self.assertRaises(ScheduleValueError, job_instance.at, "00:61:00")
+        self.assertRaises(ScheduleValueError, job_instance.at, "00:00:61")
+
+        # test invalid time format
         self.assertRaises(ScheduleValueError, job_instance.at, "25:0:0")
-        self.assertRaises(ScheduleValueError, job_instance.at, "0:0:0")
         self.assertRaises(ScheduleValueError, job_instance.at, "0:61:0")
         self.assertRaises(ScheduleValueError, job_instance.at, "0:0:61")
 

From 43705e7e41d33db50b1bd1c56adf1f8b45c7c423 Mon Sep 17 00:00:00 2001
From: ConnorSkees <39542938+ConnorSkees@users.noreply.github.com>
Date: Sun, 13 Jan 2019 12:28:47 -0500
Subject: [PATCH 24/29] Improve coverage

---
 test_schedule.py | 9 +++++++--
 1 file changed, 7 insertions(+), 2 deletions(-)

diff --git a/test_schedule.py b/test_schedule.py
index e8d03e2d..05beec83 100644
--- a/test_schedule.py
+++ b/test_schedule.py
@@ -110,11 +110,16 @@ def test_time_units(self):
         self.assertRaises(ScheduleValueError, job_instance.at, "0:61:0")
         self.assertRaises(ScheduleValueError, job_instance.at, "0:0:61")
 
-        job_instance.unit = "foo"
-        job_instance.at_time = "bar"
+        # test (very specific) seconds with unspecified start_day
+        job_instance.unit = "seconds"
+        job_instance.at_time = datetime.datetime.now()
         job_instance.start_day = None
         self.assertRaises(ScheduleValueError, job_instance._schedule_next_run)
 
+        # test self.latest >= self.interval
+        job_instance.latest = 3
+        self.assertRaises(ScheduleValueError, job_instance._schedule_next_run)
+
     def test_singular_time_units_match_plural_units(self):
         self.assertEqual(every().second.unit, every().seconds.unit)
         self.assertEqual(every().minute.unit, every().minutes.unit)

From 9a86c9c54facb702f0175d27a9748e0cf9cee2a0 Mon Sep 17 00:00:00 2001
From: ConnorSkees <39542938+ConnorSkees@users.noreply.github.com>
Date: Sun, 13 Jan 2019 12:46:35 -0500
Subject: [PATCH 25/29] Revert unittest changes

---
 test_schedule.py | 142 +++++++++++++++++++++++++++++------------------
 1 file changed, 89 insertions(+), 53 deletions(-)

diff --git a/test_schedule.py b/test_schedule.py
index 05beec83..a57cbbee 100644
--- a/test_schedule.py
+++ b/test_schedule.py
@@ -52,11 +52,11 @@ def setUp(self):
         schedule.clear()
 
     def test_time_units(self):
-        self.assertEqual(every().seconds.unit, 'seconds')
-        self.assertEqual(every().minutes.unit, 'minutes')
-        self.assertEqual(every().hours.unit, 'hours')
-        self.assertEqual(every().days.unit, 'days')
-        self.assertEqual(every().weeks.unit, 'weeks')
+        assert every().seconds.unit == 'seconds'
+        assert every().minutes.unit == 'minutes'
+        assert every().hours.unit == 'hours'
+        assert every().days.unit == 'days'
+        assert every().weeks.unit == 'weeks'
 
         job_instance = schedule.Job(interval=2)
         # without a context manager, it incorrectly raises an error because
@@ -121,11 +121,11 @@ def test_time_units(self):
         self.assertRaises(ScheduleValueError, job_instance._schedule_next_run)
 
     def test_singular_time_units_match_plural_units(self):
-        self.assertEqual(every().second.unit, every().seconds.unit)
-        self.assertEqual(every().minute.unit, every().minutes.unit)
-        self.assertEqual(every().hour.unit, every().hours.unit)
-        self.assertEqual(every().day.unit, every().days.unit)
-        self.assertEqual(every().week.unit, every().weeks.unit)
+        assert every().second.unit == every().seconds.unit
+        assert every().minute.unit == every().minutes.unit
+        assert every().hour.unit == every().hours.unit
+        assert every().day.unit == every().days.unit
+        assert every().week.unit == every().weeks.unit
 
     def test_time_range(self):
         with mock_datetime(2014, 6, 28, 12, 0):
@@ -137,9 +137,10 @@ def test_time_range(self):
                 every(5).to(30).minutes.do(mock_job).next_run.minute
                 for i in range(100)
             ])
-            self.assertGreater(len(minutes), 1)
-            self.assertGreaterEqual(min(minutes), 5)
-            self.assertLessEqual(max(minutes), 30)
+
+            assert len(minutes) > 1
+            assert min(minutes) >= 5
+            assert max(minutes) <= 30
 
     def test_time_range_repr(self):
         mock_job = make_mock_job()
@@ -164,6 +165,9 @@ def test_at_time(self):
         self.assertRaises(ScheduleValueError, every().day.at, ':2')
         self.assertRaises(ScheduleValueError, every().day.at, ' 2:30:00')
         self.assertRaises(ScheduleValueError, every().do, lambda: 0)
+        assert every().day.at('10:30').do(mock_job).next_run.hour == 10
+        assert every().day.at('10:30').do(mock_job).next_run.minute == 30
+        assert every().day.at('10:30:50').do(mock_job).next_run.second == 50
 
         self.assertRaises(TypeError, every().day.at, 2)
 
@@ -218,6 +222,15 @@ def test_at_time_hour(self):
             self.assertRaises(ScheduleValueError, every().hour.at, "61:00")
             self.assertRaises(ScheduleValueError, every().hour.at, "00:61")
             self.assertRaises(ScheduleValueError, every().hour.at, "01:61")
+            assert every().hour.at(':30').do(mock_job).next_run.hour == 12
+            assert every().hour.at(':30').do(mock_job).next_run.minute == 30
+            assert every().hour.at(':30').do(mock_job).next_run.second == 0
+            assert every().hour.at(':10').do(mock_job).next_run.hour == 13
+            assert every().hour.at(':10').do(mock_job).next_run.minute == 10
+            assert every().hour.at(':10').do(mock_job).next_run.second == 0
+            assert every().hour.at(':00').do(mock_job).next_run.hour == 13
+            assert every().hour.at(':00').do(mock_job).next_run.minute == 0
+            assert every().hour.at(':00').do(mock_job).next_run.second == 0
 
             self.assertRaises(TypeError, every().hour.at, 2)
 
@@ -244,6 +257,12 @@ def test_at_time_minute(self):
             self.assertRaises(ScheduleValueError, every().minute.at, '2:30:00')
             self.assertRaises(ScheduleValueError, every().minute.at, '2:30')
             self.assertRaises(ScheduleValueError, every().minute.at, ' :30')
+            assert every().minute.at(':40').do(mock_job).next_run.hour == 12
+            assert every().minute.at(':40').do(mock_job).next_run.minute == 20
+            assert every().minute.at(':40').do(mock_job).next_run.second == 40
+            assert every().minute.at(':10').do(mock_job).next_run.hour == 12
+            assert every().minute.at(':10').do(mock_job).next_run.minute == 21
+            assert every().minute.at(':10').do(mock_job).next_run.second == 10
 
             self.assertRaises(TypeError, every().minute.at, 2)
 
@@ -267,6 +286,21 @@ def test_next_run_time(self):
             assertEqual(every().friday.do(mock_job).next_run.day, 8)
             assertEqual(every().saturday.do(mock_job).next_run.day, 9)
             assertEqual(every().sunday.do(mock_job).next_run.day, 10)
+            assert schedule.next_run() is None
+            assert every().minute.do(mock_job).next_run.minute == 16
+            assert every(5).minutes.do(mock_job).next_run.minute == 20
+            assert every().hour.do(mock_job).next_run.hour == 13
+            assert every().day.do(mock_job).next_run.day == 7
+            assert every().day.at('09:00').do(mock_job).next_run.day == 7
+            assert every().day.at('12:30').do(mock_job).next_run.day == 6
+            assert every().week.do(mock_job).next_run.day == 13
+            assert every().monday.do(mock_job).next_run.day == 11
+            assert every().tuesday.do(mock_job).next_run.day == 12
+            assert every().wednesday.do(mock_job).next_run.day == 13
+            assert every().thursday.do(mock_job).next_run.day == 7
+            assert every().friday.do(mock_job).next_run.day == 8
+            assert every().saturday.do(mock_job).next_run.day == 9
+            assert every().sunday.do(mock_job).next_run.day == 10
 
     def test_run_all(self):
         mock_job = make_mock_job()
@@ -274,7 +308,7 @@ def test_run_all(self):
         every().hour.do(mock_job)
         every().day.at('11:00').do(mock_job)
         schedule.run_all()
-        self.assertEqual(mock_job.call_count, 3)
+        assert mock_job.call_count == 3
 
     def test_job_func_args_are_passed_on(self):
         mock_job = make_mock_job()
@@ -286,22 +320,22 @@ def test_to_string(self):
         def job_fun():
             pass
         s = str(every().minute.do(job_fun, 'foo', bar=23))
-        self.assertIn('job_fun', s)
-        self.assertIn('foo', s)
-        self.assertIn('bar=23', s)
+        assert 'job_fun' in s
+        assert 'foo' in s
+        assert 'bar=23' in s
 
     def test_to_string_lambda_job_func(self):
-        self.assertGreater(len(str(every().minute.do(lambda: 1))), 1)
-        self.assertGreater(len(str(every().day.at('10:30').do(lambda: 1))), 1)
+        assert len(str(every().minute.do(lambda: 1))) > 1
+        assert len(str(every().day.at('10:30').do(lambda: 1))) > 1
 
     def test_to_string_functools_partial_job_func(self):
         def job_fun(arg):
             pass
         job_fun = functools.partial(job_fun, 'foo')
         job_repr = repr(every().minute.do(job_fun, bar=True, somekey=23))
-        self.assertIn('functools.partial', job_repr)
-        self.assertIn('bar=True', job_repr)
-        self.assertIn('somekey=23', job_repr)
+        assert 'functools.partial' in job_repr
+        assert 'bar=True' in job_repr
+        assert 'somekey=23' in job_repr
 
     def test_run_pending(self):
         """Check that run_pending() runs pending jobs.
@@ -322,79 +356,79 @@ def test_run_pending(self):
             every().day.do(mock_job)
             every().sunday.do(mock_job)
             schedule.run_pending()
-            self.assertEqual(mock_job.call_count, 0)
+            assert mock_job.call_count == 0
 
         with mock_datetime(2010, 1, 6, 12, 16):
             schedule.run_pending()
-            self.assertEqual(mock_job.call_count, 1)
+            assert mock_job.call_count == 1
 
         with mock_datetime(2010, 1, 6, 13, 16):
             mock_job.reset_mock()
             schedule.run_pending()
-            self.assertEqual(mock_job.call_count, 2)
+            assert mock_job.call_count == 2
 
         with mock_datetime(2010, 1, 7, 13, 16):
             mock_job.reset_mock()
             schedule.run_pending()
-            self.assertEqual(mock_job.call_count, 3)
+            assert mock_job.call_count == 3
 
         with mock_datetime(2010, 1, 10, 13, 16):
             mock_job.reset_mock()
             schedule.run_pending()
-            self.assertEqual(mock_job.call_count, 4)
+            assert mock_job.call_count == 4
 
     def test_run_every_weekday_at_specific_time_today(self):
         mock_job = make_mock_job()
         with mock_datetime(2010, 1, 6, 13, 16):
             every().wednesday.at('14:12').do(mock_job)
             schedule.run_pending()
-            self.assertEqual(mock_job.call_count, 0)
+            assert mock_job.call_count == 0
 
         with mock_datetime(2010, 1, 6, 14, 16):
             schedule.run_pending()
-            self.assertEqual(mock_job.call_count, 1)
+            assert mock_job.call_count == 1
 
     def test_run_every_weekday_at_specific_time_past_today(self):
         mock_job = make_mock_job()
         with mock_datetime(2010, 1, 6, 13, 16):
             every().wednesday.at('13:15').do(mock_job)
             schedule.run_pending()
-            self.assertEqual(mock_job.call_count, 0)
+            assert mock_job.call_count == 0
 
         with mock_datetime(2010, 1, 13, 13, 14):
             schedule.run_pending()
-            self.assertEqual(mock_job.call_count, 0)
+            assert mock_job.call_count == 0
 
         with mock_datetime(2010, 1, 13, 13, 16):
             schedule.run_pending()
-            self.assertEqual(mock_job.call_count, 1)
+            assert mock_job.call_count == 1
 
     def test_run_every_n_days_at_specific_time(self):
         mock_job = make_mock_job()
         with mock_datetime(2010, 1, 6, 11, 29):
             every(2).days.at('11:30').do(mock_job)
             schedule.run_pending()
-            self.assertEqual(mock_job.call_count, 0)
+            assert mock_job.call_count == 0
 
         with mock_datetime(2010, 1, 6, 11, 31):
             schedule.run_pending()
-            self.assertEqual(mock_job.call_count, 0)
+            assert mock_job.call_count == 0
 
         with mock_datetime(2010, 1, 7, 11, 31):
             schedule.run_pending()
-            self.assertEqual(mock_job.call_count, 0)
+            assert mock_job.call_count == 0
 
         with mock_datetime(2010, 1, 8, 11, 29):
             schedule.run_pending()
-            self.assertEqual(mock_job.call_count, 0)
+            assert mock_job.call_count == 0
 
         with mock_datetime(2010, 1, 8, 11, 31):
             schedule.run_pending()
-            self.assertEqual(mock_job.call_count, 1)
+            assert mock_job.call_count == 1
 
         with mock_datetime(2010, 1, 10, 11, 31):
             schedule.run_pending()
-            self.assertEqual(mock_job.call_count, 2)
+            assert mock_job.call_count == 2
 
     def test_next_run_property(self):
         original_datetime = datetime.datetime
@@ -403,11 +437,13 @@ def test_next_run_property(self):
             daily_job = make_mock_job('daily')
             every().day.do(daily_job)
             every().hour.do(hourly_job)
-            self.assertEqual(len(schedule.jobs), 2)
+            assert len(schedule.jobs) == 2
             # Make sure the hourly job is first
             self.assertEqual(schedule.next_run(),
                              original_datetime(2010, 1, 6, 14, 16))
             self.assertEqual(schedule.idle_seconds(), 60 * 60)
+            assert schedule.next_run() == original_datetime(2010, 1, 6, 14, 16)
+            assert schedule.idle_seconds() == 60 * 60
 
     def test_cancel_job(self):
         def stop_job():
@@ -416,19 +452,19 @@ def stop_job():
 
         every().second.do(stop_job)
         mj = every().second.do(mock_job)
-        self.assertEqual(len(schedule.jobs), 2)
+        assert len(schedule.jobs) == 2
 
         schedule.run_all()
-        self.assertEqual(len(schedule.jobs), 1)
-        self.assertEqual(schedule.jobs[0], mj)
+        assert len(schedule.jobs) == 1
+        assert schedule.jobs[0] == mj
 
         schedule.cancel_job('Not a job')
-        self.assertEqual(len(schedule.jobs), 1)
+        assert len(schedule.jobs) == 1
         schedule.default_scheduler.cancel_job('Not a job')
-        self.assertEqual(len(schedule.jobs), 1)
+        assert len(schedule.jobs) == 1
 
         schedule.cancel_job(mj)
-        self.assertEqual(len(schedule.jobs), 0)
+        assert len(schedule.jobs) == 0
 
     def test_cancel_jobs(self):
         def stop_job():
@@ -437,35 +473,35 @@ def stop_job():
         every().second.do(stop_job)
         every().second.do(stop_job)
         every().second.do(stop_job)
-        self.assertEqual(len(schedule.jobs), 3)
+        assert len(schedule.jobs) == 3
 
         schedule.run_all()
-        self.assertEqual(len(schedule.jobs), 0)
+        assert len(schedule.jobs) == 0
 
     def test_tag_type_enforcement(self):
         job1 = every().second.do(make_mock_job(name='job1'))
         self.assertRaises(TypeError, job1.tag, {})
         self.assertRaises(TypeError, job1.tag, 1, 'a', [])
         job1.tag(0, 'a', True)
-        self.assertEqual(len(job1.tags), 3)
+        assert len(job1.tags) == 3
 
     def test_clear_by_tag(self):
         every().second.do(make_mock_job(name='job1')).tag('tag1')
         every().second.do(make_mock_job(name='job2')).tag('tag1', 'tag2')
         every().second.do(make_mock_job(name='job3')).tag('tag3', 'tag3',
                                                           'tag3', 'tag2')
-        self.assertEqual(len(schedule.jobs), 3)
+        assert len(schedule.jobs) == 3
         schedule.run_all()
-        self.assertEqual(len(schedule.jobs), 3)
+        assert len(schedule.jobs) == 3
         schedule.clear('tag3')
-        self.assertEqual(len(schedule.jobs), 2)
+        assert len(schedule.jobs) == 2
         schedule.clear('tag1')
-        self.assertEqual(len(schedule.jobs), 0)
+        assert len(schedule.jobs) == 0
         every().second.do(make_mock_job(name='job1'))
         every().second.do(make_mock_job(name='job2'))
         every().second.do(make_mock_job(name='job3'))
         schedule.clear()
-        self.assertEqual(len(schedule.jobs), 0)
+        assert len(schedule.jobs) == 0
 
     def test_misconfigured_job_wont_break_scheduler(self):
         """

From 86f0bf1c0fc2b6ebdd1e368951630f46c34fa521 Mon Sep 17 00:00:00 2001
From: ConnorSkees <39542938+ConnorSkees@users.noreply.github.com>
Date: Sun, 13 Jan 2019 12:58:30 -0500
Subject: [PATCH 26/29] Finish reverting changes

Sorry!! :anguished:
---
 test_schedule.py | 71 ++++++++++++++----------------------------------
 1 file changed, 21 insertions(+), 50 deletions(-)

diff --git a/test_schedule.py b/test_schedule.py
index a57cbbee..1ea2da08 100644
--- a/test_schedule.py
+++ b/test_schedule.py
@@ -152,11 +152,9 @@ def test_time_range_repr(self):
 
     def test_at_time(self):
         mock_job = make_mock_job()
-        assertEqual = self.assertEqual
-        assertEqual(every().day.at('10:30').do(mock_job).next_run.hour, 10)
-        assertEqual(every().day.at('10:30').do(mock_job).next_run.minute, 30)
-        assertEqual(every().day.at('10:30:50').do(mock_job).next_run.second,
-                    50)
+        assert every().day.at('10:30').do(mock_job).next_run.hour == 10
+        assert every().day.at('10:30').do(mock_job).next_run.minute == 30
+        assert every().day.at('10:30:50').do(mock_job).next_run.second == 50
 
         self.assertRaises(ScheduleValueError, every().day.at, '2:30:000001')
         self.assertRaises(ScheduleValueError, every().day.at, '::2')
@@ -201,18 +199,15 @@ def test_at_time(self):
     def test_at_time_hour(self):
         with mock_datetime(2010, 1, 6, 12, 20):
             mock_job = make_mock_job()
-            assertEqual = self.assertEqual
-            assertEqual(every().hour.at(':30').do(mock_job).next_run.hour, 12)
-            assertEqual(every().hour.at(':30').do(mock_job).next_run.minute,
-                        30)
-            assertEqual(every().hour.at(':30').do(mock_job).next_run.second, 0)
-            assertEqual(every().hour.at(':10').do(mock_job).next_run.hour, 13)
-            assertEqual(every().hour.at(':10').do(mock_job).next_run.minute,
-                        10)
-            assertEqual(every().hour.at(':10').do(mock_job).next_run.second, 0)
-            assertEqual(every().hour.at(':00').do(mock_job).next_run.hour, 13)
-            assertEqual(every().hour.at(':00').do(mock_job).next_run.minute, 0)
-            assertEqual(every().hour.at(':00').do(mock_job).next_run.second, 0)
+            assert every().hour.at(':30').do(mock_job).next_run.hour == 12
+            assert every().hour.at(':30').do(mock_job).next_run.minute == 30
+            assert every().hour.at(':30').do(mock_job).next_run.second == 0
+            assert every().hour.at(':10').do(mock_job).next_run.hour == 13
+            assert every().hour.at(':10').do(mock_job).next_run.minute == 10
+            assert every().hour.at(':10').do(mock_job).next_run.second == 0
+            assert every().hour.at(':00').do(mock_job).next_run.hour == 13
+            assert every().hour.at(':00').do(mock_job).next_run.minute == 0
+            assert every().hour.at(':00').do(mock_job).next_run.second == 0
 
             self.assertRaises(ScheduleValueError, every().hour.at, '2:30:00')
             self.assertRaises(ScheduleValueError, every().hour.at, '::2')
@@ -237,19 +232,12 @@ def test_at_time_hour(self):
     def test_at_time_minute(self):
         with mock_datetime(2010, 1, 6, 12, 20, 30):
             mock_job = make_mock_job()
-            assertEqual = self.assertEqual
-            assertEqual(every().minute.at(':40').do(mock_job).next_run.hour,
-                        12)
-            assertEqual(every().minute.at(':40').do(mock_job).next_run.minute,
-                        20)
-            assertEqual(every().minute.at(':40').do(mock_job).next_run.second,
-                        40)
-            assertEqual(every().minute.at(':10').do(mock_job).next_run.hour,
-                        12)
-            assertEqual(every().minute.at(':10').do(mock_job).next_run.minute,
-                        21)
-            assertEqual(every().minute.at(':10').do(mock_job).next_run.second,
-                        10)
+            assert every().minute.at(':40').do(mock_job).next_run.hour == 12
+            assert every().minute.at(':40').do(mock_job).next_run.minute == 20
+            assert every().minute.at(':40').do(mock_job).next_run.second == 40
+            assert every().minute.at(':10').do(mock_job).next_run.hour == 12
+            assert every().minute.at(':10').do(mock_job).next_run.minute == 21
+            assert every().minute.at(':10').do(mock_job).next_run.second == 10
 
             self.assertRaises(ScheduleValueError, every().minute.at, '::2')
             self.assertRaises(ScheduleValueError, every().minute.at, '.2')
@@ -269,24 +257,8 @@ def test_at_time_minute(self):
     def test_next_run_time(self):
         with mock_datetime(2010, 1, 6, 12, 15):
             mock_job = make_mock_job()
-            self.assertIsNone(schedule.next_run())
-
-            assertEqual = self.assertEqual
-            assertEqual(every().minute.do(mock_job).next_run.minute, 16)
-            assertEqual(every(5).minutes.do(mock_job).next_run.minute, 20)
-            assertEqual(every().hour.do(mock_job).next_run.hour, 13)
-            assertEqual(every().day.do(mock_job).next_run.day, 7)
-            assertEqual(every().day.at('09:00').do(mock_job).next_run.day, 7)
-            assertEqual(every().day.at('12:30').do(mock_job).next_run.day, 6)
-            assertEqual(every().week.do(mock_job).next_run.day, 13)
-            assertEqual(every().monday.do(mock_job).next_run.day, 11)
-            assertEqual(every().tuesday.do(mock_job).next_run.day, 12)
-            assertEqual(every().wednesday.do(mock_job).next_run.day, 13)
-            assertEqual(every().thursday.do(mock_job).next_run.day, 7)
-            assertEqual(every().friday.do(mock_job).next_run.day, 8)
-            assertEqual(every().saturday.do(mock_job).next_run.day, 9)
-            assertEqual(every().sunday.do(mock_job).next_run.day, 10)
             assert schedule.next_run() is None
+
             assert every().minute.do(mock_job).next_run.minute == 16
             assert every(5).minutes.do(mock_job).next_run.minute == 20
             assert every().hour.do(mock_job).next_run.hour == 13
@@ -439,9 +411,8 @@ def test_next_run_property(self):
             every().hour.do(hourly_job)
             assert len(schedule.jobs) == 2
             # Make sure the hourly job is first
-            self.assertEqual(schedule.next_run(),
-                             original_datetime(2010, 1, 6, 14, 16))
-            self.assertEqual(schedule.idle_seconds(), 60 * 60)
+            assert schedule.next_run() == original_datetime(2010, 1, 6, 14, 16)
+            assert schedule.idle_seconds() == 60 * 60
             assert schedule.next_run() == original_datetime(2010, 1, 6, 14, 16)
             assert schedule.idle_seconds() == 60 * 60
 

From 0a7ef107a1d0bd006316ee3b95c3d3d849f3191b Mon Sep 17 00:00:00 2001
From: ConnorSkees <39542938+ConnorSkees@users.noreply.github.com>
Date: Sun, 13 Jan 2019 13:09:18 -0500
Subject: [PATCH 27/29] Remove unreachable code

The regular expression above makes it impossible to have a number above 59 or below 0, so these exceptions can never be raised
---
 schedule/__init__.py | 4 ----
 1 file changed, 4 deletions(-)

diff --git a/schedule/__init__.py b/schedule/__init__.py
index 9e8d157e..554af9a6 100644
--- a/schedule/__init__.py
+++ b/schedule/__init__.py
@@ -403,11 +403,7 @@ def at(self, time_str):
             hour = 0
             minute = 0
         minute = int(minute)
-        if 0 > minute or minute > 60:
-            raise ScheduleValueError("Invalid number of minutes.")
         second = int(second)
-        if 0 > second or second > 60:
-            raise ScheduleValueError("Invalid number of seconds.")
         self.at_time = datetime.time(hour, minute, second)
         return self
 

From 62332418f31e34c03e884c86b7548d4413b089db Mon Sep 17 00:00:00 2001
From: ConnorSkees <39542938+ConnorSkees@users.noreply.github.com>
Date: Mon, 14 Jan 2019 19:45:02 -0500
Subject: [PATCH 28/29] Remove duplicated code

Accidentally added when reverting
---
 test_schedule.py | 17 -----------------
 1 file changed, 17 deletions(-)

diff --git a/test_schedule.py b/test_schedule.py
index 1ea2da08..6da3cbbf 100644
--- a/test_schedule.py
+++ b/test_schedule.py
@@ -163,10 +163,6 @@ def test_at_time(self):
         self.assertRaises(ScheduleValueError, every().day.at, ':2')
         self.assertRaises(ScheduleValueError, every().day.at, ' 2:30:00')
         self.assertRaises(ScheduleValueError, every().do, lambda: 0)
-        assert every().day.at('10:30').do(mock_job).next_run.hour == 10
-        assert every().day.at('10:30').do(mock_job).next_run.minute == 30
-        assert every().day.at('10:30:50').do(mock_job).next_run.second == 50
-
         self.assertRaises(TypeError, every().day.at, 2)
 
         # without a context manager, it incorrectly raises an error because
@@ -217,16 +213,6 @@ def test_at_time_hour(self):
             self.assertRaises(ScheduleValueError, every().hour.at, "61:00")
             self.assertRaises(ScheduleValueError, every().hour.at, "00:61")
             self.assertRaises(ScheduleValueError, every().hour.at, "01:61")
-            assert every().hour.at(':30').do(mock_job).next_run.hour == 12
-            assert every().hour.at(':30').do(mock_job).next_run.minute == 30
-            assert every().hour.at(':30').do(mock_job).next_run.second == 0
-            assert every().hour.at(':10').do(mock_job).next_run.hour == 13
-            assert every().hour.at(':10').do(mock_job).next_run.minute == 10
-            assert every().hour.at(':10').do(mock_job).next_run.second == 0
-            assert every().hour.at(':00').do(mock_job).next_run.hour == 13
-            assert every().hour.at(':00').do(mock_job).next_run.minute == 0
-            assert every().hour.at(':00').do(mock_job).next_run.second == 0
-
             self.assertRaises(TypeError, every().hour.at, 2)
 
     def test_at_time_minute(self):
@@ -258,7 +244,6 @@ def test_next_run_time(self):
         with mock_datetime(2010, 1, 6, 12, 15):
             mock_job = make_mock_job()
             assert schedule.next_run() is None
-
             assert every().minute.do(mock_job).next_run.minute == 16
             assert every(5).minutes.do(mock_job).next_run.minute == 20
             assert every().hour.do(mock_job).next_run.hour == 13
@@ -413,8 +398,6 @@ def test_next_run_property(self):
             # Make sure the hourly job is first
             assert schedule.next_run() == original_datetime(2010, 1, 6, 14, 16)
             assert schedule.idle_seconds() == 60 * 60
-            assert schedule.next_run() == original_datetime(2010, 1, 6, 14, 16)
-            assert schedule.idle_seconds() == 60 * 60
 
     def test_cancel_job(self):
         def stop_job():

From e5e00c6e9ef146e5125ef72486fffb32790852c8 Mon Sep 17 00:00:00 2001
From: ConnorSkees <39542938+ConnorSkees@users.noreply.github.com>
Date: Mon, 14 Jan 2019 19:48:05 -0500
Subject: [PATCH 29/29] Delete more duplicated code

---
 test_schedule.py | 7 -------
 1 file changed, 7 deletions(-)

diff --git a/test_schedule.py b/test_schedule.py
index 6da3cbbf..9a257507 100644
--- a/test_schedule.py
+++ b/test_schedule.py
@@ -231,13 +231,6 @@ def test_at_time_minute(self):
             self.assertRaises(ScheduleValueError, every().minute.at, '2:30:00')
             self.assertRaises(ScheduleValueError, every().minute.at, '2:30')
             self.assertRaises(ScheduleValueError, every().minute.at, ' :30')
-            assert every().minute.at(':40').do(mock_job).next_run.hour == 12
-            assert every().minute.at(':40').do(mock_job).next_run.minute == 20
-            assert every().minute.at(':40').do(mock_job).next_run.second == 40
-            assert every().minute.at(':10').do(mock_job).next_run.hour == 12
-            assert every().minute.at(':10').do(mock_job).next_run.minute == 21
-            assert every().minute.at(':10').do(mock_job).next_run.second == 10
-
             self.assertRaises(TypeError, every().minute.at, 2)
 
     def test_next_run_time(self):