machine-dialect 0.1.0a1__py3-none-any.whl

machine_dialect/cfg/tests/test_cfg_parser.py

@@ -0,0 +1,252 @@
+"""Tests for the CFG parser."""
+
+import pytest
+
+from machine_dialect.cfg import CFGParser
+
+
+class TestCFGParser:
+    """Test the CFG parser for Machine Dialect™."""
+
+    def setup_method(self) -> None:
+        """Set up test fixtures."""
+        self.parser = CFGParser()
+
+    def test_parse_set_statement(self) -> None:
+        """Test parsing Set statements."""
+        code = "Set `x` to _10_."
+        tree = self.parser.parse(code)
+        assert tree is not None
+        assert tree.data == "start"
+
+    def test_parse_give_back_statement(self) -> None:
+        """Test parsing Give back statements."""
+        code = 'Give back _"Hello, World!"_.'
+        tree = self.parser.parse(code)
+        assert tree is not None
+
+    def test_parse_arithmetic_expression(self) -> None:
+        """Test parsing arithmetic expressions."""
+        code = "Set `result` to _5_ + _3_ * _2_."
+        tree = self.parser.parse(code)
+        assert tree is not None
+
+    def test_parse_logical_expression(self) -> None:
+        """Test parsing logical expressions."""
+        code = "Set `flag` to _yes_ and not _yes_ or _yes_."
+        tree = self.parser.parse(code)
+        assert tree is not None
+
+    def test_parse_comparison(self) -> None:
+        """Test parsing comparison expressions."""
+        test_cases = [
+            "Set `check` to `x` > _5_.",
+            "Set `check` to `y` is greater than _10_.",
+            "Set `check` to `z` equals _0_.",
+            "Set `check` to `a` is not equal to `b`.",
+        ]
+
+        for code in test_cases:
+            tree = self.parser.parse(code)
+            assert tree is not None
+
+    def test_parse_if_statement(self) -> None:
+        """Test parsing if statements."""
+        code = """If `x` > _0_ then:
+> Give back _"Positive"_."""
+        tree = self.parser.parse(code)
+        assert tree is not None
+
+    def test_parse_if_else_statement(self) -> None:
+        """Test parsing if-else statements."""
+        code = """If `age` >= _18_ then:
+> Give back _"Adult"_.
+Else:
+> Give back _"Minor"_."""
+        tree = self.parser.parse(code)
+        assert tree is not None
+
+    def test_parse_multiple_statements(self) -> None:
+        """Test parsing multiple statements."""
+        code = """Set `x` to _10_.
+Set `y` to _20_.
+Set `sum` to `x` + `y`.
+Give back `sum`."""
+        tree = self.parser.parse(code)
+        assert tree is not None
+
+    def test_parse_nested_expressions(self) -> None:
+        """Test parsing nested expressions."""
+        code = "Set `result` to (_5_ + _3_) * (_10_ - _2_)."
+        tree = self.parser.parse(code)
+        assert tree is not None
+
+    def test_parse_string_literals(self) -> None:
+        """Test parsing string literals."""
+        test_cases = [
+            'Give back _"Hello"_.',
+            "Give back _'World'_.",
+            'Give back _"Machine Dialect™!"_.',
+        ]
+
+        for code in test_cases:
+            tree = self.parser.parse(code)
+            assert tree is not None
+
+    def test_parse_boolean_literals(self) -> None:
+        """Test parsing boolean literals."""
+        test_cases = [
+            "Set `flag` to _yes_.",
+            "Set `flag` to _no_.",
+        ]
+
+        for code in test_cases:
+            tree = self.parser.parse(code)
+            assert tree is not None
+
+    def test_parse_empty_literal(self) -> None:
+        """Test parsing empty literal."""
+        code = "Set `value` to _empty_."
+        tree = self.parser.parse(code)
+        assert tree is not None
+
+    def test_validate_valid_code(self) -> None:
+        """Test validation of valid code."""
+        code = "Set `x` to _5_."
+        assert self.parser.validate(code) is True
+
+    def test_validate_invalid_code(self) -> None:
+        """Test validation of invalid code."""
+        code = "Set `x` to 5"  # Missing underscores and period
+        assert self.parser.validate(code) is False
+
+    def test_case_insensitive_keywords(self) -> None:
+        """Test that keywords are case-insensitive."""
+        test_cases = [
+            "set `x` to _5_.",
+            "SET `x` to _5_.",
+            "Set `x` TO _5_.",
+            'give back _"Hello"_.',
+            'GIVE BACK _"Hello"_.',
+            'If `x` > _0_ then:\n> Give back _"Yes"_.',
+        ]
+
+        for code in test_cases:
+            tree = self.parser.parse(code)
+            assert tree is not None
+
+    def test_complex_program(self) -> None:
+        """Test parsing a complex program."""
+        code = """Set `score` to _85_.
+Set `passing_grade` to _60_.
+Set `is_excellent` to `score` >= _90_.
+If `score` >= `passing_grade` then:
+> If `is_excellent` then:
+> > Give back _"Excellent work!"_.
+> Else:
+> > Give back _"Good job, you passed."_.
+Else:
+> Give back _"Please try again."_."""
+        tree = self.parser.parse(code)
+        assert tree is not None
+
+    def test_identifier_with_underscores(self) -> None:
+        """Test parsing identifiers with underscores."""
+        code = 'Set `user_name` to _"Alice"_.'
+        tree = self.parser.parse(code)
+        assert tree is not None
+
+    def test_natural_language_operators(self) -> None:
+        """Test parsing natural language operators."""
+        test_cases = [
+            "Set `check` to `x` is equal to `y`.",
+            "Set `check` to `a` is not equal to `b`.",
+            "Set `check` to `m` is less than `n`.",
+            "Set `check` to `p` is greater than `q`.",
+        ]
+
+        for code in test_cases:
+            tree = self.parser.parse(code)
+            assert tree is not None
+
+    def test_strict_equality_operators(self) -> None:
+        """Test parsing strict equality operators."""
+        test_cases = [
+            "Give back _5_ is strictly equal to _5_.",
+            "Give back _5_ is not strictly equal to _5.0_.",
+            "Give back _5_ is exactly equal to _5_.",
+            "Give back _5_ is not exactly equal to _5.0_.",
+            "Give back _5_ is identical to _5_.",
+            "Give back _5_ is not identical to _5.0_.",
+        ]
+
+        for code in test_cases:
+            tree = self.parser.parse(code)
+            assert tree is not None
+
+    def test_float_literals(self) -> None:
+        """Test parsing float literals."""
+        test_cases = [
+            "Set `pi` to _3.14_.",
+            "Give back _2.5_ + _1.5_.",
+            "Set `result` to _10.0_ / _3.0_.",
+        ]
+
+        for code in test_cases:
+            tree = self.parser.parse(code)
+            assert tree is not None
+
+    def test_use_statement(self) -> None:
+        """Test parsing Use statements."""
+        code = 'Use `print` with _"Hello"_, _42_.'
+        tree = self.parser.parse(code)
+        assert tree is not None
+
+    @pytest.mark.skip(reason="Actions not yet implemented in main parser")
+    def test_action_statement(self) -> None:
+        """Test parsing Action statements with inputs, outputs, and body."""
+        # Action with parameters and Say statement
+        code = """Action make_noise with `sound` as Text, `volume` as Number = _60_:
+> Set `noise` to `sound`.
+> Say `noise`."""
+        tree = self.parser.parse(code)
+        assert tree is not None
+
+    @pytest.mark.skip(reason="Actions with complex syntax not yet implemented")
+    def test_action_with_markdown_format(self) -> None:
+        """Test parsing Action in markdown documentation format."""
+        # This represents the full markdown format with details tags
+        # The parser would need to handle this documentation-style format
+        code = """Action `make noise`:
+<details>
+<summary>Emits the sound of the alarm.</summary>
+
+> Set `noise` to _"WEE-OO WEE-OO WEE-OO"_.
+> Say `noise`.
+
+</details>"""
+        tree = self.parser.parse(code)
+        assert tree is not None
+
+    @pytest.mark.skip(reason="Interactions not yet implemented in main parser")
+    def test_interaction_statement(self) -> None:
+        """Test parsing Interaction statements."""
+        code = """Interaction turn_alarm_off:
+> If `alarm_is_on` then:
+> > Set `alarm_is_on` to _no_.
+> > Say _"Alarm has been turned off"_."""
+        tree = self.parser.parse(code)
+        assert tree is not None
+
+    @pytest.mark.skip(reason="Say statements not yet implemented in main parser")
+    def test_say_statement(self) -> None:
+        """Test parsing Say statements (used in actions/interactions)."""
+        test_cases = [
+            'Say _"Hello, World!"_.',
+            "Say `noise`.",
+            'Say _"Alarm is "_ + `status` + _"."_.',
+        ]
+
+        for code in test_cases:
+            tree = self.parser.parse(code)
+            assert tree is not None

