def test_check_add_observation_midnight_race(contact_tracer): with Replace("dp3t.protocols.unlinkable_db.datetime", test_datetime(**START_TIME_ENDING)): contact_tracer.check_advance_day(datetime(**START_TIME_TOMORROW)) with Replace("dp3t.protocols.unlinkable_db.datetime", test_datetime(**START_TIME_TOMORROW)): contact_tracer.add_observation(EPHID, datetime(**START_TIME_TOMORROW))
def test_gotcha_import_and_obtain(self): # Another gotcha is where people have locally obtained # a class attributes, where the normal patching doesn't # work: @replace('testfixtures.tests.sample1.datetime',test_datetime()) def test_something(): compare(sample1.str_now_2(),'2001-01-01 00:00:00') s = should_raise(test_something,AssertionError) s() # This convoluted check is because we can't stub # out the datetime, since we're testing stubbing out # the datetime ;-) j,dt1,j,dt2,j = s.raised.args[0].split("'") if '.' in dt1: dt1,ms = dt1.split('.') # check ms is just an int int(ms) # check we can parse the date dt1 = strptime(dt1,'%Y-%m-%d %H:%M:%S') # check the dt2 bit was as it should be compare(dt2,'2001-01-01 00:00:00') # What you need to do is replace the imported name: @replace('testfixtures.tests.sample1.now',test_datetime().now) def test_something(): compare(sample1.str_now_2(),'2001-01-01 00:00:00') test_something()
def test_gotcha_import(self): # standard `replace` caveat, make sure you # patch all revelent places where datetime # has been imported: @replace('datetime.datetime',test_datetime()) def test_something(): from datetime import datetime compare(datetime.now(),d(2001,1,1,0,0,0)) compare(sample1.str_now_1(),'2001-01-01 00:00:10') s = should_raise(test_something,AssertionError) s() # This convoluted check is because we can't stub # out the datetime, since we're testing stubbing out # the datetime ;-) j,dt1,j,dt2,j = s.raised.args[0].split("'") if '.' in dt1: dt1,ms = dt1.split('.') # check ms is just an int int(ms) # check we can parse the date dt1 = strptime(dt1,'%Y-%m-%d %H:%M:%S') # check the dt2 bit was as it should be compare(dt2,'2001-01-01 00:00:10') # What you need to do is replace the imported type: @replace('testfixtures.tests.sample1.datetime',test_datetime()) def test_something(): compare(sample1.str_now_1(),'2001-01-01 00:00:00') test_something()
class TestSourceEventLogging(TestCase): def setUp(self): self.logger = RemoteHostEventLogger( RemoteHost.objects.create(address='test.com')) self.expected_message = ( '+------------- [2000-01-01 12:00:00] <test.com> -------------\n' '| test message\n' '+------------------------------------------------------------\n') @replace( 'remote_host_event_logging.remote_host_event_logging.datetime.datetime', test_datetime(2000, 1, 1, 12, 0, 0)) @log_capture() def test_debug(self, log): self.logger.debug('test message') log.check( ('goto_cloud.remote_host_event_logging.remote_host_event_logging', 'DEBUG', self.expected_message)) @replace( 'remote_host_event_logging.remote_host_event_logging.datetime.datetime', test_datetime(2000, 1, 1, 12, 0, 0)) @log_capture() def test_info(self, log): self.logger.info('test message') log.check( ('goto_cloud.remote_host_event_logging.remote_host_event_logging', 'INFO', self.expected_message)) @replace( 'remote_host_event_logging.remote_host_event_logging.datetime.datetime', test_datetime(2000, 1, 1, 12, 0, 0)) @log_capture() def test_warning(self, log): self.logger.warning('test message') log.check( ('goto_cloud.remote_host_event_logging.remote_host_event_logging', 'WARNING', self.expected_message)) @replace( 'remote_host_event_logging.remote_host_event_logging.datetime.datetime', test_datetime(2000, 1, 1, 12, 0, 0)) @log_capture() def test_error(self, log): self.logger.error('test message') log.check( ('goto_cloud.remote_host_event_logging.remote_host_event_logging', 'ERROR', self.expected_message)) @replace( 'remote_host_event_logging.remote_host_event_logging.datetime.datetime', test_datetime(2000, 1, 1, 12, 0, 0)) @log_capture() def test_critical(self, log): self.logger.critical('test message') log.check( ('goto_cloud.remote_host_event_logging.remote_host_event_logging', 'CRITICAL', self.expected_message))
def cross_timezone(testcase: TestCase, gen_timezone, gen_seq_factory, poll_timezone, poll_seq_factory, strict): mocked_gen_dt = Replace(token_datetime, test_datetime(tzinfo=gen_timezone, strict=strict, delta=0)) mocked_poll_dt = Replace(token_datetime, test_datetime(tzinfo=poll_timezone, strict=strict, delta=0)) def mixed_seq(): with mocked_gen_dt as d: next(gen_seq_factory(d)) yield with mocked_poll_dt as d: poll_seq = poll_seq_factory(d) next(poll_seq) # skip first entry yield from poll_seq with testcase.subTest(tz1=gen_timezone, tz2=poll_timezone): yield mixed_seq()
def set_time(self, dt): r = Replacer() r.replace( 'testfixtures.tests.sample1.datetime', test_datetime(dt.year, dt.month, dt.day, dt.hour, dt.minute, dt.second)) return r
def test_check_advance_day_firing(contact_tracer): with Replace("dp3t.protocols.unlinkable_db.datetime", test_datetime(**START_TIME_TOMORROW)): contact_tracer.check_advance_day(datetime(**START_TIME_TOMORROW)) epoch = epoch_from_time(datetime(**START_TIME_TOMORROW)) seeds = contact_tracer.db.get_epoch_seeds(epoch, epoch + 1) assert len(seeds) == 1
def test_time_invariance(self): with Replace(token_datetime, test_datetime(None)) as d: d.set(2019, 10, 10, 1, 1, 1) tok1 = models.CustomerSignedSerialGenerator(serial=5).bare_token() d.set(2013, 9, 7, 1, 1, 1) tok2 = models.CustomerSignedSerialGenerator(serial=5).bare_token() self.assertEqual(tok1, tok2)
def test_close(self): name = "Do the dishes" tags = ["chores"] tasks = { name: task.Task( name=name, due=FIVE_PM, estimate=TEN_MINUTES, tags=tags, spans=[task.Span(start=NOW)], ) } with Replace("task.datetime", test_datetime(NOW + ONE_SECOND, delta=0)): dateparser.conf.settings.RELATIVE_BASE = NOW + ONE_SECOND task.close(tasks=tasks, active_task=tasks[name], name=name) expected = task.Task( name=name, due=FIVE_PM, estimate=TEN_MINUTES, tags=tags, spans=[task.Span(start=NOW, stop=NOW + ONE_SECOND)], open=False, ) self.assertEqual(len(tasks), 1) self.assertEqual(tasks[name], expected)
def test_valid_from_custom(self): with Replace(token_datetime, test_datetime(None)) as d: d.set(2019, 10, 10, 1, 1, 1) gen = SimpleTBTGenerator() gen.lifespan = 2 gen.valid_from = datetime.datetime(2019, 12, 10, 1, 1, 1, tzinfo=pytz.utc) val = gen.validator() tok = gen.bare_token() self.assertEqual( val.parse_token(tok)[0], tokens.TimeBasedTokenValidator.NOT_YET_VALID_TOKEN) d.set(2019, 12, 10, 0, 59, 59) self.assertEqual( val.parse_token(tok)[0], tokens.TimeBasedTokenValidator.NOT_YET_VALID_TOKEN) d.set(2019, 12, 10, 1, 0, 0) self.assertTrue(val.validate_token(tok)) d.set(2019, 12, 10, 1, 1, 1) self.assertTrue(val.validate_token(tok)) d.set(2019, 12, 10, 3, 0, 0) self.assertTrue(val.validate_token(tok)) d.set(2019, 12, 10, 3, 0, 1) self.assertEqual( val.parse_token(tok)[0], tokens.TimeBasedTokenValidator.EXPIRED_TOKEN)
def test_tag_includes_now(dir): with Replace('carthorse.cli.datetime', test_datetime()): check_tag_from_env(dir, config={ 'tool': { 'carthorse': { 'version-from': { 'name': 'dummy' }, 'tag-format': 'release-{now:%Y-%m-%d}', 'when': [ { 'name': 'dummy' }, ], 'actions': [ { 'name': 'dummy' }, ] } } }, expected=[ 'release-2001-01-01', 'release-2001-01-01', ])
def run_main(self, args=(), output='', return_code=0): # so we don't leave log handlers lying around... # ...level is so that we check the log level is correctly set # in setup_logging with LogCapture(level=100): with Replacer() as r: # set argv argv = ['x'] + args r.replace('sys.argv', argv) r.replace('picky.main.datetime', test_datetime(2001, 1, 2, 3, 4, 5)) # set PATH env variable r.replace('os.environ.PATH', self.path) # change to tempdir cwd = os.getcwd() try: os.chdir(self.dir.path) # get the exit code with ShouldRaise(SystemExit) as s: # capture output with OutputCapture() as actual: main() finally: os.chdir(cwd) # compare output, with timestamp subbed out captured = re.sub('[\d\- :]{19}', '(ts)', actual.captured) compare(output, captured) # compare return code compare(return_code, s.raised.code)
def run_actions(self, path=None, **kw): with LogCapture() as log: plugin = make_git_repo(path=path or self.dir.path, **kw) with Replacer() as r: r.replace("archivist.repos.git.datetime", test_datetime()) plugin.actions() return log
def test_add(self): tasks: task.TaskDict = dict() name = "Do the dishes" tags = ["chores"] with Replace("task.datetime", test_datetime(NOW)): dateparser.conf.settings.RELATIVE_BASE = NOW tasks = task.add( tasks=tasks, name=name, due_input="5pm today", estimate_input="10 minutes", tags=tags, ) expected = task.Task( name=name, due=FIVE_PM, estimate=TEN_MINUTES, tags=tags, ) self.assertEqual(len(tasks), 1) self.assertTrue(name in tasks.keys()) self.assertEqual(tasks[name], expected)
def test_case_get_outside_caselist_active_dates(self): cl = CaseList.objects.get(pk=1) cl.StartDate = datetime(2021, 2, 15, 9, 0) cl.EndDate = datetime(2021, 7, 22, 18, 30) cl.save() self.client.login(username='******', password='******') url = reverse('rateslide:case', kwargs={'case_id': 1}) with Replace('rateslide.models.datetime', test_datetime(2021, 1, 18, 1, 2, 3)): response = self.client.get(url) self.assertEqual(response.status_code, 404, 'Cannot access case before active') with Replace('rateslide.models.datetime', test_datetime(2021, 3, 18, 1, 2, 3)): response = self.client.get(url) self.assertEqual(response.status_code, 200, 'Access case in active period') with Replace('rateslide.models.datetime', test_datetime(2021, 1, 18, 1, 2, 3)): response = self.client.get(url) self.assertEqual(response.status_code, 404, 'Cannot access case after active')
def test_date_return_type(self): with Replacer() as r: r.replace('datetime.datetime', test_datetime()) from datetime import datetime dt = datetime(2001, 1, 1, 1, 0, 0) d = dt.date() compare(d, date(2001, 1, 1)) self.failUnless(d.__class__ is date)
def test_start(self): name = "Do the dishes" name2 = "Take out the garbage" tags = ["chores"] tasks = { name: task.Task( name=name, due=FIVE_PM, estimate=TEN_MINUTES, tags=tags, spans=[task.Span(start=NOW + ONE_SECOND)], ), name2: task.Task( name=name2, due=FIVE_PM, estimate=TEN_MINUTES, tags=tags, ), } active_task = tasks[name] with Replace("task.datetime", test_datetime(NOW + ONE_SECOND + ONE_SECOND, delta=0)): dateparser.conf.settings.RELATIVE_BASE = NOW + ONE_SECOND + ONE_SECOND tasks, active_task = task.start(tasks=tasks, name=name2, active_task=active_task) expected = task.Task( name=name, due=FIVE_PM, estimate=TEN_MINUTES, tags=tags, spans=[ task.Span(start=NOW + ONE_SECOND, stop=NOW + ONE_SECOND + ONE_SECOND) ], ) expected2 = task.Task( name=name2, due=FIVE_PM, estimate=TEN_MINUTES, tags=tags, spans=[task.Span(start=NOW + ONE_SECOND + ONE_SECOND)], ) self.assertEqual(len(tasks), 2) self.assertEqual(tasks[name], expected) self.assertEqual(tasks[name].spans[0].duration(), ONE_SECOND) self.assertEqual(active_task, tasks[name2]) self.assertEqual(active_task, expected2)
def test_validity_until(self): with Replace(token_datetime, test_datetime(None)) as d: d.set(2019, 10, 10, 13, 0, 1) tok = SimpleTBTGenerator.EXAMPLE_TOKEN self.assertEqual( simple_validator.parse_token(tok)[0], tokens.TimeBasedTokenValidator.EXPIRED_TOKEN) d.set(2019, 10, 10, 13, 0, 0) self.assertTrue(simple_validator.validate_token(tok))
def test_caselist_no_case_links_outside_active_dates(self): cl = CaseList.objects.get(pk=1) cl.StartDate = datetime(2021, 2, 15, 9, 0) cl.EndDate = datetime(2021, 7, 22, 18, 30) cl.save() url = reverse('rateslide:caselist', kwargs={'slug': 'simple-case'}) with Replace('rateslide.models.datetime', test_datetime(2021, 1, 18, 1, 2, 3)): response = self.client.get(url) self.assertEqual(response.status_code, 200) self.assertNotContains(response, 'Rate next case', msg_prefix='Current date is before active period') with Replace('rateslide.models.datetime', test_datetime(2021, 3, 18, 1, 2, 3)): response = self.client.get(url) self.assertEqual(response.status_code, 200) self.assertContains(response, 'Rate next case', count=1, msg_prefix='Current date is in active period') with Replace('rateslide.models.datetime', test_datetime(2022, 1, 18, 1, 2, 3)): response = self.client.get(url) self.assertEqual(response.status_code, 200) self.assertNotContains(response, 'Rate next case', msg_prefix='Current date is after active period')
def test_date_return_type_picky(self): date_type = test_date(strict=True) with Replacer() as r: r.replace('datetime.datetime', test_datetime(date_type=date_type, strict=True)) from datetime import datetime dt = datetime(2010, 8, 26, 14, 33, 13) d = dt.date() compare(d, date_type(2010, 8, 26)) self.failUnless(d.__class__ is date_type)
def test_delta(self): with OutputCapture() as output: datetime = test_datetime(delta=2, delta_type='hours') print(datetime.now()) print(datetime.now()) output.compare(''' 2001-01-01 00:00:00 2001-01-01 02:00:00 ''')
def test_class_salt(self): with Replace(token_datetime, test_datetime(None)) as d: d.set(2019, 10, 10, 1, 1, 1) fake_gen = FakeSimpleTBTGenerator() fake_tok = fake_gen.bare_token() gen = SimpleTBTGenerator() real_tok = gen.bare_token() self.assertEqual(real_tok, gen.EXAMPLE_TOKEN) self.assertNotEqual(fake_tok, real_tok) self.assertTrue(fake_gen.validator().validate_token(fake_tok)) self.assertFalse(gen.validator().validate_token(fake_tok))
def test_date_return_type_picky(self): # type checking is a bitch :-/ date_type = test_date(strict=True) with Replacer() as r: r.replace('datetime.datetime', test_datetime(date_type=date_type, strict=True, )) from datetime import datetime dt = datetime(2010, 8, 26, 14, 33, 13) d = dt.date() compare(d, date_type(2010, 8, 26)) self.failUnless(d.__class__ is date_type)
def test_extra_hash_data(self): with Replace(token_datetime, test_datetime(None)) as d: d.set(2019, 10, 10, 1, 1, 1) gen = ExtraTBTGenerator(stuff=4) tok1 = gen.bare_token() gen.stuff = 5 d.set(2019, 10, 10, 1, 1, 1) tok2 = gen.bare_token() self.assertNotEqual(tok1, tok2) evaluator = gen.validator(generator_kwargs={'stuff': 5}) self.assertTrue(evaluator.validate_token(tok2)) self.assertFalse(evaluator.validate_token(tok1))
def test_import_and_obtain_with_lists(self): t = test_datetime(None) t.add(2002, 1, 1, 1, 0, 0) t.add(2002, 1, 1, 2, 0, 0) from testfixtures import Replacer r = Replacer() r.replace('testfixtures.tests.sample1.now', t.now) try: compare(sample1.str_now_2(), '2002-01-01 01:00:00') compare(sample1.str_now_2(), '2002-01-01 02:00:00') finally: r.restore()
def test_simple(self): with OutputCapture() as output: datetime = test_datetime() print(datetime.now()) print(datetime.now()) print(datetime.now()) output.compare(''' 2001-01-01 00:00:00 2001-01-01 00:00:10 2001-01-01 00:00:30 ''')
def test_specific(self): with OutputCapture() as output: datetime = test_datetime(None) datetime.add(1978, 6, 13, 16, 0, 1) datetime.add(2013, 3, 23, 14, 30) print(datetime.now()) print(datetime.now()) output.compare(''' 1978-06-13 16:00:01 2013-03-23 14:30:00 ''')
def test_time_before_origin(self): with Replace(token_datetime, test_datetime(None)) as d: d.set(1919, 10, 10, 1, 1, 1) gen = SimpleTBTGenerator() with self.assertRaises(ValueError): gen.make_token() d.set(2019, 10, 10, 1, 1, 1) gen.valid_from = datetime.datetime(1919, 10, 10, 1, 1, 1, tzinfo=pytz.utc) with self.assertRaises(ValueError): gen.make_token()
def _setUp(d): removeHandlers() DummySMTP.install() datetime = test_datetime(2007, 1, 1, 10, delta=0) time = test_time(2007, 1, 1, 10, delta=0) r = Replacer() r.replace('mailinglogger.MailingLogger.now', datetime.now) r.replace('mailinglogger.common.gethostname', Dummy('host.example.com')) r.replace('time.time', time) r.replace('os.environ.TZ', 'GMT', strict=False) tzset() d['r'] = r d['smtp'] = DummySMTP d['datetime'] = datetime d['time'] = time d['removeHandlers'] = removeHandlers
def test_lifespan_zero(self): with Replace(token_datetime, test_datetime(None)) as d: d.set(2019, 10, 10, 1, 1, 1) gen = SimpleTBTGenerator() gen.lifespan = 0 tok, (valid_from, valid_until) = gen.make_token() self.assertEqual(valid_until, None) self.assertTrue(tok.startswith('0-')) d.set(2019, 10, 10, 0, 59, 59) self.assertEqual( simple_validator.parse_token(tok)[0], tokens.TimeBasedTokenValidator.NOT_YET_VALID_TOKEN) d.set(2019, 10, 10, 1, 0, 0) self.assertTrue(simple_validator.validate_token(tok)) d.set(2019, 10, 10, 13, 0, 0) self.assertTrue(simple_validator.validate_token(tok)) d.set(2019, 10, 10, 17, 0, 0) self.assertTrue(simple_validator.validate_token(tok))
def _setUp(d, stdout=True): removeHandlers() DummySMTP.install(stdout=stdout) atexit_handlers = [] datetime = test_datetime(2007, 1, 1, 10, delta=0) time = test_time(2007, 1, 1, 10, delta=0) r = Replacer() r.replace('atexit.register', atexit_handlers.append) r.replace('mailinglogger.MailingLogger.now', datetime.now) r.replace('mailinglogger.common.gethostname', Dummy('host.example.com')) r.replace('time.time', time) r.replace('os.environ.TZ', 'GMT', strict=False) tzset() d['atexit_handlers'] = atexit_handlers d['r'] = r d['smtp'] = DummySMTP d['datetime'] = datetime d['time'] = time d['removeHandlers'] = removeHandlers
def test_lifespan_custom(self): with Replace(token_datetime, test_datetime(None)) as d: d.set(2019, 10, 10, 1, 1, 1) gen = SimpleTBTGenerator() gen.lifespan = 20 tok, (valid_from, valid_until) = gen.make_token() self.assertEqual( valid_until, datetime.datetime(2019, 10, 10, 21, 0, 0, tzinfo=pytz.utc)) self.assertTrue(tok.startswith('20-')) d.set(2019, 10, 10, 0, 59, 59) self.assertEqual( simple_validator.parse_token(tok)[0], tokens.TimeBasedTokenValidator.NOT_YET_VALID_TOKEN) d.set(2019, 10, 10, 1, 0, 0) self.assertTrue(simple_validator.validate_token(tok)) d.set(2019, 10, 10, 21, 0, 1) self.assertEqual( simple_validator.parse_token(tok)[0], tokens.TimeBasedTokenValidator.EXPIRED_TOKEN) d.set(2019, 10, 10, 21, 0, 0) self.assertTrue(simple_validator.validate_token(tok))
def test_expiry_base(self): with Replace(token_datetime, test_datetime(None)) as d: d.set(2019, 10, 10, 1, 1, 1) tok, (valid_from, valid_until) = SimpleTBTGenerator().make_token() self.assertEqual( valid_from, datetime.datetime(2019, 10, 10, 1, 0, 0, tzinfo=pytz.utc)) self.assertEqual( valid_until, datetime.datetime(2019, 10, 10, 13, 0, 0, tzinfo=pytz.utc)) d.set(2019, 10, 10, 0, 59, 59) self.assertEqual( simple_validator.parse_token(tok)[0], tokens.TimeBasedTokenValidator.NOT_YET_VALID_TOKEN) d.set(2019, 10, 10, 1, 0, 0) self.assertTrue(simple_validator.validate_token(tok)) d.set(2019, 10, 10, 13, 0, 1) self.assertEqual( simple_validator.parse_token(tok)[0], tokens.TimeBasedTokenValidator.EXPIRED_TOKEN) d.set(2019, 10, 10, 13, 0, 0) self.assertTrue(simple_validator.validate_token(tok))
def _setUp(test, self=None, stdout=True): if self is None: d = test.globs else: d = self.__dict__ removeHandlers() DummySMTP.install(stdout=stdout) datetime = test_datetime(2007, 1, 1, 10, delta=0) time = test_time(2007, 1, 1, 10, delta=0) r = Replacer() r.replace('mailinglogger.MailingLogger.now', datetime.now) r.replace('mailinglogger.common.gethostname', Dummy('host.example.com')) r.replace('time.time', time) r.replace('os.environ.TZ', 'GMT', strict=False) tzset() d['r'] = r d['smtp']=DummySMTP d['datetime']=datetime d['time']=time d['removeHandlers']=removeHandlers
def setUp(test, self=None, stdout=True): if self is None: d = test.globs else: d = self.__dict__ removeHandlers() DummySMTP.install(stdout=stdout) datetime = test_datetime(2007, 1, 1, 10, delta=0) time = test_time(2007, 1, 1, 10, delta=0) r = Replacer() r.replace("mailinglogger.MailingLogger.now", datetime.now) r.replace("mailinglogger.common.gethostname", Dummy("host.example.com")) r.replace("time.time", time) r.replace("os.environ.TZ", "GMT", strict=False) tzset() d["r"] = r d["smtp"] = DummySMTP d["datetime"] = datetime d["time"] = time d["removeHandlers"] = removeHandlers
def _setUp(test, self=None, stdout=True): if self is None: d = test.globs else: d = self.__dict__ removeHandlers() DummySMTP.install(stdout=stdout) datetime = test_datetime(2007, 1, 1, 10, delta=0) time = test_time(2007, 1, 1, 10, delta=0) r = Replacer() r.replace('mailinglogger.MailingLogger.now', datetime.now) r.replace('mailinglogger.common.gethostname', Dummy('host.example.com')) r.replace('time.time', time) r.replace('os.environ.TZ', 'GMT', strict=False) tzset() d['r'] = r d['smtp'] = DummySMTP d['datetime'] = datetime d['time'] = time d['removeHandlers'] = removeHandlers
def test_tick_when_dynamic(self): # hopefully not that common? datetime = test_datetime() compare(datetime.now(), expected=d(2001, 1, 1)) datetime.tick(hours=1) compare(datetime.now(), expected=d(2001, 1, 1, 1, 0, 10))
def test_local_now_with_tz_as_string(self): with mock.patch(u'django.utils.timezone.datetime', test_datetime(2014, 9, 10, 2, 20)): # in UTC value = local_now(u'America/Montreal') self._check_dt(value, u'2014-09-09 22:20:00.000000 EDT -0400')
def test_ms_delta(self): datetime = test_datetime(delta=100, delta_type='microseconds') compare(datetime.now(), datetime(2001, 1, 1, 0, 0, 0, 0)) compare(datetime.now(), datetime(2001, 1, 1, 0, 0, 0, 100)) compare(datetime.now(), datetime(2001, 1, 1, 0, 0, 0, 200))
def test_subsecond_deltas(self): datetime = test_datetime(delta=0.5) compare(datetime.now(), datetime(2001, 1, 1, 0, 0, 0, 0)) compare(datetime.now(), datetime(2001, 1, 1, 0, 0, 0, 500000)) compare(datetime.now(), datetime(2001, 1, 1, 0, 0, 1, 0))
def test_utc_today(self): with mock.patch(u'django.utils.timezone.datetime', test_datetime(2014, 9, 10, 2, 20)): # in UTC value = utc_today() self._check_date(value, u'2014-09-10')
def test_local_today_with_tz_as_string(self): with mock.patch(u'django.utils.timezone.datetime', test_datetime(2014, 9, 10, 2, 20)): # in UTC value = local_today(u'America/Montreal') self._check_date(value, u'2014-09-09')
def test_instantiate_with_datetime(self): from datetime import datetime t = test_datetime(datetime(2002, 1, 1, 1)) compare(t.now(), d(2002, 1, 1, 1, 0, 0))
def setUp(self): self.dir = TempDirectory() self.log = LogCapture() self.r = Replacer() self.r.replace("datetime.datetime", test_datetime())
def replace_datetime(self, dl=1): self.rp_datetime = Replacer() self.rp_datetime.replace('backup.BackupManager.datetime', test_datetime(2015, 1, 1, 12, 0, 0, delta=dl))
def test_tick_with_timedelta_instance(self): datetime = test_datetime(delta=0) compare(datetime.now(), expected=d(2001, 1, 1)) datetime.tick(timedelta(hours=1)) compare(datetime.now(), expected=d(2001, 1, 1, 1))
def test_now_with_tz_instance(self): dt = test_datetime(d(2001, 1, 1, tzinfo=SampleTZInfo())) compare(dt.now(), d(2001, 1, 1))
def test_now_with_tz_instance_and_same_supplied(self): dt = test_datetime(d(2001, 1, 1, tzinfo=SampleTZInfo())) info = SampleTZInfo() compare(dt.now(info), d(2001, 1, 1, tzinfo=info))
def test_local_today_with_day_change(self): with mock.patch(u'django.utils.timezone.datetime', test_datetime(2014, 9, 10, 23, 20)): # in UTC value = local_today() self._check_date(value, u'2014-09-11')
def test_is_last_of_month_now(): with Replacer() as r: r.replace('utility.datetime', test_datetime(2011, 11, 30)) assert is_last_of_month_now()
def test_tick_when_static(self): datetime = test_datetime(delta=0) compare(datetime.now(), expected=d(2001, 1, 1)) datetime.tick(hours=1) compare(datetime.now(), expected=d(2001, 1, 1, 1))
def test_local_now(self): with mock.patch(u'django.utils.timezone.datetime', test_datetime(2014, 9, 10, 2, 20)): # in UTC value = local_now() self._check_dt(value, u'2014-09-10 04:20:00.000000 CEST +0200')
def test_utc_now(self): with mock.patch(u'django.utils.timezone.datetime', test_datetime(2014, 9, 10, 2, 20)): # in UTC value = utc_now() self._check_dt(value, u'2014-09-10 02:20:00.000000 UTC +0000')