Test cleanups and test suite configuration improvements

4 files changed, 135 insertions, 160 deletions

diff --git a/tests/test_job.py b/tests/test_job.py
index fee6c4e..6f78551 100644
--- a/tests/test_job.py
+++ b/tests/test_job.py
@@ -1,6 +1,5 @@
 from datetime import datetime, timedelta
 
-from dateutil.tz import tzoffset
 import pytest
 import six
 
@@ -14,43 +13,26 @@ try:
 except ImportError:
     from mock import MagicMock
 
-local_tz = tzoffset('DUMMYTZ', 3600)
-run_time = datetime(2010, 12, 13, 0, 8, 0, tzinfo=local_tz)
-job_defaults = {'trigger': 'date', 'executor': 'default', 'trigger_args': {'run_date': run_time, 'timezone': local_tz},
-                'func': '%s:dummyfunc' % __name__, 'args': (), 'kwargs': {}, 'id': 'testid', 'misfire_grace_time': 1,
-                'coalesce': False, 'name': None, 'max_runs': None, 'max_instances': 1}
-
 
 def dummyfunc():
     pass
 
 
-def create_job(**kwargs):
-    job_kwargs = job_defaults.copy()
-    job_kwargs.update(kwargs)
-    return Job(**job_kwargs)
-
-
 @pytest.fixture
-def trigger():
-    return DateTrigger(local_tz, run_time)
-
-
-@pytest.fixture
-def job():
-    return create_job()
+def job(create_job):
+    return create_job(func=dummyfunc)
 
 
 class TestJob(object):
-    def test_job_func(self):
+    def test_job_func(self, create_job):
         job = create_job(func=dummyfunc)
         assert job.func is dummyfunc
 
-    def test_job_func_ref(self):
+    def test_job_func_ref(self, create_job):
         job = create_job(func='%s:dummyfunc' % __name__)
         assert job.func is dummyfunc
 
-    def test_job_bad_func(self):
+    def test_job_bad_func(self, create_job):
         exc = pytest.raises(TypeError, create_job, func=object())
         assert 'textual reference' in str(exc.value)
 
@@ -58,11 +40,12 @@ class TestJob(object):
         exc = pytest.raises(ValueError, job.__setstate__, {'version': 9999})
         assert 'version' in str(exc.value)
 
-    def test_get_run_times(self, job):
+    def test_get_run_times(self, create_job, timezone):
+        run_time = datetime(2010, 12, 13, 0, 8, 0, tzinfo=timezone)
         expected_times = [run_time + timedelta(seconds=1),
                           run_time + timedelta(seconds=2)]
-        job = create_job(trigger='interval', trigger_args={'seconds': 1, 'timezone': local_tz, 'start_date': run_time},
-                         next_run_time=expected_times[0])
+        job = create_job(trigger='interval', trigger_args={'seconds': 1, 'timezone': timezone, 'start_date': run_time},
+                         next_run_time=expected_times[0], func=dummyfunc)
         run_times = job.get_run_times(run_time)
         assert run_times == []
 
@@ -72,15 +55,14 @@ class TestJob(object):
         run_times = job.get_run_times(expected_times[1])
         assert run_times == expected_times
 
-    def test_getstate(self, trigger):
-        job = create_job(trigger=trigger, trigger_args=None)
+    def test_getstate(self, job):
         state = job.__getstate__()
