openmetadata-ingestion 1.2.4.0__py3-none-any.whl → 1.3.2.0rc1__py3-none-any.whl

metadata/data_insight/processor/reports/cost_analysis_report_data_processor.py

@@ -18,7 +18,7 @@ from __future__ import annotations
 import traceback
 from collections import defaultdict
 from copy import deepcopy
-from typing import Iterable, Optional
+from typing import Dict, Iterable, Optional
 
 from metadata.data_insight.processor.reports.data_processor import DataProcessor
 from metadata.generated.schema.analytics.reportData import ReportData, ReportDataType
@@ -28,9 +28,11 @@ from metadata.generated.schema.analytics.reportDataType.aggregatedCostAnalysisRe
 from metadata.generated.schema.analytics.reportDataType.rawCostAnalysisReportData import (
     RawCostAnalysisReportData,
 )
-from metadata.generated.schema.entity.data.table import Table
+from metadata.generated.schema.type.entityReference import EntityReference
 from metadata.generated.schema.type.lifeCycle import LifeCycle
 from metadata.ingestion.ometa.ometa_api import OpenMetadata
+from metadata.ingestion.ometa.utils import model_str
+from metadata.utils.constants import ENTITY_REFERENCE_TYPE_MAP
 from metadata.utils.logger import data_insight_logger
 from metadata.utils.time_utils import get_end_of_day_timestamp_mill
 
@@ -98,36 +100,32 @@ class RawCostAnalysisReportDataProcessor(DataProcessor):
                 data=value,
             )  # type: ignore
 
-    def refine(self, entity: Table) -> None:
+    def refine(self, entity: Dict) -> None:
         """Aggregate data
         Returns:
             list:
         """
 
-        try:
-            cost_analysis_data = RawCostAnalysisReportData(
-                entity=self.metadata.get_entity_reference(
-                    entity=type(entity), fqn=entity.fullyQualifiedName
+        for entity_fqn, cost_analysis_report_data in entity.items():
+            try:
+                cost_analysis_data = RawCostAnalysisReportData(
+                    entity=EntityReference(
+                        id=cost_analysis_report_data.entity.id,
+                        fullyQualifiedName=model_str(
+                            cost_analysis_report_data.entity.fullyQualifiedName
+                        ),
+                        type=ENTITY_REFERENCE_TYPE_MAP[
+                            type(cost_analysis_report_data.entity).__name__
+                        ],
+                    ),
+                    lifeCycle=cost_analysis_report_data.life_cycle,
+                    sizeInByte=cost_analysis_report_data.size,
                 )
-            )
-            if entity.lifeCycle:
-                cost_analysis_data.lifeCycle = entity.lifeCycle
-
-            table_profile = self.metadata.get_latest_table_profile(
-                fqn=entity.fullyQualifiedName
-            )
-            if table_profile.profile:
-                cost_analysis_data.sizeInByte = table_profile.profile.sizeInByte
-
-            if cost_analysis_data.lifeCycle or cost_analysis_data.sizeInByte:
-                self._refined_data[
-                    entity.fullyQualifiedName.__root__
-                ] = cost_analysis_data
-
-            self.processor_status.scanned(entity.name.__root__)
-        except Exception as err:
-            logger.debug(traceback.format_exc())
-            logger.error(f"Error trying fetch cost analysis data -- {err}")
+                self._refined_data[entity_fqn] = cost_analysis_data
+                self.processor_status.scanned(entity_fqn)
+            except Exception as err:
+                logger.debug(traceback.format_exc())
+                logger.error(f"Error trying fetch cost analysis data -- {err}")
 
     def get_status(self):
         return self.processor_status
@@ -142,6 +140,7 @@ class AggregatedCostAnalysisReportDataProcessor(DataProcessor):
         super().__init__(metadata)
         self._refined_data = defaultdict(lambda: defaultdict(dict))
         self.post_hook = self._post_hook_fn
+        self.clean_up_cache = True
 
     def yield_refined_data(self) -> Iterable[ReportData]:
         """Yield refined data"""
@@ -152,27 +151,17 @@ class AggregatedCostAnalysisReportDataProcessor(DataProcessor):
                 data=data,
             )  # type: ignore
 
