crackerjack 0.10.8__tar.gz → 0.11.2__tar.gz

{crackerjack-0.10.8 → crackerjack-0.11.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: crackerjack
-Version: 0.10.8
+Version: 0.11.2
 Summary: Default template for PDM package
 Keywords: black,ruff,mypy,creosote,refurb
 Author-Email: lesleslie <les@wedgwoodwebworks.com>
@@ -23,17 +23,17 @@ Project-URL: documentation, https://github.com/lesleslie/crackerjack
 Project-URL: repository, https://github.com/lesleslie/crackerjack
 Requires-Python: >=3.13
 Requires-Dist: click>=8.1.8
-Requires-Dist: aioconsole>=0.8.1
-Requires-Dist: inflection>=0.5.1
 Requires-Dist: autotyping>=24.9.0
 Requires-Dist: pre-commit>=4.0.1
 Requires-Dist: pytest>=8.3.4
 Requires-Dist: pydantic>=2.10.4
-Requires-Dist: aiopath>=0.7.7
 Requires-Dist: pdm-bump>=0.9.10
 Requires-Dist: pdm>=2.22.1
-Requires-Dist: acb>=0.8.0
 Requires-Dist: uv>=0.5.13
+Requires-Dist: pytest-cov>=6.0.0
+Requires-Dist: pytest-mock>=3.14.0
+Requires-Dist: tomli-w>=1.2.0
+Requires-Dist: pytest-asyncio>=0.25.3
 Description-Content-Type: text/markdown
 
 # Crackerjack Python

crackerjack-0.11.2/crackerjack/.pdm.toml

@@ -0,0 +1 @@
+test crackerjack config

{crackerjack-0.10.8 → crackerjack-0.11.2}/crackerjack/__main__.py

@@ -1,4 +1,3 @@
-import asyncio
 import typing as t
 
 from click import command, help_option, option
@@ -58,7 +57,7 @@ def crackerjack(
     if v:
         print("-v not currently implemented")
         options.verbose = v
-    asyncio.run(crackerjack_it(options=options))
+    crackerjack_it(options=options)
 
 
 if __name__ == "__main__":

{crackerjack-0.10.8 → crackerjack-0.11.2}/crackerjack/crackerjack.py

@@ -1,43 +1,35 @@
-import asyncio
 import re
-import sys
 import typing as t
 from pathlib import Path
 from subprocess import run as execute
+from tomllib import loads
 
-from acb.actions.encode import dump, load
-from aioconsole import ainput, aprint
-from aiopath import AsyncPath
-from inflection import underscore
 from pydantic import BaseModel
-
-
-class Config(BaseModel):
-    python_version: str = "3.13"
+from tomli_w import dumps
 
 
 class Crackerjack(BaseModel, arbitrary_types_allowed=True):
-    our_path: AsyncPath = AsyncPath(__file__).parent
-    pkg_path: AsyncPath = AsyncPath(Path.cwd())
-    settings_path: AsyncPath = pkg_path / ".crackerjack.yaml"
-    pkg_dir: t.Optional[AsyncPath] = None
+    our_path: Path = Path(__file__).parent
+    pkg_path: Path = Path(Path.cwd())
+    pkg_dir: t.Optional[Path] = None
     pkg_name: str = "crackerjack"
     our_toml: t.Optional[dict[str, t.Any]] = None
     pkg_toml: t.Optional[dict[str, t.Any]] = None
-    our_toml_path: t.Optional[AsyncPath] = None
-    pkg_toml_path: t.Optional[AsyncPath] = None
-    config: t.Optional[Config] = None
+    our_toml_path: t.Optional[Path] = None
+    pkg_toml_path: t.Optional[Path] = None
+    python_version: str = "3.13"
 
-    async def update_pyproject_configs(self) -> None:
+    def update_pyproject_configs(self) -> None:
         toml_file = "pyproject.toml"
         self.our_toml_path = self.our_path / toml_file
         self.pkg_toml_path = self.pkg_path / toml_file
         if self.pkg_path.stem == "crackerjack":
-            await self.our_toml_path.write_text(await self.pkg_toml_path.read_text())
+            self.our_toml_path.write_text(self.pkg_toml_path.read_text())
             return
-        our_toml_config: t.Any = await load.toml(self.our_toml_path)  # type: ignore
-        pkg_toml_config: t.Any = await load.toml(self.pkg_toml_path)  # type: ignore
-        pkg_deps = pkg_toml_config["dependency-groups"]
+        our_toml_config: t.Any = loads(self.our_toml_path.read_text())
+        pkg_toml_config: t.Any = loads(self.pkg_toml_path.read_text())
+        pkg_toml_config.setdefault("tool", {})
+        pkg_toml_config.setdefault("project", {})
         for tool, settings in our_toml_config["tool"].items():
             for setting, value in settings.items():
                 if isinstance(value, str | list) and "crackerjack" in value:
@@ -54,54 +46,50 @@ class Crackerjack(BaseModel, arbitrary_types_allowed=True):
                     "skips",
                     "ignore",
                 ) and isinstance(value, list):
-                    settings[setting] = set(
-                        pkg_toml_config["tool"][tool][setting] + value
-                    )
+                    conf = pkg_toml_config["tool"].get(tool, {}).get(setting, [])
+                    settings[setting] = list(set(conf + value))
             pkg_toml_config["tool"][tool] = settings
-        pkg_toml_config["dependency-groups"] = pkg_deps
         python_version_pattern = r"\s*W*(\d\.\d*)"
         requires_python = our_toml_config["project"]["requires-python"]
         classifiers = []
-        for classifier in pkg_toml_config["project"]["classifiers"]:
+        for classifier in pkg_toml_config["project"].get("classifiers", []):
             classifier = re.sub(
-                python_version_pattern, f" {self.config.python_version}", classifier
+                python_version_pattern, f" {self.python_version}", classifier
             )
             classifiers.append(classifier)
         pkg_toml_config["project"]["classifiers"] = classifiers
         pkg_toml_config["project"]["requires-python"] = requires_python
-        await dump.toml(pkg_toml_config, self.pkg_toml_path)  # type: ignore
+        self.pkg_toml_path.write_text(dumps(pkg_toml_config))
 
-    async def copy_configs(self) -> None:
+    def copy_configs(self) -> None:
         config_files = (".gitignore", ".pre-commit-config.yaml", ".libcst.codemod.yaml")
         for config in config_files:
             config_path = self.our_path / config
             pkg_config_path = self.pkg_path / config
-            await pkg_config_path.touch(exist_ok=True)
+            pkg_config_path.touch()
             if self.pkg_path.stem == "crackerjack":
-                await config_path.write_text(await pkg_config_path.read_text())
+                config_path.write_text(pkg_config_path.read_text())
                 continue
             if config != ".gitignore":
-                await pkg_config_path.write_text(
-                    (await config_path.read_text()).replace(
-                        "crackerjack", self.pkg_name
-                    )
+                pkg_config_path.write_text(
+                    (config_path.read_text()).replace("crackerjack", self.pkg_name)
                 )
             execute(["git", "add", config])
 
-    async def run_interactive(self, hook: str) -> None:
+    def run_interactive(self, hook: str) -> None:
         success: bool = False
         while not success:
             fail = execute(["pre-commit", "run", hook.lower(), "--all-files"])
             if fail.returncode > 0:
-                retry = await ainput(f"\n\n{hook.title()} failed. Retry? (y/N): ")
-                await aprint()
+                retry = input(f"\n\n{hook.title()} failed. Retry? (y/N): ")
+                print()
                 if retry.strip().lower() == "y":
                     continue
-                sys.exit()
+                raise SystemExit(1)
             success = True
 
-    async def update_pkg_configs(self) -> None:
-        await self.copy_configs()
+    def update_pkg_configs(self) -> None:
+        self.copy_configs()
         installed_pkgs = execute(
             ["pdm", "list", "--freeze"],
             capture_output=True,
@@ -117,71 +105,57 @@ class Crackerjack(BaseModel, arbitrary_types_allowed=True):
             execute(["git", "add", "pdm.lock"])
             execute(["pre-commit", "install"])
             execute(["git", "config", "advice.addIgnoredFile", "false"])
-        await self.update_pyproject_configs()
-
-    async def load_config(self) -> None:
-        await self.settings_path.touch(exist_ok=True)
-        try:
-            self.config = Config(**await load.yaml(self.settings_path))
-        except TypeError:
-            self.config = Config()
-            await dump.yaml(self.config.model_dump(), self.settings_path)
-            raise SystemExit("\nPlease configure '.crackerjack.yaml' and try again\n")
+        self.update_pyproject_configs()
 
-    async def run_pre_commit(self) -> None:
+    def run_pre_commit(self) -> None:
         check_all = execute(["pre-commit", "run", "--all-files"])
         if check_all.returncode > 0:
             check_all = execute(["pre-commit", "run", "--all-files"])
             if check_all.returncode > 0:
-                await aprint("\n\nPre-commit failed. Please fix errors.\n")
-                raise SystemExit()
+                print("\n\nPre-commit failed. Please fix errors.\n")
+                raise SystemExit(1)
 
-    async def process(self, options: t.Any) -> None:
-        self.pkg_name = underscore(self.pkg_path.stem.lower())
+    def process(self, options: t.Any) -> None:
+        self.pkg_name = self.pkg_path.stem.lower().replace("-", "_")
         self.pkg_dir = self.pkg_path / self.pkg_name
-        await self.pkg_dir.mkdir(exist_ok=True)
-        await aprint("\nCrackerjacking...\n")
+        self.pkg_dir.mkdir(exist_ok=True)
+        print("\nCrackerjacking...\n")
         if not options.do_not_update_configs:
-            await self.update_pkg_configs()
+            self.update_pkg_configs()
             execute(["pdm", "install"])
         if self.pkg_path.stem == "crackerjack" and options.update_precommit:
             execute(["pre-commit", "autoupdate"])
         if options.interactive:
             for hook in ("refurb", "bandit", "pyright"):
-                await self.run_interactive(hook)
-        await self.run_pre_commit()
+                self.run_interactive(hook)
+        self.run_pre_commit()
         for option in (options.publish, options.bump):
             if option:
                 execute(["pdm", "bump", option])
                 break
         if options.publish:
             build = execute(["pdm", "build"], capture_output=True, text=True)
-            await aprint(build.stdout)
+            print(build.stdout)
             if build.returncode > 0:
-                await aprint(build.stderr)
-                await aprint("\n\nBuild failed. Please fix errors.\n")
-                raise SystemExit()
+                print(build.stderr)
+                print("\n\nBuild failed. Please fix errors.\n")
+                raise SystemExit(1)
             execute(["pdm", "publish", "--no-build"])
         if options.commit:
-            commit_msg = await ainput("\nCommit message: ")
+            commit_msg = input("\nCommit message: ")
             execute(
                 [
                     "git",
                     "commit",
                     "-m",
-                    str(commit_msg),
+                    commit_msg,
                     "--no-verify",
                     "--",
                     ".",
                 ]
             )
             execute(["git", "push", "origin", "main"])
-        await aprint("\nCrackerjack complete!\n")
-
-    async def run(self, options: t.Any) -> None:
-        await self.load_config()
-        process = asyncio.create_task(self.process(options))
-        await process
+        print("\nCrackerjack complete!\n")
 
 
-crackerjack_it = Crackerjack().run
+crackerjack_it = Crackerjack().process

{crackerjack-0.10.8 → crackerjack-0.11.2}/crackerjack/pyproject.toml

@@ -1,3 +1,7 @@
+[tool.pytest.ini_options]
+addopts = "--cov=crackerjack"
+asyncio_default_fixture_loop_scope = "function"
+
 [tool.codespell]
 skip = "*/data/*"
 quiet-level = 3
@@ -9,6 +13,7 @@ target-version = "py313"
 fix = true
 show-fixes = true
 output-format = "full"
+unsafe-fixes = true
 
 [tool.ruff.format]
 docstring-code-format = true
@@ -57,6 +62,9 @@ exclude-deps = [
     "autotyping",
     "pre-commit",
     "pytest",
+    "pytest-asyncio",
+    "pytest-cov",
+    "pytest-mock",
     "pdm",
     "pyfiglet",
     "pyyaml",
@@ -72,6 +80,7 @@ target = [
     "crackerjack",
 ]
 skips = [
+    "B101",
     "B301",
     "B311",
     "B403",
@@ -79,6 +88,7 @@ skips = [
     "B602",
     "B603",
     "B607",
+    "B704",
 ]
 
 [tool.pyright]
@@ -105,7 +115,7 @@ pythonPlatform = "Darwin"
 
 [project]
 name = "crackerjack"
-version = "0.10.7"
+version = "0.11.1"
 description = "Default template for PDM package"
 requires-python = ">=3.13"
 readme = "README.md"
@@ -132,17 +142,17 @@ classifiers = [
 ]
 dependencies = [
     "click>=8.1.8",
-    "aioconsole>=0.8.1",
-    "inflection>=0.5.1",
     "autotyping>=24.9.0",
     "pre-commit>=4.0.1",
     "pytest>=8.3.4",
     "pydantic>=2.10.4",
-    "aiopath>=0.7.7",
     "pdm-bump>=0.9.10",
     "pdm>=2.22.1",
-    "acb>=0.8.0",
     "uv>=0.5.13",
+    "pytest-cov>=6.0.0",
+    "pytest-mock>=3.14.0",
+    "tomli-w>=1.2.0",
+    "pytest-asyncio>=0.25.3",
 ]
 authors = [
     { name = "lesleslie", email = "les@wedgwoodwebworks.com" },

{crackerjack-0.10.8 → crackerjack-0.11.2}/pyproject.toml

@@ -1,3 +1,7 @@
+[tool.pytest.ini_options]
+addopts = "--cov=crackerjack"
+asyncio_default_fixture_loop_scope = "function"
+
 [tool.codespell]
 skip = "*/data/*"
 quiet-level = 3
@@ -9,6 +13,7 @@ target-version = "py313"
 fix = true
 show-fixes = true
 output-format = "full"
+unsafe-fixes = true
 
 [tool.ruff.format]
 docstring-code-format = true
@@ -59,6 +64,9 @@ exclude-deps = [
     "autotyping",
     "pre-commit",
     "pytest",
+    "pytest-asyncio",
+    "pytest-cov",
+    "pytest-mock",
     "pdm",
     "pyfiglet",
     "pyyaml",
@@ -74,6 +82,7 @@ target = [
     "crackerjack",
 ]
 skips = [
+    "B101",
     "B301",
     "B311",
     "B403",
@@ -81,6 +90,7 @@ skips = [
     "B602",
     "B603",
     "B607",
+    "B704",
 ]
 
 [tool.pyright]
@@ -107,7 +117,7 @@ pythonPlatform = "Darwin"
 
 [project]
 name = "crackerjack"
-version = "0.10.8"
+version = "0.11.2"
 description = "Default template for PDM package"
 requires-python = ">=3.13"
 readme = "README.md"
@@ -134,17 +144,17 @@ classifiers = [
 ]
 dependencies = [
     "click>=8.1.8",
-    "aioconsole>=0.8.1",
-    "inflection>=0.5.1",
     "autotyping>=24.9.0",
     "pre-commit>=4.0.1",
     "pytest>=8.3.4",
     "pydantic>=2.10.4",
-    "aiopath>=0.7.7",
     "pdm-bump>=0.9.10",
     "pdm>=2.22.1",
-    "acb>=0.8.0",
     "uv>=0.5.13",
+    "pytest-cov>=6.0.0",
+    "pytest-mock>=3.14.0",
+    "tomli-w>=1.2.0",
+    "pytest-asyncio>=0.25.3",
 ]
 authors = [
     { name = "lesleslie", email = "les@wedgwoodwebworks.com" },

crackerjack-0.11.2/tests/test_crackerjack.py

@@ -0,0 +1,174 @@
+import typing as t
+from pathlib import Path
+from unittest.mock import MagicMock, call, patch
+
+import pytest
+from crackerjack.__main__ import options
+from crackerjack.crackerjack import Crackerjack
+
+
+@pytest.fixture
+def mock_execute() -> t.Generator[t.Any, t.Any, t.Any]:
+    with patch("crackerjack.crackerjack.execute") as mock:
+        yield mock
+
+
+@pytest.fixture
+def mock_subprocess_run() -> t.Generator[t.Any, t.Any, t.Any]:
+    with patch("subprocess.run") as mock:
+        yield mock
+
+
+@pytest.fixture
+def mock_print() -> t.Generator[t.Any, t.Any, t.Any]:
+    with patch("builtins.print") as mock:
+        yield mock
+
+
+@pytest.fixture
+def mock_input() -> t.Generator[t.Any, t.Any, t.Any]:
+    with patch("builtins.input") as mock:
+        yield mock
+
+
+@pytest.fixture(autouse=True)
+def reset_options() -> None:
+    """Resets the options before each test."""
+    options.commit = False
+    options.interactive = False
+    options.doc = False
+    options.update_precommit = False
+    options.do_not_update_configs = False
+    options.publish = False
+    options.bump = False
+    options.verbose = False
+
+
+@pytest.fixture
+def tmp_path_package(tmp_path: Path) -> Path:
+    return tmp_path / "my-package"
+
+
+@pytest.fixture
+def create_package_dir(tmp_path_package: Path) -> None:
+    (tmp_path_package / "my_package").mkdir(parents=True)
+    (tmp_path_package / "pyproject.toml").touch()
+    (tmp_path_package / ".gitignore").touch()
+    (tmp_path_package / ".pre-commit-config.yaml").touch()
+    (tmp_path_package / ".libcst.codemod.yaml").touch()
+
+
+class TestCrackerjackProcess:
+    def test_process_all_options(
+        self,
+        mock_execute: MagicMock,
+        mock_print: MagicMock,
+        mock_input: MagicMock,
+        mock_subprocess_run: MagicMock,
+        tmp_path: Path,
+        tmp_path_package: Path,
+        create_package_dir: None,
+    ) -> None:
+        mock_input.return_value = "Test Commit"
+        mock_execute.return_value.returncode = 0
+        mock_execute.return_value.stdout = "Mock Build Output"
+        mock_subprocess_run.return_value.returncode = 0
+        mock_execute.return_value.stderr = ""
+        mock_subprocess_run.return_value.stdout = ""
+        mock_subprocess_run.return_value.stderr = ""
+        crackerjack_instance = Crackerjack(pkg_path=tmp_path_package)
+        options_mock = MagicMock()
+        options_mock.do_not_update_configs = False
+        options_mock.update_precommit = True
+        options_mock.interactive = True
+        options_mock.commit = False
+        options_mock.publish = None
+        options_mock.bump = None
+        crackerjack_instance.process(options_mock)
+
+        assert crackerjack_instance.pkg_name == "my_package"
+        (tmp_path_package / "my_package").exists()
+        mock_execute.assert_has_calls(
+            [
+                call(["pdm", "self", "add", "keyring"]),
+                call(["pdm", "config", "python.use_uv", "true"]),
+                call(["git", "init"]),
+                call(["git", "branch", "-m", "main"]),
+                call(["git", "add", "pyproject.toml"]),
+                call(["git", "add", "pdm.lock"]),
+                call(["pre-commit", "install"]),
+                call(["git", "config", "advice.addIgnoredFile", "false"]),
+                call(["pdm", "install"]),
+                call(["pre-commit", "run", "refurb", "--all-files"]),
+                call(["pre-commit", "run", "bandit", "--all-files"]),
+                call(["pre-commit", "run", "pyright", "--all-files"]),
+                call(["pre-commit", "run", "--all-files"]),
+                call(["git", "add", ".gitignore"]),
+                call(["git", "add", ".pre-commit-config.yaml"]),
+                call(["git", "add", ".libcst.codemod.yaml"]),
+            ],
+            any_order=True,
+        )
+
+    def test_process_no_options(
+        self,
+        mock_execute: MagicMock,
+        mock_print: MagicMock,
+        mock_subprocess_run: MagicMock,
+        tmp_path_package: Path,
+        create_package_dir: None,
+    ) -> None:
+        mock_execute.return_value.returncode = 0
+        mock_subprocess_run.return_value.returncode = 0
+        crackerjack_instance = Crackerjack(pkg_path=tmp_path_package)
+        options_mock = MagicMock()
+        options_mock.do_not_update_configs = True
+        options_mock.update_precommit = False
+        options_mock.interactive = False
+        options_mock.publish = None
+        options_mock.bump = None
+        options_mock.commit = False
+
+        crackerjack_instance.process(options_mock)
+
+        assert crackerjack_instance.pkg_name == "my_package"
+        (tmp_path_package / "my_package").exists()
+        mock_execute.assert_has_calls(
+            [
+                call(["pre-commit", "run", "--all-files"]),
+            ]
+        )
+
+    def test_process_interactive_hooks(
+        self,
+        mock_execute: MagicMock,
+        mock_print: MagicMock,
+        mock_subprocess_run: MagicMock,
+        tmp_path_package: Path,
+        create_package_dir: None,
+    ) -> None:
+        mock_execute.return_value.returncode = 0
+        mock_subprocess_run.return_value.returncode = 0
+
+        crackerjack_instance = Crackerjack(pkg_path=tmp_path_package)
+        options_mock = MagicMock()
+        options_mock.do_not_update_configs = False
+        options_mock.update_precommit = False
+        options_mock.interactive = True
+        options_mock.publish = None
+        options_mock.bump = None
+        options_mock.commit = False
+
+        crackerjack_instance.process(options_mock)
+
+        assert crackerjack_instance.pkg_name == "my_package"
+        (tmp_path_package / "my_package").exists()
+
+        mock_execute.assert_has_calls(
+            [
+                call(["pre-commit", "run", "refurb", "--all-files"]),
+                call(["pre-commit", "run", "bandit", "--all-files"]),
+                call(["pre-commit", "run", "pyright", "--all-files"]),
+                call(["pre-commit", "run", "--all-files"]),
+            ]
+        )

crackerjack-0.11.2/tests/test_main.py

@@ -0,0 +1,142 @@
+import typing as t
+
+import pytest
+from click.testing import CliRunner
+from crackerjack.__main__ import crackerjack, options
+from crackerjack.crackerjack import Crackerjack
+
+
+@pytest.fixture(autouse=True)
+def mock_crackerjack_it(monkeypatch: pytest.MonkeyPatch) -> None:
+    def mock_process(self: Crackerjack, options: t.Any) -> None:
+        pass
+
+    monkeypatch.setattr(Crackerjack, "process", mock_process)
+
+
+@pytest.fixture
+def runner() -> CliRunner:
+    return CliRunner()
+
+
+@pytest.fixture(autouse=True)
+def reset_options() -> None:
+    options.commit = False
+    options.interactive = False
+    options.doc = False
+    options.update_precommit = False
+    options.do_not_update_configs = False
+    options.publish = False
+    options.bump = False
+    options.verbose = False
+
+
+def test_no_options(runner: CliRunner) -> None:
+    result = runner.invoke(crackerjack)
+    assert result.exit_code == 0
+    assert not options.commit
+    assert not options.interactive
+    assert not options.doc
+    assert not options.update_precommit
+    assert not options.do_not_update_configs
+    assert options.publish is False
+    assert options.bump is False
+    assert not options.verbose
+
+
+def test_commit_option(runner: CliRunner) -> None:
+    result = runner.invoke(crackerjack, ["-c"])
+    assert result.exit_code == 1
+    assert options.commit
+
+
+def test_interactive_option(runner: CliRunner) -> None:
+    result = runner.invoke(crackerjack, ["-i"])
+    assert result.exit_code == 0
+    assert options.interactive
+
+
+def test_doc_option(runner: CliRunner) -> None:
+    result = runner.invoke(crackerjack, ["-d"])
+    assert result.exit_code == 0
+    assert options.doc
+
+
+def test_update_precommit_option(runner: CliRunner) -> None:
+    result = runner.invoke(crackerjack, ["-u"])
+    assert result.exit_code == 0
+    assert options.update_precommit
+
+
+def test_do_not_update_configs_option(runner: CliRunner) -> None:
+    result = runner.invoke(crackerjack, ["-x"])
+    assert result.exit_code == 0
+    assert options.do_not_update_configs
+
+
+# def test_publish_micro_option(runner: CliRunner) -> None:
+#     result = runner.invoke(crackerjack, ["-p", "micro"])
+#     assert result.exit_code == 0
+#     assert options.publish == "micro"
+#
+#
+# def test_publish_minor_option(runner: CliRunner) -> None:
+#     result = runner.invoke(crackerjack, ["-p", "minor"])
+#     assert result.exit_code == 0
+#     assert options.publish == "minor"
+#
+#
+# def test_publish_major_option(runner: CliRunner) -> None:
+#     result = runner.invoke(crackerjack, ["-p", "major"])
+#     assert result.exit_code == 0
+#     assert options.publish == "major"
+#
+#
+# def test_bump_micro_option(runner: CliRunner) -> None:
+#     result = runner.invoke(crackerjack, ["-b", "micro"])
+#     assert result.exit_code == 0
+#     assert options.bump == "micro"
+#
+#
+# def test_bump_minor_option(runner: CliRunner) -> None:
+#     result = runner.invoke(crackerjack, ["-b", "minor"])
+#     assert result.exit_code == 0
+#     assert options.bump == "minor"
+#
+#
+# def test_bump_major_option(runner: CliRunner) -> None:
+#     result = runner.invoke(crackerjack, ["-b", "major"])
+#     assert result.exit_code == 0
+#     assert options.bump == "major"
+
+
+def test_verbose_option(runner: CliRunner) -> None:
+    result = runner.invoke(crackerjack, ["-v"])
+    assert result.exit_code == 0
+    assert options.verbose
+    assert "-v not currently implemented" in result.output
+
+
+def test_multiple_options(runner: CliRunner) -> None:
+    result = runner.invoke(crackerjack, ["-c", "-i"])
+    assert result.exit_code == 1
+    assert options.commit
+    assert options.interactive
+
+
+def test_help_option(runner: CliRunner) -> None:
+    result = runner.invoke(crackerjack, ["-h"])
+    assert result.exit_code == 0
+    assert "Usage: " in result.output
+
+
+def test_invalid_publish_option(runner: CliRunner) -> None:
+    result = runner.invoke(crackerjack, ["-p", "invalid"])
+    assert result.exit_code == 0
+    assert options.publish is False
+
+
+def test_invalid_bump_option(runner: CliRunner) -> None:
+    result = runner.invoke(crackerjack, ["-b", "invalid"])
+    assert result.exit_code == 0
+    assert options.bump is False