Commit bdb15762 authored by Christian Ceelen's avatar Christian Ceelen Committed by Pierre Smeyers
Browse files

build: add bats unit tests

parent df301891
Loading
Loading
Loading
Loading
+4 −0
Original line number Diff line number Diff line
@@ -11,6 +11,10 @@ include:
  - component: $CI_SERVER_FQDN/to-be-continuous/bash/gitlab-ci-bash@3
    inputs:
      shellcheck-files: "*.sh"
      bats-enabled: true
      bats-libraries: "bats-support@https://github.com/bats-core/bats-support/archive/v0.3.0.zip bats-assert@https://github.com/bats-core/bats-assert/archive/v2.1.0.zip bats-file@https://github.com/bats-core/bats-file/archive/v0.4.0.zip"
      coverage-enabled: true
      bats-opts: "-t --verbose-run"
  - component: $CI_SERVER_FQDN/to-be-continuous/semantic-release/gitlab-ci-semrel@4
    inputs:
      # disable semrel for all synch'd repositories
+30 −0
Original line number Diff line number Diff line
#!/usr/bin/env bats
load "$BATS_LIBRARIES_DIR/bats-support/load.bash"
load "$BATS_LIBRARIES_DIR/bats-file/load.bash"
load "$BATS_LIBRARIES_DIR/bats-assert/load.bash"
load 'bash-scripts'

bats_require_minimum_version 1.5.0

function setup() {
    # Source default environment variables first
    source ./tests/test-env-defaults.bash

    TEST_TEMP_DIR="$(temp_make --prefix tests)"
}
function teardown() {
    temp_del "$TEST_TEMP_DIR"
}

@test "test something" {
    run echo "Hello there"
    assert_line "Hello there"
}

@test "tool availability" {
    set +u
    if [[ -n "$CI_PROJECT_DIR" ]]; then
        run apk add git bash xq xmlstarlet
    fi
    set -u
}
+446 −0
Original line number Diff line number Diff line
#!/usr/bin/env bats
load "$BATS_LIBRARIES_DIR/bats-support/load.bash"
load "$BATS_LIBRARIES_DIR/bats-file/load.bash"
load "$BATS_LIBRARIES_DIR/bats-assert/load.bash"
load 'bash-scripts'
load 'test-env-defaults.bash'

bats_require_minimum_version 1.5.0

function setup() {
    TEST_TEMP_DIR="$(temp_make --prefix tests)"
    # Create a default solution with projects and normalize environment variables
    create_solution_with_projects "$TEST_TEMP_DIR" "."
    # ensure version variable used by build props is defined
    export DOTNET_PROJECT_VERSION_FULL="1.0.0"
    export DOTNET_CLI_HOME="$TEST_TEMP_DIR/.dotnetcli"
    mkdir -p "$DOTNET_CLI_HOME/tools"
    cd "$TEST_TEMP_DIR"
    export CI_PROJECT_DIR="$TEST_TEMP_DIR"
    export DOTNET_PROJECT_DIR="."
}

function teardown() {
    temp_del "$TEST_TEMP_DIR"
}

# Mock dotnet command for testing
function dotnet() {
    echo "$(echo dotnet "$*" | tr '\n' ' ')" >>"$TEST_TEMP_DIR/dotnet_calls.log"
    if [[ "$1" == "test" ]]; then
        mkdir -p "$TEST_TEMP_DIR/reports"
    elif [[ "$1" == "tool" ]]; then
        if [[ "${2}" == "run" ]]; then
            if [[ "${3}" == "dotnet-sonarscanner" ]]; then
                shift 3
                echo "dotnet-sonarscanner $*" >> "$CI_PROJECT_DIR/sonar_calls.log"
            fi
        fi
    fi
    return 0
}
export -f dotnet

@test "dotnet_configure_build_props() - configures Directory.Build.props when solution exists" {
    echo "<Project/>" >"$TEST_TEMP_DIR/Directory.Build.props"
    # ensure environment points to the test dir and version variable is set
    export DOTNET_PROJECT_DIR="."
    _dotnet_set_project_environment "$DOTNET_PROJECT_DIR"
    export DOTNET_PROJECT_VERSION_FULL="1.0.0"

    run dotnet_configure_build_props
    assert_success
    assert_file_exist "$TEST_TEMP_DIR/Directory.Build.props"
    run cat "$TEST_TEMP_DIR/Directory.Build.props"
    assert_output --partial "<Version>1.0.0</Version>"
    assert_output --partial "<AnalysisMode>all</AnalysisMode>"
    assert_output --partial "<AnalysisLevel>latest</AnalysisLevel>"
    assert_output --partial "<ErrorLog>bin/dotnet-build.sarif.json,version=2.1</ErrorLog>"
    assert_output --partial "<CodeAnalysisIgnoreGeneratedCode>true</CodeAnalysisIgnoreGeneratedCode>"
}

