eljay-ai 1.1.0

package/tests/test_eljay.py

@@ -0,0 +1,209 @@
+"""Tests for the ElJay AI rename, version, compatibility alias, and npm packaging.
+
+Run from the project root:
+    python tests/test_eljay.py
+
+These are deterministic and do NOT require Ollama or network access.
+"""
+
+import json
+import os
+import sys
+import unittest
+from pathlib import Path
+
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+PROJECT_ROOT = Path(__file__).resolve().parent.parent
+
+
+class VersionTests(unittest.TestCase):
+    def test_version_string(self):
+        from agent import __version__
+        self.assertEqual(__version__, "1.1.0")
+
+    def test_version_is_semver(self):
+        from agent import __version__
+        parts = __version__.split(".")
+        self.assertEqual(len(parts), 3)
+        for p in parts:
+            self.assertTrue(p.isdigit())
+
+
+class BannerTests(unittest.TestCase):
+    def test_banner_contains_eljay_ai(self):
+        from agent.chat import BANNER
+        self.assertIn("ElJay AI", BANNER)
+
+    def test_banner_does_not_say_myagent(self):
+        from agent.chat import BANNER
+        self.assertNotIn("LOCAL AI CODING AGENT", BANNER)
+
+
+class EljayEntryTests(unittest.TestCase):
+    def test_eljay_module_importable(self):
+        import eljay  # noqa: F401
+        self.assertTrue(hasattr(eljay, "main"))
+
+    def test_eljay_has_resolve_model(self):
+        import eljay
+        self.assertTrue(callable(eljay.resolve_model))
+
+    def test_eljay_has_build_registry(self):
+        import eljay
+        self.assertTrue(callable(eljay.build_registry))
+
+
+class MyagentAliasTests(unittest.TestCase):
+    def test_myagent_module_importable(self):
+        import myagent  # noqa: F401
+        self.assertTrue(hasattr(myagent, "main"))
+
+    def test_myagent_main_delegates_to_eljay(self):
+        import myagent
+        import eljay
+        # myagent.main should be eljay.main (same function object)
+        self.assertIs(myagent.main, eljay.main)
+
+    def test_myagent_resolve_model_delegates(self):
+        import myagent
+        import eljay
+        self.assertIs(myagent.resolve_model, eljay.resolve_model)
+
+
+class HelpTextTests(unittest.TestCase):
+    def test_help_mentions_eljay(self):
+        # Read eljay.py source and check the --help text
+        src = (PROJECT_ROOT / "eljay.py").read_text(encoding="utf-8")
+        self.assertIn("eljay", src)
+        # The help line should reference eljay
+        self.assertIn("usage: eljay", src)
+
+    def test_version_flag_mentions_eljay_ai(self):
+        src = (PROJECT_ROOT / "eljay.py").read_text(encoding="utf-8")
+        self.assertIn("ElJay AI {__version__}", src)
+
+
+class PackageJsonTests(unittest.TestCase):
+    def test_package_json_exists(self):
+        self.assertTrue((PROJECT_ROOT / "package.json").exists())
+
+    def test_package_json_name(self):
+        data = json.loads((PROJECT_ROOT / "package.json").read_text())
+        self.assertEqual(data["name"], "eljay-ai")
+
+    def test_package_json_version(self):
+        data = json.loads((PROJECT_ROOT / "package.json").read_text())
+        self.assertEqual(data["version"], "1.1.0")
+
+    def test_package_json_bin_field(self):
+        data = json.loads((PROJECT_ROOT / "package.json").read_text())
+        bins = data["bin"]
+        self.assertIn("eljay", bins)
+        self.assertEqual(bins["eljay"], "eljay.js")
+
+    def test_package_json_prefer_global(self):
+        data = json.loads((PROJECT_ROOT / "package.json").read_text())
+        self.assertTrue(data.get("preferGlobal", False))
+
+    def test_package_json_has_engines(self):
+        data = json.loads((PROJECT_ROOT / "package.json").read_text())
+        self.assertIn("node", data["engines"])
+        self.assertIn("python", data["engines"])
+
+    def test_package_json_keywords(self):
+        data = json.loads((PROJECT_ROOT / "package.json").read_text())
+        self.assertIsInstance(data["keywords"], list)
+        self.assertTrue(len(data["keywords"]) > 0)
+
+
+class EljayJsTests(unittest.TestCase):
+    def test_eljay_js_exists(self):
+        self.assertTrue((PROJECT_ROOT / "eljay.js").exists())
+
+    def test_eljay_js_is_node_script(self):
+        first_line = (PROJECT_ROOT / "eljay.js").read_text(encoding="utf-8").splitlines()[0]
+        self.assertTrue("node" in first_line)
+
+    def test_eljay_js_references_eljay_py(self):
+        content = (PROJECT_ROOT / "eljay.js").read_text(encoding="utf-8")
+        self.assertIn("eljay.py", content)
+
+    def test_eljay_js_inherits_stdio(self):
+        content = (PROJECT_ROOT / "eljay.js").read_text(encoding="utf-8")
+        self.assertIn("stdio", content)
+
+
+class LauncherTests(unittest.TestCase):
+    def test_bin_eljay_exists(self):
+        path = PROJECT_ROOT / "bin" / "eljay"
+        self.assertTrue(path.exists())
+        self.assertTrue(os.access(path, os.X_OK), "bin/eljay should be executable")
+
+    def test_bin_eljay_cmd_exists(self):
+        self.assertTrue((PROJECT_ROOT / "bin" / "eljay.cmd").exists())
+
+    def test_bin_myagent_still_exists(self):
+        self.assertTrue((PROJECT_ROOT / "bin" / "myagent").exists())
+        self.assertTrue((PROJECT_ROOT / "bin" / "myagent.cmd").exists())
+
+    def test_bin_eljay_references_eljay_py(self):
+        content = (PROJECT_ROOT / "bin" / "eljay").read_text(encoding="utf-8")
+        self.assertIn("eljay.py", content)
+
+    def test_bin_eljay_cmd_references_eljay_py(self):
+        content = (PROJECT_ROOT / "bin" / "eljay.cmd").read_text(encoding="utf-8")
+        self.assertIn("eljay.py", content)
+
+    def test_bin_myagent_references_eljay_py(self):
+        """myagent launcher should delegate to eljay.py (compatibility)."""
+        content = (PROJECT_ROOT / "bin" / "myagent").read_text(encoding="utf-8")
+        self.assertIn("eljay.py", content)
+
+    def test_bin_myagent_cmd_references_eljay_py(self):
+        content = (PROJECT_ROOT / "bin" / "myagent.cmd").read_text(encoding="utf-8")
+        self.assertIn("eljay.py", content)
+
+
+class InstallPs1Tests(unittest.TestCase):
+    def test_install_ps1_references_eljay(self):
+        content = (PROJECT_ROOT / "install.ps1").read_text(encoding="utf-8")
+        self.assertIn("eljay", content)
+        # Should not say 'run myagent' as the primary instruction
+        self.assertNotIn("    myagent", content)
+
+
+class GitignoreTests(unittest.TestCase):
+    def test_gitignore_has_agent_dir(self):
+        content = (PROJECT_ROOT / ".gitignore").read_text(encoding="utf-8")
+        self.assertIn(".agent/", content)
+
+    def test_gitignore_has_pycache(self):
+        content = (PROJECT_ROOT / ".gitignore").read_text(encoding="utf-8")
+        self.assertIn("__pycache__/", content)
+
+
+class RulesTestsAlias(unittest.TestCase):
+    def test_agents_md_references_eljay(self):
+        content = (PROJECT_ROOT / "AGENTS.md").read_text(encoding="utf-8")
+        self.assertIn("eljay.py", content.lower())
+
+
+class ProviderFixTests(unittest.TestCase):
+    """Verify the _do_text fix in the Ollama provider."""
+
+    def test_ollama_provider_do_text_signature(self):
+        from agent.providers.ollama import OllamaProvider
+        # Just verify the method exists and is callable
+        self.assertTrue(hasattr(OllamaProvider, "_do_text"))
+
+    def test_ollama_provider_no_model_kwarg_in_client(self):
+        """The provider should not pass model= to OllamaClient (it doesn't accept it)."""
+        from agent.providers.ollama import OllamaProvider
+        import inspect
+        src = inspect.getsource(OllamaProvider._do_text)
+        self.assertNotIn("OllamaClient(host=self.host, model=", src)
+
+
+if __name__ == "__main__":
+    unittest.main(verbosity=2)

