nomy-data-models 0.33.0

"""Tests for the service_state module."""

import pytest

from nomy_data_models.models.enums import ProcessingState
from nomy_data_models.models.service_state import ServiceState


@pytest.fixture
def service_state_model():
    """Fixture providing a ServiceState instance.

    Returns:
        ServiceState: A ServiceState instance with pending state
    """
    model = ServiceState()
    model.service_name = "test_service"
    model.instance_id = "test_instance"
    model.service_state = ProcessingState.PENDING
    return model


@pytest.fixture
def service_state_model_with_error():
    """Fixture providing a ServiceState instance with error.

    Returns:
        ServiceState: A ServiceState instance with failed state and error message
    """
    model = ServiceState()
    model.service_name = "test_service"
    model.instance_id = "test_instance_error"
    model.service_state = ProcessingState.FAILED
    model.error_message = "Test error message"
    return model


@pytest.fixture
def service_state_model_with_result():
    """Fixture providing a ServiceState instance with result.

    Returns:
        ServiceState: A ServiceState instance with completed state and result
    """
    model = ServiceState()
    model.service_name = "test_service"
    model.instance_id = "test_instance_result"
    model.service_state = ProcessingState.COMPLETED
    model.service_result = {"status": "success", "data": {"key": "value"}}
    return model


class TestExecutionState:
    """Tests for the ProcessingState enum."""

    def test_service_state_values(self):
        """Test that ProcessingState has the expected values."""
        assert ProcessingState.PENDING.value == "pending"
        assert ProcessingState.RUNNING.value == "running"
        assert ProcessingState.COMPLETED.value == "completed"
        assert ProcessingState.FAILED.value == "failed"

    def test_service_state_comparison(self):
        """Test that ProcessingState values can be compared."""
        assert ProcessingState.PENDING == ProcessingState.PENDING
        assert ProcessingState.PENDING != ProcessingState.RUNNING
        assert ProcessingState.PENDING != ProcessingState.COMPLETED
        assert ProcessingState.PENDING != ProcessingState.FAILED


class TestServiceState:
    """Tests for the ServiceState class."""

    def test_service_state_model_creation(self, service_state_model):
        """Test creating a ServiceState instance."""
        assert service_state_model.service_name == "test_service"
        assert service_state_model.instance_id == "test_instance"
        assert service_state_model.service_state == ProcessingState.PENDING
        assert service_state_model.error_message is None
        assert service_state_model.service_result is None

    def test_service_state_model_with_error(self, service_state_model_with_error):
        """Test creating a ServiceState instance with error."""
        assert service_state_model_with_error.service_name == "test_service"
        assert service_state_model_with_error.instance_id == "test_instance_error"
        assert service_state_model_with_error.service_state == ProcessingState.FAILED
        assert service_state_model_with_error.error_message == "Test error message"
        assert service_state_model_with_error.service_result is None

    def test_service_state_model_with_result(self, service_state_model_with_result):
        """Test creating a ServiceState instance with result."""
        assert service_state_model_with_result.service_name == "test_service"
        assert service_state_model_with_result.instance_id == "test_instance_result"
        assert (
            service_state_model_with_result.service_state == ProcessingState.COMPLETED
        )
        assert service_state_model_with_result.error_message is None
        assert service_state_model_with_result.service_result == {
            "status": "success",
            "data": {"key": "value"},
        }

    def test_service_state_model_repr(self, service_state_model):
        """Test the string representation of ServiceState."""
        expected = (
            "<ServiceState(service=test_service, "
            "instance=test_instance, "
            "state=pending)>"
        )
        assert str(service_state_model) == expected

    def test_service_state_model_db_integration(self, session):
        """Test database integration for ServiceState."""
        # Create a new model instance
        model = ServiceState()
        model.service_name = "test_service"
        model.instance_id = "test_instance"
        model.service_state = ProcessingState.PENDING

        # Add to session and commit
        session.add(model)
        session.commit()

        # Query back and verify
        queried = (
            session.query(ServiceState)
            .filter_by(service_name="test_service", instance_id="test_instance")
            .first()
        )

        assert queried is not None
        assert queried.service_name == "test_service"
        assert queried.instance_id == "test_instance"
        assert queried.service_state == ProcessingState.PENDING

    def test_service_state_model_update(self, session):
        """Test updating a ServiceState instance."""
        # Create and save initial state
        model = ServiceState()
        model.service_name = "test_service"
        model.instance_id = "test_instance"
        model.service_state = ProcessingState.PENDING

        session.add(model)
        session.commit()

        # Update state
        model.service_state = ProcessingState.RUNNING
        session.commit()

        # Query back and verify
        queried = (
            session.query(ServiceState)
            .filter_by(service_name="test_service", instance_id="test_instance")
            .first()
        )

        assert queried is not None
        assert queried.service_state == ProcessingState.RUNNING


if __name__ == "__main__":
    pytest.main(["-v", __file__])