Refactory test fixtures

Author: everoddandeven

tests/test_monero_common.py

@@ -5,19 +5,15 @@
     MoneroError, MoneroRpcError, SerializableStruct
 )
 
+from utils import BaseTestClass
+
 logger: logging.Logger = logging.getLogger("TestMoneroCommon")
 
 
 @pytest.mark.unit
-class TestMoneroCommon:
+class TestMoneroCommon(BaseTestClass):
     """Monero common unit tests"""
 
-    @pytest.fixture(autouse=True)
-    def setup_and_teardown(self, request: pytest.FixtureRequest):
-        logger.info(f"Before {request.node.name}") # type: ignore
-        yield
-        logger.info(f"After {request.node.name}") # type: ignore
-
     # test monero error inheritance
     def test_monero_error(self) -> None:
         monero_err: MoneroError = MoneroError("Test monero error")

tests/test_monero_connection_manager.py

@@ -1,20 +1,20 @@
 import pytest
 import logging
 
-from typing import Optional
+from typing import Optional, override
 from monero import (
     MoneroConnectionManager, MoneroRpcConnection, MoneroConnectionPollType
 )
 from utils import (
     ConnectionChangeCollector, TestUtils as Utils,
-    AssertUtils, RpcConnectionUtils
+    AssertUtils, RpcConnectionUtils, BaseTestClass
 )
 
 logger: logging.Logger = logging.getLogger("TestMoneroConnectionManager")
 
 
 @pytest.mark.integration
-class TestMoneroConnectionManager:
+class TestMoneroConnectionManager(BaseTestClass):
     """Connection manager integration tests"""
 
     OFFLINE_PROXY_URI: str = "127.0.0.1:9050"
@@ -25,39 +25,22 @@ class TestMoneroConnectionManager:
 
     #region Fixtures
 
-    # Setup and teardown of test class
-    @pytest.fixture(scope="class", autouse=True)
-    def global_setup_and_teardown(self):
-        """Executed once before all tests"""
-        self.before_all()
-        yield
-        self.after_all()
-
     # Before all tests
+    @override
     def before_all(self) -> None:
-        """Executed once before all tests"""
-        logger.info(f"Setup test class {type(self).__name__}")
+        super().before_all()
         self._cm = MoneroConnectionManager()
 
     # After all tests
+    @override
     def after_all(self) -> None:
-        """Executed once after all tests"""
-        logger.info(f"Teardown test class {type(self).__name__}")
+        super().after_all()
         if self._cm:
             self._cm.reset()
             logger.debug("Resetted connection manager")
-        else:
-            logger.warning("Test connection manager is not set!")
 
         Utils.RPC_WALLET_MANAGER.clear()
 
-    # setup and teardown of each test
-    @pytest.fixture(autouse=True)
-    def setup_and_teardown(self, request: pytest.FixtureRequest):
-        logger.info(f"Before {request.node.name}") # type: ignore
-        yield
-        logger.info(f"After {request.node.name}") # type: ignore
-
     # test connnections fixture
     @pytest.fixture(scope="class")
     def connections(self) -> list[MoneroRpcConnection]:
@@ -123,7 +106,7 @@ def test_connection_manager(self, connection_manager: MoneroConnectionManager, c
 
         # auto connect to the best available connection
         connection_manager.start_polling(Utils.SYNC_PERIOD_IN_MS)
-        listener.wait_for_change(num_expected_changes + 1, Utils.SYNC_PERIOD_IN_MS, f"Waiting for auto connect to best available connection")
+        listener.wait_for_change(num_expected_changes + 1, Utils.SYNC_PERIOD_IN_MS, "Waiting for auto connect to best available connection")
         assert connection_manager.is_connected()
         connection = connection_manager.get_connection()
         assert connection is not None

tests/test_monero_daemon_interface.py

@@ -2,21 +2,16 @@
 import logging
 
 from monero import MoneroDaemon, MoneroBan
+from utils import BaseTestClass
 
 logger: logging.Logger = logging.getLogger("TestMoneroDaemonInterface")
 
 
 # Test calls to MoneroDaemon interface
 @pytest.mark.unit
-class TestMoneroDaemonInterface:
+class TestMoneroDaemonInterface(BaseTestClass):
     """Daemon interface bindings unit tests"""
 
-    @pytest.fixture(autouse=True)
-    def setup_and_teardown(self, request: pytest.FixtureRequest):
-        logger.info(f"Before {request.node.name}") # type: ignore
-        yield
-        logger.info(f"After {request.node.name}") # type: ignore
-
     @pytest.fixture(scope="class")
     def daemon(self) -> MoneroDaemon:
         """Test daemon interface instance"""

tests/test_monero_daemon_rpc.py

@@ -2,6 +2,8 @@
 import time
 import logging
 
+from typing import override
+
 from monero import (
     MoneroDaemonRpc, MoneroVersion, MoneroBlockHeader, MoneroBlockTemplate,
     MoneroBlock, MoneroMiningStatus, MoneroPruneResult,
@@ -20,30 +22,25 @@
     BlockUtils, GenUtils,
     DaemonUtils, WalletType,
     IntegrationTestUtils,
-    SubmitThenRelayTxTester
+    SubmitThenRelayTxTester, BaseTestClass
 )
 
 logger: logging.Logger = logging.getLogger("TestMoneroDaemonRpc")
 
 
 @pytest.mark.integration
-class TestMoneroDaemonRpc:
+class TestMoneroDaemonRpc(BaseTestClass):
     """Rpc daemon integration tests"""
     BINARY_BLOCK_CTX: BinaryBlockContext = BinaryBlockContext()
     _test_wallet: MoneroWalletRpc | None = None
 
     #region Fixtures
 
-    @pytest.fixture(scope="class", autouse=True)
+    @override
     def before_all(self):
+        # setup wallet rpc for tests
         IntegrationTestUtils.setup(WalletType.RPC)
 
-    @pytest.fixture(autouse=True)
-    def setup_and_teardown(self, request: pytest.FixtureRequest):
-        logger.info(f"Before {request.node.name}") # type: ignore
-        yield
-        logger.info(f"After {request.node.name}") # type: ignore
-
     @pytest.fixture(scope="class")
     def daemon(self) -> MoneroDaemonRpc:
         """Test rpc daemon instance"""

tests/test_monero_rpc_connection.py

@@ -5,41 +5,20 @@
     MoneroRpcConnection, MoneroConnectionType, MoneroRpcError,
     MoneroUtils, MoneroConnectionProriotyComparator
 )