@test "_dotnet_set_build_properties() - configures project file when no solution exists" {
    local base="$TEST_TEMP_DIR/project_only"
    mkdir -p "$base"
    create_project_only "$base" "." "test.csproj"
    export DOTNET_PROJECT_SOLUTION=""

    run _dotnet_set_build_properties "project_only/test.csproj"

    assert_success
    assert_file_exist "$base/test.csproj"
    run cat "$base/test.csproj"
    # old props is retained
    assert_output --partial "<TargetFramework>net8.0</TargetFramework>"
    # new props are added
    assert_output --partial "<Version>1.0.0</Version>"
    assert_output --partial "<AnalysisMode>all</AnalysisMode>"
    assert_output --partial "<AnalysisLevel>latest</AnalysisLevel>"
    assert_output --partial "<ErrorLog>bin/dotnet-build.sarif.json,version=2.1</ErrorLog>"
    assert_output --partial "<CodeAnalysisIgnoreGeneratedCode>true</CodeAnalysisIgnoreGeneratedCode>"
}

@test "dotnet_run_build() - basic functionality with defaults" {
    create_project_only "$TEST_TEMP_DIR" "project_only_build" "test.csproj"
    export DOTNET_PROJECT_DIR="project_only_build"
    export DOTNET_BUILD_FILE="test.csproj"
    _dotnet_set_project_environment "project_only_build"
    run dotnet_run_build
    assert_file_exist "$TEST_TEMP_DIR/dotnet_calls.log"
    run cat "$TEST_TEMP_DIR/dotnet_calls.log"
    assert_success
    assert_output --partial 'dotnet restore project_only_build/test.csproj --force'
    assert_output --partial 'dotnet build project_only_build/test.csproj --no-restore --configuration Release -nologo'
}

@test "dotnet_run_build() - with custom parameters" {
    create_solution_with_projects ${TEST_TEMP_DIR} custom/path
    export DOTNET_BUILD_ARGS="--verbosity minimal"

    run dotnet_run_build

    # assert_success
    assert_file_exist "$TEST_TEMP_DIR/dotnet_calls.log"
    run cat "$TEST_TEMP_DIR/dotnet_calls.log"
    assert_output --partial "dotnet build custom/path/proj.sln --verbosity minimal --no-restore --configuration Release"
}

@test "_set_project_environment and _projects_in_solution: solution and project detection" {
    # Create a solution and project files
    echo "solution content" >"${TEST_TEMP_DIR}/MyApp.sln"
    echo "project content" >"${TEST_TEMP_DIR}/MyApp.csproj"
    echo "project content" >"${TEST_TEMP_DIR}/MyApp2.csproj"

    # Mock dotnet so _projects_in_solution can return project entries from the solution
    function dotnet() {
        if [[ "$1" == "sln" && "$3" == "list" ]]; then
            echo "Project(s)"
            echo "----------"
            echo "MyApp.csproj"
            echo "MyApp2.csproj"
        else
            echo "dotnet $(echo "$*" | xargs)" >>"$TEST_TEMP_DIR/dotnet_calls.log"
        fi
        return 0
    }
    export -f dotnet

    # Use new API to set environment based on DOTNET_PROJECT_DIR
    export DOTNET_PROJECT_DIR="."
    export DOTNET_BUILD_FILE="MyApp.sln"
    _dotnet_set_project_environment "$DOTNET_PROJECT_DIR"

    # Check that DOTNET_PROJECT_SOLUTION is set and DOTNET_PROJECT_FILES contains project filenames only
    assert_equal "$(echo ${DOTNET_PROJECT_FILES} | xargs)" "MyApp.csproj MyApp2.csproj"
    assert_equal "${DOTNET_PROJECT_SOLUTION}" "MyApp.sln"

    assert_file_exist "$TEST_TEMP_DIR/dotnet-MyApp.env"
    run cat "$TEST_TEMP_DIR/dotnet-MyApp.env"

    assert_output --partial "DOTNET_PROJECT_NAME=MyApp"
    assert_output --partial "DOTNET_PROJECT_SOLUTION=MyApp.sln"
    assert_output --partial "DOTNET_BUILD_FILE=MyApp.sln"
    assert_output --partial "DOTNET_PROJECT_FILES="
    assert_output --partial '"MyApp.csproj" "MyApp2.csproj"'
    refute_output --partial "[ERROR]"
}

