Refactor server module to use dedicated public directory and enhance tests for run_server and get_public_dir functions

.gitignore

@@ -42,3 +42,6 @@ Thumbs.db
 
 # --- Logs ---
 *.log
+
+# --- Archivos Generados ---
+public/

src/m3u_list_builder/playlist.py

@@ -10,6 +10,9 @@ from m3u_list_builder.config import settings
 
 logger = logging.getLogger(__name__)
 
+# Directorio dedicado para servir archivos
+PUBLIC_DIR = Path("public")
+
 
 class PlaylistManager:
     """Clase para gestionar la generación y actualización de listas M3U."""
@@ -17,6 +20,8 @@ class PlaylistManager:
     def __init__(self):
         """Inicialize the PlaylistManager."""
         self.running = False
+        # Asegurar que el directorio público existe
+        PUBLIC_DIR.mkdir(exist_ok=True)
 
     def fetch_and_generate(self):
         """Descarga datos y regenera el archivo M3U."""
@@ -46,8 +51,8 @@ class PlaylistManager:
 
     def _write_m3u(self, channels: list):
         """Escribe el archivo M3U en disco de forma atómica."""
-        temp_file = Path(f"{settings.output_file}.tmp")
-        final_file = Path(settings.output_file)
+        temp_file = PUBLIC_DIR / f"{settings.output_file}.tmp"
+        final_file = PUBLIC_DIR / settings.output_file
 
         with open(temp_file, "w", encoding="utf-8") as f:
             f.write("#EXTM3U\n")

src/m3u_list_builder/server.py

@@ -1,22 +1,31 @@
 import logging
 from functools import partial
 from http.server import SimpleHTTPRequestHandler, ThreadingHTTPServer
+from pathlib import Path
 
 from m3u_list_builder.config import settings
 
 logger = logging.getLogger(__name__)
 
+# Directorio dedicado para servir archivos (solo playlist)
+PUBLIC_DIR = Path("public")
+
+
+def get_public_dir() -> Path:
+    """Retorna el directorio público, creándolo si no existe."""
+    PUBLIC_DIR.mkdir(exist_ok=True)
+    return PUBLIC_DIR
+
 
 def run_server():
     """Inicia el servidor HTTP bloqueante."""
-    _ = partial(SimpleHTTPRequestHandler, directory=".")
+    public_dir = get_public_dir()
 
-    # Truco: SimpleHTTPRequestHandler sirve el directorio actual,
-    # asegurarse de que el CWD es correcto o mover el archivo a una carpeta 'public'
-    # Para este ejemplo simple, asumimos que se ejecuta donde se genera el archivo.
+    # Handler que sirve solo el directorio 'public'
+    handler = partial(SimpleHTTPRequestHandler, directory=str(public_dir))
 
     server_address = ("", settings.port)
