name: bash_unit tests
on:


  push:


    branches: [ main ]


  pull_request:


    branches: [ main ]
jobs:


  ubuntu:


    runs-on: ubuntu-latest


    steps:


    - uses: actions/checkout@v4


    - name: Unit testing with bash_unit


      run: |


        curl -s https://raw.githubusercontent.com/pgrange/bash_unit/master/install.sh | bash


        FORCE_COLOR=true ./bash_unit tests/test_*

test:


  image: debian


  script:


    - apt-get update


    - apt-get install --no-install-recommends -y curl ca-certificates


    - curl -s https://raw.githubusercontent.com/pgrange/bash_unit/master/install.sh | bash


    - FORCE_COLOR=true ./bash_unit tests/test_*

repos:


  - repo: https://github.com/pgrange/bash_unit


    rev: v2.2.0


    hooks:


      - id: bash-unit


        always-run: true

fail [message]

test_can_fail() {


  fail "this test failed on purpose"
}

        Running test_can_fail ... FAILURE
this test failed on purpose
doc:2:test_can_fail()

assert <assertion> [message]

test_assert_fails() {


  assert false "this test failed, obviously"
}
test_assert_succeed() {


  assert true
}

        Running test_assert_fails ... FAILURE
this test failed, obviously
doc:2:test_assert_fails()


        Running test_assert_succeed ... SUCCESS

code() {


  touch /tmp/the_file
}
test_code_creates_the_file() {


  code


  assert "test -e /tmp/the_file"
}
test_code_makes_the_file_executable() {


  code


  assert "test -x /tmp/the_file" "/tmp/the_file should be executable"
}

        Running test_code_creates_the_file ... SUCCESS


        Running test_code_makes_the_file_executable ... FAILURE
/tmp/the_file should be executable
doc:14:test_code_makes_the_file_executable()

code() {


  echo 'not so cool' > /tmp/the_file
}
test_code_write_appropriate_content_in_the_file() {


  code


  assert "diff <(echo 'this is cool') /tmp/the_file"
}

        Running test_code_write_appropriate_content_in_the_file ... FAILURE
out> 1c1
out> < this is cool
out> ---
out> > not so cool
doc:8:test_code_write_appropriate_content_in_the_file()

assert_fail <assertion> [message]

code() {


  echo 'not so cool' > /tmp/the_file
}
test_code_does_not_write_cool_in_the_file() {


  code


  assert_fails "grep cool /tmp/the_file" "should not write 'cool' in /tmp/the_file"
}
test_code_does_not_write_this_in_the_file() {


  code


  assert_fails "grep this /tmp/the_file" "should not write 'this' in /tmp/the_file"
}

        Running test_code_does_not_write_cool_in_the_file ... FAILURE
should not write 'cool' in /tmp/the_file
out> not so cool
doc:8:test_code_does_not_write_cool_in_the_file()


        Running test_code_does_not_write_this_in_the_file ... SUCCESS

assert_status_code <expected_status_code> <assertion> [message]

code() {


  exit 23
}
test_code_should_fail_with_code_25() {


  assert_status_code 25 code
}

        Running test_code_should_fail_with_code_25 ... FAILURE


 expected status code 25 but was 23
doc:6:test_code_should_fail_with_code_25()

assert_equals <expected> <actual> [message]

test_obvious_inequality_with_assert_equals(){


  assert_equals "a string" "another string" "a string should be another string"
}
test_obvious_equality_with_assert_equals(){


  assert_equals a a
}

        Running test_obvious_equality_with_assert_equals ... SUCCESS


        Running test_obvious_inequality_with_assert_equals ... FAILURE
a string should be another string


 expected [a string] but was [another string]
doc:2:test_obvious_inequality_with_assert_equals()

assert_not_equals <unexpected> <actual> [message]

test_obvious_equality_with_assert_not_equals(){


  assert_not_equals "a string" "a string" "a string should be different from another string"
}
test_obvious_inequality_with_assert_not_equals(){


  assert_not_equals a b
}

        Running test_obvious_equality_with_assert_not_equals ... FAILURE
a string should be different from another string


 expected different value than [a string] but was the same
doc:2:test_obvious_equality_with_assert_not_equals()


        Running test_obvious_inequality_with_assert_not_equals ... SUCCESS

assert_matches <expected-regex> <actual> [message]

test_obvious_notmatching_with_assert_matches(){


  assert_matches "a str.*" "another string" "'another string' should not match 'a str.*'"
}
test_obvious_matching_with_assert_matches(){


  assert_matches "a[nN].t{0,1}.*r str.*" "another string"
}

        Running test_obvious_matching_with_assert_matches ... SUCCESS


        Running test_obvious_notmatching_with_assert_matches ... FAILURE
'another string' should not match 'a str.*'


 expected regex [a str.*] to match [another string]
doc:2:test_obvious_notmatching_with_assert_matches()

assert_not_matches <unexpected-regex> <actual> [message]

test_obvious_matching_with_assert_not_matches(){


  assert_not_matches "a str.*" "a string" "'a string' should not match 'a str.*'"
}
test_obvious_notmatching_with_assert_not_matches(){


  assert_not_matches "a str.*" "another string"
}

        Running test_obvious_matching_with_assert_not_matches ... FAILURE
