unit_test_aDOT.py

import unittest
import os
from comsdk.parser import Parser
from comsdk.graph import Graph


class TestADOTParser(unittest.TestCase):
    @classmethod
    def setUpClass(cls):
        cls.test_files_dir = os.path.join(os.path.dirname(__file__), "test_adot_files")
        cls.parser = Parser()

    def test_sequential_graph(self):
        """Тест последовательного графа"""
        graph = self.parser.parse_file(os.path.join(self.test_files_dir, "sequential.adot"))
        self.assertIsInstance(graph, Graph)

        # Проверка структуры
        init_state = graph.init_state
        self.assertEqual(len(init_state.transfers), 1)

        # Проверка выполнения
        data = {"a": 1}
        result = graph.run(data)
        self.assertTrue(result)
        self.assertEqual(data["a"], 4)  # 1 -> (inc) 2 -> (double) 4

    def test_cycled_graph(self):
        """Тест циклического графа с уменьшением a до 0"""
        graph = self.parser.parse_file(os.path.join(self.test_files_dir, "cycled.adot"))
        self.assertIsInstance(graph, Graph)

        # Проверка выполнения
        data = {"a": 5}  # Начинаем с 5
        result = graph.run(data)
        self.assertTrue(result)
        self.assertEqual(data["a"], 0,
                         "Граф должен уменьшать a до 0")

        # Дополнительная проверка с другим начальным значением
        data = {"a": 3}
        result = graph.run(data)
        self.assertTrue(result)
        self.assertEqual(data["a"], 0)

    def test_branching_graph(self):
        """Тест графа с ветвлениями"""
        graph = self.parser.parse_file(os.path.join(self.test_files_dir, "branching.adot"))
        self.assertIsInstance(graph, Graph)

        # Проверка ветвления A
        data = {"condition": True}
        result = graph.run(data)
        self.assertTrue(result)
        self.assertTrue(data["processed_by_a"])

        # Проверка ветвления B
        data = {"condition": False}
        result = graph.run(data)
        self.assertTrue(result)
        self.assertTrue(data["processed_by_b"])

    def test_subgraph_integration(self):
        """Тест интеграции подграфов"""
        graph = self.parser.parse_file(os.path.join(self.test_files_dir, "subgraph.adot"))
        self.assertIsInstance(graph, Graph)

        data = {}
        result = graph.run(data)
        self.assertTrue(result)
        self.assertTrue(data["preprocessed"])
        self.assertTrue(data["postprocessed"])

    def test_edge_types(self):
        """Тест разных типов ребер (-> и =>)"""
        graph = self.parser.parse_file(os.path.join(self.test_files_dir, "edge_types.adot"))
        self.assertIsInstance(graph, Graph)

        transfers = graph.init_state.transfers
        self.assertEqual(transfers[0].edge.order, 0)  # ->
        self.assertEqual(transfers[1].edge.order, 1)  # =>

    def test_attributes_parsing(self):
        """Тест парсинга атрибутов узлов и ребер"""
        graph = self.parser.parse_file(os.path.join(self.test_files_dir, "attributes.adot"))

        # Проверка атрибутов состояния
        state = graph.init_state
        self.assertEqual(state.parallelization_policy.__class__.__name__, "ThreadParallelizationPolicy")
        self.assertIsNotNone(state.selector)
        self.assertEqual(state.comment, "Test node with attributes")

        # Проверка атрибутов ребра
        edge = state.transfers[0].edge
        self.assertEqual(edge.comment, "Test edge with attributes")


class TestGraphExecution(unittest.TestCase):
    def test_parallel_execution(self):
        """Тест параллельного выполнения"""
        # Здесь должны быть тесты реального параллельного выполнения
        # с использованием threading/multiprocessing
        pass

    def test_error_handling(self):
        """Тест обработки ошибок"""
        parser = Parser()
        with self.assertRaises(Exception):
            parser.parse_file(os.path.join("test_adot_files", "invalid_syntax.adot"))


if __name__ == '__main__':
    unittest.main()