Exemplo n.º 1
0
    def test_get_event_loop_returns_a_loop(self):
        # Arrange
        node = TradingNode()

        # Act
        loop = node.get_event_loop()

        # Assert
        assert isinstance(loop, asyncio.AbstractEventLoop)
Exemplo n.º 2
0
class TradingNodeOperationTests(unittest.TestCase):
    def setUp(self):
        # Fixture Setup
        # Fresh isolated loop testing pattern
        self.loop = asyncio.new_event_loop()
        asyncio.set_event_loop(self.loop)

        config = {
            "trader": {
                "name": "tester",
                "id_tag": "000",
            },
            "logging": {
                "log_level_console": "INF",
                "log_level_file": "DBG",
                "log_level_store": "WRN",
            },
            "exec_database": {
                "type": "in-memory",
            },
            "strategy": {
                "load_state": True,
                "save_state": True,
            },
            "data_clients": {},
            "exec_clients": {},
        }

        self.node = TradingNode(
            strategies=[TradingStrategy("000")],
            config=config,
        )

    def test_get_event_loop_returns_a_loop(self):
        # Arrange
        # Act
        loop = self.node.get_event_loop()

        # Assert
        self.assertTrue(isinstance(loop, asyncio.AbstractEventLoop))

    def test_start(self):
        # Arrange
        run = threading.Thread(target=self.node.start, daemon=True)
        run.start()

        time.sleep(0.3)

        # Act
        # Assert
        self.assertEqual(ComponentState.RUNNING, self.node.trader.state)
        self.node.stop()

    def test_stop(self):
        # Arrange
        run = threading.Thread(target=self.node.start, daemon=True)
        run.start()

        # Allow node to start
        time.sleep(0.3)
        self.loop.call_soon_threadsafe(self.node.stop)

        # Allow node to stop
        time.sleep(3)

        # Act
        # Assert
        self.assertEqual(ComponentState.STOPPED, self.node.trader.state)

    def test_dispose(self):
        # Arrange
        run = threading.Thread(target=self.node.start, daemon=True)
        run.start()

        # Allow node to start
        time.sleep(0.3)
        self.loop.call_soon_threadsafe(self.node.stop)

        # Allow node to stop
        time.sleep(3)

        self.node.dispose()

        # Act
        # Assert
        self.assertEqual(ComponentState.DISPOSED, self.node.trader.state)