@test "dotnet_run_test() - basic functionality" {
    # Override specific variables for this test
    export DOTNET_TEST_DISABLED=false
    export DOTNET_PROJECT_DIR="."
    export DOTNET_TEST_EXTRA_ARGS="--collect:\"XPlat Code Coverage\""

    run dotnet_run_test

    assert_dir_exist "$TEST_TEMP_DIR/reports"
    assert_file_exist "$TEST_TEMP_DIR/dotnet_calls.log"
    run cat "$TEST_TEMP_DIR/dotnet_calls.log"
    assert_output --partial "dotnet test"
    assert_output --partial "junit;LogFilePath=bin/reports/dotnet-test.junit.xml"
    assert_output --partial "/p:CollectCoverage=true"
    assert_output --partial '/p:CoverletOutputFormat="cobertura"'
    assert_output --partial "/p:CoverletOutput="
    assert_output --partial "/reports/dotnet-test."
}

@test "dotnet_run_test() - with SonarQube enabled" {
    # Override specific variables for this test
    export DOTNET_TEST_DISABLED=false
    export DOTNET_PROJECT_DIR="tests"
    export SONAR_HOST_URL="https://sonar.example.com"
    create_solution_with_projects ${TEST_TEMP_DIR} tests

    run dotnet_run_test

    run cat "$TEST_TEMP_DIR/dotnet_calls.log"
    assert_output --partial "dotnet test"
    assert_output --partial '/p:CoverletOutputFormat="cobertura,opencover"'
    assert_output --partial "xunit;LogFilePath=bin/reports/dotnet-test.xunit.xml"
}

@test "dotnet_run_test() - with custom parameters" {
    export DOTNET_TEST_DISABLED=false
    export DOTNET_PROJECT_DIR="custom/test/path"
    export DOTNET_TEST_EXTRA_ARGS="--filter Category!=Integration"
    create_solution_with_projects ${TEST_TEMP_DIR} custom/test/path

    run dotnet_run_test

    run cat "$TEST_TEMP_DIR/dotnet_calls.log"
    assert_output --partial "dotnet test"
    assert_output --partial "custom/test/path"
    assert_output --partial "--filter Category!=Integration"
}

@test "dotnet_run_sonar() - basic functionality" {
    export SONAR_PROJECT_KEY="my-project"
    export SONAR_HOST_URL="https://sonar.example.com"
    export SONAR_TOKEN="my-token"
    export DOTNET_PROJECT_DIR="tests"
    export DOTNET_SONAR_EXTRA_ARGS="--debug"
    export DOTNET_RESTORE_OPTS="--no-restore"
    mkdir -p "$TEST_TEMP_DIR/$DOTNET_PROJECT_DIR"

    touch "$TEST_TEMP_DIR/$DOTNET_PROJECT_DIR/dotnet-test.opencover.xml"
    touch "$TEST_TEMP_DIR/$DOTNET_PROJECT_DIR/dotnet-test.xunit.xml"

    run dotnet_run_sonar

    assert_success
    assert_file_exist "$TEST_TEMP_DIR/dotnet_calls.log"
    assert_file_exist "$CI_PROJECT_DIR/sonar_calls.log"

    # Check dotnet tool install was called
    run cat "$TEST_TEMP_DIR/dotnet_calls.log"
    assert_output --partial "dotnet tool install"
    assert_output --partial "dotnet-sonarscanner"
    assert_output --partial "dotnet build tests/proj.sln"

    # Check sonar scanner was called
    run cat "$CI_PROJECT_DIR/sonar_calls.log"
    assert_output --partial "dotnet-sonarscanner begin"
    assert_output --partial "/k:my-project"
    assert_output --partial "/d:sonar.host.url=https://sonar.example.com"
    assert_output --partial "/d:sonar.token=my-token"
    assert_output --partial "/d:sonar.cs.opencover.reportsPaths=tests/dotnet-test.opencover.xml"
    assert_output --partial "/d:sonar.cs.xunit.reportsPaths=tests/dotnet-test.xunit.xml"
    assert_output --partial "--debug"
    assert_output --partial "dotnet-sonarscanner end"
}

