diff --git a/pyatlan/generator/templates/methods/asset/dataverse_attribute.jinja2 b/pyatlan/generator/templates/methods/asset/dataverse_attribute.jinja2 new file mode 100644 index 000000000..d2ba6ce54 --- /dev/null +++ b/pyatlan/generator/templates/methods/asset/dataverse_attribute.jinja2 @@ -0,0 +1,38 @@ + + @overload + @classmethod + def creator( + cls, + *, + name: str, + dataverse_entity_qualified_name: str, + ) -> DataverseAttribute: ... + + @overload + @classmethod + def creator( + cls, + *, + name: str, + dataverse_entity_qualified_name: str, + connection_qualified_name: str, + ) -> DataverseAttribute: ... + + @classmethod + @init_guid + def creator( + cls, + *, + name: str, + dataverse_entity_qualified_name: str, + connection_qualified_name: Optional[str] = None, + ) -> DataverseAttribute: + validate_required_fields( + ["name", "dataverse_entity_qualified_name"], [name, dataverse_entity_qualified_name], + ) + attributes = DataverseAttribute.Attributes.creator( + name=name, + dataverse_entity_qualified_name=dataverse_entity_qualified_name, + connection_qualified_name=connection_qualified_name, + ) + return cls(attributes=attributes) diff --git a/pyatlan/generator/templates/methods/asset/dataverse_entity.jinja2 b/pyatlan/generator/templates/methods/asset/dataverse_entity.jinja2 new file mode 100644 index 000000000..b030688af --- /dev/null +++ b/pyatlan/generator/templates/methods/asset/dataverse_entity.jinja2 @@ -0,0 +1,12 @@ + + @classmethod + @init_guid + def creator(cls, *, name: str, connection_qualified_name: str) -> DataverseEntity: + validate_required_fields( + ["name", "connection_qualified_name"], [name, connection_qualified_name], + ) + attributes = DataverseEntity.Attributes.creator( + name=name, + connection_qualified_name=connection_qualified_name, + ) + return cls(attributes=attributes) diff --git a/pyatlan/generator/templates/methods/attribute/dataverse_attribute.jinja2 b/pyatlan/generator/templates/methods/attribute/dataverse_attribute.jinja2 new file mode 100644 index 000000000..b4ddce979 --- /dev/null +++ b/pyatlan/generator/templates/methods/attribute/dataverse_attribute.jinja2 @@ -0,0 +1,35 @@ + + @classmethod + @init_guid + def creator( + cls, + *, + name: str, + dataverse_entity_qualified_name: str, + connection_qualified_name: Optional[str] = None, + ) -> DataverseAttribute.Attributes: + validate_required_fields( + ["name", "dataverse_entity_qualified_name"], + [name, dataverse_entity_qualified_name], + ) + if connection_qualified_name: + connector_name = AtlanConnectorType.get_connector_name( + connection_qualified_name + ) + else: + connection_qn, connector_name = AtlanConnectorType.get_connector_name( + dataverse_entity_qualified_name, + "dataverse_entity_qualified_name", + 4, + ) + + return DataverseAttribute.Attributes( + name=name, + dataverse_entity_qualified_name=dataverse_entity_qualified_name, + connection_qualified_name=connection_qualified_name or connection_qn, + qualified_name=f"{dataverse_entity_qualified_name}/{name}", + connector_name=connector_name, + dataverse_entity=DataverseEntity.ref_by_qualified_name( + dataverse_entity_qualified_name + ), + ) diff --git a/pyatlan/generator/templates/methods/attribute/dataverse_entity.jinja2 b/pyatlan/generator/templates/methods/attribute/dataverse_entity.jinja2 new file mode 100644 index 000000000..310017be7 --- /dev/null +++ b/pyatlan/generator/templates/methods/attribute/dataverse_entity.jinja2 @@ -0,0 +1,17 @@ + + @classmethod + @init_guid + def creator( + cls, *, name: str, connection_qualified_name: str + ) -> DataverseEntity.Attributes: + validate_required_fields( + ["name", "connection_qualified_name"], [name, connection_qualified_name], + ) + return DataverseEntity.Attributes( + name=name, + qualified_name=f"{connection_qualified_name}/{name}", + connection_qualified_name=connection_qualified_name, + connector_name=AtlanConnectorType.get_connector_name( + connection_qualified_name + ), + ) diff --git a/pyatlan/model/assets/dataverse_attribute.py b/pyatlan/model/assets/dataverse_attribute.py index 1c74130ff..6b7332dcc 100644 --- a/pyatlan/model/assets/dataverse_attribute.py +++ b/pyatlan/model/assets/dataverse_attribute.py @@ -4,11 +4,13 @@ from __future__ import annotations -from typing import ClassVar, List, Optional +from typing import ClassVar, List, Optional, overload from pydantic.v1 import Field, validator +from pyatlan.model.enums import AtlanConnectorType from pyatlan.model.fields.atlan_fields import BooleanField, KeywordField, RelationField +from pyatlan.utils import init_guid, validate_required_fields from .dataverse import Dataverse @@ -16,6 +18,45 @@ class DataverseAttribute(Dataverse): """Description""" + @overload + @classmethod + def creator( + cls, + *, + name: str, + dataverse_entity_qualified_name: str, + ) -> DataverseAttribute: ... + + @overload + @classmethod + def creator( + cls, + *, + name: str, + dataverse_entity_qualified_name: str, + connection_qualified_name: str, + ) -> DataverseAttribute: ... + + @classmethod + @init_guid + def creator( + cls, + *, + name: str, + dataverse_entity_qualified_name: str, + connection_qualified_name: Optional[str] = None, + ) -> DataverseAttribute: + validate_required_fields( + ["name", "dataverse_entity_qualified_name"], + [name, dataverse_entity_qualified_name], + ) + attributes = DataverseAttribute.Attributes.creator( + name=name, + dataverse_entity_qualified_name=dataverse_entity_qualified_name, + connection_qualified_name=connection_qualified_name, + ) + return cls(attributes=attributes) + type_name: str = Field(default="DataverseAttribute", allow_mutation=False) @validator("type_name") @@ -188,6 +229,41 @@ class Attributes(Dataverse.Attributes): default=None, description="" ) # relationship + @classmethod + @init_guid + def creator( + cls, + *, + name: str, + dataverse_entity_qualified_name: str, + connection_qualified_name: Optional[str] = None, + ) -> DataverseAttribute.Attributes: + validate_required_fields( + ["name", "dataverse_entity_qualified_name"], + [name, dataverse_entity_qualified_name], + ) + if connection_qualified_name: + connector_name = AtlanConnectorType.get_connector_name( + connection_qualified_name + ) + else: + connection_qn, connector_name = AtlanConnectorType.get_connector_name( + dataverse_entity_qualified_name, + "dataverse_entity_qualified_name", + 4, + ) + + return DataverseAttribute.Attributes( + name=name, + dataverse_entity_qualified_name=dataverse_entity_qualified_name, + connection_qualified_name=connection_qualified_name or connection_qn, + qualified_name=f"{dataverse_entity_qualified_name}/{name}", + connector_name=connector_name, + dataverse_entity=DataverseEntity.ref_by_qualified_name( + dataverse_entity_qualified_name + ), + ) + attributes: DataverseAttribute.Attributes = Field( default_factory=lambda: DataverseAttribute.Attributes(), description=( diff --git a/pyatlan/model/assets/dataverse_entity.py b/pyatlan/model/assets/dataverse_entity.py index ecbd9ede0..3bde074ab 100644 --- a/pyatlan/model/assets/dataverse_entity.py +++ b/pyatlan/model/assets/dataverse_entity.py @@ -8,7 +8,9 @@ from pydantic.v1 import Field, validator +from pyatlan.model.enums import AtlanConnectorType from pyatlan.model.fields.atlan_fields import KeywordField, RelationField +from pyatlan.utils import init_guid, validate_required_fields from .dataverse import Dataverse @@ -16,6 +18,19 @@ class DataverseEntity(Dataverse): """Description""" + @classmethod + @init_guid + def creator(cls, *, name: str, connection_qualified_name: str) -> DataverseEntity: + validate_required_fields( + ["name", "connection_qualified_name"], + [name, connection_qualified_name], + ) + attributes = DataverseEntity.Attributes.creator( + name=name, + connection_qualified_name=connection_qualified_name, + ) + return cls(attributes=attributes) + type_name: str = Field(default="DataverseEntity", allow_mutation=False) @validator("type_name") @@ -102,6 +117,24 @@ class Attributes(Dataverse.Attributes): default=None, description="" ) # relationship + @classmethod + @init_guid + def creator( + cls, *, name: str, connection_qualified_name: str + ) -> DataverseEntity.Attributes: + validate_required_fields( + ["name", "connection_qualified_name"], + [name, connection_qualified_name], + ) + return DataverseEntity.Attributes( + name=name, + qualified_name=f"{connection_qualified_name}/{name}", + connection_qualified_name=connection_qualified_name, + connector_name=AtlanConnectorType.get_connector_name( + connection_qualified_name + ), + ) + attributes: DataverseEntity.Attributes = Field( default_factory=lambda: DataverseEntity.Attributes(), description=( diff --git a/pyatlan/model/constants.py b/pyatlan/model/constants.py index 34ec484f2..65f40c6a6 100644 --- a/pyatlan/model/constants.py +++ b/pyatlan/model/constants.py @@ -43,6 +43,8 @@ "ColumnProcess", "Connection", "DataStudioAsset", + "DataverseAttribute", + "DataverseEntity", "Database", "DbtColumnProcess", "DbtMetric", diff --git a/pyatlan/model/structs.py b/pyatlan/model/structs.py index 42df88751..633dd2f50 100644 --- a/pyatlan/model/structs.py +++ b/pyatlan/model/structs.py @@ -110,13 +110,6 @@ class ColumnValueFrequencyMap(AtlanObject): column_value_frequency: Optional[int] = Field(default=None, description="") -class SourceTagAttachmentValue(AtlanObject): - """Description""" - - tag_attachment_key: Optional[str] = Field(default=None, description="") - tag_attachment_value: Optional[str] = Field(default=None, description="") - - class SourceTagAttachment(AtlanObject): """Description""" @@ -261,6 +254,13 @@ def of( ) +class SourceTagAttachmentValue(AtlanObject): + """Description""" + + tag_attachment_key: Optional[str] = Field(default=None, description="") + tag_attachment_value: Optional[str] = Field(default=None, description="") + + class BadgeCondition(AtlanObject): """Description""" @@ -295,18 +295,18 @@ def create( badge_condition_colorhex: Optional[str] = Field(default=None, description="") -class AzureTag(AtlanObject): +class StarredDetails(AtlanObject): """Description""" - azure_tag_key: str = Field(description="") - azure_tag_value: str = Field(description="") + asset_starred_by: Optional[str] = Field(default=None, description="") + asset_starred_at: Optional[datetime] = Field(default=None, description="") -class StarredDetails(AtlanObject): +class AzureTag(AtlanObject): """Description""" - asset_starred_by: Optional[str] = Field(default=None, description="") - asset_starred_at: Optional[datetime] = Field(default=None, description="") + azure_tag_key: str = Field(description="") + azure_tag_value: str = Field(description="") class AuthPolicyCondition(AtlanObject): @@ -410,16 +410,16 @@ class SourceTagAttribute(AtlanObject): ColumnValueFrequencyMap.update_forward_refs() -SourceTagAttachmentValue.update_forward_refs() - SourceTagAttachment.update_forward_refs() -BadgeCondition.update_forward_refs() +SourceTagAttachmentValue.update_forward_refs() -AzureTag.update_forward_refs() +BadgeCondition.update_forward_refs() StarredDetails.update_forward_refs() +AzureTag.update_forward_refs() + AuthPolicyCondition.update_forward_refs() AwsTag.update_forward_refs() diff --git a/pyatlan/model/typedef.py b/pyatlan/model/typedef.py index dd19c92bb..37201f8cb 100644 --- a/pyatlan/model/typedef.py +++ b/pyatlan/model/typedef.py @@ -53,6 +53,8 @@ "ColumnProcess", "Connection", "DataStudioAsset", + "DataverseAttribute", + "DataverseEntity", "Database", "DbtColumnProcess", "DbtMetric", diff --git a/tests/integration/dataverse_asset_test.py b/tests/integration/dataverse_asset_test.py new file mode 100644 index 000000000..a2a1be61b --- /dev/null +++ b/tests/integration/dataverse_asset_test.py @@ -0,0 +1,250 @@ +from typing import Generator + +import pytest + +from pyatlan.client.atlan import AtlanClient +from pyatlan.model.assets import Connection, DataverseAttribute, DataverseEntity +from pyatlan.model.core import Announcement +from pyatlan.model.enums import ( + AnnouncementType, + AtlanConnectorType, + CertificateStatus, + EntityStatus, +) +from tests.integration.client import TestId, delete_asset +from tests.integration.connection_test import create_connection + +MODULE_NAME = TestId.make_unique("DATAVERSE") + +CONNECTOR_TYPE = AtlanConnectorType.DATAVERSE +DATAVERSE_ENTITY_NAME = f"{MODULE_NAME}-dataverse-entity" +DATAVERSE_ATTRIBUTE_NAME = f"{MODULE_NAME}-dataverse-attribute" +DATAVERSE_ATTRIBUTE_NAME_OVERLOAD = f"{MODULE_NAME}-dataverse-attribute-overload" + +CERTIFICATE_STATUS = CertificateStatus.VERIFIED + +ANNOUNCEMENT_TITLE = "Python SDK testing." +ANNOUNCEMENT_TYPE = AnnouncementType.INFORMATION +CERTIFICATE_MESSAGE = "Automated testing of the Python SDK." +ANNOUNCEMENT_MESSAGE = "Automated testing of the Python SDK." + + +@pytest.fixture(scope="module") +def connection(client: AtlanClient) -> Generator[Connection, None, None]: + result = create_connection( + client=client, name=MODULE_NAME, connector_type=CONNECTOR_TYPE + ) + yield result + delete_asset(client, guid=result.guid, asset_type=Connection) + + +@pytest.fixture(scope="module") +def dataverse_entity( + client: AtlanClient, connection: Connection +) -> Generator[DataverseEntity, None, None]: + assert connection.qualified_name + to_create = DataverseEntity.creator( + name=DATAVERSE_ENTITY_NAME, connection_qualified_name=connection.qualified_name + ) + response = client.asset.save(to_create) + result = response.assets_created(asset_type=DataverseEntity)[0] + yield result + delete_asset(client, guid=result.guid, asset_type=DataverseEntity) + + +def test_dataverse_entity( + client: AtlanClient, connection: Connection, dataverse_entity: DataverseEntity +): + assert dataverse_entity + assert dataverse_entity.guid + assert dataverse_entity.qualified_name + assert dataverse_entity.name == DATAVERSE_ENTITY_NAME + assert dataverse_entity.connection_qualified_name == connection.qualified_name + assert dataverse_entity.connector_name == AtlanConnectorType.DATAVERSE.value + + +@pytest.fixture(scope="module") +def dataverse_attribute( + client: AtlanClient, dataverse_entity: DataverseEntity +) -> Generator[DataverseAttribute, None, None]: + assert dataverse_entity.qualified_name + to_create = DataverseAttribute.creator( + name=DATAVERSE_ATTRIBUTE_NAME, + dataverse_entity_qualified_name=dataverse_entity.qualified_name, + ) + response = client.asset.save(to_create) + result = response.assets_created(asset_type=DataverseAttribute)[0] + yield result + delete_asset(client, guid=result.guid, asset_type=DataverseAttribute) + + +def test_dataverse_attribute( + client: AtlanClient, + dataverse_entity: DataverseEntity, + dataverse_attribute: DataverseAttribute, +): + assert dataverse_attribute + assert dataverse_attribute.guid + assert dataverse_attribute.qualified_name + assert dataverse_attribute.name == DATAVERSE_ATTRIBUTE_NAME + assert ( + dataverse_attribute.connection_qualified_name + == dataverse_entity.connection_qualified_name + ) + assert dataverse_attribute.connector_name == AtlanConnectorType.DATAVERSE.value + + +@pytest.fixture(scope="module") +def dataverse_attribute_overload( + client: AtlanClient, connection: Connection, dataverse_entity: DataverseEntity +) -> Generator[DataverseAttribute, None, None]: + assert connection.qualified_name + assert dataverse_entity.qualified_name + to_create = DataverseAttribute.creator( + name=DATAVERSE_ATTRIBUTE_NAME_OVERLOAD, + dataverse_entity_qualified_name=dataverse_entity.qualified_name, + connection_qualified_name=connection.qualified_name, + ) + response = client.asset.save(to_create) + result = response.assets_created(asset_type=DataverseAttribute)[0] + yield result + delete_asset(client, guid=result.guid, asset_type=DataverseAttribute) + + +def test_overload_dataverse_attribute( + client: AtlanClient, + dataverse_entity: DataverseEntity, + dataverse_attribute_overload: DataverseAttribute, +): + assert dataverse_attribute_overload + assert dataverse_attribute_overload.guid + assert dataverse_attribute_overload.qualified_name + assert dataverse_attribute_overload.name == DATAVERSE_ATTRIBUTE_NAME_OVERLOAD + assert ( + dataverse_attribute_overload.connection_qualified_name + == dataverse_entity.connection_qualified_name + ) + assert ( + dataverse_attribute_overload.connector_name + == AtlanConnectorType.DATAVERSE.value + ) + + +def _update_cert_and_annoucement(client, asset, asset_type): + assert asset.name + assert asset.qualified_name + + updated = client.asset.update_certificate( + name=asset.name, + asset_type=asset_type, + qualified_name=asset.qualified_name, + message=CERTIFICATE_MESSAGE, + certificate_status=CERTIFICATE_STATUS, + ) + assert updated + assert updated.certificate_status == CERTIFICATE_STATUS + assert updated.certificate_status_message == CERTIFICATE_MESSAGE + + updated = client.asset.update_announcement( + name=asset.name, + asset_type=asset_type, + qualified_name=asset.qualified_name, + announcement=Announcement( + announcement_type=ANNOUNCEMENT_TYPE, + announcement_title=ANNOUNCEMENT_TITLE, + announcement_message=ANNOUNCEMENT_MESSAGE, + ), + ) + assert updated + assert updated.announcement_type == ANNOUNCEMENT_TYPE + assert updated.announcement_title == ANNOUNCEMENT_TITLE + assert updated.announcement_message == ANNOUNCEMENT_MESSAGE + + +def test_update_dataverse_assets( + client: AtlanClient, + dataverse_entity: DataverseEntity, + dataverse_attribute: DataverseAttribute, +): + _update_cert_and_annoucement(client, dataverse_entity, DataverseEntity) + _update_cert_and_annoucement(client, dataverse_attribute, DataverseAttribute) + + +def _retrieve_dataverse_assets(client, asset, asset_type): + retrieved = client.asset.get_by_guid( + asset.guid, asset_type=asset_type, ignore_relationships=False + ) + assert retrieved + assert not retrieved.is_incomplete + assert retrieved.guid == asset.guid + assert retrieved.qualified_name == asset.qualified_name + assert retrieved.name == asset.name + assert retrieved.connector_name == AtlanConnectorType.DATAVERSE + assert retrieved.certificate_status == CERTIFICATE_STATUS + assert retrieved.certificate_status_message == CERTIFICATE_MESSAGE + + +@pytest.mark.order(after="test_update_dataverse_assets") +def test_retrieve_dataverse_assets( + client: AtlanClient, + dataverse_entity: DataverseEntity, + dataverse_attribute: DataverseAttribute, +): + _retrieve_dataverse_assets(client, dataverse_entity, DataverseEntity) + _retrieve_dataverse_assets(client, dataverse_attribute, DataverseAttribute) + + +@pytest.mark.order(after="test_retrieve_dataverse_assets") +def test_delete_dataverse_attribute( + client: AtlanClient, + dataverse_attribute: DataverseAttribute, +): + response = client.asset.delete_by_guid(guid=dataverse_attribute.guid) + assert response + assert not response.assets_created(asset_type=DataverseAttribute) + assert not response.assets_updated(asset_type=DataverseAttribute) + deleted = response.assets_deleted(asset_type=DataverseAttribute) + + assert deleted + assert len(deleted) == 1 + assert deleted[0].guid == dataverse_attribute.guid + assert deleted[0].delete_handler == "SOFT" + assert deleted[0].status == EntityStatus.DELETED + assert deleted[0].qualified_name == dataverse_attribute.qualified_name + + +@pytest.mark.order(after="test_delete_dataverse_attribute") +def test_read_deleted_dataverse_attribute( + client: AtlanClient, + dataverse_attribute: DataverseAttribute, +): + deleted = client.asset.get_by_guid( + dataverse_attribute.guid, + asset_type=DataverseAttribute, + ignore_relationships=False, + ) + assert deleted + assert deleted.status == EntityStatus.DELETED + assert deleted.guid == dataverse_attribute.guid + assert deleted.qualified_name == dataverse_attribute.qualified_name + + +@pytest.mark.order(after="test_read_deleted_dataverse_attribute") +def test_restore_dataverse_attribute( + client: AtlanClient, + dataverse_attribute: DataverseAttribute, +): + assert dataverse_attribute.qualified_name + assert client.asset.restore( + asset_type=DataverseAttribute, qualified_name=dataverse_attribute.qualified_name + ) + assert dataverse_attribute.qualified_name + restored = client.asset.get_by_qualified_name( + asset_type=DataverseAttribute, + qualified_name=dataverse_attribute.qualified_name, + ignore_relationships=False, + ) + assert restored + assert restored.guid == dataverse_attribute.guid + assert restored.status == EntityStatus.ACTIVE + assert restored.qualified_name == dataverse_attribute.qualified_name diff --git a/tests/unit/model/constants.py b/tests/unit/model/constants.py index 28f9a43b3..87ed6e20f 100644 --- a/tests/unit/model/constants.py +++ b/tests/unit/model/constants.py @@ -238,3 +238,14 @@ f"{SUPERSET_DASHBOARD_QUALIFIED_NAME}/{SUPERSET_DATASET_NAME}" ) PROCEDURE_NAME = "test-procedure" + +DATAVERSE_CONNECTION_QUALIFIED_NAME = "default/dataverse/123456789" +DATAVERSE_CONNECTOR_TYPE = "dataverse" +DATAVERSE_ENTITY_NAME = "dv-entity" +DATAVERSE_ENTITY_QUALIFIED_NAME = ( + f"{DATAVERSE_CONNECTION_QUALIFIED_NAME}/{DATAVERSE_ENTITY_NAME}" +) +DATAVERSE_ATTRIBUTE_NAME = "dv-attribute" +DATAVERSE_ATTRIBUTE_QUALIFIED_NAME = ( + f"{DATAVERSE_ENTITY_QUALIFIED_NAME}/{DATAVERSE_ATTRIBUTE_NAME}" +) diff --git a/tests/unit/model/dataverse_attribute_test.py b/tests/unit/model/dataverse_attribute_test.py new file mode 100644 index 000000000..e50d14a76 --- /dev/null +++ b/tests/unit/model/dataverse_attribute_test.py @@ -0,0 +1,70 @@ +import pytest + +from pyatlan.model.assets import DataverseAttribute +from tests.unit.model.constants import ( + DATAVERSE_ATTRIBUTE_NAME, + DATAVERSE_ATTRIBUTE_QUALIFIED_NAME, + DATAVERSE_CONNECTION_QUALIFIED_NAME, + DATAVERSE_CONNECTOR_TYPE, + DATAVERSE_ENTITY_QUALIFIED_NAME, +) + + +@pytest.mark.parametrize( + "name, entity_qualified_name, message", + [ + (None, "connection/name", "name is required"), + (DATAVERSE_ATTRIBUTE_NAME, None, "entity_qualified_name is required"), + ], +) +def test_creator_with_missing_parameters_raise_value_error( + name: str, entity_qualified_name: str, message: str +): + with pytest.raises(ValueError, match=message): + DataverseAttribute.creator( + name=name, dataverse_entity_qualified_name=entity_qualified_name + ) + + +def test_creator(): + sut = DataverseAttribute.creator( + name=DATAVERSE_ATTRIBUTE_NAME, + dataverse_entity_qualified_name=DATAVERSE_ENTITY_QUALIFIED_NAME, + ) + + assert sut.name == DATAVERSE_ATTRIBUTE_NAME + assert sut.connection_qualified_name == DATAVERSE_CONNECTION_QUALIFIED_NAME + assert sut.qualified_name == DATAVERSE_ATTRIBUTE_QUALIFIED_NAME + assert sut.connector_name == DATAVERSE_CONNECTOR_TYPE + + +@pytest.mark.parametrize( + "qualified_name, name, message", + [ + (None, DATAVERSE_ENTITY_QUALIFIED_NAME, "qualified_name is required"), + (DATAVERSE_ATTRIBUTE_NAME, None, "name is required"), + ], +) +def test_updater_with_invalid_parameter_raises_value_error( + qualified_name: str, name: str, message: str +): + with pytest.raises(ValueError, match=message): + DataverseAttribute.updater(qualified_name=qualified_name, name=name) + + +def test_updater(): + sut = DataverseAttribute.updater( + qualified_name=DATAVERSE_ATTRIBUTE_QUALIFIED_NAME, name=DATAVERSE_ATTRIBUTE_NAME + ) + + assert sut.qualified_name == DATAVERSE_ATTRIBUTE_QUALIFIED_NAME + assert sut.name == DATAVERSE_ATTRIBUTE_NAME + + +def test_trim_to_required(): + sut = DataverseAttribute.updater( + name=DATAVERSE_ATTRIBUTE_NAME, qualified_name=DATAVERSE_ATTRIBUTE_QUALIFIED_NAME + ).trim_to_required() + + assert sut.name == DATAVERSE_ATTRIBUTE_NAME + assert sut.qualified_name == DATAVERSE_ATTRIBUTE_QUALIFIED_NAME diff --git a/tests/unit/model/dataverse_entity_test.py b/tests/unit/model/dataverse_entity_test.py new file mode 100644 index 000000000..665f6c940 --- /dev/null +++ b/tests/unit/model/dataverse_entity_test.py @@ -0,0 +1,69 @@ +import pytest + +from pyatlan.model.assets import DataverseEntity +from tests.unit.model.constants import ( + DATAVERSE_CONNECTION_QUALIFIED_NAME, + DATAVERSE_CONNECTOR_TYPE, + DATAVERSE_ENTITY_NAME, + DATAVERSE_ENTITY_QUALIFIED_NAME, +) + + +@pytest.mark.parametrize( + "name, connection_qualified_name, message", + [ + (None, "connection/name", "name is required"), + (DATAVERSE_ENTITY_NAME, None, "connection_qualified_name is required"), + ], +) +def test_creator_with_missing_parameters_raise_value_error( + name: str, connection_qualified_name: str, message: str +): + with pytest.raises(ValueError, match=message): + DataverseEntity.creator( + name=name, connection_qualified_name=connection_qualified_name + ) + + +def test_creator(): + sut = DataverseEntity.creator( + name=DATAVERSE_ENTITY_NAME, + connection_qualified_name=DATAVERSE_CONNECTION_QUALIFIED_NAME, + ) + + assert sut.name == DATAVERSE_ENTITY_NAME + assert sut.connection_qualified_name == DATAVERSE_CONNECTION_QUALIFIED_NAME + assert sut.qualified_name == DATAVERSE_ENTITY_QUALIFIED_NAME + assert sut.connector_name == DATAVERSE_CONNECTOR_TYPE + + +@pytest.mark.parametrize( + "qualified_name, name, message", + [ + (None, DATAVERSE_CONNECTION_QUALIFIED_NAME, "qualified_name is required"), + (DATAVERSE_ENTITY_NAME, None, "name is required"), + ], +) +def test_updater_with_invalid_parameter_raises_value_error( + qualified_name: str, name: str, message: str +): + with pytest.raises(ValueError, match=message): + DataverseEntity.updater(qualified_name=qualified_name, name=name) + + +def test_updater(): + sut = DataverseEntity.updater( + qualified_name=DATAVERSE_ENTITY_QUALIFIED_NAME, name=DATAVERSE_ENTITY_NAME + ) + + assert sut.qualified_name == DATAVERSE_ENTITY_QUALIFIED_NAME + assert sut.name == DATAVERSE_ENTITY_NAME + + +def test_trim_to_required(): + sut = DataverseEntity.updater( + name=DATAVERSE_ENTITY_NAME, qualified_name=DATAVERSE_ENTITY_QUALIFIED_NAME + ).trim_to_required() + + assert sut.name == DATAVERSE_ENTITY_NAME + assert sut.qualified_name == DATAVERSE_ENTITY_QUALIFIED_NAME diff --git a/tests/unit/test_model.py b/tests/unit/test_model.py index c296d29bb..fa45e46d1 100644 --- a/tests/unit/test_model.py +++ b/tests/unit/test_model.py @@ -45,6 +45,8 @@ Column, ColumnProcess, Database, + DataverseAttribute, + DataverseEntity, DbtMetric, DbtModel, DbtModelColumn, @@ -525,6 +527,8 @@ "Optional[MatillionJob]": MatillionJob(), "Optional[List[LookerFolder]]": [LookerFolder()], "Optional[List[AtlanTagName]]": [], + "Optional[DataverseEntity]": DataverseEntity(), + "Optional[List[DataverseAttribute]]": [DataverseAttribute()], "List[str]": [], }