mockery::mock and mockery::stub do not work propperly with quasiquotation?-CodePudding

I've written an import function that gets a single file from an aws s3-bucket. That function itself is a wrapper arround 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)

CodePudding user response：

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