Make installer work on any os/arch and add installer tests (#3712)

.github/workflows/ci.yaml

@@ -1,4 +1,4 @@
-name: ci
+name: Build
 
 on:
   push:
@@ -16,7 +16,7 @@ on:
 
 jobs:
   prebuild:
-    name: Pre-Build checks
+    name: Pre-build checks
     runs-on: ubuntu-latest
     timeout-minutes: 5
     env:

.github/workflows/installer.yml

@@ -0,0 +1,57 @@
+name: Installer integration
+
+on:
+  push:
+    branches:
+      - main
+    paths:
+      - "installer.sh"
+  pull_request:
+    branches:
+      - main
+
+jobs:
+  ubuntu:
+    name: Test installer on Ubuntu
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout repo
+        uses: actions/checkout@v2
+
+      - name: Install code-server
+        run: ./install.sh
+
+      - name: Test code-server
+        run: yarn test:standalone-release code-server
+
+  alpine:
+    name: Test installer on Alpine
+    runs-on: ubuntu-latest
+    container: "alpine:3.14"
+    steps:
+      - name: Checkout repo
+        uses: actions/checkout@v2
+
+      - name: Install curl
+        run: apk add curl
+
+      - name: Add user
+        run: adduser coder --disabled-password
+
+      # Standalone should work without root.
+      - name: Test standalone to a non-existent prefix
+        run: su coder -c "./install.sh --method standalone --prefix /tmp/does/not/yet/exist"
+
+  macos:
+    name: Test installer on macOS
+    runs-on: macos-latest
+
+    steps:
+      - name: Checkout repo
+        uses: actions/checkout@v2
+
+      - name: Install code-server
+        run: ./install.sh
+
+      - name: Test code-server
+        run: yarn test:standalone-release code-server

.github/workflows/scripts.yml

@@ -0,0 +1,30 @@
+name: Script unit tests
+
+on:
+  push:
+    branches:
+      - main
+    paths:
+      - "installer.sh"
+  pull_request:
+    branches:
+      - main
+
+jobs:
+  test:
+    name: Run script unit tests
+    runs-on: ubuntu-latest
+    # This runs on Alpine to make sure we're testing with actual sh.
+    container: "alpine:3.14"
+    steps:
+      - name: Checkout repo
+        uses: actions/checkout@v2
+
+      - name: Install test utilities
+        run: apk add bats checkbashisms
+
+      - name: Check Bashisms
+        run: checkbashisms ./install.sh
+
+      - name: Run script unit tests
+        run: ./ci/dev/test-scripts.sh

ci/build/test-standalone-release.sh

@@ -1,7 +1,9 @@
 #!/usr/bin/env bash
 set -euo pipefail
 
-# Makes sure the release works.
+# Make sure a code-server release works. You can pass in the path otherwise it
+# will use release-standalone in the current directory.
+#
 # This is to make sure we don't have Node version errors or any other
 # compilation-related errors.
 main() {
@@ -10,12 +12,14 @@ main() {
   local EXTENSIONS_DIR
   EXTENSIONS_DIR="$(mktemp -d)"
 
-  echo "Testing standalone release."
+  local path=${1:-./release-standalone/bin/code-server}
 
-  # Note: using a basic theme extension because it doesn't update often and is more reliable for testing
+  echo "Testing standalone release in $path."
-  ./release-standalone/bin/code-server --extensions-dir "$EXTENSIONS_DIR" --install-extension wesbos.theme-cobalt2
+
+  # NOTE: using a basic theme extension because it doesn't update often and is more reliable for testing
+  "$path" --extensions-dir "$EXTENSIONS_DIR" --install-extension wesbos.theme-cobalt2
   local installed_extensions
-  installed_extensions="$(./release-standalone/bin/code-server --extensions-dir "$EXTENSIONS_DIR" --list-extensions 2>&1)"
+  installed_extensions="$("$path" --extensions-dir "$EXTENSIONS_DIR" --list-extensions 2>&1)"
   # We use grep as wesbos.theme-cobalt2 may have dependency extensions that change.
   if ! echo "$installed_extensions" | grep -q "wesbos.theme-cobalt2"; then
     echo "Unexpected output from listing extensions:"

ci/dev/test-scripts.sh

@@ -0,0 +1,9 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+main() {
+  cd "$(dirname "$0")/../.."
+  bats ./test/scripts
+}
+
+main "$@"

docs/CONTRIBUTING.md

@@ -44,6 +44,8 @@ Here is what is needed:
   - Get this by running `apt-get install -y build-essential`
 - `rsync` and `unzip`
   - Used for code-server releases
+- `bats`
+  - Used to run script unit tests
 
 ## Creating pull requests
 

install.sh

@@ -14,7 +14,7 @@ usage() {
   fi
 
   cath << EOF
-Installs code-server for Linux, macOS and FreeBSD.
+Installs code-server.
 It tries to use the system package manager if possible.
 After successful installation it explains how to start using code-server.
 
@@ -48,24 +48,23 @@ Usage:
   --rsh <bin>
       Specifies the remote shell for remote installation. Defaults to ssh.
 
-- For Debian, Ubuntu and Raspbian it will install the latest deb package.
+The detection method works as follows:
-- For Fedora, CentOS, RHEL and openSUSE it will install the latest rpm package.
+  - Debian, Ubuntu, Raspbian: install the deb package from GitHub.
-- For Arch Linux it will install the AUR package.
+  - Fedora, CentOS, RHEL, openSUSE: install the rpm package from GitHub.
-- For any unrecognized Linux operating system it will install the latest standalone
+  - Arch Linux: install from the AUR (which pulls releases from GitHub).
-  release into ~/.local
+  - FreeBSD, Alpine: install from yarn/npm.
+  - macOS: install using Homebrew if installed otherwise install from GitHub.
+  - All others: install the release from GitHub.
 
-- For macOS it will install the Homebrew package.
+We only build releases on GitHub for amd64 and arm64 on Linux and amd64 for
-  - If Homebrew is not installed it will install the latest standalone release
+macOS. When the detection method tries to pull a release from GitHub it will
-    into ~/.local
+fall back to installing from npm when there is no matching release for the
+system's operating system and architecture.
 
-- For FreeBSD or Alpine, it will install the npm package with yarn or npm.
+The standalone method will force installion using GitHub releases. It will not
+fall back to npm so on architectures without pre-built releases this will error.
 
-- If ran on an architecture with no releases, it will install the
+The installer will cache all downloaded assets into ~/.cache/code-server
-  npm package with yarn or npm.
-  - We only have releases for amd64 and arm64 presently.
-  - The npm package builds the native modules on postinstall.
-
-It will cache all downloaded assets into ~/.cache/code-server
 
 More installation docs are at https://coder.com/docs/code-server/v3.10.2/install
 EOF
@@ -82,10 +81,11 @@ echo_latest_version() {
 echo_npm_postinstall() {
   echoh
   cath << EOF
-The npm package has been installed successfully!
+npm package has been installed.
-Please extend your path to use code-server:
+
+Extend your path to use code-server:
   PATH="$NPM_BIN_DIR:\$PATH"
-Please run with:
+Then run with:
   code-server
 EOF
 }
@@ -94,9 +94,20 @@ echo_standalone_postinstall() {
   echoh
   cath << EOF
 Standalone release has been installed into $STANDALONE_INSTALL_PREFIX/lib/code-server-$VERSION
-Please extend your path to use code-server:
+
+Extend your path to use code-server:
   PATH="$STANDALONE_INSTALL_PREFIX/bin:\$PATH"
-Then you can run:
+Then run with:
+  code-server
+EOF
+}
+
+echo_brew_postinstall() {
+  echoh
+  cath << EOF
+Brew release has been installed.
+
+Run with:
   code-server
 EOF
 }
@@ -104,6 +115,8 @@ EOF
 echo_systemd_postinstall() {
   echoh
   cath << EOF
+$1 package has been installed.
+
 To have systemd start code-server now and restart on boot:
   sudo systemctl enable --now code-server@\$USER
 Or, if you don't want/need a background service you can run:
@@ -119,8 +132,6 @@ main() {
   unset \
     DRY_RUN \
     METHOD \
-    STANDALONE_INSTALL_PREFIX \
-    VERSION \
     OPTIONAL \
     ALL_FLAGS \
     RSH_ARGS \
@@ -198,80 +209,70 @@ main() {
     return
   fi
 
-  VERSION="${VERSION-$(echo_latest_version)}"
   METHOD="${METHOD-detect}"
   if [ "$METHOD" != detect ] && [ "$METHOD" != standalone ]; then
     echoerr "Unknown install method \"$METHOD\""
     echoerr "Run with --help to see usage."
     exit 1
   fi
-  STANDALONE_INSTALL_PREFIX="${STANDALONE_INSTALL_PREFIX-$HOME/.local}"
 
-  OS="$(os)"
+  # These are used by the various install_* functions that make use of GitHub
-  if [ ! "$OS" ]; then
+  # releases in order to download and unpack the right release.
-    echoerr "Unsupported OS $(uname)."
+  CACHE_DIR=$(echo_cache_dir)
-    exit 1
+  STANDALONE_INSTALL_PREFIX=${STANDALONE_INSTALL_PREFIX:-$HOME/.local}
-  fi
+  VERSION=${VERSION:-$(echo_latest_version)}
+  # These can be overridden for testing but shouldn't normally be used as it can
+  # result in a broken code-server.
+  OS=${OS:-$(os)}
+  ARCH=${ARCH:-$(arch)}
 
   distro_name
 
-  ARCH="$(arch)"
+  # Standalone installs by pulling pre-built releases from GitHub.
-  if [ ! "$ARCH" ]; then
-    if [ "$METHOD" = standalone ]; then
-      echoerr "No precompiled releases for $(uname -m)."
-      echoerr 'Please rerun without the "--method standalone" flag to install from npm.'
-      exit 1
-    fi
-    echoh "No precompiled releases for $(uname -m)."
-    install_npm
-    return
-  fi
-
-  if [ "$OS" = "freebsd" ]; then
-    if [ "$METHOD" = standalone ]; then
-      echoerr "No precompiled releases available for $OS."
-      echoerr 'Please rerun without the "--method standalone" flag to install from npm.'
-      exit 1
-    fi
-    echoh "No precompiled releases available for $OS."
-    install_npm
-    return
-  fi
-
-  if [ "$OS" = "linux" ] && [ "$(distro)" = "alpine" ]; then
-    if [ "$METHOD" = standalone ]; then
-      echoerr "No precompiled releases available for alpine."
-      echoerr 'Please rerun without the "--method standalone" flag to install from npm.'
-      exit 1
-    fi
-    echoh "No precompiled releases available for alpine."
-    install_npm
-    return
-  fi
-
-  CACHE_DIR="$(echo_cache_dir)"
-
   if [ "$METHOD" = standalone ]; then
+    if has_standalone; then
       install_standalone
-    return
+      exit 0
+    else
+      echoerr "There are no standalone releases for $ARCH"
+      echoerr "Please try again without '--method standalone'"
+      exit 1
+    fi
   fi
 
-  case "$(distro)" in
+  # DISTRO can be overridden for testing but shouldn't normally be used as it
+  # can result in a broken code-server.
+  DISTRO=${DISTRO:-$(distro)}
+
+  case $DISTRO in
+    # macOS uses brew when available and falls back to standalone. We only have
+    # amd64 for macOS so for anything else use npm.
     macos)
-      install_macos
+      BREW_PATH="${BREW_PATH-brew}"
-      ;;
+      if command_exists "$BREW_PATH"; then
-    debian)
+        install_brew
-      install_deb
+      else
-      ;;
+        echoh "Homebrew not installed."
-    fedora | opensuse)
+        echoh "Falling back to standalone installation."
-      install_rpm
+        npm_fallback install_standalone
-      ;;
+      fi
-    arch)
-      install_aur
       ;;
+    # The .deb and .rpm files are pulled from GitHub and we only have amd64 and
+    # arm64 there and need to fall back to npm otherwise.
+    debian) npm_fallback install_deb ;;
+    fedora | opensuse) npm_fallback install_rpm ;;
+    # Arch uses the AUR package which only supports amd64 and arm64 since it
+    # pulls releases from GitHub so we need to fall back to npm.
+    arch) npm_fallback install_aur ;;
+    # We don't have GitHub releases that work on Alpine or FreeBSD so we have no
+    # choice but to use npm here.
+    alpine | freebsd) install_npm ;;
+    # For anything else we'll try to install standalone but fall back to npm if
+    # we don't have releases for the architecture.
     *)
       echoh "Unsupported package manager."