-    def refine(self, entity: Table) -> None:
+    def refine(self, entity: Dict) -> None:
         """Aggregate data
         Returns:
             list:
         """
         try:
-            life_cycle = None
-            if entity.lifeCycle:
-                life_cycle = entity.lifeCycle
-
-            size = None
-            table_profile = self.metadata.get_latest_table_profile(
-                fqn=entity.fullyQualifiedName
-            )
-            if table_profile.profile:
-                size = table_profile.profile.sizeInByte
-
-            if life_cycle or size:
-                entity_type = str(entity.__class__.__name__)
-                service_type = str(entity.serviceType.name)
-                service_name = str(entity.service.name)
+
+            for entity_fqn, cost_analysis_report_data in entity.items():
+                entity_type = str(cost_analysis_report_data.entity.__class__.__name__)
+                service_type = str(cost_analysis_report_data.entity.serviceType.name)
+                service_name = str(cost_analysis_report_data.entity.service.name)
                 if not self._refined_data[str(entity_type)][service_type].get(
                     service_name
                 ):
@@ -185,18 +174,18 @@ class AggregatedCostAnalysisReportDataProcessor(DataProcessor):
                 else:
                     self._refined_data[entity_type][service_type][service_name][
                         TOTAL_SIZE
-                    ] += (size or 0)
+                    ] += (cost_analysis_report_data.size or 0)
                     self._refined_data[entity_type][service_type][service_name][
                         TOTAL_COUNT
                     ] += 1
 
                 self._get_data_assets_dict(
-                    life_cycle=life_cycle,
-                    size=size,
+                    life_cycle=cost_analysis_report_data.life_cycle,
+                    size=cost_analysis_report_data.size,
                     data=self._refined_data[entity_type][service_type][service_name],
                 )
 
-            self.processor_status.scanned(entity.name.__root__)
+                self.processor_status.scanned(entity_fqn)
         except Exception as err:
             logger.debug(traceback.format_exc())
             logger.error(f"Error trying fetch cost analysis data -- {err}")
@@ -241,13 +230,16 @@ class AggregatedCostAnalysisReportDataProcessor(DataProcessor):
         Helper method to calculate number of data assets within time period
         """
         try:
-            if not life_cycle:
+            if not life_cycle or not life_cycle.accessed:
                 return
 
             # Iterate over the different time periods and update the data
             for days, key in DAYS:
                 days_before_timestamp = get_end_of_day_timestamp_mill(days=days)
-                if life_cycle.accessed.timestamp.__root__ <= days_before_timestamp:
+                if (
+                    life_cycle.accessed
+                    and life_cycle.accessed.timestamp.__root__ <= days_before_timestamp
+                ):
                     data[UNUSED_DATA_ASSETS][COUNT][key] += 1
                     data[UNUSED_DATA_ASSETS][SIZE][key] += size or 0
                 else:

metadata/data_insight/processor/reports/data_processor.py

@@ -47,6 +47,7 @@ class DataProcessor(abc.ABC):
         self._refined_data = {}
         self.post_hook: Optional[Callable] = None
         self.pre_hook: Optional[Callable] = None
+        self.clean_up_cache: bool = False
 
     @classmethod
     def create(cls, _data_processor_type, metadata: OpenMetadata):

metadata/data_insight/processor/reports/entity_report_data_processor.py

@@ -38,10 +38,12 @@ from metadata.generated.schema.entity.data import (
     table,
     topic,
 )
+from metadata.generated.schema.entity.services.ingestionPipelines.status import (
+    StackTraceError,
+)
 from metadata.generated.schema.entity.teams.user import User
 from metadata.generated.schema.type.entityReference import EntityReference
 from metadata.generated.schema.type.entityReferenceList import EntityReferenceList
-from metadata.ingestion.api.models import StackTraceError
 from metadata.ingestion.ometa.ometa_api import OpenMetadata
 from metadata.utils.helpers import get_entity_tier_from_tags
 from metadata.utils.logger import data_insight_logger
@@ -75,6 +77,10 @@ class EntityReportDataProcessor(DataProcessor):
         self._refined_data = defaultdict(lambda: defaultdict(lambda: defaultdict(dict)))
         self.post_hook = self._post_hook_fn
 
+    @property
+    def name(self) -> str:
+        return "Entity Report Processor"
+
     def _get_team(self, owner: EntityReference) -> Optional[str]:
         """Get the team from an entity. We'll use this info as well to
         add info if an entity has an owner
