示例#1
0
    def _get_table(self, custom_stats_format: bool = False) -> None:
        if custom_stats_format:
            test_exp_col = self.test_exp_col_stats_formatted
        else:
            test_exp_col = self.test_exp_col_stats_raw
        ent_attrs = cast(dict, self.entity1['attributes'])
        self._mock_get_table_entity()
        self._create_mocked_report_entities_collection()
        self.proxy._get_owners = MagicMock(
            return_value=[User(email=ent_attrs['owner'])])  # type: ignore
        response = self.proxy.get_table(table_uri=self.table_uri)

        classif_name = self.classification_entity['classifications'][0][
            'typeName']

        col_attrs = cast(dict, self.test_column['attributes'])
        exp_col_stats = list()

        for stats in test_exp_col:
            exp_col_stats.append(
                Stat(
                    stat_type=stats['attributes']['stat_name'],
                    stat_val=stats['attributes']['stat_val'],
                    start_epoch=stats['attributes']['start_epoch'],
                    end_epoch=stats['attributes']['end_epoch'],
                ))

        exp_col = Column(
            name=col_attrs['name'],
            description='column description',
            col_type='Managed',
            sort_order=col_attrs['position'],
            stats=exp_col_stats,
            badges=[Badge(category='default', badge_name='active_col_badge')])

        expected = Table(
            database=self.entity_type,
            cluster=self.cluster,
            schema=self.db,
            name=ent_attrs['name'],
            tags=[],
            badges=[Badge(badge_name=classif_name, category="default")],
            description=ent_attrs['description'],
            owners=[User(email=ent_attrs['owner'])],
            resource_reports=[],
            last_updated_timestamp=int(str(self.entity1['updateTime'])[:10]),
            columns=[exp_col] * self.active_columns,
            watermarks=[],
            programmatic_descriptions=[
                ProgrammaticDescription(source='test parameter key a',
                                        text='testParameterValueA'),
                ProgrammaticDescription(source='test parameter key b',
                                        text='testParameterValueB')
            ],
            is_view=False)

        self.assertEqual(str(expected), str(response))
示例#2
0
    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))
示例#3
0
    def test_get_badges(self) -> None:
        expected = [
            Badge(badge_name=item, category="default")
            for item in self.metrics_data['tag'].get("tagEntities").keys()
        ]

        self.proxy.client.admin.get_metrics = MagicMock(
            return_value=self.metrics_data)
        response = self.proxy.get_badges()
        self.assertEqual(expected.__repr__(), response.__repr__())