-    httpd = ThreadingHTTPServer(server_address, SimpleHTTPRequestHandler)
+    httpd = ThreadingHTTPServer(server_address, handler)
 
     logger.info(
         f"Servidor M3U activo en http://localhost:{settings.port}/{settings.output_file}"

tests/test_playlist.py

@@ -219,51 +219,49 @@ class TestPlaylistManager:
 
     def test_write_m3u_empty_channels(self, temp_dir):
         """Test: _write_m3u genera archivo con solo header para lista vacía."""
-        output_file = temp_dir / "playlist.m3u"
+        with patch("m3u_list_builder.playlist.PUBLIC_DIR", temp_dir):
+            with patch("m3u_list_builder.playlist.settings") as mock_settings:
+                mock_settings.host = "http://test-iptv.com"
+                mock_settings.username = "testuser"
+                mock_settings.password = "testpass"
+                mock_settings.output_file = "playlist.m3u"
 
-        with patch("m3u_list_builder.playlist.settings") as mock_settings:
-            mock_settings.host = "http://test-iptv.com"
-            mock_settings.username = "testuser"
-            mock_settings.password = "testpass"
-            mock_settings.output_file = str(output_file)
+                from m3u_list_builder.playlist import PlaylistManager
 
-            from m3u_list_builder.playlist import PlaylistManager
+                manager = PlaylistManager()
+                manager._write_m3u([])
 
-            manager = PlaylistManager()
-            manager._write_m3u([])
-
-            content = output_file.read_text()
-            assert content == "#EXTM3U\n"
+                output_file = temp_dir / "playlist.m3u"
+                content = output_file.read_text()
+                assert content == "#EXTM3U\n"
 
     def test_write_m3u_multiple_channels(self, temp_dir, sample_channels):
         """Test: _write_m3u genera archivo correcto con múltiples canales."""
-        output_file = temp_dir / "playlist.m3u"
+        with patch("m3u_list_builder.playlist.PUBLIC_DIR", temp_dir):
+            with patch("m3u_list_builder.playlist.settings") as mock_settings:
+                mock_settings.host = "http://test-iptv.com"
+                mock_settings.username = "testuser"
+                mock_settings.password = "testpass"
+                mock_settings.output_file = "playlist.m3u"
 
-        with patch("m3u_list_builder.playlist.settings") as mock_settings:
-            mock_settings.host = "http://test-iptv.com"
-            mock_settings.username = "testuser"
-            mock_settings.password = "testpass"
-            mock_settings.output_file = str(output_file)
+                from m3u_list_builder.playlist import PlaylistManager
 
-            from m3u_list_builder.playlist import PlaylistManager
+                manager = PlaylistManager()
+                manager._write_m3u(sample_channels)
 
-            manager = PlaylistManager()
-            manager._write_m3u(sample_channels)
+                output_file = temp_dir / "playlist.m3u"
+                content = output_file.read_text()
 
-            content = output_file.read_text()
+                # Verificar header
+                assert content.startswith("#EXTM3U\n")
 
-            # Verificar header
-            assert content.startswith("#EXTM3U\n")
-
-            # Verificar cada canal
-            for channel in sample_channels:
-                assert channel["name"] in content
-                assert str(channel["stream_id"]) in content
+                # Verificar cada canal
+                for channel in sample_channels:
+                    assert channel["name"] in content
+                    assert str(channel["stream_id"]) in content
 
     def test_write_m3u_channel_format(self, temp_dir):
         """Test: _write_m3u genera formato EXTINF correcto."""
-        output_file = temp_dir / "playlist.m3u"
-
         channel = [
             {
                 "name": "Test Channel",
@@ -273,52 +271,54 @@ class TestPlaylistManager:
             }
         ]
 
-        with patch("m3u_list_builder.playlist.settings") as mock_settings:
-            mock_settings.host = "http://iptv.com"
-            mock_settings.username = "user"
-            mock_settings.password = "pass"
-            mock_settings.output_file = str(output_file)
+        with patch("m3u_list_builder.playlist.PUBLIC_DIR", temp_dir):
+            with patch("m3u_list_builder.playlist.settings") as mock_settings:
+                mock_settings.host = "http://iptv.com"
+                mock_settings.username = "user"
+                mock_settings.password = "pass"
+                mock_settings.output_file = "playlist.m3u"
 
-            from m3u_list_builder.playlist import PlaylistManager
+                from m3u_list_builder.playlist import PlaylistManager
 
-            manager = PlaylistManager()
-            manager._write_m3u(channel)
+                manager = PlaylistManager()
+                manager._write_m3u(channel)
 
-            content = output_file.read_text()
-            lines = content.strip().split("\n")
+                output_file = temp_dir / "playlist.m3u"
+                content = output_file.read_text()
+                lines = content.strip().split("\n")
 
-            assert len(lines) == 3  # Header + EXTINF + URL
+                assert len(lines) == 3  # Header + EXTINF + URL
 
-            # Verificar EXTINF
-            assert '#EXTINF:-1 tvg-id="Test Channel"' in lines[1]
-            assert 'tvg-logo="http://icon.com/test.png"' in lines[1]
-            assert 'group-title="Cat_5"' in lines[1]
-            assert lines[1].endswith(",Test Channel")
+                # Verificar EXTINF
+                assert '#EXTINF:-1 tvg-id="Test Channel"' in lines[1]
+                assert 'tvg-logo="http://icon.com/test.png"' in lines[1]
+                assert 'group-title="Cat_5"' in lines[1]
+                assert lines[1].endswith(",Test Channel")
 
-            # Verificar URL
-            assert lines[2] == "http://iptv.com/live/user/pass/123.ts"
+                # Verificar URL
+                assert lines[2] == "http://iptv.com/live/user/pass/123.ts"
 
     def test_write_m3u_missing_fields_uses_defaults(self, temp_dir, minimal_channel):
         """Test: _write_m3u usa valores por defecto para campos faltantes."""
-        output_file = temp_dir / "playlist.m3u"
+        with patch("m3u_list_builder.playlist.PUBLIC_DIR", temp_dir):
+            with patch("m3u_list_builder.playlist.settings") as mock_settings:
+                mock_settings.host = "http://test-iptv.com"
+                mock_settings.username = "testuser"
+                mock_settings.password = "testpass"
+                mock_settings.output_file = "playlist.m3u"
 
-        with patch("m3u_list_builder.playlist.settings") as mock_settings:
-            mock_settings.host = "http://test-iptv.com"
-            mock_settings.username = "testuser"
-            mock_settings.password = "testpass"
-            mock_settings.output_file = str(output_file)
+                from m3u_list_builder.playlist import PlaylistManager
 
-            from m3u_list_builder.playlist import PlaylistManager
+                manager = PlaylistManager()
+                manager._write_m3u(minimal_channel)
 
-            manager = PlaylistManager()
-            manager._write_m3u(minimal_channel)
+                output_file = temp_dir / "playlist.m3u"
+                content = output_file.read_text()
 
-            content = output_file.read_text()
-
-            # Debe usar "Unknown" como nombre por defecto
-            assert "Unknown" in content
-            # Debe tener icono vacío
-            assert 'tvg-logo=""' in content
+                # Debe usar "Unknown" como nombre por defecto
+                assert "Unknown" in content
+                # Debe tener icono vacío
+                assert 'tvg-logo=""' in content
 
     def test_write_m3u_atomic_replacement(self, temp_dir):
         """Test: _write_m3u reemplaza atómicamente (usa archivo temporal)."""
@@ -328,22 +328,23 @@ class TestPlaylistManager:
         # Crear archivo existente
         output_file.write_text("OLD CONTENT")
 
-        with patch("m3u_list_builder.playlist.settings") as mock_settings:
-            mock_settings.host = "http://test-iptv.com"
-            mock_settings.username = "testuser"
-            mock_settings.password = "testpass"
-            mock_settings.output_file = str(output_file)
+        with patch("m3u_list_builder.playlist.PUBLIC_DIR", temp_dir):
+            with patch("m3u_list_builder.playlist.settings") as mock_settings:
+                mock_settings.host = "http://test-iptv.com"
+                mock_settings.username = "testuser"
+                mock_settings.password = "testpass"
+                mock_settings.output_file = "playlist.m3u"
 
-            from m3u_list_builder.playlist import PlaylistManager
+                from m3u_list_builder.playlist import PlaylistManager
 
-            manager = PlaylistManager()
-            manager._write_m3u([])
+                manager = PlaylistManager()
+                manager._write_m3u([])
 
-            # El archivo temporal no debe existir después
-            assert not temp_file.exists()
+                # El archivo temporal no debe existir después
+                assert not temp_file.exists()
 
-            # El archivo final debe tener el nuevo contenido
-            assert output_file.read_text() == "#EXTM3U\n"
+                # El archivo final debe tener el nuevo contenido
+                assert output_file.read_text() == "#EXTM3U\n"
 
     # ========================================
     # Tests para loop - Complejidad Media

tests/test_server.py

@@ -1,5 +1,7 @@
 """Tests unitarios para el módulo server."""
 
+import tempfile
+from pathlib import Path
 from unittest.mock import MagicMock, patch
 
 
@@ -15,165 +17,228 @@ class TestRunServer:
 
     def test_run_server_creates_server_with_correct_address(self):
         """Test: run_server crea servidor en la dirección correcta."""
-        with patch("m3u_list_builder.server.settings") as mock_settings:
-            mock_settings.port = 9999
-            mock_settings.output_file = "test.m3u"
-
+        with tempfile.TemporaryDirectory() as tmpdir:
             with patch(
-                "m3u_list_builder.server.ThreadingHTTPServer"
-            ) as mock_server_class:
-                mock_server = MagicMock()
-                mock_server.serve_forever.side_effect = KeyboardInterrupt()
-                mock_server_class.return_value = mock_server
+                "m3u_list_builder.server.get_public_dir", return_value=Path(tmpdir)
+            ):
+                with patch("m3u_list_builder.server.settings") as mock_settings:
+                    mock_settings.port = 9999
+                    mock_settings.output_file = "test.m3u"
 
