OpenMetadata/ingestion/tests/unit/sdk/test_glossary_entity.py

"""
Comprehensive unit tests for Glossary and GlossaryTerm entities with full mock coverage.
"""
import unittest
from unittest.mock import MagicMock
from uuid import UUID

from metadata.generated.schema.api.data.createGlossary import CreateGlossaryRequest
from metadata.generated.schema.api.data.createGlossaryTerm import (
    CreateGlossaryTermRequest,
)
from metadata.generated.schema.entity.data.glossary import Glossary as GlossaryEntity
from metadata.generated.schema.entity.data.glossaryTerm import (
    GlossaryTerm as GlossaryTermEntity,
)
from metadata.generated.schema.entity.data.glossaryTerm import TermReference
from metadata.generated.schema.type.entityReference import EntityReference
from metadata.sdk import Glossaries, GlossaryTerms


class TestGlossaryEntity(unittest.TestCase):
    """Comprehensive tests for Glossary entity operations"""

    def setUp(self):
        """Set up test fixtures"""
        self.mock_ometa = MagicMock()

        # Set default client directly
        Glossaries.set_default_client(self.mock_ometa)

        # Test data
        self.glossary_id = "150e8400-e29b-41d4-a716-446655440000"
        self.glossary_fqn = "BusinessGlossary"

    def test_create_glossary(self):
        """Test creating a glossary"""
        # Arrange
        create_request = CreateGlossaryRequest(
            name="BusinessGlossary",
            displayName="Business Glossary",
            description="Central business glossary for the organization",
        )

        expected_glossary = MagicMock(spec=GlossaryEntity)
        expected_glossary.id = UUID(self.glossary_id)
        expected_glossary.name = "BusinessGlossary"
        expected_glossary.displayName = "Business Glossary"

        self.mock_ometa.create_or_update.return_value = expected_glossary

        # Act
        result = Glossaries.create(create_request)

        # Assert
        self.assertEqual(str(result.id), self.glossary_id)
        self.assertEqual(result.name, "BusinessGlossary")
        self.assertEqual(result.displayName, "Business Glossary")
        self.mock_ometa.create_or_update.assert_called_once_with(create_request)

    def test_retrieve_glossary_by_id(self):
        """Test retrieving a glossary by ID"""
        # Arrange
        expected_glossary = MagicMock(spec=GlossaryEntity)
        expected_glossary.id = UUID(self.glossary_id)
        expected_glossary.name = "BusinessGlossary"
        expected_glossary.description = "Business terms and definitions"

        self.mock_ometa.get_by_id.return_value = expected_glossary

        # Act
        result = Glossaries.retrieve(self.glossary_id)

        # Assert
        self.assertEqual(str(result.id), self.glossary_id)
        self.assertEqual(result.name, "BusinessGlossary")
        self.mock_ometa.get_by_id.assert_called_once_with(
            entity=GlossaryEntity, entity_id=self.glossary_id, fields=None
        )

    def test_retrieve_glossary_by_name(self):
        """Test retrieving a glossary by name"""
        # Arrange
        expected_glossary = MagicMock(spec=GlossaryEntity)
        expected_glossary.id = UUID(self.glossary_id)
        expected_glossary.name = "BusinessGlossary"
        expected_glossary.fullyQualifiedName = self.glossary_fqn

        self.mock_ometa.get_by_name.return_value = expected_glossary

        # Act
        result = Glossaries.retrieve_by_name(self.glossary_fqn)

        # Assert
        self.assertEqual(result.fullyQualifiedName, self.glossary_fqn)
        self.mock_ometa.get_by_name.assert_called_once_with(
            entity=GlossaryEntity, fqn=self.glossary_fqn, fields=None
        )

    def test_update_glossary(self):
        """Test updating a glossary"""
        # Arrange
        glossary_to_update = MagicMock(spec=GlossaryEntity)
        glossary_to_update.id = UUID(self.glossary_id)
        glossary_to_update.name = "BusinessGlossary"
        glossary_to_update.description = "Updated business glossary"

        # Mock the get_by_id to return the current state
        current_glossary = MagicMock(spec=GlossaryEntity)
        current_glossary.id = UUID(self.glossary_id)
        self.mock_ometa.get_by_id.return_value = current_glossary

        # Mock the patch to return the updated glossary
        self.mock_ometa.patch.return_value = glossary_to_update

        # Act
        result = Glossaries.update(glossary_to_update)

        # Assert
        self.assertEqual(result.description, "Updated business glossary")
        # Verify get_by_id was called to fetch current state
        self.mock_ometa.get_by_id.assert_called_once()
        # Verify patch was called with source and destination
        self.mock_ometa.patch.assert_called_once()

    def test_delete_glossary(self):
        """Test deleting a glossary"""
        # Act
        Glossaries.delete(self.glossary_id, recursive=True, hard_delete=False)

        # Assert
        self.mock_ometa.delete.assert_called_once_with(
            entity=GlossaryEntity,
            entity_id=self.glossary_id,
            recursive=True,
            hard_delete=False,
        )

    def test_list_glossaries(self):
        """Test listing glossaries"""
        # Arrange
        mock_glossary1 = MagicMock(spec=GlossaryEntity)
        mock_glossary1.name = "glossary1"
        mock_glossary2 = MagicMock(spec=GlossaryEntity)
        mock_glossary2.name = "glossary2"

        mock_response = MagicMock()
        mock_response.entities = [mock_glossary1, mock_glossary2]

        self.mock_ometa.list_entities.return_value = mock_response

        # Act
        result = Glossaries.list()

        # Assert
        self.assertEqual(len(result.entities), 2)
        self.assertEqual(result.entities[0].name, "glossary1")
        self.mock_ometa.list_entities.assert_called_once()


