def test_auth_okta(self, _config_mock):
keyman = Keyman(["foo", "-o", "foo", "-u", "bar", "-a", "baz"])
keyman.okta_client = mock.MagicMock()
keyman.okta_client.auth.return_value = None
ret = keyman.auth_okta()
self.assertEqual(ret, None)
def test_auth_okta(self, _config_mock):
keyman = Keyman(['foo', '-o', 'foo', '-u', 'bar', '-a', 'baz'])
keyman.okta_client = mock.MagicMock()
keyman.okta_client.auth.return_value = None
ret = keyman.auth_okta()
self.assertEqual(ret, None)
def test_auth_okta_bad_password(self, _config_mock):
keyman = Keyman(['foo', '-o', 'foo', '-u', 'bar', '-a', 'baz'])
keyman.okta_client = mock.MagicMock()
keyman.okta_client.auth.side_effect = okta.InvalidPassword
with self.assertRaises(SystemExit):
keyman.auth_okta()
def test_handle_duo_factor_selection(self, _config_mock):
keyman = Keyman(['foo', '-o', 'foo', '-u', 'bar'])
keyman.config.accounts = [{'name': 'myAccount', 'appid': 'myID'}]
keyman.config.appid = None
keyman.selector_menu = mock.MagicMock(name='selector_menu')
keyman.selector_menu.return_value = 0
keyman.config.set_appid_from_account_id = mock.MagicMock()
ret = keyman.handle_duo_factor_selection()
keyman.selector_menu.assert_has_calls([
mock.call([{
'name': '📲 Duo Push',
'factor': 'push'
}, {
'name': '📟 OTP Passcode',
'factor': 'passcode'
}, {
'name': '📞 Phone call',
'factor': 'call'
}], [{
'name': 'Duo Factor'
}])
])
self.assertEqual(ret, 'push')
def test_init_okta(self, okta_mock, _config_mock):
okta_mock.OktaSaml = mock.MagicMock()
keyman = Keyman(['foo', '-o', 'foo', '-u', 'bar', '-a', 'baz'])
keyman.init_okta('troz')
okta_mock.OktaSaml.assert_has_calls(
[mock.call(mock.ANY, mock.ANY, 'troz', duo_factor=mock.ANY)])
def test_handle_appid_selection(self, _config_mock):
keyman = Keyman(['foo', '-o', 'foo', '-u', 'bar'])
keyman.config.accounts = [{
'name': 'myAccount',
'appid': 'myID'
}, {
'name': 'myAccount',
'appid': 'myID'
}]
keyman.config.appid = None
keyman.selector_menu = mock.MagicMock(name='selector_menu')
keyman.selector_menu.return_value = 0
keyman.config.set_appid_from_account_id = mock.MagicMock()
keyman.handle_appid_selection()
keyman.selector_menu.assert_has_calls([
mock.call([{
'name': 'myAccount',
'appid': 'myID'
}, {
'name': 'myAccount',
'appid': 'myID'
}], [{
'name': 'Account'
}])
])
keyman.config.set_appid_from_account_id.assert_has_calls(
[mock.call(0)])
def test_auth_okta_unknown_error(self, _config_mock):
keyman = Keyman(["foo", "-o", "foo", "-u", "bar", "-a", "baz"])
keyman.okta_client = mock.MagicMock()
keyman.okta_client.auth.side_effect = okta.UnknownError
with self.assertRaises(SystemExit):
keyman.auth_okta()
def test_selector_menu(self, _config_mock):
keyman = Keyman(['foo'])
Keyman.generate_template = mock.MagicMock()
Keyman.print_selector_table = mock.MagicMock()
keyman.user_input = mock.MagicMock()
keyman.user_input.side_effect = ['invalid', '', 0]
stuff = [{'artist': 'Metallica'}, {'artist': 'Soundgarden'}]
header = [{'artist': 'Artist'}]
ret = keyman.selector_menu(stuff, header)
self.assertEqual(ret, 0)
keyman.user_input.assert_has_calls([
mock.call('Selection: '),
mock.call('Selection: '),
mock.call('Selection: ')
])
Keyman.generate_template.assert_has_calls([
mock.call([{
'artist': 'Metallica'
}, {
'artist': 'Soundgarden'
}], [{
'artist': 'Artist'
}]),
])
Keyman.print_selector_table.assert_has_calls([
mock.call(mock.ANY, [{
'artist': 'Artist'
}], [{
'artist': 'Metallica'
}, {
'artist': 'Soundgarden'
}]),
])
def test_init_use_debug(self, config_mock):
config_mock().debug = True
keyman = Keyman(['foo', '-o', 'foo', '-u', 'bar', '-a', 'baz', '-D'])
log_level = logging.getLevelName(keyman.log.getEffectiveLevel())
self.assertEqual('DEBUG', log_level)
def test_handle_multiple_roles(self, _config_mock):
keyman = Keyman(["foo", "-o", "foo", "-u", "bar", "-a", "baz"])
keyman.selector_menu = mock.MagicMock()
keyman.selector_menu.return_value = 0
roles = [
{"account": "acct1", "role_name": "role1", "roleIdx": 0},
{"account": "acct1", "role_name": "role2", "roleIdx": 1},
]
mock_session = mock.MagicMock()
mock_session.available_roles.return_value = roles
keyman.config.account = None
keyman.config.role = None
keyman.handle_multiple_roles(mock_session)
keyman.selector_menu.assert_has_calls(
[
mock.call(
roles,
[{"account": "Account"}, {"role_name": "Role"}],
),
],
)
mock_session.assert_has_calls(
[
mock.call.available_roles(),
],
)
def test_handle_multiple_roles(self, _config_mock):
keyman = Keyman(['foo', '-o', 'foo', '-u', 'bar', '-a', 'baz'])
keyman.selector_menu = mock.MagicMock()
keyman.selector_menu.return_value = 0
roles = ([{
'account': 'acct1',
'role_name': 'role1',
'roleIdx': 0
}, {
'account': 'acct1',
'role_name': 'role2',
'roleIdx': 1
}])
mock_session = mock.MagicMock()
mock_session.available_roles.return_value = roles
keyman.config.account = None
keyman.config.role = None
keyman.handle_multiple_roles(mock_session)
keyman.selector_menu.assert_has_calls([
mock.call(roles, [{
'account': 'Account'
}, {
'role_name': 'Role'
}])
])
mock_session.assert_has_calls([mock.call.available_roles()])
def test_auth_okta_unknown_error(self, _config_mock):
keyman = Keyman(['foo', '-o', 'foo', '-u', 'bar', '-a', 'baz'])
keyman.okta_client = mock.MagicMock()
keyman.okta_client.auth.side_effect = okta.UnknownError
with self.assertRaises(SystemExit):
keyman.auth_okta()
def test_auth_okta_bad_password(self, _config_mock):
keyman = Keyman(["foo", "-o", "foo", "-u", "bar", "-a", "baz"])
keyman.okta_client = mock.MagicMock()
keyman.okta_client.auth.side_effect = okta.InvalidPassword
with self.assertRaises(SystemExit):
keyman.auth_okta()
def test_handle_multiple_roles_single_role_match(self, _config_mock):
keyman = Keyman(["foo", "-o", "foo", "-u", "bar", "-a", "baz"])
keyman.selector_menu = mock.MagicMock()
keyman.selector_menu.return_value = 0
roles = [
{"account": "acct1", "role_name": "role1", "roleIdx": 0},
{"account": "acct1", "role_name": "role2", "roleIdx": 1},
{"account": "acct2", "role_name": "role1", "roleIdx": 2},
{"account": "acct2", "role_name": "role2", "roleIdx": 3},
]
mock_session = mock.MagicMock()
mock_session.available_roles.return_value = roles
keyman.config.account = "acct1"
keyman.config.role = "role2"
assert keyman.handle_multiple_roles(mock_session)
assert keyman.role == 1
keyman.selector_menu.assert_not_called()
mock_session.assert_has_calls(
[
mock.call.available_roles(),
],
)
def test_update_old_pip(self, subp_mock, plat_mock):
keyman = Keyman(["foo", "-o", "foo", "-u", "bar"])
keyman.get_pip_version = mock.MagicMock()
keyman.get_pip_version.return_value = "100000"
keyman.log = mock.MagicMock()
plat_mock.system.return_value = "Linux"
subp_mock.check_call.return_value = 0
keyman.update(__version__)
keyman.log.info.assert_has_calls(
[
mock.call("New version 100000. Updaing.."),
],
)
subp_mock.assert_has_calls(
[
mock.call.check_call(
[
mock.ANY,
"-m",
"pip",
"install",
"--upgrade",
"aws-okta-keyman",
],
),
],
)
def test_handle_appid_selection(self, _config_mock):
keyman = Keyman(["foo", "-o", "foo", "-u", "bar"])
keyman.config.accounts = [
{"name": "myAccount", "appid": "myID"},
{"name": "myAccount", "appid": "myID"},
]
keyman.config.appid = None
keyman.selector_menu = mock.MagicMock(name="selector_menu")
keyman.selector_menu.return_value = 0
keyman.config.set_appid_from_account_id = mock.MagicMock()
keyman.handle_appid_selection()
keyman.selector_menu.assert_has_calls(
[
mock.call(
[
{"name": "myAccount", "appid": "myID"},
{"name": "myAccount", "appid": "myID"},
],
[{"name": "Account"}],
),
],
)
keyman.config.set_appid_from_account_id.assert_has_calls(
[
mock.call(0),
],
)
def test_start_session_okta_failure(self, _config_mock):
keyman = Keyman(["foo", "-o", "foo", "-u", "bar", "-a", "baz"])
keyman.okta_client = mock.MagicMock()
keyman.okta_client.get_assertion.side_effect = okta.UnknownError
with self.assertRaises(okta.UnknownError):
keyman.start_session()
def test_init_use_debug(self, config_mock):
config_mock().debug = True
keyman = Keyman(["foo", "-o", "foo", "-u", "bar", "-a", "baz", "-D"])
log_level = logging.getLevelName(keyman.log.getEffectiveLevel())
self.assertEqual("DEBUG", log_level)
def test_start_session_okta_failure(self, _config_mock):
keyman = Keyman(['foo', '-o', 'foo', '-u', 'bar', '-a', 'baz'])
keyman.okta_client = mock.MagicMock()
keyman.okta_client.get_assertion.side_effect = okta.UnknownError
with self.assertRaises(okta.UnknownError):
keyman.start_session()
def test_init_okta_with_empty_input(self, okta_mock, _config_mock):
okta_mock.EmptyInput = BaseException
okta_mock.OktaSaml = mock.MagicMock()
okta_mock.OktaSaml.side_effect = okta.EmptyInput
keyman = Keyman(['foo', '-o', 'foo', '-u', 'bar', '-a', 'baz'])
with self.assertRaises(SystemExit):
keyman.init_okta('troz')
def test_handle_multiple_roles_no_match_role(self, _config_mock):
keyman = Keyman(['foo', '-o', 'foo', '-u', 'bar', '-a', 'baz'])
keyman.selector_menu = mock.MagicMock()
keyman.selector_menu.return_value = 0
roles = ([{
'account': 'acct1',
'role_name': 'role1',
'roleIdx': 0
}, {
'account': 'acct1',
'role_name': 'role2',
'roleIdx': 1
}, {
'account': 'acct2',
'role_name': 'role1',
'roleIdx': 2
}])
mock_session = mock.MagicMock()
mock_session.available_roles.return_value = roles
keyman.config.account = 'role3'
keyman.config.role = None
assert not keyman.handle_multiple_roles(mock_session)
keyman.selector_menu.assert_not_called()
mock_session.assert_has_calls([mock.call.available_roles()])
def test_start_session_xml_failure(self, session_mock, _config_mock):
keyman = Keyman(["foo", "-o", "foo", "-u", "bar", "-a", "baz"])
keyman.okta_client = mock.MagicMock()
xml_error = xml.etree.ElementTree.ParseError()
session_mock.side_effect = xml_error
with self.assertRaises(aws.InvalidSaml):
keyman.start_session()
def test_main_keyboard_interrupt(self, _config_mock):
keyman = Keyman(['foo', '-o', 'foo', '-u', 'bar', '-a', 'baz'])
keyman.handle_appid_selection = mock.MagicMock()
keyman.user_password = mock.MagicMock()
keyman.user_password.side_effect = KeyboardInterrupt
with self.assertRaises(SystemExit):
keyman.main()
def test_main_unhandled_exception(self, _config_mock):
keyman = Keyman(['foo', '-o', 'foo', '-u', 'bar', '-a', 'baz'])
keyman.handle_appid_selection = mock.MagicMock()
keyman.user_password = mock.MagicMock()
keyman.user_password.side_effect = Exception()
with self.assertRaises(SystemExit):
keyman.main()
def test_init_okta_with_oktapreview(self, okta_mock, _config_mock):
okta_mock.OktaSaml = mock.MagicMock()
keyman = Keyman(['foo', '-o', 'foo', '-u', 'bar', '-a', 'baz'])
keyman.config.oktapreview = True
keyman.init_okta('troz')
okta_mock.OktaSaml.assert_has_calls(
[mock.call(mock.ANY, mock.ANY, 'troz', oktapreview=True)])
def test_main_unhandled_exception(self, _config_mock):
keyman = Keyman(["foo", "-o", "foo", "-u", "bar", "-a", "baz"])
keyman.handle_appid_selection = mock.MagicMock()
keyman.user_password = mock.MagicMock()
keyman.user_password.side_effect = Exception()
with self.assertRaises(SystemExit):
keyman.main()
def test_main_keyboard_interrupt(self, _config_mock):
keyman = Keyman(["foo", "-o", "foo", "-u", "bar", "-a", "baz"])
keyman.handle_appid_selection = mock.MagicMock()
keyman.user_password = mock.MagicMock()
keyman.user_password.side_effect = KeyboardInterrupt
with self.assertRaises(SystemExit):
keyman.main()
def test_update_current(self):
keyman = Keyman(['foo', '-o', 'foo', '-u', 'bar'])
keyman.get_pip_version = mock.MagicMock()
keyman.get_pip_version.return_value = __version__
keyman.log = mock.MagicMock()
keyman.update(__version__)
keyman.log.info.assert_has_calls([mock.call('Keyman is up to date')])
def test_handle_appid_selection_one_account(self, _config_mock):
keyman = Keyman(['foo', '-o', 'foo', '-u', 'bar'])
keyman.config.accounts = [{'name': 'myAccount', 'appid': 'myID'}]
keyman.config.appid = None
keyman.config.set_appid_from_account_id = mock.MagicMock()
keyman.handle_appid_selection()
keyman.config.set_appid_from_account_id.assert_has_calls(
[mock.call(0)])
def test_init_okta_with_empty_input(self, okta_mock, _config_mock):
okta_mock.EmptyInput = BaseException
okta_mock.OktaSaml = mock.MagicMock()
okta_mock.OktaSaml.side_effect = okta.EmptyInput
keyman = Keyman(["foo", "-o", "foo", "-u", "bar", "-a", "baz"])
with self.assertRaises(SystemExit):
keyman.init_okta("troz")
