Updated Converter CLI. Added unit test(testCli.py).

Author: ft-lab

pyproject.toml

@@ -18,7 +18,7 @@ Repository = "https://github.com/newton-physics/urdf-usd-converter"
 Changelog = "https://github.com/newton-physics/urdf-usd-converter/blob/main/CHANGELOG.md"
 
 [project.scripts]
-urdf_usd_converter = "urdf_usd_converter.__main__:cli_main"
+urdf_usd_converter = "urdf_usd_converter.__main__:run"
 
 [dependency-groups]
 dev = [

tests/data/simple_box.urdf

@@ -0,0 +1,15 @@
+<?xml verison="1.0"?>
+<robot name="simple_box">
+  <material name="blue">
+    <color rgba="0.0 0.0 1.0 1.0"/>
+  </material>
+
+  <link name="link1">
+    <visual>
+      <geometry>
+        <box size="2.0 2.0 2.0"/>
+      </geometry>
+      <material name="blue"/>
+    </visual>
+  </link>
+</robot> 

tests/testCli.py

@@ -1,10 +1,116 @@
 # SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
 # SPDX-License-Identifier: Apache-2.0
+import pathlib
+import shutil
+from unittest.mock import patch
+
+import usdex.test
+from pxr import Tf
 
 from tests.util.ConverterTestCase import ConverterTestCase
+from urdf_usd_converter._impl.cli import run
 
 
 class TestCli(ConverterTestCase):
 
     def test_run(self):
-        pass  # dummy test for now
+        for robot in pathlib.Path("tests/data").glob("*.urdf"):
+            robot_name = robot.stem
+            with patch("sys.argv", ["urdf_usd_converter", str(robot), self.tmpDir()]):
+                self.assertEqual(run(), 0, f"Failed to convert {robot}")
+            self.assertTrue((pathlib.Path(self.tmpDir()) / f"{robot_name}.usda").exists())
+
+    # TODO: test_no_layer_structure, test_no_physics_scene, test_comment
+
+    def test_invalid_input(self):
+        with (
+            patch("sys.argv", ["urdf_usd_converter", "tests/data/invalid.xml", self.tmpDir()]),
+            usdex.test.ScopedDiagnosticChecker(self, [(Tf.TF_DIAGNOSTIC_WARNING_TYPE, "Input file does not exist.*")]),
+        ):
+            self.assertEqual(run(), 1, "Expected non-zero exit code for invalid input")
+
+    def test_invalid_output(self):
+        # create a file that is not a directory
+        pathlib.Path("tests/output").mkdir(parents=True, exist_ok=True)
+        pathlib.Path("tests/output/invalid").touch()
+        with (
+            patch("sys.argv", ["urdf_usd_converter", "tests/data/simple_box.urdf", "tests/output/invalid"]),
+            usdex.test.ScopedDiagnosticChecker(self, [(Tf.TF_DIAGNOSTIC_WARNING_TYPE, "Output path exists but is not a directory.*")]),
+        ):
+            self.assertEqual(run(), 1, "Expected non-zero exit code for invalid output")
+
+    def test_input_path_is_directory(self):
+        # Create a directory as input_file (should fail)
+        input_dir = pathlib.Path("tests/data/input_dir")
+        input_dir.mkdir(parents=True, exist_ok=True)
+        try:
+            with (
+                patch("sys.argv", ["urdf_usd_converter", str(input_dir), self.tmpDir()]),
+                usdex.test.ScopedDiagnosticChecker(self, [(Tf.TF_DIAGNOSTIC_WARNING_TYPE, "Input path is not a file.*")]),
+            ):
+                self.assertEqual(run(), 1, "Expected non-zero exit code for input path as directory")
+        finally:
+            shutil.rmtree(input_dir)
+
+    def test_input_file_not_xml(self):
+        # Create a non-xml file as input_file (should fail)
+        not_xml = pathlib.Path("tests/data/not_xml.txt")
+        not_xml.write_text("dummy content")
+        try:
+            with (
+                patch("sys.argv", ["urdf_usd_converter", str(not_xml), self.tmpDir()]),
+                usdex.test.ScopedDiagnosticChecker(self, [(Tf.TF_DIAGNOSTIC_WARNING_TYPE, "Only URDF.*are supported as input.*")]),
+            ):
+                self.assertEqual(run(), 1, "Expected non-zero exit code for non-xml input file")
+        finally:
+            not_xml.unlink()
+
+    def test_output_dir_cannot_create(self):
+        # Simulate output_dir.mkdir raising an exception (should fail)
+        robot = "tests/data/simple_box.urdf"
+        output_dir = pathlib.Path("tests/output/cannot_create")
+        with (
+            patch("pathlib.Path.mkdir", side_effect=OSError("Permission denied")),
+            patch("sys.argv", ["urdf_usd_converter", robot, str(output_dir)]),
+            usdex.test.ScopedDiagnosticChecker(self, [(Tf.TF_DIAGNOSTIC_WARNING_TYPE, "Failed to create output directory.*")]),
+        ):
+            self.assertEqual(run(), 1, "Expected non-zero exit code when output dir cannot be created")
+
+    def test_conversion_returns_none(self):
+        # Test the case where converter.convert() returns None/false value
+        robot = "tests/data/simple_box.urdf"
+        with (
+            patch("urdf_usd_converter.Converter.convert", return_value=None),
+            patch("sys.argv", ["urdf_usd_converter", robot, self.tmpDir()]),
+            usdex.test.ScopedDiagnosticChecker(
+                self,
+                [(Tf.TF_DIAGNOSTIC_WARNING_TYPE, "Conversion failed for unknown reason.*")],
+                level=usdex.core.DiagnosticsLevel.eWarning,
+            ),
+        ):
+            self.assertEqual(run(), 1, "Expected non-zero exit code when conversion returns None")
+
+    def test_conversion_exception_non_verbose(self):
+        # Test exception handling when verbose=False (should not re-raise)
+        robot = "tests/data/simple_box.urdf"
+        with (
+            patch("urdf_usd_converter.Converter.convert", side_effect=RuntimeError("Test conversion error")),
+            patch("sys.argv", ["urdf_usd_converter", robot, self.tmpDir()]),
+            usdex.test.ScopedDiagnosticChecker(
+                self,
+                [(Tf.TF_DIAGNOSTIC_WARNING_TYPE, "Conversion failed: Test conversion error.*")],
+                level=usdex.core.DiagnosticsLevel.eWarning,
+            ),
+        ):
+            self.assertEqual(run(), 1, "Expected non-zero exit code when conversion raises exception")
+
+    def test_conversion_exception_verbose(self):
+        # Test exception handling when verbose=True (should re-raise)
+        robot = "tests/data/simple_box.urdf"
+        with (
+            patch("urdf_usd_converter.Converter.convert", side_effect=RuntimeError("Test conversion error")),
+            patch("sys.argv", ["urdf_usd_converter", robot, self.tmpDir(), "--verbose"]),
+            self.assertRaises(RuntimeError),
+            usdex.test.ScopedDiagnosticChecker(self, [], level=usdex.core.DiagnosticsLevel.eWarning),
+        ):
+            run()

urdf_usd_converter/_impl/cli.py

@@ -78,7 +78,7 @@ def __create_parser() -> argparse.ArgumentParser:
         "output_dir",
         type=Path,
         help="""
-        Path to the output USD directory. The primary USD file will be <output_dir>/<modelname>.usda
+        Path to the output USD directory. The primary USD file will be <output_dir>/<robotname>.usda
         and it will be an Atomic Component with Asset Interface layer and payloaded contents
         (unless --no-layer-structure is used)
         """,

urdf_usd_converter/_impl/convert.py

@@ -3,7 +3,10 @@
 import pathlib
 from dataclasses import dataclass
 
-from pxr import Sdf, Tf
+import usdex.core
+from pxr import Sdf, Tf, UsdGeom
+
+from .utils import get_authoring_metadata
 
 __all__ = ["Converter"]
 
@@ -45,9 +48,16 @@ def convert(self, input_file: str, output_dir: str) -> Sdf.AssetPath:
         if not output_path.exists():
             output_path.mkdir(parents=True)
 
-        # TODO: Still a dummy.
         file_name = f"{input_file.stem}.usda"
         asset_identifier = str(output_dir / file_name)
-
         Tf.Status(f"Converting {input_path} into {output_path}")
+        asset_stage = usdex.core.createStage(
+            asset_identifier,
+            defaultPrimName="Robot",  # TODO: use parsed name
+            upAxis=UsdGeom.Tokens.z,
+            linearUnits=UsdGeom.LinearUnits.meters,
+            authoringMetadata=get_authoring_metadata(),
+        )
+        # TODO: implement core logic
+        usdex.core.saveStage(asset_stage, comment=self.params.comment)
         return Sdf.AssetPath(asset_identifier)

urdf_usd_converter/_impl/utils.py

@@ -0,0 +1,9 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+from .._version import __version__
+
+__all__ = ["get_authoring_metadata"]
+
+
+def get_authoring_metadata() -> str:
+    return f"URDF USD Converter v{__version__}"