-from utils import TestUtils as Utils, DaemonUtils, StringUtils
+from utils import TestUtils as Utils, DaemonUtils, StringUtils, BaseTestClass
 
 logger: logging.Logger = logging.getLogger("TestMoneroRpcConnection")
 
 
 @pytest.mark.integration
-class TestMoneroRpcConnection:
+class TestMoneroRpcConnection(BaseTestClass):
     """Rpc connection integration tests"""
 
     TIMEOUT_MS: int = Utils.AUTO_CONNECT_TIMEOUT_MS * 5
     """Rpc connection timeout in milliseconds."""
 
     # region Fixtures
 
-    # Setup and teardown of test class
-    @pytest.fixture(scope="class", autouse=True)
-    def global_setup_and_teardown(self):
-        """Executed once before all tests"""
-        logger.info(f"Setup test class {type(self).__name__}")
-        self.before_all()
-        yield
-        logger.info(f"Teardown test class {type(self).__name__}")
-
-    # Before all tests
-    def before_all(self) -> None:
-        """Executed once before all tests"""
-        logger.info(f"Setup test class {type(self).__name__}")
-
-    # Setup and teardown of each tests
-    @pytest.fixture(autouse=True)
-    def setup_and_teardown(self, request: pytest.FixtureRequest):
-        logger.info(f"Before {request.node.name}") # type: ignore
-        yield
-        logger.info(f"After {request.node.name}") # type: ignore
-
     # Node rpc connection fixture
     @pytest.fixture(scope="class")
     def node_connection(self) -> MoneroRpcConnection:

tests/test_monero_utils.py

@@ -8,13 +8,13 @@
 from monero import (
     MoneroNetworkType, MoneroIntegratedAddress, MoneroUtils, MoneroTxConfig
 )
-from utils import AddressBook, KeysBook, WalletUtils
+from utils import AddressBook, KeysBook, WalletUtils, BaseTestClass
 
 logger: logging.Logger = logging.getLogger("TestMoneroUtils")
 
 
 @pytest.mark.unit
-class TestMoneroUtils:
+class TestMoneroUtils(BaseTestClass):
     """Monero utilities unit tests"""
 
     class Config:
@@ -59,22 +59,6 @@ def config(self) -> TestMoneroUtils.Config:
         parser.read('tests/config/test_monero_utils.ini')
         return TestMoneroUtils.Config.parse(parser)
 
-    # Setup and teardown of test class
-    @pytest.fixture(scope="class", autouse=True)
-    def global_setup_and_teardown(self):
-        """Executed once before all tests"""
-        logger.info(f"Setup test class {type(self).__name__}")
-        yield
-        logger.info(f"Teardown test class {type(self).__name__}")
-
-    # Setup and teardown of each tests
-    @pytest.fixture(autouse=True)
-    def setup_and_teardown(self, request: pytest.FixtureRequest):
-        """Executed once before each test"""
-        logger.info(f"Before {request.node.name}") # type: ignore
-        yield
-        logger.info(f"After {request.node.name}") # type: ignore
-
     #endregion
 
     #region Tests

tests/test_monero_wallet_common.py

