SmokeCrossFit 0.0.0__tar.gz → 1.0.0a1__tar.gz

{smokecrossfit-0.0.0 → smokecrossfit-1.0.0a1}/.github/workflows/ci.yml

@@ -1,6 +1,12 @@
 name: CI/CD
 
 on:
+  workflow_dispatch:
+    inputs:
+      tag:
+        description: "Tag to build/publish"
+        required: true
+        type: string
   push:
     branches: ["*"]
     tags:
@@ -37,15 +43,50 @@ jobs:
       - name: Run unit tests
         run: pytest testing/unit-tests -v --tb=short
 
+  sanity-tests:
+    name: Sanity Tests
+    runs-on: ubuntu-latest
+    if: startsWith(github.ref, 'refs/tags/v')
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+
+      - name: Set up .NET SDK
+        uses: actions/setup-dotnet@v4
+        with:
+          dotnet-version: "8.0.x"
+
+      - name: Cache pip dependencies
+        uses: actions/cache@v4
+        with:
+          path: ~/.cache/pip
+          key: ${{ runner.os }}-pip-sanity-${{ hashFiles('requirements.txt') }}
+          restore-keys: |
+            ${{ runner.os }}-pip-sanity-
+
+      - name: Install dependencies
+        run: |
+          python -m pip install --upgrade pip
+          pip install -r requirements.txt
+          pip install -e .
+
+      - name: Run sanity tests
+        run: pytest testing/sanity -v --tb=short
+
   build:
     name: Build distributions
     runs-on: ubuntu-latest
-    needs: [unit-tests]
+    needs: [unit-tests, sanity-tests]
     if: startsWith(github.ref, 'refs/tags/v')
     steps:
       - uses: actions/checkout@v4
         with:
           fetch-depth: 0
+          fetch-tags: true
 
       - name: Set up Python
         uses: actions/setup-python@v5

{smokecrossfit-0.0.0/SmokeCrossFit.egg-info → smokecrossfit-1.0.0a1}/PKG-INFO

@@ -1,9 +1,20 @@
 Metadata-Version: 2.4
 Name: SmokeCrossFit
-Version: 0.0.0
+Version: 1.0.0a1
 Summary: A unified interface for various code coverage tools (JaCoCo, dotnet-coverage)
 Requires-Python: >=3.12
 Description-Content-Type: text/markdown
+Requires-Dist: annotated-types~=0.7.0
+Requires-Dist: colorama~=0.4.6
+Requires-Dist: pydantic~=2.11.7
+Requires-Dist: pydantic_core~=2.33.2
+Requires-Dist: Pygments~=2.19.2
+Requires-Dist: typeguard~=4.4.4
+Requires-Dist: typing-inspection~=0.4.1
+Requires-Dist: typing_extensions~=4.14.1
+Requires-Dist: pytest>=8.4.3
+Requires-Dist: build>=1.2.0
+Requires-Dist: twine>=5.0.0
 
 # CrossFit Coverage Tools
 

{smokecrossfit-0.0.0 → smokecrossfit-1.0.0a1/SmokeCrossFit.egg-info}/PKG-INFO

@@ -1,9 +1,20 @@
 Metadata-Version: 2.4
 Name: SmokeCrossFit
-Version: 0.0.0
+Version: 1.0.0a1
 Summary: A unified interface for various code coverage tools (JaCoCo, dotnet-coverage)
 Requires-Python: >=3.12
 Description-Content-Type: text/markdown
+Requires-Dist: annotated-types~=0.7.0
+Requires-Dist: colorama~=0.4.6
+Requires-Dist: pydantic~=2.11.7
+Requires-Dist: pydantic_core~=2.33.2
+Requires-Dist: Pygments~=2.19.2
+Requires-Dist: typeguard~=4.4.4
+Requires-Dist: typing-inspection~=0.4.1
+Requires-Dist: typing_extensions~=4.14.1
+Requires-Dist: pytest>=8.4.3
+Requires-Dist: build>=1.2.0
+Requires-Dist: twine>=5.0.0
 
 # CrossFit Coverage Tools
 

{smokecrossfit-0.0.0 → smokecrossfit-1.0.0a1}/SmokeCrossFit.egg-info/SOURCES.txt

@@ -6,6 +6,7 @@ requirements.txt
 SmokeCrossFit.egg-info/PKG-INFO
 SmokeCrossFit.egg-info/SOURCES.txt
 SmokeCrossFit.egg-info/dependency_links.txt
+SmokeCrossFit.egg-info/requires.txt
 SmokeCrossFit.egg-info/top_level.txt
 crossfit/__init__.py
 crossfit/bin/tools/jacococli.jar

smokecrossfit-1.0.0a1/SmokeCrossFit.egg-info/requires.txt

@@ -0,0 +1,11 @@
+annotated-types~=0.7.0
+colorama~=0.4.6
+pydantic~=2.11.7
+pydantic_core~=2.33.2
+Pygments~=2.19.2
+typeguard~=4.4.4
+typing-inspection~=0.4.1
+typing_extensions~=4.14.1
+pytest>=8.4.3
+build>=1.2.0
+twine>=5.0.0

{smokecrossfit-0.0.0 → smokecrossfit-1.0.0a1}/crossfit/__init__.py

@@ -1,5 +1,5 @@
 from crossfit import refs
-from crossfit.commands.command import Command
+from crossfit.commands import Command
 from crossfit.tools import Tool, Jacoco, DotnetCoverage, create_tool
 from crossfit.executors import Executor, LocalExecutor, create_executor
 

smokecrossfit-1.0.0a1/crossfit/commands/__init__.py

@@ -0,0 +1,4 @@
+from .command import Command
+from .command_builder import CommandBuilder
+
+__all__ = ['Command', 'CommandBuilder']

{smokecrossfit-0.0.0 → smokecrossfit-1.0.0a1}/crossfit/commands/command.py

@@ -1,7 +1,7 @@
 import copy
 import glob
 from pathlib import Path
