Mirrors/junest
1
0
Fork 0
mirror of https://github.com/fsquillace/junest.git synced 2026-01-23 02:34:30 +00:00
Code Issues Projects Releases Wiki Activity

Add option to specify location of backend command

Browse source
This commit is contained in:
Filippo Squillace 2020-03-27 18:39:58 +01:00
parent 348b73ce73
commit 09b9c644d9
8 changed files with 273 additions and 148 deletions
Download patch file Download diff file Expand all files Collapse all files

22
bin/junest
View file

@ -39,22 +39,27 @@ usage() {
echo -e " -d, --delete Delete $NAME from ${JUNEST_HOME}"
echo
echo -e " n[s] Access via Linux Namespaces using BubbleWrap (Default action)"
echo -e " -f, --fakeroot Run $NAME with fakeroot privileges"
echo -e " --backend-command <cmd> Bwrap command to use"
echo -e " -b, --backend-args <args> Arguments for bwrap backend program"
echo -e " ($CMD ns -b \"--help\" to check out the bwrap options)"
echo -e " -n, --no-copy-files Do not copy common etc files into $NAME environment"
echo
echo -e " p[root] Access via PRoot"
echo -e " -f, --fakeroot Run $NAME with fakeroot privileges"
echo -e " --backend-command <cmd> PRoot command to use"
echo -e " -b, --backend-args <args> Arguments for PRoot backend program"
echo -e " ($CMD proot -b \"--help\" to check out the PRoot options)"
echo -e " -n, --no-copy-files Do not copy common etc files into $NAME environment"
echo
echo -e " g[root] Access with root privileges via GRoot"
echo -e " --backend-command <cmd> GRoot command to use"
echo -e " -b, --backend-args <args> Arguments for GRoot backend program"
echo -e " ($CMD groot -b \"--help\" to check out the GRoot options)"
echo -e " -n, --no-copy-files Do not copy common etc files into $NAME environment"
echo
echo -e " r[oot] Access with root privileges via classic chroot"
echo -e " --backend-command <cmd> Chroot command to use"
echo -e " -b, --backend-args <args> Arguments for chroot backend program"
echo -e " ($CMD root -b \"--help\" to check out the chroot options)"
echo -e " -n, --no-copy-files Do not copy common etc files into $NAME environment"
@ -114,15 +119,16 @@ function parse_arguments(){
function _parse_root_opts() {
# Options:
OPT_BACKEND_ARGS=false
BACKEND_ARGS=""
OPT_NO_COPY_FILES=false
BACKEND_COMMAND=""
while [[ -n "$1" ]]
do
case "$1" in
-b|--backend-args) OPT_BACKEND_ARGS=true ; shift ; BACKEND_ARGS=$1; shift ;;
-b|--backend-args) shift ; BACKEND_ARGS=$1; shift ;;
-n|--no-copy-files) OPT_NO_COPY_FILES=true ; shift ;;
--backend-command) shift; BACKEND_COMMAND="$1"; shift ;;
--) shift ; break ;;
-*) die "Invalid option $1" ;;
*) break ;;
@ -139,16 +145,17 @@ function _parse_root_opts() {
function _parse_ns_opts() {
# Options:
OPT_FAKEROOT=false
OPT_BACKEND_ARGS=false
BACKEND_ARGS=""
OPT_NO_COPY_FILES=false
BACKEND_COMMAND=""
while [[ -n "$1" ]]
do
case "$1" in
-f|--fakeroot) OPT_FAKEROOT=true ; shift ;;
-b|--backend-args) OPT_BACKEND_ARGS=true ; shift ; BACKEND_ARGS=$1; shift ;;
-b|--backend-args) shift ; BACKEND_ARGS=$1; shift ;;
-n|--no-copy-files) OPT_NO_COPY_FILES=true ; shift ;;
--backend-command) shift; BACKEND_COMMAND="$1"; shift ;;
--) shift ; break ;;
-*) die "Invalid option $1" ;;
*) break ;;
@ -165,16 +172,17 @@ function _parse_ns_opts() {
function _parse_proot_opts() {
# Options:
OPT_FAKEROOT=false
OPT_BACKEND_ARGS=false
BACKEND_ARGS=""
OPT_NO_COPY_FILES=false
BACKEND_COMMAND=""
while [[ -n "$1" ]]
do
case "$1" in
-f|--fakeroot) OPT_FAKEROOT=true ; shift ;;
-b|--backend-args) OPT_BACKEND_ARGS=true ; shift ; BACKEND_ARGS=$1; shift ;;
-b|--backend-args) shift ; BACKEND_ARGS=$1; shift ;;
-n|--no-copy-files) OPT_NO_COPY_FILES=true ; shift ;;
--backend-command) shift; BACKEND_COMMAND="$1"; shift ;;
--) shift ; break ;;
-*) die "Invalid option $1" ;;
*) break ;;
@ -269,7 +277,7 @@ function execute_operation() {
run_env=run_env_as_chroot
fi
$run_env "${BACKEND_ARGS}" $OPT_NO_COPY_FILES "${ARGS[@]}"
$run_env "$BACKEND_COMMAND" "${BACKEND_ARGS}" $OPT_NO_COPY_FILES "${ARGS[@]}"
}

22
lib/core/chroot.sh
View file

@ -58,15 +58,18 @@ function _run_env_as_xroot(){
function run_env_as_groot(){
check_nested_env
local backend_args="$1"
local no_copy_files="$2"
shift 2
local backend_command="$1"
local backend_args="$2"
local no_copy_files="$3"
shift 3
[[ -z "$backend_command" ]] && backend_command="$GROOT"
provide_common_bindings
local bindings=${RESULT}
unset RESULT
_run_env_as_xroot "$GROOT $bindings" "$backend_args" "$no_copy_files" "$@"
_run_env_as_xroot "$backend_command $bindings" "$backend_args" "$no_copy_files" "$@"
}
#######################################
@ -92,9 +95,12 @@ function run_env_as_groot(){
function run_env_as_chroot(){
check_nested_env
local backend_args="$1"
local no_copy_files="$2"
shift 2
local backend_command="$1"
local backend_args="$2"
local no_copy_files="$3"
shift 3
_run_env_as_xroot chroot_cmd "$backend_args" "$no_copy_files" "$@"
[[ -z "$backend_command" ]] && backend_command=chroot_cmd
_run_env_as_xroot "$backend_command" "$backend_args" "$no_copy_files" "$@"
}

29
lib/core/namespace.sh
View file

@ -56,14 +56,17 @@ function _check_user_namespace() {
}
function _run_env_with_bwrap(){
local backend_args="$1"
shift
local backend_command="$1"
local backend_args="$2"
shift 2
[[ -z "$backend_command" ]] && backend_command=bwrap_cmd
if [[ "$1" != "" ]]
then
JUNEST_ENV=1 bwrap_cmd --bind "$JUNEST_HOME" / --bind "$HOME" "$HOME" --bind /tmp /tmp --proc /proc --dev /dev --unshare-user-try ${backend_args} "${SH[@]}" "-c" "$(insert_quotes_on_spaces "${@}")"
JUNEST_ENV=1 "$backend_command" --bind "$JUNEST_HOME" / --bind "$HOME" "$HOME" --bind /tmp /tmp --proc /proc --dev /dev --unshare-user-try ${backend_args} "${SH[@]}" "-c" "$(insert_quotes_on_spaces "${@}")"
else
JUNEST_ENV=1 bwrap_cmd --bind "$JUNEST_HOME" / --bind "$HOME" "$HOME" --bind /tmp /tmp --proc /proc --dev /dev --unshare-user-try ${backend_args} "${SH[@]}"
JUNEST_ENV=1 "$backend_command" --bind "$JUNEST_HOME" / --bind "$HOME" "$HOME" --bind /tmp /tmp --proc /proc --dev /dev --unshare-user-try ${backend_args} "${SH[@]}"
fi
}
@ -89,9 +92,10 @@ function _run_env_with_bwrap(){
function run_env_as_bwrap_fakeroot(){
check_nested_env
local backend_args="$1"
local no_copy_files="$2"
shift 2
local backend_command="$1"
local backend_args="$2"
local no_copy_files="$3"
shift 3
_check_user_namespace
@ -102,7 +106,7 @@ function run_env_as_bwrap_fakeroot(){
copy_common_files
fi
_run_env_with_bwrap "--uid 0 $backend_args" "$@"
_run_env_with_bwrap "$backend_command" "--uid 0 $backend_args" "$@"
}
@ -126,9 +130,10 @@ function run_env_as_bwrap_fakeroot(){
function run_env_as_bwrap_user() {
check_nested_env
local backend_args="$1"
local no_copy_files="$2"
shift 2
local backend_command="$1"
local backend_args="$2"
local no_copy_files="$3"
shift 3
_check_user_namespace
@ -145,7 +150,7 @@ function run_env_as_bwrap_user() {
copy_passwd_and_group
fi
_run_env_with_bwrap "$backend_args" "$@"
_run_env_with_bwrap "$backend_command" "$backend_args" "$@"
}

40
lib/core/proot.sh
View file

@ -9,19 +9,25 @@
# vim: ft=sh
function _run_env_with_proot(){
local proot_args="$1"
shift
local backend_command="$1"
local backend_args="$2"
shift 2
[[ -z "$backend_command" ]] && backend_command=proot_cmd
if [ "$1" != "" ]
then
JUNEST_ENV=1 proot_cmd "${proot_args}" "${SH[@]}" "-c" "$(insert_quotes_on_spaces "${@}")"
JUNEST_ENV=1 "${backend_command}" "${backend_args}" "${SH[@]}" "-c" "$(insert_quotes_on_spaces "${@}")"
else
JUNEST_ENV=1 proot_cmd "${proot_args}" "${SH[@]}"
JUNEST_ENV=1 "${backend_command}" "${backend_args}" "${SH[@]}"
fi
}
function _run_env_with_qemu(){
local proot_args="$1"
local backend_command="$1"
local backend_args="$2"
shift 2
source ${JUNEST_HOME}/etc/junest/info
if [ "$JUNEST_ARCH" != "$ARCH" ]
@ -34,10 +40,10 @@ function _run_env_with_qemu(){
warn "Emulating $NAME via QEMU..."
[ -e ${qemu_symlink} ] || \
ln_cmd -s ${JUNEST_HOME}/bin/${qemu_bin} ${qemu_symlink}
proot_args="-q ${qemu_symlink} $proot_args"
backend_args="-q ${qemu_symlink} $backend_args"
fi
shift
_run_env_with_proot "$proot_args" "${@}"
_run_env_with_proot "$backend_args" "${@}"
}
#######################################
@ -63,9 +69,10 @@ function run_env_as_proot_fakeroot(){
die_on_status $ROOT_ACCESS_ERROR "You cannot access with root privileges. Use --groot option instead."
check_nested_env
local backend_args="$1"
local no_copy_files="$2"
shift 2
local backend_command="$1"
local backend_args="$2"
local no_copy_files="$3"
shift 3
if ! $no_copy_files
then
@ -78,7 +85,7 @@ function run_env_as_proot_fakeroot(){
# An alternative is via -S option:
#_run_env_with_qemu "-S ${JUNEST_HOME} $1" "${@:2}"
_run_env_with_qemu "-0 ${bindings} -r ${JUNEST_HOME} $backend_args" "$@"
_run_env_with_qemu "$backend_command" "-0 ${bindings} -r ${JUNEST_HOME} $backend_args" "$@"
}
#######################################
@ -104,9 +111,10 @@ function run_env_as_proot_user(){
die_on_status $ROOT_ACCESS_ERROR "You cannot access with root privileges. Use --groot option instead."
check_nested_env
local backend_args="$1"
local no_copy_files="$2"
shift 2
local backend_command="$1"
local backend_args="$2"
local no_copy_files="$3"
shift 3
if ! $no_copy_files
then
@ -127,5 +135,5 @@ function run_env_as_proot_user(){
local bindings=${RESULT}
unset RESULT
_run_env_with_qemu "${bindings} -r ${JUNEST_HOME} $backend_args" "$@"
_run_env_with_qemu "$backend_command" "${bindings} -r ${JUNEST_HOME} $backend_args" "$@"
}

33
tests/unit-tests/test-chroot.sh
View file

@ -32,20 +32,28 @@ function init_mocks() {
echo "chroot_cmd $@"
}
GROOT=chroot_cmd
mychroot() {
echo mychroot $@
}
}
function test_run_env_as_groot_cmd(){
assertCommandSuccess run_env_as_groot "" "false" pwd
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)"
}
function test_run_env_as_groot_no_cmd(){
assertCommandSuccess run_env_as_groot "" "false" ""
assertCommandSuccess run_env_as_groot "" "" "false" ""
assertEquals "chroot_cmd -b $HOME -b /tmp -b /proc -b /sys -b /dev $JUNEST_HOME /bin/sh --login -c /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 -c /bin/sh --login" "$(cat $STDOUTF)"
}
function test_run_env_as_groot_no_copy(){
assertCommandSuccess run_env_as_groot "" "true" pwd
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)"
[[ ! -e ${JUNEST_HOME}/etc/hosts ]]
@ -60,27 +68,32 @@ function test_run_env_as_groot_no_copy(){
function test_run_env_as_groot_nested_env(){
JUNEST_ENV=1
assertCommandFailOnStatus 106 run_env_as_groot "" "false" ""
assertCommandFailOnStatus 106 run_env_as_groot "" "" "false" ""
unset JUNEST_ENV
}
function test_run_env_as_groot_cmd_with_backend_args(){
assertCommandSuccess run_env_as_groot "-n -b /home/blah" "false" pwd
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)"
}
function test_run_env_as_chroot_cmd(){
assertCommandSuccess run_env_as_chroot "" "false" pwd
assertCommandSuccess run_env_as_chroot "" "" "false" pwd
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" ""
assertCommandSuccess run_env_as_chroot "" "" "false" ""
assertEquals "chroot_cmd $JUNEST_HOME /bin/sh --login -c /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 -c /bin/sh --login" "$(cat $STDOUTF)"
}
function test_run_env_as_chroot_no_copy(){
assertCommandSuccess run_env_as_chroot "" "true" pwd
assertCommandSuccess run_env_as_chroot "" "" "true" pwd
assertEquals "chroot_cmd $JUNEST_HOME /bin/sh --login -c pwd" "$(cat $STDOUTF)"
[[ ! -e ${JUNEST_HOME}/etc/hosts ]]
@ -95,12 +108,12 @@ function test_run_env_as_chroot_no_copy(){
function test_run_env_as_choot_nested_env(){
JUNEST_ENV=1
assertCommandFailOnStatus 106 run_env_as_chroot "" "false" ""
assertCommandFailOnStatus 106 run_env_as_chroot "" "" "false" ""
unset JUNEST_ENV
}
function test_run_env_as_chroot_cmd_with_backend_args(){
assertCommandSuccess run_env_as_chroot "-n -b /home/blah" "false" pwd
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)"
}

182
tests/unit-tests/test-junest.sh
View file

@ -38,40 +38,46 @@ function setup_env(){
echo "setup_env($1)"
}
function run_env_as_proot_fakeroot(){
local backend_args="$1"
local no_copy_files="$2"
shift 2
echo "run_env_as_proot_fakeroot($backend_args,$no_copy_files,$@)"
local backend_command="$1"
local backend_args="$2"
local no_copy_files="$3"
shift 3
echo "run_env_as_proot_fakeroot($backend_command,$backend_args,$no_copy_files,$@)"
}
function run_env_as_groot(){
local backend_args="$1"
local no_copy_files="$2"
shift 2
echo "run_env_as_groot($backend_args,$no_copy_files,$@)"
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,$@)"
}
function run_env_as_chroot(){
local backend_args="$1"
local no_copy_files="$2"
shift 2
echo "run_env_as_chroot($backend_args,$no_copy_files,$@)"
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,$@)"
}
function run_env_as_proot_user(){
local backend_args="$1"
local no_copy_files="$2"
shift 2
echo "run_env_as_proot_user($backend_args,$no_copy_files,$@)"
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,$@)"
}
function run_env_as_bwrap_fakeroot(){
local backend_args="$1"
local no_copy_files="$2"
shift 2
echo "run_env_as_bwrap_fakeroot($backend_args,$no_copy_files,$@)"
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,$@)"
}
function run_env_as_bwrap_user(){
local backend_args="$1"
local no_copy_files="$2"
shift 2
echo "run_env_as_bwrap_user($backend_args,$no_copy_files,$@)"
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,$@)"
}
function test_help(){
@ -139,20 +145,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)"
assertCommandSuccess main proot -f --backend-command blah
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
@ -162,18 +173,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)"
assertCommandSuccess main proot --backend-command blah
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
@ -183,15 +199,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)"
assertCommandSuccess main groot --backend-command blah
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
@ -201,13 +223,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)"
assertCommandSuccess main root --backend-command blah
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
@ -217,34 +245,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)"
assertCommandSuccess main -f --backend-command blah
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
@ -254,34 +287,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)"
assertCommandSuccess main --backend-command blah
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

