Merge pull request 'massive changes' (#3) from dev into main

Reviewed-on: https://codeberg.org/salmonik/senator-sperma/pulls/3
stable enough

42 files changed, 2103 insertions, 292 deletions

diff --git a/.gitignore b/.gitignore
index c9cc484..40d765c 100644
--- a/.gitignore
+++ b/.gitignore
@@ -3,4 +3,5 @@ __pycache__/
 data/
 .idea/
 .venv/
-.zed
+.zed/
+.pytest_cache/
diff --git a/AGENTS.md b/AGENTS.md
new file mode 100644
index 0000000..44be9d5
--- /dev/null
+++ b/AGENTS.md
@@ -0,0 +1,28 @@
+# Agent Instructions for Senator Sperma
+
+## Required Setup
+- Requires **Python 3.13** (3.14 not supported - py-cord incompatibility)
+- System dependencies: `ffmpeg`, `zbar` library (installed system-wide)
+- Bot token in `.env` file (copy from `.env.example`)
+
+## Commands
+- Run bot: `.venv/bin/python main.py`
+- Type check: `.venv/bin/basedpyright`
+- Test: `.venv/bin/pytest`
+
+## Architecture
+- Slash commands defined as cogs in `cogs/*.py`
+- Discord API uses `discord.ApplicationContext`
+- Music auto-complete queries copyparty server (`COPYPARTY_URL` config)
+
+## Environment
+- Copyparty URL for read-only access is COPYPARTY_URL
+- Copyparty URL for write-only access is COPYPARTY_URL_UPLOAD
+- Above should be accessed using COPYPARTY_PASSWORD as a cookie
+- Channel for vclogs and alike is STATUS_CHANNEL_ID
+- Trigger word for assistant is ASSISTANT_KEYWORD
+
+## Testing
+- Tests in `tests/cogs/test_*.py`
+- Uses pytest-asyncio with `asyncio_default_fixture_loop_scope = function`
+- `conftest.py` provides fixtures for mocking Discord objects
diff --git a/README.md b/README.md
index 92468a7..8e71dbe 100644
--- a/README.md
+++ b/README.md
@@ -83,7 +83,6 @@ All settings are optional - defaults are provided if not set.
 - `/download` - Download video/audio
 - `/tts` - Text to speech
 - `/qr_koduj` / `qr_dekoduj` - QR encode/decode
-- `/funkcja` - Math plot
 - `/kompresja` - Compress images
 - `/konwersja` - Convert audio/video
 
diff --git a/cogs/ai.py b/cogs/ai.py
index 4a04693..6f79ac5 100644
--- a/cogs/ai.py
+++ b/cogs/ai.py
@@ -7,7 +7,7 @@ import os
 import discord
 from discord.ext import commands
 import logging
-import requests
+import httpx
 from gtts import gTTS
 from cogs.music import audio_playback
 import io
@@ -52,23 +52,24 @@ class AI(commands.Cog):
              ],
 
          }
-        response = requests.post(url=url, headers=headers, json=payload)
-        response_data = response.json()
-        logger.info(response_data)
-        if not response_data["choices"]:
-            await ctx.send_followup("bot siem zesroł")
-        else:
-            response_text = response_data["choices"][0]["message"]["content"]
-            if tts:
-                # Generate TTS
-                tts_obj = gTTS(text=response_text, lang='pl')
-                tts_buffer = io.BytesIO()
-                tts_obj.write_to_fp(tts_buffer)
-                tts_buffer.seek(0)
-                await audio_playback.AudioPlaybackManager.play(ctx, discord.FFmpegPCMAudio(tts_buffer), delete_after_play=True)
-
+        async with httpx.AsyncClient() as client:
+            response = await client.post(url=url, headers=headers, json=payload)
+            response_data = response.json()
+            logger.info(response_data)
+            if not response_data["choices"]:
+                await ctx.send_followup("bot siem zesroł")
             else:
-                await ctx.send_followup(response_text)
+                response_text = response_data["choices"][0]["message"]["content"]
+                if tts:
+                    # Generate TTS
+                    tts_obj = gTTS(text=response_text, lang='pl')
+                    tts_buffer = io.BytesIO()
+                    tts_obj.write_to_fp(tts_buffer)
+                    tts_buffer.seek(0)
+                    await audio_playback.AudioPlaybackManager.play(ctx, discord.FFmpegPCMAudio(tts_buffer), delete_after_play=True)
+
+                else:
+                    await ctx.send_followup(response_text)
 
 
 
diff --git a/cogs/assistant.py b/cogs/assistant.py
index 71f5150..21e4989 100644
--- a/cogs/assistant.py
+++ b/cogs/assistant.py
@@ -6,7 +6,7 @@
 import re
 import discord
 from discord.ext import commands
-import requests
+import httpx
 import json
 import logging
 import shutil
@@ -133,11 +133,12 @@ class Jarvis(commands.Cog):
 
     @staticmethod
     async def _make_api_request(payload, headers):
-        url = "https://openrouter.ai/api/v1/chat/completions"
-        response = requests.post(url=url, headers=headers, json=payload)
-        response_data = response.json()
-        logger.info(response_data)
-        return response_data
+        async with httpx.AsyncClient() as client:
+            url = "https://openrouter.ai/api/v1/chat/completions"
+            response = await client.post(url=url, headers=headers, json=payload)
+            response_data = response.json()
+            logger.info(response_data)
+            return response_data
 
     @staticmethod
     def _parse_response(response_data):
diff --git a/cogs/compression.py b/cogs/compression.py
index 150239f..acc9eda 100644
--- a/cogs/compression.py
+++ b/cogs/compression.py
@@ -275,6 +275,7 @@ class Compression(commands.Cog):
             if file_type == "Image":
                 command, output_path = command
             elif file_type == "Audio":
+                # Audio output path remains unchanged - already processed in _process_audio
                 pass
 
             success = await self._execute_compression(command)
diff --git a/cogs/cron.py b/cogs/cron.py
index 6b83866..da8127b 100644
--- a/cogs/cron.py
+++ b/cogs/cron.py
@@ -74,7 +74,7 @@ class Cron(commands.Cog):
             prev_time = cron.get_prev(datetime)
             time_diff = abs((now - prev_time).total_seconds())
             result = time_diff <= 30