-from typing import Optional, List, Tuple, Self
+from typing import Optional, Self
 from typeguard import typechecked
 
 COMMAND_DELIMITER = " "
@@ -11,9 +11,9 @@ class Command:
     next_command: Optional[Self]
     execution_call: Optional[str]
     command_to_execute: Optional[str]
-    command_body: List[str]
-    options: List[Tuple[str, Optional[str]]]
-    arguments: List[str]
+    command_body: list[str]
+    options: list[tuple[str, Optional[str]]]
+    arguments: list[str]
     values_delimiter: Optional[str]
 
     @typechecked()
@@ -30,14 +30,14 @@ class Command:
         self.values_delimiter = None
 
     @property
-    def command(self) -> List[str]:
+    def command(self) -> list[str]:
         """
         :returns: The command itself as a list of strings
         """
         return list(filter(lambda s: s is not None, [self.execution_call, self.command_to_execute, *self.command_body]))
 
     @command.setter
-    def command(self, value: List[str]):
+    def command(self, value: list[str]):
         """
         Sets the command body from a list of strings
         :param value: The command body as list of strings

{smokecrossfit-0.0.0 → smokecrossfit-1.0.0a1}/crossfit/commands/command_builder.py

@@ -1,8 +1,9 @@
 import copy
 import glob
 import os.path
+
 from pathlib import Path
-from typing import List, Optional, Self, Tuple
+from typing import Optional, Self
 from typeguard import typechecked
 from crossfit.commands.command import Command
 
@@ -26,7 +27,7 @@ class CommandBuilder:
         self._command.next_command = command
 
     @typechecked()
-    def with_command(self, command: List[str]) -> Self:
+    def with_command(self, command: list[str]) -> Self:
         """
         Initializes the command from a list of strings.
         :param command: A list containing at least two strings - execution call and command to execute
@@ -49,7 +50,7 @@ class CommandBuilder:
         :param path: Optional path to prepend to the execution call
         :returns: Self for method chaining
         """
-        self._command.execution_call = execution_call if path is None else os.path.relpath(path / execution_call)
+        self._command.execution_call = execution_call if path is None else str(os.path.relpath(path / execution_call))
         return self
 
     @typechecked()
@@ -63,7 +64,7 @@ class CommandBuilder:
         return self
 
     @typechecked()
-    def set_command_body(self, command_body: List[str]) -> Self:
+    def set_command_body(self, command_body: list[str]) -> Self:
         """
         Sets the command body containing arguments and options.
         :param command_body: A list of strings representing the command body
@@ -83,7 +84,7 @@ class CommandBuilder:
         if self._command.values_delimiter != delimiter:
             self._command.values_delimiter = delimiter
             if update_current_values:
-                self.__update_all_options()
+                self._update_all_options()
         return self
 
     @typechecked()
@@ -99,7 +100,7 @@ class CommandBuilder:
         return self
 
     @typechecked()
-    def add_options(self, *args: Tuple[str, Optional[str]]) -> Self:
+    def add_options(self, *args: tuple[str, Optional[str]]) -> Self:
         """
         Adds multiple options to the command.
         :param args: Variable number of tuples, each containing (option, value) pairs
@@ -144,12 +145,12 @@ class CommandBuilder:
         """
         return copy.copy(self._command)
 
-    def __update_all_options(self) -> Self:
+    def _update_all_options(self) -> Self:
         """
         Updates all existing options with the current delimiter.
         :returns: Self for method chaining
         """
-        self._command.command_body = self._command.command_body[:-sum(len(option) for option in self._command.options)]
+        self._command.command_body = self._command.arguments
         options = self._command.options.copy()
         self._command.options = []
         self.add_options(*options)

smokecrossfit-1.0.0a1/crossfit/executors/executor_factory.py

@@ -0,0 +1,16 @@
+from crossfit.models.executor_models import ExecutorType
+from crossfit.executors.local_executor import LocalExecutor
+
+def create_executor(executor_type: ExecutorType, logger = None, catch: bool = True, **kwargs):
+    """
+    Factory method to create an executor based on the specified type.
+    :param executor_type: The type of executor to create.
+    :param logger: Optional logger instance for logging execution details.
+    :param catch: Whether to catch exceptions during execution.
+    :param kwargs: Additional keyword arguments for executor initialization.
+    :return: An instance of the specified executor type.
+    """
+    if executor_type == ExecutorType.Local:
+        return LocalExecutor(logger, catch, **kwargs)
+    else:
+        raise ValueError(f"Unknown executor type: {executor_type}")

{smokecrossfit-0.0.0 → smokecrossfit-1.0.0a1}/crossfit/executors/local_executor.py

@@ -1,6 +1,8 @@
 import subprocess
 from logging import Logger
 import shlex
+from pathlib import Path
+
 from crossfit.commands.command import Command
 from crossfit.executors.executor import Executor
 from crossfit.models.command_models import CommandResult
@@ -9,20 +11,25 @@ from crossfit.models.command_models import CommandResult
 class LocalExecutor(Executor):
     """Executor that runs commands locally via subprocess."""
 
-    def __init__(self, logger: Logger, catch: bool = True, **execution_kwargs):
+    def __init__(self, logger: Logger, catch: bool = True, workdir: Path = None, **execution_kwargs):
         """
         :param logger: Logger instance for logging execution details (required)
         :param catch: If True, catches exceptions and returns error in CommandResult.
                       If False, re-raises exceptions.
         :param execution_kwargs: Additional arguments passed to subprocess.run
         """
+        self._workdir = workdir
+        if workdir is not None:
+            execution_kwargs["cwd"] = str(workdir)
+
         super().__init__(logger, catch)
+
         self._exec_kwargs = {
             "capture_output": True,
             "check": True,
             "text": True,
+            **execution_kwargs,
         }
