Rust Testing Framework Integration $350

[rparcus]

Overview

Implement a testing framework for Rust code in Lux, enabling seamless integration with the existing test infrastructure and comprehensive test coverage.

Core Features

• Rust test runner
• Integration with mix test
• Coverage reporting
• Cross-language test utilities
• Test fixtures and helpers

Technical Details

• Implement Rust test runner
• Create integration with mix test
• Set up coverage reporting
• Add cross-language test utilities
• Implement test fixtures and helpers

Acceptance Criteria

• Implement Rust test runner
• Create integration with mix test
• Set up coverage reporting
• Add cross-language test utilities
• Implement test fixtures and helpers
• Add documentation for testing
• Include examples of Rust tests

Budget: $350

[saimuren]

/attempt #I'm working on the Rust integration suite (#100, #101, #102) to build a unified native performance layer.

[saimuren]

/attempt #I'm working on the Rust integration suite (#100, #101, #102) to build a unified native performance layer.

[KimberleyOCaseyfv]

Claim: Rust Testing Framework Integration - Technical Proposal

Hi @Spectral-Finance team,

I'd like to work on this Rust testing framework integration. Based on my analysis of Lux's architecture and Rust-Elixir interoperability requirements, here's my comprehensive proposal:

---

1. Technical Solution

Architecture (integrating with existing Lux test infrastructure):

priv/rust/testing/
├── rust_test_runner.ex          # Elixir test runner module
├── cargo_test_wrapper.sh        # Cargo test wrapper script
├── coverage/
│   ├── grcov_parser.ex          # Grcov coverage report parser
│   └── coverage_reporter.ex     # Coverage report generator
├── fixtures/
│   ├── rust_test_fixture.ex     # Test fixtures for Rust tests
│   └── cross_lang_helpers.ex    # Elixir-Rust test utilities
└── mix/tasks/
    ├── rust.test.ex             # mix rust.test task
    └── rust.test.coverage.ex    # mix rust.test.coverage task

priv/rust/
└── tests/
    ├── test_helpers.rs          # Rust test helpers
    └── integration_tests.rs     # Example integration tests

Core Implementation:

A. Rust Test Runner (Elixir):

defmodule Lux.Rust.TestRunner do
  @moduledoc """
  Test runner for Rust code in Lux framework.
  Integrates with mix test and provides seamless testing experience.
  """
  
  @doc """
  Run all Rust tests with cargo
  
  ## Options
  - :verbose - Show detailed output
  - :filter - Run only tests matching pattern
  - :coverage - Generate coverage report
  
  ## Examples
      iex> Lux.Rust.TestRunner.run()
      :ok
      
      iex> Lux.Rust.TestRunner.run(verbose: true, filter: "integration")
      :ok
  """
  def run(opts \\ []) do
    cargo_args = build_cargo_args(opts)
    
    case System.cmd("cargo", ["test"] ++ cargo_args, 
                    cd: rust_project_path(),
                    stderr_to_stdout: true) do
      {output, 0} -> 
        parse_test_results(output)
        :ok
      {output, _} ->
        IO.puts(output)
        {:error, :tests_failed}
    end
  end
  
  defp build_cargo_args(opts) do
    args = []
    args = if opts[:verbose], do: args ++ ["--", "--nocapture"], else: args
    args = if opts[:filter], do: args ++ [opts[:filter]], else: args
    args
  end
  
  defp parse_test_results(output) do
    # Parse cargo test output and format like ExUnit
    results = Regex.scan(~r/test result: (\w+). (\d+) passed; (\d+) failed/, output)
    
    case results do
      [[_, "ok", passed, "0"]] ->
        IO.puts("\nRust Tests: #{passed} passed")
      [[_, _, passed, failed]] ->
        IO.puts("\nRust Tests: #{passed} passed, #{failed} failed")
      _ ->
        IO.puts(output)
    end
  end
end

B. Mix Task Integration:

defmodule Mix.Tasks.Rust.Test do
  @moduledoc """
  Run Rust tests in Lux framework
  
  ## Usage
      mix rust.test              # Run all Rust tests
      mix rust.test --verbose    # Show detailed output
      mix rust.test --coverage   # Generate coverage report
      mix rust.test pattern      # Run tests matching pattern
  """
  
  use Mix.Task
  
  @shortdoc "Run Rust tests"
  
  def run(args) do
    {opts, _, _} = OptionParser.parse(args,
      switches: [verbose: :boolean, coverage: :boolean],
      aliases: [v: :verbose, c: :coverage]
    )
    
    # Ensure Rust code is compiled
    Mix.Task.run("rust.compile")
    
    # Run tests
    result = Lux.Rust.TestRunner.run(
      verbose: opts[:verbose],
      coverage: opts[:coverage]
    )
    
    case result do
      :ok -> exit(:normal)
      {:error, _} -> exit({:shutdown, 1})
    end
  end
end

C. Coverage Reporting:

defmodule Lux.Rust.Coverage do
  @moduledoc """
  Coverage reporting for Rust tests using grcov
  """
  
  @doc """
  Generate coverage report for Rust code
  
  ## Options
  - :format - Report format (lcov, html, cobertura)
  - :output - Output directory
  
  ## Examples
      iex> Lux.Rust.Coverage.generate()
      :ok
  """
  def generate(opts \\ []) do
    format = opts[:format] || "lcov"
    output = opts[:output] || "cover/rust"
    
    # Set environment variables for coverage
    env = [
      {"CARGO_INCREMENTAL", "0"},
      {"RUSTFLAGS", "-Cinstrument-coverage"},
      {"LLVM_PROFILE_FILE", "rust-coverage-%p-%m.profraw"}
    ]
    
    # Run tests with coverage
    System.cmd("cargo", ["test"], env: env, cd: rust_project_path())
    
    # Generate report with grcov
    System.cmd("grcov", [
      ".",
      "--binary-path", "./target/debug/deps",
      "-s", ".",
      "-t", format,
      "--branch",
      "--ignore-not-existing",
      "-o", output
    ], cd: rust_project_path())
    
    :ok
  end
  
  @doc """
  Get coverage percentage summary
  """
  def summary do
    # Parse lcov file and calculate coverage
    lcov_path = Path.join(rust_project_path(), "cover/rust/lcov.info")
    
    if File.exists?(lcov_path) do
      parse_lcov(lcov_path)
    else
      {:error, :no_coverage_data}
    end
  end
  
  defp parse_lcov(path) do
    content = File.read!(path)
    
    # Parse LF (lines found) and LH (lines hit)
    lines_found = Regex.scan(~r/LF:(\d+)/, content) |> Enum.map(fn [_, n] -> String.to_integer(n) end) |> Enum.sum()
    lines_hit = Regex.scan(~r/LH:(\d+)/, content) |> Enum.map(fn [_, n] -> String.to_integer(n) end) |> Enum.sum()
    
    percentage = if lines_found > 0, do: (lines_hit / lines_found * 100) |> Float.round(2), else: 0.0
    
    %{
      lines_found: lines_found,
      lines_hit: lines_hit,
      percentage: percentage,
      status: if(percentage >= 80, do: :pass, else: :fail)
    }
  end
end

D. Cross-Language Test Utilities:

defmodule Lux.Rust.Test.Fixtures do
  @moduledoc """
  Test fixtures and utilities for Rust-Elixir integration tests
  """
  
  @doc """
  Create a temporary Rust project for testing
  
  ## Examples
      iex> {:ok, path} = Lux.Rust.Test.Fixtures.temp_rust_project()
      iex> String.ends_with?(path, "/test_project")
      true
  """
  def temp_rust_project do
    # Create temp directory with Cargo.toml and basic structure
    temp_dir = System.tmp_dir!()
    project_path = Path.join(temp_dir, "lux_test_#{:rand.uniform(10000)}")
    
    File.mkdir_p!(project_path)
    
    # Create Cargo.toml
    File.write!(Path.join(project_path, "Cargo.toml"), """
    [package]
    name = "test_project"
    version = "0.1.0"
    edition = "2021"
    
    [dependencies]
    """)
    
    # Create src/lib.rs
    File.mkdir_p!(Path.join(project_path, "src"))
    File.write!(Path.join(project_path, "src/lib.rs"), "// Test lib
")
    
    {:ok, project_path}
  end
  
  @doc """
  Setup test environment with cleanup
  
  ## Examples
      iex> Lux.Rust.Test.Fixtures.setup_test_env(fn path ->
      ...>   # Run tests with temp project
      ...>   assert File.exists?(Path.join(path, "Cargo.toml"))
      ...> end)
      :ok
  """
  def setup_test_env(callback) do
    {:ok, path} = temp_rust_project()
    
    try do
      callback.(path)
    after
      # Cleanup
      File.rm_rf!(path)
    end
  end
end

---

2. Performance Estimation

Metric	Value	Notes
Test Discovery	<100ms	Fast cargo test listing
Test Execution	Depends on test count	Native Rust performance
Coverage Generation	2-5s	Grcov processing time
Mix Integration	<50ms	Task dispatch overhead
Memory Usage	<50MB	Test runner footprint

Comparison with Native:

• Rust test execution: Same as cargo test
• Reporting: Adds ~200ms for parsing
• Coverage: Adds 3-5s for grcov processing

---

3. Technical Q&A

Q1: How to integrate with existing mix test?

A: Hook into test runner:

# In test_helper.exs
ExUnit.configure(
  formatters: [Lux.Rust.Test.Formatter]
)

# After Elixir tests, run Rust tests
ExUnit.after_suite(fn _ ->
  Lux.Rust.TestRunner.run()
end)

Q2: How to handle Rust compilation errors during tests?

A: Pre-compile check:

defp ensure_compiled do
  case System.cmd("cargo", ["check"], cd: rust_path()) do
    {_, 0} -> :ok
    {output, _} ->
      IO.puts(:stderr, "Rust compilation failed:")
      IO.puts(:stderr, output)
      exit({:shutdown, 1})
  end
end

Q3: Cross-language test coordination?

A: Shared test fixtures:

# Elixir sets up test data
{:ok, data} = TestData.generate()

# Write to file for Rust
File.write!("test_data.json", Jason.encode!(data))

# Run Rust test that reads the file
System.cmd("cargo", ["test", "integration"], env: [{"TEST_DATA", "test_data.json"}])

Q4: Coverage reporting integration?

A: Unified coverage report:

# Combine Elixir and Rust coverage
elixir_cov = read_excoveralls()
rust_cov = Lux.Rust.Coverage.summary()

%{
  elixir: elixir_cov,
  rust: rust_cov,
  combined: calculate_combined(elixir_cov, rust_cov)
}

Q5: Test parallelization?

A: Use cargo test --jobs N:

defp parallel_jobs do
  System.schedulers_online()
end

System.cmd("cargo", ["test", "--jobs", to_string(parallel_jobs())])

---

4. Timeline

Phase	Duration	Deliverables
Research	2h	Study existing Lux test structure, Rustler integration
Test Runner	3h	Lux.Rust.TestRunner module, cargo integration
Mix Tasks	2h	mix rust.test, mix rust.test.coverage tasks
Coverage	2h	Grcov integration, coverage reporting
Fixtures	2h	Test fixtures, cross-lang utilities
Testing	2h	Unit tests, integration tests (>80% coverage)
Documentation	2h	README, examples, usage guide
Total	15h	~2 days

Buffer: +3h for review feedback

---

5. Experience

Related Projects:

• Elixir-Rust Integration: Built Rustler-based NIFs with test suites
• Testing Frameworks: Experience with ExUnit, Rust test, pytest
• Coverage Tools: Worked with grcov, tarpaulin, coveralls
• Lux Contributions: Familiar with Lux architecture (see previous claims)

Technical Background:

• 5+ years Elixir/Erlang development
• 3+ years Rust systems programming
• Built cross-language test suites before
• Experience with cargo, mix, and CI integration

---

Ready to Start

I have a clear understanding of the requirements and can begin implementation immediately upon approval.

Approach: Start with core test runner, add mix integration, then coverage and fixtures.

Looking forward to your feedback!

cc: @maintainers

[Robertg761]

/attempt #102

I am submitting a focused Rust testing framework integration for the $350 bounty: a cargo-backed Lux.Rust.TestRunner, mix rust.test / rust.test.coverage tasks, temp Rust fixture helpers, deterministic result parsing, docs, and unit coverage that does not depend on live services. I will keep it scoped to the test infrastructure layer so it can land before or alongside deeper Rust runtime work.