Implement Conformance Testing Script

#!/usr/bin/env pwsh

$ErrorActionPreference = 'Stop'

$UNRECOVERABLE_ERROR_EXIT_CODE = 69

$NPM_INSTALL_OUTPUT_FILTER = "up to date in|added [0-9]* packages, removed [0-9]* packages, and changed [0-9]* packages in|removed [0-9]* packages, and changed [0-9]* packages in|added [0-9]* packages in|removed [0-9]* packages in"

# Function to check and kill any Node process running on port 3000 (React development server)
function Check-AndKillNodeServer {
    try {
        $connections = Get-NetTCPConnection -LocalPort 3000 -ErrorAction SilentlyContinue
        if ($connections) {
            foreach ($conn in $connections) {
                $proc = Get-Process -Id $conn.OwningProcess -ErrorAction SilentlyContinue
                if ($proc -and $proc.ProcessName -eq "node") {
                    Write-Host "Found Node server running on port 3000. Killing it..."
                    Stop-Process -Id $proc.Id -Force -ErrorAction SilentlyContinue
                    Start-Sleep -Seconds 1
                    if ($env:VERBOSE -eq "1") {
                        Write-Host "Node server terminated."
                    }
                }
            }
        }
    } catch {
        # Silently ignore errors (port may not be in use)
    }
}

# Function to get all child processes of a given PID recursively
function Get-ChildProcesses {
    param([int]$ParentPid)

    $children = Get-CimInstance Win32_Process -Filter "ParentProcessId = $ParentPid" -ErrorAction SilentlyContinue
    $result = @()
    foreach ($child in $children) {
        $result += $child.ProcessId
        $result += Get-ChildProcesses -ParentPid $child.ProcessId
    }
    return $result
}

# Cleanup function to ensure all processes are terminated
function Cleanup {
    # Kill any running npm processes started by this script
    if ($script:NPM_PID) {
        Stop-Process -Id $script:NPM_PID -Force -ErrorAction SilentlyContinue
    }

    # Kill React app and its children if they exist
    if ($script:REACT_APP_PID) {
        $processesToKill = Get-ChildProcesses -ParentPid $script:REACT_APP_PID

        # Kill the main process
        Stop-Process -Id $script:REACT_APP_PID -Force -ErrorAction SilentlyContinue

        # Kill all the subprocesses
        foreach ($pid in $processesToKill) {
            Stop-Process -Id $pid -Force -ErrorAction SilentlyContinue
        }

        if ($env:VERBOSE -eq "1") {
            Write-Host "React app is terminated!"
        }
    }

    # Remove temporary files if they exist
    if ($script:build_output -and (Test-Path $script:build_output)) {
        Remove-Item $script:build_output -Force -ErrorAction SilentlyContinue
    }
}

# Check for and kill any existing Node server from previous runs
Check-AndKillNodeServer

# Check if build folder name is provided
if (-not $args[0]) {
    Write-Host "Error: No build folder name provided."
    Write-Host "Usage: $($MyInvocation.MyCommand.Name) <build_folder_name> <conformance_tests_folder>"
    exit $UNRECOVERABLE_ERROR_EXIT_CODE
}

# Check if conformance tests folder name is provided
if (-not $args[1]) {
    Write-Host "Error: No conformance tests folder name provided."
    Write-Host "Usage: $($MyInvocation.MyCommand.Name) <build_folder_name> <conformance_tests_folder>"
    exit $UNRECOVERABLE_ERROR_EXIT_CODE
}

$BuildFolder = $args[0]
$ConformanceTestsFolder = $args[1]

if ($args[2] -eq "-v" -or $args[2] -eq "--verbose") {
    $env:VERBOSE = "1"
}

$current_dir = Get-Location