@@ -191,7 +197,7 @@ class EntityReportDataProcessor(DataProcessor):
                 StackTraceError(
                     name=entity.name.__root__,
                     error="Error retrieving team",
-                    stack_trace=traceback.format_exc(),
+                    stackTrace=traceback.format_exc(),
                 )
             )
             raise

metadata/data_insight/processor/reports/web_analytic_report_data_processor.py

@@ -78,6 +78,10 @@ class WebAnalyticEntityViewReportDataProcessor(DataProcessor):
         super().__init__(metadata)
         self.pre_hook = self._pre_hook_fn
 
+    @property
+    def name(self) -> str:
+        return "Web Analytics Processor"
+
     def _pre_hook_fn(self):
         """Start our generator function"""
         # pylint: disable=attribute-defined-outside-init

metadata/data_insight/producer/cost_analysis_producer.py

@@ -13,16 +13,31 @@ Producer class for data insight entity reports
 """
 
 import traceback
-from typing import Iterable
+from typing import Dict, Iterable, Optional
+
+from pydantic import BaseModel
 
 from metadata.data_insight.producer.producer_interface import ProducerInterface
 from metadata.generated.schema.entity.data.table import Table
 from metadata.generated.schema.entity.services.databaseService import DatabaseService
+from metadata.generated.schema.type.lifeCycle import LifeCycle
+from metadata.ingestion.api.models import Entity
+from metadata.ingestion.ometa.utils import model_str
 from metadata.utils.logger import data_insight_logger
 
 logger = data_insight_logger()
 
 
+class CostAnalysisReportData(BaseModel):
+    """
+    Query executed get life cycle
+    """
+
+    entity: Entity
+    life_cycle: Optional[LifeCycle]
+    size: Optional[float]
+
+
 class CostAnalysisProducer(ProducerInterface):
     """entity producer class"""
 
@@ -36,27 +51,76 @@ class CostAnalysisProducer(ProducerInterface):
             and database_service.connection.config.supportsProfiler.__root__
         )
 
+    def _check_life_cycle_and_size_data(
+        self, table: Table
+    ) -> Optional[CostAnalysisReportData]:
+        """
+        Method to check if the valid life cycle and table size data is present for the table
+        """
+        cost_analysis_report_data = CostAnalysisReportData(entity=table)
+        if table.lifeCycle and table.lifeCycle.accessed:
+            cost_analysis_report_data.life_cycle = table.lifeCycle
+
+        table_profile = self.metadata.get_latest_table_profile(
+            fqn=table.fullyQualifiedName
+        )
+        if table_profile.profile:
+            cost_analysis_report_data.size = table_profile.profile.sizeInByte
+
+        if cost_analysis_report_data.life_cycle or cost_analysis_report_data.size:
+            return cost_analysis_report_data
+        return None
+
+    def life_cycle_data_dict(
+        self, entities_cache: Optional[Dict], database_service_fqn: str
+    ) -> Iterable[Dict]:
+        """
+        Cache the required lifecycle data to be used by the processors and return the dict
+        """
+        if entities_cache.get(database_service_fqn):
+            yield entities_cache[database_service_fqn]
+        else:
+            tables = self.metadata.list_all_entities(
+                Table,
+                limit=100,
+                skip_on_failure=True,
+                params={"database": database_service_fqn},
+            )
+            entities_cache[database_service_fqn] = {}
+
+            for table in tables:
+                try:
+                    cost_analysis_data = self._check_life_cycle_and_size_data(
+                        table=table
+                    )
+                    if cost_analysis_data:
+                        entities_cache[database_service_fqn][
+                            model_str(table.fullyQualifiedName)
+                        ] = cost_analysis_data
+                except Exception as err:
+                    logger.error(
+                        f"Error trying to fetch cost analysis data for [{model_str(table.fullyQualifiedName)}] -- {err}"
+                    )
+                    logger.debug(traceback.format_exc())
+
+            yield entities_cache[database_service_fqn]
+
     # pylint: disable=dangerous-default-value
-    def fetch_data(self, limit=100, fields=["*"]) -> Iterable:
+    def fetch_data(
+        self, limit=100, fields=["*"], entities_cache=None
+    ) -> Optional[Iterable[Dict]]:
         database_services = self.metadata.list_all_entities(
             DatabaseService, limit=limit, fields=fields, skip_on_failure=True
         )
-        entities_list = []
         for database_service in database_services or []:
             try:
                 if self._check_profiler_and_usage_support(database_service):
-                    entities_list.extend(
-                        self.metadata.list_all_entities(
-                            Table,
-                            limit=limit,
-                            fields=fields,
-                            skip_on_failure=True,
-                            params={
-                                "database": database_service.fullyQualifiedName.__root__
-                            },
-                        )
+                    yield from self.life_cycle_data_dict(
+                        entities_cache=entities_cache,
+                        database_service_fqn=model_str(
+                            database_service.fullyQualifiedName
+                        ),
                     )
             except Exception as err:
                 logger.error(f"Error trying to fetch entities -- {err}")
                 logger.debug(traceback.format_exc())
-        return entities_list

metadata/data_insight/producer/entity_producer.py

@@ -52,7 +52,7 @@ class EntityProducer(ProducerInterface):
     ]
 
     # pylint: disable=dangerous-default-value
-    def fetch_data(self, limit=100, fields=["*"]) -> Iterable:
+    def fetch_data(self, limit=100, fields=["*"], entities_cache=None) -> Iterable:
         for entity in self.entities:
             try:
                 yield from self.metadata.list_all_entities(

metadata/data_insight/producer/producer_interface.py

@@ -24,6 +24,6 @@ class ProducerInterface(ABC):
         self.metadata = metadata
 
     @abstractmethod
-    def fetch_data(self, limit, fields):
+    def fetch_data(self, limit, fields, entities_cache=None):
         """fetch data from source"""
         raise NotImplementedError

metadata/data_insight/producer/web_analytics_producer.py

@@ -75,7 +75,7 @@ class WebAnalyticsProducer(ProducerInterface):
         CACHED_EVENTS.clear()
 
     def fetch_data(
-        self, limit=100, fields=["*"]
+        self, limit=100, fields=["*"], entities_cache=None
     ):  # pylint: disable=dangerous-default-value
         """fetch data for web analytics event"""
         events = self._get_events(None, limit, fields)

metadata/data_insight/source/metadata.py

@@ -33,7 +33,10 @@ from metadata.data_insight.processor.reports.web_analytic_report_data_processor
 )
 from metadata.data_insight.producer.producer_factory import producer_factory
 from metadata.generated.schema.analytics.reportData import ReportData, ReportDataType
-from metadata.ingestion.api.models import Either, StackTraceError
+from metadata.generated.schema.entity.services.ingestionPipelines.status import (
+    StackTraceError,
+)
+from metadata.ingestion.api.models import Either
 from metadata.ingestion.api.step import Step
 from metadata.ingestion.api.steps import Source
 from metadata.ingestion.ometa.ometa_api import OpenMetadata
@@ -71,6 +74,7 @@ class DataInsightSource(Source):
         super().__init__()
         self.metadata = metadata
         self.date = datetime.utcnow().strftime("%Y-%m-%d")
+        self.entities_cache = {}
 
         _processors = self._instantiate_processors()
         self._processors: Dict[
@@ -87,9 +91,13 @@ class DataInsightSource(Source):
             _processors
         )  # make an immutable copy of the dict
 
+    @property
+    def name(self) -> str:
+        return "OpenMetadata Insights"
+
     @property
     def processors(self) -> Dict[str, Optional[DataProcessor]]:
-        """dictionnaray of processors"""
+        """dictionary of processors"""
         return self._processors
 
     def _instantiate_processors(self) -> Dict[str, DataProcessor]:
@@ -123,11 +131,19 @@ class DataInsightSource(Source):
                 processor = cast(DataProcessor, processor)
                 processor.pre_hook() if processor.pre_hook else None  # pylint: disable=expression-not-assigned
 
-                for data in producer.fetch_data(fields=["owner", "tags"]):
+                for data in (
+                    producer.fetch_data(
+                        fields=["owner", "tags"], entities_cache=self.entities_cache
+                    )
+                    or []
+                ):
                     processor.refine(data)
 
                 processor.post_hook() if processor.post_hook else None  # pylint: disable=expression-not-assigned
 
+                if processor.clean_up_cache:
+                    self.entities_cache.clear()
+
                 for data in processor.yield_refined_data():
                     yield Either(left=None, right=DataInsightRecord(data=data))
             except KeyError as key_error:
@@ -136,7 +152,7 @@ class DataInsightSource(Source):
                         name=report_data_type.value,
                         error=f"Error retrieving processor with exception [{key_error}]."
                         "Available processors are {self.processors}",
-                        stack_trace=traceback.format_exc(),
+                        stackTrace=traceback.format_exc(),
                     ),
                     right=None,
                 )
@@ -145,7 +161,7 @@ class DataInsightSource(Source):
                     left=StackTraceError(
                         name=report_data_type.value,
                         error=f"Error listing data for report with exception [{exc}]",
-                        stack_trace=traceback.format_exc(),
+                        stackTrace=traceback.format_exc(),
                     ),
                     right=None,
                 )

metadata/data_quality/interface/sqlalchemy/databricks/test_suite_interface.py

@@ -0,0 +1,29 @@
+#  Copyright 2021 Collate
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#  http://www.apache.org/licenses/LICENSE-2.0
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+
+"""
+Interfaces with database for all database engine
+supporting sqlalchemy abstraction layer
+"""
+
+
+from metadata.data_quality.interface.sqlalchemy.sqa_test_suite_interface import (
+    SQATestSuiteInterface,
+)
+
+
+class DatabricksTestSuiteInterface(SQATestSuiteInterface):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+
+    def create_session(self):
+        super().create_session()
+        self.set_catalog(self.session)

metadata/data_quality/interface/sqlalchemy/snowflake/test_suite_interface.py

@@ -0,0 +1,29 @@
+#  Copyright 2021 Collate
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#  http://www.apache.org/licenses/LICENSE-2.0
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+
+"""
+Interfaces with database for all database engine
+supporting sqlalchemy abstraction layer
+"""
+
+
+from metadata.data_quality.interface.sqlalchemy.sqa_test_suite_interface import (
+    SQATestSuiteInterface,
+)
+
+
+class SnowflakeTestSuiteInterface(SQATestSuiteInterface):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+
+    def create_session(self):
+        super().create_session()
+        self.set_session_tag(self.session)

metadata/data_quality/interface/sqlalchemy/sqa_test_suite_interface.py

@@ -58,12 +58,7 @@ class SQATestSuiteInterface(SQAInterfaceMixin, TestSuiteInterface):
         self.ometa_client = ometa_client
         self.table_entity = table_entity
         self.service_connection_config = service_connection_config
-        self.session = create_and_bind_session(
-            get_connection(self.service_connection_config)
-        )
-        self.set_session_tag(self.session)
-        self.set_catalog(self.session)
-
+        self.create_session()
         self._table = self._convert_table_to_orm_object(sqa_metadata)
 
         (
@@ -75,6 +70,11 @@ class SQATestSuiteInterface(SQAInterfaceMixin, TestSuiteInterface):
         self._sampler = self._create_sampler()
         self._runner = self._create_runner()
 
+    def create_session(self):
+        self.session = create_and_bind_session(
+            get_connection(self.service_connection_config)
+        )
+
     @property
     def sample(self) -> Union[DeclarativeMeta, AliasedClass]:
         """_summary_

