test.yml

# This is a basic workflow to help you get started with Actions

name: Test

defaults:
  run:
    shell: bash
    
# Controls when the action will run. 
on:
  # Triggers the workflow on push or pull request events but only for the master branch
  push:
    branches: [ master, dev, ci ]
  pull_request:
    branches: [ master, dev, ci ]

# A workflow run is made up of one or more jobs that can run sequentially or in parallel
jobs:
  build-and-test:
    # Runs on all major platforms 
    runs-on: ${{ matrix.os }} 
    strategy:
      matrix:
        os: [windows-latest, ubuntu-latest, macos-latest]
        agda: ["Agda-2.6.3", "Agda-2.6.4", "Agda-2.7.0"]
      fail-fast: false

    # Steps represent a sequence of tasks that will be executed as part of the job
    steps:
      - name: 📥 Checkout repository
        uses: actions/checkout@v4

      # actions:

      # $DIST is where the binary & its dependencies is placed
      - name: 🛠️ Setting variables
        run: | 
          echo "DIST=${{ matrix.agda }}-${{ matrix.os }}"  >> "$GITHUB_ENV"

      - name: 🔍 Reviewing variables
        run: |
          echo "runner.os         = ${{ runner.os                               }}"
          echo "ghc-path          = ${{ steps.haskell-setup.outputs.ghc-path    }}"
          echo "ghc-exe           = ${{ steps.haskell-setup.outputs.ghc-exe     }}"
          echo "stack-path        = ${{ steps.haskell-setup.outputs.stack-path  }}"
          echo "stack-exe         = ${{ steps.haskell-setup.outputs.stack-exe   }}"
          echo "stack-root        = ${{ steps.haskell-setup.outputs.stack-root  }}"
          echo "DIST              = $DIST"
    
      # cached stuff to be restored:
      # - name: 💾 Restore cached stack global package db
      #   id:   stack-global
      #   uses: actions/cache/restore@v4
      #   with:
      #     path: ${{ steps.haskell-setup.outputs.stack-root }}
      #     key: ${{ runner.os }}-stack-global-${{ matrix.agda }}
      #     restore-keys: |
      #         ${{ runner.os }}-stack-global

      # - name: 💾 Restore stack-installed binaries in ~/.local/bin
      #   id:   stack-binaries
      #   uses: actions/cache/restore@v4
      #   with:
      #     path: ${{ env.STACK_LOCAL_BIN  }}
      #     key: ${{ runner.os }}-stack-binaries-${{ matrix.agda }}
      #     restore-keys: |
      #         ${{ runner.os }}-stack-binaries
        
      - name: 💾 Restore Agda from ${{ env.DIST }}
        id:   agda-artefacts
        uses: actions/cache/restore@v4
        with:
          path: ${{ env.DIST  }}
          key: ${{ env.DIST  }}
          restore-keys: |
              ${{ env.DIST  }}
        
      - name: ⏬ Setup Node.js environment
        uses: actions/setup-node@v4
        with:
          node-version: 20.x
      
      - name: 🛠️ Add ${{ env.DIST }}/bin to PATH
        run: echo $(pwd)/$DIST/bin >> $GITHUB_PATH
              
      # - name: 🛠️ Add ${{ env.STACK_LOCAL_BIN }} to PATH
      #   run: echo $STACK_LOCAL_BIN >> $GITHUB_PATH

      - name: 🔍 Check if Agda has been installed
        id: check-agda
        continue-on-error: true
        run: which agda

      - name: 📦 Setup ${{ env.DIST }}
        if: ${{ steps.check-agda.outcome == 'failure'}}
        run: |
          mkdir -p $DIST
          mkdir -p $DIST/bin
  
      - name: ⏬ Setup Haskell environment
        if: ${{ steps.check-agda.outcome == 'failure'}}
        id: haskell-setup
        uses: haskell-actions/setup@v2
        with:
          ghc-version: '9.2.8'
          stack-version: latest
          cabal-update: false
          enable-stack: true

      - name: ⏬ Install Agda
        if: ${{ steps.check-agda.outcome == 'failure'}}
        run: |
          stack install --resolver=lts-20.26 ${{ matrix.agda }}
          echo "STACK_LOCAL_BIN=$(stack path --local-bin)" >> "$GITHUB_ENV"

      - name: 📦 Move artefacts to ${{ env.DIST }}
        if: ${{ steps.check-agda.outcome == 'failure'}}
        run: |

          # Copy the binary:
          cp $STACK_LOCAL_BIN/agda $DIST/bin
          
          # Strip the binary:
          if [[ ${{ runner.os }} == "Windows" ]]; then
            strip $DIST/bin/agda.exe
            file $DIST/bin/agda.exe
          else
            strip $DIST/bin/agda
            file $DIST/bin/agda
          fi

          # Copy the rest of the artefacts:
          cp -a $($STACK_LOCAL_BIN/agda --print-agda-dir)/. $DIST
          
      - name: 🌐 Setting the $Agda_datadir environment variable
        run: echo "Agda_datadir=$(pwd)/$DIST" >> "$GITHUB_ENV"

      - name: 🔍 Check if Agda has been installed again
        if: ${{ steps.check-agda.outcome == 'failure'}}
        run: |
          echo "Agda_datadir    = $Agda_datadir"
          echo "Path of Agda    = $(which agda)"
          echo "Version of Agda = $(agda -V)"

      # things to be cached
      # - name: 💾 Cache stack global package db
      #   if:   always() && steps.stack-global.outputs.cache-hit != 'true'
      #   uses: actions/cache/save@v4
      #   with:
      #     path: ${{ steps.haskell-setup.outputs.stack-root }}
      #     key: ${{ steps.stack-global.outputs.cache-primary-key }}

      # - name: 💾 Cache stack-installed binaries
      #   if:   always() && steps.stack-binaries.outputs.cache-hit != 'true'
      #   uses: actions/cache/save@v4
      #   with:
      #     path: ${{ env.STACK_LOCAL_BIN }}
      #     key: ${{ steps.stack-binaries.outputs.cache-primary-key }}
     
      - name: 💾 Cache Agda in ${{ env.DIST  }}
        if:   always() && steps.agda-artefacts.outputs.cache-hit != 'true'
        uses: actions/cache/save@v4
        with:
          path: ${{ env.DIST  }}
          key: ${{ steps.agda-artefacts.outputs.cache-primary-key }}
    
      - name: ⏬ Install NPM Dependencies
        run: npm install
        
      - name: 🔨 Build stuff 
        run: npm run build

      - name: 🚗 Run tests
        run: |
          if [[ ${{ runner.os }} == "Linux" ]]; then
            xvfb-run -a npm test
          else
            npm test
          fi