run

#!/bin/bash
#
# The 'run' script performs simple tests that verifies usability
# of the image
#
# IMAGE_NAME specifies a name of the candidate image used for testing.
# The image has to be available before this script is executed. It may be a
# short image name such as 'foobar', or it may be a fully qualified name in the
# form of example.com/project/repository/image@sha256:hashinhex
#
# OPENSHIFT_ONLY environment variable, if 'true', only tests features used by
# OpenShift's try-it feature.
#
# TEST_PORT specifies the port on the docker host to be used for testing.
# The container application will still use 8080, but this port will be bound
# to the running container when testing asp.net projects.
#
# DEBUG environment variable, if not empty, makes 'run' to log every step
# of testing.
#
# STOP_ON_ERROR determines if the tests should exit on encountering
# the first error, or keep going and list all failed tests at the end.
# Defaults to 'true', can be set to 'false'.
#
# SKIP_VERSION_CHECK environment variable, if 'true', versions are not checked.
#
# Example usage: $ sudo ./test/run


STOP_ON_ERROR=${STOP_ON_ERROR:-true}

IMAGE_OS=${IMAGE_OS:-RHEL8}

IMAGE_NAME=${IMAGE_NAME:-localhost/ubi9/dotnet-100}
# Infer runtime image from SDK image when it is not explicitly set
OPENSHIFT_ONLY=${OPENSHIFT_ONLY:-false}

test_dir="$(readlink -f "$(dirname "${BASH_SOURCE[0]}")")"
source "${test_dir}/testcommon"

dotnet_version_series="10.0"

sample_app_url="https://github.com/redhat-developer/s2i-dotnetcore-ex.git"

s2i_build_and_run() {
  local app="$1"

  local image=$(s2i_build ${app})
  local output=$(docker_run ${image})
  docker_rmi ${image}

  echo "$output"
}

test_s2i_usage_projfile()
{
  # startup_project_not_found contains two project files
  # but doesn't set DOTNET_STARTUP_PROJECT to select one.
  local app=startup_project_not_found

  # build image
  local image=$(s2i_image_tag ${app})
  local s2i_build=$(s2i_build_output_log ${app} ${image})
  # cleanup
  docker_rmi ${image}

  # verify usage instructions
  local expected="error: DOTNET_STARTUP_PROJECT has no project file
You can specify the startup project by adding an '.s2i/environment' file to the source repository.
The source repository contains the following projects:
- proj1/proj1.csproj
- proj2/proj2.fsproj
Update the '.s2i/environment' file to specify the project you want to publish, for example DOTNET_STARTUP_PROJECT=proj1/proj1.csproj."
  assert_contains_multiline "${s2i_build}" "${expected}"
}

test_s2i_usage() {
  local output=$(s2i_usage ${IMAGE_NAME} 2>&1)

  # s2i usage refers to the sample app
  assert_contains "$output" "${sample_app_url}"
}

test_usage() {
  test_start

  test_s2i_usage
  test_s2i_usage_projfile
}

test_default_cmd() {
  test_start

  # verify the default command is bash.
  local container=$(docker_run_withargs $IMAGE_NAME -td) # use '-t' to stop bash from exiting.
  local processes=$(docker top $container)
  # cleanup
  docker_rm ${container}

  # Ensure there is a single bash process.
  #  The output of 'docker top' looks like
  #      USER        PID         PPID        %CPU        ELAPSED           TTY         TIME        COMMAND
  #      root        1           0           0.000       16m30.479579703s  pts/0       0s          /bin/bash
  assert_equal $(echo "$processes" | wc -l) "2"
  assert_contains_multiline "$processes" "/bin/bash"
}

test_image() {
  test_start

  # verify dotnet is available
  assert_contains $(docker_run ${IMAGE_NAME} dotnet --version) "$dotnet_version_series"

  # Like Microsoft images, we set set DOTNET_SDK_VERSION.
  # Its value get checked during the build.
  # This is to ensure it is provided as environment variables.
  assert_contains $(docker_get_env $IMAGE_NAME DOTNET_SDK_VERSION) "$dotnet_version_series"

  # DOTNET_DEFAULT_CMD
  assert_equal $(docker_get_env $IMAGE_NAME DOTNET_DEFAULT_CMD) "default-cmd.sh"
  # DOTNET_APP_PATH
  assert_equal $(docker_get_env $IMAGE_NAME DOTNET_APP_PATH) "/opt/app-root/app"

  # Verify $HOME != $CWD. See https://github.com/redhat-developer/s2i-dotnetcore/issues/28
  local working_dir=$(docker_run ${IMAGE_NAME} pwd)
  assert_equal "${working_dir}" "/opt/app-root/src"
  local env=$(docker_run ${IMAGE_NAME} env)
  assert_contains "${env}" "HOME=/opt/app-root$"

  # Verify the `dotnet watch` command can detect file changes in the container.
  assert_contains "${env}" "DOTNET_USE_POLLING_FILE_WATCHER=true$"

  # verify no 'Welcome' message appears, due to running first time actions in build Dockerfile.
  local dotnet_help=$(docker_run ${IMAGE_NAME} dotnet help)
  assert_not_contains "${dotnet_help}" "Welcome"

  # Certificate folders created by the 1001 user are not accepted by .NET
  # when the image runs on OpenShift as another user.
  # Ensure there are no certificate store folders.
  # This also ensures the image doesn't include an ASP.NET Core developer certificate.
  local certificate_stores=$(docker run --rm ${IMAGE_NAME} stat /opt/app-root/.dotnet/corefx/cryptography/x509stores 2>&1)
  assert_contains "${certificate_stores}" "No such file or directory"
}

test_port() {
  test_start

  # Port 8080 is exposed (for s2i based apps)
  assert_equal $(docker_get_exposedports $IMAGE_NAME) '{"8080/tcp":{}}'
}

test_consoleapp() {
  test_start

  # helloworld is a C# console application

  # application returns expected output
  assert_contains "$(s2i_build_and_run helloworld)" "Hello World!"
}

test_multiframework() {
  test_start

  # hw_framework_config targets both: net451 and netcoreapp
  # this test verifies we are building and able to run the .NET target.

  # application returns expected output
  assert_contains "$(s2i_build_and_run hw_framework_config)" "Hello World!"
}

test_fsharp() {
  test_start

  # helloworld-fs is an F# console application

  # application returns expected output
  assert_contains "$(s2i_build_and_run helloworld-fs)" "Hello World from F#!"
}

test_vb() {
  test_start

  # helloworld-vb is a VB console application

  # application returns expected output
  assert_contains "$(s2i_build_and_run helloworld-vb)" "Hello World from VB!"
}

test_published_files() {
  test_start

  # qotd has an appsettings.json and quotes.txt files that must
  # be published with the app and found at runtime.

  # application returns expected output
  assert_contains "$(s2i_build_and_run qotd)" "QOTD"
}

test_aspnetapp() {
  test_start

  # asp-net-hello-world is an ASP.NET Core application

  local app=asp-net-hello-world
  # build image
  local image=$(s2i_build ${app})
  # start container
  local container=$(docker_run_d ${image})
  local url=$(container_url ${container})
  # request
  local response_base=$(curl_retry ${url}/)
  local response_file=$(curl_retry ${url}/TextFile.txt)
  local pid1_process=$(docker_exec ${container} /bin/bash -c 'ps --no-headers -o args 1')
  # cleanup
  docker_rm ${container}
  docker_rmi ${image}

  # Check response by ASP.NET pipeline
  assert_equal "${response_base}" "Hello world"
  # Check response by file middleware
  assert_equal "${response_file}" "A text file."
  # Verify dotnet runs as PID 1
  assert_equal "${pid1_process}" "dotnet asp-net-hello-world.dll"
}

test_user() {
  test_start

  local app=asp-net-hello-world
  # user to run the app (30002) is different than user that built the app (1001).
  local run_user=30002

  # build image
  local image=$(s2i_build ${app})
  # start container
  local container=$(docker_run_as_d ${image} ${run_user})
  local url=$(container_url ${container})
  # request
  local response=$(curl_retry ${url}/)
  # cleanup
  docker_rm ${container}
  docker_rmi ${image}
  docker_rmi ${image}-as-${run_user} # image created on podman systems by docker_run_as_d

  # app is working
  assert_equal "${response}" "Hello world"
}

test_template()
{
  local template=$1
  info " template: $template"

  # newweb creates instantiates the 'dotnet new mvc' template
  # in the assemble script.
  local app=newtemplate
  # build image
  local image=$(s2i_build ${app} -e TEMPLATE=$template)
  # start container
  local container=$(docker_run_d ${image})
  local url=$(container_url ${container})
  # request
  local response=$(curl_retry ${url}/)
  # cleanup
  docker_rm ${container}
  docker_rmi ${image}

  # app is working
  assert_contains "${response}" "html"
}

test_templates() {
  test_start

  # mvc is a pure ASP.NET Core MVC web application
  local templates=(mvc)
  for template in ${templates[@]}; do
    test_template $template
  done
}

test_config_configuration() {
  # DOTNET_CONFIGURATION=Debug
  assert_contains "$(s2i_build_and_run dotnet-configuration-debug)" "Debug"
  # DOTNET_CONFIGURATION=Release
  assert_contains "$(s2i_build_and_run dotnet-configuration-release)" "Release"
}

test_config_1() {
  # groups envvar tests which are performed against asp-net-hello-world-envvar

  local app=asp-net-hello-world-envvar
  # build image
  local image=$(s2i_image_tag ${app})
  local s2i_build=$(s2i_build_output_log ${app} ${image})
  # find gulp and packed all
  local watch_path=$(docker_run ${image} bash -c "command -v dotnet-symbol")
  local dotnetrpm_path=$(docker_run ${image} bash -c "command -v dotnet-rpm")
  local packed_app=$(docker_run ${image} ls /opt/app-root/app.tar.gz)
  local src_folder_content=$(docker_run ${image} ls -a /opt/app-root/src)
  # start container
  local container=$(docker_run_d ${image})
  local url=$(container_url ${container})
  # request
  local response=$(curl_retry ${url}/)
  local container_log=$(docker logs ${container})
  # cleanup
  docker_rm ${container}
  docker_rmi ${image}

  # DOTNET_STARTUP_PROJECT=src/app
  assert_equal "${response}" "Hello world"
  # DOTNET_TEST_PROJECTS=test/test1 test/test2
  assert_contains "${s2i_build}" "Passed!.*test1"
  assert_contains "${s2i_build}" "Passed!.*test2"
  # DOTNET_TEST_CONFIGURATION=Debug
  assert_contains "${s2i_build}" "test1/bin/Debug"
  assert_contains "${s2i_build}" "test2/bin/Debug"
  # DOTNET_ASSEMBLY_NAME=SampleApp
  assert_contains "${s2i_build}" "/opt/app-root/src/src/app/bin/Debug/net10.0/SampleApp.dll"
  # DOTNET_RESTORE_SOURCES=https://api.nuget.org/v3/index.json https://www.myget.org/F/s2i-dotnetcore
  assert_contains "${s2i_build}" 'Restored /opt/app-root/src/src/app/app.csproj \([^)]+\)\.' # Includes S2iDotNetCoreDummy from myget.org.
  # DOTNET_PACK=true
  assert_contains "${s2i_build}" "Packing application..."
  assert_equal "${packed_app}" "/opt/app-root/app.tar.gz"
  # DOTNET_TOOLS=dotnet-symbol@1.0.5 dotnet-serve
  assert_equal "${watch_path}" "/opt/app-root/.dotnet/tools/dotnet-symbol"
  assert_equal "${dotnetrpm_path}" "/opt/app-root/.dotnet/tools/dotnet-rpm"
  assert_contains "${s2i_build}" "Tool 'dotnet-symbol' \(version '1.0.5'\) was successfully installed."
  # DOTNET_RM_SRC=true
  # The application folder contains a file and folder that starts with a '.', we verify that *all* files are removed.
  assert_contains "${s2i_build}" "Removing sources..."
  assert_not_contains "${src_folder_content}" "[^.]"
  # DOTNET_INFO=true
  assert_contains "${s2i_build}" ".NET information:"
  assert_contains "${s2i_build}" "Heap Size:"
  assert_contains "${container_log}" ".NET information:"
  assert_contains "${container_log}" "Heap Size:"
}

