def test_create_id_set_flow(repo, mocker):
# Note: if DEMISTO_SDK_ID_SET_REFRESH_INTERVAL is set it can fail the test
mocker.patch.dict(os.environ,
{'DEMISTO_SDK_ID_SET_REFRESH_INTERVAL': '-1'})
number_of_packs_to_create = 10
repo.setup_content_repo(number_of_packs_to_create)
with ChangeCWD(repo.path):
id_set_creator = IDSetCreator(repo.id_set.path, print_logs=False)
id_set_creator.create_id_set()
id_set_content = repo.id_set.read_json_as_dict()
assert not IsEqualFunctions.is_dicts_equal(id_set_content, {})
assert IsEqualFunctions.is_lists_equal(list(id_set_content.keys()),
ID_SET_ENTITIES)
for id_set_entity in ID_SET_ENTITIES:
entity_content_in_id_set = id_set_content.get(id_set_entity)
assert entity_content_in_id_set
# Since Layouts folder contains both layouts and layoutcontainers then this folder has 2 * amount objects
if id_set_entity != 'Layouts':
assert len(entity_content_in_id_set) == number_of_packs_to_create
else:
assert len(
entity_content_in_id_set) == number_of_packs_to_create * 2
def test_get_integration_data(self):
"""
Test for getting all the integration data
"""
non_unified_file_path = TESTS_DIR + '/test_files/DummyPack/Integrations/DummyIntegration/DummyIntegration.yml'
unified_file_path = TESTS_DIR + '/test_files/DummyPack/Integrations/integration-DummyIntegration.yml'
non_unified_integration_data = get_integration_data(
non_unified_file_path)
unified_integration_data = get_integration_data(unified_file_path)
test_pairs = [(non_unified_integration_data,
TestIntegrations.INTEGRATION_DATA),
(unified_integration_data,
TestIntegrations.UNIFIED_INTEGRATION_DATA)]
for pair in test_pairs:
returned = pair[0]
constant = pair[1]
assert IsEqualFunctions.is_lists_equal(list(returned.keys()),
list(constant.keys()))
const_data = constant.get('Dummy Integration')
returned_data = returned.get('Dummy Integration')
assert IsEqualFunctions.is_dicts_equal(returned_data, const_data)
def test_get_script_data():
"""
Test for getting the script data
"""
file_path = TESTS_DIR + '/test_files/DummyPack/Scripts/DummyScript.yml'
data = get_script_data(file_path)
assert IsEqualFunctions.is_lists_equal(list(data.keys()), list(TestScripts.SCRIPT_DATA.keys()))
const_data = TestScripts.SCRIPT_DATA.get('DummyScript')
returned_data = data.get('DummyScript')
assert IsEqualFunctions.is_dicts_equal(returned_data, const_data)
def test_collect_scripts_command_to_integration(self, id_set):
"""
Given
- A script entry in the id_set containing command_to_integration.
When
- Building dependency graph for pack.
Then
- Extracting the pack that the script depends on.
- Should recognize the pack.
"""
expected_result = {('Active_Directory_Query', True)}
test_input = [
{
"DummyScript": {
"name": "ADGetUser",
"file_path": "Packs/Active_Directory_Query/Scripts/script-ADGetUser.yml",
"depends_on": [
],
"command_to_integration": {
"ad-search": "activedir"
},
"pack": "Active_Directory_Query"
}
}
]
found_result = PackDependencies._collect_scripts_dependencies(pack_scripts=test_input,
id_set=id_set,
verbose_file=VerboseFile(),
)
assert IsEqualFunctions.is_sets_equal(found_result, expected_result)
def test_collect_scripts_depends_on_two_integrations(self, id_set):
"""
Given
- A script entry in the id_set depending on 2 integrations.
When
- Building dependency graph for pack.
Then
- Extracting the packs that the script depends on.
- Should recognize both packs.
"""
expected_result = {('Active_Directory_Query', True), ('Feedsslabusech', True)}
test_input = [
{
"DummyScript": {
"name": "DummyScript",
"file_path": "dummy_path",
"depends_on": [
"sslbl-get-indicators",
"ad-get-user"
],
"pack": "dummy_pack"
}
}
]
found_result = PackDependencies._collect_scripts_dependencies(pack_scripts=test_input,
id_set=id_set,
verbose_file=VerboseFile(),
)
assert IsEqualFunctions.is_sets_equal(found_result, expected_result)
def test_collect_scripts__filter_toversion(self, id_set):
"""
Given
- A script entry in the id_set depending on QRadar command.
When
- Building dependency graph for pack.
Then
- Extracting the packs that the script depends on.
- Should ignore the Deprecated pack due to toversion settings of old QRadar integration.
"""
expected_result = {('QRadar', True)}
test_input = [
{
"DummyScript": {
"name": "DummyScript",
"file_path": "dummy_path",
"depends_on": [
"qradar-searches",
],
"pack": "dummy_pack"
}
}
]
found_result = PackDependencies._collect_scripts_dependencies(pack_scripts=test_input,
id_set=id_set,
verbose_file=VerboseFile(),
exclude_ignored_dependencies=False
)
assert IsEqualFunctions.is_sets_equal(found_result, expected_result)
def test_collect_scripts_depends_on_two_scripts(self, id_set):
"""
Given
- A script entry in the id_set depending on 2 scripts.
When
- Building dependency graph for pack.
Then
- Extracting the packs that the script depends on.
- Should recognize both packs.
"""
expected_result = {('HelloWorld', True), ('PrismaCloudCompute', True)}
test_input = [
{
"DummyScript": {
"name": "DummyScript",
"file_path": "dummy_path",
"depends_on": [
"PrismaCloudComputeParseAuditAlert",
"HelloWorldScript"
],
"pack": "dummy_pack"
}
}
]
found_result = PackDependencies._collect_scripts_dependencies(pack_scripts=test_input,
id_set=id_set,
verbose_file=VerboseFile(),
)
assert IsEqualFunctions.is_sets_equal(found_result, expected_result)
def test_collect_scripts_depends_on_integration(self, dependency_integration_command, expected_result, id_set):
"""
Given
- A script entry in the id_set depending on integration commands.
When
- Building dependency graph for pack.
Then
- Extracting the packs that the script depends on.
- Should recognize the pack.
"""
test_input = [
{
"DummyScript": {
"name": "DummyScript",
"file_path": "dummy_path",
"depends_on": [
dependency_integration_command
],
"pack": "dummy_pack"
}
}
]
found_result = PackDependencies._collect_scripts_dependencies(pack_scripts=test_input,
id_set=id_set,
verbose_file=VerboseFile(),
)
assert IsEqualFunctions.is_sets_equal(found_result, expected_result)
def test_collect_playbooks_dependencies_on_incident_fields(self, id_set):
expected_result = {("DigitalGuardian", True), ("EmployeeOffboarding", True)}
test_input = [
{
"Dummy Playbook": {
"name": "Dummy Playbook",
"file_path": "dummy_path",
"fromversion": "dummy_version",
"implementing_scripts": [
],
"implementing_playbooks": [
],
"command_to_integration": {
},
"tests": [
"dummy_playbook"
],
"pack": "dummy_pack",
"incident_fields": [
"digitalguardianusername",
"Google Display Name"
]
}
}
]
found_result = PackDependencies._collect_playbooks_dependencies(pack_playbooks=test_input,
id_set=id_set)
assert IsEqualFunctions.is_sets_equal(found_result, expected_result)
def test_dependencies(mocker, repo, test_number):
""" This test will run 5 times, when each time it will randomly generate dependencies in the repo and verify that
the expected dependencies has been updated in the pack metadata correctly.
Given
- Content repository
When
- Running find_dependencies
Then
- Update packs dependencies in pack metadata
"""
number_of_packs = 10
repo.setup_content_repo(number_of_packs)
repo.setup_one_pack('CommonTypes')
pack_to_verify = random.choice(range(number_of_packs))
number_of_methods_to_choose = random.choice(range(1, len(METHODS_POOL)))
dependencies = run_random_methods(repo, pack_to_verify,
METHODS_POOL.copy(),
number_of_methods_to_choose)
run_find_dependencies(mocker, repo.path, f'pack_{pack_to_verify}')
dependencies_from_pack_metadata = repo.packs[
pack_to_verify].pack_metadata.read_json_as_dict().get(
'dependencies').keys()
if f'pack_{pack_to_verify}' in dependencies:
dependencies.remove(f'pack_{pack_to_verify}')
assert IsEqualFunctions.is_lists_equal(
list(dependencies), list(dependencies_from_pack_metadata))
def test_collect_classifier_dependencies(self, id_set):
"""
Given
- A classifier entry in the id_set.
When
- Building dependency graph for pack.
Then
- Extracting the packs that the classifier depends on.
"""
expected_result = {("Claroty", True), ("PAN-OS", True), ("Logzio", True)}
test_input = [
{
"Dummy Classifier": {
"name": "Dummy Classifier",
"fromversion": "5.0.0",
"pack": "dummy_pack",
"incident_types": [
"Claroty Integrity Incident",
"FirewallUpgrade",
"Logz.io Alert"
],
}
}
]
found_result = PackDependencies._collect_classifiers_dependencies(
pack_classifiers=test_input, id_set=id_set)
assert IsEqualFunctions.is_sets_equal(found_result, expected_result)
def test_collect_integration_dependencies(self, id_set):
"""
Given
- An integration entry in the id_set.
When
- Building dependency graph for pack.
Then
- Extracting the packs that the integration depends on.
"""
expected_result = {("HelloWorld", True), ("Claroty", True), ("EWS", True), ("CrisisManagement", True), ("CommonTypes", True)}
test_input = [
{
"Dummy Integration": {
"name": "Dummy Integration",
"fromversion": "5.0.0",
"pack": "dummy_pack",
"classifiers": "HelloWorld",
"mappers": [
"Claroty-mapper",
"EWS v2-mapper"
],
"incident_types": "HR Ticket",
"indicator_fields": "CommonTypes",
}
}
]
found_result = PackDependencies._collect_integrations_dependencies(
pack_integrations=test_input, id_set=id_set)
assert IsEqualFunctions.is_sets_equal(found_result, expected_result)
def test_collect_incident_type_dependencies(self, id_set):
"""
Given
- An incident type entry in the id_set.
When
- Building dependency graph for pack.
Then
- Extracting the packs that the incident type depends on.
"""
expected_result = {("AutoFocus", True), ("Volatility", True)}
test_input = [
{
"Dummy Incident Type": {
"name": "Dummy Incident Type",
"fromversion": "5.0.0",
"pack": "dummy_pack",
"playbooks": "Autofocus Query Samples, Sessions and Tags",
"scripts": "AnalyzeMemImage"
}
}
]
found_result = PackDependencies._collect_incidents_types_dependencies(
pack_incidents_types=test_input, id_set=id_set)
assert IsEqualFunctions.is_sets_equal(found_result, expected_result)
def test_collect_widgets_dependencies(self, id_set):
"""
Given
- A mapper entry in the id_set.
When
- Building dependency graph for pack.
Then
- Extracting the packs that the mapper depends on.
"""
expected_result = {('CommonScripts', True)}
test_input = [
{
"Dummy_widget": {
"name": "Dummy Widget",
"fromversion": "5.0.0",
"pack": "dummy_pack",
"scripts": [
"AssignAnalystToIncident"
]
}
}
]
found_result = PackDependencies._collect_widget_dependencies(
pack_widgets=test_input,
id_set=id_set,
verbose_file=VerboseFile(),
)
assert IsEqualFunctions.is_sets_equal(found_result, expected_result)
def test_collect_incident_field_dependencies(self, id_set):
"""
Given
- An incident field entry in the id_set.
When
- Building dependency graph for pack.
Then
- Extracting the packs that the incident field depends on.
"""
expected_result = {("Expanse", True), ("IllusiveNetworks", True), ("Carbon_Black_Enterprise_Response", True), ("Phishing", True)}
test_input = [
{
"Dummy Incident Field": {
"name": "Dummy Incident Field",
"fromversion": "5.0.0",
"pack": "dummy_pack",
"incident_types": [
"Expanse Appearance",
"Illusive Networks Incident"
],
"scripts": [
"CBLiveFetchFiles",
"CheckEmailAuthenticity"
]
}
}
]
found_result = PackDependencies._collect_incidents_fields_dependencies(
pack_incidents_fields=test_input, id_set=id_set)
assert IsEqualFunctions.is_sets_equal(found_result, expected_result)
def test_collect_playbooks_dependencies_on_integrations(self, integration_command, expected_result, id_set):
test_input = [
{
"Dummy Playbook": {
"name": "Dummy Playbook",
"file_path": "dummy_path",
"fromversion": "dummy_version",
"implementing_scripts": [
],
"implementing_playbooks": [
],
"command_to_integration": {
integration_command: ""
},
"tests": [
"dummy_playbook"
],
"pack": "dummy_pack"
}
}
]
found_result = PackDependencies._collect_playbooks_dependencies(pack_playbooks=test_input, id_set=id_set)
assert IsEqualFunctions.is_sets_equal(found_result, expected_result)
def test_collect_scripts_depends_on_with_two_inputs(self, id_set):
expected_result = {('Active_Directory_Query', True), ('Feedsslabusech', True)}
test_input = [
{
"DummyScript1": {
"name": "DummyScript1",
"file_path": "dummy_path1",
"depends_on": [
"sslbl-get-indicators"
],
"pack": "dummy_pack"
}
},
{
"DummyScript2": {
"name": "DummyScript2",
"file_path": "dummy_path1",
"depends_on": [
"ad-get-user"
],
"pack": "dummy_pack"
}
}
]
found_result = PackDependencies._collect_scripts_dependencies(pack_scripts=test_input, id_set=id_set)
assert IsEqualFunctions.is_sets_equal(found_result, expected_result)
def test_specific_entity(mocker, repo, entity_class):
""" This test will run for each entity in the repo, when each time it will randomly generate dependencies
in the repo and verify that the expected dependencies has been updated in the pack metadata correctly.
Given
- Content repository and content entity
When
- Running find_dependencies
Then
- Update packs dependencies in pack metadata
"""
number_of_packs = 20
repo.setup_content_repo(number_of_packs)
repo.setup_one_pack('CommonTypes')
methods_pool: list = \
[(method_name, entity_class) for method_name in list(entity_class.__dict__.keys())
if '_' != method_name[0]]
dependencies = run_random_methods(repo, 0, methods_pool, len(methods_pool))
run_find_dependencies(mocker, repo.path, 'pack_0')
dependencies_from_pack_metadata = repo.packs[
0].pack_metadata.read_json_as_dict().get('dependencies').keys()
if 'pack_0' in dependencies:
dependencies.remove('pack_0')
assert IsEqualFunctions.is_lists_equal(
list(dependencies), list(dependencies_from_pack_metadata))
def test_collect_mapper_dependencies(self, id_set):
"""
Given
- A mapper entry in the id_set.
When
- Building dependency graph for pack.
Then
- Extracting the packs that the mapper depends on.
"""
expected_result = {("AccessInvestigation", True), ("CommonTypes", True), ("PrismaCloud", True), ("BruteForce", True)}
test_input = [
{
"Dummy Mapper": {
"name": "Dummy Mapper",
"fromversion": "5.0.0",
"pack": "dummy_pack",
"incident_types": [
"Access",
"Authentication",
"AWS CloudTrail Misconfiguration"
],
"incident_fields": [
"incident_accountgroups",
"incident_accountid"
],
}
}
]
found_result = PackDependencies._collect_mappers_dependencies(
pack_mappers=test_input, id_set=id_set)
assert IsEqualFunctions.is_sets_equal(found_result, expected_result)
def test_get_playbook_data():
"""
Test for getting the playbook data
"""
file_path = TESTS_DIR + '/test_files/DummyPack/Playbooks/DummyPlaybook.yml'
data = get_playbook_data(file_path)['Dummy Playbook']
assert IsEqualFunctions.is_dicts_equal(data, TestPlaybooks.PLAYBOOK_DATA)
def test_dependencies_case_2(mocker, repo):
"""
Given
- Content repo with the following items:
-"foo" pack containing:
- integration_foo which is a feed integration
- "bar" pack containing:
- mapper_in_bar
- integration_foo using:
- mapper_in_bar
When
- running find_dependencies
Then
- foo pack's pack_metadata should include the following dependencies:
- bar
- CommonTypes
"""
# setup the packs
pack_foo = repo.create_pack('foo')
pack_bar = repo.create_pack('bar')
pack_common_types = repo.create_pack('CommonTypes')
integration_foo = pack_foo.create_integration('integration_foo', yml={'name': 'integration_foo', 'category': ''})
mapper_in_bar = pack_bar.create_mapper(name='mapper_in_bar', content={'id': 'mapper_in_bar',
'name': 'mapper_in_bar',
'mapping': {},
'type': 'mapping'})
# Pack can not be empty
pack_common_types.create_integration('integration_common_types',
yml={'name': 'integration_common_types', 'category': ''})
# make integration_foo feed
IntegrationDependencies.make_integration_feed(
integration_foo
)
# make integration_foo depend on mapper_in_bar
IntegrationDependencies.make_integration_depend_on_mapper_in(
integration_foo,
mapper_in_bar
)
run_find_dependencies(mocker, repo.path, 'foo')
expected_dependencies = ['bar', 'CommonTypes']
dependencies_from_pack_metadata = repo.packs[0].pack_metadata.read_json_as_dict().get('dependencies').keys()
assert IsEqualFunctions.is_lists_equal(expected_dependencies, list(dependencies_from_pack_metadata))
def test_create_id_set_flow(repo):
number_of_packs_to_create = 10
repo.setup_content_repo(number_of_packs_to_create)
with ChangeCWD(repo.path):
id_set_creator = IDSetCreator(repo.id_set.path, print_logs=False)
id_set_creator.create_id_set()
id_set_content = repo.id_set.read_json_as_dict()
assert not IsEqualFunctions.is_dicts_equal(id_set_content, {})
assert IsEqualFunctions.is_lists_equal(list(id_set_content.keys()),
ID_SET_ENTITIES)
for id_set_entity in ID_SET_ENTITIES:
entity_content_in_id_set = id_set_content.get(id_set_entity)
assert entity_content_in_id_set
# Since Layouts folder contains both layouts and layoutcontainers then this folder has 2 * amount objects
if id_set_entity != 'Layouts':
assert len(entity_content_in_id_set) == number_of_packs_to_create
else:
assert len(
entity_content_in_id_set) == number_of_packs_to_create * 2
def test_process_integration__sanity(self):
"""
Given
- A valid script package folder located at Packs/DummyPack/Scripts/DummyScript.
When
- parsing script files
Then
- integration data will be collected properly
"""
non_unified_file_path = os.path.join(TESTS_DIR, 'test_files',
'DummyPack', 'Integrations', 'DummyIntegration')
res = process_integration(non_unified_file_path, True)
assert len(res) == 1
non_unified_integration_data = res[0]
unified_file_path = os.path.join(TESTS_DIR, 'test_files',
'DummyPack', 'Integrations', 'integration-DummyIntegration.yml')
res = process_integration(unified_file_path, True)
assert len(res) == 1
unified_integration_data = res[0]
test_pairs = [
(non_unified_integration_data, TestIntegrations.INTEGRATION_DATA),
(unified_integration_data, TestIntegrations.UNIFIED_INTEGRATION_DATA)
]
for returned, constant in test_pairs:
assert IsEqualFunctions.is_lists_equal(list(returned.keys()), list(constant.keys()))
const_data = constant.get('Dummy Integration')
returned_data = returned.get('Dummy Integration')
assert IsEqualFunctions.is_dicts_equal(returned_data, const_data)
def test_collect_scripts_command_to_integrations_and_script_executions(self, id_set):
"""
Given
- A script entry in the id_set containing command_to_integrations with a reputation command
and script_executions.
When
- Building dependency graph for pack.
Then
- Extracting the packs that the script depends on.
- Should recognize the mandatory pack and the non mandatory packs.
"""
expected_result = {
('Active_Directory_Query', True), ('Recorded_Future', False), ('illuminate', False), ('ThreatQ', False),
('Anomali_ThreatStream', False), ('URLHaus', False), ('Symantec_Deepsight', False),
('XForceExchange', False), ('Active_Directory_Query', True), ('XFE', False), ('MISP', False),
('AlienVault_OTX', False), ('ThreatMiner', False), ('isight', False), ('CrowdStrikeIntel', False),
('ReversingLabs_A1000', False), ('PolySwarm', False), ('TruSTAR', False),
('ReversingLabs_Titanium_Cloud', False), ('ThreatExchange', False), ('EclecticIQ', False),
('AutoFocus', False), ('McAfee-TIE', False), ('Maltiverse', False), ('Palo_Alto_Networks_WildFire', False),
('Polygon', False), ('Cofense-Intelligence', False), ('Lastline', False), ('ThreatConnect', False),
('VirusTotal', False), ('Flashpoint', False)
}
test_input = [
{
"DummyScript": {
"name": "double_dependency",
"file_path": "Packs/DeprecatedContent/Scripts/script-ADIsUserMember.yml",
"deprecated": False,
"depends_on": [
],
"command_to_integration": {
"file": "many integrations"
},
"script_executions": [
"ADGetUser",
],
"pack": "Active_Directory_Query"
}
}
]
found_result = PackDependencies._collect_scripts_dependencies(pack_scripts=test_input,
id_set=id_set,
verbose_file=VerboseFile(),
)
assert IsEqualFunctions.is_sets_equal(found_result, expected_result)
def test_process_script__sanity_package():
"""
Given
- An invalid "script" file located at invalid_file_structures where commonfields object is not a dict.
When
- parsing script files
Then
- an exception will be raised
"""
test_file_path = os.path.join(TESTS_DIR, 'test_files',
'Packs', 'DummyPack', 'Scripts', 'DummyScript')
res = process_script(test_file_path, True)
assert len(res) == 1
data = res[0]
assert IsEqualFunctions.is_lists_equal(list(data.keys()), list(TestScripts.PACK_SCRIPT_DATA.keys()))
const_data = TestScripts.PACK_SCRIPT_DATA.get('DummyScript')
returned_data = data.get('DummyScript')
assert IsEqualFunctions.is_dicts_equal(returned_data, const_data)
def test_collect_scripts_depends_on_integration(self, dependency_integration_command, expected_result, id_set):
test_input = [
{
"DummyScript": {
"name": "DummyScript",
"file_path": "dummy_path",
"depends_on": [
dependency_integration_command
],
"pack": "dummy_pack"
}
}
]
found_result = PackDependencies._collect_scripts_dependencies(pack_scripts=test_input, id_set=id_set)
assert IsEqualFunctions.is_sets_equal(found_result, expected_result)
def test_collect_scripts_depends_on_script(self, dependency_script,
expected_result, id_set):
test_input = [{
"DummyScript": {
"name": "DummyScript",
"file_path": "dummy_path",
"depends_on": [dependency_script],
"pack": "dummy_pack"
}
}]
found_result = PackDependencies._collect_scripts_dependencies(
pack_scripts=test_input,
id_set=id_set,
verbose_file=VerboseFile(),
)
assert IsEqualFunctions.is_sets_equal(found_result, expected_result)
def test_collect_indicator_type_dependencies(self, id_set):
"""
Given
- An indicator type entry in the id_set.
When
- Building dependency graph for pack.
Then
- Extracting the packs that the indicator type depends on.
"""
expected_result = {
# integration dependencies
("Feedsslabusech", False), ("AbuseDB", False), ("ActiveMQ", False),
# script dependencies
("CommonScripts", True), ("Carbon_Black_Enterprise_Response", True)
}
test_input = [
{
"Dummy Indicator Type": {
"name": "Dummy Indicator Type",
"fromversion": "5.0.0",
"pack": "dummy_pack",
"integrations": [
"abuse.ch SSL Blacklist Feed",
"AbuseIPDB",
"ActiveMQ"
],
"scripts": [
"AssignAnalystToIncident",
"CBAlerts"
]
}
}
]
found_result = PackDependencies._collect_indicators_types_dependencies(
pack_indicators_types=test_input,
id_set=id_set,
verbose_file=VerboseFile(),
)
assert IsEqualFunctions.is_sets_equal(found_result, expected_result)
def test_search_for_specific_pack_playbook_item(self, id_set):
pack_id = "Expanse"
expected_result = [{
"ExpanseParseRawIncident": {
"name": "Expanse Incident Playbook",
"file_path":
"Packs/Expanse/Playbooks/Expanse_Incident_Playbook.yml",
"fromversion": "5.0.0",
"implementing_scripts": ["ExpanseParseRawIncident"],
"tests": ["No tests (auto formatted)"],
"pack": "Expanse"
}
}]
found_filtered_result = PackDependencies._search_for_pack_items(
pack_id, id_set['playbooks'])
assert IsEqualFunctions.is_lists_equal(found_filtered_result,
expected_result)
def test_collect_scripts_depends_on_two_scripts(self, id_set):
expected_result = {('HelloWorld', True), ('PrismaCloudCompute', True)}
test_input = [
{
"DummyScript": {
"name": "DummyScript",
"file_path": "dummy_path",
"depends_on": [
"PrismaCloudComputeParseAuditAlert",
"HelloWorldScript"
],
"pack": "dummy_pack"
}
}
]
found_result = PackDependencies._collect_scripts_dependencies(pack_scripts=test_input, id_set=id_set)
assert IsEqualFunctions.is_sets_equal(found_result, expected_result)