-        assert state == dict(version=1, trigger=trigger, executor='default', func='tests.test_job:dummyfunc',
+        assert state == dict(version=1, trigger=job.trigger, executor='default', func='tests.test_job:dummyfunc',
                              name='dummyfunc', args=(), kwargs={}, id='testid', misfire_grace_time=1, coalesce=False,
                              max_runs=None, max_instances=1, runs=0, next_run_time=None)
 
-    def test_setstate(self, job):
-        trigger = DateTrigger(local_tz, '2010-12-14 13:05:00')
+    def test_setstate(self, job, timezone):
+        trigger = DateTrigger(timezone, '2010-12-14 13:05:00')
         state = dict(version=1, trigger=trigger, executor='dummyexecutor', func='tests.test_job:dummyfunc',
                      name='testjob.dummyfunc', args=[], kwargs={}, id='other_id', misfire_grace_time=2, max_runs=2,
                      coalesce=True, max_instances=2, runs=1, next_run_time=None)
@@ -95,10 +77,12 @@ class TestJob(object):
         assert job.runs == 1
         assert job.next_run_time is None
 
-    def test_jobs_equal(self, job):
+    def test_jobs_equal(self, create_job, timezone):
+        job = create_job(func=dummyfunc)
         assert job == job
 
-        job2 = create_job(trigger=DateTrigger(local_tz, run_time), id='otherid', func=lambda: None)
+        job2 = create_job(trigger='date', id='otherid', trigger_args={'run_date': datetime.now(), 'timezone': timezone},
+                          func=dummyfunc)
         assert not job == job2
 
         job2.id = job.id
@@ -166,9 +150,9 @@ class TestJobHandle(object):
         assert repr(jobhandle) == '<JobHandle (id=testid name=dummyfunc)>'
 
     def test_jobhandle_str(self, jobhandle):
-        assert str(jobhandle) == 'dummyfunc (trigger: date[2010-12-13 00:08:00 DUMMYTZ], next run at: None)'
+        assert str(jobhandle) == 'dummyfunc (trigger: date[2011-04-03 18:40:00 DUMMYTZ], next run at: None)'
 
     @maxpython(3, 0)
     def test_jobhandle_unicode(self, jobhandle):
         assert jobhandle.__unicode__() == six.u(
-            'dummyfunc (trigger: date[2010-12-13 00:08:00 DUMMYTZ], next run at: None)')
+            'dummyfunc (trigger: date[2011-04-03 18:40:00 DUMMYTZ], next run at: None)')
diff --git a/tests/test_jobstores.py b/tests/test_jobstores.py
index 5c87c94..740ce54 100644
--- a/tests/test_jobstores.py
+++ b/tests/test_jobstores.py
@@ -8,10 +8,7 @@ from apscheduler.jobstores.base import JobLookupError, ConflictingIdError, Trans
 from apscheduler.triggers.date import DateTrigger
 from apscheduler.job import Job
 
-#local_tz = tzoffset('DUMMYTZ', 3600)
 run_time = datetime(2999, 1, 1)
-#job_defaults = {'args': (), 'kwargs': {},  'misfire_grace_time': 1, 'coalesce': False, 'name': None, 'max_runs': None,
-#                'max_instances': 1}
 
 
 def dummy_job():
diff --git a/tests/test_triggers.py b/tests/test_triggers.py
index 70079f0..92f299d 100644
--- a/tests/test_triggers.py
+++ b/tests/test_triggers.py
@@ -7,195 +7,193 @@ from apscheduler.triggers.cron import CronTrigger
 from apscheduler.triggers.date import DateTrigger
 from apscheduler.triggers.interval import IntervalTrigger
 
-local_tz = tzoffset('DUMMYTZ', 3600)
-
 
 class TestCronTrigger(object):
-    def test_cron_trigger_1(self):
-        trigger = CronTrigger(local_tz, year='2009/2', month='1/3', day='5-13')
+    def test_cron_trigger_1(self, timezone):
+        trigger = CronTrigger(timezone, year='2009/2', month='1/3', day='5-13')
         assert repr(trigger) == "<CronTrigger (year='2009/2', month='1/3', day='5-13')>"
         assert str(trigger) == "cron[year='2009/2', month='1/3', day='5-13']"
-        start_date = datetime(2008, 12, 1, tzinfo=local_tz)
-        correct_next_date = datetime(2009, 1, 5, tzinfo=local_tz)
+        start_date = datetime(2008, 12, 1, tzinfo=timezone)
+        correct_next_date = datetime(2009, 1, 5, tzinfo=timezone)
         assert trigger.get_next_fire_time(start_date) == correct_next_date
 
-    def test_cron_trigger_2(self):
-        trigger = CronTrigger(local_tz, year='2009/2', month='1/3', day='5-13')
-        start_date = datetime(2009, 10, 14, tzinfo=local_tz)
-        correct_next_date = datetime(2011, 1, 5, tzinfo=local_tz)
+    def test_cron_trigger_2(self, timezone):
+        trigger = CronTrigger(timezone, year='2009/2', month='1/3', day='5-13')
+        start_date = datetime(2009, 10, 14, tzinfo=timezone)
+        correct_next_date = datetime(2011, 1, 5, tzinfo=timezone)
         assert trigger.get_next_fire_time(start_date) == correct_next_date
 