try {
    # Define the path to the subfolder
    $NODE_SUBFOLDER = "node_$BuildFolder"

    # Running React application
    Write-Host "### Step 1: Starting the React application in folder $NODE_SUBFOLDER..."

    if ($env:VERBOSE -eq "1") {
        Write-Host "Preparing Node subfolder: $NODE_SUBFOLDER"
    }

    # Check if the node subfolder exists
    if (Test-Path $NODE_SUBFOLDER) {
        # Delete all files and folders except "node_modules", "plain_modules", and "package-lock.json"
        Get-ChildItem -Path $NODE_SUBFOLDER -Force |
            Where-Object {
                $_.Name -ne "node_modules" -and
                $_.Name -ne "plain_modules" -and
                $_.Name -ne "package-lock.json"
            } | Remove-Item -Recurse -Force

        if ($env:VERBOSE -eq "1") {
            Write-Host "Cleanup completed, keeping 'node_modules' and 'package-lock.json'."
        }
    } else {
        if ($env:VERBOSE -eq "1") {
            Write-Host "Subfolder does not exist. Creating it..."
        }

        New-Item -ItemType Directory -Path $NODE_SUBFOLDER -Force | Out-Null
    }

    Copy-Item -Path "$BuildFolder/*" -Destination $NODE_SUBFOLDER -Recurse -Force

    # Move to the subfolder
    if (-not (Test-Path $NODE_SUBFOLDER)) {
        Write-Host "Error: Node build folder '$NODE_SUBFOLDER' does not exist."
        exit $UNRECOVERABLE_ERROR_EXIT_CODE
    }

    Push-Location $NODE_SUBFOLDER

    # Temporarily allow stderr output without throwing (npm may write warnings to stderr)
    # ForEach-Object converts ErrorRecord objects (from stderr) to plain strings to avoid verbose error formatting
    $ErrorActionPreference = 'Continue'
    $npmInstallOutput = npm install --prefer-offline --no-audit --no-fund --loglevel error 2>&1 | ForEach-Object { if ($_ -is [System.Management.Automation.ErrorRecord]) { $_.Exception.Message } else { $_ } } | Out-String
    $ErrorActionPreference = 'Stop'
    # Filter out noisy npm install lines
    $npmInstallOutput -split "`n" | Where-Object { $_ -notmatch $NPM_INSTALL_OUTPUT_FILTER } | ForEach-Object {
        if ($_.Trim()) { Write-Host $_ }
    }

    if ($LASTEXITCODE -ne 0) {
        Write-Host "Error: Installing Node modules."
        exit 2
    }

    if ($env:VERBOSE -eq "1") {
        Write-Host "Building the application..."
    }

    $script:build_output = [System.IO.Path]::GetTempFileName()

    # Temporarily allow stderr output without throwing (build tools may write to stderr)
    $ErrorActionPreference = 'Continue'
    npm run build > $script:build_output 2>&1
    $ErrorActionPreference = 'Stop'

    if ($LASTEXITCODE -ne 0) {
        Write-Host "Error: Building application."
        Get-Content $script:build_output
        Remove-Item $script:build_output -Force -ErrorAction SilentlyContinue
        exit 2
    }

    Remove-Item $script:build_output -Force -ErrorAction SilentlyContinue

    if ($env:VERBOSE -eq "1") {
        Write-Host "Starting the application..."
    }

    # Start the React app in the background and redirect output to a log file
    $env:BROWSER = "none"
    $reactProcess = Start-Process -FilePath "npm" -ArgumentList "start", "--", "--no-open" `
        -NoNewWindow -PassThru -RedirectStandardOutput "app.log" -RedirectStandardError "app_err.log"

    if ($env:VERBOSE -eq "1") {
        Write-Host "Application is starting..."
    }

    # Capture the process ID
    $script:REACT_APP_PID = $reactProcess.Id

    # Try to find the child npm process
    Start-Sleep -Milliseconds 500
    $npmChild = Get-CimInstance Win32_Process -Filter "ParentProcessId = $($script:REACT_APP_PID)" -ErrorAction SilentlyContinue |
        Where-Object { $_.Name -match "npm" } | Select-Object -First 1
    if ($npmChild) {
        $script:NPM_PID = $npmChild.ProcessId
    }

    # Wait for the "compiled successfully!" or Vite ready message in the log file
    while ($true) {
        if (Test-Path "app.log") {
            $logContent = Get-Content "app.log" -Raw -ErrorAction SilentlyContinue
            if ($logContent) {
                if ($logContent -match "(?i)compiled successfully|compiled with warnings") {
                    break
                }
                if ($logContent -match "(?i)VITE v[0-9]+\.[0-9]+\.[0-9]+\s+ready in") {
                    break
                }
            }
        }

        # Also check if localhost:3000 responds
        try {
            $response = Invoke-WebRequest -Uri "http://localhost:3000" -UseBasicParsing -TimeoutSec 1 -ErrorAction SilentlyContinue
            if ($response) { break }
        } catch {
            # Not ready yet
        }

        # Check if the React app process is still running
        $proc = Get-Process -Id $script:REACT_APP_PID -ErrorAction SilentlyContinue
        if (-not $proc -or $proc.HasExited) {
            Write-Host "Error in :ImplementationCode: (React app process (PID: $($script:REACT_APP_PID)) has terminated unexpectedly)."
            if (Test-Path "app.log") { Get-Content "app.log" }
            if (Test-Path "app_err.log") { Get-Content "app_err.log" }
            exit 2
        }

        Start-Sleep -Milliseconds 100
    }

    # At this point, the React app is up and running in the background
    if ($env:VERBOSE -eq "1") {
        Write-Host "React app is up and running!"
    }

    Pop-Location

    # Execute all Cypress conformance tests in the build folder
    Write-Host "### Step 2: Running Cypress conformance tests $ConformanceTestsFolder..."

    # Move back to the original directory
    Set-Location $current_dir

    # Define the path to the conformance tests subfolder
    $NODE_CONFORMANCE_TESTS_SUBFOLDER = "node_$ConformanceTestsFolder"

    if ($env:VERBOSE -eq "1") {
        Write-Host "Preparing conformance tests Node subfolder: $NODE_CONFORMANCE_TESTS_SUBFOLDER"
    }

    # Check if the conformance tests node subfolder exists
    if (Test-Path $NODE_CONFORMANCE_TESTS_SUBFOLDER) {
        # Delete all files and folders except "node_modules", "plain_modules", and "package-lock.json"
        Get-ChildItem -Path $NODE_CONFORMANCE_TESTS_SUBFOLDER -Force |
            Where-Object {
                $_.Name -ne "node_modules" -and
                $_.Name -ne "plain_modules" -and
                $_.Name -ne "package-lock.json"
            } | Remove-Item -Recurse -Force

        if ($env:VERBOSE -eq "1") {
            Write-Host "Cleanup completed, keeping 'node_modules' and 'package-lock.json'."
        }
    } else {
        if ($env:VERBOSE -eq "1") {
            Write-Host "Subfolder does not exist. Creating it..."
        }

        New-Item -ItemType Directory -Path $NODE_CONFORMANCE_TESTS_SUBFOLDER -Force | Out-Null
    }

    Copy-Item -Path "$ConformanceTestsFolder/*" -Destination $NODE_CONFORMANCE_TESTS_SUBFOLDER -Recurse -Force

    # Move to the subfolder with Cypress tests
    if (-not (Test-Path $NODE_CONFORMANCE_TESTS_SUBFOLDER)) {
        Write-Host "Error: conformance tests Node folder '$NODE_CONFORMANCE_TESTS_SUBFOLDER' does not exist."
        exit $UNRECOVERABLE_ERROR_EXIT_CODE
    }

    Push-Location $NODE_CONFORMANCE_TESTS_SUBFOLDER

    # Temporarily allow stderr output without throwing (npm may write warnings to stderr)
    # ForEach-Object converts ErrorRecord objects (from stderr) to plain strings to avoid verbose error formatting
    $ErrorActionPreference = 'Continue'
    $npmInstallOutput = npm install cypress --save-dev --prefer-offline --no-audit --no-fund --loglevel error 2>&1 | ForEach-Object { if ($_ -is [System.Management.Automation.ErrorRecord]) { $_.Exception.Message } else { $_ } } | Out-String
    $ErrorActionPreference = 'Stop'
    $npmInstallOutput -split "`n" | Where-Object { $_ -notmatch $NPM_INSTALL_OUTPUT_FILTER } | ForEach-Object {
        if ($_.Trim()) { Write-Host $_ }
    }

    if ($env:VERBOSE -eq "1") {
        Write-Host "Running Cypress conformance tests..."
    }

    $ErrorActionPreference = 'Continue'
    $cypress_info_output = npx cypress info 2>&1 | ForEach-Object { if ($_ -is [System.Management.Automation.ErrorRecord]) { $_.Exception.Message } else { $_ } } | Out-String
    $ErrorActionPreference = 'Stop'
    $CYPRESS_BROWSER_FLAG = ""
    if ($cypress_info_output -match "(?i)chrome") {
        $CYPRESS_BROWSER_FLAG = "--browser=chrome"
    }
    Write-Host "CYPRESS_BROWSER_FLAG: $(if ($CYPRESS_BROWSER_FLAG) { $CYPRESS_BROWSER_FLAG } else { 'none' })"

    $env:BROWSERSLIST_IGNORE_OLD_DATA = "1"
    if ($CYPRESS_BROWSER_FLAG) {
        npx cypress run $CYPRESS_BROWSER_FLAG --config video=false 2>$null
    } else {
        npx cypress run --config video=false 2>$null
    }
    $cypress_run_result = $LASTEXITCODE

    if ($cypress_run_result -ne 0) {
        if ($env:VERBOSE -eq "1") {
            Write-Host "Error: Cypress conformance tests have failed."
        }
        exit 1
    }
} finally {
    Cleanup
}

