mockery::mock and mockery::stub do not work properly with quasiquotation?

I've written an import function that gets a single file from an aws s3-bucket.

That function itself is a wrapper around aws.s3::s3read_using() which takes a reading function as its first argument.

Why do I wrap around aws.s3::s3read_using() ? Because I need to do some special error-handling and want the wrapping function to do some Recall() up to a limit... but that's a different story.

Now that i've successfully build and tested my wrapping function i want to do another wrapping arround that:

I want to iterate n times over my wrapper to bind the downloaded files together. I now have the difficulty to hand the 'reading_function' to the FUN argument of aws.s3::s3read_using().

I could do that by simply using ... - BUT! I want to make clear to the USER of my wrapping wrapper, that he needs to specify that argument.

So I've decided to use rlangs rlang::enexpr() to capture the argument and to hand it over to my first wrapper via !! - which in return captures that argument again with rlang::enexpr() and hands it over - finally - to aws.s3::s3read_using() via rlang::expr(aws.s3::s3read_using(FUN = !!reading_fn, object = s3_object))

That works perfectly fine and smooth. My Problem is with testing that function construct using testthat and mockery

Here is some broadly simplyfied code:

my_workhorse_function <- function(fn_to_work_with, value_to_work_on) {
  fn <- rlang::enexpr(fn_to_work_with)
  # Some other magic happens here - error handling, condition-checking, etc...
  out <- eval(rlang::expr((!!fn)(value_to_work_on)))
}

my_iterating_function <- function(fn_to_iter_with, iterate_over) {
  fn <- rlang::enexpr(fn_to_iter_with)
  out <- list()
  for(i in seq_along(iterate_over)) {
    out[[i]] <- my_workhorse_function(!!fn, iterate_over[i])
  }
  return(out)
}

# Works just fine
my_iterating_function(sqrt, c(9:16))

Now, to the test:

# Throws an ERROR: 'Error in `!fn`: invalid argument type'
test_that("my_iterating_function iterates length(iterate_over) times over my_workhorse_function", {
  mock_1 <- mockery::mock(1, cycle = TRUE)
  stub(my_iterating_function, "my_workhorse_function", mock_1)
  expect_equal(my_iterating_function(sqrt, c(9:16)), list(1,1,1,1,1,1,1,1))
  expect_called(mock_1, 8)
})

I've used a workarround, but that just doesn't feel right, even though, it works:

# Test passed
test_that("my_iterating_function iterates length(iterate_over) times over my_workhorse_function", {
  mock_1 <- mockery::mock(1, cycle = TRUE)
  stub(my_iterating_function, "my_workhorse_function", 
       function(fn_to_work_with, value_to_work_on) {
         fn <- rlang::enexpr(fn_to_work_with)
         out <- mock_1(fn, value_to_work_on)
         out})
  expect_equal(my_iterating_function(sqrt, c(9:16)), list(1,1,1,1,1,1,1,1))
  expect_called(mock_1, 8)
})

I'm using version of R: 4.1.1 I'm using versions of testthat(3.1.1), mockery(0.4.2), rlang(0.4.12)

I think you're complicating things here, although maybe I'm not fully understanding your end goal. You can directly pass functions through arguments without any issue. Your example code above can be easily simplified to (keeping the loop just to match your test_that() call):

library(testthat)
library(mockery)

my_workhorse_function <- function(fn_to_work_with, value_to_work_on) {
  fn_to_work_with(value_to_work_on)
}

my_iterating_function <- function(fn_to_iter_with, iterate_over) {
  out <- list()
  for(i in seq_along(iterate_over)) {
    out[[i]] <- my_workhorse_function(fn_to_iter_with, iterate_over[i])
  }
  return(out)
}

# Works just fine
my_iterating_function(sqrt, c(9:16))
#> [[1]]
#> [1] 3
#> 
#> ...

test_that("my_iterating_function iterates length(iterate_over) times over my_workhorse_function", {
  mock_1 <- mockery::mock(1, cycle = TRUE)
  stub(my_iterating_function, "my_workhorse_function", mock_1)
  expect_equal(my_iterating_function(sqrt, c(9:16)), list(1,1,1,1,1,1,1,1))
  expect_called(mock_1, 8)
})
#> Test passed 🥇

You can just pass FUN directly through all of your nested functions. The functions you're wrapping with enexpr() were never going to be evaluated in the first place until you explicitly call them. You usually use enexpr when users are supplying expressions, not just functions.