def test_split_chained_sub_model_plans(
tmp_path: pathlib.Path, simplified_nist_catalog: oscatalog.Catalog,
keep_cwd: pathlib.Path) -> None:
"""Test for split_model method with chained sum models like catalog.metadata.parties.*."""
# Assume we are running a command like below
# trestle split -f catalog.json -e catalog.metadata.parties.*
# see https://github.com/IBM/compliance-trestle/issues/172
content_type = FileContentType.JSON
# prepare trestle project dir with the file
catalog_dir, catalog_file = test_utils.prepare_trestle_project_dir(
tmp_path, content_type, simplified_nist_catalog,
test_utils.CATALOGS_DIR)
# read the model from file
catalog = oscatalog.Catalog.oscal_read(catalog_file)
element = Element(catalog)
element_args = ['catalog.metadata.parties.*']
element_paths = cmd_utils.parse_element_args(
None, element_args, catalog_dir.relative_to(tmp_path))
assert 2 == len(element_paths)
expected_plan = Plan()
# prepare to extract metadata and parties
metadata_file = catalog_dir / element_paths[0].to_file_path(content_type)
metadata_field_alias = element_paths[0].get_element_name()
metadata = element.get_at(element_paths[0])
meta_element = Element(metadata, metadata_field_alias)
# extract parties
parties_dir = catalog_dir / 'catalog/metadata/parties'
for i, party in enumerate(meta_element.get_at(element_paths[1], False)):
prefix = str(i).zfill(const.FILE_DIGIT_PREFIX_LENGTH)
sub_model_actions = SplitCmd.prepare_sub_model_split_actions(
party, parties_dir, prefix, content_type)
expected_plan.add_actions(sub_model_actions)
# stripped metadata
stripped_metadata = metadata.stripped_instance(
stripped_fields_aliases=['parties'])
expected_plan.add_action(CreatePathAction(metadata_file))
expected_plan.add_action(
WriteFileAction(metadata_file,
Element(stripped_metadata, metadata_field_alias),
content_type))
# stripped catalog
root_file = catalog_dir / element_paths[0].to_root_path(content_type)
remaining_root = element.get().stripped_instance(metadata_field_alias)
expected_plan.add_action(CreatePathAction(root_file, True))
expected_plan.add_action(
WriteFileAction(root_file, Element(remaining_root), content_type))
split_plan = SplitCmd.split_model(catalog, element_paths, catalog_dir,
content_type, '', None)
assert expected_plan == split_plan
def test_split_model_plans(
tmp_path: pathlib.Path,
sample_nist_component_def: component.ComponentDefinition) -> None:
"""Test for split_model method."""
# Assume we are running a command like below
# trestle split -f component-definition.yaml -e component-definition.metadata
content_type = FileContentType.YAML
# prepare trestle project dir with the file
component_def_dir, component_def_file = test_utils.prepare_trestle_project_dir(
tmp_path, content_type, sample_nist_component_def,
test_utils.COMPONENT_DEF_DIR)
# read the model from file
component_def = component.ComponentDefinition.oscal_read(
component_def_file)
element = Element(component_def)
element_args = ['component-definition.metadata']
element_paths = cmd_utils.parse_element_args(None, element_args)
# extract values
metadata_file = component_def_dir / element_paths[0].to_file_path(
content_type)
metadata = element.get_at(element_paths[0])
root_file = component_def_dir / element_paths[0].to_root_path(content_type)
remaining_root = element.get().stripped_instance(
element_paths[0].get_element_name())
# prepare the plan
expected_plan = Plan()
expected_plan.add_action(CreatePathAction(metadata_file))
expected_plan.add_action(
WriteFileAction(metadata_file, Element(metadata), content_type))
expected_plan.add_action(CreatePathAction(root_file, True))
expected_plan.add_action(
WriteFileAction(root_file, Element(remaining_root), content_type))
split_plan = SplitCmd.split_model(component_def, element_paths,
component_def_dir, content_type, '',
None)
assert expected_plan == split_plan
def test_split_model(tmp_dir, sample_target_def: ostarget.TargetDefinition):
"""Test for split_model method."""
# Assume we are running a command like below
# trestle split -f target-definition.yaml -e target-definition.metadata
content_type = FileContentType.YAML
# prepare trestle project dir with the file
target_def_dir, target_def_file = test_utils.prepare_trestle_project_dir(
tmp_dir, content_type, sample_target_def, test_utils.TARGET_DEFS_DIR)
# read the model from file
target_def = ostarget.TargetDefinition.oscal_read(target_def_file)
element = Element(target_def)
element_args = ['target-definition.metadata']
element_paths = cmd_utils.parse_element_args(element_args)
# extract values
metadata_file = target_def_dir / element_paths[0].to_file_path(
content_type)
metadata = element.get_at(element_paths[0])
root_file = target_def_dir / element_paths[0].to_root_path(content_type)
remaining_root = element.get().stripped_instance(
element_paths[0].get_element_name())
# prepare the plan
expected_plan = Plan()
expected_plan.add_action(CreatePathAction(metadata_file))
expected_plan.add_action(
WriteFileAction(metadata_file, Element(metadata), content_type))
expected_plan.add_action(CreatePathAction(root_file, True))
expected_plan.add_action(
WriteFileAction(root_file, Element(remaining_root), content_type))
split_plan = SplitCmd.split_model(target_def, element_paths,
target_def_dir, content_type)
assert expected_plan == split_plan
def test_split_multi_level_dict(
tmp_path: pathlib.Path,
sample_target_def: ostarget.TargetDefinition) -> None:
"""Test for split_model method."""
# Assume we are running a command like below
# trestle split -f target.yaml -e target-definition.targets.*.target-control-implementations.*
content_type = FileContentType.YAML
# prepare trestle project dir with the file
target_def_dir, target_def_file = test_utils.prepare_trestle_project_dir(
tmp_path, content_type, sample_target_def, test_utils.TARGET_DEFS_DIR)
file_ext = FileContentType.to_file_extension(content_type)
# read the model from file
target_def: ostarget.TargetDefinition = ostarget.TargetDefinition.oscal_read(
target_def_file)
element = Element(target_def)
element_args = [
'target-definition.targets.*.target-control-implementations.*'
]
element_paths = test_utils.prepare_element_paths(target_def_dir,
element_args)
expected_plan = Plan()
# extract values
targets: dict = element.get_at(element_paths[0])
targets_dir = target_def_dir / element_paths[0].to_file_path()
# split every targets
for key in targets:
# individual target dir
target: ostarget.Target = targets[key]
target_element = Element(targets[key])
model_type = utils.classname_to_alias(type(target).__name__, 'json')
dir_prefix = key
target_dir_name = f'{dir_prefix}{const.IDX_SEP}{model_type}'
target_file = targets_dir / f'{target_dir_name}{file_ext}'
# target control impl dir for the target
target_ctrl_impls: dict = target_element.get_at(element_paths[1])
targets_ctrl_dir = targets_dir / element_paths[1].to_file_path(
root_dir=target_dir_name)
for i, target_ctrl_impl in enumerate(target_ctrl_impls):
model_type = utils.classname_to_alias(
type(target_ctrl_impl).__name__, 'json')
file_prefix = str(i).zfill(const.FILE_DIGIT_PREFIX_LENGTH)
file_name = f'{file_prefix}{const.IDX_SEP}{model_type}{file_ext}'
file_path = targets_ctrl_dir / file_name
expected_plan.add_action(CreatePathAction(file_path))
expected_plan.add_action(
WriteFileAction(file_path, Element(target_ctrl_impl),
content_type))
# write stripped target model
stripped_target = target.stripped_instance(
stripped_fields_aliases=[element_paths[1].get_element_name()])
expected_plan.add_action(CreatePathAction(target_file))
expected_plan.add_action(
WriteFileAction(target_file, Element(stripped_target),
content_type))
root_file = target_def_dir / f'target-definition{file_ext}'
remaining_root = element.get().stripped_instance(
stripped_fields_aliases=[element_paths[0].get_element_name()])
expected_plan.add_action(CreatePathAction(root_file, True))
expected_plan.add_action(
WriteFileAction(root_file, Element(remaining_root), content_type))
split_plan = SplitCmd.split_model(target_def, element_paths,
target_def_dir, content_type)
assert expected_plan == split_plan
def test_subsequent_split_model(
tmp_path: pathlib.Path,
sample_target_def: ostarget.TargetDefinition) -> None:
"""Test subsequent split of sub models."""
# Assume we are running a command like below
# trestle split -f target-definition.yaml -e target-definition.metadata
content_type = FileContentType.YAML
# prepare trestle project dir with the file
target_def_dir, target_def_file = test_utils.prepare_trestle_project_dir(
tmp_path, content_type, sample_target_def, test_utils.TARGET_DEFS_DIR)
# first split the target-def into metadata
target_def = ostarget.TargetDefinition.oscal_read(target_def_file)
element = Element(target_def, 'target-definition')
element_args = ['target-definition.metadata']
element_paths = test_utils.prepare_element_paths(target_def_dir,
element_args)
metadata_file = target_def_dir / element_paths[0].to_file_path(
content_type)
metadata: ostarget.Metadata = element.get_at(element_paths[0])
root_file = target_def_dir / element_paths[0].to_root_path(content_type)
metadata_field_alias = element_paths[0].get_element_name()
stripped_root = element.get().stripped_instance(
stripped_fields_aliases=[metadata_field_alias])
root_wrapper_alias = utils.classname_to_alias(
stripped_root.__class__.__name__, 'json')
first_plan = Plan()
first_plan.add_action(CreatePathAction(metadata_file))
first_plan.add_action(
WriteFileAction(metadata_file, Element(metadata, metadata_field_alias),
content_type))
first_plan.add_action(CreatePathAction(root_file, True))
first_plan.add_action(
WriteFileAction(root_file, Element(stripped_root, root_wrapper_alias),
content_type))
first_plan.execute() # this will split the files in the temp directory
# now, prepare the expected plan to split metadta at parties
second_plan = Plan()
metadata_file_dir = target_def_dir / element_paths[0].to_root_path()
metadata2 = ostarget.Metadata.oscal_read(metadata_file)
element = Element(metadata2, metadata_field_alias)
element_args = ['metadata.parties.*']
element_paths = test_utils.prepare_element_paths(target_def_dir,
element_args)
parties_dir = metadata_file_dir / element_paths[0].to_file_path()
for i, party in enumerate(element.get_at(element_paths[0])):
prefix = str(i).zfill(const.FILE_DIGIT_PREFIX_LENGTH)
sub_model_actions = SplitCmd.prepare_sub_model_split_actions(
party, parties_dir, prefix, content_type)
second_plan.add_actions(sub_model_actions)
# stripped metadata
stripped_metadata = metadata2.stripped_instance(
stripped_fields_aliases=['parties'])
second_plan.add_action(CreatePathAction(metadata_file, True))
second_plan.add_action(
WriteFileAction(metadata_file,
Element(stripped_metadata, metadata_field_alias),
content_type))
# call the split command and compare the plans
split_plan = SplitCmd.split_model(metadata, element_paths,
metadata_file_dir, content_type)
assert second_plan == split_plan
def test_split_multi_level_dict_plans(
tmp_path: pathlib.Path,
sample_nist_component_def: component.ComponentDefinition,
keep_cwd) -> None:
"""Test for split_model method."""
# Assume we are running a command like below
# trestle split -f target.yaml -e component-definition.components.*.control-implementations.*
content_type = FileContentType.YAML
# prepare trestle project dir with the file
component_def_dir, component_def_file = test_utils.prepare_trestle_project_dir(
tmp_path, content_type, sample_nist_component_def,
test_utils.COMPONENT_DEF_DIR)
file_ext = FileContentType.to_file_extension(content_type)
# read the model from file
component_def: component.ComponentDefinition = component.ComponentDefinition.oscal_read(
component_def_file)
element = Element(component_def)
element_args = [
'component-definition.components.*.control-implementations.*'
]
element_paths = cmd_utils.parse_element_args(
None, element_args, component_def_dir.relative_to(tmp_path))
expected_plan = Plan()
# extract values
components: list = element.get_at(element_paths[0])
components_dir = component_def_dir / element_paths[0].to_file_path()
# split every targets
for index, comp_obj in enumerate(components):
# individual target dir
component_element = Element(comp_obj)
model_type = str_utils.classname_to_alias(
type(comp_obj).__name__, AliasMode.JSON)
dir_prefix = str(index).zfill(const.FILE_DIGIT_PREFIX_LENGTH)
component_dir_name = f'{dir_prefix}{const.IDX_SEP}{model_type}'
component_file = components_dir / f'{component_dir_name}{file_ext}'
# target control impl dir for the target
component_ctrl_impls: list = component_element.get_at(element_paths[1])
component_ctrl_dir = components_dir / element_paths[1].to_file_path(
root_dir=component_dir_name)
for i, component_ctrl_impl in enumerate(component_ctrl_impls):
model_type = str_utils.classname_to_alias(
type(component_ctrl_impl).__name__, AliasMode.JSON)
file_prefix = str(i).zfill(const.FILE_DIGIT_PREFIX_LENGTH)
file_name = f'{file_prefix}{const.IDX_SEP}{model_type}{file_ext}'
file_path = component_ctrl_dir / file_name
expected_plan.add_action(CreatePathAction(file_path))
expected_plan.add_action(
WriteFileAction(file_path, Element(component_ctrl_impl),
content_type))
# write stripped target model
stripped_target = comp_obj.stripped_instance(
stripped_fields_aliases=[element_paths[1].get_element_name()])
expected_plan.add_action(CreatePathAction(component_file))
expected_plan.add_action(
WriteFileAction(component_file, Element(stripped_target),
content_type))
root_file = component_def_dir / f'component-definition{file_ext}'
remaining_root = element.get().stripped_instance(
stripped_fields_aliases=[element_paths[0].get_element_name()])
expected_plan.add_action(CreatePathAction(root_file, True))
expected_plan.add_action(
WriteFileAction(root_file, Element(remaining_root), content_type))
split_plan = SplitCmd.split_model(component_def, element_paths,
component_def_dir, content_type, '',
None)
assert expected_plan == split_plan