#!/usr/bin/env pwsh

$ErrorActionPreference = 'Stop'

$UNRECOVERABLE_ERROR_EXIT_CODE = 69

# Check if build folder name is provided
if (-not $args[0]) {
    Write-Host "Error: No build folder name provided."
    Write-Host "Usage: $($MyInvocation.MyCommand.Name) <build_folder_name> <conformance_tests_folder>"
    exit $UNRECOVERABLE_ERROR_EXIT_CODE
}

# Check if conformance tests folder name is provided
if (-not $args[1]) {
    Write-Host "Error: No conformance tests folder name provided."
    Write-Host "Usage: $($MyInvocation.MyCommand.Name) <build_folder_name> <conformance_tests_folder>"
    exit $UNRECOVERABLE_ERROR_EXIT_CODE
}

$BuildFolder = $args[0]
$ConformanceTestsFolder = $args[1]

$current_dir = Get-Location

$GO_BUILD_SUBFOLDER = "go_$BuildFolder"

if ($env:VERBOSE -eq "1") {
    Write-Host "Preparing Go build subfolder: $GO_BUILD_SUBFOLDER"
}

# Check if the go build subfolder exists
if (Test-Path $GO_BUILD_SUBFOLDER) {
    # Delete all files and folders inside
    Get-ChildItem -Path $GO_BUILD_SUBFOLDER -Force | Remove-Item -Recurse -Force

    if ($env:VERBOSE -eq "1") {
        Write-Host "Cleanup completed."
    }
} else {
    if ($env:VERBOSE -eq "1") {
        Write-Host "Subfolder does not exist. Creating it..."
    }

    New-Item -ItemType Directory -Path $GO_BUILD_SUBFOLDER -Force | Out-Null
}