-        self._exec_kwargs.update(execution_kwargs)
 
     def _execute_single(self, command: Command) -> CommandResult:
         """

{smokecrossfit-0.0.0 → smokecrossfit-1.0.0a1}/crossfit/models/command_models.py

@@ -1,6 +1,5 @@
 from enum import Enum
 from typing import Optional
-
 from pydantic import BaseModel
 
 

{smokecrossfit-0.0.0 → smokecrossfit-1.0.0a1}/crossfit/tools/dotnet_coverage.py

@@ -1,5 +1,5 @@
 from pathlib import Path
-from typing import List, Tuple, Optional
+from typing import Optional
 
 from crossfit import Command
 from crossfit.models import ReportFormat, ToolType
@@ -9,16 +9,54 @@ from crossfit.tools.tool import Tool
 class DotnetCoverage(Tool):
     _tool_type = ToolType.DotnetCoverage
 
-    def snapshot_coverage(self, session, target_dir, target_file, *extras: Tuple[str, Optional[str]]) -> Command:
+    def save_report(self,
+                    coverage_files,
+                    target_dir,
+                    sourcecode_dir=None,
+                    report_format: ReportFormat = None,
+                    report_formats: list[ReportFormat] = None,
+                    *extras: tuple[str, Optional[str]]) -> Command:
+        """
+        Creates a dotnet-coverage report from coverage files to the given path.
+        :param coverage_files: File paths (can handle wildcards) to create dotnet-coverage report from.
+        :param target_dir: Targeted directory to save the dotnet-coverage report to.
+        :param sourcecode_dir: Directory containing the covered source code files.
+        :param report_format: Primary format of the dotnet-coverage report.
+        :param report_formats: Additional formats of dotnet-coverage reports to create.
+        :param extras: Extra options to pass to the dotnet CLI's report command.
+        :return: A Command object configured to generate the coverage report.
+        """
+        multiple_values_delimiter = ';'
+        if sourcecode_dir:
+            extras += ("-sourcedirs", str(sourcecode_dir)),
+        extras += ("-targetdir", str(target_dir)),
+        command_builder = (
+            self._create_command_builder("", ToolType.DotnetReportGenerator, None, *extras)
+            .set_values_delimiter(":", True)
+            .add_option("-reports", f"\"{multiple_values_delimiter.join(map(str, coverage_files))}\""))
+        combined_formats = set((report_formats or []) + [report_format])
+        command_builder = command_builder.add_option(
+            "-reporttypes",f"\"{multiple_values_delimiter.join([rf.value for rf in combined_formats if rf])}\"")
+
+        command = command_builder.build_command()
+        command.command = [kw.replace("--", "-") for kw in command.command[2:]]
+
+        return command
+
+    def snapshot_coverage(self,
+                          session,
+                          target_dir,
+                          target_file,
+                          *extras: tuple[str, Optional[str]]) -> Command:
         """
         Triggers dotnet-coverage agent to save cobertura formatted coverage files to the given path.
-        :param session: Session id of the dotnet-coverage agent collected-coverage to snapshot.
+        :param session: Session id of the dotnet-coverage agent collected-coverage for snapshot.
         :param target_dir: Targeted directory to save the dotnet-coverage collection to.
         :param target_file: Specified snapshot file name - when not given, uses default with .xml suffix.
         :param extras: Extra options to pass to the dotnet-coverage CLI's snapshot command.
         :return: A Command object configured to snapshot coverage data.
         """
-        target_path = Path(target_dir) / (
+        target_path = target_dir / (
             target_file if target_file is not None else self._get_default_target_filename())
         if not target_path.suffix:
             target_path = target_path.with_suffix(".xml")
@@ -28,7 +66,11 @@ class DotnetCoverage(Tool):
 
         return command_builder.build_command()
 
-    def merge_coverage(self, coverage_files, target_dir, target_file, *extras: Tuple[str, Optional[str]]) -> Command:
+    def merge_coverage(self,
+                       coverage_files,
+                       target_dir,
+                       target_file,
+                       *extras: tuple[str, Optional[str]]) -> Command:
         """
         Merges multiple coverage files into a single unified coverage file.
         :param coverage_files: File paths to coverage files to merge.
@@ -37,7 +79,7 @@ class DotnetCoverage(Tool):
         :param extras: Extra options to pass to the dotnet-coverage CLI's merge command.
         :return: A Command object configured to merge coverage files.
         """
-        extras += ("--output", str(Path(target_dir) / (
+        extras += ("--output", str(target_dir / (
             target_file if target_file is not None else Path(self._get_default_target_filename()).with_suffix(
                 ".xml")))),
         command_builder = self._create_command_builder("merge", None, coverage_files, *extras)
@@ -45,33 +87,3 @@ class DotnetCoverage(Tool):
             command_builder = command_builder.add_option("--output-format", ReportFormat.Cobertura.value.lower())
 
         return command_builder.build_command()
-
-    def save_report(self, coverage_files, target_dir, sourcecode_dir,
-                    report_format: ReportFormat = None, report_formats: List[ReportFormat] = None,
-                    *extras: Tuple[str, Optional[str]]) -> Command:
-        """
-        Creates a dotnet-coverage report from coverage files to the given path.
-        :param coverage_files: File paths (can handle wildcards) to create dotnet-coverage report from.
-        :param target_dir: Targeted directory to save the dotnet-coverage report to.
-        :param sourcecode_dir: Directory containing the covered source code files.
-        :param report_format: Primary format of the dotnet-coverage report.
-        :param report_formats: Additional formats of dotnet-coverage reports to create.
-        :param extras: Extra options to pass to the dotnet CLI's report command.
-        :return: A Command object configured to generate the coverage report.
-        """
-        multiple_values_delimiter = ';'
-        if sourcecode_dir:
-            extras += ("-sourcedirs", str(sourcecode_dir)),
-        extras += ("-targetdir", str(target_dir)),
-        command_builder = (
-            self._create_command_builder("", ToolType.DotnetReportGenerator, None, *extras)
-            .set_values_delimiter(":", True)
-            .add_option("-reports", f"\"{multiple_values_delimiter.join(map(str, coverage_files))}\""))
-        combined_formats = set((report_formats or []) + [report_format])
-        command_builder = command_builder.add_option(
-            "-reporttypes",f"\"{multiple_values_delimiter.join([rf.value for rf in combined_formats if rf])}\"")
-
-        command = command_builder.build_command()
-        command.command = [kw.replace("--", "-") for kw in command.command[2:]]
-
-        return command

{smokecrossfit-0.0.0 → smokecrossfit-1.0.0a1}/crossfit/tools/jacoco.py

@@ -1,6 +1,6 @@
 import os.path
-from pathlib import Path
-from typing import Optional, Tuple
+
+from typing import Optional
 from crossfit import Command
 from crossfit.commands.command_builder import CommandBuilder
 from crossfit.models.tool_models import ReportFormat, ToolType
@@ -11,8 +11,12 @@ class Jacoco(Tool):
     """JaCoCo coverage tool implementation for Java projects."""
     _tool_type = ToolType.Jacoco
 
-    def _create_command_builder(self, command, tool_type = None, path_arguments = None, required_flags = None,
-                                *extras: Tuple[str, Optional[str]]) -> CommandBuilder:
+    def _create_command_builder(self,
+                                command,
+                                tool_type = None,
+                                path_arguments = None,
+                                required_flags = None,
+                                *extras: tuple[str, Optional[str]]) -> CommandBuilder:
         """
         Creates a CommandBuilder for JaCoCo CLI commands.
         :param command: The JaCoCo command to execute (e.g., 'report', 'dump', 'merge').
