python2mobile 1.0.1__py3-none-any.whl

tests/test_build_test_gate.py

@@ -0,0 +1,150 @@
+"""
+Tests for the `p2m build` test-gate step.
+
+Verifies that:
+- build aborts when tests/ contains failing tests
+- build proceeds when tests/ passes (or is absent)
+- --skip-tests bypasses the gate
+- --help exposes the new flag
+
+All subprocess tests run in a minimal temp project dir to avoid touching
+the framework's own test suite.
+"""
+
+import subprocess
+import sys
+import textwrap
+from pathlib import Path
+
+import pytest
+
+_TOML = textwrap.dedent("""\
+    [project]
+    name = "test_proj"
+    version = "0.1.0"
+    entry = "main.py"
+    [build]
+    target = ["android"]
+    generator = "flutter"
+    llm_provider = "openai"
+    llm_model = "gpt-4o"
+    output_dir = "./build"
+    cache = false
+    [devserver]
+    port = 3000
+    hot_reload = true
+    mobile_frame = true
+    [style]
+    system = "tailwind"
+""")
+
+_MAIN_PY = textwrap.dedent("""\
+    from p2m.core import Render
+    from p2m.ui import Column, Text
+
+    def create_view():
+        root = Column()
+        root.add(Text("Hello"))
+        return root.build()
+
+    def main():
+        Render.execute(create_view)
+""")
+
+
+def _make_project(tmp_path: Path, test_content: str = None) -> Path:
+    (tmp_path / "p2m.toml").write_text(_TOML)
+    (tmp_path / "main.py").write_text(_MAIN_PY)
+    if test_content is not None:
+        tests_dir = tmp_path / "tests"
+        tests_dir.mkdir()
+        (tests_dir / "__init__.py").write_text("")
+        (tests_dir / "test_app.py").write_text(test_content)
+    return tmp_path
+
+
+def _build(tmp_path: Path, *extra_args):
+    """Invoke `python -m p2m.cli build` in *tmp_path* and return CompletedProcess."""
+    return subprocess.run(
+        [sys.executable, "-m", "p2m.cli", "build", *extra_args],
+        capture_output=True, text=True, cwd=str(tmp_path),
+    )
+
+
+# ── Help flag ─────────────────────────────────────────────────────────────────
+
+class TestBuildHelp:
+    def test_skip_tests_flag_in_help(self):
+        proc = subprocess.run(
+            ["p2m", "build", "--help"], capture_output=True, text=True
+        )
+        assert proc.returncode == 0
+        assert "--skip-tests" in proc.stdout
+
+    def test_skip_validation_still_present(self):
+        proc = subprocess.run(
+            ["p2m", "build", "--help"], capture_output=True, text=True
+        )
+        assert "--skip-validation" in proc.stdout
+
+
+# ── Test gate behaviour ───────────────────────────────────────────────────────
+
+class TestBuildTestGate:
+    def test_failing_tests_abort_build(self, tmp_path):
+        _make_project(tmp_path, test_content="def test_fail():\n    assert False\n")
+        proc = _build(tmp_path, "--skip-validation", "--target", "flutter")
+        assert proc.returncode != 0
+        combined = proc.stdout + proc.stderr
+        assert "Tests failed" in combined
+
+    def test_failing_tests_message_mentions_skip_tests(self, tmp_path):
+        _make_project(tmp_path, test_content="def test_fail():\n    assert False\n")
+        proc = _build(tmp_path, "--skip-validation", "--target", "flutter")
+        combined = proc.stdout + proc.stderr
+        assert "--skip-tests" in combined
+
+    def test_passing_tests_allow_build(self, tmp_path):
+        _make_project(tmp_path, test_content="def test_ok():\n    assert True\n")
+        proc = _build(tmp_path, "--skip-validation", "--target", "flutter")
+        combined = proc.stdout + proc.stderr
+        assert "Tests failed" not in combined
+        assert "All tests passed" in combined
+
+    def test_no_tests_dir_warns_and_continues(self, tmp_path):
+        _make_project(tmp_path, test_content=None)  # no tests/ dir
+        proc = _build(tmp_path, "--skip-validation", "--target", "flutter")
+        combined = proc.stdout + proc.stderr
+        assert "No tests/" in combined or "skipping tests" in combined
+
+    def test_skip_tests_bypasses_failing_tests(self, tmp_path):
+        _make_project(tmp_path, test_content="def test_fail():\n    assert False\n")
+        proc = _build(tmp_path, "--skip-validation", "--skip-tests", "--target", "flutter")
+        combined = proc.stdout + proc.stderr
+        assert "Tests failed" not in combined
+
+
+# ── Ordering ─────────────────────────────────────────────────────────────────
+
+class TestBuildOrder:
+    def test_validation_runs_before_tests(self, tmp_path):
+        """Syntax error in main.py → validation fires before tests run."""
+        (tmp_path / "p2m.toml").write_text(_TOML)
+        (tmp_path / "main.py").write_text("def create_view(\n")  # syntax error
+        tests_dir = tmp_path / "tests"
+        tests_dir.mkdir()
+        (tests_dir / "__init__.py").write_text("")
+        (tests_dir / "test_app.py").write_text("def test_fail():\n    assert False\n")
+
+        proc = _build(tmp_path, "--target", "flutter")
+        combined = proc.stdout + proc.stderr
+        assert "Validation failed" in combined
+        assert "Running unit tests" not in combined
+
+    def test_tests_run_after_validation(self, tmp_path):
+        """With passing tests, 'Running unit tests' appears after validation passes."""
+        _make_project(tmp_path, test_content="def test_ok():\n    assert True\n")
+        proc = _build(tmp_path, "--skip-validation", "--target", "flutter")
+        combined = proc.stdout + proc.stderr
+        assert "Running unit tests" in combined
+        assert "All tests passed" in combined