-                from m3u_list_builder.server import run_server
+                    with patch(
+                        "m3u_list_builder.server.ThreadingHTTPServer"
+                    ) as mock_server_class:
+                        mock_server = MagicMock()
+                        mock_server.serve_forever.side_effect = KeyboardInterrupt()
+                        mock_server_class.return_value = mock_server
 
-                run_server()
+                        from m3u_list_builder.server import run_server
 
-                # Verificar que se creó con la dirección correcta
-                mock_server_class.assert_called_once()
-                call_args = mock_server_class.call_args[0]
-                assert call_args[0] == ("", 9999)
+                        run_server()
+
+                        # Verificar que se creó con la dirección correcta
+                        mock_server_class.assert_called_once()
+                        call_args = mock_server_class.call_args[0]
+                        assert call_args[0] == ("", 9999)
 
     def test_run_server_uses_correct_port(self):
         """Test: run_server usa el puerto de settings."""
-        with patch("m3u_list_builder.server.settings") as mock_settings:
-            mock_settings.port = 8080
-            mock_settings.output_file = "playlist.m3u"
-
+        with tempfile.TemporaryDirectory() as tmpdir:
             with patch(
-                "m3u_list_builder.server.ThreadingHTTPServer"
-            ) as mock_server_class:
-                mock_server = MagicMock()
-                mock_server.serve_forever.side_effect = KeyboardInterrupt()
-                mock_server_class.return_value = mock_server
+                "m3u_list_builder.server.get_public_dir", return_value=Path(tmpdir)
+            ):
+                with patch("m3u_list_builder.server.settings") as mock_settings:
+                    mock_settings.port = 8080
+                    mock_settings.output_file = "playlist.m3u"
 
