odooflow-cli 0.1.0__py3-none-any.whl

tests/test_commands_config.py

@@ -0,0 +1,104 @@
+import json
+import pytest
+from pathlib import Path
+from unittest.mock import patch
+from typer.testing import CliRunner
+
+from odooflow.cli import app
+from odooflow import config_manager
+
+
+@pytest.fixture
+def runner():
+    """Create a CLI runner for testing."""
+    return CliRunner()
+
+
+@pytest.fixture
+def temp_config_file(tmp_path):
+    """Create a temporary config file for testing."""
+    config_path = tmp_path / ".odooflowrc"
+    return config_path
+
+
+@pytest.fixture
+def mock_home(tmp_path, temp_config_file):
+    """Mock home directory."""
+    with patch("odooflow.config_manager.Path.home", return_value=tmp_path):
+        yield tmp_path
+
+
+class TestConfigCommand:
+    """Test cases for config command."""
+
+    def test_config_show_default(self, runner, mock_home):
+        """Test showing default configuration."""
+        result = runner.invoke(app, ["config", "--show"])
+        assert result.exit_code == 0
+        assert "env_file" in result.stdout
+
+    def test_config_show_custom(self, runner, mock_home, temp_config_file):
+        """Test showing custom configuration."""
+        test_config = {
+            "env_file": ".custom.env.json",
+            "manifest_file": "__openerp__.py"
+        }
+        temp_config_file.write_text(json.dumps(test_config))
+        
+        result = runner.invoke(app, ["config", "--show"])
+        assert result.exit_code == 0
+        assert ".custom.env.json" in result.stdout
+
+    def test_config_set_env_file(self, runner, mock_home):
+        """Test setting env_file in config."""
+        result = runner.invoke(app, ["config", "--env-file", ".test.env.json"])
+        assert result.exit_code == 0
+        assert "Configuration updated" in result.stdout
+        
+        config = config_manager.load_config()
+        assert config["env_file"] == ".test.env.json"
+
+    def test_config_set_manifest_file(self, runner, mock_home):
+        """Test setting manifest_file in config."""
+        result = runner.invoke(app, ["config", "--manifest-file", "__openerp__.py"])
+        assert result.exit_code == 0
+        assert "Configuration updated" in result.stdout
+        
+        config = config_manager.load_config()
+        assert config["manifest_file"] == "__openerp__.py"
+
+    def test_config_set_access_token(self, runner, mock_home):
+        """Test setting access token in config."""
+        result = runner.invoke(app, ["config", "--access-token", "test_token_123"])
+        assert result.exit_code == 0
+        assert "Configuration updated" in result.stdout
+        
+        config = config_manager.load_config()
+        assert config["access_token"] == "test_token_123"
+
+    def test_config_add_core_module(self, runner, mock_home):
+        """Test adding core modules to config."""
+        result = runner.invoke(app, ["config", "--add-core-module", "sale,purchase"])
+        assert result.exit_code == 0
+        assert "Added core module" in result.stdout
+        
+        config = config_manager.load_config()
+        assert "sale" in config["core_modules"]
+        assert "purchase" in config["core_modules"]
+
+    def test_config_set_sync_keys(self, runner, mock_home):
+        """Test setting sync keys in config."""
+        result = runner.invoke(app, ["config", "--sync-keys", "name,version,author"])
+        assert result.exit_code == 0
+        assert "Updated sync keys" in result.stdout
+        
+        config = config_manager.load_config()
+        assert "name" in config["sync_keys"]
+        assert "version" in config["sync_keys"]
+        assert "author" in config["sync_keys"]
+
+    def test_config_no_changes(self, runner, mock_home):
+        """Test config command with no changes."""
+        result = runner.invoke(app, ["config"])
+        assert result.exit_code == 0
+        assert "No changes provided" in result.stdout

tests/test_commands_init_module_env.py