@test "dotnet_run_sonar() - with environment variables" {
    # Override defaults for this test
    export SONAR_PROJECT_KEY="env-project"
    export SONAR_HOST_URL="https://env-sonar.example.com"
    export SONAR_TOKEN="env-token"
    export DOTNET_PROJECT_DIR="env-tests"
    export DOTNET_SONAR_EXTRA_ARGS="/d:sonar.projectVersion=1.0.0"
    export DOTNET_RESTORE_OPTS="--no-restore"

    mkdir -p "$TEST_TEMP_DIR/$DOTNET_PROJECT_DIR/bin/reports"
    touch "$TEST_TEMP_DIR/$DOTNET_PROJECT_DIR/bin/reports/dotnet-test.opencover.xml"
    touch "$TEST_TEMP_DIR/$DOTNET_PROJECT_DIR/bin/reports/dotnet-test.xunit.xml"

    run dotnet_run_sonar

    assert_success
    run cat "$CI_PROJECT_DIR/sonar_calls.log"
    assert_output --partial "/k:env-project"
    assert_output --partial "/d:sonar.host.url=https://env-sonar.example.com"
    assert_output --partial "/d:sonar.token=env-token"
    assert_output --partial "/d:sonar.projectVersion=1.0.0"
    assert_output --partial "/d:sonar.cs.opencover.reportsPaths=env-tests/bin/reports/dotnet-test.opencover.xml"
    assert_output --partial "/d:sonar.cs.xunit.reportsPaths=env-tests/bin/reports/dotnet-test.xunit.xml"

    run cat "$TEST_TEMP_DIR/dotnet_calls.log"
    assert_output --partial "dotnet build env-tests/proj.sln"
}

@test "dotnet_run_sonar() - missing required parameters" {
    # Test missing project key
    export SONAR_PROJECT_KEY=""
    export SONAR_HOST_URL="https://sonar.example.com"
    export SONAR_TOKEN="token"

    run dotnet_run_sonar
    assert_failure
    assert_output --partial "SONAR_PROJECT_KEY is required"

    # Test missing host URL
    export SONAR_PROJECT_KEY="project"
    export SONAR_HOST_URL=""
    export SONAR_TOKEN="token"

    run dotnet_run_sonar
    assert_failure
    assert_output --partial "SONAR_HOST_URL is required"

    # Test missing token
    export SONAR_PROJECT_KEY="project"
    export SONAR_HOST_URL="https://sonar.example.com"
    export SONAR_TOKEN=""

    run dotnet_run_sonar
    assert_failure
    assert_output --partial "SONAR_TOKEN is required"
}

@test "dotnet_run_format executes with correct arguments" {
    export DOTNET_PROJECT_DIR="custom/path"
    mkdir -p "$TEST_TEMP_DIR/$DOTNET_PROJECT_DIR"
    echo "solution content" >"$TEST_TEMP_DIR/$DOTNET_PROJECT_DIR/proj.sln"
    _dotnet_set_project_environment "$DOTNET_PROJECT_DIR"
    run dotnet_run_format
    assert_success
    assert_file_exist "$TEST_TEMP_DIR/dotnet_calls.log"
    run cat "$TEST_TEMP_DIR/dotnet_calls.log"
    assert_success
    assert_output --partial 'dotnet format whitespace custom/path/proj.sln --verify-no-changes'
    assert_output --partial 'dotnet format style custom/path/proj.sln --verify-no-changes'
    assert_output --partial 'dotnet format analyzers custom/path/proj.sln --verify-no-changes'
}

@test "dotnet_run_format uses custom project directory" {
    local custom_dir="custom"
    export DOTNET_PROJECT_DIR="custom"
    export DOTNET_BUILD_FILE="proj.csproj"
    create_project_only "$TEST_TEMP_DIR" "custom" "proj.csproj"
    _dotnet_set_project_environment "custom"
    # Expect the dotnet.<basename>.env file to be created for custom project path
    assert_file_exist "$CI_PROJECT_DIR/custom/dotnet-proj.env"

    run dotnet_run_format
    assert_success
    run cat "$TEST_TEMP_DIR/dotnet_calls.log"
    assert_success
    assert_output --partial "dotnet format whitespace custom/proj.csproj --verify-no-changes"
    assert_output --partial "dotnet format style custom/proj.csproj --verify-no-changes"
    assert_output --partial "dotnet format analyzers custom/proj.csproj --verify-no-changes"
}