-                from m3u_list_builder.server import run_server
+                    with patch(
+                        "m3u_list_builder.server.ThreadingHTTPServer"
+                    ) as mock_server_class:
+                        mock_server = MagicMock()
+                        mock_server.serve_forever.side_effect = KeyboardInterrupt()
+                        mock_server_class.return_value = mock_server
 
-                run_server()
+                        from m3u_list_builder.server import run_server
 
-                call_args = mock_server_class.call_args[0]
-                assert call_args[0][1] == 8080
+                        run_server()
+
+                        call_args = mock_server_class.call_args[0]
+                        assert call_args[0][1] == 8080
 
     def test_run_server_calls_serve_forever(self):
         """Test: run_server llama a serve_forever."""
-        with patch("m3u_list_builder.server.settings") as mock_settings:
-            mock_settings.port = 8080
-            mock_settings.output_file = "playlist.m3u"
-
+        with tempfile.TemporaryDirectory() as tmpdir:
             with patch(
-                "m3u_list_builder.server.ThreadingHTTPServer"
-            ) as mock_server_class:
-                mock_server = MagicMock()
-                mock_server.serve_forever.side_effect = KeyboardInterrupt()
-                mock_server_class.return_value = mock_server
+                "m3u_list_builder.server.get_public_dir", return_value=Path(tmpdir)
+            ):
+                with patch("m3u_list_builder.server.settings") as mock_settings:
+                    mock_settings.port = 8080
+                    mock_settings.output_file = "playlist.m3u"
 
-                from m3u_list_builder.server import run_server
+                    with patch(
+                        "m3u_list_builder.server.ThreadingHTTPServer"
+                    ) as mock_server_class:
+                        mock_server = MagicMock()
+                        mock_server.serve_forever.side_effect = KeyboardInterrupt()
+                        mock_server_class.return_value = mock_server
 
-                run_server()
+                        from m3u_list_builder.server import run_server
 
-                mock_server.serve_forever.assert_called_once()
+                        run_server()
+
+                        mock_server.serve_forever.assert_called_once()
 
     def test_run_server_handles_keyboard_interrupt(self):
         """Test: run_server maneja KeyboardInterrupt sin crash."""
