pjt222/write-testthat-tests

testthat-Tests schreiben

Umfassende Tests fuer R-Paketfunktionen mit testthat Edition 3 erstellen.

Wann verwenden

• Tests fuer neue Paketfunktionen hinzufuegen
• Testabdeckung fuer bestehenden Code erhoehen
• Regressionstests fuer Fehlerbehebungen schreiben
• Testinfrastruktur fuer ein neues Paket einrichten

Eingaben

• Erforderlich: Zu testende R-Funktionen
• Erforderlich: Erwartetes Verhalten und Grenzfaelle
• Optional: Test-Fixtures oder Beispieldaten
• Optional: Zielabdeckungsprozentsatz (Standard: 80%)

Vorgehensweise

Schritt 1: Testinfrastruktur einrichten

Falls noch nicht geschehen:

usethis::use_testthat(edition = 3)

Dies erstellt tests/testthat.R und das Verzeichnis tests/testthat/.

Erwartet: tests/testthat.R und Verzeichnis tests/testthat/ erstellt. DESCRIPTION hat Config/testthat/edition: 3 gesetzt.

Bei Fehler: Wenn usethis nicht verfuegbar ist, tests/testthat.R manuell erstellen mit dem Inhalt library(testthat); library(packagename); test_check("packagename") und das Verzeichnis tests/testthat/ hinzufuegen.

Schritt 2: Testdatei erstellen

usethis::use_test("function_name")

Erstellt tests/testthat/test-function_name.R mit einer Vorlage.

Erwartet: Testdatei unter tests/testthat/test-function_name.R erstellt mit einem Platzhalter-test_that()-Block zum Ausfuellen.

Bei Fehler: Wenn usethis::use_test() nicht verfuegbar ist, die Datei manuell erstellen. Die Namenskonvention test-<function_name>.R einhalten.

Schritt 3: Grundlegende Tests schreiben

test_that("weighted_mean computes correct result", {
  expect_equal(weighted_mean(1:3, c(1, 1, 1)), 2)
  expect_equal(weighted_mean(c(10, 20), c(1, 3)), 17.5)
})

test_that("weighted_mean handles NA values", {
  expect_equal(weighted_mean(c(1, NA, 3), c(1, 1, 1), na.rm = TRUE), 2)
  expect_true(is.na(weighted_mean(c(1, NA, 3), c(1, 1, 1), na.rm = FALSE)))
})

test_that("weighted_mean validates input", {
  expect_error(weighted_mean("a", 1), "numeric")
  expect_error(weighted_mean(1:3, 1:2), "length")
})

Erwartet: Grundlegende Tests decken korrekte Ausgaben fuer typische Eingaben, NA-Behandlungsverhalten und Eingabevalidierungs-Fehlermeldungen ab.

Bei Fehler: Wenn Tests sofort fehlschlagen, pruefen, ob die Funktion geladen ist (devtools::load_all()). Wenn Fehlermeldungen nicht uebereinstimmen, ein Regex-Muster in expect_error() statt eines exakten Strings verwenden.

Schritt 4: Grenzfaelle testen

test_that("weighted_mean handles edge cases", {
  # Empty input
  expect_error(weighted_mean(numeric(0), numeric(0)))

  # Single value
  expect_equal(weighted_mean(5, 1), 5)

  # Zero weights
  expect_true(is.nan(weighted_mean(1:3, c(0, 0, 0))))

  # Very large values
  expect_equal(weighted_mean(c(1e15, 1e15), c(1, 1)), 1e15)

  # Negative weights
  expect_error(weighted_mean(1:3, c(-1, 1, 1)))
})

Erwartet: Grenzfaelle sind abgedeckt: leere Eingabe, einzelne Werte, Nullgewichte, extreme Werte und ungueltigen Eingaben. Jeder Grenzfall hat ein klar definiertes erwartetes Verhalten.

Bei Fehler: Wenn die Funktion einen Grenzfall nicht wie erwartet behandelt, entscheiden, ob die Funktion oder der Test angepasst werden soll. Das beabsichtigte Verhalten fuer mehrdeutige Faelle dokumentieren.

Schritt 5: Fixtures fuer komplexe Tests verwenden

tests/testthat/fixtures/ fuer Testdaten erstellen:

# tests/testthat/helper.R (wird automatisch geladen)
create_test_data <- function() {
  data.frame(
    x = c(1, 2, 3, NA, 5),
    group = c("a", "a", "b", "b", "b")
  )
}

# In der Testdatei
test_that("process_data works with grouped data", {
  test_data <- create_test_data()
  result <- process_data(test_data)
  expect_s3_class(result, "data.frame")
  expect_equal(nrow(result), 2)
})

Erwartet: Fixtures stellen konsistente Testdaten ueber mehrere Testdateien hinweg bereit. Hilfsfunktionen in tests/testthat/helper.R werden von testthat automatisch geladen.

Bei Fehler: Wenn Hilfsfunktionen nicht gefunden werden, sicherstellen, dass die Datei helper.R heisst (nicht helpers.R) und sich in tests/testthat/ befindet. Die R-Sitzung bei Bedarf neu starten.

Schritt 6: Externe Abhaengigkeiten mocken

test_that("fetch_data handles API errors", {
  local_mocked_bindings(
    api_call = function(...) stop("Connection refused")
  )
  expect_error(fetch_data("endpoint"), "Connection refused")
})