42
tests/unit-tests/test-namespace.sh
View file

@ -18,6 +18,9 @@ function init_mocks() {
function bwrap_cmd(){
echo "bwrap $@"
}
function mybwrap(){
echo "mybwrap $@"
}
}
function setUp(){
@ -100,22 +103,37 @@ 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"
assertCommandSuccess run_env_as_bwrap_fakeroot "" "" "false"
assertEquals "bwrap --bind $JUNEST_HOME / --bind $HOME $HOME --bind /tmp /tmp --proc /proc --dev /dev --unshare-user-try --uid 0 /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 --bind $JUNEST_HOME / --bind $HOME $HOME --bind /tmp /tmp --proc /proc --dev /dev --unshare-user-try --uid 0 /bin/sh --login" "$(cat $STDOUTF)"
_test_copy_common_files
}
function test_run_env_as_bwrap_user() {
assertCommandSuccess run_env_as_bwrap_user "" "false"
assertCommandSuccess run_env_as_bwrap_user "" "" "false"
assertEquals "bwrap --bind $JUNEST_HOME / --bind $HOME $HOME --bind /tmp /tmp --proc /proc --dev /dev --unshare-user-try /bin/sh --login" "$(cat $STDOUTF)"
_test_copy_common_files
_test_copy_remaining_files
}
function test_run_env_as_bwrap_user_with_backend_command() {
assertCommandSuccess run_env_as_bwrap_user "mybwrap" "" "false"
assertEquals "mybwrap --bind $JUNEST_HOME / --bind $HOME $HOME --bind /tmp /tmp --proc /proc --dev /dev --unshare-user-try /bin/sh --login" "$(cat $STDOUTF)"
_test_copy_common_files
_test_copy_remaining_files
}
function test_run_env_as_bwrap_fakeroot_no_copy() {
assertCommandSuccess run_env_as_bwrap_fakeroot "" "true" ""
assertCommandSuccess run_env_as_bwrap_fakeroot "" "" "true" ""
assertEquals "bwrap --bind $JUNEST_HOME / --bind $HOME $HOME --bind /tmp /tmp --proc /proc --dev /dev --unshare-user-try --uid 0 /bin/sh --login" "$(cat $STDOUTF)"
[[ ! -e ${JUNEST_HOME}/etc/hosts ]]
@ -141,7 +159,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" ""
assertCommandSuccess run_env_as_bwrap_user "" "" "true" ""
assertEquals "bwrap --bind $JUNEST_HOME / --bind $HOME $HOME --bind /tmp /tmp --proc /proc --dev /dev --unshare-user-try /bin/sh --login" "$(cat $STDOUTF)"
[[ ! -e ${JUNEST_HOME}/etc/hosts ]]
@ -167,14 +185,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"
assertCommandSuccess run_env_as_bwrap_fakeroot "" "--bind /usr /usr" "false"
assertEquals "bwrap --bind $JUNEST_HOME / --bind $HOME $HOME --bind /tmp /tmp --proc /proc --dev /dev --unshare-user-try --uid 0 --bind /usr /usr /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"
assertCommandSuccess run_env_as_bwrap_user "" "--bind /usr /usr" "false"
assertEquals "bwrap --bind $JUNEST_HOME / --bind $HOME $HOME --bind /tmp /tmp --proc /proc --dev /dev --unshare-user-try --bind /usr /usr /bin/sh --login" "$(cat $STDOUTF)"
_test_copy_common_files
@ -182,14 +200,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"
assertCommandSuccess run_env_as_bwrap_fakeroot "" "" "false" "ls -la"
assertEquals "bwrap --bind $JUNEST_HOME / --bind $HOME $HOME --bind /tmp /tmp --proc /proc --dev /dev --unshare-user-try --uid 0 /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"
assertCommandSuccess run_env_as_bwrap_user "" "" "false" "ls -la"
assertEquals "bwrap --bind $JUNEST_HOME / --bind $HOME $HOME --bind /tmp /tmp --proc /proc --dev /dev --unshare-user-try /bin/sh --login -c \"ls -la\"" "$(cat $STDOUTF)"
_test_copy_common_files
@ -197,14 +215,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"
assertCommandSuccess run_env_as_bwrap_fakeroot "" "--bind /usr /usr" "false" "ls -la"
assertEquals "bwrap --bind $JUNEST_HOME / --bind $HOME $HOME --bind /tmp /tmp --proc /proc --dev /dev --unshare-user-try --uid 0 --bind /usr /usr /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"
assertCommandSuccess run_env_as_bwrap_user "" "--bind /usr /usr" "false" "ls -la"
assertEquals "bwrap --bind $JUNEST_HOME / --bind $HOME $HOME --bind /tmp /tmp --proc /proc --dev /dev --unshare-user-try --bind /usr /usr /bin/sh --login -c \"ls -la\"" "$(cat $STDOUTF)"
_test_copy_common_files
@ -213,13 +231,13 @@ function test_run_env_as_bwrap_user_with_backend_args_and_command() {
function test_run_env_as_bwrap_fakeroot_nested_env(){
JUNEST_ENV=1
assertCommandFailOnStatus 106 run_env_as_bwrap_fakeroot "" "false" ""
assertCommandFailOnStatus 106 run_env_as_bwrap_fakeroot "" "" "false" ""
unset JUNEST_ENV
}
function test_run_env_as_bwrap_user_nested_env(){
JUNEST_ENV=1
assertCommandFailOnStatus 106 run_env_as_bwrap_user "" "false" ""
assertCommandFailOnStatus 106 run_env_as_bwrap_user "" "" "false" ""
unset JUNEST_ENV
}

51
tests/unit-tests/test-proot.sh
View file

@ -51,22 +51,37 @@ function test_run_env_as_proot_user(){
_run_env_with_qemu() {
echo $@
}
assertCommandSuccess run_env_as_proot_user "-k 3.10" "false" "/usr/bin/mkdir" "-v" "/newdir2"
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)"
SH=("/usr/bin/echo")
assertCommandSuccess run_env_as_proot_user "-k 3.10" "false"
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)"
_test_copy_common_files
_test_copy_remaining_files
}
function test_run_env_as_proot_user_with_backend_command(){
_run_env_with_qemu() {
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)"
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)"
_test_copy_common_files
_test_copy_remaining_files
}
function test_run_env_as_proot_user_no_copy(){
_run_env_with_qemu() {
echo $@
}
assertCommandSuccess run_env_as_proot_user "-k 3.10" "true" "/usr/bin/mkdir" "-v" "/newdir2"
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)"
[[ ! -e ${JUNEST_HOME}/etc/hosts ]]
@ -93,7 +108,7 @@ function test_run_env_as_proot_user_no_copy(){
function test_run_env_as_proot_user_nested_env(){
JUNEST_ENV=1
assertCommandFailOnStatus 106 run_env_as_proot_user "" "false"
assertCommandFailOnStatus 106 run_env_as_proot_user "" "" "false"
unset JUNEST_ENV
}
@ -101,19 +116,33 @@ function test_run_env_as_proot_fakeroot(){
_run_env_with_qemu() {
echo $@
}
assertCommandSuccess run_env_as_proot_fakeroot "-k 3.10" "false" "/usr/bin/mkdir" "-v" "/newdir2"
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)"
SH=("/usr/bin/echo")
assertCommandSuccess run_env_as_proot_fakeroot "-k 3.10" "false"
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)"
_test_copy_common_files
}
function test_run_env_as_proot_fakeroot_with_backend_command(){
_run_env_with_qemu() {
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)"
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)"
_test_copy_common_files
}
function test_run_env_as_proot_fakeroot_nested_env(){
JUNEST_ENV=1
assertCommandFailOnStatus 106 run_env_as_proot_fakeroot "" "false" ""
assertCommandFailOnStatus 106 run_env_as_proot_fakeroot "" "" "false" ""
unset JUNEST_ENV
}
@ -121,7 +150,7 @@ function test_run_env_with_quotes(){
_run_env_with_qemu() {
echo $@
}
assertCommandSuccess run_env_as_proot_user "-k 3.10" "false" "bash" "-c" "/usr/bin/mkdir -v /newdir2"
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)"
}
@ -131,10 +160,10 @@ function test_run_env_with_proot_args(){
echo $@
}
assertCommandSuccess _run_env_with_proot --help
assertCommandSuccess _run_env_with_proot "" "--help"
assertEquals "--help /bin/sh --login" "$(cat $STDOUTF)"
assertCommandSuccess _run_env_with_proot --help mycommand
assertCommandSuccess _run_env_with_proot "" "--help" mycommand
assertEquals "--help /bin/sh --login -c mycommand" "$(cat $STDOUTF)"
assertCommandFail _run_env_with_proot
@ -152,7 +181,7 @@ function test_qemu() {
echo $@
}
RANDOM=100 ARCH=x86_64 assertCommandSuccess _run_env_with_qemu ""
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)"
}