-      install_standalone
+      echoh "Falling back to standalone installation."
+      npm_fallback install_standalone
       ;;
   esac
 }
@@ -326,45 +327,39 @@ fetch() {
   sh_c mv "$FILE.incomplete" "$FILE"
 }
 
-install_macos() {
+install_brew() {
-  if command_exists brew; then
+  echoh "Installing latest from Homebrew."
-    echoh "Installing from Homebrew."
   echoh
 
-    sh_c brew install code-server
+  sh_c "$BREW_PATH" install code-server
 
-    return
+  echo_brew_postinstall
-  fi
-
-  echoh "Homebrew not installed."
-
-  install_standalone
 }
 
 install_deb() {
-  echoh "Installing v$VERSION deb package from GitHub releases."
+  echoh "Installing v$VERSION of the $ARCH deb package from GitHub."
   echoh
 
   fetch "https://github.com/cdr/code-server/releases/download/v$VERSION/code-server_${VERSION}_$ARCH.deb" \
     "$CACHE_DIR/code-server_${VERSION}_$ARCH.deb"
   sudo_sh_c dpkg -i "$CACHE_DIR/code-server_${VERSION}_$ARCH.deb"
 
-  echo_systemd_postinstall
+  echo_systemd_postinstall deb
 }
 
 install_rpm() {
-  echoh "Installing v$VERSION rpm package from GitHub releases."
+  echoh "Installing v$VERSION of the $ARCH rpm package from GitHub."
   echoh
 
   fetch "https://github.com/cdr/code-server/releases/download/v$VERSION/code-server-$VERSION-$ARCH.rpm" \
     "$CACHE_DIR/code-server-$VERSION-$ARCH.rpm"
   sudo_sh_c rpm -i "$CACHE_DIR/code-server-$VERSION-$ARCH.rpm"
 
-  echo_systemd_postinstall
+  echo_systemd_postinstall rpm
 }
 
 install_aur() {
-  echoh "Installing from the AUR."
+  echoh "Installing latest from the AUR."
   echoh
 
   sh_c mkdir -p "$CACHE_DIR/code-server-aur"
@@ -375,16 +370,20 @@ install_aur() {
   fi
   sh_c makepkg -si
 
-  echo_systemd_postinstall
+  echo_systemd_postinstall AUR
 }
 
 install_standalone() {
-  echoh "Installing standalone release archive v$VERSION from GitHub releases."
+  echoh "Installing v$VERSION of the $ARCH release from GitHub."
   echoh
 
   fetch "https://github.com/cdr/code-server/releases/download/v$VERSION/code-server-$VERSION-$OS-$ARCH.tar.gz" \
     "$CACHE_DIR/code-server-$VERSION-$OS-$ARCH.tar.gz"
 
+  # -w only works if the directory exists so try creating it first. If this
+  # fails we can ignore the error as the -w check will then swap us to sudo.
+  sh_c mkdir -p "$STANDALONE_INSTALL_PREFIX" 2> /dev/null || true
+
   sh_c="sh_c"
   if [ ! -w "$STANDALONE_INSTALL_PREFIX" ]; then
     sh_c="sudo_sh_c"
@@ -406,50 +405,74 @@ install_standalone() {
 }
 
 install_npm() {
-  if command_exists yarn; then
+  echoh "Installing latest from npm."
+  echoh
+
+  YARN_PATH="${YARN_PATH-yarn}"
+  NPM_PATH="${YARN_PATH-npm}"
+  if command_exists "$YARN_PATH"; then
     sh_c="sh_c"
-    if [ ! -w "$(yarn global bin)" ]; then
+    if [ ! "${DRY_RUN-}" ] && [ ! -w "$($YARN_PATH global bin)" ]; then
       sh_c="sudo_sh_c"
     fi
     echoh "Installing with yarn."
     echoh
-    "$sh_c" yarn global add code-server --unsafe-perm
+    "$sh_c" "$YARN_PATH" global add code-server --unsafe-perm
-    NPM_BIN_DIR="$(yarn global bin)" echo_npm_postinstall
+    NPM_BIN_DIR="\$($YARN_PATH global bin)" echo_npm_postinstall
     return
-  elif command_exists npm; then
+  elif command_exists "$NPM_PATH"; then
     sh_c="sh_c"
-    if [ ! -w "$(npm config get prefix)" ]; then
+    if [ ! "${DRY_RUN-}" ] && [ ! -w "$(NPM_PATH config get prefix)" ]; then
       sh_c="sudo_sh_c"
     fi
     echoh "Installing with npm."
     echoh
-    "$sh_c" npm install -g code-server --unsafe-perm
+    "$sh_c" "$NPM_PATH" install -g code-server --unsafe-perm
-    NPM_BIN_DIR="$(npm bin -g)" echo_npm_postinstall
+    NPM_BIN_DIR="\$($NPM_PATH bin -g)" echo_npm_postinstall
     return
   fi
-  echoh
   echoerr "Please install npm or yarn to install code-server!"
   echoerr "You will need at least node v12 and a few C dependencies."
   echoerr "See the docs https://coder.com/docs/code-server/v3.10.2/install#yarn-npm"
+
   exit 1
 }
 
-os() {
+# Run $1 if we have a standalone otherwise run install_npm.
-  case "$(uname)" in
+npm_fallback() {
-    Linux)
+  if has_standalone; then
-      echo linux
+    $1
-      ;;
+  else
-    Darwin)
+    echoh "No standalone releases for $ARCH."
-      echo macos
+    echoh "Falling back to installation from npm."
-      ;;
+    install_npm
-    FreeBSD)
+  fi
-      echo freebsd
+}
+
+# Determine if we have standalone releases on GitHub for the system's arch.
+has_standalone() {
+  case $ARCH in
+    amd64) return 0 ;;
+    # We only have amd64 for macOS.
+    arm64)
+      [ "$(distro)" != macos ]
+      return
       ;;