示例#4
0
    def get_badges(self) -> List:
        badges = list()

        metrics = self.client.admin.get_metrics()
        try:
            system_badges = metrics["tag"].get("tagEntities").keys()

            for item in system_badges:
                badges.append(Badge(badge_name=item, category="default"))
        except AttributeError:
            LOGGER.info("No badges/classifications available in the system.")

        return badges
    def get_table(self, *, table_uri: str) -> Table:
        """
        Gathers all the information needed for the Table Detail Page.
        :param table_uri:
        :return: A Table object with all the information available
        or gathered from different entities.
        """
        entity = self._get_table_entity(table_uri=table_uri)
        table_details = entity.entity

        try:
            attrs = table_details[self.ATTRS_KEY]

            programmatic_descriptions = self._get_programmatic_descriptions(attrs.get('parameters', dict()))

            table_qn = parse_table_qualified_name(
                qualified_name=attrs.get(self.QN_KEY)
            )

            badges = []
            # Using or in case, if the key 'classifications' is there with a None
            for classification in table_details.get('classifications') or list():
                badges.append(
                    Badge(
                        badge_name=classification.get('typeName'),
                        category="default"
                    )
                )

            tags = []
            for term in table_details.get(self.REL_ATTRS_KEY).get("meanings") or list():
                if term.get('entityStatus') == Status.ACTIVE and \
                        term.get('relationshipStatus') == Status.ACTIVE:
                    tags.append(
                        Tag(
                            tag_name=term.get("displayText"),
                            tag_type="default"
                        )
                    )

            columns = self._serialize_columns(entity=entity)

            reports_guids = [report.get("guid") for report in attrs.get("reports") or list()]

            table_type = attrs.get('tableType') or 'table'
            is_view = 'view' in table_type.lower()

            readers = self._get_readers(table_details)

            table = Table(
                database=table_details.get('typeName'),
                cluster=table_qn.get('cluster_name', ''),
                schema=table_qn.get('db_name', ''),
                name=attrs.get('name') or table_qn.get("table_name", ''),
                badges=badges,
                tags=tags,
                description=attrs.get('description') or attrs.get('comment'),
                owners=self._get_owners(
                    table_details[self.REL_ATTRS_KEY].get('ownedBy', []), attrs.get('owner')),
                resource_reports=self._get_reports(guids=reports_guids),
                columns=columns,
                is_view=is_view,
                table_readers=readers,
                last_updated_timestamp=self._parse_date(table_details.get('updateTime')),
                programmatic_descriptions=programmatic_descriptions,
                watermarks=self._get_table_watermarks(table_details))

            return table
        except KeyError as ex:
            LOGGER.exception('Error while accessing table information. {}'
                             .format(str(ex)))
            raise BadRequest('Some of the required attributes '
                             'are missing in : ( {table_uri} )'
                             .format(table_uri=table_uri))
    def _serialize_columns(self, *, entity: AtlasEntityWithExtInfo) -> \
            Union[List[Column], List]:
        """
        Helper function to fetch the columns from entity and serialize them
        using Column and Stat model.
        :param entity: AtlasEntityWithExtInfo object,
        along with relationshipAttributes
        :return: A list of Column objects, if there are any columns available,
        else an empty list.
        """
        columns = list()
        for column in entity.entity[self.REL_ATTRS_KEY].get('columns') or list():
            column_status = column.get('entityStatus', 'inactive').lower()

            if column_status != 'active':
                continue

            col_entity = entity.referredEntities[column[self.GUID_KEY]]
            col_attrs = col_entity[self.ATTRS_KEY]
            statistics = list()

            badges = list()
            for column_classification in col_entity.get('classifications') or list():
                if column_classification.get('entityStatus') == Status.ACTIVE:
                    name = column_classification.get('typeName')

                    badges.append(Badge(badge_name=name, category='default'))

            for stats in col_attrs.get('statistics') or list():
                stats_attrs = stats['attributes']

                stat_type = stats_attrs.get('stat_name')

                stat_format = self.STATISTICS_FORMAT_SPEC.get(stat_type, dict())

                if not stat_format.get('drop', False):
                    stat_type = stat_format.get('new_name', stat_type)

                    stat_val = stats_attrs.get('stat_val')

                    format_val = stat_format.get('format')

                    if format_val:
                        stat_val = format_val.format(stat_val)
                    else:
                        stat_val = str(stat_val)

                    start_epoch = stats_attrs.get('start_epoch')
                    end_epoch = stats_attrs.get('end_epoch')

                    statistics.append(
                        Stat(
                            stat_type=stat_type,
                            stat_val=stat_val,
                            start_epoch=start_epoch,
                            end_epoch=end_epoch,
                        )
                    )

            columns.append(
                Column(
                    name=col_attrs.get('name'),
                    description=col_attrs.get('description') or col_attrs.get('comment'),
                    col_type=col_attrs.get('type') or col_attrs.get('dataType') or col_attrs.get('data_type'),
                    sort_order=col_attrs.get('position') or 9999,
                    stats=statistics,
                    badges=badges
                )
            )
        return sorted(columns, key=lambda item: item.sort_order)