package/tests/test_runner.py

@@ -0,0 +1,114 @@
+"""Tests for the command runner — classification + real (safe) execution.
+
+Run from the project root:
+    python tests/test_runner.py
+"""
+
+import os
+import sys
+import tempfile
+import unittest
+from pathlib import Path
+
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+from agent.runner import analyse, classify_command, run_command  # noqa: E402
+from agent.tools import RISK_ASK, RISK_HIGH  # noqa: E402
+from agent.workspace import Workspace  # noqa: E402
+
+
+class ClassifyTests(unittest.TestCase):
+    def test_allow_listed_programs_are_ask(self):
+        for cmd in (
+            "python --version",
+            "npm run build",
+            "php artisan test",
+            "git status",
+            "node -v",
+            "pytest",
+        ):
+            self.assertEqual(classify_command(cmd), RISK_ASK, cmd)
+
+    def test_unknown_program_is_high(self):
+        self.assertEqual(classify_command("some_random_tool --go"), RISK_HIGH)
+
+    def test_dangerous_commands_are_high(self):
+        for cmd in (
+            "rm -rf /",
+            "rmdir somedir",
+            "del important.txt",
+            "git push origin main",
+            "git reset --hard HEAD",
+            "git clean -fd",
+            "npm uninstall react",
+            "composer remove laravel/framework",
+            "pip uninstall requests",
+            "drop database prod",
+            "shutdown now",
+            "sudo reboot",
+        ):
+            self.assertEqual(classify_command(cmd), RISK_HIGH, cmd)
+
+    def test_empty_command_is_high(self):
+        self.assertEqual(classify_command(""), RISK_HIGH)
+
+
+class AnalyseTests(unittest.TestCase):
+    def test_simple_command_parses(self):
+        argv, err = analyse("npm run build")
+        self.assertEqual(argv, ["npm", "run", "build"])
+        self.assertEqual(err, "")
+
+    def test_shell_operators_rejected(self):
+        for cmd in ("a | b", "a > file.txt", "a && b", "a; b", "a `b`", "a $(b)"):
+            argv, err = analyse(cmd)
+            self.assertIsNone(argv, cmd)
+            self.assertIn("ERROR", err)
+
+    def test_empty_rejected(self):
+        argv, err = analyse("   ")
+        self.assertIsNone(argv)
+        self.assertIn("ERROR", err)
+
+
+class RunTests(unittest.TestCase):
+    def setUp(self):
+        self._tmp = tempfile.TemporaryDirectory()
+        self.root = Path(self._tmp.name)
+        self.ws = Workspace(self.root)
+
+    def tearDown(self):
+        self._tmp.cleanup()
+
+    def test_runs_and_captures_output(self):
+        out = run_command(self.ws, "python --version")
+        self.assertIn("Exit code: 0", out)
+        self.assertIn("Python", out)
+
+    def test_failing_command_reports_failure(self):
+        out = run_command(self.ws, "python does_not_exist_xyz.py")
+        self.assertIn("FAILED", out)
+        self.assertNotIn("Exit code: 0", out)
+
+    def test_unknown_program_reports_error(self):
+        out = run_command(self.ws, "definitely_not_a_real_program_xyz")
+        self.assertIn("command not found", out)
+
+    def test_timeout_is_enforced(self):
+        (self.root / "slow.py").write_text(
+            "import time\ntime.sleep(10)\n", encoding="utf-8"
+        )
+        out = run_command(self.ws, "python slow.py", timeout=1)
+        self.assertIn("timed out", out)
+
+    def test_cwd_outside_root_rejected(self):
+        out = run_command(self.ws, "python --version", cwd="../..")
+        self.assertIn("ERROR", out)
+
+    def test_shell_operator_rejected_at_run(self):
+        out = run_command(self.ws, "python --version | more")
+        self.assertIn("ERROR", out)
+
+
+if __name__ == "__main__":
+    unittest.main(verbosity=2)