@@ -0,0 +1,74 @@
+import json
+import pytest
+from pathlib import Path
+from unittest.mock import patch
+from typer.testing import CliRunner
+
+from odooflow.cli import app
+
+
+@pytest.fixture
+def runner():
+    """Create a CLI runner for testing."""
+    return CliRunner()
+
+
+@pytest.fixture
+def temp_dir(tmp_path):
+    """Create a temporary directory with manifest file."""
+    manifest_content = """{
+    'name': 'test_module',
+    'version': '16.0',
+    'author': 'Default Author',
+    'license': 'LGPL-3',
+    'website': 'https://example.com',
+    'depends': ['base', 'web']
+}"""
+    manifest_path = tmp_path / "__manifest__.py"
+    manifest_path.write_text(manifest_content)
+    return tmp_path
+
+
+class TestInitModuleEnv:
+    """Test cases for init command."""
+
+    def test_init_with_all_params(self, runner, temp_dir):
+        """Test init command with all parameters."""
+        with patch("pathlib.Path.cwd", return_value=temp_dir):
+            result = runner.invoke(app, [
+                "init",
+                "--author", "Test Author",
+                "--odoo-version", "17.0",
+                "--license", "MIT",
+                "--website", "https://test.com"
+            ])
+            assert result.exit_code == 0
+            
+            env_path = temp_dir / ".odooflow.env.json"
+            assert env_path.exists()
+            
+            env = json.loads(env_path.read_text())
+            assert env["author"] == "Test Author"
+            assert env["version"] == "17.0"
+            assert env["license"] == "MIT"
+            assert env["website"] == "https://test.com"
+
+    def test_init_without_manifest(self, runner, tmp_path):
+        """Test init command without manifest file."""
+        with patch("pathlib.Path.cwd", return_value=tmp_path):
+            result = runner.invoke(app, ["init"])
+            assert result.exit_code == 1
+
+    def test_init_partial_params(self, runner, temp_dir):
+        """Test init command with partial parameters."""
+        with patch("pathlib.Path.cwd", return_value=temp_dir):
+            result = runner.invoke(app, [
+                "init",
+                "--author", "Test Author"
+            ])
+            assert result.exit_code == 0
+            
+            env_path = temp_dir / ".odooflow.env.json"
+            env = json.loads(env_path.read_text())
+            assert env["author"] == "Test Author"
+            assert env["version"] == "16.0"  # Default from manifest

tests/test_commands_keygen.py

@@ -0,0 +1,23 @@
+import pytest
+from pathlib import Path
+from unittest.mock import patch, MagicMock
+from typer.testing import CliRunner
+from odooflow.cli import app
+
+@pytest.fixture
+def runner():
+    return CliRunner()
+
+class TestKeygenCommand:
+    def test_keygen_basic(self, runner, tmp_path):
+        with patch("pathlib.Path.home", return_value=tmp_path):
+            with patch("subprocess.run") as mock_run:
+                result = runner.invoke(app, ["ssh-keygen"])
+                assert result.exit_code == 0
+                mock_run.assert_called_once()
+
+    def test_keygen_with_custom_name(self, runner, tmp_path):
+        with patch("pathlib.Path.home", return_value=tmp_path):
+            with patch("subprocess.run"):
+                result = runner.invoke(app, ["ssh-keygen", "--key-name", "custom_key"])
+                assert result.exit_code == 0

tests/test_commands_remote.py

@@ -0,0 +1,32 @@
+import json
+import pytest
+from pathlib import Path
+from unittest.mock import patch
+from typer.testing import CliRunner
+from odooflow.cli import app
+
+@pytest.fixture
+def runner():
+    return CliRunner()
+
+@pytest.fixture
+def temp_dir_with_env(tmp_path):
+    env_path = tmp_path / ".odooflow.env.json"
+    env_path.write_text('{"name": "test", "remotes": {}}')
+    return tmp_path
+
+class TestRemoteCommand:
+    def test_remote_add_repo(self, runner, temp_dir_with_env):
+        with patch("pathlib.Path.cwd", return_value=temp_dir_with_env):
+            with patch("odooflow.commands.remote.get_current_branch", return_value="main"):
+                result = runner.invoke(app, ["remote", "--add-repo", "https://gitlab.com/test/repo.git"])
+                assert result.exit_code == 0
+                env = json.loads((temp_dir_with_env / ".odooflow.env.json").read_text())
+                assert env["remotes"]["repo"]["url"] == "https://gitlab.com/test/repo.git"
+
+    def test_remote_add_server(self, runner, temp_dir_with_env):
+        with patch("pathlib.Path.cwd", return_value=temp_dir_with_env):
+            result = runner.invoke(app, ["remote", "--server-json", '{"host": "127.0.0.1", "port": 22, "user": "test", "directory": "/opt/odoo"}'])
+            assert result.exit_code == 0
+            env = json.loads((temp_dir_with_env / ".odooflow.env.json").read_text())
+            assert env["remotes"]["server"]["host"] == "127.0.0.1"

