Tests

• Data parsing and format conversion
• Statistical calculations (compare against hand-computed values or reference implementations)
• Edge cases: empty inputs, single-element inputs, missing values
• String/ID manipulation (off-by-one errors in genomic coordinates are common)

2. Integration Tests

Verify that pipeline steps connect correctly:

• Output format from step A matches expected input format for step B
• Intermediate files are produced with expected structure
• Database/API connections work (if applicable)
• File paths resolve correctly across environments

3. Regression Tests

Capture outputs from a "known good" run and compare future runs against them:

• Store checksums or key output values (not entire large files)
• Useful when you cannot derive expected outputs analytically
• Catches silent breakage from dependency updates or code changes
• Update baselines deliberately when expected behavior changes

4. End-to-End Tests

Run the full pipeline on a small, curated test dataset:

• Dataset must be small enough to complete in minutes, not hours
• Include representative complexity (multiple samples, edge cases)
• Store test data in version control or a stable URL
• Validates the entire execution path including environment setup

5. Negative Tests

Verify the pipeline fails gracefully on bad input:

• Malformed input files, missing columns, wrong formats
• Missing required files or directories
• Invalid parameter combinations
• Out-of-range values

pytest (Python)

# tests/test_analysis.py
import pytest
import numpy as np
from mypackage.analysis import normalize, differential_expression

def test_normalize_basic():
    """Known input/output pair."""
    raw = np.array([[10, 20], [30, 40]])
    result = normalize(raw)
    expected = np.array([[0.25, 0.5], [0.75, 1.0]])
    np.testing.assert_allclose(result, expected, rtol=1e-5)

def test_normalize_empty():
    """Edge case: empty input."""
    with pytest.raises(ValueError, match="empty"):
        normalize(np.array([]))

def test_normalize_single_sample():
    """Edge case: single sample."""
    raw = np.array([[5, 10]])
    result = normalize(raw)
    assert result.shape == (1, 2)

@pytest.fixture
def small_dataset(tmp_path):
    """Create a minimal test dataset."""
    data_file = tmp_path / "counts.csv"
    data_file.write_text("gene,sample1,sample2\nTP53,100,200\nBRCA1,50,75\n")
    return data_file

def test_differential_expression(small_dataset):
    """Integration test with fixture."""
    result = differential_expression(small_dataset)
    assert "pvalue" in result.columns
    assert all(result["pvalue"] >= 0)
    assert all(result["pvalue"] <= 1)

Run tests:

# Load Python on Gizmo
ml fhPython/3.11.3-foss-2023a

# Run all tests
pytest tests/ -v

# Run with coverage
pytest tests/ --cov=mypackage --cov-report=term-missing

# Run a specific test
pytest tests/test_analysis.py::test_normalize_basic

pytest fixtures for scientific code

@pytest.fixture(scope="session")
def reference_genome(tmp_path_factory):
    """Download or create a small reference genome for testing.
    Session-scoped so it's only created once per test run."""
    ref_dir = tmp_path_factory.mktemp("reference")
    ref_file = ref_dir / "chr22_subset.fa"
    # Create a minimal FASTA or copy from test data
    ref_file.write_text(">chr22\nACGTACGTACGT\n")
    return ref_file

testthat (R)

# tests/testthat/test-analysis.R
library(testthat)

test_that("normalize_counts returns expected values", {
  raw <- matrix(c(10, 30, 20, 40), nrow = 2)
  result <- normalize_counts(raw)
  expect_equal(dim(result), c(2, 2))
  expect_true(all(result >= 0 & result <= 1))
})

test_that("normalize_counts rejects empty input", {
  expect_error(normalize_counts(matrix(nrow = 0, ncol = 0)), "empty")
})

test_that("differential_expression returns valid p-values", {
  # Use a small built-in or bundled dataset
  result <- run_de(test_counts, test_metadata)
  expect_true(all(result$pvalue >= 0 & result$pvalue <= 1))
  expect_true("log2FoldChange" %in% colnames(result))
})

Run tests:

# In R on Gizmo
ml R/4.4.1-foss-2023b
R -e 'testthat::test_dir("tests/testthat")'

# Or from within R