@test "dotnet_roslyn_scan executes when enabled" {
    export DOTNET_PROJECT_DIR="$TEST_TEMP_DIR"
    export CI_JOB_NAME="dotnet-build"
    export DOTNET_PROJECT_NAME="MyApp"
    mkdir -p "$DOTNET_PROJECT_DIR/test1"
    touch "$DOTNET_PROJECT_DIR/test1/dotnet-build.sarif"
    mkdir -p "$DOTNET_PROJECT_DIR/test2"
    touch "$DOTNET_PROJECT_DIR/test2/dotnet-build.sarif"
    function curl() {
        echo "curl $*" >>"$TEST_TEMP_DIR/curl_calls.log"
        {
            echo "#!/bin/sh"
            echo "echo sarif-converter \$@"
            return 0
        } > "$TEST_TEMP_DIR/.dotnetcli/bin/sarif"
        return 0
    }
    export -f curl

    run dotnet_run_build
    assert_success
    assert_line --partial "Collecting SARIF reports"
    assert_line --partial "Downloading sarif-converter tool ..."
    assert_line --partial "sarif-converter --version"
    assert_line --partial "sarif-converter --type codequality"
    assert_line --partial "test1/dotnet-build.sarif"
    assert_line --partial "test2/dotnet-build.sarif"
    assert_line --partial "reports/dotnet-build-MyApp.gitlab-codequality.json"
}

@test "extract framework from project file" {
    cat >"$TEST_TEMP_DIR/App.csproj" <<'EOF'
<Project Sdk="Microsoft.NET.Sdk">
  <PropertyGroup>
    <TargetFramework>net8.0</TargetFramework>
    <OutputType>Library</OutputType>
  </PropertyGroup>
</Project>
EOF

    run _dotnet_project_frameworks $TEST_TEMP_DIR/App.csproj
    assert_line "net8.0"
}

@test "extract multiple frameworks from project file" {
    cat >"$TEST_TEMP_DIR/App.csproj" <<'EOF'
<Project Sdk="Microsoft.NET.Sdk">
  <PropertyGroup>
    <TargetFrameworks>net8.0;net9.0</TargetFrameworks>
    <OutputType>Library</OutputType>
  </PropertyGroup>
</Project>
EOF
    run _dotnet_project_frameworks $TEST_TEMP_DIR/App.csproj
    assert_output --partial "net8.0"
    assert_output --partial "net9.0"
}

@test "extract unique frameworks from project file" {

    cat >"$TEST_TEMP_DIR/App.csproj" <<'EOF'
<Project Sdk="Microsoft.NET.Sdk">
  <PropertyGroup>
    <TargetFrameworks>net6.0;net10.0;net8.0;net8.0</TargetFrameworks>
    <OutputType>Library</OutputType>
  </PropertyGroup>
</Project>
EOF
    run _dotnet_project_frameworks $TEST_TEMP_DIR/App.csproj
    assert_output --partial "net6.0"
    assert_output --partial "net8.0"
    assert_output --partial "net10.0"
}

@test "find required frameworks in project" {
    cat >"$TEST_TEMP_DIR/Library.csproj" <<'EOF'
<Project Sdk="Microsoft.NET.Sdk">
  <PropertyGroup>
    <TargetFramework>netstandard2.1</TargetFramework>
    <OutputType>Library</OutputType>
  </PropertyGroup>
</Project>
EOF

    cat >"$TEST_TEMP_DIR/App1.csproj" <<'EOF'
<Project Sdk="Microsoft.NET.Sdk">
  <PropertyGroup>
    <TargetFramework>net8.0</TargetFramework>
    <OutputType>Library</OutputType>
  </PropertyGroup>
</Project>
EOF

    mkdir -p "$TEST_TEMP_DIR/subdir"

    cat >"$TEST_TEMP_DIR/subdir/App2.csproj" <<'EOF'
<Project Sdk="Microsoft.NET.Sdk">
  <PropertyGroup>
    <TargetFrameworks>net8.0;net9.0</TargetFrameworks>
    <OutputType>Library</OutputType>
  </PropertyGroup>
</Project>
EOF

    cat >"$TEST_TEMP_DIR/subdir/App3.csproj" <<'EOF'
<Project Sdk="Microsoft.NET.Sdk">
  <PropertyGroup>
    <TargetFrameworks>net6.0;net8.0;net10.0</TargetFrameworks>
    <OutputType>Library</OutputType>
  </PropertyGroup>
</Project>
EOF
    run _dotnet_required_dotnet_versions "Library.csproj App1.csproj subdir/App2.csproj subdir/App3.csproj"
    assert_success
    assert_output --partial "net6.0"
    assert_output --partial "net8.0"
    assert_output --partial "net9.0"
    assert_output --partial "net10.0"
}