'a string' should not match 'a str.*'


 expected regex [a str.*] should not match but matched [a string]
doc:2:test_obvious_matching_with_assert_not_matches()


        Running test_obvious_notmatching_with_assert_not_matches ... SUCCESS

assert_within_delta <expected num> <actual num> <max delta> [message]

test_matches_within_delta(){


  assert_within_delta 5 3 2


  assert_within_delta 5 4 2


  assert_within_delta 5 5 2


  assert_within_delta 5 6 2


  assert_within_delta 5 7 2
}
test_does_not_match_within_delta(){


  assert_within_delta 5 2 2
}

        Running test_does_not_match_within_delta ... FAILURE


 expected value [5] to match [2] with a maximum delta of [2]
doc:9:test_does_not_match_within_delta()


        Running test_matches_within_delta ... SUCCESS

assert_no_diff <expected> <actual> [message]

test_obvious_notmatching_with_assert_no_diff(){


  assert_no_diff <(echo foo) <(echo bar)
}
test_obvious_matching_with_assert_assert_no_diff(){


  assert_no_diff bash_unit bash_unit
}

        Running test_obvious_matching_with_assert_assert_no_diff ... SUCCESS


        Running test_obvious_notmatching_with_assert_no_diff ... FAILURE


 expected 'doc' to be identical to 'doc' but was different
out> 1c1
out> < foo
out> ---
out> > bar
doc:2:test_obvious_notmatching_with_assert_no_diff()

code() {


  ps a | grep apache
}
test_code_succeeds_if_apache_runs() {


  fake ps <<EOF


  PID TTY          TIME CMD
13525 pts/7    00:00:01 bash
24162 pts/7    00:00:00 ps


 8387 ?            0:00 /usr/sbin/apache2 -k start
EOF


  assert code "code should succeed when apache is running"
}
test_code_fails_if_apache_does_not_run() {


  fake ps <<EOF


  PID TTY          TIME CMD
13525 pts/7    00:00:01 bash
24162 pts/7    00:00:00 ps
EOF


  assert_fails code "code should fail when apache is not running"
}

        Running test_code_fails_if_apache_does_not_run ... SUCCESS


        Running test_code_succeeds_if_apache_runs ... SUCCESS

fake ps echo hello world
ps

hello world

_ps() {


  echo hello world
}
fake ps _ps
ps

hello world

_ps() {


  echo hello world
}
fake ps _ps
bash -c ps

environment: line 1: _ps: command not found

_ps() {


  echo hello world
}
export -f _ps
fake ps _ps
bash -c ps

hello world

code() {


  ps a | grep apache
}
test_code_gives_ps_appropriate_parameters() {


  _ps() {


    cat <<EOF


  PID TTY          TIME CMD
13525 pts/7    00:00:01 bash
24162 pts/7    00:00:00 ps


 8387 ?            0:00 /usr/sbin/apache2 -k start
EOF


    assert_equals ax "${FAKE_PARAMS[@]}"


  }


  export -f _ps


  fake ps _ps


  code >/dev/null
}

        Running test_code_gives_ps_appropriate_parameters ... SUCCESS

code() {


  ps a | grep apache
}

code() {


  ps a | grep apache
}
test_code_gives_ps_appropriate_parameters() {


  _ps() {


    assert_equals ax "${FAKE_PARAMS[@]}"


  }


  export -f _ps


  fake ps _ps


  code >/dev/null
}

        Running test_code_gives_ps_appropriate_parameters ...

code() {


  ps a | grep apache
}
test_code_gives_ps_appropriate_parameters() {


  _ps() {


    echo ${FAKE_PARAMS[@]} > /tmp/fake_params


  }


  export -f _ps


  fake ps _ps


  code || true


  assert_equals ax "$(head -n1 /tmp/fake_params)"
}
setup() {


  rm -f /tmp/fake_params
}

        Running test_code_gives_ps_appropriate_parameters ... FAILURE


 expected [ax] but was [a]
doc:14:test_code_gives_ps_appropriate_parameters()

code() {


  ps a | grep apache
}
test_code_gives_ps_appropriate_parameters() {


  fake ps 'echo ${FAKE_PARAMS[@]} >/tmp/fake_params'


  code || true


  assert_equals ax "$(head -n1 /tmp/fake_params)"
}
setup() {


  rm -f /tmp/fake_params
}

        Running test_code_gives_ps_appropriate_parameters ... FAILURE


 expected [ax] but was [a]
doc:10:test_code_gives_ps_appropriate_parameters()

code() {


  ps a | grep apache
}
test_get_data_from_fake() {


  #Fasten you seat belt ...


  coproc cat


  exec {test_channel}>&${COPROC[1]}


  fake ps 'echo ${FAKE_PARAMS[@]} >&$test_channel'


  code || true


  assert_equals ax "$(head -n1 <&${COPROC[0]})"
}

        Running test_get_data_from_fake ... FAILURE


 expected [ax] but was [a]
doc:13:test_get_data_from_fake()