-        with patch("m3u_list_builder.server.settings") as mock_settings:
-            mock_settings.port = 8080
-            mock_settings.output_file = "playlist.m3u"
-
+        with tempfile.TemporaryDirectory() as tmpdir:
             with patch(
-                "m3u_list_builder.server.ThreadingHTTPServer"
-            ) as mock_server_class:
-                mock_server = MagicMock()
-                mock_server.serve_forever.side_effect = KeyboardInterrupt()
-                mock_server_class.return_value = mock_server
+                "m3u_list_builder.server.get_public_dir", return_value=Path(tmpdir)
+            ):
+                with patch("m3u_list_builder.server.settings") as mock_settings:
+                    mock_settings.port = 8080
+                    mock_settings.output_file = "playlist.m3u"
 
-                from m3u_list_builder.server import run_server
+                    with patch(
+                        "m3u_list_builder.server.ThreadingHTTPServer"
+                    ) as mock_server_class:
+                        mock_server = MagicMock()
+                        mock_server.serve_forever.side_effect = KeyboardInterrupt()
+                        mock_server_class.return_value = mock_server
 
-                # No debe lanzar excepción
-                run_server()
+                        from m3u_list_builder.server import run_server
+
+                        # No debe lanzar excepción
+                        run_server()
 
     def test_run_server_closes_server_on_interrupt(self):
         """Test: run_server cierra el servidor tras KeyboardInterrupt."""
-        with patch("m3u_list_builder.server.settings") as mock_settings:
-            mock_settings.port = 8080
-            mock_settings.output_file = "playlist.m3u"
-
+        with tempfile.TemporaryDirectory() as tmpdir:
             with patch(
-                "m3u_list_builder.server.ThreadingHTTPServer"
-            ) as mock_server_class:
-                mock_server = MagicMock()
-                mock_server.serve_forever.side_effect = KeyboardInterrupt()
-                mock_server_class.return_value = mock_server
+                "m3u_list_builder.server.get_public_dir", return_value=Path(tmpdir)
+            ):
+                with patch("m3u_list_builder.server.settings") as mock_settings:
+                    mock_settings.port = 8080
+                    mock_settings.output_file = "playlist.m3u"
 
-                from m3u_list_builder.server import run_server
+                    with patch(
+                        "m3u_list_builder.server.ThreadingHTTPServer"
+                    ) as mock_server_class:
+                        mock_server = MagicMock()
+                        mock_server.serve_forever.side_effect = KeyboardInterrupt()
+                        mock_server_class.return_value = mock_server
 
-                run_server()
+                        from m3u_list_builder.server import run_server
 
-                mock_server.server_close.assert_called_once()
+                        run_server()
+
+                        mock_server.server_close.assert_called_once()
 
     def test_run_server_closes_server_on_normal_exit(self):
         """Test: run_server cierra el servidor en salida normal."""
-        with patch("m3u_list_builder.server.settings") as mock_settings:
-            mock_settings.port = 8080
-            mock_settings.output_file = "playlist.m3u"
-
+        with tempfile.TemporaryDirectory() as tmpdir:
             with patch(
-                "m3u_list_builder.server.ThreadingHTTPServer"
-            ) as mock_server_class:
-                mock_server = MagicMock()
-                # Simular que serve_forever termina normalmente
-                mock_server.serve_forever.return_value = None
-                mock_server_class.return_value = mock_server
+                "m3u_list_builder.server.get_public_dir", return_value=Path(tmpdir)
+            ):
+                with patch("m3u_list_builder.server.settings") as mock_settings:
+                    mock_settings.port = 8080
+                    mock_settings.output_file = "playlist.m3u"
 
-                from m3u_list_builder.server import run_server
+                    with patch(
+                        "m3u_list_builder.server.ThreadingHTTPServer"
+                    ) as mock_server_class:
+                        mock_server = MagicMock()
+                        # Simular que serve_forever termina normalmente
+                        mock_server.serve_forever.return_value = None
+                        mock_server_class.return_value = mock_server
 
-                run_server()
+                        from m3u_list_builder.server import run_server
 
-                mock_server.server_close.assert_called_once()
+                        run_server()
+
+                        mock_server.server_close.assert_called_once()
 
     def test_run_server_logs_startup_message(self, caplog):
         """Test: run_server registra mensaje de inicio."""
