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 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 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 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_api_login(runner, mocked_creds_path):
login_input = "*****@*****.**" + "\n" + "userpassword" + "\n"
successful_login_msg = "Your ~/.onecodex credentials file was successfully created."
with Replace("onecodex.auth.fetch_api_key_from_uname", mock_fetch_api_key):
result = runner.invoke(Cli, ["login"], input=login_input)
assert result.exit_code == 0
assert successful_login_msg in result.output
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_demonstrate_today(fake_out):
with Replace('testfixtures.tests.sample1.date', test_date(1978, 6, 13)):
global date
date = Mock()
date.today = str_today_1
demonstrate_today()
assert fake_out.getvalue() == "1978-06-13\n"
def action_open(self, namespace, repository):
self.set_mock_popen_commands([
('xdg-open {}'.format(self.service.format_path(namespace=namespace, repository=repository)), b'', b'', 0),
('open {}'.format(self.service.format_path(namespace=namespace, repository=repository)), b'', b'', 0),
])
with Replace('subprocess.Popen', self.Popen):
self.service.open(user=namespace, repo=repository)
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_slips_processor(self):
def _get_queue(queue, data):
for line in data.strip().split("\n"):
queue.put(line)
queue.put('stop')
def mock_print_data(slf):
df = pd.DataFrame([i.strip().split(',') for i in slf.output_list])
return df
with Replace('st_engine.slips.Processor.print_output',
mock_print_data):
queue = Queue()
args = {
"width": 5,
"verbose": 0,
"amount": -1,
"output": "temp_file"
}
df = self.df("diamond_data_normal", keep=True)
df = df.to_csv(index=False)
proc = Processor(queue, args["output"], args["width"], None,
args["verbose"], args["amount"], None)
_get_queue(queue, df)
proc.run()
self.assertGolden(proc.print_output(), "diamond_data_normal_pred")
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_get_df_with_retries():
start = datetime.date(2020, 12, 1)
end = datetime.date(2020, 12, 2)
counter = 0
def fetch0():
return pd.DataFrame()
def fetch1():
nonlocal counter
counter += 1
if counter > 1:
return pd.DataFrame([['foo'], ['bar']])
return pd.DataFrame()
def mock_apply(self, *_args, **_kwargs):
return self.base_date - datetime.timedelta(days=1)
with Replace('gs_quant.timeseries.helper.RelativeDate.apply_rule',
mock_apply):
df = get_df_with_retries(fetch0, start, end, 'NYSE')
assert df.empty
df = get_df_with_retries(fetch1, start, end, 'NYSE', 0)
assert df.empty
df = get_df_with_retries(fetch1, start, end, 'NYSE', 1)
assert not df.empty
df = get_df_with_retries(fetch1, start, end, 'NYSE', 2)
assert not df.empty
def test_version_tagged_upstream(self, git, capfd):
with Replace('os.environ.TAG', 'v1.2.3', strict=False):
git.make_repo_with_content('remote')
rev = git.rev_parse('HEAD', 'remote')
git('clone remote local', git.dir.path)
git('tag v1.2.3', 'remote')
git.check_tags(repo='local', expected={})
git.check_tags(repo='remote', expected={b'v1.2.3': rev})
os.chdir(git.dir.getpath('local'))
git.dir.write('local/a', 'changed')
git('config user.email "*****@*****.**"')
git('config user.name "Test User"')
git("commit -am changed")
assert not version_not_tagged()
git.check_tags(repo='local', expected={b'v1.2.3': rev})
git.check_tags(repo='remote', expected={b'v1.2.3': rev})
out, _ = capfd.readouterr()
compare(out,
expected=('$ git remote -v\n'
f"{git('remote -v').decode('ascii')}"
"$ git fetch origin 'refs/tags/*:refs/tags/*'\n"
'$ git rev-parse --verify -q v1.2.3\n'
f'{rev}\n'
'Version is already tagged.\n'))
def test_api_login(runner, mocked_creds_path):
login_input = '*****@*****.**' + '\n' + 'userpassword' + '\n'
successful_login_msg = 'Your ~/.onecodex credentials file was successfully created.'
with Replace('onecodex.auth.fetch_api_key_from_uname', mock_fetch_api_key):
result = runner.invoke(Cli, ['login'], input=login_input)
assert result.exit_code == 0
assert successful_login_msg in result.output
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_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_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_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_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 mockup_git(self, namespace, repository):
# disable refspec check
from git import remote
remote.Remote._assert_refspec = lambda self: None
# write FETCH_HEAD ref
with open(os.path.join(self.repository.git_dir, 'FETCH_HEAD'), 'w') as f:
f.write("749656b8b3b282d11a4221bb84e48291ca23ecc6" \
" branch 'master' of git@{}/{}/{}".format(self.service.fqdn, namespace, repository))
return Replace('git.cmd.Popen', self.Popen)
def test_create_date_naive(self):
with self.settings(USE_TZ=False):
with Replace('webwhois.utils.public_response.date',
test_date(2017, 5, 25)):
public_response = PublicResponse(sentinel.object_type,
sentinel.public_request_id,
sentinel.request_type,
sentinel.handle,
sentinel.confirmation_method)
self.assertEqual(public_response.create_date, date(2017, 5, 25))
def test_replace_context_manager(self):
def test_z():
return 'replacement z'
compare(sample1.z(), 'original z')
with Replace('testfixtures.tests.sample1.z', test_z) as z:
compare(z(), 'replacement z')
compare(sample1.z(), 'replacement z')
compare(sample1.z(), 'original z')
def test_simple_strict_re_defaulted(self):
with Replace('testfixtures.LogCapture.default_ensure_checks_above',
ERROR):
LogCapture.default_ensure_checks_above = ERROR
log_capture = LogCapture()
root.error('during')
log_capture.uninstall()
with ShouldAssert(
"Not asserted ERROR log(s): [('root', 'ERROR', 'during')]"
):
log_capture.ensure_checked()
def test_not_in_git_repo(self, dir, capfd):
with Replace('os.environ.TAG', 'v1.2.3', strict=False):
with ShouldRaise(CalledProcessError):
version_not_tagged()
out, err = capfd.readouterr()
compare(out, expected='$ git remote -v\n')
compare(
err.lower(),
expected=
'fatal: not a git repository (or any of the parent directories): .git\n'
)
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_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_version_not_tagged(self, git, capfd):
with Replace('os.environ.TAG', '1.2.3', strict=False):
git.make_repo_with_content()
os.chdir(git.dir.getpath(git.repo))
assert version_not_tagged()
out, err = capfd.readouterr()
compare(out,
expected=('$ git remote -v\n'
'$ git rev-parse --verify -q 1.2.3\n'
'No tag found.\n'))
compare(err, expected='')
def test_simple(self, git, capfd):
with Replace('os.environ.TAG', 'v1.2.3', strict=False):
git.make_repo_with_content('remote')
git('clone remote local', git.dir.path)
git.check_tags(repo='local', expected={})
git.check_tags(repo='remote', expected={})
rev = git.rev_parse('HEAD')
os.chdir(git.dir.getpath('local'))
create_tag()
git.check_tags(repo='local', expected={b'v1.2.3': rev})
git.check_tags(repo='remote', expected={b'v1.2.3': rev})
capfd.readouterr()
def test_generated_methods(self):
for api_version, type_, name in self.methods_to_test():
session = Session('test', api_version=api_version)
obj = type_(session, ID='xxx')
method = getattr(obj, name)
workfront_name = re.search('``(.+?)``', method.__doc__).group(1)
server = MockOpen('https://test.attask-ondemand.com/attask/api/' +
api_version)
server.add(url='/{}/xxx/{}'.format(type_.code, workfront_name),
params='method=PUT',
response='{"data": {"result": null}}')
with Replace('workfront.six.moves.urllib.request.urlopen', server):
method()
def test_version_tagged(self, git, capfd):
with Replace('os.environ.TAG', 'v1.2.3', strict=False):
git.make_repo_with_content()
git('tag v1.2.3')
rev = git.rev_parse('HEAD')
os.chdir(git.dir.getpath(git.repo))
assert not version_not_tagged()
out, err = capfd.readouterr()
compare(out,
expected=('$ git remote -v\n'
'$ git rev-parse --verify -q v1.2.3\n'
f'{rev}\n'
'Version is already tagged.\n'))
compare(err, expected='')