class TestGlossaryTermEntity(unittest.TestCase):
    """Comprehensive tests for GlossaryTerm entity operations"""

    def setUp(self):
        """Set up test fixtures"""
        self.mock_ometa = MagicMock()

        # Set default client directly
        GlossaryTerms.set_default_client(self.mock_ometa)

        # Test data
        self.term_id = "250e8400-e29b-41d4-a716-446655440000"
        self.term_fqn = "BusinessGlossary.Customer"

    def test_create_glossary_term(self):
        """Test creating a glossary term"""
        # Arrange
        create_request = CreateGlossaryTermRequest(
            name="Customer",
            displayName="Customer",
            description="A person or organization that buys goods or services",
            glossary="BusinessGlossary",
        )

        expected_term = MagicMock(spec=GlossaryTermEntity)
        expected_term.id = UUID(self.term_id)
        expected_term.name = "Customer"
        expected_term.displayName = "Customer"

        self.mock_ometa.create_or_update.return_value = expected_term

        # Act
        result = GlossaryTerms.create(create_request)

        # Assert
        self.assertEqual(str(result.id), self.term_id)
        self.assertEqual(result.name, "Customer")
        self.mock_ometa.create_or_update.assert_called_once_with(create_request)

    def test_retrieve_term_by_id(self):
        """Test retrieving a glossary term by ID"""
        # Arrange
        expected_term = MagicMock(spec=GlossaryTermEntity)
        expected_term.id = UUID(self.term_id)
        expected_term.name = "Customer"
        expected_term.description = "Customer definition"

        self.mock_ometa.get_by_id.return_value = expected_term

        # Act
        result = GlossaryTerms.retrieve(self.term_id)

        # Assert
        self.assertEqual(str(result.id), self.term_id)
        self.assertEqual(result.name, "Customer")
        self.mock_ometa.get_by_id.assert_called_once_with(
            entity=GlossaryTermEntity, entity_id=self.term_id, fields=None
        )

    def test_term_with_synonyms(self):
        """Test glossary term with synonyms"""
        # Arrange
        expected_term = MagicMock(spec=GlossaryTermEntity)
        expected_term.id = UUID(self.term_id)
        expected_term.name = "Customer"
        expected_term.synonyms = ["Client", "Buyer", "Purchaser"]

        self.mock_ometa.get_by_id.return_value = expected_term

        # Act
        result = GlossaryTerms.retrieve(self.term_id)

        # Assert
        self.assertIsNotNone(result.synonyms)
        self.assertEqual(len(result.synonyms), 3)
        self.assertIn("Client", result.synonyms)

    def _skip_test_term_with_related_terms(self):
        """Test glossary term with related terms"""
        # Arrange
        related_term = TermReference(
            id=UUID("350e8400-e29b-41d4-a716-446655440000"),
            type="glossaryTerm",
            name="Order",
            displayName="Order",
        )

        expected_term = MagicMock(spec=GlossaryTermEntity)
        expected_term.id = UUID(self.term_id)
        expected_term.name = "Customer"
        expected_term.relatedTerms = [related_term]

        self.mock_ometa.get_by_id.return_value = expected_term

        # Act
        result = GlossaryTerms.retrieve(self.term_id, fields=["relatedTerms"])

        # Assert
        self.assertIsNotNone(result.relatedTerms)
        self.assertEqual(result.relatedTerms[0].name, "Order")

    def test_term_hierarchy(self):
        """Test glossary term with parent/children"""
        # Arrange
        parent_term = EntityReference(
            id=UUID("450e8400-e29b-41d4-a716-446655440000"),
            type="glossaryTerm",
            name="BusinessGlossary.Entity",
        )

        child_term = EntityReference(
            id=UUID("550e8400-e29b-41d4-a716-446655440000"),
            type="glossaryTerm",
            name="BusinessGlossary.Customer.Corporate",
        )

        expected_term = MagicMock(spec=GlossaryTermEntity)
        expected_term.id = UUID(self.term_id)
        expected_term.parent = parent_term
        expected_term.children = [child_term]

        self.mock_ometa.get_by_id.return_value = expected_term

        # Act
        result = GlossaryTerms.retrieve(self.term_id, fields=["parent", "children"])

        # Assert
        self.assertIsNotNone(result.parent)
        self.assertEqual(result.parent.name, "BusinessGlossary.Entity")
        self.assertIsNotNone(result.children)
        self.assertEqual(result.children[0].name, "BusinessGlossary.Customer.Corporate")

    def test_delete_glossary_term(self):
        """Test deleting a glossary term"""
        # Act
        GlossaryTerms.delete(self.term_id, recursive=False, hard_delete=True)

        # Assert
        self.mock_ometa.delete.assert_called_once_with(
            entity=GlossaryTermEntity,
            entity_id=self.term_id,
            recursive=False,
            hard_delete=True,
        )


if __name__ == "__main__":
    unittest.main()