tests/test_commands_sync_env.py

@@ -0,0 +1,70 @@
+import json
+import pytest
+from pathlib import Path
+from unittest.mock import patch
+from typer.testing import CliRunner
+
+from odooflow.cli import app
+
+
+@pytest.fixture
+def runner():
+    """Create a CLI runner for testing."""
+    return CliRunner()
+
+
+@pytest.fixture
+def temp_dir_with_files(tmp_path):
+    """Create a temporary directory with manifest and env files."""
+    manifest_content = """{
+    'name': 'test_module',
+    'version': '16.0',
+    'author': 'Test Author',
+    'license': 'LGPL-3',
+    'depends': ['base', 'web']
+}"""
+    manifest_path = tmp_path / "__manifest__.py"
+    manifest_path.write_text(manifest_content)
+    
+    env_content = """{
+    "name": "old_name",
+    "version": "15.0"
+}"""
+    env_path = tmp_path / ".odooflow.env.json"
+    env_path.write_text(env_content)
+    
+    return tmp_path
+
+
+class TestSyncEnv:
+    """Test cases for sync-env command."""
+
+    def test_sync_env_default_keys(self, runner, temp_dir_with_files):
+        """Test sync-env with default keys."""
+        with patch("pathlib.Path.cwd", return_value=temp_dir_with_files):
+            result = runner.invoke(app, ["sync-env"])
+            assert result.exit_code == 0
+            
+            env_path = temp_dir_with_files / ".odooflow.env.json"
+            env = json.loads(env_path.read_text())
+            assert env["name"] == "test_module"
+            assert env["version"] == "16.0"
+            assert env["author"] == "Test Author"
+
+    def test_sync_env_custom_keys(self, runner, temp_dir_with_files):
+        """Test sync-env with custom keys."""
+        with patch("pathlib.Path.cwd", return_value=temp_dir_with_files):
+            result = runner.invoke(app, ["sync-env", "--keys", "name,license"])
+            assert result.exit_code == 0
+            
+            env_path = temp_dir_with_files / ".odooflow.env.json"
+            env = json.loads(env_path.read_text())
+            assert env["name"] == "test_module"
+            assert env["license"] == "LGPL-3"
+            assert env["version"] == "15.0"  # Should not be updated
+
+    def test_sync_env_no_manifest(self, runner, tmp_path):
+        """Test sync-env without manifest file."""
+        with patch("pathlib.Path.cwd", return_value=tmp_path):
+            result = runner.invoke(app, ["sync-env"])
+            assert result.exit_code == 1

tests/test_config_manager.py

