def test_tag_for_table_zero_values_should_set_all_available_fields( # noqa:E501
self): # noqa:E125
metadata_def = utils.Utils.get_metadata_def_obj(self.__MODULE_PATH)
factory = datacatalog_tag_factory.DataCatalogTagFactory(metadata_def)
tag_template = datacatalog.TagTemplate()
tag_template.name = 'template_name'
tables_dict = {
'creator': 'creator_test',
'owner': 'owner_test',
'update_user': '******',
'num_rows': 0,
'table_size_MB': 0
}
tag = factory. \
make_tag_for_table_metadata(tag_template, tables_dict, 'schema')
self.assertEqual('schema', tag.fields['schema_name'].string_value)
self.assertEqual('creator_test',
tag.fields['table_creator'].string_value)
self.assertEqual('owner_test', tag.fields['table_owner'].string_value)
self.assertEqual('update_user_test',
tag.fields['table_update_user'].string_value)
self.assertEqual(0, tag.fields['num_rows'].double_value)
self.assertEqual(0, tag.fields['table_size_MB'].double_value)
def __create_tag_template(cls):
template = datacatalog.TagTemplate()
tag_template_id = 'template'
template.name = 'template name'
template.display_name = 'template display name'
bool_field = datacatalog.TagTemplateField()
bool_field.type.primitive_type = cls.__BOOL_TYPE
template.fields['bool-field'] = bool_field
double_field = datacatalog.TagTemplateField()
double_field.type.primitive_type = cls.__DOUBLE_TYPE
template.fields['double-field'] = double_field
string_field = datacatalog.TagTemplateField()
string_field.type.primitive_type = cls.__STRING_TYPE
template.fields['string-field'] = string_field
timestamp_field = datacatalog.TagTemplateField()
timestamp_field.type.primitive_type = cls.__TIMESTAMP_TYPE
template.fields['timestamp-field'] = timestamp_field
enum_value = datacatalog.FieldType.EnumType.EnumValue()
enum_value.display_name = 'Test ENUM Value'
enum_field = datacatalog.TagTemplateField()
enum_field.type.enum_type.allowed_values.append(enum_value)
template.fields['enum-field'] = enum_field
return tag_template_id, template
def create_fake_tag_template(cls):
tag_template = datacatalog.TagTemplate()
tag_template_id = 'template'
tag_template.name = 'template name'
tag_template.display_name = 'template display name'
tag_template.fields['test-bool-field']. \
type.primitive_type = Utils.__BOOL_TYPE
tag_template.fields['test-bool-field']. \
display_name = 'Bool Field'
tag_template.fields['test-double-field']. \
type.primitive_type = Utils.__DOUBLE_TYPE
tag_template.fields['test-double-field']. \
display_name = 'Double Field'
tag_template.fields['test-string-field']. \
type.primitive_type = Utils.__STRING_TYPE
tag_template.fields['test-string-field']. \
display_name = 'String Field'
tag_template.fields['test-timestamp-field']. \
type.primitive_type = Utils.__TIMESTAMP_TYPE
tag_template.fields['test-timestamp-field']. \
display_name = 'Timestamp Field'
tag_template.fields[
'test-enum-field']. \
type.enum_type.allowed_values.add(). \
display_name = 'Test ENUM Value'
return tag_template_id, tag_template
def test_make_assembled_entry_for_dashboard_should_make_entry_and_tags(
self):
dashboard = self.__make_fake_dashboard()
dashboard_tag_template = datacatalog.TagTemplate()
dashboard_tag_template.name = 'tagTemplates/sisense_dashboard_metadata'
jaql_tag_template = datacatalog.TagTemplate()
jaql_tag_template.name = 'tagTemplates/sisense_jaql_metadata'
tag_templates_dict = {
'sisense_dashboard_metadata': dashboard_tag_template,
'sisense_jaql_metadata': jaql_tag_template
}
fake_entry = ('test-dashboard', {})
entry_factory = self.__mock_entry_factory
entry_factory.make_entry_for_dashboard.return_value = fake_entry
tag_factory = self.__mock_tag_factory
fake_dashboard_tag = datacatalog.Tag()
fake_dashboard_tag.template = 'tagTemplates/sisense_dashboard_metadata'
tag_factory.make_tag_for_dashboard.return_value = fake_dashboard_tag
fake_filter_tag = datacatalog.Tag()
fake_filter_tag.template = 'tagTemplates/sisense_jaql_metadata'
tag_factory.make_tags_for_dashboard_filters.return_value = [
fake_filter_tag
]
assembled_entry = self.__factory\
._AssembledEntryFactory__make_assembled_entry_for_dashboard(
dashboard, tag_templates_dict)
self.assertEqual('test-dashboard', assembled_entry.entry_id)
self.assertEqual({}, assembled_entry.entry)
entry_factory.make_entry_for_dashboard.assert_called_once_with(
dashboard)
tags = assembled_entry.tags
self.assertEqual(2, len(tags))
self.assertEqual('tagTemplates/sisense_dashboard_metadata',
tags[0].template)
self.assertEqual('tagTemplates/sisense_jaql_metadata',
tags[1].template)
tag_factory.make_tag_for_dashboard.assert_called_once_with(
dashboard_tag_template, dashboard)
tag_factory.make_tags_for_dashboard_filters.assert_called_once_with(
jaql_tag_template, dashboard)
def test_make_tags_for_jaql_should_return_empty_list_if_no_metadata(self):
tag_template = datacatalog.TagTemplate()
tag_template.name = 'tagTemplates/sisense_jaql_metadata'
tags = self.__factory._DataCatalogTagFactory__make_tags_for_jaql(
tag_template, {}, 'test')
self.assertEqual(0, len(tags))
def make_fake_tag_template():
tag_template = datacatalog.TagTemplate()
tag_template.name = 'test_template'
tag_template.fields['bool_field'] = \
make_primitive_type_template_field(datacatalog.FieldType.PrimitiveType.BOOL)
tag_template.fields['string_field'] = \
make_primitive_type_template_field(datacatalog.FieldType.PrimitiveType.STRING)
return tag_template
def make_tag_template_for_custom_property_value(self, definition_metadata,
value):
tag_template = datacatalog.TagTemplate()
template_id = dph.DynamicPropertiesHelper\
.make_id_for_custom_property_value_tag_template(
definition_metadata, value)
tag_template.name = datacatalog.DataCatalogClient.tag_template_path(
project=self.__project_id,
location=self.__location_id,
tag_template=template_id)
tag_template.display_name = dph.DynamicPropertiesHelper\
.make_display_name_for_custom_property_value_tag_template(
definition_metadata, value)
self._add_primitive_type_field(tag_template, 'id', self.__STRING_TYPE,
'Unique Id')
self._add_primitive_type_field(tag_template, 'created_date',
self.__TIMESTAMP_TYPE, 'Created date')
self._add_primitive_type_field(tag_template, 'modified_date',
self.__TIMESTAMP_TYPE, 'Modified date')
self._add_primitive_type_field(tag_template, 'modified_by_username',
self.__STRING_TYPE,
'Username who modified it')
self._add_primitive_type_field(tag_template, 'value',
self.__STRING_TYPE, 'Value')
self._add_primitive_type_field(tag_template, 'property_definition_id',
self.__STRING_TYPE,
'Property Definition Id')
# According to the Qlik Analytics Platform Architecture Team, there was
# no way of searching assets by the Custom Property values using Qlik
# when this feature was implemented (Dec, 2020), which means the
# catalog search might be helpful to address such a use case. Hence the
# 'definition_' part was supressed from this Tag Field Id to turn seach
# queries more intuitive, e.g. tag:property_name:<PROPERTY-NAME>.
self._add_primitive_type_field(tag_template, 'property_name',
self.__STRING_TYPE,
'Property Definition name')
self._add_primitive_type_field(
tag_template, 'property_definition_entry', self.__STRING_TYPE,
'Data Catalog Entry for the Property Definition')
self._add_primitive_type_field(tag_template, 'site_url',
self.__STRING_TYPE,
'Qlik Sense site url')
return tag_template
def test_add_enum_type_field_should_optionally_set_order(self):
tag_template = datacatalog.TagTemplate()
prepare.BaseTagTemplateFactory._add_enum_type_field(tag_template,
'enum-field',
['VALUE_1'],
'Enum field',
order=10)
field = tag_template.fields['enum-field']
self.assertEqual(10, field.order)
def test_add_enum_type_field_should_optionally_set_is_required(self):
tag_template = datacatalog.TagTemplate()
prepare.BaseTagTemplateFactory._add_enum_type_field(tag_template,
'enum-field',
['VALUE_1'],
'Enum field',
is_required=True)
field = tag_template.fields['enum-field']
self.assertEqual(True, field.is_required)
def test_add_enum_type_field_should_set_elementary_properties(self):
tag_template = datacatalog.TagTemplate()
prepare.BaseTagTemplateFactory._add_enum_type_field(
tag_template, 'enum-field', ['VALUE_1', 'VALUE_2'], 'Enum field')
self.assertIn('enum-field', tag_template.fields)
field = tag_template.fields['enum-field']
self.assertEqual(2, len(field.type.enum_type.allowed_values))
self.assertEqual('Enum field', field.display_name)
def test_add_primitive_type_field_should_optionally_set_is_required(self):
tag_template = datacatalog.TagTemplate()
prepare.BaseTagTemplateFactory._add_primitive_type_field(
tag_template,
'string-field',
datacatalog.FieldType.PrimitiveType.STRING,
'String field',
is_required=True)
field = tag_template.fields['string-field']
self.assertEqual(True, field.is_required)
def test_add_primitive_type_field_should_optionally_set_order(self):
tag_template = datacatalog.TagTemplate()
prepare.BaseTagTemplateFactory._add_primitive_type_field(
tag_template,
'string-field',
datacatalog.FieldType.PrimitiveType.STRING,
'String field',
order=10)
field = tag_template.fields['string-field']
self.assertEqual(10, field.order)
def test_add_primitive_type_field_should_set_elementary_properties(self):
tag_template = datacatalog.TagTemplate()
prepare.BaseTagTemplateFactory._add_primitive_type_field(
tag_template, 'string-field',
datacatalog.FieldType.PrimitiveType.STRING, 'String field')
self.assertIn('string-field', tag_template.fields)
field = tag_template.fields['string-field']
self.assertEqual(datacatalog.FieldType.PrimitiveType.STRING,
field.type.primitive_type)
self.assertEqual('String field', field.display_name)
def test_make_tag_for_jaql_filter_by_should_return_none_if_no_filter(self):
tag_template = datacatalog.TagTemplate()
tag_template.name = 'tagTemplates/sisense_jaql_metadata'
metadata = {
'title': 'TEST',
}
tag = self.__factory \
._DataCatalogTagFactory__make_tag_for_jaql_filter_by(
tag_template, metadata, 'JAQL Filter By test')
self.assertIsNone(tag)
def test_make_tag_for_widget_should_set_datasource_from_string(self):
tag_template = datacatalog.TagTemplate()
tag_template.name = 'tagTemplates/sisense_widget_metadata'
metadata = {
'dashboardData': {},
'datasource': 'Test Data Source',
}
tag = self.__factory.make_tag_for_widget(tag_template, metadata)
self.assertEqual('Test Data Source',
tag.fields['datasource'].string_value)
def test_make_tag_for_dashboard_should_set_all_available_fields(self):
tag_template = datacatalog.TagTemplate()
tag_template.name = 'tagTemplates/sisense_dashboard_metadata'
metadata = {
'oid': 'test-dashboard',
'folderData': {
'oid': 'parent-folder',
'name': 'Parent Folder',
},
'ownerData': {
'userName': '******',
'firstName': 'John',
'lastName': 'Doe',
},
'datasource': {
'title': 'Test Data Source',
},
'lastPublish': '2021-05-01T13:00:15.400Z',
'lastOpened': '2021-05-02T23:00:22.939Z',
}
tag = self.__factory.make_tag_for_dashboard(tag_template, metadata)
self.assertEqual('tagTemplates/sisense_dashboard_metadata',
tag.template)
self.assertEqual('test-dashboard', tag.fields['id'].string_value)
self.assertEqual('parent-folder', tag.fields['folder_id'].string_value)
self.assertEqual('Parent Folder',
tag.fields['folder_name'].string_value)
self.assertEqual('*****@*****.**',
tag.fields['owner_username'].string_value)
self.assertEqual('John Doe', tag.fields['owner_name'].string_value)
self.assertEqual('Test Data Source',
tag.fields['datasource'].string_value)
publish_datetime = datetime.strptime('2021-05-01T13:00:15.400+0000',
self.__DATETIME_FORMAT)
self.assertEqual(
publish_datetime.timestamp(),
tag.fields['last_publish'].timestamp_value.timestamp())
opened_datetime = datetime.strptime('2021-05-02T23:00:22.939+0000',
self.__DATETIME_FORMAT)
self.assertEqual(opened_datetime.timestamp(),
tag.fields['last_opened'].timestamp_value.timestamp())
self.assertEqual('https://test.com',
tag.fields['server_url'].string_value)
def test_tag_for_table_container_missing_fields_should_succeed( # noqa:E501
self): # noqa:E125
metadata_def = utils.Utils.get_metadata_def_obj(self.__MODULE_PATH)
factory = datacatalog_tag_factory.DataCatalogTagFactory(metadata_def)
tag_template = datacatalog.TagTemplate()
tag_template.name = 'template_name'
schema_dict = {'tables': [{}, {}]}
tag = factory. \
make_tag_for_table_container_metadata(tag_template, schema_dict)
self.assertEqual(2, tag.fields['num_tables'].double_value)
def test_make_tags_for_jaql_should_set_all_available_fields(
self, mock_make_tags_for_jaql_formula,
mock_make_tag_for_jaql_filter_by):
tag_template = datacatalog.TagTemplate()
tag_template.name = 'tagTemplates/sisense_jaql_metadata'
metadata = {
'dim': '[table_a.column_a]',
'formula': 'AVG([ODY], [COID])',
'context': {
'[ODY]': {
'dim': '[Orders.OrderDate (Calendar)]',
'title': 'OrderDateYears',
},
'[COID]': {
'dim': '[Orders.OrderID]',
'title': 'CountOrderID',
},
},
'agg': 'avg',
'title': 'TEST',
}
mock_make_tags_for_jaql_formula.return_value = []
mock_make_tag_for_jaql_filter_by.return_value = None
tags = self.__factory._DataCatalogTagFactory__make_tags_for_jaql(
tag_template, metadata, 'test')
self.assertEqual(1, len(tags))
tag = tags[0]
self.assertEqual('tagTemplates/sisense_jaql_metadata', tag.template)
self.assertEqual('table_a', tag.fields['table'].string_value)
self.assertEqual('column_a', tag.fields['column'].string_value)
self.assertEqual('[table_a.column_a]',
tag.fields['dimension'].string_value)
self.assertEqual('AVG([OrderDateYears], [CountOrderID])',
tag.fields['formula'].string_value)
self.assertEqual('avg', tag.fields['aggregation'].string_value)
self.assertEqual('https://test.com',
tag.fields['server_url'].string_value)
mock_make_tags_for_jaql_formula.assert_called_once_with(
tag_template, metadata, 'test.TEST')
mock_make_tag_for_jaql_filter_by.assert_called_once_with(
tag_template, metadata, 'test.TEST')
def make_tag_template_for_custom_property_definition(self):
tag_template = datacatalog.TagTemplate()
tag_template.name = datacatalog.DataCatalogClient.tag_template_path(
project=self.__project_id,
location=self.__location_id,
tag_template=constants.TAG_TEMPLATE_ID_CUSTOM_PROPERTY_DEFINITION)
tag_template.display_name = 'Qlik Custom Property Definition Metadata'
self._add_primitive_type_field(tag_template=tag_template,
field_id='id',
field_type=self.__STRING_TYPE,
display_name='Unique Id',
is_required=True,
order=6)
self._add_primitive_type_field(tag_template=tag_template,
field_id='modified_by_username',
field_type=self.__STRING_TYPE,
display_name='Username who modified it',
order=5)
self._add_primitive_type_field(tag_template=tag_template,
field_id='value_type',
field_type=self.__STRING_TYPE,
display_name='Value type',
order=4)
self._add_primitive_type_field(tag_template=tag_template,
field_id='choice_values',
field_type=self.__STRING_TYPE,
display_name='Choice values',
order=3)
self._add_primitive_type_field(tag_template=tag_template,
field_id='object_types',
field_type=self.__STRING_TYPE,
display_name='Object types',
order=2)
self._add_primitive_type_field(tag_template=tag_template,
field_id='site_url',
field_type=self.__STRING_TYPE,
display_name='Qlik Sense site url',
is_required=True,
order=1)
return tag_template
def make_tag_template_for_sheet(self):
tag_template = datacatalog.TagTemplate()
tag_template.name = datacatalog.DataCatalogClient.tag_template_path(
project=self.__project_id,
location=self.__location_id,
tag_template=constants.TAG_TEMPLATE_ID_SHEET)
tag_template.display_name = 'Qlik Sheet Metadata'
self._add_primitive_type_field(tag_template, 'id', self.__STRING_TYPE,
'Unique Id')
self._add_primitive_type_field(tag_template, 'owner_username',
self.__STRING_TYPE, 'Owner username')
self._add_primitive_type_field(tag_template, 'owner_name',
self.__STRING_TYPE, 'Owner name')
self._add_primitive_type_field(tag_template, 'published',
self.__BOOL_TYPE, 'Published')
self._add_primitive_type_field(tag_template, 'publish_time',
self.__TIMESTAMP_TYPE, 'Publish time')
self._add_primitive_type_field(tag_template, 'approved',
self.__BOOL_TYPE, 'Approved')
self._add_primitive_type_field(tag_template, 'app_id',
self.__STRING_TYPE, 'App Id')
self._add_primitive_type_field(tag_template, 'app_name',
self.__STRING_TYPE, 'App name')
self._add_primitive_type_field(tag_template, 'app_entry',
self.__STRING_TYPE,
'Data Catalog Entry for the App')
self._add_primitive_type_field(tag_template, 'source_object',
self.__STRING_TYPE, 'Source object')
self._add_primitive_type_field(tag_template, 'draft_object',
self.__STRING_TYPE, 'Draft object')
self._add_primitive_type_field(tag_template, 'site_url',
self.__STRING_TYPE,
'Qlik Sense site url')
return tag_template
def make_tag_template_for_table_metadata(self):
"""Create a Tag Template with technical fields for Table metadata.
:return: tag_template_id, tag_template
"""
tag_template = datacatalog.TagTemplate()
table_type = self.__metadata_definition['table_def']['type']
tag_template_id = '{}_{}_metadata'.format(self.__entry_group_id,
table_type)
tag_template.name = \
datacatalog.DataCatalogClient.tag_template_path(
project=self.__project_id,
location=self.__location_id,
tag_template=tag_template_id)
tag_template.display_name = '{} {} - Metadata'.format(
self.__entry_group_id.capitalize(), table_type.capitalize())
self.__add_creator_field_to_template(table_type, tag_template)
self.__add_owner_field_to_template(table_type, tag_template)
self.__add_update_user_field_to_template(table_type, tag_template)
table_container_name = self.__metadata_definition[
'table_container_def']['name']
table_container_type = self.__metadata_definition[
'table_container_def']['type']
self._add_primitive_type_field(
tag_template, table_container_name, self.__STRING_TYPE,
'{} Name'.format(table_container_type.capitalize()))
self.__add_database_name_to_tag_template(tag_template)
self._add_primitive_type_field(tag_template, 'num_rows',
self.__DOUBLE_TYPE, 'Number of rows')
self._add_primitive_type_field(tag_template, 'table_size_MB',
self.__DOUBLE_TYPE, 'Table Size in MB')
self._add_primitive_type_field(tag_template, 'table_type',
self.__STRING_TYPE, 'Table Type')
self._add_primitive_type_field(tag_template, 'has_primary_key',
self.__BOOL_TYPE, 'Has Primary Key')
return tag_template_id, tag_template
def test_make_tag_for_table_metadata_missing_fields_should_succeed(
self): # noqa:E125
metadata_def = utils.Utils.get_metadata_def_obj(self.__MODULE_PATH)
factory = datacatalog_tag_factory.DataCatalogTagFactory(metadata_def)
tag_template = datacatalog.TagTemplate()
tag_template.name = 'template_name'
tables_dict = {'num_rows': 5}
tag = factory. \
make_tag_for_table_metadata(tag_template, tables_dict, 'schema')
self.assertEqual('schema', tag.fields['schema_name'].string_value)
self.assertEqual(5, tag.fields['num_rows'].double_value)
def test_make_tags_for_jaql_formula_should_return_empty_list_if_no_context(
self):
tag_template = datacatalog.TagTemplate()
tag_template.name = 'tagTemplates/sisense_jaql_metadata'
metadata = {
'formula': 'AVG([ODY], [COID])',
}
tags = self.__factory \
._DataCatalogTagFactory__make_tags_for_jaql_formula(
tag_template, metadata, 'JAQL Formula test')
self.assertEqual(0, len(tags))
def test_make_tags_for_jaql_should_set_formula_as_is_if_no_context(self):
tag_template = datacatalog.TagTemplate()
tag_template.name = 'tagTemplates/sisense_jaql_metadata'
metadata = {
'formula': 'AVG([ODY], [COID])',
'title': 'TEST',
}
tags = self.__factory._DataCatalogTagFactory__make_tags_for_jaql(
tag_template, metadata, 'test')
tag = tags[0]
self.assertEqual('AVG([ODY], [COID])',
tag.fields['formula'].string_value)
def make_tag_template_for_jaql(self) -> TagTemplate:
tag_template = datacatalog.TagTemplate()
tag_template.name = datacatalog.DataCatalogClient.tag_template_path(
project=self.__project_id,
location=self.__location_id,
tag_template=constants.TAG_TEMPLATE_ID_JAQL)
tag_template.display_name = 'Sisense JAQL Metadata'
self._add_primitive_type_field(tag_template=tag_template,
field_id='table',
field_type=self.__STRING_TYPE,
display_name='Table',
order=6)
self._add_primitive_type_field(tag_template=tag_template,
field_id='column',
field_type=self.__STRING_TYPE,
display_name='Column',
order=5)
self._add_primitive_type_field(tag_template=tag_template,
field_id='dimension',
field_type=self.__STRING_TYPE,
display_name='Dimension',
order=4)
self._add_primitive_type_field(tag_template=tag_template,
field_id='formula',
field_type=self.__STRING_TYPE,
display_name='Formula',
order=3)
self._add_primitive_type_field(tag_template=tag_template,
field_id='aggregation',
field_type=self.__STRING_TYPE,
display_name='Aggregation',
order=2)
self._add_primitive_type_field(tag_template=tag_template,
field_id='server_url',
field_type=self.__STRING_TYPE,
display_name='Sisense Server Url',
is_required=True,
order=1)
return tag_template
def test_make_tags_for_widget_filters_should_skip_if_no_filters(self):
tag_template = datacatalog.TagTemplate()
tag_template.name = 'tagTemplates/sisense_jaql_metadata'
metadata = {
'metadata': {
'panels': [{
'name': 'testField',
}],
},
}
tags = self.__factory.make_tags_for_widget_filters(
tag_template, metadata)
self.assertEqual(0, len(tags))
def __create_entity_type_tag_template(self, entity_type_dict,
entity_types_dict, enum_types_dict):
tag_template = datacatalog.TagTemplate()
entity_type_data = entity_type_dict['data']
name = entity_type_data['name']
formatted_name = attr_normalizer.DataCatalogAttributeNormalizer.\
format_name(name)
version = entity_type_data.get('version')
tag_template_id = attr_normalizer.DataCatalogAttributeNormalizer.\
create_tag_template_id(formatted_name,
constant.ENTITY_TYPE_PREFIX,
version)
tag_template.name = self.get_tag_template_path(tag_template_id)
tag_template.display_name = 'Type - {}'.format(name)
entity_super_types = entity_type_dict.get('superTypes')
attribute_defs = entity_type_data['attributeDefs']
if entity_super_types:
self.__add_fields_from_super_types(tag_template,
entity_super_types,
entity_types_dict,
enum_types_dict)
self.__add_fields_from_attribute_defs(tag_template, attribute_defs,
enum_types_dict)
self._add_primitive_type_field(tag_template, formatted_name,
self.__BOOL_TYPE, formatted_name)
self._add_primitive_type_field(tag_template, constant.ENTITY_GUID,
self.__STRING_TYPE, 'entity guid')
self._add_primitive_type_field(tag_template,
constant.INSTANCE_URL_FIELD,
self.__STRING_TYPE, 'instance url')
self.__create_custom_fields_for_entity_type(tag_template,
entity_type_data)
return {tag_template_id: tag_template}
def make_column_tag_template(self):
tag_template = datacatalog.TagTemplate()
tag_template_id = attr_normalizer.DataCatalogAttributeNormalizer.\
create_tag_template_id(
'ref', constant.COLUMN_PREFIX)
tag_template.name = self.get_tag_template_path(tag_template_id)
tag_template.display_name = 'Column'
self._add_primitive_type_field(tag_template, 'column_guid',
self.__STRING_TYPE, 'column guid')
self._add_primitive_type_field(tag_template, 'column_entry',
self.__STRING_TYPE,
'column data catalog entry')
return {tag_template_id: tag_template}
def test_make_tags_for_widget_filters_should_process_all_filters(
self, mock_make_tags_for_jaql):
tag_template = datacatalog.TagTemplate()
tag_template.name = 'tagTemplates/sisense_jaql_metadata'
metadata = {
'metadata': {
'panels': [{
'name':
'filters',
'items': [
{
'jaql': {
'datatype': 'text',
},
},
{
'jaql': {
'datatype': 'datetime',
},
},
],
}],
},
}
mock_make_tags_for_jaql.return_value = [datacatalog.Tag()]
tags = self.__factory.make_tags_for_widget_filters(
tag_template, metadata)
self.assertEqual(2, len(tags))
self.assertEqual(2, mock_make_tags_for_jaql.call_count)
calls = [
mock.call(tag_template, {
'datatype': 'text',
}, 'filters'),
mock.call(tag_template, {
'datatype': 'datetime',
}, 'filters')
]
mock_make_tags_for_jaql.assert_has_calls(calls)
def make_tag_template_for_visualization(self):
tag_template = datacatalog.TagTemplate()
tag_template.name = datacatalog.DataCatalogClient.tag_template_path(
project=self.__project_id,
location=self.__location_id,
tag_template=constants.TAG_TEMPLATE_ID_VISUALIZATION)
tag_template.display_name = 'Qlik Visualization Metadata'
self._add_primitive_type_field(tag_template, 'id', self.__STRING_TYPE,
'Unique Id')
self._add_primitive_type_field(tag_template, 'title',
self.__STRING_TYPE, 'Title')
self._add_primitive_type_field(tag_template, 'subtitle',
self.__STRING_TYPE, 'Subtitle')
self._add_primitive_type_field(tag_template, 'footnote',
self.__STRING_TYPE, 'Footnote')
self._add_primitive_type_field(tag_template, 'type',
self.__STRING_TYPE, 'Type')
self._add_primitive_type_field(tag_template, 'tags',
self.__STRING_TYPE, 'Qlik tags')
self._add_primitive_type_field(tag_template, 'app_id',
self.__STRING_TYPE, 'App Id')
self._add_primitive_type_field(tag_template, 'app_name',
self.__STRING_TYPE, 'App name')
self._add_primitive_type_field(tag_template, 'app_entry',
self.__STRING_TYPE,
'Data Catalog Entry for the App')
self._add_primitive_type_field(tag_template, 'site_url',
self.__STRING_TYPE,
'Qlik Sense site url')
return tag_template