-        with patch("m3u_list_builder.server.settings") as mock_settings:
-            mock_settings.port = 8080
-            mock_settings.output_file = "playlist.m3u"
-
+        with tempfile.TemporaryDirectory() as tmpdir:
             with patch(
-                "m3u_list_builder.server.ThreadingHTTPServer"
-            ) as mock_server_class:
-                mock_server = MagicMock()
-                mock_server.serve_forever.side_effect = KeyboardInterrupt()
-                mock_server_class.return_value = mock_server
+                "m3u_list_builder.server.get_public_dir", return_value=Path(tmpdir)
+            ):
+                with patch("m3u_list_builder.server.settings") as mock_settings:
+                    mock_settings.port = 8080
+                    mock_settings.output_file = "playlist.m3u"
 
-                import logging
+                    with patch(
+                        "m3u_list_builder.server.ThreadingHTTPServer"
+                    ) as mock_server_class:
+                        mock_server = MagicMock()
+                        mock_server.serve_forever.side_effect = KeyboardInterrupt()
+                        mock_server_class.return_value = mock_server
 
-                with caplog.at_level(logging.INFO):
-                    from m3u_list_builder.server import run_server
+                        import logging
 
-                    run_server()
+                        with caplog.at_level(logging.INFO):
+                            from m3u_list_builder.server import run_server
 
-                    # El mensaje puede estar en el log
-                    # Nota: Dependiendo del orden de imports, puede que no se capture
-
-    def test_run_server_uses_simple_http_handler(self):
-        """Test: run_server usa SimpleHTTPRequestHandler."""
-        with patch("m3u_list_builder.server.settings") as mock_settings:
-            mock_settings.port = 8080
-            mock_settings.output_file = "playlist.m3u"
+                            run_server()
 
+    def test_run_server_serves_from_public_dir(self):
+        """Test: run_server sirve desde el directorio public."""
+        with tempfile.TemporaryDirectory() as tmpdir:
+            public_path = Path(tmpdir)
             with patch(
-                "m3u_list_builder.server.ThreadingHTTPServer"
-            ) as mock_server_class:
-                with patch(
-                    "m3u_list_builder.server.SimpleHTTPRequestHandler"
-                ) as mock_handler:
-                    mock_server = MagicMock()
-                    mock_server.serve_forever.side_effect = KeyboardInterrupt()
-                    mock_server_class.return_value = mock_server
+                "m3u_list_builder.server.get_public_dir", return_value=public_path
+            ):
+                with patch("m3u_list_builder.server.settings") as mock_settings:
+                    mock_settings.port = 8080
+                    mock_settings.output_file = "playlist.m3u"
 
-                    from m3u_list_builder.server import run_server
+                    with patch(
+                        "m3u_list_builder.server.ThreadingHTTPServer"
+                    ) as mock_server_class:
+                        with patch(
+                            "m3u_list_builder.server.partial"
+                        ) as mock_partial:
+                            mock_server = MagicMock()
+                            mock_server.serve_forever.side_effect = KeyboardInterrupt()
+                            mock_server_class.return_value = mock_server
 
-                    run_server()
+                            from m3u_list_builder.server import run_server
 
-                    # Verificar que se pasó el handler correcto
-                    call_args = mock_server_class.call_args[0]
-                    assert call_args[1] == mock_handler
+                            run_server()
+
+                            # Verificar que partial se llamó con el directorio correcto
+                            mock_partial.assert_called_once()
+                            call_kwargs = mock_partial.call_args[1]
+                            assert call_kwargs["directory"] == str(public_path)
+
+
+class TestGetPublicDir:
+    """Tests para la función get_public_dir."""
+
+    def test_get_public_dir_creates_directory(self, tmp_path, monkeypatch):
+        """Test: get_public_dir crea el directorio si no existe."""
+        import m3u_list_builder.server as server_module
+
+        test_public = tmp_path / "test_public"
+        monkeypatch.setattr(server_module, "PUBLIC_DIR", test_public)
+
+        from m3u_list_builder.server import get_public_dir
+
+        result = get_public_dir()
+
+        assert result == test_public
+        assert test_public.exists()
+
+    def test_get_public_dir_returns_existing_directory(self, tmp_path, monkeypatch):
+        """Test: get_public_dir retorna directorio existente."""
+        import m3u_list_builder.server as server_module
+
+        test_public = tmp_path / "existing_public"
+        test_public.mkdir()
+        monkeypatch.setattr(server_module, "PUBLIC_DIR", test_public)
+
+        from m3u_list_builder.server import get_public_dir
+
+        result = get_public_dir()
+
+        assert result == test_public