def test_get_path_lists_search(iterate_mock, search_text, complementary_search,
search_in_fields, paths, expected_result):
"""Test `get_path_lists` functionality when using the `search` parameter.
Parameters
----------
search_text : str
The text to search.
complementary_search : bool
If True, only results NOT containing `search_text` will be returned. If False, only results that contains
`search_text` will be returned.
search_in_fields : str
Name of the field to search in for the `search_text`.
paths : list of str
A list of CDB files to read, with their relative path.
expected_result : list of dict
The content expected to be returned by `get_lists` when using the specified search parameters.
"""
common.reset_context_cache()
result = get_path_lists(filename=paths,
search_text=search_text,
complementary_search=complementary_search,
search_in_fields=search_in_fields,
sort_by=['filename'])
assert isinstance(result, AffectedItemsWazuhResult)
assert result.total_affected_items == len(expected_result)
assert result.affected_items == expected_result
def test_context_cached():
"""Verify that context_cached decorator correctly saves and returns saved value when called again."""
test_context_cached.calls_to_foo = 0
@context_cached('foobar')
def foo(arg='bar', **data):
test_context_cached.calls_to_foo += 1
print(data)
return arg
# The result of function 'foo' is being cached and it has been called once
assert foo(
) == 'bar' and test_context_cached.calls_to_foo == 1, '"bar" should be returned with 1 call to foo.'
assert foo(
) == 'bar' and test_context_cached.calls_to_foo == 1, '"bar" should be returned with 1 call to foo.'
assert isinstance(
get_context_cache()[json.dumps({
"key": "foobar",
"args": [],
"kwargs": {}
})], ContextVar)
# foo called with an argument
assert foo('other_arg') == 'other_arg' and test_context_cached.calls_to_foo == 2, '"other_arg" should be ' \
'returned with 2 calls to foo. '
assert isinstance(
get_context_cache()[json.dumps({
"key": "foobar",
"args": ['other_arg'],
"kwargs": {}
})], ContextVar)
# foo called with the same argument as default, a new context var is created in the cache
assert foo('bar') == 'bar' and test_context_cached.calls_to_foo == 3, '"bar" should be returned with 3 calls to ' \
'foo. '
assert isinstance(
get_context_cache()[json.dumps({
"key": "foobar",
"args": ['bar'],
"kwargs": {}
})], ContextVar)
# Reset cache and calls to foo
reset_context_cache()
test_context_cached.calls_to_foo = 0
# foo called with kwargs, a new context var is created with kwargs not empty
assert foo(data='bar') == 'bar' and test_context_cached.calls_to_foo == 1, '"bar" should be returned with 1 ' \
'calls to foo. '
assert isinstance(
get_context_cache()[json.dumps({
"key": "foobar",
"args": [],
"kwargs": {
"data": "bar"
}
})], ContextVar)
def run_local():
self.logger.debug("Starting to execute request locally")
common.rbac.set(self.rbac_permissions)
common.broadcast.set(self.broadcasting)
common.cluster_nodes.set(self.nodes)
common.current_user.set(self.current_user)
data = self.f(**self.f_kwargs)
common.reset_context_cache()
self.logger.debug("Finished executing request locally")
return data
def test_context_cached():
"""Verify that context_cached decorator correctly saves and returns saved value when called again"""
@context_cached('foobar')
def foo(arg='bar'):
return arg
assert foo() == 'bar', '"bar" should be returned.'
assert foo('other_arg') != 'other_arg', '"bar" should be returned.'
reset_context_cache()
assert foo('other_arg_2') == 'other_arg_2', '"other_arg_2" should be returned.'
assert foo() == 'other_arg_2', '"other_arg_2" should be returned.'
def test_get_path_lists(iterate_mock):
"""Test `get_path_lists` functionality without any other parameter aside from `path`.
`get_path_lists` works different than `get_lists` as it will read every CDB file from the default path (mocked to
`DATA_PATH`) and will remove from the result any file that is not in the `path` parameter provided.
"""
common.reset_context_cache()
result = get_path_lists(filename=[NAME_FILE_1])
assert isinstance(result, AffectedItemsWazuhResult)
assert result.total_affected_items == len(RESULT_GET_PATH_LIST_FILE_1)
assert result.affected_items == RESULT_GET_PATH_LIST_FILE_1
def test_get_path_lists_offset(iterate_mock, offset):
"""Test `get__path_lists` functionality when using the `offset` parameter.
Parameters
----------
offset : int
Indicates the first item to return.
"""
common.reset_context_cache()
result = get_path_lists(filename=NAME_FILES,
offset=offset,
sort_by=['filename'])
assert isinstance(result, AffectedItemsWazuhResult)
assert result.total_affected_items == TOTAL_LISTS
assert result.affected_items == RESULTS_GET_PATH_LIST[offset:]
def test_get_path_lists_limit(iterate_mock, limit):
"""Test `get_path_lists` functionality when using the `limit` parameter.
Parameters
----------
limit : int
Maximum number of items to be returned by `get_path_lists`
"""
common.reset_context_cache()
result = get_path_lists(filename=NAME_FILES,
limit=limit,
sort_by=['filename'])
assert isinstance(result, AffectedItemsWazuhResult)
assert result.total_affected_items == TOTAL_LISTS
assert result.affected_items == RESULTS_GET_PATH_LIST[:limit]
def run_local(f, f_kwargs, logger, rbac_permissions, broadcasting, nodes,
current_user):
"""Run framework SDK function locally in another process."""
def debug_log(logger, message):
if logger.name == 'wazuh-api':
logger.debug2(message)
else:
logger.debug(message)
debug_log(logger, "Starting to execute request locally")
common.rbac.set(rbac_permissions)
common.broadcast.set(broadcasting)
common.cluster_nodes.set(nodes)
common.current_user.set(current_user)
data = f(**f_kwargs)
common.reset_context_cache()
debug_log(logger, "Finished executing request locally")
return data
def test_iterate_lists(only_names, path):
"""Test `iterate_lists` core functionality.
`Iterate_list` must get the content of all CDB lists in a specified path skipping `.cdb` and `.swp` files. It will
return a list of dictionaries.
Parameters
----------
only_names : bool
If this parameter is true, only the name of all lists will be showed by `iterate_lists` instead of its content.
path : str
Path to iterate lists from.
"""
required_fields = ['relative_dirname', 'filename'] if only_names else ['relative_dirname', 'filename', 'items']
common.reset_context_cache()
result = iterate_lists(absolute_path=path, only_names=only_names)
assert isinstance(result, list)
assert len(result) != 0
for entry in result:
for field in required_fields:
assert field in entry