@test "correct template replacement for generating download paths" {
    run _dotnet_generate_os_arch_template "<OS>_<ARCH>" ""
    assert_success
    assert_output "linux_amd64"
}
 No newline at end of file
+116 −0
Original line number Diff line number Diff line
#!/usr/bin/env bats
load "$BATS_LIBRARIES_DIR/bats-support/load.bash"
load "$BATS_LIBRARIES_DIR/bats-file/load.bash"
load "$BATS_LIBRARIES_DIR/bats-assert/load.bash"
load 'bash-scripts'
load 'test-env-defaults.bash'

setup() {
  export OLD_DIR="$PWD"
  export TEST_DIR=$(temp_make --prefix test)
  export CI_PROJECT_DIR="$TEST_DIR"
  export DOTNET_PROJECT_DIR="$TEST_DIR"
  mkdir -p "$DOTNET_PROJECT_DIR"

  unset CI_COMMIT_TAG CI_COMMIT_REF_NAME CI_COMMIT_REF_SLUG CI_PIPELINE_ID DOTNET_PROJECT_VERSION DOTNET_PROJECT_VERSION_SUFFIX

  cd "$TEST_DIR"
}

teardown() {
  cd "$OLD_DIR"
  temp_del "$TEST_DIR"
}

@test "_dotnet_set_version_env: uses tag version when CI_COMMIT_TAG is set" {
  export CI_COMMIT_TAG="v1.2.3"
  export DOTNET_PROJECT_DIR="$CI_PROJECT_DIR"
  export DOTNET_PROJECT_ENV_FILE="$CI_PROJECT_DIR/version.env"

  touch "$CI_PROJECT_DIR/version.env"
  _dotnet_set_version_env

  assert_file_exist "$CI_PROJECT_DIR/version.env"
  run cat "$CI_PROJECT_DIR/version.env"
  assert_success
  assert_output --partial "DOTNET_PROJECT_VERSION=1.2.3"
}

@test "_dotnet_set_version_env: uses project file version when no tag" {
  # create a simple csproj with Version
  cat >"$CI_PROJECT_DIR/Project.csproj" <<'EOF'
<Project Sdk="Microsoft.NET.Sdk">
  <PropertyGroup>
    <Version>2.0.0</Version>
  </PropertyGroup>
</Project>
EOF
  export DOTNET_PROJECT_DIR="$CI_PROJECT_DIR"
  export DOTNET_PROJECT_ENV_FILE="$CI_PROJECT_DIR/.dotnet.env"
  export DOTNET_PROJECT_FILES='"Project.csproj"'
  _dotnet_set_version_env

  run cat "$CI_PROJECT_DIR/.dotnet.env"
  assert_success
  assert_output --partial "DOTNET_PROJECT_VERSION=2.0.0"
}

@test "_dotnet_set_version_env: uses largest version from multiple project files" {
  # create a simple csproj with Version
  echo "fake solution" >"$CI_PROJECT_DIR/fake.sln"
  cat >"$CI_PROJECT_DIR/Project.csproj" <<'EOF'
<Project Sdk="Microsoft.NET.Sdk">
  <PropertyGroup>
    <Version>2.0.0</Version>
  </PropertyGroup>
</Project>
EOF
  cat >"$CI_PROJECT_DIR/Project2.csproj" <<'EOF'
<Project Sdk="Microsoft.NET.Sdk">
  <PropertyGroup>
    <Version>2.0.1</Version>
  </PropertyGroup>
</Project>
EOF
  cat >"$CI_PROJECT_DIR/Project Space.csproj" <<'EOF'
<Project Sdk="Microsoft.NET.Sdk">
  <PropertyGroup>
    <Version>2.0.2</Version>
  </PropertyGroup>
</Project>
EOF
  export DOTNET_BUILD_FILE="Project.csproj"
  export DOTNET_PROJECT_DIR="$CI_PROJECT_DIR"
  export DOTNET_PROJECT_SOLUTION="fake.sln"
  export DOTNET_PROJECT_ENV_FILE="dotnet-fake.env"
  export DOTNET_PROJECT_FILES='"Project.csproj" "Project2.csproj" "Project Space.csproj"'
  _dotnet_set_version_env

  run cat "$CI_PROJECT_DIR/dotnet-fake.env"
  assert_success
  assert_output --partial "DOTNET_PROJECT_VERSION=2.0.2"
}

