def test_main(self):
with ArgvContext(program, '-p', 'dev', '--debug'):
output = {
'roleCredentials': {
'accessKeyId': 'AAAA4IGTCPYNIZGVJCVW',
'secretAccessKey':
'00GGc0cDG6WzbJIcDlw/gh0BaMOCKK0M/qDtDxR1',
'sessionToken': 'VeryLongBase664String==',
'expiration': datetime.utcnow().timestamp()
}
}
success = True
cli_v2 = 'aws-cli/2.0.9 Python/3.8.2 Darwin/19.4.0 botocore/2.0.0dev13 (MOCK)'
when(cli).invoke(contains('aws --version')).thenReturn(
(success, cli_v2))
when(cli).invoke(
contains('aws sts get-caller-identity')).thenReturn(
(success, 'does-not-matter'))
when(cli).invoke(
contains('aws sso get-role-credentials')).thenReturn(
(success, json.dumps(output)))
cli.main()
cred = cli.read_config(self.credentials.name)
new_tok = cred['dev']['aws_session_token']
self.assertNotEqual(new_tok, 'tok')
self.assertEqual(new_tok, 'VeryLongBase664String==')
verify(cli, times=3).invoke(...)
def test_prune_report(self):
_id = self.report.id
action = 'P'
proxy = mock()
when(xmlrpclib).ServerProxy(any(), allow_none=any()).thenReturn(proxy)
when(proxy).prune_report(contains(str(_id)), any()).thenReturn(False)
response = self.client.post('/report/action/%d/%s' %(_id, action))
self.assertEqual(200, response.status_code)
verify(proxy).prune_report(contains(str(_id)), contains(str("No Comment")))
self._verifyMessage(False, self.report.resultsName)
def test_prune_report(self):
_id = self.report.id
action = 'P'
proxy = mock()
when(xmlrpclib).ServerProxy(any(), allow_none=any()).thenReturn(proxy)
when(proxy).prune_report(contains(str(_id)), any()).thenReturn(False)
response = self.client.post('/report/action/%d/%s' % (_id, action))
self.assertEqual(200, response.status_code)
verify(proxy).prune_report(contains(str(_id)),
contains(str("No Comment")))
self._verifyMessage(False, self.report.resultsName)
def test_ensure_project_properties_are_logged_when_calling_log_project_properties(self):
project = Project("spam")
project.set_property("spam", "spam")
project.set_property("eggs", "eggs")
self.reactor.project = project
self.reactor.log_project_properties()
verify(self.logger).debug("Project properties: %s", contains("basedir : spam"))
verify(self.logger).debug("Project properties: %s", contains("eggs : eggs"))
verify(self.logger).debug("Project properties: %s", contains("spam : spam"))
def test_archive_report_with_comment(self):
comment = 'foo'
_id = self.report.id
action = 'A'
proxy = mock()
when(xmlrpclib).ServerProxy(any(), allow_none=any()).thenReturn(proxy)
when(proxy).archive_report(contains(str(_id)), any()).thenReturn(False)
response = self.client.post('/report/action/%d/%s' %(_id, action), data = {'comment':comment})
self.assertEqual(200, response.status_code)
verify(proxy).archive_report(contains(str(_id)), contains(comment))
self._verifyMessage(False, self.report.resultsName)
def test_fetch_credentials_with_assume_role_no_success(self):
when(cli).invoke(contains('aws sts assume-role')).thenReturn(
(False, "does-not-matter"))
when(cli).invoke(contains('aws iam get-role')).thenReturn(
(True, '{"Role": {"MaxSessionDuration": 3600}}'))
p = {
'role_arn': 'arn:aws:iam::1234567890:role/FullAdmin',
'region': 'us-east-1'
}
cred = cli.fetch_credentials_with_assume_role("default", p)
self.assertIsNone(cred)
def test_archive_report_with_comment(self):
comment = 'foo'
_id = self.report.id
action = 'A'
proxy = mock()
when(xmlrpclib).ServerProxy(any(), allow_none=any()).thenReturn(proxy)
when(proxy).archive_report(contains(str(_id)), any()).thenReturn(False)
response = self.client.post('/report/action/%d/%s' % (_id, action),
data={'comment': comment})
self.assertEqual(200, response.status_code)
verify(proxy).archive_report(contains(str(_id)), contains(comment))
self._verifyMessage(False, self.report.resultsName)
def test_fetch_credentials_with_assume_role_no_success_2(self):
when(cli).invoke(contains('aws sts assume-role')).thenReturn(
(False, "does-not-matter"))
when(cli).invoke(contains('aws iam get-role')).thenReturn(
(True, '{"Role": {"MaxSessionDuration": 3600}}'))
p = {
'role_arn': 'arn:aws:iam::1234567890:role/FullAdmin',
'region': 'us-east-1'
}
with self.assertRaises(SystemExit) as x:
cli.fetch_credentials_with_assume_role("default", p)
self.assertEqual(x.exception.code, 1)
def test_ensure_project_properties_are_logged_when_calling_log_project_properties(self):
project = Project("spam")
project.set_property("spam", "spam")
project.set_property("eggs", "eggs")
self.reactor.project = project
self.reactor.log_project_properties()
verify(self.logger).debug(
"Project properties: %s", contains("basedir : spam"))
verify(self.logger).debug(
"Project properties: %s", contains("eggs : eggs"))
verify(self.logger).debug(
"Project properties: %s", contains("spam : spam"))
def test_execute_restore(self):
"""This test should ensure backup agent
resolves backup instance
determines backup/restore type
transfers/downloads data and invokes the restore module
reports status
"""
backup = mock(DBBackup)
backup.location = "/backup/location/123"
backup.backup_type = 'InnoBackupEx'
when(utils).execute(contains('sudo rm -rf')).thenReturn(None)
when(utils).clean_out(any()).thenReturn(None)
when(backupagent).get_storage_strategy(any(), any()).thenReturn(
MockStorage)
when(backupagent).get_restore_strategy(
'InnoBackupEx', any()).thenReturn(MockRestoreRunner)
when(DatabaseModelBase).find_by(id='123').thenReturn(backup)
when(backup).save().thenReturn(backup)
agent = backupagent.BackupAgent()
bkup_info = {'id': '123',
'location': 'fake-location',
'type': 'InnoBackupEx',
'checksum': 'fake-checksum',
}
agent.execute_restore(TroveContext(), bkup_info, '/var/lib/mysql')
def test_aws_cli_version_fail(self):
when(cli).invoke(contains('aws --version')).thenReturn(
(False, 'does-not-matter'))
with ArgvContext(program, '-p', 'dev',
'-t'), self.assertRaises(SystemExit) as x:
cli.main()
self.assertEqual(x.exception.code, 1)
def test_execute_restore(self):
"""This test should ensure backup agent
resolves backup instance
determines backup/restore type
transfers/downloads data and invokes the restore module
reports status
"""
backup = mock(DBBackup)
backup.location = "/backup/location/123"
backup.backup_type = 'InnoBackupEx'
when(utils).execute(contains('sudo rm -rf')).thenReturn(None)
when(utils).clean_out(any()).thenReturn(None)
when(backupagent).get_storage_strategy(any(), any()).thenReturn(
MockStorage)
when(backupagent).get_restore_strategy(
'InnoBackupEx', any()).thenReturn(MockRestoreRunner)
when(DatabaseModelBase).find_by(id='123').thenReturn(backup)
when(backup).save().thenReturn(backup)
agent = backupagent.BackupAgent()
bkup_info = {'id': '123',
'location': 'fake-location',
'type': 'InnoBackupEx',
'checksum': 'fake-checksum',
}
agent.execute_restore(TroveContext(), bkup_info, '/var/lib/mysql')
def test_middleware_called_mixed(webapi, telegraf_client):
assert webapi.get('/a').status_code == 200
assert webapi.get('/b').status_code == 200
assert webapi.get('/c/1').status_code == 200
verify(telegraf_client, times=3).metric(contains('hits-'),
values={'hits': 1},
tags=any(dict))
def test_aws_cli_v1(self):
with ArgvContext(program, '-p', 'dev',
'-t'), self.assertRaises(SystemExit) as x:
mock_cli_v1 = 'aws-cli/1.18.61 Python/2.7.17 Linux/5.3.0-1020-azure botocore/1.16.11 (MOCK v1)'
when(cli).invoke(contains('aws --version')).thenReturn(
(True, mock_cli_v1))
cli.main()
self.assertEqual(x.exception.code, 1)
def _miktex():
when(base.BaseExternalTool)._is_installed().thenReturn(True)
when(elib).run(contains('--version'), mute=True).thenReturn(
('miktex version\ntext', 0))
miktex = MikTex()
miktex.install_dir = '.'
yield miktex
verify(base.BaseExternalTool)._is_installed()
def test_pandoc():
pandoc = external_tools.Pandoc()
exe = Path('exe')
when(pandoc).get_exe().thenReturn(exe)
when(elib).run(contains('--version'), mute=True).thenReturn(
('pandoc version\ntext', 0))
assert pandoc.get_version() == 'version'
assert pandoc.get_version() == 'version'
verifyStubbedInvocationsAreUsed()
def test_get_role_max_session_duration_no_success(self):
when(cli).invoke(contains('aws iam get-role')).thenReturn(
(False, "does-not-matter"))
p = {
'role_arn': 'arn:aws:iam::1234567890:role/FullAdmin',
'region': 'us-east-1'
}
duration_seconds = cli.get_role_max_session_duration("default", p)
self.assertEqual(3600, duration_seconds)
def test_login_command_default(self):
when(cli).poll(contains('aws sso login'), ...).thenReturn(True)
with ArgvContext(program, '-t', 'login'):
cli.main()
cred = cli.read_config(self.credentials.name)
new_tok = cred['default']['aws_session_token']
self.assertNotEqual(new_tok, 'tok')
self.assertEqual(new_tok, 'VeryLongBase664String==')
verify(cli, times=1).poll(...)
def test_login_command_fail(self):
when(cli).poll(contains('aws sso login'), ...).thenReturn(False)
with ArgvContext(program, '-t', 'login', '--profile', 'dev',
'--this'), self.assertRaises(SystemExit) as x:
cli.main()
self.assertEqual(x.exception.code, 1)
cred = cli.read_config(self.credentials.name)
tok_now = cred['dev']['aws_session_token']
self.assertEqual(tok_now, 'tok') # assert no update
verify(cli, times=1).invoke(...)
def test_login_command_export_vars_2(self):
when(cli).poll(contains('aws sso login'), ...).thenReturn(True)
with ArgvContext(program, '-t', '-e',
'login'), self.assertRaises(SystemExit) as x:
cli.main()
self.assertEqual(x.exception.code, 0)
cred = cli.read_config(self.credentials.name)
new_tok = cred['default']['aws_session_token']
self.assertNotEqual(new_tok, 'tok')
self.assertEqual(new_tok, 'VeryLongBase664String==')
verify(cli, times=1).poll(...)
def test_export_report(self):
_id = self.report.id
username = self.ionadmin.username
comment = "abc"
# returns method results directly
result = iondb.rundb.data.tasks.export_report(username, _id, comment)
self.assertEquals(result[0], True)
verifyMessage(self, True, self.report.resultsName)
verify(proxy).export_report(any(), contains(comment))
def test_archive_report(self):
_id = self.report.id
username = self.ionadmin.username
comment = "abc"
proxy = mock()
when(xmlrpclib).ServerProxy(any(), allow_none=any()).thenReturn(proxy)
proxyResult = True
when(proxy).archive_report(any(), any()).thenReturn(proxyResult)
# returns method results directly
result = iondb.backup.tasks.archive_report(username, _id, comment)
self.assertEquals(result[0], proxyResult)
verifyMessage(self, proxyResult, self.report.resultsName)
verify(proxy).archive_report(any(), contains(comment))
def test_archive_report_using_delay(self):
_id = self.report.id
username = self.ionadmin.username
comment = "abc"
proxy = mock()
when(xmlrpclib).ServerProxy(any(), allow_none=any()).thenReturn(proxy)
proxyResult = True
when(proxy).archive_report(any(), any()).thenReturn(proxyResult)
#returns ASyncResult wrapping method invocation results
result = iondb.backup.tasks.archive_report.delay(username, _id, comment)
self.assertEquals(result.get()[0], proxyResult)
verifyMessage(self, proxyResult, self.report.resultsName)
verify(proxy).archive_report(any(), contains(comment))
def test_restore_unknown(self):
backup = mock(DBBackup)
backup.location = "/backup/location/123"
backup.backup_type = 'foo'
when(utils).execute(contains('sudo rm -rf')).thenReturn(None)
when(utils).clean_out(any()).thenReturn(None)
when(DatabaseModelBase).find_by(id='123').thenReturn(backup)
when(backupagent).get_restore_strategy(
'foo', any()).thenRaise(ImportError)
agent = backupagent.BackupAgent()
self.assertRaises(UnknownBackupType, agent.execute_restore,
context=None, backup_id='123',
restore_location='/var/lib/mysql')
def test_restore_unknown(self):
backup = mock(DBBackup)
backup.location = "/backup/location/123"
backup.backup_type = 'foo'
when(utils).execute(contains('sudo rm -rf')).thenReturn(None)
when(utils).clean_out(any()).thenReturn(None)
when(DatabaseModelBase).find_by(id='123').thenReturn(backup)
when(backupagent).get_restore_strategy('foo',
any()).thenRaise(ImportError)
agent = backupagent.BackupAgent()
self.assertRaises(UnknownBackupType,
agent.execute_restore,
context=None,
backup_id='123',
restore_location='/var/lib/mysql')
def test_timer(self):
# user-defined outout_fn; recur
res = []
with qPyUtils.log.timer.Timer('Long task 中文',
output_fn=res.append) as timer:
with timer.child('large step'):
time.sleep(0.1)
for _ in range(5):
with timer.child('small step'):
time.sleep(0.05)
self.assertRegexpMatches(
res[0], r'Long task 中文: 0.3\d+s\n'
r' 5x small step: 0.2\d+s \(7\d%\)\n'
r' 1x large step: 0.1\d+s \(2\d%\)')
# user-defined fmt; stdout
with mockify(sys.stdout) as sys.stdout:
with qPyUtils.log.timer.Timer(
'Long task 中文', fmt='{name} --> {elapsed:.3f}') as timer:
time.sleep(0.1)
# print('\n'.join(timer.format()), file=sys.stderr)
verify(sys.stdout).write(contains('Long task 中文 --> 0.1'))
def test_show_logger_src(self):
LOGGER_NAME = "dummy_logger"
sys.stderr = mock(
{'write':
dummy_fn}) # clean console; CAUTION: before the 3rd-party logger
# 3rd-party logger
logger = logging.getLogger(LOGGER_NAME)
logger.setLevel(logging.DEBUG)
ch = logging.StreamHandler()
ch.setLevel(logging.DEBUG)
logger.addHandler(ch)
with mockify(sys.stderr) as sys.stderr:
# add handlers for root logger; catching any specific loggers
writer.init_log(LOGGER_NAME,
self.log_file_stem,
is_show_logger_src=True)
# using specific(may be 3rd-party) logger
logger.warning('dummy warning')
time.sleep(0.2)
# verify stderr
verify(sys.stderr, times=1).write(contains(LOGGER_NAME))
def setUp(self) -> None:
self.config = tempfile.NamedTemporaryFile()
conf_ini = b"""
[default]
sso_start_url = https://petshop.awsapps.com/start
sso_region = ap-southeast-2
sso_account_id = 9876543210
sso_role_name = AdministratorAccess
region = ap-southeast-2
output = json
[profile dev]
sso_start_url = https://petshop.awsapps.com/start
sso_region = ap-southeast-2
sso_account_id = 123456789
sso_role_name = AdministratorAccess
region = ap-southeast-2
output = json
[profile zzz]
region = ap-southeast-2
output = json
cli_pager =
[profile lab]
sso_start_url = https://petshop.awsapps.com/start
sso_region = ap-southeast-2
sso_account_id = 923456781
sso_role_name = AdministratorAccess
region = ap-southeast-2
output = json
[profile lab1]
sso_start_url = https://petshop.awsapps.com/start
sso_region = ap-southeast-2
sso_account_id = 9874567321
sso_role_name = AdministratorAccess
region = ap-southeast-2
output = json
[profile lab2]
sso_start_url = https://petshop.awsapps.com/start
sso_region = ap-southeast-2
sso_account_id = 983456721
sso_role_name = AdministratorAccess
region = ap-southeast-2
output = json
"""
self.config.write(conf_ini)
self.config.seek(0)
self.config.read()
self.credentials = tempfile.NamedTemporaryFile()
cred_ini = b"""
[default]
region = ap-southeast-2
aws_access_key_id = MOCK
aws_secret_access_key = MOCK
aws_session_token = tok
aws_session_expiration = 2020-05-27T18:21:43+0000
[dev]
region = ap-southeast-2
aws_access_key_id = MOCK
aws_secret_access_key = MOCK
aws_session_token = tok
aws_session_expiration = 2020-05-27T18:21:43+0000
"""
self.credentials.write(cred_ini)
self.credentials.seek(0)
self.credentials.read()
self.sso_cache_dir = tempfile.TemporaryDirectory()
self.sso_cache_json = tempfile.NamedTemporaryFile(
dir=self.sso_cache_dir.name, suffix='.json')
cache_json = {
"startUrl":
"https://petshop.awsapps.com/start",
"region":
"ap-southeast-2",
"accessToken":
"longTextA.AverylOngText",
"expiresAt":
f"{str((datetime.utcnow() + timedelta(hours=3)).isoformat())[:-7]}UTC"
}
self.sso_cache_json.write(json.dumps(cache_json).encode('utf-8'))
self.sso_cache_json.seek(0)
self.sso_cache_json.read()
cli.aws_config_file = self.config.name
cli.aws_shared_credentials_file = self.credentials.name
cli.aws_sso_cache_path = self.sso_cache_dir.name
mock_output = {
'roleCredentials': {
'accessKeyId': 'does-not-matter',
'secretAccessKey': 'does-not-matter',
'sessionToken': 'VeryLongBase664String==',
'expiration': datetime.utcnow().timestamp()
}
}
mock_assume_role = {
"Credentials": {
"AccessKeyId": "does-not-matter",
"SecretAccessKey": "does-not-matter",
"SessionToken": "VeryLongBase664String==",
"Expiration": "2020-06-13T17:15:23+00:00"
},
"AssumedRoleUser": {
"AssumedRoleId":
"does-not-matter:yawsso-session-1",
"Arn":
"arn:aws:sts::456789123:assumed-role/FullAdmin/yawsso-session-1"
}
}
mock_get_role = {
"Role": {
"Path": "/",
"RoleName": "FullAdmin",
"RoleId": "does-not-matter",
"Arn": "arn:aws:iam::456789123:role/FullAdmin",
"CreateDate": "2019-04-29T04:40:43+00:00",
"AssumeRolePolicyDocument": {
"Version":
"2012-10-17",
"Statement": [{
"Effect": "Allow",
"Principal": {
"AWS": "arn:aws:iam::123456789:root"
},
"Action": "sts:AssumeRole"
}]
},
"MaxSessionDuration": 43200,
"RoleLastUsed": {
"LastUsedDate": "2020-06-14T02:27:18+00:00",
"Region": "ap-southeast-2"
}
}
}
mock_success = True
mock_cli_v2 = 'aws-cli/2.0.9 Python/3.8.2 Darwin/19.4.0 botocore/2.0.0dev13 (MOCK)'
when(cli).invoke(contains('aws --version')).thenReturn(
(mock_success, mock_cli_v2))
when(cli).invoke(contains('aws sts get-caller-identity')).thenReturn(
(mock_success, 'does-not-matter'))
when(cli).invoke(contains('aws sso get-role-credentials')).thenReturn(
(mock_success, json.dumps(mock_output)))
when(cli).invoke(contains('aws iam get-role')).thenReturn(
(mock_success, json.dumps(mock_get_role)))
when(cli).invoke(contains('aws sts assume-role')).thenReturn(
(mock_success, json.dumps(mock_assume_role)))
def __init__(self, text):
self.contains = contains(text)
def testShouldNotSatisfiyStringWhichIsNotSubstringOfGivenString(self):
self.assertFalse(contains("barfoo").matches("foobar"))
def test_sso_get_role_credentials_fail(self):
when(cli).invoke(contains('aws sso get-role-credentials')).thenReturn(
(False, 'does-not-matter'))
with self.assertRaises(SystemExit) as x:
cli.update_profile("dev", cli.read_config(self.config.name))
self.assertEqual(x.exception.code, 1)
def I_should_not_see(context, msg):
verify(context.output, never).write(contains(msg))
def testVerifiesUsingContainsMatcher(self):
ourMock = mock()
ourMock.foo("foobar")
verify(ourMock).foo(contains("foo"))
verify(ourMock).foo(contains("bar"))
def testShouldNotSatisfiyNone(self):
self.assertFalse(contains(None).matches("foobar"))
def testShouldSatisfiySubstringOfGivenString(self):
self.assertTrue(contains("foo").matches("foobar"))
def test_sts_get_caller_identity_fail(self):
when(cli).invoke(contains('aws sts get-caller-identity')).thenReturn(
(False, 'does-not-matter'))
with self.assertRaises(SystemExit) as x:
cli.update_profile("dev", cli.read_config(self.config.name))
self.assertEqual(x.exception.code, 1)
def testShouldNotSatisfiyNone(self):
self.assertFalse(contains(None).matches("foobar"))
def given_response_for_url(self, url, response): open_url = mock() when(self.urllib).urlopen(contains(url)).thenReturn(open_url) when(open_url).read().thenReturn(response)
def testVerifiesUsingContainsMatcher(self):
ourMock = mock()
ourMock.foo("foobar")
verify(ourMock).foo(contains("foo"))
verify(ourMock).foo(contains("bar"))
def testShouldSatisfySameString(self):
self.assertTrue(contains("foobar").matches("foobar"))
def testShouldSatisfySameString(self):
self.assertTrue(contains("foobar").matches("foobar"))
def testShouldNotSatisfiyStringWhichIsNotSubstringOfGivenString(self):
self.assertFalse(contains("barfoo").matches("foobar"))
def testShouldNotSatisfiyEmptyString(self):
self.assertFalse(contains("").matches("foobar"))
def testShouldNotSatisfiyEmptyString(self):
self.assertFalse(contains("").matches("foobar"))
def then_i_should_see_msg(context, msg):
verify(context.output).write(contains(msg))
