chore: import upstream snapshot with attribution

libs/python/cua-cli/tests/commands/test_skills.py

@@ -0,0 +1,235 @@
+"""Tests for skills command module."""
+
+import argparse
+from unittest.mock import patch
+
+from cua_cli.commands import skills
+
+
+class TestRegisterParser:
+    """Tests for register_parser function."""
+
+    def test_registers_skills_command(self):
+        """Test that skills command is registered."""
+        parser = argparse.ArgumentParser()
+        subparsers = parser.add_subparsers()
+
+        skills.register_parser(subparsers)
+
+        args = parser.parse_args(["skills", "list"])
+        assert args.skills_command == "list"
+
+    def test_record_command_exists(self):
+        """Test that record command is registered."""
+        parser = argparse.ArgumentParser()
+        subparsers = parser.add_subparsers()
+        skills.register_parser(subparsers)
+
+        args = parser.parse_args(["skills", "record"])
+        assert args.skills_command == "record"
+
+    def test_record_command_has_sandbox_flag(self):
+        """Test that record command has --sandbox flag."""
+        parser = argparse.ArgumentParser()
+        subparsers = parser.add_subparsers()
+        skills.register_parser(subparsers)
+
+        args = parser.parse_args(["skills", "record", "--sandbox", "my-sandbox"])
+        assert args.sandbox == "my-sandbox"
+
+    def test_read_command_has_name_arg(self):
+        """Test that read command has name argument."""
+        parser = argparse.ArgumentParser()
+        subparsers = parser.add_subparsers()
+        skills.register_parser(subparsers)
+
+        args = parser.parse_args(["skills", "read", "my-skill"])
+        assert args.name == "my-skill"
+
+
+class TestExecute:
+    """Tests for execute function."""
+
+    def test_dispatch_to_list(self, args_namespace):
+        """Test dispatch to list command."""
+        args = args_namespace(command="skills", skills_command="list", json=False)
+
+        with patch.object(skills, "cmd_list", return_value=0) as mock_cmd:
+            result = skills.execute(args)
+
+        mock_cmd.assert_called_once_with(args)
+        assert result == 0
+
+    def test_dispatch_to_read(self, args_namespace):
+        """Test dispatch to read command."""
+        args = args_namespace(command="skills", skills_command="read", name="my-skill")
+
+        with patch.object(skills, "cmd_read", return_value=0) as mock_cmd:
+            skills.execute(args)
+
+        mock_cmd.assert_called_once_with(args)
+
+    def test_dispatch_to_delete(self, args_namespace):
+        """Test dispatch to delete command."""
+        args = args_namespace(command="skills", skills_command="delete", name="my-skill")
+
+        with patch.object(skills, "cmd_delete", return_value=0) as mock_cmd:
+            skills.execute(args)
+
+        mock_cmd.assert_called_once_with(args)
+
+    def test_unknown_command_returns_error(self, args_namespace):
+        """Test that unknown command returns error."""
+        args = args_namespace(command="skills", skills_command=None)
+
+        with patch.object(skills, "print_error"):
+            result = skills.execute(args)
+
+        assert result == 1
+
+
+class TestCmdList:
+    """Tests for cmd_list function."""
+
+    def test_list_empty_directory(self, args_namespace, temp_skills_dir):
+        """Test listing when no skills exist."""
+        args = args_namespace(json=False)
+
+        with patch.object(skills, "print_info") as mock_print:
+            result = skills.cmd_list(args)
+
+        assert result == 0
+        mock_print.assert_called()
+
+    def test_list_with_skills(self, args_namespace, sample_skill, temp_skills_dir):
+        """Test listing existing skills."""
+        args = args_namespace(json=False)
+
+        with patch.object(skills, "print_table") as mock_print:
+            result = skills.cmd_list(args)
+
+        assert result == 0
+        mock_print.assert_called_once()
+        # Verify the skill is in the output
+        call_args = mock_print.call_args[0]
+        skill_data = call_args[0]
+        assert len(skill_data) == 1
+        assert skill_data[0]["name"] == "test-skill"
+
+    def test_list_json_output(self, args_namespace, sample_skill, temp_skills_dir):
+        """Test JSON output format."""
+        args = args_namespace(json=True)
+
+        with patch.object(skills, "print_json") as mock_print:
+            result = skills.cmd_list(args)
+
+        assert result == 0
+        mock_print.assert_called_once()
+
+
+class TestCmdRead:
+    """Tests for cmd_read function."""
+
+    def test_read_existing_skill(self, args_namespace, sample_skill, temp_skills_dir, capsys):
+        """Test reading an existing skill."""
+        args = args_namespace(name="test-skill", format="md")
+
+        result = skills.cmd_read(args)
+
+        assert result == 0
+        # Verify content was printed to stdout
+        captured = capsys.readouterr()
+        assert "test-skill" in captured.out
+
+    def test_read_nonexistent_skill(self, args_namespace, temp_skills_dir):
+        """Test reading a nonexistent skill."""
+        args = args_namespace(name="nonexistent", format="md")
+
+        with patch.object(skills, "print_error") as mock_error:
+            result = skills.cmd_read(args)
+
+        assert result == 1
+        mock_error.assert_called()
+
+
+class TestCmdDelete:
+    """Tests for cmd_delete function."""
+
+    def test_delete_existing_skill(self, args_namespace, sample_skill, temp_skills_dir):
+        """Test deleting an existing skill."""
+        args = args_namespace(name="test-skill")
+
+        assert sample_skill.exists()
+
+        with patch.object(skills, "print_success"):
+            result = skills.cmd_delete(args)
+
+        assert result == 0
+        assert not sample_skill.exists()
+
+    def test_delete_nonexistent_skill(self, args_namespace, temp_skills_dir):
+        """Test deleting a nonexistent skill."""
+        args = args_namespace(name="nonexistent")
+
+        with patch.object(skills, "print_error") as mock_error:
+            result = skills.cmd_delete(args)
+
+        assert result == 1
+        mock_error.assert_called()
+
+
+class TestCmdClean:
+    """Tests for cmd_clean function."""
+
+    def test_clean_removes_all_skills(self, args_namespace, sample_skill, temp_skills_dir):
+        """Test that clean removes all skills."""
+        args = args_namespace()
+
+        assert sample_skill.exists()
+
+        with patch("builtins.input", return_value="y"):
+            with patch.object(skills, "print_success"):
+                result = skills.cmd_clean(args)
+
+        assert result == 0
+        # Verify no skills remain
+        remaining = list(temp_skills_dir.iterdir())
+        assert len(remaining) == 0
+
+    def test_clean_empty_directory(self, args_namespace, temp_skills_dir):
+        """Test clean on empty directory."""
+        args = args_namespace()
+
+        with patch.object(skills, "print_info"):
+            result = skills.cmd_clean(args)
+
+        assert result == 0
+
+
+class TestCmdReplay:
+    """Tests for cmd_replay function."""
+
+    def test_replay_existing_skill(
+        self, args_namespace, sample_skill, temp_skills_dir, mock_webbrowser
+    ):
+        """Test replaying an existing skill opens the video."""
+        args = args_namespace(name="test-skill")
+
+        with patch.object(skills, "print_info"):
+            result = skills.cmd_replay(args)
+
+        assert result == 0
+        # Verify webbrowser was called with the video path
+        mock_webbrowser.assert_called_once()
+        call_url = mock_webbrowser.call_args[0][0]
+        assert "test-skill.mp4" in call_url
+
+    def test_replay_nonexistent_skill(self, args_namespace, temp_skills_dir):
+        """Test replaying a nonexistent skill."""
+        args = args_namespace(name="nonexistent")
+
+        with patch.object(skills, "print_error") as mock_error:
+            result = skills.cmd_replay(args)
+
+        assert result == 1
+        mock_error.assert_called()