@@ -0,0 +1,123 @@
+import json
+import pytest
+from pathlib import Path
+from unittest.mock import patch, MagicMock
+import typer
+
+from odooflow.config_manager import (
+    DEFAULT_CONFIG,
+    get_global_config_path,
+    load_config,
+    save_config,
+    get_access_token,
+    get_core_modules_from_config,
+)
+
+
+@pytest.fixture
+def temp_config_file(tmp_path):
+    """Create a temporary config file for testing."""
+    config_path = tmp_path / ".odooflowrc"
+    return config_path
+
+
+@pytest.fixture
+def mock_home(tmp_path):
+    """Mock home directory."""
+    with patch("odooflow.config_manager.Path.home", return_value=tmp_path):
+        yield tmp_path
+
+
+class TestConfigManager:
+    """Test cases for config_manager module."""
+
+    def test_default_config_structure(self):
+        """Test that DEFAULT_CONFIG has all required keys."""
+        assert "env_file" in DEFAULT_CONFIG
+        assert "manifest_file" in DEFAULT_CONFIG
+        assert "core_modules" in DEFAULT_CONFIG
+        assert "sync_keys" in DEFAULT_CONFIG
+        assert "gitlab_url" in DEFAULT_CONFIG
+
+    def test_get_global_config_path(self, mock_home):
+        """Test getting global config path."""
+        path = get_global_config_path()
+        assert path == mock_home / ".odooflowrc"
+
+    def test_load_config_no_file(self, mock_home):
+        """Test loading config when no config file exists."""
+        config = load_config()
+        assert config == DEFAULT_CONFIG
+
+    def test_load_config_with_file(self, mock_home, temp_config_file):
+        """Test loading config from existing file."""
+        test_config = {
+            "env_file": ".custom.env.json",
+            "manifest_file": "__openerp__.py",
+            "core_modules": ["base", "web"],
+            "sync_keys": ["name", "version"],
+            "gitlab_url": "https://custom.gitlab.com"
+        }
+        temp_config_file.write_text(json.dumps(test_config))
+        
+        config = load_config()
+        assert config == test_config
+
+    def test_load_config_invalid_json(self, mock_home, temp_config_file):
+        """Test loading config with invalid JSON."""
+        temp_config_file.write_text("invalid json")
+        config = load_config()
+        assert config == DEFAULT_CONFIG
+
+    def test_save_config(self, mock_home, temp_config_file):
+        """Test saving config to file."""
+        test_config = {"env_file": ".test.env.json"}
+        save_config(test_config)
+        
+        assert temp_config_file.exists()
+        loaded = json.loads(temp_config_file.read_text())
+        assert loaded == test_config
+
+    def test_get_access_token_from_env(self, mock_home):
+        """Test getting access token from environment variable."""
+        with patch.dict("os.environ", {"ODOOFLOW_ACCESS_TOKEN": "test_token"}):
+            token = get_access_token()
+            assert token == "test_token"
+
+    def test_get_access_token_from_config(self, mock_home, temp_config_file):
+        """Test getting access token from config file."""
+        test_config = {"access_token": "config_token"}
+        temp_config_file.write_text(json.dumps(test_config))
+        
+        with patch.dict("os.environ", {}, clear=True):
+            token = get_access_token()
+            assert token == "config_token"
+
+    def test_get_access_token_not_found(self, mock_home):
+        """Test getting access token when not found."""
+        with patch.dict("os.environ", {}, clear=True):
+            with pytest.raises(typer.Exit):
+                get_access_token()
+
+    def test_get_core_modules_from_config_default(self, mock_home):
+        """Test getting core modules with default config."""
+        modules = get_core_modules_from_config()
+        assert modules == set(DEFAULT_CONFIG["core_modules"])
+
+    def test_get_core_modules_from_config_custom(self, mock_home, temp_config_file):
+        """Test getting core modules with custom config."""
+        test_config = {
+            "core_modules": ["base", "web", "custom"]
+        }
+        temp_config_file.write_text(json.dumps(test_config))
+        
+        modules = get_core_modules_from_config()
+        assert modules == {"base", "web", "custom"}
+
+    def test_get_core_modules_from_config_empty(self, mock_home, temp_config_file):
+        """Test getting core modules when config has empty list."""
+        test_config = {"core_modules": []}
+        temp_config_file.write_text(json.dumps(test_config))
+        
+        modules = get_core_modules_from_config()
+        assert modules == set()

tests/test_utils_env.py

