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

test_can_fail() {
  fail "this test failed on purpose"
}

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

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()

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

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()

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()

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

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()

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

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

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
}

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()