@@ -25,11 +29,11 @@ class Jacoco(Tool):
         """
         tool_type = tool_type or self._tool_type
         command_builder = (super()._create_command_builder(command, tool_type, path_arguments, *extras)
-                           .set_execution_call(f"java -jar {os.path.relpath(Path(self._path) / str(tool_type.value))}"))
+                           .set_execution_call(f"java -jar {os.path.relpath(self._path / str(tool_type.value))}"))
 
         required_flags = required_flags or []
         for required_flag in required_flags:
-            if required_flag not in [extra[0] for extra in list(extras)]:
+            if required_flag not in [extra[0] for extra in extras]:
                 msg = (f"Encountered error while building {tool_type.name} command. "
                        f"JaCoCo flag option {required_flag} is required for command '{command}'.")
                 self._logger.error(msg)
@@ -39,8 +43,14 @@ class Jacoco(Tool):
 
         return command_builder
 
-    def save_report(self, coverage_files, target_dir, report_format, report_formats, sourcecode_dir, build_dir, *extras)\
-            -> Command:
+    def save_report(self,
+                    coverage_files,
+                    target_dir,
+                    sourcecode_dir=None,
+                    report_format = None,
+                    report_formats = None,
+                    build_dir = None,
+                    *extras) -> Command:
         """
         Creates a JaCoCo coverage report from coverage files to the given path.
         :param coverage_files: File paths to JaCoCo .exec coverage files to create the report from.