-            logger.info(
+            logger.debug(
                 f"Cron '{cron_expr}': prev={prev_time}, now={now}, diff={time_diff}, run={result}"
             )
             return result
@@ -92,13 +92,13 @@ class Cron(commands.Cog):
 
             channel = self.bot.get_channel(channel_id)
             if not channel:
-                logger.warning(f"Channel {channel_id} not found for task {task['id']}")
+                logger.warning(f"Channel {channel_id} not found for task ID: {task.get('id')}")
                 return
 
             logger.info(f"Found channel {channel} (type: {type(channel).__name__})")
 
             perms = channel.permissions_for(channel.guild.me)
-            logger.info(
+            logger.debug(
                 f"Bot permissions: send_messages={perms.send_messages}, attach_files={perms.attach_files}"
             )
 
@@ -151,7 +151,7 @@ class Cron(commands.Cog):
         message = task["message"]
         logger.info(f"Message to send: '{message}' | Channel: {channel.id}")
         await channel.send(message)
-        logger.info("Message sent successfully")
+        logger.debug("Message sent successfully")
 
     async def audio_autocomplete(self, ctx: discord.AutocompleteContext):
         """Autocomplete for audio files from file_search"""
diff --git a/cogs/downloader.py b/cogs/downloader.py
index d364b3a..36bd723 100644
--- a/cogs/downloader.py
+++ b/cogs/downloader.py
@@ -195,7 +195,7 @@ class Downloader(commands.Cog):
         }
 
     @staticmethod
-    def _create_error_response(content: str, details: str, temp_dir: str) -> dict:
+    def _create_error_response(content: str, details: str, temp_dir: str | None) -> dict:
         return {
             "status": "error",
             "type": "error",
diff --git a/cogs/music/audio_playback.py b/cogs/music/audio_playback.py
index 1267fa7..28c6118 100644
--- a/cogs/music/audio_playback.py
+++ b/cogs/music/audio_playback.py
@@ -60,17 +60,18 @@ class AudioPlaybackManager:
         """Connect or move to voice channel. Returns voice client."""
         try:
             # Check if vc is valid and actually connected
-            is_connected = vc is not None and vc.is_connected()
-            # Connect to voice channel if not connected
-            if not is_connected:
-                logger.info(f"Connecting to voice channel: {target_channel.name}")
-                vc = await target_channel.connect()
-                logger.info(f"Connected to voice channel: {target_channel.name}")
-            # Move to user's channel if in a different one
-            elif vc.channel != target_channel:
-                logger.info(f"Moving to voice channel: {target_channel.name}")
-                await vc.move_to(target_channel)
-                logger.info(f"Moved to voice channel: {target_channel.name}")
+            if vc is not None and vc.is_connected():
+                # Already connected - check if need to move
+                if vc.channel != target_channel:
+                    logger.info(f"Moving to voice channel: {target_channel.name}")
+                    await vc.move_to(target_channel)
+                    logger.info(f"Moved to voice channel: {target_channel.name}")
+                return vc
+
+            # Not connected - connect now
+            logger.info(f"Connecting to voice channel: {target_channel.name}")
+            vc = await target_channel.connect()
+            logger.info(f"Connected to voice channel: {target_channel.name}")
             return vc
         except Exception as e:
             logger.error(f"Error connecting to voice channel: {str(e)}")
@@ -138,15 +139,35 @@ class AudioPlaybackManager:
     @staticmethod
     async def execute_playback(ctx, source, display_name, is_url):
         """Execute the actual audio playback."""
-        vc = ctx.voice_client
         target_channel = await AudioPlaybackManager.validate_voice_channel(ctx)
         if not target_channel:
             return False
 
+        # Get existing voice client from bot or connect
+        guild = ctx.guild
+        vc = discord.utils.get(ctx.bot.voice_clients, guild=guild)
+
         try:
-            vc = await AudioPlaybackManager.connect_to_voice_channel(
-                ctx, vc, target_channel
-            )
+            # Handle various connection states
+            if vc is None:
+                logger.info("No existing voice client, connecting...")
+                try:
+                    vc = await target_channel.connect()
+                except discord.ClientException:
+                    vc = discord.utils.get(ctx.bot.voice_clients, guild=guild)
+            elif not vc.is_connected():
+                logger.info("Voice client exists but disconnected, reconnecting...")
+                try:
+                    await vc.disconnect()
+                except Exception:
+                    pass
+                try:
+                    vc = await target_channel.connect()
+                except discord.ClientException:
+                    vc = discord.utils.get(ctx.bot.voice_clients, guild=guild)
+            elif vc.channel != target_channel:
+                logger.info(f"Moving to voice channel: {target_channel.name}")
+                await vc.move_to(target_channel)
 
             # Stop any currently playing audio
             if vc.is_playing() or vc.is_paused():  # type: ignore[union-attr]
@@ -171,7 +192,7 @@ class AudioPlaybackManager:
             # Play the audio
             vc.play(audio_source, after=after_playing)
             logger.info(f"Playing: {final_display_name}")
-            await ctx.respond(f"grom: {final_display_name}")
+            await ctx.followup.send(f"grom: {final_display_name}")
 
             # Wait for FFmpeg to attempt connection - errors usually happen within 5 seconds
             await asyncio.sleep(5)
@@ -195,7 +216,7 @@ class AudioPlaybackManager:
 
         except Exception as e:
             logger.error(f"Error in play: {str(e)}", exc_info=True)
-            await ctx.respond(f"eror: {str(e)}", ephemeral=True)
+            await ctx.followup.send(f"eror: {str(e)}", ephemeral=True)
             return False
 
     @staticmethod
diff --git a/cogs/music/play_commands.py b/cogs/music/play_commands.py
index fd5113a..5373436 100644
--- a/cogs/music/play_commands.py
+++ b/cogs/music/play_commands.py
@@ -6,18 +6,25 @@
 import logging
 import os
 import urllib.parse
+import asyncio
 from os import PathLike
 from typing import Awaitable, Callable, List, Tuple
+import re
+from yt_dlp import YoutubeDL
 
 import discord
 from discord.commands import OptionChoice
 from discord.ext import commands
 
 from cogs.music import audio_playback, media_processing
-from cogs.utils import file_search as search_utils
+from cogs.utils.file_search import UniversalSearcher
 
 logger = logging.getLogger(__name__)
 
+EXTERNAL_URL_PATTERN = re.compile(
+    r"^https://(?=.*(?:youtube|youtu\.be|soundcloud|bandcamp))"
+)
+
 
 class PlayCommands(commands.Cog):
     """Discord slash commands for music playback."""
@@ -88,9 +95,12 @@ class PlayCommands(commands.Cog):
         self, ctx: discord.AutocompleteContext
     ) -> List[OptionChoice]:
         """Autocomplete handler for search queries."""
+        if ctx.value.lower().startswith(("http://", "https://")):
+            return []
+
         query = ctx.value.lower()
         try:
-            results = await search_utils.UniversalSearcher.search_copyparty_autocomplete_audio(
+            results = await UniversalSearcher.search_copyparty_autocomplete_audio(
                 query, max_results=25
             )
             choices = []
@@ -139,9 +149,10 @@ class PlayCommands(commands.Cog):
                     local_path = os.path.join(self.temp_dir, filename)
                     os.makedirs(self.temp_dir, exist_ok=True)
 
+                    loop = asyncio.get_event_loop()
                     with open(local_path, "wb") as f:
                         async for chunk in response.content.iter_chunked(8192):
-                            f.write(chunk)
+                            await loop.run_in_executor(None, f.write, chunk)
 
             compressed_path = await media_processing.AudioCompressor.compress(
                 ctx, local_path
@@ -162,6 +173,96 @@ class PlayCommands(commands.Cog):
                 except Exception:
                     pass
 
+    async def _handle_external_url_play(
+        self, ctx: discord.ApplicationContext, url: str
+    ) -> None:
+        """Download from external URL, upload to copyparty, then play."""
+        local_path = None
+        try:
+            ytdl_opts = {
+                "outtmpl": os.path.join(self.temp_dir, "%(title)s.%(ext)s"),
+                "postprocessors": [
+                    {
+                        "key": "FFmpegExtractAudio",
+                        "preferredcodec": "mp3",
+                        "preferredquality": "192",
+                    }
+                ],
+                "force_ipv4": True,
+            }
+
+            loop = asyncio.get_event_loop()
+            with YoutubeDL(ytdl_opts) as ydl:
+                info_dict = await loop.run_in_executor(
+                    None, lambda: ydl.extract_info(url, download=True)
+                )
+                title = info_dict.get("title", "nieznany")
+                base_filename = os.path.splitext(ydl.prepare_filename(info_dict))[0]
+                local_path = f"{base_filename}.mp3"
+
+            if not os.path.exists(local_path):
+                await ctx.respond("Nie udało się pobrać pliku.", ephemeral=True)
+                return
+
+            upload_task = asyncio.create_task(self._upload_to_copyparty_async(local_path))
+
+            await audio_playback.AudioPlaybackManager.play(
+                ctx, local_path, delete_after_play=True
+            )
+
+            try:
+                await asyncio.wait_for(upload_task, timeout=30.0)
+            except asyncio.TimeoutError:
+                logger.warning("Upload timed out")
+        except Exception as e:
+            logger.error(f"Error downloading external URL: {str(e)}", exc_info=True)
+            if local_path and os.path.exists(local_path):
+                try:
+                    os.remove(local_path)
+                except Exception:
+                    pass
+            await ctx.respond(f"Błąd pobierania: {str(e)}", ephemeral=True)
+
+    async def _upload_to_copyparty_async(self, file_path: str) -> None:
+        """Upload file to copyparty asynchronously (fire and forget)."""
+        import aiohttp
+
+        try:
+            logger.info(f"Starting async upload: {file_path}")
+            baseurl = os.getenv("COPYPARTY_URL_UPLOAD")
+            password = os.getenv("COPYPARTY_PASSWORD", "")
+
+            logger.info(f"Upload - baseurl: {baseurl}, password set: {bool(password)}")
+
+            if not baseurl:
+                logger.error("COPYPARTY_URL_UPLOAD not set!")
+                return
+
+            with open(file_path, "rb") as f:
+                content = f.read()
+
+            files = aiohttp.FormData()
+            files.add_field(
+                "f",
+                content,
+                filename=os.path.basename(file_path),
+                content_type="application/octet-stream",
+            )
+            headers = {"Cookie": f"cppwd={password}"}
+            params = {"j": "1", "ck": "b2"}
+
+            logger.info(f"Posting to {baseurl}")
+            async with aiohttp.ClientSession() as session:
+                async with session.post(baseurl, data=files, headers=headers, params=params) as response:
+                    text = await response.text()
+                    logger.info(f"Upload response: {response.status} - {text[:200] if text else 'empty'}")
+
+                    if response.status in [200, 201]:
+                        result = await response.json()
+                        logger.info(f"Uploaded to copyparty: {result.get('fileurl')}")
+        except Exception as e:
+            logger.error(f"Async upload failed: {e}", exc_info=True)
+
     async def _handle_local_file_play(
         self, ctx: discord.ApplicationContext, file: str, compressed: bool
     ) -> None:
@@ -209,7 +310,10 @@ class PlayCommands(commands.Cog):
             await audio_playback.AudioPlaybackManager.play(ctx, file_path)
         else:
             try:
-                await self._handle_local_file_play(ctx, melodia, compressed)
+                if EXTERNAL_URL_PATTERN.match(melodia.lower()):
+                    await self._handle_external_url_play(ctx, melodia)
+                else:
+                    await self._handle_local_file_play(ctx, melodia, compressed)
             except Exception as e:
                 logger.error(f"Error playing: {str(e)}", exc_info=True)
                 await ctx.respond(
diff --git a/cogs/plot.py b/cogs/plot.py
deleted file mode 100644
index 4fcde44..0000000
--- a/cogs/plot.py
+++ /dev/null
@@ -1,188 +0,0 @@
-# This file is part of Senator Sperma
-# Licensed under the GPL-3.0 License
-# Copyright (C) 2026 Salmonik @ salmonik@tuta.io
-# https://codeberg.org/salmonik/senator-sperma
-
-import asyncio
-import logging
-import math
-import os
-import re
-
-import discord
-from discord.ext import commands
-
-logger = logging.getLogger(__name__)
-
-_plt_module = None
-_plot_available = False
-
-
-def _ensure_plot():
-    global _plt_module, _plot_available
-    
-    if _plt_module is not None:
-        return _plot_available
-    
-    try:
-        import matplotlib
-        matplotlib.use("Agg")
-        import matplotlib.pyplot as _plt_module
-        _plot_available = True
-    except ImportError:
-        _plot_available = False
-        logger.warning("matplotlib not available, plot command will be disabled")
-    return _plot_available
-
-
-def parse_expression(expr: str) -> str:
-    expr = expr.replace("^", "**")
-    expr = re.sub(r"(\d)([x])", r"\1*\2", expr)
-    expr = re.sub(r"([x])(\d)", r"\1*\2", expr)
-    expr = re.sub(r"(\d)([y])", r"\1*\2", expr)
-    expr = re.sub(r"([y])(\d)", r"\1*\2", expr)
-    return expr
-
-
-def is_implicit(expr: str) -> bool:
-    return "=" in expr and "y" in expr and "x" in expr
-
-
-def parse_implicit(expr: str) -> tuple[str, str]:
-    lhs, rhs = expr.split("=", 1)
-    lhs = parse_expression(lhs.strip())
-    rhs = parse_expression(rhs.strip())
-    return lhs, rhs
-
-
-class Plot(commands.Cog):
-    def __init__(self, bot):
-        self.bot = bot
-
-    def _generate_plot(self, func_expr: str, output_path: str):
-        global _plt_module
-        
-        if not _ensure_plot():
-            raise RuntimeError("matplotlib not available")
-
-        plt = _plt_module
-        
-        if is_implicit(func_expr):
-            self._generate_implicit_plot(func_expr, output_path)
-            return
-
-        parsed_expr = parse_expression(func_expr)
-
-        x = [i * 0.1 for i in range(-100, 101)]
-        y = []
-
-        for xi in x:
-            try:
-                result = eval(
-                    parsed_expr,
-                    {
-                        "x": xi,
-                        "math": math,
-                        "sin": math.sin,
-                        "cos": math.cos,
-                        "tan": math.tan,
-                        "sqrt": math.sqrt,
-                        "log": math.log,
-                        "exp": math.exp,
-                        "pi": math.pi,
-                        "e": math.e,
-                    },
-                )
-                if math.isfinite(result):
-                    y.append(result)
-                else:
-                    y.append(float("nan"))
-            except Exception:
-                y.append(float("nan"))
-
-        fig, ax = plt.subplots(figsize=(10, 6))
-        ax.plot(x, y, linewidth=2, color="#00ff00")
-        ax.set_title(f"y = {func_expr}", fontsize=14)
-        ax.set_xlabel("x", fontsize=12)
-        ax.set_ylabel("y", fontsize=12)
-        ax.grid(True, alpha=0.3)
-        ax.axhline(y=0, color="white", linewidth=0.5)
-        ax.axvline(x=0, color="white", linewidth=0.5)
-        ax.set_facecolor("#1a1a1a")
-        fig.patch.set_facecolor("#1a1a1a")
-
-        plt.savefig(output_path, dpi=100, bbox_inches="tight")
-        plt.close()
-
-    def _generate_implicit_plot(self, func_expr: str, output_path: str):
-        global _plt_module
-        plt = _plt_module
-        
-        lhs, rhs = parse_implicit(func_expr)
-        
-        x_range = 20
-        y_range = 20
-        
-        x_vals = []
-        y_vals = []
-        
-        for xi in range(-x_range * 10, x_range * 10 + 1):
-            x = xi / 10.0
-            for yi in range(-y_range * 10, y_range * 10 + 1):
-                y = yi / 10.0
-                try:
-                    left_val = eval(lhs, {"x": x, "y": y, "math": math, "sqrt": math.sqrt, "pi": math.pi, "e": math.e})
-                    right_val = eval(rhs, {"x": x, "y": y, "math": math, "sqrt": math.sqrt, "pi": math.pi, "e": math.e})
-                    diff = abs(left_val - right_val)
-                    if math.isfinite(diff) and diff < 0.3:
-                        x_vals.append(x)
-                        y_vals.append(y)
-                except Exception:
-                    pass
-        
-        fig, ax = plt.subplots(figsize=(10, 10))
-        ax.scatter(x_vals, y_vals, s=1, color="#00ff00", alpha=0.5)
-        ax.set_title(f"{func_expr}", fontsize=14)
-        ax.set_xlabel("x", fontsize=12)
-        ax.set_ylabel("y", fontsize=12)
-        ax.grid(True, alpha=0.3)
-        ax.axhline(y=0, color="white", linewidth=0.5)
-        ax.axvline(x=0, color="white", linewidth=0.5)
-        ax.set_xlim(-x_range, x_range)
-        ax.set_ylim(-y_range, y_range)
-        ax.set_aspect("equal")
-        ax.set_facecolor("#1a1a1a")
-        fig.patch.set_facecolor("#1a1a1a")
-        
-        plt.savefig(output_path, dpi=100, bbox_inches="tight")
-        plt.close()
-
-    @commands.slash_command(name="funkcja", description="Generuje wykres funkcji matematycznej")
-    async def plot(self, ctx, funkcja: str = discord.Option(str, "Funkcja np. x^3, sin(x), x^2 + 2*x - 1", required=True)):
-        if not _ensure_plot():
-            await ctx.respond("Generowanie wykresów nie jest dostępne (brak matplotlib)", ephemeral=True)
-            return
-
-        await ctx.defer()
-
-        from cogs.utils.temp import get_temp_dir
-        temp_path = os.path.join(get_temp_dir(), f"plot_{os.getpid()}_{asyncio.get_event_loop().time()}.png")
-
-        try:
-            loop = asyncio.get_event_loop()
-            await loop.run_in_executor(None, self._generate_plot, funkcja, temp_path)
-            await ctx.respond(file=discord.File(temp_path, filename="plot.png"))
-            logger.info(f"Generated plot for function: {funkcja}")
-        except Exception as e:
-            logger.error(f"Plot generation error: {e}")
-            await ctx.respond(f"Błąd generowania wykresu: {str(e)}", ephemeral=True)
-        finally:
-            try:
-                if os.path.exists(temp_path):
-                    os.unlink(temp_path)
-            except Exception as e:
-                logger.error(f"Error cleaning up temp file: {e}")
-
-
-def setup(bot):
-    bot.add_cog(Plot(bot))
\ No newline at end of file
diff --git a/cogs/qr.py b/cogs/qr.py
index c1fd499..32c574e 100644
--- a/cogs/qr.py
+++ b/cogs/qr.py
@@ -22,10 +22,10 @@ _decode_available = False
 
 def _ensure_qr():
     global _pil_image, _decode_func, _decode_available
-    
+
     if _pil_image is not None:
         return _decode_available
-    
+
     try:
         from PIL import Image
         from pyzbar.pyzbar import decode as _decode_func
@@ -48,7 +48,7 @@ class QR(commands.Cog):
                 if response.status == 200:
                     content = await response.read()
                     with tempfile.NamedTemporaryFile(delete=False, suffix=".png") as f:
-                        f.write(content)
+                        await asyncio.get_event_loop().run_in_executor(None, f.write, content)
                         return f.name
         return None
 
@@ -137,7 +137,7 @@ class QR(commands.Cog):
 
     def _decode_qr(self, image_path):
         """Decode QR code from image (runs in executor)"""
-        if not _ensure_qr():
+        if not _ensure_qr() or _decode_func is None:
             return None
 
         try:
diff --git a/cogs/trigger.py b/cogs/trigger.py
index 0e76cef..02e5573 100644
--- a/cogs/trigger.py
+++ b/cogs/trigger.py
@@ -15,6 +15,12 @@ logger = logging.getLogger(__name__)
 
 DB_PATH = 'data/triggers.db'
 
+_SELECT_KEYWORD_SQL = "SELECT keyword FROM trigger_keywords WHERE trigger_id=?"
+_SELECT_RESPONSE_SQL = "SELECT response_text FROM trigger_responses WHERE trigger_id=?"
+_SELECT_TRIGGER_ID_SQL = "SELECT id FROM triggers WHERE name=?"
+_TRIGGER_NOT_FOUND_MSG = "Trigger not found."
+_TRIGGER_NAME_OPTION = "the name of the trigger"
+
 
 def get_connection():
     return sqlite3.connect(DB_PATH)
@@ -112,10 +118,10 @@ class Trigger(commands.Cog):
             c = conn.cursor()
             c.execute("SELECT id, name FROM triggers")
             for trigger_id, name in c.fetchall():
-                c.execute("SELECT keyword FROM trigger_keywords WHERE trigger_id=?", (trigger_id,))
+                c.execute(_SELECT_KEYWORD_SQL, (trigger_id,))
                 keywords = [row[0] for row in c.fetchall()]
                 if any(keyword in content for keyword in keywords):
-                    c.execute("SELECT response_text FROM trigger_responses WHERE trigger_id=?", (trigger_id,))
+                    c.execute(_SELECT_RESPONSE_SQL, (trigger_id,))
                     responses = [row[0] for row in c.fetchall()]
                     if responses:
                         await message.channel.send(random.choice(responses).replace('\\n', '\n'))
@@ -137,7 +143,7 @@ class Trigger(commands.Cog):
         ctx: discord.ApplicationContext,
         name = discord.Option(
             str,
-            "the name of the trigger",
+            _TRIGGER_NAME_OPTION,
             autocomplete= discord.utils.basic_autocomplete(get_type),
             required=True
         )
@@ -157,7 +163,7 @@ class Trigger(commands.Cog):
         ctx: discord.ApplicationContext,
         name = discord.Option(
             str,
-            "the name of the trigger",
+            _TRIGGER_NAME_OPTION,
             autocomplete= discord.utils.basic_autocomplete(get_type),
             required=True
         ),
@@ -174,10 +180,10 @@ class Trigger(commands.Cog):
     ):
         with get_connection() as conn:
             c = conn.cursor()
-            c.execute("SELECT id FROM triggers WHERE name=?", (name,))
+            c.execute(_SELECT_TRIGGER_ID_SQL, (name,))
             row = c.fetchone()
             if not row:
-                await ctx.respond("Trigger not found.")
+                await ctx.respond(_TRIGGER_NOT_FOUND_MSG)
                 logger.warning(f"Trigger not found: {name}")
                 return
             trigger_id = row[0]
@@ -204,7 +210,7 @@ class Trigger(commands.Cog):
         ctx: discord.ApplicationContext,
         name = discord.Option(
             str,
-            "the name of the trigger",
+            _TRIGGER_NAME_OPTION,
             autocomplete= discord.utils.basic_autocomplete(get_type),
             required=True
         ),
@@ -221,10 +227,10 @@ class Trigger(commands.Cog):
     ):
         with get_connection() as conn:
             c = conn.cursor()
-            c.execute("SELECT id FROM triggers WHERE name=?", (name,))
+            c.execute(_SELECT_TRIGGER_ID_SQL, (name,))
             row = c.fetchone()
             if not row:
-                await ctx.respond("Trigger not found.")
+                await ctx.respond(_TRIGGER_NOT_FOUND_MSG)
                 logger.warning(f"Trigger not found: {name}")
                 return
             trigger_id = row[0]
@@ -245,17 +251,17 @@ class Trigger(commands.Cog):
         ctx: discord.ApplicationContext,
                 name = discord.Option(
             str,
-            "the name of the trigger",
+            _TRIGGER_NAME_OPTION,
             autocomplete= discord.utils.basic_autocomplete(get_type),
             required=True
         )
     ):
         with get_connection() as conn:
             c = conn.cursor()
-            c.execute("SELECT id FROM triggers WHERE name=?", (name,))
+            c.execute(_SELECT_TRIGGER_ID_SQL, (name,))
             row = c.fetchone()
             if not row:
-                await ctx.respond("Trigger not found.")
+                await ctx.respond(_TRIGGER_NOT_FOUND_MSG)
                 return
             trigger_id = row[0]
             c.execute("DELETE FROM trigger_keywords WHERE trigger_id=?", (trigger_id,))
@@ -275,7 +281,7 @@ class Trigger(commands.Cog):
         ctx: discord.ApplicationContext,
         name = discord.Option(
             str,
-            "the name of the trigger",
+            _TRIGGER_NAME_OPTION,
             autocomplete=discord.utils.basic_autocomplete(get_type),
             required=True
         )
@@ -286,13 +292,13 @@ class Trigger(commands.Cog):
                 c.execute("SELECT id FROM triggers WHERE name=?", (name,))
                 row = c.fetchone()
                 if not row:
-                    await ctx.respond("Trigger not found.")
+                    await ctx.respond(_TRIGGER_NOT_FOUND_MSG)
                     logger.warning(f"Trigger not found: {name}")
                     return
                 trigger_id = row[0]
-                c.execute("SELECT keyword FROM trigger_keywords WHERE trigger_id=?", (trigger_id,))
+                c.execute(_SELECT_KEYWORD_SQL, (trigger_id,))
                 triggers = [row[0] for row in c.fetchall()]
-                c.execute("SELECT response_text FROM trigger_responses WHERE trigger_id=?", (trigger_id,))
+                c.execute(_SELECT_RESPONSE_SQL, (trigger_id,))
                 responses = [row[0] for row in c.fetchall()]
                 trigger_list = "\n".join(triggers)
                 response_list = "\n".join(responses)
@@ -303,13 +309,13 @@ class Trigger(commands.Cog):
                 c.execute("SELECT id, name FROM triggers")
                 messages = []
                 for trigger_id, name in c.fetchall():
-                    c.execute("SELECT keyword FROM trigger_keywords WHERE trigger_id=?", (trigger_id,))
+                    c.execute(_SELECT_KEYWORD_SQL, (trigger_id,))
                     triggers = ", ".join([row[0] for row in c.fetchall()])
-                    c.execute("SELECT response_text FROM trigger_responses WHERE trigger_id=?", (trigger_id,))
+                    c.execute(_SELECT_RESPONSE_SQL, (trigger_id,))
                     responses = ", ".join([row[0] for row in c.fetchall()])
                     messages.append(f"**{name}**\nTriggers: {triggers}\nResponses: {responses}")
                 await ctx.respond("\n\n".join(messages))
-                logger.info(f"Triggers listed")
+                logger.info("Triggers listed")
 
     @trigger_group.command(
         description="how to use trigger group?"
diff --git a/cogs/tts.py b/cogs/tts.py
index 3dc4c09..68eb27f 100644
--- a/cogs/tts.py
+++ b/cogs/tts.py
@@ -54,19 +54,17 @@ class TTS(commands.Cog):
             if not voice_client:
                 await ctx.respond("Failed to connect to voice channel", ephemeral=True)
                 return
-                
-            # Play the TTS audio with volume adjustment
+
+            if voice_client.is_playing():
+                await ctx.respond("Audio is already playing, try again later", ephemeral=True)
+                return
+
             audio_source = discord.FFmpegPCMAudio(
                 temp_path,
                 options=f'-filter:a "volume={volume}"'
             )
-            voice_client.play(audio_source)
             logger.info(f"Playing TTS: {text}")
 
-            # Wait for the audio to finish playing
-            while voice_client.is_playing():
-                await asyncio.sleep(0.1)
-
         except Exception as e:
             logger.error(f"Error in voice channel handling: {e}")
             await ctx.respond("eror :c", ephemeral=True)
diff --git a/cogs/utils/settings.py b/cogs/utils/settings.py
index 984ec16..d66ce7f 100644
--- a/cogs/utils/settings.py
+++ b/cogs/utils/settings.py
@@ -12,18 +12,19 @@ from dataclasses import dataclass, field
 logger = logging.getLogger(__name__)
 
 settings_file = "data/settings.json"
+DEFAULT_BASEURL = "http://localhost:8080"
 
 
 @dataclass
 class Settings:
     volume: float = 1.0
-    baseurl: str = "http://localhost:8080"
+    baseurl: str = DEFAULT_BASEURL
     _data: dict = field(default_factory=dict, init=False)
 
     async def load(self) -> "Settings":
         default_settings = {
             "volume": 1.0,
-            "baseurl": "http://localhost:8080",
+            "baseurl": DEFAULT_BASEURL,
         }
 
         try:
@@ -44,7 +45,7 @@ class Settings:
                 self._sync_from_data()
                 await self.save()
                 logger.info("Created default settings.json")
-        except (json.JSONDecodeError, Exception) as e:
+        except json.JSONDecodeError as e:
             logger.error(f"Error loading settings: {e}")
             self._data = default_settings.copy()
             self._sync_from_data()
@@ -53,7 +54,7 @@ class Settings:
 
     def _sync_from_data(self):
         self.volume = self._data.get("volume", 1.0)
-        self.baseurl = self._data.get("baseurl", "http://localhost:8080")
+        self.baseurl = self._data.get("baseurl", DEFAULT_BASEURL)
 
     def _sync_to_data(self):
         self._data["volume"] = self.volume
@@ -89,4 +90,4 @@ def get_volume() -> float:
 
 
 def get_baseurl() -> str:
-    return _settings_instance.baseurl.rstrip("/") if _settings_instance else "http://localhost:8080"
+    return _settings_instance.baseurl.rstrip("/") if _settings_instance else DEFAULT_BASEURL
diff --git a/cogs/utils/temp.py b/cogs/utils/temp.py
index 528d6a3..0b2c8d7 100644
--- a/cogs/utils/temp.py
+++ b/cogs/utils/temp.py
@@ -8,11 +8,11 @@ import tempfile
 
 def get_temp_dir(subdir: str = "senator_sperma") -> str:
     """Get or create a temp subdirectory.
-    
+
     Uses system temp directory (/tmp on Linux, %TEMP% on Windows).
     OS handles cleanup automatically.
     """
     base_temp = tempfile.gettempdir()
     temp_path = os.path.join(base_temp, subdir)
     os.makedirs(temp_path, exist_ok=True)
-    return temp_path
\ No newline at end of file
+    return temp_path
diff --git a/cogs/vclogs.py b/cogs/vclogs.py
index 397d296..fb0a2e0 100644
--- a/cogs/vclogs.py
+++ b/cogs/vclogs.py
@@ -14,9 +14,11 @@ from gtts import gTTS
 from cogs.voice import get_voice_manager
 from cogs.utils.settings import get_volume, save_settings
 
+import tempfile
+
 logger = logging.getLogger(__name__)
 
-ACTIVITY_FILE = 'temp/voice_activity.json'
+ACTIVITY_FILE = os.path.join(tempfile.gettempdir(), 'voice_activity.json')
 
 
 def load_activity_data():
@@ -100,12 +102,20 @@ class VcLogs(commands.Cog):
             volume = get_volume()
             logger.info(f"connected: {voice_client}")
 
-            if voice_client and not is_playing:
+            if voice_client:
+                if is_playing:
+                    logger.info("voice already playing, stopping current audio")
+                    voice_client.stop()
+                    await asyncio.sleep(0.1)
+
                 logger.info("preparing to play audio")
-                audio_source = discord.FFmpegPCMAudio(tts_file, options=f'-filter:a "volume={volume}"')
+                audio_source = discord.FFmpegPCMAudio(tts_file)
+                if volume != 1.0:
+                    audio_source = discord.PCMVolumeTransformer(audio_source)
+                    audio_source.volume = volume
                 voice_client.play(audio_source)
                 while voice_client.is_playing():
-                    await asyncio.sleep(0.5)
+                    await asyncio.sleep(0.1)
         except Exception as e:
             logger.error(f"TTS playback error: {e}")
         finally:
@@ -125,7 +135,16 @@ class VcLogs(commands.Cog):
 
     @commands.Cog.listener()
     async def on_voice_state_update(self, member, before, after):
-        log_channel = self.bot.get_channel(1213843195457183885)
+        log_channel_id = os.getenv("STATUS_CHANNEL_ID")
+        if not log_channel_id:
+            logger.warning("STATUS_CHANNEL_ID not set in environment")
+            return
+
+        log_channel = self.bot.get_channel(int(log_channel_id))
+        if log_channel is None:
+            logger.warning("Log channel not found or not accessible")
+            return
+
         current_time = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
         current_ts = datetime.datetime.now().timestamp()
         tts_text = None
diff --git a/cogs/voice.py b/cogs/voice.py
index 07015cc..319bb16 100644
--- a/cogs/voice.py
+++ b/cogs/voice.py
@@ -95,7 +95,7 @@ class VoiceManager:
         if not voice_client:
             return False
 
-        if volume != 1.0:
+        if abs(volume - 1.0) > 1e-9:
             audio_source = discord.PCMVolumeTransformer(audio_source)
             audio_source.volume = volume
 
@@ -197,4 +197,4 @@ class Voice(commands.Cog):
 
 
 def setup(bot):
-    bot.add_cog(Voice(bot))
\ No newline at end of file
+    bot.add_cog(Voice(bot))
diff --git a/cogs/web.py b/cogs/web.py
index e003399..b072e99 100644
--- a/cogs/web.py
+++ b/cogs/web.py
@@ -97,4 +97,4 @@ class Web(commands.Cog):
 
 
 def setup(bot):
-    bot.add_cog(Web(bot))
\ No newline at end of file
+    bot.add_cog(Web(bot))
diff --git a/main.py b/main.py
index 6c8c35b..1f5e3f6 100644
--- a/main.py
+++ b/main.py
@@ -19,11 +19,17 @@ from cogs.utils import settings
 def setup_logging(debug: bool = False):
     """Configure logging based on debug flag."""
     level = logging.DEBUG if debug else logging.INFO
+
+    class DecryptionFilter(logging.Filter):
+        def filter(self, record):
+            return "Decryption failed" not in record.getMessage()
+
     logging.basicConfig(
         level=level,
         format="%(levelname)s - %(filename)s - %(name)s - %(message)s",
         handlers=[logging.StreamHandler(sys.stdout)],
     )
+    logging.getLogger().addFilter(DecryptionFilter())
 
 
 # Create a new event loop and set it as the current loop
@@ -39,12 +45,6 @@ async def on_ready():
     logger = logging.getLogger(__name__)
     logger.info("ŁUKASZ SPERMA AKTYWACJA")
 
-    channel_id = os.getenv("STATUS_CHANNEL_ID")
-    if channel_id:
-        channel = bot.get_channel(int(channel_id))
-        if channel:
-            await channel.send("ŁUKASZ SPERMA AKTYWACJA")
-
     await settings.load_settings()
 
 
@@ -74,7 +74,6 @@ if __name__ == "__main__":
         "cogs.trigger",
         "cogs.cron",
         "cogs.qr",
-        "cogs.plot",
         "cogs.voice",
     ]
 
@@ -93,4 +92,4 @@ if __name__ == "__main__":
 
     except Exception as e:
         logging.getLogger(__name__).error(f"Error starting the bot: {e}")
-        sys.exit(1)
\ No newline at end of file
+        sys.exit(1)
diff --git a/pyrightconfig.json b/pyrightconfig.json
index f0b2a2d..7722ae1 100644
--- a/pyrightconfig.json
+++ b/pyrightconfig.json
@@ -15,4 +15,5 @@
   "reportAttributeAccessIssue": false,
   "reportPossiblyUnboundVariable": false,
   "reportArgumentType": false,
+  "reportUnreachable": false,
 }
