From 51218917d8d3075c5b53fb98a39c7745ae4a5dfe Mon Sep 17 00:00:00 2001 From: Hadley Wickham Date: Wed, 5 Nov 2025 09:06:56 -0600 Subject: [PATCH 01/10] testthat 3.3.0 First draft --- .gitignore | 3 + content/blog/testhat-3-3-0/index.Rmd | 166 +++++++++++++++++++++++++++ 2 files changed, 169 insertions(+) create mode 100644 content/blog/testhat-3-3-0/index.Rmd diff --git a/.gitignore b/.gitignore index aa8a25777..6d69e073d 100644 --- a/.gitignore +++ b/.gitignore @@ -6,4 +6,7 @@ public .DS_Store README.html +# Don't accidentally commit quarto generated files /.quarto/ +content/**/index_files/** +content/**/index.html diff --git a/content/blog/testhat-3-3-0/index.Rmd b/content/blog/testhat-3-3-0/index.Rmd new file mode 100644 index 000000000..0d57a5aef --- /dev/null +++ b/content/blog/testhat-3-3-0/index.Rmd @@ -0,0 +1,166 @@ +--- +output: hugodown::hugo_document + +slug: testhat-3-3-0 +title: testhat 3 3 0 +date: 2025-11-05 +author: Hadley Wickham +description: > + A 2-3 sentence description of the post that appears on the articles page. + This can be omitted if it would just recapitulate the title. + +photo: + url: https://unsplash.com/photos/n6vS3xlnsCc + author: Kelley Bozarth + +# one of: "deep-dive", "learn", "package", "programming", "roundup", or "other" +categories: [package] +tags: [] +--- + +```{r} +#| include: false +knitr::opts_chunk$set(collapse = TRUE, comment = "#>") +``` + + + +We're chuffed to announce the release of []({ home }) . is ... + +You can install it from CRAN with: + +```{r, eval = FALSE} +install.packages("{package}") +``` + +This blog post will ... + +You can see a full list of changes in the [release notes]({ github_release }) + +```{r setup} +library(testthat) +``` + +## Claude code experiences + +I also used this version of testthat as an opportunity to learn claude code, and hence it's the first project where I've really used AI to support development of many features + +* `settings.json` - +* `CLAUDE.md` - + +Overall it was a successful experiement and helped me close over a 100 issues, in what felt like less time than usual. Overall, while there might have been a few specific cases where I got 2x performance, on average it feels more like a 10-20% improvement. Obviously this is still significant, especially since I'm already an experienced R programmer. I mostly used it for smaller well-defined tasks where I had a good sense of what was needed. I found it particularly useful for refactoring. It was rare for me to accept what it did as is, but often it got me started. + +I also found it generally useful for getting over the "activation energy hump". There were a few issues that had been stangnating for years because they felt like they were going to be hard to do, and with relatively limited payoff. I let claude code lose on a few of these and found it super useful. Again, it only produced code I was happy with a couple of times, but every time it gave me something to react too (often with strong negative feelings!) and that got me started actually engaging with the problem. + +## Lifecycle changes + +The biggest change in this release is that `local_mock()` and `with_mock()` are now defunct. They were deprecated in 3.0.0 (2020-10-31) because the technique that made them work is no longer permitted in R 4.5.0. This was a fairly disruptive change, affecting ~100 CRAN packages, but it had to be done, and I've been working on notifying package developers since January so everyone had plenty of time to update. (Fortunately the changes needed were also generally small). + +Other changes: + +* testthat now requires R 4.1. This is in line [with our supported version policy](https://tidyverse.org/blog/2019/04/r-version-support/) where we support five version of R. Importantly means that we can now use the base pipe and the short-form of `function() {}`, `\() {}`. This is exciting for us! + +* `is_null()`/`matches()`, deprecated in 2.0.0 (2017-12-19), and `is_true()`/`is_false()`, deprecated in 2.1.0 (2019-04-23), have been removed. These conflicted with other tidyverse functions so we pushed their deprecation through, even though we have largely left the old form of testthat (which uses `test_that()`) largely untouched. + +* `expect_snapshot(binary)`, soft deprecated in 3.0.3 (2021-06-16), is now fully deprecated. `test_files(wrap)`, deprecated in 3.0.0 (2020-10-31) has now been removed. + +* There are a few other changes that broke existing packaes listed below. The most impactful change was to start checking the inputs to `expect()` which (unfortunately, depsite the name) is an internal helper. That revealed a surprising number of packages were accidentally using it instead of `expect_true()` or `expect_equal()`. We technically don't consider this a breaking change because it revealed off-label usage of existing functions. + +## Expectations and the interactive testing experience + +A lot of work in this version was prompted by an overhaul of `vignette("custom-expectations")`. This was motivated by _finally_ creating some decent documentation about how to write your own expectations. But as I worked on this vignette, I realised that I didn't really know how to write new expectations and there was a lot of variation in how existing expectations were written. So this kick off a bunch of changes: + +* All `expect_` functions have had their failure messages rewritten. They now all state what was expected, what was actually received, and, if possible, clearly illustrate the difference. + +* They consistently return the value of the first argument, regardless of whether the expectation succeeds or fails (the only exception is `expect_message()` and friends which return the condition). This shouldn't affect existing tests, but will make failures clearer when you chain together multiple expectations. + +* A new `pass()` function makes it clear how to signal when an expectation succeeds. + +* Revised `expect_success()` and `expect_failure()` functions test that an expectation follows the expectation contract: each call of an `expect_` function should return exactly one success or failure (this ensures that the counts you see in the reporters are always correct). + +This framework helped us write six new expectations: + +* New `expect_all_equal()`, `expect_all_true()`, and `expect_all_false()` check that every element of a vector has the same value, giving better error messages than `expect_true(all(...))`. + + ```{r} + #| error: true + + test_that("some test", { + x <- c(0.408, 0.961, 0.883, 0.46, 0.537, 0.961, 0.851, 0.887, 0.023) + expect_all_true(x < 0.95) + }) + ``` + +* New `expect_disjoint()` expects values to to be absent. + + ```{r} + #| error: true + + test_that("", { + expect_disjoint(c("a", "b", "c"), c("c", "d", "e")) + }) + ``` + +* New `expect_r6_class()` expects an R6 object. + + ```{r} + #| error: true + + test_that("", { + x <- 10 + expect_r6_class(x, "foo") + + x <- R6::R6Class("bar")$new() + expect_r6_class(x, "foo") + }) + ``` + +* New `expect_shape()` expects a specific shape (i.e., `nrow()`, `ncol()`, or `dim()`). + + ```{r} + #| error: true + + test_that("show off expect_shape() failure messages", { + x <- matrix(1:9, nrow = 3) + expect_shape(x, nrow = 4) + expect_shape(x, dim = c(3, 3, 3)) + expect_shape(x, dim = c(3, 4)) + }) + ``` + +As I wrote this vignette, I also realised that the interactive behaviour of `test_that()` (i.e. when you execute a single test at the console, not as part of a test suite) could be improved so you now see the number of successes and failures. You'll notice that in the examples above. + + +## Other new features + +* I've generally consider the case of nested tests (i.e. putting a `test_that()` inside another `test_that()`, or more typically `it()` inside of `describe()`). They should now generally generate more informative failure messages, free from duplication, with more informative skips if any of the subtests are empty. + +* On CRAN, `test_that()` will automatically skip if a package is not installed, which means that you no longer need to check if suggested packages are installed in your tests. + +* New `vignette("mocking")` explains mocking in detail, and `local_mocked_s3_method()`, `local_mocked_s4_method()`, and `local_mocked_r6_class()` make it easier to mock S3 and S4 methods and R6 classes. + +* `test_dir()`, `test_check()`, and friends gain a `shuffle` argument that uses `sample()` to randomly reorder the top-level expressions in each test file. This random reordering surfaces dependencies between tests and code outside of any test, as well as dependencies between tests. This helps you find and eliminate unintentional dependencies. + +* `try_again()` is now publicised, making it easier to test flaky code. We changed the first argument to represent the number of retries, not tries. + +* New `skip_unless_r()` skip tests on unsuitable versions of R. It has a convenient sytnax so you can use, e.g., `skip_unless_r(">= 4.1.0")` to skip tests that require `...names()`. + +* We put a lot of work into the snapshot experience, fixing all known bug and adding some new helpers. `snapshot_reject()` rejects all modified snapshots by deleting the `.new` variants, and `snapshot_download_gh()` makes it easy to get snapshots off GitHub and into your local package. `expect_snapshot()` and friends will now fail when creating a new snapshot on CI. This is usually a signal that you've forgotten to run it locally before committing. + +* New `SlowReporter` makes it easier to find the slowest tests in your package. You can run it with `devtools::test(reporter = "slow")`. + +* New `vignette("challenging-functions")` provides an index to other documentation organised by various challenges (#1265). + + +## Acknowledgements From 693a1a7776cc00b65ed735aacfa9b51a4f6fa111 Mon Sep 17 00:00:00 2001 From: Hadley Wickham Date: Wed, 5 Nov 2025 10:49:51 -0600 Subject: [PATCH 02/10] Mention review bot --- content/blog/testhat-3-3-0/index.Rmd | 2 ++ 1 file changed, 2 insertions(+) diff --git a/content/blog/testhat-3-3-0/index.Rmd b/content/blog/testhat-3-3-0/index.Rmd index 0d57a5aef..385157f56 100644 --- a/content/blog/testhat-3-3-0/index.Rmd +++ b/content/blog/testhat-3-3-0/index.Rmd @@ -63,6 +63,8 @@ Overall it was a successful experiement and helped me close over a 100 issues, i I also found it generally useful for getting over the "activation energy hump". There were a few issues that had been stangnating for years because they felt like they were going to be hard to do, and with relatively limited payoff. I let claude code lose on a few of these and found it super useful. Again, it only produced code I was happy with a couple of times, but every time it gave me something to react too (often with strong negative feelings!) and that got me started actually engaging with the problem. +I also experimented with using claude code to review PRs. It was just barely useful enough that I kept it turned on for my own PRs, but didn't bother trying to get it to work for contributed PRs. Most of the time it either gave a thumbs up or bad advice. But every now and then it would pick up a smaller error. + ## Lifecycle changes The biggest change in this release is that `local_mock()` and `with_mock()` are now defunct. They were deprecated in 3.0.0 (2020-10-31) because the technique that made them work is no longer permitted in R 4.5.0. This was a fairly disruptive change, affecting ~100 CRAN packages, but it had to be done, and I've been working on notifying package developers since January so everyone had plenty of time to update. (Fortunately the changes needed were also generally small). From c21d3835529400a45efc856c24bccfb397b37fbe Mon Sep 17 00:00:00 2001 From: Hadley Wickham Date: Thu, 6 Nov 2025 08:39:00 -0600 Subject: [PATCH 03/10] Hacking it into shape --- content/blog/testhat-3-3-0/index.Rmd | 66 +++++++++++++++++----------- 1 file changed, 41 insertions(+), 25 deletions(-) diff --git a/content/blog/testhat-3-3-0/index.Rmd b/content/blog/testhat-3-3-0/index.Rmd index 385157f56..73190c6ac 100644 --- a/content/blog/testhat-3-3-0/index.Rmd +++ b/content/blog/testhat-3-3-0/index.Rmd @@ -67,33 +67,33 @@ I also experimented with using claude code to review PRs. It was just barely use ## Lifecycle changes -The biggest change in this release is that `local_mock()` and `with_mock()` are now defunct. They were deprecated in 3.0.0 (2020-10-31) because the technique that made them work is no longer permitted in R 4.5.0. This was a fairly disruptive change, affecting ~100 CRAN packages, but it had to be done, and I've been working on notifying package developers since January so everyone had plenty of time to update. (Fortunately the changes needed were also generally small). +The biggest change in this release is that `local_mock()` and `with_mock()` are now defunct. They were deprecated in 3.0.0 (2020-10-31) because it was becoming increasing clear that the technique that made them work was going to be removed from R. This has happened in R 4.5.0, leading to their removal. This was a fairly disruptive change, affecting ~100 CRAN packages, but it had to be done, and I've been working on notifying package developers since January so everyone had plenty of time to update. Fortunately, the needed changes are generally small, since the newer `local_mocked_bindings()` and `with_mocked_binding()` can solve most additional needs. I also wrote `vignette("mocking")` to make it easier to understand when and how to use mocking. -Other changes: +Other lifecycle changes: -* testthat now requires R 4.1. This is in line [with our supported version policy](https://tidyverse.org/blog/2019/04/r-version-support/) where we support five version of R. Importantly means that we can now use the base pipe and the short-form of `function() {}`, `\() {}`. This is exciting for us! +* testthat now requires R 4.1. This follows [our supported version policy](https://tidyverse.org/blog/2019/04/r-version-support/), which documents our commitment to support five version of R (the current and four previous). We are excited to be able to finally take advantage of the base pipe and compact anonymous functions (i.e. `\(x) x + 1`). -* `is_null()`/`matches()`, deprecated in 2.0.0 (2017-12-19), and `is_true()`/`is_false()`, deprecated in 2.1.0 (2019-04-23), have been removed. These conflicted with other tidyverse functions so we pushed their deprecation through, even though we have largely left the old form of testthat (which uses `test_that()`) largely untouched. +* `is_null()`/`matches()`, deprecated in 2.0.0 (2017-12-19), and `is_true()`/`is_false()`, deprecated in 2.1.0 (2019-04-23), have been removed. These conflicted with other tidyverse functions so we pushed their deprecation through, even though we have generally left the old `test_that()` API untouched. * `expect_snapshot(binary)`, soft deprecated in 3.0.3 (2021-06-16), is now fully deprecated. `test_files(wrap)`, deprecated in 3.0.0 (2020-10-31) has now been removed. -* There are a few other changes that broke existing packaes listed below. The most impactful change was to start checking the inputs to `expect()` which (unfortunately, depsite the name) is an internal helper. That revealed a surprising number of packages were accidentally using it instead of `expect_true()` or `expect_equal()`. We technically don't consider this a breaking change because it revealed off-label usage of existing functions. +* There were a few other changes that broke existing packages. The most impactful change was to start checking the inputs to `expect()` which, depsite the name, is actually an internal helper. That revealed a surprising number of packages were accidentally using `expect()` instead of `expect_true()` or `expect_equal()`. We technically don't consider this a breaking change because it revealed off-label function usage. ## Expectations and the interactive testing experience -A lot of work in this version was prompted by an overhaul of `vignette("custom-expectations")`. This was motivated by _finally_ creating some decent documentation about how to write your own expectations. But as I worked on this vignette, I realised that I didn't really know how to write new expectations and there was a lot of variation in how existing expectations were written. So this kick off a bunch of changes: +A lot of work in this release was prompted by an overhaul of `vignette("custom-expectations")`, which describes how to create your own expectations that work just like testthat's. This is a long time coming, and as I was working on it, I realised that I didn't really know how to write new expectations and there was a lot of variation in the implementation of existing expectations. So this lead to a lot of experimentation and iterating, leading to a swatch of improvements: -* All `expect_` functions have had their failure messages rewritten. They now all state what was expected, what was actually received, and, if possible, clearly illustrate the difference. +* All expectations have new failure messages: they now all state what was expected, what was actually received, and, if possible, clearly illustrate the difference. -* They consistently return the value of the first argument, regardless of whether the expectation succeeds or fails (the only exception is `expect_message()` and friends which return the condition). This shouldn't affect existing tests, but will make failures clearer when you chain together multiple expectations. +* Expectations now consistently return the value of the first argument, regardless of whether the expectation succeeds or fails (the only exception is `expect_error()` and friends which return the captured condition). This is a relatively subtle change, that won't affects tests that already pass, but it does improve failures when you pipe together multiple expectations. -* A new `pass()` function makes it clear how to signal when an expectation succeeds. +* A new `pass()` function makes it clear how to signal when an expectation succeeds. All expectations were rewritten to use `pass()` and (the existing) `fail()` instead of `expect()`, which I think makes the flow of logic easy to understand. -* Revised `expect_success()` and `expect_failure()` functions test that an expectation follows the expectation contract: each call of an `expect_` function should return exactly one success or failure (this ensures that the counts you see in the reporters are always correct). +* Improvement `expect_success()` and `expect_failure()` expectations test that an expectation always returns exactly one success or failure (this ensures that the counts you see in the reporters are always correct). -This framework helped us write six new expectations: +This new framework helped us write six new expectations: -* New `expect_all_equal()`, `expect_all_true()`, and `expect_all_false()` check that every element of a vector has the same value, giving better error messages than `expect_true(all(...))`. +* `expect_all_equal()`, `expect_all_true()`, and `expect_all_false()` check that every element of a vector has the same value, giving better error messages than `expect_true(all(...))`: ```{r} #| error: true @@ -104,7 +104,7 @@ This framework helped us write six new expectations: }) ``` -* New `expect_disjoint()` expects values to to be absent. +* `expect_disjoint()` expects values to to be absent: ```{r} #| error: true @@ -114,7 +114,7 @@ This framework helped us write six new expectations: }) ``` -* New `expect_r6_class()` expects an R6 object. +* `expect_r6_class()` expects an R6 object: ```{r} #| error: true @@ -128,7 +128,7 @@ This framework helped us write six new expectations: }) ``` -* New `expect_shape()` expects a specific shape (i.e., `nrow()`, `ncol()`, or `dim()`). +* `expect_shape()` expects a specific shape (i.e., `nrow()`, `ncol()`, or `dim()`): ```{r} #| error: true @@ -141,28 +141,44 @@ This framework helped us write six new expectations: }) ``` -As I wrote this vignette, I also realised that the interactive behaviour of `test_that()` (i.e. when you execute a single test at the console, not as part of a test suite) could be improved so you now see the number of successes and failures. You'll notice that in the examples above. - +As you can see from the examples above, when you run a single test interactively (i.e. not as a part of a test suite) you now see exactly how many expectations succeeded and failure. ## Other new features -* I've generally consider the case of nested tests (i.e. putting a `test_that()` inside another `test_that()`, or more typically `it()` inside of `describe()`). They should now generally generate more informative failure messages, free from duplication, with more informative skips if any of the subtests are empty. +* testthat generally does a better job of handling nested tests, aka subtests, where you put a `test_that()` inside another `test_that()`, or more typically `it()` inside of `describe()`. Subtests will now generate more informative failure messages, free from duplication, with more informative skips if any subtests don't contain any expectations. + +* We put a lot of work into the snapshot experience, fixing all known bugs and adding some new helpers: `snapshot_reject()` rejects all modified snapshots by deleting the `.new` variants, and `snapshot_download_gh()` makes it easy to get snapshots off GitHub and into your local package. Additionally, `expect_snapshot()` and friends will now fail when creating a new snapshot on CI, as that's usually a signal that you've forgotten to run the snapshot code locally before committing. * On CRAN, `test_that()` will automatically skip if a package is not installed, which means that you no longer need to check if suggested packages are installed in your tests. -* New `vignette("mocking")` explains mocking in detail, and `local_mocked_s3_method()`, `local_mocked_s4_method()`, and `local_mocked_r6_class()` make it easier to mock S3 and S4 methods and R6 classes. +* `vignette("mocking")` explains mocking in detail, and new `local_mocked_s3_method()`, `local_mocked_s4_method()`, and `local_mocked_r6_class()` make it easier to mock S3 and S4 methods and R6 classes. -* `test_dir()`, `test_check()`, and friends gain a `shuffle` argument that uses `sample()` to randomly reorder the top-level expressions in each test file. This random reordering surfaces dependencies between tests and code outside of any test, as well as dependencies between tests. This helps you find and eliminate unintentional dependencies. +* `test_dir()`, `test_check()`, and friends gain a `shuffle` argument that uses `sample()` to randomly reorder the top-level expressions in each test file. This random reordering surfaces dependencies between tests and code outside of any test, as well as dependencies between tests, helping you find and eliminate unintentional dependencies. -* `try_again()` is now publicised, making it easier to test flaky code. We changed the first argument to represent the number of retries, not tries. +* `try_again()` is now publicised, as it's a useful tool for testing flaky code: -* New `skip_unless_r()` skip tests on unsuitable versions of R. It has a convenient sytnax so you can use, e.g., `skip_unless_r(">= 4.1.0")` to skip tests that require `...names()`. + ```{r} + #| eval: false -* We put a lot of work into the snapshot experience, fixing all known bug and adding some new helpers. `snapshot_reject()` rejects all modified snapshots by deleting the `.new` variants, and `snapshot_download_gh()` makes it easy to get snapshots off GitHub and into your local package. `expect_snapshot()` and friends will now fail when creating a new snapshot on CI. This is usually a signal that you've forgotten to run it locally before committing. + flaky_function <- function(i) { + if (runif(1) < 0.1) 0 else 1 + } + test_that("my flaky test is ok", { + # 10% chance of failure: + expect_equal(usually_return_1(), 1) -* New `SlowReporter` makes it easier to find the slowest tests in your package. You can run it with `devtools::test(reporter = "slow")`. + # 1% chance of failure: + try_again(1, expect_equal(usually_return_1(), 1)) -* New `vignette("challenging-functions")` provides an index to other documentation organised by various challenges (#1265). + # 0.1% chance of failure: + try_again(2, expect_equal(usually_return_1(), 1)) + }) + ``` + +* New `skip_unless_r()` skip tests on unsuitable versions of R. It has a convenient sytnax so you can use, e.g., `skip_unless_r(">= 4.1.0")` to skip tests that require `...names()`. + +* New `SlowReporter` makes it easier to find the slowest tests in your package. You can run it with `devtools::test(reporter = "slow")`. +* New `vignette("challenging-functions")` provides an index to other documentation organised by various challenges. ## Acknowledgements From e4093eabbb98bedc5ca7abf87e931c761c55ee17 Mon Sep 17 00:00:00 2001 From: Hadley Wickham Date: Thu, 6 Nov 2025 08:43:43 -0600 Subject: [PATCH 04/10] Proofread --- content/blog/testhat-3-3-0/index.Rmd | 73 +++++++++++----------------- 1 file changed, 29 insertions(+), 44 deletions(-) diff --git a/content/blog/testhat-3-3-0/index.Rmd b/content/blog/testhat-3-3-0/index.Rmd index 73190c6ac..93b8c5165 100644 --- a/content/blog/testhat-3-3-0/index.Rmd +++ b/content/blog/testhat-3-3-0/index.Rmd @@ -1,13 +1,14 @@ --- output: hugodown::hugo_document -slug: testhat-3-3-0 -title: testhat 3 3 0 +slug: testthat-3-3-0 +title: testthat 3.3.0 date: 2025-11-05 author: Hadley Wickham description: > - A 2-3 sentence description of the post that appears on the articles page. - This can be omitted if it would just recapitulate the title. + testthat 3.3.0 brings improved expectations with better error messages, + new expectations for common testing patterns, and lifecycle changes including + the removal of `local_mock()` and `with_mock()`. photo: url: https://unsplash.com/photos/n6vS3xlnsCc @@ -23,73 +24,57 @@ tags: [] knitr::opts_chunk$set(collapse = TRUE, comment = "#>") ``` - - -We're chuffed to announce the release of []({ home }) . is ... +We're chuffed to announce the release of [testthat](https://testthat.r-lib.org) 3.3.0. testthat is a testing framework for R that makes it easy to turn your existing informal tests into formal, automated tests that you can rerun quickly and easily. You can install it from CRAN with: ```{r, eval = FALSE} -install.packages("{package}") +install.packages("testthat") ``` -This blog post will ... +This blog post highlights the most important changes in this release, including lifecycle changes that removed long-deprecated mocking functions, improvements to expectations and their error messages, and a variety of new features that make testing easier and more robust. -You can see a full list of changes in the [release notes]({ github_release }) +You can see a full list of changes in the [release notes](https://github.com/r-lib/testthat/releases/tag/v3.3.0) ```{r setup} library(testthat) ``` -## Claude code experiences +## Claude Code experiences -I also used this version of testthat as an opportunity to learn claude code, and hence it's the first project where I've really used AI to support development of many features +I also used this version of testthat as an opportunity to learn Claude Code, and hence it's the first project where I've really used AI to support the development of many features. -* `settings.json` - -* `CLAUDE.md` - +Overall it was a successful experiment and helped me close over 100 issues, in what felt like less time than usual. While there might have been a few specific cases where I got 2x performance, on average it feels more like a 10-20% improvement. This is still significant, especially since I'm already an experienced R programmer. I mostly used it for smaller, well-defined tasks where I had a good sense of what was needed. I found it particularly useful for refactoring. It was rare for me to accept what it did as is, but it often got me started. -Overall it was a successful experiement and helped me close over a 100 issues, in what felt like less time than usual. Overall, while there might have been a few specific cases where I got 2x performance, on average it feels more like a 10-20% improvement. Obviously this is still significant, especially since I'm already an experienced R programmer. I mostly used it for smaller well-defined tasks where I had a good sense of what was needed. I found it particularly useful for refactoring. It was rare for me to accept what it did as is, but often it got me started. +I also found it generally useful for getting over the "activation energy hump". There were a few issues that had been stagnating for years because they felt like they were going to be hard to do, with relatively limited payoff. I let Claude Code loose on a few of these and found it super useful. Again, it only produced code I was happy with a couple of times, but every time it gave me something to react to (often with strong negative feelings!) and that got me started actually engaging with the problem. -I also found it generally useful for getting over the "activation energy hump". There were a few issues that had been stangnating for years because they felt like they were going to be hard to do, and with relatively limited payoff. I let claude code lose on a few of these and found it super useful. Again, it only produced code I was happy with a couple of times, but every time it gave me something to react too (often with strong negative feelings!) and that got me started actually engaging with the problem. - -I also experimented with using claude code to review PRs. It was just barely useful enough that I kept it turned on for my own PRs, but didn't bother trying to get it to work for contributed PRs. Most of the time it either gave a thumbs up or bad advice. But every now and then it would pick up a smaller error. +I also experimented with using Claude Code to review PRs. It was just barely useful enough that I kept it turned on for my own PRs, but I didn't bother trying to get it to work for contributed PRs. Most of the time it either gave a thumbs up or bad advice, but every now and then it would pick up a small error. ## Lifecycle changes -The biggest change in this release is that `local_mock()` and `with_mock()` are now defunct. They were deprecated in 3.0.0 (2020-10-31) because it was becoming increasing clear that the technique that made them work was going to be removed from R. This has happened in R 4.5.0, leading to their removal. This was a fairly disruptive change, affecting ~100 CRAN packages, but it had to be done, and I've been working on notifying package developers since January so everyone had plenty of time to update. Fortunately, the needed changes are generally small, since the newer `local_mocked_bindings()` and `with_mocked_binding()` can solve most additional needs. I also wrote `vignette("mocking")` to make it easier to understand when and how to use mocking. +The biggest change in this release is that `local_mock()` and `with_mock()` are now defunct. They were deprecated in 3.0.0 (2020-10-31) because it was becoming increasingly clear that the technique that made them work was going to be removed from R. This has happened in R 4.5.0, leading to their removal. This was a fairly disruptive change, affecting ~100 CRAN packages, but it had to be done, and I've been working on notifying package developers since January so everyone had plenty of time to update. Fortunately, the needed changes are generally small, since the newer `local_mocked_bindings()` and `with_mocked_binding()` can solve most additional needs. I also wrote `vignette("mocking")` to make it easier to understand when and how to use mocking. Other lifecycle changes: -* testthat now requires R 4.1. This follows [our supported version policy](https://tidyverse.org/blog/2019/04/r-version-support/), which documents our commitment to support five version of R (the current and four previous). We are excited to be able to finally take advantage of the base pipe and compact anonymous functions (i.e. `\(x) x + 1`). +* testthat now requires R 4.1. This follows [our supported version policy](https://tidyverse.org/blog/2019/04/r-version-support/), which documents our commitment to support five versions of R (the current and four previous). We are excited to be able to finally take advantage of the base pipe and compact anonymous functions (i.e. `\(x) x + 1`). * `is_null()`/`matches()`, deprecated in 2.0.0 (2017-12-19), and `is_true()`/`is_false()`, deprecated in 2.1.0 (2019-04-23), have been removed. These conflicted with other tidyverse functions so we pushed their deprecation through, even though we have generally left the old `test_that()` API untouched. -* `expect_snapshot(binary)`, soft deprecated in 3.0.3 (2021-06-16), is now fully deprecated. `test_files(wrap)`, deprecated in 3.0.0 (2020-10-31) has now been removed. +* `expect_snapshot(binary)`, soft deprecated in 3.0.3 (2021-06-16), is now fully deprecated. `test_files(wrap)`, deprecated in 3.0.0 (2020-10-31), has now been removed. -* There were a few other changes that broke existing packages. The most impactful change was to start checking the inputs to `expect()` which, depsite the name, is actually an internal helper. That revealed a surprising number of packages were accidentally using `expect()` instead of `expect_true()` or `expect_equal()`. We technically don't consider this a breaking change because it revealed off-label function usage. +* There were a few other changes that broke existing packages. The most impactful change was to start checking the inputs to `expect()` which, despite the name, is actually an internal helper. That revealed a surprising number of packages were accidentally using `expect()` instead of `expect_true()` or `expect_equal()`. We technically don't consider this a breaking change because it revealed off-label function usage. ## Expectations and the interactive testing experience -A lot of work in this release was prompted by an overhaul of `vignette("custom-expectations")`, which describes how to create your own expectations that work just like testthat's. This is a long time coming, and as I was working on it, I realised that I didn't really know how to write new expectations and there was a lot of variation in the implementation of existing expectations. So this lead to a lot of experimentation and iterating, leading to a swatch of improvements: +A lot of work in this release was prompted by an overhaul of `vignette("custom-expectations")`, which describes how to create your own expectations that work just like testthat's. This is a long time coming, and as I was working on it, I realized that I didn't really know how to write new expectations and there was a lot of variation in the implementation of existing expectations. So this led to a lot of experimentation and iterating, leading to a swath of improvements: -* All expectations have new failure messages: they now all state what was expected, what was actually received, and, if possible, clearly illustrate the difference. +* All expectations have new failure messages: they now all state what was expected, what was actually received, and, if possible, clearly illustrate the difference. -* Expectations now consistently return the value of the first argument, regardless of whether the expectation succeeds or fails (the only exception is `expect_error()` and friends which return the captured condition). This is a relatively subtle change, that won't affects tests that already pass, but it does improve failures when you pipe together multiple expectations. +* Expectations now consistently return the value of the first argument, regardless of whether the expectation succeeds or fails (the only exception is `expect_error()` and friends which return the captured condition). This is a relatively subtle change that won't affect tests that already pass, but it does improve failures when you pipe together multiple expectations. -* A new `pass()` function makes it clear how to signal when an expectation succeeds. All expectations were rewritten to use `pass()` and (the existing) `fail()` instead of `expect()`, which I think makes the flow of logic easy to understand. +* A new `pass()` function makes it clear how to signal when an expectation succeeds. All expectations were rewritten to use `pass()` and (the existing) `fail()` instead of `expect()`, which I think makes the flow of logic easier to understand. -* Improvement `expect_success()` and `expect_failure()` expectations test that an expectation always returns exactly one success or failure (this ensures that the counts you see in the reporters are always correct). +* Improved `expect_success()` and `expect_failure()` expectations test that an expectation always returns exactly one success or failure (this ensures that the counts you see in the reporters are always correct). This new framework helped us write six new expectations: @@ -104,7 +89,7 @@ This new framework helped us write six new expectations: }) ``` -* `expect_disjoint()` expects values to to be absent: +* `expect_disjoint()` expects values to be absent: ```{r} #| error: true @@ -141,13 +126,13 @@ This new framework helped us write six new expectations: }) ``` -As you can see from the examples above, when you run a single test interactively (i.e. not as a part of a test suite) you now see exactly how many expectations succeeded and failure. +As you can see from the examples above, when you run a single test interactively (i.e. not as a part of a test suite) you now see exactly how many expectations succeeded and failed. ## Other new features * testthat generally does a better job of handling nested tests, aka subtests, where you put a `test_that()` inside another `test_that()`, or more typically `it()` inside of `describe()`. Subtests will now generate more informative failure messages, free from duplication, with more informative skips if any subtests don't contain any expectations. -* We put a lot of work into the snapshot experience, fixing all known bugs and adding some new helpers: `snapshot_reject()` rejects all modified snapshots by deleting the `.new` variants, and `snapshot_download_gh()` makes it easy to get snapshots off GitHub and into your local package. Additionally, `expect_snapshot()` and friends will now fail when creating a new snapshot on CI, as that's usually a signal that you've forgotten to run the snapshot code locally before committing. +* The snapshot experience has been significantly improved, with all known bugs fixed and some new helpers added: `snapshot_reject()` rejects all modified snapshots by deleting the `.new` variants, and `snapshot_download_gh()` makes it easy to get snapshots off GitHub and into your local package. Additionally, `expect_snapshot()` and friends will now fail when creating a new snapshot on CI, as that's usually a signal that you've forgotten to run the snapshot code locally before committing. * On CRAN, `test_that()` will automatically skip if a package is not installed, which means that you no longer need to check if suggested packages are installed in your tests. @@ -155,7 +140,7 @@ As you can see from the examples above, when you run a single test interactively * `test_dir()`, `test_check()`, and friends gain a `shuffle` argument that uses `sample()` to randomly reorder the top-level expressions in each test file. This random reordering surfaces dependencies between tests and code outside of any test, as well as dependencies between tests, helping you find and eliminate unintentional dependencies. -* `try_again()` is now publicised, as it's a useful tool for testing flaky code: +* `try_again()` is now publicized, as it's a useful tool for testing flaky code: ```{r} #| eval: false @@ -175,10 +160,10 @@ As you can see from the examples above, when you run a single test interactively }) ``` -* New `skip_unless_r()` skip tests on unsuitable versions of R. It has a convenient sytnax so you can use, e.g., `skip_unless_r(">= 4.1.0")` to skip tests that require `...names()`. +* New `skip_unless_r()` skips tests on unsuitable versions of R. It has a convenient syntax so you can use, e.g., `skip_unless_r(">= 4.1.0")` to skip tests that require `...names()`. * New `SlowReporter` makes it easier to find the slowest tests in your package. You can run it with `devtools::test(reporter = "slow")`. -* New `vignette("challenging-functions")` provides an index to other documentation organised by various challenges. +* New `vignette("challenging-functions")` provides an index to other documentation organized by various challenges. ## Acknowledgements From 421cac6a76f6a3e7202e0e59105a7c1b833ff436 Mon Sep 17 00:00:00 2001 From: Hadley Wickham Date: Thu, 6 Nov 2025 08:44:01 -0600 Subject: [PATCH 05/10] Correct path --- content/blog/{testhat-3-3-0 => testthat-3-3-0}/index.Rmd | 0 1 file changed, 0 insertions(+), 0 deletions(-) rename content/blog/{testhat-3-3-0 => testthat-3-3-0}/index.Rmd (100%) diff --git a/content/blog/testhat-3-3-0/index.Rmd b/content/blog/testthat-3-3-0/index.Rmd similarity index 100% rename from content/blog/testhat-3-3-0/index.Rmd rename to content/blog/testthat-3-3-0/index.Rmd From 1fc91714e31eeb160bbc4a5a5090389b35859fea Mon Sep 17 00:00:00 2001 From: Hadley Wickham Date: Fri, 7 Nov 2025 14:03:04 -0600 Subject: [PATCH 06/10] Polishing --- content/blog/testthat-3-3-0/index.Rmd | 37 +++++++++++++++------------ 1 file changed, 20 insertions(+), 17 deletions(-) diff --git a/content/blog/testthat-3-3-0/index.Rmd b/content/blog/testthat-3-3-0/index.Rmd index 93b8c5165..bf6d5b6f5 100644 --- a/content/blog/testthat-3-3-0/index.Rmd +++ b/content/blog/testthat-3-3-0/index.Rmd @@ -7,8 +7,7 @@ date: 2025-11-05 author: Hadley Wickham description: > testthat 3.3.0 brings improved expectations with better error messages, - new expectations for common testing patterns, and lifecycle changes including - the removal of `local_mock()` and `with_mock()`. + new expectations for common testing patterns, and lifecycle changes including the removal of `local_mock()` and `with_mock()`. photo: url: https://unsplash.com/photos/n6vS3xlnsCc @@ -32,9 +31,7 @@ You can install it from CRAN with: install.packages("testthat") ``` -This blog post highlights the most important changes in this release, including lifecycle changes that removed long-deprecated mocking functions, improvements to expectations and their error messages, and a variety of new features that make testing easier and more robust. - -You can see a full list of changes in the [release notes](https://github.com/r-lib/testthat/releases/tag/v3.3.0) +This blog post highlights the most important changes in this release, including lifecycle changes that removed long-deprecated mocking functions, improvements to expectations and their error messages, and a variety of new features that make testing easier and more robust. You can see a full list of changes in the [release notes](https://github.com/r-lib/testthat/releases/tag/v3.3.0) ```{r setup} library(testthat) @@ -42,39 +39,45 @@ library(testthat) ## Claude Code experiences -I also used this version of testthat as an opportunity to learn Claude Code, and hence it's the first project where I've really used AI to support the development of many features. +I also used this release as an opportunity to learn [Claude Code](https://www.claude.com/product/claude-code), making it the first project where I've really used AI to support the development of many features. + +Overall it was a successful experiment. It helped me close over 100 issues in what felt like less time than usual. I don't have any hard numbers, but my gut feeling is that it was maybe a 10-20% improvement to my development philosophy. This is still significant, especially since I'm an experienced R programmer and my workflow has been pretty stable for the last few years. I mostly used Claude for smaller, well-defined tasks where I had a good sense of what was needed. I found it particularly useful for refactoring, where it was easy to say precisely what I wanted, but executing the changes required a bunch of fiddly edits across many files. -Overall it was a successful experiment and helped me close over 100 issues, in what felt like less time than usual. While there might have been a few specific cases where I got 2x performance, on average it feels more like a 10-20% improvement. This is still significant, especially since I'm already an experienced R programmer. I mostly used it for smaller, well-defined tasks where I had a good sense of what was needed. I found it particularly useful for refactoring. It was rare for me to accept what it did as is, but it often got me started. +I also found it generally useful for getting over the "activation energy hump": there were a few issues that had been stagnating for years because they felt like they were going to be hard to do and with relatively limited payoff. I let Claude Code loose on a few of these and found it super useful. It only produced code I was really happy with a couple of times, but every time it gave me something to react to (often with strong negative feelings!) and that got me started actually engaging with the problem. -I also found it generally useful for getting over the "activation energy hump". There were a few issues that had been stagnating for years because they felt like they were going to be hard to do, with relatively limited payoff. I let Claude Code loose on a few of these and found it super useful. Again, it only produced code I was happy with a couple of times, but every time it gave me something to react to (often with strong negative feelings!) and that got me started actually engaging with the problem. +If you're interested in using Claude Code yourself, there are a couple of files you might find useful. My [`CLAUDE.md`](https://github.com/r-lib/testthat/blob/main/.claude/CLAUDE.md) tells Claude how to execute a devtools based workflow, along with a few pointers to resolve common issues. My [`settings.json`](https://github.com/r-lib/testthat/blob/main/.claude/settings.json) allows Claude to run longer with out human intervention, doing things that should mostly be safe. One note of caution: these settings do allow Claude to run R code, which does allow it to do practically anything. In my experience, Claude only used R to run tests or documentation. I also experimented with using Claude Code to review PRs. It was just barely useful enough that I kept it turned on for my own PRs, but I didn't bother trying to get it to work for contributed PRs. Most of the time it either gave a thumbs up or bad advice, but every now and then it would pick up a small error. +(I've also used claude code to proofread this blog post!) + ## Lifecycle changes -The biggest change in this release is that `local_mock()` and `with_mock()` are now defunct. They were deprecated in 3.0.0 (2020-10-31) because it was becoming increasingly clear that the technique that made them work was going to be removed from R. This has happened in R 4.5.0, leading to their removal. This was a fairly disruptive change, affecting ~100 CRAN packages, but it had to be done, and I've been working on notifying package developers since January so everyone had plenty of time to update. Fortunately, the needed changes are generally small, since the newer `local_mocked_bindings()` and `with_mocked_binding()` can solve most additional needs. I also wrote `vignette("mocking")` to make it easier to understand when and how to use mocking. +The biggest change in this release is that `local_mock()` and `with_mock()` are defunct. They were deprecated in 3.0.0 (2020-10-31) because it was becoming clear that the technique that made them work would be disallowed in a future verson of R. This has now happened in R 4.5.0, so the functions have been removed. Removing `local_mock()` and `with_mock()` was a fairly disruptive change, affecting ~100 CRAN packages, but it had to be done, and I've been working on notifying package developers since January so everyone had plenty of time to update. Fortunately, the needed changes are generally small, since the newer `local_mocked_bindings()` and `with_mocked_binding()` can solve most additional needs. (If you haven't heard of mocking before you can read the new `vignette("mocking")` to learn what it is and why you might want to use it..) Other lifecycle changes: -* testthat now requires R 4.1. This follows [our supported version policy](https://tidyverse.org/blog/2019/04/r-version-support/), which documents our commitment to support five versions of R (the current and four previous). We are excited to be able to finally take advantage of the base pipe and compact anonymous functions (i.e. `\(x) x + 1`). +* testthat now requires R 4.1. This follows [our supported version policy](https://tidyverse.org/blog/2019/04/r-version-support/), which documents our commitment to support five versions of R (the current version and four previous version). We're excited to be able to finally take advantage of the base pipe and compact anonymous functions (i.e. `\(x) x + 1`)! * `is_null()`/`matches()`, deprecated in 2.0.0 (2017-12-19), and `is_true()`/`is_false()`, deprecated in 2.1.0 (2019-04-23), have been removed. These conflicted with other tidyverse functions so we pushed their deprecation through, even though we have generally left the old `test_that()` API untouched. * `expect_snapshot(binary)`, soft deprecated in 3.0.3 (2021-06-16), is now fully deprecated. `test_files(wrap)`, deprecated in 3.0.0 (2020-10-31), has now been removed. -* There were a few other changes that broke existing packages. The most impactful change was to start checking the inputs to `expect()` which, despite the name, is actually an internal helper. That revealed a surprising number of packages were accidentally using `expect()` instead of `expect_true()` or `expect_equal()`. We technically don't consider this a breaking change because it revealed off-label function usage. +* There were a few other changes that broke existing packages. The most impactful change was to start checking the inputs to `expect()` which, despite the name, is actually an internal helper. That revealed a surprising number of packages were accidentally using `expect()` instead of `expect_true()` or `expect_equal()`. We don't technically consider this a breaking change because it revealed off-label function usage: the function API hasn't changed; you just now learn when you're using it incorrectly. + +If you're interested in the proces we use to manage the release of a package that breaks its reverse dependencies, you might like to read [the issue](https://github.com/r-lib/testthat/issues/2021) where I track all the problems and prepare PRs to fix them. ## Expectations and the interactive testing experience -A lot of work in this release was prompted by an overhaul of `vignette("custom-expectations")`, which describes how to create your own expectations that work just like testthat's. This is a long time coming, and as I was working on it, I realized that I didn't really know how to write new expectations and there was a lot of variation in the implementation of existing expectations. So this led to a lot of experimentation and iterating, leading to a swath of improvements: +A lot of work in this release was prompted by an overhaul of `vignette("custom-expectations")`, which describes how to create your own expectations that work just like testthat's. This is a long time coming, and as I was working on it, I realized that I didn't really know how to write new expectations, which had lead to a lot of variation in the existing implementations. This kicked off a bunch of experimentation and iterating, leading to a swath of improvements: -* All expectations have new failure messages: they now all state what was expected, what was actually received, and, if possible, clearly illustrate the difference. +* All expectations have new failure messages: they now state what was expected, what was actually received, and, if possible, they clearly illustrate the difference. * Expectations now consistently return the value of the first argument, regardless of whether the expectation succeeds or fails (the only exception is `expect_error()` and friends which return the captured condition). This is a relatively subtle change that won't affect tests that already pass, but it does improve failures when you pipe together multiple expectations. -* A new `pass()` function makes it clear how to signal when an expectation succeeds. All expectations were rewritten to use `pass()` and (the existing) `fail()` instead of `expect()`, which I think makes the flow of logic easier to understand. +* A new `pass()` function makes it clear how to signal when an expectation succeeds. All existing expectations were rewritten to use `pass()` and (the existing) `fail()` instead of `expect()`, which I think makes the flow of logic easier to understand. -* Improved `expect_success()` and `expect_failure()` expectations test that an expectation always returns exactly one success or failure (this ensures that the counts you see in the reporters are always correct). +* Improved `expect_success()` and `expect_failure()` expectations now test that an expectation always returns exactly one success or failure (this ensures that the counts that you see in the reporters are correct). This new framework helped us write six new expectations: @@ -89,7 +92,7 @@ This new framework helped us write six new expectations: }) ``` -* `expect_disjoint()` expects values to be absent: +* `expect_disjoint()`, by [@stibu81](https://github.com/stibu81), expects values to be absent: ```{r} #| error: true @@ -113,7 +116,7 @@ This new framework helped us write six new expectations: }) ``` -* `expect_shape()` expects a specific shape (i.e., `nrow()`, `ncol()`, or `dim()`): +* `expect_shape()`, by [@michaelchirico](https://github.com/michaelchirico), expects a specific shape (i.e., `nrow()`, `ncol()`, or `dim()`): ```{r} #| error: true From c49deee5002334fc535c4661f8a8be1a0c58a7c5 Mon Sep 17 00:00:00 2001 From: Hadley Wickham Date: Sat, 8 Nov 2025 06:58:27 -0600 Subject: [PATCH 07/10] Claude code proofreading --- content/blog/testthat-3-3-0/index.Rmd | 24 ++++++++++++------------ 1 file changed, 12 insertions(+), 12 deletions(-) diff --git a/content/blog/testthat-3-3-0/index.Rmd b/content/blog/testthat-3-3-0/index.Rmd index bf6d5b6f5..dec7d67e2 100644 --- a/content/blog/testthat-3-3-0/index.Rmd +++ b/content/blog/testthat-3-3-0/index.Rmd @@ -31,7 +31,7 @@ You can install it from CRAN with: install.packages("testthat") ``` -This blog post highlights the most important changes in this release, including lifecycle changes that removed long-deprecated mocking functions, improvements to expectations and their error messages, and a variety of new features that make testing easier and more robust. You can see a full list of changes in the [release notes](https://github.com/r-lib/testthat/releases/tag/v3.3.0) +This blog post highlights the most important changes in this release, including lifecycle changes that removed long-deprecated mocking functions, improvements to expectations and their error messages, and a variety of new features that make testing easier and more robust. You can see a full list of changes in the [release notes](https://github.com/r-lib/testthat/releases/tag/v3.3.0). ```{r setup} library(testthat) @@ -41,23 +41,23 @@ library(testthat) I also used this release as an opportunity to learn [Claude Code](https://www.claude.com/product/claude-code), making it the first project where I've really used AI to support the development of many features. -Overall it was a successful experiment. It helped me close over 100 issues in what felt like less time than usual. I don't have any hard numbers, but my gut feeling is that it was maybe a 10-20% improvement to my development philosophy. This is still significant, especially since I'm an experienced R programmer and my workflow has been pretty stable for the last few years. I mostly used Claude for smaller, well-defined tasks where I had a good sense of what was needed. I found it particularly useful for refactoring, where it was easy to say precisely what I wanted, but executing the changes required a bunch of fiddly edits across many files. +Overall it was a successful experiment. It helped me close over 100 issues in what felt like less time than usual. I don't have any hard numbers, but my gut feeling is that it was maybe a 10-20% improvement to my development velocity. This is still significant, especially since I'm an experienced R programmer and my workflow has been pretty stable for the last few years. I mostly used Claude for smaller, well-defined tasks where I had a good sense of what was needed. I found it particularly useful for refactoring, where it was easy to say precisely what I wanted, but executing the changes required a bunch of fiddly edits across many files. I also found it generally useful for getting over the "activation energy hump": there were a few issues that had been stagnating for years because they felt like they were going to be hard to do and with relatively limited payoff. I let Claude Code loose on a few of these and found it super useful. It only produced code I was really happy with a couple of times, but every time it gave me something to react to (often with strong negative feelings!) and that got me started actually engaging with the problem. -If you're interested in using Claude Code yourself, there are a couple of files you might find useful. My [`CLAUDE.md`](https://github.com/r-lib/testthat/blob/main/.claude/CLAUDE.md) tells Claude how to execute a devtools based workflow, along with a few pointers to resolve common issues. My [`settings.json`](https://github.com/r-lib/testthat/blob/main/.claude/settings.json) allows Claude to run longer with out human intervention, doing things that should mostly be safe. One note of caution: these settings do allow Claude to run R code, which does allow it to do practically anything. In my experience, Claude only used R to run tests or documentation. +If you're interested in using Claude Code yourself, there are a couple of files you might find useful. My [`CLAUDE.md`](https://github.com/r-lib/testthat/blob/main/.claude/CLAUDE.md) tells Claude how to execute a devtools based workflow, along with a few pointers to resolve common issues. My [`settings.json`](https://github.com/r-lib/testthat/blob/main/.claude/settings.json) allows Claude to run longer without human intervention, doing things that should mostly be safe. One note of caution: these settings do allow Claude to run R code, which does allow it to do practically anything. In my experience, Claude only used R to run tests or documentation. I also experimented with using Claude Code to review PRs. It was just barely useful enough that I kept it turned on for my own PRs, but I didn't bother trying to get it to work for contributed PRs. Most of the time it either gave a thumbs up or bad advice, but every now and then it would pick up a small error. -(I've also used claude code to proofread this blog post!) +(I've also used Claude Code to proofread this blog post!) ## Lifecycle changes -The biggest change in this release is that `local_mock()` and `with_mock()` are defunct. They were deprecated in 3.0.0 (2020-10-31) because it was becoming clear that the technique that made them work would be disallowed in a future verson of R. This has now happened in R 4.5.0, so the functions have been removed. Removing `local_mock()` and `with_mock()` was a fairly disruptive change, affecting ~100 CRAN packages, but it had to be done, and I've been working on notifying package developers since January so everyone had plenty of time to update. Fortunately, the needed changes are generally small, since the newer `local_mocked_bindings()` and `with_mocked_binding()` can solve most additional needs. (If you haven't heard of mocking before you can read the new `vignette("mocking")` to learn what it is and why you might want to use it..) +The biggest change in this release is that `local_mock()` and `with_mock()` are defunct. They were deprecated in 3.0.0 (2020-10-31) because it was becoming clear that the technique that made them work would be disallowed in a future version of R. This has now happened in R 4.5.0, so the functions have been removed. Removing `local_mock()` and `with_mock()` was a fairly disruptive change, affecting ~100 CRAN packages, but it had to be done, and I've been working on notifying package developers since January so everyone had plenty of time to update. Fortunately, the needed changes are generally small, since the newer `local_mocked_bindings()` and `with_mocked_binding()` can solve most additional needs. (If you haven't heard of mocking before you can read the new `vignette("mocking")` to learn what it is and why you might want to use it.) Other lifecycle changes: -* testthat now requires R 4.1. This follows [our supported version policy](https://tidyverse.org/blog/2019/04/r-version-support/), which documents our commitment to support five versions of R (the current version and four previous version). We're excited to be able to finally take advantage of the base pipe and compact anonymous functions (i.e. `\(x) x + 1`)! +* testthat now requires R 4.1. This follows [our supported version policy](https://tidyverse.org/blog/2019/04/r-version-support/), which documents our commitment to support five versions of R (the current version and four previous versions). We're excited to be able to finally take advantage of the base pipe and compact anonymous functions (i.e. `\(x) x + 1`)! * `is_null()`/`matches()`, deprecated in 2.0.0 (2017-12-19), and `is_true()`/`is_false()`, deprecated in 2.1.0 (2019-04-23), have been removed. These conflicted with other tidyverse functions so we pushed their deprecation through, even though we have generally left the old `test_that()` API untouched. @@ -65,11 +65,11 @@ Other lifecycle changes: * There were a few other changes that broke existing packages. The most impactful change was to start checking the inputs to `expect()` which, despite the name, is actually an internal helper. That revealed a surprising number of packages were accidentally using `expect()` instead of `expect_true()` or `expect_equal()`. We don't technically consider this a breaking change because it revealed off-label function usage: the function API hasn't changed; you just now learn when you're using it incorrectly. -If you're interested in the proces we use to manage the release of a package that breaks its reverse dependencies, you might like to read [the issue](https://github.com/r-lib/testthat/issues/2021) where I track all the problems and prepare PRs to fix them. +If you're interested in the process we use to manage the release of a package that breaks its reverse dependencies, you might like to read [the issue](https://github.com/r-lib/testthat/issues/2021) where I track all the problems and prepare PRs to fix them. ## Expectations and the interactive testing experience -A lot of work in this release was prompted by an overhaul of `vignette("custom-expectations")`, which describes how to create your own expectations that work just like testthat's. This is a long time coming, and as I was working on it, I realized that I didn't really know how to write new expectations, which had lead to a lot of variation in the existing implementations. This kicked off a bunch of experimentation and iterating, leading to a swath of improvements: +A lot of work in this release was prompted by an overhaul of `vignette("custom-expectations")`, which describes how to create your own expectations that work just like testthat's. This is a long time coming, and as I was working on it, I realized that I didn't really know how to write new expectations, which had led to a lot of variation in the existing implementations. This kicked off a bunch of experimentation and iterating, leading to a swath of improvements: * All expectations have new failure messages: they now state what was expected, what was actually received, and, if possible, they clearly illustrate the difference. @@ -148,18 +148,18 @@ As you can see from the examples above, when you run a single test interactively ```{r} #| eval: false - flaky_function <- function(i) { + flaky_function <- function() { if (runif(1) < 0.1) 0 else 1 } test_that("my flaky test is ok", { # 10% chance of failure: - expect_equal(usually_return_1(), 1) + expect_equal(flaky_function(), 1) # 1% chance of failure: - try_again(1, expect_equal(usually_return_1(), 1)) + try_again(1, expect_equal(flaky_function(), 1)) # 0.1% chance of failure: - try_again(2, expect_equal(usually_return_1(), 1)) + try_again(2, expect_equal(flaky_function(), 1)) }) ``` From c9ae969f46af27f067e2a2675a0cd66159f9c74d Mon Sep 17 00:00:00 2001 From: Hadley Wickham Date: Tue, 11 Nov 2025 08:01:19 -0600 Subject: [PATCH 08/10] Code review + more proofreading --- content/blog/testthat-3-3-0/index.Rmd | 24 ++- content/blog/testthat-3-3-0/index.md | 221 ++++++++++++++++++++++++++ 2 files changed, 238 insertions(+), 7 deletions(-) create mode 100644 content/blog/testthat-3-3-0/index.md diff --git a/content/blog/testthat-3-3-0/index.Rmd b/content/blog/testthat-3-3-0/index.Rmd index dec7d67e2..ff44c0676 100644 --- a/content/blog/testthat-3-3-0/index.Rmd +++ b/content/blog/testthat-3-3-0/index.Rmd @@ -39,13 +39,13 @@ library(testthat) ## Claude Code experiences -I also used this release as an opportunity to learn [Claude Code](https://www.claude.com/product/claude-code), making it the first project where I've really used AI to support the development of many features. +Before we dive into the changes, I wanted to talk a little bit about some changes to my development process, as I used this release as an opportunity to learn [Claude Code](https://www.claude.com/product/claude-code). This is the first package where I've really used AI to support the development of many features and I thought it might be useful to share my experience. Overall it was a successful experiment. It helped me close over 100 issues in what felt like less time than usual. I don't have any hard numbers, but my gut feeling is that it was maybe a 10-20% improvement to my development velocity. This is still significant, especially since I'm an experienced R programmer and my workflow has been pretty stable for the last few years. I mostly used Claude for smaller, well-defined tasks where I had a good sense of what was needed. I found it particularly useful for refactoring, where it was easy to say precisely what I wanted, but executing the changes required a bunch of fiddly edits across many files. I also found it generally useful for getting over the "activation energy hump": there were a few issues that had been stagnating for years because they felt like they were going to be hard to do and with relatively limited payoff. I let Claude Code loose on a few of these and found it super useful. It only produced code I was really happy with a couple of times, but every time it gave me something to react to (often with strong negative feelings!) and that got me started actually engaging with the problem. -If you're interested in using Claude Code yourself, there are a couple of files you might find useful. My [`CLAUDE.md`](https://github.com/r-lib/testthat/blob/main/.claude/CLAUDE.md) tells Claude how to execute a devtools based workflow, along with a few pointers to resolve common issues. My [`settings.json`](https://github.com/r-lib/testthat/blob/main/.claude/settings.json) allows Claude to run longer without human intervention, doing things that should mostly be safe. One note of caution: these settings do allow Claude to run R code, which does allow it to do practically anything. In my experience, Claude only used R to run tests or documentation. +If you're interested in using Claude Code yourself, there are a couple of files you might find useful. My [`CLAUDE.md`](https://github.com/r-lib/testthat/blob/main/.claude/CLAUDE.md) tells Claude how to execute a devtools-based workflow, along with a few pointers to resolve common issues. My [`settings.json`](https://github.com/r-lib/testthat/blob/main/.claude/settings.json) allows Claude to run longer without human intervention, doing things that should mostly be safe. One note of caution: these settings do allow Claude to run R code, which does allow it to do practically anything. In my experience, Claude only used R to run tests or documentation. I also experimented with using Claude Code to review PRs. It was just barely useful enough that I kept it turned on for my own PRs, but I didn't bother trying to get it to work for contributed PRs. Most of the time it either gave a thumbs up or bad advice, but every now and then it would pick up a small error. @@ -53,7 +53,7 @@ I also experimented with using Claude Code to review PRs. It was just barely use ## Lifecycle changes -The biggest change in this release is that `local_mock()` and `with_mock()` are defunct. They were deprecated in 3.0.0 (2020-10-31) because it was becoming clear that the technique that made them work would be disallowed in a future version of R. This has now happened in R 4.5.0, so the functions have been removed. Removing `local_mock()` and `with_mock()` was a fairly disruptive change, affecting ~100 CRAN packages, but it had to be done, and I've been working on notifying package developers since January so everyone had plenty of time to update. Fortunately, the needed changes are generally small, since the newer `local_mocked_bindings()` and `with_mocked_binding()` can solve most additional needs. (If you haven't heard of mocking before you can read the new `vignette("mocking")` to learn what it is and why you might want to use it.) +The biggest change in this release is that `local_mock()` and `with_mock()` are defunct. They were deprecated in 3.0.0 (2020-10-31) because it was becoming clear that the technique that made them work would be disallowed in a future version of R. This has now happened in R 4.5.0, so the functions have been removed. Removing `local_mock()` and `with_mock()` was a fairly disruptive change, affecting ~100 CRAN packages, but it had to be done, and I've been working on notifying package developers since January so everyone had plenty of time to update. Fortunately, the needed changes are generally small, since the newer `local_mocked_bindings()` and `with_mocked_bindings()` can solve most additional needs. (If you haven't heard of mocking before, you can read the new `vignette("mocking")` to learn what it is and why you might want to use it.) Other lifecycle changes: @@ -73,7 +73,7 @@ A lot of work in this release was prompted by an overhaul of `vignette("custom-e * All expectations have new failure messages: they now state what was expected, what was actually received, and, if possible, they clearly illustrate the difference. -* Expectations now consistently return the value of the first argument, regardless of whether the expectation succeeds or fails (the only exception is `expect_error()` and friends which return the captured condition). This is a relatively subtle change that won't affect tests that already pass, but it does improve failures when you pipe together multiple expectations. +* Expectations now consistently return the value of the first argument, regardless of whether the expectation succeeds or fails (the only exception is `expect_error()` and friends which return the captured condition so that you can perform additional checks on the condition object). This is a relatively subtle change that won't affect tests that already pass, but it does improve failures when you pipe together multiple expectations. * A new `pass()` function makes it clear how to signal when an expectation succeeds. All existing expectations were rewritten to use `pass()` and (the existing) `fail()` instead of `expect()`, which I think makes the flow of logic easier to understand. @@ -151,18 +151,28 @@ As you can see from the examples above, when you run a single test interactively flaky_function <- function() { if (runif(1) < 0.1) 0 else 1 } + + # 10% chance of failure: test_that("my flaky test is ok", { - # 10% chance of failure: + skip_on_cran() expect_equal(flaky_function(), 1) + }) - # 1% chance of failure: + # 1% chance of failure: + test_that("my flaky test is ok", { + skip_on_cran() try_again(1, expect_equal(flaky_function(), 1)) + }) - # 0.1% chance of failure: + # 0.1% chance of failure: + test_that("my flaky test is ok", { + skip_on_cran() try_again(2, expect_equal(flaky_function(), 1)) }) ``` + Note that it's still good practice to skip such tests on CRAN. + * New `skip_unless_r()` skips tests on unsuitable versions of R. It has a convenient syntax so you can use, e.g., `skip_unless_r(">= 4.1.0")` to skip tests that require `...names()`. * New `SlowReporter` makes it easier to find the slowest tests in your package. You can run it with `devtools::test(reporter = "slow")`. diff --git a/content/blog/testthat-3-3-0/index.md b/content/blog/testthat-3-3-0/index.md new file mode 100644 index 000000000..3cd509dd1 --- /dev/null +++ b/content/blog/testthat-3-3-0/index.md @@ -0,0 +1,221 @@ +--- +output: hugodown::hugo_document + +slug: testthat-3-3-0 +title: testthat 3.3.0 +date: 2025-11-05 +author: Hadley Wickham +description: > + testthat 3.3.0 brings improved expectations with better error messages, + new expectations for common testing patterns, and lifecycle changes including the removal of `local_mock()` and `with_mock()`. + +photo: + url: https://unsplash.com/photos/n6vS3xlnsCc + author: Kelley Bozarth + +# one of: "deep-dive", "learn", "package", "programming", "roundup", or "other" +categories: [package] +tags: [] +rmd_hash: a016ade71001134a + +--- + +We're chuffed to announce the release of [testthat](https://testthat.r-lib.org) 3.3.0. testthat is a testing framework for R that makes it easy to turn your existing informal tests into formal, automated tests that you can rerun quickly and easily. + +You can install it from CRAN with: + +
+ +
install.packages("testthat")
+ +
+ +This blog post highlights the most important changes in this release, including lifecycle changes that removed long-deprecated mocking functions, improvements to expectations and their error messages, and a variety of new features that make testing easier and more robust. You can see a full list of changes in the [release notes](https://github.com/r-lib/testthat/releases/tag/v3.3.0). + +
+ +
library(testthat)
+ +
+ +## Claude Code experiences + +Before we dive into the changes, I wanted to talk a little bit about some changes to my development process, as I used this release as an opportunity to learn [Claude Code](https://www.claude.com/product/claude-code). This is the first package where I've really used AI to support the development of many features and I thought it might be useful to share my experience. + +Overall it was a successful experiment. It helped me close over 100 issues in what felt like less time than usual. I don't have any hard numbers, but my gut feeling is that it was maybe a 10-20% improvement to my development velocity. This is still significant, especially since I'm an experienced R programmer and my workflow has been pretty stable for the last few years. I mostly used Claude for smaller, well-defined tasks where I had a good sense of what was needed. I found it particularly useful for refactoring, where it was easy to say precisely what I wanted, but executing the changes required a bunch of fiddly edits across many files. + +I also found it generally useful for getting over the "activation energy hump": there were a few issues that had been stagnating for years because they felt like they were going to be hard to do and with relatively limited payoff. I let Claude Code loose on a few of these and found it super useful. It only produced code I was really happy with a couple of times, but every time it gave me something to react to (often with strong negative feelings!) and that got me started actually engaging with the problem. + +If you're interested in using Claude Code yourself, there are a couple of files you might find useful. My [`CLAUDE.md`](https://github.com/r-lib/testthat/blob/main/.claude/CLAUDE.md) tells Claude how to execute a devtools-based workflow, along with a few pointers to resolve common issues. My [`settings.json`](https://github.com/r-lib/testthat/blob/main/.claude/settings.json) allows Claude to run longer without human intervention, doing things that should mostly be safe. One note of caution: these settings do allow Claude to run R code, which does allow it to do practically anything. In my experience, Claude only used R to run tests or documentation. + +I also experimented with using Claude Code to review PRs. It was just barely useful enough that I kept it turned on for my own PRs, but I didn't bother trying to get it to work for contributed PRs. Most of the time it either gave a thumbs up or bad advice, but every now and then it would pick up a small error. + +(I've also used Claude Code to proofread this blog post!) + +## Lifecycle changes + +The biggest change in this release is that [`local_mock()`](https://testthat.r-lib.org/reference/with_mock.html) and [`with_mock()`](https://testthat.r-lib.org/reference/with_mock.html) are defunct. They were deprecated in 3.0.0 (2020-10-31) because it was becoming clear that the technique that made them work would be disallowed in a future version of R. This has now happened in R 4.5.0, so the functions have been removed. Removing [`local_mock()`](https://testthat.r-lib.org/reference/with_mock.html) and [`with_mock()`](https://testthat.r-lib.org/reference/with_mock.html) was a fairly disruptive change, affecting ~100 CRAN packages, but it had to be done, and I've been working on notifying package developers since January so everyone had plenty of time to update. Fortunately, the needed changes are generally small, since the newer [`local_mocked_bindings()`](https://testthat.r-lib.org/reference/local_mocked_bindings.html) and [`with_mocked_bindings()`](https://testthat.r-lib.org/reference/local_mocked_bindings.html) can solve most additional needs. (If you haven't heard of mocking before, you can read the new `vignette("mocking")` to learn what it is and why you might want to use it.) + +Other lifecycle changes: + +- testthat now requires R 4.1. This follows [our supported version policy](https://tidyverse.org/blog/2019/04/r-version-support/), which documents our commitment to support five versions of R (the current version and four previous versions). We're excited to be able to finally take advantage of the base pipe and compact anonymous functions (i.e. `\(x) x + 1`)! + +- `is_null()`/`matches()`, deprecated in 2.0.0 (2017-12-19), and `is_true()`/`is_false()`, deprecated in 2.1.0 (2019-04-23), have been removed. These conflicted with other tidyverse functions so we pushed their deprecation through, even though we have generally left the old [`test_that()`](https://testthat.r-lib.org/reference/test_that.html) API untouched. + +- `expect_snapshot(binary)`, soft deprecated in 3.0.3 (2021-06-16), is now fully deprecated. `test_files(wrap)`, deprecated in 3.0.0 (2020-10-31), has now been removed. + +- There were a few other changes that broke existing packages. The most impactful change was to start checking the inputs to [`expect()`](https://testthat.r-lib.org/reference/expect.html) which, despite the name, is actually an internal helper. That revealed a surprising number of packages were accidentally using [`expect()`](https://testthat.r-lib.org/reference/expect.html) instead of [`expect_true()`](https://testthat.r-lib.org/reference/logical-expectations.html) or [`expect_equal()`](https://testthat.r-lib.org/reference/equality-expectations.html). We don't technically consider this a breaking change because it revealed off-label function usage: the function API hasn't changed; you just now learn when you're using it incorrectly. + +If you're interested in the process we use to manage the release of a package that breaks its reverse dependencies, you might like to read [the issue](https://github.com/r-lib/testthat/issues/2021) where I track all the problems and prepare PRs to fix them. + +## Expectations and the interactive testing experience + +A lot of work in this release was prompted by an overhaul of `vignette("custom-expectations")`, which describes how to create your own expectations that work just like testthat's. This is a long time coming, and as I was working on it, I realized that I didn't really know how to write new expectations, which had led to a lot of variation in the existing implementations. This kicked off a bunch of experimentation and iterating, leading to a swath of improvements: + +- All expectations have new failure messages: they now state what was expected, what was actually received, and, if possible, they clearly illustrate the difference. + +- Expectations now consistently return the value of the first argument, regardless of whether the expectation succeeds or fails (the only exception is [`expect_error()`](https://testthat.r-lib.org/reference/expect_error.html) and friends which return the captured condition so that you can perform additional checks on the condition object). This is a relatively subtle change that won't affect tests that already pass, but it does improve failures when you pipe together multiple expectations. + +- A new [`pass()`](https://testthat.r-lib.org/reference/fail.html) function makes it clear how to signal when an expectation succeeds. All existing expectations were rewritten to use [`pass()`](https://testthat.r-lib.org/reference/fail.html) and (the existing) [`fail()`](https://testthat.r-lib.org/reference/fail.html) instead of [`expect()`](https://testthat.r-lib.org/reference/expect.html), which I think makes the flow of logic easier to understand. + +- Improved [`expect_success()`](https://testthat.r-lib.org/reference/expect_success.html) and [`expect_failure()`](https://testthat.r-lib.org/reference/expect_success.html) expectations now test that an expectation always returns exactly one success or failure (this ensures that the counts that you see in the reporters are correct). + +This new framework helped us write six new expectations: + +- [`expect_all_equal()`](https://testthat.r-lib.org/reference/expect_all_equal.html), [`expect_all_true()`](https://testthat.r-lib.org/reference/expect_all_equal.html), and [`expect_all_false()`](https://testthat.r-lib.org/reference/expect_all_equal.html) check that every element of a vector has the same value, giving better error messages than `expect_true(all(...))`: + +
+ + 
test_that("some test", {
+      x <- c(0.408, 0.961, 0.883, 0.46, 0.537, 0.961, 0.851, 0.887, 0.023)
+      expect_all_true(x < 0.95)
+    })
+    #> ── Failure: some test ─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
+    #> Expected every element of `x < 0.95` to equal TRUE.
+    #> Differences:
+    #> `actual`:   TRUE FALSE TRUE TRUE TRUE FALSE TRUE TRUE TRUE
+    #> `expected`: TRUE TRUE  TRUE TRUE TRUE TRUE  TRUE TRUE TRUE
+    #> Error:
+    #> ! Test failed with 1 failure and 0 successes.
+
+ +
+ +- [`expect_disjoint()`](https://testthat.r-lib.org/reference/expect_setequal.html), by [@stibu81](https://github.com/stibu81), expects values to be absent: + +
+ + 
test_that("", {
+      expect_disjoint(c("a", "b", "c"), c("c", "d", "e"))
+    })
+    #> ── Failure:  ──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
+    #> Expected `c("a", "b", "c")` to be disjoint from `c("c", "d", "e")`.
+    #> Actual: "a", "b", "c"
+    #> Expected: None of "c", "d", "e"
+    #> Invalid: "c"
+    #> Error:
+    #> ! Test failed with 1 failure and 0 successes.
+
+ +
+ +- [`expect_r6_class()`](https://testthat.r-lib.org/reference/inheritance-expectations.html) expects an R6 object: + +
+ + 
test_that("", {
+      x <- 10
+      expect_r6_class(x, "foo")
+    
+      x <- R6::R6Class("bar")$new()
+      expect_r6_class(x, "foo")
+    })
+    #> ── Failure:  ──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
+    #> Expected `x` to be an R6 object.
+    #> Actual OO type: none.
+    #> ── Failure:  ──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
+    #> Expected `x` to inherit from "foo".
+    #> Actual class: "bar"/"R6".
+    #> Error:
+    #> ! Test failed with 2 failures and 0 successes.
+
+ +
+ +- [`expect_shape()`](https://testthat.r-lib.org/reference/expect_length.html), by [@michaelchirico](https://github.com/michaelchirico), expects a specific shape (i.e., [`nrow()`](https://rdrr.io/r/base/nrow.html), [`ncol()`](https://rdrr.io/r/base/nrow.html), or [`dim()`](https://rdrr.io/r/base/dim.html)): + +
+ + 
test_that("show off expect_shape() failure messages", {
+      x <- matrix(1:9, nrow = 3)
+      expect_shape(x, nrow = 4)
+      expect_shape(x, dim = c(3, 3, 3))
+      expect_shape(x, dim = c(3, 4))
+    })
+    #> ── Failure: show off expect_shape() failure messages ──────────────────────────────────────────────────────────────────────────────────────────────────────
+    #> Expected `x` to have 4 rows.
+    #> Actual rows: 3.
+    #> ── Failure: show off expect_shape() failure messages ──────────────────────────────────────────────────────────────────────────────────────────────────────
+    #> Expected `x` to have 3 dimensions.
+    #> Actual dimensions: 2.
+    #> ── Failure: show off expect_shape() failure messages ──────────────────────────────────────────────────────────────────────────────────────────────────────
+    #> Expected `x` to have dim (3, 4).
+    #> Actual dim: (3, 3).
+    #> Error:
+    #> ! Test failed with 3 failures and 0 successes.
+
+ +
+ +As you can see from the examples above, when you run a single test interactively (i.e. not as a part of a test suite) you now see exactly how many expectations succeeded and failed. + +## Other new features + +- testthat generally does a better job of handling nested tests, aka subtests, where you put a [`test_that()`](https://testthat.r-lib.org/reference/test_that.html) inside another [`test_that()`](https://testthat.r-lib.org/reference/test_that.html), or more typically [`it()`](https://testthat.r-lib.org/reference/describe.html) inside of [`describe()`](https://testthat.r-lib.org/reference/describe.html). Subtests will now generate more informative failure messages, free from duplication, with more informative skips if any subtests don't contain any expectations. + +- The snapshot experience has been significantly improved, with all known bugs fixed and some new helpers added: [`snapshot_reject()`](https://testthat.r-lib.org/reference/snapshot_accept.html) rejects all modified snapshots by deleting the `.new` variants, and [`snapshot_download_gh()`](https://testthat.r-lib.org/reference/snapshot_download_gh.html) makes it easy to get snapshots off GitHub and into your local package. Additionally, [`expect_snapshot()`](https://testthat.r-lib.org/reference/expect_snapshot.html) and friends will now fail when creating a new snapshot on CI, as that's usually a signal that you've forgotten to run the snapshot code locally before committing. + +- On CRAN, [`test_that()`](https://testthat.r-lib.org/reference/test_that.html) will automatically skip if a package is not installed, which means that you no longer need to check if suggested packages are installed in your tests. + +- `vignette("mocking")` explains mocking in detail, and new [`local_mocked_s3_method()`](https://testthat.r-lib.org/reference/local_mocked_s3_method.html), [`local_mocked_s4_method()`](https://testthat.r-lib.org/reference/local_mocked_s3_method.html), and [`local_mocked_r6_class()`](https://testthat.r-lib.org/reference/local_mocked_r6_class.html) make it easier to mock S3 and S4 methods and R6 classes. + +- [`test_dir()`](https://testthat.r-lib.org/reference/test_dir.html), [`test_check()`](https://testthat.r-lib.org/reference/test_package.html), and friends gain a `shuffle` argument that uses [`sample()`](https://rdrr.io/r/base/sample.html) to randomly reorder the top-level expressions in each test file. This random reordering surfaces dependencies between tests and code outside of any test, as well as dependencies between tests, helping you find and eliminate unintentional dependencies. + +- [`try_again()`](https://testthat.r-lib.org/reference/try_again.html) is now publicized, as it's a useful tool for testing flaky code: + +
+ + 
flaky_function <- function() {
+        if (runif(1) < 0.1) 0 else 1
+      }
+      
+      # 10% chance of failure:
+      test_that("my flaky test is ok", {
+        skip_on_cran()
+        expect_equal(flaky_function(), 1)
+      })
+      
+      # 1% chance of failure:
+      test_that("my flaky test is ok", {
+        skip_on_cran()
+        try_again(1, expect_equal(flaky_function(), 1))
+      })
+      
+      # 0.1% chance of failure:
+      test_that("my flaky test is ok", {
+        skip_on_cran()
+        try_again(2, expect_equal(flaky_function(), 1))
+      })
+ +
+ + Note that it's still good practice to skip such tests on CRAN. + +- New [`skip_unless_r()`](https://testthat.r-lib.org/reference/skip.html) skips tests on unsuitable versions of R. It has a convenient syntax so you can use, e.g., `skip_unless_r(">= 4.1.0")` to skip tests that require [`...names()`](https://rdrr.io/r/base/dots.html). + +- New `SlowReporter` makes it easier to find the slowest tests in your package. You can run it with `devtools::test(reporter = "slow")`. + +- New `vignette("challenging-functions")` provides an index to other documentation organized by various challenges. + +## Acknowledgements + From d63ea680da14ccdc114e3e3b313f19efdc0768b6 Mon Sep 17 00:00:00 2001 From: Hadley Wickham Date: Tue, 11 Nov 2025 08:07:49 -0600 Subject: [PATCH 09/10] Add post metadata, images, and thanks --- content/blog/testthat-3-3-0/index.Rmd | 27 +++++++++++++++---- content/blog/testthat-3-3-0/index.md | 27 ++++++++++++++----- content/blog/testthat-3-3-0/thumbnail-sq.jpg | Bin 0 -> 39832 bytes content/blog/testthat-3-3-0/thumbnail-wd.jpg | Bin 0 -> 116709 bytes 4 files changed, 43 insertions(+), 11 deletions(-) create mode 100644 content/blog/testthat-3-3-0/thumbnail-sq.jpg create mode 100644 content/blog/testthat-3-3-0/thumbnail-wd.jpg diff --git a/content/blog/testthat-3-3-0/index.Rmd b/content/blog/testthat-3-3-0/index.Rmd index ff44c0676..fb47e00df 100644 --- a/content/blog/testthat-3-3-0/index.Rmd +++ b/content/blog/testthat-3-3-0/index.Rmd @@ -7,17 +7,32 @@ date: 2025-11-05 author: Hadley Wickham description: > testthat 3.3.0 brings improved expectations with better error messages, - new expectations for common testing patterns, and lifecycle changes including the removal of `local_mock()` and `with_mock()`. - + new expectations for common testing patterns, and lifecycle changes including the removal of `local_mock()` and `with_mock()`. It also includes + a write-up of my experience doing package development with Claude Code. photo: - url: https://unsplash.com/photos/n6vS3xlnsCc - author: Kelley Bozarth + url: https://unsplash.com/photos/a-rack-filled-with-lots-of-yellow-hard-hats-wp81DxKUd1Ez + author: Pop & Zebra # one of: "deep-dive", "learn", "package", "programming", "roundup", or "other" categories: [package] -tags: [] +tags: [testthat, devtools] --- +```{=html} + +``` + ```{r} #| include: false knitr::opts_chunk$set(collapse = TRUE, comment = "#>") @@ -180,3 +195,5 @@ As you can see from the examples above, when you run a single test interactively * New `vignette("challenging-functions")` provides an index to other documentation organized by various challenges. ## Acknowledgements + +A big thank you to all the folks who helped make this release happen: [@3styleJam](https://github.com/3styleJam), [@afinez](https://github.com/afinez), [@andybeet](https://github.com/andybeet), [@atheriel](https://github.com/atheriel), [@averissimo](https://github.com/averissimo), [@d-morrison](https://github.com/d-morrison), [@DanChaltiel](https://github.com/DanChaltiel), [@DanielHermosilla](https://github.com/DanielHermosilla), [@eitsupi](https://github.com/eitsupi), [@EmilHvitfeldt](https://github.com/EmilHvitfeldt), [@emstruong](https://github.com/emstruong), [@gaborcsardi](https://github.com/gaborcsardi), [@gael-millot](https://github.com/gael-millot), [@hadley](https://github.com/hadley), [@hoeflerb](https://github.com/hoeflerb), [@jamesfowkes](https://github.com/jamesfowkes), [@jan-swissre](https://github.com/jan-swissre), [@jdblischak](https://github.com/jdblischak), [@jennybc](https://github.com/jennybc), [@jeroenjanssens](https://github.com/jeroenjanssens), [@kevinushey](https://github.com/kevinushey), [@krivit](https://github.com/krivit), [@kubajal](https://github.com/kubajal), [@lawalter](https://github.com/lawalter), [@m-muecke](https://github.com/m-muecke), [@maelle](https://github.com/maelle), [@math-mcshane](https://github.com/math-mcshane), [@mcol](https://github.com/mcol), [@metanoid](https://github.com/metanoid), [@MichaelChirico](https://github.com/MichaelChirico), [@moodymudskipper](https://github.com/moodymudskipper), [@njtierney](https://github.com/njtierney), [@nunotexbsd](https://github.com/nunotexbsd), [@pabangan](https://github.com/pabangan), [@pachadotdev](https://github.com/pachadotdev), [@plietar](https://github.com/plietar), [@schloerke](https://github.com/schloerke), [@schuemie](https://github.com/schuemie), [@sebkopf](https://github.com/sebkopf), [@shikokuchuo](https://github.com/shikokuchuo), [@snystrom](https://github.com/snystrom), [@stibu81](https://github.com/stibu81), [@TimTaylor](https://github.com/TimTaylor), and [@tylermorganwall](https://github.com/tylermorganwall). diff --git a/content/blog/testthat-3-3-0/index.md b/content/blog/testthat-3-3-0/index.md index 3cd509dd1..0133e3797 100644 --- a/content/blog/testthat-3-3-0/index.md +++ b/content/blog/testthat-3-3-0/index.md @@ -7,19 +7,32 @@ date: 2025-11-05 author: Hadley Wickham description: > testthat 3.3.0 brings improved expectations with better error messages, - new expectations for common testing patterns, and lifecycle changes including the removal of `local_mock()` and `with_mock()`. - + new expectations for common testing patterns, and lifecycle changes including the removal of `local_mock()` and `with_mock()`. It also includes + a write-up of my experience doing package development with Claude Code. photo: - url: https://unsplash.com/photos/n6vS3xlnsCc - author: Kelley Bozarth + url: https://unsplash.com/photos/a-rack-filled-with-lots-of-yellow-hard-hats-wp81DxKUd1Ez + author: Pop & Zebra # one of: "deep-dive", "learn", "package", "programming", "roundup", or "other" categories: [package] -tags: [] -rmd_hash: a016ade71001134a +tags: [testthat, devtools] +rmd_hash: 0ef3010e84b47ab3 --- + + We're chuffed to announce the release of [testthat](https://testthat.r-lib.org) 3.3.0. testthat is a testing framework for R that makes it easy to turn your existing informal tests into formal, automated tests that you can rerun quickly and easily. You can install it from CRAN with: @@ -219,3 +232,5 @@ As you can see from the examples above, when you run a single test interactively ## Acknowledgements +A big thank you to all the folks who helped make this release happen: [@3styleJam](https://github.com/3styleJam), [@afinez](https://github.com/afinez), [@andybeet](https://github.com/andybeet), [@atheriel](https://github.com/atheriel), [@averissimo](https://github.com/averissimo), [@d-morrison](https://github.com/d-morrison), [@DanChaltiel](https://github.com/DanChaltiel), [@DanielHermosilla](https://github.com/DanielHermosilla), [@eitsupi](https://github.com/eitsupi), [@EmilHvitfeldt](https://github.com/EmilHvitfeldt), [@emstruong](https://github.com/emstruong), [@gaborcsardi](https://github.com/gaborcsardi), [@gael-millot](https://github.com/gael-millot), [@hadley](https://github.com/hadley), [@hoeflerb](https://github.com/hoeflerb), [@jamesfowkes](https://github.com/jamesfowkes), [@jan-swissre](https://github.com/jan-swissre), [@jdblischak](https://github.com/jdblischak), [@jennybc](https://github.com/jennybc), [@jeroenjanssens](https://github.com/jeroenjanssens), [@kevinushey](https://github.com/kevinushey), [@krivit](https://github.com/krivit), [@kubajal](https://github.com/kubajal), [@lawalter](https://github.com/lawalter), [@m-muecke](https://github.com/m-muecke), [@maelle](https://github.com/maelle), [@math-mcshane](https://github.com/math-mcshane), [@mcol](https://github.com/mcol), [@metanoid](https://github.com/metanoid), [@MichaelChirico](https://github.com/MichaelChirico), [@moodymudskipper](https://github.com/moodymudskipper), [@njtierney](https://github.com/njtierney), [@nunotexbsd](https://github.com/nunotexbsd), [@pabangan](https://github.com/pabangan), [@pachadotdev](https://github.com/pachadotdev), [@plietar](https://github.com/plietar), [@schloerke](https://github.com/schloerke), [@schuemie](https://github.com/schuemie), [@sebkopf](https://github.com/sebkopf), [@shikokuchuo](https://github.com/shikokuchuo), [@snystrom](https://github.com/snystrom), [@stibu81](https://github.com/stibu81), [@TimTaylor](https://github.com/TimTaylor), and [@tylermorganwall](https://github.com/tylermorganwall). + diff --git a/content/blog/testthat-3-3-0/thumbnail-sq.jpg b/content/blog/testthat-3-3-0/thumbnail-sq.jpg new file mode 100644 index 0000000000000000000000000000000000000000..57f2a057161f6ff421bace49f413e8e0d1d25a29 GIT binary patch literal 39832 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 CH5lmt literal 0 HcmV?d00001 From 8947c3268a07576429c2dcce475de5f5fba0fc32 Mon Sep 17 00:00:00 2001 From: Hadley Wickham Date: Tue, 11 Nov 2025 13:58:00 -0600 Subject: [PATCH 10/10] Set `cli.width` --- content/blog/testthat-3-3-0/index.Rmd | 1 + content/blog/testthat-3-3-0/index.md | 16 ++++++++-------- 2 files changed, 9 insertions(+), 8 deletions(-) diff --git a/content/blog/testthat-3-3-0/index.Rmd b/content/blog/testthat-3-3-0/index.Rmd index fb47e00df..be8eb83d8 100644 --- a/content/blog/testthat-3-3-0/index.Rmd +++ b/content/blog/testthat-3-3-0/index.Rmd @@ -36,6 +36,7 @@ TODO: ```{r} #| include: false knitr::opts_chunk$set(collapse = TRUE, comment = "#>") +options(cli.width = 70) ``` We're chuffed to announce the release of [testthat](https://testthat.r-lib.org) 3.3.0. testthat is a testing framework for R that makes it easy to turn your existing informal tests into formal, automated tests that you can rerun quickly and easily. diff --git a/content/blog/testthat-3-3-0/index.md b/content/blog/testthat-3-3-0/index.md index 0133e3797..a88c001c1 100644 --- a/content/blog/testthat-3-3-0/index.md +++ b/content/blog/testthat-3-3-0/index.md @@ -16,7 +16,7 @@ photo: # one of: "deep-dive", "learn", "package", "programming", "roundup", or "other" categories: [package] tags: [testthat, devtools] -rmd_hash: 0ef3010e84b47ab3 +rmd_hash: cafc41a1570ad7aa --- @@ -103,7 +103,7 @@ This new framework helped us write six new expectations: x <- c(0.408, 0.961, 0.883, 0.46, 0.537, 0.961, 0.851, 0.887, 0.023) expect_all_true(x < 0.95) }) - #> ── Failure: some test ───────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────── + #> ── Failure: some test ──────────────────────────────────────────────── #> Expected every element of `x < 0.95` to equal TRUE. #> Differences: #> `actual`: TRUE FALSE TRUE TRUE TRUE FALSE TRUE TRUE TRUE @@ -121,7 +121,7 @@ This new framework helped us write six new expectations: 
    test_that("", {
       expect_disjoint(c("a", "b", "c"), c("c", "d", "e"))
     })
-    #> ── Failure:  ──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
+    #> ── Failure:  ─────────────────────────────────────────────────────────
     #> Expected `c("a", "b", "c")` to be disjoint from `c("c", "d", "e")`.
     #> Actual: "a", "b", "c"
     #> Expected: None of "c", "d", "e"
@@ -143,10 +143,10 @@ This new framework helped us write six new expectations:
       x <- R6::R6Class("bar")$new()
       expect_r6_class(x, "foo")
     })
-    #> ── Failure:  ──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
+    #> ── Failure:  ─────────────────────────────────────────────────────────
     #> Expected `x` to be an R6 object.
     #> Actual OO type: none.
-    #> ── Failure:  ──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
+    #> ── Failure:  ─────────────────────────────────────────────────────────
     #> Expected `x` to inherit from "foo".
     #> Actual class: "bar"/"R6".
     #> Error:
@@ -165,13 +165,13 @@ This new framework helped us write six new expectations:
       expect_shape(x, dim = c(3, 3, 3))
       expect_shape(x, dim = c(3, 4))
     })
-    #> ── Failure: show off expect_shape() failure messages ──────────────────────────────────────────────────────────────────────────────────────────────────────
+    #> ── Failure: show off expect_shape() failure messages ─────────────────
     #> Expected `x` to have 4 rows.
     #> Actual rows: 3.
-    #> ── Failure: show off expect_shape() failure messages ──────────────────────────────────────────────────────────────────────────────────────────────────────
+    #> ── Failure: show off expect_shape() failure messages ─────────────────
     #> Expected `x` to have 3 dimensions.
     #> Actual dimensions: 2.
-    #> ── Failure: show off expect_shape() failure messages ──────────────────────────────────────────────────────────────────────────────────────────────────────
+    #> ── Failure: show off expect_shape() failure messages ─────────────────
     #> Expected `x` to have dim (3, 4).
     #> Actual dim: (3, 3).
     #> Error: