Input Validation¶

Input validation is one of the most important pillars of professional PowerShell scripting. A script that accepts user input—parameters, file paths, credentials, or data from external systems—must verify that the input is correct, safe, and usable before performing any actions. Without validation, scripts become fragile, unpredictable, and potentially dangerous.

This section explains why input validation matters, how PowerShell supports it natively, and how to design robust validation strategies that prevent errors and protect your environment.

1. Why Input Validation Matters¶

Professional scripts must assume that input may be:

• Missing
• Incorrect
• Malformed
• Unexpected
• Unsafe

Good validation ensures:

• Reliability — the script behaves predictably
• Safety — invalid input does not cause destructive actions
• Clarity — users receive meaningful error messages
• Maintainability — future administrators understand constraints
• Security — malicious or accidental misuse is prevented

A script that validates input early avoids cascading failures later.

2. PowerShell’s Built‑In Validation Attributes¶

PowerShell provides a rich set of validation attributes that can be applied directly to parameters. These attributes enforce rules before the script runs any logic.

Common validation attributes include:

• [ValidateNotNull()] — value cannot be $null
• [ValidateNotNullOrEmpty()] — value cannot be empty
• [ValidateSet()] — restricts input to specific values
• [ValidateRange()] — enforces numeric boundaries
• [ValidatePattern()] — enforces regex patterns
• [ValidateScript()] — custom validation logic

These attributes make validation declarative and consistent.

3. Examples of Parameter Validation¶

3.1 Ensuring a required string is not empty¶

param(
    [Parameter(Mandatory)]
    [ValidateNotNullOrEmpty()]
    [string]$UserName
)

This prevents the script from running unless a valid username is provided.

3.2 Restricting input to a predefined set¶

param(
    [ValidateSet("Low","Medium","High")]
    [string]$Priority
)

This ensures that only valid values are accepted.

3.3 Validating numeric ranges¶

param(
    [ValidateRange(1, 100)]
    [int]$RetryCount
)

This prevents invalid or dangerous values from being used.

3.4 Validating with a regular expression¶

param(
    [ValidatePattern("^[a-z0-9._%-]+@contoso\.com$")]
    [string]$Email
)

This ensures the email address matches a specific domain format.

3.5 Using custom validation logic¶

ValidateScript allows you to write arbitrary validation code.

param(
    [ValidateScript({ Test-Path $_ })]
    [string]$Path
)

This ensures the provided path exists before the script runs.

4. Manual Validation Inside the Script¶

Not all validation can be expressed through attributes. Sometimes you need more complex logic.

Example: validating a CSV file structure¶

$requiredColumns = "Name","SamAccountName","Password"
$csv = Import-Csv $Path

foreach ($col in $requiredColumns) {
    if (-not ($csv | Get-Member -Name $col)) {
        throw "The CSV file is missing the required column: $col"
    }
}

This prevents the script from running with incomplete data.

5. Validating External Dependencies¶

Professional scripts also validate:

Modules¶

if (-not (Get-Module -ListAvailable ActiveDirectory)) {
    throw "ActiveDirectory module is required."
}

Permissions¶

if (-not ([bool](whoami /groups | Select-String "Domain Admins"))) {
    throw "This script must be run as a domain administrator."
}

Network connectivity¶

if (-not (Test-Connection -ComputerName $Server -Count 1 -Quiet)) {
    throw "Cannot reach server: $Server"
}

Validation must extend beyond parameters to the entire execution environment.

6. Providing Helpful Error Messages¶

Validation errors should be:

• Clear
• Specific
• Actionable

Bad example¶

Error: Invalid input.

Good example¶

The value 'abc' is not valid for parameter RetryCount. Expected a number between 1 and 100.

Clear messages reduce confusion and support troubleshooting.

7. Failing Fast¶

A professional script should stop immediately when validation fails.

This prevents:

• Partial execution
• Inconsistent state
• Corrupted data
• Unpredictable behavior

Example¶

if (-not (Test-Path $Path)) {
    throw "Input file not found: $Path"
}

Failing fast is safer than attempting to continue.

8. Combining Validation with Logging¶

Validation and logging work together:

if (-not (Test-Path $Path)) {
    Write-Log -Message "Input file missing: $Path" -Level "ERROR" -Path $LogPath
    throw "Input file not found."
}

This ensures that validation failures are recorded for auditing.

9. Practical Example: A Script with Strong Validation¶

param(
    [Parameter(Mandatory)]
    [ValidateNotNullOrEmpty()]
    [string]$Path,

    [ValidateSet("Low","Medium","High")]
    [string]$Priority = "Medium",

    [ValidateScript({ Test-Path $_ })]
    [string]$LogPath
)

if (-not (Get-Module -ListAvailable ActiveDirectory)) {
    throw "ActiveDirectory module is required."
}

$csv = Import-Csv $Path
if (-not $csv) {
    throw "The CSV file is empty or invalid."
}

This script:

• Validates parameters
• Validates environment
• Validates input files
• Prevents execution unless everything is correct

10. Summary¶

Input validation is a core component of professional PowerShell scripting. It ensures that your scripts are:

• Safe
• Predictable
• Maintainable
• User‑friendly
• Resistant to invalid or malicious input

By using PowerShell’s built‑in validation attributes, performing manual checks, validating the environment, and providing clear error messages, you create scripts that behave reliably and inspire confidence in anyone who uses them.