def test_policy_definitions(self):
self.generator.generate_custom_attribute("policy", title="My Attribute")
self.generator.generate_custom_attribute(
"policy", title="Mandatory Attribute", mandatory=True)
definitions = get_object_column_definitions(models.Policy)
mapping_names = get_mapping_names(models.Policy.__name__)
display_names = {val["display_name"] for val in definitions.itervalues()}
element_names = {
"Code",
"Title",
"Description",
"Notes",
"Owner",
"Primary Contact",
"Secondary Contact",
"Policy URL",
"Reference URL",
"Kind/Type",
"Effective Date",
"Stop Date",
"State",
"My Attribute",
"Mandatory Attribute",
"Review State",
"Delete",
}
expected_names = element_names.union(mapping_names)
self.assertEqual(expected_names, display_names)
vals = {val["display_name"]: val for val in definitions.itervalues()}
self.assertTrue(vals["Title"]["mandatory"])
self.assertTrue(vals["Owner"]["mandatory"])
self.assertTrue(vals["Title"]["unique"])
self.assertTrue(vals["Mandatory Attribute"]["mandatory"])
def __init__(self, converter, object_class, rows, raw_headers,
offset, class_name, csv_lines):
# pylint: disable=too-many-arguments
super(ImportBlockConverter, self).__init__(
converter,
object_class=object_class,
raw_headers=raw_headers,
rows=rows,
offset=offset,
class_name=class_name,
operation="import"
)
names = {n.strip().strip("*").lower() for n in raw_headers or []} or None
self.object_headers = get_object_column_definitions(
self.object_class,
names,
include_hidden=True,
)
self.check_for_duplicate_columns(raw_headers)
self.headers = self.clean_headers(raw_headers)
self.csv_lines = csv_lines
self.converter = converter
self.unique_values = self.get_unique_values_dict(self.object_class)
self.revision_ids = []
self._import_info = self._make_empty_info()
def test_program_definitions(self):
""" test default headers for Program """
names = {
"Title",
"Description",
"Notes",
"Manager",
"Reader",
"Editor",
"Program URL",
"Reference URL",
"Code",
"Effective Date",
"Stop Date",
"State",
"Review State",
"Delete",
}
expected_fields = {
"mandatory": {
"Code",
"Title",
"Manager",
},
"unique": {
"Code",
"Title",
},
}
self._test_single_object(models.Program, names, expected_fields)
definitions = get_object_column_definitions(models.Program)
vals = {val["display_name"]: val for val in definitions.itervalues()}
self.assertEqual(vals["Manager"]["type"], "user_role")
def test_workflow_definitions(self):
""" test default headers for Workflow """
definitions = get_object_column_definitions(wf_models.Workflow)
display_names = {val["display_name"] for val in definitions.itervalues()}
expected_names = {
"Title",
"Description",
"Custom email message",
"Manager",
"Member",
"Unit",
"Repeat Every",
"Force real-time email updates",
"Code",
"Delete",
"Need Verification",
'Created Date',
'Last Updated',
'Last Updated By',
}
self.assertEqual(expected_names, display_names)
vals = {val["display_name"]: val for val in definitions.itervalues()}
self.assertTrue(vals["Title"]["mandatory"])
self.assertTrue(vals["Manager"]["mandatory"])
self.assertIn("type", vals["Manager"])
self.assertIn("type", vals["Member"])
self.assertEqual(vals["Manager"]["type"], "user_role")
self.assertEqual(vals["Member"]["type"], "user_role")
def test_cycle_task_definitions(self):
""" test default headers for Cycle Task Group Object Task """
definitions = get_object_column_definitions(
wf_models.CycleTaskGroupObjectTask)
mapping_names = get_mapping_names(
wf_models.CycleTaskGroupObjectTask.__name__)
display_names = {val["display_name"] for val in definitions.itervalues()}
element_names = {
"Code",
"Cycle",
"Summary",
"Task Type",
"Assignee",
"Task Details",
"Start Date",
"End Date",
"Actual Verified Date",
"Actual Finish Date",
"Task Group",
"State",
"Delete",
}
expected_names = element_names.union(mapping_names)
self.assertEqual(expected_names, display_names)
vals = {val["display_name"]: val for val in definitions.itervalues()}
self.assertTrue(vals["Summary"]["mandatory"])
self.assertTrue(vals["Assignee"]["mandatory"])
def test_risk_assessemnt(self):
"""Test default headers for Risk Assessment."""
definitions = get_object_column_definitions(all_models.RiskAssessment)
display_names = {val["display_name"] for val in definitions.itervalues()}
expected_names = {
"Title",
"Description",
"Notes",
"State",
"Start Date",
"End Date",
"Risk Manager",
"Risk Counsel",
"Code",
"Program",
"Delete",
"Assessment Procedure",
"Created Date",
"Last Updated Date",
"Last Updated By",
}
self.assertEqual(expected_names, display_names)
vals = {val["display_name"]: val for val in definitions.itervalues()}
self.assertTrue(vals["Title"]["mandatory"])
self.assertTrue(vals["Start Date"]["mandatory"])
self.assertTrue(vals["End Date"]["mandatory"])
def test_program_definitions(self):
""" test custom attribute headers for Program."""
self.generator.generate_custom_attribute(
"program",
title="My Attribute")
self.generator.generate_custom_attribute(
"program",
title="Mandatory Attribute",
mandatory=True)
self.generator.generate_custom_attribute(
"program",
title="Choose",
mandatory=True,
attribute_type="Dropdown",
multi_choice="hello,world,what's,up"
)
definitions = get_object_column_definitions(all_models.Program)
mapping_names = get_mapping_names(all_models.Program.__name__)
display_names = {val["display_name"] for val in definitions.itervalues()}
element_names = {
"Title",
"Description",
"Notes",
"Reference URL",
"Code",
"Effective Date",
"Last Deprecated Date",
"State",
"My Attribute",
"Mandatory Attribute",
"Choose",
"Review State",
"Reviewers",
"Delete",
"Primary Contacts",
"Secondary Contacts",
"Program Managers",
"Program Editors",
"Program Readers",
"Created Date",
"Last Updated Date",
"Last Updated By",
"Folder",
"Send by default",
"Recipients",
"Comments",
}
expected_names = element_names.union(mapping_names)
self.assertEqual(expected_names, display_names)
vals = {val["display_name"]: val for val in definitions.itervalues()}
self.assertTrue(vals["Title"]["mandatory"])
self.assertTrue(vals["Title"]["unique"])
self.assertTrue(vals["Mandatory Attribute"]["mandatory"])
self.assertTrue(vals["Choose"]["mandatory"])
def get_csv_template(objects):
"""Make csv template"""
for object_data in objects:
class_name = object_data["object_name"]
object_class = EXPORTABLES_MAP[class_name]
ignore_fields = IGNORE_FIELD_IN_TEMPLATE.get(class_name, [])
filtered_fields = [field for field in
get_object_column_definitions(object_class)
if field not in ignore_fields]
object_data["fields"] = filtered_fields
return make_export(objects)
def __init__(self, converter, object_class, object_ids, fields, class_name):
# pylint: disable=too-many-arguments
super(ExportBlockConverter, self).__init__(
converter,
object_class=object_class,
object_ids=object_ids,
class_name=class_name,
operation="export"
)
self.object_headers = get_object_column_definitions(self.object_class)
raw_headers = [unicode(key) for key in self._get_header_names().keys()]
self.headers = self.clean_headers(raw_headers)
self.organize_fields(fields)
def test_acl_definitions(self, model):
"""Test ACL column definitions."""
factory = factories.AccessControlRoleFactory
factories.AccessControlRoleFactory(
object_type="Control",
read=True
)
role_names = {factory(object_type=model.__name__).name for _ in range(2)}
expected_names = set()
if issubclass(model, roleable.Roleable):
expected_names = role_names
definitions = get_object_column_definitions(model)
definition_names = {d["display_name"]: d for d in definitions.values()}
self.assertLessEqual(expected_names, set(definition_names.keys()))
def test_program_definitions(self):
""" test custom attribute headers for Program """
self.generator.generate_custom_attribute(
"program",
title="My Attribute")
self.generator.generate_custom_attribute(
"program",
title="Mandatory Attribute",
mandatory=True)
self.generator.generate_custom_attribute(
"program",
title="Choose",
mandatory=True,
attribute_type="Dropdown",
multi_choice="hello,world,what's,up"
)
definitions = get_object_column_definitions(models.Program)
mapping_names = get_mapping_names(models.Program.__name__)
unmapping_names = get_unmapping_names(models.Program.__name__)
display_names = {val["display_name"] for val in definitions.itervalues()}
element_names = {
"Title",
"Description",
"Notes",
"Manager",
"Reader",
"Editor",
"Program URL",
"Reference URL",
"Code",
"Effective Date",
"Stop Date",
"State",
"My Attribute",
"Mandatory Attribute",
"Choose",
"Review State",
"Delete",
}
expected_names = element_names.union(mapping_names).union(unmapping_names)
self.assertEqual(expected_names, display_names)
vals = {val["display_name"]: val for val in definitions.itervalues()}
self.assertTrue(vals["Title"]["mandatory"])
self.assertTrue(vals["Manager"]["mandatory"])
self.assertTrue(vals["Title"]["unique"])
self.assertTrue(vals["Mandatory Attribute"]["mandatory"])
self.assertTrue(vals["Choose"]["mandatory"])
def _test_definition_names(self, obj_class, names, has_mappings=True):
""" Test name definitions for one class
This function checks if names returned by get_object_column_definitions
match provided list of names with the appropriate mapping names fro that
class if has_mappings attribute is set.
"""
definitions = get_object_column_definitions(obj_class)
display_names = {val["display_name"] for val in definitions.itervalues()}
mapping_names = get_mapping_names(obj_class.__name__)
expected_names = names.union(mapping_names)
self.assertEqual(expected_names, display_names)
if has_mappings:
self.assertNotEqual(set(), mapping_names)
else:
self.assertEqual(set(), mapping_names)
def test_task_group_definitions(self):
""" test default headers for Task Group """
definitions = get_object_column_definitions(wf_models.TaskGroup)
display_names = {val["display_name"] for val in definitions.itervalues()}
expected_names = {
"Summary",
"Details",
"Assignee",
"Code",
"Workflow",
"Objects",
"Delete",
}
self.assertEqual(expected_names, display_names)
vals = {val["display_name"]: val for val in definitions.itervalues()}
self.assertTrue(vals["Summary"]["mandatory"])
self.assertTrue(vals["Assignee"]["mandatory"])
def __init__(self, converter, object_class, class_name,
operation, object_ids=None, raw_headers=None, offset=None,
rows=None):
# pylint: disable=too-many-instance-attributes,protected-access
# pylint: disable=too-many-arguments
# This class holds cache and object data for all rows and handlers below
# it, so it is expected to hold a lot of instance attributes.
# The protected access is a false warning for inflector access.
self._mapping_cache = None
self._ticket_tracker_cache = None
self._owners_cache = None
self._roles_cache = None
self._user_roles_cache = None
self._ca_definitions_cache = None
self.converter = converter
self.offset = offset
self.object_class = object_class
self.rows = rows
self.operation = operation
self.object_ids = object_ids if object_ids else []
self.block_errors = []
self.block_warnings = []
self.row_errors = []
self.row_warnings = []
self.row_converters = []
self.ignore = False
self._has_non_importable_columns = False
# For import contains model name from csv file.
# For export contains 'Model.__name__' value.
self.class_name = class_name
# TODO: remove 'if' statement. Init should initialize only.
if self.object_class:
names = {n.strip().strip("*").lower() for n in raw_headers or []} or None
self.object_headers = get_object_column_definitions(self.object_class,
names)
if not raw_headers:
all_header_names = [unicode(key)
for key in self._get_header_names().keys()]
raw_headers = all_header_names
self.check_for_duplicate_columns(raw_headers)
self.headers = self.clean_headers(raw_headers)
self.table_singular = self.object_class._inflector.table_singular
self.name = self.object_class._inflector.human_singular.title()
else:
self.name = ""
def _test_definition_fields(self, obj_class, field_name, expected):
""" Test expected fields in column definitions.
Check that the definitions contain correct values in the fields for all
names in the expected list.
Args:
obj_class (db.Model): class to check definitions.
field_name (str): Name of the field we want to check (ie. manatory).
expected (list of str): List of display names for all attributes that
should have the field field_name set to true.
"""
definitions = get_object_column_definitions(obj_class)
definition_fields = {
val["display_name"] for val in definitions.itervalues()
if val.get(field_name)
}
self.assertEqual(definition_fields, expected)
def test_task_group_task_definitions(self):
""" test default headers for Task Group Task """
definitions = get_object_column_definitions(wf_models.TaskGroupTask)
display_names = {val["display_name"] for val in definitions.itervalues()}
expected_names = {
"Summary",
"Task Type",
"Assignee",
"Task Description",
"Start",
"End",
"Task Group",
"Code",
"Delete",
}
self.assertEqual(expected_names, display_names)
vals = {val["display_name"]: val for val in definitions.itervalues()}
self.assertTrue(vals["Summary"]["mandatory"])
self.assertTrue(vals["Assignee"]["mandatory"])
def test_policy_definitions(self):
"""Test custom attribute definitions on Policy model."""
self.generator.generate_custom_attribute("policy", title="My Attribute")
self.generator.generate_custom_attribute(
"policy", title="Mandatory Attribute", mandatory=True)
definitions = get_object_column_definitions(all_models.Policy)
mapping_names = get_mapping_names(all_models.Policy.__name__)
display_names = {val["display_name"] for val in definitions.itervalues()}
element_names = {
"Code",
"Title",
"Description",
"Notes",
"Admin",
"Reference URL",
"Kind/Type",
"Effective Date",
"Last Deprecated Date",
"State",
"My Attribute",
"Mandatory Attribute",
"Review State",
"Reviewers",
"Delete",
"Primary Contacts",
"Secondary Contacts",
"Recipients",
"Send by default",
"Comments",
"Assessment Procedure",
"Created Date",
"Last Updated Date",
"Last Updated By",
"Folder",
}
expected_names = element_names.union(mapping_names)
self.assertEqual(expected_names, display_names)
vals = {val["display_name"]: val for val in definitions.itervalues()}
self.assertTrue(vals["Title"]["mandatory"])
self.assertTrue(vals["Admin"]["mandatory"])
self.assertTrue(vals["Title"]["unique"])
self.assertTrue(vals["Mandatory Attribute"]["mandatory"])
def test_cycle_task_definitions(self):
""" test default headers for Cycle Task Group Object Task """
definitions = get_object_column_definitions(
wf_models.CycleTaskGroupObjectTask)
mapping_names = get_mapping_names(
wf_models.CycleTaskGroupObjectTask.__name__)
unmapping_names = get_unmapping_names(
wf_models.CycleTaskGroupObjectTask.__name__)
display_names = {
val["display_name"]
for val in definitions.itervalues()
}
element_names = {
"Code",
"Cycle",
"Summary",
"Task Type",
"Task Assignees",
"Task Secondary Assignees",
"Task Details",
"Start Date",
"Due Date",
"Actual Verified Date",
"Actual Finish Date",
"Task Group",
"State",
"Delete",
"Created Date",
"Last Updated Date",
"Last Updated By",
"Last Deprecated Date",
"Send by default",
"Comments",
"Recipients",
}
expected_names = element_names.union(mapping_names).union(
unmapping_names)
self.assertEqual(expected_names, display_names)
vals = {val["display_name"]: val for val in definitions.itervalues()}
self.assertTrue(vals["Summary"]["mandatory"])
self.assertTrue(vals["Task Assignees"]["mandatory"])
def test_policy_definitions(self):
"""Test custom attribute definitions on Policy model."""
self.generator.generate_custom_attribute("policy", title="My Attribute")
self.generator.generate_custom_attribute(
"policy", title="Mandatory Attribute", mandatory=True)
definitions = get_object_column_definitions(models.Policy)
mapping_names = get_mapping_names(models.Policy.__name__)
display_names = {val["display_name"] for val in definitions.itervalues()}
element_names = {
"Code",
"Title",
"Description",
"Notes",
"Admin",
"Reference URL",
"Kind/Type",
"Effective Date",
"Last Deprecated Date",
"State",
"My Attribute",
"Mandatory Attribute",
"Review State",
"Delete",
"Primary Contacts",
"Secondary Contacts",
"Recipients",
"Send by default",
"Comments",
"Assessment Procedure",
"Created Date",
"Last Updated Date",
"Last Updated By",
"Folder",
}
expected_names = element_names.union(mapping_names)
self.assertEqual(expected_names, display_names)
vals = {val["display_name"]: val for val in definitions.itervalues()}
self.assertTrue(vals["Title"]["mandatory"])
self.assertTrue(vals["Admin"]["mandatory"])
self.assertTrue(vals["Title"]["unique"])
self.assertTrue(vals["Mandatory Attribute"]["mandatory"])
def __init__(self, converter, **options):
# pylint: disable=too-many-instance-attributes,protected-access
# This class holds cache and object data for all rows and handlers below
# it, so it is expected to hold a lot of instance attributes.
# The protected access is a false warning for inflector access.
self.revision_ids = []
self._mapping_cache = None
self._owners_cache = None
self._roles_cache = None
self._user_roles_cache = None
self._ca_definitions_cache = None
self.converter = converter
self.offset = options.get("offset", 0)
self.object_class = options.get("object_class")
self.rows = options.get("rows", [])
self.operation = 'import' if self.rows else 'export'
self.object_ids = options.get("object_ids", [])
self.block_errors = []
self.block_warnings = []
self.row_errors = []
self.row_warnings = []
self.row_converters = []
self.ignore = False
self._has_non_importable_columns = False
# For import contains model name from csv file.
# For export contains 'Model.__name__' value.
self.class_name = options.get("class_name", "")
# TODO: remove 'if' statement. Init should initialize only.
if self.object_class:
self.object_headers = get_object_column_definitions(self.object_class)
all_header_names = [unicode(key)
for key in self.get_header_names().keys()]
raw_headers = options.get("raw_headers", all_header_names)
self.check_for_duplicate_columns(raw_headers)
self.headers = self.clean_headers(raw_headers)
self.unique_counts = self.get_unique_counts_dict(self.object_class)
self.table_singular = self.object_class._inflector.table_singular
self.name = self.object_class._inflector.human_singular.title()
self.organize_fields(options.get("fields", []))
else:
self.name = ""
def __init__(self, converter, **options):
# pylint: disable=too-many-instance-attributes,protected-access
# This class holds cache and object data for all rows and handlers below
# it, so it is expected to hold a lot of instance attributes.
# The protected access is a false warning for inflector access.
self.revision_ids = []
self._mapping_cache = None
self._owners_cache = None
self._roles_cache = None
self._user_roles_cache = None
self._ca_definitions_cache = None
self.converter = converter
self.offset = options.get("offset", 0)
self.object_class = options.get("object_class")
self.rows = options.get("rows", [])
self.operation = 'import' if self.rows else 'export'
self.object_ids = options.get("object_ids", [])
self.block_errors = []
self.block_warnings = []
self.row_errors = []
self.row_warnings = []
self.row_converters = []
self.ignore = False
self._has_non_importable_columns = False
# For import contains model name from csv file.
# For export contains 'Model.__name__' value.
self.class_name = options.get("class_name", "")
# TODO: remove 'if' statement. Init should initialize only.
if self.object_class:
self.object_headers = get_object_column_definitions(self.object_class)
all_header_names = [unicode(key)
for key in self.get_header_names().keys()]
raw_headers = options.get("raw_headers", all_header_names)
self.check_for_duplicate_columns(raw_headers)
self.headers = self.clean_headers(raw_headers)
self.unique_counts = self.get_unique_counts_dict(self.object_class)
self.table_singular = self.object_class._inflector.table_singular
self.name = self.object_class._inflector.human_singular.title()
self.organize_fields(options.get("fields", []))
else:
self.name = ""
def test_risk_assessemnt_definitions(self):
""" test default headers for Workflow """
definitions = get_object_column_definitions(ra_models.RiskAssessment)
display_names = {val["display_name"] for val in definitions.itervalues()}
expected_names = {
"Title",
"Description",
"Notes",
"Start Date",
"End Date",
"Risk Manager",
"Risk Counsel",
"Code",
"Program",
"Delete",
}
self.assertEqual(expected_names, display_names)
vals = {val["display_name"]: val for val in definitions.itervalues()}
self.assertTrue(vals["Title"]["mandatory"])
self.assertTrue(vals["Start Date"]["mandatory"])
self.assertTrue(vals["End Date"]["mandatory"])
def test_policy_definitions(self):
self.generator.generate_custom_attribute("policy",
title="My Attribute")
self.generator.generate_custom_attribute("policy",
title="Mandatory Attribute",
mandatory=True)
definitions = get_object_column_definitions(models.Policy)
mapping_names = get_mapping_names(models.Policy.__name__)
unmapping_names = get_unmapping_names(models.Policy.__name__)
display_names = {
val["display_name"]
for val in definitions.itervalues()
}
element_names = {
"Code",
"Title",
"Description",
"Notes",
"Owner",
"Primary Contact",
"Secondary Contact",
"Policy URL",
"Reference URL",
"Kind/Type",
"Effective Date",
"Stop Date",
"State",
"My Attribute",
"Mandatory Attribute",
"Review State",
"Delete",
}
expected_names = element_names.union(mapping_names).union(
unmapping_names)
self.assertEqual(expected_names, display_names)
vals = {val["display_name"]: val for val in definitions.itervalues()}
self.assertTrue(vals["Title"]["mandatory"])
self.assertTrue(vals["Owner"]["mandatory"])
self.assertTrue(vals["Title"]["unique"])
self.assertTrue(vals["Mandatory Attribute"]["mandatory"])
def test_control_definitions(self):
""" test default headers for Control """
definitions = get_object_column_definitions(models.Control)
mapping_names = get_mapping_names(models.Control.__name__)
display_names = {
val["display_name"]
for val in definitions.itervalues()
}
element_names = {
"Title",
"Description",
"Test Plan",
"Notes",
"Owner",
"Primary Contact",
"Secondary Contact",
"Control URL",
"Reference URL",
"Code",
"Kind/Nature",
"Fraud Related",
"Significance",
"Type/Means",
"Effective Date",
"Stop Date",
"Frequency",
"Assertions",
"Categories",
"Principal Assessor",
"Secondary Assessor",
"State",
"Delete",
}
expected_names = element_names.union(mapping_names)
self.assertEqual(expected_names, display_names)
vals = {val["display_name"]: val for val in definitions.itervalues()}
self.assertTrue(vals["Title"]["mandatory"])
self.assertTrue(vals["Owner"]["mandatory"])
self.assertTrue(vals["Title"]["unique"])
def test_task_group_task_definitions(self):
""" test default headers for Task Group Task """
definitions = get_object_column_definitions(wf_models.TaskGroupTask)
display_names = {
val["display_name"]
for val in definitions.itervalues()
}
expected_names = {
"Summary",
"Task Type",
"Assignee",
"Task Description",
"Start",
"End",
"Task Group",
"Code",
"Delete",
}
self.assertEqual(expected_names, display_names)
vals = {val["display_name"]: val for val in definitions.itervalues()}
self.assertTrue(vals["Summary"]["mandatory"])
self.assertTrue(vals["Assignee"]["mandatory"])
def get_csv_template(objects):
"""Make csv template"""
ca_cache = {}
for object_data in objects:
class_name = object_data["object_name"]
template_ids = tuple(object_data.get("template_ids") or [])
object_class = EXPORTABLES_MAP[class_name]
ignore_fields = IGNORE_FIELD_IN_TEMPLATE.get(class_name, [])
class_name = utils.underscore_from_camelcase(class_name)
ca_cache[class_name] = (objects_cache.related_cads_for_object_type(
class_name, template_ids))
filtered_fields = [
field for field in import_helper.get_object_column_definitions(
object_class,
ca_cache=ca_cache,
) if field not in ignore_fields
]
object_data["fields"] = filtered_fields
return make_export(objects, ca_cache=ca_cache)
def test_program_definitions(self):
"""Test default headers for Program."""
names = {
"Title",
"Description",
"Notes",
"Manager",
"Reader",
"Editor",
"Reference URL",
"Code",
"Effective Date",
"Last Deprecated Date",
"State",
"Review State",
"Delete",
"Primary Contacts",
"Secondary Contacts",
'Created Date',
'Last Updated',
'Last Updated By',
'Folder',
}
expected_fields = {
"mandatory": {
"Code",
"Title",
"Manager",
},
"unique": {
"Code",
"Title",
},
}
self._test_single_object(models.Program, names, expected_fields)
definitions = get_object_column_definitions(models.Program)
vals = {val["display_name"]: val for val in definitions.itervalues()}
self.assertEqual(vals["Manager"]["type"], "user_role")
def _test_definition_names(self, obj_class, names, has_mappings=True):
"""Test name definitions for one class
This function checks if names returned by get_object_column_definitions
match provided list of names with the appropriate mapping names fro that
class if has_mappings attribute is set.
"""
definitions = get_object_column_definitions(obj_class)
display_names = {
val["display_name"]
for val in definitions.itervalues()
}
mapping_names = get_mapping_names(obj_class.__name__)
unmapping_names = get_unmapping_names(obj_class.__name__)
if has_mappings:
self.assertNotEqual(mapping_names, None)
self.assertNotEqual(unmapping_names, None)
expected_names = names.union(mapping_names).union(unmapping_names)
else:
self.assertEqual(mapping_names, None)
self.assertEqual(unmapping_names, None)
expected_names = names
self.assertEqual(display_names, expected_names)
def test_task_group_definitions(self):
""" test default headers for Task Group """
definitions = get_object_column_definitions(wf_models.TaskGroup)
display_names = {
val["display_name"]
for val in definitions.itervalues()
}
expected_names = {
"Summary",
"Details",
"Assignee",
"Code",
"Workflow",
"Objects",
"Delete",
'Created Date',
'Last Updated Date',
'Last Updated By',
}
self.assertEqual(expected_names, display_names)
vals = {val["display_name"]: val for val in definitions.itervalues()}
self.assertTrue(vals["Summary"]["mandatory"])
self.assertTrue(vals["Assignee"]["mandatory"])
def test_cycle_task_definitions(self):
""" test default headers for Cycle Task Group Object Task """
definitions = get_object_column_definitions(
wf_models.CycleTaskGroupObjectTask)
mapping_names = get_mapping_names(
wf_models.CycleTaskGroupObjectTask.__name__)
unmapping_names = get_unmapping_names(
wf_models.CycleTaskGroupObjectTask.__name__)
display_names = {val["display_name"] for val in definitions.itervalues()}
element_names = {
"Code",
"Cycle",
"Summary",
"Task Type",
"Task Assignees",
"Task Secondary Assignees",
"Task Description",
"Start Date",
"Due Date",
"Actual Verified Date",
"Actual Finish Date",
"Task Group",
"State",
"Delete",
"Created Date",
"Last Updated Date",
"Last Updated By",
"Last Deprecated Date",
"Send by default",
"Comments",
"Recipients",
}
expected_names = element_names.union(mapping_names).union(unmapping_names)
self.assertEqual(expected_names, display_names)
vals = {val["display_name"]: val for val in definitions.itervalues()}
self.assertTrue(vals["Summary"]["mandatory"])
self.assertTrue(vals["Task Assignees"]["mandatory"])
def test_single_object(obj):
"""Test colum handlers for a single object.
Args:
obj: sqlachemy model.
Raises:
AssertionError if object definition contains the wrong handler.
"""
handlers = column_handlers.COLUMN_HANDLERS
column_definitions = import_helper.get_object_column_definitions(obj)
for key, value in column_definitions.items():
if key in handlers:
handler_key = value.get("handler_key", key)
self.assertEqual(
value["handler"],
handlers[handler_key],
"Object '{}', column '{}': expected {}, found {}".format(
obj.__name__,
key,
handlers[key].__name__,
value["handler"].__name__,
)
)
def test_objective_definitions(self):
""" test default headers for Objective """
definitions = get_object_column_definitions(models.Objective)
mapping_names = get_mapping_names(models.Objective.__name__)
display_names = {val["display_name"] for val in definitions.itervalues()}
element_names = {
"Title",
"Description",
"Notes",
"Owner",
"Primary Contact",
"Secondary Contact",
"Objective URL",
"Reference URL",
"Code",
"State",
"Delete",
}
expected_names = element_names.union(mapping_names)
self.assertEqual(expected_names, display_names)
vals = {val["display_name"]: val for val in definitions.itervalues()}
self.assertTrue(vals["Title"]["mandatory"])
self.assertTrue(vals["Owner"]["mandatory"])
self.assertTrue(vals["Title"]["unique"])
def test_section_definitions(self):
""" test default headers for Section """
definitions = get_object_column_definitions(models.Section)
mapping_names = get_mapping_names(models.Section.__name__)
display_names = {val["display_name"] for val in definitions.itervalues()}
element_names = {
"Title",
"Text of Section",
"Notes",
"Policy / Regulation / Standard / Contract",
"Owner",
"Primary Contact",
"Secondary Contact",
"Section URL",
"Reference URL",
"Code",
"State",
"Delete",
}
expected_names = element_names.union(mapping_names)
self.assertEqual(expected_names, display_names)
vals = {val["display_name"]: val for val in definitions.itervalues()}
self.assertTrue(vals["Title"]["mandatory"])
self.assertTrue(vals["Owner"]["mandatory"])
def __init__(self, converter, object_class, rows, raw_headers, offset,
class_name, csv_lines):
# pylint: disable=too-many-arguments
super(ImportBlockConverter, self).__init__(converter,
object_class=object_class,
raw_headers=raw_headers,
rows=rows,
offset=offset,
class_name=class_name,
operation="import")
names = {n.strip().strip("*").lower()
for n in raw_headers or []} or None
self.object_headers = import_helper.get_object_column_definitions(
self.object_class,
fields=names,
include_hidden=True,
)
self.check_for_duplicate_columns(raw_headers)
self.headers = self.clean_headers(raw_headers)
self.csv_lines = csv_lines
self.converter = converter
self.unique_values = self.get_unique_values_dict(self.object_class)
self.revision_ids = []
self._import_info = self._make_empty_info()
def test_single_object(obj):
"""Test colum handlers for a single object.
Args:
obj: sqlachemy model.
Raises:
AssertionError if object definition contains the wrong handler.
"""
handlers = column_handlers.COLUMN_HANDLERS
column_definitions = import_helper.get_object_column_definitions(
obj)
for key, value in column_definitions.items():
if key in handlers:
handler_key = value.get("handler_key", key)
self.assertEqual(
value["handler"], handlers[handler_key],
"Object '{}', column '{}': expected {}, found {}".
format(
obj.__name__,
key,
handlers[key].__name__,
value["handler"].__name__,
))
def test_workflow_definitions(self):
""" test default headers for Workflow """
definitions = get_object_column_definitions(wf_models.Workflow)
display_names = {val["display_name"] for val in definitions.itervalues()}
expected_names = {
"Title",
"Description",
"Custom email message",
"Manager",
"Member",
"Frequency",
"Force real-time email updates",
"Code",
"Delete",
}
self.assertEqual(expected_names, display_names)
vals = {val["display_name"]: val for val in definitions.itervalues()}
self.assertTrue(vals["Title"]["mandatory"])
self.assertTrue(vals["Manager"]["mandatory"])
self.assertTrue(vals["Frequency"]["mandatory"])
self.assertIn("type", vals["Manager"])
self.assertIn("type", vals["Member"])
self.assertEqual(vals["Manager"]["type"], "user_role")
self.assertEqual(vals["Member"]["type"], "user_role")
def test_task_group_definitions(self):
""" test default headers for Task Group """
definitions = get_object_column_definitions(wf_models.TaskGroup)
display_names = {val["display_name"] for val in definitions.itervalues()}
expected_names = {
"Title",
"Details",
"Assignee",
"Code",
"Workflow",
"Delete",
'Created Date',
'Last Updated Date',
'Last Updated By',
'map:policy',
'unmap:regulation',
'unmap:technology environment',
'map:requirement',
'unmap:access group',
'unmap:threat',
'map:process',
'map:regulation',
'map:issue',
'unmap:project',
'map:control',
'map:data asset',
'unmap:org group',
'unmap:objective',
'map:access group',
'map:objective',
'map:risk',
'unmap:process',
'map:contract',
'map:standard',
'unmap:product group',
'unmap:policy',
'unmap:contract',
'map:project',
'unmap:requirement',
'map:metric',
'unmap:vendor',
'map:program',
'unmap:market',
'map:product group',
'unmap:system',
'map:technology environment',
'map:vendor',
'map:threat',
'unmap:standard',
'map:product',
'map:key report',
'unmap:control',
'unmap:issue',
'map:system',
'map:market',
'unmap:key report',
'unmap:product',
'unmap:data asset',
'unmap:metric',
'unmap:program',
'map:org group',
'map:facility',
'unmap:facility',
'unmap:risk',
'map:account balance',
'unmap:account balance',
}
self.assertEqual(expected_names, display_names)
vals = {val["display_name"]: val for val in definitions.itervalues()}
self.assertTrue(vals["Title"]["mandatory"])
self.assertTrue(vals["Assignee"]["mandatory"])
def _get_aliases(model): """Get aliases for provided model""" return [c for c in import_helper.get_object_column_definitions(model)]
def test_task_group_definitions(self):
""" test default headers for Task Group """
definitions = get_object_column_definitions(wf_models.TaskGroup)
display_names = {
val["display_name"]
for val in definitions.itervalues()
}
expected_names = {
"Title",
"Details",
"Assignee",
"Code",
"Workflow",
"Delete",
'Created Date',
'Last Updated Date',
'Last Updated By',
'map:policy',
'unmap:regulation',
'unmap:technology environment',
'map:requirement',
'unmap:access group',
'unmap:threat',
'map:process',
'map:regulation',
'map:issue',
'unmap:project',
'map:control',
'map:data asset',
'unmap:org group',
'unmap:objective',
'map:access group',
'map:objective',
'map:risk',
'unmap:process',
'map:contract',
'map:standard',
'unmap:product group',
'unmap:policy',
'unmap:contract',
'map:project',
'unmap:requirement',
'map:metric',
'unmap:vendor',
'map:program',
'unmap:market',
'map:product group',
'unmap:system',
'map:technology environment',
'map:vendor',
'map:threat',
'unmap:standard',
'map:product',
'map:key report',
'unmap:control',
'unmap:issue',
'map:system',
'map:market',
'unmap:key report',
'unmap:product',
'unmap:data asset',
'unmap:metric',
'unmap:program',
'map:org group',
'map:facility',
'unmap:facility',
'unmap:risk',
'map:account balance',
'unmap:account balance',
}
self.assertEqual(expected_names, display_names)
vals = {val["display_name"]: val for val in definitions.itervalues()}
self.assertTrue(vals["Title"]["mandatory"])
self.assertTrue(vals["Assignee"]["mandatory"])