test_config_2() {
  # groups envvar tests which are performed against asp-net-hello-world-envvar2

  local app=asp-net-hello-world-envvar2
  # build image
  local image=$(s2i_image_tag ${app})
  local s2i_build=$(s2i_build_output_log ${app} ${image})
  # start container
  local container=$(docker_run_d ${image})
  local url=$(container_url ${container})
  # request
  local response=$(curl_retry ${url}/)
  # cleanup
  docker_rm ${container}
  docker_rmi ${image}

  # DOTNET_STARTUP_PROJECT=src/app/app.csproj
  # DOTNET_RESTORE_CONFIGFILE=src/app/NuGet.Config.s2i
  # The config file was used to restore S2iDotNetCoreDummy and didn't cause issues for the test and tool install.
  assert_equal "${response}" "Hello world"
  # DOTNET_TEST_PROJECTS=test/test1/test1.csproj test/test2
  assert_contains "${s2i_build}" "Finished:    test1"
  assert_contains "${s2i_build}" "Finished:    test2"
  # DOTNET_TEST_CONFIGURATION=Release
  assert_contains "${s2i_build}" "test1/bin/Release"
  assert_contains "${s2i_build}" "test2/bin/Release"

  # DOTNET_VERBOSITY=normal
  ## Environment
  assert_contains "${s2i_build}" "Environment:"
  assert_contains "${s2i_build}" "DOTNET_VERBOSITY=normal"
  assert_contains "${s2i_build}" ".NET information:"
  assert_contains "${s2i_build}" "Heap Size:"
  ## Test project restore
  assert_contains "${s2i_build}" 'Project "/opt/app-root/src/test/test1/test1.csproj" on node 1 \(Restore target\(s\)\).'
  ## Test project test
  assert_contains "${s2i_build}" 'Project "/opt/app-root/src/test/test1/test1.csproj" on node 1 \(VSTest target\(s\)\).'
  ## App project restore
  assert_contains "${s2i_build}" 'Project "/opt/app-root/src/src/app/app.csproj" on node 1 \(Restore target\(s\)\).'
  ## App project publish
  assert_contains "${s2i_build}" 'Project "/opt/app-root/src/src/app/app.csproj" on node 1 \(Publish target\(s\)\).'
  # DOTNET_PUBLISH_READYTORUN=true
  if [ "$(uname -m)" == "s390x" -o "$(uname -m)" == "ppc64le" ]; then
    assert_contains "${s2i_build}" 'DOTNET_PUBLISH_READYTORUN is not supported on'
  else
    assert_contains "${s2i_build}" '_CreateR2RImages'
  fi
}

test_config_3() {
  # groups envvar tests which are performed against dotnet-configuration-debug

  local app=dotnet-configuration-debug
  # build image
  local image=$(s2i_image_tag ${app})
  local s2i_build=$(s2i_build_output_log ${app} ${image})
  # cleanup
  docker_rmi ${image}

  # DOTNET_RESTORE_DISABLE_PARALLEL=true
  assert_contains "${s2i_build}" "Running non-parallel restore"
}

test_config() {
  test_start

  test_config_configuration
  test_config_1
  test_config_2
  test_config_3
}