tests/test_carousel_modal.py

@@ -0,0 +1,84 @@
+"""
+Tests for Carousel component and Modal display:none fix.
+"""
+
+import pytest
+from p2m.ui import Carousel, Modal, Text, Column
+from p2m.core.render_engine import RenderEngine
+
+
+def _html(component):
+    return RenderEngine().render_content(component.build())
+
+
+class TestCarousel:
+    def test_carousel_build_type(self):
+        c = Carousel()
+        tree = c.build()
+        assert tree["type"] == "Carousel"
+
+    def test_carousel_in_tag_map(self):
+        """Carousel maps to <div> in the render engine."""
+        html = _html(Carousel(class_="px-4"))
+        assert "<div" in html
+
+    def test_carousel_renders_horizontal_scroll(self):
+        html = _html(Carousel())
+        assert "overflow-x:auto" in html
+
+    def test_carousel_has_flex_row(self):
+        html = _html(Carousel())
+        assert "flex-direction:row" in html
+
+    def test_carousel_children_rendered(self):
+        c = Carousel()
+        c.add(Text("Item A"))
+        c.add(Text("Item B"))
+        html = _html(c)
+        assert "Item A" in html
+        assert "Item B" in html
+
+    def test_carousel_class_applied(self):
+        html = _html(Carousel(class_="px-4 gap-2"))
+        # px-4 → padding-left:1rem; padding-right:1rem;
+        assert "padding-left:1rem" in html
+
+    def test_carousel_webkit_scrolling(self):
+        html = _html(Carousel())
+        assert "-webkit-overflow-scrolling:touch" in html
+
+
+class TestModalDisplayNone:
+    def test_modal_visible_no_display_none(self):
+        html = _html(Modal(visible=True, class_="fixed inset-0"))
+        assert "display:none" not in html
+
+    def test_modal_hidden_has_display_none(self):
+        html = _html(Modal(visible=False))
+        assert "display:none" in html
+
+    def test_modal_no_duplicate_style_attr(self):
+        """Regression: Modal(visible=False) must not produce two style= attrs."""
+        html = _html(Modal(visible=False, class_="fixed inset-0"))
+        assert html.count("style=") == 1
+
+    def test_modal_visible_with_class_styles(self):
+        """visible=True + class should still render class styles."""
+        html = _html(Modal(visible=True, class_="fixed inset-0"))
+        # fixed → position:fixed; inset-0 → top:0; right:0; bottom:0; left:0;
+        assert "position:fixed" in html
+
+    def test_modal_hidden_with_class_and_display_none(self):
+        """visible=False merges class styles with display:none in one style=."""
+        html = _html(Modal(visible=False, class_="fixed inset-0"))
+        assert "position:fixed" in html
+        assert "display:none" in html
+        assert html.count("style=") == 1
+
+    def test_modal_children_hidden(self):
+        """Children are still in the DOM (just hidden via CSS)."""
+        m = Modal(visible=False)
+        m.add(Text("Secret content"))
+        html = _html(m)
+        assert "Secret content" in html
+        assert "display:none" in html