+    *) return 1 ;;
   esac
 }
 
-# distro prints the detected operating system including linux distros.
+os() {
-# Also parses ID_LIKE for common distro bases.
+  uname="$(uname)"
+  case $uname in
+    Linux) echo linux ;;
+    Darwin) echo macos ;;
+    FreeBSD) echo freebsd ;;
+    *) echo "$uname" ;;
+  esac
+}
+
+# Print the detected Linux distro, otherwise print the OS name.
 #
 # Example outputs:
 # - macos -> macos
@@ -486,7 +509,7 @@ distro() {
   fi
 }
 
-# os_name prints a pretty human readable name for the OS/Distro.
+# Print a human-readable name for the OS/distro.
 distro_name() {
   if [ "$(uname)" = "Darwin" ]; then
     echo "macOS v$(sw_vers -productVersion)"
@@ -506,20 +529,16 @@ distro_name() {
 }
 
 arch() {
-  case "$(uname -m)" in
+  uname_m=$(uname -m)
-    aarch64)
+  case $uname_m in
-      echo arm64
+    aarch64) echo arm64 ;;
-      ;;
+    x86_64) echo amd64 ;;
-    x86_64)
+    *) echo "$uname_m" ;;
-      echo amd64
-      ;;
-    amd64) # FreeBSD.
-      echo amd64
-      ;;
   esac
 }
 
 command_exists() {
+  if [ ! "$1" ]; then return 1; fi
   command -v "$@" > /dev/null
 }
 