@test "_dotnet_set_version_env: sets full version and suffix for branch builds" {
  export CI_COMMIT_REF_NAME="feature/x"
  export CI_COMMIT_REF_SLUG="feature-x"
  # export CI_COMMIT_TAG="v1.2.3"
  export DOTNET_PROJECT_DIR="$CI_PROJECT_DIR"
  export DOTNET_PROJECT_ENV_FILE="version.env"
  export DOTNET_PROJECT_FILES='"Project.csproj"'
  cat >"$CI_PROJECT_DIR/Project.csproj" <<'EOF'
<Project Sdk="Microsoft.NET.Sdk">
  <PropertyGroup>
  </PropertyGroup>
</Project>
EOF

  _dotnet_set_version_env

  assert_file_exist "$CI_PROJECT_DIR/version.env"
  run cat "$CI_PROJECT_DIR/version.env"
  assert_success
  assert_output --partial "DOTNET_PROJECT_VERSION=1.0.0"
  assert_output --partial "DOTNET_PROJECT_VERSION_SUFFIX=feature-x"
  assert_output --partial "DOTNET_PROJECT_VERSION_FULL=1.0.0-feature-x"
}
+64 −0
Original line number Diff line number Diff line
#!/usr/bin/env bats
load "$BATS_LIBRARIES_DIR/bats-support/load.bash"
load "$BATS_LIBRARIES_DIR/bats-file/load.bash"
load "$BATS_LIBRARIES_DIR/bats-assert/load.bash"
load 'bash-scripts'
load 'test-env-defaults.bash'

# Tests for packaging/publishing helpers

setup() {
    TEST_TEMP_DIR="$(temp_make --prefix publish-tests)"
    mkdir -p "$TEST_TEMP_DIR"
    export CI_PROJECT_DIR="$TEST_TEMP_DIR"
    cd "$TEST_TEMP_DIR"
}

teardown() {
    temp_del "$TEST_TEMP_DIR"
}

function dotnet() {
    # capture dotnet invocations for assertions
    echo "dotnet $(echo "$*" | xargs)" >>"$TEST_TEMP_DIR/dotnet_calls.log"
    return 0
}

@test "_dotnet_package_app packages executable projects only" {
    create_solution_with_projects "$TEST_TEMP_DIR" "appdir"

    function dotnet() {
        echo "dotnet $(echo "$*" | xargs)" >>"$TEST_TEMP_DIR/dotnet_calls.log"
        if [[ "$1" == "sln" && "$3" == "list" ]]; then
            echo "Project(s)"
            echo "----------"
            echo "App1.csproj"
            echo "Lib1.csproj"
        fi
        return 0
    }
    export -f dotnet

    export DOTNET_PROJECT_DIR="appdir"
    _dotnet_set_project_environment "$DOTNET_PROJECT_DIR"

    run _dotnet_package_app
    assert_success
    assert_file_exist "$TEST_TEMP_DIR/dotnet_calls.log"
    run cat "$TEST_TEMP_DIR/dotnet_calls.log"
    assert_success
    assert_output --partial "dotnet publish appdir/App1.csproj"
}

@test "_dotnet_package_lib creates nuget packages from build file" {
    # Create a single project file (library) and verify pack is invoked
    create_project_only "$TEST_TEMP_DIR" "libdir" "LibOnly.csproj"
    _dotnet_set_project_environment "$DOTNET_PROJECT_DIR"

    run _dotnet_package_lib
    assert_success
    assert_file_exist "$TEST_TEMP_DIR/dotnet_calls.log"
    run cat "$TEST_TEMP_DIR/dotnet_calls.log"
    assert_success
    assert_output --partial "dotnet pack"
}
Loading