Asib27's picture
try 1
065fee7 verified
raw
history blame
42.7 kB
import datetime
import typing
from test.unit import MockCredentialsProvider
from unittest import mock
from unittest.mock import MagicMock, call
import pytest # type: ignore
from dateutil.tz import tzutc
from pytest_mock import mocker # type: ignore
from redshift_connector import InterfaceError, ProgrammingError, RedshiftProperty
from redshift_connector.auth import AWSCredentialsProvider
from redshift_connector.config import ClientProtocolVersion
from redshift_connector.credentials_holder import CredentialsHolder
from redshift_connector.iam_helper import IamHelper
from redshift_connector.idp_auth_helper import IdpAuthHelper
from redshift_connector.plugin import (
AdfsCredentialsProvider,
AzureCredentialsProvider,
BasicJwtCredentialsProvider,
BrowserAzureCredentialsProvider,
BrowserSamlCredentialsProvider,
OktaCredentialsProvider,
PingCredentialsProvider,
)
from .helpers import make_redshift_property
@pytest.fixture
def mock_set_iam_credentials(mocker):
mocker.patch("redshift_connector.iam_helper.IamHelper.set_iam_credentials", return_value=None)
@pytest.fixture
def mock_set_cluster_credentials(mocker):
mocker.patch("redshift_connector.iam_helper.IamHelper.set_cluster_credentials", return_value=None)
@pytest.fixture
def mock_all_provider_get_credentials(mocker):
for provider in [
"OktaCredentialsProvider",
"AzureCredentialsProvider",
"BrowserAzureCredentialsProvider",
"PingCredentialsProvider",
"AdfsCredentialsProvider",
"BrowserSamlCredentialsProvider",
"SamlCredentialsProvider",
]:
mocker.patch("redshift_connector.plugin.{}.get_credentials".format(provider), return_value=None)
def make_basic_redshift_property(**kwargs) -> RedshiftProperty:
rp: RedshiftProperty = RedshiftProperty()
rp.put("user_name", "awsuser")
rp.put("host", "redshift-cluster-1.abcdefghijk.us-east-1.redshift.amazonaws.com")
rp.put("db_name", "dev")
for k, v in kwargs.items():
rp.put(k, v)
return rp
@pytest.mark.usefixtures("mock_set_iam_credentials")
def test_set_iam_properties_fails_when_non_str_credential_provider() -> None:
keywords: typing.Dict[str, typing.Union[int, bool]] = {
"credentials_provider": 1,
"iam": True,
}
with pytest.raises(InterfaceError) as excinfo:
IamHelper.set_iam_properties(make_basic_redshift_property(**keywords))
assert "Invalid connection property setting" in str(excinfo.value)
ssl_mode_descriptions: typing.List[typing.Tuple[typing.Optional[str], str]] = [
("verify-ca", "verify-ca"),
("verify-full", "verify-full"),
("disable", "verify-ca"),
("allow", "verify-ca"),
("prefer", "verify-ca"),
("require", "verify-ca"),
("bogus", "verify-ca"),
(None, "verify-ca"),
]
@pytest.mark.usefixtures("mock_set_iam_credentials")
@pytest.mark.parametrize("ssl_param", ssl_mode_descriptions)
def test_set_iam_properties_enforce_min_ssl_mode(ssl_param) -> None:
test_input, expected_mode = ssl_param
keywords: typing.Dict[str, typing.Union[str, bool]] = {
"sslmode": test_input,
"ssl": True,
"host": "redshift-cluster-1.aaaaaaaaaaaa.us-east-1.redshift.amazonaws.com",
}
rp: RedshiftProperty = make_basic_redshift_property(**keywords)
if test_input is None:
assert rp.sslmode == expected_mode
else:
assert rp.sslmode == test_input
IamHelper.set_iam_properties(rp)
assert rp.sslmode == expected_mode
client_protocol_version_values: typing.List[int] = ClientProtocolVersion.list()
@pytest.mark.parametrize("_input", client_protocol_version_values)
def test_set_iam_properties_enforce_client_protocol_version(_input) -> None:
keywords: typing.Dict[str, typing.Union[str, int]] = {
"client_protocol_version": _input,
"host": "redshift-cluster-1.aaaaaaaaaaaa.us-east-1.redshift.amazonaws.com",
}
rp: RedshiftProperty = make_basic_redshift_property(**keywords)
assert rp.client_protocol_version == _input
IamHelper.set_iam_properties(rp)
assert rp.client_protocol_version == _input
multi_req_params: typing.List[typing.Tuple[typing.Dict, str]] = [
(
{"ssl": False, "iam": True},
"Invalid connection property setting. cluster_identifier must be provided when IAM is enabled",
),
(
{"iam": True, "ssl": True},
"Invalid connection property setting",
),
(
{
"iam": True,
"ssl": True,
"access_key_id": "my_key",
"credentials_provider": "OktaCredentialsProvider",
"cluster_identifier": "my_cluster",
},
"Invalid connection property setting. It is not valid to provide both Credentials provider and AWS credentials or AWS profile",
),
(
{
"iam": True,
"ssl": True,
"secret_access_key": "my_secret",
"credentials_provider": "OktaCredentialsProvider",
"cluster_identifier": "my_cluster",
},
"Invalid connection property setting. It is not valid to provide both Credentials provider and AWS credentials or AWS profile",
),
(
{
"iam": True,
"ssl": True,
"session_token": "token",
"credentials_provider": "OktaCredentialsProvider",
"cluster_identifier": "my_cluster",
},
"Invalid connection property setting. It is not valid to provide both Credentials provider and AWS credentials or AWS profile",
),
(
{
"iam": True,
"ssl": True,
"profile": "default",
"credentials_provider": "OktaCredentialsProvider",
"cluster_identifier": "my_cluster",
},
"Invalid connection property setting. It is not valid to provide both Credentials provider and AWS credentials or AWS profile",
),
(
{"iam": True, "ssl": True, "credentials_provider": 1, "cluster_identifier": "my_cluster"},
"Invalid connection property setting. It is not valid to provide a non-string value to credentials_provider.",
),
(
{"iam": True, "ssl": True, "profile": "default", "access_key_id": "my_key", "cluster_identifier": "my_cluster"},
"Invalid connection property setting. It is not valid to provide any of access_key_id, secret_access_key, or session_token when profile is provided",
),
(
{
"iam": True,
"ssl": True,
"profile": "default",
"secret_access_key": "my_secret",
"cluster_identifier": "my_cluster",
},
"Invalid connection property setting. It is not valid to provide any of access_key_id, secret_access_key, or session_token when profile is provided",
),
(
{"iam": True, "ssl": True, "profile": "default", "session_token": "token", "cluster_identifier": "my_cluster"},
"Invalid connection property setting. It is not valid to provide any of access_key_id, secret_access_key, or session_token when profile is provided",
),
(
{"iam": True, "ssl": True, "access_key_id": "my_access_key", "cluster_identifier": "my_cluster"},
"Invalid connection property setting. secret access key must be provided in either secret_access_key or password field",
),
(
{"iam": True, "ssl": True, "cluster_identifier": "my_cluster", "secret_access_key": "someSecretAccessKey"},
"Invalid connection property setting. access_key_id is required when secret_access_key is provided",
),
(
{"iam": True, "ssl": True, "cluster_identifier": "my_cluster", "session_token": "someSessionToken"},
"Invalid connection property setting. access_key_id and secret_access_key are required when session_token is provided",
),
(
{"iam": True, "ssl": True, "secret_access_key": "my_secret"},
"Invalid connection property setting",
),
(
{"iam": True, "ssl": True, "session_token": "token"},
"Invalid connection property setting",
),
(
{"iam": True, "ssl": True, "access_key_id": "my_key", "password": ""},
"Invalid connection property setting",
),
(
{
"iam": True,
"ssl": True,
},
"Invalid connection property setting. cluster_identifier must be provided when IAM is enabled",
),
(
{"iam": True, "ssl": True, "credentials_provider": "SomeProvider"},
"Invalid connection property setting. cluster_identifier must be provided when IAM is enabled",
),
(
{"iam": True, "ssl": True, "cluster_identifier": "some-cluster", "auth_profile": "someAuthProfile"},
"Invalid connection property setting. access_key_id, secret_access_key, and region are required for authentication via Redshift auth_profile",
),
]
@pytest.mark.usefixtures("mock_set_iam_credentials")
@pytest.mark.parametrize("joint_params", multi_req_params)
def test_set_iam_properties_enforce_setting_compatibility(mocker, joint_params) -> None:
test_input, expected_exception_msg = joint_params
with pytest.raises(InterfaceError) as excinfo:
IamHelper.set_iam_properties(make_basic_redshift_property(**test_input))
assert expected_exception_msg in str(excinfo.value)
valid_credential_providers: typing.List[typing.Tuple[str, typing.Any]] = [
("OktaCredentialsProvider", OktaCredentialsProvider),
("AzureCredentialsProvider", AzureCredentialsProvider),
("BrowserAzureCredentialsProvider", BrowserAzureCredentialsProvider),
("PingCredentialsProvider", PingCredentialsProvider),
("BrowserSamlCredentialsProvider", BrowserSamlCredentialsProvider),
("AdfsCredentialsProvider", AdfsCredentialsProvider),
("BasicJwtCredentialsProvider", BasicJwtCredentialsProvider),
]
def test_set_iam_properties_raises_exception_when_info_is_none() -> None:
with pytest.raises(InterfaceError) as excinfo:
IamHelper.set_auth_properties(None) # type: ignore
assert "Invalid connection property setting. info must be specified" in str(excinfo.value)
def mock_add_parameter():
return mocker.patch
@pytest.mark.usefixtures("mock_all_provider_get_credentials")
@pytest.mark.usefixtures("mock_set_cluster_credentials")
@pytest.mark.parametrize("provider", valid_credential_providers)
def test_set_iam_properties_provider_assigned(mocker, provider) -> None:
test_input, expectedProvider = provider
mocker.patch("redshift_connector.plugin.{}.get_credentials".format(test_input))
rp: RedshiftProperty = make_redshift_property()
rp.credentials_provider = test_input
spy = mocker.spy(expectedProvider, "add_parameter")
IamHelper.set_iam_credentials(rp)
assert spy.called
assert spy.call_count == 1
# ensure call to add_Parameter was made on the expected Provider class
assert isinstance(spy.call_args[0][0], expectedProvider) is True
valid_aws_credential_args: typing.List[typing.Dict[str, str]] = [
{"user": "", "password": "", "profile": "default"},
{"user": "", "password": "", "access_key_id": "myAccessKey", "secret_access_key": "mySecret"},
{"user": "", "secret_access_key": "", "access_key_id": "myAccessKey", "password": "myHiddenSecret"},
{
"user": "",
"password": "",
"access_key_id": "myAccessKey",
"secret_access_key": "mySecret",
"session_token": "mySession",
},
{"user": "", "password": "", "credentials_provider": "BrowserSamlCredentialsProvider"},
]
@pytest.mark.parametrize("test_input", valid_aws_credential_args)
def test_set_iam_properties_via_aws_credentials(mocker, test_input) -> None:
# spy = mocker.spy("redshift_connector", "set_iam_credentials")
rp: RedshiftProperty = make_basic_redshift_property(
**{**test_input, **{"ssl": True, "iam": True, "cluster_identifier": "blah"}}
)
mocker.patch("redshift_connector.iam_helper.IamHelper.set_iam_credentials", return_value=None)
IamHelper.set_iam_properties(rp)
for aws_cred_key, aws_cred_val in enumerate(test_input):
if aws_cred_key == "profile":
assert rp.profile == aws_cred_val
if aws_cred_key == "access_key_id":
assert rp.access_key_id == aws_cred_val
if aws_cred_key == "secret_access_key":
assert rp.secret_access_key == aws_cred_val
if aws_cred_key == "password":
assert rp.password == aws_cred_val
if aws_cred_key == "session_token":
assert rp.session_token == aws_cred_val
def test_set_iam_credentials_via_aws_credentials(mocker) -> None:
redshift_property: RedshiftProperty = RedshiftProperty()
redshift_property.profile = "profile_val"
redshift_property.access_key_id = "access_val"
redshift_property.secret_access_key = "secret_val"
redshift_property.session_token = "session_val"
redshift_property.host = "redshift-cluster-1.aaaaaaaaaaaa.amazonaws.com"
mocker.patch("redshift_connector.iam_helper.IamHelper.set_cluster_credentials", return_value=None)
spy = mocker.spy(AWSCredentialsProvider, "add_parameter")
IamHelper.set_iam_credentials(redshift_property)
assert spy.called is True
assert spy.call_count == 1
assert spy.call_args[0][1] == redshift_property
@mock.patch("boto3.client")
def test_set_iam_credentials_for_serverless_uses_redshift_serverless_client(
mock_boto_client, serverless_iam_db_kwargs
) -> None:
rp: RedshiftProperty = RedshiftProperty()
for k, v in serverless_iam_db_kwargs.items():
rp.put(k, v)
mock_cred_provider = MagicMock()
mock_cred_holder = MagicMock()
mock_cred_provider.get_credentials.return_value = mock_cred_holder
mock_cred_holder.has_associated_session = False
IamHelper.set_cluster_credentials(mock_cred_provider, rp)
# ensure client creation
assert mock_boto_client.called is True
assert mock_boto_client.call_count == 1
assert mock_boto_client.call_args[1]["service_name"] == "redshift-serverless"
@mock.patch("boto3.client")
@pytest.mark.parametrize(
"serverless_host",
(
"testwg1.012345678901.us-east-2.redshift-serverless.amazonaws.com",
"012345678901.us-east-2.redshift-serverless.amazonaws.com",
),
)
def test_set_iam_credentials_for_serverless_calls_get_credentials(
mock_boto_client, serverless_host, mocker, serverless_iam_db_kwargs
) -> None:
rp: RedshiftProperty = RedshiftProperty()
for k, v in serverless_iam_db_kwargs.items():
rp.put(k, v)
rp.set_serverless_acct_id()
rp.set_region_from_host()
rp.set_serverless_work_group_from_host()
mock_cred_provider = MagicMock()
mock_cred_holder = MagicMock()
mock_cred_provider.get_credentials.return_value = mock_cred_holder
mock_cred_holder.has_associated_session = False
spy = mocker.spy(rp, "put")
IamHelper.set_cluster_credentials(mock_cred_provider, rp)
# ensure describe_configuration is called
if rp.serverless_work_group:
mock_boto_client.assert_has_calls(
[call().get_credentials(dbName=rp.db_name, workgroupName=rp.serverless_work_group)]
)
else:
mock_boto_client.assert_has_calls([call().get_credentials(dbName=rp.db_name)])
# ensure host, port values were set
assert spy.called
# ensure RedshiftProperty.put method was called
assert "user_name" in [c[0][0] for c in spy.call_args_list]
assert "password" in [c[0][0] for c in spy.call_args_list]
def test_serverless_properties_used_when_is_serverless_true(mocker) -> None:
rp: RedshiftProperty = RedshiftProperty()
rp.host = "test-endpoint-xxxx.123456789123.us-east-2.redshift-serverless.amazonaws.com"
rp.is_serverless = True
rp.serverless_work_group = "something"
rp.serverless_acct_id = "111111111111"
mocker.patch(
"redshift_connector.native_plugin_helper.NativeAuthPluginHelper.get_native_auth_plugin_credentials",
return_value=None,
)
result = IamHelper.set_iam_properties(rp)
assert result.is_serverless == True
assert result.serverless_work_group == rp.serverless_work_group
assert result.serverless_acct_id == rp.serverless_acct_id
def test_internal_is_serverless_prop_true_for_nlb_host() -> None:
rp: RedshiftProperty = RedshiftProperty()
rp.is_serverless = True
assert rp._is_serverless is True
@pytest.mark.parametrize(
"serverless_host",
(
"testwg1.012345678901.us-east-2.redshift-serverless.amazonaws.com",
"012345678901.us-east-2.redshift-serverless.amazonaws.com",
),
)
def test_internal_is_serverless_prop_true_for_serverless_host(serverless_host) -> None:
rp: RedshiftProperty = RedshiftProperty()
rp.host = serverless_host
rp.serverless_work_group = "something"
rp.serverless_acct_id = "111111111111"
assert rp._is_serverless is True
def test_dynamically_loading_credential_holder(mocker) -> None:
external_class_name: str = "test.unit.MockCredentialsProvider"
mocker.patch("{}.get_credentials".format(external_class_name))
mocker.patch("redshift_connector.iam_helper.IamHelper.set_cluster_credentials", return_value=None)
rp: RedshiftProperty = make_redshift_property()
rp.credentials_provider = external_class_name
spy = mocker.spy(MockCredentialsProvider, "add_parameter")
IamHelper.set_iam_credentials(rp)
assert spy.called
assert spy.call_count == 1
# ensure call to add_Parameter was made on the expected Provider class
assert isinstance(spy.call_args[0][0], MockCredentialsProvider) is True
def test_get_credentials_cache_key() -> None:
rp: RedshiftProperty = RedshiftProperty()
rp.db_user = "2"
rp.db_name = "1"
rp.db_groups = ["4", "3", "5"]
rp.cluster_identifier = "6"
rp.auto_create = False
res_cache_key: str = IamHelper.get_credentials_cache_key(rp, None) # type: ignore
assert res_cache_key is not None
assert res_cache_key == "2;1;3,4,5;6;False;900"
def test_get_credentials_cache_key_no_db_groups() -> None:
rp: RedshiftProperty = RedshiftProperty()
rp.db_user = "2"
rp.db_name = "1"
rp.cluster_identifier = "6"
rp.auto_create = False
res_cache_key: str = IamHelper.get_credentials_cache_key(rp, None) # type: ignore
assert res_cache_key is not None
assert res_cache_key == "2;1;6;False;900"
@mock.patch("boto3.client.get_cluster_credentials")
@mock.patch("boto3.client")
def test_set_cluster_credentials_uses_custom_domain_name_if_custom_domain_name_cluster(
mock_boto_client, mock_get_cluster_credentials
) -> None:
mock_cred_provider = MagicMock()
mock_cred_holder = MagicMock()
mock_cred_provider.get_credentials.return_value = mock_cred_holder
mock_cred_provider.get_cache_key.return_value = "mocked"
mock_cred_holder.has_associated_session = False
rp: RedshiftProperty = make_redshift_property()
rp.put("cluster_identifier", None)
rp.put("host", "mycustom.domain.name")
rp.put("is_cname", True)
IamHelper.credentials_cache.clear()
IamHelper.set_cluster_credentials(mock_cred_provider, rp)
assert mock_boto_client.called is True
mock_boto_client.assert_has_calls(
[
call().get_cluster_credentials(
AutoCreate=rp.auto_create,
CustomDomainName=rp.host,
DbGroups=rp.db_groups,
DbName=rp.db_name,
DbUser=rp.db_user,
)
]
)
@mock.patch("boto3.client.get_credentials")
@mock.patch("boto3.client")
def test_set_cluster_credentials_uses_custom_domain_name_if_custom_domain_name_serverless(
mock_boto_client, mock_get_cluster_credentials
):
mock_cred_provider = MagicMock()
mock_cred_holder = MagicMock()
mock_cred_provider.get_credentials.return_value = mock_cred_holder
mock_cred_provider.get_cache_key.return_value = "mocked"
mock_cred_holder.has_associated_session = False
rp: RedshiftProperty = make_redshift_property()
rp.put("cluster_identifier", None)
rp.put("host", "mycustom.domain.name")
rp.put("is_serverless", True)
rp.put("is_cname", True)
IamHelper.credentials_cache.clear()
IamHelper.set_cluster_credentials(mock_cred_provider, rp)
assert mock_boto_client.called is True
mock_boto_client.assert_has_calls(
[
call().get_credentials(
customDomainName=rp.host,
dbName=rp.db_name,
)
]
)
@mock.patch("boto3.client.get_credentials")
@mock.patch("boto3.client")
def test_set_cluster_credentials_uses_workgroup_if_nlb_serverless(mock_boto_client, mock_get_cluster_credentials):
mock_cred_provider = MagicMock()
mock_cred_holder = MagicMock()
mock_cred_provider.get_credentials.return_value = mock_cred_holder
mock_cred_provider.get_cache_key.return_value = "mocked"
mock_cred_holder.has_associated_session = False
rp: RedshiftProperty = make_redshift_property()
rp.put("cluster_identifier", None)
rp.put("host", "mycustom.domain.name")
rp.put("is_serverless", True)
rp.put("serverless_work_group", "xyz")
rp.put("serverless_acct_id", "012345678901")
IamHelper.credentials_cache.clear()
IamHelper.set_cluster_credentials(mock_cred_provider, rp)
assert mock_boto_client.called is True
mock_boto_client.assert_has_calls(
[
call().get_credentials(
workgroupName=rp.serverless_work_group,
dbName=rp.db_name,
)
]
)
@mock.patch("boto3.client.get_cluster_credentials")
@mock.patch("boto3.client")
def test_set_cluster_credentials_caches_credentials(mock_boto_client, mock_get_cluster_credentials) -> None:
mock_cred_provider = MagicMock()
mock_cred_holder = MagicMock()
mock_cred_provider.get_credentials.return_value = mock_cred_holder
mock_cred_provider.get_cache_key.return_value = "mocked"
mock_cred_holder.has_associated_session = False
rp: RedshiftProperty = make_redshift_property()
IamHelper.credentials_cache.clear()
IamHelper.set_cluster_credentials(mock_cred_provider, rp)
assert len(IamHelper.credentials_cache) == 1
assert mock_boto_client.called is True
mock_boto_client.assert_has_calls(
[
call().get_cluster_credentials(
AutoCreate=rp.auto_create,
ClusterIdentifier=rp.cluster_identifier,
DbGroups=rp.db_groups,
DbName=rp.db_name,
DbUser=rp.db_user,
)
]
)
@mock.patch("boto3.client.get_cluster_credentials")
@mock.patch("boto3.client")
def test_set_cluster_credentials_honors_iam_disable_cache(mock_boto_client, mock_get_cluster_credentials) -> None:
mock_cred_provider = MagicMock()
mock_cred_holder = MagicMock()
mock_cred_provider.get_credentials.return_value = mock_cred_holder
mock_cred_holder.has_associated_session = False
rp: RedshiftProperty = make_redshift_property()
rp.iam_disable_cache = True
IamHelper.credentials_cache.clear()
IamHelper.set_cluster_credentials(mock_cred_provider, rp)
assert len(IamHelper.credentials_cache) == 0
assert mock_boto_client.called is True
mock_boto_client.assert_has_calls(
[
call().get_cluster_credentials(
AutoCreate=rp.auto_create,
ClusterIdentifier=rp.cluster_identifier,
DbGroups=rp.db_groups,
DbName=rp.db_name,
DbUser=rp.db_user,
)
]
)
@mock.patch("boto3.client.get_cluster_credentials")
@mock.patch("boto3.client")
def test_set_cluster_credentials_ignores_cache_when_disabled(mock_boto_client, mock_get_cluster_credentials) -> None:
mock_cred_provider = MagicMock()
mock_cred_holder = MagicMock()
mock_cred_provider.get_credentials.return_value = mock_cred_holder
mock_cred_holder.has_associated_session = False
rp: RedshiftProperty = make_redshift_property()
rp.iam_disable_cache = True
# mock out the boto3 response temporary credentials stored from prior auth
mock_cred_obj: typing.Dict[str, typing.Union[str, datetime.datetime]] = {
"DbUser": "xyz",
"DbPassword": "turtle",
"Expiration": datetime.datetime(9999, 1, 1, tzinfo=tzutc()),
}
# populate the cache
IamHelper.credentials_cache.clear()
IamHelper.credentials_cache[IamHelper.get_credentials_cache_key(rp, mock_cred_provider)] = mock_cred_obj
IamHelper.set_cluster_credentials(mock_cred_provider, rp)
assert len(IamHelper.credentials_cache) == 1
assert IamHelper.credentials_cache[IamHelper.get_credentials_cache_key(rp, mock_cred_provider)] is mock_cred_obj
assert mock_boto_client.called is True
# we should not have retrieved user/password from the cache
assert rp.user_name != mock_cred_obj["DbUser"]
assert rp.password != mock_cred_obj["DbPassword"]
assert (
call().get_cluster_credentials(
AutoCreate=rp.auto_create,
ClusterIdentifier=rp.cluster_identifier,
DbGroups=rp.db_groups,
DbName=rp.db_name,
DbUser=rp.db_user,
)
in mock_boto_client.mock_calls
)
@mock.patch("boto3.client.get_cluster_credentials")
@mock.patch("boto3.client")
def test_set_cluster_credentials_uses_cache_if_possible(mock_boto_client, mock_get_cluster_credentials) -> None:
mock_cred_provider = MagicMock()
mock_cred_holder = MagicMock()
mock_cred_provider.get_credentials.return_value = mock_cred_holder
mock_cred_holder.has_associated_session = False
rp: RedshiftProperty = make_redshift_property()
# mock out the boto3 response temporary credentials stored from prior auth
mock_cred_obj: typing.Dict[str, typing.Union[str, datetime.datetime]] = {
"DbUser": "xyz",
"DbPassword": "turtle",
"Expiration": datetime.datetime(9999, 1, 1, tzinfo=tzutc()),
}
# populate the cache
IamHelper.credentials_cache.clear()
IamHelper.credentials_cache[IamHelper.get_credentials_cache_key(rp, mock_cred_provider)] = mock_cred_obj
IamHelper.set_cluster_credentials(mock_cred_provider, rp)
assert len(IamHelper.credentials_cache) == 1
assert IamHelper.credentials_cache[IamHelper.get_credentials_cache_key(rp, mock_cred_provider)] is mock_cred_obj
assert mock_boto_client.called is True
assert rp.user_name == mock_cred_obj["DbUser"]
assert rp.password == mock_cred_obj["DbPassword"]
assert (
call().get_cluster_credentials(
AutoCreate=rp.auto_create,
ClusterIdentifier=rp.cluster_identifier,
DbGroups=rp.db_groups,
DbName=rp.db_name,
DbUser=rp.db_user,
)
not in mock_boto_client.mock_calls
)
@mock.patch("boto3.client.get_cluster_credentials")
@mock.patch("boto3.client")
def test_set_cluster_credentials_refreshes_stale_credentials(mock_boto_client, mock_get_cluster_credentials) -> None:
mock_cred_provider = MagicMock()
mock_cred_holder = MagicMock()
mock_cred_provider.get_credentials.return_value = mock_cred_holder
mock_cred_holder.has_associated_session = False
rp: RedshiftProperty = make_redshift_property()
# mock out the boto3 response temporary credentials stored from prior auth (now stale)
mock_cred_obj: typing.Dict[str, typing.Union[str, datetime.datetime]] = {
"DbUser": "xyz",
"DbPassword": "turtle",
"Expiration": datetime.datetime(1, 1, 1, tzinfo=tzutc()),
}
# populate the cache
IamHelper.credentials_cache.clear()
IamHelper.credentials_cache[IamHelper.get_credentials_cache_key(rp, mock_cred_provider)] = mock_cred_obj
IamHelper.set_cluster_credentials(mock_cred_provider, rp)
assert len(IamHelper.credentials_cache) == 1
# ensure new temporary credentials have been replaced in cache
assert IamHelper.get_credentials_cache_key(rp, mock_cred_provider) in IamHelper.credentials_cache
assert IamHelper.credentials_cache[IamHelper.get_credentials_cache_key(rp, mock_cred_provider)] is not mock_cred_obj
assert mock_boto_client.called is True
mock_boto_client.assert_has_calls(
[
call().get_cluster_credentials(
AutoCreate=rp.auto_create,
ClusterIdentifier=rp.cluster_identifier,
DbGroups=rp.db_groups,
DbName=rp.db_name,
DbUser=rp.db_user,
)
]
)
def test_get_authentication_type_for_iam_with_profile() -> None:
provider = AWSCredentialsProvider()
provider.profile = "test"
assert IamHelper.get_authentication_type(provider) == IamHelper.IAMAuthenticationType.PROFILE
def test_get_authentication_type_for_iam_with_key_session() -> None:
provider = AWSCredentialsProvider()
provider.access_key_id = "test_key"
provider.session_token = "test_token"
provider.secret_access_key = "test_secret_key"
assert IamHelper.get_authentication_type(provider) == IamHelper.IAMAuthenticationType.IAM_KEYS_WITH_SESSION
def test_get_authentication_type_for_iam_with_key() -> None:
provider = AWSCredentialsProvider()
provider.access_key_id = "test_key"
provider.secret_access_key = "test_secret_key"
assert IamHelper.get_authentication_type(provider) == IamHelper.IAMAuthenticationType.IAM_KEYS
def test_get_authentication_type_for_iam_with_plugin() -> None:
provider = BrowserSamlCredentialsProvider()
assert IamHelper.get_authentication_type(provider) == IamHelper.IAMAuthenticationType.PLUGIN
@pytest.mark.parametrize(
"conn_params, provider, exp_result",
(
(
{"credentials_provider": "BrowserSamlCredentialsProvider"},
IamHelper.IAMAuthenticationType.PLUGIN,
IamHelper.GetClusterCredentialsAPIType.IAM_V1,
),
(
{"group_federation": True},
IamHelper.IAMAuthenticationType.PROFILE,
IamHelper.GetClusterCredentialsAPIType.IAM_V2,
),
(
{"is_serverless": True},
IamHelper.IAMAuthenticationType.PROFILE,
IamHelper.GetClusterCredentialsAPIType.SERVERLESS_V1,
),
(
{"is_serverless": True, "group_federation": True},
IamHelper.IAMAuthenticationType.IAM_KEYS,
IamHelper.GetClusterCredentialsAPIType.IAM_V2,
),
(
{"group_federation": True},
IamHelper.IAMAuthenticationType.IAM_KEYS,
IamHelper.GetClusterCredentialsAPIType.IAM_V2,
),
(
{"is_serverless": True},
IamHelper.IAMAuthenticationType.IAM_KEYS,
IamHelper.GetClusterCredentialsAPIType.SERVERLESS_V1,
),
(
{"is_serverless": True, "group_federation": True},
IamHelper.IAMAuthenticationType.IAM_KEYS_WITH_SESSION,
IamHelper.GetClusterCredentialsAPIType.IAM_V2,
),
(
{"group_federation": True},
IamHelper.IAMAuthenticationType.IAM_KEYS_WITH_SESSION,
IamHelper.GetClusterCredentialsAPIType.IAM_V2,
),
(
{"is_serverless": True},
IamHelper.IAMAuthenticationType.IAM_KEYS_WITH_SESSION,
IamHelper.GetClusterCredentialsAPIType.SERVERLESS_V1,
),
(
{"is_serverless": True, "group_federation": True},
IamHelper.IAMAuthenticationType.PROFILE,
IamHelper.GetClusterCredentialsAPIType.IAM_V2,
),
(
{"group_federation": True, "credentials_provider": "BrowserSamlCredentialsProvider"},
IamHelper.IAMAuthenticationType.PLUGIN,
IamHelper.GetClusterCredentialsAPIType.IAM_V2,
),
(
{"is_serverless": True, "group_federation": True, "credentials_provider": "BrowserSamlCredentialsProvider"},
IamHelper.IAMAuthenticationType.PLUGIN,
IamHelper.GetClusterCredentialsAPIType.IAM_V2,
),
(
{"is_serverless": True, "group_federation": True, "is_cname": True},
IamHelper.IAMAuthenticationType.PROFILE,
"Custom cluster names are not supported for Redshift Serverless",
),
),
)
def test_get_cluster_credentials_api_type_will_use_correct_api(conn_params, provider, exp_result) -> None:
info = RedshiftProperty()
for param in conn_params.items():
info.put(param[0], param[1])
if isinstance(exp_result, IamHelper.GetClusterCredentialsAPIType):
assert IamHelper.get_cluster_credentials_api_type(info, provider) == exp_result
else:
with pytest.raises(InterfaceError, match=exp_result):
IamHelper.get_cluster_credentials_api_type(info, provider)
@pytest.mark.parametrize(
"boto3_version,connection_args",
(
("1.17.110", {"iam": True, "ssl": True, "auth_profile": "SomeTestProfile", "cluster_identifier": "my_cluster"}),
("1.17.100", {"iam": True, "ssl": True, "auth_profile": "SomeTestProfile", "cluster_identifier": "my_cluster"}),
),
)
def test_set_iam_properties_raises_exception_when_insufficient_boto3_version(
mocker, boto3_version, connection_args
) -> None:
from packaging.version import Version
mock_boto3_dist_obj = Version(boto3_version)
mocker.patch("redshift_connector.idp_auth_helper.IdpAuthHelper.get_pkg_version", return_value=mock_boto3_dist_obj)
rp = RedshiftProperty()
for key, value in connection_args.items():
rp.put(key, value)
with pytest.raises(ModuleNotFoundError) as excinfo:
IamHelper.set_iam_properties(rp)
assert "boto3" in str(excinfo)
assert "required for authentication" in str(excinfo.value)
def test_set_iam_properties_use_redshift_auth_profile_calls_read_auth_profile(mocker) -> None:
mocker.patch(
"redshift_connector.idp_auth_helper.IdpAuthHelper.read_auth_profile",
return_value=RedshiftProperty(kwargs={"": ""}),
)
mocker.patch("redshift_connector.iam_helper.IamHelper.set_iam_credentials", return_value=None)
spy = mocker.spy(IdpAuthHelper, "read_auth_profile")
# anticipate read_auth_profile being called with the following parameters
exp_call_arg: typing.Dict[str, str] = {
"auth_profile": "someTestProfile",
"access_key_id": "someAccessKeyIdValue",
"session_token": "someSessionTokenValue",
"secret_access_key": "someSecretAccessValue",
"region": "someRegion",
"endpoint_url": "someEndpointUrl",
}
rp: RedshiftProperty = make_basic_redshift_property(
**{**{"iam": True, "ssl": True, "cluster_identifier": "someCluster"}, **exp_call_arg}
)
IamHelper.set_iam_properties(rp)
assert spy.called is True
assert spy.call_count == 1
assert "auth_profile" in spy.call_args[1]
assert spy.call_args[1]["auth_profile"] == exp_call_arg["auth_profile"]
assert "iam_access_key_id" in spy.call_args[1]
assert spy.call_args[1]["iam_access_key_id"] == exp_call_arg["access_key_id"]
assert "iam_session_token" in spy.call_args[1]
assert spy.call_args[1]["iam_session_token"] == exp_call_arg["session_token"]
assert "iam_secret_key" in spy.call_args[1]
assert spy.call_args[1]["iam_secret_key"] == exp_call_arg["secret_access_key"]
assert "info" in spy.call_args[1]
assert spy.call_args[1]["info"].region == exp_call_arg["region"]
assert spy.call_args[1]["info"].endpoint_url == exp_call_arg["endpoint_url"]
def test_set_iam_properties_redshift_auth_profile_does_override(mocker) -> None:
mock_contents: typing.Dict[str, str] = {
"password": "overridePassword",
}
mock_auth_profile_contents: RedshiftProperty = RedshiftProperty(**mock_contents)
mocker.patch(
"redshift_connector.idp_auth_helper.IdpAuthHelper.read_auth_profile", return_value=mock_auth_profile_contents
)
mocker.patch("redshift_connector.iam_helper.IamHelper.set_iam_credentials", return_value=None)
redshift_auth_profile_spy = mocker.spy(IdpAuthHelper, "read_auth_profile")
set_iam_crednetials_spy = mocker.spy(IamHelper, "set_iam_credentials")
exp_call_arg: typing.Dict[str, str] = {
"auth_profile": "someTestProfile",
"access_key_id": "someAccessKeyIdValue",
"session_token": "someSessionTokenValue",
"secret_access_key": "someSecretAccessValue",
"region": "someRegion",
"endpoint_url": "someEndpointUrl",
}
rp: RedshiftProperty = make_basic_redshift_property(
**{
**{"iam": True, "ssl": True, "cluster_identifier": "someCluster"},
**exp_call_arg,
}
)
res = IamHelper.set_iam_properties(rp)
assert rp.password == mock_auth_profile_contents.password
assert redshift_auth_profile_spy.called is True
assert redshift_auth_profile_spy.call_count == 1
assert res.password == mock_auth_profile_contents.password
assert set_iam_crednetials_spy.called is True
assert set_iam_crednetials_spy.call_count == 1
assert set_iam_crednetials_spy.call_args[0][0].password == mock_auth_profile_contents.password
def test_read_auth_profile_raises_exception_if_profile_dne(mocker):
from botocore import exceptions # type: ignore
req_params: typing.Dict = {
"auth_profile": "testProfile",
"iam_access_key_id": "testAccessKey",
"iam_secret_key": "someSecretKey",
"iam_session_token": "someToken",
"info": RedshiftProperty(),
}
req_params["info"].put("region", "us-east-1")
mock_redshift_client: MagicMock = MagicMock()
mock_redshift_client.describe_authentication_profiles.side_effect = exceptions.ClientError(
operation_name="ErrorOp", error_response=MagicMock()
)
mocker.patch("boto3.client", return_value=mock_redshift_client)
with pytest.raises(InterfaceError):
IamHelper.read_auth_profile(**req_params)
def test_read_auth_profile_loads_json_payload(mocker) -> None:
import json
req_params: typing.Dict = {
"auth_profile": "testProfile",
"iam_access_key_id": "testAccessKey",
"iam_secret_key": "someSecretKey",
"iam_session_token": "someToken",
"info": RedshiftProperty(),
}
req_params["info"].put("region", "us-east-1")
mock_payload: typing.Dict[str, str] = {"region": "someTestRegion", "cluster_identifier": "someCluster"}
mock_redshift_client: MagicMock = MagicMock()
mock_redshift_client.describe_authentication_profiles.return_value = {
"AuthenticationProfiles": [{"AuthenticationProfileContent": json.dumps(mock_payload)}]
}
mocker.patch("boto3.client", return_value=mock_redshift_client)
result = IamHelper.read_auth_profile(**req_params)
assert result.region == mock_payload["region"]
assert result.cluster_identifier == mock_payload["cluster_identifier"]
def test_read_auth_profile_invalid_json_payload_raises_exception(mocker) -> None:
import json
req_params: typing.Dict = {
"auth_profile": "testProfile",
"iam_access_key_id": "testAccessKey",
"iam_secret_key": "someSecretKey",
"iam_session_token": "someToken",
"info": RedshiftProperty(),
}
req_params["info"].put("region", "us-east-1")
mock_redshift_client: MagicMock = MagicMock()
mock_redshift_client.describe_authentication_profiles.return_value = {
"AuthenticationProfiles": [{"AuthenticationProfileContent": "{{{{"}]
}
mocker.patch("boto3.client", return_value=mock_redshift_client)
with pytest.raises(
ProgrammingError, match="Unable to decode the JSON content of the Redshift authentication profile"
):
IamHelper.read_auth_profile(**req_params)
def test_set_iam_properties_calls_set_auth_props(mocker) -> None:
mocker.patch("redshift_connector.iam_helper.IdpAuthHelper.set_auth_properties", return_value=None)
spy = mocker.spy(IdpAuthHelper, "set_auth_properties")
mock_rp: MagicMock = MagicMock()
mock_rp.credentials_provider = None
mock_rp._is_serverless = False
mock_rp.is_cname = False
IamHelper.set_iam_properties(mock_rp)
assert spy.called is True
assert spy.call_count == 1
assert spy.call_args[0][0] == mock_rp
def test_set_cluster_identifier_calls_describe_custom_domain_associations(mocker) -> None:
custom_domain_name: str = "my.custom.domain.com"
rp: RedshiftProperty = RedshiftProperty()
rp.put("host", custom_domain_name)
mock_redshift_client: MagicMock = MagicMock()
spy = mocker.spy(mock_redshift_client, "describe_custom_domain_associations")
mocker.patch("redshift_connector.iam_helper.IamHelper.get_boto3_redshift_client", return_value=mock_redshift_client)
IamHelper.set_cluster_identifier(MagicMock(), rp)
assert spy.called is True
assert spy.call_count == 1
assert "CustomDomainName" in spy.call_args[1]
assert spy.call_args[1]["CustomDomainName"] == custom_domain_name
def test_set_cluster_identifier_sets_cluster_identifier(mocker) -> None:
exp_cluster_identifier: str = "my-cname-test"
custom_domain_name: str = "my.custom.domain.com"
rp: RedshiftProperty = RedshiftProperty()
rp.put("host", custom_domain_name)
mock_redshift_client: MagicMock = MagicMock()
mocker.patch("redshift_connector.iam_helper.IamHelper.get_boto3_redshift_client", return_value=mock_redshift_client)
mock_redshift_client.describe_custom_domain_associations.return_value = {
"Associations": [
{
"CustomDomainCertificateArn": "arn:aws:acm:us-east-1:123456789123:certificate/5237b206-ffd3-11ed-be56-0242ac120002",
"CustomDomainCertificateExpiryDate": datetime.datetime(2023, 10, 20, 23, 59, 59, tzinfo=tzutc()),
"CertificateAssociations": [
{"CustomDomainName": custom_domain_name, "ClusterIdentifier": exp_cluster_identifier}
],
}
],
"ResponseMetadata": {
"RequestId": "d432c0b8-12c5-43a4-b3b9-dfc66427bbd0",
"HTTPStatusCode": 200,
"HTTPHeaders": {
"x-amzn-requestid": "d432c0b8-12c5-43a4-b3b9-dfc66427bbd0",
"content-type": "text/xml",
"content-length": "950",
"date": "Wed, 31 May 2023 16:50:00 GMT",
},
"RetryAttempts": 0,
},
}
IamHelper.set_cluster_identifier(MagicMock(), rp)
assert rp.cluster_identifier == exp_cluster_identifier