tests/test_config_system.py

@@ -0,0 +1,272 @@
+"""
+Test suite for P2M configuration system
+"""
+
+import sys
+import tempfile
+from pathlib import Path
+
+# Add project to path
+sys.path.insert(0, str(Path(__file__).parent.parent))
+
+from p2m.config import Config, ProjectConfig, BuildConfig, DevServerConfig, StyleConfig, LLMConfig
+
+
+def test_default_config():
+    """Test default configuration"""
+    print("\n🧪 Test 1: Default Configuration")
+    
+    try:
+        config = Config()
+        
+        assert config.project is not None
+        assert config.project.name == "MyApp"
+        assert config.project.version == "0.1.0"
+        assert config.project.entry == "main.py"
+        
+        assert config.build is not None
+        assert config.build.generator == "flutter"
+        assert config.build.llm_provider == "openai"
+        
+        assert config.devserver is not None
+        assert config.devserver.port == 3000
+        assert config.devserver.hot_reload == True
+        
+        print("✅ Default config test passed")
+        return True
+    except Exception as e:
+        print(f"❌ Default config test failed: {e}")
+        import traceback
+        traceback.print_exc()
+        return False
+
+
+def test_config_save_and_load():
+    """Test saving and loading configuration"""
+    print("\n🧪 Test 2: Config Save and Load")
+    
+    try:
+        with tempfile.TemporaryDirectory() as tmpdir:
+            config_path = Path(tmpdir) / "p2m.toml"
+            
+            # Create and save config
+            config = Config()
+            config.project.name = "TestApp"
+            config.project.version = "1.0.0"
+            config.build.generator = "react-native"
+            config.save(str(config_path))
+            
+            assert config_path.exists()
+            
+            # Load config
+            loaded_config = Config(str(config_path))
+            
+            assert loaded_config.project.name == "TestApp"
+            assert loaded_config.project.version == "1.0.0"
+            assert loaded_config.build.generator == "react-native"
+            
+            print("✅ Config save and load test passed")
+            return True
+    except Exception as e:
+        print(f"❌ Config save and load test failed: {e}")
+        import traceback
+        traceback.print_exc()
+        return False
+
+
+def test_llm_config():
+    """Test LLM configuration"""
+    print("\n🧪 Test 3: LLM Configuration")
+    
+    try:
+        config = Config()
+        
+        llm_config = config.get_llm_config()
+        
+        assert llm_config is not None
+        assert llm_config.provider == "openai"
+        assert llm_config.model == "gpt-4o"
+        
+        print("✅ LLM config test passed")
+        return True
+    except Exception as e:
+        print(f"❌ LLM config test failed: {e}")
+        import traceback
+        traceback.print_exc()
+        return False
+
+
+def test_project_config_dataclass():
+    """Test ProjectConfig dataclass"""
+    print("\n🧪 Test 4: ProjectConfig Dataclass")
+    
+    try:
+        project = ProjectConfig(
+            name="MyProject",
+            version="0.2.0",
+            entry="app.py"
+        )
+        
+        assert project.name == "MyProject"
+        assert project.version == "0.2.0"
+        assert project.entry == "app.py"
+        
+        print("✅ ProjectConfig dataclass test passed")
+        return True
+    except Exception as e:
+        print(f"❌ ProjectConfig dataclass test failed: {e}")
+        import traceback
+        traceback.print_exc()
+        return False
+
+
+def test_build_config_dataclass():
+    """Test BuildConfig dataclass"""
+    print("\n🧪 Test 5: BuildConfig Dataclass")
+    
+    try:
+        build = BuildConfig(
+            target=["android", "ios", "web"],
+            generator="react-native",
+            llm_provider="anthropic",
+            llm_model="claude-3-opus-20240229",
+            output_dir="./dist",
+            cache=True
+        )
+        
+        assert build.target == ["android", "ios", "web"]
+        assert build.generator == "react-native"
+        assert build.llm_provider == "anthropic"
+        assert build.cache == True
+        
+        print("✅ BuildConfig dataclass test passed")
+        return True
+    except Exception as e:
+        print(f"❌ BuildConfig dataclass test failed: {e}")
+        import traceback
+        traceback.print_exc()
+        return False
+
+
+def test_devserver_config_dataclass():
+    """Test DevServerConfig dataclass"""
+    print("\n🧪 Test 6: DevServerConfig Dataclass")
+    
+    try:
+        devserver = DevServerConfig(
+            port=8000,
+            hot_reload=True,
+            mobile_frame=False
+        )
+        
+        assert devserver.port == 8000
+        assert devserver.hot_reload == True
+        assert devserver.mobile_frame == False
+        
+        print("✅ DevServerConfig dataclass test passed")
+        return True
+    except Exception as e:
+        print(f"❌ DevServerConfig dataclass test failed: {e}")
+        import traceback
+        traceback.print_exc()
+        return False
+
+
+def test_style_config_dataclass():
+    """Test StyleConfig dataclass"""
+    print("\n🧪 Test 7: StyleConfig Dataclass")
+    
+    try:
+        style = StyleConfig(system="tailwind")
+        
+        assert style.system == "tailwind"
+        
+        print("✅ StyleConfig dataclass test passed")
+        return True
+    except Exception as e:
+        print(f"❌ StyleConfig dataclass test failed: {e}")
+        import traceback
+        traceback.print_exc()
+        return False
+
+
+def test_llm_config_dataclass():
+    """Test LLMConfig dataclass"""
+    print("\n🧪 Test 8: LLMConfig Dataclass")
+    
+    try:
+        llm = LLMConfig(
+            provider="openai-compatible",
+            api_key="test-key",
+            model="custom-model",
+            base_url="https://api.example.com/v1",
+            x_api_key="optional-header"
+        )
+        
+        assert llm.provider == "openai-compatible"
+        assert llm.api_key == "test-key"
+        assert llm.model == "custom-model"
+        assert llm.base_url == "https://api.example.com/v1"
+        assert llm.x_api_key == "optional-header"
+        
+        print("✅ LLMConfig dataclass test passed")
+        return True
+    except Exception as e:
+        print(f"❌ LLMConfig dataclass test failed: {e}")
+        import traceback
+        traceback.print_exc()
+        return False
+
+
+def run_all_tests():
+    """Run all tests"""
+    print("\n" + "="*60)
+    print("🧪 P2M Configuration System Test Suite")
+    print("="*60)
+    
+    tests = [
+        test_default_config,
+        test_config_save_and_load,
+        test_llm_config,
+        test_project_config_dataclass,
+        test_build_config_dataclass,
+        test_devserver_config_dataclass,
+        test_style_config_dataclass,
+        test_llm_config_dataclass,
+    ]
+    
+    results = []
+    
+    for test_func in tests:
+        try:
+            result = test_func()
+            results.append((test_func.__name__, result))
+        except Exception as e:
+            results.append((test_func.__name__, False))
+            print(f"❌ {test_func.__name__} failed: {e}")
+    
+    # Summary
+    print("\n" + "="*60)
+    print("📊 Test Summary")
+    print("="*60)
+    
+    passed = sum(1 for _, success in results if success)
+    total = len(results)
+    
+    for name, success in results:
+        status = "✅ PASS" if success else "❌ FAIL"
+        print(f"{status} - {name}")
+    
+    print(f"\n📈 Results: {passed}/{total} tests passed")
+    
+    if passed == total:
+        print("\n🎉 All tests passed!")
+    else:
+        print(f"\n⚠️  {total - passed} test(s) failed")
+    
+    return passed == total
+
+
+if __name__ == "__main__":
+    success = run_all_tests()
+    sys.exit(0 if success else 1)

