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_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_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_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_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_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 _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')
