tests/test_models.py - master - Roman_arv/UpnpUtil

tests/test_models.py
365 строк12 KB
Roman_arv
gigacode generated v2 Fix menu fix 2 choice
22 июл 2026, 13:54
22 июл 2026, 13:541add557
"""
Тесты для моделей данных DLNA/UPnP клиента.
"""

import pytest
from unittest.mock import Mock, patch

from dlna.models import (
    Track,
    Folder,
    Collection,
    ValidationError,
    validate_url,
    validate_filepath,
    validate_port,
    validate_object_id,
)


class TestTrack:
    """Тесты для модели Track."""

    def test_track_creation(self):
        """Тест создания трека."""
        track = Track(
            id="1",
            title="Song Title",
            artist="Artist Name",
            album="Album Name",
            genre="Rock",
            duration=180,
            url="http://example.com/song.mp3"
        )
        
        assert track.id == "1"
        assert track.title == "Song Title"
        assert track.artist == "Artist Name"
        assert track.album == "Album Name"
        assert track.genre == "Rock"
        assert track.duration == 180
        assert track.url == "http://example.com/song.mp3"

    def test_track_default_values(self):
        """Тест трека с значениями по умолчанию."""
        track = Track(id="1", title="Test")
        
        assert track.artist == ""
        assert track.album == ""
        assert track.genre == ""
        assert track.duration == 0
        assert track.url == ""

    def test_track_str_representation(self):
        """Тест строкового представления трека."""
        track = Track(
            id="1",
            title="Song",
            artist="Artist",
            album="Album"
        )
        
        assert str(track) == "Song - Artist (Album)"

    def test_track_to_dict(self):
        """Тест преобразования трека в словарь."""
        track = Track(
            id="1",
            title="Song",
            artist="Artist"
        )
        
        result = track.to_dict()
        
        assert result["id"] == "1"
        assert result["title"] == "Song"
        assert result["artist"] == "Artist"
        assert result["album"] == ""
        assert result["duration"] == 0


class TestFolder:
    """Тесты для модели Folder."""

    def test_folder_creation(self):
        """Тест создания папки."""
        folder = Folder(
            id="0",
            title="Music",
            parent_id="root"
        )
        
        assert folder.id == "0"
        assert folder.title == "Music"
        assert folder.parent_id == "root"
        assert len(folder.tracks) == 0
        assert len(folder.folders) == 0

    def test_folder_add_track(self):
        """Тест добавления трека в папку."""
        folder = Folder(id="0", title="Music")
        track = Track(id="1", title="Song")
        
        folder.add_track(track)
        
        assert len(folder.tracks) == 1
        assert folder.tracks[0] == track

    def test_folder_add_folder(self):
        """Тест добавления подпапки."""
        parent = Folder(id="0", title="Music")
        child = Folder(id="1", title="Rock", parent_id="0")
        
        parent.add_folder(child)
        
        assert len(parent.folders) == 1
        assert parent.folders[0] == child

    def test_folder_get_all_tracks(self):
        """Тест получения всех треков рекурсивно."""
        root = Folder(id="0", title="Music")
        rock = Folder(id="1", title="Rock", parent_id="0")
        
        track1 = Track(id="t1", title="Song 1")
        track2 = Track(id="t2", title="Song 2")
        track3 = Track(id="t3", title="Song 3")
        
        root.add_track(track1)
        rock.add_track(track2)
        root.add_folder(rock)
        root.tracks.append(track3)
        
        all_tracks = root.get_all_tracks()
        
        assert len(all_tracks) == 3
        assert track1 in all_tracks
        assert track2 in all_tracks
        assert track3 in all_tracks

    def test_folder_find_by_id(self):
        """Тест поиска элемента по ID."""
        root = Folder(id="0", title="Music")
        rock = Folder(id="1", title="Rock", parent_id="0")
        track = Track(id="t1", title="Song")
        
        root.add_folder(rock)
        rock.add_track(track)
        
        assert root.find_by_id("0") == root
        assert root.find_by_id("1") == rock
        assert root.find_by_id("t1") == track
        assert root.find_by_id("nonexistent") is None

    def test_folder_to_dict(self):
        """Тест преобразования папки в словарь."""
        folder = Folder(id="0", title="Music")
        track = Track(id="t1", title="Song")
        folder.add_track(track)
        
        result = folder.to_dict()
        
        assert result["id"] == "0"
        assert result["title"] == "Music"
        assert len(result["tracks"]) == 1
        assert result["tracks"][0]["title"] == "Song"


