diff --git a/.travis.yml b/.travis.yml
index 786b363..2ad29e8 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -61,6 +61,7 @@ script:
   - bash --version
   - bash ./tests/checkstyle/checkstyle.sh
   - bash ./tests/unit-tests/unit-tests.sh
+  - shellcheck bin/junest lib/**/*.sh ci/*.sh tests/**/*.sh
 
   # ARM with qemu does seem to work properly. Disabling integ tests for ARM for now.
   #- export JUNEST_HOME=~/.junest-arm
diff --git a/bin/junest b/bin/junest
index c09f339..d3435fe 100755
--- a/bin/junest
+++ b/bin/junest
@@ -1,4 +1,5 @@
 #!/usr/bin/env bash
+# shellcheck disable=SC1091
 #
 # This file is part of JuNest (https://github.com/fsquillace/junest).
 #
@@ -7,7 +8,7 @@ set -e
 
 # JUNEST_BASE can be overridden for testing purposes.
 # There is no need for doing it for normal usage.
-JUNEST_BASE="${JUNEST_BASE:-$(readlink -f $(dirname $(readlink -f "$0"))/..)}"
+JUNEST_BASE="${JUNEST_BASE:-$(readlink -f "$(dirname "$(readlink -f "$0")")"/..)}"
 
 source "${JUNEST_BASE}/lib/utils/utils.sh"
 source "${JUNEST_BASE}/lib/core/common.sh"
@@ -24,7 +25,7 @@ source "${JUNEST_BASE}/lib/core/wrappers.sh"
 ### General functions           ###
 ###################################
 usage() {
-    echo -e "$NAME (v$(cat $JUNEST_BASE/VERSION)): $DESCRIPTION"
+    echo -e "$NAME (v$(cat "$JUNEST_BASE"/VERSION)): $DESCRIPTION"
     echo
     echo -e "Usage: $CMD [action] [options] [--] [command]"
     echo
@@ -74,7 +75,7 @@ usage() {
 }
 
 version() {
-    echo -e "$NAME $(cat $JUNEST_BASE/VERSION)"
+    echo -e "$NAME $(cat "$JUNEST_BASE"/VERSION)"
 }
 
 function parse_arguments(){
@@ -226,14 +227,13 @@ function _parse_create_wrappers_opts() {
 function _parse_setup_opts() {
     OPT_FROM_FILE=false
     IMAGE_FILE=""
-    OPT_ARCH=false
     ARCH_ARG=""
     OPT_DELETE=false
     while [[ -n "$1" ]]
     do
         case "$1" in
             -i|--from-file) OPT_FROM_FILE=true ; shift ; IMAGE_FILE=$1 ; shift ;;
-            -a|--arch) OPT_ARCH=true ; shift ; ARCH_ARG=$1; shift ;;
+            -a|--arch) shift ; ARCH_ARG=$1; shift ;;
             -d|--delete) OPT_DELETE=true ; shift ;;
             *) die "Invalid option $1" ;;
         esac