tests/test_i18n.py

@@ -0,0 +1,101 @@
+"""
+Tests for p2m.i18n — configure, set_locale, get_locale, t.
+"""
+
+import json
+import pytest
+from pathlib import Path
+
+
+@pytest.fixture()
+def locale_dir(tmp_path):
+    """Create a temporary locales directory with pt.json and en.json."""
+    pt = {"greeting": "Olá, {name}!", "key_only": "Valor", "shared": "Português"}
+    en = {"greeting": "Hello, {name}!", "key_only": "Value",  "shared": "English"}
+    (tmp_path / "pt.json").write_text(json.dumps(pt), encoding="utf-8")
+    (tmp_path / "en.json").write_text(json.dumps(en), encoding="utf-8")
+    return tmp_path
+
+
+@pytest.fixture(autouse=True)
+def reset_i18n():
+    """Reset i18n module state between tests."""
+    import p2m.i18n.translator as _t
+    _t._locale = "en"
+    _t._translations = {}
+    _t._locales_dir = None
+    yield
+    _t._locale = "en"
+    _t._translations = {}
+    _t._locales_dir = None
+
+
+class TestConfigure:
+    def test_configure_and_translate(self, locale_dir):
+        from p2m.i18n import configure, t
+        configure(str(locale_dir), default_locale="pt")
+        assert t("key_only") == "Valor"
+
+    def test_configure_sets_locale(self, locale_dir):
+        from p2m.i18n import configure, get_locale
+        configure(str(locale_dir), default_locale="pt")
+        assert get_locale() == "pt"
+
+    def test_configure_default_en(self, locale_dir):
+        from p2m.i18n import configure, t
+        configure(str(locale_dir), default_locale="en")
+        assert t("key_only") == "Value"
+
+
+class TestFormatKwargs:
+    def test_format_kwargs(self, locale_dir):
+        from p2m.i18n import configure, t
+        configure(str(locale_dir), default_locale="pt")
+        assert t("greeting", name="João") == "Olá, João!"
+
+    def test_format_kwargs_en(self, locale_dir):
+        from p2m.i18n import configure, set_locale, t
+        configure(str(locale_dir), default_locale="pt")
+        set_locale("en")
+        assert t("greeting", name="Alice") == "Hello, Alice!"
+
+
+class TestMissingKey:
+    def test_missing_key_returns_key(self, locale_dir):
+        from p2m.i18n import configure, t
+        configure(str(locale_dir), default_locale="pt")
+        assert t("nonexistent_key") == "nonexistent_key"
+
+    def test_missing_locale_file_returns_key(self, tmp_path):
+        from p2m.i18n import configure, t
+        configure(str(tmp_path), default_locale="xx")
+        assert t("some_key") == "some_key"
+
+
+class TestSetLocale:
+    def test_set_locale_switches_language(self, locale_dir):
+        from p2m.i18n import configure, set_locale, t
+        configure(str(locale_dir), default_locale="pt")
+        assert t("shared") == "Português"
+        set_locale("en")
+        assert t("shared") == "English"
+
+    def test_set_locale_back(self, locale_dir):
+        from p2m.i18n import configure, set_locale, t
+        configure(str(locale_dir), default_locale="en")
+        set_locale("pt")
+        set_locale("en")
+        assert t("shared") == "English"
+
+
+class TestGetLocale:
+    def test_get_locale_default(self, locale_dir):
+        from p2m.i18n import configure, get_locale
+        configure(str(locale_dir), default_locale="pt")
+        assert get_locale() == "pt"
+
+    def test_get_locale_after_switch(self, locale_dir):
+        from p2m.i18n import configure, set_locale, get_locale
+        configure(str(locale_dir), default_locale="pt")
+        set_locale("en")
+        assert get_locale() == "en"