示例#7
0
    def test_get_dashboard(self, mock_rds_client: Any) -> None:
        # dashboard_metadata
        dashboard = RDSDashboard(
            rk='foo_dashboard://gold.bar/dashboard_id',
            name='dashboard name',
            dashboard_url='http://www.foo.bar/dashboard_id',
            created_timestamp=123456789)
        dashboard_group = RDSDashboardGroup(
            name='group_name', dashboard_group_url='http://www.group_url.com')
        dashboard_group.cluster = RDSCluster(name='cluster_name')
        dashboard.group = dashboard_group
        dashboard.description = RDSDashboardDescription(
            description='description')
        dashboard.execution = [
            RDSDashboardExecution(rk='dashboard_last_successful_execution',
                                  timestamp=9876543210),
            RDSDashboardExecution(rk='dashboard_last_execution',
                                  timestamp=987654321,
                                  state='good_state')
        ]
        dashboard.timestamp = RDSDashboardTimestamp(timestamp=123456654321)
        dashboard.tags = [
            RDSTag(rk='tag_key1', tag_type='default'),
            RDSTag(rk='tag_key2', tag_type='default')
        ]
        dashboard.badges = [RDSBadge(rk='golden', category='table_status')]
        dashboard.owners = [
            RDSUser(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'),
            RDSUser(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')
        ]
        dashboard.usage = [RDSDashboardUsage(read_count=100)]

        mock_client = MagicMock()
        mock_rds_client.return_value = mock_client

        mock_create_session = MagicMock()
        mock_client.create_session.return_value = mock_create_session

        mock_session = MagicMock()
        mock_create_session.__enter__.return_value = mock_session

        mock_session_query = MagicMock()
        mock_session.query.return_value = mock_session_query

        mock_session_query_filter = MagicMock()
        mock_session_query.filter.return_value = mock_session_query_filter

        mock_session_query_filter.first.return_value = dashboard

        # queries
        query1 = RDSDashboardQuery(name='query1')
        query2 = RDSDashboardQuery(name='query2',
                                   url='http://foo.bar/query',
                                   query_text='SELECT * FROM foo.bar')
        query1.charts = [RDSDashboardChart(name='chart1')]
        query2.charts = [RDSDashboardChart(name='chart2')]
        queries = [query1, query2]

        # tables
        database1 = RDSDatabase(name='db1')
        database2 = RDSDatabase(name='db2')
        cluster1 = RDSCluster(name='cluster1')
        cluster2 = RDSCluster(name='cluster2')
        schema1 = RDSSchema(name='schema1')
        schema2 = RDSSchema(name='schema2')
        table1 = RDSTable(name='table1')
        table2 = RDSTable(name='table2')
        description1 = RDSTableDescription(description='table description 1')

        schema1.cluster = cluster1
        cluster1.database = database1
        schema2.cluster = cluster2
        cluster2.database = database2
        table1.schema = schema1
        table2.schema = schema2
        table1.description = description1
        tables = [table1, table2]

        mock_session_query_filter_options = MagicMock()
        mock_session_query_filter.options.return_value = mock_session_query_filter_options

        mock_session_query_filter_options.all.side_effect = [queries, tables]

        expected = DashboardDetail(
            uri='foo_dashboard://gold.bar/dashboard_id',
            cluster='cluster_name',
            group_name='group_name',
            group_url='http://www.group_url.com',
            product='foo',
            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'],
            queries=[
                DashboardQuery(name='query1'),
                DashboardQuery(name='query2',
                               url='http://foo.bar/query',
                               query_text='SELECT * FROM foo.bar')
            ],
            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='default', tag_name='tag_key1'),
                Tag(tag_type='default', tag_name='tag_key2')
            ],
            badges=[Badge(badge_name='golden', category='table_status')],
            recent_view_count=100)

        proxy = MySQLProxy()
        actual = proxy.get_dashboard(id='dashboard_id')

        self.assertEqual(expected, actual)