@@ -259,9 +259,9 @@ function execute_operation() {
             fi
 
             if $OPT_FROM_FILE; then
-                setup_env_from_file $IMAGE_FILE
+                setup_env_from_file "$IMAGE_FILE"
             else
-                setup_env $ARCH_ARG
+                setup_env "$ARCH_ARG"
             fi
             create_wrappers
         fi
@@ -300,7 +300,7 @@ function execute_operation() {
     fi
 
     # Call create_wrappers in case new bin files have been created
-    trap "create_wrappers" EXIT QUIT TERM KILL
+    trap "create_wrappers" EXIT QUIT TERM
     $run_env "$BACKEND_COMMAND" "${BACKEND_ARGS}" $OPT_NO_COPY_FILES "${ARGS[@]}"
 }
 
diff --git a/ci/deploy.sh b/ci/deploy.sh
index d953f04..b3ba92c 100755
--- a/ci/deploy.sh
+++ b/ci/deploy.sh
@@ -10,10 +10,10 @@ MAX_OLD_IMAGES=30
 
 # ARCH can be one of: x86, x86_64, arm
 HOST_ARCH=$(uname -m)
-if [ $HOST_ARCH == "i686" ] || [ $HOST_ARCH == "i386" ]
+if [ "$HOST_ARCH" == "i686" ] || [ "$HOST_ARCH" == "i386" ]
 then
     ARCH="x86"
-elif [ $HOST_ARCH == "x86_64" ]
+elif [ "$HOST_ARCH" == "x86_64" ]
 then
     ARCH="x86_64"
 elif [[ $HOST_ARCH =~ .*(arm).* ]]
@@ -31,14 +31,14 @@ then
     # Upload image
     # The put is done via a temporary filename in order to prevent outage on the
     # production file for a longer period of time.
-    img_name=$(basename ${IMG_PATH})
-    cp ${IMG_PATH} ${IMG_PATH}.temp
-    aws s3 cp ${IMG_PATH}.temp s3://junest-repo/junest/
-    aws s3 mv s3://junest-repo/junest/$img_name.temp s3://junest-repo/junest/$img_name
+    img_name=$(basename "${IMG_PATH}")
+    cp "${IMG_PATH}" "${IMG_PATH}".temp
+    aws s3 cp "${IMG_PATH}".temp s3://junest-repo/junest/
+    aws s3 mv s3://junest-repo/junest/"$img_name".temp s3://junest-repo/junest/"$img_name"
 
     DATE=$(date +'%Y-%m-%d-%H-%M-%S')
 
-    aws s3 cp s3://junest-repo/junest/$img_name s3://junest-repo/junest/${img_name}.${DATE}
+    aws s3 cp "s3://junest-repo/junest/$img_name" "s3://junest-repo/junest/${img_name}.${DATE}"
 
     # Cleanup old images
     aws s3 ls s3://junest-repo/junest/junest-${ARCH}.tar.gz. | awk '{print $4}' | head -n -${MAX_OLD_IMAGES} | xargs -I {} aws s3 rm "s3://junest-repo/junest/{}"
diff --git a/ci/install-bash.sh b/ci/install-bash.sh
index 575c9c5..b766123 100755
--- a/ci/install-bash.sh
+++ b/ci/install-bash.sh
@@ -4,10 +4,10 @@ set -ex
 VERSION=$1
 
 cd /tmp
-wget http://ftp.gnu.org/gnu/bash/bash-$VERSION.tar.gz
+wget "http://ftp.gnu.org/gnu/bash/bash-$VERSION.tar.gz"
 
-tar -zxf bash-$VERSION.tar.gz
-cd /tmp/bash-$VERSION*
+tar -zxf "bash-$VERSION.tar.gz"
+cd /tmp/bash-"$VERSION"*
 ./configure
 make
 sudo make install
diff --git a/lib/checks/check.sh b/lib/checks/check.sh
index 7af5832..f984d96 100755
--- a/lib/checks/check.sh
+++ b/lib/checks/check.sh
@@ -1,4 +1,5 @@
 #!/usr/bin/env bash
+# shellcheck disable=SC1091
 #
 # This modules is used for:
 #  - Running checks against the building JuNest image
@@ -34,7 +35,7 @@ JUNEST_HOME=${JUNEST_HOME:-$HOME/.junest}
 
 # JUNEST_BASE can be overridden for testing purposes.
 # There is no need for doing it for normal usage.
-JUNEST_BASE="${JUNEST_BASE:-$(readlink -f $(dirname $(readlink -f "$0"))/../..)}"
+JUNEST_BASE="${JUNEST_BASE:-$(readlink -f "$(dirname "$(readlink -f "$0")")"/../..)}"
 
 source "${JUNEST_BASE}/lib/utils/utils.sh"
 source "${JUNEST_BASE}/lib/core/common.sh"
@@ -44,27 +45,35 @@ info "Validating JuNest located in ${JUNEST_HOME}..."
 info "Initial JuNest setup..."
 # The following ensures that the gpg agent gets killed (if exists)
 # otherwise it is not possible to exit from the session
-trap "[[ -e /etc/pacman.d/gnupg/S.gpg-agent ]] && gpg-connect-agent -S /etc/pacman.d/gnupg/S.gpg-agent killagent /bye" QUIT EXIT ABRT KILL TERM INT
+trap "[[ -e /etc/pacman.d/gnupg/S.gpg-agent ]] && gpg-connect-agent -S /etc/pacman.d/gnupg/S.gpg-agent killagent /bye" QUIT EXIT ABRT TERM INT
 
 PACMAN_OPTIONS="--noconfirm --disable-download-timeout"
 
+# shellcheck disable=SC2086
 $SUDO pacman $PACMAN_OPTIONS -Syy
 
 # Awk is required for pacman-key
+# shellcheck disable=SC2086
 $SUDO pacman $PACMAN_OPTIONS -S gawk
 $SUDO pacman-key --init
 
 if [[ $(uname -m) == *"arm"* ]]
 then
+    # shellcheck disable=SC2086
     $SUDO pacman $PACMAN_OPTIONS -S archlinuxarm-keyring
     $SUDO pacman-key --populate archlinuxarm
 else
+    # shellcheck disable=SC2086
     $SUDO pacman $PACMAN_OPTIONS -S archlinux-keyring
     $SUDO pacman-key --populate archlinux
 fi
 
+# shellcheck disable=SC2086
 $SUDO pacman $PACMAN_OPTIONS -Su
+# shellcheck disable=SC2086
 $SUDO pacman $PACMAN_OPTIONS -S grep coreutils
+# shellcheck disable=SC2086
+# shellcheck disable=SC2046
 $SUDO pacman $PACMAN_OPTIONS -S $(pacman -Sg base-devel | cut -d ' ' -f 2 | grep -v sudo)
 
 info "Checking basic executables work..."
@@ -73,18 +82,22 @@ $SUDO pacman -Qi pacman 1> /dev/null
 
 repo_package1=tree
 echo "Checking ${repo_package1} package from official repo..."
+# shellcheck disable=SC2086
 $SUDO pacman $PACMAN_OPTIONS -S ${repo_package1}
 tree -L 1
+# shellcheck disable=SC2086
 $SUDO pacman $PACMAN_OPTIONS -Rsn ${repo_package1}
 
 repo_package2=iftop
 info "Checking ${repo_package2} package from official repo..."
+# shellcheck disable=SC2086
 $SUDO pacman $PACMAN_OPTIONS -S ${repo_package2}
 if $RUN_ROOT_TESTS
 then
     # Time it out given that sometimes it gets stuck after few seconds.
     $SUDO timeout 10 iftop -t -s 5 || true
 fi
+# shellcheck disable=SC2086
 $SUDO pacman $PACMAN_OPTIONS -Rsn ${repo_package2}
 
 if ! $SKIP_AUR_TESTS
@@ -92,6 +105,7 @@ then
     aur_package=tcptraceroute
     info "Checking ${aur_package} package from AUR repo..."
     yay --noconfirm -S ${aur_package}
+    # shellcheck disable=SC2086
     $SUDO pacman $PACMAN_OPTIONS -Rsn ${aur_package}
 fi
 
diff --git a/lib/checks/check_all.sh b/lib/checks/check_all.sh
index 210ebfb..394309c 100755
--- a/lib/checks/check_all.sh
+++ b/lib/checks/check_all.sh
@@ -5,7 +5,7 @@ set -ex
 
 # JUNEST_BASE can be overridden for testing purposes.
 # There is no need for doing it for normal usage.
-JUNEST_BASE="${JUNEST_BASE:-$(readlink -f $(dirname $(readlink -f "$0"))/../..)}"
+JUNEST_BASE="${JUNEST_BASE:-$(readlink -f "$(dirname "$(readlink -f "$0")")"/../..)}"
 
 JUNEST_SCRIPT=${JUNEST_SCRIPT:-${JUNEST_BASE}/bin/junest}
 
@@ -19,8 +19,8 @@ $JUNEST_SCRIPT ns --fakeroot -- "$CHECK_SCRIPT" --skip-aur-tests
 $JUNEST_SCRIPT ns -- "$CHECK_SCRIPT" --use-sudo
 # Test the backend command option
 $JUNEST_SCRIPT ns --backend-command "$JUNEST_HOME/usr/bin/bwrap" -- exit
-sudo -E $JUNEST_SCRIPT groot -- "$CHECK_SCRIPT" --run-root-tests --skip-aur-tests
+sudo -E "$JUNEST_SCRIPT" groot -- "$CHECK_SCRIPT" --run-root-tests --skip-aur-tests
 
 # Test the wrappers work
-$JUNEST_SCRIPT create-bin-wrappers --force
-$JUNEST_HOME/usr/bin_wrappers/pacman --help
+"$JUNEST_SCRIPT" create-bin-wrappers --force
+"$JUNEST_HOME"/usr/bin_wrappers/pacman --help
diff --git a/lib/core/build.sh b/lib/core/build.sh
index e17650a..48996f9 100644
--- a/lib/core/build.sh
+++ b/lib/core/build.sh
@@ -16,10 +16,10 @@ function _install_pkg(){
     # Generate a working directory because sources will be downloaded to there
     working_dir=$(TMPDIR=/tmp mktemp -d -t junest-wd.XXXXXXXXXX)
     cp -R "$pkgbuilddir"/* "$working_dir"
-    builtin cd ${working_dir}
+    builtin cd "${working_dir}" || return 1
     makepkg -sfcd
-    makepkg --printsrcinfo > ${pkgbuilddir}/.SRCINFO
-    sudo pacman --noconfirm --root ${maindir}/root -U *.pkg.tar.*
+    makepkg --printsrcinfo > "${pkgbuilddir}"/.SRCINFO
+    sudo pacman --noconfirm --root "${maindir}"/root -U ./*.pkg.tar.*
 }
 
 function _prepare() {
@@ -42,29 +42,31 @@ function build_image_env(){
 
     local disable_validation=$1
 
-    local maindir=$(TMPDIR=$JUNEST_TEMPDIR mktemp -d -t ${CMD}.XXXXXXXXXX)
-    sudo mkdir -p ${maindir}/root
-    trap - QUIT EXIT ABRT KILL TERM INT
-    trap "sudo rm -rf ${maindir}; die \"Error occurred when installing ${NAME}\"" EXIT QUIT ABRT KILL TERM INT
+    local maindir
+    maindir=$(TMPDIR=$JUNEST_TEMPDIR mktemp -d -t "${CMD}".XXXXXXXXXX)
+    sudo mkdir -p "${maindir}"/root
+    trap - QUIT EXIT ABRT TERM INT
+    # shellcheck disable=SC2064
+    trap "sudo rm -rf ${maindir}; die \"Error occurred when installing ${NAME}\"" EXIT QUIT ABRT TERM INT
     info "Installing pacman and its dependencies..."
     # All the essential executables (ln, mkdir, chown, etc) are in coreutils
     # bwrap command belongs to bubblewrap
-    sudo pacstrap -G -M -d ${maindir}/root pacman coreutils bubblewrap
+    sudo pacstrap -G -M -d "${maindir}"/root pacman coreutils bubblewrap
 
     if [[ ${ARCH} != "arm" ]]
     then
         # x86_64 does not have any mirror set by default...
         sudo bash -c "echo 'Server = $DEFAULT_MIRROR' >> ${maindir}/root/etc/pacman.d/mirrorlist"
     fi
-    sudo mkdir -p ${maindir}/root/run/lock
+    sudo mkdir -p "${maindir}"/root/run/lock
 
-    sudo tee -a ${maindir}/root/etc/pacman.conf > /dev/null <<EOT
+    sudo tee -a "${maindir}"/root/etc/pacman.conf > /dev/null <<EOT
 
 [junest]
 SigLevel = Optional TrustedOnly
 Server = https://raw.githubusercontent.com/fsquillace/junest-repo/master/any
 EOT
-    sudo pacman --noconfirm --config ${maindir}/root/etc/pacman.conf --root ${maindir}/root -Sy sudo-fake groot-git proot-static qemu-user-static-bin-alt yay
+    sudo pacman --noconfirm --config "${maindir}"/root/etc/pacman.conf --root "${maindir}"/root -Sy sudo-fake groot-git proot-static qemu-user-static-bin-alt yay
 
     echo "Generating the metadata info"
     sudo install -d -m 755 "${maindir}/root/etc/${CMD}"
@@ -74,18 +76,18 @@ EOT
     # sed command is required for locale-gen but it is required by fakeroot
     # and cannot be removed
     # localedef (called by locale-gen) requires gzip
-    sudo pacman --noconfirm --root ${maindir}/root -S sed gzip
-    sudo ln -sf /usr/share/zoneinfo/posix/UTC ${maindir}/root/etc/localtime
+    sudo pacman --noconfirm --root "${maindir}"/root -S sed gzip
+    sudo ln -sf /usr/share/zoneinfo/posix/UTC "${maindir}"/root/etc/localtime
     sudo bash -c "echo 'en_US.UTF-8 UTF-8' >> ${maindir}/root/etc/locale.gen"
-    sudo ${maindir}/root/bin/groot ${maindir}/root locale-gen
+    sudo "${maindir}"/root/bin/groot "${maindir}"/root locale-gen
     sudo bash -c "echo LANG=\"en_US.UTF-8\" >> ${maindir}/root/etc/locale.conf"
-    sudo pacman --noconfirm --root ${maindir}/root -Rsn gzip
+    sudo pacman --noconfirm --root "${maindir}"/root -Rsn gzip
 
     info "Setting up the pacman keyring (this might take a while!)..."
     # gawk command is required for pacman-key
-    sudo pacman --noconfirm --root ${maindir}/root -S gawk
+    sudo pacman --noconfirm --root "${maindir}"/root -S gawk
     # TODO check why the following did not fail!
-    sudo ${maindir}/root/bin/groot --no-umount --avoid-bind -b /dev ${maindir}/root bash -c '
+    sudo "${maindir}"/root/bin/groot --no-umount --avoid-bind -b /dev "${maindir}"/root bash -c '
     set -e
     pacman-key --init;
     for keyring_file in /usr/share/pacman/keyrings/*.gpg;
@@ -94,31 +96,31 @@ EOT
         pacman-key --populate $keyring;
     done;
     [ -e /etc/pacman.d/gnupg/S.gpg-agent ] && gpg-connect-agent -S /etc/pacman.d/gnupg/S.gpg-agent killagent /bye'
-    sudo umount --force --recursive --lazy ${maindir}/root/dev
-    sudo umount --force --recursive ${maindir}/root
-    sudo pacman --noconfirm --root ${maindir}/root -Rsn gawk
+    sudo umount --force --recursive --lazy "${maindir}"/root/dev
+    sudo umount --force --recursive "${maindir}"/root
+    sudo pacman --noconfirm --root "${maindir}"/root -Rsn gawk
 
-    sudo rm ${maindir}/root/var/cache/pacman/pkg/*
+    sudo rm "${maindir}"/root/var/cache/pacman/pkg/*
     # This is needed on system with busybox tar command.
     # If the file does not have write permission, the tar command to extract files fails.
-    sudo chmod -R u+rw ${maindir}/root/
+    sudo chmod -R u+rw "${maindir}"/root/
 
-    mkdir -p ${maindir}/output
-    builtin cd ${maindir}/output
+    mkdir -p "${maindir}"/output
+    builtin cd "${maindir}"/output || return 1
     local imagefile="${CMD}-${ARCH}.tar.gz"
     info "Compressing image to ${imagefile}..."
-    sudo $TAR -zcpf ${imagefile} -C ${maindir}/root .
+    sudo "$TAR" -zcpf "${imagefile}" -C "${maindir}"/root .
 
     if ! $disable_validation
     then
-        mkdir -p ${maindir}/root_test
-        $TAR -zxpf ${imagefile} -C "${maindir}/root_test"
-        JUNEST_HOME="${maindir}/root_test" ${JUNEST_BASE}/lib/checks/check_all.sh
+        mkdir -p "${maindir}"/root_test
+        $TAR -zxpf "${imagefile}" -C "${maindir}/root_test"
+        JUNEST_HOME="${maindir}/root_test" "${JUNEST_BASE}"/lib/checks/check_all.sh
     fi
 
-    sudo cp ${maindir}/output/${imagefile} ${ORIGIN_WD}
+    sudo cp "${maindir}"/output/"${imagefile}" "${ORIGIN_WD}"
 
-    builtin cd ${ORIGIN_WD}
+    builtin cd "${ORIGIN_WD}" || return 1
     trap - QUIT EXIT ABRT KILL TERM INT
     sudo rm -fr "$maindir"
 
diff --git a/lib/core/chroot.sh b/lib/core/chroot.sh
index afabc71..c2237a9 100644
--- a/lib/core/chroot.sh
+++ b/lib/core/chroot.sh
@@ -18,20 +18,22 @@ function _run_env_as_xroot(){
 
     local uid=$UID
     # SUDO_USER is more reliable compared to SUDO_UID
-    [ -z $SUDO_USER ] || uid=$SUDO_USER:$SUDO_GID
+    [[ -z $SUDO_USER ]] || uid=$SUDO_USER:$SUDO_GID
 
     local args=()
     [[ "$1" != "" ]] && args=("-c" "$(insert_quotes_on_spaces "${@}")")
 
     # With chown the ownership of the files is assigned to the real user
     trap - QUIT EXIT ABRT KILL TERM INT
-    trap "[ -z $uid ] || chown_cmd -R ${uid} ${JUNEST_HOME};" EXIT QUIT ABRT KILL TERM INT
+    # shellcheck disable=SC2064
+    trap "[ -z $uid ] || chown_cmd -R ${uid} ${JUNEST_HOME};" EXIT QUIT ABRT TERM INT
 
     if ! $no_copy_files
     then
         copy_common_files
     fi
 
+    # shellcheck disable=SC2086
     JUNEST_ENV=1 $cmd $backend_args "$JUNEST_HOME" "${DEFAULT_SH[@]}" "${args[@]}"
 }
 
diff --git a/lib/core/common.sh b/lib/core/common.sh
index 7d23d07..a75aff9 100644
--- a/lib/core/common.sh
+++ b/lib/core/common.sh
@@ -1,4 +1,6 @@
 #!/usr/bin/env bash
+# shellcheck disable=SC2034
+# shellcheck disable=SC1091
 #
 # This module contains all common functionalities for JuNest.
 #
@@ -29,7 +31,7 @@ PATH=/usr/bin:/bin:/usr/local/bin:/usr/sbin:/sbin:${HOME}/.local/bin
 
 # The executable uname is essential in order to get the architecture
 # of the host system, so a fallback mechanism cannot be used for it.
-UNAME=uname
+UNAME="uname"
 
 ARCH_LIST=('x86_64' 'x86' 'arm')
 HOST_ARCH=$($UNAME -m)
@@ -53,6 +55,7 @@ fi
 
 MAIN_REPO=https://dwa8bhj1f036z.cloudfront.net
 ENV_REPO=${MAIN_REPO}/${CMD}
+# shellcheck disable=SC2016
 DEFAULT_MIRROR='https://mirror.rackspace.com/archlinux/$repo/os/$arch'
 
 ORIGIN_WD=$(pwd)
@@ -73,16 +76,16 @@ GROOT="${JUNEST_HOME}/usr/bin/groot"
 CLASSIC_CHROOT=chroot
 WGET="wget --no-check-certificate"
 CURL="curl -L -J -O -k"
-TAR=tar
+TAR="tar"
 CHOWN="chown"
-LN=ln
-RM=rm
-MKDIR=mkdir
-GETENT=getent
-CP=cp
+LN="ln"
+RM="rm"
+MKDIR="mkdir"
+GETENT="getent"
+CP="cp"
 # Used for checking user namespace in config.gz file
-ZGREP=zgrep
-UNSHARE=unshare
+ZGREP="zgrep"
+UNSHARE="unshare"
 
 LD_EXEC="$LD_LIB --library-path ${JUNEST_HOME}/usr/lib:${JUNEST_HOME}/lib"
 
@@ -91,32 +94,32 @@ LD_EXEC="$LD_LIB --library-path ${JUNEST_HOME}/usr/lib:${JUNEST_HOME}/lib"
 # image.
 
 function ln_cmd(){
-    $LN "$@" || $LD_EXEC ${JUNEST_HOME}/usr/bin/$LN "$@"
+    $LN "$@" || $LD_EXEC "${JUNEST_HOME}"/usr/bin/$LN "$@"
 }
 
 function getent_cmd(){
-    $GETENT "$@" || $LD_EXEC ${JUNEST_HOME}/usr/bin/$GETENT "$@"
+    $GETENT "$@" || $LD_EXEC "${JUNEST_HOME}"/usr/bin/$GETENT "$@"
 }
 
 function cp_cmd(){
-    $CP "$@" || $LD_EXEC ${JUNEST_HOME}/usr/bin/$CP "$@"
+    $CP "$@" || $LD_EXEC "${JUNEST_HOME}"/usr/bin/$CP "$@"
 }
 
 function rm_cmd(){
-    $RM "$@" || $LD_EXEC ${JUNEST_HOME}/usr/bin/$RM "$@"
+    $RM "$@" || $LD_EXEC "${JUNEST_HOME}"/usr/bin/$RM "$@"
 }
 
 function chown_cmd(){
-    $CHOWN "$@" || $LD_EXEC ${JUNEST_HOME}/usr/bin/$CHOWN "$@"
+    $CHOWN "$@" || $LD_EXEC "${JUNEST_HOME}"/usr/bin/$CHOWN "$@"
 }
 
 function mkdir_cmd(){
-    $MKDIR "$@" || $LD_EXEC ${JUNEST_HOME}/usr/bin/$MKDIR "$@"
+    $MKDIR "$@" || $LD_EXEC "${JUNEST_HOME}"/usr/bin/$MKDIR "$@"
 }
 
 function zgrep_cmd(){
     # No need for LD_EXEC as zgrep is a POSIX shell script
-    $ZGREP "$@" || ${JUNEST_HOME}/usr/bin/$ZGREP "$@"
+    $ZGREP "$@" || "${JUNEST_HOME}"/usr/bin/$ZGREP "$@"
 }
 
 function download_cmd(){
@@ -124,7 +127,7 @@ function download_cmd(){
 }
 
 function chroot_cmd(){
-    $CLASSIC_CHROOT "$@" || $LD_EXEC ${JUNEST_HOME}/usr/bin/$CLASSIC_CHROOT "$@"
+    $CLASSIC_CHROOT "$@" || $LD_EXEC "${JUNEST_HOME}"/usr/bin/$CLASSIC_CHROOT "$@"
 }
 
 function unshare_cmd(){
@@ -134,9 +137,9 @@ function unshare_cmd(){
     # Also, unshare provides an environment in which /bin/sh maps to dash shell,
     # therefore it ignores all the remaining DEFAULT_SH arguments (i.e. --login) as
     # they are not supported by dash.
-    if $LD_EXEC ${JUNEST_HOME}/usr/bin/$UNSHARE --user "${DEFAULT_SH[0]}" "-c" ":"
+    if $LD_EXEC "${JUNEST_HOME}"/usr/bin/$UNSHARE --user "${DEFAULT_SH[0]}" "-c" ":"
     then
-        $LD_EXEC ${JUNEST_HOME}/usr/bin/$UNSHARE "${@}"
+        $LD_EXEC "${JUNEST_HOME}"/usr/bin/$UNSHARE "${@}"
     elif $UNSHARE --user "${DEFAULT_SH[0]}" "-c" ":"
     then
         $UNSHARE "$@"
@@ -146,9 +149,9 @@ function unshare_cmd(){
 }
 
 function bwrap_cmd(){
-    if $LD_EXEC $BWRAP --dev-bind / / "${DEFAULT_SH[0]}" "-c" ":"
+    if $LD_EXEC "$BWRAP" --dev-bind / / "${DEFAULT_SH[0]}" "-c" ":"
     then
-        $LD_EXEC $BWRAP "${@}"
+        $LD_EXEC "$BWRAP" "${@}"
     else
         die "Error: Something went wrong while executing bwrap command. Exiting"
     fi
@@ -157,8 +160,10 @@ function bwrap_cmd(){
 function proot_cmd(){
     local proot_args="$1"
     shift
+    # shellcheck disable=SC2086
     if ${PROOT} ${proot_args} "${DEFAULT_SH[@]}" "-c" ":"
     then
+        # shellcheck disable=SC2086
         ${PROOT} ${proot_args} "${@}"
     elif PROOT_NO_SECCOMP=1 ${PROOT} ${proot_args} "${DEFAULT_SH[@]}" "-c" ":"
     then
@@ -192,7 +197,7 @@ function check_nested_env() {
     if [[ $JUNEST_ENV == "1" ]]
     then
         die_on_status $NESTED_ENVIRONMENT "Error: Nested ${NAME} environments are not allowed"
-    elif [[ ! -z $JUNEST_ENV ]] && [[ $JUNEST_ENV != "0" ]]
+    elif [[ -n $JUNEST_ENV ]] && [[ $JUNEST_ENV != "0" ]]
     then
         die_on_status $VARIABLE_NOT_SET "The variable JUNEST_ENV is not properly set"
     fi
@@ -214,7 +219,7 @@ function check_nested_env() {
 #   None
 #######################################
 function check_same_arch() {
-    source ${JUNEST_HOME}/etc/junest/info
+    source "${JUNEST_HOME}"/etc/junest/info
     [ "$JUNEST_ARCH" != "$ARCH" ] && \
         die_on_status $ARCHITECTURE_MISMATCH "The host system architecture is not correct: $ARCH != $JUNEST_ARCH"
     return 0
@@ -272,14 +277,14 @@ function copy_passwd_and_group(){
     # is configured.
     # Try to at least get the current user via `getent passwd $USER` since it uses
     # a more reliable and faster system call (getpwnam(3)).
-    if ! getent_cmd passwd > ${JUNEST_HOME}/etc/passwd || \
-        ! getent_cmd passwd ${USER} >> ${JUNEST_HOME}/etc/passwd
+    if ! getent_cmd passwd > "${JUNEST_HOME}"/etc/passwd || \
+        ! getent_cmd passwd "${USER}" >> "${JUNEST_HOME}"/etc/passwd
     then
         warn "getent command failed or does not exist. Binding directly from /etc/passwd."
         copy_file /etc/passwd
     fi
 
-    if ! getent_cmd group > ${JUNEST_HOME}/etc/group
+    if ! getent_cmd group > "${JUNEST_HOME}"/etc/group
     then
         warn "getent command failed or does not exist. Binding directly from /etc/group."
         copy_file /etc/group
diff --git a/lib/core/namespace.sh b/lib/core/namespace.sh
index 0567989..2754dab 100644
--- a/lib/core/namespace.sh
+++ b/lib/core/namespace.sh
@@ -10,6 +10,7 @@
 #
 # vim: ft=sh
 
+# shellcheck disable=SC2027
 COMMON_BWRAP_OPTION="--bind "$JUNEST_HOME" / --bind "$HOME" "$HOME" --bind /tmp /tmp --bind /sys /sys --bind /proc /proc --dev-bind-try /dev /dev --unshare-user-try"
 CONFIG_PROC_FILE="/proc/config.gz"
 CONFIG_BOOT_FILE="/boot/config-$($UNAME -r)"
@@ -24,14 +25,14 @@ function _is_user_namespace_enabled() {
     then
         config_file=$CONFIG_BOOT_FILE
     else
-        return $NOT_EXISTING_FILE
+        return "$NOT_EXISTING_FILE"
     fi
 
     # `-q` option in zgrep may cause a gzip: stdout: Broken pipe
     # Use redirect to /dev/null instead
-    if ! zgrep_cmd "CONFIG_USER_NS=y" $config_file > /dev/null
+    if ! zgrep_cmd "CONFIG_USER_NS=y" "$config_file" > /dev/null
     then
-        return $NO_CONFIG_FOUND
+        return "$NO_CONFIG_FOUND"
     fi
 
     if [[ ! -e $PROC_USERNS_CLONE_FILE ]]
@@ -43,7 +44,7 @@ function _is_user_namespace_enabled() {
     # Use redirect to /dev/null instead
     if ! zgrep_cmd "1" $PROC_USERNS_CLONE_FILE > /dev/null
     then
-        return $UNPRIVILEGED_USERNS_DISABLED
+        return "$UNPRIVILEGED_USERNS_DISABLED"
     fi
 
     return 0
@@ -53,9 +54,9 @@ function _check_user_namespace() {
     set +e
     _is_user_namespace_enabled
     case $? in
-        $NOT_EXISTING_FILE) warn "Could not understand if user namespace is enabled. No config.gz file found. Proceeding anyway..." ;;
-        $NO_CONFIG_FOUND) warn "Unprivileged user namespace is disabled at kernel compile time or kernel too old (<3.8). Proceeding anyway..." ;;
-        $UNPRIVILEGED_USERNS_DISABLED) warn "Unprivileged user namespace disabled. Root permissions are required to enable it: sudo sysctl kernel.unprivileged_userns_clone=1" ;;
+        "$NOT_EXISTING_FILE") warn "Could not understand if user namespace is enabled. No config.gz file found. Proceeding anyway..." ;;
+        "$NO_CONFIG_FOUND") warn "Unprivileged user namespace is disabled at kernel compile time or kernel too old (<3.8). Proceeding anyway..." ;;
+        "$UNPRIVILEGED_USERNS_DISABLED") warn "Unprivileged user namespace disabled. Root permissions are required to enable it: sudo sysctl kernel.unprivileged_userns_clone=1" ;;
     esac
     set -e
 }
@@ -100,6 +101,7 @@ function run_env_as_bwrap_fakeroot(){
     local args=()
     [[ "$1" != "" ]] && args=("-c" "$(insert_quotes_on_spaces "${@}")")
 
+    # shellcheck disable=SC2086
     BWRAP="${backend_command}" JUNEST_ENV=1 bwrap_cmd $COMMON_BWRAP_OPTION --cap-add ALL --uid 0 --gid 0 $backend_args sudo "${DEFAULT_SH[@]}" "${args[@]}"
 }
 
@@ -148,6 +150,7 @@ function run_env_as_bwrap_user() {
     local args=()
     [[ "$1" != "" ]] && args=("-c" "$(insert_quotes_on_spaces "${@}")")
 
+    # shellcheck disable=SC2086
     BWRAP="${backend_command}" JUNEST_ENV=1 bwrap_cmd $COMMON_BWRAP_OPTION $backend_args "${DEFAULT_SH[@]}" "${args[@]}"
 }
 
diff --git a/lib/core/proot.sh b/lib/core/proot.sh
index f074b47..259c8b7 100644
--- a/lib/core/proot.sh
+++ b/lib/core/proot.sh
@@ -1,4 +1,5 @@
 #!/usr/bin/env bash
+# shellcheck disable=SC1091
 #
 # This module contains all proot functionalities for JuNest.
 #
@@ -24,18 +25,19 @@ function _run_env_with_qemu(){
     local backend_args="$2"
     shift 2
 
-    source ${JUNEST_HOME}/etc/junest/info
+    source "${JUNEST_HOME}"/etc/junest/info
 
     if [ "$JUNEST_ARCH" != "$ARCH" ]
     then
         local qemu_bin="qemu-$JUNEST_ARCH-static-$ARCH"
         local qemu_symlink="/tmp/${qemu_bin}-$RANDOM"
         trap - QUIT EXIT ABRT KILL TERM INT
-        trap "[ -e ${qemu_symlink} ] && rm_cmd -f ${qemu_symlink}" EXIT QUIT ABRT KILL TERM INT
+        # shellcheck disable=SC2064
+        trap "[ -e ${qemu_symlink} ] && rm_cmd -f ${qemu_symlink}" EXIT QUIT ABRT TERM INT
 
         warn "Emulating $NAME via QEMU..."
-        [ -e ${qemu_symlink} ] || \
-            ln_cmd -s ${JUNEST_HOME}/bin/${qemu_bin} ${qemu_symlink}
+        [[ -e ${qemu_symlink} ]] || \
+            ln_cmd -s "${JUNEST_HOME}/bin/${qemu_bin}" "${qemu_symlink}"
         backend_args="-q ${qemu_symlink} $backend_args"
     fi
 
@@ -62,7 +64,7 @@ function _run_env_with_qemu(){
 #######################################
 function run_env_as_proot_fakeroot(){
     (( EUID == 0 )) && \
-        die_on_status $ROOT_ACCESS_ERROR "You cannot access with root privileges. Use --groot option instead."
+        die_on_status "$ROOT_ACCESS_ERROR" "You cannot access with root privileges. Use --groot option instead."
     check_nested_env
 
     local backend_command="$1"
@@ -104,7 +106,7 @@ function run_env_as_proot_fakeroot(){
 #######################################
 function run_env_as_proot_user(){
     (( EUID == 0 )) && \
-        die_on_status $ROOT_ACCESS_ERROR "You cannot access with root privileges. Use --groot option instead."
+        die_on_status "$ROOT_ACCESS_ERROR" "You cannot access with root privileges. Use --groot option instead."
     check_nested_env
 
     local backend_command="$1"
diff --git a/lib/core/setup.sh b/lib/core/setup.sh
index 28b04d3..749fd66 100644
--- a/lib/core/setup.sh
+++ b/lib/core/setup.sh
@@ -22,7 +22,7 @@
 #   None
 #######################################
 function is_env_installed(){
-    [ -d "$JUNEST_HOME" ] && [ "$(ls -A $JUNEST_HOME)" ] && return 0
+    [[ -d "$JUNEST_HOME" ]] && [[ "$(ls -A "$JUNEST_HOME")" ]] && return 0
     return 1
 }
 
@@ -30,7 +30,7 @@ function is_env_installed(){
 function _cleanup_build_directory(){
     local maindir=$1
     check_not_null "$maindir"
-    builtin cd $ORIGIN_WD
+    builtin cd "$ORIGIN_WD" || return 1
     trap - QUIT EXIT ABRT KILL TERM INT
     rm_cmd -fr "$maindir"
 }
@@ -40,7 +40,8 @@ function _prepare_build_directory(){
     local maindir=$1
     check_not_null "$maindir"
     trap - QUIT EXIT ABRT KILL TERM INT
-    trap "rm_cmd -rf ${maindir}; die \"Error occurred when installing ${NAME}\"" EXIT QUIT ABRT KILL TERM INT
+    # shellcheck disable=SC2064
+    trap "rm_cmd -rf ${maindir}; die \"Error occurred when installing ${NAME}\"" EXIT QUIT ABRT TERM INT
 }
 
 
@@ -51,7 +52,7 @@ function _setup_env(){
     is_env_installed && die "Error: ${NAME} has been already installed in $JUNEST_HOME"
 
     mkdir_cmd -p "${JUNEST_HOME}"
-    $TAR -zxpf ${imagepath} -C ${JUNEST_HOME}
+    $TAR -zxpf "${imagepath}" -C "${JUNEST_HOME}"
     info "${NAME} installed successfully!"
     echo
     info "Default mirror URL set to: ${DEFAULT_MIRROR}"
@@ -84,21 +85,22 @@ function _setup_env(){
 #######################################
 function setup_env(){
     local arch=${1:-$ARCH}
-    contains_element $arch "${ARCH_LIST[@]}" || \
-        die_on_status $NOT_AVAILABLE_ARCH "The architecture is not one of: ${ARCH_LIST[@]}"
+    contains_element "$arch" "${ARCH_LIST[@]}" || \
+        die_on_status "$NOT_AVAILABLE_ARCH" "The architecture is not one of: ${ARCH_LIST[*]}"
 
-    local maindir=$(TMPDIR=$JUNEST_TEMPDIR mktemp -d -t ${CMD}.XXXXXXXXXX)
-    _prepare_build_directory $maindir
+    local maindir
+    maindir=$(TMPDIR=$JUNEST_TEMPDIR mktemp -d -t "${CMD}".XXXXXXXXXX)
+    _prepare_build_directory "$maindir"
 
     info "Downloading ${NAME}..."
-    builtin cd ${maindir}
+    builtin cd "${maindir}" || return 1
     local imagefile=${CMD}-${arch}.tar.gz
-    download_cmd ${ENV_REPO}/${imagefile}
+    download_cmd "${ENV_REPO}/${imagefile}"
 
     info "Installing ${NAME}..."
-    _setup_env ${maindir}/${imagefile}
+    _setup_env "${maindir}/${imagefile}"
 
-    _cleanup_build_directory ${maindir}
+    _cleanup_build_directory "${maindir}"
 }
 
 #######################################
@@ -118,10 +120,10 @@ function setup_env(){
 function setup_env_from_file(){
     local imagefile=$1
     check_not_null "$imagefile"
-    [ ! -e ${imagefile} ] && die_on_status $NOT_EXISTING_FILE "Error: The ${NAME} image file ${imagefile} does not exist"
+    [[ ! -e ${imagefile} ]] && die_on_status "$NOT_EXISTING_FILE" "Error: The ${NAME} image file ${imagefile} does not exist"
 
     info "Installing ${NAME} from ${imagefile}..."
-    _setup_env ${imagefile}
+    _setup_env "${imagefile}"
 }
 
 #######################################
@@ -138,18 +140,18 @@ function setup_env_from_file(){
 #######################################
 function delete_env(){
     ! ask "Are you sure to delete ${NAME} located in ${JUNEST_HOME}" "N" && return
-    if mountpoint -q ${JUNEST_HOME}
+    if mountpoint -q "${JUNEST_HOME}"
     then
         info "There are mounted directories inside ${JUNEST_HOME}"
-        if ! umount --force ${JUNEST_HOME}
+        if ! umount --force "${JUNEST_HOME}"
         then
             error "Cannot umount directories in ${JUNEST_HOME}"
             die "Try to delete ${NAME} using root permissions"
         fi
     fi
     # the CA directories are read only and can be deleted only by changing the mod
-    chmod -R +w ${JUNEST_HOME}/etc/ca-certificates
-    if rm_cmd -rf ${JUNEST_HOME}
+    chmod -R +w "${JUNEST_HOME}"/etc/ca-certificates
+    if rm_cmd -rf "${JUNEST_HOME}"
     then
         info "${NAME} deleted in ${JUNEST_HOME}"
     else
diff --git a/lib/utils/utils.sh b/lib/utils/utils.sh
index 00e2cb6..5659568 100644
--- a/lib/utils/utils.sh
+++ b/lib/utils/utils.sh
@@ -50,7 +50,7 @@ function echoerr() {
 #   Message printed to stderr.
 #######################################
 function die() {
-    error $@
+    error "$@"
     exit 1
 }
 
@@ -70,8 +70,8 @@ function die() {
 function die_on_status() {
     status=$1
     shift
-    error $@
-    exit $status
+    error "$@"
+    exit "$status"
 }
 
 #######################################
@@ -87,7 +87,7 @@ function die_on_status() {
 #   Message printed to stderr.
 #######################################
 function error() {
-    echoerr -e "\033[1;31m$@\033[0m"
+    echoerr -e "\033[1;31m$*\033[0m"
 }
 
 #######################################
@@ -104,7 +104,7 @@ function error() {
 #######################################
 function warn() {
     # $@: msg (mandatory) - str: Message to print
-    echoerr -e "\033[1;33m$@\033[0m"
+    echoerr -e "\033[1;33m$*\033[0m"
 }
 
 #######################################
@@ -120,7 +120,7 @@ function warn() {
 #   Message printed to stdout.
 #######################################
 function info(){
-    echo -e "\033[1;36m$@\033[0m"
+    echo -e "\033[1;36m$*\033[0m"
 }
 
 #######################################
@@ -142,12 +142,12 @@ function info(){
 function ask(){
     local question=$1
     local default_answer=$2
-    check_not_null $question
+    check_not_null "$question"
 
-    if [ ! -z "$default_answer" ]
+    if [ -n "$default_answer" ]
     then
         local answers="Y y N n"
-        [[ "$answers" =~ "$default_answer" ]] || { error "The default answer: $default_answer is wrong."; return $WRONG_ANSWER; }
+        [[ "$answers" =~ $default_answer ]] || { error "The default answer: $default_answer is wrong."; return $WRONG_ANSWER; }
     fi
 
     local default="Y"
@@ -156,12 +156,13 @@ function ask(){
     local other="n"
     [ "$default" == "N" ] && other="y"
 
-    local prompt=$(info "$question (${default}/${other})> ")
+    local prompt
+    prompt=$(info "$question (${default}/${other})> ")
 
     local res="none"
     while [ "$res" != "Y" ] && [ "$res" != "N"  ] && [ "$res" != "" ];
     do
-        read -p "$prompt" res
+        read -r -p "$prompt" res
         res=$(echo "$res" | tr '[:lower:]' '[:upper:]')
     done
 
@@ -170,36 +171,31 @@ function ask(){
     [ "$res" == "Y" ]
 }
 
-function check_and_trap() {
-    local sigs="${@:2:${#@}}"
-    local traps="$(trap -p $sigs)"
-    [[ $traps ]] && die "Attempting to overwrite existing $sigs trap: $traps"
-    trap $@
-}
-
-function check_and_force_trap() {
-    local sigs="${@:2:${#@}}"
-    local traps="$(trap -p $sigs)"
-    [[ $traps ]] && warn "Attempting to overwrite existing $sigs trap: $traps"
-    trap $@
-}
-
 function insert_quotes_on_spaces(){
 # It inserts quotes between arguments.
 # Useful to preserve quotes on command
 # to be used inside sh -c/bash -c
-    C=''
+    local C=""
     whitespace="[[:space:]]"
     for i in "$@"
     do
         if [[ $i =~ $whitespace ]]
         then
-            C="$C \"$i\""
+            temp_C="\"$i\""
         else
-            C="$C $i"
+            temp_C="$i"
         fi
+
+        # Handle edge case when C is empty to avoid adding an extra space
+        if [[ -z $C ]]
+        then
+            C="$temp_C"
+        else
+            C="$C $temp_C"
+        fi
+
     done
-    echo $C
+    echo "$C"
 }
 
 contains_element () {
diff --git a/tests/checkstyle/checkstyle.sh b/tests/checkstyle/checkstyle.sh
index 27cb82a..4f71965 100755
--- a/tests/checkstyle/checkstyle.sh
+++ b/tests/checkstyle/checkstyle.sh
@@ -1,6 +1,7 @@
 #!/usr/bin/env bash
+# shellcheck disable=SC1091
 
-source "$(dirname $0)/../utils/utils.sh"
+source "$(dirname "$0")/../utils/utils.sh"
 
 # Disable the exiterr
 set +e
@@ -10,12 +11,12 @@ function oneTimeSetUp(){
 }
 
 function test_check_no_tabs(){
-    assertCommandFailOnStatus 1 grep -R "$(printf '\t')" $(dirname $0)/../../bin/*
-    assertEquals "" "$(cat $STDOUTF)"
-    assertEquals "" "$(cat $STDERRF)"
-    assertCommandFailOnStatus 1 grep -R "$(printf '\t')" $(dirname $0)/../../lib/*
-    assertEquals "" "$(cat $STDOUTF)"
-    assertEquals "" "$(cat $STDERRF)"
+    assertCommandFailOnStatus 1 grep -R "$(printf '\t')" "$(dirname "$0")"/../../bin/*
+    assertEquals "" "$(cat "$STDOUTF")"
+    assertEquals "" "$(cat "$STDERRF")"
+    assertCommandFailOnStatus 1 grep -R "$(printf '\t')" "$(dirname "$0")"/../../lib/*
+    assertEquals "" "$(cat "$STDOUTF")"
+    assertEquals "" "$(cat "$STDERRF")"
 }
 
-source $(dirname $0)/../utils/shunit2
+source "$(dirname "$0")"/../utils/shunit2
diff --git a/tests/unit-tests/test-chroot.sh b/tests/unit-tests/test-chroot.sh
index 44999f7..f634b5b 100755
--- a/tests/unit-tests/test-chroot.sh
+++ b/tests/unit-tests/test-chroot.sh
@@ -1,6 +1,7 @@
 #!/bin/bash
+# shellcheck disable=SC1091
 
-JUNEST_ROOT=$(readlink -f $(dirname $0)/../..)
+JUNEST_ROOT=$(readlink -f "$(dirname "$0")"/../..)
 
 source "$JUNEST_ROOT/tests/utils/utils.sh"
 
@@ -29,32 +30,33 @@ function tearDown(){
 function init_mocks() {
     chroot_cmd() {
         [ "$JUNEST_ENV" != "1" ] && return 1
-        echo "chroot_cmd $@"
+        echo "chroot_cmd $*"
     }
+    # shellcheck disable=SC2034
     GROOT=chroot_cmd
     mychroot() {
-        echo mychroot $@
+        echo mychroot "$*"
     }
 }
 
 function test_run_env_as_groot_cmd(){
     assertCommandSuccess run_env_as_groot "" "" "false" pwd
-    assertEquals "chroot_cmd -b $HOME -b /tmp -b /proc -b /sys -b /dev $JUNEST_HOME /bin/sh --login -c pwd" "$(cat $STDOUTF)"
+    assertEquals "chroot_cmd -b $HOME -b /tmp -b /proc -b /sys -b /dev $JUNEST_HOME /bin/sh --login -c pwd" "$(cat "$STDOUTF")"
 }
 
 function test_run_env_as_groot_no_cmd(){
     assertCommandSuccess run_env_as_groot "" "" "false" ""
-    assertEquals "chroot_cmd -b $HOME -b /tmp -b /proc -b /sys -b /dev $JUNEST_HOME /bin/sh --login" "$(cat $STDOUTF)"
+    assertEquals "chroot_cmd -b $HOME -b /tmp -b /proc -b /sys -b /dev $JUNEST_HOME /bin/sh --login" "$(cat "$STDOUTF")"
 }
 
 function test_run_env_as_groot_with_backend_command(){
     assertCommandSuccess run_env_as_groot "mychroot" "" "false" ""
-    assertEquals "mychroot -b $HOME -b /tmp -b /proc -b /sys -b /dev $JUNEST_HOME /bin/sh --login" "$(cat $STDOUTF)"
+    assertEquals "mychroot -b $HOME -b /tmp -b /proc -b /sys -b /dev $JUNEST_HOME /bin/sh --login" "$(cat "$STDOUTF")"
 }
 
 function test_run_env_as_groot_no_copy(){
     assertCommandSuccess run_env_as_groot "" "" "true" pwd
-    assertEquals "chroot_cmd -b $HOME -b /tmp -b /proc -b /sys -b /dev $JUNEST_HOME /bin/sh --login -c pwd" "$(cat $STDOUTF)"
+    assertEquals "chroot_cmd -b $HOME -b /tmp -b /proc -b /sys -b /dev $JUNEST_HOME /bin/sh --login -c pwd" "$(cat "$STDOUTF")"
 
     [[ ! -e ${JUNEST_HOME}/etc/hosts ]]
     assertEquals 0 $?
@@ -74,27 +76,27 @@ function test_run_env_as_groot_nested_env(){
 
 function test_run_env_as_groot_cmd_with_backend_args(){
     assertCommandSuccess run_env_as_groot "" "-n -b /home/blah" "false" pwd
-    assertEquals "chroot_cmd -b $HOME -b /tmp -b /proc -b /sys -b /dev -n -b /home/blah $JUNEST_HOME /bin/sh --login -c pwd" "$(cat $STDOUTF)"
+    assertEquals "chroot_cmd -b $HOME -b /tmp -b /proc -b /sys -b /dev -n -b /home/blah $JUNEST_HOME /bin/sh --login -c pwd" "$(cat "$STDOUTF")"
 }
 
 function test_run_env_as_chroot_cmd(){
     assertCommandSuccess run_env_as_chroot "" "" "false" pwd
-    assertEquals "chroot_cmd $JUNEST_HOME /bin/sh --login -c pwd" "$(cat $STDOUTF)"
+    assertEquals "chroot_cmd $JUNEST_HOME /bin/sh --login -c pwd" "$(cat "$STDOUTF")"
 }
 
 function test_run_env_as_chroot_no_cmd(){
     assertCommandSuccess run_env_as_chroot "" "" "false" ""
-    assertEquals "chroot_cmd $JUNEST_HOME /bin/sh --login" "$(cat $STDOUTF)"
+    assertEquals "chroot_cmd $JUNEST_HOME /bin/sh --login" "$(cat "$STDOUTF")"
 }
 
 function test_run_env_as_chroot_with_backend_command(){
     assertCommandSuccess run_env_as_chroot "mychroot" "" "false" ""
-    assertEquals "mychroot $JUNEST_HOME /bin/sh --login" "$(cat $STDOUTF)"
+    assertEquals "mychroot $JUNEST_HOME /bin/sh --login" "$(cat "$STDOUTF")"
 }
 
 function test_run_env_as_chroot_no_copy(){
     assertCommandSuccess run_env_as_chroot "" "" "true" pwd
-    assertEquals "chroot_cmd $JUNEST_HOME /bin/sh --login -c pwd" "$(cat $STDOUTF)"
+    assertEquals "chroot_cmd $JUNEST_HOME /bin/sh --login -c pwd" "$(cat "$STDOUTF")"
 
     [[ ! -e ${JUNEST_HOME}/etc/hosts ]]
     assertEquals 0 $?
@@ -114,7 +116,7 @@ function test_run_env_as_choot_nested_env(){
 
 function test_run_env_as_chroot_cmd_with_backend_args(){
     assertCommandSuccess run_env_as_chroot "" "-n -b /home/blah" "false" pwd
-    assertEquals "chroot_cmd -n -b /home/blah $JUNEST_HOME /bin/sh --login -c pwd" "$(cat $STDOUTF)"
+    assertEquals "chroot_cmd -n -b /home/blah $JUNEST_HOME /bin/sh --login -c pwd" "$(cat "$STDOUTF")"
 }
 
-source $JUNEST_ROOT/tests/utils/shunit2
+source "$JUNEST_ROOT"/tests/utils/shunit2
diff --git a/tests/unit-tests/test-common.sh b/tests/unit-tests/test-common.sh
index 7037f98..d0a6c0b 100755
--- a/tests/unit-tests/test-common.sh
+++ b/tests/unit-tests/test-common.sh
@@ -1,6 +1,7 @@
 #!/bin/bash
+# shellcheck disable=SC1091
 
-JUNEST_ROOT=$(readlink -f $(dirname $0)/../..)
+JUNEST_ROOT=$(readlink -f "$(dirname "$0")"/../..)
 
 source "$JUNEST_ROOT/tests/utils/utils.sh"
 
@@ -21,52 +22,55 @@ function oneTimeTearDown(){
 
 function setUp(){
     ld_exec_mock() {
-        echo "ld_exec $@"
+        echo "ld_exec $*"
     }
     ld_exec_mock_false() {
-        echo "ld_exec $@"
+        echo "ld_exec $*"
         return 1
     }
+    # shellcheck disable=SC2034
     LD_EXEC=ld_exec_mock
 
     unshare_mock() {
-        echo "unshare $@"
+        echo "unshare $*"
     }
+    # shellcheck disable=SC2034
     UNSHARE=unshare_mock
 
     bwrap_mock() {
-        echo "bwrap $@"
+        echo "bwrap $*"
     }
+    # shellcheck disable=SC2034
     BWRAP=bwrap_mock
 
 }
 
 function test_ln(){
-    LN=echo assertCommandSuccess ln_cmd -s ln_file new_file
-    assertEquals "-s ln_file new_file" "$(cat $STDOUTF)"
+    LN="echo" assertCommandSuccess ln_cmd -s ln_file new_file
+    assertEquals "-s ln_file new_file" "$(cat "$STDOUTF")"
 
     LN=false assertCommandSuccess ln_cmd -s ln_file new_file
-    assertEquals "ld_exec ${JUNEST_HOME}/usr/bin/false -s ln_file new_file" "$(cat $STDOUTF)"
+    assertEquals "ld_exec ${JUNEST_HOME}/usr/bin/false -s ln_file new_file" "$(cat "$STDOUTF")"
 
     LN=false LD_EXEC=false assertCommandFail ln_cmd
 }
 
 function test_getent(){
-    GETENT=echo assertCommandSuccess getent_cmd passwd
-    assertEquals "passwd" "$(cat $STDOUTF)"
+    GETENT="echo" assertCommandSuccess getent_cmd passwd
+    assertEquals "passwd" "$(cat "$STDOUTF")"
 
-    GETENT=false assertCommandSuccess getent_cmd passwd
-    assertEquals "ld_exec ${JUNEST_HOME}/usr/bin/false passwd" "$(cat $STDOUTF)"
+    GETENT="false" assertCommandSuccess getent_cmd passwd
+    assertEquals "ld_exec ${JUNEST_HOME}/usr/bin/false passwd" "$(cat "$STDOUTF")"
 
     GETENT=false LD_EXEC=false assertCommandFail getent_cmd
 }
 
 function test_cp(){
-    CP=echo assertCommandSuccess cp_cmd passwd
-    assertEquals "passwd" "$(cat $STDOUTF)"
+    CP="echo" assertCommandSuccess cp_cmd passwd
+    assertEquals "passwd" "$(cat "$STDOUTF")"
 
     CP=false assertCommandSuccess cp_cmd passwd
-    assertEquals "ld_exec ${JUNEST_HOME}/usr/bin/false passwd" "$(cat $STDOUTF)"
+    assertEquals "ld_exec ${JUNEST_HOME}/usr/bin/false passwd" "$(cat "$STDOUTF")"
 
     CP=false LD_EXEC=false assertCommandFail cp_cmd
 }
@@ -76,7 +80,9 @@ function test_download(){
     CURL=/bin/false
     assertCommandSuccess download_cmd
 
+    # shellcheck disable=SC2034
     WGET=/bin/false
+    # shellcheck disable=SC2034
     CURL=/bin/true
     assertCommandSuccess download_cmd
 
@@ -84,76 +90,77 @@ function test_download(){
 }
 
 function test_rm(){
-    RM=echo assertCommandSuccess rm_cmd rm_file
-    assertEquals "rm_file" "$(cat $STDOUTF)"
+    RM="echo" assertCommandSuccess rm_cmd rm_file
+    assertEquals "rm_file" "$(cat "$STDOUTF")"
 
-    RM=false assertCommandSuccess rm_cmd rm_file
-    assertEquals "ld_exec ${JUNEST_HOME}/usr/bin/false rm_file" "$(cat $STDOUTF)"
+    RM="false" assertCommandSuccess rm_cmd rm_file
+    assertEquals "ld_exec ${JUNEST_HOME}/usr/bin/false rm_file" "$(cat "$STDOUTF")"
 
     RM=false LD_EXEC=false assertCommandFail rm_cmd rm_file
 }
 
 function test_chown(){
-    local id=$(id -u)
+    local id
+    id=$(id -u)
 
-    CHOWN=echo assertCommandSuccess chown_cmd $id chown_file
-    assertEquals "$id chown_file" "$(cat $STDOUTF)"
+    CHOWN="echo" assertCommandSuccess chown_cmd "$id" chown_file
+    assertEquals "$id chown_file" "$(cat "$STDOUTF")"
 
-    CHOWN=false assertCommandSuccess chown_cmd $id chown_file
-    assertEquals "ld_exec ${JUNEST_HOME}/usr/bin/false $id chown_file" "$(cat $STDOUTF)"
+    CHOWN="false" assertCommandSuccess chown_cmd "$id" chown_file
+    assertEquals "ld_exec ${JUNEST_HOME}/usr/bin/false $id chown_file" "$(cat "$STDOUTF")"
 
-    CHOWN=false LD_EXEC=false assertCommandFail chown_cmd $id chown_file
+    CHOWN=false LD_EXEC=false assertCommandFail chown_cmd "$id" chown_file
 }
 
 function test_mkdir(){
-    MKDIR=echo assertCommandSuccess mkdir_cmd -p new_dir/new_dir
-    assertEquals "-p new_dir/new_dir" "$(cat $STDOUTF)"
+    MKDIR="echo" assertCommandSuccess mkdir_cmd -p new_dir/new_dir
+    assertEquals "-p new_dir/new_dir" "$(cat "$STDOUTF")"
 
     MKDIR=false assertCommandSuccess mkdir_cmd -p new_dir/new_dir
-    assertEquals "ld_exec ${JUNEST_HOME}/usr/bin/false -p new_dir/new_dir" "$(cat $STDOUTF)"
+    assertEquals "ld_exec ${JUNEST_HOME}/usr/bin/false -p new_dir/new_dir" "$(cat "$STDOUTF")"
 
     MKDIR=false LD_EXEC=false assertCommandFail mkdir_cmd -p new_dir/new_dir
 }
 
 function test_zgrep(){
-    ZGREP=echo assertCommandSuccess zgrep_cmd new_file
-    assertEquals "new_file" "$(cat $STDOUTF)"
+    ZGREP="echo" assertCommandSuccess zgrep_cmd new_file
+    assertEquals "new_file" "$(cat "$STDOUTF")"
 
-    mkdir -p ${JUNEST_HOME}/usr/bin
-    touch  ${JUNEST_HOME}/usr/bin/false
-    chmod +x ${JUNEST_HOME}/usr/bin/false
+    mkdir -p "${JUNEST_HOME}"/usr/bin
+    touch "${JUNEST_HOME}"/usr/bin/false
+    chmod +x "${JUNEST_HOME}"/usr/bin/false
 
-    echo -e "#!/bin/bash\necho zgrep" > ${JUNEST_HOME}/usr/bin/false
+    echo -e "#!/bin/bash\necho zgrep" > "${JUNEST_HOME}"/usr/bin/false
     ZGREP=false assertCommandSuccess zgrep_cmd new_file
-    assertEquals "zgrep" "$(cat $STDOUTF)"
+    assertEquals "zgrep" "$(cat "$STDOUTF")"
 
-    echo -e "#!/bin/bash\nexit 1" > ${JUNEST_HOME}/usr/bin/false
+    echo -e "#!/bin/bash\nexit 1" > "${JUNEST_HOME}"/usr/bin/false
     ZGREP=false assertCommandFail zgrep_cmd new_file
 }
 
 function test_unshare(){
     assertCommandSuccess unshare_cmd new_program
-    assertEquals "$(echo -e "ld_exec ${JUNEST_HOME}/usr/bin/$UNSHARE --user /bin/sh -c :\nld_exec ${JUNEST_HOME}/usr/bin/$UNSHARE new_program")" "$(cat $STDOUTF)"
+    assertEquals "$(echo -e "ld_exec ${JUNEST_HOME}/usr/bin/$UNSHARE --user /bin/sh -c :\nld_exec ${JUNEST_HOME}/usr/bin/$UNSHARE new_program")" "$(cat "$STDOUTF")"
 
     LD_EXEC=ld_exec_mock_false assertCommandSuccess unshare_cmd new_program
-    assertEquals "$(echo -e "ld_exec ${JUNEST_HOME}/usr/bin/unshare_mock --user /bin/sh -c :\nunshare --user /bin/sh -c :\nunshare new_program")" "$(cat $STDOUTF)"
+    assertEquals "$(echo -e "ld_exec ${JUNEST_HOME}/usr/bin/unshare_mock --user /bin/sh -c :\nunshare --user /bin/sh -c :\nunshare new_program")" "$(cat "$STDOUTF")"
 
     UNSHARE=false LD_EXEC=false assertCommandFail unshare_cmd new_program
 }
 
 function test_bwrap(){
     assertCommandSuccess bwrap_cmd new_program
-    assertEquals "$(echo -e "ld_exec $BWRAP --dev-bind / / /bin/sh -c :\nld_exec $BWRAP new_program")" "$(cat $STDOUTF)"
+    assertEquals "$(echo -e "ld_exec $BWRAP --dev-bind / / /bin/sh -c :\nld_exec $BWRAP new_program")" "$(cat "$STDOUTF")"
 
     BWRAP=false LD_EXEC=false assertCommandFail bwrap_cmd new_program
 }
 
 function test_chroot(){
-    CLASSIC_CHROOT=echo assertCommandSuccess chroot_cmd root
-    assertEquals "root" "$(cat $STDOUTF)"
+    CLASSIC_CHROOT="echo" assertCommandSuccess chroot_cmd root
+    assertEquals "root" "$(cat "$STDOUTF")"
 
     CLASSIC_CHROOT=false assertCommandSuccess chroot_cmd root
-    assertEquals "ld_exec $JUNEST_HOME/usr/bin/false root" "$(cat $STDOUTF)"
+    assertEquals "ld_exec $JUNEST_HOME/usr/bin/false root" "$(cat "$STDOUTF")"
 
     CLASSIC_CHROOT=false LD_EXEC=false assertCommandFail chroot_cmd root
 }
@@ -170,34 +177,35 @@ function test_proot_cmd_seccomp(){
     }
     PROOT=envv
     assertCommandSuccess proot_cmd cmd
-    assertEquals "" "$(cat $STDOUTF | grep "^PROOT_NO_SECCOMP")"
+    assertEquals "" "$(grep "^PROOT_NO_SECCOMP" "$STDOUTF")"
 
     envv(){
         env | grep "^PROOT_NO_SECCOMP"
     }
+    # shellcheck disable=SC2034
     PROOT=envv
     assertCommandSuccess proot_cmd cmd
     # The variable PROOT_NO_SECCOMP will be produced
     # twice due to the fallback mechanism
     assertEquals "PROOT_NO_SECCOMP=1
-PROOT_NO_SECCOMP=1" "$(cat $STDOUTF | grep "^PROOT_NO_SECCOMP")"
+PROOT_NO_SECCOMP=1" "$(grep "^PROOT_NO_SECCOMP" "$STDOUTF")"
 }
 
 function test_copy_passwd_and_group(){
     getent_cmd_mock() {
-        echo $@
+        echo "$*"
     }
     GETENT=getent_cmd_mock assertCommandSuccess copy_passwd_and_group
-    assertEquals "$(echo -e "passwd\npasswd $USER")" "$(cat $JUNEST_HOME/etc/passwd)"
-    assertEquals "group" "$(cat $JUNEST_HOME/etc/group)"
+    assertEquals "$(echo -e "passwd\npasswd $USER")" "$(cat "$JUNEST_HOME"/etc/passwd)"
+    assertEquals "group" "$(cat "$JUNEST_HOME"/etc/group)"
 }
 
 function test_copy_passwd_and_group_fallback(){
     cp_cmd_mock() {
-        echo $@
+        echo "$*"
     }
     CP=cp_cmd_mock GETENT=false LD_EXEC=false assertCommandSuccess copy_passwd_and_group
-    assertEquals "$(echo -e "-f /etc/passwd $JUNEST_HOME//etc/passwd\n-f /etc/group $JUNEST_HOME//etc/group")" "$(cat $STDOUTF)"
+    assertEquals "$(echo -e "-f /etc/passwd $JUNEST_HOME//etc/passwd\n-f /etc/group $JUNEST_HOME//etc/group")" "$(cat "$STDOUTF")"
 }
 
 function test_copy_passwd_and_group_failure(){
@@ -213,14 +221,14 @@ function test_nested_env_not_set_variable(){
 }
 
 function test_check_same_arch_not_same(){
-    echo "JUNEST_ARCH=XXX" > ${JUNEST_HOME}/etc/junest/info
+    echo "JUNEST_ARCH=XXX" > "${JUNEST_HOME}"/etc/junest/info
     assertCommandFailOnStatus 104 check_same_arch
 }
 
 function test_check_same_arch(){
-    echo "JUNEST_ARCH=$ARCH" > ${JUNEST_HOME}/etc/junest/info
+    echo "JUNEST_ARCH=$ARCH" > "${JUNEST_HOME}"/etc/junest/info
     assertCommandSuccess check_same_arch
 }
 
 
-source $JUNEST_ROOT/tests/utils/shunit2
+source "$JUNEST_ROOT"/tests/utils/shunit2
diff --git a/tests/unit-tests/test-junest.sh b/tests/unit-tests/test-junest.sh
index 123b4bd..086062f 100755
--- a/tests/unit-tests/test-junest.sh
+++ b/tests/unit-tests/test-junest.sh
@@ -1,8 +1,10 @@
 #!/bin/bash
-source "$(dirname $0)/../utils/utils.sh"
+# shellcheck disable=SC1091
 
-JUNEST_BASE="$(dirname $0)/../.."
-source $JUNEST_BASE/bin/junest -h &> /dev/null
+source "$(dirname "$0")/../utils/utils.sh"
+
+JUNEST_BASE="$(dirname "$0")/../.."
+source "$JUNEST_BASE"/bin/junest -h &> /dev/null
 
 # Disable the exiterr
 set +e
@@ -37,42 +39,42 @@ function setUp(){
         local backend_args="$2"
         local no_copy_files="$3"
         shift 3
-        echo "run_env_as_proot_fakeroot($backend_command,$backend_args,$no_copy_files,$@)"
+        echo "run_env_as_proot_fakeroot($backend_command,$backend_args,$no_copy_files,$*)"
     }
     function run_env_as_groot(){
         local backend_command="$1"
         local backend_args="$2"
         local no_copy_files="$3"
         shift 3
-        echo "run_env_as_groot($backend_command,$backend_args,$no_copy_files,$@)"
+        echo "run_env_as_groot($backend_command,$backend_args,$no_copy_files,$*)"
     }
     function run_env_as_chroot(){
         local backend_command="$1"
         local backend_args="$2"
         local no_copy_files="$3"
         shift 3
-        echo "run_env_as_chroot($backend_command,$backend_args,$no_copy_files,$@)"
+        echo "run_env_as_chroot($backend_command,$backend_args,$no_copy_files,$*)"
     }
     function run_env_as_proot_user(){
         local backend_command="$1"
         local backend_args="$2"
         local no_copy_files="$3"
         shift 3
-        echo "run_env_as_proot_user($backend_command,$backend_args,$no_copy_files,$@)"
+        echo "run_env_as_proot_user($backend_command,$backend_args,$no_copy_files,$*)"
     }
     function run_env_as_bwrap_fakeroot(){
         local backend_command="$1"
         local backend_args="$2"
         local no_copy_files="$3"
         shift 3
-        echo "run_env_as_bwrap_fakeroot($backend_command,$backend_args,$no_copy_files,$@)"
+        echo "run_env_as_bwrap_fakeroot($backend_command,$backend_args,$no_copy_files,$*)"
     }
     function run_env_as_bwrap_user(){
         local backend_command="$1"
         local backend_args="$2"
         local no_copy_files="$3"
         shift 3
-        echo "run_env_as_bwrap_user($backend_command,$backend_args,$no_copy_files,$@)"
+        echo "run_env_as_bwrap_user($backend_command,$backend_args,$no_copy_files,$*)"
     }
     function is_env_installed(){
         return 0
@@ -84,25 +86,25 @@ function setUp(){
 
 function test_help(){
     assertCommandSuccess main -h
-    assertEquals "usage" "$(cat $STDOUTF)"
+    assertEquals "usage" "$(cat "$STDOUTF")"
     assertCommandSuccess main --help
-    assertEquals "usage" "$(cat $STDOUTF)"
+    assertEquals "usage" "$(cat "$STDOUTF")"
 }
 function test_version(){
     assertCommandSuccess main -V
-    assertEquals "version" "$(cat $STDOUTF)"
+    assertEquals "version" "$(cat "$STDOUTF")"
     assertCommandSuccess main --version
-    assertEquals "version" "$(cat $STDOUTF)"
+    assertEquals "version" "$(cat "$STDOUTF")"
 }
 function test_build_image_env(){
     assertCommandSuccess main b
-    assertEquals "build_image_env(false)" "$(cat $STDOUTF)"
+    assertEquals "build_image_env(false)" "$(cat "$STDOUTF")"
     assertCommandSuccess main build
-    assertEquals "build_image_env(false)" "$(cat $STDOUTF)"
+    assertEquals "build_image_env(false)" "$(cat "$STDOUTF")"
     assertCommandSuccess main b -n
-    assertEquals "build_image_env(true)" "$(cat $STDOUTF)"
+    assertEquals "build_image_env(true)" "$(cat "$STDOUTF")"
     assertCommandSuccess main build --disable-check
-    assertEquals "build_image_env(true)" "$(cat $STDOUTF)"
+    assertEquals "build_image_env(true)" "$(cat "$STDOUTF")"
 }
 
 function test_create_wrappers(){
@@ -111,26 +113,26 @@ function test_create_wrappers(){
         echo "create_wrappers($force)"
     }
     assertCommandSuccess main create-bin-wrappers
-    assertEquals "create_wrappers(false)" "$(cat $STDOUTF)"
+    assertEquals "create_wrappers(false)" "$(cat "$STDOUTF")"
 
     assertCommandSuccess main create-bin-wrappers --force
-    assertEquals "create_wrappers(true)" "$(cat $STDOUTF)"
+    assertEquals "create_wrappers(true)" "$(cat "$STDOUTF")"
 }
 
 function test_delete_env(){
     assertCommandSuccess main s -d
-    assertEquals "delete_env" "$(cat $STDOUTF)"
+    assertEquals "delete_env" "$(cat "$STDOUTF")"
     assertCommandSuccess main setup --delete
-    assertEquals "delete_env" "$(cat $STDOUTF)"
+    assertEquals "delete_env" "$(cat "$STDOUTF")"
 }
 function test_setup_env_from_file(){
     is_env_installed(){
         return 1
     }
     assertCommandSuccess main s -i myimage
-    assertEquals "setup_env_from_file(myimage)" "$(cat $STDOUTF)"
+    assertEquals "setup_env_from_file(myimage)" "$(cat "$STDOUTF")"
     assertCommandSuccess main setup --from-file myimage
-    assertEquals "setup_env_from_file(myimage)" "$(cat $STDOUTF)"
+    assertEquals "setup_env_from_file(myimage)" "$(cat "$STDOUTF")"
 
     is_env_installed(){
         return 0
@@ -143,13 +145,13 @@ function test_setup_env(){
         return 1
     }
     assertCommandSuccess main s
-    assertEquals "setup_env()" "$(cat $STDOUTF)"
+    assertEquals "setup_env()" "$(cat "$STDOUTF")"
     assertCommandSuccess main setup
-    assertEquals "setup_env()" "$(cat $STDOUTF)"
+    assertEquals "setup_env()" "$(cat "$STDOUTF")"
     assertCommandSuccess main s -a arm
-    assertEquals "setup_env(arm)" "$(cat $STDOUTF)"
+    assertEquals "setup_env(arm)" "$(cat "$STDOUTF")"
     assertCommandSuccess main setup --arch arm
-    assertEquals "setup_env(arm)" "$(cat $STDOUTF)"
+    assertEquals "setup_env(arm)" "$(cat "$STDOUTF")"
 
     is_env_installed(){
         return 0
@@ -159,25 +161,25 @@ function test_setup_env(){
 
 function test_run_env_as_proot_fakeroot(){
     assertCommandSuccess main p -f
-    assertEquals "run_env_as_proot_fakeroot(,,false,)" "$(cat $STDOUTF)"
+    assertEquals "run_env_as_proot_fakeroot(,,false,)" "$(cat "$STDOUTF")"
     assertCommandSuccess main proot --fakeroot
-    assertEquals "run_env_as_proot_fakeroot(,,false,)" "$(cat $STDOUTF)"
+    assertEquals "run_env_as_proot_fakeroot(,,false,)" "$(cat "$STDOUTF")"
     assertCommandSuccess main p -f -n
-    assertEquals "run_env_as_proot_fakeroot(,,true,)" "$(cat $STDOUTF)"
+    assertEquals "run_env_as_proot_fakeroot(,,true,)" "$(cat "$STDOUTF")"
 
     assertCommandSuccess main p -f --backend-command blah
-    assertEquals "run_env_as_proot_fakeroot(blah,,false,)" "$(cat $STDOUTF)"
+    assertEquals "run_env_as_proot_fakeroot(blah,,false,)" "$(cat "$STDOUTF")"
     assertCommandSuccess main proot -f --backend-command blah
-    assertEquals "run_env_as_proot_fakeroot(blah,,false,)" "$(cat $STDOUTF)"
+    assertEquals "run_env_as_proot_fakeroot(blah,,false,)" "$(cat "$STDOUTF")"
 
     assertCommandSuccess main proot -f -b "-b arg"
-    assertEquals "run_env_as_proot_fakeroot(,-b arg,false,)" "$(cat $STDOUTF)"
+    assertEquals "run_env_as_proot_fakeroot(,-b arg,false,)" "$(cat "$STDOUTF")"
     assertCommandSuccess main proot -f -b "-b arg" -- command -kv
-    assertEquals "run_env_as_proot_fakeroot(,-b arg,false,command -kv)" "$(cat $STDOUTF)"
+    assertEquals "run_env_as_proot_fakeroot(,-b arg,false,command -kv)" "$(cat "$STDOUTF")"
     assertCommandSuccess main proot -f command --as
-    assertEquals "run_env_as_proot_fakeroot(,,false,command --as)" "$(cat $STDOUTF)"
+    assertEquals "run_env_as_proot_fakeroot(,,false,command --as)" "$(cat "$STDOUTF")"
     assertCommandSuccess main proot -f  -- command --as
-    assertEquals "run_env_as_proot_fakeroot(,,false,command --as)" "$(cat $STDOUTF)"
+    assertEquals "run_env_as_proot_fakeroot(,,false,command --as)" "$(cat "$STDOUTF")"
 
     is_env_installed(){
         return 1
@@ -187,23 +189,23 @@ function test_run_env_as_proot_fakeroot(){
 
 function test_run_env_as_user(){
     assertCommandSuccess main proot
-    assertEquals "run_env_as_proot_user(,,false,)" "$(cat $STDOUTF)"
+    assertEquals "run_env_as_proot_user(,,false,)" "$(cat "$STDOUTF")"
     assertCommandSuccess main p -n
-    assertEquals "run_env_as_proot_user(,,true,)" "$(cat $STDOUTF)"
+    assertEquals "run_env_as_proot_user(,,true,)" "$(cat "$STDOUTF")"
 
     assertCommandSuccess main p --backend-command blah
-    assertEquals "run_env_as_proot_user(blah,,false,)" "$(cat $STDOUTF)"
+    assertEquals "run_env_as_proot_user(blah,,false,)" "$(cat "$STDOUTF")"
     assertCommandSuccess main proot --backend-command blah
-    assertEquals "run_env_as_proot_user(blah,,false,)" "$(cat $STDOUTF)"
+    assertEquals "run_env_as_proot_user(blah,,false,)" "$(cat "$STDOUTF")"
 
     assertCommandSuccess main proot -b "-b arg"
-    assertEquals "run_env_as_proot_user(,-b arg,false,)" "$(cat $STDOUTF)"
+    assertEquals "run_env_as_proot_user(,-b arg,false,)" "$(cat "$STDOUTF")"
     assertCommandSuccess main proot -b "-b arg" -- command -ll
-    assertEquals "run_env_as_proot_user(,-b arg,false,command -ll)" "$(cat $STDOUTF)"
+    assertEquals "run_env_as_proot_user(,-b arg,false,command -ll)" "$(cat "$STDOUTF")"
     assertCommandSuccess main proot command -ls
-    assertEquals "run_env_as_proot_user(,,false,command -ls)" "$(cat $STDOUTF)"
+    assertEquals "run_env_as_proot_user(,,false,command -ls)" "$(cat "$STDOUTF")"
     assertCommandSuccess main proot -- command -ls
-    assertEquals "run_env_as_proot_user(,,false,command -ls)" "$(cat $STDOUTF)"
+    assertEquals "run_env_as_proot_user(,,false,command -ls)" "$(cat "$STDOUTF")"
 
     is_env_installed(){
         return 1
@@ -213,21 +215,21 @@ function test_run_env_as_user(){
 
 function test_run_env_as_groot(){
     assertCommandSuccess main g
-    assertEquals "run_env_as_groot(,,false,)" "$(cat $STDOUTF)"
+    assertEquals "run_env_as_groot(,,false,)" "$(cat "$STDOUTF")"
     assertCommandSuccess main g -n
-    assertEquals "run_env_as_groot(,,true,)" "$(cat $STDOUTF)"
+    assertEquals "run_env_as_groot(,,true,)" "$(cat "$STDOUTF")"
     assertCommandSuccess main g -b "-b arg"
-    assertEquals "run_env_as_groot(,-b arg,false,)" "$(cat $STDOUTF)"
+    assertEquals "run_env_as_groot(,-b arg,false,)" "$(cat "$STDOUTF")"
 
     assertCommandSuccess main g --backend-command blah
-    assertEquals "run_env_as_groot(blah,,false,)" "$(cat $STDOUTF)"
+    assertEquals "run_env_as_groot(blah,,false,)" "$(cat "$STDOUTF")"
     assertCommandSuccess main groot --backend-command blah
-    assertEquals "run_env_as_groot(blah,,false,)" "$(cat $STDOUTF)"
+    assertEquals "run_env_as_groot(blah,,false,)" "$(cat "$STDOUTF")"
 
     assertCommandSuccess main groot command
-    assertEquals "run_env_as_groot(,,false,command)" "$(cat $STDOUTF)"
+    assertEquals "run_env_as_groot(,,false,command)" "$(cat "$STDOUTF")"
     assertCommandSuccess main groot -- command
-    assertEquals "run_env_as_groot(,,false,command)" "$(cat $STDOUTF)"
+    assertEquals "run_env_as_groot(,,false,command)" "$(cat "$STDOUTF")"
 
     is_env_installed(){
         return 1
@@ -237,19 +239,19 @@ function test_run_env_as_groot(){
 
 function test_run_env_as_chroot(){
     assertCommandSuccess main r
-    assertEquals "run_env_as_chroot(,,false,)" "$(cat $STDOUTF)"
+    assertEquals "run_env_as_chroot(,,false,)" "$(cat "$STDOUTF")"
     assertCommandSuccess main r -b "-b arg"
-    assertEquals "run_env_as_chroot(,-b arg,false,)" "$(cat $STDOUTF)"
+    assertEquals "run_env_as_chroot(,-b arg,false,)" "$(cat "$STDOUTF")"
 
     assertCommandSuccess main r --backend-command blah
-    assertEquals "run_env_as_chroot(blah,,false,)" "$(cat $STDOUTF)"
+    assertEquals "run_env_as_chroot(blah,,false,)" "$(cat "$STDOUTF")"
     assertCommandSuccess main root --backend-command blah
-    assertEquals "run_env_as_chroot(blah,,false,)" "$(cat $STDOUTF)"
+    assertEquals "run_env_as_chroot(blah,,false,)" "$(cat "$STDOUTF")"
 
     assertCommandSuccess main root command
-    assertEquals "run_env_as_chroot(,,false,command)" "$(cat $STDOUTF)"
+    assertEquals "run_env_as_chroot(,,false,command)" "$(cat "$STDOUTF")"
     assertCommandSuccess main root -- command
-    assertEquals "run_env_as_chroot(,,false,command)" "$(cat $STDOUTF)"
+    assertEquals "run_env_as_chroot(,,false,command)" "$(cat "$STDOUTF")"
 
     is_env_installed(){
         return 1
@@ -259,39 +261,39 @@ function test_run_env_as_chroot(){
 
 function test_run_env_as_bwrap_fakeroot(){
     assertCommandSuccess main n -f
-    assertEquals "run_env_as_bwrap_fakeroot(,,false,)" "$(cat $STDOUTF)"
+    assertEquals "run_env_as_bwrap_fakeroot(,,false,)" "$(cat "$STDOUTF")"
     assertCommandSuccess main ns -f
-    assertEquals "run_env_as_bwrap_fakeroot(,,false,)" "$(cat $STDOUTF)"
+    assertEquals "run_env_as_bwrap_fakeroot(,,false,)" "$(cat "$STDOUTF")"
     assertCommandSuccess main ns -n -f
-    assertEquals "run_env_as_bwrap_fakeroot(,,true,)" "$(cat $STDOUTF)"
+    assertEquals "run_env_as_bwrap_fakeroot(,,true,)" "$(cat "$STDOUTF")"
 
     assertCommandSuccess main ns -f -b "-b arg"
-    assertEquals "run_env_as_bwrap_fakeroot(,-b arg,false,)" "$(cat $STDOUTF)"
+    assertEquals "run_env_as_bwrap_fakeroot(,-b arg,false,)" "$(cat "$STDOUTF")"
     assertCommandSuccess main ns -f -b "-b arg" -- command -kv
-    assertEquals "run_env_as_bwrap_fakeroot(,-b arg,false,command -kv)" "$(cat $STDOUTF)"
+    assertEquals "run_env_as_bwrap_fakeroot(,-b arg,false,command -kv)" "$(cat "$STDOUTF")"
     assertCommandSuccess main ns -f command --as
-    assertEquals "run_env_as_bwrap_fakeroot(,,false,command --as)" "$(cat $STDOUTF)"
+    assertEquals "run_env_as_bwrap_fakeroot(,,false,command --as)" "$(cat "$STDOUTF")"
     assertCommandSuccess main ns -f -- command --as
-    assertEquals "run_env_as_bwrap_fakeroot(,,false,command --as)" "$(cat $STDOUTF)"
+    assertEquals "run_env_as_bwrap_fakeroot(,,false,command --as)" "$(cat "$STDOUTF")"
 
     assertCommandSuccess main ns -f --backend-command blah
-    assertEquals "run_env_as_bwrap_fakeroot(blah,,false,)" "$(cat $STDOUTF)"
+    assertEquals "run_env_as_bwrap_fakeroot(blah,,false,)" "$(cat "$STDOUTF")"
     assertCommandSuccess main -f --backend-command blah
-    assertEquals "run_env_as_bwrap_fakeroot(blah,,false,)" "$(cat $STDOUTF)"
+    assertEquals "run_env_as_bwrap_fakeroot(blah,,false,)" "$(cat "$STDOUTF")"
 
     assertCommandSuccess main -f
-    assertEquals "run_env_as_bwrap_fakeroot(,,false,)" "$(cat $STDOUTF)"
+    assertEquals "run_env_as_bwrap_fakeroot(,,false,)" "$(cat "$STDOUTF")"
     assertCommandSuccess main -f
-    assertEquals "run_env_as_bwrap_fakeroot(,,false,)" "$(cat $STDOUTF)"
+    assertEquals "run_env_as_bwrap_fakeroot(,,false,)" "$(cat "$STDOUTF")"
 
     assertCommandSuccess main -f -b "-b arg"
-    assertEquals "run_env_as_bwrap_fakeroot(,-b arg,false,)" "$(cat $STDOUTF)"
+    assertEquals "run_env_as_bwrap_fakeroot(,-b arg,false,)" "$(cat "$STDOUTF")"
     assertCommandSuccess main -f -b "-b arg" -- command -kv
-    assertEquals "run_env_as_bwrap_fakeroot(,-b arg,false,command -kv)" "$(cat $STDOUTF)"
+    assertEquals "run_env_as_bwrap_fakeroot(,-b arg,false,command -kv)" "$(cat "$STDOUTF")"
     assertCommandSuccess main -f command --as
-    assertEquals "run_env_as_bwrap_fakeroot(,,false,command --as)" "$(cat $STDOUTF)"
+    assertEquals "run_env_as_bwrap_fakeroot(,,false,command --as)" "$(cat "$STDOUTF")"
     assertCommandSuccess main -f -- command --as
-    assertEquals "run_env_as_bwrap_fakeroot(,,false,command --as)" "$(cat $STDOUTF)"
+    assertEquals "run_env_as_bwrap_fakeroot(,,false,command --as)" "$(cat "$STDOUTF")"
 
     is_env_installed(){
         return 1
@@ -301,39 +303,39 @@ function test_run_env_as_bwrap_fakeroot(){
 
 function test_run_env_as_bwrap_user(){
     assertCommandSuccess main n
-    assertEquals "run_env_as_bwrap_user(,,false,)" "$(cat $STDOUTF)"
+    assertEquals "run_env_as_bwrap_user(,,false,)" "$(cat "$STDOUTF")"
     assertCommandSuccess main ns
-    assertEquals "run_env_as_bwrap_user(,,false,)" "$(cat $STDOUTF)"
+    assertEquals "run_env_as_bwrap_user(,,false,)" "$(cat "$STDOUTF")"
     assertCommandSuccess main ns -n
-    assertEquals "run_env_as_bwrap_user(,,true,)" "$(cat $STDOUTF)"
+    assertEquals "run_env_as_bwrap_user(,,true,)" "$(cat "$STDOUTF")"
 
     assertCommandSuccess main ns -b "-b arg"
-    assertEquals "run_env_as_bwrap_user(,-b arg,false,)" "$(cat $STDOUTF)"
+    assertEquals "run_env_as_bwrap_user(,-b arg,false,)" "$(cat "$STDOUTF")"
     assertCommandSuccess main ns -b "-b arg" -- command -kv
-    assertEquals "run_env_as_bwrap_user(,-b arg,false,command -kv)" "$(cat $STDOUTF)"
+    assertEquals "run_env_as_bwrap_user(,-b arg,false,command -kv)" "$(cat "$STDOUTF")"
     assertCommandSuccess main ns command --as
-    assertEquals "run_env_as_bwrap_user(,,false,command --as)" "$(cat $STDOUTF)"
+    assertEquals "run_env_as_bwrap_user(,,false,command --as)" "$(cat "$STDOUTF")"
     assertCommandSuccess main ns -- command --as
-    assertEquals "run_env_as_bwrap_user(,,false,command --as)" "$(cat $STDOUTF)"
+    assertEquals "run_env_as_bwrap_user(,,false,command --as)" "$(cat "$STDOUTF")"
 
     assertCommandSuccess main ns --backend-command blah
-    assertEquals "run_env_as_bwrap_user(blah,,false,)" "$(cat $STDOUTF)"
+    assertEquals "run_env_as_bwrap_user(blah,,false,)" "$(cat "$STDOUTF")"
     assertCommandSuccess main --backend-command blah
-    assertEquals "run_env_as_bwrap_user(blah,,false,)" "$(cat $STDOUTF)"
+    assertEquals "run_env_as_bwrap_user(blah,,false,)" "$(cat "$STDOUTF")"
 
     assertCommandSuccess main
-    assertEquals "run_env_as_bwrap_user(,,false,)" "$(cat $STDOUTF)"
+    assertEquals "run_env_as_bwrap_user(,,false,)" "$(cat "$STDOUTF")"
     assertCommandSuccess main
-    assertEquals "run_env_as_bwrap_user(,,false,)" "$(cat $STDOUTF)"
+    assertEquals "run_env_as_bwrap_user(,,false,)" "$(cat "$STDOUTF")"
 
     assertCommandSuccess main -b "-b arg"
-    assertEquals "run_env_as_bwrap_user(,-b arg,false,)" "$(cat $STDOUTF)"
+    assertEquals "run_env_as_bwrap_user(,-b arg,false,)" "$(cat "$STDOUTF")"
     assertCommandSuccess main -b "-b arg" -- command -kv
-    assertEquals "run_env_as_bwrap_user(,-b arg,false,command -kv)" "$(cat $STDOUTF)"
+    assertEquals "run_env_as_bwrap_user(,-b arg,false,command -kv)" "$(cat "$STDOUTF")"
     assertCommandSuccess main command --as
-    assertEquals "run_env_as_bwrap_user(,,false,command --as)" "$(cat $STDOUTF)"
+    assertEquals "run_env_as_bwrap_user(,,false,command --as)" "$(cat "$STDOUTF")"
     assertCommandSuccess main -- command --as
-    assertEquals "run_env_as_bwrap_user(,,false,command --as)" "$(cat $STDOUTF)"
+    assertEquals "run_env_as_bwrap_user(,,false,command --as)" "$(cat "$STDOUTF")"
 
     is_env_installed(){
         return 1
@@ -353,4 +355,4 @@ function test_invalid_option(){
     assertCommandFail main s --no-option
 }
 
-source $(dirname $0)/../utils/shunit2
+source "$(dirname "$0")"/../utils/shunit2
diff --git a/tests/unit-tests/test-namespace.sh b/tests/unit-tests/test-namespace.sh
index 72b9035..373c1be 100755
--- a/tests/unit-tests/test-namespace.sh
+++ b/tests/unit-tests/test-namespace.sh
@@ -1,6 +1,7 @@
 #!/bin/bash
+# shellcheck disable=SC1091
 
-JUNEST_ROOT=$(readlink -f $(dirname $0)/../..)
+JUNEST_ROOT=$(readlink -f "$(dirname "$0")"/../..)
 
 source "$JUNEST_ROOT/tests/utils/utils.sh"
 
@@ -16,7 +17,7 @@ function oneTimeSetUp(){
 ## Mock functions ##
 function init_mocks() {
     function bwrap_cmd(){
-        echo "$BWRAP $@"
+        echo "$BWRAP $*"
     }
 }
 
@@ -39,16 +40,16 @@ function tearDown(){
 }
 
 function _test_copy_common_files() {
-    [[ -e /etc/hosts ]] && assertEquals "$(cat /etc/hosts)" "$(cat ${JUNEST_HOME}/etc/hosts)"
-    [[ -e /etc/host.conf ]] && assertEquals "$(cat /etc/host.conf)" "$(cat ${JUNEST_HOME}/etc/host.conf)"
-    [[ -e /etc/nsswitch.conf ]] && assertEquals "$(cat /etc/nsswitch.conf)" "$(cat ${JUNEST_HOME}/etc/nsswitch.conf)"
-    [[ -e /etc/resolv.conf ]] && assertEquals "$(cat /etc/resolv.conf)" "$(cat ${JUNEST_HOME}/etc/resolv.conf)"
+    [[ -e /etc/hosts ]] && assertEquals "$(cat /etc/hosts)" "$(cat "${JUNEST_HOME}"/etc/hosts)"
+    [[ -e /etc/host.conf ]] && assertEquals "$(cat /etc/host.conf)" "$(cat "${JUNEST_HOME}"/etc/host.conf)"
+    [[ -e /etc/nsswitch.conf ]] && assertEquals "$(cat /etc/nsswitch.conf)" "$(cat "${JUNEST_HOME}"/etc/nsswitch.conf)"
+    [[ -e /etc/resolv.conf ]] && assertEquals "$(cat /etc/resolv.conf)" "$(cat "${JUNEST_HOME}"/etc/resolv.conf)"
 }
 
 function _test_copy_remaining_files() {
-    [[ -e /etc/hosts.equiv ]] && assertEquals "$(cat /etc/hosts.equiv)" "$(cat ${JUNEST_HOME}/etc/hosts.equiv)"
-    [[ -e /etc/netgroup ]] && assertEquals "$(cat /etc/netgroup)" "$(cat ${JUNEST_HOME}/etc/netgroup)"
-    [[ -e /etc/networks ]] && assertEquals "$(cat /etc/networks)" "$(cat ${JUNEST_HOME}/etc/networks)"
+    [[ -e /etc/hosts.equiv ]] && assertEquals "$(cat /etc/hosts.equiv)" "$(cat "${JUNEST_HOME}"/etc/hosts.equiv)"
+    [[ -e /etc/netgroup ]] && assertEquals "$(cat /etc/netgroup)" "$(cat "${JUNEST_HOME}"/etc/netgroup)"
+    [[ -e /etc/networks ]] && assertEquals "$(cat /etc/networks)" "$(cat "${JUNEST_HOME}"/etc/networks)"
 
     [[ -e ${JUNEST_HOME}/etc/passwd ]]
     assertEquals 0 $?
@@ -59,7 +60,7 @@ function _test_copy_remaining_files() {
 function test_is_user_namespace_enabled_no_config_file(){
     CONFIG_PROC_FILE="blah"
     CONFIG_BOOT_FILE="blah"
-    assertCommandFailOnStatus $NOT_EXISTING_FILE _is_user_namespace_enabled
+    assertCommandFailOnStatus "$NOT_EXISTING_FILE" _is_user_namespace_enabled
 }
 
 function test_is_user_namespace_enabled_no_config(){
@@ -67,7 +68,7 @@ function test_is_user_namespace_enabled_no_config(){
     gzip config
     CONFIG_PROC_FILE="config.gz"
     CONFIG_BOOT_FILE="blah"
-    assertCommandFailOnStatus $NO_CONFIG_FOUND _is_user_namespace_enabled
+    assertCommandFailOnStatus "$NO_CONFIG_FOUND" _is_user_namespace_enabled
 }
 
 function test_is_user_namespace_enabled_with_config(){
@@ -86,13 +87,15 @@ function test_is_user_namespace_enabled_with_userns_clone_file_disabled(){
     CONFIG_BOOT_FILE="blah"
     PROC_USERNS_CLONE_FILE="unprivileged_userns_clone"
     echo "0" > $PROC_USERNS_CLONE_FILE
-    assertCommandFailOnStatus $UNPRIVILEGED_USERNS_DISABLED _is_user_namespace_enabled
+    assertCommandFailOnStatus "$UNPRIVILEGED_USERNS_DISABLED" _is_user_namespace_enabled
 }
 
 function test_is_user_namespace_enabled_with_userns_clone_file_enabled(){
     echo "CONFIG_USER_NS=y" > config
     gzip config
+    # shellcheck disable=SC2034
     CONFIG_PROC_FILE="config.gz"
+    # shellcheck disable=SC2034
     CONFIG_BOOT_FILE="blah"
     PROC_USERNS_CLONE_FILE="unprivileged_userns_clone"
     echo "1" > $PROC_USERNS_CLONE_FILE
@@ -101,21 +104,21 @@ function test_is_user_namespace_enabled_with_userns_clone_file_enabled(){
 
 function test_run_env_as_bwrap_fakeroot() {
     assertCommandSuccess run_env_as_bwrap_fakeroot "" "" "false"
-    assertEquals "$BWRAP $COMMON_BWRAP_OPTION --cap-add ALL --uid 0 --gid 0 sudo /bin/sh --login" "$(cat $STDOUTF)"
+    assertEquals "$BWRAP $COMMON_BWRAP_OPTION --cap-add ALL --uid 0 --gid 0 sudo /bin/sh --login" "$(cat "$STDOUTF")"
 
     _test_copy_common_files
 }
 
 function test_run_env_as_bwrap_fakeroot_with_backend_command() {
     assertCommandSuccess run_env_as_bwrap_fakeroot "mybwrap" "" "false"
-    assertEquals "mybwrap $COMMON_BWRAP_OPTION --cap-add ALL --uid 0 --gid 0 sudo /bin/sh --login" "$(cat $STDOUTF)"
+    assertEquals "mybwrap $COMMON_BWRAP_OPTION --cap-add ALL --uid 0 --gid 0 sudo /bin/sh --login" "$(cat "$STDOUTF")"
 
     _test_copy_common_files
 }
 
 function test_run_env_as_bwrap_user() {
     assertCommandSuccess run_env_as_bwrap_user "" "" "false"
-    assertEquals "$BWRAP $COMMON_BWRAP_OPTION /bin/sh --login" "$(cat $STDOUTF)"
+    assertEquals "$BWRAP $COMMON_BWRAP_OPTION /bin/sh --login" "$(cat "$STDOUTF")"
 
     _test_copy_common_files
     _test_copy_remaining_files
@@ -123,7 +126,7 @@ function test_run_env_as_bwrap_user() {
 
 function test_run_env_as_bwrap_user_with_backend_command() {
     assertCommandSuccess run_env_as_bwrap_user "mybwrap" "" "false"
-    assertEquals "mybwrap $COMMON_BWRAP_OPTION /bin/sh --login" "$(cat $STDOUTF)"
+    assertEquals "mybwrap $COMMON_BWRAP_OPTION /bin/sh --login" "$(cat "$STDOUTF")"
 
     _test_copy_common_files
     _test_copy_remaining_files
@@ -131,7 +134,7 @@ function test_run_env_as_bwrap_user_with_backend_command() {
 
 function test_run_env_as_bwrap_fakeroot_no_copy() {
     assertCommandSuccess run_env_as_bwrap_fakeroot "" "" "true" ""
-    assertEquals "$BWRAP $COMMON_BWRAP_OPTION --cap-add ALL --uid 0 --gid 0 sudo /bin/sh --login" "$(cat $STDOUTF)"
+    assertEquals "$BWRAP $COMMON_BWRAP_OPTION --cap-add ALL --uid 0 --gid 0 sudo /bin/sh --login" "$(cat "$STDOUTF")"
 
     [[ ! -e ${JUNEST_HOME}/etc/hosts ]]
     assertEquals 0 $?
@@ -157,7 +160,7 @@ function test_run_env_as_bwrap_fakeroot_no_copy() {
 
 function test_run_env_as_bwrap_user_no_copy() {
     assertCommandSuccess run_env_as_bwrap_user "" "" "true" ""
-    assertEquals "$BWRAP $COMMON_BWRAP_OPTION /bin/sh --login" "$(cat $STDOUTF)"
+    assertEquals "$BWRAP $COMMON_BWRAP_OPTION /bin/sh --login" "$(cat "$STDOUTF")"
 
     [[ ! -e ${JUNEST_HOME}/etc/hosts ]]
     assertEquals 0 $?
@@ -183,14 +186,14 @@ function test_run_env_as_bwrap_user_no_copy() {
 
 function test_run_env_as_bwrap_fakeroot_with_backend_args() {
     assertCommandSuccess run_env_as_bwrap_fakeroot "" "--bind /usr /usr" "false"
-    assertEquals "$BWRAP $COMMON_BWRAP_OPTION --cap-add ALL --uid 0 --gid 0 --bind /usr /usr sudo /bin/sh --login" "$(cat $STDOUTF)"
+    assertEquals "$BWRAP $COMMON_BWRAP_OPTION --cap-add ALL --uid 0 --gid 0 --bind /usr /usr sudo /bin/sh --login" "$(cat "$STDOUTF")"
 
     _test_copy_common_files
 }
 
 function test_run_env_as_bwrap_user_with_backend_args() {
     assertCommandSuccess run_env_as_bwrap_user "" "--bind /usr /usr" "false"
-    assertEquals "$BWRAP $COMMON_BWRAP_OPTION --bind /usr /usr /bin/sh --login" "$(cat $STDOUTF)"
+    assertEquals "$BWRAP $COMMON_BWRAP_OPTION --bind /usr /usr /bin/sh --login" "$(cat "$STDOUTF")"
 
     _test_copy_common_files
     _test_copy_remaining_files
@@ -198,14 +201,14 @@ function test_run_env_as_bwrap_user_with_backend_args() {
 
 function test_run_env_as_bwrap_fakeroot_with_command() {
     assertCommandSuccess run_env_as_bwrap_fakeroot "" "" "false" "ls -la"
-    assertEquals "$BWRAP $COMMON_BWRAP_OPTION --cap-add ALL --uid 0 --gid 0 sudo /bin/sh --login -c \"ls -la\"" "$(cat $STDOUTF)"
+    assertEquals "$BWRAP $COMMON_BWRAP_OPTION --cap-add ALL --uid 0 --gid 0 sudo /bin/sh --login -c \"ls -la\"" "$(cat "$STDOUTF")"
 
     _test_copy_common_files
 }
 
 function test_run_env_as_bwrap_user_with_command() {
     assertCommandSuccess run_env_as_bwrap_user "" "" "false" "ls -la"
-    assertEquals "$BWRAP $COMMON_BWRAP_OPTION /bin/sh --login -c \"ls -la\"" "$(cat $STDOUTF)"
+    assertEquals "$BWRAP $COMMON_BWRAP_OPTION /bin/sh --login -c \"ls -la\"" "$(cat "$STDOUTF")"
 
     _test_copy_common_files
     _test_copy_remaining_files
@@ -213,14 +216,14 @@ function test_run_env_as_bwrap_user_with_command() {
 
 function test_run_env_as_bwrap_fakeroot_with_backend_args_and_command() {
     assertCommandSuccess run_env_as_bwrap_fakeroot "" "--bind /usr /usr" "false" "ls -la"
-    assertEquals "$BWRAP $COMMON_BWRAP_OPTION --cap-add ALL --uid 0 --gid 0 --bind /usr /usr sudo /bin/sh --login -c \"ls -la\"" "$(cat $STDOUTF)"
+    assertEquals "$BWRAP $COMMON_BWRAP_OPTION --cap-add ALL --uid 0 --gid 0 --bind /usr /usr sudo /bin/sh --login -c \"ls -la\"" "$(cat "$STDOUTF")"
 
     _test_copy_common_files
 }
 
 function test_run_env_as_bwrap_user_with_backend_args_and_command() {
     assertCommandSuccess run_env_as_bwrap_user "" "--bind /usr /usr" "false" "ls -la"
-    assertEquals "$BWRAP $COMMON_BWRAP_OPTION --bind /usr /usr /bin/sh --login -c \"ls -la\"" "$(cat $STDOUTF)"
+    assertEquals "$BWRAP $COMMON_BWRAP_OPTION --bind /usr /usr /bin/sh --login -c \"ls -la\"" "$(cat "$STDOUTF")"
 
     _test_copy_common_files
     _test_copy_remaining_files
@@ -233,9 +236,10 @@ function test_run_env_as_bwrap_fakeroot_nested_env(){
 }
 
 function test_run_env_as_bwrap_user_nested_env(){
+    # shellcheck disable=SC2034
     JUNEST_ENV=1
     assertCommandFailOnStatus 106 run_env_as_bwrap_user "" "" "false" ""
     unset JUNEST_ENV
 }
 
-source $JUNEST_ROOT/tests/utils/shunit2
+source "$JUNEST_ROOT"/tests/utils/shunit2
diff --git a/tests/unit-tests/test-proot.sh b/tests/unit-tests/test-proot.sh
index 9e152f9..2217150 100755
--- a/tests/unit-tests/test-proot.sh
+++ b/tests/unit-tests/test-proot.sh
@@ -1,6 +1,7 @@
 #!/bin/bash
+# shellcheck disable=SC1091
 
-JUNEST_ROOT=$(readlink -f $(dirname $0)/../..)
+JUNEST_ROOT=$(readlink -f "$(dirname "$0")"/../..)
 
 source "$JUNEST_ROOT/tests/utils/utils.sh"
 
@@ -30,16 +31,16 @@ function tearDown(){
 }
 
 function _test_copy_common_files() {
-    [[ -e /etc/hosts ]] && assertEquals "$(cat /etc/hosts)" "$(cat ${JUNEST_HOME}/etc/hosts)"
-    [[ -e /etc/host.conf ]] && assertEquals "$(cat /etc/host.conf)" "$(cat ${JUNEST_HOME}/etc/host.conf)"
-    [[ -e /etc/nsswitch.conf ]] && assertEquals "$(cat /etc/nsswitch.conf)" "$(cat ${JUNEST_HOME}/etc/nsswitch.conf)"
-    [[ -e /etc/resolv.conf ]] && assertEquals "$(cat /etc/resolv.conf)" "$(cat ${JUNEST_HOME}/etc/resolv.conf)"
+    [[ -e /etc/hosts ]] && assertEquals "$(cat /etc/hosts)" "$(cat "${JUNEST_HOME}"/etc/hosts)"
+    [[ -e /etc/host.conf ]] && assertEquals "$(cat /etc/host.conf)" "$(cat "${JUNEST_HOME}"/etc/host.conf)"
+    [[ -e /etc/nsswitch.conf ]] && assertEquals "$(cat /etc/nsswitch.conf)" "$(cat "${JUNEST_HOME}"/etc/nsswitch.conf)"
+    [[ -e /etc/resolv.conf ]] && assertEquals "$(cat /etc/resolv.conf)" "$(cat "${JUNEST_HOME}"/etc/resolv.conf)"
 }
 
 function _test_copy_remaining_files() {
-    [[ -e /etc/hosts.equiv ]] && assertEquals "$(cat /etc/hosts.equiv)" "$(cat ${JUNEST_HOME}/etc/hosts.equiv)"
-    [[ -e /etc/netgroup ]] && assertEquals "$(cat /etc/netgroup)" "$(cat ${JUNEST_HOME}/etc/netgroup)"
-    [[ -e /etc/networks ]] && assertEquals "$(cat /etc/networks)" "$(cat ${JUNEST_HOME}/etc/networks)"
+    [[ -e /etc/hosts.equiv ]] && assertEquals "$(cat /etc/hosts.equiv)" "$(cat "${JUNEST_HOME}"/etc/hosts.equiv)"
+    [[ -e /etc/netgroup ]] && assertEquals "$(cat /etc/netgroup)" "$(cat "${JUNEST_HOME}"/etc/netgroup)"
+    [[ -e /etc/networks ]] && assertEquals "$(cat /etc/networks)" "$(cat "${JUNEST_HOME}"/etc/networks)"
 
     [[ -e ${JUNEST_HOME}/etc/passwd ]]
     assertEquals 0 $?
@@ -49,14 +50,16 @@ function _test_copy_remaining_files() {
 
 function test_run_env_as_proot_user(){
     _run_env_with_qemu() {
-        echo $@
+        # shellcheck disable=SC2086
+        # shellcheck disable=SC2048
+        echo $*
     }
     assertCommandSuccess run_env_as_proot_user "" "-k 3.10" "false" "/usr/bin/mkdir" "-v" "/newdir2"
-    assertEquals "-b $HOME -b /tmp -b /proc -b /sys -b /dev -r ${JUNEST_HOME} -k 3.10 /usr/bin/mkdir -v /newdir2" "$(cat $STDOUTF)"
+    assertEquals "-b $HOME -b /tmp -b /proc -b /sys -b /dev -r ${JUNEST_HOME} -k 3.10 /usr/bin/mkdir -v /newdir2" "$(cat "$STDOUTF")"
 
     SH=("/usr/bin/echo")
     assertCommandSuccess run_env_as_proot_user "" "-k 3.10" "false"
-    assertEquals "-b $HOME -b /tmp -b /proc -b /sys -b /dev -r ${JUNEST_HOME} -k 3.10" "$(cat $STDOUTF)"
+    assertEquals "-b $HOME -b /tmp -b /proc -b /sys -b /dev -r ${JUNEST_HOME} -k 3.10" "$(cat "$STDOUTF")"
 
     _test_copy_common_files
     _test_copy_remaining_files
@@ -64,14 +67,16 @@ function test_run_env_as_proot_user(){
 
 function test_run_env_as_proot_user_with_backend_command(){
     _run_env_with_qemu() {
-        echo $@
+        # shellcheck disable=SC2086
+        # shellcheck disable=SC2048
+        echo $*
     }
     assertCommandSuccess run_env_as_proot_user "myproot" "-k 3.10" "false" "/usr/bin/mkdir" "-v" "/newdir2"
-    assertEquals "myproot -b $HOME -b /tmp -b /proc -b /sys -b /dev -r ${JUNEST_HOME} -k 3.10 /usr/bin/mkdir -v /newdir2" "$(cat $STDOUTF)"
+    assertEquals "myproot -b $HOME -b /tmp -b /proc -b /sys -b /dev -r ${JUNEST_HOME} -k 3.10 /usr/bin/mkdir -v /newdir2" "$(cat "$STDOUTF")"
 
     SH=("/usr/bin/echo")
     assertCommandSuccess run_env_as_proot_user "myproot" "-k 3.10" "false"
-    assertEquals "myproot -b $HOME -b /tmp -b /proc -b /sys -b /dev -r ${JUNEST_HOME} -k 3.10" "$(cat $STDOUTF)"
+    assertEquals "myproot -b $HOME -b /tmp -b /proc -b /sys -b /dev -r ${JUNEST_HOME} -k 3.10" "$(cat "$STDOUTF")"
 
     _test_copy_common_files
     _test_copy_remaining_files
@@ -79,10 +84,12 @@ function test_run_env_as_proot_user_with_backend_command(){
 
 function test_run_env_as_proot_user_no_copy(){
     _run_env_with_qemu() {
-        echo $@
+        # shellcheck disable=SC2086
+        # shellcheck disable=SC2048
+        echo $*
     }
     assertCommandSuccess run_env_as_proot_user "" "-k 3.10" "true" "/usr/bin/mkdir" "-v" "/newdir2"
-    assertEquals "-b $HOME -b /tmp -b /proc -b /sys -b /dev -r ${JUNEST_HOME} -k 3.10 /usr/bin/mkdir -v /newdir2" "$(cat $STDOUTF)"
+    assertEquals "-b $HOME -b /tmp -b /proc -b /sys -b /dev -r ${JUNEST_HOME} -k 3.10 /usr/bin/mkdir -v /newdir2" "$(cat "$STDOUTF")"
 
     [[ ! -e ${JUNEST_HOME}/etc/hosts ]]
     assertEquals 0 $?
@@ -114,28 +121,33 @@ function test_run_env_as_proot_user_nested_env(){
 
 function test_run_env_as_proot_fakeroot(){
     _run_env_with_qemu() {
-        echo $@
+        # shellcheck disable=SC2086
+        # shellcheck disable=SC2048
+        echo $*
     }
     assertCommandSuccess run_env_as_proot_fakeroot "" "-k 3.10" "false" "/usr/bin/mkdir" "-v" "/newdir2"
-    assertEquals "-0 -b ${HOME} -b /tmp -b /proc -b /sys -b /dev -r ${JUNEST_HOME} -k 3.10 /usr/bin/mkdir -v /newdir2" "$(cat $STDOUTF)"
+    assertEquals "-0 -b ${HOME} -b /tmp -b /proc -b /sys -b /dev -r ${JUNEST_HOME} -k 3.10 /usr/bin/mkdir -v /newdir2" "$(cat "$STDOUTF")"
 
     SH=("/usr/bin/echo")
     assertCommandSuccess run_env_as_proot_fakeroot "" "-k 3.10" "false"
-    assertEquals "-0 -b ${HOME} -b /tmp -b /proc -b /sys -b /dev -r ${JUNEST_HOME} -k 3.10" "$(cat $STDOUTF)"
+    assertEquals "-0 -b ${HOME} -b /tmp -b /proc -b /sys -b /dev -r ${JUNEST_HOME} -k 3.10" "$(cat "$STDOUTF")"
 
     _test_copy_common_files
 }
 
 function test_run_env_as_proot_fakeroot_with_backend_command(){
     _run_env_with_qemu() {
-        echo $@
+        # shellcheck disable=SC2086
+        # shellcheck disable=SC2048
+        echo $*
     }
     assertCommandSuccess run_env_as_proot_fakeroot "myproot" "-k 3.10" "false" "/usr/bin/mkdir" "-v" "/newdir2"
-    assertEquals "myproot -0 -b ${HOME} -b /tmp -b /proc -b /sys -b /dev -r ${JUNEST_HOME} -k 3.10 /usr/bin/mkdir -v /newdir2" "$(cat $STDOUTF)"
+    assertEquals "myproot -0 -b ${HOME} -b /tmp -b /proc -b /sys -b /dev -r ${JUNEST_HOME} -k 3.10 /usr/bin/mkdir -v /newdir2" "$(cat "$STDOUTF")"
 
+    # shellcheck disable=SC2034
     SH=("/usr/bin/echo")
     assertCommandSuccess run_env_as_proot_fakeroot "myproot" "-k 3.10" "false"
-    assertEquals "myproot -0 -b ${HOME} -b /tmp -b /proc -b /sys -b /dev -r ${JUNEST_HOME} -k 3.10" "$(cat $STDOUTF)"
+    assertEquals "myproot -0 -b ${HOME} -b /tmp -b /proc -b /sys -b /dev -r ${JUNEST_HOME} -k 3.10" "$(cat "$STDOUTF")"
 
     _test_copy_common_files
 }
@@ -148,41 +160,51 @@ function test_run_env_as_proot_fakeroot_nested_env(){
 
 function test_run_env_with_quotes(){
     _run_env_with_qemu() {
-        echo $@
+        # shellcheck disable=SC2086
+        # shellcheck disable=SC2048
+        echo $*
     }
     assertCommandSuccess run_env_as_proot_user "" "-k 3.10" "false" "bash" "-c" "/usr/bin/mkdir -v /newdir2"
-    assertEquals "-b ${HOME} -b /tmp -b /proc -b /sys -b /dev -r ${JUNEST_HOME} -k 3.10 bash -c /usr/bin/mkdir -v /newdir2" "$(cat $STDOUTF)"
+    assertEquals "-b ${HOME} -b /tmp -b /proc -b /sys -b /dev -r ${JUNEST_HOME} -k 3.10 bash -c /usr/bin/mkdir -v /newdir2" "$(cat "$STDOUTF")"
 }
 
 function test_run_env_with_proot_args(){
     proot_cmd() {
         [ "$JUNEST_ENV" != "1" ] && return 1
-        echo $@
+        # shellcheck disable=SC2086
+        # shellcheck disable=SC2048
+        echo $*
     }
 
     assertCommandSuccess _run_env_with_proot "" "--help"
-    assertEquals "--help /bin/sh --login" "$(cat $STDOUTF)"
+    assertEquals "--help /bin/sh --login" "$(cat "$STDOUTF")"
 
     assertCommandSuccess _run_env_with_proot "" "--help" mycommand
-    assertEquals "--help /bin/sh --login -c mycommand" "$(cat $STDOUTF)"
+    assertEquals "--help /bin/sh --login -c mycommand" "$(cat "$STDOUTF")"
 
     assertCommandFail _run_env_with_proot
 }
 
 function test_qemu() {
-    echo "JUNEST_ARCH=arm" > ${JUNEST_HOME}/etc/junest/info
+    echo "JUNEST_ARCH=arm" > "${JUNEST_HOME}"/etc/junest/info
     rm_cmd() {
-        echo $@
+        # shellcheck disable=SC2086
+        # shellcheck disable=SC2048
+        echo $*
     }
     ln_cmd() {
-        echo $@
+        # shellcheck disable=SC2086
+        # shellcheck disable=SC2048
+        echo $*
     }
     _run_env_with_proot() {
-        echo $@
+        # shellcheck disable=SC2086
+        # shellcheck disable=SC2048
+        echo $*
     }
 
     RANDOM=100 ARCH=x86_64 assertCommandSuccess _run_env_with_qemu "" ""
-    assertEquals "$(echo -e "-s $JUNEST_HOME/bin/qemu-arm-static-x86_64 /tmp/qemu-arm-static-x86_64-100\n-q /tmp/qemu-arm-static-x86_64-100")" "$(cat $STDOUTF)"
+    assertEquals "$(echo -e "-s $JUNEST_HOME/bin/qemu-arm-static-x86_64 /tmp/qemu-arm-static-x86_64-100\n-q /tmp/qemu-arm-static-x86_64-100")" "$(cat "$STDOUTF")"
 }
 
-source $JUNEST_ROOT/tests/utils/shunit2
+source "$JUNEST_ROOT"/tests/utils/shunit2
diff --git a/tests/unit-tests/test-setup.sh b/tests/unit-tests/test-setup.sh
index a15dbca..d8c2456 100755
--- a/tests/unit-tests/test-setup.sh
+++ b/tests/unit-tests/test-setup.sh
@@ -1,6 +1,7 @@
 #!/bin/bash
+# shellcheck disable=SC1091
 
-JUNEST_ROOT=$(readlink -f $(dirname $0)/../..)
+JUNEST_ROOT=$(readlink -f "$(dirname "$0")"/../..)
 
 source "$JUNEST_ROOT/tests/utils/utils.sh"
 
@@ -26,24 +27,26 @@ function tearDown(){
 }
 
 function test_is_env_installed(){
-    rm -rf $JUNEST_HOME/*
+    rm -rf "${JUNEST_HOME:?}"/*
     assertCommandFail is_env_installed
-    touch $JUNEST_HOME/just_file
+    touch "$JUNEST_HOME"/just_file
     assertCommandSuccess is_env_installed
 }
 
 function test_setup_env(){
-    rm -rf $JUNEST_HOME/*
+    rm -rf "${JUNEST_HOME:?}"/*
     wget_mock(){
         # Proof that the setup is happening
         # inside $JUNEST_TEMPDIR
-        local cwd=${PWD#${JUNEST_TEMPDIR}}
-        local parent_dir=${PWD%${cwd}}
+        local cwd=${PWD#"${JUNEST_TEMPDIR}"}
+        local parent_dir=${PWD%"${cwd}"}
         assertEquals "$JUNEST_TEMPDIR" "${parent_dir}"
         touch file
-        tar -czvf ${CMD}-${ARCH}.tar.gz file
+        tar -czvf "${CMD}-${ARCH}".tar.gz file
     }
+    # shellcheck disable=SC2034
     WGET=wget_mock
+    # shellcheck disable=SC2119
     setup_env 1> /dev/null
     assertTrue "[ -e $JUNEST_HOME/file ]"
 
@@ -52,10 +55,10 @@ function test_setup_env(){
 
 
 function test_setup_env_from_file(){
-    rm -rf $JUNEST_HOME/*
+    rm -rf "${JUNEST_HOME:?}"/*
     touch file
-    tar -czvf ${CMD}-${ARCH}.tar.gz file 1> /dev/null
-    assertCommandSuccess setup_env_from_file ${CMD}-${ARCH}.tar.gz
+    tar -czvf "${CMD}-${ARCH}".tar.gz file 1> /dev/null
+    assertCommandSuccess setup_env_from_file "${CMD}-${ARCH}.tar.gz"
     assertTrue "[ -e $JUNEST_HOME/file ]"
 }
 
@@ -64,10 +67,10 @@ function test_setup_env_from_file_not_existing_file(){
 }
 
 function test_setup_env_from_file_with_absolute_path(){
-    rm -rf $JUNEST_HOME/*
+    rm -rf "${JUNEST_HOME:?}"/*
     touch file
-    tar -czf ${CMD}-${ARCH}.tar.gz file
-    assertCommandSuccess setup_env_from_file ${CMD}-${ARCH}.tar.gz
+    tar -czf "${CMD}-${ARCH}".tar.gz file
+    assertCommandSuccess setup_env_from_file "${CMD}-${ARCH}.tar.gz"
     assertTrue "[ -e $JUNEST_HOME/file ]"
 }
 
@@ -78,4 +81,4 @@ function test_delete_env(){
     assertCommandFail is_env_installed
 }
 
-source $JUNEST_ROOT/tests/utils/shunit2
+source "$JUNEST_ROOT"/tests/utils/shunit2
diff --git a/tests/unit-tests/test-utils.sh b/tests/unit-tests/test-utils.sh
index c0b1ebf..03e602a 100755
--- a/tests/unit-tests/test-utils.sh
+++ b/tests/unit-tests/test-utils.sh
@@ -1,10 +1,13 @@
 #!/bin/bash
-source "$(dirname $0)/../utils/utils.sh"
+# shellcheck disable=SC1091
+
+source "$(dirname "$0")/../utils/utils.sh"
 
 unset HOME
-export HOME=$(TMPDIR=/tmp mktemp -d -t pearl-user-home.XXXXXXX)
+export HOME
+HOME=$(TMPDIR=/tmp mktemp -d -t pearl-user-home.XXXXXXX)
 
-source "$(dirname $0)/../../lib/utils/utils.sh"
+source "$(dirname "$0")/../../lib/utils/utils.sh"
 
 # Disable the exiterr
 set +e
@@ -20,37 +23,42 @@ function test_check_not_null(){
 
 function test_echoerr(){
     assertCommandSuccess echoerr "Test"
-    assertEquals "Test" "$(cat $STDERRF)"
+    assertEquals "Test" "$(cat "$STDERRF")"
 }
 
 function test_error(){
     assertCommandSuccess error "Test"
-    local expected=$(echo -e "\033[1;31mTest\033[0m")
-    assertEquals "$expected" "$(cat $STDERRF)"
+    local expected
+    expected=$(echo -e "\033[1;31mTest\033[0m")
+    assertEquals "$expected" "$(cat "$STDERRF")"
 }
 
 function test_warn(){
     assertCommandSuccess warn "Test"
-    local expected=$(echo -e "\033[1;33mTest\033[0m")
-    assertEquals "$expected" "$(cat $STDERRF)"
+    local expected
+    expected=$(echo -e "\033[1;33mTest\033[0m")
+    assertEquals "$expected" "$(cat "$STDERRF")"
 }
 
 function test_info(){
     assertCommandSuccess info "Test"
-    local expected=$(echo -e "\033[1;36mTest\033[0m")
-    assertEquals "$expected" "$(cat $STDOUTF)"
+    local expected
+    expected=$(echo -e "\033[1;36mTest\033[0m")
+    assertEquals "$expected" "$(cat "$STDOUTF")"
 }
 
 function test_die(){
     assertCommandFail die "Test"
-    local expected=$(echo -e "\033[1;31mTest\033[0m")
-    assertEquals "$expected" "$(cat $STDERRF)"
+    local expected
+    expected=$(echo -e "\033[1;31mTest\033[0m")
+    assertEquals "$expected" "$(cat "$STDERRF")"
 }
 
 function test_die_on_status(){
     assertCommandFailOnStatus 222 die_on_status 222 "Test"
-    local expected=$(echo -e "\033[1;31mTest\033[0m")
-    assertEquals "$expected" "$(cat $STDERRF)"
+    local expected
+    expected=$(echo -e "\033[1;31mTest\033[0m")
+    assertEquals "$expected" "$(cat "$STDERRF")"
 }
 
 function test_ask_null_question(){
@@ -79,34 +87,12 @@ function test_ask_wrong_default_answer() {
     assertEquals 33 $?
 }
 
-function test_check_and_trap_fail() {
-    trap echo EXIT
-    trap ls QUIT
-    assertCommandFailOnStatus 1 check_and_trap 'pwd' EXIT QUIT
-}
-
-function test_check_and_trap() {
-    trap - EXIT QUIT
-    assertCommandSuccess check_and_trap 'echo' EXIT QUIT
-}
-
-function test_check_and_force_trap_fail() {
-    trap echo EXIT
-    trap ls QUIT
-    assertCommandSuccess check_and_force_trap 'echo' EXIT QUIT
-}
-
-function test_check_and_force_trap() {
-    trap - EXIT QUIT
-    assertCommandSuccess check_and_force_trap 'echo' EXIT QUIT
-}
-
 function test_insert_quotes_on_spaces(){
     assertCommandSuccess insert_quotes_on_spaces this is "a test"
-    assertEquals "this is \"a test\"" "$(cat $STDOUTF)"
+    assertEquals "this is \"a test\"" "$(cat "$STDOUTF")"
 
     assertCommandSuccess insert_quotes_on_spaces this is 'a test'
-    assertEquals "this is \"a test\"" "$(cat $STDOUTF)"
+    assertEquals "this is \"a test\"" "$(cat "$STDOUTF")"
 }
 
 function test_contains_element(){
@@ -116,4 +102,4 @@ function test_contains_element(){
     assertCommandFailOnStatus 1 contains_element "blabla" "${array[@]}"
 }
 
-source $(dirname $0)/../utils/shunit2
+source "$(dirname "$0")"/../utils/shunit2
diff --git a/tests/unit-tests/test-wrappers.sh b/tests/unit-tests/test-wrappers.sh
index 9daf0f9..af7aae2 100755
--- a/tests/unit-tests/test-wrappers.sh
+++ b/tests/unit-tests/test-wrappers.sh
@@ -1,7 +1,9 @@
 #!/bin/bash
-source "$(dirname $0)/../utils/utils.sh"
+# shellcheck disable=SC1091
 
-source "$(dirname $0)/../../lib/core/wrappers.sh"
+source "$(dirname "$0")/../utils/utils.sh"
+
+source "$(dirname "$0")/../../lib/core/wrappers.sh"
 
 # Disable the exiterr
 set +e
@@ -20,61 +22,61 @@ function tearDown(){
 
 function test_create_wrappers_empty_bin(){
     assertCommandSuccess create_wrappers
-    assertEquals "" "$(cat $STDOUTF)"
+    assertEquals "" "$(cat "$STDOUTF")"
     assertTrue "bin_wrappers does not exist" "[ -e $JUNEST_HOME/usr/bin_wrappers ]"
 }
 
 function test_create_wrappers_not_executable_file(){
-    touch $JUNEST_HOME/usr/bin/myfile
+    touch "$JUNEST_HOME"/usr/bin/myfile
     assertCommandSuccess create_wrappers
-    assertEquals "" "$(cat $STDOUTF)"
+    assertEquals "" "$(cat "$STDOUTF")"
     assertTrue "bin_wrappers should exist" "[ -e $JUNEST_HOME/usr/bin_wrappers ]"
     assertTrue "myfile wrapper should not exist" "[ ! -x $JUNEST_HOME/usr/bin_wrappers/myfile ]"
 }
 
 function test_create_wrappers_executable_file(){
-    touch $JUNEST_HOME/usr/bin/myfile
-    chmod +x $JUNEST_HOME/usr/bin/myfile
+    touch "$JUNEST_HOME"/usr/bin/myfile
+    chmod +x "$JUNEST_HOME"/usr/bin/myfile
     assertCommandSuccess create_wrappers
-    assertEquals "" "$(cat $STDOUTF)"
+    assertEquals "" "$(cat "$STDOUTF")"
     assertTrue "bin_wrappers should exist" "[ -e $JUNEST_HOME/usr/bin_wrappers ]"
     assertTrue "myfile wrapper should exist" "[ -x $JUNEST_HOME/usr/bin_wrappers/myfile ]"
 }
 
 function test_create_wrappers_already_exist(){
-    touch $JUNEST_HOME/usr/bin/myfile
-    chmod +x $JUNEST_HOME/usr/bin/myfile
-    mkdir -p $JUNEST_HOME/usr/bin_wrappers
-    echo "original" > $JUNEST_HOME/usr/bin_wrappers/myfile
-    chmod +x $JUNEST_HOME/usr/bin_wrappers/myfile
+    touch "$JUNEST_HOME"/usr/bin/myfile
+    chmod +x "$JUNEST_HOME"/usr/bin/myfile
+    mkdir -p "$JUNEST_HOME"/usr/bin_wrappers
+    echo "original" > "$JUNEST_HOME"/usr/bin_wrappers/myfile
+    chmod +x "$JUNEST_HOME"/usr/bin_wrappers/myfile
     assertCommandSuccess create_wrappers false
-    assertEquals "" "$(cat $STDOUTF)"
+    assertEquals "" "$(cat "$STDOUTF")"
     assertTrue "bin_wrappers should exist" "[ -e $JUNEST_HOME/usr/bin_wrappers ]"
     assertTrue "myfile wrapper should exist" "[ -x $JUNEST_HOME/usr/bin_wrappers/myfile ]"
-    assertEquals "original" "$(cat $JUNEST_HOME/usr/bin_wrappers/myfile)"
+    assertEquals "original" "$(cat "$JUNEST_HOME"/usr/bin_wrappers/myfile)"
 }
 
 function test_create_wrappers_forced_already_exist(){
-    echo "new" > $JUNEST_HOME/usr/bin/myfile
-    chmod +x $JUNEST_HOME/usr/bin/myfile
-    mkdir -p $JUNEST_HOME/usr/bin_wrappers
-    echo "original" > $JUNEST_HOME/usr/bin_wrappers/myfile
-    chmod +x $JUNEST_HOME/usr/bin_wrappers/myfile
+    echo "new" > "$JUNEST_HOME"/usr/bin/myfile
+    chmod +x "$JUNEST_HOME"/usr/bin/myfile
+    mkdir -p "$JUNEST_HOME"/usr/bin_wrappers
+    echo "original" > "$JUNEST_HOME"/usr/bin_wrappers/myfile
+    chmod +x "$JUNEST_HOME"/usr/bin_wrappers/myfile
     assertCommandSuccess create_wrappers true
-    assertEquals "" "$(cat $STDOUTF)"
+    assertEquals "" "$(cat "$STDOUTF")"
     assertTrue "bin_wrappers should exist" "[ -e $JUNEST_HOME/usr/bin_wrappers ]"
     assertTrue "myfile wrapper should exist" "[ -x $JUNEST_HOME/usr/bin_wrappers/myfile ]"
-    assertNotEquals "original" "$(cat $JUNEST_HOME/usr/bin_wrappers/myfile)"
+    assertNotEquals "original" "$(cat "$JUNEST_HOME"/usr/bin_wrappers/myfile)"
 }
 
 function test_create_wrappers_executable_no_longer_exist(){
-    mkdir -p $JUNEST_HOME/usr/bin_wrappers
-    touch $JUNEST_HOME/usr/bin_wrappers/myfile
-    chmod +x $JUNEST_HOME/usr/bin_wrappers/myfile
+    mkdir -p "$JUNEST_HOME"/usr/bin_wrappers
+    touch "$JUNEST_HOME"/usr/bin_wrappers/myfile
+    chmod +x "$JUNEST_HOME"/usr/bin_wrappers/myfile
     assertCommandSuccess create_wrappers
-    assertEquals "" "$(cat $STDOUTF)"
+    assertEquals "" "$(cat "$STDOUTF")"
     assertTrue "bin_wrappers should exist" "[ -e $JUNEST_HOME/usr/bin_wrappers ]"
     assertTrue "myfile wrapper should not exist" "[ ! -x $JUNEST_HOME/usr/bin_wrappers/myfile ]"
 }
 
-source $(dirname $0)/../utils/shunit2
+source "$(dirname "$0")"/../utils/shunit2
diff --git a/tests/unit-tests/unit-tests.sh b/tests/unit-tests/unit-tests.sh
index acf1bba..e90ed22 100755
--- a/tests/unit-tests/unit-tests.sh
+++ b/tests/unit-tests/unit-tests.sh
@@ -1,6 +1,7 @@
 #!/bin/bash
 tests_succeded=true
-for tst in $(ls $(dirname $0)/test* | grep -v $(basename $0))
+# shellcheck disable=SC2010
+for tst in $(ls "$(dirname "$0")"/test* | grep -v "$(basename "$0")")
 do
     $tst || tests_succeded=false
 done
diff --git a/tests/utils/utils.sh b/tests/utils/utils.sh
index 542af68..ab37bd9 100644
--- a/tests/utils/utils.sh
+++ b/tests/utils/utils.sh
@@ -1,26 +1,28 @@
+#!/usr/bin/env bash
+
 OLD_CWD=${PWD}
 function cwdSetUp(){
     ORIGIN_CWD=$(TMPDIR=/tmp mktemp -d -t junest-cwd.XXXXXXXXXX)
-    cd $ORIGIN_CWD
+    cd "$ORIGIN_CWD" || return 1
 }
 
 function cwdTearDown(){
-    rm -rf $ORIGIN_CWD
-    cd $OLD_CWD
+    rm -rf "$ORIGIN_CWD"
+    cd "$OLD_CWD" || return 1
 }
 
 function junestSetUp(){
     JUNEST_HOME=$(TMPDIR=/tmp mktemp -d -t junest-home.XXXXXXXXXX)
-    mkdir -p ${JUNEST_HOME}/usr/bin
-    mkdir -p ${JUNEST_HOME}/etc/junest
-    echo "JUNEST_ARCH=x86_64" > ${JUNEST_HOME}/etc/junest/info
-    mkdir -p ${JUNEST_HOME}/etc/ca-certificates
+    mkdir -p "${JUNEST_HOME}/usr/bin"
+    mkdir -p "${JUNEST_HOME}/etc/junest"
+    echo "JUNEST_ARCH=x86_64" > "${JUNEST_HOME}/etc/junest/info"
+    mkdir -p "${JUNEST_HOME}/etc/ca-certificates"
 }
 
 function junestTearDown(){
     # the CA directories are read only and can be deleted only by changing the mod
-    [ -d ${JUNEST_HOME}/etc/ca-certificates ] && chmod -R +w ${JUNEST_HOME}/etc/ca-certificates
-    rm -rf $JUNEST_HOME
+    [ -d "${JUNEST_HOME}/etc/ca-certificates" ] && chmod -R +w "${JUNEST_HOME}/etc/ca-certificates"
+    rm -rf "$JUNEST_HOME"
     unset JUNEST_HOME
 }
 
@@ -32,15 +34,17 @@ function setUpUnitTests(){
 }
 
 function assertCommandSuccess(){
+    # shellcheck disable=SC2091
     $(set -e
-      "$@" > $STDOUTF 2> $STDERRF
+      "$@" > "$STDOUTF" 2> "$STDERRF"
     )
     assertTrue "The command $1 did not return 0 exit status" $?
 }
 
 function assertCommandFail(){
+    # shellcheck disable=SC2091
     $(set -e
-      "$@" > $STDOUTF 2> $STDERRF
+      "$@" > "$STDOUTF" 2> "$STDERRF"
     )
     assertFalse "The command $1 returned 0 exit status" $?
 }
@@ -50,8 +54,9 @@ function assertCommandFail(){
 function assertCommandFailOnStatus(){
     local status=$1
     shift
+    # shellcheck disable=SC2091
     $(set -e
-      "$@" > $STDOUTF 2> $STDERRF
+      "$@" > "$STDOUTF" 2> "$STDERRF"
     )
-    assertEquals $status $?
+    assertEquals "$status" $?
 }