metadata/data_quality/interface/sqlalchemy/unity_catalog/test_suite_interface.py

@@ -0,0 +1,35 @@
+#  Copyright 2021 Collate
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#  http://www.apache.org/licenses/LICENSE-2.0
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+
+"""
+Interfaces with database for all database engine
+supporting sqlalchemy abstraction layer
+"""
+
+
+from metadata.data_quality.interface.sqlalchemy.sqa_test_suite_interface import (
+    SQATestSuiteInterface,
+)
+from metadata.ingestion.connections.session import create_and_bind_session
+from metadata.ingestion.source.database.databricks.connection import (
+    get_connection as databricks_get_connection,
+)
+
+
+class UnityCatalogTestSuiteInterface(SQATestSuiteInterface):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+
+    def create_session(self):
+        self.session = create_and_bind_session(
+            databricks_get_connection(self.service_connection_config)
+        )
+        self.set_catalog(self.session)

metadata/data_quality/interface/test_suite_interface_factory.py

@@ -17,14 +17,32 @@ from logging import Logger
 from metadata.data_quality.interface.pandas.pandas_test_suite_interface import (
     PandasTestSuiteInterface,
 )
+from metadata.data_quality.interface.sqlalchemy.databricks.test_suite_interface import (
+    DatabricksTestSuiteInterface,
+)
+from metadata.data_quality.interface.sqlalchemy.snowflake.test_suite_interface import (
+    SnowflakeTestSuiteInterface,
+)
 from metadata.data_quality.interface.sqlalchemy.sqa_test_suite_interface import (
     SQATestSuiteInterface,
 )
