def test_not_including_empty_attribute(self) -> None: test_user = User(email='*****@*****.**', foo='bar') self.assertDictEqual( neo4_serializer.serialize_node(test_user.create_next_node()), { 'KEY': '*****@*****.**', 'LABEL': 'User', 'email': '*****@*****.**', 'is_active:UNQUOTED': True, 'profile_url': '', 'first_name': '', 'last_name': '', 'full_name': '', 'github_username': '', 'team_name': '', 'employee_type': '', 'slack_id': '', 'role_name': '', 'updated_at:UNQUOTED': 0, 'foo': 'bar' }) test_user2 = User(email='*****@*****.**', foo='bar', is_active=False, do_not_update_empty_attribute=True) self.assertDictEqual( neo4_serializer.serialize_node(test_user2.create_next_node()), { 'KEY': '*****@*****.**', 'LABEL': 'User', 'email': '*****@*****.**', 'foo': 'bar' })
def test_create_node_additional_attr(self) -> None: test_user = User(first_name='test_first', last_name='test_last', full_name='test_first test_last', email='*****@*****.**', github_username='******', team_name='test_team', employee_type='FTE', manager_email='*****@*****.**', slack_id='slack', is_active=True, updated_at=1, role_name='swe', enable_notify=True) node = test_user.create_next_node() serialized_node = neo4_serializer.serialize_node(node) self.assertEqual(serialized_node['email'], '*****@*****.**') self.assertEqual(serialized_node['role_name'], 'swe') self.assertTrue(serialized_node['enable_notify:UNQUOTED'])
def test_create_node_additional_attr_neptune(self) -> None: test_user = User(first_name='test_first', last_name='test_last', name='test_first test_last', email='*****@*****.**', github_username='******', team_name='test_team', employee_type='FTE', manager_email='*****@*****.**', slack_id='slack', is_active=True, updated_at=1, role_name='swe', enable_notify=True) node = test_user.create_next_node() serialized_node = neptune_serializer.convert_node(node) self.assertEqual(serialized_node['email:String(single)'], '*****@*****.**') self.assertEqual(serialized_node['role_name:String(single)'], 'swe') self.assertTrue(serialized_node['enable_notify:Bool(single)'])
class DashboardUsage(GraphSerializable, TableSerializable): """ A model that encapsulate Dashboard usage between Dashboard and User """ def __init__(self, dashboard_group_id: Optional[str], dashboard_id: Optional[str], email: str, view_count: int, should_create_user_node: Optional[bool] = False, product: Optional[str] = '', cluster: Optional[str] = 'gold', **kwargs: Any) -> None: """ :param dashboard_group_id: :param dashboard_id: :param email: :param view_count: :param should_create_user_node: Enable this if it is fine to create/update User node with only with email address. Please be advised that other fields will be emptied. Current use case is to create anonymous user. For example, Mode dashboard does not provide which user viewed the dashboard and anonymous user can be used to show the usage. :param product: :param cluster: :param kwargs: """ self._dashboard_group_id = dashboard_group_id self._dashboard_id = dashboard_id self._email = email self._view_count = int(view_count) self._product = product self._cluster = cluster self._user_model = User(email=email) self._should_create_user_node = bool(should_create_user_node) self._relation_iterator = self._create_relation_iterator() self._record_iterator = self._create_record_iterator() def create_next_node(self) -> Union[GraphNode, None]: if self._should_create_user_node: return self._user_model.create_next_node() return None def create_next_relation(self) -> Union[GraphRelationship, None]: try: return next(self._relation_iterator) except StopIteration: return None def _create_relation_iterator(self) -> Iterator[GraphRelationship]: relationship = GraphRelationship( start_label=DashboardMetadata.DASHBOARD_NODE_LABEL, end_label=User.USER_NODE_LABEL, start_key=DashboardMetadata.DASHBOARD_KEY_FORMAT.format( product=self._product, cluster=self._cluster, dashboard_group=self._dashboard_group_id, dashboard_name=self._dashboard_id), end_key=User.get_user_model_key(email=self._email), type=READ_REVERSE_RELATION_TYPE, reverse_type=READ_RELATION_TYPE, attributes={READ_RELATION_COUNT_PROPERTY: self._view_count}) yield relationship def create_next_record(self) -> Union[RDSModel, None]: try: return next(self._record_iterator) except StopIteration: return None def _create_record_iterator(self) -> Iterator[RDSModel]: if self._should_create_user_node: user_record = self._user_model.create_next_record() if user_record: yield user_record dashboard_usage_record = RDSDashboardUsage( user_rk=User.get_user_model_key(email=self._email), dashboard_rk=DashboardMetadata.DASHBOARD_KEY_FORMAT.format( product=self._product, cluster=self._cluster, dashboard_group=self._dashboard_group_id, dashboard_name=self._dashboard_id), read_count=self._view_count) yield dashboard_usage_record def __repr__(self) -> str: return f'DashboardUsage({self._dashboard_group_id!r}, {self._dashboard_id!r}, ' \ f'{self._email!r}, {self._view_count!r}, {self._should_create_user_node!r}, ' \ f'{self._product!r}, {self._cluster!r})'
class DashboardUsage(Neo4jCsvSerializable): """ A model that encapsulate Dashboard usage between Dashboard and User """ def __init__( self, dashboard_group_id, # type: Optional[str] dashboard_id, # type: Optional[str] email, # type: str view_count, # type: int should_create_user_node=False, # type: Optional[bool] product='', # type: Optional[str] cluster='gold', # type: Optional[str] **kwargs): # type: () -> None """ :param dashboard_group_id: :param dashboard_id: :param email: :param view_count: :param should_create_user_node: Enable this if it is fine to create/update User node with only with email address. Please be advised that other fields will be emptied. Current use case is to create anonymous user. For example, Mode dashboard does not provide which user viewed the dashboard and anonymous user can be used to show the usage. :param product: :param cluster: :param kwargs: """ self._dashboard_group_id = dashboard_group_id self._dashboard_id = dashboard_id self._email = email self._view_count = view_count self._product = product self._cluster = cluster self._user_model = User(email=email) self._should_create_user_node = bool(should_create_user_node) self._relation_iterator = self._create_relation_iterator() def create_next_node(self): # type: () -> Union[Dict[str, Any], None] if self._should_create_user_node: return self._user_model.create_next_node() def create_next_relation(self): # type: () -> Union[Dict[str, Any], None] try: return next(self._relation_iterator) except StopIteration: return None def _create_relation_iterator(self): # type: () -> Iterator[[Dict[str, Any]]] yield { RELATION_START_LABEL: DashboardMetadata.DASHBOARD_NODE_LABEL, RELATION_END_LABEL: User.USER_NODE_LABEL, RELATION_START_KEY: DashboardMetadata.DASHBOARD_KEY_FORMAT.format( product=self._product, cluster=self._cluster, dashboard_group=self._dashboard_group_id, dashboard_name=self._dashboard_id), RELATION_END_KEY: User.get_user_model_key(email=self._email), RELATION_TYPE: READ_REVERSE_RELATION_TYPE, RELATION_REVERSE_TYPE: READ_RELATION_TYPE, READ_RELATION_COUNT_PROPERTY: self._view_count } def __repr__(self): return 'DashboardUsage({!r}, {!r}, {!r}, {!r}, {!r}, {!r}, {!r})'.format( self._dashboard_group_id, self._dashboard_id, self._email, self._view_count, self._should_create_user_node, self._product, self._cluster)
class TestUser(unittest.TestCase): def setUp(self) -> None: super(TestUser, self).setUp() self.user = User(first_name='test_first', last_name='test_last', full_name='test_first test_last', email='*****@*****.**', github_username='******', team_name='test_team', employee_type='FTE', manager_email='*****@*****.**', slack_id='slack', is_active=True, profile_url='https://profile', updated_at=1, role_name='swe') def test_get_user_model_key(self) -> None: user_email = User.get_user_model_key(email=self.user.email) self.assertEqual(user_email, '*****@*****.**') def test_create_nodes(self) -> None: expected_nodes = [{ 'LABEL': 'User', 'KEY': '*****@*****.**', 'email': '*****@*****.**', 'is_active:UNQUOTED': True, 'profile_url': 'https://profile', 'first_name': 'test_first', 'last_name': 'test_last', 'full_name': 'test_first test_last', 'github_username': '******', 'team_name': 'test_team', 'employee_type': 'FTE', 'slack_id': 'slack', 'role_name': 'swe', 'updated_at:UNQUOTED': 1 }] actual = [] node = self.user.create_next_node() while node: serialized_node = neo4_serializer.serialize_node(node) actual.append(serialized_node) node = self.user.create_next_node() self.assertEqual(actual, expected_nodes) def test_create_node_additional_attr(self) -> None: test_user = User(first_name='test_first', last_name='test_last', full_name='test_first test_last', email='*****@*****.**', github_username='******', team_name='test_team', employee_type='FTE', manager_email='*****@*****.**', slack_id='slack', is_active=True, profile_url='https://profile', updated_at=1, role_name='swe', enable_notify=True) node = test_user.create_next_node() serialized_node = neo4_serializer.serialize_node(node) self.assertEqual(serialized_node['email'], '*****@*****.**') self.assertEqual(serialized_node['role_name'], 'swe') self.assertTrue(serialized_node['enable_notify:UNQUOTED']) def test_create_node_additional_attr_neptune(self) -> None: test_user = User(first_name='test_first', last_name='test_last', name='test_first test_last', email='*****@*****.**', github_username='******', team_name='test_team', employee_type='FTE', manager_email='*****@*****.**', slack_id='slack', is_active=True, profile_url='https://profile', updated_at=1, role_name='swe', enable_notify=True) node = test_user.create_next_node() serialized_node = neptune_serializer.convert_node(node) self.assertEqual(serialized_node['email:String(single)'], '*****@*****.**') self.assertEqual(serialized_node['role_name:String(single)'], 'swe') self.assertTrue(serialized_node['enable_notify:Bool(single)']) def test_create_record_additional_attr_mysql(self) -> None: test_user = User(first_name='test_first', last_name='test_last', name='test_first test_last', email='*****@*****.**', github_username='******', team_name='test_team', employee_type='FTE', manager_email='*****@*****.**', slack_id='slack', is_active=True, profile_url='https://profile', updated_at=1, role_name='swe', enable_notify=True) record = test_user.create_next_record() serialized_record = mysql_serializer.serialize_record(record) self.assertEqual(serialized_record['email'], '*****@*****.**') self.assertEqual(serialized_record['role_name'], 'swe') def test_create_relation(self) -> None: actual = [] relation = self.user.create_next_relation() while relation: serialized_relation = neo4_serializer.serialize_relationship( relation) actual.append(serialized_relation) relation = self.user.create_next_relation() start_key = '*****@*****.**' end_key = '*****@*****.**' expected_relations = [{ RELATION_START_KEY: start_key, RELATION_START_LABEL: User.USER_NODE_LABEL, RELATION_END_KEY: end_key, RELATION_END_LABEL: User.USER_NODE_LABEL, RELATION_TYPE: User.USER_MANAGER_RELATION_TYPE, RELATION_REVERSE_TYPE: User.MANAGER_USER_RELATION_TYPE }] self.assertTrue(expected_relations, actual) def test_create_relation_neptune(self) -> None: actual = [] relation = self.user.create_next_relation() while relation: serialized = neptune_serializer.convert_relationship(relation) actual.append(serialized) relation = self.user.create_next_relation() start_key = 'User:{email}'.format(email='*****@*****.**') end_key = 'User:{email}'.format(email='*****@*****.**') expected = [[{ NEPTUNE_HEADER_ID: "{label}:{from_vertex_id}_{to_vertex_id}".format( from_vertex_id=start_key, to_vertex_id=end_key, label=User.USER_MANAGER_RELATION_TYPE), METADATA_KEY_PROPERTY_NAME_BULK_LOADER_FORMAT: "{label}:{from_vertex_id}_{to_vertex_id}".format( from_vertex_id=start_key, to_vertex_id=end_key, label=User.USER_MANAGER_RELATION_TYPE), NEPTUNE_RELATIONSHIP_HEADER_FROM: start_key, NEPTUNE_RELATIONSHIP_HEADER_TO: end_key, NEPTUNE_HEADER_LABEL: User.USER_MANAGER_RELATION_TYPE, NEPTUNE_LAST_EXTRACTED_AT_RELATIONSHIP_PROPERTY_NAME_BULK_LOADER_FORMAT: ANY, NEPTUNE_CREATION_TYPE_RELATIONSHIP_PROPERTY_NAME_BULK_LOADER_FORMAT: NEPTUNE_CREATION_TYPE_JOB }, { NEPTUNE_HEADER_ID: "{label}:{from_vertex_id}_{to_vertex_id}".format( from_vertex_id=end_key, to_vertex_id=start_key, label=User.MANAGER_USER_RELATION_TYPE), METADATA_KEY_PROPERTY_NAME_BULK_LOADER_FORMAT: "{label}:{from_vertex_id}_{to_vertex_id}".format( from_vertex_id=end_key, to_vertex_id=start_key, label=User.MANAGER_USER_RELATION_TYPE), NEPTUNE_RELATIONSHIP_HEADER_FROM: end_key, NEPTUNE_RELATIONSHIP_HEADER_TO: start_key, NEPTUNE_HEADER_LABEL: User.MANAGER_USER_RELATION_TYPE, NEPTUNE_LAST_EXTRACTED_AT_RELATIONSHIP_PROPERTY_NAME_BULK_LOADER_FORMAT: ANY, NEPTUNE_CREATION_TYPE_RELATIONSHIP_PROPERTY_NAME_BULK_LOADER_FORMAT: NEPTUNE_CREATION_TYPE_JOB }]] self.assertListEqual(actual, expected) def test_not_including_empty_attribute(self) -> None: test_user = User(email='*****@*****.**', foo='bar') self.assertDictEqual( neo4_serializer.serialize_node(test_user.create_next_node()), { 'KEY': '*****@*****.**', 'LABEL': 'User', 'email': '*****@*****.**', 'is_active:UNQUOTED': True, 'profile_url': '', 'first_name': '', 'last_name': '', 'full_name': '', 'github_username': '', 'team_name': '', 'employee_type': '', 'slack_id': '', 'role_name': '', 'updated_at:UNQUOTED': 0, 'foo': 'bar' }) test_user2 = User(email='*****@*****.**', foo='bar', is_active=False, do_not_update_empty_attribute=True) self.assertDictEqual( neo4_serializer.serialize_node(test_user2.create_next_node()), { 'KEY': '*****@*****.**', 'LABEL': 'User', 'email': '*****@*****.**', 'foo': 'bar' })