-    def test_cron_trigger_3(self):
-        trigger = CronTrigger(local_tz, year='2009', month='2', hour='8-10')
+    def test_cron_trigger_3(self, timezone):
+        trigger = CronTrigger(timezone, year='2009', month='2', hour='8-10')
         assert repr(trigger) == "<CronTrigger (year='2009', month='2', hour='8-10')>"
-        start_date = datetime(2009, 1, 1, tzinfo=local_tz)
-        correct_next_date = datetime(2009, 2, 1, 8, tzinfo=local_tz)
+        start_date = datetime(2009, 1, 1, tzinfo=timezone)
+        correct_next_date = datetime(2009, 2, 1, 8, tzinfo=timezone)
         assert trigger.get_next_fire_time(start_date) == correct_next_date
 
-    def test_cron_trigger_4(self):
-        trigger = CronTrigger(local_tz, year='2012', month='2', day='last')
+    def test_cron_trigger_4(self, timezone):
+        trigger = CronTrigger(timezone, year='2012', month='2', day='last')
         assert repr(trigger) == "<CronTrigger (year='2012', month='2', day='last')>"
-        start_date = datetime(2012, 2, 1, tzinfo=local_tz)
-        correct_next_date = datetime(2012, 2, 29, tzinfo=local_tz)
+        start_date = datetime(2012, 2, 1, tzinfo=timezone)
+        correct_next_date = datetime(2012, 2, 29, tzinfo=timezone)
         assert trigger.get_next_fire_time(start_date) == correct_next_date
 
-    def test_cron_zero_value(self):
-        trigger = CronTrigger(local_tz, year=2009, month=2, hour=0)
+    def test_cron_zero_value(self, timezone):
+        trigger = CronTrigger(timezone, year=2009, month=2, hour=0)
         assert repr(trigger) == "<CronTrigger (year='2009', month='2', hour='0')>"
 
-    def test_cron_year_list(self):
-        trigger = CronTrigger(local_tz, year='2009,2008')
+    def test_cron_year_list(self, timezone):
+        trigger = CronTrigger(timezone, year='2009,2008')
         assert repr(trigger) == "<CronTrigger (year='2009,2008')>"
         assert str(trigger) == "cron[year='2009,2008']"
-        start_date = datetime(2009, 1, 1, tzinfo=local_tz)
-        correct_next_date = datetime(2009, 1, 1, tzinfo=local_tz)
+        start_date = datetime(2009, 1, 1, tzinfo=timezone)
+        correct_next_date = datetime(2009, 1, 1, tzinfo=timezone)
         assert trigger.get_next_fire_time(start_date) == correct_next_date
 