machine_dialect/cfg/tests/test_config.py

@@ -0,0 +1,188 @@
+"""Tests for the configuration module."""
+
+import os
+import tempfile
+from pathlib import Path
+from unittest.mock import patch
+
+from machine_dialect.cfg.config import AIAPIConfig, ConfigLoader, get_ai_config
+
+
+class TestAIAPIConfig:
+    """Test AIAPIConfig dataclass."""
+
+    def test_is_valid_with_both_fields(self) -> None:
+        """Test is_valid returns True when both fields are set."""
+        config = AIAPIConfig(model="gpt-4o", key="test-key")
+        assert config.is_valid() is True
+
+    def test_is_valid_with_missing_model(self) -> None:
+        """Test is_valid returns False when model is missing."""
+        config = AIAPIConfig(key="test-key")
+        assert config.is_valid() is False
+
+    def test_is_valid_with_missing_key(self) -> None:
+        """Test is_valid returns False when key is missing."""
+        config = AIAPIConfig(model="gpt-4o")
+        assert config.is_valid() is False
+
+    def test_is_valid_with_both_missing(self) -> None:
+        """Test is_valid returns False when both fields are missing."""
+        config = AIAPIConfig()
+        assert config.is_valid() is False
+
+
+class TestConfigLoader:
+    """Test ConfigLoader class."""
+
+    def test_load_from_config_file(self) -> None:
+        """Test loading configuration from .mdconfig file."""
+        with tempfile.TemporaryDirectory() as tmpdir:
+            config_file = Path(tmpdir) / ".mdconfig"
+            config_file.write_text(
+                """[ai-api]
+model = gpt-4o-mini
+key = test-api-key-123
+"""
+            )
+
+            with patch.object(Path, "home", return_value=Path(tmpdir)):
+                loader = ConfigLoader()
+                config = loader.load()
+
+                assert config.model == "gpt-4o-mini"
+                assert config.key == "test-api-key-123"
+
+    def test_load_from_environment_variables(self) -> None:
+        """Test loading configuration from environment variables."""
+        with patch.dict(os.environ, {"MD_AI_API_MODEL": "gpt-4-turbo", "MD_AI_API_KEY": "env-key-456"}):
+            with patch.object(Path, "exists", return_value=False):
+                loader = ConfigLoader()
+                config = loader.load()
+
+                assert config.model == "gpt-4-turbo"
+                assert config.key == "env-key-456"
+
+    def test_environment_overrides_file_partially(self) -> None:
+        """Test that environment variables can override file config partially."""
+        with tempfile.TemporaryDirectory() as tmpdir:
+            config_file = Path(tmpdir) / ".mdconfig"
+            config_file.write_text(
+                """[ai-api]
+model = gpt-3.5-turbo
+key = file-key
+"""
+            )
+
+            with patch.object(Path, "home", return_value=Path(tmpdir)):
+                with patch.dict(os.environ, {"MD_AI_API_MODEL": "gpt-4o"}):
+                    loader = ConfigLoader()
+                    config = loader.load()
+
+                    # Model from env, key from file
+                    assert config.model == "gpt-4o"
+                    assert config.key == "file-key"
+
+    def test_legacy_openai_key_fallback(self) -> None:
+        """Test fallback to OPENAI_API_KEY for backward compatibility."""
+        with patch.dict(os.environ, {"OPENAI_API_KEY": "legacy-key-789"}):
+            with patch.object(Path, "exists", return_value=False):
+                loader = ConfigLoader()
+                config = loader.load()
+
+                assert config.key == "legacy-key-789"
+                assert config.model is None  # No model specified
+
+    def test_md_key_overrides_openai_key(self) -> None:
+        """Test that MD_AI_API_KEY takes precedence over OPENAI_API_KEY."""
+        with patch.dict(os.environ, {"MD_AI_API_KEY": "new-key", "OPENAI_API_KEY": "old-key"}):
+            with patch.object(Path, "exists", return_value=False):
+                loader = ConfigLoader()
+                config = loader.load()
+
+                assert config.key == "new-key"
+
+    def test_missing_config_section(self) -> None:
+        """Test handling of missing [ai-api] section in config file."""
+        with tempfile.TemporaryDirectory() as tmpdir:
+            config_file = Path(tmpdir) / ".mdconfig"
+            config_file.write_text(
+                """[other-section]
+some = value
+"""
+            )
+
+            with patch.object(Path, "home", return_value=Path(tmpdir)):
+                loader = ConfigLoader()
+                config = loader.load()
+
+                assert config.model is None
+                assert config.key is None
+
+    def test_empty_config_file(self) -> None:
+        """Test handling of empty config file."""
+        with tempfile.TemporaryDirectory() as tmpdir:
+            config_file = Path(tmpdir) / ".mdconfig"
+            config_file.write_text("")
+
+            with patch.object(Path, "home", return_value=Path(tmpdir)):
+                loader = ConfigLoader()
+                config = loader.load()
+
+                assert config.model is None
+                assert config.key is None
+
+    def test_get_error_message(self) -> None:
+        """Test error message generation."""
+        loader = ConfigLoader()
+        error_msg = loader.get_error_message()
+
+        assert "AI API configuration not found" in error_msg
+        assert ".mdconfig" in error_msg
+        assert "MD_AI_API_MODEL" in error_msg
+        assert "MD_AI_API_KEY" in error_msg
+        assert "OPENAI_API_KEY" in error_msg
+
+    def test_config_caching(self) -> None:
+        """Test that configuration is cached after first load."""
+        with tempfile.TemporaryDirectory() as tmpdir:
+            config_file = Path(tmpdir) / ".mdconfig"
+            config_file.write_text(
+                """[ai-api]
+model = gpt-4o
+key = test-key
+"""
+            )
+
+            with patch.object(Path, "home", return_value=Path(tmpdir)):
+                loader = ConfigLoader()
+                config1 = loader.load()
+
+                # Modify the file
+                config_file.write_text(
+                    """[ai-api]
+model = different-model
+key = different-key
+"""
+                )
+
+                # Should still get cached config
+                config2 = loader.load()
+
+                assert config1.model == config2.model
+                assert config1.key == config2.key
+                assert config2.model == "gpt-4o"
+
+
+class TestGetAIConfig:
+    """Test the convenience function get_ai_config."""
+
+    def test_get_ai_config(self) -> None:
+        """Test that get_ai_config returns a valid config."""
+        with patch.dict(os.environ, {"MD_AI_API_MODEL": "test-model", "MD_AI_API_KEY": "test-key"}):
+            with patch.object(Path, "exists", return_value=False):
+                config = get_ai_config()
+
+                assert isinstance(config, AIAPIConfig)
+                assert config.model == "test-model"
+                assert config.key == "test-key"