示例#8
0
    def test_get_table(self, mock_rds_client: Any) -> None:
        database = RDSDatabase(name='hive')
        cluster = RDSCluster(name='gold')
        schema = RDSSchema(name='foo_schema')
        schema.cluster = cluster
        cluster.database = database

        table = RDSTable(name='foo_table')
        table.schema = schema
        table.description = RDSTableDescription(description='foo description')

        col1 = RDSColumn(name='bar_id_1', type='varchar', sort_order=0)
        col1.description = RDSColumnDescription(
            description='bar col description')
        col1.stats = [
            RDSColumnStat(stat_type='avg',
                          start_epoch='1',
                          end_epoch='1',
                          stat_val='1')
        ]

        col2 = RDSColumn(name='bar_id_2', type='bigint', sort_order=1)
        col2.description = RDSColumnDescription(
            description='bar col2 description')
        col2.stats = [
            RDSColumnStat(stat_type='avg',
                          start_epoch='2',
                          end_epoch='2',
                          stat_val='2')
        ]
        col2.badges = [RDSBadge(rk='primary key', category='column')]
        columns = [col1, col2]

        table.watermarks = [
            RDSTableWatermark(
                rk='hive://gold.test_schema/test_table/high_watermark/',
                partition_key='ds',
                partition_value='fake_value',
                create_time='fake_time'),
            RDSTableWatermark(
                rk='hive://gold.test_schema/test_table/low_watermark/',
                partition_key='ds',
                partition_value='fake_value',
                create_time='fake_time')
        ]

        table.application = RDSApplication(
            application_url='airflow_host/admin/airflow/tree?dag_id=test_table',
            description='DAG generating a table',
            name='Airflow',
            id='dag/task_id')
        table.timestamp = RDSTableTimestamp(last_updated_timestamp=1)

        table.owners = [
            RDSUser(rk='*****@*****.**', email='*****@*****.**')
        ]
        table.tags = [RDSTag(rk='test', tag_type='default')]
        table.badges = [RDSBadge(rk='golden', category='table_status')]
        table.source = RDSTableSource(rk='some key',
                                      source_type='github',
                                      source='/source_file_loc')
        table.programmatic_descriptions = [
            RDSTableProgrammaticDescription(description_source='s3_crawler',
                                            description='Test Test Test'),
            RDSTableProgrammaticDescription(
                description_source='quality_report', description='Test Test')
        ]

        readers = [RDSTableUsage(user_rk='*****@*****.**', read_count=5)]

        mock_client = MagicMock()
        mock_rds_client.return_value = mock_client

        mock_create_session = MagicMock()
        mock_client.create_session.return_value = mock_create_session

        mock_session = MagicMock()
        mock_create_session.__enter__.return_value = mock_session

        mock_session_query = MagicMock()
        mock_session.query.return_value = mock_session_query

        mock_session_query_filter = MagicMock()
        mock_session_query.filter.return_value = mock_session_query_filter
        mock_session_query_filter.first.return_value = table

        mock_session_query_filter_orderby = MagicMock()
        mock_session_query_filter.order_by.return_value = mock_session_query_filter_orderby

        mock_session_query_filter_orderby_limit = MagicMock()
        mock_session_query_filter_orderby.limit.return_value = mock_session_query_filter_orderby_limit
        mock_session_query_filter_orderby_limit.all.return_value = readers

        mock_session_query_filter_options = MagicMock()
        mock_session_query_filter.options.return_value = mock_session_query_filter_options
        mock_session_query_filter_options.all.return_value = columns

        proxy = MySQLProxy()
        actual_table = 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=[
                Reader(user=User(email='*****@*****.**'), read_count=5)
            ],
            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=
                'airflow_host/admin/airflow/tree?dag_id=test_table',
                description='DAG generating a table',
                name='Airflow',
                id='dag/task_id'),
            last_updated_timestamp=1,
            source=Source(source='/source_file_loc', source_type='github'),
            is_view=False,
            programmatic_descriptions=[
                ProgrammaticDescription(source='quality_report',
                                        text='Test Test'),
                ProgrammaticDescription(source='s3_crawler',
                                        text='Test Test Test')
            ])

        self.assertEqual(str(expected), str(actual_table))
示例#9
0
    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'
                }],
                'badges': [{
                    'key': 'golden',
                    'category': 'table_status'
                }],
                'charts': [{
                    'name': 'chart1'
                }, {
                    'name': 'chart2'
                }],
                'queries': [{
                    'name': 'query1'
                }, {
                    'name': 'query2',
                    'url': 'http://foo.bar/query',
                    'query_text': 'SELECT * FROM foo.bar'
                }],
                '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': [],
                'badges': [],
                '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'],
                queries=[
                    DashboardQuery(name='query1'),
                    DashboardQuery(name='query2',
                                   url='http://foo.bar/query',
                                   query_text='SELECT * FROM foo.bar')
                ],
                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')
                ],
                badges=[Badge(badge_name='golden', category='table_status')],
                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=[],
                badges=[],
                last_successful_run_timestamp=None,
                recent_view_count=0)

            self.assertEqual(expected2, dashboard2)