@@ -0,0 +1,106 @@
+import json
+import pytest
+from pathlib import Path
+from unittest.mock import patch
+
+from odooflow.utils.env import (
+    read_manifest,
+    update_manifest,
+    write_env_file,
+    read_env_file,
+)
+
+
+@pytest.fixture
+def temp_manifest_file(tmp_path):
+    """Create a temporary manifest file for testing."""
+    manifest_path = tmp_path / "__manifest__.py"
+    return manifest_path
+
+
+@pytest.fixture
+def temp_env_file(tmp_path):
+    """Create a temporary env file for testing."""
+    env_path = tmp_path / ".odooflow.env.json"
+    return env_path
+
+
+class TestEnvUtils:
+    """Test cases for env utility functions."""
+
+    def test_read_manifest_valid(self, temp_manifest_file):
+        """Test reading a valid manifest file."""
+        manifest_content = "{'name': 'test_module', 'version': '16.0'}"
+        temp_manifest_file.write_text(manifest_content)
+        
+        manifest = read_manifest(temp_manifest_file)
+        assert manifest == {"name": "test_module", "version": "16.0"}
+
+    def test_read_manifest_invalid_syntax(self, temp_manifest_file):
+        """Test reading manifest with invalid syntax."""
+        temp_manifest_file.write_text("invalid python")
+        
+        manifest = read_manifest(temp_manifest_file)
+        assert manifest == {}
+
+    def test_read_manifest_empty_file(self, temp_manifest_file):
+        """Test reading an empty manifest file."""
+        temp_manifest_file.write_text("")
+        
+        manifest = read_manifest(temp_manifest_file)
+        assert manifest == {}
+
+    def test_read_manifest_security(self, temp_manifest_file):
+        """Test that eval is not used (security check)."""
+        # This should not execute arbitrary code
+        malicious_content = "__import__('os').system('echo malicious')"
+        temp_manifest_file.write_text(malicious_content)
+        
+        manifest = read_manifest(temp_manifest_file)
+        # Should return empty dict due to ast.literal_eval failing
+        assert manifest == {}
+
+    def test_write_env_file(self, temp_env_file):
+        """Test writing env file."""
+        test_values = {
+            "name": "test_module",
+            "author": "Test Author",
+            "version": "16.0"
+        }
+        write_env_file(temp_env_file, test_values)
+        
+        assert temp_env_file.exists()
+        loaded = json.loads(temp_env_file.read_text())
+        assert loaded == test_values
+
+    def test_read_env_file_valid(self, temp_env_file):
+        """Test reading a valid env file."""
+        test_values = {"name": "test_module", "version": "16.0"}
+        temp_env_file.write_text(json.dumps(test_values))
+        
+        env = read_env_file(temp_env_file)
+        assert env == test_values
+
+    def test_read_env_file_invalid_json(self, temp_env_file):
+        """Test reading env file with invalid JSON."""
+        temp_env_file.write_text("invalid json")
+        
+        env = read_env_file(temp_env_file)
+        assert env == {}
+
+    def test_read_env_file_not_exists(self, temp_env_file):
+        """Test reading env file that doesn't exist."""
+        env = read_env_file(temp_env_file)
+        assert env == {}
+
+    def test_update_manifest(self, temp_manifest_file):
+        """Test updating manifest file."""
+        initial_content = "{'name': 'test_module', 'version': '16.0'}"
+        temp_manifest_file.write_text(initial_content)
+        
+        updates = {"author": "Test Author", "license": "LGPL-3"}
+        update_manifest(temp_manifest_file, updates)
+        
+        updated_content = temp_manifest_file.read_text()
+        assert "Test Author" in updated_content
+        assert "LGPL-3" in updated_content

tests/test_utils_ssh.py

@@ -0,0 +1,23 @@
+import pytest
+from pathlib import Path
+from unittest.mock import patch, MagicMock
+from odooflow.utils.ssh import resolve_remote_path, compress_directory
+
+class TestSSHUtils:
+    def test_resolve_remote_path_absolute(self):
+        sftp = MagicMock()
+        sftp.normalize.return_value = "/home/user"
+        result = resolve_remote_path(sftp, "/opt/odoo")
+        assert result == "/opt/odoo"
+
+    def test_resolve_remote_path_relative(self):
+        sftp = MagicMock()
+        sftp.normalize.return_value = "/home/user"
+        result = resolve_remote_path(sftp, "odoo")
+        assert result == "/home/user/odoo"
+
+    def test_resolve_remote_path_tilde(self):
+        sftp = MagicMock()
+        sftp.normalize.return_value = "/home/user"
+        result = resolve_remote_path(sftp, "~/odoo")
+        assert result == "/home/user/odoo"