@@ -3,10 +3,11 @@
 import pytest
 import logging
 
+from typing import override
 from time import sleep
 from random import shuffle
 from configparser import ConfigParser
-from abc import ABC, abstractmethod
+from abc import abstractmethod
 from typing import Optional
 from datetime import datetime
 
@@ -28,14 +29,14 @@
     ViewOnlyAndOfflineWalletTester,
     WalletNotificationCollector,
     MiningUtils, SendAndUpdateTxsTester,
-    SyncWithPoolSubmitTester
+    SyncWithPoolSubmitTester, BaseTestClass
 )
 
 logger: logging.Logger = logging.getLogger("TestMoneroWalletCommon")
 
 
 # Base class for common wallet tests
-class BaseTestMoneroWallet(ABC):
+class BaseTestMoneroWallet(BaseTestClass):
     """Common wallet tests that every Monero wallet implementation should support"""
     CREATED_WALLET_KEYS_ERROR: str = "Wallet created from keys is not connected to authenticated daemon"
     _test_wallet: Optional[MoneroWallet] = None
@@ -177,50 +178,27 @@ def wallet(self) -> MoneroWallet:
         """Test wallet instance"""
         pytest.skip("No wallet test instance setup")
 
-    # Setup and teardown of test class
-    @pytest.fixture(scope="class", autouse=True)
-    def global_setup_and_teardown(self):
-        """Executed once before all tests"""
-        self.before_all()
-        yield
-        self.after_all()
-
-    # Setup and teardown of each test
-    @pytest.fixture(autouse=True)
-    def setup_and_teardown(self, request: pytest.FixtureRequest):
-        self.before_each(request)
-        yield
-        self.after_each(request)
-
     # Before all tests
+    @override
     def before_all(self) -> None:
-        """Executed once before all tests"""
-        logger.info(f"Setup test class {type(self).__name__}")
+        super().before_all()
         IntegrationTestUtils.setup(self.get_wallet_type())
 
     # After all tests
+    @override
     def after_all(self) -> None:
-        """Executed once after all tests"""
-        logger.info(f"Teardown test class {type(self).__name__}")
-        daemon: MoneroDaemonRpc | None = self._get_test_daemon()
-        try:
-            daemon.stop_mining()
-        except Exception as e:
-            logger.debug(str(e))
+        super().after_all()
+        daemon: MoneroDaemonRpc = self._get_test_daemon()
+        MiningUtils.try_stop_mining(daemon)
 
         # close wallet
         wallet = self.get_test_wallet()
         wallet.close(True)
 
     # Before each test
+    @override
     def before_each(self, request: pytest.FixtureRequest) -> None:
-        """
-        Executed before each test
-
-        :param pytest.FixtureRequest: Request fixture
-        """
-        logger.info(f"Before {request.node.name}") # type: ignore
-
+        super().before_each(request)
         daemon = self._get_test_daemon()
         wallet = self.get_test_wallet()
         status = daemon.get_mining_status()
@@ -229,14 +207,9 @@ def before_each(self, request: pytest.FixtureRequest) -> None:
             wallet.stop_mining()
 
     # After each test
+    @override
     def after_each(self, request: pytest.FixtureRequest) -> None:
-        """
-        Executed after each test
-
-        :param pytest.FixtureRequest: Request fixture
-        """
-        logger.info(f"After {request.node.name}") # type: ignore
-
+        super().after_each(request)
         daemon = self._get_test_daemon()
         status = daemon.get_mining_status()
 

tests/test_monero_wallet_interface.py

@@ -8,36 +8,21 @@
     MoneroTxWallet
 )
 
-from utils import WalletUtils, StringUtils
+from utils import WalletUtils, StringUtils, BaseTestClass
 
 logger: logging.Logger = logging.getLogger("TestMoneroWalletInterface")
 
 
 # Test binding calls to MoneroWallet interface
 @pytest.mark.unit
-class TestMoneroWalletInterface:
+class TestMoneroWalletInterface(BaseTestClass):
     """Wallet interface binding calls unit tests"""
 
     @pytest.fixture(scope="class")
     def wallet(self) -> MoneroWallet:
         """Test wallet instance"""
         return MoneroWallet()
 
-    # Setup and teardown of test class
-    @pytest.fixture(scope="class", autouse=True)
-    def global_setup_and_teardown(self):
-        """Executed once before all tests"""
-        logger.info(f"Setup test class {type(self).__name__}")
-        yield
-        logger.info(f"Teardown test class {type(self).__name__}")
-
-    # Setup and teardown of each tests
-    @pytest.fixture(autouse=True)
-    def setup_and_teardown(self, request: pytest.FixtureRequest):
-        logger.info(f"Before {request.node.name}") # type: ignore
-        yield
-        logger.info(f"After {request.node.name}") # type: ignore
-
     #region Tests
 
     # Test default language static property