class TestCollection:
    """Тесты для модели Collection."""

    def test_collection_creation(self):
        """Тест создания коллекции."""
        root = Folder(id="0", title="Music")
        collection = Collection(
            name="My Library",
            server_name="Test Server",
            root_folder=root
        )
        
        assert collection.name == "My Library"
        assert collection.server_name == "Test Server"
        assert collection.root_folder == root

    def test_collection_get_all_tracks(self):
        """Тест получения всех треков коллекции."""
        root = Folder(id="0", title="Music")
        track1 = Track(id="t1", title="Song 1")
        track2 = Track(id="t2", title="Song 2")
        root.add_track(track1)
        root.add_track(track2)
        
        collection = Collection(
            name="My Library",
            server_name="Test Server",
            root_folder=root
        )
        
        tracks = collection.get_all_tracks()
        assert len(tracks) == 2
        assert track1 in tracks
        assert track2 in tracks

    def test_collection_get_genres(self):
        """Тест получения жанров."""
        root = Folder(id="0", title="Music")
        track1 = Track(id="t1", title="Song 1", genre="Rock")
        track2 = Track(id="t2", title="Song 2", genre="Jazz")
        track3 = Track(id="t3", title="Song 3", genre="rock")  # duplicate case
        root.add_track(track1)
        root.add_track(track2)
        root.add_track(track3)
        
        collection = Collection(
            name="My Library",
            server_name="Test Server",
            root_folder=root
        )
        
        genres = collection.get_genres()
        assert len(genres) == 2
        assert "jazz" in genres
        assert "rock" in genres

    def test_collection_get_artists(self):
        """Тест получения артистов."""
        root = Folder(id="0", title="Music")
        track1 = Track(id="t1", title="Song 1", artist="Artist A")
        track2 = Track(id="t2", title="Song 2", artist="Artist B")
        track3 = Track(id="t3", title="Song 3", artist="Artist A")  # duplicate
        root.add_track(track1)
        root.add_track(track2)
        root.add_track(track3)
        
        collection = Collection(
            name="My Library",
            server_name="Test Server",
            root_folder=root
        )
        
        artists = collection.get_artists()
        assert len(artists) == 2
        assert "artist a" in artists
        assert "artist b" in artists
        assert "Artist A" not in artists
        assert "Artist B" not in artists

    def test_collection_to_dict(self):
        """Тест преобразования коллекции в словарь."""
        root = Folder(id="0", title="Music")
        track = Track(id="t1", title="Song", artist="Artist")
        root.add_track(track)
        
        collection = Collection(
            name="My Library",
            server_name="Test Server",
            root_folder=root
        )
        
        result = collection.to_dict()
        
        assert result["name"] == "My Library"
        assert result["server_name"] == "Test Server"
        assert result["stats"]["total_tracks"] == 1


class TestValidation:
    """Тесты для функций валидации."""

    def test_validate_url_valid(self):
        """Тест валидного URL."""
        assert validate_url("http://example.com") is True
        assert validate_url("https://example.com:8080/path") is True
        assert validate_url("http://localhost") is True

    def test_validate_url_invalid(self):
        """Тест некорректного URL."""
        with pytest.raises(ValidationError):
            validate_url("")
        
        with pytest.raises(ValidationError):
            validate_url("ftp://example.com")
        
        with pytest.raises(ValidationError):
            validate_url("not-a-url")
        
        with pytest.raises(ValidationError):
            validate_url(None)

    def test_validate_filepath_valid(self):
        """Тест валидного пути к файлу."""
        assert validate_filepath("/path/to/file.json") is True
        assert validate_filepath("relative/path.txt") is True

    def test_validate_filepath_invalid(self):
        """Тест некорректного пути к файлу."""
        with pytest.raises(ValidationError):
            validate_filepath("")
        
        with pytest.raises(ValidationError):
            validate_filepath("/path/with<invalid>chars.txt")

    def test_validate_port_valid(self):
        """Тест валидного порта."""
        assert validate_port(80) is True
        assert validate_port(8080) is True
        assert validate_port(65535) is True

    def test_validate_port_invalid(self):
        """Тест некорректного порта."""
        with pytest.raises(ValidationError):
            validate_port(0)
        
        with pytest.raises(ValidationError):
            validate_port(65536)
        
        with pytest.raises(ValidationError):
            validate_port("8080")

    def test_validate_object_id_valid(self):
        """Тест валидного ID объекта."""
        assert validate_object_id("0") is True
        assert validate_object_id("folder_1") is True
        assert validate_object_id("track-123") is True

    def test_validate_object_id_invalid(self):
        """Тест некорректного ID объекта."""
        with pytest.raises(ValidationError):
            validate_object_id("")
        
        with pytest.raises(ValidationError):
            validate_object_id("folder with spaces")
        
        with pytest.raises(ValidationError):
            validate_object_id("<script>")


class TestUPnPClientMock:
    """Тесты UPnPClient с моками."""

    @patch('dlna.models.api.upnpclient')
    def test_find_devices(self, mock_upnpclient):
        """Тест поиска устройств."""
        # Настроим мок (upnpclient 2.x использует services, а не serviceList)
        mock_service = Mock()
        mock_service.service_type = "urn:schemas-upnp-org:service:ContentDirectory:1"
        mock_service.service_id = "urn:upnp-org:serviceId:contentdir"
        
        mock_device = Mock()
        mock_device.friendly_name = "Test Server"
        mock_device.device_type = "urn:schemas-upnp-org:device:MediaServer:1"
        mock_device.location = "http://example.com"
        mock_device.udn = "uuid:test"
        mock_device.manufacturer = "Test"
        mock_device.model_name = "Test Model"
        mock_device.model_description = "Test Description"
        mock_device.services = [mock_service]  # upnpclient 2.x
        
        mock_upnpclient.discover.return_value = [mock_device]
        
        from dlna.models import UPnPClient
        client = UPnPClient()
        
        devices = client.find_devices()
        
        assert len(devices) == 1
        assert devices[0].friendly_name == "Test Server"