test_imagestream_sample() {
  test_start

  # test the sample app defined with the imagestreams:
  # "sampleRepo": "https://github.com/redhat-developer/s2i-dotnetcore-ex.git",
  # "sampleContextDir": "app",
  # "sampleRef": "dotnet-10.0"

  # build image
  local image=$(s2i_image_tag sample)
  docker_rmi ${tag}
  local s2i_build=$(s2i_build_core ${image} --pull-policy=always --context-dir=app --ref=dotnet-10.0 https://github.com/redhat-developer/s2i-dotnetcore-ex.git 2>&1)
  # start container
  local container=$(docker_run_d ${image})
  local url=$(container_url ${container})
  # request
  local response=$(curl_retry ${url}/)
  # cleanup
  docker_rm ${container}
  docker_rmi ${image}

  # app is working
  assert_contains "${response}" "html"
}

test_binary()
{
  test_start

  # precompiled contains 2 pre-compiled .net console applications
  # console.dll: prints out "Hello World!"
  # world2/console.dll: prints out "Hello World2!"
  local app=precompiled

  # verify the console.dll entry point assembly is detected and ran
  local image=$(s2i_build ${app})
  local output=$(docker_run ${image})
  docker_rmi ${image}
  assert_contains "${output}" "Hello World!"

  # verify we can run world2/console.dll by setting DOTNET_STARTUP_ASSEMBLY
  image=$(s2i_build ${app} -e DOTNET_STARTUP_ASSEMBLY=world2/console.dll)
  output=$(docker_run ${image})
  docker_rmi ${image}
  assert_contains "${output}" "Hello World2!"
}

test_incremental()
{
  test_start

  # asp-net-hello-world-envvar2 is an ASP.NET Core application
  local app=asp-net-hello-world-envvar2

  # perform a first build, with the incremental flag
  local image=$(s2i_image_tag ${app})
  docker_rmi ${image}
  local s2i_build=$(s2i_build_output_log ${app} ${image} -e DOTNET_INCREMENTAL=true)

  # verify packages are installed
  assert_contains "${s2i_build}" "GET https://api.nuget.org/v3-flatcontainer/newtonsoft.json/13.0.1/newtonsoft.json.13.0.1.nupkg"
  # verify the build completes succesfully
  assert_completed_build ${image} "${s2i_build}"

  # perform a second build, with the incremental flag
  s2i_build=$(s2i_build_output_log ${app} ${image} --incremental -e DOTNET_INCREMENTAL=true)
  # verify NO other packages are installed
  assert_not_contains "${s2i_build}" "GET https://api.nuget.org/v3-flatcontainer/newtonsoft.json/13.0.1/newtonsoft.json.13.0.1.nupkg"
  # verify the build completes succesfully
  assert_completed_build ${image} "${s2i_build}"

  # cleanup
  docker_rmi ${image}
}

test_incremental_without_packages()
{
  test_start

  # asp-net-hello-world-envvar2 is an ASP.NET Core application
  local app=asp-net-hello-world-envvar2

  # perform a first build without keeping packages
  local image=$(s2i_image_tag ${app})
  local s2i_build=$(s2i_build_output_log ${app} ${image} -e DOTNET_INCREMENTAL=false)
  # verify packages are installed
  assert_contains "${s2i_build}" "GET https://api.nuget.org/v3-flatcontainer/newtonsoft.json/13.0.1/newtonsoft.json.13.0.1.nupkg"
  # verify the build completes succesfully
  assert_completed_build ${image} "${s2i_build}"

  # perform a second build, with the incremental flag
  s2i_build=$(s2i_build_output_log ${app} ${image} --incremental)
  # verify NO incremental packages are installed
  assert_not_contains "${s2i_build}" "Installing artifacts from incremental build"
  # verify the build completes succesfully
  assert_completed_build ${image} "${s2i_build}"

  # cleanup
  docker_rmi ${image}
}

test_repos() {
  test_start

  local output=$(docker_run_as $IMAGE_NAME 0 bash -c 'microdnf install -y zlib-devel || dnf install -y zlib-devel')
  assert_contains "$output" "Complete"
}

test_rm_tmp_dotnet() {
  test_start

  # rm-tmp-dotnet creates a directory at /tmp/.dotnet/shm during assemble.
  local app=rm-tmp-dotnet

  # build image
  local image=$(s2i_image_tag ${app})
  local s2i_build=$(s2i_build_output_log ${app} ${image})
  local tmp_dotnet=$(docker run --rm ${image} stat /tmp/.dotnet 2>&1)

  # cleanup
  docker_rmi ${image}

  # verify /tmp/.dotnet was removed
  assert_contains "${tmp_dotnet}" "No such file or directory"
}

test_msbuild_exec_task() {
  test_start

  # msbuild-exec-task uses an MSBuild Exec Task.
  # MSBuild Exec sets the en_US locale. This test verifies the locale doesn't cause issues in the container image.
  # See https://github.com/redhat-developer/s2i-dotnetcore/issues/478.
  local app=msbuild-exec-task

  # build image
  local image=$(s2i_image_tag ${app})
  local s2i_build=$(s2i_build_output_log ${app} ${image})

  # cleanup
  docker_rmi ${image}

  # verify the Exec task ran
  assert_contains "${s2i_build}" "Running RunExecTask"
  # verify the build did not fail
  assert_completed_build ${image} "${s2i_build}"
}

info "Testing ${IMAGE_NAME}"

if [ ${OPENSHIFT_ONLY} != true ]; then
  test_image
  test_port
  test_config
  test_usage
  test_default_cmd
  test_repos
  test_rm_tmp_dotnet
  test_consoleapp
  test_multiframework
  test_fsharp
  test_vb
  test_published_files
  test_aspnetapp
  test_templates
  test_user
  test_binary
  test_incremental
  test_incremental_without_packages
  test_msbuild_exec_task
else
  test_imagestream_sample
fi

if [ "$STOP_ON_ERROR" != "true" ]; then
  failures=(${TEST_FAILURES})
  if [ ${#failures[@]} -gt 0 ]; then
    echo "[ERROR] Tests failed: ${#failures[@]}"
    for item in ${failures[@]}; do
      echo "  ${item}"
    done
    exit 1
  fi
fi

info "All tests finished successfully."