24 files changed, 576 insertions, 104 deletions

diff --git a/tests/cogs/test_ai.py b/tests/cogs/test_ai.py
index a1c3fd4..6d92f55 100644
--- a/tests/cogs/test_ai.py
+++ b/tests/cogs/test_ai.py
@@ -2,7 +2,7 @@ import pytest
 from unittest.mock import AsyncMock, patch, MagicMock
 import discord
 import httpx
-from tests.conftest import MockApplicationContext
+from conftest import MockApplicationContext
 
 
 @pytest.fixture
diff --git a/tests/cogs/test_assistant.py b/tests/cogs/test_assistant.py
index 9a33232..056a868 100644
--- a/tests/cogs/test_assistant.py
+++ b/tests/cogs/test_assistant.py
@@ -1,6 +1,6 @@
 import pytest
 from unittest.mock import AsyncMock, patch, MagicMock
-from tests.conftest import MockApplicationContext
+from conftest import MockApplicationContext
 
 
 @pytest.fixture
diff --git a/tests/cogs/test_compression_conversion.py b/tests/cogs/test_compression_conversion.py
index f9d3427..892482b 100644
--- a/tests/cogs/test_compression_conversion.py
+++ b/tests/cogs/test_compression_conversion.py
@@ -2,7 +2,7 @@ import pytest
 from unittest.mock import AsyncMock, patch, MagicMock
 import os
 import discord
-from tests.conftest import MockApplicationContext
+from conftest import MockApplicationContext
 
 
 def test_compression_filetype_video():
diff --git a/tests/cogs/test_cron.py b/tests/cogs/test_cron.py
index 93031f8..28ccfe1 100644
--- a/tests/cogs/test_cron.py
+++ b/tests/cogs/test_cron.py
@@ -1,10 +1,9 @@
-import json
-import os
 import pytest
 from datetime import datetime
 from unittest.mock import MagicMock, patch
 
 from cogs.cron import Cron
+from cogs.utils.database import _ConnectionContextManager
 
 
 @pytest.fixture
@@ -17,90 +16,74 @@ def mock_bot():
     return bot
 
 
-def create_cog(mock_bot, tmp_path):
+def create_cog(mock_bot):
     with patch.object(Cron, "__init__", lambda self, bot: None):
-        cog = Cron.__new__(Cron)
-        cog.bot = mock_bot
-        cog.scheduled_tasks = []
-        cog.cron_file = str(tmp_path / "cron_jobs.json")
-        cog.task = MagicMock()
-        return cog
+        with patch("cogs.cron.init_database"):
+            cog = Cron.__new__(Cron)
+            cog.bot = mock_bot
+            cog.scheduled_tasks = []
+            cog.task = MagicMock()
+            return cog
 
 
 class TestLoadTasks:
-    def test_load_tasks_file_not_exists(self, mock_bot, tmp_path):
-        cog = create_cog(mock_bot, tmp_path)
-        cog.cron_file = str(tmp_path / "nonexistent.json")
-        cog.load_tasks()
-        assert cog.scheduled_tasks == []
-
-    def test_load_tasks_empty_file(self, mock_bot, tmp_path):
-        cron_file = tmp_path / "empty.json"
-        cron_file.write_text("")
-        cog = create_cog(mock_bot, tmp_path)
-        cog.cron_file = str(cron_file)
-        cog.load_tasks()
-        assert cog.scheduled_tasks == []
-
-    def test_load_tasks_valid_file(self, mock_bot, tmp_path):
-        cron_file = tmp_path / "valid.json"
-        tasks = [{"id": 1, "cron_expression": "* * * * *", "type": "audio", "channel_id": 123, "active": True}]
-        cron_file.write_text(json.dumps(tasks))
-        cog = create_cog(mock_bot, tmp_path)
-        cog.cron_file = str(cron_file)
-        cog.load_tasks()
-        assert len(cog.scheduled_tasks) == 1
-        assert cog.scheduled_tasks[0]["id"] == 1
+    def test_load_tasks_with_data(self, mock_bot):
+        mock_conn = MagicMock()
+        mock_cursor = MagicMock()
+        mock_cursor.fetchall.return_value = [
+            (1, "* * * * *", "audio", 123, 1, None, "test message")
+        ]
+        mock_conn.cursor.return_value = mock_cursor
 
-    def test_load_tasks_io_error(self, mock_bot, tmp_path):
-        cog = create_cog(mock_bot, tmp_path)
-        with patch("builtins.open", side_effect=IOError("test error")):
-            cog.load_tasks()
-        assert cog.scheduled_tasks == []
+        # Create a context manager mock
+        mock_ctx = MagicMock()
+        mock_ctx.__enter__ = MagicMock(return_value=mock_conn)
+        mock_ctx.__exit__ = MagicMock(return_value=False)
 
+        with patch("cogs.cron.get_connection", return_value=mock_ctx):
+            cog = Cron.__new__(Cron)
+            cog.bot = mock_bot
+            cog.scheduled_tasks = []
+            cog.task = MagicMock()
+            cog.load_tasks()
+            assert len(cog.scheduled_tasks) == 1
+            assert cog.scheduled_tasks[0]["id"] == 1
 
 class TestSaveTasks:
