targets: Move file handling out of targets module

Author: rwalton-arm

src/mbed_tools/build/config.py

@@ -5,6 +5,7 @@
 """Parses the Mbed configuration system and generates a CMake config script."""
 import pathlib
 
+from mbed_tools.lib.json_helpers import decode_json_file
 from mbed_tools.project import MbedProgram
 from mbed_tools.targets import get_target_by_name
 from mbed_tools.build._internal.cmake_file import generate_mbed_config_cmake_file
@@ -23,7 +24,7 @@ def generate_config(target_name: str, toolchain: str, program: MbedProgram) -> p
     Returns:
         Path to the generated config file.
     """
-    target_build_attributes = get_target_by_name(target_name, program.mbed_os.targets_json_file)
+    target_build_attributes = get_target_by_name(target_name, decode_json_file(program.mbed_os.targets_json_file))
     config = assemble_config(target_build_attributes, program.root, program.files.app_config_file)
     cmake_file_contents = generate_mbed_config_cmake_file(target_name, target_build_attributes, config, toolchain)
     cmake_config_file_path = program.files.cmake_config_file

src/mbed_tools/targets/_internal/target_attributes.py

@@ -7,12 +7,11 @@
 This information is parsed from the targets.json configuration file
 found in the mbed-os repo.
 """
-import json
 import pathlib
-from json.decoder import JSONDecodeError
-from typing import Dict, Any, Set, Optional, cast
+from typing import Dict, Any, Set, Optional
 
 from mbed_tools.lib.exceptions import ToolsError
