add new assertions

requirements-dev.txt

@@ -9,3 +9,4 @@ pytest==7.4.2
 pytest-asyncio==0.21.1
 pytest-cov==4.1.0
 setuptools==68.1.2
+dessert==1.4.7

requirements.txt

@@ -1,5 +1,4 @@
 cabina>=0.7,<2.0
-dessert>=1.4,<2.0
 filelock>=3.5,<4.0
 niltype>=0.3,<2.0
 pyparsing>=3.0,<4.0

tests/commands/plugin_command/plugin_manager/_utils.py

@@ -1,4 +1,4 @@
-from os import chdir, linesep
+from os import linesep
 from pathlib import Path
 from time import time
 from typing import List, Optional
@@ -7,7 +7,6 @@
 
 
 def create_config(tmp_path: Path, config: Optional[List[str]] = None) -> Path:
-    chdir(tmp_path)
     now = int(time() * 1000)
     config_file = Path(f"vedro-cfg-{now}.py")
     if config is not None:

tests/commands/plugin_command/plugin_manager/test_plugin_manager.py

@@ -1,3 +1,4 @@
+import os
 from os import linesep
 from pathlib import Path
 
@@ -9,6 +10,16 @@
 from ._utils import create_config, read_config
 
 
+@pytest.fixture()
+def tmp_path(tmp_path: Path) -> Path:
+    cwd = os.getcwd()
+    try:
+        os.chdir(tmp_path)
+        yield tmp_path
+    finally:
+        os.chdir(cwd)
+
+
 async def test_plugin_manager_no_file(tmp_path: Path):
     with given:
         config_path = create_config(tmp_path)

tests/commands/run_command/_utils.py

@@ -1,4 +1,5 @@
-from os import chdir, linesep
+import os
+from os import linesep
 from pathlib import Path
 
 import pytest
@@ -10,9 +11,14 @@
 
 @pytest.fixture()
 def tmp_dir(tmp_path: Path) -> Path:
-    chdir(tmp_path)
-    Path("./scenarios").mkdir(exist_ok=True)
-    yield tmp_path
+    cwd = os.getcwd()
+    try:
+        os.chdir(tmp_path)
+
+        Path("./scenarios").mkdir(exist_ok=True)
+        yield tmp_path
+    finally:
+        os.chdir(cwd)
 
 
 def create_scenario(tmp_dir: Path, scenario_path: str) -> None:

tests/core/module_loader/test_module_file_loader.py

@@ -0,0 +1,73 @@
+from pathlib import Path
+from types import ModuleType
+
+import pytest
+from _pytest.python_api import raises
+from baby_steps import given, then, when
+
+from vedro.core import ModuleFileLoader
+
+
+def make_module(tmp_path: Path, name: str, content: str) -> Path:
+    module_path = tmp_path / name
+    module_path.write_text(content)
+    return module_path
+
+
+async def test_load_module(tmp_path: Path):
+    with given:
+        loader = ModuleFileLoader()
+        module_path = make_module(tmp_path, "test_module.py", "x = 42")
+
+    with when:
+        module = await loader.load(module_path)
+
+    with then:
+        assert isinstance(module, ModuleType)
+        assert module.x == 42
+
+
+async def test_load_module_with_valid_name(tmp_path: Path):
+    with given:
+        loader = ModuleFileLoader(validate_module_names=True)
+        rel_path = tmp_path.relative_to(Path.cwd())
+        module_path = make_module(rel_path, "test_module.py", "x = 42")
+
+    with when:
+        module = await loader.load(module_path)
+
+    with then:
+        assert isinstance(module, ModuleType)
+        assert module.x == 42
+
+
+@pytest.mark.parametrize("name", ["123name", "import"])
+async def test_load_module_with_invalid_name(tmp_path: Path, name: str):
+    with given:
+        loader = ModuleFileLoader(validate_module_names=True)
+        rel_path = tmp_path.relative_to(Path.cwd())
+        module_path = make_module(rel_path, f"{name}.py", "x = 42")
+
+    with when, raises(BaseException) as exc:
+        await loader.load(module_path)
+
+    with then:
+        assert exc.type is ValueError
+        assert str(exc.value) == (
+            f"The module name derived from the path '{module_path}' is invalid due to the segment "
+            f"'{name}'. A valid module name should start with a letter or underscore, contain "
+            "only letters, digits, or underscores, and not be a Python keyword."
+        )
+
+
+async def test_load_module_with_non_existent_path():
+    with given:
+        loader = ModuleFileLoader()
+        non_existent_path = Path("non_existent_module.py")
+
+    with when, raises(BaseException) as exc:
+        await loader.load(non_existent_path)
+
+    with then:
+        assert exc.type is FileNotFoundError
+        assert "[Errno 2] No such file or directory" in str(exc.value)

