Merge pull request #234 from davidhozic/feature/testing

Better testing structure

Author: davidhozic

src/daf/core.py

@@ -309,6 +309,7 @@ def remove_object(snowflake: Union[int, dc.Object, dc.Guild, dc.User, dc.Object,
         GLOBALS.server_list.remove(snowflake)
         snowflake._delete()
 
+@typechecked
 @misc.doc_category("Getters")
 def get_guild_user(snowflake: Union[int, dc.Object, dc.Guild, dc.User, dc.Object]) -> Union[guild.GUILD, guild.USER, None]:
     """

testing/fixtures/main.py

@@ -1,3 +1,4 @@
+from contextlib import suppress
 import asyncio
 import pytest
 import pytest_asyncio
@@ -31,31 +32,42 @@ def start_daf(event_loop: asyncio.AbstractEventLoop):
 
 
 @pytest_asyncio.fixture(scope="session")
-async def category():
+async def guilds():
+    """
+    Create tests guilds.
+    """
     client = daf.get_client()
-    guild: daf.discord.Guild = client.get_guild(TEST_GUILD_ID)
-    cat = await guild.create_category(TEST_CATEGORY_NAME)
-    yield cat
-    await cat.delete()
+    guild_include = None
+    guild_exclude = None
 
+    for guild in client.guilds:
+        if guild.name == "magic-123-magic":
+            guild_include = guild
+            break
+    else:
+        guild_include = await client.create_guild(name="magic-123-magic")
 
-@pytest_asyncio.fixture(scope="session")
-async def text_channels(category: daf.discord.CategoryChannel):
-    ret = []
-    for i in range(TEST_TEXT_CHANNEL_NUM):
-        ret.append(await category.create_text_channel(TEST_TEXT_CHANNEL_NAME_FORM))
+    for guild in client.guilds:
+        if guild.name == "magic-321-magic":
+            guild_exclude = guild
+            break
+    else:
+        guild_exclude = await client.create_guild(name="magic-321-magic")
 
-    yield ret
-    for c in ret:
-        await c.delete()
+    return guild_include, guild_exclude
 
 
 @pytest_asyncio.fixture(scope="session")
-async def voice_channels(category: daf.discord.CategoryChannel):
-    ret = []
-    for i in range(TEST_VOICE_CHANNEL_NUM):
-        ret.append(await category.create_voice_channel(TEST_VOICE_CHANNEL_NAME_FORM))
-    
-    yield ret
-    for c in ret:
-        await c.delete()
+async def channels(guilds):
+    guild: daf.discord.Guild
+    guild, _ = guilds
+    t_channels = []
+    v_channels = []
+    for i in range(10):
+        t_channels.append(await guild.create_text_channel(f"testpy-{i}"))
+        v_channels.append(await guild.create_voice_channel(f"testpy-{i}"))
+
+    yield t_channels, v_channels
+    for channel in t_channels + v_channels:
+        with suppress(daf.discord.HTTPException):
+            await channel.delete()

testing/test_autogen.py

@@ -10,46 +10,6 @@
 import daf
 import asyncio
 
-@pytest_asyncio.fixture(scope="module")
-async def guilds():
-    """
-    Create tests guilds.
-    """
-    client = daf.get_client()
-    guild_include = None
-    guild_exclude = None
-
-    for guild in client.guilds:
-        if guild.name == "magic-123-magic":
-            guild_include = guild
-            break
-    else:
-        guild_include = await client.create_guild(name="magic-123-magic")
-
-    for guild in client.guilds:
-        if guild.name == "magic-321-magic":
-            guild_exclude = guild
-            break
-    else:
-        guild_exclude = await client.create_guild(name="magic-321-magic")
-
-    return guild_include, guild_exclude
-
-
-@pytest_asyncio.fixture(scope="module")
-async def channels(guilds):
-    guild: daf.discord.Guild
-    guild, _ = guilds
-    t_channels = []
-    v_channels = []
-    for i in range(10):
-        t_channels.append(await guild.create_text_channel(f"testpy-{i}"))
-        v_channels.append(await guild.create_voice_channel(f"testpy-{i}"))
-
-    yield t_channels, v_channels
-    for channel in t_channels + v_channels:
-        await channel.delete()
-
 
 @pytest.mark.asyncio
 async def test_autoguild(guilds):
@@ -70,41 +30,46 @@ async def test_autochannel(guilds, channels):
     """
     Tests if AutoCHANNEL functions properly.
     """
-    guild: daf.discord.Guild
-    guild, _ = guilds
-    text_channels, voice_channels = channels
-    auto_channel = daf.message.AutoCHANNEL(
+    daf_guild = None
+    try:
+        guild: daf.discord.Guild
+        guild, _ = guilds
+        text_channels, voice_channels = channels
+        auto_channel = daf.message.AutoCHANNEL(
+            "testpy-[0-9]", "testpy-[5-9]")
+        auto_channel2 = daf.message.AutoCHANNEL(
         "testpy-[0-9]", "testpy-[5-9]")
-    auto_channel2 = daf.message.AutoCHANNEL(
-    "testpy-[0-9]", "testpy-[5-9]")
-    
-    daf_guild = daf.GUILD(
-        guild,
-        messages=[
-            tm := daf.TextMESSAGE(None, timedelta(seconds=1), "Hello World", auto_channel),
-            vc := daf.VoiceMESSAGE(None, timedelta(seconds=1), daf.AUDIO("https://www.youtube.com/watch?v=IGQBtbKSVhY"), auto_channel2)
-        ]
-    )
-    await daf.add_object(daf_guild)
-    sort_key = lambda x: x.name
-    auto_channel._process()
-    auto_channel2._process()
-    assert sorted(text_channels[:5], key=sort_key) == sorted(auto_channel.channels, key=sort_key), "Correct behavior would be for AutoCHANNEL to only find first 5 text channels"
-    assert sorted(voice_channels[:5], key=sort_key) == sorted(auto_channel2.channels, key=sort_key), "Correct behavior would be for AutoCHANNEL to only find first 5 voice channels"
-
-    await auto_channel.update(exclude_pattern=None)
-    await auto_channel2.update(exclude_pattern=None)
-    auto_channel._process()
-    auto_channel2._process()
-    assert sorted(text_channels, key=sort_key) == sorted(auto_channel.channels, key=sort_key), "Correct behavior would be for AutoCHANNEL to find all text channels"
-    assert sorted(voice_channels, key=sort_key) == sorted(auto_channel2.channels, key=sort_key), "Correct behavior would be for AutoCHANNEL to find all voice channels"
-
-    # Test update
-    await daf_guild.update()
-    await tm.update()
-    await vc.update()
-    await auto_channel.update()
-    await auto_channel2.update()
+        
+        daf_guild = daf.GUILD(
+            guild,
+            messages=[
+                tm := daf.TextMESSAGE(None, timedelta(seconds=1), "Hello World", auto_channel),
+                vc := daf.VoiceMESSAGE(None, timedelta(seconds=1), daf.AUDIO("https://www.youtube.com/watch?v=IGQBtbKSVhY"), auto_channel2)
+            ]
+        )
+        await daf.add_object(daf_guild)
+        sort_key = lambda x: x.name
+        auto_channel._process()
+        auto_channel2._process()
+        assert sorted(text_channels[:5], key=sort_key) == sorted(auto_channel.channels, key=sort_key), "Correct behavior would be for AutoCHANNEL to only find first 5 text channels"
+        assert sorted(voice_channels[:5], key=sort_key) == sorted(auto_channel2.channels, key=sort_key), "Correct behavior would be for AutoCHANNEL to only find first 5 voice channels"
+
+        await auto_channel.update(exclude_pattern=None)
+        await auto_channel2.update(exclude_pattern=None)
+        auto_channel._process()
+        auto_channel2._process()
+        assert sorted(text_channels, key=sort_key) == sorted(auto_channel.channels, key=sort_key), "Correct behavior would be for AutoCHANNEL to find all text channels"
+        assert sorted(voice_channels, key=sort_key) == sorted(auto_channel2.channels, key=sort_key), "Correct behavior would be for AutoCHANNEL to find all voice channels"
+
+        # Test update
+        await daf_guild.update()
+        await tm.update()
+        await vc.update()
+        await auto_channel.update()
+        await auto_channel2.update()
+    finally:
+        if daf_guild is not None:
+            daf.remove_object(daf_guild)
 
 
 

testing/test_logging.py

@@ -7,20 +7,21 @@
 import pathlib
 import json
 
-TEST_GUILD_ID = 863071397207212052
 TEST_USER_ID = 145196308985020416
 C_FILE_NAME_FORBIDDEN_CHAR = ('<','>','"','/','\\','|','?','*',":")
 
 
 @pytest.mark.asyncio
-async def test_logging_json(text_channels):
+async def test_logging_json(channels, guilds):
     "Test if json logging works"
+    dc_guild, _ = guilds
+    text_channels, _ = channels
     try:
         json_logger = daf.LoggerJSON("./History")
         await json_logger.initialize()
         daf.logging._set_logger(json_logger)
 
-        guild = daf.GUILD(TEST_GUILD_ID, logging=True)
+        guild = daf.GUILD(dc_guild, logging=True)
         await guild.initialize()
         guild_context = guild.generate_log_context()
         await guild.add_message(tm := daf.TextMESSAGE(None, timedelta(seconds=5), data="Hello World", channels=text_channels))
@@ -68,17 +69,19 @@ def check_json_results(message_context):
 
 
 @pytest.mark.asyncio
-async def test_logging_sql(text_channels):
+async def test_logging_sql(channels, guilds):
     """
     Tests if SQL logging works(only sqlite).
     It does not test any of the results as it assumes the database
     will raise an exception if anything is wrong.
     """
+    dc_guild, _ = guilds
+    text_channels, _ = channels
     try:
         sql_logger = daf.LoggerSQL(database="testdb")
         await sql_logger.initialize()
         daf.logging._set_logger(sql_logger)
-        guild = daf.GUILD(TEST_GUILD_ID, logging=True)
+        guild = daf.GUILD(dc_guild, logging=True)
         await guild.initialize()
         guild_context = guild.generate_log_context()
         await guild.add_message(tm := daf.TextMESSAGE(None, timedelta(seconds=5), data="Hello World", channels=text_channels))

testing/test_period_dynamic.py

@@ -9,7 +9,6 @@
 # SIMULATION
 
 # CONFIGURATION
-TEST_GUILD_ID = 863071397207212052
 TEST_USER_ID = 145196308985020416
 TEST_SEND_PERIOD_TEXT = timedelta(seconds=6)
 TEST_SEND_PERIOD_VOICE = timedelta(seconds=10)
@@ -19,14 +18,17 @@
 
 
 @pytest.mark.asyncio
-async def test_text_period(text_channels):
+async def test_text_period(channels, guilds):
     "Tests if the period and dynamic data works"
-    guild = daf.GUILD(TEST_GUILD_ID)
+    text_channels, _ = channels
+    dc_guild, _ = guilds
+    guild = daf.GUILD(dc_guild)
     user = daf.USER(TEST_USER_ID)
     try:
+        await asyncio.sleep(5) # Clears rate limit
         await daf.add_object(guild)
         await daf.add_object(user)
-        
+
         @daf.data_function
         def dynamic_getter(items: list):
             item = items.pop(0)
@@ -46,7 +48,6 @@ async def dynamic_getter_async(items: list):
         TEXT_MESSAGE_TEST_MESSAGE = dynamic_getter(data_.copy())
         DIRECT_MESSAGE_TEST_MESSAGE = dynamic_getter_async(data_.copy())
 
-        await asyncio.sleep(10) # Clears rate limit
         client = daf.get_client()
 
         # Preparation
@@ -76,7 +77,7 @@ async def dynamic_getter_async(items: list):
                 assert item.to_dict() in embeds, "TextMESSAGE embed not in message embeds"
 
         guild.remove_message(text_message)
-        await asyncio.sleep(10) # Clears rate limit
+        await asyncio.sleep(5)
         # Test DirectMESSAGE
         direct_message = daf.message.DirectMESSAGE(None, TEST_SEND_PERIOD_TEXT, DIRECT_MESSAGE_TEST_MESSAGE, "send",
                                                    start_in=TEST_SEND_PERIOD_TEXT, remove_after=None)
@@ -107,12 +108,14 @@ async def dynamic_getter_async(items: list):
 
 
 @pytest.mark.asyncio
-async def test_voice_period(voice_channels):
+async def test_voice_period(channels, guilds):
     "Tests if the period and dynamic data works"
-    guild = daf.GUILD(TEST_GUILD_ID)
+    _, voice_channels = channels
+    dc_guild, _ = guilds
+    guild = daf.GUILD(dc_guild)
     user = daf.USER(TEST_USER_ID)
     try:
-        await asyncio.sleep(10)
+        await asyncio.sleep(5)
 
         @daf.data_function
         def dynamic_getter(items: list):
@@ -127,7 +130,7 @@ def dynamic_getter(items: list):
             (3, daf.AUDIO("https://www.youtube.com/watch?v=1O0yazhqaxs"))
         ]
         VOICE_MESSAGE_TEST_MESSAGE = dynamic_getter(data_.copy())
-        guild = daf.get_guild_user(TEST_GUILD_ID)
+        guild = daf.get_guild_user(dc_guild)
         client = daf.get_client()
 
         test_period_secs = TEST_SEND_PERIOD_VOICE.total_seconds()

testing/test_send_normal.py

@@ -6,17 +6,18 @@
 import asyncio
 
 # CONFIGURATION
-TEST_GUILD_ID = 863071397207212052
 TEST_USER_ID = 145196308985020416
 VOICE_MESSAGE_TEST_LENGTH = 3 # Test if entire message is played
 
 
 @pytest.mark.asyncio
-async def test_text_message_send(text_channels):
+async def test_text_message_send(channels, guilds):
     "This tests if all the text messages succeed in their sends"
+    dc_guild, _ = guilds
+    text_channels, _ = channels
     TEXT_MESSAGE_TEST_MESSAGE = "Hello world", daf.discord.Embed(title="Hello world")
 
-    guild = daf.GUILD(TEST_GUILD_ID)
+    guild = daf.GUILD(dc_guild)
     user = daf.USER(TEST_USER_ID)
     text_message = daf.message.TextMESSAGE(None, timedelta(seconds=5), TEXT_MESSAGE_TEST_MESSAGE, text_channels,
                                         "send", start_in=timedelta(), remove_after=None)
@@ -57,12 +58,14 @@ async def test_text_message_send(text_channels):
 
 
 @pytest.mark.asyncio
-async def test_voice_message_send(voice_channels):
+async def test_voice_message_send(channels, guilds):
     "This tests if all the voice messages succeed in their sends"
+    dc_guild, _ = guilds
+    _, voice_channels = channels
     await asyncio.sleep(5) # Wait for any messages still playing
     VOICE_MESSAGE_TEST_MESSAGE = daf.AUDIO("https://www.youtube.com/watch?v=1O0yazhqaxs") # 3 second countdown
 
-    guild = daf.GUILD(TEST_GUILD_ID)
+    guild = daf.GUILD(dc_guild)
     voice_message = daf.message.VoiceMESSAGE(None, timedelta(seconds=20), VOICE_MESSAGE_TEST_MESSAGE, voice_channels,
                                             volume=50, start_in=timedelta(), remove_after=None)