tests/test_metadata.py

"""
Testes para sistema de metadados.
"""

import pytest
from datetime import datetime
from src.metadata import DocumentMetadata, MetadataManager


class TestDocumentMetadata:
    """Testes para classe DocumentMetadata."""

    def test_create_metadata(self):
        """Testa criacao de metadata."""
        metadata = DocumentMetadata(
            document_type="PDF",
            tags=["tech", "ai"],
            author="John Doe"
        )

        assert metadata.document_type == "PDF"
        assert metadata.tags == ["tech", "ai"]
        assert metadata.author == "John Doe"

    def test_to_dict(self):
        """Testa conversao para dicionario."""
        metadata = DocumentMetadata(
            document_type="PDF",
            upload_date=datetime(2026, 1, 23, 10, 30),
            tags=["tech"]
        )

        data = metadata.to_dict()

        assert data['document_type'] == "PDF"
        assert data['upload_date'] == "2026-01-23T10:30:00"
        assert data['tags'] == ["tech"]
        assert 'author' not in data  # None nao deve aparecer

    def test_from_dict(self):
        """Testa criacao a partir de dicionario."""
        data = {
            'document_type': 'TXT',
            'upload_date': '2026-01-23T10:30:00',
            'tags': ['doc', 'test']
        }

        metadata = DocumentMetadata.from_dict(data)

        assert metadata.document_type == 'TXT'
        assert metadata.upload_date == datetime(2026, 1, 23, 10, 30)
        assert metadata.tags == ['doc', 'test']

    def test_to_json(self):
        """Testa conversao para JSON."""
        metadata = DocumentMetadata(
            document_type="PDF",
            tags=["tech"]
        )

        json_str = metadata.to_json()

        assert '"document_type": "PDF"' in json_str
        assert '"tags": ["tech"]' in json_str

    def test_from_json(self):
        """Testa criacao a partir de JSON."""
        json_str = '{"document_type": "PDF", "tags": ["tech"], "author": "Test"}'

        metadata = DocumentMetadata.from_json(json_str)

        assert metadata.document_type == "PDF"
        assert metadata.tags == ["tech"]
        assert metadata.author == "Test"


class TestMetadataManager:
    """Testes para classe MetadataManager."""

    @pytest.fixture
    def mock_db(self, mocker):
        """Mock do DatabaseManager."""
        return mocker.Mock()

    @pytest.fixture
    def manager(self, mock_db):
        """Instancia de MetadataManager."""
        return MetadataManager(mock_db)

    def test_validate_metadata_valid(self, manager):
        """Testa validacao de metadata valido."""
        metadata = DocumentMetadata(
            document_type="PDF",
            security_level="public",
            tags=["tech", "ai"]
        )

        assert manager.validate_metadata(metadata) is True

    def test_validate_metadata_invalid_type(self, manager):
        """Testa validacao com tipo invalido."""
        metadata = DocumentMetadata(
            document_type="INVALID"
        )

        with pytest.raises(ValueError, match="document_type invalido"):
            manager.validate_metadata(metadata)

    def test_validate_metadata_invalid_security(self, manager):
        """Testa validacao com security_level invalido."""
        metadata = DocumentMetadata(
            security_level="top_secret"  # Nao existe
        )

        with pytest.raises(ValueError, match="security_level invalido"):
            manager.validate_metadata(metadata)

    def test_validate_metadata_invalid_tags(self, manager):
        """Testa validacao com tags invalidas."""
        metadata = DocumentMetadata(
            tags="not_a_list"  # Deve ser lista
        )

        with pytest.raises(ValueError, match="tags deve ser uma lista"):
            manager.validate_metadata(metadata)

    def test_build_filters_dict(self):
        """Testa construcao de dicionario de filtros."""
        from ui.filters_component import build_filters_dict

        filters = build_filters_dict(
            doc_type="PDF",
            security_level="public",
            author="John",
            department=None,
            tags=["tech", "ai"],
            date_from="2026-01-01",
            date_to="2026-12-31"
        )

        assert filters['document_type'] == "PDF"
        assert filters['security_level'] == "public"
        assert filters['author'] == "John"
        assert 'department' not in filters
        assert filters['tags'] == ["tech", "ai"]
        assert filters['upload_date_from'] == "2026-01-01"
        assert filters['upload_date_to'] == "2026-12-31"

    def test_build_filters_dict_invalid_date(self):
        """Testa que datas invalidas sao ignoradas."""
        from ui.filters_component import build_filters_dict

        filters = build_filters_dict(
            doc_type="PDF",
            security_level=None,
            author=None,
            department=None,
            tags=None,
            date_from="invalid-date",
            date_to="2026-99-99"
        )

        assert 'upload_date_from' not in filters
        assert 'upload_date_to' not in filters

    def test_format_active_filters(self):
        """Testa formatacao de filtros ativos."""
        from ui.filters_component import format_active_filters

        filters = {
            'document_type': 'PDF',
            'tags': ['tech', 'ai'],
            'author': 'John'
        }

        formatted = format_active_filters(filters)

        assert '**Filtros Ativos:**' in formatted
        assert 'Tipo: `PDF`' in formatted
        assert 'Tags: `tech`, `ai`' in formatted
        assert 'Autor: `John`' in formatted

    def test_format_active_filters_empty(self):
        """Testa formatacao com filtros vazios."""
        from ui.filters_component import format_active_filters

        formatted = format_active_filters({})

        assert formatted == "Nenhum filtro ativo"

    def test_clear_all_filters(self):
        """Testa limpeza de todos os filtros."""
        from ui.filters_component import clear_all_filters

        result = clear_all_filters()

        assert result[0] is None  # doc_type
        assert result[1] is None  # security_level
        assert result[2] is None  # author
        assert result[3] is None  # department
        assert result[4] is None  # tags
        assert result[5] == ""    # date_from
        assert result[6] == ""    # date_to
        assert result[7] == "Nenhum filtro ativo"


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