[Config] Rewrite (#869)

tests/cogs/test_alias.py

@@ -2,12 +2,11 @@ from cogs.alias import Alias
 import pytest
 
 
-@pytest.fixture
-def alias(monkeysession, config):
-    def get_mock_conf(*args, **kwargs):
-        return config
+@pytest.fixture()
+def alias(config):
+    import cogs.alias.alias
 
-    monkeysession.setattr("core.config.Config.get_conf", get_mock_conf)
+    cogs.alias.alias.Config.get_conf = lambda *args, **kwargs: config
 
     return Alias(None)
 
@@ -25,9 +24,17 @@ def test_empty_global_aliases(alias):
     assert list(alias.unloaded_global_aliases()) == []
 
 
+async def create_test_guild_alias(alias, ctx):
+    await alias.add_alias(ctx, "test", "ping", global_=False)
+
+
+async def create_test_global_alias(alias, ctx):
+    await alias.add_alias(ctx, "test", "ping", global_=True)
+
+
 @pytest.mark.asyncio
 async def test_add_guild_alias(alias, ctx):
-    await alias.add_alias(ctx, "test", "ping", global_=False)
+    await create_test_guild_alias(alias, ctx)
 
     is_alias, alias_obj = alias.is_alias(ctx.guild, "test")
     assert is_alias is True
@@ -36,6 +43,7 @@ async def test_add_guild_alias(alias, ctx):
 
 @pytest.mark.asyncio
 async def test_delete_guild_alias(alias, ctx):
+    await create_test_guild_alias(alias, ctx)
     is_alias, _ = alias.is_alias(ctx.guild, "test")
     assert is_alias is True
 
@@ -47,7 +55,7 @@ async def test_delete_guild_alias(alias, ctx):
 
 @pytest.mark.asyncio
 async def test_add_global_alias(alias, ctx):
-    await alias.add_alias(ctx, "test", "ping", global_=True)
+    await create_test_global_alias(alias, ctx)
     is_alias, alias_obj = alias.is_alias(ctx.guild, "test")
 
     assert is_alias is True
@@ -56,6 +64,7 @@ async def test_add_global_alias(alias, ctx):
 
 @pytest.mark.asyncio
 async def test_delete_global_alias(alias, ctx):
+    await create_test_global_alias(alias, ctx)
     is_alias, alias_obj = alias.is_alias(ctx.guild, "test")
     assert is_alias is True
     assert alias_obj.global_ is True

tests/conftest.py

@@ -17,21 +17,27 @@ def monkeysession(request):
     mpatch.undo()
 
 
-@pytest.fixture(scope="module")
+@pytest.fixture()
 def json_driver(tmpdir_factory):
+    import uuid
+    rand = str(uuid.uuid4())
+    path = Path(str(tmpdir_factory.mktemp(rand)))
     driver = red_json.JSON(
         "PyTest",
-        data_path_override=Path(str(tmpdir_factory.getbasetemp()))
+        data_path_override=path
     )
     return driver
 
 
 @pytest.fixture()
 def config(json_driver):
-    return Config(
+    import uuid
+    conf = Config(
         cog_name="PyTest",
-        unique_identifier=0,
+        unique_identifier=str(uuid.uuid4()),
         driver_spawn=json_driver)
+    yield conf
+    conf.defaults = {}
 
 
 @pytest.fixture()
@@ -39,19 +45,32 @@ def config_fr(json_driver):
     """
     Mocked config object with force_register enabled.
     """
-    return Config(
+    import uuid
+    conf = Config(
         cog_name="PyTest",
-        unique_identifier=0,
+        unique_identifier=str(uuid.uuid4()),
         driver_spawn=json_driver,
         force_registration=True
     )
+    yield conf
+    conf.defaults = {}
 
 
 #region Dpy Mocks
-@pytest.fixture(scope="module")
-def empty_guild():
+@pytest.fixture()
+def guild_factory():
     mock_guild = namedtuple("Guild", "id members")
-    return mock_guild(random.randint(1, 999999999), [])
+
+    class GuildFactory:
+        def get(self):
+            return mock_guild(random.randint(1, 999999999), [])
+
+    return GuildFactory()
+
+
+@pytest.fixture()
+def empty_guild(guild_factory):
+    return guild_factory.get()
 
 
 @pytest.fixture(scope="module")
@@ -66,16 +85,39 @@ def empty_role():
     return mock_role(random.randint(1, 999999999))
 
 
-@pytest.fixture(scope="module")
-def empty_member(empty_guild):
+@pytest.fixture()
+def member_factory(guild_factory):
     mock_member = namedtuple("Member", "id guild")
-    return mock_member(random.randint(1, 999999999), empty_guild)
+
+    class MemberFactory:
+        def get(self):
+            return mock_member(
+                random.randint(1, 999999999),
+                guild_factory.get())
+
+    return MemberFactory()
 
 
-@pytest.fixture(scope="module")
-def empty_user():
+@pytest.fixture()
+def empty_member(member_factory):
+    return member_factory.get()
+
+
+@pytest.fixture()
+def user_factory():
     mock_user = namedtuple("User", "id")
-    return mock_user(random.randint(1, 999999999))
+
+    class UserFactory:
+        def get(self):
+            return mock_user(
+                random.randint(1, 999999999))
+
+    return UserFactory()
+
+
+@pytest.fixture()
+def empty_user(user_factory):
+    return user_factory.get()
 
 
 @pytest.fixture(scope="module")
@@ -84,7 +126,7 @@ def empty_message():
     return mock_msg("No content.")
 
 
-@pytest.fixture
+@pytest.fixture()
 def ctx(empty_member, empty_channel, red):
     mock_ctx = namedtuple("Context", "author guild channel message bot")
     return mock_ctx(empty_member, empty_member.guild, empty_channel,
@@ -93,15 +135,14 @@ def ctx(empty_member, empty_channel, red):
 
 
 #region Red Mock
-@pytest.fixture
-def red(monkeysession, config_fr):
+@pytest.fixture()
+def red(config_fr):
     from core.cli import parse_cli_flags
     cli_flags = parse_cli_flags()
 
     description = "Red v3 - Alpha"
 
-    monkeysession.setattr("core.config.Config.get_core_conf",
-                          lambda *args, **kwargs: config_fr)
+    Config.get_core_conf = (lambda *args, **kwargs: config_fr)
 
     red = Red(cli_flags, description=description, pm_help=None)
 

tests/core/test_config.py

@@ -15,9 +15,9 @@ def test_config_register_global_badvalues(config):
 
 def test_config_register_guild(config, empty_guild):
     config.register_guild(enabled=False, some_list=[], some_dict={})
-    assert config.defaults["GUILD"]["enabled"] is False
-    assert config.defaults["GUILD"]["some_list"] == []
-    assert config.defaults["GUILD"]["some_dict"] == {}
+    assert config.defaults[config.GUILD]["enabled"] is False
+    assert config.defaults[config.GUILD]["some_list"] == []
+    assert config.defaults[config.GUILD]["some_dict"] == {}
 
     assert config.guild(empty_guild).enabled() is False
     assert config.guild(empty_guild).some_list() == []
@@ -26,25 +26,25 @@ def test_config_register_guild(config, empty_guild):
 
 def test_config_register_channel(config, empty_channel):
     config.register_channel(enabled=False)
-    assert config.defaults["CHANNEL"]["enabled"] is False
+    assert config.defaults[config.CHANNEL]["enabled"] is False
     assert config.channel(empty_channel).enabled() is False
 
 
 def test_config_register_role(config, empty_role):
     config.register_role(enabled=False)
-    assert config.defaults["ROLE"]["enabled"] is False
+    assert config.defaults[config.ROLE]["enabled"] is False
     assert config.role(empty_role).enabled() is False
 
 
 def test_config_register_member(config, empty_member):
     config.register_member(some_number=-1)
-    assert config.defaults["MEMBER"]["some_number"] == -1
+    assert config.defaults[config.MEMBER]["some_number"] == -1
     assert config.member(empty_member).some_number() == -1
 
 
 def test_config_register_user(config, empty_user):
     config.register_user(some_value=None)
-    assert config.defaults["USER"]["some_value"] is None
+    assert config.defaults[config.USER]["some_value"] is None
     assert config.user(empty_user).some_value() is None
 
 
@@ -57,106 +57,233 @@ def test_config_force_register_global(config_fr):
 #endregion
 
 
+# Test nested registration
+def test_nested_registration(config):
+    config.register_global(foo__bar__baz=False)
+    assert config.foo.bar.baz() is False
+
+
+def test_nested_registration_asdict(config):
+    defaults = {'bar': {'baz': False}}
+    config.register_global(foo=defaults)
+
+    assert config.foo.bar.baz() is False
+
+
+@pytest.mark.asyncio
+async def test_nested_registration_and_changing(config):
+    defaults = {'bar': {'baz': False}}
+    config.register_global(foo=defaults)
+
+    assert config.foo.bar.baz() is False
+
+    with pytest.raises(ValueError):
+        await config.foo.set(True)
+
+
+def test_doubleset_default(config):
+    config.register_global(foo=True)
+    config.register_global(foo=False)
+
+    assert config.foo() is False
+
+
+def test_nested_registration_multidict(config):
+    defaults = {
+        "foo": {
+            "bar": {
+                "baz": True
+            }
+        },
+        "blah": True
+    }
+    config.register_global(**defaults)
+
+    assert config.foo.bar.baz() is True
+    assert config.blah() is True
+
+
+def test_nested_group_value_badreg(config):
+    config.register_global(foo=True)
+    with pytest.raises(KeyError):
+        config.register_global(foo__bar=False)
+
+
+def test_nested_toplevel_reg(config):
+    defaults = {'bar': True, 'baz': False}
+    config.register_global(foo=defaults)
+
+    assert config.foo.bar() is True
+    assert config.foo.baz() is False
+
+
+def test_nested_overlapping(config):
+    config.register_global(foo__bar=True)
+    config.register_global(foo__baz=False)
+
+    assert config.foo.bar() is True
+    assert config.foo.baz() is False
+
+
+def test_nesting_nofr(config):
+    config.register_global(foo={})
+    assert config.foo.bar() is None
+    assert config.foo() == {}
+
+
 #region Default Value Overrides
 def test_global_default_override(config):
     assert config.enabled(True) is True
-    assert config.get("enabled") is None
-    assert config.get("enabled", default=True) is True
 
 
 def test_global_default_nofr(config):
     assert config.nofr() is None
     assert config.nofr(True) is True
-    assert config.get("nofr") is None
-    assert config.get("nofr", default=True) is True
 
 
 def test_guild_default_override(config, empty_guild):
     assert config.guild(empty_guild).enabled(True) is True
-    assert config.guild(empty_guild).get("enabled") is None
-    assert config.guild(empty_guild).get("enabled", default=True) is True
 
 
 def test_channel_default_override(config, empty_channel):
     assert config.channel(empty_channel).enabled(True) is True
-    assert config.channel(empty_channel).get("enabled") is None
-    assert config.channel(empty_channel).get("enabled", default=True) is True
 
 
 def test_role_default_override(config, empty_role):
     assert config.role(empty_role).enabled(True) is True
-    assert config.role(empty_role).get("enabled") is None
-    assert config.role(empty_role).get("enabled", default=True) is True
 
 
 def test_member_default_override(config, empty_member):
     assert config.member(empty_member).enabled(True) is True
-    assert config.member(empty_member).get("enabled") is None
-    assert config.member(empty_member).get("enabled", default=True) is True
 
 
 def test_user_default_override(config, empty_user):
     assert config.user(empty_user).some_value(True) is True
-    assert config.user(empty_user).get("some_value") is None
-    assert config.user(empty_user).get("some_value", default=True) is True
 #endregion
 
 
 #region Setting Values
 @pytest.mark.asyncio
 async def test_set_global(config):
-    await config.set("enabled", True)
+    await config.enabled.set(True)
     assert config.enabled() is True
 
 
-@pytest.mark.asyncio
-async def test_set_global_badkey(config):
-    with pytest.raises(RuntimeError):
-        await config.set("this is a bad key", True)
-
-
-@pytest.mark.asyncio
-async def test_set_global_invalidkey(config):
-    with pytest.raises(KeyError):
-        await config.set("uuid", True)
-
-
 @pytest.mark.asyncio
 async def test_set_guild(config, empty_guild):
-    await config.guild(empty_guild).set("enabled", True)
+    await config.guild(empty_guild).enabled.set(True)
     assert config.guild(empty_guild).enabled() is True
 
     curr_list = config.guild(empty_guild).some_list([1, 2, 3])
     assert curr_list == [1, 2, 3]
     curr_list.append(4)
 
-    await config.guild(empty_guild).set("some_list", curr_list)
+    await config.guild(empty_guild).some_list.set(curr_list)
     assert config.guild(empty_guild).some_list() == curr_list
 
 
 @pytest.mark.asyncio
 async def test_set_channel(config, empty_channel):
-    await config.channel(empty_channel).set("enabled", True)
+    await config.channel(empty_channel).enabled.set(True)
     assert config.channel(empty_channel).enabled() is True
 
 
 @pytest.mark.asyncio
 async def test_set_channel_no_register(config, empty_channel):
-    await config.channel(empty_channel).set("no_register", True)
+    await config.channel(empty_channel).no_register.set(True)
     assert config.channel(empty_channel).no_register() is True
 #endregion
 
 
-# region Getting Values
-def test_get_func_w_reg(config):
-    config.register_global(
-        thing=True
-    )
-    assert config.get("thing") is True
-    assert config.get("thing", False) is False
+# Dynamic attribute testing
+@pytest.mark.asyncio
+async def test_set_dynamic_attr(config):
+    await config.set_attr("foobar", True)
+
+    assert config.foobar() is True
 
 
-def test_get_func_wo_reg(config):
-    assert config.get("thing") is None
-    assert config.get("thing", True) is True
-# endregion
+def test_get_dynamic_attr(config):
+    assert config.get_attr("foobaz", True) is True
+
+
+# Member Group testing
+@pytest.mark.asyncio
+async def test_membergroup_allguilds(config, empty_member):
+    await config.member(empty_member).foo.set(False)
+
+    all_servers = config.member(empty_member).all_guilds()
+    assert str(empty_member.guild.id) in all_servers
+
+
+@pytest.mark.asyncio
+async def test_membergroup_allmembers(config, empty_member):
+    await config.member(empty_member).foo.set(False)
+
+    all_members = config.member(empty_member).all()
+    assert str(empty_member.id) in all_members
+
+
+# Clearing testing
+@pytest.mark.asyncio
+async def test_global_clear(config):
+    config.register_global(foo=True, bar=False)
+
+    await config.foo.set(False)
+    await config.bar.set(True)
+
+    assert config.foo() is False
+    assert config.bar() is True
+
+    await config.clear()
+
+    assert config.foo() is True
+    assert config.bar() is False
+
+
+@pytest.mark.asyncio
+async def test_member_clear(config, member_factory):
+    config.register_member(foo=True)
+
+    m1 = member_factory.get()
+    await config.member(m1).foo.set(False)
+    assert config.member(m1).foo() is False
+
+    m2 = member_factory.get()
+    await config.member(m2).foo.set(False)
+    assert config.member(m2).foo() is False
+
+    assert m1.guild.id != m2.guild.id
+
+    await config.member(m1).clear()
+    assert config.member(m1).foo() is True
+    assert config.member(m2).foo() is False
+
+
+@pytest.mark.asyncio
+async def test_member_clear_all(config, member_factory):
+    server_ids = []
+    for _ in range(5):
+        member = member_factory.get()
+        await config.member(member).foo.set(True)
+        server_ids.append(member.guild.id)
+
+    member = member_factory.get()
+    assert len(config.member(member).all_guilds()) == len(server_ids)
+
+    await config.member(member).clear_all()
+
+    assert len(config.member(member).all_guilds()) == 0
+
+
+# Get All testing
+@pytest.mark.asyncio
+async def test_user_get_all(config, user_factory):
+    for _ in range(5):
+        user = user_factory.get()
+        await config.user(user).foo.set(True)
+
+    user = user_factory.get()
+    all_data = config.user(user).all()
+
+    assert len(all_data) == 5