def test_non_primitive(self, caplog):
check = AgentCheck('test', {}, [{'foo': ['bar']}])
check.check_id = 'test:123'
with caplog.at_level(
logging.DEBUG), mock.patch(SET_CHECK_METADATA_METHOD) as m:
check.set_metadata('config',
check.instance,
section='instance',
whitelist=['foo'])
assert m.call_count == 1
args, _ = m.call_args
assert args[0] == 'test:123'
assert args[1] == 'config.instance'
expected_message = (
'Skipping metadata submission of non-primitive type `list` for field `foo` in section `instance`'
)
for _, level, message in caplog.record_tuples:
if level == logging.DEBUG and message == expected_message:
break
else:
raise AssertionError(
'Expected ERROR log with message: {}'.format(
expected_message))
def test_parts_final_scheme(self):
check = AgentCheck('test', {}, [{}])
check.check_id = 'test:123'
with mock.patch(SET_CHECK_METADATA_METHOD) as m:
check.set_metadata(
'version',
'19.15.2.2',
scheme='parts',
final_scheme='calver',
part_map={
'year': '19',
'major': '15',
'minor': '2',
'patch': '2',
'revision': '56789'
},
)
m.assert_any_call('test:123', 'version.year', '19')
m.assert_any_call('test:123', 'version.major', '15')
m.assert_any_call('test:123', 'version.minor', '2')
m.assert_any_call('test:123', 'version.patch', '2')
m.assert_any_call('test:123', 'version.revision', '56789')
m.assert_any_call('test:123', 'version.raw', '19.15.2.2')
m.assert_any_call('test:123', 'version.scheme', 'calver')
assert m.call_count == 7
def test_blacklist_user_override(self):
check = AgentCheck('test', {}, [{
'foo': 'bar',
'bar': 'foo',
'metadata_blacklist': ['bar']
}])
check.check_id = 'test:123'
with mock.patch(SET_CHECK_METADATA_METHOD) as m:
check.set_metadata('config',
check.instance,
section='instance',
whitelist=['foo', 'bar'],
blacklist=['foo'])
assert m.call_count == 1
args, _ = m.call_args
assert args[0] == 'test:123'
assert args[1] == 'config.instance'
data = json.loads(args[2])
assert len(data) == 1
data = data[0]
assert data.pop('is_set', None) is True
assert data.pop('value', None) == 'bar'
assert not data
def test_load_configuration_models(dd_run_check, mocker):
instance = {'endpoint': 'url', 'tags': ['foo:bar'], 'proxy': {'http': 'http://1.2.3.4:9000'}}
init_config = {'proxy': {'https': 'https://1.2.3.4:4242'}}
check = AgentCheck('test', init_config, [instance])
check.check_id = 'test:123'
check.check = lambda _: None
assert check._config_model_instance is None
assert check._config_model_shared is None
instance_config = {}
shared_config = {}
package = mocker.MagicMock()
package.InstanceConfig = mocker.MagicMock(return_value=instance_config)
package.SharedConfig = mocker.MagicMock(return_value=shared_config)
import_module = mocker.patch('importlib.import_module', return_value=package)
dd_run_check(check)
instance_data = check._get_config_model_initialization_data()
instance_data.update(instance)
init_config_data = check._get_config_model_initialization_data()
init_config_data.update(init_config)
import_module.assert_called_with('datadog_checks.base.config_models')
package.InstanceConfig.assert_called_once_with(**instance_data)
package.SharedConfig.assert_called_once_with(**init_config_data)
assert check._config_model_instance is instance_config
assert check._config_model_shared is shared_config
def test_no_whitelist(self):
check = AgentCheck('test', {}, [{'foo': 'bar'}])
check.check_id = 'test:123'
with mock.patch(SET_CHECK_METADATA_METHOD) as m:
check.set_metadata('config', check.instance, section='instance')
assert m.call_count == 0
def test_blacklist_default(self):
check = AgentCheck('test', {}, [{'product_password': '******'}])
check.check_id = 'test:123'
with mock.patch(SET_CHECK_METADATA_METHOD) as m:
check.set_metadata('config', check.instance, section='instance', whitelist=['product_password'])
assert m.call_count == 0
def test_persistent_cache(datadog_agent):
check = AgentCheck()
check.check_id = 'test'
check.write_persistent_cache('foo', 'bar')
assert datadog_agent.read_persistent_cache('test_foo') == 'bar'
assert check.read_persistent_cache('foo') == 'bar'
def test_default(self):
check = AgentCheck('test', {}, [{}])
check.check_id = 'test:123'
with mock.patch(SET_CHECK_METADATA_METHOD) as m:
check.set_metadata('foo', 'bar')
m.assert_called_once_with('test:123', 'foo', 'bar')
def test_semver_default(self):
check = AgentCheck('test', {}, [{}])
check.check_id = 'test:123'
with mock.patch(SET_CHECK_METADATA_METHOD) as m:
check.set_metadata('version', '1.0.5')
m.assert_any_call('test:123', 'version.major', '1')
m.assert_any_call('test:123', 'version.minor', '0')
m.assert_any_call('test:123', 'version.patch', '5')
m.assert_any_call('test:123', 'version.raw', '1.0.5')
m.assert_any_call('test:123', 'version.scheme', 'semver')
assert m.call_count == 5
def test_regex(self, version, pattern, expected_parts):
check = AgentCheck('test', {}, [{}])
check.check_id = 'test:123'
with mock.patch(SET_CHECK_METADATA_METHOD) as m:
check.set_metadata('version', version, scheme='regex', pattern=pattern)
for name, value in expected_parts.items():
m.assert_any_call('test:123', 'version.{}'.format(name), value)
m.assert_any_call('test:123', 'version.raw', version)
m.assert_any_call('test:123', 'version.scheme', 'test')
assert m.call_count == len(expected_parts) + 2
def test_unknown_scheme(self, caplog):
check = AgentCheck('test', {}, [{}])
check.check_id = 'test:123'
with caplog.at_level(logging.DEBUG), mock.patch(SET_CHECK_METADATA_METHOD) as m:
check.set_metadata('version', '1.0.0', scheme='foo')
assert m.call_count == 0
expected_message = 'Unable to transform `version` metadata value `1.0.0`: Unsupported version scheme `foo`'
for _, level, message in caplog.record_tuples:
if level == logging.WARNING and message == expected_message:
break
else:
raise AssertionError('Expected ERROR log with message: {}'.format(expected_message))
def test_semver_release_and_build(self):
check = AgentCheck('test', {}, [{}])
check.check_id = 'test:123'
with mock.patch(SET_CHECK_METADATA_METHOD) as m:
check.set_metadata('version', '1.0.5-gke.6+3', scheme='semver')
m.assert_any_call('test:123', 'version.major', '1')
m.assert_any_call('test:123', 'version.minor', '0')
m.assert_any_call('test:123', 'version.patch', '5')
m.assert_any_call('test:123', 'version.release', 'gke.6')
m.assert_any_call('test:123', 'version.build', '3')
m.assert_any_call('test:123', 'version.raw', '1.0.5-gke.6+3')
m.assert_any_call('test:123', 'version.scheme', 'semver')
assert m.call_count == 7
def test_semver_invalid(self, caplog):
check = AgentCheck('test', {}, [{}])
check.check_id = 'test:123'
with caplog.at_level(logging.DEBUG), mock.patch(SET_CHECK_METADATA_METHOD) as m:
check.set_metadata('version', '1.0', scheme='semver')
assert m.call_count == 0
expected_prefix = 'Unable to transform `version` metadata value `1.0`: '
for _, level, message in caplog.record_tuples:
if level == logging.WARNING and message.startswith(expected_prefix):
break
else:
raise AssertionError('Expected ERROR log starting with message: {}'.format(expected_prefix))
def test_no_section(self, caplog):
check = AgentCheck('test', {}, [{}])
check.check_id = 'test:123'
with caplog.at_level(logging.DEBUG), mock.patch(SET_CHECK_METADATA_METHOD) as m:
check.set_metadata('config', {})
assert m.call_count == 0
expected_message = 'Unable to transform `config` metadata: The `section` option is required'
for _, level, message in caplog.record_tuples:
if level == logging.WARNING and message == expected_message:
break
else:
raise AssertionError('Expected ERROR log with message: {}'.format(expected_message))
def test_encoding(self):
check = AgentCheck('test', {}, [{}])
check.check_id = 'test:123'
if PY3:
constructor = ensure_bytes
finalizer = ensure_unicode
else:
constructor = ensure_unicode
finalizer = ensure_bytes
name = constructor(u'nam\u00E9')
value = constructor(u'valu\u00E9')
with mock.patch(SET_CHECK_METADATA_METHOD) as m:
check.set_metadata(name, value)
m.assert_called_once_with('test:123', finalizer(name), finalizer(value))
def test_whitelist_no_field(self):
check = AgentCheck('test', {}, [{}])
check.check_id = 'test:123'
with mock.patch(SET_CHECK_METADATA_METHOD) as m:
check.set_metadata('config', check.instance, section='instance', whitelist=['foo'])
assert m.call_count == 1
args, _ = m.call_args
assert args[0] == 'test:123'
assert args[1] == 'config.instance'
data = json.loads(args[2])[0]
assert data.pop('is_set', None) is False
assert not data
def test_regex_no_pattern(self, caplog):
check = AgentCheck('test', {}, [{}])
check.check_id = 'test:123'
with caplog.at_level(logging.DEBUG), mock.patch(SET_CHECK_METADATA_METHOD) as m:
check.set_metadata('version', '1.0', scheme='regex')
assert m.call_count == 0
expected_message = (
'Unable to transform `version` metadata value `1.0`: Version scheme `regex` requires a `pattern` option'
)
for _, level, message in caplog.record_tuples:
if level == logging.WARNING and message == expected_message:
break
else:
raise AssertionError('Expected ERROR log with message: {}'.format(expected_message))
def test_regex_no_subgroups(self, caplog):
check = AgentCheck('test', {}, [{}])
check.check_id = 'test:123'
with caplog.at_level(logging.DEBUG), mock.patch(SET_CHECK_METADATA_METHOD) as m:
check.set_metadata('version', '1.0.0', scheme='regex', pattern=r'\d\.\d\.\d')
assert m.call_count == 0
expected_message = (
'Unable to transform `version` metadata value `1.0.0`: '
'Regular expression pattern has no named subgroups'
)
for _, level, message in caplog.record_tuples:
if level == logging.ERROR and message == expected_message:
break
else:
raise AssertionError('Expected ERROR log with message: {}'.format(expected_message))
def test_detect_typos_configuration_models(
dd_run_check, mocker, caplog, check_instance_config, default_instance_config, log_lines
):
caplog.clear()
caplog.set_level(logging.WARNING)
empty_config = {}
default_instance = mocker.MagicMock()
default_instance.__iter__ = mocker.MagicMock(return_value=iter(default_instance_config))
check = AgentCheck('test', empty_config, [check_instance_config])
check.check_id = 'test:123'
check.log_typos_in_options(check_instance_config, default_instance, 'instance')
if log_lines is not None:
for log_line in log_lines:
assert log_line in caplog.text
else:
assert 'Detected potential typo in configuration option' not in caplog.text
def test_regex_final_scheme(self):
check = AgentCheck('test', {}, [{}])
check.check_id = 'test:123'
with mock.patch(SET_CHECK_METADATA_METHOD) as m:
check.set_metadata(
'version',
'1.2.3.beta',
scheme='regex',
final_scheme='semver',
pattern=r'(?P<major>\d+)\.(?P<minor>\d+)\.(?P<patch>\d+).(?P<release>\w+)',
)
m.assert_any_call('test:123', 'version.major', '1')
m.assert_any_call('test:123', 'version.minor', '2')
m.assert_any_call('test:123', 'version.patch', '3')
m.assert_any_call('test:123', 'version.release', 'beta')
m.assert_any_call('test:123', 'version.raw', '1.2.3.beta')
m.assert_any_call('test:123', 'version.scheme', 'semver')
assert m.call_count == 6