+from metadata.data_quality.interface.sqlalchemy.unity_catalog.test_suite_interface import (
+    UnityCatalogTestSuiteInterface,
+)
 from metadata.data_quality.interface.test_suite_interface import TestSuiteInterface
 from metadata.generated.schema.entity.data.table import Table
+from metadata.generated.schema.entity.services.connections.database.databricksConnection import (
+    DatabricksConnection,
+)
 from metadata.generated.schema.entity.services.connections.database.datalakeConnection import (
     DatalakeConnection,
 )
+from metadata.generated.schema.entity.services.connections.database.snowflakeConnection import (
+    SnowflakeConnection,
+)
+from metadata.generated.schema.entity.services.connections.database.unityCatalogConnection import (
+    UnityCatalogConnection,
+)
 from metadata.generated.schema.entity.services.databaseService import DatabaseConnection
 from metadata.ingestion.ometa.ometa_api import OpenMetadata
 from metadata.utils.logger import test_suite_logger
@@ -51,6 +69,17 @@ class TestSuiteInterfaceFactory:
         """
         self._interface_type[interface_type] = interface
 
+    def register_many(self, interface_dict):
+        """
+        Registers multiple profiler interfaces at once.
+
+        Args:
+            interface_dict: A dictionary mapping connection class names (strings) to their
+            corresponding profiler interface classes.
+        """
+        for interface_type, interface_class in interface_dict.items():
+            self.register(interface_type, interface_class)
+
     def create(
         self,
         service_connection_config: DatabaseConnection,
@@ -86,3 +115,14 @@ class TestSuiteInterfaceFactory:
 
 
 test_suite_interface_factory = TestSuiteInterfaceFactory()
+
+
+test_suite_interface = {
+    DatabaseConnection.__name__: SQATestSuiteInterface,
+    DatalakeConnection.__name__: PandasTestSuiteInterface,
+    SnowflakeConnection.__name__: SnowflakeTestSuiteInterface,
+    UnityCatalogConnection.__name__: UnityCatalogTestSuiteInterface,
+    DatabricksConnection.__name__: DatabricksTestSuiteInterface,
+}
+
+test_suite_interface_factory.register_many(test_suite_interface)