-    def test_save_tasks_with_real_file(self, mock_bot, tmp_path):
-        cron_file = tmp_path / "cron_jobs.json"
-        cog = create_cog(mock_bot, tmp_path)
-        cog.cron_file = str(cron_file)
-        cog.scheduled_tasks = [{"id": 1, "cron_expression": "* * * * *"}]
-        cog.save_tasks()
-        assert os.path.exists(cron_file)
-        with open(cron_file) as f:
-            loaded = json.load(f)
-        assert len(loaded) == 1
+    def test_save_tasks(self, mock_bot):
+        cog = create_cog(mock_bot)
+        cog.scheduled_tasks = [{"id": 1, "cron_expression": "* * * * *", "type": "audio", "channel_id": 123, "active": True}]
 
-    def test_save_tasks_creates_directory_structure(self, mock_bot, tmp_path):
-        cog = create_cog(mock_bot, tmp_path)
-        new_dir = tmp_path / "new_dir"
-        cron_file = new_dir / "cron_jobs.json"
-        cog.cron_file = str(cron_file)
-        cog.scheduled_tasks = [{"id": 1}]
+        mock_conn = MagicMock()
+        mock_cursor = MagicMock()
+        mock_conn.cursor.return_value = mock_cursor
 
-        cog.save_tasks()
-
-        assert os.path.exists(new_dir)
+        # Create a context manager mock
+        mock_ctx = MagicMock()
+        mock_ctx.__enter__ = MagicMock(return_value=mock_conn)
+        mock_ctx.__exit__ = MagicMock(return_value=False)
 
+        with patch("cogs.cron.get_connection", return_value=mock_ctx):
+            cog.save_tasks()
+        assert len(cog.scheduled_tasks) == 1
 
 class TestShouldRunTask:
-    def test_should_run_task_invalid_cron(self, mock_bot, tmp_path):
-        cog = create_cog(mock_bot, tmp_path)
+    def test_should_run_task_invalid_cron(self, mock_bot):
+        cog = create_cog(mock_bot)
         task = {"cron_expression": "invalid"}
         now = datetime.now()
         result = cog.should_run_task(task, now)
         assert result is False
 
-    def test_should_run_task_missing_cron_expression(self, mock_bot, tmp_path):
-        cog = create_cog(mock_bot, tmp_path)
+    def test_should_run_task_missing_cron_expression(self, mock_bot):
+        cog = create_cog(mock_bot)
         task = {}
         now = datetime.now()
         result = cog.should_run_task(task, now)
         assert result is False
 
-
 class TestCogUnload:
-    def test_cog_unload_cancels_task(self, mock_bot, tmp_path):
+    def test_cog_unload_cancels_task(self, mock_bot):
         with patch.object(Cron, "__init__", lambda self, bot: None):
             cog = Cron.__new__(Cron)
             cog.bot = mock_bot
@@ -109,10 +92,9 @@ class TestCogUnload:
             cog.cog_unload()
             cog.task.cancel.assert_called_once()
 
-
 class TestTaskManagement:
