From 8f72f4d7c95b8e209156b04cfe730043ed765909 Mon Sep 17 00:00:00 2001 From: Ali-Akber Saifee Date: Mon, 25 May 2020 17:40:28 -0700 Subject: [PATCH] Convert tests to use pytest --- .github/workflows/main.yml | 2 +- pytest.ini | 8 + requirements/test.txt | 4 +- tests/test_context_mgr.py | 460 +++++++++++++++++++------------------ tests/test_runners.py | 108 +++++---- tests/test_utils.py | 61 +++-- 6 files changed, 329 insertions(+), 314 deletions(-) create mode 100644 pytest.ini diff --git a/.github/workflows/main.yml b/.github/workflows/main.yml index 09023fa..162117a 100644 --- a/.github/workflows/main.yml +++ b/.github/workflows/main.yml @@ -31,7 +31,7 @@ jobs: pip install -r requirements/ci.txt - name: Tests run: | - nosetests --with-cov + pytest - name: Post Coverage env: COVERALLS_REPO_TOKEN: ${{ secrets.COVERALLS_REPO_TOKEN }} diff --git a/pytest.ini b/pytest.ini new file mode 100644 index 0000000..7c0bc17 --- /dev/null +++ b/pytest.ini @@ -0,0 +1,8 @@ +[pytest] +norecursedirs = build *.egg +addopts = + --verbose + --tb=short + --capture=no + -rfEsxX + --cov=hiro diff --git a/requirements/test.txt b/requirements/test.txt index 363eab1..52bbc64 100644 --- a/requirements/test.txt +++ b/requirements/test.txt @@ -1,3 +1,3 @@ -r main.txt -nose -nose-cov +pytest +pytest-cov diff --git a/tests/test_context_mgr.py b/tests/test_context_mgr.py index 0b99534..1301c5b 100644 --- a/tests/test_context_mgr.py +++ b/tests/test_context_mgr.py @@ -1,5 +1,4 @@ import os -import unittest import time from datetime import datetime, date, timedelta import math @@ -8,243 +7,246 @@ from hiro import Timeline from hiro.utils import timedelta_to_seconds from tests.emulated_modules import sample_1, sample_2, sample_3 +import pytest -class TestScaledContext(unittest.TestCase): - - def test_accelerate(self): - s = time.time() - with Timeline(100): - time.sleep(10) - self.assertTrue(time.time() - s < 10) - - def test_deccelerate(self): - s = time.time() - with Timeline(0.5): - time.sleep(0.25) - self.assertTrue(time.time() - s > 0.25) - - def test_check_time(self): - start = time.time() - with Timeline(100): - for i in range(0, 10): - time.sleep(1) - delta = time.time() - (start + (i + 1) * 100) - self.assertTrue(delta <= 1.5, delta) - - def test_utc(self): - start_local = datetime.now() - start_utc = datetime.utcnow() - with Timeline(100000): - time.sleep(60 * 60) - self.assertEquals( - math.ceil( - (datetime.now() - datetime.utcnow()).seconds / 60.0 / 60.0 - ), - math.ceil( - (start_local - start_utc).seconds / 60.0 / 60.0 - ) - ) - - time.sleep(60 * 60 * 23) - self.assertEquals((datetime.now() - start_local).days, 1) - self.assertEquals((datetime.utcnow() - start_utc).days, 1) - - -class TestTimelineContext(unittest.TestCase): - def test_forward(self): - original = date.today() - with Timeline() as timeline: - timeline.forward(86400) - self.assertEquals((date.today() - original).days, 1) - - def test_rewind(self): - original_day = date.today() - original_datetime = datetime.now() - with Timeline() as timeline: - timeline.rewind(86400) - self.assertEquals((original_day - date.today()).days, 1) - timeline.forward(timedelta(days=1)) - self.assertEquals((original_day - date.today()).days, 0) - timeline.rewind(timedelta(days=1)) - amount = (original_datetime - datetime.now()) - amount_seconds = timedelta_to_seconds(amount) - self.assertTrue(int(amount_seconds) >= 86399, amount_seconds) - - def test_freeze(self): - with Timeline() as timeline: - timeline.freeze() - originals = ( - sample_1.sub_module_1.sub_sample_1_1_time(), - sample_1.sub_module_1.sub_sample_1_1_now() - ) - time.sleep(1) - self.assertEquals(time.time(), originals[0]) - self.assertEquals(datetime.now(), originals[1]) - with Timeline() as timeline: - timeline.freeze() - originals = ( - sample_2.sub_module_2.sub_sample_2_1_time(), - sample_2.sub_module_2.sub_sample_2_1_now() - ) - time.sleep(1) - self.assertEquals(time.time(), originals[0]) - self.assertEquals(datetime.now(), originals[1]) - with Timeline() as timeline: - timeline.freeze() - originals = ( - sample_3.sub_module_3.sub_sample_3_1_time(), - sample_3.sub_module_3.sub_sample_3_1_now(), - sample_3.sub_module_3.sub_sample_3_1_gmtime() - ) - time.sleep(1) - self.assertEquals(time.time(), originals[0]) - self.assertEquals(datetime.now(), originals[1]) - self.assertEquals(time.gmtime(), originals[2]) - - def test_freeze_target(self): - with Timeline() as timeline: - timeline.freeze(datetime.fromtimestamp(0)) - self.assertAlmostEquals(time.time(), 0, 1) - - with Timeline() as timeline: - timeline.freeze(0) - self.assertAlmostEquals(time.time(), 0, 1) - - with Timeline() as timeline: - self.assertRaises(TypeError, timeline.freeze, "now") - - with Timeline() as timeline: - self.assertRaises(AttributeError, timeline.freeze, -1) - self.assertRaises( - AttributeError, timeline.freeze, date(1969, 1, 1) - ) - - def test_unfreeze(self): - real_day = date.today() - with Timeline() as timeline: - timeline.freeze(0) - self.assertAlmostEquals(time.time(), 0) - timeline.unfreeze() - timeline.scale(10) - time.sleep(1) - self.assertEqual(int(time.time()), 1) - timeline.forward(timedelta(minutes=2)) - self.assertEqual(int(time.time()), 121) - timeline.reset() - self.assertTrue( - ( - int(time.time()) - int(os.popen("date +%s").read().strip()) - ) <= 1 - ) - timeline.forward(timedelta(days=1)) - self.assertTrue((date.today() - real_day).days == 1) - - def test_freeze_forward_unfreeze(self): - - # start at 2012/12/12 0:0:0 - test_timeline = Timeline( - scale=100, start=datetime(2012, 12, 12, 0, 0, 0) - ) +def test_accelerate(): + s = time.time() + with Timeline(100): + time.sleep(10) + assert time.time() - s < 10 - # jump forward an hour and freeze - with test_timeline.forward(60 * 60).freeze(): - self.assertAlmostEqual( - (datetime.now() - datetime(2012, 12, 12, 1, 0, 0)).seconds, 0 - ) - # sleep 10 seconds - time.sleep(10) - # assert no changes - self.assertAlmostEqual( - (datetime.now() - datetime(2012, 12, 12, 1, 0, 0)).seconds, 0 - ) - # unfreeze timeline - test_timeline.unfreeze() - # ensure unfreeze was at the original freeze point - self.assertAlmostEqual( - (datetime.now() - datetime(2012, 12, 12, 1, 0, 0)).seconds, 0 - ) - # sleep 10 seconds - time.sleep(10) - # ensure post unfreeze, time moves - self.assertAlmostEqual( - (datetime.now() - datetime(2012, 12, 12, 1, 0, 0)).seconds, 10 - ) - # ensure post unfreeze, forward operations work - test_timeline.forward(timedelta(hours=2)) - self.assertAlmostEqual( - int( - timedelta_to_seconds( - datetime.now() - datetime(2012, 12, 12, 1, 0, 0) - ) - ), - (60 * 60 * 2) + 10 - ) - # reset everything - test_timeline.reset() - self.assertEquals( - int(time.time()), int(os.popen("date +%s").read().strip()) - ) - - def test_fluent(self): - start = datetime.now() - with Timeline().scale(10).forward(120): - self.assertTrue( - int(timedelta_to_seconds(datetime.now() - start)) >= 120 - ) - time.sleep(10) - self.assertTrue( - int(timedelta_to_seconds(datetime.now() - start)) >= 130 - ) - self.assertTrue((datetime.now() - start).seconds < 10) - - def test_decorated(self): - start = datetime(2013, 1, 1, 0, 0, 0) - real_start = datetime.now() - - @Timeline(scale=10, start=start) - def _decorated(): - time.sleep(10) - self.assertTrue( - int(timedelta_to_seconds(datetime.now() - start)) >= 10 - ) - _decorated() - self.assertTrue(((datetime.now() - real_start).seconds < 10)) - def test_decorated_with_argument(self): - @Timeline() - def _decorated(timeline): - self.assertTrue(isinstance(timeline, Timeline)) - _decorated() +def test_deccelerate(): + s = time.time() + with Timeline(0.5): + time.sleep(0.25) + assert time.time() - s > 0.25 - @Timeline() - def _decorated(timeline=None): - self.assertTrue(isinstance(timeline, Timeline)) - _decorated() - def test_decorated_exception(self): - class SomeException(Exception): - pass +def test_check_time(): + start = time.time() + with Timeline(100): + for i in range(0, 10): + time.sleep(1) + delta = time.time() - (start + (i + 1) * 100) + assert delta <= 1.5, delta - @Timeline() - def _decorated(): - raise SomeException("asdf") - self.assertRaises(SomeException, _decorated) +def test_utc(): + start_local = datetime.now() + start_utc = datetime.utcnow() + with Timeline(100000): + time.sleep(60 * 60) + future_diff = ( + (datetime.now() - datetime.utcnow()).seconds / 60.0 / 60.0 + ) + start_diff = (start_local - start_utc).seconds / 60.0 / 60.0 + assert math.ceil(future_diff) == math.ceil(start_diff) + + time.sleep(60 * 60 * 23) + assert (datetime.now() - start_local).days == 1 + assert (datetime.utcnow() - start_utc).days == 1 + + +def test_forward(): + original = date.today() + with Timeline() as timeline: + timeline.forward(86400) + assert (date.today() - original).days == 1 + + +def test_rewind(): + original_day = date.today() + original_datetime = datetime.now() + with Timeline() as timeline: + timeline.rewind(86400) + assert (original_day - date.today()).days == 1 + timeline.forward(timedelta(days=1)) + assert (original_day - date.today()).days == 0 + timeline.rewind(timedelta(days=1)) + amount = (original_datetime - datetime.now()) + amount_seconds = timedelta_to_seconds(amount) + assert int(amount_seconds) >= 86399, amount_seconds + + +def test_freeze(): + with Timeline() as timeline: + timeline.freeze() + originals = ( + sample_1.sub_module_1.sub_sample_1_1_time(), + sample_1.sub_module_1.sub_sample_1_1_now() + ) + time.sleep(1) + assert time.time() == originals[0] + assert datetime.now() == originals[1] + with Timeline() as timeline: + timeline.freeze() + originals = ( + sample_2.sub_module_2.sub_sample_2_1_time(), + sample_2.sub_module_2.sub_sample_2_1_now() + ) + time.sleep(1) + assert time.time() == originals[0] + assert datetime.now() == originals[1] + with Timeline() as timeline: + timeline.freeze() + originals = ( + sample_3.sub_module_3.sub_sample_3_1_time(), + sample_3.sub_module_3.sub_sample_3_1_now(), + sample_3.sub_module_3.sub_sample_3_1_gmtime() + ) + time.sleep(1) + assert time.time() == originals[0] + assert datetime.now() == originals[1] + assert time.gmtime() == originals[2] + + +def test_freeze_target(): + with Timeline() as timeline: + timeline.freeze(datetime.fromtimestamp(0)) + assert round(abs(time.time() - 0), 1) == 0 + + with Timeline() as timeline: + timeline.freeze(0) + assert round(abs(time.time() - 0), 1) == 0 + + with Timeline() as timeline: + with pytest.raises(TypeError): + timeline.freeze("now") + + with Timeline() as timeline: + with pytest.raises(AttributeError): + timeline.freeze(-1) + with pytest.raises(AttributeError): + timeline.freeze(date(1969, 1, 1)) + + +def test_unfreeze(): + real_day = date.today() + with Timeline() as timeline: + timeline.freeze(0) + assert round(abs(time.time() - 0), 7) == 0 + timeline.unfreeze() + timeline.scale(10) + time.sleep(1) + assert int(time.time()) == 1 + timeline.forward(timedelta(minutes=2)) + assert int(time.time()) == 121 + timeline.reset() + assert ( + int(time.time()) - int(os.popen("date +%s").read().strip()) + ) <= 1 + timeline.forward(timedelta(days=1)) + assert (date.today() - real_day).days == 1 + + +def test_freeze_forward_unfreeze(): + + # start at 2012/12/12 0:0:0 + test_timeline = Timeline( + scale=100, start=datetime(2012, 12, 12, 0, 0, 0) + ) + + # jump forward an hour and freeze + with test_timeline.forward(60 * 60).freeze(): + assert round( + abs( + (datetime.now() - datetime(2012, 12, 12, 1, 0, 0)).seconds - 0 + ), 7 + ) == 0 + # sleep 10 seconds + time.sleep(10) + # assert no changes + assert round( + abs( + (datetime.now() - datetime(2012, 12, 12, 1, 0, 0)).seconds - 0 + ), 7 + ) == 0 + # unfreeze timeline + test_timeline.unfreeze() + # ensure unfreeze was at the original freeze point + assert round( + abs( + (datetime.now() - datetime(2012, 12, 12, 1, 0, 0)).seconds - 0 + ), 7 + ) == 0 + # sleep 10 seconds + time.sleep(10) + # ensure post unfreeze, time moves + assert round( + abs( + (datetime.now() - datetime(2012, 12, 12, 1, 0, 0)).seconds - 10 + ), 7 + ) == 0 + # ensure post unfreeze, forward operations work + test_timeline.forward(timedelta(hours=2)) + assert int( + (datetime.now() - datetime(2012, 12, 12, 1, 0, 0)).seconds / 3600 + ) == 2 + # reset everything + test_timeline.reset() + assert int(time.time()) == int(os.popen("date +%s").read().strip()) + + +def test_fluent(): + start = datetime.now() + with Timeline().scale(10).forward(120): + assert int(timedelta_to_seconds(datetime.now() - start)) >= 120 + time.sleep(10) + assert int(timedelta_to_seconds(datetime.now() - start)) >= 130 + assert (datetime.now() - start).seconds < 10 + + +def test_decorated(): + start = datetime(2013, 1, 1, 0, 0, 0) + real_start = datetime.now() + + @Timeline(scale=10, start=start) + def _decorated(): + time.sleep(10) + assert int(timedelta_to_seconds(datetime.now() - start)) >= 10 + _decorated() + assert ((datetime.now() - real_start).seconds < 10) + + +def test_decorated_with_argument(): + @Timeline() + def _decorated(timeline): + assert isinstance(timeline, Timeline) + _decorated() + + @Timeline() + def _decorated(timeline=None): + assert isinstance(timeline, Timeline) + _decorated() + + +def test_decorated_exception(): + class SomeException(Exception): + pass + + @Timeline() + def _decorated(): + raise SomeException("asdf") + + with pytest.raises(SomeException): + _decorated() + - @mock.patch('hiro.core.BLACKLIST', new_callable=set) - def test_patch_blacklist(self, BLACKLIST): - hiro_dummy_module = mock.MagicMock( - __dir__=mock.MagicMock(side_effect=Exception)) +@mock.patch('hiro.core.BLACKLIST', new_callable=set) +def test_patch_blacklist(BLACKLIST): + hiro_dummy_module = mock.MagicMock( + __dir__=mock.MagicMock(side_effect=Exception)) - with mock.patch.dict( - 'sys.modules', {'hiro_dummy_module': hiro_dummy_module} - ): - with Timeline().freeze(): - pass + with mock.patch.dict( + 'sys.modules', {'hiro_dummy_module': hiro_dummy_module} + ): + with Timeline().freeze(): + pass - with Timeline().freeze(): - pass + with Timeline().freeze(): + pass - hiro_dummy_module.__dir__.assert_called_once() - self.assertTrue(hiro_dummy_module in BLACKLIST) + hiro_dummy_module.__dir__.assert_called_once() + assert hiro_dummy_module in BLACKLIST diff --git a/tests/test_runners.py b/tests/test_runners.py index 340fc72..7b479cd 100644 --- a/tests/test_runners.py +++ b/tests/test_runners.py @@ -1,57 +1,63 @@ """ """ -import unittest import time import hiro from hiro.errors import SegmentNotComplete - - -class TestSyncRunner(unittest.TestCase): - def test_scale_up_runner(self): - def _slow_func(): - time.sleep(1) - return 1 - f = hiro.run_sync(4, _slow_func) - self.assertTrue(f.get_execution_time() < 1) - self.assertEquals(f.get_response(), 1) - - def test_scale_up_runner_fail(self): - def _slow_func(): - time.sleep(1) - raise Exception("foo") - f = hiro.run_sync(4, _slow_func) - self.assertRaises(Exception, f.get_response) - self.assertTrue(f.get_execution_time() < 1) - - -class TestASyncRunner(unittest.TestCase): - def test_scale_up_runner(self): - def _slow_func(): - time.sleep(1) - f = hiro.run_async(4, _slow_func) - self.assertTrue(f.is_running()) - f.join() - self.assertTrue(f.get_execution_time() < 1) - - def test_scale_up_runner_fail(self): - def _slow_func(): - time.sleep(1) - raise Exception("foo") - f = hiro.run_async(4, _slow_func) - self.assertTrue(f.is_running()) - f.join() - self.assertRaises(Exception, f.get_response) - self.assertTrue(f.get_execution_time() < 1) - - def test_segment_not_complete_error(self): - def _slow_func(): - time.sleep(1) - raise Exception("foo") - f = hiro.run_async(4, _slow_func) - self.assertRaises(SegmentNotComplete, f.get_execution_time) - self.assertRaises(SegmentNotComplete, f.get_response) - self.assertTrue(f.is_running()) - f.join() - self.assertRaises(Exception, f.get_response) - self.assertTrue(f.get_execution_time() < 1) +import pytest + + +def test_scale_up_sync_runner(): + def _slow_func(): + time.sleep(1) + return 1 + f = hiro.run_sync(4, _slow_func) + assert f.get_execution_time() < 1 + assert f.get_response() == 1 + + +def test_scale_up_sync_runner_fail(): + def _slow_func(): + time.sleep(1) + raise Exception("foo") + f = hiro.run_sync(4, _slow_func) + with pytest.raises(Exception): + f.get_response() + assert f.get_execution_time() < 1 + + +def test_scale_up_async_runner(): + def _slow_func(): + time.sleep(1) + f = hiro.run_async(4, _slow_func) + assert f.is_running() + f.join() + assert f.get_execution_time() < 1 + + +def test_scale_up_async_runner_fail(): + def _slow_func(): + time.sleep(1) + raise Exception("foo") + f = hiro.run_async(4, _slow_func) + assert f.is_running() + f.join() + with pytest.raises(Exception): + f.get_response() + assert f.get_execution_time() < 1 + + +def test_segment_not_complete_error(): + def _slow_func(): + time.sleep(1) + raise Exception("foo") + f = hiro.run_async(4, _slow_func) + with pytest.raises(SegmentNotComplete): + f.get_execution_time() + with pytest.raises(SegmentNotComplete): + f.get_response() + assert f.is_running() + f.join() + with pytest.raises(Exception): + f.get_response() + assert f.get_execution_time() < 1 diff --git a/tests/test_utils.py b/tests/test_utils.py index 4117cc9..d3d459d 100644 --- a/tests/test_utils.py +++ b/tests/test_utils.py @@ -1,61 +1,60 @@ import datetime import six -import unittest from hiro.errors import InvalidTypeError from hiro.utils import timedelta_to_seconds, time_in_seconds, chained +import pytest -class TestTimeDeltaToSeconds(unittest.TestCase): - def test_fractional(self): - delta = datetime.timedelta(seconds=1, microseconds=1000) - self.assertAlmostEqual(timedelta_to_seconds(delta), 1.001) +def test_fractional(): + delta = datetime.timedelta(seconds=1, microseconds=1000) + assert round(abs(timedelta_to_seconds(delta) - 1.001), 7) == 0 - def test_days(self): - delta = datetime.timedelta(days=10) - self.assertEqual( - timedelta_to_seconds(delta), - delta.days * 24 * 60 * 60 - ) +def test_days(): + delta = datetime.timedelta(days=10) + assert timedelta_to_seconds(delta) == delta.days * 24 * 60 * 60 -class TestTimeInSeconds(unittest.TestCase): - def test_passthrough(self): - self.assertEqual(time_in_seconds(1), 1) - long_instance = long(1) if six.PY2 else 1 # noqa: F821 - self.assertEqual(time_in_seconds(long_instance), long_instance) - self.assertEqual(time_in_seconds(1.0), 1.0) +def test_passthrough(): + assert time_in_seconds(1) == 1 - def test_date(self): - d = datetime.date(1970, 1, 1) - self.assertEqual(time_in_seconds(d), 0) + long_instance = long(1) if six.PY2 else 1 # noqa: F821 + assert time_in_seconds(long_instance) == long_instance + assert time_in_seconds(1.0) == 1.0 - def test_datetime(self): - d = datetime.datetime(1970, 1, 1, 0, 0, 0) - self.assertEqual(time_in_seconds(d), 0) - def test_invalid_type(self): - self.assertRaises( - InvalidTypeError, time_in_seconds, "this is a string") +def test_date(): + d = datetime.date(1970, 1, 1) + assert time_in_seconds(d) == 0 -class TestChained(unittest.TestCase): +def test_datetime(): + d = datetime.datetime(1970, 1, 1, 0, 0, 0) + assert time_in_seconds(d) == 0 + + +def test_invalid_type(): + with pytest.raises(InvalidTypeError): + time_in_seconds("this is a string") + + +class TestChained(object): class Foo(object): @chained def return_value(self, value=None): return value - def setUp(self): + def setup_method(self): self.obj = self.Foo() def test_no_return(self): - self.assertTrue(self.obj.return_value() is self.obj) + assert self.obj.return_value() is self.obj def test_with_return(self): o = object() - self.assertTrue(self.obj.return_value(o) is o) + assert self.obj.return_value(o) is o def test_kwargs(self): o = object() - self.assertTrue(self.obj.return_value(value=o) is o) + assert self.obj.return_value(value=o) is o