+from mbed_tools.lib.json_helpers import decode_json_file
 
 from mbed_tools.targets._internal.targets_json_parsers.accumulating_attribute_parser import (
     get_accumulating_attributes_for_target,
@@ -39,25 +38,22 @@ class TargetNotFoundError(TargetAttributesError):
     """Target definition not found in targets.json."""
 
 
-def get_target_attributes(path_to_targets_json: pathlib.Path, target_name: str) -> dict:
+def get_target_attributes(targets_json_data: dict, target_name: str) -> dict:
     """Retrieves attribute data taken from targets.json for a single target.
 
     Args:
-        path_to_targets_json: an absolute or relative path to the location of targets.json.
+        targets_json_data: target definitions from targets.json
         target_name: the name of the target (often a Board's board_type).
 
     Returns:
         A dictionary representation of the attributes for the target.
 
     Raises:
-        FileNotFoundError: path provided does not lead to targets.json
         ParsingTargetJSONError: error parsing targets.json
         TargetNotFoundError: there is no target attribute data found for that target.
     """
-    targets_json_path = path_to_targets_json
-    all_targets_data = _read_json_file(targets_json_path)
-    target_attributes = _extract_target_attributes(all_targets_data, target_name)
-    target_attributes["labels"] = get_labels_for_target(all_targets_data, target_name).union(
+    target_attributes = _extract_target_attributes(targets_json_data, target_name)
+    target_attributes["labels"] = get_labels_for_target(targets_json_data, target_name).union(
         _extract_core_labels(target_attributes.get("core", None))
     )
     target_attributes["extra_labels"] = set(target_attributes.get("extra_labels", []))
@@ -70,26 +66,6 @@ def get_target_attributes(path_to_targets_json: pathlib.Path, target_name: str)
     return target_attributes
 
 
-def _read_json_file(path_to_file: pathlib.Path) -> dict:
-    """Reads the data from a json file.
-
-    Args:
-        path_to_file: location of the json file.
-
-    Returns:
-        A dictionary representation of all the data in the json file.
-
-    Raises:
-        ParsingTargetJSONError: error parsing targets.json
-        FileNotFoundError: path provided does not lead to a valid json file
-    """
-    try:
-        # mypy doesn't recognise that json.loads always returns a dictionary
-        return cast(dict, json.loads(path_to_file.read_text()))
-    except JSONDecodeError as json_err:
-        raise ParsingTargetsJSONError(f"Invalid JSON found in '{path_to_file}'.") from json_err
-
-
 def _extract_target_attributes(all_targets_data: Dict[str, Any], target_name: str) -> dict:
     """Extracts the definition for a particular target from all the targets in targets.json.
 
@@ -127,7 +103,7 @@ def _extract_core_labels(target_core: Optional[str]) -> Set[str]:
         if either core is undefined or no labels found for the core.
     """
     if target_core:
-        mbed_os_metadata = _read_json_file(MBED_OS_METADATA_FILE)
+        mbed_os_metadata = decode_json_file(MBED_OS_METADATA_FILE)
         return set(mbed_os_metadata["CORE_LABELS"].get(target_core, []))
     return set()
 

src/mbed_tools/targets/get_target.py

@@ -7,40 +7,38 @@
 An instance of `mbed_tools.targets.target.Target`
 can be retrieved by calling one of the public functions.
 """
-import pathlib
-
 from mbed_tools.targets.exceptions import TargetError
 from mbed_tools.targets._internal import target_attributes
 
 
-def get_target_by_name(name: str, path_to_targets_json: pathlib.Path) -> dict:
+def get_target_by_name(name: str, targets_json_data: dict) -> dict:
     """Returns a dictionary of attributes for the target whose name matches the name given.
 
     The target is as defined in the targets.json file found in the Mbed OS library.
 
     Args:
         name: the name of the Target to be returned
-        path_to_targets_json: path to a targets.json file containing target definitions
+        targets_json_data: target definitions from targets.json
 
     Raises:
         TargetError: an error has occurred while fetching target
     """
     try:
-        return target_attributes.get_target_attributes(path_to_targets_json, name)
+        return target_attributes.get_target_attributes(targets_json_data, name)
     except (FileNotFoundError, target_attributes.TargetAttributesError) as e:
         raise TargetError(e) from e
 
 
-def get_target_by_board_type(board_type: str, path_to_targets_json: pathlib.Path) -> dict:
+def get_target_by_board_type(board_type: str, targets_json_data: dict) -> dict:
     """Returns the target whose name matches a board's build_type.
 
     The target is as defined in the targets.json file found in the Mbed OS library.
 
     Args:
         board_type: a board's board_type (see `mbed_tools.targets.board.Board`)
-        path_to_targets_json: path to a targets.json file containing target definitions
+        targets_json_data: target definitions from targets.json
 
     Raises:
         TargetError: an error has occurred while fetching target
     """
-    return get_target_by_name(board_type, path_to_targets_json)
+    return get_target_by_name(board_type, targets_json_data)

tests/targets/_internal/test_target_attributes.py

@@ -3,16 +3,12 @@
 # SPDX-License-Identifier: Apache-2.0
 #
 """Tests for `mbed_tools.targets.target_attributes`."""
-import pathlib
-import tempfile
 from unittest import TestCase, mock
 
 from mbed_tools.targets._internal.exceptions import TargetsJsonConfigurationError
 from mbed_tools.targets._internal.target_attributes import (
-    ParsingTargetsJSONError,
     TargetNotFoundError,
     get_target_attributes,
-    _read_json_file,
     _extract_target_attributes,
     _extract_core_labels,
     _apply_config_overrides,
@@ -55,64 +51,26 @@ def test_target_private(self):
             _extract_target_attributes(all_targets_data, "Target_1"),
 
 
-class TestReadTargetsJSON(TestCase):
-    def test_valid_path(self):
-        contents = """{
-            "Target_Name": {
-                "attribute_1": []
-            }
-        }"""
-        with tempfile.TemporaryDirectory() as directory:
-            json_file = pathlib.Path(directory, "targets.json")
-            json_file.write_text(contents)
-            result = _read_json_file(json_file)
-
-            self.assertEqual(type(result), dict)
-
-    def test_invalid_path(self):
-        json_file = pathlib.Path("i_dont_exist")
-
-        with self.assertRaises(FileNotFoundError):
-            _read_json_file(json_file)
-
-    def test_malformed_json(self):
-        contents = """{
-            "Target_Name": {
-                []
-            }
-        }"""
-        with tempfile.TemporaryDirectory() as directory:
-            json_file = pathlib.Path(directory, "targets.json")
-            json_file.write_text(contents)
-
-            with self.assertRaises(ParsingTargetsJSONError):
-                _read_json_file(json_file)
-
-
 class TestGetTargetAttributes(TestCase):
-    @mock.patch("mbed_tools.targets._internal.target_attributes._read_json_file")
     @mock.patch("mbed_tools.targets._internal.target_attributes._extract_target_attributes")
     @mock.patch("mbed_tools.targets._internal.target_attributes.get_labels_for_target")
     @mock.patch("mbed_tools.targets._internal.target_attributes._extract_core_labels")
-    def test_gets_attributes_for_target(
-        self, extract_core_labels, get_labels_for_target, extract_target_attributes, read_json_file
-    ):
-        targets_json_path = pathlib.Path("mbed-os/targets/targets.json")
+    def test_gets_attributes_for_target(self, extract_core_labels, get_labels_for_target, extract_target_attributes):
+        targets_json_data = {"attrs": "vals"}
         target_name = "My_Target"
         build_attributes = {"attribute": "value"}
         extract_target_attributes.return_value = build_attributes
 
-        result = get_target_attributes(targets_json_path, target_name)
+        result = get_target_attributes(targets_json_data, target_name)
 
-        read_json_file.assert_called_once_with(targets_json_path)
-        extract_target_attributes.assert_called_once_with(read_json_file.return_value, target_name)
-        get_labels_for_target.assert_called_once_with(read_json_file.return_value, target_name)
+        extract_target_attributes.assert_called_once_with(targets_json_data, target_name)
+        get_labels_for_target.assert_called_once_with(targets_json_data, target_name)
         extract_core_labels.assert_called_once_with(build_attributes.get("core", None))
         self.assertEqual(result, extract_target_attributes.return_value)
 
 
 class TestExtractCoreLabels(TestCase):
-    @mock.patch("mbed_tools.targets._internal.target_attributes._read_json_file")
+    @mock.patch("mbed_tools.targets._internal.target_attributes.decode_json_file")
     def test_extract_core(self, read_json_file):
         core_labels = ["FOO", "BAR"]
         metadata = {"CORE_LABELS": {"core_name": core_labels}}
@@ -127,7 +85,7 @@ def test_no_core(self):
         result = _extract_core_labels(None)
         self.assertEqual(result, set())
 
-    @mock.patch("mbed_tools.targets._internal.target_attributes._read_json_file")
+    @mock.patch("mbed_tools.targets._internal.target_attributes.decode_json_file")
     def test_no_labels(self, read_json_file):
         metadata = {"CORE_LABELS": {"not_the_same_core": []}}
         read_json_file.return_value = metadata