-    def test_add_task_increments_id(self, mock_bot, tmp_path):
-        cog = create_cog(mock_bot, tmp_path)
+    def test_add_task_increments_id(self, mock_bot):
+        cog = create_cog(mock_bot)
         cog.scheduled_tasks = [
             {"id": 1, "cron_expression": "* * * * *"},
             {"id": 2, "cron_expression": "0 * * * *"},
@@ -121,8 +103,8 @@ class TestTaskManagement:
         new_id = max([t["id"] for t in cog.scheduled_tasks], default=0) + 1
         assert new_id == 3
 
-    def test_find_task_by_id(self, mock_bot, tmp_path):
-        cog = create_cog(mock_bot, tmp_path)
+    def test_find_task_by_id(self, mock_bot):
+        cog = create_cog(mock_bot)
         cog.scheduled_tasks = [
             {"id": 1, "cron_expression": "* * * * *"},
             {"id": 2, "cron_expression": "0 * * * *"},
@@ -132,8 +114,8 @@ class TestTaskManagement:
         assert found_task is not None
         assert found_task["cron_expression"] == "0 * * * *"
 
-    def test_remove_task_by_index(self, mock_bot, tmp_path):
-        cog = create_cog(mock_bot, tmp_path)
+    def test_remove_task_by_index(self, mock_bot):
+        cog = create_cog(mock_bot)
         cog.scheduled_tasks = [
             {"id": 1, "cron_expression": "* * * * *"},
             {"id": 2, "cron_expression": "0 * * * *"},
@@ -143,8 +125,8 @@ class TestTaskManagement:
         assert len(cog.scheduled_tasks) == 1
         assert cog.scheduled_tasks[0]["id"] == 2
 
-    def test_toggle_task_active(self, mock_bot, tmp_path):
-        cog = create_cog(mock_bot, tmp_path)
+    def test_toggle_task_active(self, mock_bot):
+        cog = create_cog(mock_bot)
         cog.scheduled_tasks = [{"id": 1, "active": True}]
 
         cog.scheduled_tasks[0]["active"] = False
@@ -153,14 +135,13 @@ class TestTaskManagement:
         cog.scheduled_tasks[0]["active"] = True
         assert cog.scheduled_tasks[0]["active"] is True
 
-
 class TestTaskTypes:
-    def test_task_type_audio_aliases(self, mock_bot, tmp_path):
+    def test_task_type_audio_aliases(self, mock_bot):
         audio_types = ("zagraj_audio", "audio")
         for task_type in audio_types:
             assert task_type in ("zagraj_audio", "audio")
 
-    def test_task_type_message_aliases(self, mock_bot, tmp_path):
+    def test_task_type_message_aliases(self, mock_bot):
         message_types = ("wyślij_wiadomość", "send_message")
         for task_type in message_types:
             assert task_type in ("wyślij_wiadomość", "send_message")
diff --git a/tests/cogs/test_cron_integration.py b/tests/cogs/test_cron_integration.py
new file mode 100644
index 0000000..f56fc46
--- /dev/null
+++ b/tests/cogs/test_cron_integration.py
@@ -0,0 +1,39 @@
+import pytest
+import time
+from unittest.mock import MagicMock, AsyncMock, patch
+
+
+@pytest.fixture
+def cron_cog(bot):
+    # Patch create_task to prevent background task creation
+    with patch.object(bot.loop, 'create_task', return_value=MagicMock()):
+        from cogs.cron import Cron
+        cog = Cron(bot)
+        yield cog
+
+
+@pytest.mark.slow
+@pytest.mark.asyncio
+async def test_cron_job_execution(cron_cog):
+    """Test cron job executes when due."""
+    cog = cron_cog
+
+    job = {
+        "id": "test_job",
+        "cron_expression": "* * * * *",
+        "type": "message",
+        "channel_id": 456,
+        "active": True,
+        "message": "Test",
+    }
+    cog.scheduled_tasks.append(job)
+
+    # Mock the execute_task method
+    with patch.object(cog, 'execute_task', new_callable=AsyncMock) as mock_exec:
+        # Mock should_run_task to return True
+        with patch.object(cog, 'should_run_task', return_value=True):
+            # Test single iteration of schedule_checker logic
+            for task in cog.scheduled_tasks:
+                if task.get("active", True) and cog.should_run_task(task, None):
+                    await cog.execute_task(task)
+            mock_exec.assert_called_once_with(job)
\ No newline at end of file
diff --git a/tests/cogs/test_downloader.py b/tests/cogs/test_downloader.py
index 6ac8ae7..125a103 100644
--- a/tests/cogs/test_downloader.py
+++ b/tests/cogs/test_downloader.py
@@ -1,7 +1,7 @@
 import pytest
 from unittest.mock import AsyncMock, patch, MagicMock
 import discord
-from tests.conftest import MockApplicationContext, MockMessage
+from conftest import MockApplicationContext, MockMessage
 
 
 @pytest.fixture
diff --git a/tests/cogs/test_downloader_integration.py b/tests/cogs/test_downloader_integration.py
new file mode 100644
index 0000000..c7c9790
--- /dev/null
+++ b/tests/cogs/test_downloader_integration.py
@@ -0,0 +1,37 @@
+import pytest
+from unittest.mock import MagicMock, AsyncMock, patch
+
+
+@pytest.fixture
+def downloader_cog(bot):
+    from cogs.downloader import Downloader
+    cog = Downloader(bot)
+    return cog
+
+
+@pytest.mark.slow
+@pytest.mark.asyncio
+async def test_download_command_flow(downloader_cog, bot):
+    """Test download command with URL processing."""
+    cog = downloader_cog
+
+    ctx = MagicMock()
+    ctx.author = MagicMock()
+    ctx.guild = MagicMock()
+    ctx.channel = MagicMock()
+    ctx.respond = AsyncMock()
+    ctx.defer = AsyncMock()
+    ctx.followup = AsyncMock()
+    ctx.voice_client = None
+
+    # Mock the download_standalone static method
+    mock_response = {
+        "status": "success",
+        "type": "url",
+        "content": "http://example.com/video.mp4"
+    }
+
+    with patch.object(cog, 'download_standalone', new_callable=AsyncMock, return_value=mock_response):
+        await cog.download.callback(cog, ctx, url="http://youtube.com/test")
+
+        ctx.respond.assert_called_once()
diff --git a/tests/cogs/test_math_commands.py b/tests/cogs/test_math_commands.py
index 5c78027..21e9a2e 100644
--- a/tests/cogs/test_math_commands.py
+++ b/tests/cogs/test_math_commands.py
@@ -1,6 +1,6 @@
 import pytest
 from unittest.mock import AsyncMock, patch, MagicMock
-from tests.conftest import MockApplicationContext
+from conftest import MockApplicationContext
 
 
 @pytest.fixture
diff --git a/tests/cogs/test_music_audio.py b/tests/cogs/test_music_audio.py
index 7ea902e..705f1b3 100644
--- a/tests/cogs/test_music_audio.py
+++ b/tests/cogs/test_music_audio.py
@@ -1,7 +1,7 @@
 import pytest
 from unittest.mock import AsyncMock, patch, MagicMock
 import os
-from tests.conftest import MockApplicationContext
+from conftest import MockApplicationContext
 
 
 @pytest.mark.asyncio
diff --git a/tests/cogs/test_music_external_play.py b/tests/cogs/test_music_external_play.py
index fd4b625..2e9c5b1 100644
--- a/tests/cogs/test_music_external_play.py
+++ b/tests/cogs/test_music_external_play.py
@@ -3,7 +3,7 @@ import os
 import asyncio
 import tempfile
 from unittest.mock import AsyncMock, patch, MagicMock
-from tests.conftest import MockApplicationContext
+from conftest import MockApplicationContext
 
 
 @pytest.fixture
diff --git a/tests/cogs/test_music_integration.py b/tests/cogs/test_music_integration.py
new file mode 100644
index 0000000..1c0260a
--- /dev/null
+++ b/tests/cogs/test_music_integration.py
@@ -0,0 +1,44 @@
+import pytest
+from unittest.mock import MagicMock, AsyncMock, patch, PropertyMock
+import sys
+sys.path.insert(0, '/home/salmon/Documents/botcode/senator-sperma/tests')
+from conftest import MockApplicationContext
+
+
+@pytest.fixture
+def music_cog(bot):
+    from cogs.music.play_commands import PlayCommands
+    cog = PlayCommands(bot)
+    return cog
+
+
+@pytest.mark.slow
+@pytest.mark.asyncio
+async def test_music_join_stop(music_cog, bot):
+    """Test music join and stop commands."""
+    from cogs.music.join import Join
+    from cogs.music.stop import Stop
+
+    join_cog = Join(bot)
+    stop_cog = Stop(bot)
+
+    ctx = MockApplicationContext(bot=bot)
+    ctx.author.voice = MagicMock()
+    ctx.author.voice.channel = MagicMock()
+    ctx.guild = MagicMock()
+
+    voice_client = AsyncMock()
+    ctx.voice_client = voice_client
+
+    # Test join
+    ctx.author.voice.channel.connect = AsyncMock(return_value=voice_client)
+    with patch.object(ctx, 'respond', new_callable=AsyncMock):
+        with patch.object(ctx.interaction, 'delete_original_response', new_callable=AsyncMock):
+            await join_cog.join.callback(join_cog, ctx)
+            ctx.author.voice.channel.connect.assert_called_once()
+
+    # Test stop
+    with patch.object(ctx, 'respond', new_callable=AsyncMock):
+        with patch.object(ctx.interaction, 'delete_original_response', new_callable=AsyncMock):
+            await stop_cog.stop.callback(stop_cog, ctx)
+            voice_client.disconnect.assert_called_once()
diff --git a/tests/cogs/test_music_join.py b/tests/cogs/test_music_join.py
index 3c7ca6e..0176759 100644
--- a/tests/cogs/test_music_join.py
+++ b/tests/cogs/test_music_join.py
@@ -1,6 +1,6 @@
 import pytest
 from unittest.mock import AsyncMock, patch, MagicMock
-from tests.conftest import MockApplicationContext
+from conftest import MockApplicationContext
 
 
 @pytest.fixture
diff --git a/tests/cogs/test_music_play.py b/tests/cogs/test_music_play.py
index e720c9a..7684729 100644
--- a/tests/cogs/test_music_play.py
+++ b/tests/cogs/test_music_play.py
@@ -1,7 +1,7 @@
 import pytest
 from unittest.mock import AsyncMock, patch, MagicMock
 import os
-from tests.conftest import MockApplicationContext
+from conftest import MockApplicationContext
 
 
 @pytest.fixture
diff --git a/tests/cogs/test_qr.py b/tests/cogs/test_qr.py
index 2a132ca..b5cb31f 100644
--- a/tests/cogs/test_qr.py
+++ b/tests/cogs/test_qr.py
@@ -2,7 +2,7 @@ import pytest
 from unittest.mock import AsyncMock, patch, MagicMock, mock_open
 import os
 from cogs.qr import QR
-from tests.conftest import MockApplicationContext
+from conftest import MockApplicationContext
 
 
 @pytest.fixture
diff --git a/tests/cogs/test_say.py b/tests/cogs/test_say.py
index 13cad40..76f1b94 100644
--- a/tests/cogs/test_say.py
+++ b/tests/cogs/test_say.py
@@ -1,7 +1,7 @@
 import pytest
 from unittest.mock import AsyncMock, patch
 from cogs.say import Say
-from tests.conftest import MockApplicationContext
+from conftest import MockApplicationContext
 
 
 @pytest.fixture
diff --git a/tests/cogs/test_search.py b/tests/cogs/test_search.py
index 8c04dfc..c9c7d0e 100644
--- a/tests/cogs/test_search.py
+++ b/tests/cogs/test_search.py
@@ -1,7 +1,7 @@
 import pytest
 from unittest.mock import AsyncMock, patch, MagicMock
 import discord
-from tests.conftest import MockApplicationContext
+from conftest import MockApplicationContext
 
 
 @pytest.fixture
diff --git a/tests/cogs/test_trigger.py b/tests/cogs/test_trigger.py
index 6aaaa11..a60a139 100644
--- a/tests/cogs/test_trigger.py
+++ b/tests/cogs/test_trigger.py
@@ -1,7 +1,7 @@
 import pytest
 from unittest.mock import AsyncMock, patch, MagicMock
 import sqlite3
-from tests.conftest import MockApplicationContext
+from conftest import MockApplicationContext
 
 
 @pytest.fixture
diff --git a/tests/cogs/test_trigger_integration.py b/tests/cogs/test_trigger_integration.py
new file mode 100644
index 0000000..4828387
--- /dev/null
+++ b/tests/cogs/test_trigger_integration.py
@@ -0,0 +1,54 @@
+import pytest
+from unittest.mock import MagicMock, AsyncMock, patch
+from cogs.trigger import Trigger
+
+
+@pytest.fixture
+def trigger_cog(bot):
+    from cogs.utils.database import init_database
+    init_database()
+    from cogs.trigger import Trigger
+    cog = Trigger(bot)
+    return cog
+
+
+@pytest.mark.slow
+@pytest.mark.asyncio
+async def test_trigger_response_flow(trigger_cog):
+    """Test trigger creation and response in a simulated message flow."""
+    cog = trigger_cog
+
+    ctx = MagicMock()
+    ctx.author = MagicMock()
+    ctx.author.id = 123
+    ctx.guild = MagicMock()
+    ctx.guild.id = 456
+    ctx.respond = AsyncMock()
+
+    # Create a trigger using the create command
+    await cog.create.callback(cog, ctx, name="test_trigger")
+
+    # Add a keyword and response
+    await cog.add.callback(cog, ctx, name="test_trigger", trigger="hello", response="world")
+
+    # Verify trigger was created - check DB
+    from cogs.utils.database import get_connection
+    with get_connection() as conn:
+        c = conn.cursor()
+        c.execute("SELECT id FROM triggers WHERE name=?", ("test_trigger",))
+        result = c.fetchone()
+        assert result is not None
+
+    # Simulate a message that should trigger
+    message = MagicMock()
+    message.author = ctx.author
+    message.author.bot = False
+    message.guild = ctx.guild
+    message.content = "say hello to me"
+    message.channel.send = AsyncMock()  # Make send awaitable
+
+    # Check if trigger matches using the static method
+    await Trigger.trigger(message)
+
+    # Verify message.channel.send was called with the response
+    message.channel.send.assert_called_once_with("world")
diff --git a/tests/cogs/test_tts.py b/tests/cogs/test_tts.py
index de68580..c6563e6 100644
--- a/tests/cogs/test_tts.py
+++ b/tests/cogs/test_tts.py
@@ -1,7 +1,7 @@
 import pytest
 from unittest.mock import AsyncMock, patch, MagicMock
 import discord
-from tests.conftest import MockApplicationContext
+from conftest import MockApplicationContext
 
 
 @pytest.fixture
diff --git a/tests/cogs/test_uploader.py b/tests/cogs/test_uploader.py
new file mode 100644
index 0000000..0777126
--- /dev/null
+++ b/tests/cogs/test_uploader.py
@@ -0,0 +1,226 @@
+import pytest
+from unittest.mock import AsyncMock, patch, MagicMock
+import os
+import discord
+from conftest import MockApplicationContext, MockMessage, MockUser
+
+
+@pytest.fixture
+def uploader_cog(bot):
+    with patch('cogs.utils.temp.get_temp_dir', return_value='/tmp/test'):
+        from cogs.uploader import Uploader
+        cog = Uploader(bot)
+        return cog
+
+
+@pytest.mark.asyncio
+async def test_file_autocomplete(uploader_cog):
+    mock_autocomplete_ctx = MagicMock()
+    mock_autocomplete_ctx.value = "test"
+    mock_interaction = MagicMock()
+    mock_user = MockUser(id=12345)
+    mock_interaction.user = mock_user
+    mock_autocomplete_ctx.interaction = mock_interaction
+
+    with patch('cogs.utils.file_search.UniversalSearcher.search_copyparty_autocomplete', new_callable=AsyncMock) as mock_search:
+        mock_search.return_value = [
+            "https://copyparty.local/testfile1.mp3",
+            "https://copyparty.local/testfile2.mp3"
+        ]
+        result = await uploader_cog._file_autocomplete(mock_autocomplete_ctx)
+        assert len(result) == 2
+        assert result[0].name == "testfile1.mp3"
+
+
+@pytest.mark.asyncio
+async def test_file_autocomplete_empty_query(uploader_cog):
+    mock_autocomplete_ctx = MagicMock()
+    mock_autocomplete_ctx.value = ""
+    mock_interaction = MagicMock()
+    mock_interaction.user = MockUser(id=12345)
+    mock_autocomplete_ctx.interaction = mock_interaction
+
+    with patch('cogs.utils.file_search.UniversalSearcher.search_copyparty_autocomplete', new_callable=AsyncMock) as mock_search:
+        result = await uploader_cog._file_autocomplete(mock_autocomplete_ctx)
+        mock_search.assert_called_once_with("", max_results=25)
+
+
+@pytest.mark.asyncio
+async def test_download_from_url_success(uploader_cog):
+    with patch('requests.get') as mock_get:
+        mock_response = MagicMock()
+        mock_response.status_code = 200
+        mock_response.content = b"test file content"
+        mock_get.return_value = mock_response
+
+        mock_file = MagicMock()
+        mock_file.write = AsyncMock()
+        
+        mock_cm = AsyncMock()
+        mock_cm.__aenter__ = AsyncMock(return_value=mock_file)
+        mock_cm.__aexit__ = AsyncMock(return_value=None)
+
+        with patch('cogs.uploader.aiofiles.open', return_value=mock_cm):
+            result = await uploader_cog._download_from_url("https://copyparty.local/file.txt")
+
+            assert result is not None
+            assert "file.txt" in result
+            mock_file.write.assert_called_once_with(b"test file content")
+
+
+@pytest.mark.asyncio
+async def test_download_from_url_failure(uploader_cog):
+    with patch('requests.get') as mock_get:
+        mock_response = MagicMock()
+        mock_response.status_code = 404
+        mock_get.return_value = mock_response
+
+        result = await uploader_cog._download_from_url("https://copyparty.local/notfound.txt")
+
+        assert result is None
+
+
+@pytest.mark.asyncio
+async def test_upload_to_copyparty_success(uploader_cog):
+    mock_file = MagicMock()
+    mock_file.read = AsyncMock(return_value=b"test content")
+
+    mock_cm = AsyncMock()
+    mock_cm.__aenter__ = AsyncMock(return_value=mock_file)
+    mock_cm.__aexit__ = AsyncMock(return_value=None)
+
+    with patch('cogs.uploader.aiofiles.open', return_value=mock_cm):
+        with patch('requests.post') as mock_post:
+            mock_response = MagicMock()
+            mock_response.status_code = 200
+            mock_response.json.return_value = {"fileurl": "https://copyparty.local/uploaded.txt"}
+            mock_post.return_value = mock_response
+
+            with patch.dict(os.environ, {"COPYPARTY_PASSWORD": "testpass"}):
+                result = await uploader_cog._upload_to_copyparty("/tmp/testfile.txt")
+
+                assert result == "https://copyparty.local/uploaded.txt"
+
+
+@pytest.mark.asyncio
+async def test_upload_to_copyparty_failure(uploader_cog):
+    mock_file = MagicMock()
+    mock_file.read = AsyncMock(return_value=b"test content")
+
+    mock_cm = AsyncMock()
+    mock_cm.__aenter__ = AsyncMock(return_value=mock_file)
+    mock_cm.__aexit__ = AsyncMock(return_value=None)
+
+    with patch('cogs.uploader.aiofiles.open', return_value=mock_cm):
+        with patch('requests.post') as mock_post:
+            mock_response = MagicMock()
+            mock_response.status_code = 500
+            mock_post.return_value = mock_response
+
+            result = await uploader_cog._upload_to_copyparty("/tmp/testfile.txt")
+
+            assert result is None
+
+
+@pytest.mark.asyncio
+async def test_upload_file_no_url(uploader_cog):
+    uploader_cog._uploadurl = None
+
+    result = await uploader_cog._upload_file("/tmp/test.txt")
+
+    assert result is None
+
+
+@pytest.mark.asyncio
+async def test_message_upload_no_attachments(uploader_cog, mock_channel, mock_guild, bot):
+    ctx = MockApplicationContext(bot=bot, channel=mock_channel, guild=mock_guild)
+
+    mock_message = MagicMock()
+    mock_message.attachments = []
+
+    with patch.object(ctx, 'respond', new_callable=AsyncMock) as mock_respond:
+        await uploader_cog.message_upload.callback(uploader_cog, ctx, message=mock_message)
+        mock_respond.assert_called_once_with("Brak załączników w wiadomości", ephemeral=True)
+
+
+@pytest.mark.asyncio
+async def test_message_upload_success(uploader_cog, mock_channel, mock_guild, bot):
+    ctx = MockApplicationContext(bot=bot, channel=mock_channel, guild=mock_guild)
+
+    mock_attachment = MagicMock()
+    mock_attachment.filename = "test.txt"
+    mock_attachment.save = AsyncMock()
+
+    mock_message = MagicMock()
+    mock_message.attachments = [mock_attachment]
+
+    with patch.object(uploader_cog, '_upload_file', new_callable=AsyncMock) as mock_upload:
+        mock_upload.return_value = "https://copyparty.local/uploaded.txt"
+
+        with patch('os.path.exists', return_value=True):
+            with patch('os.remove'):
+                with patch.object(ctx, 'defer', new_callable=AsyncMock):
+                    with patch.object(ctx, 'respond', new_callable=AsyncMock) as mock_respond:
+                        await uploader_cog.message_upload.callback(uploader_cog, ctx, message=mock_message)
+                        mock_respond.assert_called_once()
+                        assert "Wysłano" in str(mock_respond.call_args)
+
+
+@pytest.mark.asyncio
+async def test_message_upload_all_failed(uploader_cog, mock_channel, mock_guild, bot):
+    ctx = MockApplicationContext(bot=bot, channel=mock_channel, guild=mock_guild)
+
+    mock_attachment = MagicMock()
+    mock_attachment.filename = "test.txt"
+    mock_attachment.save = AsyncMock()
+
+    mock_message = MagicMock()
+    mock_message.attachments = [mock_attachment]
+
+    with patch.object(uploader_cog, '_upload_file', new_callable=AsyncMock) as mock_upload:
+        mock_upload.return_value = None
+
+        with patch('os.path.exists', return_value=True):
+            with patch('os.remove'):
+                with patch.object(ctx, 'defer', new_callable=AsyncMock):
+                    with patch.object(ctx, 'respond', new_callable=AsyncMock) as mock_respond:
+                        await uploader_cog.message_upload.callback(uploader_cog, ctx, message=mock_message)
+                        mock_respond.assert_called_once_with("Nie udało się wysłać żadnych plików", ephemeral=True)
+
+
+@pytest.mark.asyncio
+async def test_upload_slash_command_success(uploader_cog, mock_channel, mock_guild, bot):
+    ctx = MockApplicationContext(bot=bot, channel=mock_channel, guild=mock_guild)
+
+    mock_attachment = MagicMock()
+    mock_attachment.filename = "test.txt"
+    mock_attachment.save = AsyncMock()
+
+    with patch.object(uploader_cog, '_upload_file', new_callable=AsyncMock) as mock_upload:
+        mock_upload.return_value = "https://copyparty.local/uploaded.txt"
+
+        with patch('os.path.exists', return_value=True):
+            with patch('os.remove'):
+                with patch.object(ctx, 'defer', new_callable=AsyncMock):
+                    with patch.object(ctx, 'respond', new_callable=AsyncMock) as mock_respond:
+                        await uploader_cog.upload.callback(uploader_cog, ctx, zalacznik=mock_attachment)
+                        mock_respond.assert_called_once_with("https://copyparty.local/uploaded.txt")
+
+
+@pytest.mark.asyncio
+async def test_upload_slash_command_failure(uploader_cog, mock_channel, mock_guild, bot):
+    ctx = MockApplicationContext(bot=bot, channel=mock_channel, guild=mock_guild)
+
+    mock_attachment = MagicMock()
+    mock_attachment.filename = "test.txt"
+    mock_attachment.save = AsyncMock()
+
+    with patch.object(uploader_cog, '_upload_file', new_callable=AsyncMock) as mock_upload:
+        mock_upload.return_value = None
+
+        with patch('os.path.exists', return_value=True):
+            with patch('os.remove'):
+                with patch.object(ctx, 'defer', new_callable=AsyncMock):
+                    with patch.object(ctx, 'respond', new_callable=AsyncMock) as mock_respond:
+                        await uploader_cog.upload.callback(uploader_cog, ctx, zalacznik=mock_attachment)
+                        mock_respond.assert_called_once_with("Nie udało się wysłać pliku", ephemeral=True)
\ No newline at end of file
diff --git a/tests/cogs/test_vclogs.py b/tests/cogs/test_vclogs.py
index 2003478..17ff839 100644
--- a/tests/cogs/test_vclogs.py
+++ b/tests/cogs/test_vclogs.py
@@ -1,7 +1,6 @@
 import pytest
 from unittest.mock import AsyncMock, patch, MagicMock
-import json
-from tests.conftest import MockApplicationContext
+from conftest import MockApplicationContext
 
 
 def test_format_duration():
@@ -13,20 +12,26 @@ def test_format_duration():
 
 
 def test_load_activity_data():
-    with patch('builtins.open', MagicMock()):
-        with patch('os.path.exists', return_value=True):
-            with patch('json.load', return_value={"123": {"active": True}}):
-                from cogs.vclogs import load_activity_data
-                data = load_activity_data()
-                assert isinstance(data, dict)
+    with patch("cogs.vclogs.get_connection") as mock_conn:
+        mock_cursor = MagicMock()
+        mock_conn.return_value.cursor.return_value = mock_cursor
+        mock_conn.return_value.close.return_value = None
+        mock_cursor.fetchall.return_value = []
+
+        from cogs.vclogs import load_activity_data
+        data = load_activity_data()
+        assert isinstance(data, dict)
 
 
 def test_save_activity_data():
-    with patch('builtins.open', MagicMock()) as mock_open:
-        with patch('json.dump'):
-            from cogs.vclogs import save_activity_data
-            save_activity_data({"123": {"active": True}})
-            mock_open.assert_called_once()
+    with patch("cogs.vclogs.get_connection") as mock_conn:
+        mock_cursor = MagicMock()
+        mock_conn.return_value.cursor.return_value = mock_cursor
+        mock_conn.return_value.commit.return_value = None
+        mock_conn.return_value.close.return_value = None
+
+        from cogs.vclogs import save_activity_data
+        save_activity_data({"123": {"active": True}})
 
 
 @pytest.fixture
@@ -80,4 +85,4 @@ async def test_handle_state_change_mute_false(vclogs_cog):
 
     tts_text, channel = await vclogs_cog.handle_state_change(mock_member, mock_channel, 'mute', False, None)
 
-    assert "zrobił jajecznice" in tts_text
+    assert "zrobił jajecznice" in tts_text
\ No newline at end of file
diff --git a/tests/cogs/test_vclogs_integration.py b/tests/cogs/test_vclogs_integration.py
new file mode 100644
index 0000000..9391876
--- /dev/null
+++ b/tests/cogs/test_vclogs_integration.py
@@ -0,0 +1,86 @@
+import pytest
+import asyncio
+from unittest.mock import MagicMock, AsyncMock, patch
+
+
+@pytest.fixture
+def vclogs_cog(bot):
+    from cogs.vclogs import VcLogs
+    cog = VcLogs(bot)
+    return cog
+
+
+@pytest.mark.slow
+@pytest.mark.asyncio
+async def test_full_voice_session_tracking(vclogs_cog, monkeypatch):
+    """Test complete voice session with AFK transitions using real time sleeps."""
+    cog = vclogs_cog
+
+    # Set up environment
+    monkeypatch.setenv("STATUS_CHANNEL_ID", "123456")
+
+    member = MagicMock()
+    member.id = 123
+    member.guild.id = 456
+    member.bot = False
+    member.display_name = "TestUser"
+    member.guild.get_member.return_value = member
+
+    # Create a mock log channel
+    log_channel = MagicMock()
+    log_channel.send = AsyncMock(return_value=MagicMock())
+
+    # Mock bot.get_channel to return our log channel
+    with patch.object(vclogs_cog.bot, 'get_channel', return_value=log_channel):
+        # Join voice
+        before = MagicMock()
+        before.channel = None
+        after_join = MagicMock()
+        after_join.channel = MagicMock()
+        after_join.channel.id = 789
+        after_join.channel.name = "Test Voice"
+        after_join.self_deaf = False
+        after_join.self_mute = False
+        after_join.deaf = False
+        after_join.mute = False
+        await cog.on_voice_state_update(member, before, after_join)
+
+        await asyncio.sleep(2)  # Simulate 2s active
+
+        # Go AFK (self_deaf)
+        before_afk = after_join
+        after_afk = MagicMock()
+        after_afk.channel = before_afk.channel
+        after_afk.self_deaf = True
+        after_afk.self_mute = False
+        after_afk.deaf = True
+        after_afk.mute = False
+        await cog.on_voice_state_update(member, before_afk, after_afk)
+
+        await asyncio.sleep(3)  # Simulate 3s AFK
+
+        # Return from AFK
+        before_back = after_afk
+        after_back = MagicMock()
+        after_back.channel = before_back.channel
+        after_back.self_deaf = False
+        after_back.self_mute = False
+        after_back.deaf = False
+        after_back.mute = False
+        await cog.on_voice_state_update(member, before_back, after_back)
+
+        await asyncio.sleep(1)  # Simulate 1s active
+
+        # Leave voice
+        before_leave = after_back
+        after_leave = MagicMock()
+        after_leave.channel = None
+        after_leave.self_deaf = False
+        after_leave.self_mute = False
+        await cog.on_voice_state_update(member, before_leave, after_leave)
+
+    # Verify activity was saved (check DB)
+    from cogs.vclogs import load_activity_data
+    activity_data = load_activity_data()
+    # After leaving, data should be deleted, so check the log channel was called
+    assert log_channel.send.called
diff --git a/tests/cogs/test_voice.py b/tests/cogs/test_voice.py
index ade29cb..104eea6 100644
--- a/tests/cogs/test_voice.py
+++ b/tests/cogs/test_voice.py
@@ -1,7 +1,7 @@
 import pytest
 from unittest.mock import AsyncMock, patch, MagicMock
 import asyncio
-from tests.conftest import MockApplicationContext
+from conftest import MockApplicationContext
 
 
 @pytest.mark.asyncio
diff --git a/tests/cogs/test_web.py b/tests/cogs/test_web.py
index e0d2208..4de2e8b 100644
--- a/tests/cogs/test_web.py
+++ b/tests/cogs/test_web.py
@@ -1,7 +1,7 @@
 import pytest
 from unittest.mock import AsyncMock, patch, MagicMock
 from cogs.web import Web
-from tests.conftest import MockApplicationContext
+from conftest import MockApplicationContext
 
 
 @pytest.fixture