How to set up a workflow that tests an R package against a Julia package

So, how does a workflow to test an R package against a Julia package looks like?

First of all, I have used the skeleton of fwildclusterboot to produce a wrapper around WildBootTests.jl, wildboottestjlr. All data pre-processing is handled by functions copied from fwildclusterboot. For running the bootstrap, R sends all required objects to Julia (via the excellent JuliaConnectoR package, on which I will blog in the future). In a second step, I have added wildboottestjlr to fwildclusterboot's dependencies and have initiated a github actions workflow via usethis::use_github_actions(). (Note that it is in fact not neccessariy to write an entire R wrapper-package for the Julia algorithm you want to test. wildboottestjlr exists because WildBootTests.jl is actually a magnitude faster than fwildclusterboot and because it has many additional feature, as e.g. a wild cluster bootstrap for instrumental variables.)

The created workflow yaml looks like this:

# For help debugging build failures open an issue on the RStudio community with the 'github-actions' tag.
# https://community.rstudio.com/new-topic?category=Package%20development&tags=github-actions
on:
  push:
    branches:
      - main
      - master
  pull_request:
    branches:
      - main
      - master

name: R-CMD-check

jobs:
  R-CMD-check:
    runs-on: ${{ matrix.config.os }}

    name: ${{ matrix.config.os }} (${{ matrix.config.r }})

    strategy:
      fail-fast: false
      matrix:
        config:
          - {os: windows-latest, r: 'release'}
          - {os: macOS-latest, r: 'release'}
          - {os: ubuntu-20.04, r: 'release', rspm: "https://packagemanager.rstudio.com/cran/__linux__/focal/latest"}

    env:
      R_REMOTES_NO_ERRORS_FROM_WARNINGS: true
      RSPM: ${{ matrix.config.rspm }}
      GITHUB_PAT: ${{ secrets.GITHUB_TOKEN }}

    steps:
      - uses: actions/checkout@v2

      - uses: r-lib/actions/setup-r@v2
        with:
          r-version: ${{ matrix.config.r }}

      - uses: r-lib/actions/setup-pandoc@v2

      - name: Query dependencies
        run: |
          install.packages('remotes')
          saveRDS(remotes::dev_package_deps(dependencies = TRUE), ".github/depends.Rds", version = 2)
          writeLines(sprintf("R-%i.%i", getRversion()$major, getRversion()$minor), ".github/R-version")
        shell: Rscript {0}

      - name: Cache R packages
        if: runner.os != 'Windows'
        uses: actions/cache@v2
        with:
          path: ${{ env.R_LIBS_USER }}
          key: ${{ runner.os }}-${{ hashFiles('.github/R-version') }}-1-${{ hashFiles('.github/depends.Rds') }}
          restore-keys: ${{ runner.os }}-${{ hashFiles('.github/R-version') }}-1-

      - name: Install system dependencies
        if: runner.os == 'Linux'
        run: |
          while read -r cmd
          do
            eval sudo $cmd
          done < <(Rscript -e 'writeLines(remotes::system_requirements("ubuntu", "20.04"))')
      - name: Install dependencies
        run: |
          remotes::install_deps(dependencies = TRUE)
          remotes::install_cran("rcmdcheck")
        shell: Rscript {0}
        
      # install julia
      - uses: julia-actions/setup-julia@v1
      # add julia to renviron
      - name: Create and populate .Renviron file
        run: echo JULIA_BINDIR= "${{ env.juliaLocation }}" >> ~/.Renviron
        shell: bash

      # install WildBootTests.jl
      - name: install WildBootTests.jl 
        run: julia -e 'using Pkg; Pkg.add("WildBootTests")'
        # use shell bash to ensure consistent behavior across OS
        shell: bash

      - name: Check
        env:
          _R_CHECK_CRAN_INCOMING_REMOTE_: false
        run: rcmdcheck::rcmdcheck(args = c("--no-manual", "--as-cran"), error_on = "warning", check_dir = "check")
        shell: Rscript {0}

      - name: Upload check results
        if: failure()
        uses: actions/upload-artifact@main
        with:
          name: ${{ runner.os }}-r${{ matrix.config.r }}-results
          path: check

In a nutshell, this workflow installs R and fwildclusterboot in a clean ubuntu environment, conducts a cmd-check and initiates all of fwildclusterboot's unit tests.

To enable testing against Julia and WildBootTests.jl, it further adds three ‘steps’ to the workflow: the workflow has to install Julia, WildBootTests.jl (and all its Julia dependencies) and link R and Julia so that JuliaConnectoR could communicate between the two languages.

This is easily be achieved by adding the lines below to the yaml file create by usethis::use_github_action():

# install julia
- uses: julia-actions/setup-julia@v1
# add julia to renviron
- name: Create and populate .Renviron file
  run: echo JULIA_BINDIR= "${{ env.juliaLocation }}" >> ~/.Renviron
  shell: bash

# install WildBootTests.jl
  - name: install WildBootTests.jl 
    run: julia -e 'using Pkg; Pkg.add("WildBootTests")'
  # use shell bash to ensure consistent behavior across OS
    shell: bash

Placing these few lines in the workflow yaml before the cmd check is triggered completes the workflow. It now downloads R and Julia, installs fwildclusterboot, wildboottestjlr and WildBootTests.jl, links R and Julia, and runs all of fwildclusterboot's unit tests. The remaining step is to push to github, and then all unit tests are running!