@@ -64,11 +74,15 @@ class Jacoco(Tool):
                 command = command.add_option(f"--{rf.name.lower()}", str(target_dir))
             elif rf is not None:
                 command = command.add_option(f"--{rf.name.lower()}",
-                                             str((Path(target_dir) / self._get_default_target_filename())
+                                             str((target_dir / self._get_default_target_filename())
                                                  .with_suffix(f".{rf.value.lower()}")))
         return command.build_command()
 
-    def snapshot_coverage(self, session, target_dir, target_file, *extras) -> Command:
+    def snapshot_coverage(self,
+                          session,
+                          target_dir,
+                          target_file,
+                          *extras) -> Command:
         """
         Triggers JaCoCo agent to dump coverage data to the given path.
         :param session: Session identifier (not used by JaCoCo dump but kept for interface consistency).
@@ -77,7 +91,7 @@ class Jacoco(Tool):
         :param extras: Extra options to pass to the JaCoCo CLI's dump command.
         :return: A Command object configured to dump coverage data.
         """
-        target_path = Path(target_dir) / (
+        target_path = target_dir / (
             target_file if target_file is not None else self._get_default_target_filename())
         if not target_path.suffix:
             target_path = target_path.with_suffix(".exec")
@@ -86,7 +100,11 @@ class Jacoco(Tool):
             "dump", None, None, None, *extras)
         return command.build_command()
 
-    def merge_coverage(self, coverage_files, target_dir, target_file, *extras) -> Command:
+    def merge_coverage(self,
+                       coverage_files,
+                       target_dir,
+                       target_file,
+                       *extras) -> Command:
         """
         Merges multiple JaCoCo coverage files into a single unified coverage file.
         :param coverage_files: File paths to JaCoCo .exec coverage files to merge.
@@ -95,7 +113,7 @@ class Jacoco(Tool):
         :param extras: Extra options to pass to the JaCoCo CLI's merge command.
         :return: A Command object configured to merge coverage files.
         """
-        target_path = Path(target_dir) / (
+        target_path = target_dir / (
             target_file if target_file is not None else self._get_default_target_filename())
         if not target_path.suffix:
             target_path = target_path.with_suffix(".exec")

{smokecrossfit-0.0.0 → smokecrossfit-1.0.0a1}/crossfit/tools/tool.py

@@ -1,27 +1,28 @@
 import tempfile
-import logging
+
 from abc import ABC, abstractmethod
+from logging import Logger
 from pathlib import Path
-from typing import Collection, Optional, Tuple, List, Union
-from crossfit.commands.command import Command
-from crossfit.commands.command_builder import CommandBuilder
-from crossfit.models.tool_models import ToolType
+from typing import Optional
+from crossfit import Command
+from crossfit.commands import CommandBuilder
+from crossfit.models import ToolType, ReportFormat
 
 
 class Tool(ABC):
     """Abstract base class for coverage tools. Tools build and return Commands."""
     _tool_type: ToolType
     _path: Optional[Path]
-    _logger: logging.Logger
+    _logger: Logger
     _catch: bool
 
-    def __init__(self, logger: logging.Logger, path: Optional[Path] = None, catch: bool = True):
+    def __init__(self, logger: Logger, path: Optional[Path] = None, catch: bool = True):
         """
         :param logger: Logger instance for logging (required).
         :param path: The path to the tool executable/jar.
         :param catch: If True, catches exceptions and returns fallback. If False, re-raises.
         """
-        self._logger: logging.Logger = logger
+        self._logger: Logger = logger
         self._path: Optional[Path] = path
         self._catch: bool = catch
 
@@ -29,9 +30,11 @@ class Tool(ABC):
         """Returns the default target filename for this tool."""
         return f"cross-{self._tool_type.name}".lower()
 
-    def _create_command_builder(self, command: str, tool_type: Optional[ToolType] = None,
-                             path_arguments: Optional[Collection[Path]] = None,
-                             *extras: Tuple[str, Optional[str]]) -> CommandBuilder:
+    def _create_command_builder(self,
+                                command: str,
+                                tool_type: Optional[ToolType] = None,
+                                path_arguments: Optional[list[Path]] = None,
+                                *extras: tuple[str, Optional[str]]) -> CommandBuilder:
         """
         Creates a CommandBuilder for the tool's wanted functionality.
         :param command: The command of the tool to build on.
@@ -45,8 +48,10 @@ class Tool(ABC):
 
         command_builder = CommandBuilder().set_execution_call(str(tool_type.value), self._path)
         try:
-            return command_builder.set_command_to_execute(command).add_path_arguments(*path_arguments).add_options(
-                *extras)
+            return (command_builder
+                    .set_command_to_execute(command)
+                    .add_path_arguments(*path_arguments)
+                    .add_options(*extras))
         except FileNotFoundError as e:
             self._logger.error(f"Encountered exception while building {tool_type.name} command. Error - {e}")
             if not self._catch:
@@ -54,25 +59,37 @@ class Tool(ABC):
             return command_builder.set_command_body(["--help"])
 
     @abstractmethod
-    def save_report(self, coverage_files: List[Union[Path, str]], target_dir: Path, report_format, report_formats,
-                    sourcecode_dir: Optional[Path], build_dir: Optional[Path],
-                    *extras: Tuple[str, Optional[str]]) -> Command:
+    def save_report(self,
+                    coverage_files: list[Path],
+                    target_dir: Path,
+                    sourcecode_dir: Optional[Path] = None,
+                    report_format: ReportFormat = None,
+                    report_formats: list[ReportFormat] = None,
+                    *extras: tuple[str, Optional[str]]) -> Command:
         """Builds a command to create a coverage report."""
         raise NotImplementedError
 
     @abstractmethod
-    def snapshot_coverage(self, session: str, target_dir: Path, target_file: Optional[Path],
-                          *extras: Tuple[str, Optional[str]]) -> Command:
+    def snapshot_coverage(self,
+                          session: str,
+                          target_dir: Path,
+                          target_file: Optional[Path],
+                          *extras: tuple[str, Optional[str]]) -> Command:
         """Builds a command to snapshot coverage data."""
         raise NotImplementedError
 
     @abstractmethod
-    def merge_coverage(self, coverage_files: List[Union[Path, str]], target_dir: Path, target_file: Optional[Path],
-                       *extras: Tuple[str, Optional[str]]) -> Command:
+    def merge_coverage(self,
+                       coverage_files: list[Path],
+                       target_dir: Path,
+                       target_file: Optional[Path],
+                       *extras: tuple[str, Optional[str]]) -> Command:
         """Builds a command to merge coverage files."""
         raise NotImplementedError
 
-    def reset_coverage(self, session: str, *extras: Tuple[str, Optional[str]]) -> Command:
+    def reset_coverage(self,
+                       session: str,
+                       *extras: tuple[str, Optional[str]]) -> Command:
         """
         Builds a command to reset coverage data.
         Uses next_command chaining to snapshot with --reset flag and then clean up temp file.
@@ -81,7 +98,7 @@ class Tool(ABC):
         :returns: A Command with chained cleanup command via next_command.
         """
         target_dir = Path(tempfile.gettempdir()) / r"crossfit"
-        extras = extras + (("--reset", None),)
+        extras += ("--reset", None),
 
         snapshot_command = self.snapshot_coverage(session, target_dir, None, *extras)
         cleanup_command = CommandBuilder().with_command(["rm", "-f", str(target_dir)]).build_command()

smokecrossfit-1.0.0a1/crossfit/tools/tool_factory.py

@@ -0,0 +1,23 @@
+from logging import Logger
+from pathlib import Path
+
+import crossfit.refs
+from crossfit.tools import Jacoco, DotnetCoverage
+from crossfit.models import ToolType
+
+
+def create_tool(tool_type: ToolType, tool_path: Path = None, logger: Logger = None, catch: bool = True):
+    """
+    Factory method to create a tool based on the specified type.
+    :param tool_type: The type of tool to create.
+    :param tool_path: Optional path to the tool executable.
+    :param logger: Optional logger instance for logging tool operations.
+    :param catch: Whether to catch exceptions during tool operations.
+    :return: An instance of the specified tool type.
+    """
+    if tool_type == ToolType.Jacoco:
+        return Jacoco(logger, tool_path or crossfit.refs.tools_dir, catch)
+    elif tool_type == ToolType.DotnetCoverage:
+        return DotnetCoverage(logger, tool_path or crossfit.refs.tools_dir, catch)
+    else:
+        raise ValueError(f"Unknown tool type: {tool_type}")

{smokecrossfit-0.0.0 → smokecrossfit-1.0.0a1}/pyproject.toml

@@ -4,12 +4,15 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "SmokeCrossFit"
-dynamic = ["version"]
+dynamic = ["version", "dependencies"]
 description = "A unified interface for various code coverage tools (JaCoCo, dotnet-coverage)"
 readme = "README.md"
 requires-python = ">=3.12"
 
-[tool.setuptools-scm]
+[tool.setuptools.dynamic]
+dependencies = { file = ["requirements.txt"] }
+
+[tool.setuptools_scm]
 
 [tool.setuptools.packages.find]
 include = ["crossfit*"]

{smokecrossfit-0.0.0 → smokecrossfit-1.0.0a1}/testing/conftest.py

@@ -1,8 +1,10 @@
 import logging
 import sys
+import pytest
+
 from pathlib import Path
+from crossfit import LocalExecutor
 
-import pytest
 
 @pytest.fixture(scope="session")
 def tests_dir_path() -> Path:
@@ -17,3 +19,7 @@ def logger() -> logging.Logger:
         lg.addHandler(handler)
     lg.setLevel(logging.DEBUG)
     return lg
+
+@pytest.fixture
+def local_executor(logger):
+    return LocalExecutor(logger, False, **{"check": True})

smokecrossfit-1.0.0a1/testing/sanity/test_dotnet_coverage.py

@@ -0,0 +1,142 @@
+import pytest
+import subprocess
+import shutil
+import os
+from pathlib import Path
+from crossfit import DotnetCoverage, Command
+from crossfit.executors import LocalExecutor
+from crossfit.models import CommandResult, ReportFormat
+
+# Path where global dotnet tools are installed
+DOTNET_TOOLS_PATH = os.path.expanduser("~/.dotnet/tools")
+
+
+def _get_dotnet_path():
+    """Find dotnet executable in PATH or common installation locations."""
+    # First try to find dotnet in PATH
+    dotnet_in_path = shutil.which("dotnet")
+    if dotnet_in_path:
+        return dotnet_in_path
+
+    # Fallback to common installation paths
+    common_paths = [
+        "/usr/local/share/dotnet/dotnet",  # macOS
+        "/usr/share/dotnet/dotnet",         # Linux
+        "/usr/bin/dotnet",                  # Linux alternative
+    ]
+    for path in common_paths:
+        if os.path.isfile(path) and os.access(path, os.X_OK):
+            return path
+
+    raise RuntimeError("dotnet executable not found. Please install .NET SDK.")
+
+
+def _get_dotnet_major_version(dotnet_path):
+    """Get the major version of the .NET SDK."""
+    try:
+        result = subprocess.run([dotnet_path, "--version"], capture_output=True, text=True, check=True)
+        version_str = result.stdout.strip()
+        major_version = int(version_str.split('.')[0])
+        return major_version
+    except Exception:
+        return None
+
+
+def _get_tool_versions(dotnet_path):
+    """Get compatible tool versions based on .NET SDK version."""
+    major_version = _get_dotnet_major_version(dotnet_path)
+
+    # For .NET 7 or older, use older compatible versions
+    if major_version is not None and major_version < 8:
+        return {
+            "dotnet-coverage": "17.13.0",
+            "dotnet-reportgenerator-globaltool": "5.2.5"
+        }
+    # For .NET 8+, let dotnet choose the latest compatible versions
+    return None
+
+
+@pytest.fixture(scope="module")
+def install_dotnet_tools():
+    """Install required dotnet tools before tests and uninstall after."""
+    dotnet_path = _get_dotnet_path()
+    tool_versions = _get_tool_versions(dotnet_path)
+
+    # Install the tools
+    if tool_versions:
+        subprocess.run([dotnet_path, "tool", "install", "--global", "dotnet-coverage",
+                       "--version", tool_versions["dotnet-coverage"]], check=False)
+        subprocess.run([dotnet_path, "tool", "install", "--global", "dotnet-reportgenerator-globaltool",
+                       "--version", tool_versions["dotnet-reportgenerator-globaltool"]], check=False)
+    else:
+        subprocess.run([dotnet_path, "tool", "install", "--global", "dotnet-coverage"], check=False)
+        subprocess.run([dotnet_path, "tool", "install", "--global", "dotnet-reportgenerator-globaltool"], check=False)
+
+    yield
+
+    # Cleanup: uninstall the tools after tests
+    subprocess.run([dotnet_path, "tool", "uninstall", "--global", "dotnet-coverage"], check=False)
+    subprocess.run([dotnet_path, "tool", "uninstall", "--global", "dotnet-reportgenerator-globaltool"], check=False)
+
+
+@pytest.fixture
+def dotnetcoverage_tool(logger, install_dotnet_tools):
+    return DotnetCoverage(logger, catch=True)
+
+
+@pytest.fixture
+def local_executor(logger, install_dotnet_tools):
+    # Add dotnet tools directory to PATH for subprocess execution
+    env = os.environ.copy()
+    env["PATH"] = f"{DOTNET_TOOLS_PATH}:{env.get('PATH', '')}"
+    return LocalExecutor(logger, False, **{"check": True, "env": env})
+
+
+@pytest.fixture
+def coverage_files(tests_dir_path):
+    return [Path(tests_dir_path / r"helpers/tools/dotnetcoverage/s1.cobertura.xml"),
+            Path(tests_dir_path / r"helpers/tools/dotnetcoverage/s2.cobertura.xml")]
+
+
+@pytest.fixture
+def target_dir(tests_dir_path):
+    target = Path(tests_dir_path / r"helpers/tools/dotnetcoverage/output/")
+    target.mkdir(parents=True, exist_ok=True)
+    return target
+
+
+@pytest.fixture
+def sourcecode_dir(tests_dir_path):
+    return Path(tests_dir_path / r"helpers/tools/dotnetcoverage/sourcecode/")
+
+
+@pytest.mark.parametrize("report_format, report_formats, expected_return_code", [
+    (None, [ReportFormat.Html, ReportFormat.Xml], 0),
+    (ReportFormat.Html, None, 0),
+    (ReportFormat.Xml, [], 0),
+], ids=[
+    "Csv_Report_With_Html_And_Xml",
+    "Html_Report",
+    "Xml_Report_Only",
+])
+def test_dotnetcoverage_execute_report(dotnetcoverage_tool, local_executor, coverage_files, target_dir, sourcecode_dir,
+                                       report_format, report_formats, expected_return_code):
+    command = dotnetcoverage_tool.save_report(
+        coverage_files, target_dir, sourcecode_dir, report_format, report_formats)
+
+    assert isinstance(command, Command)
+
+    result = local_executor.execute(command)
+    assert isinstance(result, CommandResult)
+    assert result.code == expected_return_code
+
+
+def test_dotnetcoverage_merge_coverage(dotnetcoverage_tool, local_executor, coverage_files, target_dir):
+    target_file = Path("merged")
+
+    command = dotnetcoverage_tool.merge_coverage(coverage_files, target_dir, target_file)
+    assert isinstance(command, Command)
+
+    result = local_executor.execute(command)
+    assert isinstance(result, CommandResult)
+    assert result.code == 0

{smokecrossfit-0.0.0 → smokecrossfit-1.0.0a1}/testing/sanity/test_jacoco.py

@@ -25,7 +25,9 @@ def coverage_files(tests_dir_path):
 
 @pytest.fixture
 def target_dir(tests_dir_path):
-    return Path(str(os.path.relpath(tests_dir_path / r"helpers/tools/jacoco/output/")))
+    target = Path(str(os.path.relpath(tests_dir_path / r"helpers/tools/jacoco/output/")))
+    target.mkdir(parents=True, exist_ok=True)
+    return target
 
 
 @pytest.fixture
@@ -54,9 +56,9 @@ def test_jacoco_execute_report(jacoco_tool, local_executor, coverage_files, targ
     command = jacoco_tool.save_report(
         coverage_files,
         target_dir,
+        sourcecode_dir,
         report_format,
         report_formats,
-        sourcecode_dir,
         classfiles_dir,
         *extras
     )
@@ -68,7 +70,7 @@ def test_jacoco_execute_report(jacoco_tool, local_executor, coverage_files, targ
     assert result.code == expected_return_code
 
 
-def test_jacoco_execute_report_files_wildcard(jacoco_tool, local_executor, target_dir, sourcecode_dir, classfiles_dir):
+def test_jacoco_execute_report_files_wildcard(jacoco_tool, local_executor, target_dir, sourcecode_dir, classfiles_dir, tests_dir_path):
     report_format = ReportFormat.Csv
     coverage_files = [Path(tests_dir_path / r"helpers/tools/jacoco/*.exec")]
     report_formats = [ReportFormat.Html, ReportFormat.Xml]
@@ -77,9 +79,9 @@ def test_jacoco_execute_report_files_wildcard(jacoco_tool, local_executor, targe
     command = jacoco_tool.save_report(
         coverage_files,
         target_dir,
+        sourcecode_dir,
         report_format,
         report_formats,
-        sourcecode_dir,
         classfiles_dir,
         *extras
     )

{smokecrossfit-0.0.0 → smokecrossfit-1.0.0a1}/testing/unit-tests/command_tests/test_command.py

@@ -1,9 +1,8 @@
 import copy
-from pathlib import Path
-
 import pytest
 
-from crossfit import Command
+from pathlib import Path
+from crossfit.commands.command import Command
 
 
 class TestCommand:

{smokecrossfit-0.0.0 → smokecrossfit-1.0.0a1}/testing/unit-tests/command_tests/test_command_builder.py

@@ -1,8 +1,9 @@
 import os.path
-from pathlib import Path
 import pytest
+
+from pathlib import Path
 from typeguard import TypeCheckError
-from crossfit import Command
+from crossfit.commands.command import Command
 from crossfit.commands.command_builder import CommandBuilder
 
 

{smokecrossfit-0.0.0 → smokecrossfit-1.0.0a1}/testing/unit-tests/tools_tests/test_dotnet_coverage.py

@@ -2,7 +2,6 @@ from pathlib import Path
 import pytest
 import crossfit
 from crossfit import DotnetCoverage, Command
-from crossfit.executors import LocalExecutor
 from crossfit.models import CommandResult, ReportFormat
 
 
@@ -11,11 +10,6 @@ def dotnetcoverage_tool(logger):
     return DotnetCoverage(logger, crossfit.refs.tools_dir, True)
 
 
-@pytest.fixture
-def local_executor(logger):
-    return LocalExecutor(logger, False, **{"check": True})
-
-
 @pytest.fixture
 def coverage_files(tests_dir_path):
     return [Path(tests_dir_path / r"helpers/tools/dotnetcoverage/s1.cobertura.xml"),

{smokecrossfit-0.0.0 → smokecrossfit-1.0.0a1}/testing/unit-tests/tools_tests/test_jacoco.py

@@ -3,7 +3,6 @@ from pathlib import Path
 import pytest
 import crossfit
 from crossfit import Jacoco, Command
-from crossfit.executors.local_executor import LocalExecutor
 from crossfit.models import CommandResult, ReportFormat
 
 
@@ -12,11 +11,6 @@ def jacoco_tool(logger):
     return Jacoco(logger, crossfit.refs.tools_dir, True)
 
 
-@pytest.fixture
-def local_executor(logger):
-    return LocalExecutor(logger, False, **{"check": True})
-
-
 @pytest.fixture
 def coverage_files(tests_dir_path):
     return [
@@ -61,9 +55,9 @@ def test_jacoco_execute_report(
     command = jacoco_tool.save_report(
         coverage_files,
         target_dir,
+        sourcecode_dir,
         report_format,
         report_formats,
-        sourcecode_dir,
         classfiles_dir,
     )
     assert isinstance(command, Command)

{smokecrossfit-0.0.0 → smokecrossfit-1.0.0a1}/testing/unit-tests/tools_tests/test_tool.py

@@ -1,13 +1,13 @@
 # test_tool.py
 import tempfile
+import pytest
+
 from pathlib import Path
 from typing import List, Optional, Tuple
 
-import pytest
-
 from crossfit.commands.command import Command
 from crossfit.commands.command_builder import CommandBuilder
-from crossfit.models.tool_models import ToolType
+from crossfit.models.tool_models import ToolType, ReportFormat
 from crossfit.tools.tool import Tool
 
 
@@ -18,9 +18,9 @@ class ConcreteTool(Tool):
     def __init__(self, logger, path: Optional[Path] = None, catch: bool = True):
         super().__init__(logger, path, catch)
 
-    def save_report(self, coverage_files: List[Path], target_dir: Path, report_format, report_formats,
-                    sourcecode_dir: Optional[Path], build_dir: Optional[Path],
-                    *extras: Tuple[str, Optional[str]]) -> Command:
+    def save_report(self, coverage_files: list[Path], target_dir: Path, sourcecode_dir: Optional[Path] = None,
+                    report_format: ReportFormat = None, report_formats: list[ReportFormat] = None,
+                    *extras: tuple[str, Optional[str]]) -> Command:
         return self._create_command_builder("report", None, coverage_files, *extras).build_command()
 
     def snapshot_coverage(self, session: str, target_dir: Path, target_file: Optional[str],
@@ -189,7 +189,7 @@ class TestToolAbstractMethods:
 
     def test_save_report_returns_command(self, tool):
         """Test that save_report returns a Command."""
-        command = tool.save_report([], Path("/output"), None, None, None, None)
+        command = tool.save_report([], Path("/output"), None, None, None)
         assert isinstance(command, Command)
 
     def test_snapshot_coverage_returns_command(self, tool):

smokecrossfit-0.0.0/crossfit/commands/__init__.py

@@ -1,3 +0,0 @@
-from .command import Command
-
-__all__ = ['Command']

smokecrossfit-0.0.0/crossfit/executors/executor_factory.py

@@ -1,8 +0,0 @@
-from crossfit.models.executor_models import ExecutorType
-from crossfit.executors.local_executor import LocalExecutor
-
-def create_executor(executor_type: ExecutorType, logger = None, catch: bool = True, **kwargs):
-    if executor_type == ExecutorType.Local:
-        return LocalExecutor(logger, catch, **kwargs)
-    else:
-        raise ValueError(f"Unknown executor type: {executor_type}")

smokecrossfit-0.0.0/crossfit/tools/tool_factory.py

@@ -1,20 +0,0 @@
-import os
-from logging import Logger
-from pathlib import Path
-from typing import Union
-
-import crossfit.refs
-from crossfit.tools import Jacoco, DotnetCoverage
-from crossfit.models import ToolType
-
-
-def create_tool(tool_type: ToolType, tool_path: str = None, cwd: Union[str, os.PathLike] = None, logger: Logger = None,
-                catch: bool = True, **kwargs):
-    if cwd:
-        kwargs["cwd"] = cwd
-    if tool_type == ToolType.Jacoco:
-        return Jacoco(logger, Path(tool_path) or Path(crossfit.refs.tools_dir), catch)
-    elif tool_type == ToolType.DotnetCoverage:
-        return DotnetCoverage(logger, Path(tool_path) or Path(crossfit.refs.tools_dir), catch)
-    else:
-        raise ValueError(f"Unknown tool type: {tool_type}")

smokecrossfit-0.0.0/testing/sanity/test_dotnet_coverage.py

@@ -1,63 +0,0 @@
-import pytest
-from pathlib import Path
-from crossfit import DotnetCoverage, Command
-from crossfit.executors import LocalExecutor
-from crossfit.models import CommandResult, ReportFormat
-
-
-@pytest.fixture
-def dotnetcoverage_tool(logger):
-    return DotnetCoverage(logger, catch=True)
-
-
-@pytest.fixture
-def local_executor(logger):
-    return LocalExecutor(logger, False, **{"check": True})
-
-
-@pytest.fixture
-def coverage_files(tests_dir_path):
-    return [Path(tests_dir_path / r"helpers/tools/dotnetcoverage/s1.cobertura.xml"),
-            Path(tests_dir_path / r"helpers/tools/dotnetcoverage/s2.cobertura.xml")]
-
-
-@pytest.fixture
-def target_dir(tests_dir_path):
-    return Path(tests_dir_path / r"helpers/tools/dotnetcoverage/output/")
-
-
-@pytest.fixture
-def sourcecode_dir(tests_dir_path):
-    return Path(tests_dir_path / r"helpers/tools/dotnetcoverage/sourcecode/")
-
-
-@pytest.mark.parametrize("report_format, report_formats, expected_return_code", [
-    (None, [ReportFormat.Html, ReportFormat.Xml], 0),
-    (ReportFormat.Html, None, 0),
-    (ReportFormat.Xml, [], 0),
-], ids=[
-    "Csv_Report_With_Html_And_Xml",
-    "Html_Report",
-    "Xml_Report_Only",
-])
-def test_dotnetcoverage_execute_report(dotnetcoverage_tool, local_executor, coverage_files, target_dir, sourcecode_dir,
-                                       report_format, report_formats, expected_return_code):
-    command = dotnetcoverage_tool.save_report(
-        coverage_files, target_dir, sourcecode_dir, report_format, report_formats)
-
-    assert isinstance(command, Command)
-
-    result = local_executor.execute(command)
-    assert isinstance(result, CommandResult)
-    assert result.code == expected_return_code
-
-
-def test_dotnetcoverage_merge_coverage(dotnetcoverage_tool, local_executor, coverage_files, target_dir):
-    target_file = Path("merged")
-
-    command = dotnetcoverage_tool.merge_coverage(coverage_files, target_dir, target_file)
-    assert isinstance(command, Command)
-
-    result = local_executor.execute(command)
-    assert isinstance(result, CommandResult)
-    assert result.code == 0