Testing Shell Scripts

Testing is an essential part of shell scripting to ensure that your scripts work as expected and handle errors gracefully. In this tutorial, we will cover various techniques and best practices for testing shell scripts effectively.

1. Why Test?

Testing your shell scripts is crucial for several reasons:

Reliability: Ensure scripts work correctly in different environments.
Maintainability: Catch errors early and simplify debugging.
Quality: Improve the overall quality of your scripts.

2. Types of Tests

There are various types of tests you can perform on shell scripts:

Unit Tests: Test individual functions or components.
Integration Tests: Test how different parts of the script work together.
System Tests: Test the script in a complete environment.
Acceptance Tests: Verify the script meets user requirements.

3. Writing Unit Tests

Unit tests focus on testing individual functions or small parts of your script. Use a testing framework like shunit2 or write custom test functions.

Example:

Writing a unit test:

# File: test_math.sh
source ./math.sh

test_add() {
   result=$(add 2 3)
   if [ "$result" -ne 5 ]; then
      echo "test_add failed"
      exit 1
   fi
}

test_add
echo "All tests passed"

4. Using a Testing Framework

Using a testing framework like shunit2 can simplify writing and running tests. It provides a structured way to define and run tests.

Example:

Using shunit2:

# File: test_math.sh
source ./math.sh

testAdd() {
   assertEquals "Addition failed" 5 $(add 2 3)
}

. shunit2

5. Testing Edge Cases

It's important to test edge cases and error conditions to ensure your script handles unexpected input or scenarios gracefully.

Example:

Testing edge cases:

# File: test_string.sh
source ./string_utils.sh

testToUppercase() {
   assertEquals "Empty string failed" "" "$(to_uppercase "")"
   assertEquals "Lowercase to uppercase failed" "HELLO" "$(to_uppercase "hello")"
}

. shunit2

6. Mocking and Stubbing

Mocking and stubbing are techniques used to simulate parts of your script for testing. This is useful for testing functions that rely on external commands or services.

Example:

Mocking a command:

# File: test_network.sh
wget() {
   echo "Mocked wget command"
}

testDownload() {
   result=$(wget http://example.com)
   assertEquals "Download failed" "Mocked wget command" "$result"
}

. shunit2

7. Integration Testing

Integration tests verify that different parts of your script work together as expected. They typically involve running the script in a controlled environment and checking the output.

Example:

Running an integration test:

# File: test_integration.sh
source ./math.sh
source ./string_utils.sh

testIntegration() {
   result=$(to_uppercase $(add 2 3))
   if [ "$result" != "5" ]; then
      echo "Integration test failed"
      exit 1
   fi
}

testIntegration
echo "Integration test passed"

8. Continuous Integration

Continuous Integration (CI) is a practice where code changes are automatically tested. Set up a CI system like Jenkins, Travis CI, or GitHub Actions to automate testing.

Example:

Using GitHub Actions for CI:

# File: .github/workflows/test.yml
name: Shell Script CI

on: [push, pull_request]

jobs:
   test:
      runs-on: ubuntu-latest
      steps:
         - uses: actions/checkout@v2
         - name: Run Tests
            run: ./run_tests.sh

9. Conclusion

Effective testing of shell scripts is crucial for ensuring reliability and maintainability. By writing unit tests, using testing frameworks, testing edge cases, and integrating with CI systems, you can significantly improve the quality of your shell scripts.