refactor: many changes

- Add missing actions and make a clear boundary between actions,
  services and nfra (i.e: actions shouldn't use stuff from infra/)
- Delete stuff not in use: tts, gtts, etc
- Add a ton of tests

tests/test_repos.py

@@ -1,75 +1,95 @@
-import json
+import uuid
 
 import pytest
 
 from huesoporro.infra.repos import QuoteRepo, UserRepo
-from huesoporro.models import User
+from huesoporro.models import TwitchAuth, User
 
 
-@pytest.fixture
-async def user_repo(s, db, user: User):
-    async with db.get_client() as client:
-        await client.execute(
-            "INSERT INTO users (user, external_auth) VALUES (?, ?)",
-            (user.user, json.dumps(user.external_auth)),
-        )
-
-    return UserRepo(s=s)
+async def test_create_user_raises_value_error_for_existing_user(
+    user_repo: UserRepo, persisted_user: User
+):
+    with pytest.raises(
+        ValueError, match=f"User {persisted_user.username} already exists"
+    ):
+        await user_repo.create(persisted_user)
 
 
-@pytest.fixture
-async def quote_repo(s, db):
-    async with db.get_client() as client:
-        await client.execute(
-            "INSERT INTO quotes (channel, quote, author) VALUES (?, ?, ?)",
-            ("channel", "quote", "author"),
-        )
-    return QuoteRepo(s=s)
-
-
-async def test_get_user(user_repo: UserRepo, user: User):
-    db_user = await user_repo.get_by_user(user.user)
-    assert db_user == user
+async def test_get_user_by_username(user_repo: UserRepo, persisted_user: User):
+    db_user = await user_repo.get_by_username(persisted_user.username)
+    assert db_user == persisted_user
 
 
 async def test_get_user_returns_none(user_repo: UserRepo):
-    assert await user_repo.get_by_user("unknown_user") is None
+    assert await user_repo.get_by_username("unknown_user") is None
 
 
-async def test_create_user(user_repo: UserRepo):
-    new_user = User(
-        user="new_user", external_auth={"twitch": {"token": "twitch_token"}}
-    )
-    assert await user_repo.create(new_user) == new_user
+async def test_get_user_by_id(user_repo: UserRepo, persisted_user: User):
+    db_user = await user_repo.get_by_id(persisted_user.id)
+    assert db_user == persisted_user
 
 
-async def test_update_users_tokens(user_repo: UserRepo, user: User):
-    new_tokens = {"twitch": {"token": "new_tokens"}}
-    user.external_auth = new_tokens  # type: ignore[assignment]
-    assert await user_repo.update(user) == user
+async def test_get_user_by_id_returns_none(user_repo: UserRepo):
+    assert await user_repo.get_by_id(uuid.uuid4()) is None
 
 
-async def test_update_non_existing_user_raises_value_error(user_repo: UserRepo):
-    with pytest.raises(ValueError, match="User unknown_user does not exist"):
-        await user_repo.update(
-            User(
-                user="unknown_user", external_auth={"twitch": {"token": "twitch_token"}}
-            )
+async def test_update_users_tokens(
+    user_repo: UserRepo, twitch_auth: TwitchAuth, persisted_user: User
+):
+    twitch_auth.access_token = uuid.uuid4().hex
+    twitch_auth.refresh_token = uuid.uuid4().hex
+    new_tokens = {"twitch": twitch_auth}
+    persisted_user.external_auth = new_tokens  # type: ignore[assignment]
+    assert await user_repo.update(persisted_user) == persisted_user
+
+
+async def test_update_username(user_repo: UserRepo, persisted_user: User):
+    persisted_user.username = "new_username"
+    assert await user_repo.update(persisted_user) == persisted_user
+
+
+async def test_update_non_existing_user_raises_value_error(
+    user_repo: UserRepo, user: User
+):
+    with pytest.raises(ValueError, match=f"User {user.username} does not exist"):
+        await user_repo.update(user)
+
+
+async def test_delete_user(user_repo: UserRepo, persisted_user: User):
+    assert await user_repo.delete(persisted_user) is None
+    assert await user_repo.get_by_id(persisted_user.id) is None
+
+
+async def test_create_chatbot_raises_value_error_for_existing_chatbot(
+    chatbot_repo, chatbot_factory, persisted_chatbot
+):
+    with pytest.raises(
+        ValueError, match=f"Chatbot {persisted_chatbot.user_id} already exists"
+    ):
+        await chatbot_repo.create(
+            chatbot_factory.build(user_id=persisted_chatbot.user_id)
         )
 
 
-async def test_delete_user(user_repo: UserRepo, user: User):
-    assert await user_repo.delete(user) is None
-    assert await user_repo.get_by_user(user.user) is None
+async def test_update_chatbot(persisted_chatbot, faker, chatbot_repo):
+    persisted_chatbot.automatic_generation_timer = faker.pyint()
+    persisted_chatbot.automatic_quote_timer = faker.pyint()
+    persisted_chatbot.mods = ["mod1", "mod2"]
+
+    updated_chatbot = await chatbot_repo.update(persisted_chatbot)
+    persisted_chatbot.last_updated_at = updated_chatbot.last_updated_at
+    assert updated_chatbot == persisted_chatbot
 
 
-async def test_get_random_quote(quote_repo: QuoteRepo):
-    quote = await quote_repo.get_random("channel")
+async def test_update_chatbot_raises_value_error_on_non_existing_chatbot(
+    chatbot_repo, chatbot
+):
+    with pytest.raises(ValueError, match=f"Chatbot {chatbot.user_id} does not exist"):
+        await chatbot_repo.update(chatbot)
+
+
+async def test_get_random_quote(quote_repo: QuoteRepo, persisted_quote):
+    quote = await quote_repo.get_random(persisted_quote.channel_name)
     assert quote
-    assert quote.author.user == "author"
-    assert quote.channel.user == "channel"
-
-
-async def test_create_quote(quote, quote_repo):
-    new_quote = await quote_repo.create(quote)
-    assert new_quote == quote
+    assert quote.author == persisted_quote.author
+    assert quote.channel_name == persisted_quote.channel_name