diff --git a/pytest.ini b/pytest.ini
new file mode 100644
index 0000000..03a070f
--- /dev/null
+++ b/pytest.ini
@@ -0,0 +1,7 @@
+[pytest]
+asyncio_default_fixture_loop_scope = function
+python_files = test_*.py
+python_classes = Test*
+python_functions = test_*
+testpaths = tests
+pythonpath = .
\ No newline at end of file
diff --git a/requirements-dev.txt b/requirements-dev.txt
new file mode 100644
index 0000000..abba086
--- /dev/null
+++ b/requirements-dev.txt
@@ -0,0 +1,59 @@
+pytest==8.3.4
+pytest-asyncio==0.25.2
+pytest-mock==3.14.0
+aiofiles==25.1.0
+aiohappyeyeballs==2.6.1
+aiohttp==3.13.3
+aiosignal==1.4.0
+anyio==4.12.1
+attrs==25.4.0
+basedpyright==1.39.2
+beautifulsoup4==4.14.3
+brotli==1.2.0
+bs4==0.0.2
+certifi==2026.2.25
+cffi==2.0.0
+charset-normalizer==3.4.6
+click==8.1.8
+contourpy==1.3.3
+croniter==6.2.2
+cycler==0.12.1
+davey==0.1.4
+dotenv==0.9.9
+fonttools==4.62.1
+frozenlist==1.8.0
+gTTS==2.5.4
+h11==0.16.0
+httpcore==1.0.9
+httpx==0.28.1
+idna==3.11
+kiwisolver==1.5.0
+matplotlib==3.10.8
+multidict==6.7.1
+mutagen==1.47.0
+nodejs-wheel-binaries==24.14.1
+numpy==2.4.4
+packaging==26.1
+pillow==12.2.0
+propcache==0.4.1
+py-cord @ file:///home/salmon/Documents/botcode/senator-sperma/pycord
+pycparser==3.0
+pycryptodomex==3.23.0
+PyNaCl==1.6.2
+pyparsing==3.3.2
+python-dateutil==2.9.0.post0
+python-dotenv==1.2.2
+pytube==15.0.0
+pyzbar==0.1.9
+qrcode==8.2
+RapidFuzz==3.14.3
+requests==2.32.5
+six==1.17.0
+soupsieve==2.8.3
+typing_extensions==4.15.0
+urllib3==2.6.3
+websockets==16.0
+yarl==1.23.0
+youtube-search-python==1.6.6
+yt-dlp==2026.3.17
+yt-dlp-ejs==0.8.0
diff --git a/tests/cogs/test_ai.py b/tests/cogs/test_ai.py
new file mode 100644
index 0000000..a1c3fd4
--- /dev/null
+++ b/tests/cogs/test_ai.py
@@ -0,0 +1,83 @@
+import pytest
+from unittest.mock import AsyncMock, patch, MagicMock
+import discord
+import httpx
+from tests.conftest import MockApplicationContext
+
+
+@pytest.fixture
+def ai_cog(bot):
+    from cogs.ai import AI
+    cog = AI(bot)
+    return cog
+
+
+@pytest.fixture
+def mock_ai_response():
+    return {
+        "choices": [
+            {
+                "message": {
+                    "content": "Test response from AI"
+                }
+            }
+        ]
+    }
+
+
+@pytest.mark.asyncio
+async def test_senator_command_success(ai_cog, mock_channel, mock_guild, bot, mock_ai_response):
+    ctx = MockApplicationContext(bot=bot, channel=mock_channel, guild=mock_guild)
+
+    mock_response = MagicMock()
+    mock_response.json = MagicMock(return_value=mock_ai_response)
+
+    mock_client = MagicMock()
+    mock_client.post = AsyncMock(return_value=mock_response)
+    mock_client.__aenter__ = AsyncMock(return_value=mock_response)
+    mock_client.__aexit__ = AsyncMock(return_value=None)
+
+    with patch('cogs.ai.httpx.AsyncClient') as mock_httpx:
+        instance = mock_httpx.return_value.__aenter__.return_value
+        instance.post = AsyncMock(return_value=mock_response)
+        with patch.object(ctx, 'send_followup', new_callable=AsyncMock) as mock_followup:
+            await ai_cog.senator.callback(ai_cog, ctx, text="Hello", tts=False)
+            mock_followup.assert_called_once_with("Test response from AI")
+
+
+@pytest.mark.asyncio
+async def test_senator_command_empty_choices(ai_cog, mock_channel, mock_guild, bot):
+    ctx = MockApplicationContext(bot=bot, channel=mock_channel, guild=mock_guild)
+
+    mock_response = MagicMock()
+    mock_response.json = MagicMock(return_value={"choices": []})
+
+    mock_client = MagicMock()
+    mock_client.post = AsyncMock(return_value=mock_response)
+    mock_client.__aenter__ = AsyncMock(return_value=mock_response)
+    mock_client.__aexit__ = AsyncMock(return_value=None)
+
+    with patch('cogs.ai.httpx.AsyncClient') as mock_httpx:
+        instance = mock_httpx.return_value.__aenter__.return_value
+        instance.post = AsyncMock(return_value=mock_response)
+        with patch.object(ctx, 'send_followup', new_callable=AsyncMock) as mock_followup:
+            await ai_cog.senator.callback(ai_cog, ctx, text="Hello", tts=False)
+            mock_followup.assert_called_once_with("bot siem zesroł")
+
+
+@pytest.mark.asyncio
+async def test_senator_command_no_choices_key(ai_cog, mock_channel, mock_guild, bot):
+    ctx = MockApplicationContext(bot=bot, channel=mock_channel, guild=mock_guild)
+
+    mock_response = MagicMock()
+    mock_response.json = MagicMock(return_value={})
+
+    with patch('cogs.ai.httpx.AsyncClient') as mock_httpx:
+        instance = mock_httpx.return_value.__aenter__.return_value
+        instance.post = AsyncMock(return_value=mock_response)
+        with patch('cogs.ai.logger') as mock_logger:
+            try:
+                await ai_cog.senator.callback(ai_cog, ctx, text="Hello", tts=False)
+            except KeyError:
+                pass
+            assert mock_logger.info.called
diff --git a/tests/cogs/test_assistant.py b/tests/cogs/test_assistant.py
new file mode 100644
index 0000000..9a33232
--- /dev/null
+++ b/tests/cogs/test_assistant.py
@@ -0,0 +1,66 @@
+import pytest
+from unittest.mock import AsyncMock, patch, MagicMock
+from tests.conftest import MockApplicationContext
+
+
+@pytest.fixture
+def assistant_cog():
+    with patch('os.getenv', return_value="test_keyword"):
+        from cogs.assistant import Jarvis
+
+        mock_bot = MagicMock()
+        mock_bot.user = MagicMock()
+        mock_bot.user.id = 111
+
+        cog = Jarvis(mock_bot)
+    return cog
+
+
+def test_assistant_keyword_default(assistant_cog):
+    assert assistant_cog.keyword == "test_keyword"
+
+
+@pytest.mark.asyncio
+async def test_assistant_on_message_ignored_bot_message(assistant_cog):
+    mock_author = MagicMock()
+    mock_author.id = 456
+    mock_author.bot = True
+
+    mock_message = MagicMock()
+    mock_message.author = mock_author
+
+    with patch.object(assistant_cog, 'assistant', new_callable=AsyncMock) as mock_assistant:
+        await assistant_cog.on_message(mock_message)
+        mock_assistant.assert_not_called()
+
+
+@pytest.mark.asyncio
+async def test_assistant_on_message_mentions_bot(assistant_cog):
+    mock_message = MagicMock()
+    mock_message.author = MagicMock()
+    mock_message.author.id = 123
+
+    mock_mention = MagicMock()
+    mock_mention.id = 111
+    mock_message.mentions = [mock_mention]
+    mock_message.content = "test"
+
+    with patch.object(assistant_cog, 'assistant', new_callable=AsyncMock) as mock_assistant:
+        await assistant_cog.on_message(mock_message)
+        mock_assistant.assert_called_once_with(mock_message)
+
+
+@pytest.mark.asyncio
+async def test_assistant_on_message_keyword_match(assistant_cog):
+    assistant_cog.keyword = "test"
+
+    mock_message = MagicMock()
+    mock_message.author = MagicMock()
+    mock_message.author.id = 123
+
+    mock_message.mentions = []
+    mock_message.content = "test message with test keyword"
+
+    with patch.object(assistant_cog, 'assistant', new_callable=AsyncMock) as mock_assistant:
+        await assistant_cog.on_message(mock_message)
+        mock_assistant.assert_called_once_with(mock_message)
diff --git a/tests/cogs/test_compression_conversion.py b/tests/cogs/test_compression_conversion.py
new file mode 100644
index 0000000..f9d3427
--- /dev/null
+++ b/tests/cogs/test_compression_conversion.py
@@ -0,0 +1,139 @@
+import pytest
+from unittest.mock import AsyncMock, patch, MagicMock
+import os
+import discord
+from tests.conftest import MockApplicationContext
+
+
+def test_compression_filetype_video():
+    from cogs.compression import filetype
+    assert filetype("test.mp4") == "Video"
+    assert filetype("test.avi") == "Video"
+
+
+def test_compression_filetype_audio():
+    from cogs.compression import filetype
+    assert filetype("test.mp3") == "Audio"
+    assert filetype("test.wav") == "Audio"
+
+
+def test_compression_filetype_image():
+    from cogs.compression import filetype
+    assert filetype("test.jpg") == "Image"
+    assert filetype("test.png") == "Image"
+
+
+def test_conversion_filetype():
+    from cogs.conversion import filetype
+    assert filetype("test.mp4") == "Video"
+    assert filetype("test.mp3") == "Audio"
+    assert filetype("test.jpg") == "Image"
+    assert filetype("test.xyz") == "Unknown"
+
+
+@pytest.mark.asyncio
+async def test_build_conversion_command_video():
+    with patch('os.getenv', return_value="https://example.com"):
+        with patch('cogs.utils.temp.get_temp_dir', return_value="/tmp"):
+            with patch('cogs.utils.settings.get_baseurl', return_value="https://example.com"):
+                import importlib
+                import cogs.conversion
+                importlib.reload(cogs.conversion)
+                from cogs.conversion import Conversion
+
+                cog = Conversion.__new__(Conversion)
+                cog._baseurl = "https://example.com"
+                cog._uploadurl = "https://example.com"
+
+                cmd = cog._build_conversion_command("Video", "/tmp/test.mp4", "/tmp/output.mp4", "")
+                assert cmd is not None
+                assert "ffmpeg" in cmd
+
+
+@pytest.mark.asyncio
+async def test_build_conversion_command_image():
+    with patch('os.getenv', return_value="https://example.com"):
+        with patch('cogs.utils.temp.get_temp_dir', return_value="/tmp"):
+            with patch('cogs.utils.settings.get_baseurl', return_value="https://example.com"):
+                import importlib
+                import cogs.conversion
+                importlib.reload(cogs.conversion)
+                from cogs.conversion import Conversion
+
+                cog = Conversion.__new__(Conversion)
+                cog._baseurl = "https://example.com"
+                cog._uploadurl = "https://example.com"
+
+                cmd = cog._build_conversion_command("Image", "/tmp/test.jpg", "/tmp/output.png", "")
+                assert cmd is not None
+                assert "magick" in cmd
+
+
+@pytest.mark.asyncio
+async def test_build_conversion_command_unknown():
+    with patch('os.getenv', return_value="https://example.com"):
+        with patch('cogs.utils.temp.get_temp_dir', return_value="/tmp"):
+            with patch('cogs.utils.settings.get_baseurl', return_value="https://example.com"):
+                import importlib
+                import cogs.conversion
+                importlib.reload(cogs.conversion)
+                from cogs.conversion import Conversion
+
+                cog = Conversion.__new__(Conversion)
+                cog._baseurl = "https://example.com"
+                cog._uploadurl = "https://example.com"
+
+                cmd = cog._build_conversion_command("Unknown", "/tmp/test.xyz", "/tmp/output.abc", "")
+                assert cmd is None
+
+
+@pytest.mark.asyncio
+async def test_compression_get_command_video():
+    with patch('os.getenv', return_value="https://example.com"):
+        with patch('cogs.utils.temp.get_temp_dir', return_value="/tmp"):
+            with patch('cogs.utils.settings.get_baseurl', return_value="https://example.com"):
+                import importlib
+                import cogs.compression
+                importlib.reload(cogs.compression)
+                from cogs.compression import Compression
+
+                cog = Compression.__new__(Compression)
+                cog.temp_dir = "/tmp"
+
+                cmd = cog._get_compression_command("Video", "/tmp/test.mp4", "/tmp/output.mp4")
+                assert cmd is not None
+                assert "ffmpeg" in cmd
+
+
+@pytest.mark.asyncio
+async def test_compression_get_command_image():
+    with patch('os.getenv', return_value="https://example.com"):
+        with patch('cogs.utils.temp.get_temp_dir', return_value="/tmp"):
+            with patch('cogs.utils.settings.get_baseurl', return_value="https://example.com"):
+                import importlib
+                import cogs.compression
+                importlib.reload(cogs.compression)
+                from cogs.compression import Compression
+
+                cog = Compression.__new__(Compression)
+                cog.temp_dir = "/tmp"
+
+                cmd = cog._get_compression_command("Image", "/tmp/test.jpg", "/tmp/output.jpg")
+                assert cmd is not None
+
+
+@pytest.mark.asyncio
+async def test_compression_get_command_unknown():
+    with patch('os.getenv', return_value="https://example.com"):
+        with patch('cogs.utils.temp.get_temp_dir', return_value="/tmp"):
+            with patch('cogs.utils.settings.get_baseurl', return_value="https://example.com"):
+                import importlib
+                import cogs.compression
+                importlib.reload(cogs.compression)
+                from cogs.compression import Compression
+
+                cog = Compression.__new__(Compression)
+                cog.temp_dir = "/tmp"
+
+                cmd = cog._get_compression_command("Unknown", "/tmp/test.xyz", "/tmp/output.xyz")
+                assert cmd is None
diff --git a/tests/cogs/test_cron.py b/tests/cogs/test_cron.py
new file mode 100644
index 0000000..93031f8
--- /dev/null
+++ b/tests/cogs/test_cron.py
@@ -0,0 +1,166 @@
+import json
+import os
+import pytest
+from datetime import datetime
+from unittest.mock import MagicMock, patch
+
+from cogs.cron import Cron
+
+
+@pytest.fixture
+def mock_bot():
+    bot = MagicMock()
+    bot.loop = MagicMock()
+    bot.is_closed = MagicMock(return_value=False)
+    bot.wait_until_ready = MagicMock()
+    bot.loop.create_task = MagicMock(return_value=MagicMock())
+    return bot
+
+
+def create_cog(mock_bot, tmp_path):
+    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
+
+
+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_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 == []
+
+
+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_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}]
+
+        cog.save_tasks()
+
+        assert os.path.exists(new_dir)
+
+
+class TestShouldRunTask:
+    def test_should_run_task_invalid_cron(self, mock_bot, tmp_path):
+        cog = create_cog(mock_bot, tmp_path)
+        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)
+        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):
+        with patch.object(Cron, "__init__", lambda self, bot: None):
+            cog = Cron.__new__(Cron)
+            cog.bot = mock_bot
+            cog.task = MagicMock()
+
+            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)
+        cog.scheduled_tasks = [
+            {"id": 1, "cron_expression": "* * * * *"},
+            {"id": 2, "cron_expression": "0 * * * *"},
+        ]
+
+        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)
+        cog.scheduled_tasks = [
+            {"id": 1, "cron_expression": "* * * * *"},
+            {"id": 2, "cron_expression": "0 * * * *"},
+        ]
+
+        found_task = next((t for t in cog.scheduled_tasks if t["id"] == 2), None)
+        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)
+        cog.scheduled_tasks = [
+            {"id": 1, "cron_expression": "* * * * *"},
+            {"id": 2, "cron_expression": "0 * * * *"},
+        ]
+
+        cog.scheduled_tasks.pop(0)
+        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)
+        cog.scheduled_tasks = [{"id": 1, "active": True}]
+
+        cog.scheduled_tasks[0]["active"] = False
+        assert cog.scheduled_tasks[0]["active"] is False
+
+        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):
+        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):
+        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_downloader.py b/tests/cogs/test_downloader.py
new file mode 100644
index 0000000..6ac8ae7
--- /dev/null
+++ b/tests/cogs/test_downloader.py
@@ -0,0 +1,93 @@
+import pytest
+from unittest.mock import AsyncMock, patch, MagicMock
+import discord
+from tests.conftest import MockApplicationContext, MockMessage
+
+
+@pytest.fixture
+def downloader_cog(bot):
+    from cogs.downloader import Downloader
+    cog = Downloader(bot)
+    return cog
+
+
+@pytest.mark.asyncio
+async def test_download_command_success_file(downloader_cog, mock_channel, mock_guild, bot):
+    ctx = MockApplicationContext(bot=bot, channel=mock_channel, guild=mock_guild)
+
+    mock_file_path = "/tmp/test_video.mp4"
+
+    with patch('cogs.downloader.Downloader.download_standalone', return_value={
+        "status": "success",
+        "type": "file",
+        "content": mock_file_path,
+        "filename": "test_video.mp4"
+    }):
+        with patch('discord.File', return_value=MagicMock()) as mock_file:
+            with patch.object(ctx, 'respond', new_callable=AsyncMock) as mock_respond:
+                await downloader_cog.download.callback(downloader_cog, ctx, url="https://example.com/video", catbox=False, fformat="mp4", filename_user=None)
+                mock_respond.assert_called_once()
+                call_args = mock_respond.call_args
+                assert 'file' in str(call_args) or mock_file.called
+
+
+@pytest.mark.asyncio
+async def test_download_command_success_url(downloader_cog, mock_channel, mock_guild, bot):
+    ctx = MockApplicationContext(bot=bot, channel=mock_channel, guild=mock_guild)
+
+    with patch('cogs.downloader.Downloader.download_standalone', return_value={
+        "status": "success",
+        "type": "url",
+        "content": "https://catbox.2137697.xyz/sperma/test.mp4"
+    }):
+        with patch.object(ctx, 'respond', new_callable=AsyncMock) as mock_respond:
+            await downloader_cog.download.callback(downloader_cog, ctx, url="https://example.com/video", catbox=True, fformat="mp4", filename_user=None)
+            mock_respond.assert_called_once()
+            call_args = mock_respond.call_args
+            assert "pobioron" in str(call_args)
+
+
+@pytest.mark.asyncio
+async def test_download_command_error(downloader_cog, mock_channel, mock_guild, bot):
+    ctx = MockApplicationContext(bot=bot, channel=mock_channel, guild=mock_guild)
+
+    with patch('cogs.downloader.Downloader.download_standalone', return_value={
+        "status": "error",
+        "type": "error",
+        "content": "Download failed",
+        "details": "Connection timeout"
+    }):
+        with patch('cogs.downloader.logger') as mock_logger:
+            await downloader_cog.download.callback(downloader_cog, ctx, url="https://badurl.com", catbox=False, fformat="mp4", filename_user=None)
+            assert mock_logger.error.called
+
+
+@pytest.mark.asyncio
+async def test_message_download_with_url(downloader_cog, mock_channel, mock_guild, bot, mock_user):
+    ctx = MockApplicationContext(bot=bot, channel=mock_channel, guild=mock_guild)
+
+    mock_message = MagicMock()
+    mock_message.content = "Check this out https://example.com/video"
+
+    with patch('cogs.downloader.Downloader.download_standalone', return_value={
+        "status": "success",
+        "type": "file",
+        "content": "/tmp/test.mp4"
+    }):
+        with patch.object(downloader_cog, 'download', new_callable=AsyncMock) as mock_download:
+            await downloader_cog.message_download.callback(downloader_cog, ctx, message=mock_message)
+            mock_download.assert_called_once()
+
+
+@pytest.mark.asyncio
+async def test_message_download_no_url(downloader_cog, mock_channel, mock_guild, bot):
+    ctx = MockApplicationContext(bot=bot, channel=mock_channel, guild=mock_guild)
+
+    mock_message = MagicMock()
+    mock_message.content = "No URL here"
+
+    with patch.object(ctx, 'respond', new_callable=AsyncMock) as mock_respond:
+        await downloader_cog.message_download.callback(downloader_cog, ctx, message=mock_message)
+        mock_respond.assert_called_once()
+        call_args = mock_respond.call_args
+        assert "Brak" in str(call_args)
diff --git a/tests/cogs/test_math_commands.py b/tests/cogs/test_math_commands.py
new file mode 100644
index 0000000..5c78027
--- /dev/null
+++ b/tests/cogs/test_math_commands.py
@@ -0,0 +1,55 @@
+import pytest
+from unittest.mock import AsyncMock, patch, MagicMock
+from tests.conftest import MockApplicationContext
+
+
+@pytest.fixture
+def math_cog(bot):
+    from cogs.math_commands import Math
+    cog = Math(bot)
+    return cog
+
+
+@pytest.mark.asyncio
+async def test_math_command_valid_expression(math_cog, mock_channel, mock_guild, bot):
+    ctx = MockApplicationContext(bot=bot, channel=mock_channel, guild=mock_guild)
+
+    mock_process = MagicMock()
+    mock_process.returncode = 0
+    mock_process.communicate = AsyncMock(return_value=(b"4", b""))
+
+    with patch('cogs.math_commands.asyncio.create_subprocess_exec', return_value=mock_process) as mock_subprocess:
+        with patch('cogs.math_commands.re.search', return_value=None):
+            with patch.object(ctx, 'respond', new_callable=AsyncMock) as mock_respond:
+                await math_cog.math.callback(math_cog, ctx, equation="2+2")
+                mock_subprocess.assert_called_once()
+                mock_respond.assert_called_once()
+
+
+@pytest.mark.asyncio
+async def test_math_command_invalid_expression(math_cog, mock_channel, mock_guild, bot):
+    ctx = MockApplicationContext(bot=bot, channel=mock_channel, guild=mock_guild)
+
+    with patch('cogs.math_commands.re.search', return_value=MagicMock()):
+        with patch.object(ctx, 'respond', new_callable=AsyncMock) as mock_respond:
+            await math_cog.math.callback(math_cog, ctx, equation="eval(1)")
+            mock_respond.assert_called_once()
+            args = mock_respond.call_args
+            assert "Invalid" in str(args)
+
+
+@pytest.mark.asyncio
+async def test_math_command_process_error(math_cog, mock_channel, mock_guild, bot):
+    ctx = MockApplicationContext(bot=bot, channel=mock_channel, guild=mock_guild)
+
+    mock_process = MagicMock()
+    mock_process.returncode = 1
+    mock_process.communicate = AsyncMock(return_value=(b"", b"Error: invalid expression"))
+
+    with patch('cogs.math_commands.asyncio.create_subprocess_exec', return_value=mock_process):
+        with patch('cogs.math_commands.re.search', return_value=None):
+            with patch.object(ctx, 'respond', new_callable=AsyncMock) as mock_respond:
+                await math_cog.math.callback(math_cog, ctx, equation="2++")
+                mock_respond.assert_called_once()
+                args = mock_respond.call_args
+                assert "error" in str(args).lower() or "Error" in str(args)
diff --git a/tests/cogs/test_music_audio.py b/tests/cogs/test_music_audio.py
new file mode 100644
index 0000000..7ea902e
--- /dev/null
+++ b/tests/cogs/test_music_audio.py
@@ -0,0 +1,93 @@
+import pytest
+from unittest.mock import AsyncMock, patch, MagicMock
+import os
+from tests.conftest import MockApplicationContext
+
+
+@pytest.mark.asyncio
+async def test_validate_voice_channel_not_in_voice():
+    from cogs.music.audio_playback import AudioPlaybackManager
+
+    mock_ctx = MagicMock()
+    mock_ctx.author.voice = None
+    mock_ctx.respond = AsyncMock()
+
+    result = await AudioPlaybackManager.validate_voice_channel(mock_ctx)
+
+    assert result is None
+    mock_ctx.respond.assert_called_once()
+
+
+@pytest.mark.asyncio
+async def test_validate_voice_channel_in_voice():
+    from cogs.music.audio_playback import AudioPlaybackManager
+
+    mock_channel = MagicMock()
+    mock_ctx = MagicMock()
+    mock_ctx.author.voice = MagicMock()
+    mock_ctx.author.voice.channel = mock_channel
+    mock_ctx.respond = AsyncMock()
+
+    result = await AudioPlaybackManager.validate_voice_channel(mock_ctx)
+
+    assert result == mock_channel
+
+
+@pytest.mark.asyncio
+async def test_prepare_file_source_file_not_found():
+    from cogs.music.audio_playback import AudioPlaybackManager
+
+    display_name, absolute_path = await AudioPlaybackManager.prepare_file_source("/nonexistent/file.mp3")
+
+    assert display_name is None
+    assert absolute_path is None
+
+
+@pytest.mark.asyncio
+async def test_prepare_file_source_absolute_path():
+    from cogs.music.audio_playback import AudioPlaybackManager
+
+    with patch('os.path.exists', return_value=True):
+        with patch('os.path.isabs', return_value=True):
+            display_name, absolute_path = await AudioPlaybackManager.prepare_file_source("/tmp/test.mp3")
+
+            assert display_name == "test"
+            assert absolute_path == "/tmp/test.mp3"
+
+
+@pytest.mark.asyncio
+async def test_prepare_source_url():
+    from cogs.music.audio_playback import AudioPlaybackManager
+
+    source, _, is_url = await AudioPlaybackManager.prepare_source(MagicMock(), "https://example.com/stream")
+
+    assert is_url == True
+    assert source == "https://example.com/stream"
+
+
+@pytest.mark.asyncio
+async def test_prepare_source_local_file():
+    from cogs.music.audio_playback import AudioPlaybackManager
+
+    with patch('os.path.exists', return_value=True):
+        source, display_name, is_url = await AudioPlaybackManager.prepare_source(MagicMock(), "/tmp/test.mp3")
+
+        assert is_url == False
+        assert display_name == "test"
+
+
+@pytest.mark.asyncio
+async def test_cleanup_temp_file():
+    from cogs.music.audio_playback import AudioPlaybackManager
+
+    with patch('os.path.exists', return_value=True):
+        with patch('os.remove'):
+            await AudioPlaybackManager.cleanup_temp_file("/tmp/test.mp3")
+
+
+@pytest.mark.asyncio
+async def test_cleanup_temp_file_not_exists():
+    from cogs.music.audio_playback import AudioPlaybackManager
+
+    with patch('os.path.exists', return_value=False):
+        await AudioPlaybackManager.cleanup_temp_file("/nonexistent/file.mp3")
diff --git a/tests/cogs/test_music_external_play.py b/tests/cogs/test_music_external_play.py
new file mode 100644
index 0000000..fd4b625
--- /dev/null
+++ b/tests/cogs/test_music_external_play.py
@@ -0,0 +1,116 @@
+import pytest
+import os
+import asyncio
+import tempfile
+from unittest.mock import AsyncMock, patch, MagicMock
+from tests.conftest import MockApplicationContext
+
+
+@pytest.fixture
+def play_commands_cog(bot):
+    with patch('cogs.utils.temp.get_temp_dir', return_value="/tmp"):
+        from cogs.music.play_commands import PlayCommands
+        cog = PlayCommands(bot)
+    return cog
+
+
+@pytest.fixture
+def temp_mp3_file():
+    with tempfile.NamedTemporaryFile(suffix='.mp3', delete=False) as f:
+        f.write(b'fake mp3 content')
+        temp_path = f.name
+    yield temp_path
+    if os.path.exists(temp_path):
+        os.remove(temp_path)
+
+
+@pytest.mark.asyncio
+async def test_external_url_pattern_matches_youtube(play_commands_cog):
+    from cogs.music.play_commands import EXTERNAL_URL_PATTERN
+
+    assert EXTERNAL_URL_PATTERN.match("https://youtube.com/watch?v=test")
+    assert EXTERNAL_URL_PATTERN.match("https://youtu.be/test")
+    assert EXTERNAL_URL_PATTERN.match("https://www.youtube.com/watch?v=test")
+
+
+@pytest.mark.asyncio
+async def test_external_url_pattern_matches_soundcloud(play_commands_cog):
+    from cogs.music.play_commands import EXTERNAL_URL_PATTERN
+
+    assert EXTERNAL_URL_PATTERN.match("https://soundcloud.com/artist/track")
+    assert EXTERNAL_URL_PATTERN.match("https://api.soundcloud.com/tracks")
+
+
+@pytest.mark.asyncio
+async def test_external_url_pattern_matches_bandcamp(play_commands_cog):
+    from cogs.music.play_commands import EXTERNAL_URL_PATTERN
+
+    assert EXTERNAL_URL_PATTERN.match("https://artist.bandcamp.com/track")
+
+
+@pytest.mark.asyncio
+async def test_external_url_pattern_rejects_copyparty(play_commands_cog):
+    from cogs.music.play_commands import EXTERNAL_URL_PATTERN
+
+    assert not EXTERNAL_URL_PATTERN.match("https://catbox.2137697.xyz/sperma/file.mp3")
+    assert not EXTERNAL_URL_PATTERN.match("some search query")
+
+
+@pytest.mark.asyncio
+async def test_play_command_calls_external_handler(play_commands_cog, mock_channel, mock_guild, bot):
+    ctx = MockApplicationContext(bot=bot, channel=mock_channel, guild=mock_guild)
+
+    with patch.object(play_commands_cog, '_handle_external_url_play', new_callable=AsyncMock) as mock_handler:
+        mock_handler.return_value = None
+        mock_defer = AsyncMock()
+        ctx.defer = mock_defer
+        ctx.respond = AsyncMock()
+
+        await play_commands_cog.play.callback(
+            play_commands_cog, ctx,
+            melodia="https://youtube.com/watch?v=test",
+            file=None, compressed=False
+        )
+
+        mock_handler.assert_called_once_with(ctx, "https://youtube.com/watch?v=test")
+
+
+@pytest.mark.asyncio
+async def test_play_command_calls_local_handler(play_commands_cog, mock_channel, mock_guild, bot):
+    ctx = MockApplicationContext(bot=bot, channel=mock_channel, guild=mock_guild)
+
+    with patch.object(play_commands_cog, '_handle_local_file_play', new_callable=AsyncMock) as mock_handler:
+        mock_handler.return_value = None
+        mock_defer = AsyncMock()
+        ctx.defer = mock_defer
+        ctx.respond = AsyncMock()
+
+        await play_commands_cog.play.callback(
+            play_commands_cog, ctx,
+            melodia="some search query",
+            file=None, compressed=False
+        )
+
+        mock_handler.assert_called_once_with(ctx, "some search query", False)
+
+
+@pytest.mark.asyncio
+async def test_upload_to_copyparty_async(play_commands_cog, temp_mp3_file, monkeypatch):
+    monkeypatch.setenv("COPYPARTY_URL_UPLOAD", "https://catbox.2137697.xyz/sperma/")
+    monkeypatch.setenv("COPYPARTY_PASSWORD", "testpassword")
+
+    mock_response = AsyncMock()
+    mock_response.status = 200
+    mock_response.text = AsyncMock(return_value="")
+    mock_response.json = AsyncMock(return_value={"fileurl": "https://example.com/file.mp3"})
+    mock_response.__aenter__ = AsyncMock(return_value=mock_response)
+    mock_response.__aexit__ = AsyncMock()
+
+    mock_session_context = AsyncMock()
+    mock_session_context.__aenter__ = AsyncMock(return_value=mock_session_context)
+    mock_session_context.__aexit__ = AsyncMock()
+    mock_session_context.post = MagicMock(return_value=mock_response)
+
+    with patch('aiohttp.ClientSession', return_value=mock_session_context):
+        await play_commands_cog._upload_to_copyparty_async(temp_mp3_file)
+        mock_session_context.post.assert_called_once()
diff --git a/tests/cogs/test_music_join.py b/tests/cogs/test_music_join.py
new file mode 100644
index 0000000..3c7ca6e
--- /dev/null
+++ b/tests/cogs/test_music_join.py
@@ -0,0 +1,53 @@
+import pytest
+from unittest.mock import AsyncMock, patch, MagicMock
+from tests.conftest import MockApplicationContext
+
+
+@pytest.fixture
+def join_cog(bot):
+    from cogs.music.join import Join
+    cog = Join(bot)
+    return cog
+
+
+@pytest.fixture
+def stop_cog(bot):
+    from cogs.music.stop import Stop
+    cog = Stop(bot)
+    return cog
+
+
+@pytest.mark.asyncio
+async def test_join_command_success(join_cog, mock_channel, mock_guild, bot, mock_user):
+    ctx = MockApplicationContext(bot=bot, channel=mock_channel, guild=mock_guild)
+    ctx.user = mock_user
+    ctx.author = mock_user
+
+    mock_voice_channel = MagicMock()
+    mock_voice = MagicMock()
+    mock_voice_channel.connect = AsyncMock(return_value=mock_voice)
+
+    ctx.author.voice = MagicMock()
+    ctx.author.voice.channel = mock_voice_channel
+
+    with patch.object(mock_voice_channel, 'connect', new_callable=AsyncMock, return_value=mock_voice):
+        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)
+
+
+@pytest.mark.asyncio
+async def test_stop_command_success(stop_cog, mock_channel, mock_guild, bot, mock_user):
+    ctx = MockApplicationContext(bot=bot, channel=mock_channel, guild=mock_guild)
+    ctx.user = mock_user
+    ctx.author = mock_user
+
+    mock_voice_client = MagicMock()
+    mock_voice_client.disconnect = AsyncMock()
+    ctx.voice_client = mock_voice_client
+
+    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)
+
+            mock_voice_client.disconnect.assert_called_once()
diff --git a/tests/cogs/test_music_play.py b/tests/cogs/test_music_play.py
new file mode 100644
index 0000000..e720c9a
--- /dev/null
+++ b/tests/cogs/test_music_play.py
@@ -0,0 +1,104 @@
+import pytest
+from unittest.mock import AsyncMock, patch, MagicMock
+import os
+from tests.conftest import MockApplicationContext
+
+
+@pytest.fixture
+def play_commands_cog(bot):
+    with patch('cogs.utils.temp.get_temp_dir', return_value="/tmp"):
+        from cogs.music.play_commands import PlayCommands
+        cog = PlayCommands(bot)
+    return cog
+
+
+@pytest.fixture
+def loop_cog(bot):
+    from cogs.music.loop import Loop
+    cog = Loop(bot)
+    return cog
+
+
+@pytest.mark.asyncio
+async def test_create_search_embed_empty(play_commands_cog):
+    embed, view = await play_commands_cog._create_search_embed([])
+
+    assert embed.title == "Wyniki wyszukiwania"
+    assert len(view.children) == 0
+
+
+@pytest.mark.asyncio
+async def test_create_search_embed_with_candidates(play_commands_cog):
+    candidates = [
+        "https://example.com/test1.mp3",
+        "https://example.com/test2.mp3"
+    ]
+
+    embed, view = await play_commands_cog._create_search_embed(candidates)
+
+    assert embed.title == "Wyniki wyszukiwania"
+    assert len(embed.fields) == 2
+
+
+@pytest.mark.asyncio
+async def test_play_command_no_file_or_search(play_commands_cog, mock_channel, mock_guild, bot):
+    ctx = MockApplicationContext(bot=bot, channel=mock_channel, guild=mock_guild)
+
+    with patch.object(ctx, 'respond', new_callable=AsyncMock) as mock_respond:
+        await play_commands_cog.play.callback(play_commands_cog, ctx, melodia=None, file=None, compressed=False)
+        mock_respond.assert_called_once()
+        args = mock_respond.call_args
+        assert "Musisz podać" in str(args)
+
+
+@pytest.mark.asyncio
+async def test_play_command_both_file_and_search(play_commands_cog, mock_channel, mock_guild, bot):
+    ctx = MockApplicationContext(bot=bot, channel=mock_channel, guild=mock_guild)
+
+    mock_file = MagicMock()
+    mock_file.filename = "test.mp3"
+
+    with patch.object(ctx, 'respond', new_callable=AsyncMock) as mock_respond:
+        await play_commands_cog.play.callback(play_commands_cog, ctx, melodia="test", file=mock_file, compressed=False)
+        mock_respond.assert_called_once()
+        args = mock_respond.call_args
+        assert "nie oba" in str(args) or "LUB" in str(args)
+
+
+def test_loop_cog_is_looping_initial(loop_cog):
+    assert loop_cog.is_looping(123) == False
+
+
+def test_loop_cog_set_looping(loop_cog):
+    loop_cog.set_looping(123, True)
+    assert loop_cog.is_looping(123) == True
+
+
+@pytest.mark.asyncio
+async def test_loop_command_toggle_on(loop_cog, mock_channel, mock_guild, bot, mock_user):
+    ctx = MockApplicationContext(bot=bot, channel=mock_channel, guild=mock_guild)
+    ctx.user = mock_user
+    ctx.author = mock_user
+    ctx.guild.id = 123
+
+    with patch.object(ctx, 'respond', new_callable=AsyncMock) as mock_respond:
+        await loop_cog.loop.callback(loop_cog, ctx)
+        mock_respond.assert_called_once()
+        args = mock_respond.call_args
+        assert "włączony" in str(args)
+
+
+@pytest.mark.asyncio
+async def test_loop_command_toggle_off(loop_cog, mock_channel, mock_guild, bot, mock_user):
+    ctx = MockApplicationContext(bot=bot, channel=mock_channel, guild=mock_guild)
+    ctx.user = mock_user
+    ctx.author = mock_user
+    ctx.guild.id = 456
+
+    loop_cog.set_looping(456, True)
+
+    with patch.object(ctx, 'respond', new_callable=AsyncMock) as mock_respond:
+        await loop_cog.loop.callback(loop_cog, ctx)
+        mock_respond.assert_called_once()
+        args = mock_respond.call_args
+        assert "wyłączony" in str(args)
diff --git a/tests/cogs/test_qr.py b/tests/cogs/test_qr.py
new file mode 100644
index 0000000..2a132ca
--- /dev/null
+++ b/tests/cogs/test_qr.py
@@ -0,0 +1,75 @@
+import pytest
+from unittest.mock import AsyncMock, patch, MagicMock, mock_open
+import os
+from cogs.qr import QR
+from tests.conftest import MockApplicationContext
+
+
+@pytest.fixture
+def qr_cog(bot):
+    cog = QR(bot)
+    return cog
+
+
+@pytest.fixture
+def mock_temp_file():
+    with patch('tempfile.NamedTemporaryFile') as mock:
+        mock_file = MagicMock()
+        mock_file.name = "/tmp/test_qr.png"
+        mock.return_value = mock_file
+        yield mock_file
+
+
+@pytest.mark.asyncio
+async def test_qr_generate_success(qr_cog, mock_channel, mock_guild, bot, mock_temp_file):
+    ctx = MockApplicationContext(bot=bot, channel=mock_channel, guild=mock_guild)
+
+    with patch('cogs.qr.QR._generate_qr') as mock_generate:
+        with patch.object(ctx, 'respond', new_callable=AsyncMock) as mock_respond:
+            with patch('os.path.exists', return_value=True):
+                with patch('os.unlink'):
+                    await qr_cog.qr.callback(qr_cog, ctx, text="https://example.com")
+                    mock_generate.assert_called_once()
+                    mock_respond.assert_called_once()
+
+
+@pytest.mark.asyncio
+async def test_qr_generate_empty_text(qr_cog, mock_channel, mock_guild, bot):
+    ctx = MockApplicationContext(bot=bot, channel=mock_channel, guild=mock_guild)
+
+    with patch('cogs.qr.QR._generate_qr'):
+        with patch.object(ctx, 'respond', new_callable=AsyncMock) as mock_respond:
+            with patch('os.path.exists', return_value=False):
+                await qr_cog.qr.callback(qr_cog, ctx, text="")
+                mock_respond.assert_called_once()
+
+
+@pytest.mark.asyncio
+async def test_qr_decode_not_available(qr_cog, mock_channel, mock_guild, bot):
+    ctx = MockApplicationContext(bot=bot, channel=mock_channel, guild=mock_guild)
+
+    mock_attachment = MagicMock()
+    mock_attachment.url = "https://example.com/qr.png"
+
+    with patch('cogs.qr._ensure_qr', return_value=False):
+        with patch.object(ctx, 'respond', new_callable=AsyncMock) as mock_respond:
+            await qr_cog.decode.callback(qr_cog, ctx, image=mock_attachment)
+            mock_respond.assert_called_once()
+            args = mock_respond.call_args
+            assert "nie jest dostępne" in str(args) or "not available" in str(args).lower()
+
+
+@pytest.mark.asyncio
+async def test_qr_decode_download_failure(qr_cog, mock_channel, mock_guild, bot):
+    ctx = MockApplicationContext(bot=bot, channel=mock_channel, guild=mock_guild)
+
+    mock_attachment = MagicMock()
+    mock_attachment.url = "https://example.com/qr.png"
+
+    with patch('cogs.qr._ensure_qr', return_value=True):
+        with patch.object(qr_cog, '_download_image', return_value=None):
+            with patch.object(ctx, 'respond', new_callable=AsyncMock) as mock_respond:
+                await qr_cog.decode.callback(qr_cog, ctx, image=mock_attachment)
+                mock_respond.assert_called_once()
+                args = mock_respond.call_args
+                assert "Nie udało się" in str(args) or "failed" in str(args).lower()
diff --git a/tests/cogs/test_say.py b/tests/cogs/test_say.py
new file mode 100644
index 0000000..13cad40
--- /dev/null
+++ b/tests/cogs/test_say.py
@@ -0,0 +1,38 @@
+import pytest
+from unittest.mock import AsyncMock, patch
+from cogs.say import Say
+from tests.conftest import MockApplicationContext
+
+
+@pytest.fixture
+def say_cog(bot):
+    cog = Say(bot)
+    return cog
+
+
+@pytest.mark.asyncio
+async def test_say_command(say_cog, mock_channel, mock_guild, bot):
+    ctx = MockApplicationContext(bot=bot, channel=mock_channel, guild=mock_guild)
+
+    with patch.object(ctx, 'send', new_callable=AsyncMock) as mock_send:
+        await say_cog.say.callback(say_cog, ctx, "Hello World")
+        mock_send.assert_called_once_with(content="Hello World")
+
+
+@pytest.mark.asyncio
+async def test_say_command_empty_text(say_cog, mock_channel, mock_guild, bot):
+    ctx = MockApplicationContext(bot=bot, channel=mock_channel, guild=mock_guild)
+
+    with patch.object(ctx, 'send', new_callable=AsyncMock) as mock_send:
+        await say_cog.say.callback(say_cog, ctx, "")
+        mock_send.assert_called_once_with(content="")
+
+
+@pytest.mark.asyncio
+async def test_say_command_long_text(say_cog, mock_channel, mock_guild, bot):
+    ctx = MockApplicationContext(bot=bot, channel=mock_channel, guild=mock_guild)
+    long_text = "A" * 2000
+
+    with patch.object(ctx, 'send', new_callable=AsyncMock) as mock_send:
+        await say_cog.say.callback(say_cog, ctx, long_text)
+        mock_send.assert_called_once_with(content=long_text)
diff --git a/tests/cogs/test_search.py b/tests/cogs/test_search.py
new file mode 100644
index 0000000..8c04dfc
--- /dev/null
+++ b/tests/cogs/test_search.py
@@ -0,0 +1,83 @@
+import pytest
+from unittest.mock import AsyncMock, patch, MagicMock
+import discord
+from tests.conftest import MockApplicationContext
+
+
+@pytest.fixture
+def search_cog(bot):
+    from cogs.search import Search
+    cog = Search(bot)
+    return cog
+
+
+@pytest.mark.asyncio
+async def test_search_command_success(search_cog, mock_channel, mock_guild, bot, mock_user):
+    ctx = MockApplicationContext(bot=bot, channel=mock_channel, guild=mock_guild)
+    ctx.user = mock_user
+    ctx.author = mock_user
+
+    search_cog._cached_results[mock_user.id] = {
+        "testfile.mp4": "https://example.com/files/testfile.mp4"
+    }
+
+    with patch.object(ctx, 'send_followup', new_callable=AsyncMock) as mock_followup:
+        await search_cog.search.callback(search_cog, ctx, filename="testfile.mp4")
+        mock_followup.assert_called_once_with("https://example.com/files/testfile.mp4")
+        assert mock_user.id not in search_cog._cached_results
+
+
+@pytest.mark.asyncio
+async def test_search_command_no_cache(search_cog, mock_channel, mock_guild, bot, mock_user):
+    ctx = MockApplicationContext(bot=bot, channel=mock_channel, guild=mock_guild)
+    ctx.user = mock_user
+    ctx.author = mock_user
+
+    with patch.object(ctx, 'send_followup', new_callable=AsyncMock) as mock_followup:
+        await search_cog.search.callback(search_cog, ctx, filename="testfile.mp4")
+        mock_followup.assert_called_once_with("Search results expired. Please search again.")
+
+
+@pytest.mark.asyncio
+async def test_search_command_file_not_found(search_cog, mock_channel, mock_guild, bot, mock_user):
+    ctx = MockApplicationContext(bot=bot, channel=mock_channel, guild=mock_guild)
+    ctx.user = mock_user
+    ctx.author = mock_user
+
+    search_cog._cached_results[mock_user.id] = {
+        "testfile.mp4": "https://example.com/files/testfile.mp4"
+    }
+
+    with patch.object(ctx, 'send_followup', new_callable=AsyncMock) as mock_followup:
+        await search_cog.search.callback(search_cog, ctx, filename="nonexistent.mp4")
+        mock_followup.assert_called_once_with("File 'nonexistent.mp4' not found.")
+
+
+@pytest.mark.asyncio
+async def test_search_command_empty_filename(search_cog, mock_channel, mock_guild, bot, mock_user):
+    ctx = MockApplicationContext(bot=bot, channel=mock_channel, guild=mock_guild)
+    ctx.user = mock_user
+    ctx.author = mock_user
+
+    with patch.object(ctx, 'reply', new_callable=AsyncMock) as mock_reply:
+        await search_cog.search.callback(search_cog, ctx, filename="")
+        mock_reply.assert_called_once_with("Please select a file from the autocomplete options.")
+
+
+@pytest.mark.asyncio
+async def test_file_autocomplete(search_cog, mock_channel, mock_guild, bot, mock_user):
+    mock_autocomplete_ctx = MagicMock()
+    mock_autocomplete_ctx.value = "test"
+    mock_autocomplete_ctx.interaction = MagicMock()
+    mock_autocomplete_ctx.interaction.user = mock_user
+
+    with patch('cogs.utils.file_search.UniversalSearcher.search_copyparty_autocomplete', new_callable=AsyncMock) as mock_search:
+        mock_search.return_value = [
+            "https://example.com/files/test1.mp4",
+            "https://example.com/files/test2.mp4"
+        ]
+
+        choices = await search_cog.file_autocomplete(mock_autocomplete_ctx)
+
+        assert len(choices) == 2
+        assert mock_user.id in search_cog._cached_results
diff --git a/tests/cogs/test_trigger.py b/tests/cogs/test_trigger.py
new file mode 100644
index 0000000..6aaaa11
--- /dev/null
+++ b/tests/cogs/test_trigger.py
@@ -0,0 +1,106 @@
+import pytest
+from unittest.mock import AsyncMock, patch, MagicMock
+import sqlite3
+from tests.conftest import MockApplicationContext
+
+
+@pytest.fixture
+def trigger_cog(bot):
+    with patch('cogs.trigger.get_connection') as mock_conn:
+        mock_conn.return_value.__enter__ = MagicMock(return_value=MagicMock())
+        mock_conn.return_value.__exit__ = MagicMock(return_value=False)
+        from cogs.trigger import Trigger
+        cog = Trigger(bot)
+    return cog
+
+
+@pytest.fixture
+def mock_db_connection():
+    with patch('cogs.trigger.get_connection') as mock_get_conn:
+        mock_conn = MagicMock()
+        mock_cursor = MagicMock()
+        mock_conn.cursor.return_value = mock_cursor
+        mock_get_conn.return_value.__enter__ = MagicMock(return_value=mock_conn)
+        mock_get_conn.return_value.__exit__ = MagicMock(return_value=False)
+        yield mock_conn, mock_cursor
+
+
+@pytest.mark.asyncio
+async def test_trigger_create_command(trigger_cog, mock_channel, mock_guild, bot, mock_db_connection):
+    ctx = MockApplicationContext(bot=bot, channel=mock_channel, guild=mock_guild)
+
+    mock_conn, mock_cursor = mock_db_connection
+    mock_cursor.fetchone.return_value = None
+
+    with patch('cogs.trigger.get_connection') as mock_get_conn:
+        mock_conn = MagicMock()
+        mock_cursor = MagicMock()
+        mock_conn.cursor.return_value = mock_cursor
+        mock_get_conn.return_value.__enter__ = MagicMock(return_value=mock_conn)
+        mock_get_conn.return_value.__exit__ = MagicMock(return_value=False)
+
+        with patch.object(ctx, 'respond', new_callable=AsyncMock) as mock_respond:
+            await trigger_cog.create.callback(trigger_cog, ctx, name="test_trigger")
+            mock_respond.assert_called_once_with("trigger added")
+
+
+@pytest.mark.asyncio
+async def test_trigger_add_command(trigger_cog, mock_channel, mock_guild, bot, mock_db_connection):
+    ctx = MockApplicationContext(bot=bot, channel=mock_channel, guild=mock_guild)
+
+    with patch('cogs.trigger.get_connection') as mock_get_conn:
+        mock_conn = MagicMock()
+        mock_cursor = MagicMock()
+        mock_cursor.fetchone.return_value = (1,)  # trigger exists
+        mock_conn.cursor.return_value = mock_cursor
+        mock_get_conn.return_value.__enter__ = MagicMock(return_value=mock_conn)
+        mock_get_conn.return_value.__exit__ = MagicMock(return_value=False)
+
+        with patch.object(ctx, 'respond', new_callable=AsyncMock) as mock_respond:
+            await trigger_cog.add.callback(trigger_cog, ctx, name="test_trigger", trigger="hello", response="Hi there!")
+            mock_respond.assert_called_once_with("trigger updated")
+
+
+@pytest.mark.asyncio
+async def test_trigger_add_command_not_found(trigger_cog, mock_channel, mock_guild, bot, mock_db_connection):
+    ctx = MockApplicationContext(bot=bot, channel=mock_channel, guild=mock_guild)
+
+    with patch('cogs.trigger.get_connection') as mock_get_conn:
+        mock_conn = MagicMock()
+        mock_cursor = MagicMock()
+        mock_cursor.fetchone.return_value = None  # trigger not found
+        mock_conn.cursor.return_value = mock_cursor
+        mock_get_conn.return_value.__enter__ = MagicMock(return_value=mock_conn)
+        mock_get_conn.return_value.__exit__ = MagicMock(return_value=False)
+
+        with patch.object(ctx, 'respond', new_callable=AsyncMock) as mock_respond:
+            await trigger_cog.add.callback(trigger_cog, ctx, name="nonexistent", trigger="hello", response="Hi")
+            mock_respond.assert_called_once_with("Trigger not found.")
+
+
+@pytest.mark.asyncio
+async def test_trigger_delete_command(trigger_cog, mock_channel, mock_guild, bot, mock_db_connection):
+    ctx = MockApplicationContext(bot=bot, channel=mock_channel, guild=mock_guild)
+
+    with patch('cogs.trigger.get_connection') as mock_get_conn:
+        mock_conn = MagicMock()
+        mock_cursor = MagicMock()
+        mock_cursor.fetchone.return_value = (1,)  # trigger exists
+        mock_conn.cursor.return_value = mock_cursor
+        mock_get_conn.return_value.__enter__ = MagicMock(return_value=mock_conn)
+        mock_get_conn.return_value.__exit__ = MagicMock(return_value=False)
+
+        with patch.object(ctx, 'respond', new_callable=AsyncMock) as mock_respond:
+            await trigger_cog.delete.callback(trigger_cog, ctx, name="test_trigger")
+            mock_respond.assert_called_once_with("trigger deleted")
+
+
+@pytest.mark.asyncio
+async def test_trigger_help_command(trigger_cog, mock_channel, mock_guild, bot):
+    ctx = MockApplicationContext(bot=bot, channel=mock_channel, guild=mock_guild)
+
+    with patch.object(ctx, 'respond', new_callable=AsyncMock) as mock_respond:
+        await trigger_cog.help.callback(trigger_cog, ctx)
+        mock_respond.assert_called_once()
+        args = mock_respond.call_args
+        assert "Trigger create" in str(args)
diff --git a/tests/cogs/test_tts.py b/tests/cogs/test_tts.py
new file mode 100644
index 0000000..de68580
--- /dev/null
+++ b/tests/cogs/test_tts.py
@@ -0,0 +1,58 @@
+import pytest
+from unittest.mock import AsyncMock, patch, MagicMock
+import discord
+from tests.conftest import MockApplicationContext
+
+
+@pytest.fixture
+def tts_cog(bot):
+    from cogs.tts import TTS
+    cog = TTS(bot)
+    return cog
+
+
+@pytest.mark.asyncio
+async def test_tts_file_output(tts_cog, mock_channel, mock_guild, bot, mock_user):
+    ctx = MockApplicationContext(bot=bot, channel=mock_channel, guild=mock_guild)
+    ctx.user = mock_user
+    ctx.author = mock_user
+
+    "/tmp/test_tts.mp3"
+
+    with patch('cogs.tts.gTTS') as _:
+        with patch('os.path.exists', return_value=True):
+            with patch('os.unlink'):
+                with patch.object(ctx, 'respond', new_callable=AsyncMock) as mock_respond:
+                    with patch('cogs.tts.get_volume', return_value=1.0):
+                        await tts_cog.tts.callback(tts_cog, ctx, text="Hello", output="file")
+                        mock_respond.assert_called_once()
+
+
+@pytest.mark.asyncio
+async def test_tts_voice_output_not_in_channel(tts_cog, mock_channel, mock_guild, bot, mock_user):
+    ctx = MockApplicationContext(bot=bot, channel=mock_channel, guild=mock_guild)
+    ctx.user = mock_user
+    ctx.author = mock_user
+    ctx.author.voice = None
+
+    with patch('cogs.tts.gTTS'):
+        with patch('os.path.exists', return_value=True):
+            with patch('os.unlink'):
+                with patch.object(ctx, 'respond', new_callable=AsyncMock) as mock_respond:
+                    with patch('cogs.tts.get_volume', return_value=1.0):
+                        await tts_cog.tts.callback(tts_cog, ctx, text="Hello", output="vc")
+
+
+@pytest.mark.asyncio
+async def test_tts_error_handling(tts_cog, mock_channel, mock_guild, bot, mock_user):
+    ctx = MockApplicationContext(bot=bot, channel=mock_channel, guild=mock_guild)
+    ctx.user = mock_user
+    ctx.author = mock_user
+
+    with patch('cogs.tts.gTTS', side_effect=Exception("TTS Error")):
+        with patch('os.path.exists', return_value=False):
+            with patch.object(ctx, 'respond', new_callable=AsyncMock) as mock_respond:
+                await tts_cog.tts.callback(tts_cog, ctx, text="Hello", output="file")
+                mock_respond.assert_called_once()
+                args = mock_respond.call_args
+                assert "Error" in str(args) or "eror" in str(args)
diff --git a/tests/cogs/test_vclogs.py b/tests/cogs/test_vclogs.py
new file mode 100644
index 0000000..2003478
--- /dev/null
+++ b/tests/cogs/test_vclogs.py
@@ -0,0 +1,83 @@
+import pytest
+from unittest.mock import AsyncMock, patch, MagicMock
+import json
+from tests.conftest import MockApplicationContext
+
+
+def test_format_duration():
+    from cogs.vclogs import format_duration
+
+    assert format_duration(30) == "30s"
+    assert format_duration(90) == "1m 30s"
+    assert format_duration(3661) == "1h 1m 1s"
+
+
+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)
+
+
+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()
+
+
+@pytest.fixture
+def vclogs_cog(bot):
+    with patch('cogs.vclogs.get_voice_manager'):
+        with patch('cogs.vclogs.get_volume', return_value=1.0):
+            with patch('cogs.vclogs.save_settings'):
+                from cogs.vclogs import VcLogs
+                cog = VcLogs(bot)
+    return cog
+
+
+@pytest.mark.asyncio
+async def test_handle_state_change_deaf_true(vclogs_cog):
+    mock_member = MagicMock()
+    mock_member.display_name = "TestUser"
+    mock_channel = MagicMock()
+
+    tts_text, channel = await vclogs_cog.handle_state_change(mock_member, mock_channel, 'deaf', True, None)
+
+    assert "jest bity przez ojca" in tts_text
+
+
+@pytest.mark.asyncio
+async def test_handle_state_change_deaf_false(vclogs_cog):
+    mock_member = MagicMock()
+    mock_member.display_name = "TestUser"
+    mock_channel = MagicMock()
+
+    tts_text, channel = await vclogs_cog.handle_state_change(mock_member, mock_channel, 'deaf', False, None)
+
+    assert "uciek od ojca" in tts_text
+
+
+@pytest.mark.asyncio
+async def test_handle_state_change_mute_true(vclogs_cog):
+    mock_member = MagicMock()
+    mock_member.display_name = "TestUser"
+    mock_channel = MagicMock()
+
+    tts_text, channel = await vclogs_cog.handle_state_change(mock_member, mock_channel, 'mute', True, None)
+
+    assert "idzie robić jajecznice" in tts_text
+
+
+@pytest.mark.asyncio
+async def test_handle_state_change_mute_false(vclogs_cog):
+    mock_member = MagicMock()
+    mock_member.display_name = "TestUser"
+    mock_channel = MagicMock()
+
+    tts_text, channel = await vclogs_cog.handle_state_change(mock_member, mock_channel, 'mute', False, None)
+
+    assert "zrobił jajecznice" in tts_text
diff --git a/tests/cogs/test_voice.py b/tests/cogs/test_voice.py
new file mode 100644
index 0000000..ade29cb
--- /dev/null
+++ b/tests/cogs/test_voice.py
@@ -0,0 +1,79 @@
+import pytest
+from unittest.mock import AsyncMock, patch, MagicMock
+import asyncio
+from tests.conftest import MockApplicationContext
+
+
+@pytest.mark.asyncio
+async def test_get_voice_manager():
+    from cogs.voice import get_voice_manager, VoiceManager
+
+    mock_bot = MagicMock()
+    mock_bot.user = MagicMock()
+    mock_bot.user.id = 12345
+
+    manager1 = get_voice_manager(mock_bot)
+    manager2 = get_voice_manager(mock_bot)
+
+    assert isinstance(manager1, VoiceManager)
+    assert manager1 is manager2
+
+
+@pytest.mark.asyncio
+async def test_voice_manager_join_channel_not_found():
+    from cogs.voice import VoiceManager
+
+    mock_bot = MagicMock()
+    mock_bot.get_channel.return_value = None
+
+    manager = VoiceManager(mock_bot)
+    result = await manager.join_by_channel_id(999)
+
+    assert result is None
+
+
+@pytest.mark.asyncio
+async def test_voice_manager_join_invalid_channel():
+    from cogs.voice import VoiceManager
+
+    mock_bot = MagicMock()
+    mock_channel = MagicMock()
+    mock_bot.get_channel.return_value = mock_channel
+
+    manager = VoiceManager(mock_bot)
+    result = await manager.join_by_channel_id(999)
+
+    assert result is None
+
+
+@pytest.mark.asyncio
+async def test_voice_manager_get_voice_status_not_connected():
+    from cogs.voice import VoiceManager
+
+    mock_bot = MagicMock()
+    mock_guild = MagicMock()
+
+    with patch('cogs.voice.VoiceManager.get_voice_client', return_value=None):
+        manager = VoiceManager(mock_bot)
+        voice_client, is_connected, is_playing = await manager.get_voice_status(mock_guild)
+
+        assert voice_client is None
+        assert is_connected == False
+        assert is_playing == False
+
+
+@pytest.mark.asyncio
+async def test_voice_manager_stop():
+    from cogs.voice import VoiceManager
+
+    mock_bot = MagicMock()
+    mock_guild = MagicMock()
+    mock_voice_client = MagicMock()
+    mock_voice_client.disconnect = AsyncMock()
+
+    with patch('cogs.voice.VoiceManager.get_voice_client', return_value=mock_voice_client):
+        manager = VoiceManager(mock_bot)
+        await manager.stop(mock_guild)
+
+        mock_voice_client.stop.assert_called_once()
+        mock_voice_client.disconnect.assert_called_once()
diff --git a/tests/cogs/test_web.py b/tests/cogs/test_web.py
new file mode 100644
index 0000000..e0d2208
--- /dev/null
+++ b/tests/cogs/test_web.py
@@ -0,0 +1,57 @@
+import pytest
+from unittest.mock import AsyncMock, patch, MagicMock
+from cogs.web import Web
+from tests.conftest import MockApplicationContext
+
+
+@pytest.fixture
+def web_cog(bot):
+    cog = Web(bot)
+    return cog
+
+
+@pytest.mark.asyncio
+async def test_web_command_success(web_cog, mock_channel, mock_guild, bot):
+    ctx = MockApplicationContext(bot=bot, channel=mock_channel, guild=mock_guild)
+
+    mock_response = MagicMock()
+    mock_response.status_code = 200
+    mock_response.text = '''
+        <html>
+            <a class="result__a" href="https://example.com">Test Result</a>
+            <a class="result__a" href="https://example.com/2">Test Result 2</a>
+        </html>
+    '''
+
+    with patch('cogs.web.requests.get', return_value=mock_response) as mock_get:
+        with patch.object(ctx, 'respond', new_callable=AsyncMock) as mock_respond:
+            await web_cog.web.callback(web_cog, ctx, query="test query")
+            mock_get.assert_called_once()
+            mock_respond.assert_called_once()
+
+
+@pytest.mark.asyncio
+async def test_web_command_no_results(web_cog, mock_channel, mock_guild, bot):
+    ctx = MockApplicationContext(bot=bot, channel=mock_channel, guild=mock_guild)
+
+    mock_response = MagicMock()
+    mock_response.status_code = 200
+    mock_response.text = '<html><body></body></html>'
+
+    with patch('cogs.web.requests.get', return_value=mock_response):
+        with patch.object(ctx, 'respond', new_callable=AsyncMock) as mock_respond:
+            await web_cog.web.callback(web_cog, ctx, query="test")
+            mock_respond.assert_called_once_with(content="No results found.", ephemeral=True)
+
+
+@pytest.mark.asyncio
+async def test_web_command_http_error(web_cog, mock_channel, mock_guild, bot):
+    ctx = MockApplicationContext(bot=bot, channel=mock_channel, guild=mock_guild)
+
+    mock_response = MagicMock()
+    mock_response.status_code = 500
+
+    with patch('cogs.web.requests.get', return_value=mock_response):
+        with patch.object(ctx, 'respond', new_callable=AsyncMock) as mock_respond:
+            await web_cog.web.callback(web_cog, ctx, query="test")
+            mock_respond.assert_called_once_with(content="Error: 500", ephemeral=True)
diff --git a/tests/conftest.py b/tests/conftest.py
new file mode 100644
index 0000000..e9f0f6f
--- /dev/null
+++ b/tests/conftest.py
@@ -0,0 +1,206 @@
+import asyncio
+from unittest.mock import AsyncMock, MagicMock
+import pytest
+
+import discord
+from discord.ext import commands
+
+
+class MockUser:
+    def __init__(self, id=12345, name="testuser", discriminator="0001"):
+        self.id = id
+        self.name = name
+        self.discriminator = discriminator
+        self.mention = f"@{name}"
+        self.display_name = name
+        self.avatar = None
+        self.bot = False
+        self.guild = None
+        self._state = MagicMock()
+
+    def __str__(self):
+        return f"{self.name}#{self.discriminator}"
+
+
+class MockChannel:
+    def __init__(self, id=11111, name="test-channel", type=discord.ChannelType.text):
+        self.id = id
+        self.name = name
+        self.type = type
+        self.mention = f"#{name}"
+        self.guild = None
+        self.category = None
+        self._state = MagicMock()
+
+    def send(self, *args, **kwargs):
+        return MagicMock()
+
+
+class MockTextChannel(MockChannel):
+    def __init__(self, id=11111, name="test-channel"):
+        super().__init__(id, name, discord.ChannelType.text)
+
+
+class MockVoiceChannel(MockChannel):
+    def __init__(self, id=11112, name="test-voice"):
+        super().__init__(id, name, discord.ChannelType.voice)
+        self.voice_states = {}
+
+
+class MockGuild:
+    def __init__(self, id=99999, name="Test Server"):
+        self.id = id
+        self.name = name
+        self.channels = []
+        self.roles = []
+        self.emojis = []
+        self.me = MockUser(id=111111, name="Sen Bot")
+        self._state = MagicMock()
+        self._default_role = None
+
+    def get_channel(self, channel_id):
+        for ch in self.channels:
+            if ch.id == channel_id:
+                return ch
+        return None
+
+    def get_role(self, role_id):
+        for role in self.roles:
+            if role.id == role_id:
+                return role
+        return None
+
+    def get_member(self, member_id):
+        return None
+
+
+class MockMessage:
+    def __init__(self, id=22222, content="test message", author=None, channel=None, guild=None):
+        self.id = id
+        self.content = content
+        self.author = author or MockUser()
+        self.channel = channel or MockChannel()
+        self.guild = guild
+        self.attachments = []
+        self.embeds = []
+        self.jump_url = "https://discord.com/channels/..."
+        self.created_at = None
+
+    async def reply(self, *args, **kwargs):
+        return MagicMock()
+        # Stub for reply - kept async to match Discord interface signature
+
+
+class MockInteraction:
+    def __init__(self, user=None, channel=None, guild=None):
+        self.user = user or MockUser()
+        self.channel = channel or MockChannel()
+        self.guild = guild or MockGuild()
+        self.message = None
+        self.response = AsyncMock()
+        self.followup = AsyncMock()
+        self.client = None
+        self.id = 33333
+        self.token = "test_token"
+        self._state = MagicMock()
+
+    async def defer(self, *args, **kwargs):
+        pass
+
+    async def respond(self, *args, **kwargs):
+        pass
+
+    async def delete_original_response(self, *args, **kwargs):
+        pass
+
+    async def send(self, *args, **kwargs):
+        return MagicMock()
+
+
+# Stub for Discord interaction - test implementation only
+class MockApplicationContext:
+    def __init__(self, bot=None, interaction=None, user=None, channel=None, guild=None):
+        self.bot = bot
+        self.interaction = interaction or MockInteraction(user=user, channel=channel, guild=guild)
+        self.user = user or MockUser()
+        self.channel = channel or MockChannel()
+        self.guild = guild or MockGuild()
+        self.message = None
+        self.response = AsyncMock()
+        self.followup = AsyncMock()
+        self.client = self.bot
+        self.id = 33333
+        self.token = "test_token"
+        self._state = self.interaction._state
+        self.author = self.user
+
+    async def defer(self, *args, **kwargs):
+        pass
+        # Stub for defer - tests don't verify interaction state
+
+    async def respond(self, *args, **kwargs):
+        pass
+        # Stub for respond - tests mock the response
+
+    async def delete_original_response(self, *args, **kwargs):
+        pass
+        # Stub for delete_original_response - not used in tests
+
+    async def send(self, *args, **kwargs):
+        return MagicMock()
+        # Stub for send - not used in tests
+
+    async def reply(self, *args, **kwargs):
+        return MagicMock()
+        # Stub for reply - not used in tests
+
+    async def send_followup(self, *args, **kwargs):
+        return MagicMock()
+        # Stub for send_followup - not used in tests
+
+
+@pytest.fixture
+def mock_guild():
+    return MockGuild()
+
+
+@pytest.fixture
+def mock_channel(mock_guild):
+    channel = MockTextChannel()
+    channel.guild = mock_guild
+    return channel
+
+
+@pytest.fixture
+def mock_voice_channel(mock_guild):
+    channel = MockVoiceChannel()
+    channel.guild = mock_guild
+    return channel
+
+
+@pytest.fixture
+def mock_user():
+    return MockUser()
+
+
+@pytest.fixture
+def mock_member(mock_guild):
+    member = MockUser()
+    member.guild = mock_guild
+    return member
+
+
+@pytest.fixture
+def mock_message(mock_channel, mock_user, mock_guild):
+    return MockMessage(channel=mock_channel, author=mock_user, guild=mock_guild)
+
+
+@pytest.fixture
+def mock_interaction(mock_channel, mock_user, mock_guild):
+    return MockInteraction(user=mock_user, channel=mock_channel, guild=mock_guild)
+
+
+@pytest.fixture
+def bot():
+    intents = discord.Intents.all()
+    return commands.Bot(intents=intents, command_prefix="!", loop=asyncio.new_event_loop())