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

metadata/ingestion/ometa/mixins/suggestions_mixin.py

@@ -0,0 +1,41 @@
+#  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.
+"""
+Mixin class containing Suggestions specific methods
+
+To be used by OpenMetadata class
+"""
+from metadata.generated.schema.entity.feed.suggestion import Suggestion
+from metadata.ingestion.ometa.client import REST
+from metadata.utils.logger import ometa_logger
+
+logger = ometa_logger()
+
+
+class OMetaSuggestionsMixin:
+    """
+    OpenMetadata API methods related to the Suggestion Entity
+
+    To be inherited by OpenMetadata
+    """
+
+    client: REST
+
+    def update_suggestion(self, suggestion: Suggestion) -> Suggestion:
+        """
+        Update an existing Suggestion with new fields
+        """
+        resp = self.client.put(
+            f"{self.get_suffix(Suggestion)}/{str(suggestion.id.__root__)}",
+            data=suggestion.json(),
+        )
+
+        return Suggestion(**resp)

metadata/ingestion/ometa/mixins/table_mixin.py

@@ -22,6 +22,9 @@ from requests.utils import quote
 from metadata.generated.schema.api.data.createTableProfile import (
     CreateTableProfileRequest,
 )
+from metadata.generated.schema.api.tests.createCustomMetric import (
+    CreateCustomMetricRequest,
+)
 from metadata.generated.schema.entity.data.table import (
     ColumnProfile,
     DataModel,
@@ -288,3 +291,18 @@ class OMetaTableMixin:
             Optional[Table]: OM table object
         """
         return self._get(Table, f"{quote(model_str(fqn))}/tableProfile/latest")
+
+    def create_or_update_custom_metric(
+        self, custom_metric: CreateCustomMetricRequest, table_id: str
+    ) -> Table:
+        """Create or update custom metric. If custom metric name matches an existing
+        one then it will be updated.
+
+        Args:
+            custom_metric (CreateCustomMetricRequest): custom metric to be create or updated
+        """
+        resp = self.client.put(
+            f"{self.get_suffix(Table)}/{table_id}/customMetric",
+            data=custom_metric.json(),
+        )
+        return Table(**resp)

metadata/ingestion/ometa/mixins/tests_mixin.py

@@ -23,6 +23,9 @@ from metadata.generated.schema.api.tests.createLogicalTestCases import (
     CreateLogicalTestCases,
 )
 from metadata.generated.schema.api.tests.createTestCase import CreateTestCaseRequest
+from metadata.generated.schema.api.tests.createTestCaseResolutionStatus import (
+    CreateTestCaseResolutionStatus,
+)
 from metadata.generated.schema.api.tests.createTestDefinition import (
     CreateTestDefinitionRequest,
 )
@@ -30,6 +33,9 @@ from metadata.generated.schema.api.tests.createTestSuite import CreateTestSuiteR
 from metadata.generated.schema.entity.data.table import Table
 from metadata.generated.schema.tests.basic import TestCaseResult
 from metadata.generated.schema.tests.testCase import TestCase, TestCaseParameterValue
+from metadata.generated.schema.tests.testCaseResolutionStatus import (
+    TestCaseResolutionStatus,
+)
 from metadata.generated.schema.tests.testDefinition import (
     EntityType,
     TestCaseParameterDefinition,
@@ -242,10 +248,9 @@ class OMetaTestsMixin:
             end_ts (int): timestamp
         """
 
-        # timestamp should be changed to milliseconds in https://github.com/open-metadata/OpenMetadata/issues/8930
         params = {
-            "startTs": start_ts // 1000,
-            "endTs": end_ts // 1000,
+            "startTs": start_ts,
+            "endTs": end_ts,
         }
 
         resp = self.client.get(
@@ -302,3 +307,19 @@ class OMetaTestsMixin:
         """
         path = self.get_suffix(TestCase) + "/logicalTestCases"
         self.client.put(path, data=data.json(encoder=show_secrets_encoder))
+
+    def create_test_case_resolution(
+        self, data: CreateTestCaseResolutionStatus
+    ) -> TestCaseResolutionStatus:
+        """Create a test case resolution
+
+        Args:
+            data (CreateTestCaseResolutionStatus): test case resolution
+
+        Returns:
+            TestCaseResolutionStatus
+        """
+        path = self.get_suffix(TestCase) + "/testCaseIncidentStatus"
+        response = self.client.post(path, data=data.json(encoder=show_secrets_encoder))
+
+        return TestCaseResolutionStatus(**response)

metadata/ingestion/ometa/mixins/user_mixin.py

@@ -13,12 +13,15 @@ Mixin class containing User specific methods
 
 To be used by OpenMetadata class
 """
-import traceback
 from functools import lru_cache
-from typing import Optional
+from typing import Optional, Type
 
+from metadata.generated.schema.entity.teams.team import Team
 from metadata.generated.schema.entity.teams.user import User
+from metadata.generated.schema.type.entityReference import EntityReference
+from metadata.ingestion.api.common import T
 from metadata.ingestion.ometa.client import REST
+from metadata.utils.constants import ENTITY_REFERENCE_TYPE_MAP
 from metadata.utils.elasticsearch import ES_INDEX_MAP
 from metadata.utils.logger import ometa_logger
 
@@ -34,42 +37,134 @@ class OMetaUserMixin:
 
     client: REST
 
-    email_search = (
-        "/search/query?q=email.keyword:{email}&from={from_}&size={size}&index="
-        + ES_INDEX_MAP[User.__name__]
-    )
+    @staticmethod
+    def email_search_query_es(entity: Type[T]) -> str:
+        return (
+            "/search/query?q=email.keyword:{email}&from={from_}&size={size}&index="
+            + ES_INDEX_MAP[entity.__name__]
+        )
 
-    @lru_cache(maxsize=None)
-    def get_user_by_email(
+    @staticmethod
+    def name_search_query_es(entity: Type[T]) -> str:
+        """
+        Allow for more flexible lookup following what the UI is doing when searching users.
+
+        We don't want to stick to `q=name:{name}` since in case a user is named `random.user`
+        but looked as `Random User`, we want to find this match.
+        """
+        return (
+            "/search/query?q={name}&from={from_}&size={size}&index="
+            + ES_INDEX_MAP[entity.__name__]
+        )
+
+    def _search_by_email(
         self,
+        entity: Type[T],
         email: Optional[str],
         from_count: int = 0,
         size: int = 1,
         fields: Optional[list] = None,
-    ) -> Optional[User]:
+    ) -> Optional[T]:
         """
-        GET user entity by name
+        GET user or team entity by mail
 
         Args:
             email: user email to search
             from_count: records to expect
             size: number of records
+            fields: Optional field list to pass to ES request
         """
         if email:
-            query_string = self.email_search.format(
+            query_string = self.email_search_query_es(entity=entity).format(
                 email=email, from_=from_count, size=size
             )
+            return self._get_entity_from_es(
+                entity=entity, query_string=query_string, fields=fields
+            )
+
+        return None
+
+    def _search_by_name(
+        self,
+        entity: Type[T],
+        name: Optional[str],
+        from_count: int = 0,
+        size: int = 1,
+        fields: Optional[list] = None,
+    ) -> Optional[T]:
+        """
+        GET entity by name
+
+        Args:
+            name: user name to search
+            from_count: records to expect
+            size: number of records
+            fields: Optional field list to pass to ES request
+        """
+        if name:
+            query_string = self.name_search_query_es(entity=entity).format(
+                name=name, from_=from_count, size=size
+            )
+            return self._get_entity_from_es(
+                entity=entity, query_string=query_string, fields=fields
+            )
 
-            try:
-                entity_list = self._search_es_entity(
-                    entity_type=User, query_string=query_string, fields=fields
-                )
-                for user in entity_list or []:
-                    return user
-            except Exception as err:
-                logger.debug(traceback.format_exc())
-                logger.warning(
-                    f"Could not get user info from ES for user email {email} due to {err}"
-                )
+        return None
+
+    @lru_cache(maxsize=None)
+    def get_reference_by_email(
+        self,
+        email: Optional[str],
+        from_count: int = 0,
+        size: int = 1,
+        fields: Optional[list] = None,
+    ) -> Optional[EntityReference]:
+        """
+        Get a User or Team Entity Reference by searching by its mail
+        """
+        maybe_user = self._search_by_email(
+            entity=User, email=email, from_count=from_count, size=size, fields=fields
+        )
+        if maybe_user:
+            return EntityReference(
+                id=maybe_user.id.__root__, type=ENTITY_REFERENCE_TYPE_MAP[User.__name__]
+            )
+
+        maybe_team = self._search_by_email(
+            entity=Team, email=email, from_count=from_count, size=size, fields=fields
+        )
+        if maybe_team:
+            return EntityReference(
+                id=maybe_team.id.__root__, type=ENTITY_REFERENCE_TYPE_MAP[Team.__name__]
+            )
+
+        return None
+
+    @lru_cache(maxsize=None)
+    def get_reference_by_name(
+        self,
+        name: Optional[str],
+        from_count: int = 0,
+        size: int = 1,
+        fields: Optional[list] = None,
+    ) -> Optional[EntityReference]:
+        """
+        Get a User or Team Entity Reference by searching by its name
+        """
+        maybe_user = self._search_by_name(
+            entity=User, name=name, from_count=from_count, size=size, fields=fields
+        )
+        if maybe_user:
+            return EntityReference(
+                id=maybe_user.id.__root__, type=ENTITY_REFERENCE_TYPE_MAP[User.__name__]
+            )
+
+        maybe_team = self._search_by_name(
+            entity=Team, name=name, from_count=from_count, size=size, fields=fields
+        )
+        if maybe_team:
+            return EntityReference(
+                id=maybe_team.id.__root__, type=ENTITY_REFERENCE_TYPE_MAP[Team.__name__]
+            )
 
         return None

metadata/ingestion/ometa/ometa_api.py

@@ -31,7 +31,7 @@ from metadata.generated.schema.type.basic import FullyQualifiedEntityName
 from metadata.generated.schema.type.entityHistory import EntityVersionHistory
 from metadata.generated.schema.type.entityReference import EntityReference
 from metadata.ingestion.models.encoders import show_secrets_encoder
-from metadata.ingestion.ometa.auth_provider import AuthenticationProvider
+from metadata.ingestion.ometa.auth_provider import OpenMetadataAuthenticationProvider
 from metadata.ingestion.ometa.client import REST, APIError, ClientConfig
 from metadata.ingestion.ometa.mixins.custom_property_mixin import (
     OMetaCustomPropertyMixin,
@@ -39,7 +39,6 @@ from metadata.ingestion.ometa.mixins.custom_property_mixin import (
 from metadata.ingestion.ometa.mixins.dashboard_mixin import OMetaDashboardMixin
 from metadata.ingestion.ometa.mixins.data_insight_mixin import DataInsightMixin
 from metadata.ingestion.ometa.mixins.es_mixin import ESMixin
-from metadata.ingestion.ometa.mixins.glossary_mixin import GlossaryMixin
 from metadata.ingestion.ometa.mixins.ingestion_pipeline_mixin import (
     OMetaIngestionPipelineMixin,
 )
@@ -51,16 +50,13 @@ from metadata.ingestion.ometa.mixins.role_policy_mixin import OMetaRolePolicyMix
 from metadata.ingestion.ometa.mixins.search_index_mixin import OMetaSearchIndexMixin
 from metadata.ingestion.ometa.mixins.server_mixin import OMetaServerMixin
 from metadata.ingestion.ometa.mixins.service_mixin import OMetaServiceMixin
+from metadata.ingestion.ometa.mixins.suggestions_mixin import OMetaSuggestionsMixin
 from metadata.ingestion.ometa.mixins.table_mixin import OMetaTableMixin
 from metadata.ingestion.ometa.mixins.tests_mixin import OMetaTestsMixin
 from metadata.ingestion.ometa.mixins.topic_mixin import OMetaTopicMixin
 from metadata.ingestion.ometa.mixins.user_mixin import OMetaUserMixin
 from metadata.ingestion.ometa.mixins.version_mixin import OMetaVersionMixin
 from metadata.ingestion.ometa.models import EntityList
-from metadata.ingestion.ometa.provider_registry import (
-    InvalidAuthProviderException,
-    auth_provider_registry,
-)
 from metadata.ingestion.ometa.routes import ROUTES
 from metadata.ingestion.ometa.utils import get_entity_type, model_str
 from metadata.utils.logger import ometa_logger
@@ -100,7 +96,6 @@ class OpenMetadata(
     OMetaTableMixin,
     OMetaTopicMixin,
     OMetaVersionMixin,
-    GlossaryMixin,
     OMetaServiceMixin,
     ESMixin,
     OMetaServerMixin,
@@ -114,6 +109,7 @@ class OpenMetadata(
     OMetaRolePolicyMixin,
     OMetaSearchIndexMixin,
     OMetaCustomPropertyMixin,
+    OMetaSuggestionsMixin,
     Generic[T, C],
 ):
     """
@@ -125,7 +121,7 @@ class OpenMetadata(
     """
 
     client: REST
-    _auth_provider: AuthenticationProvider
+    _auth_provider: OpenMetadataAuthenticationProvider
     config: OpenMetadataConnection
 
     class_root = ".".join(["metadata", "generated", "schema"])
@@ -146,16 +142,7 @@ class OpenMetadata(
             config.secretsManagerLoader,
         ).get_secrets_manager()
 
-        # Load the auth provider init from the registry
-        auth_provider_fn = auth_provider_registry.registry.get(
-            self.config.authProvider.value
-        )
-        if not auth_provider_fn:
-            raise InvalidAuthProviderException(
-                f"Cannot find {self.config.authProvider.value} in {auth_provider_registry.registry}"
-            )
-
-        self._auth_provider = auth_provider_fn(self.config)
+        self._auth_provider = OpenMetadataAuthenticationProvider.create(self.config)
 
         get_verify_ssl = get_verify_ssl_fn(self.config.verifySSL)
 
@@ -261,11 +248,9 @@ class OpenMetadata(
         )
         return entity_class
 
-    def create_or_update(self, data: C) -> T:
+    def _create(self, data: C, method: str) -> T:
         """
-        We allow CreateEntity for PUT, so we expect a type C.
-
-        We PUT to the endpoint and return the Entity generated result
+        Internal logic to run POST vs. PUT
         """
         entity = data.__class__
         is_create = "create" in data.__class__.__name__.lower()
@@ -277,15 +262,23 @@ class OpenMetadata(
             raise InvalidEntityException(
                 f"PUT operations need a CreateEntity, not {entity}"
             )
-        resp = self.client.put(
-            self.get_suffix(entity), data=data.json(encoder=show_secrets_encoder)
-        )
+
+        fn = getattr(self.client, method)
+        resp = fn(self.get_suffix(entity), data=data.json(encoder=show_secrets_encoder))
         if not resp:
             raise EmptyPayloadException(
                 f"Got an empty response when trying to PUT to {self.get_suffix(entity)}, {data.json()}"
             )
         return entity_class(**resp)
 
+    def create_or_update(self, data: C) -> T:
+        """Run a PUT requesting via create request C"""
+        return self._create(data=data, method="put")
+
+    def create(self, data: C) -> T:
+        """Run a POST requesting via create request C"""
+        return self._create(data=data, method="post")
+
     def get_by_name(
         self,
         entity: Type[T],
@@ -425,7 +418,7 @@ class OpenMetadata(
         self,
         entity: Type[T],
         fields: Optional[List[str]] = None,
-        limit: int = 1000,
+        limit: int = 100,
         params: Optional[Dict[str, str]] = None,
         skip_on_failure: bool = False,
     ) -> Iterable[T]:

metadata/ingestion/ometa/routes.py

@@ -50,6 +50,7 @@ from metadata.generated.schema.api.domains.createDataProduct import (
     CreateDataProductRequest,
 )
 from metadata.generated.schema.api.domains.createDomain import CreateDomainRequest
+from metadata.generated.schema.api.feed.createSuggestion import CreateSuggestionRequest
 from metadata.generated.schema.api.lineage.addLineage import AddLineageRequest
 from metadata.generated.schema.api.policies.createPolicy import CreatePolicyRequest
 from metadata.generated.schema.api.services.createDashboardService import (
@@ -90,6 +91,7 @@ from metadata.generated.schema.api.tests.createTestSuite import CreateTestSuiteR
 from metadata.generated.schema.dataInsight.dataInsightChart import DataInsightChart
 from metadata.generated.schema.dataInsight.kpi.kpi import Kpi
 from metadata.generated.schema.entity.automations.workflow import Workflow
+from metadata.generated.schema.entity.bot import Bot
 from metadata.generated.schema.entity.classification.classification import (
     Classification,
 )
@@ -113,6 +115,7 @@ from metadata.generated.schema.entity.data.table import Table
 from metadata.generated.schema.entity.data.topic import Topic
 from metadata.generated.schema.entity.domains.dataProduct import DataProduct
 from metadata.generated.schema.entity.domains.domain import Domain
+from metadata.generated.schema.entity.feed.suggestion import Suggestion
 from metadata.generated.schema.entity.policies.policy import Policy
 from metadata.generated.schema.entity.services.connections.testConnectionDefinition import (
     TestConnectionDefinition,
@@ -181,6 +184,7 @@ ROUTES = {
     User.__name__: "/users",
     CreateUserRequest.__name__: "/users",
     AuthenticationMechanism.__name__: "/users/auth-mechanism",
+    Bot.__name__: "/bots",  # We won't allow bot creation from the client
     # Roles
     Role.__name__: "/roles",
     CreateRoleRequest.__name__: "/roles",
@@ -225,4 +229,7 @@ ROUTES = {
     CreateDomainRequest.__name__: "/domains",
     DataProduct.__name__: "/dataProducts",
     CreateDataProductRequest.__name__: "/dataProducts",
+    # Suggestions
+    Suggestion.__name__: "/suggestions",
+    CreateSuggestionRequest.__name__: "/suggestions",
 }

metadata/ingestion/processor/query_parser.py

@@ -17,10 +17,13 @@ import traceback
 from typing import Optional
 
 from metadata.config.common import ConfigModel
+from metadata.generated.schema.entity.services.ingestionPipelines.status import (
+    StackTraceError,
+)
 from metadata.generated.schema.type.basic import DateTime
 from metadata.generated.schema.type.queryParserData import ParsedData, QueryParserData
 from metadata.generated.schema.type.tableQuery import TableQueries, TableQuery
-from metadata.ingestion.api.models import Either, StackTraceError
+from metadata.ingestion.api.models import Either
 from metadata.ingestion.api.steps import Processor
 from metadata.ingestion.lineage.models import ConnectionTypeDialectMapper, Dialect
 from metadata.ingestion.lineage.parser import LineageParser
@@ -84,6 +87,10 @@ class QueryParserProcessor(Processor):
         self.metadata = metadata
         self.connection_type = connection_type
 
+    @property
+    def name(self) -> str:
+        return "Query Parser"
+
     @classmethod
     def create(cls, config_dict: dict, metadata: OpenMetadata, **kwargs):
         config = ConfigModel.parse_obj(config_dict)
@@ -106,7 +113,7 @@ class QueryParserProcessor(Processor):
                         left=StackTraceError(
                             name="Query",
                             error=f"Error processing query [{table_query.query}]: {exc}",
-                            stack_trace=traceback.format_exc(),
+                            stackTrace=traceback.format_exc(),
                         )
                     )
 

metadata/ingestion/sink/metadata_rest.py

@@ -47,6 +47,9 @@ from metadata.generated.schema.entity.teams.team import Team
 from metadata.generated.schema.entity.teams.user import User
 from metadata.generated.schema.tests.basic import TestCaseResult
 from metadata.generated.schema.tests.testCase import TestCase
+from metadata.generated.schema.tests.testCaseResolutionStatus import (
+    TestCaseResolutionStatus,
+)
 from metadata.generated.schema.tests.testSuite import TestSuite
 from metadata.generated.schema.type.schema import Topic
 from metadata.ingestion.api.models import Either, Entity, StackTraceError
@@ -59,7 +62,9 @@ from metadata.ingestion.models.ometa_classification import OMetaTagAndClassifica
 from metadata.ingestion.models.ometa_topic_data import OMetaTopicSampleData
 from metadata.ingestion.models.patch_request import (
     ALLOWED_COMMON_PATCH_FIELDS,
+    ARRAY_ENTITY_FIELDS,
     RESTRICT_UPDATE_LIST,
+    PatchedEntity,
     PatchRequest,
 )
 from metadata.ingestion.models.pipeline_status import OMetaPipelineStatus
@@ -67,6 +72,7 @@ from metadata.ingestion.models.profile_data import OMetaTableProfileSampleData
 from metadata.ingestion.models.search_index_data import OMetaIndexSampleData
 from metadata.ingestion.models.tests_data import (
     OMetaLogicalTestSuiteSample,
+    OMetaTestCaseResolutionStatus,
     OMetaTestCaseResultsSample,
     OMetaTestCaseSample,
     OMetaTestSuiteSample,
@@ -77,7 +83,7 @@ from metadata.ingestion.ometa.ometa_api import OpenMetadata
 from metadata.ingestion.source.dashboard.dashboard_service import DashboardUsage
 from metadata.ingestion.source.database.database_service import DataModelLink
 from metadata.profiler.api.models import ProfilerResponse
-from metadata.utils.helpers import calculate_execution_time
+from metadata.utils.execution_time_tracker import calculate_execution_time
 from metadata.utils.logger import get_log_name, ingestion_logger
 
 logger = ingestion_logger()
@@ -115,12 +121,16 @@ class MetadataRestSink(Sink):  # pylint: disable=too-many-public-methods
         config = MetadataRestSinkConfig.parse_obj(config_dict)
         return cls(config, metadata)
 
+    @property
+    def name(self) -> str:
+        return "OpenMetadata"
+
     @singledispatchmethod
     def _run_dispatch(self, record: Entity) -> Either[Any]:
         logger.debug(f"Processing Create request {type(record)}")
         return self.write_create_request(record)
 
-    @calculate_execution_time
+    @calculate_execution_time(store=False)
     def _run(self, record: Entity, *_, **__) -> Either[Any]:
         """
         Default implementation for the single dispatch
@@ -132,14 +142,14 @@ class MetadataRestSink(Sink):  # pylint: disable=too-many-public-methods
             error = f"Failed to ingest {log} due to api request failure: {err}"
             return Either(
                 left=StackTraceError(
-                    name=log, error=error, stack_trace=traceback.format_exc()
+                    name=log, error=error, stackTrace=traceback.format_exc()
                 )
             )
         except Exception as exc:
             error = f"Failed to ingest {log}: {exc}"
             return Either(
                 left=StackTraceError(
-                    name=log, error=error, stack_trace=traceback.format_exc()
+                    name=log, error=error, stackTrace=traceback.format_exc()
                 )
             )
 
@@ -155,7 +165,7 @@ class MetadataRestSink(Sink):  # pylint: disable=too-many-public-methods
         error = f"Failed to ingest {type(entity_request).__name__}"
         return Either(
             left=StackTraceError(
-                name=type(entity_request).__name__, error=error, stack_trace=None
+                name=type(entity_request).__name__, error=error, stackTrace=None
             )
         )
 
@@ -170,8 +180,10 @@ class MetadataRestSink(Sink):  # pylint: disable=too-many-public-methods
             destination=record.new_entity,
             allowed_fields=ALLOWED_COMMON_PATCH_FIELDS,
             restrict_update_fields=RESTRICT_UPDATE_LIST,
+            array_entity_fields=ARRAY_ENTITY_FIELDS,
         )
-        return Either(right=entity)
+        patched_entity = PatchedEntity(new_entity=entity) if entity else None
+        return Either(right=patched_entity)
 
     @_run_dispatch.register
     def write_custom_properties(self, record: OMetaCustomProperties) -> Either[Dict]:
@@ -200,7 +212,7 @@ class MetadataRestSink(Sink):  # pylint: disable=too-many-public-methods
             left=StackTraceError(
                 name="Data Model",
                 error="Sink did not receive a table. We cannot ingest the data model.",
-                stack_trace=None,
+                stackTrace=None,
             )
         )
 
@@ -275,7 +287,7 @@ class MetadataRestSink(Sink):  # pylint: disable=too-many-public-methods
             for role in record.roles:
                 try:
                     role_entity = self.metadata.get_by_name(
-                        entity=Role, fqn=str(role.name.__root__.__root__)
+                        entity=Role, fqn=str(role.name.__root__)
                     )
                 except APIError:
                     role_entity = self._create_role(role)
@@ -411,6 +423,15 @@ class MetadataRestSink(Sink):  # pylint: disable=too-many-public-methods
         )
         return Either(right=res)
 
+    @_run_dispatch.register
+    def write_test_case_resolution_status(
+        self, record: OMetaTestCaseResolutionStatus
+    ) -> TestCaseResolutionStatus:
+        """For sample data"""
+        res = self.metadata.create_test_case_resolution(record.test_case_resolution)
+
+        return Either(right=res)
+
     @_run_dispatch.register
     def write_data_insight_sample(
         self, record: OMetaDataInsightSample