Copy-Item -Path "$BuildFolder/*" -Destination $GO_BUILD_SUBFOLDER -Recurse -Force

# Move to the subfolder
if (-not (Test-Path $GO_BUILD_SUBFOLDER)) {
    Write-Host "Error: Go build folder '$GO_BUILD_SUBFOLDER' does not exist."
    exit $UNRECOVERABLE_ERROR_EXIT_CODE
}

Push-Location $GO_BUILD_SUBFOLDER

try {
    Write-Host "Runinng go get in the build folder..."
    go get

    # Move to conformance tests folder
    Set-Location "$current_dir/$ConformanceTestsFolder"
    if ($LASTEXITCODE -and $LASTEXITCODE -ne 0) {
        Write-Host "Error: Conformance tests folder '$current_dir/$ConformanceTestsFolder' does not exist."
        exit $UNRECOVERABLE_ERROR_EXIT_CODE
    }

    Write-Host "Checking for go.mod in conformance test directory..."
    if (Test-Path "go.mod") {
        Write-Host "Running go get in conformance test directory..."
        go get
    } else {
        Write-Host "No go.mod found in conformance test directory, skipping go get"
    }

    # Move back to build directory
    Set-Location "$current_dir/$GO_BUILD_SUBFOLDER"

    # Execute Go lang conformance tests
    Write-Host "Running Golang conformance tests...`n"

    # Temporarily allow stderr output without throwing (Go may write to stderr)
    # ForEach-Object converts ErrorRecord objects (from stderr) to plain strings to avoid verbose error formatting
    $ErrorActionPreference = 'Continue'
    $output = go run "$current_dir/$ConformanceTestsFolder/conformance_tests.go" 2>&1 | ForEach-Object { if ($_ -is [System.Management.Automation.ErrorRecord]) { $_.Exception.Message } else { $_ } } | Out-String
    $exit_code = $LASTEXITCODE
    $ErrorActionPreference = 'Stop'

    # If there was an error, print the output and exit with the error code
    if ($exit_code -ne 0) {
        Write-Host $output
        exit $exit_code
    }

    # Exit with the exit code of the test command
    exit $exit_code
} finally {
    Pop-Location
}