tests/core/module_loader/test_module_loader.py

@@ -0,0 +1,13 @@
+from baby_steps import given, when
+from pytest import raises
+
+from vedro.core import ModuleLoader
+
+
+def test_abstract_module_loader_instantiation():
+    with when, raises(BaseException) as exc_info:
+        ModuleLoader()
+
+    with given:
+        assert exc_info.type is TypeError
+        assert "Can't instantiate abstract class ModuleLoader" in str(exc_info.value)

tests/core/scenario_loader/test_scenario_file_loader.py

@@ -88,50 +88,6 @@ def __init__(self, user):
         assert len(scenarios) == 2
 
 
-async def test_scenario_file_loader_with_invalid_module_name(tmp_scn_dir: Path):
-    with given:
-        path = tmp_scn_dir / "scenario with space.py"
-        path.write_text(dedent('''
-            import vedro
-            class Scenario(vedro.Scenario):
-                pass
-        '''))
-        loader = ScenarioFileLoader()
-        loader._validate_module_names = True
-
-    with when, raises(BaseException) as exc:
-        await loader.load(path)
-
-    with then:
-        assert exc.type is ValueError
-        assert str(exc.value) == (
-            "The module name derived from the path 'scenarios/scenario with space.py' "
-            "is invalid due to the segment 'scenario with space'. "
-            "A valid module name should start with a letter or underscore, contain "
-            "only letters, digits, or underscores, and not be a Python keyword."
-        )
-
-
-async def test_scenario_file_loader_with_invalid_class_name(tmp_scn_dir: Path):
-    with given:
-        path = tmp_scn_dir / "scenario.py"
-        path.write_text(dedent('''
-            import vedro
-            class Scn(vedro.Scenario):
-                pass
-        '''))
-        loader = ScenarioFileLoader()
-
-    with when, raises(BaseException) as exc:
-        await loader.load(path)
-
-    with then:
-        assert exc.type is ValueError
-        assert str(exc.value) == (
-            "'scenarios.scenario.Scn' must have a name that starts or ends with 'Scenario'"
-        )
-
-
 async def test_scenario_file_loader_without_inheriting_scenario(tmp_scn_dir: Path):
     with given:
         path = tmp_scn_dir / "scenario.py"
@@ -161,7 +117,7 @@ async def test_scenario_file_loader_without_scenarios(tmp_scn_dir: Path):
     with then:
         assert exc.type is ValueError
         assert str(exc.value) == (
-            "No valid Vedro scenarios found in the module at 'scenarios/scenario.py'. "
+            "No Vedro scenarios found in the module at 'scenarios/scenario.py'. "
             "Ensure the module contains at least one subclass of 'vedro.Scenario'"
         )
 

tests/plugins/assert_rewriter/_utils.py

@@ -0,0 +1,61 @@
+import os
+from argparse import ArgumentParser, Namespace
+from pathlib import Path
+
+import pytest
+
+from vedro.core import Config, ConfigType, Dispatcher, Factory, ModuleFileLoader, ModuleLoader
+from vedro.events import ArgParsedEvent, ArgParseEvent, ConfigLoadedEvent
+from vedro.plugins.assert_rewriter import AssertRewriter, AssertRewriterPlugin
+
+__all__ = ("tmp_scn_dir", "dispatcher", "assert_rewriter_plugin", "make_config",
+           "fire_config_loaded_event", "fire_arg_parsed_event",)
+
+
+@pytest.fixture()
+def tmp_scn_dir(tmp_path: Path) -> Path:
+    cwd = os.getcwd()
+    try:
+        os.chdir(tmp_path)
+
+        scn_dir = tmp_path / "scenarios/"
+        scn_dir.mkdir(exist_ok=True)
+        yield scn_dir.relative_to(tmp_path)
+    finally:
+        os.chdir(cwd)
+
+
+@pytest.fixture()
+def dispatcher() -> Dispatcher:
+    return Dispatcher()
+
+
+@pytest.fixture()
+def assert_rewriter_plugin(dispatcher: Dispatcher) -> AssertRewriterPlugin:
+    plugin = AssertRewriterPlugin(AssertRewriter)
+    plugin.subscribe(dispatcher)
+    return plugin
+
+
+def make_config() -> ConfigType:
+    class TestConfig(Config):
+        class Registry(Config.Registry):
+            ModuleLoader = Factory[ModuleLoader](ModuleFileLoader)
+
+    return TestConfig
+
+
+async def fire_config_loaded_event(dispatcher: Dispatcher, config: ConfigType) -> None:
+    config_loaded_event = ConfigLoadedEvent(Path(), config)
+    await dispatcher.fire(config_loaded_event)
+
+
+async def fire_arg_parsed_event(
+        dispatcher: Dispatcher, *,
+        legacy_assertions: bool = AssertRewriter.legacy_assertions
+        ) -> None:
+    arg_parse_event = ArgParseEvent(ArgumentParser())
+    await dispatcher.fire(arg_parse_event)
+
+    arg_parsed_event = ArgParsedEvent(Namespace(legacy_assertions=legacy_assertions))
+    await dispatcher.fire(arg_parsed_event)