-    def test_cron_start_date(self):
-        trigger = CronTrigger(local_tz, year='2009', month='2', hour='8-10',
+    def test_cron_start_date(self, timezone):
+        trigger = CronTrigger(timezone, year='2009', month='2', hour='8-10',
                               start_date='2009-02-03 11:00:00')
         assert repr(trigger) == \
             "<CronTrigger (year='2009', month='2', hour='8-10', start_date='2009-02-03 11:00:00 DUMMYTZ')>"
         assert str(trigger) == "cron[year='2009', month='2', hour='8-10']"
-        start_date = datetime(2009, 1, 1, tzinfo=local_tz)
-        correct_next_date = datetime(2009, 2, 4, 8, tzinfo=local_tz)
+        start_date = datetime(2009, 1, 1, tzinfo=timezone)
+        correct_next_date = datetime(2009, 2, 4, 8, tzinfo=timezone)
         assert trigger.get_next_fire_time(start_date) == correct_next_date
 
-    def test_cron_weekday_overlap(self):
-        trigger = CronTrigger(local_tz, year=2009, month=1, day='6-10',
+    def test_cron_weekday_overlap(self, timezone):
+        trigger = CronTrigger(timezone, year=2009, month=1, day='6-10',
                               day_of_week='2-4')
         assert repr(trigger) == "<CronTrigger (year='2009', month='1', day='6-10', day_of_week='2-4')>"
         assert str(trigger) == "cron[year='2009', month='1', day='6-10', day_of_week='2-4']"
-        start_date = datetime(2009, 1, 1, tzinfo=local_tz)
-        correct_next_date = datetime(2009, 1, 7, tzinfo=local_tz)
+        start_date = datetime(2009, 1, 1, tzinfo=timezone)
+        correct_next_date = datetime(2009, 1, 7, tzinfo=timezone)
         assert trigger.get_next_fire_time(start_date) == correct_next_date
 
-    def test_cron_weekday_nomatch(self):
-        trigger = CronTrigger(local_tz, year=2009, month=1, day='6-10', day_of_week='0,6')
+    def test_cron_weekday_nomatch(self, timezone):
+        trigger = CronTrigger(timezone, year=2009, month=1, day='6-10', day_of_week='0,6')
         assert repr(trigger) == "<CronTrigger (year='2009', month='1', day='6-10', day_of_week='0,6')>"
         assert str(trigger) == "cron[year='2009', month='1', day='6-10', day_of_week='0,6']"
-        start_date = datetime(2009, 1, 1, tzinfo=local_tz)
+        start_date = datetime(2009, 1, 1, tzinfo=timezone)
         correct_next_date = None
         assert trigger.get_next_fire_time(start_date) == correct_next_date
 
-    def test_cron_weekday_positional(self):
-        trigger = CronTrigger(local_tz, year=2009, month=1, day='4th wed')
+    def test_cron_weekday_positional(self, timezone):
+        trigger = CronTrigger(timezone, year=2009, month=1, day='4th wed')
         assert repr(trigger) == "<CronTrigger (year='2009', month='1', day='4th wed')>"
         assert str(trigger) == "cron[year='2009', month='1', day='4th wed']"
-        start_date = datetime(2009, 1, 1, tzinfo=local_tz)
-        correct_next_date = datetime(2009, 1, 28, tzinfo=local_tz)
+        start_date = datetime(2009, 1, 1, tzinfo=timezone)
+        correct_next_date = datetime(2009, 1, 28, tzinfo=timezone)
         assert trigger.get_next_fire_time(start_date) == correct_next_date
 
-    def test_week_1(self):
-        trigger = CronTrigger(local_tz, year=2009, month=2, week=8)
+    def test_week_1(self, timezone):
+        trigger = CronTrigger(timezone, year=2009, month=2, week=8)
         assert repr(trigger) == "<CronTrigger (year='2009', month='2', week='8')>"
         assert str(trigger) == "cron[year='2009', month='2', week='8']"
-        start_date = datetime(2009, 1, 1, tzinfo=local_tz)
-        correct_next_date = datetime(2009, 2, 16, tzinfo=local_tz)
+        start_date = datetime(2009, 1, 1, tzinfo=timezone)
+        correct_next_date = datetime(2009, 2, 16, tzinfo=timezone)
         assert trigger.get_next_fire_time(start_date) == correct_next_date
 
-    def test_week_2(self):
-        trigger = CronTrigger(local_tz, year=2009, week=15, day_of_week=2)
+    def test_week_2(self, timezone):
+        trigger = CronTrigger(timezone, year=2009, week=15, day_of_week=2)
         assert repr(trigger) == "<CronTrigger (year='2009', week='15', day_of_week='2')>"
         assert str(trigger) == "cron[year='2009', week='15', day_of_week='2']"
-        start_date = datetime(2009, 1, 1, tzinfo=local_tz)
-        correct_next_date = datetime(2009, 4, 8, tzinfo=local_tz)
+        start_date = datetime(2009, 1, 1, tzinfo=timezone)
+        correct_next_date = datetime(2009, 4, 8, tzinfo=timezone)
         assert trigger.get_next_fire_time(start_date) == correct_next_date
 
-    def test_cron_extra_coverage(self):
+    def test_cron_extra_coverage(self, timezone):
         # This test has no value other than patching holes in test coverage
-        trigger = CronTrigger(local_tz, day='6,8')
+        trigger = CronTrigger(timezone, day='6,8')
         assert repr(trigger) == "<CronTrigger (day='6,8')>"
         assert str(trigger) == "cron[day='6,8']"
-        start_date = datetime(2009, 12, 31, tzinfo=local_tz)
-        correct_next_date = datetime(2010, 1, 6, tzinfo=local_tz)
+        start_date = datetime(2009, 12, 31, tzinfo=timezone)
+        correct_next_date = datetime(2010, 1, 6, tzinfo=timezone)
         assert trigger.get_next_fire_time(start_date) == correct_next_date
 
-    def test_cron_faulty_expr(self):
-        pytest.raises(ValueError, CronTrigger, local_tz, year='2009-fault')
+    def test_cron_faulty_expr(self, timezone):
+        pytest.raises(ValueError, CronTrigger, timezone, year='2009-fault')
 
-    def test_cron_increment_weekday(self):
+    def test_cron_increment_weekday(self, timezone):
         # Makes sure that incrementing the weekday field in the process of
         # calculating the next matching date won't cause problems
-        trigger = CronTrigger(local_tz, hour='5-6')
+        trigger = CronTrigger(timezone, hour='5-6')
         assert repr(trigger) == "<CronTrigger (hour='5-6')>"
         assert str(trigger) == "cron[hour='5-6']"
-        start_date = datetime(2009, 9, 25, 7, tzinfo=local_tz)
-        correct_next_date = datetime(2009, 9, 26, 5, tzinfo=local_tz)
+        start_date = datetime(2009, 9, 25, 7, tzinfo=timezone)
+        correct_next_date = datetime(2009, 9, 26, 5, tzinfo=timezone)
         assert trigger.get_next_fire_time(start_date) == correct_next_date
 
-    def test_cron_bad_kwarg(self):
-        pytest.raises(TypeError, CronTrigger, local_tz, second=0, third=1)
+    def test_cron_bad_kwarg(self, timezone):
+        pytest.raises(TypeError, CronTrigger, timezone, second=0, third=1)
 
-    def test_different_tz(self):
+    def test_different_tz(self, timezone):
         alter_tz = tzoffset('ALTERNATE', -3600)
-        trigger = CronTrigger(local_tz, year=2009, week=15, day_of_week=2)
+        trigger = CronTrigger(timezone, year=2009, week=15, day_of_week=2)
         assert repr(trigger) == "<CronTrigger (year='2009', week='15', day_of_week='2')>"
         assert str(trigger) == "cron[year='2009', week='15', day_of_week='2']"
         start_date = datetime(2008, 12, 31, 22, tzinfo=alter_tz)
-        correct_next_date = datetime(2009, 4, 8, tzinfo=local_tz)
+        correct_next_date = datetime(2009, 4, 8, tzinfo=timezone)
         assert trigger.get_next_fire_time(start_date) == correct_next_date
 
 
 class TestDateTrigger(object):
-    def test_date_trigger_earlier(self):
-        fire_date = datetime(2009, 7, 6, tzinfo=local_tz)
-        trigger = DateTrigger(local_tz, fire_date)
+    def test_date_trigger_earlier(self, timezone):
+        fire_date = datetime(2009, 7, 6, tzinfo=timezone)
+        trigger = DateTrigger(timezone, fire_date)
         assert repr(trigger) == "<DateTrigger (run_date='2009-07-06 00:00:00 DUMMYTZ')>"
         assert str(trigger) == "date[2009-07-06 00:00:00 DUMMYTZ]"
-        start_date = datetime(2008, 12, 1, tzinfo=local_tz)
+        start_date = datetime(2008, 12, 1, tzinfo=timezone)
         assert trigger.get_next_fire_time(start_date) == fire_date
 
-    def test_date_trigger_exact(self):
-        fire_date = datetime(2009, 7, 6, tzinfo=local_tz)
-        trigger = DateTrigger(local_tz, fire_date)
-        start_date = datetime(2009, 7, 6, tzinfo=local_tz)
+    def test_date_trigger_exact(self, timezone):
+        fire_date = datetime(2009, 7, 6, tzinfo=timezone)
+        trigger = DateTrigger(timezone, fire_date)
+        start_date = datetime(2009, 7, 6, tzinfo=timezone)
         assert trigger.get_next_fire_time(start_date) == fire_date
 
-    def test_date_trigger_later(self):
-        fire_date = datetime(2009, 7, 6, tzinfo=local_tz)
-        trigger = DateTrigger(local_tz, fire_date)
-        start_date = datetime(2009, 7, 7, tzinfo=local_tz)
+    def test_date_trigger_later(self, timezone):
+        fire_date = datetime(2009, 7, 6, tzinfo=timezone)
+        trigger = DateTrigger(timezone, fire_date)
+        start_date = datetime(2009, 7, 7, tzinfo=timezone)
         assert trigger.get_next_fire_time(start_date) is None
 
-    def test_date_trigger_text(self):
-        trigger = DateTrigger(local_tz, '2009-7-6')
-        start_date = datetime(2009, 7, 6, tzinfo=local_tz)
-        assert trigger.get_next_fire_time(start_date) == datetime(2009, 7, 6, tzinfo=local_tz)
+    def test_date_trigger_text(self, timezone):
+        trigger = DateTrigger(timezone, '2009-7-6')
+        start_date = datetime(2009, 7, 6, tzinfo=timezone)
+        assert trigger.get_next_fire_time(start_date) == datetime(2009, 7, 6, tzinfo=timezone)
 
-    def test_different_tz(self):
+    def test_different_tz(self, timezone):
         alter_tz = tzoffset('ALTERNATE', -3600)
         fire_date = datetime(2009, 7, 5, 22, tzinfo=alter_tz)
-        trigger = DateTrigger(local_tz, fire_date)
-        start_date = datetime(2009, 7, 6, tzinfo=local_tz)
+        trigger = DateTrigger(timezone, fire_date)
+        start_date = datetime(2009, 7, 6, tzinfo=timezone)
         assert trigger.get_next_fire_time(start_date) == fire_date
 
 
 class TestIntervalTrigger(object):
     @pytest.fixture()
-    def trigger(self):
-        return IntervalTrigger(local_tz, seconds=1, start_date=datetime(2009, 8, 4, second=2))
+    def trigger(self, timezone):
+        return IntervalTrigger(timezone, seconds=1, start_date=datetime(2009, 8, 4, second=2))
 
-    def test_interval_invalid_interval(self):
-        pytest.raises(TypeError, IntervalTrigger, local_tz, '1-6')
+    def test_interval_invalid_interval(self, timezone):
+        pytest.raises(TypeError, IntervalTrigger, timezone, '1-6')
 
-    def test_interval_repr(self, trigger):
+    def test_interval_repr(self, trigger, timezone):
         assert repr(trigger) == \
             "<IntervalTrigger (interval=datetime.timedelta(0, 1), start_date='2009-08-04 00:00:02 DUMMYTZ')>"
         assert str(trigger) == "interval[0:00:01]"
 
-    def test_interval_before(self, trigger):
-        start_date = datetime(2009, 8, 4, tzinfo=local_tz)
-        correct_next_date = datetime(2009, 8, 4, second=2, tzinfo=local_tz)
+    def test_interval_before(self, trigger, timezone):
+        start_date = datetime(2009, 8, 4, tzinfo=timezone)
+        correct_next_date = datetime(2009, 8, 4, second=2, tzinfo=timezone)
         assert trigger.get_next_fire_time(start_date) == correct_next_date
 
-    def test_interval_within(self, trigger):
-        start_date = datetime(2009, 8, 4, second=2, microsecond=1000, tzinfo=local_tz)
-        correct_next_date = datetime(2009, 8, 4, second=3, tzinfo=local_tz)
+    def test_interval_within(self, trigger, timezone):
+        start_date = datetime(2009, 8, 4, second=2, microsecond=1000, tzinfo=timezone)
+        correct_next_date = datetime(2009, 8, 4, second=3, tzinfo=timezone)
         assert trigger.get_next_fire_time(start_date) == correct_next_date
 
-    def test_different_tz(self, trigger):
+    def test_different_tz(self, trigger, timezone):
         alter_tz = tzoffset('ALTERNATE', -3600)
         start_date = datetime(2009, 8, 3, 22, second=2, microsecond=1000, tzinfo=alter_tz)
-        correct_next_date = datetime(2009, 8, 4, second=3, tzinfo=local_tz)
+        correct_next_date = datetime(2009, 8, 4, second=3, tzinfo=timezone)
         assert trigger.get_next_fire_time(start_date) == correct_next_date
diff --git a/tests/test_util.py b/tests/test_util.py
index 03e3c34..d61cac9 100644
--- a/tests/test_util.py
+++ b/tests/test_util.py
@@ -1,9 +1,7 @@
 # coding: utf-8
 from datetime import date, datetime, timedelta, tzinfo
-import time
-import os
-import shelve
 from functools import partial
+import shelve
 
 from dateutil.tz import tzoffset, gettz
 import pytest
@@ -11,8 +9,6 @@ import pytest
 from apscheduler.util import *
 from tests.conftest import minpython
 
-local_tz = tzoffset('DUMMYTZ', 3600)
-
 
 class DummyClass(object):
     def meth(self):
@@ -86,51 +82,51 @@ def test_astimezone_fail():
     pytest.raises(TypeError, astimezone, 4)
 
 
-def test_convert_datetime_date():
+def test_convert_datetime_date(timezone):
     dateval = date(2009, 8, 1)
-    datetimeval = convert_to_datetime(dateval, local_tz, None)
+    datetimeval = convert_to_datetime(dateval, timezone, None)
     correct_datetime = datetime(2009, 8, 1)
     assert isinstance(datetimeval, datetime)
-    assert datetimeval == correct_datetime.replace(tzinfo=local_tz)
+    assert datetimeval == correct_datetime.replace(tzinfo=timezone)
 
 
-def test_convert_datetime_passthrough():
+def test_convert_datetime_passthrough(timezone):
     datetimeval = datetime(2009, 8, 1, 5, 6, 12)
-    convertedval = convert_to_datetime(datetimeval, local_tz, None)
-    assert convertedval == datetimeval.replace(tzinfo=local_tz)
+    convertedval = convert_to_datetime(datetimeval, timezone, None)
+    assert convertedval == datetimeval.replace(tzinfo=timezone)
 
 
-def test_convert_datetime_text1():
-    convertedval = convert_to_datetime('2009-8-1', local_tz, None)
-    assert convertedval == datetime(2009, 8, 1, tzinfo=local_tz)
+def test_convert_datetime_text1(timezone):
+    convertedval = convert_to_datetime('2009-8-1', timezone, None)
+    assert convertedval == datetime(2009, 8, 1, tzinfo=timezone)
 
 
-def test_convert_datetime_text2():
-    convertedval = convert_to_datetime('2009-8-1 5:16:12', local_tz, None)
-    assert convertedval == datetime(2009, 8, 1, 5, 16, 12, tzinfo=local_tz)
+def test_convert_datetime_text2(timezone):
+    convertedval = convert_to_datetime('2009-8-1 5:16:12', timezone, None)
+    assert convertedval == datetime(2009, 8, 1, 5, 16, 12, tzinfo=timezone)
 
 
-def test_datestring_parse_datetime_micro():
-    convertedval = convert_to_datetime('2009-8-1 5:16:12.843821', local_tz, None)
-    assert convertedval == datetime(2009, 8, 1, 5, 16, 12, 843821, tzinfo=local_tz)
+def test_datestring_parse_datetime_micro(timezone):
+    convertedval = convert_to_datetime('2009-8-1 5:16:12.843821', timezone, None)
+    assert convertedval == datetime(2009, 8, 1, 5, 16, 12, 843821, tzinfo=timezone)
 
 
-def test_existing_tzinfo():
+def test_existing_tzinfo(timezone):
     alter_tz = tzoffset('ALTERNATE', -3600)
     dateval = datetime(2009, 8, 1, tzinfo=alter_tz)
-    assert convert_to_datetime(dateval, local_tz, None) == dateval
+    assert convert_to_datetime(dateval, timezone, None) == dateval
 
 
-def test_convert_datetime_invalid():
-    pytest.raises(TypeError, convert_to_datetime, 995302092123, local_tz, None)
+def test_convert_datetime_invalid(timezone):
+    pytest.raises(TypeError, convert_to_datetime, 995302092123, timezone, None)
 
 
-def test_convert_datetime_invalid_str():
-    pytest.raises(ValueError, convert_to_datetime, '19700-12-1', local_tz, None)
+def test_convert_datetime_invalid_str(timezone):
+    pytest.raises(ValueError, convert_to_datetime, '19700-12-1', timezone, None)
 
 
-def test_datetime_to_utc_timestamp():
-    dt = datetime(2014, 3, 12, 5, tzinfo=local_tz)
+def test_datetime_to_utc_timestamp(timezone):
+    dt = datetime(2014, 3, 12, 5, tzinfo=timezone)
     timestamp = datetime_to_utc_timestamp(dt)
     dt2 = utc_timestamp_to_datetime(timestamp)
     assert dt2 == dt