def test_get_resources_by_user_relation(self) -> None: with patch.object(GraphDatabase, 'driver'), \ patch.object(Neo4jProxy, '_execute_cypher_query') as mock_execute, \ patch.object(Neo4jProxy, '_exec_col_query') as mock_col_query: mock_execute.return_value.single.return_value = { 'table_records': [{ 'key': 'table_uri', }] } mock_col_query.return_value = 'not_related', { 'db': { 'name': 'db_name' }, 'clstr': { 'name': 'cluster' }, 'schema': { 'name': 'schema' }, 'tbl': { 'name': 'table_name' } } neo4j_proxy = Neo4jProxy(host='DOES_NOT_MATTER', port=0000) result = neo4j_proxy.get_table_by_user_relation( user_email='test_user', relation_type=UserResourceRel.follow) self.assertEqual(len(result['table']), 1) self.assertEqual(result['table'][0].name, 'table_name') self.assertEqual(result['table'][0].database, 'db_name') self.assertEqual(result['table'][0].cluster, 'cluster') self.assertEqual(result['table'][0].schema, 'schema')
def test_get_tags(self) -> None: with patch.object(GraphDatabase, 'driver'), patch.object( Neo4jProxy, '_execute_cypher_query') as mock_execute: mock_execute.return_value = [{ 'tag_name': { 'key': 'tag1' }, 'tag_count': 2 }, { 'tag_name': { 'key': 'tag2' }, 'tag_count': 1 }] neo4j_proxy = Neo4jProxy(host='DOES_NOT_MATTER', port=0000) actual = neo4j_proxy.get_tags() expected = [ TagDetail(tag_name='tag1', tag_count=2), TagDetail(tag_name='tag2', tag_count=1), ] self.assertEqual(actual.__repr__(), expected.__repr__())
def test_get_table_by_user_relation(self) -> None: with patch.object(GraphDatabase, 'driver'), patch.object( Neo4jProxy, '_execute_cypher_query') as mock_execute: mock_execute.return_value = [{ 'resource': { 'name': 'table_name' }, 'db': { 'name': 'db_name' }, 'clstr': { 'name': 'cluster' }, 'schema': { 'name': 'schema' }, }] neo4j_proxy = Neo4jProxy(host='DOES_NOT_MATTER', port=0000) result = neo4j_proxy.get_table_by_user_relation( user_email='test_user', relation_type=UserResourceRel.follow) self.assertEqual(len(result['table']), 1) self.assertEqual(result['table'][0].name, 'table_name') self.assertEqual(result['table'][0].database, 'db_name') self.assertEqual(result['table'][0].cluster, 'cluster') self.assertEqual(result['table'][0].schema, 'schema')
def test_get_table(self) -> None: with patch.object(GraphDatabase, 'driver'), patch.object( Neo4jProxy, '_execute_cypher_query') as mock_execute: mock_execute.side_effect = [ self.col_usage_return_value, [], self.table_level_return_value ] neo4j_proxy = Neo4jProxy(host='DOES_NOT_MATTER', port=0000) table = neo4j_proxy.get_table(table_uri='dummy_uri') expected = Table( database='hive', cluster='gold', schema='foo_schema', name='foo_table', tags=[Tag(tag_name='test', tag_type='default')], table_readers=[], description='foo description', watermarks=[ Watermark(watermark_type='high_watermark', partition_key='ds', partition_value='fake_value', create_time='fake_time'), Watermark(watermark_type='low_watermark', partition_key='ds', partition_value='fake_value', create_time='fake_time') ], columns=[ Column(name='bar_id_1', description='bar col description', col_type='varchar', sort_order=0, stats=[ Statistics(start_epoch=1, end_epoch=1, stat_type='avg', stat_val='1') ]), Column(name='bar_id_2', description='bar col2 description', col_type='bigint', sort_order=1, stats=[ Statistics(start_epoch=2, end_epoch=2, stat_type='avg', stat_val='2') ]) ], owners=[User(email='*****@*****.**')], table_writer=Application( application_url=self.table_writer['application_url'], description=self.table_writer['description'], name=self.table_writer['name'], id=self.table_writer['id']), last_updated_timestamp=1, source=Source(source='/source_file_loc', source_type='github')) self.assertEqual(str(expected), str(table))
def test_get_user_other_key_values(self) -> None: with patch.object(GraphDatabase, 'driver'), patch.object( Neo4jProxy, '_execute_cypher_query') as mock_execute: mock_execute.return_value.single.return_value = { 'user_record': { 'employee_type': 'teamMember', 'full_name': 'test_full_name', 'is_active': 'True', 'github_username': '******', 'slack_id': 'test_id', 'last_name': 'test_last_name', 'first_name': 'test_first_name', 'team_name': 'test_team', 'email': 'test_email', 'mode_user_id': 'mode_foo_bar', 'etc': 'etc_foo_bar', }, 'manager_record': { 'full_name': 'test_manager_fullname' } } neo4j_proxy = Neo4jProxy(host='DOES_NOT_MATTER', port=0000) neo4j_user = neo4j_proxy.get_user(id='test_email') self.assertEquals(neo4j_user.other_key_values, {'mode_user_id': 'mode_foo_bar'})
def test_user_resource_relation_clause(self) -> None: with patch.object(GraphDatabase, 'driver'): neo4j_proxy = Neo4jProxy(host='DOES_NOT_MATTER', port=0000) actual = neo4j_proxy._get_user_resource_relationship_clause( UserResourceRel.follow, id='foo', user_key='bar', resource_type=ResourceType.Table) expected = '(usr:User {key: $user_key})-[rel:FOLLOW]->(resource:Table {key: $resource_key})' self.assertEqual(expected, actual) actual = neo4j_proxy._get_user_resource_relationship_clause( UserResourceRel.read, id='foo', user_key='bar', resource_type=ResourceType.Table) expected = '(usr:User {key: $user_key})-[rel:READ]->(resource:Table {key: $resource_key})' self.assertEqual(expected, actual) actual = neo4j_proxy._get_user_resource_relationship_clause( UserResourceRel.own, id='foo', user_key='bar', resource_type=ResourceType.Table) expected = '(usr:User {key: $user_key})<-[rel:OWNER]-(resource:Table {key: $resource_key})' self.assertEqual(expected, actual) actual = neo4j_proxy._get_user_resource_relationship_clause( UserResourceRel.follow, id='foo', user_key='bar', resource_type=ResourceType.Dashboard) expected = '(usr:User {key: $user_key})-[rel:FOLLOW]->(resource:Dashboard {key: $resource_key})' self.assertEqual(expected, actual)
def test_put_dashboard_description(self) -> None: """ Test updating table description :return: """ with patch.object(GraphDatabase, 'driver') as mock_driver: mock_session = MagicMock() mock_driver.return_value.session.return_value = mock_session mock_transaction = MagicMock() mock_session.begin_transaction.return_value = mock_transaction mock_run = MagicMock() mock_transaction.run = mock_run mock_commit = MagicMock() mock_transaction.commit = mock_commit neo4j_proxy = Neo4jProxy(host='DOES_NOT_MATTER', port=0000) neo4j_proxy.put_dashboard_description( id='test_dashboard', description='test_description') self.assertEquals(mock_run.call_count, 2) self.assertEquals(mock_commit.call_count, 1) expected_stmt = textwrap.dedent(""" MATCH (n1:Description {key: $desc_key}), (n2:Dashboard {key: $key}) MERGE (n2)-[r2:DESCRIPTION]->(n1) RETURN n1.key, n2.key """) mock_run.assert_called_with(expected_stmt, { 'desc_key': 'test_dashboard/_description', 'key': 'test_dashboard' })
def test_get_column_with_valid_description(self) -> None: """ Test description is returned for column :return: """ with patch.object(GraphDatabase, 'driver'), patch.object( Neo4jProxy, '_execute_cypher_query') as mock_execute: mock_execute.return_value.single.return_value = dict( description='sample description') neo4j_proxy = Neo4jProxy(host='DOES_NOT_MATTER', port=0000) col_description = neo4j_proxy.get_column_description( table_uri='test_table', column_name='test_column') column_description_query = textwrap.dedent(""" MATCH (tbl:Table {key: $tbl_key})-[:COLUMN]->(c:Column {name: $column_name})-[:DESCRIPTION]->(d:Description) RETURN d.description AS description; """) mock_execute.assert_called_with(statement=column_description_query, param_dict={ 'tbl_key': 'test_table', 'column_name': 'test_column' }) self.assertEquals(col_description, 'sample description')
def test_get_users(self) -> None: with patch.object(GraphDatabase, 'driver'), patch.object( Neo4jProxy, '_execute_cypher_query') as mock_execute: test_user = { 'employee_type': 'teamMember', 'full_name': 'test_full_name', 'is_active': True, 'github_username': '******', 'slack_id': 'test_id', 'last_name': 'test_last_name', 'first_name': 'test_first_name', 'team_name': 'test_team', 'email': 'test_email', 'manager_fullname': 'test_manager', } mock_execute.return_value.single.return_value = { 'users': [test_user] } neo4j_proxy = Neo4jProxy(host='DOES_NOT_MATTER', port=0000) users = neo4j_proxy.get_users() actual_data = UserSchema(many=True).load([test_user]).data for attr in [ 'employee_type', 'full_name', 'is_active', 'github_username', 'slack_id', 'last_name', 'first_name', 'team_name', 'email', 'manager_fullname' ]: self.assertEquals(getattr(users[0], attr), getattr(actual_data[0], attr))
def test_get_dashboard_by_user_relation(self) -> None: with patch.object(GraphDatabase, 'driver'), patch.object(Neo4jProxy, '_execute_cypher_query') as mock_execute: mock_execute.return_value = [ { 'uri': 'dashboard_uri', 'cluster_name': 'cluster', 'dg_name': 'dashboard_group', 'dg_url': 'http://foo.bar/group', 'product': 'foobar', 'name': 'dashboard', 'url': 'http://foo.bar/dashboard', 'description': 'description', 'last_successful_run_timestamp': 1234567890 } ] neo4j_proxy = Neo4jProxy(host='DOES_NOT_MATTER', port=0000) result = neo4j_proxy.get_dashboard_by_user_relation(user_email='test_user', relation_type=UserResourceRel.follow) expected = DashboardSummary(uri='dashboard_uri', cluster='cluster', group_name='dashboard_group', group_url='http://foo.bar/group', product='foobar', name='dashboard', url='http://foo.bar/dashboard', description='description', last_successful_run_timestamp=1234567890) self.assertEqual(len(result['dashboard']), 1) self.assertEqual(expected, result['dashboard'][0])
def test_get_neo4j_latest_updated_ts(self) -> None: with patch.object(GraphDatabase, 'driver'), patch.object( Neo4jProxy, '_execute_cypher_query') as mock_execute: mock_execute.return_value.single.return_value = { 'ts': { 'latest_timestmap': '1000' } } neo4j_proxy = Neo4jProxy(host='DOES_NOT_MATTER', port=0000) neo4j_last_updated_ts = neo4j_proxy.get_latest_updated_ts() self.assertEquals(neo4j_last_updated_ts, '1000') mock_execute.return_value.single.return_value = {'ts': {}} neo4j_proxy = Neo4jProxy(host='DOES_NOT_MATTER', port=0000) neo4j_last_updated_ts = neo4j_proxy.get_latest_updated_ts() self.assertIs(neo4j_last_updated_ts, None)
def test_get_invalid_user(self) -> None: with patch.object(GraphDatabase, 'driver'), patch.object( Neo4jProxy, '_execute_cypher_query') as mock_execute: mock_execute.return_value.single.return_value = None neo4j_proxy = Neo4jProxy(host='DOES_NOT_MATTER', port=0000) self.assertRaises(NotFoundException, neo4j_proxy.get_user, id='invalid_email')
def test_with_neo4j_proxy(self) -> None: with patch.object(GraphDatabase, 'driver'), \ patch.object(Neo4jProxy, '_execute_cypher_query'), \ patch.object(statsd_utilities, '_get_statsd_client') as mock_statsd_client: mock_success_incr = MagicMock() mock_statsd_client.return_value.incr = mock_success_incr neo4j_proxy = Neo4jProxy(endpoint='bogus') neo4j_proxy.add_owner(table_uri='bogus_uri', owner='foo') self.assertEqual(mock_success_incr.call_count, 1)
def test_get_table_view_only(self) -> None: col_usage_return_value = copy.deepcopy(self.col_usage_return_value) for col in col_usage_return_value: col['tbl']['is_view'] = True with patch.object(GraphDatabase, 'driver'), patch.object(Neo4jProxy, '_execute_cypher_query') as mock_execute: mock_execute.side_effect = [col_usage_return_value, [], self.table_level_return_value] neo4j_proxy = Neo4jProxy(host='DOES_NOT_MATTER', port=0000) table = neo4j_proxy.get_table(table_uri='dummy_uri') expected = Table(database='hive', cluster='gold', schema='foo_schema', name='foo_table', tags=[Tag(tag_name='test', tag_type='default')], badges=[Badge(badge_name='golden', category='table_status')], table_readers=[], description='foo description', watermarks=[Watermark(watermark_type='high_watermark', partition_key='ds', partition_value='fake_value', create_time='fake_time'), Watermark(watermark_type='low_watermark', partition_key='ds', partition_value='fake_value', create_time='fake_time')], columns=[Column(name='bar_id_1', description='bar col description', col_type='varchar', sort_order=0, stats=[Stat(start_epoch=1, end_epoch=1, stat_type='avg', stat_val='1')], badges=[]), Column(name='bar_id_2', description='bar col2 description', col_type='bigint', sort_order=1, stats=[Stat(start_epoch=2, end_epoch=2, stat_type='avg', stat_val='2')], badges=[Badge(badge_name='primary key', category='column')])], owners=[User(email='*****@*****.**')], table_writer=Application(application_url=self.table_writer['application_url'], description=self.table_writer['description'], name=self.table_writer['name'], id=self.table_writer['id']), last_updated_timestamp=1, source=Source(source='/source_file_loc', source_type='github'), is_view=True, programmatic_descriptions=[ ProgrammaticDescription(source='quality_report', text='Test Test'), ProgrammaticDescription(source='s3_crawler', text='Test Test Test') ]) self.assertEqual(str(expected), str(table))
def test_delete_tag(self) -> None: with patch.object(GraphDatabase, 'driver') as mock_driver: mock_session = MagicMock() mock_driver.return_value.session.return_value = mock_session mock_transaction = MagicMock() mock_session.begin_transaction.return_value = mock_transaction mock_run = MagicMock() mock_transaction.run = mock_run mock_commit = MagicMock() mock_transaction.commit = mock_commit neo4j_proxy = Neo4jProxy(endpoint='bogus') neo4j_proxy.delete_tag(table_uri='dummy_uri', tag='hive') # we only call neo4j once in delete_tag call self.assertEquals(mock_run.call_count, 1) self.assertEquals(mock_commit.call_count, 1)
def test_add_tag(self) -> None: with patch.object(GraphDatabase, 'driver') as mock_driver: mock_session = MagicMock() mock_driver.return_value.session.return_value = mock_session mock_transaction = MagicMock() mock_session.begin_transaction.return_value = mock_transaction mock_run = MagicMock() mock_transaction.run = mock_run mock_commit = MagicMock() mock_transaction.commit = mock_commit neo4j_proxy = Neo4jProxy(host='DOES_NOT_MATTER', port=0000) neo4j_proxy.add_tag(id='dummy_uri', tag='hive') # we call neo4j twice in add_tag call self.assertEquals(mock_run.call_count, 3) self.assertEquals(mock_commit.call_count, 1)
def test_delete_owner(self) -> None: with patch.object(GraphDatabase, 'driver') as mock_driver: mock_session = MagicMock() mock_driver.return_value.session.return_value = mock_session mock_transaction = MagicMock() mock_session.begin_transaction.return_value = mock_transaction mock_run = MagicMock() mock_transaction.run = mock_run mock_commit = MagicMock() mock_transaction.commit = mock_commit neo4j_proxy = Neo4jProxy(host='DOES_NOT_MATTER', port=0000) neo4j_proxy.delete_owner(table_uri='dummy_uri', owner='tester') # we only call neo4j once in delete_owner call self.assertEquals(mock_run.call_count, 1) self.assertEquals(mock_commit.call_count, 1)
def test_add_owner(self) -> None: with patch.object(GraphDatabase, 'driver') as mock_driver: mock_session = MagicMock() mock_driver.return_value.session.return_value = mock_session mock_transaction = MagicMock() mock_session.begin_transaction.return_value = mock_transaction mock_run = MagicMock() mock_transaction.run = mock_run mock_commit = MagicMock() mock_transaction.commit = mock_commit neo4j_proxy = Neo4jProxy(endpoint='bogus') neo4j_proxy.add_owner(table_uri='dummy_uri', owner='tester') # we call neo4j twice in add_owner call self.assertEquals(mock_run.call_count, 2) self.assertEquals(mock_commit.call_count, 1)
def test_get_dashboard_with_valid_description(self) -> None: """ Test description is returned for dashboard :return: """ with patch.object(GraphDatabase, 'driver'), patch.object(Neo4jProxy, '_execute_cypher_query') as mock_execute: mock_execute.return_value.single.return_value = dict(description='sample description') neo4j_proxy = Neo4jProxy(host='DOES_NOT_MATTER', port=0000) table_description = neo4j_proxy.get_dashboard_description(id='test_dashboard') dashboard_description_query = textwrap.dedent(""" MATCH (n:Dashboard {key: $key})-[:DESCRIPTION]->(d:Description) RETURN d.description AS description; """) mock_execute.assert_called_with(statement=dashboard_description_query, param_dict={'key': 'test_dashboard'}) self.assertEquals(table_description.description, 'sample description')
def test_get_table_with_no_description(self) -> None: """ Test None is returned for table with no description :return: """ with patch.object(GraphDatabase, 'driver'), patch.object(Neo4jProxy, '_execute_cypher_query') as mock_execute: mock_execute.return_value.single.return_value = None neo4j_proxy = Neo4jProxy(host='DOES_NOT_MATTER', port=0000) table_description = neo4j_proxy.get_table_description(table_uri='test_table') table_description_query = textwrap.dedent(""" MATCH (tbl:Table {key: $tbl_key})-[:DESCRIPTION]->(d:Description) RETURN d.description AS description; """) mock_execute.assert_called_with(statement=table_description_query, param_dict={'tbl_key': 'test_table'}) self.assertIsNone(table_description)
def test_delete_resource_relation_by_user(self) -> None: with patch.object(GraphDatabase, 'driver') as mock_driver: mock_session = MagicMock() mock_driver.return_value.session.return_value = mock_session mock_transaction = MagicMock() mock_session.begin_transaction.return_value = mock_transaction mock_run = MagicMock() mock_transaction.run = mock_run mock_commit = MagicMock() mock_transaction.commit = mock_commit neo4j_proxy = Neo4jProxy(host='DOES_NOT_MATTER', port=0000) neo4j_proxy.delete_table_relation_by_user(table_uri='dummy_uri', user_email='tester', relation_type=UserResourceRel.follow) self.assertEquals(mock_run.call_count, 1) self.assertEquals(mock_commit.call_count, 1)
def test_add_resource_relation_by_user(self) -> None: with patch.object(GraphDatabase, 'driver') as mock_driver: mock_session = MagicMock() mock_driver.return_value.session.return_value = mock_session mock_transaction = MagicMock() mock_session.begin_transaction.return_value = mock_transaction mock_run = MagicMock() mock_transaction.run = mock_run mock_commit = MagicMock() mock_transaction.commit = mock_commit neo4j_proxy = Neo4jProxy(endpoint='bogus') neo4j_proxy.add_table_relation_by_user( table_uri='dummy_uri', user_email='tester', relation_type=UserResourceRel.follow) self.assertEquals(mock_run.call_count, 2) self.assertEquals(mock_commit.call_count, 1)
def test_get_users(self) -> None: with patch.object(GraphDatabase, 'driver'), patch.object( Neo4jProxy, '_execute_cypher_query') as mock_execute: mock_execute.return_value.single.return_value = { 'user_record': { 'employee_type': 'teamMember', 'full_name': 'test_full_name', 'is_active': 'True', 'github_username': '******', 'slack_id': 'test_id', 'last_name': 'test_last_name', 'first_name': 'test_first_name', 'team_name': 'test_team', 'email': 'test_email', }, 'manager_record': { 'full_name': 'test_manager_fullname' } } neo4j_proxy = Neo4jProxy(endpoint='bogus') neo4j_user = neo4j_proxy.get_user_detail(user_id='test_email') self.assertEquals(neo4j_user.email, 'test_email')
def test_put_table_description(self) -> None: """ Test updating table description :return: """ with patch.object(GraphDatabase, 'driver') as mock_driver: mock_session = MagicMock() mock_driver.return_value.session.return_value = mock_session mock_transaction = MagicMock() mock_session.begin_transaction.return_value = mock_transaction mock_run = MagicMock() mock_transaction.run = mock_run mock_commit = MagicMock() mock_transaction.commit = mock_commit neo4j_proxy = Neo4jProxy(endpoint='DOES_NOT_MATTER') neo4j_proxy.put_table_description(table_uri='test_table', description='test_description') self.assertEquals(mock_run.call_count, 2) self.assertEquals(mock_commit.call_count, 1)
def test_get_resources_by_user_relation(self) -> None: with patch.object(GraphDatabase, 'driver'), \ patch.object(Neo4jProxy, '_execute_cypher_query') as mock_execute, \ patch.object(Neo4jProxy, 'get_table') as mock_get_table: mock_execute.return_value.single.return_value = { 'table_records': [{ 'key': 'table_uri', }] } mock_get_table.return_value = Table( database='hive', cluster='gold', schema='foo_schema', name='foo_table', tags=[Tag(tag_name='test', tag_type='default')], table_readers=[], description='foo description', watermarks=[ Watermark(watermark_type='high_watermark', partition_key='ds', partition_value='fake_value', create_time='fake_time'), Watermark(watermark_type='low_watermark', partition_key='ds', partition_value='fake_value', create_time='fake_time') ], columns=[ Column(name='bar_id_1', description='bar col description', col_type='varchar', sort_order=0, stats=[ Statistics(start_epoch=1, end_epoch=1, stat_type='avg', stat_val='1') ]), Column(name='bar_id_2', description='bar col2 description', col_type='bigint', sort_order=1, stats=[ Statistics(start_epoch=2, end_epoch=2, stat_type='avg', stat_val='2') ]) ], owners=[User(email='*****@*****.**')], table_writer=Application( application_url=self.table_writer['application_url'], description=self.table_writer['description'], name=self.table_writer['name'], id=self.table_writer['id']), last_updated_timestamp=1, source=Source(source='/source_file_loc', source_type='github')) neo4j_proxy = Neo4jProxy(host='DOES_NOT_MATTER', port=0000) result = neo4j_proxy.get_table_by_user_relation( user_email='test_user', relation_type=UserResourceRel.follow) self.assertEqual(len(result['table']), 1) self.assertEqual(result['table'][0].name, 'foo_table')
def test_get_popular_tables(self) -> None: # Test cache hit for global popular tables with patch.object(GraphDatabase, 'driver'), patch.object( Neo4jProxy, '_execute_cypher_query') as mock_execute: mock_execute.return_value = [{ 'table_key': 'foo' }, { 'table_key': 'bar' }] neo4j_proxy = Neo4jProxy(host='DOES_NOT_MATTER', port=0000) self.assertEqual(neo4j_proxy._get_global_popular_tables_uris(2), ['foo', 'bar']) self.assertEqual(neo4j_proxy._get_global_popular_tables_uris(2), ['foo', 'bar']) self.assertEqual(neo4j_proxy._get_global_popular_tables_uris(2), ['foo', 'bar']) self.assertEqual(mock_execute.call_count, 1) # Test cache hit for personal popular tables with patch.object(GraphDatabase, 'driver'), patch.object( Neo4jProxy, '_execute_cypher_query') as mock_execute: mock_execute.return_value = [{ 'table_key': 'foo' }, { 'table_key': 'bar' }] neo4j_proxy = Neo4jProxy(host='DOES_NOT_MATTER', port=0000) self.assertEqual( neo4j_proxy._get_personal_popular_tables_uris(2, 'test_id'), ['foo', 'bar']) self.assertEqual( neo4j_proxy._get_personal_popular_tables_uris(2, 'test_id'), ['foo', 'bar']) self.assertEqual( neo4j_proxy._get_personal_popular_tables_uris(2, 'other_id'), ['foo', 'bar']) self.assertEqual(mock_execute.call_count, 2) with patch.object(GraphDatabase, 'driver'), patch.object( Neo4jProxy, '_execute_cypher_query') as mock_execute: mock_execute.return_value = [{ 'database_name': 'db', 'cluster_name': 'clstr', 'schema_name': 'sch', 'table_name': 'foo', 'table_description': 'test description' }, { 'database_name': 'db', 'cluster_name': 'clstr', 'schema_name': 'sch', 'table_name': 'bar' }] neo4j_proxy = Neo4jProxy(host='DOES_NOT_MATTER', port=0000) actual = neo4j_proxy.get_popular_tables(num_entries=2) expected = [ PopularTable(database='db', cluster='clstr', schema='sch', name='foo', description='test description'), PopularTable(database='db', cluster='clstr', schema='sch', name='bar'), ] self.assertEqual(actual.__repr__(), expected.__repr__())
def test_get_dashboard(self) -> None: with patch.object(GraphDatabase, 'driver'), patch.object( Neo4jProxy, '_execute_cypher_query') as mock_execute: mock_execute.return_value.single.side_effect = [{ 'cluster_name': 'cluster_name', 'uri': 'foo_dashboard://gold.bar/dashboard_id', 'url': 'http://www.foo.bar/dashboard_id', 'product': 'foobar', 'name': 'dashboard name', 'created_timestamp': 123456789, 'description': 'description', 'group_name': 'group_name', 'group_url': 'http://www.group_url.com', 'last_successful_run_timestamp': 9876543210, 'last_run_timestamp': 987654321, 'last_run_state': 'good_state', 'updated_timestamp': 123456654321, 'recent_view_count': 100, 'owners': [{ 'employee_type': 'teamMember', 'full_name': 'test_full_name', 'is_active': 'True', 'github_username': '******', 'slack_id': 'test_id', 'last_name': 'test_last_name', 'first_name': 'test_first_name', 'team_name': 'test_team', 'email': 'test_email', }, { 'employee_type': 'teamMember', 'full_name': 'test_full_name2', 'is_active': 'True', 'github_username': '******', 'slack_id': 'test_id2', 'last_name': 'test_last_name2', 'first_name': 'test_first_name2', 'team_name': 'test_team2', 'email': 'test_email2', }], 'tags': [{ 'key': 'tag_key1', 'tag_type': 'tag_type1' }, { 'key': 'tag_key2', 'tag_type': 'tag_type2' }], 'charts': [{ 'name': 'chart1' }, { 'name': 'chart2' }], 'queries': [{ 'name': 'query1' }, { 'name': 'query2' }], 'tables': [{ 'database': 'db1', 'name': 'table1', 'description': 'table description 1', 'cluster': 'cluster1', 'schema': 'schema1' }, { 'database': 'db2', 'name': 'table2', 'description': None, 'cluster': 'cluster2', 'schema': 'schema2' }] }, { 'cluster_name': 'cluster_name', 'uri': 'foo_dashboard://gold.bar/dashboard_id', 'url': 'http://www.foo.bar/dashboard_id', 'product': 'foobar', 'name': 'dashboard name', 'created_timestamp': 123456789, 'description': None, 'group_name': 'group_name', 'group_url': 'http://www.group_url.com', 'last_run_timestamp': None, 'last_run_state': None, 'updated_timestamp': None, 'recent_view_count': 0, 'owners': [], 'tags': [], 'charts': [], 'queries': [], 'tables': [] }] neo4j_proxy = Neo4jProxy(host='DOES_NOT_MATTER', port=0000) dashboard = neo4j_proxy.get_dashboard(id='dashboard_id') expected = DashboardDetail( uri='foo_dashboard://gold.bar/dashboard_id', cluster='cluster_name', group_name='group_name', group_url='http://www.group_url.com', product='foobar', name='dashboard name', url='http://www.foo.bar/dashboard_id', description='description', created_timestamp=123456789, last_successful_run_timestamp=9876543210, updated_timestamp=123456654321, last_run_timestamp=987654321, last_run_state='good_state', owners=[ User(email='test_email', first_name='test_first_name', last_name='test_last_name', full_name='test_full_name', is_active='True', github_username='******', team_name='test_team', slack_id='test_id', employee_type='teamMember', manager_fullname=''), User(email='test_email2', first_name='test_first_name2', last_name='test_last_name2', full_name='test_full_name2', is_active='True', github_username='******', team_name='test_team2', slack_id='test_id2', employee_type='teamMember', manager_fullname='') ], frequent_users=[], chart_names=['chart1', 'chart2'], query_names=['query1', 'query2'], tables=[ PopularTable(database='db1', name='table1', description='table description 1', cluster='cluster1', schema='schema1'), PopularTable(database='db2', name='table2', cluster='cluster2', schema='schema2'), ], tags=[ Tag(tag_type='tag_type1', tag_name='tag_key1'), Tag(tag_type='tag_type2', tag_name='tag_key2') ], recent_view_count=100) self.assertEqual(expected, dashboard) dashboard2 = neo4j_proxy.get_dashboard(id='dashboard_id') expected2 = DashboardDetail( uri='foo_dashboard://gold.bar/dashboard_id', cluster='cluster_name', group_name='group_name', group_url='http://www.group_url.com', product='foobar', name='dashboard name', url='http://www.foo.bar/dashboard_id', description=None, created_timestamp=123456789, updated_timestamp=None, last_run_timestamp=None, last_run_state=None, owners=[], frequent_users=[], chart_names=[], query_names=[], tables=[], tags=[], last_successful_run_timestamp=None, recent_view_count=0) self.assertEqual(expected2, dashboard2)