test_that("fetch_data returns parsed data", {
  local_mocked_bindings(
    api_call = function(...) list(data = list(value = 42))
  )
  result <- fetch_data("endpoint")
  expect_equal(result$value, 42)
})

Erwartet: Externe Abhaengigkeiten (APIs, Datenbanken, Netzwerkaufrufe) werden gemockt, sodass Tests ohne echte Verbindungen laufen. Mock-Rueckgabewerte testen die Datenverarbeitungslogik der Funktion.

Bei Fehler: Wenn local_mocked_bindings() fehlschlaegt, sicherstellen, dass die zu mockende Funktion im Testbereich zugreifbar ist. Fuer Funktionen in anderen Paketen das Argument .package verwenden.

Schritt 7: Snapshot-Tests fuer komplexe Ausgaben

test_that("format_report produces expected output", {
  expect_snapshot(format_report(test_data))
})

test_that("plot_results creates expected plot", {
  expect_snapshot_file(
    save_plot(plot_results(test_data), "test-plot.png"),
    "expected-plot.png"
  )
})

Erwartet: Snapshot-Dateien werden in tests/testthat/_snaps/ erstellt. Der erste Lauf erstellt den Ausgangszustand; spaeteren Laeufe vergleichen damit.

Bei Fehler: Wenn Snapshots nach einer beabsichtigten Aenderung fehlschlagen, sie mit testthat::snapshot_accept() aktualisieren. Bei plattformuebergreifenden Unterschieden den Parameter variant verwenden, um plattformspezifische Snapshots zu pflegen.

Schritt 8: Uebersprungbedingungen verwenden

test_that("database query works", {
  skip_on_cran()
  skip_if_not(has_db_connection(), "No database available")

  result <- query_db("SELECT 1")
  expect_equal(result[[1]], 1)
})

test_that("parallel computation works", {
  skip_on_os("windows")
  skip_if(parallel::detectCores() < 2, "Need multiple cores")

  result <- parallel_compute(1:100)
  expect_length(result, 100)
})

Erwartet: Tests, die spezielle Umgebungen (Netzwerk, Datenbank, mehrere Kerne) erfordern, sind mit Uebersprungbedingungen abgesichert. Diese Tests laufen lokal, werden aber bei CRAN oder in eingeschraenkten CI-Umgebungen uebersprungen.

Bei Fehler: Wenn Tests bei CRAN oder CI fehlschlagen, lokal aber bestehen, die entsprechende Bedingung skip_on_cran(), skip_on_os() oder skip_if_not() am Anfang des test_that()-Blocks hinzufuegen.

Schritt 9: Tests ausfuehren und Abdeckung pruefen

# Alle Tests ausfuehren
devtools::test()

# Bestimmte Testdatei ausfuehren
devtools::test_active_file()  # in RStudio
testthat::test_file("tests/testthat/test-function_name.R")

# Abdeckung pruefen
covr::package_coverage()
covr::report()

Erwartet: Alle Tests bestehen mit devtools::test(). Der Abdeckungsbericht zeigt, dass der Zielprozentsatz erreicht wird (Ziel: >80%).

Bei Fehler: Wenn Tests fehlschlagen, die Testausgabe nach spezifischen Prueffehlem durchsuchen. Wenn die Abdeckung unter dem Ziel liegt, covr::report() verwenden, um nicht getestete Codepfade zu identifizieren und Tests hinzuzufuegen.

Validierung

• [ ] Alle Tests bestehen mit devtools::test()
• [ ] Abdeckung ueberschreitet den Zielprozentsatz
• [ ] Jede exportierte Funktion hat mindestens einen Test
• [ ] Fehlerbedingungen werden getestet
• [ ] Grenzfaelle sind abgedeckt (NA, NULL, leer, Grenzwerte)
• [ ] Keine Tests haengen von externem Zustand oder Ausfuehrungsreihenfolge ab

Haeufige Stolperfallen

• Voneinander abhaengige Tests: Jeder test_that()-Block muss unabhaengig sein
• Hartcodierte Dateipfade: testthat::test_path() fuer Test-Fixtures verwenden
• Gleitkommavergleich: expect_equal() (hat Toleranz) statt expect_identical() verwenden
• Private Funktionen testen: Moeglichst ueber die oeffentliche API testen. ::: sparsam verwenden.
• Snapshot-Tests in CI: Snapshots sind plattformsensitiv. Parameter variant fuer plattformuebergreifende Tests verwenden.
• skip_on_cran() vergessen: Tests, die Netzwerk, Datenbanken oder lange Laufzeit erfordern, muessen bei CRAN uebersprungen werden

Beispiele

# Muster: Testdatei spiegelt R/-Datei
# R/weighted_mean.R -> tests/testthat/test-weighted_mean.R

# Muster: Beschreibende Testnamen
test_that("weighted_mean returns NA when na.rm = FALSE and input contains NA", {
  result <- weighted_mean(c(1, NA), c(1, 1), na.rm = FALSE)
  expect_true(is.na(result))
})

# Muster: Warnungen testen
test_that("deprecated_function emits deprecation warning", {
  expect_warning(deprecated_function(), "deprecated")
})

Verwandte Skills

• create-r-package - Testinfrastruktur als Teil der Paketerstellung einrichten
• write-roxygen-docs - die getesteten Funktionen dokumentieren
• setup-github-actions-ci - Tests automatisch bei Push ausfuehren
• submit-to-cran - CRAN erfordert, dass Tests auf allen Plattformen bestehen