| #!/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 os |
| import csv |
| import tempfile |
| from typing import List |
| import shutil |
| import unittest |
| |
| from file_reading import enumerate_all_argument_combinations |
| from file_reading import expand_tests_from_action_parameter_wildcards |
| from file_reading import enumerate_markdown_file_lines_to_table_rows |
| from file_reading import human_friendly_name_to_canonical_action_name |
| from file_reading import generate_test_id_from_test_steps |
| from file_reading import get_and_maybe_delete_tests_in_browsertest |
| from file_reading import read_actions_file |
| from file_reading import read_enums_file |
| from file_reading import read_platform_supported_actions |
| from file_reading import resolve_bash_style_replacement |
| from file_reading import read_unprocessed_coverage_tests_file |
| from models import ActionsByName |
| from models import ArgEnum |
| from models import CoverageTest |
| from models import TestIdTestNameTuple |
| from models import TestPlatform |
| |
| TEST_DATA_DIR = os.path.join(os.path.dirname(os.path.abspath(__file__)), |
| "test_data") |
| |
| |
| class TestAnalysisTest(unittest.TestCase): |
| def test_markdown_file_mapping(self): |
| test_input = [ |
| "Test", "# Hello", "| #test |", "| ------- | Value |", |
| "| WML | Value | Value", " | ADF |" |
| ] |
| output = enumerate_markdown_file_lines_to_table_rows(test_input) |
| expected = [(4, ["WML", "Value", "Value"]), (5, ["ADF"])] |
| self.assertEqual(expected, output) |
| |
| def test_argument_combinations(self): |
| argument_types: List[ArgEnum] = [] |
| argument_types.append(ArgEnum("T1", ["T1V1", "T1V2"], None)) |
| argument_types.append(ArgEnum("T2", ["T2V1", "T2V2"], None)) |
| |
| combinations = enumerate_all_argument_combinations(argument_types) |
| |
| self.assertEqual([["T1V1", "T2V1"], ["T1V1", "T2V2"], ["T1V2", "T2V1"], |
| ["T1V2", "T2V2"]], combinations) |
| |
| def test_resolving_output_action_names(self): |
| self.assertEqual("Test", |
| resolve_bash_style_replacement("$1", ["Test"])) |
| self.assertEqual( |
| "Correct sentence! over over.", |
| resolve_bash_style_replacement("$1 $2ence! $3 $3.", |
| ["Correct", "sent", "over"])) |
| |
| def test_human_friendly_name_to_canonical_action_name(self): |
| self.assertEqual( |
| "action_with_arg1_arg2", |
| human_friendly_name_to_canonical_action_name( |
| "action_with(arg1, arg2)", {})) |
| self.assertEqual( |
| "action_with_arg1_arg2", |
| human_friendly_name_to_canonical_action_name( |
| "action_with", {"action_with": "arg1_arg2"})) |
| |
| def test_enums(self): |
| enums_file = os.path.join(TEST_DATA_DIR, "test_enums.md") |
| |
| with open(enums_file, "r", encoding="utf-8") \ |
| as enum_types: |
| enums = read_enums_file(enum_types.readlines()) |
| self.assertEqual(len(enums), 3) |
| self.assertIn("Animal", enums) |
| animal = enums["Animal"] |
| self.assertEqual("Animal", animal.type_name) |
| self.assertEqual(["Chicken", "Dog"], animal.values) |
| self.assertEqual("Chicken", animal.default_value) |
| |
| self.assertIn("AnimalLess", enums) |
| animal = enums["AnimalLess"] |
| self.assertEqual("AnimalLess", animal.type_name) |
| self.assertEqual(["Chicken"], animal.values) |
| self.assertEqual("Chicken", animal.default_value) |
| |
| self.assertIn("Color", enums) |
| color = enums["Color"] |
| self.assertEqual("Color", color.type_name) |
| self.assertEqual(["Green", "Red"], color.values) |
| self.assertEqual(None, color.default_value) |
| |
| def test_supported_actions(self): |
| supported_actions_filename = os.path.join( |
| TEST_DATA_DIR, "framework_supported_actions.csv") |
| |
| with open(supported_actions_filename, "r", encoding="utf-8") \ |
| as supported_actions: |
| supported = read_platform_supported_actions( |
| csv.reader(supported_actions, delimiter=',')) |
| self.assertEqual(len(supported), 4) |
| (check_a_partial, check_a_full) = supported["check_a"] |
| self.assertEqual(len(check_a_partial), 1) |
| self.assertEqual(len(check_a_full), 3) |
| (check_b_partial, check_b_full) = supported["check_b"] |
| self.assertEqual(len(check_b_partial), 1) |
| self.assertEqual(len(check_b_full), 3) |
| (state_change_a_partial, |
| state_change_a_full) = supported["state_change_a"] |
| self.assertEqual(len(state_change_a_partial), 0) |
| self.assertEqual(len(state_change_a_full), 4) |
| (state_change_b_partial, |
| state_change_b_full) = supported["state_change_b"] |
| self.assertEqual(len(state_change_b_partial), 0) |
| self.assertEqual(len(state_change_b_full), 3) |
| |
| def test_action_file_reading(self): |
| actions_filename = os.path.join(TEST_DATA_DIR, "test_actions.md") |
| supported_actions_filename = os.path.join( |
| TEST_DATA_DIR, "framework_supported_actions.csv") |
| enums_filename = os.path.join(TEST_DATA_DIR, "test_enums.md") |
| |
| with open(actions_filename, "r", encoding="utf-8") as f, \ |
| open(supported_actions_filename, "r", encoding="utf-8") \ |
| as supported_actions, \ |
| open (enums_filename, "r", encoding="utf-8") as enums: |
| supported_actions = read_platform_supported_actions( |
| csv.reader(supported_actions, delimiter=',')) |
| actions_tsv = f.readlines() |
| enums = read_enums_file(enums.readlines()) |
| |
| (actions, action_base_name_to_default_param) = read_actions_file( |
| actions_tsv, enums, supported_actions) |
| self.assertEqual(len(actions), 13) |
| self.assertEqual(len(action_base_name_to_default_param), 3) |
| |
| # Check Cpp methods |
| self.assertIn('check_b_Chicken_Green', actions) |
| self.assertEqual("CheckB(Animal::kChicken, Color::kGreen)", |
| actions['check_b_Chicken_Green'].cpp_method) |
| |
| # Check parameterized action state. |
| self.assertIn('changes_Chicken', actions) |
| self.assertIn('changes_Dog', actions) |
| self.assertTrue('checks' in actions) |
| checks_output_actions = actions['checks'].output_actions |
| self.assertEqual(len(checks_output_actions), 2) |
| self.assertCountEqual( |
| checks_output_actions, |
| [actions['check_a_Chicken'], actions['check_b_Chicken_Green']]) |
| |
| def test_coverage_file_reading(self): |
| actions_filename = os.path.join(TEST_DATA_DIR, "test_actions.md") |
| supported_actions_filename = os.path.join( |
| TEST_DATA_DIR, "framework_supported_actions.csv") |
| enums_filename = os.path.join(TEST_DATA_DIR, "test_enums.md") |
| |
| actions: ActionsByName = {} |
| action_base_name_to_default_param = {} |
| with open(actions_filename) as f, \ |
| open(supported_actions_filename, "r", encoding="utf-8") \ |
| as supported_actions, \ |
| open(enums_filename, "r", encoding="utf-8") as enums: |
| supported_actions = read_platform_supported_actions( |
| csv.reader(supported_actions, delimiter=',')) |
| actions_tsv = f.readlines() |
| enums = read_enums_file(enums.readlines()) |
| (actions, action_base_name_to_default_param) = read_actions_file( |
| actions_tsv, enums, supported_actions) |
| |
| coverage_filename = os.path.join(TEST_DATA_DIR, |
| "test_unprocessed_coverage.md") |
| coverage_tests: List[CoverageTest] = [] |
| with open(coverage_filename) as f: |
| coverage_tsv = f.readlines() |
| coverage_tests = read_unprocessed_coverage_tests_file( |
| coverage_tsv, actions, enums, |
| action_base_name_to_default_param) |
| self.assertEqual(6, len(coverage_tests)) |
| |
| def test_browsertest_detection(self): |
| browsertest_filename = os.path.join(TEST_DATA_DIR, "tests_default.cc") |
| tests_and_platforms = get_and_maybe_delete_tests_in_browsertest( |
| browsertest_filename) |
| expected_key = TestIdTestNameTuple( |
| "state_change_a_Chicken_check_a_Chicken_check_b_Chicken_Green", |
| "3Chicken_1Chicken_2ChickenGreen") |
| self.assertListEqual(list(tests_and_platforms.keys()), [expected_key]) |
| tests_and_platforms = tests_and_platforms[expected_key] |
| self.assertEqual( |
| {TestPlatform.LINUX, TestPlatform.CHROME_OS, TestPlatform.MAC}, |
| tests_and_platforms) |
| |
| def test_browertest_in_place_deletion(self): |
| input_file = os.path.join(TEST_DATA_DIR, "tests_for_deletion.cc") |
| after_deletion_file = os.path.join(TEST_DATA_DIR, "tests_default.cc") |
| with tempfile.TemporaryDirectory(dir=TEST_DATA_DIR) as tmpdirname: |
| output_file = os.path.join(tmpdirname, "output.cc") |
| shutil.copyfile(input_file, output_file) |
| tests_and_platforms = get_and_maybe_delete_tests_in_browsertest( |
| output_file, { |
| TestIdTestNameTuple( |
| "state_change_a_Chicken_check_a_Chicken_check_b_Chicken_Green", |
| "StateChangeAChicken") |
| }, |
| delete_in_place=True) |
| |
| with open(output_file, 'r') as f, open(after_deletion_file, |
| 'r') as f2: |
| self.assertTrue(f.read(), f2.read()) |
| |
| tests_and_platforms = tests_and_platforms[TestIdTestNameTuple( |
| "state_change_a_Chicken_check_a_Chicken_check_b_Chicken_Green", |
| "3Chicken_1Chicken_2ChickenGreen")] |
| self.assertEqual( |
| {TestPlatform.LINUX, TestPlatform.CHROME_OS, TestPlatform.MAC}, |
| tests_and_platforms) |
| |
| def test_action_param_expansion(self): |
| enum_map: Dict[str, ArgEnum] = { |
| "EnumType": ArgEnum("EnumType", ["Value1", "Value2"], None) |
| } |
| actions: List[str] = [ |
| "Action1(EnumType::All)", "Action2(EnumType::All, EnumType::All)" |
| ] |
| |
| combinations = expand_tests_from_action_parameter_wildcards( |
| enum_map, actions) |
| expected = [['Action1(Value1)', 'Action2(Value1, Value1)'], |
| ['Action1(Value2)', 'Action2(Value1, Value1)'], |
| ['Action1(Value1)', 'Action2(Value1, Value2)'], |
| ['Action1(Value2)', 'Action2(Value1, Value2)'], |
| ['Action1(Value1)', 'Action2(Value2, Value1)'], |
| ['Action1(Value2)', 'Action2(Value2, Value1)'], |
| ['Action1(Value1)', 'Action2(Value2, Value2)'], |
| ['Action1(Value2)', 'Action2(Value2, Value2)']] |
| self.assertCountEqual(combinations, expected) |
| |
| def test_generate_test_id_from_test_steps(self): |
| test_steps = [ |
| "helper_.StateChangeA(Animal::kChicken);", |
| "helper_.CheckB(Animal::kChicken, Color::kGreen);", |
| "helper_.StateChangeB();" |
| ] |
| test_id = generate_test_id_from_test_steps(test_steps) |
| expected_test_id = ( |
| "state_change_a_Chicken_check_b_Chicken_Green_state_change_b" |
| ) |
| self.assertEqual(test_id, expected_test_id) |
| |
| |
| if __name__ == '__main__': |
| unittest.main() |