package.json

@@ -20,6 +20,7 @@
     "test:e2e": "./ci/dev/test-e2e.sh",
     "test:standalone-release": "./ci/build/test-standalone-release.sh",
     "test:unit": "./ci/dev/test-unit.sh",
+    "test:scripts": "./ci/dev/test-scripts.sh",
     "package": "./ci/build/build-packages.sh",
     "postinstall": "./ci/dev/postinstall.sh",
     "update:vscode": "./ci/dev/update-vscode.sh",

test/scripts/install.bats

@@ -0,0 +1,163 @@
+#!/usr/bin/env bats
+
+SCRIPT_NAME="install.sh"
+SCRIPT="$BATS_TEST_DIRNAME/../../$SCRIPT_NAME"
+
+# Override version so it doesn't have to curl and to avoid caching in case the
+# user already has the latest version installed.
+export VERSION="9999.99.9"
+
+function should-use-deb() {
+  DISTRO=$1 ARCH=$2 OS=linux run "$SCRIPT" --dry-run
+  [ "$status" -eq 0 ]
+  [ "${lines[1]}" = "Installing v$VERSION of the $2 deb package from GitHub." ]
+  [ "${lines[-5]}" = "deb package has been installed." ]
+}
+
+function should-use-rpm() {
+  DISTRO=$1 ARCH=$2 OS=linux run "$SCRIPT" --dry-run
+  [ "$status" -eq 0 ]
+  [ "${lines[1]}" = "Installing v$VERSION of the $2 rpm package from GitHub." ]
+  [ "${lines[-5]}" = "rpm package has been installed." ]
+}
+
+function should-fallback-npm() {
+  YARN_PATH=true DISTRO=$1 ARCH=$2 OS=linux run "$SCRIPT" --dry-run
+  [ "$status" -eq 0 ]
+  [ "${lines[1]}" = "No standalone releases for $2." ]
+  [ "${lines[2]}" = "Falling back to installation from npm." ]
+  [ "${lines[3]}" = "Installing latest from npm." ]
+  [ "${lines[-5]}" = "npm package has been installed." ]
+}
+
+function should-use-npm() {
+  YARN_PATH=true DISTRO=$1 ARCH=$2 OS=linux run "$SCRIPT" --dry-run
+  [ "$status" -eq 0 ]
+  [ "${lines[1]}" = "Installing latest from npm." ]
+  [ "${lines[-5]}" = "npm package has been installed." ]
+}
+
+function should-use-aur() {
+  DISTRO=$1 ARCH=$2 OS=linux run "$SCRIPT" --dry-run
+  [ "$status" -eq 0 ]
+  [ "${lines[1]}" = "Installing latest from the AUR." ]
+  [ "${lines[-5]}" = "AUR package has been installed." ]
+}
+
+function should-fallback-npm-brew() {
+  YARN_PATH=true BREW_PATH= OS=macos ARCH=$1 run "$SCRIPT" --dry-run
+  [ "$status" -eq 0 ]
+  [ "${lines[1]}" = "Homebrew not installed." ]
+  [ "${lines[2]}" = "Falling back to standalone installation." ]
+  [ "${lines[3]}" = "No standalone releases for $1." ]
+  [ "${lines[4]}" = "Falling back to installation from npm." ]
+  [ "${lines[5]}" = "Installing latest from npm." ]
+  [ "${lines[-5]}" = "npm package has been installed." ]
+}
+
+function should-use-brew() {
+  BREW_PATH=true OS=macos ARCH=$1 run "$SCRIPT" --dry-run
+  [ "$status" -eq 0 ]
+  [ "${lines[1]}" = "Installing latest from Homebrew." ]
+  [ "${lines[-3]}" = "Brew release has been installed." ]
+}
+
+function should-use-standalone() {
+  DISTRO=$1 ARCH=$2 OS=$3 run "$SCRIPT" --method standalone --dry-run
+  [ "$status" -eq 0 ]
+  [ "${lines[1]}" = "Installing v$VERSION of the $2 release from GitHub." ]
+  [[ "${lines[-5]}" = "Standalone release has been installed"* ]]
+}
+
+@test "$SCRIPT_NAME: usage with --help" {
+  run "$SCRIPT" --help
+  [ "$status" -eq 0 ]
+  [ "${lines[0]}" = "Installs code-server." ]
+  [[ "${lines[-1]}" = "More installation docs are at"* ]]
+}
+
+# These use the deb but fall back to npm for unsupported architectures.
+@test "$SCRIPT_NAME: debian arm64" {
+  should-use-deb "debian" "arm64"
+}
+@test "$SCRIPT_NAME: debian amd64" {
+  should-use-deb "debian" "amd64"
+}
+@test "$SCRIPT_NAME: debian i386" {
+  should-fallback-npm "debian" "i386"
+}
+
+# These use the rpm but fall back to npm for unsupported architectures.
+@test "$SCRIPT_NAME: fedora arm64" {
+  should-use-rpm "fedora" "arm64"
+}
+@test "$SCRIPT_NAME: fedora amd64" {
+  should-use-rpm "fedora" "amd64"
+}
+@test "$SCRIPT_NAME: fedora i386" {
+  should-fallback-npm "fedora" "i386"
+}
+
+# These always use npm regardless of the architecture.
+@test "$SCRIPT_NAME: alpine arm64" {
+  should-use-npm "alpine" "arm64"
+}
+@test "$SCRIPT_NAME: alpine amd64" {
+  should-use-npm "alpine" "amd64"
+}
+@test "$SCRIPT_NAME: alpine i386" {
+  should-use-npm "alpine" "i386"
+}
+
+@test "$SCRIPT_NAME: freebsd arm64" {
+  should-use-npm "freebsd" "arm64"
+}
+@test "$SCRIPT_NAME: freebsd amd64" {
+  should-use-npm "freebsd" "amd64"
+}
+@test "$SCRIPT_NAME: freebsd i386" {
+  should-use-npm "freebsd" "i386"
+}
+
+# Arch Linux uses AUR but falls back to npm for unsuppported architectures.
+@test "$SCRIPT_NAME: arch arm64" {
+  should-use-aur "arch" "arm64"
+}
+@test "$SCRIPT_NAME: arch amd64" {
+  should-use-aur "arch" "amd64"
+}
+@test "$SCRIPT_NAME: arch i386" {
+  should-fallback-npm "arch" "i386"
+}
+
+# macOS use homebrew but falls back to standalone when brew is unavailable then
+# to npm for unsupported architectures.
+@test "$SCRIPT_NAME: macos arm64 (no brew)" {
+  should-fallback-npm-brew "arm64"
+}
+@test "$SCRIPT_NAME: macos amd64 (no brew)" {
+  BREW_PATH= OS=macos ARCH=amd64 run "$SCRIPT" --dry-run
+  [ "$status" -eq 0 ]
+  [ "${lines[1]}" = "Homebrew not installed." ]
+  [ "${lines[2]}" = "Falling back to standalone installation." ]
+  [ "${lines[3]}" = "Installing v$VERSION of the amd64 release from GitHub." ]
+  [[ "${lines[-5]}" = "Standalone release has been installed"* ]]
+}
+@test "$SCRIPT_NAME: macos i386 (no brew)" {
+  should-fallback-npm-brew "i386"
+}
+
+@test "$SCRIPT_NAME: macos arm64 (brew)" {
+  should-use-brew "arm64"
+}
+@test "$SCRIPT_NAME: macos amd64 (brew)" {
+  should-use-brew "amd64"
+}
+@test "$SCRIPT_NAME: macos i386 (brew)" {
+  should-use-brew "i386"
+}
+
+# Force standalone.
+@test "$SCRIPT_NAME: debian amd64 --method standalone" {
+  should-use-standalone "debian" "amd64" "linux"
+}