test

#!/bin/bash

set -e
set -x

export path_test="./tmp-test"

export TEST_MODE="${TEST_MODE:-full}"
export REUSE_EXISTING_WORKSPACE="${REUSE_EXISTING_WORKSPACE:-no}"
export TEARDOWN_ENVIRONMENT="${TEARDOWN_ENVIRONMENT:-yes}"

function main()
{
    local harness="$1"
    local mode="$2"
    local sync="${3:-}"
    local akeneo_version
    local drupal_version

    local sync_path=""
    if [[ -n "$sync" ]]; then
      sync_path="-${sync}"
    fi
    export path_test="./tmp-test-${harness}-${mode}${sync_path}"

    if [[ "$TEARDOWN_ENVIRONMENT" == "yes" ]]; then
      trap 'clean' EXIT
    fi

    if [[ "$mode" == "static" ]]; then
      export MY127WS_ENV=pipeline
    fi

    if [[ "$harness" =~ ^(akeneo5)$ ]]; then
        akeneo_version=5
        harness="akeneo"
    elif [[ "$harness" =~ ^(akeneo6)$ ]]; then
        akeneo_version=6
        harness="akeneo"
    elif [[ "$harness" =~ ^(akeneo7)$ ]]; then
        akeneo_version=7
        harness="akeneo"
    fi
    if [[ "$harness" =~ ^(drupal10)$ ]]; then
        drupal_version=10
        harness="drupal"
    elif [[ "$harness" =~ ^(drupal9)$ ]]; then
        drupal_version=9
        harness="drupal"
    elif [[ "$harness" =~ ^(drupal8)$ ]]; then
        drupal_version=8
        harness="drupal"
    fi

    if [[ "$REUSE_EXISTING_WORKSPACE" != "yes" ]]; then
      # Test default mode of static or dynamic harnesses
      # For dynamic this means a mountpoint for the application code
      # or mutagen
      setup "$harness" "$mode"
      if [[ "$sync" == "" ]]; then
        setup_dynamic_mountpoint
      elif [[ "$sync" == "mutagen" ]]; then
        setup_dynamic_mutagen
      fi
      if [ -n "${akeneo_version:-}" ]; then
        setup_akeneo_version "$akeneo_version"
      fi
      if [ -n "${drupal_version:-}" ]; then
        setup_drupal_version "$drupal_version"
      fi
      prepare_environment
    fi

    if [[ "$TEST_MODE" == "quality" || "$TEST_MODE" == "full" ]]; then
      test_harness_quality "$harness" "$mode" "$sync"
    fi
    if [[ "$TEST_MODE" == "acceptance" || "$TEST_MODE" == "full"  ]]; then
      test_harness_acceptance "$harness" "$mode" "$sync"
    fi
    if [[ "$TEARDOWN_ENVIRONMENT" == "yes" ]]; then
      teardown
    fi
}

function test_harness_quality()
{
    local harness="$1"
    local mode="$2"
    local sync="$3"

    ./quality "${path_test}/.my127ws"
}

function test_harness_acceptance()
(
    local harness="$1"
    local mode="$2"
    local sync="$3"

    if ! [[ "$harness" =~ ^(magento1)$ ]]; then
      install_console
      run_project_quality_tests "$harness"
    fi
    install_environment
    check_environment_started "$harness" "$mode"
    run_project_acceptance_tests "$harness"
    restart_environment
    check_environment_started "$harness" "$mode"
    if [[ "$sync" != "" ]]; then
      wait_for_vendor_directory
    fi
)

function setup()
(
    local harness="$1"
    local mode="$2"

    local path_harness="./dist/harness-${harness}"

    if [ -d "${path_test}" ]; then
        rm -rf "${path_test}"
    fi

    cp -ap "${path_harness}/.ci/sample-${mode}" "${path_test}"

    # download parent harness layers
    pushd "${path_test}" >/dev/null
    ws harness download
    popd >/dev/null

    rsync --archive "${path_harness}/" "${path_test}/.my127ws/"
)

function prepare_environment()
(
    cd "${path_test}"

    if [ -e init.sh ]; then
        bash -x ./init.sh
    fi

    ws harness prepare
)

function install_console()
(
    cd "${path_test}"
    ws enable console
)

function install_environment()
(
    cd "${path_test}"
    ws install
)

function check_environment_started()
(
    local harness="$1"
    local mode="$2"

    cd "${path_test}"

    project="ci-${harness}-sample-${mode}"
    if [[ "$mode" == "static" ]]; then
      project="$(git log -n 1 --pretty=format:'%H')"
    fi

    if [ "$(docker compose -p "$project" ps | grep -v "lighthouse" | grep -c Exit)" -gt 0 ]; then
      echo 'Some containers failed to start'
      docker compose -p "$project" ps
      return 1
    fi
)

function run_project_quality_tests()
(
  local harness="$1"
  cd "${path_test}"

  ws helm kubeval --cleanup app

  # Check if we have a composer.json so we can run tests
  # Check inside the console container as static builds do not
  # update the local filesystem
  if ws exec stat /app/composer.json > /dev/null 2>&1; then
    # Run checks that don't reqiure development dependencies
    ws exec composer test-production-quality
    # Bring in dev dependencies
    ws exec app composer:development_dependencies
    # Run the tests
    ws exec composer test-quality
    if [[ "${harness}" != "drupal" ]]; then
      ws exec composer test-unit
    fi
  fi
)

function run_project_acceptance_tests()
(
    local harness="$1"

    if [[ "$harness" =~ ^(magento1)$ ]]; then
      run_project_quality_tests "$harness"
    fi

    cd "${path_test}"

    # Check if we have a composer.json so we can run tests
    # Check inside the console container as static builds do not
    # update the local filesystem
    if ws exec stat /app/composer.json > /dev/null 2>&1; then
      ws exec composer test-acceptance
    fi
    if [[ "${harness}" == "drupal" ]]; then
      ws test-unit
    fi

    ws lighthouse
)

function restart_environment()
(
    cd "${path_test}"
    ws disable
    ws enable
)

function setup_dynamic_mountpoint()
(
    cd "${path_test}"
    echo "attribute('host.os'): linux" > workspace.override.yml
)

function setup_dynamic_mutagen()
(
    cd "${path_test}"
    echo "attribute('host.os'): darwin" > workspace.override.yml
    echo "attribute('mutagen'): yes" >> workspace.override.yml
)

function setup_akeneo_version() {
    local version="$1"
    echo "attribute('akeneo.major_version'): ${version}" >> "${path_test}/workspace.override.yml"
}

function setup_drupal_version() {
    local version="$1"
    echo "attribute('drupal.major_version'): ${version}" >> "${path_test}/workspace.override.yml"
}

function wait_for_vendor_directory()
(
    set +x
    cd "${path_test}"
    if [ ! -f composer.json ]; then
        return 0
    fi
    local timer=600
    while [ $timer -gt 0 ]; do
      if [ -d vendor ]; then
          echo "Found vendor directory, sync worked"
          return 0
      fi
      timer=$(( timer - 1 ))
      sleep 1
    done
    echo "vendor directory not found within 600 seconds, sync failed"
    ls -la
    return 1
)

function teardown()
(
    cd "${path_test}"
    ws destroy || (docker ps -a && return 1)
    rm -rf .my127ws
)

function clean()
{
    if [ -d "$path_test" ]; then 
        if [ -d "${path_test}/.my127ws" ]; then
            (cd "$path_test" && ws destroy) || (docker ps -a && return 1)
        fi
        rm -rf "$path_test"
    fi
}

main "$@"