tests/plugins/assert_rewriter/test_assert_rewriter_loader.py

@@ -0,0 +1,66 @@
+from pathlib import Path
+from textwrap import dedent
+
+from baby_steps import given, then, when
+from niltype import Nil
+from pytest import raises
+
+from vedro.plugins.assert_rewriter import AssertRewriterLoader, CompareOperator, assert_
+
+from ._utils import tmp_scn_dir
+
+__all__ = ("tmp_scn_dir",)  # pytest fixtures
+
+
+async def test_load_assertion_failure(tmp_scn_dir: Path):
+    with given:
+        path = tmp_scn_dir / "scenario.py"
+        path.write_text(dedent('''
+            import vedro
+            class Scenario(vedro.Scenario):
+                def step(self):
+                    assert 1 == 2
+        '''))
+
+        loader = AssertRewriterLoader()
+        module = await loader.load(path)
+        scenario = module.Scenario()
+
+    with when, raises(BaseException) as exc:
+        scenario.step()
+
+    with then:
+        assert exc.type is AssertionError
+        assert str(exc.value) == ""
+
+        assert assert_.get_left(exc.value) == 1
+        assert assert_.get_right(exc.value) == 2
+        assert assert_.get_operator(exc.value) == CompareOperator.EQUAL
+        assert assert_.get_message(exc.value) == Nil
+
+
+async def test_load_assertion_failure_with_message(tmp_scn_dir: Path):
+    with given:
+        path = tmp_scn_dir / "scenario.py"
+        path.write_text(dedent('''
+            import vedro
+            class Scenario(vedro.Scenario):
+                def step(self):
+                    assert 1 == 2, "assertion failed"
+        '''))
+
+        loader = AssertRewriterLoader()
+        module = await loader.load(path)
+        scenario = module.Scenario()
+
+    with when, raises(BaseException) as exc:
+        scenario.step()
+
+    with then:
+        assert exc.type is AssertionError
+        assert str(exc.value) == "assertion failed"
+
+        assert assert_.get_left(exc.value) == 1
+        assert assert_.get_right(exc.value) == 2
+        assert assert_.get_operator(exc.value) == CompareOperator.EQUAL
+        assert assert_.get_message(exc.value) == "assertion failed"

tests/plugins/assert_rewriter/test_assert_rewriter_plugin.py

@@ -1,12 +1,41 @@
-from baby_steps import then, when
+import pytest
+from baby_steps import given, then, when
 
-from vedro.core import Plugin
-from vedro.plugins.assert_rewriter import AssertRewriter, AssertRewriterPlugin
+from vedro.core import Dispatcher
+from vedro.plugins.assert_rewriter import AssertRewriterLoader, LegacyAssertRewriterLoader
 
+from ._utils import (
+    assert_rewriter_plugin,
+    dispatcher,
+    fire_arg_parsed_event,
+    fire_config_loaded_event,
+    make_config,
+)
+
+__all__ = ("dispatcher", "assert_rewriter_plugin",)  # pytest fixtures
+
+
+@pytest.mark.usefixtures(assert_rewriter_plugin.__name__)
+async def test_registers_default_assert_rewriter_loader(*, dispatcher: Dispatcher):
+    with given:
+        config = make_config()
+        await fire_config_loaded_event(dispatcher, config)
+
+    with when:
+        await fire_arg_parsed_event(dispatcher)
+
+    with then:
+        assert isinstance(config.Registry.ModuleLoader(), AssertRewriterLoader)
+
+
+@pytest.mark.usefixtures(assert_rewriter_plugin.__name__)
+async def test_registers_legacy_assert_rewriter_loader(*, dispatcher: Dispatcher):
+    with given:
+        config = make_config()
+        await fire_config_loaded_event(dispatcher, config)
 
-def test_plugin():
     with when:
-        plugin = AssertRewriterPlugin(AssertRewriter)
+        await fire_arg_parsed_event(dispatcher, legacy_assertions=True)
 
     with then:
-        assert isinstance(plugin, Plugin)
+        assert isinstance(config.Registry.ModuleLoader(), LegacyAssertRewriterLoader)