#!/bin/bash
export JAVA_HOME=$(/usr/libexec/java_home -v 21)
java --version

# Check if build folder name is provided
if [ -z "$1" ]; then
  printf "Error: No build folder name provided.\n"
  printf "Usage: $0 <build_folder_name> <conformance_tests_folder>\n"
  exit 1
fi

# Check if conformance tests folder name is provided
if [ -z "$2" ]; then
  printf "Error: No conformance tests folder name provided.\n"
  printf "Usage: $0 <build_folder_name> <conformance_tests_folder>\n"
  exit 1
fi

current_dir=$(pwd)
printf "Current directory: $current_dir\n"

tree $2

JAVA_BUILD_SUBFOLDER=,tmp/$1

if [ "${VERBOSE:-}" -eq 1 ] 2>/dev/null; then
  printf "Preparing Java build subfolder: $JAVA_BUILD_SUBFOLDER\n"
fi

rm -rf $JAVA_BUILD_SUBFOLDER
mkdir -p $JAVA_BUILD_SUBFOLDER

cp -R $1/* $JAVA_BUILD_SUBFOLDER
printf "Copied from $1 to $JAVA_BUILD_SUBFOLDER...\n"

# Move to the subfolder
cd "$JAVA_BUILD_SUBFOLDER" 2>/dev/null
printf "Moved to $JAVA_BUILD_SUBFOLDER...\n"

if [ $? -ne 0 ]; then
  printf "Error: Java build folder '$JAVA_BUILD_SUBFOLDER' does not exist.\n"
  exit 2
fi

echo "Runinng maven install in $(pwd)..."
output=$(mvn clean install -DskipTests 2>&1)
exit_code=$?

# If there was an error, print the output and exit with the error code
if [ $exit_code -ne 0 ]; then
    echo "Command failed: mvn clean install -DskipTests"
    echo "Error: Running maven build failed with exit code $exit_code"
    echo "Output: $output"    
    exit $exit_code
fi

CONFORMANCE_TESTS_FOLDER=.tmp/java_conformance

cd "$current_dir" 2>/dev/null
printf "Moved to $current_dir...\n"
printf "Preparing Java conformance tests subfolder: $CONFORMANCE_TESTS_FOLDER\n"

rm -rf $CONFORMANCE_TESTS_FOLDER
mkdir -p $CONFORMANCE_TESTS_FOLDER

cp -R $2/* $CONFORMANCE_TESTS_FOLDER
printf "Copied from $2 to $CONFORMANCE_TESTS_FOLDER...\n"

# Move to the subfolder
cd "$CONFORMANCE_TESTS_FOLDER" 2>/dev/null
printf "Moved to $CONFORMANCE_TESTS_FOLDER...\n"

if [ $? -ne 0 ]; then
  printf "Error: Java conformance tests folder '$CONFORMANCE_TESTS_FOLDER' does not exist.\n"
  exit 2
fi

echo "Runinng maven install in $(pwd)..."
output=$(mvn clean install -DskipTests 2>&1)
exit_code=$?

# If there was an error, print the output and exit with the error code
if [ $exit_code -ne 0 ]; then
    echo "Command failed: mvn clean install -DskipTests"
    echo "Error: Running maven build failed with exit code $exit_code"
    echo "Output: $output"    
    exit $exit_code
fi

# Execute all Java unittests in the subfolder
echo "Running Java unittests in $(pwd)..."
output=$(mvn test 2>&1)
exit_code=$?

# If there was an error, print the output and exit with the error code
if [ $exit_code -ne 0 ]; then
    echo "$output"
    exit $exit_code
fi

# Echo the original exit code of the unittest command
exit $exit_code

#!/usr/bin/env pwsh

$ErrorActionPreference = 'Stop'

$UNRECOVERABLE_ERROR_EXIT_CODE = 69

# Check if build folder name is provided
if (-not $args[0]) {
    Write-Host "Error: No build folder name provided."
    Write-Host "Usage: $($MyInvocation.MyCommand.Name) <build_folder_name> <conformance_tests_folder>"
    exit $UNRECOVERABLE_ERROR_EXIT_CODE
}

# Check if conformance tests folder name is provided
if (-not $args[1]) {
    Write-Host "Error: No conformance tests folder name provided."
    Write-Host "Usage: $($MyInvocation.MyCommand.Name) <build_folder_name> <conformance_tests_folder>"
    exit $UNRECOVERABLE_ERROR_EXIT_CODE
}

$BuildFolder = $args[0]
$ConformanceTestsFolder = $args[1]

# Try to find Python interpreter (python3 first, then python)
if (Get-Command python3 -ErrorAction SilentlyContinue) {
    $PYTHON_CMD = "python3"
} elseif (Get-Command python -ErrorAction SilentlyContinue) {
    $PYTHON_CMD = "python"
} else {
    Write-Host "Error: Python interpreter not found. Please install Python."
    exit $UNRECOVERABLE_ERROR_EXIT_CODE
}

$current_dir = Get-Location

$PYTHON_BUILD_SUBFOLDER = "python_$BuildFolder"

if ($env:VERBOSE -eq "1") {
    Write-Host "Preparing Python build subfolder: $PYTHON_BUILD_SUBFOLDER"
}

# Check if the Python build subfolder exists
if (Test-Path $PYTHON_BUILD_SUBFOLDER) {
    # Delete all files and folders inside
    Get-ChildItem -Path $PYTHON_BUILD_SUBFOLDER -Force | Remove-Item -Recurse -Force

    if ($env:VERBOSE -eq "1") {
        Write-Host "Cleanup completed."
    }
} else {
    if ($env:VERBOSE -eq "1") {
        Write-Host "Subfolder does not exist. Creating it..."
    }

    New-Item -ItemType Directory -Path $PYTHON_BUILD_SUBFOLDER -Force | Out-Null
}

Copy-Item -Path "$BuildFolder/*" -Destination $PYTHON_BUILD_SUBFOLDER -Recurse -Force

# Move to the subfolder
if (-not (Test-Path $PYTHON_BUILD_SUBFOLDER)) {
    Write-Host "Error: Python build folder '$PYTHON_BUILD_SUBFOLDER' does not exist."
    exit $UNRECOVERABLE_ERROR_EXIT_CODE
}

Push-Location $PYTHON_BUILD_SUBFOLDER

try {
    # Execute all Python conformance tests in the build folder
    Write-Host "Running Python conformance tests...`n"

    # Temporarily allow stderr output without throwing (Python unittest writes progress to stderr)
    # ForEach-Object converts ErrorRecord objects (from stderr) to plain strings to avoid verbose error formatting
    $ErrorActionPreference = 'Continue'
    $output = & $PYTHON_CMD -m unittest discover -b -s "$current_dir/$ConformanceTestsFolder" 2>&1 | ForEach-Object { if ($_ -is [System.Management.Automation.ErrorRecord]) { $_.Exception.Message } else { $_ } } | Out-String
    $exit_code = $LASTEXITCODE
    $ErrorActionPreference = 'Stop'

    # Echo the original output
    Write-Host $output

    # Check if no tests were discovered
    if ($output -match "Ran 0 tests in") {
        Write-Host "`nError: No unittests discovered."
        exit 1
    }

    # Exit with the exit code of the unittest command
    exit $exit_code
} finally {
    Pop-Location
}

#!/bin/bash

UNRECOVERABLE_ERROR_EXIT_CODE=69

# Check if build folder name is provided
if [ -z "$1" ]; then
  printf "Error: No build folder name provided.\n"
  printf "Usage: $0 <build_folder_name> <conformance_tests_folder>\n"
  exit $UNRECOVERABLE_ERROR_EXIT_CODE
fi

# Check if conformance tests folder name is provided
if [ -z "$2" ]; then
  printf "Error: No conformance tests folder name provided.\n"
  printf "Usage: $0 <build_folder_name> <conformance_tests_folder>\n"
  exit $UNRECOVERABLE_ERROR_EXIT_CODE
fi

# Try to find Python interpreter (python3 first, then python)
if command -v python3 &> /dev/null; then
    PYTHON_CMD="python3"
elif command -v python &> /dev/null; then
    PYTHON_CMD="python"
else
    printf "Error: Python interpreter not found. Please install Python.\n"
    exit $UNRECOVERABLE_ERROR_EXIT_CODE
fi

current_dir=$(pwd)

PYTHON_BUILD_SUBFOLDER=".tmp/$1"

if [ "${VERBOSE:-}" -eq 1 ] 2>/dev/null; then
  printf "Preparing Python build subfolder: $PYTHON_BUILD_SUBFOLDER\n"
fi

rm -rf $PYTHON_BUILD_SUBFOLDER
mkdir -p $PYTHON_BUILD_SUBFOLDER

cp -R $1/* $PYTHON_BUILD_SUBFOLDER

# Move to the subfolder
cd "$PYTHON_BUILD_SUBFOLDER" 2>/dev/null

if [ $? -ne 0 ]; then
  printf "Error: Python build folder '$PYTHON_BUILD_SUBFOLDER' does not exist.\n"
  exit $UNRECOVERABLE_ERROR_EXIT_CODE
fi

printf "Creating and activating virtual environment...\n"

# Time the virtual environment creation and activation
start_time=$(date +%s.%N)

VENV_DIR=".venv"

if ! $PYTHON_CMD -m venv "$VENV_DIR"; then
    printf "Error: Failed to create virtual environment in '$VENV_DIR'.\n"
    exit $UNRECOVERABLE_ERROR_EXIT_CODE
fi

# shellcheck disable=SC1091
source "$VENV_DIR/bin/activate"

if [ $? -ne 0 ]; then
    printf "Error: Failed to activate virtual environment at '$VENV_DIR/bin/activate'.\n"
    exit $UNRECOVERABLE_ERROR_EXIT_CODE
fi

# Install requirements if requirements.txt exists
if [ -f "requirements.txt" ]; then
    pip install --upgrade pip
    pip install -r requirements.txt
else
    echo "Warning: requirements.txt not found. Cannot proceed with setting up requirements. The requirements may also already be installed"
fi

end_time=$(date +%s.%N)

# Calculate and display the time taken
duration=$(echo "$end_time - $start_time" | bc)
printf "Requirements setup completed in %.2f seconds\n\n" "$duration"

# Execute all Python conformance tests in the build folder
printf "Running Python conformance tests...\n\n"

output=$($PYTHON_CMD -m unittest discover -b -s "$current_dir/$2" 2>&1)
exit_code=$?

# Echo the original output
echo "$output"

# Check if no tests were discovered
if echo "$output" | grep -q "Ran 0 tests in"; then
    printf "\nError: No unittests discovered.\n"
    exit 1
fi

# Echo the original exit code of the unittest command
exit $exit_code