chrome/test/webapps/graph_analysis_unittest.py

#!/usr/bin/env python3
# Copyright 2021 The Chromium Authors
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.

import csv
from file_reading import read_actions_file, read_enums_file, read_platform_supported_actions, read_unprocessed_coverage_tests_file
from test_analysis import expand_parameterized_tests, filter_coverage_tests_for_platform, partition_framework_tests_per_platform_combination
from graph_analysis import build_action_node_graph, generate_framework_tests, trim_graph_to_platform_actions
import os
import unittest

from models import ActionNode, CoverageTestsByPlatform, CoverageTestsByPlatformSet, TestPartitionDescription
from models import TestPlatform

TEST_DATA_DIR = os.path.join(os.path.dirname(os.path.abspath(__file__)),
                             "test_data")


class GraphAnalysisUnittest(unittest.TestCase):
    def test_test_generation(self):
        self.maxDiff = None
        actions_filename = os.path.join(TEST_DATA_DIR, "test_actions.md")
        enums_filename = os.path.join(TEST_DATA_DIR, "test_enums.md")
        supported_actions_filename = os.path.join(
            TEST_DATA_DIR, "framework_supported_actions.csv")

        coverage_filename = os.path.join(TEST_DATA_DIR,
                                         "test_unprocessed_coverage.md")

        test_partition = TestPartitionDescription(
            action_name_prefixes=set(),
            browsertest_dir=os.path.join(TEST_DATA_DIR, "expected_test_txt"),
            test_file_prefix="tests_default",
            test_fixture="TestName")

        with open(actions_filename, "r", encoding="utf-8") as actions_file, \
                open(supported_actions_filename, "r", encoding="utf-8") \
                    as supported_actions_file, \
                open (enums_filename, "r", encoding="utf-8") as enums, \
                open(coverage_filename, "r", encoding="utf-8") \
                    as coverage_file:
            enums = read_enums_file(enums.readlines())
            platform_supported_actions = read_platform_supported_actions(
                csv.reader(supported_actions_file, delimiter=','))
            (actions, action_base_name_to_default_param) = read_actions_file(
                actions_file.readlines(), enums, platform_supported_actions)

            required_coverage_tests = read_unprocessed_coverage_tests_file(
                coverage_file.readlines(), actions, enums,
                action_base_name_to_default_param)

            required_coverage_tests = expand_parameterized_tests(
                required_coverage_tests)

            required_coverage_by_platform: CoverageTestsByPlatform = {}
            generated_tests_by_platform: CoverageTestsByPlatform = {}
            for platform in TestPlatform:
                platform_tests = filter_coverage_tests_for_platform(
                    required_coverage_tests.copy(), platform)
                required_coverage_by_platform[platform] = platform_tests

                generated_tests_root_node = ActionNode.CreateRootNode()
                build_action_node_graph(generated_tests_root_node,
                                        platform_tests)
                trim_graph_to_platform_actions(generated_tests_root_node,
                                               platform)
                generated_tests_by_platform[
                    platform] = generate_framework_tests(
                        generated_tests_root_node, platform)

            required_coverage_by_platform_set: CoverageTestsByPlatformSet = (
                partition_framework_tests_per_platform_combination(
                    generated_tests_by_platform))
            for platform_set, tests in required_coverage_by_platform_set.items(
            ):
                expected_filename = os.path.join(
                    test_partition.browsertest_dir,
                    test_partition.test_file_prefix)
                if len(platform_set) != len(TestPlatform):
                    for platform in TestPlatform:
                        if platform in platform_set:
                            expected_filename += "_" + platform.suffix
                expected_filename += ".txt"
                with open(expected_filename, "r",
                          encoding="utf-8") as expected_tests_file:
                    expected_tests_str = expected_tests_file.read()
                    actual_tests_str = "\n".join([
                        test.generate_browsertest(test_partition)
                        for test in tests
                    ])
                    self.assertEqual(expected_tests_str, actual_tests_str)


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