def test_running_on_windows_ci():
with mock.patch.dict(os.environ, {
'SYSTEM_TEAMFOUNDATIONCOLLECTIONURI': 'url',
'AGENT_OS': 'Windows_NT'
}):
assert running_on_ci() is True
assert running_on_windows_ci() is True
class TestProxies:
def test_config_default(self):
instance = {}
init_config = {}
http = RequestsWrapper(instance, init_config)
assert http.options['proxies'] is None
assert http.no_proxy_uris is None
def test_config_proxy_agent(self):
with mock.patch(
'datadog_checks.base.stubs.datadog_agent.get_config',
return_value={
'http': 'http_host',
'https': 'https_host',
'no_proxy': 'uri1,uri2;uri3,uri4'
},
):
instance = {}
init_config = {}
http = RequestsWrapper(instance, init_config)
assert http.options['proxies'] == {
'http': 'http_host',
'https': 'https_host'
}
assert http.no_proxy_uris == ['uri1', 'uri2', 'uri3', 'uri4']
def test_config_proxy_init_config_override(self):
with mock.patch(
'datadog_checks.base.stubs.datadog_agent.get_config',
return_value={
'http': 'unused',
'https': 'unused',
'no_proxy': 'unused'
},
):
instance = {}
init_config = {
'proxy': {
'http': 'http_host',
'https': 'https_host',
'no_proxy': 'uri1,uri2;uri3,uri4'
}
}
http = RequestsWrapper(instance, init_config)
assert http.options['proxies'] == {
'http': 'http_host',
'https': 'https_host'
}
assert http.no_proxy_uris == ['uri1', 'uri2', 'uri3', 'uri4']
def test_config_proxy_instance_override(self):
with mock.patch(
'datadog_checks.base.stubs.datadog_agent.get_config',
return_value={
'http': 'unused',
'https': 'unused',
'no_proxy': 'unused'
},
):
instance = {
'proxy': {
'http': 'http_host',
'https': 'https_host',
'no_proxy': 'uri1,uri2;uri3,uri4'
}
}
init_config = {
'proxy': {
'http': 'unused',
'https': 'unused',
'no_proxy': 'unused'
}
}
http = RequestsWrapper(instance, init_config)
assert http.options['proxies'] == {
'http': 'http_host',
'https': 'https_host'
}
assert http.no_proxy_uris == ['uri1', 'uri2', 'uri3', 'uri4']
def test_config_no_proxy_as_list(self):
with mock.patch(
'datadog_checks.base.stubs.datadog_agent.get_config',
return_value={
'http': 'http_host',
'https': 'https_host',
'no_proxy': ['uri1', 'uri2', 'uri3', 'uri4']
},
):
instance = {}
init_config = {}
http = RequestsWrapper(instance, init_config)
assert http.options['proxies'] == {
'http': 'http_host',
'https': 'https_host'
}
assert http.no_proxy_uris == ['uri1', 'uri2', 'uri3', 'uri4']
def test_config_proxy_skip(self):
instance = {
'proxy': {
'http': 'unused',
'https': 'unused',
'no_proxy': 'unused'
},
'skip_proxy': True
}
init_config = {
'proxy': {
'http': 'unused',
'https': 'unused',
'no_proxy': 'unused'
}
}
http = RequestsWrapper(instance, init_config)
assert http.options['proxies'] == {'http': '', 'https': ''}
assert http.no_proxy_uris is None
def test_config_proxy_skip_init_config(self):
instance = {
'proxy': {
'http': 'unused',
'https': 'unused',
'no_proxy': 'unused'
}
}
init_config = {
'proxy': {
'http': 'unused',
'https': 'unused',
'no_proxy': 'unused'
},
'skip_proxy': True
}
http = RequestsWrapper(instance, init_config)
assert http.options['proxies'] == {'http': '', 'https': ''}
assert http.no_proxy_uris is None
def test_proxy_env_vars_skip(self):
instance = {'skip_proxy': True}
init_config = {}
http = RequestsWrapper(instance, init_config)
with EnvVars({'HTTP_PROXY': 'http://1.2.3.4:567'}):
response = http.get('http://www.google.com')
response.raise_for_status()
with EnvVars({'HTTPS_PROXY': 'https://1.2.3.4:567'}):
response = http.get('https://www.google.com')
response.raise_for_status()
def test_proxy_env_vars_override_skip_fail(self):
instance = {'skip_proxy': True}
init_config = {}
http = RequestsWrapper(instance, init_config)
with EnvVars({'HTTP_PROXY': 'http://1.2.3.4:567'}):
with pytest.raises((ConnectTimeout, ProxyError)):
http.get('http://www.google.com', timeout=1, proxies=None)
with EnvVars({'HTTPS_PROXY': 'https://1.2.3.4:567'}):
with pytest.raises((ConnectTimeout, ProxyError)):
http.get('https://www.google.com', timeout=1, proxies=None)
def test_proxy_bad(self):
instance = {
'proxy': {
'http': 'http://1.2.3.4:567',
'https': 'https://1.2.3.4:567'
}
}
init_config = {}
http = RequestsWrapper(instance, init_config)
with pytest.raises((ConnectTimeout, ProxyError)):
http.get('http://www.google.com', timeout=1)
with pytest.raises((ConnectTimeout, ProxyError)):
http.get('https://www.google.com', timeout=1)
def test_proxy_bad_no_proxy_override_success(self):
instance = {
'proxy': {
'http': 'http://1.2.3.4:567',
'https': 'https://1.2.3.4:567',
'no_proxy': 'unused,google.com'
}
}
init_config = {}
http = RequestsWrapper(instance, init_config)
response = http.get('http://www.google.com')
response.raise_for_status()
response = http.get('https://www.google.com')
response.raise_for_status()
def test_no_proxy_uris_coverage(self):
http = RequestsWrapper({}, {})
# Coverage is not smart enough to detect that looping an empty
# iterable will never occur when gated by `if iterable:`.
http.no_proxy_uris = mock.MagicMock()
http.no_proxy_uris.__iter__ = lambda self, *args, **kwargs: iter([])
http.no_proxy_uris.__bool__ = lambda self, *args, **kwargs: True
# TODO: Remove with Python 2
http.no_proxy_uris.__nonzero__ = lambda self, *args, **kwargs: True
http.get('https://www.google.com')
@pytest.mark.skipif(running_on_windows_ci(),
reason='Test cannot be run on Windows CI')
def test_socks5_proxy(self, socks5_proxy):
instance = {'proxy': {'http': 'socks5h://{}'.format(socks5_proxy)}}
init_config = {}
http = RequestsWrapper(instance, init_config)
http.get('http://www.google.com')
http.get('http://nginx')
@pytest.mark.skipif(running_on_windows_ci(),
reason='Test cannot be run on Windows CI')
def test_no_proxy_domain(self, socks5_proxy):
instance = {
'proxy': {
'http': 'http://1.2.3.4:567',
'no_proxy': '.google.com,example.com,9'
}
}
init_config = {}
http = RequestsWrapper(instance, init_config)
# no_proxy match: .google.com
http.get('http://www.google.com')
# no_proxy match: example.com
http.get('http://www.example.com')
http.get('http://example.com')
# no_proxy match: 9
http.get('http://127.0.0.9')
@pytest.mark.skipif(running_on_windows_ci(),
reason='Test cannot be run on Windows CI')
def test_no_proxy_domain_fail(self, socks5_proxy):
instance = {
'proxy': {
'http': 'http://1.2.3.4:567',
'no_proxy': '.google.com,example.com,example,9'
}
}
init_config = {}
http = RequestsWrapper(instance, init_config)
# no_proxy not match: .google.com
# ".y.com" matches "x.y.com" but not "y.com"
with pytest.raises((ConnectTimeout, ProxyError)):
http.get('http://google.com', timeout=1)
# no_proxy not match: example or example.com
with pytest.raises((ConnectTimeout, ProxyError)):
http.get('http://notexample.com', timeout=1)
with pytest.raises((ConnectTimeout, ProxyError)):
http.get('http://example.org', timeout=1)
# no_proxy not match: 9
with pytest.raises((ConnectTimeout, ProxyError)):
http.get('http://127.0.0.99', timeout=1)
@pytest.mark.skipif(running_on_windows_ci(),
reason='Test cannot be run on Windows CI')
def test_no_proxy_ip(self, socks5_proxy):
instance = {
'proxy': {
'http':
'http://1.2.3.4:567',
'no_proxy':
'127.0.0.1,127.0.0.2/32,127.1.0.0/25,127.1.1.0/255.255.255.128,127.1.2.0/0.0.0.127',
}
}
init_config = {}
http = RequestsWrapper(instance, init_config)
# no_proxy match: 127.0.0.1
http.get('http://127.0.0.1', timeout=1)
# no_proxy match: 127.0.0.2/32
http.get('http://127.0.0.2', timeout=1)
# no_proxy match: IP within 127.1.0.0/25 subnet - cidr bits format
http.get('http://127.1.0.50', timeout=1)
http.get('http://127.1.0.100', timeout=1)
# no_proxy match: IP within 127.1.1.0/255.255.255.128 subnet - net mask format
http.get('http://127.1.1.50', timeout=1)
http.get('http://127.1.1.100', timeout=1)
# no_proxy match: IP within 127.1.2.0/0.0.0.127 subnet - host mask format
http.get('http://127.1.2.50', timeout=1)
http.get('http://127.1.2.100', timeout=1)
@pytest.mark.skipif(running_on_windows_ci(),
reason='Test cannot be run on Windows CI')
def test_no_proxy_ip_fail(self, socks5_proxy):
instance = {
'proxy': {
'http':
'http://1.2.3.4:567',
'no_proxy':
'127.0.0.1,127.0.0.2/32,127.1.0.0/25,127.1.1.0/255.255.255.128,127.1.2.0/0.0.0.127',
}
}
init_config = {}
http = RequestsWrapper(instance, init_config)
# no_proxy not match: 127.0.0.1
with pytest.raises((ConnectTimeout, ProxyError)):
http.get('http://127.0.0.11', timeout=1)
# no_proxy not match: 127.0.0.2/32
with pytest.raises((ConnectTimeout, ProxyError)):
http.get('http://127.0.0.22', timeout=1)
# no_proxy not match: IP outside 127.1.0.0/25 subnet - cidr bits format
with pytest.raises((ConnectTimeout, ProxyError)):
http.get('http://127.1.0.150', timeout=1)
http.get('http://127.1.0.200', timeout=1)
# no_proxy not match: IP outside 127.1.1.0/255.255.255.128 subnet - net mask format
with pytest.raises((ConnectTimeout, ProxyError)):
http.get('http://127.1.1.150', timeout=1)
http.get('http://127.1.1.200', timeout=1)
# no_proxy not match: IP outside 127.1.2.0/0.0.0.127 subnet - host mask format
with pytest.raises((ConnectTimeout, ProxyError)):
http.get('http://127.1.2.150', timeout=1)
http.get('http://127.1.2.200', timeout=1)
class TestAuth:
def test_config_default(self):
instance = {}
init_config = {}
http = RequestsWrapper(instance, init_config)
assert http.options['auth'] is None
def test_config_basic(self):
instance = {'username': '******', 'password': '******'}
init_config = {}
http = RequestsWrapper(instance, init_config)
assert http.options['auth'] == ('user', 'pass')
def test_config_basic_authtype(self):
instance = {
'username': '******',
'password': '******',
'auth_type': 'basic'
}
init_config = {}
http = RequestsWrapper(instance, init_config)
assert http.options['auth'] == ('user', 'pass')
def test_config_digest_authtype(self):
instance = {
'username': '******',
'password': '******',
'auth_type': 'digest'
}
init_config = {}
http = RequestsWrapper(instance, init_config)
assert isinstance(http.options['auth'], requests.auth.HTTPDigestAuth)
def test_config_basic_only_username(self):
instance = {'username': '******'}
init_config = {}
http = RequestsWrapper(instance, init_config)
assert http.options['auth'] is None
def test_config_basic_only_password(self):
instance = {'password': '******'}
init_config = {}
http = RequestsWrapper(instance, init_config)
assert http.options['auth'] is None
def test_config_kerberos(self):
instance = {'kerberos_auth': 'required'}
init_config = {}
# Trigger lazy import
http = RequestsWrapper(instance, init_config)
assert isinstance(http.options['auth'],
requests_kerberos.HTTPKerberosAuth)
with mock.patch(
'datadog_checks.base.utils.http.requests_kerberos.HTTPKerberosAuth'
) as m:
RequestsWrapper(instance, init_config)
m.assert_called_once_with(
mutual_authentication=requests_kerberos.REQUIRED,
delegate=False,
force_preemptive=False,
hostname_override=None,
principal=None,
)
with mock.patch(
'datadog_checks.base.utils.http.requests_kerberos.HTTPKerberosAuth'
) as m:
RequestsWrapper({'kerberos_auth': 'optional'}, init_config)
m.assert_called_once_with(
mutual_authentication=requests_kerberos.OPTIONAL,
delegate=False,
force_preemptive=False,
hostname_override=None,
principal=None,
)
with mock.patch(
'datadog_checks.base.utils.http.requests_kerberos.HTTPKerberosAuth'
) as m:
RequestsWrapper({'kerberos_auth': 'disabled'}, init_config)
m.assert_called_once_with(
mutual_authentication=requests_kerberos.DISABLED,
delegate=False,
force_preemptive=False,
hostname_override=None,
principal=None,
)
def test_config_kerberos_shortcut(self):
instance = {'kerberos_auth': True}
init_config = {}
# Trigger lazy import
http = RequestsWrapper(instance, init_config)
assert isinstance(http.options['auth'],
requests_kerberos.HTTPKerberosAuth)
with mock.patch(
'datadog_checks.base.utils.http.requests_kerberos.HTTPKerberosAuth'
) as m:
RequestsWrapper(instance, init_config)
m.assert_called_once_with(
mutual_authentication=requests_kerberos.REQUIRED,
delegate=False,
force_preemptive=False,
hostname_override=None,
principal=None,
)
def test_config_kerberos_unknown(self):
instance = {'kerberos_auth': 'unknown'}
init_config = {}
with pytest.raises(ConfigurationError):
RequestsWrapper(instance, init_config)
def test_config_kerberos_keytab_file(self):
instance = {'kerberos_keytab': '/test/file'}
init_config = {}
http = RequestsWrapper(instance, init_config)
assert os.environ.get('KRB5_CLIENT_KTNAME') is None
with mock.patch('requests.get',
side_effect=lambda *args, **kwargs: os.environ.get(
'KRB5_CLIENT_KTNAME')):
assert http.get('https://www.google.com') == '/test/file'
assert os.environ.get('KRB5_CLIENT_KTNAME') is None
def test_config_kerberos_cache(self):
instance = {'kerberos_cache': '/test/file'}
init_config = {}
http = RequestsWrapper(instance, init_config)
assert os.environ.get('KRB5CCNAME') is None
with mock.patch('requests.get',
side_effect=lambda *args, **kwargs: os.environ.get(
'KRB5CCNAME')):
assert http.get('https://www.google.com') == '/test/file'
assert os.environ.get('KRB5CCNAME') is None
def test_config_kerberos_cache_restores_rollback(self):
instance = {'kerberos_cache': '/test/file'}
init_config = {}
http = RequestsWrapper(instance, init_config)
with EnvVars({'KRB5CCNAME': 'old'}):
with mock.patch('requests.get',
side_effect=lambda *args, **kwargs: os.environ.get(
'KRB5CCNAME')):
assert http.get('https://www.google.com') == '/test/file'
assert os.environ.get('KRB5CCNAME') == 'old'
def test_config_kerberos_keytab_file_rollback(self):
instance = {'kerberos_keytab': '/test/file'}
init_config = {}
http = RequestsWrapper(instance, init_config)
with EnvVars({'KRB5_CLIENT_KTNAME': 'old'}):
assert os.environ.get('KRB5_CLIENT_KTNAME') == 'old'
with mock.patch('requests.get',
side_effect=lambda *args, **kwargs: os.environ.get(
'KRB5_CLIENT_KTNAME')):
assert http.get('https://www.google.com') == '/test/file'
assert os.environ.get('KRB5_CLIENT_KTNAME') == 'old'
def test_config_kerberos_legacy_remap(self):
instance = {'kerberos': True}
init_config = {}
# Trigger lazy import
http = RequestsWrapper(instance, init_config)
assert isinstance(http.options['auth'],
requests_kerberos.HTTPKerberosAuth)
with mock.patch(
'datadog_checks.base.utils.http.requests_kerberos.HTTPKerberosAuth'
) as m:
RequestsWrapper(instance, init_config)
m.assert_called_once_with(
mutual_authentication=requests_kerberos.REQUIRED,
delegate=False,
force_preemptive=False,
hostname_override=None,
principal=None,
)
@pytest.mark.skipif(running_on_windows_ci(),
reason='Test cannot be run on Windows CI')
def test_kerberos_auth_noconf(self, kerberos):
instance = {}
init_config = {}
http = RequestsWrapper(instance, init_config)
response = http.get(kerberos["url"])
assert response.status_code == 401
@pytest.mark.skipif(running_on_windows_ci(),
reason='Test cannot be run on Windows CI')
def test_kerberos_auth_principal_inexistent(self, kerberos):
instance = {
'url': kerberos["url"],
'kerberos_auth': 'required',
'kerberos_hostname': kerberos["hostname"],
'kerberos_cache': "DIR:{}".format(kerberos["cache"]),
'kerberos_keytab': kerberos["keytab"],
'kerberos_principal':
"user/doesnotexist@{}".format(kerberos["realm"]),
'kerberos_force_initiate': 'false',
}
init_config = {}
http = RequestsWrapper(instance, init_config)
response = http.get(instance["url"])
assert response.status_code == 401
@pytest.mark.skipif(running_on_windows_ci(),
reason='Test cannot be run on Windows CI')
def test_kerberos_auth_principal_incache_nokeytab(self, kerberos):
instance = {
'url': kerberos["url"],
'kerberos_auth': 'required',
'kerberos_cache': "DIR:{}".format(kerberos["cache"]),
'kerberos_hostname': kerberos["hostname"],
'kerberos_principal': "user/nokeytab@{}".format(kerberos["realm"]),
'kerberos_force_initiate': 'true',
}
init_config = {}
http = RequestsWrapper(instance, init_config)
response = http.get(instance["url"])
assert response.status_code == 200
@pytest.mark.skipif(running_on_windows_ci(),
reason='Test cannot be run on Windows CI')
def test_kerberos_auth_principal_inkeytab_nocache(self, kerberos):
instance = {
'url': kerberos["url"],
'kerberos_auth': 'required',
'kerberos_hostname': kerberos["hostname"],
'kerberos_cache': "DIR:{}".format(kerberos["tmp_dir"]),
'kerberos_keytab': kerberos["keytab"],
'kerberos_principal': "user/inkeytab@{}".format(kerberos["realm"]),
'kerberos_force_initiate': 'true',
}
init_config = {}
http = RequestsWrapper(instance, init_config)
response = http.get(instance["url"])
assert response.status_code == 200
def test_config_ntlm(self):
instance = {'ntlm_domain': 'domain\\user', 'password': '******'}
init_config = {}
# Trigger lazy import
http = RequestsWrapper(instance, init_config)
assert isinstance(http.options['auth'], requests_ntlm.HttpNtlmAuth)
with mock.patch(
'datadog_checks.base.utils.http.requests_ntlm.HttpNtlmAuth'
) as m:
RequestsWrapper(instance, init_config)
m.assert_called_once_with('domain\\user', 'pass')
class TestProxies:
def test_config_default(self):
instance = {}
init_config = {}
http = RequestsWrapper(instance, init_config)
assert http.options['proxies'] is None
assert http.no_proxy_uris is None
def test_config_proxy_agent(self):
with mock.patch(
'datadog_checks.base.stubs.datadog_agent.get_config',
return_value={
'http': 'http_host',
'https': 'https_host',
'no_proxy': 'uri1,uri2;uri3,uri4'
},
):
instance = {}
init_config = {}
http = RequestsWrapper(instance, init_config)
assert http.options['proxies'] == {
'http': 'http_host',
'https': 'https_host'
}
assert http.no_proxy_uris == ['uri1', 'uri2', 'uri3', 'uri4']
def test_config_proxy_init_config_override(self):
with mock.patch(
'datadog_checks.base.stubs.datadog_agent.get_config',
return_value={
'http': 'unused',
'https': 'unused',
'no_proxy': 'unused'
},
):
instance = {}
init_config = {
'proxy': {
'http': 'http_host',
'https': 'https_host',
'no_proxy': 'uri1,uri2;uri3,uri4'
}
}
http = RequestsWrapper(instance, init_config)
assert http.options['proxies'] == {
'http': 'http_host',
'https': 'https_host'
}
assert http.no_proxy_uris == ['uri1', 'uri2', 'uri3', 'uri4']
def test_config_proxy_instance_override(self):
with mock.patch(
'datadog_checks.base.stubs.datadog_agent.get_config',
return_value={
'http': 'unused',
'https': 'unused',
'no_proxy': 'unused'
},
):
instance = {
'proxy': {
'http': 'http_host',
'https': 'https_host',
'no_proxy': 'uri1,uri2;uri3,uri4'
}
}
init_config = {
'proxy': {
'http': 'unused',
'https': 'unused',
'no_proxy': 'unused'
}
}
http = RequestsWrapper(instance, init_config)
assert http.options['proxies'] == {
'http': 'http_host',
'https': 'https_host'
}
assert http.no_proxy_uris == ['uri1', 'uri2', 'uri3', 'uri4']
def test_config_no_proxy_as_list(self):
with mock.patch(
'datadog_checks.base.stubs.datadog_agent.get_config',
return_value={
'http': 'http_host',
'https': 'https_host',
'no_proxy': ['uri1', 'uri2', 'uri3', 'uri4']
},
):
instance = {}
init_config = {}
http = RequestsWrapper(instance, init_config)
assert http.options['proxies'] == {
'http': 'http_host',
'https': 'https_host'
}
assert http.no_proxy_uris == ['uri1', 'uri2', 'uri3', 'uri4']
def test_config_proxy_skip(self):
instance = {
'proxy': {
'http': 'unused',
'https': 'unused',
'no_proxy': 'unused'
},
'skip_proxy': True
}
init_config = {
'proxy': {
'http': 'unused',
'https': 'unused',
'no_proxy': 'unused'
}
}
http = RequestsWrapper(instance, init_config)
assert http.options['proxies'] == {'http': '', 'https': ''}
assert http.no_proxy_uris is None
def test_config_proxy_skip_init_config(self):
instance = {
'proxy': {
'http': 'unused',
'https': 'unused',
'no_proxy': 'unused'
}
}
init_config = {
'proxy': {
'http': 'unused',
'https': 'unused',
'no_proxy': 'unused'
},
'skip_proxy': True
}
http = RequestsWrapper(instance, init_config)
assert http.options['proxies'] == {'http': '', 'https': ''}
assert http.no_proxy_uris is None
def test_proxy_env_vars_skip(self):
instance = {'skip_proxy': True}
init_config = {}
http = RequestsWrapper(instance, init_config)
with EnvVars({'HTTP_PROXY': 'http://1.2.3.4:567'}):
response = http.get('http://www.google.com')
response.raise_for_status()
with EnvVars({'HTTPS_PROXY': 'https://1.2.3.4:567'}):
response = http.get('https://www.google.com')
response.raise_for_status()
def test_proxy_env_vars_override_skip_fail(self):
instance = {'skip_proxy': True}
init_config = {}
http = RequestsWrapper(instance, init_config)
with EnvVars({'HTTP_PROXY': 'http://1.2.3.4:567'}):
with pytest.raises((ConnectTimeout, ProxyError)):
http.get('http://www.google.com', timeout=1, proxies=None)
with EnvVars({'HTTPS_PROXY': 'https://1.2.3.4:567'}):
with pytest.raises((ConnectTimeout, ProxyError)):
http.get('https://www.google.com', timeout=1, proxies=None)
def test_proxy_bad(self):
instance = {
'proxy': {
'http': 'http://1.2.3.4:567',
'https': 'https://1.2.3.4:567'
}
}
init_config = {}
http = RequestsWrapper(instance, init_config)
with pytest.raises((ConnectTimeout, ProxyError)):
http.get('http://www.google.com', timeout=1)
with pytest.raises((ConnectTimeout, ProxyError)):
http.get('https://www.google.com', timeout=1)
def test_proxy_bad_no_proxy_override_success(self):
instance = {
'proxy': {
'http': 'http://1.2.3.4:567',
'https': 'https://1.2.3.4:567',
'no_proxy': 'unused,google.com'
}
}
init_config = {}
http = RequestsWrapper(instance, init_config)
response = http.get('http://www.google.com')
response.raise_for_status()
response = http.get('https://www.google.com')
response.raise_for_status()
def test_no_proxy_uris_coverage(self):
http = RequestsWrapper({}, {})
# Coverage is not smart enough to detect that looping an empty
# iterable will never occur when gated by `if iterable:`.
http.no_proxy_uris = mock.MagicMock()
http.no_proxy_uris.__iter__ = lambda self, *args, **kwargs: iter([])
http.no_proxy_uris.__bool__ = lambda self, *args, **kwargs: True
# TODO: Remove with Python 2
http.no_proxy_uris.__nonzero__ = lambda self, *args, **kwargs: True
http.get('https://www.google.com')
@pytest.mark.skipif(running_on_windows_ci(),
reason='Test cannot be run on Windows CI')
def test_socks5_proxy(self, socks5_proxy):
instance = {'proxy': {'http': 'socks5h://{}'.format(socks5_proxy)}}
init_config = {}
http = RequestsWrapper(instance, init_config)
http.get('http://www.google.com')
http.get('http://nginx')
# (C) Datadog, Inc. 2019
# All rights reserved
# Licensed under a 3-clause BSD style license (see LICENSE)
import pytest
from datadog_checks.dev.utils import running_on_windows_ci
windows_ci = pytest.mark.skipif(not running_on_windows_ci(),
reason='Test can only be run on Windows CI')
not_windows_ci = pytest.mark.skipif(running_on_windows_ci(),
reason='Test cannot be run on Windows CI')
class TestAuth:
def test_config_default(self):
instance = {}
init_config = {}
http = RequestsWrapper(instance, init_config)
assert http.options['auth'] is None
def test_config_basic(self):
instance = {'username': '******', 'password': '******'}
init_config = {}
http = RequestsWrapper(instance, init_config)
assert http.options['auth'] == ('user', 'pass')
def test_config_basic_authtype(self):
instance = {'username': '******', 'password': '******', 'auth_type': 'basic'}
init_config = {}
http = RequestsWrapper(instance, init_config)
assert http.options['auth'] == ('user', 'pass')
def test_config_basic_no_legacy_encoding(self):
instance = {'username': '******', 'password': '******', 'use_legacy_auth_encoding': False}
init_config = {}
http = RequestsWrapper(instance, init_config)
assert http.options['auth'] == (b'user', b'pass')
def test_config_digest_authtype(self):
instance = {'username': '******', 'password': '******', 'auth_type': 'digest'}
init_config = {}
http = RequestsWrapper(instance, init_config)
assert isinstance(http.options['auth'], requests_auth.HTTPDigestAuth)
with mock.patch('datadog_checks.base.utils.http.requests_auth.HTTPDigestAuth') as m:
RequestsWrapper(instance, init_config)
m.assert_called_once_with('user', 'pass')
def test_config_basic_only_username(self):
instance = {'username': '******'}
init_config = {}
http = RequestsWrapper(instance, init_config)
assert http.options['auth'] is None
def test_config_basic_only_password(self):
instance = {'password': '******'}
init_config = {}
http = RequestsWrapper(instance, init_config)
assert http.options['auth'] is None
def test_config_kerberos_legacy(self):
instance = {'kerberos_auth': 'required'}
init_config = {}
# Trigger lazy import
http = RequestsWrapper(instance, init_config)
assert isinstance(http.options['auth'], requests_kerberos.HTTPKerberosAuth)
with mock.patch('datadog_checks.base.utils.http.requests_kerberos.HTTPKerberosAuth') as m:
RequestsWrapper(instance, init_config)
m.assert_called_once_with(
mutual_authentication=requests_kerberos.REQUIRED,
delegate=False,
force_preemptive=False,
hostname_override=None,
principal=None,
)
def test_config_kerberos(self):
instance = {'auth_type': 'kerberos', 'kerberos_auth': 'required'}
init_config = {}
# Trigger lazy import
http = RequestsWrapper(instance, init_config)
assert isinstance(http.options['auth'], requests_kerberos.HTTPKerberosAuth)
with mock.patch('datadog_checks.base.utils.http.requests_kerberos.HTTPKerberosAuth') as m:
RequestsWrapper(instance, init_config)
m.assert_called_once_with(
mutual_authentication=requests_kerberos.REQUIRED,
delegate=False,
force_preemptive=False,
hostname_override=None,
principal=None,
)
with mock.patch('datadog_checks.base.utils.http.requests_kerberos.HTTPKerberosAuth') as m:
RequestsWrapper({'auth_type': 'kerberos', 'kerberos_auth': 'optional'}, init_config)
m.assert_called_once_with(
mutual_authentication=requests_kerberos.OPTIONAL,
delegate=False,
force_preemptive=False,
hostname_override=None,
principal=None,
)
with mock.patch('datadog_checks.base.utils.http.requests_kerberos.HTTPKerberosAuth') as m:
RequestsWrapper({'auth_type': 'kerberos', 'kerberos_auth': 'disabled'}, init_config)
m.assert_called_once_with(
mutual_authentication=requests_kerberos.DISABLED,
delegate=False,
force_preemptive=False,
hostname_override=None,
principal=None,
)
def test_config_kerberos_shortcut(self):
instance = {'auth_type': 'kerberos', 'kerberos_auth': True}
init_config = {}
# Trigger lazy import
http = RequestsWrapper(instance, init_config)
assert isinstance(http.options['auth'], requests_kerberos.HTTPKerberosAuth)
with mock.patch('datadog_checks.base.utils.http.requests_kerberos.HTTPKerberosAuth') as m:
RequestsWrapper(instance, init_config)
m.assert_called_once_with(
mutual_authentication=requests_kerberos.REQUIRED,
delegate=False,
force_preemptive=False,
hostname_override=None,
principal=None,
)
def test_config_kerberos_unknown(self):
instance = {'auth_type': 'kerberos', 'kerberos_auth': 'unknown'}
init_config = {}
with pytest.raises(ConfigurationError):
RequestsWrapper(instance, init_config)
def test_config_kerberos_keytab_file(self):
instance = {'auth_type': 'kerberos', 'kerberos_keytab': '/test/file'}
init_config = {}
http = RequestsWrapper(instance, init_config)
assert os.environ.get('KRB5_CLIENT_KTNAME') is None
with mock.patch('requests.get', side_effect=lambda *args, **kwargs: os.environ.get('KRB5_CLIENT_KTNAME')):
assert http.get('https://www.google.com') == '/test/file'
assert os.environ.get('KRB5_CLIENT_KTNAME') is None
def test_config_kerberos_cache(self):
instance = {'auth_type': 'kerberos', 'kerberos_cache': '/test/file'}
init_config = {}
http = RequestsWrapper(instance, init_config)
assert os.environ.get('KRB5CCNAME') is None
with mock.patch('requests.get', side_effect=lambda *args, **kwargs: os.environ.get('KRB5CCNAME')):
assert http.get('https://www.google.com') == '/test/file'
assert os.environ.get('KRB5CCNAME') is None
def test_config_kerberos_cache_restores_rollback(self):
instance = {'auth_type': 'kerberos', 'kerberos_cache': '/test/file'}
init_config = {}
http = RequestsWrapper(instance, init_config)
with EnvVars({'KRB5CCNAME': 'old'}):
with mock.patch('requests.get', side_effect=lambda *args, **kwargs: os.environ.get('KRB5CCNAME')):
assert http.get('https://www.google.com') == '/test/file'
assert os.environ.get('KRB5CCNAME') == 'old'
def test_config_kerberos_keytab_file_rollback(self):
instance = {'auth_type': 'kerberos', 'kerberos_keytab': '/test/file'}
init_config = {}
http = RequestsWrapper(instance, init_config)
with EnvVars({'KRB5_CLIENT_KTNAME': 'old'}):
assert os.environ.get('KRB5_CLIENT_KTNAME') == 'old'
with mock.patch('requests.get', side_effect=lambda *args, **kwargs: os.environ.get('KRB5_CLIENT_KTNAME')):
assert http.get('https://www.google.com') == '/test/file'
assert os.environ.get('KRB5_CLIENT_KTNAME') == 'old'
def test_config_kerberos_legacy_remap(self):
instance = {'auth_type': 'kerberos', 'kerberos': True}
init_config = {}
# Trigger lazy import
http = RequestsWrapper(instance, init_config)
assert isinstance(http.options['auth'], requests_kerberos.HTTPKerberosAuth)
with mock.patch('datadog_checks.base.utils.http.requests_kerberos.HTTPKerberosAuth') as m:
RequestsWrapper(instance, init_config)
m.assert_called_once_with(
mutual_authentication=requests_kerberos.REQUIRED,
delegate=False,
force_preemptive=False,
hostname_override=None,
principal=None,
)
@pytest.mark.skipif(running_on_windows_ci(), reason='Test cannot be run on Windows CI')
def test_kerberos_auth_noconf(self, kerberos):
instance = {}
init_config = {}
http = RequestsWrapper(instance, init_config)
response = http.get(kerberos["url"])
assert response.status_code == 401
@pytest.mark.skipif(running_on_windows_ci(), reason='Test cannot be run on Windows CI')
def test_kerberos_auth_principal_inexistent(self, kerberos):
instance = {
'url': kerberos["url"],
'auth_type': 'kerberos',
'kerberos_auth': 'required',
'kerberos_hostname': kerberos["hostname"],
'kerberos_cache': "DIR:{}".format(kerberos["cache"]),
'kerberos_keytab': kerberos["keytab"],
'kerberos_principal': "user/doesnotexist@{}".format(kerberos["realm"]),
'kerberos_force_initiate': 'false',
}
init_config = {}
http = RequestsWrapper(instance, init_config)
response = http.get(instance["url"])
assert response.status_code == 401
@pytest.mark.skipif(running_on_windows_ci(), reason='Test cannot be run on Windows CI')
def test_kerberos_auth_principal_incache_nokeytab(self, kerberos):
instance = {
'url': kerberos["url"],
'auth_type': 'kerberos',
'kerberos_auth': 'required',
'kerberos_cache': "DIR:{}".format(kerberos["cache"]),
'kerberos_hostname': kerberos["hostname"],
'kerberos_principal': "user/nokeytab@{}".format(kerberos["realm"]),
'kerberos_force_initiate': 'true',
}
init_config = {}
http = RequestsWrapper(instance, init_config)
response = http.get(instance["url"])
assert response.status_code == 200
@pytest.mark.skipif(running_on_windows_ci(), reason='Test cannot be run on Windows CI')
def test_kerberos_auth_principal_inkeytab_nocache(self, kerberos):
instance = {
'url': kerberos["url"],
'auth_type': 'kerberos',
'kerberos_auth': 'required',
'kerberos_hostname': kerberos["hostname"],
'kerberos_cache': "DIR:{}".format(kerberos["tmp_dir"]),
'kerberos_keytab': kerberos["keytab"],
'kerberos_principal': "user/inkeytab@{}".format(kerberos["realm"]),
'kerberos_force_initiate': 'true',
}
init_config = {}
http = RequestsWrapper(instance, init_config)
response = http.get(instance["url"])
assert response.status_code == 200
def test_config_ntlm(self):
instance = {'auth_type': 'ntlm', 'ntlm_domain': 'domain\\user', 'password': '******'}
init_config = {}
# Trigger lazy import
http = RequestsWrapper(instance, init_config)
assert isinstance(http.options['auth'], requests_ntlm.HttpNtlmAuth)
with mock.patch('datadog_checks.base.utils.http.requests_ntlm.HttpNtlmAuth') as m:
RequestsWrapper(instance, init_config)
m.assert_called_once_with('domain\\user', 'pass')
def test_config_ntlm_legacy(self, caplog):
instance = {'ntlm_domain': 'domain\\user', 'password': '******'}
init_config = {}
# Trigger lazy import
http = RequestsWrapper(instance, init_config)
assert isinstance(http.options['auth'], requests_ntlm.HttpNtlmAuth)
with mock.patch('datadog_checks.base.utils.http.requests_ntlm.HttpNtlmAuth') as m:
RequestsWrapper(instance, init_config)
m.assert_called_once_with('domain\\user', 'pass')
assert (
'The ability to use NTLM auth without explicitly setting auth_type to '
'`ntlm` is deprecated and will be removed in Agent 8'
) in caplog.text
def test_config_aws(self):
instance = {'auth_type': 'aws', 'aws_host': 'uri', 'aws_region': 'earth', 'aws_service': 'saas'}
init_config = {}
# Trigger lazy import
http = RequestsWrapper(instance, init_config)
assert isinstance(http.options['auth'], requests_aws.BotoAWSRequestsAuth)
with mock.patch('datadog_checks.base.utils.http.requests_aws.BotoAWSRequestsAuth') as m:
RequestsWrapper(instance, init_config)
m.assert_called_once_with(aws_host='uri', aws_region='earth', aws_service='saas')
def test_config_aws_service_remapper(self):
instance = {'auth_type': 'aws', 'aws_region': 'us-east-1'}
init_config = {}
remapper = {
'aws_service': {'name': 'aws_service', 'default': 'es'},
'aws_host': {'name': 'aws_host', 'default': 'uri'},
}
with mock.patch('datadog_checks.base.utils.http.requests_aws.BotoAWSRequestsAuth') as m:
RequestsWrapper(instance, init_config, remapper)
m.assert_called_once_with(aws_host='uri', aws_region='us-east-1', aws_service='es')
@pytest.mark.parametrize(
'case, instance, match',
[
('no host', {'auth_type': 'aws'}, '^AWS auth requires the setting `aws_host`$'),
('no region', {'auth_type': 'aws', 'aws_host': 'uri'}, '^AWS auth requires the setting `aws_region`$'),
(
'no service',
{'auth_type': 'aws', 'aws_host': 'uri', 'aws_region': 'us-east-1'},
'^AWS auth requires the setting `aws_service`$',
),
('empty host', {'auth_type': 'aws', 'aws_host': ''}, '^AWS auth requires the setting `aws_host`$'),
(
'empty region',
{'auth_type': 'aws', 'aws_host': 'uri', 'aws_region': ''},
'^AWS auth requires the setting `aws_region`$',
),
(
'empty service',
{'auth_type': 'aws', 'aws_host': 'uri', 'aws_region': 'us-east-1', 'aws_service': ''},
'^AWS auth requires the setting `aws_service`$',
),
],
)
def test_config_aws_invalid_cases(self, case, instance, match):
init_config = {}
with pytest.raises(ConfigurationError, match=match):
RequestsWrapper(instance, init_config)
# (C) Datadog, Inc. 2018
# All rights reserved
# Licensed under a 3-clause BSD style license (see LICENSE)
import os
import pytest
from datadog_checks.dev import get_docker_hostname, get_here
from datadog_checks.dev.utils import running_on_windows_ci
not_windows_ci = pytest.mark.skipif(running_on_windows_ci(), reason='Test cannot be run on Windows CI')
HERE = get_here()
FIXTURE_DIR = os.path.join(HERE, 'fixtures')
CHECK_NAME = 'mesos_slave'
URL = 'http://{}:5051'.format(get_docker_hostname())
INSTANCE = {'url': URL, 'tasks': ['hello'], 'tags': ['instance:mytag1']}
BAD_INSTANCE = {'url': 'http://localhost:9999', 'tasks': ['hello']}
