Skip to content

Instantly share code, notes, and snippets.

Embed
What would you like to do?
Source code belonging with blogpost at http://blog.victorvogelpoel.nl about testing a SharePoint 2007 deployment with PowerShell tests.Source code contains following PowerShell (v2) functions for SharePoint 2007: Get-SPFeature, Get-SPSolution, Add-SPSolution, Wait-SPSolutionJob, Install-SPSolution, Remove-SPSolution, Uninstall-SPSolution + Get-S…
# Test-PortalDeployment.ps1
# Written for SharePoint 2007, but with a few adaptations it'll work for later versions as well...
# This is a example of testing SharePoint portal artefact deployment and configuration using PSaint testing framework
# Victor Vogelpoel <victor@victorvogelpoel.nl>
# September 2013
# See blogpost at http://blog.victorvogelpoel.nl
#
# Note: SharePoint 2007 requires PowerShell v2 (not v3),
# so start PowerShell session with "PowerShell -version 2"
#
# Disclaimer
# This script is provided AS IS without warranty of any kind. I disclaim all implied warranties including, without limitation,
# any implied warranties of merchantability or of fitness for a particular purpose. The entire risk arising out of the use or
# performance of the sample scripts and documentation remains with you. In no event shall I be liable for any damages whatsoever
# (including, without limitation, damages for loss of business profits, business interruption, loss of business information,
# or other pecuniary loss) arising out of the use of or inability to use the script or documentation.
Set-PSDebug -Strict
Set-StrictMode -Version Latest
# Allways stop at an error
$global:ErrorActionPreference = "Stop"
# Load SharePoint assemblies
[reflection.assembly]::LoadWithPartialName("Microsoft.SharePoint") | out-null
$PSScriptRoot = $MyInvocation.MyCommand.Path | Split-Path # Directory /Test/
function Initialize-TestFramework
{
[CmdletBinding(SupportsShouldProcess=$false)]
param
(
[Parameter(HelpMessage="If the test framework was loaded before, the force switch will unload the framework before loading it again")]
[switch]$Force
)
$modulesDirectory = Join-Path $PSScriptRoot "Modules" # Directory "/Test/Modules/
$rootDirectory = $script:modulesDirectory | Split-Path # Directory
$moduleNames = "Reflection", "PSaint"
$loadedModules = @(Get-Module $moduleNames | select -ExpandProperty name)
if (($loadedModules.Length -eq 0) -or $Force)
{
if ($loadedModules.Length -gt 0)
{
Write-Host "Unloading modules $($loadedModules -join ', ')."
Remove-Module $loadedModules -ErrorAction SilentlyContinue -Force
}
# Load Module Reflection and PSaint, TypeExtensions and FormatExtensions
Write-Host "Loading module: Reflection ..."
Import-Module "$modulesDirectory\Reflection\Reflection.psd1" -Force -Global
# if (!(Test-Path variable:global:ReflectionTypeExtensionLoaded))
# {
# Set-Variable -Name "ReflectionTypeExtensionLoaded" -Scope global -Value $true -Force
# Update-TypeData "$modulesDirectory\Reflection\extensionMethods.ps1xml"
# }
Write-Host "Loading module: PSaint ..."
Import-Module "$modulesDirectory\PSaint\PSaint.psd1" -Force -Global
}
<#
.SYNOPSIS
Initialize the PSaint test framework for use: load the PSaint module
.DESCRIPTION
Initialize the Testing framework by loading PSaint and Reflection
modules and Type-/Format extensions.
.PARAMETER Force
If the test framework was loaded before, the force switch will unload
the framework before loading it again.
Note that the type/format extensions cannot be reloaded.
.LINK
about_MacawPowerShell
about_MacawPowerShell_Tests
#>
}
##---------------------------------------------------------------------------------------------------------------------------------------------------
function Get-SPSolution
{
[CmdletBinding(SupportsShouldProcess=$false)]
param
(
[Parameter(Mandatory=$false, Position=0, ValueFromPipeline=$true, ValueFromPipelineByPropertyName=$true, HelpMessage="Name of the solution")]
[Alias("SolutionName")]
[string[]]$Name = "*" # name can contain wildcards
)
process
{
foreach ($aName in $Name)
{
Write-Output ([Microsoft.SharePoint.Administration.SPFarm]::Local.Solutions | where { $_.Name -like $aName})
}
}
<#
.SYNOPSIS
Get all solutions from the SharePoint solution store or the solution specified by name
.DESCRIPTION
.PARAMETER $Name
One or more names of the wsp to get the SPSolution; name may be a wildcard!
if not specified, all SPSolutions are returned;
.NOTES
Author : Victor Vogelpoel
.LINK
.EXAMPLE
[ps] Get-SPSolution | select name,deployed
Name Deployed
---- --------
lapointe.sharepoint.stsadm.commands.wsp True
radeditormoss.wsp True
.EXAMPLE
[ps] Get-SPSolution -name "radeditormoss.wsp" | select name
Name
----
radeditormoss.wsp
.EXAMPLE
[ps] Get-SPSolution -name "rad*.wsp" | select name
Name
----
radeditormoss.wsp
.EXAMPLE
[ps] Get-SPSolution -name "rad*.wsp", "lapointe*.wsp" | select name
Name
----
radeditormoss.wsp
lapointe.sharepoint.stsadm.commands.wsp
#>
}
#---------------------------------------------------------------------------------------------------------------------------------------------------
function Add-SPSolution
{
[CmdletBinding(SupportsShouldProcess=$false)]
param
(
[Parameter(Mandatory=$true, Position=0, ValueFromPipeline=$true, ValueFromPipelineByPropertyName=$true, HelpMessage="Path to the WSP file")]
[Alias("Filename")]
[string[]]$Path
)
process
{
foreach ($wspfile in $Path)
{
if ($PSCmdLet.ShouldProcess("$wspfile", "Add-SPSolution `"$wspfile`""))
{
Write-Host "Adding SP solution `"$wspfile`"..."
trap { Write-Host "ERROR: $($_.Exception.Message)"; if ($_.Exception.Message -like "Access denied*") { throw "ERROR: executing account does not have proper permissions" } else {continue} }
Write-Output ([Microsoft.SharePoint.Administration.SPFarm]::Local.Solutions.Add($wspfile))
}
}
}
}
function Wait-SPSolutionJob
{
[CmdletBinding(SupportsShouldProcess=$true, DefaultParameterSetName="SolutionName")]
param
(
[Parameter(Mandatory=$true, Position=0, ParameterSetName="SolutionName", ValueFromPipeline=$true, ValueFromPipelineByPropertyName=$true, HelpMessage="Name of the solution")]
[Alias("SolutionName")]
[string]$Name, # name can contain wildcards,
[Parameter(Mandatory=$true, Position=0, ParameterSetName="Solution", ValueFromPipeline=$true, ValueFromPipelineByPropertyName=$true, HelpMessage="Solution")]
[Alias("Solution")]
[Microsoft.SharePoint.Administration.SPSolution]$SPSolution
)
process
{
if ($psCmdlet.ParameterSetName -eq "Solution")
{
$Name = $SPSolution | Select -ExpandProperty Name
}
$solutions = Get-SPSolution -name $Name
if ($solutions)
{
foreach ($solution in $solutions)
{
$solutionName = $solution.Name
if ($solution.JobExists)
{
$waitForMax = 720 # after 720*5 = 3600 seconds , the script should exit
while ($waitForMax -gt 0 -and
$solution.JobExists -and
(($solution.JobStatus -eq [Microsoft.SharePoint.Administration.SPRunningJobStatus]::Initialized) -or
($solution.JobStatus -eq [Microsoft.SharePoint.Administration.SPRunningJobStatus]::Scheduled)))
{
$waitForMax--
Write-Host "Job for solution `"$solutionName`" is `"$($solution.JobStatus)`". (Waiting 5 seconds for next update...)"
Start-Sleep -Seconds 5 # wait 5 second
# Re-get the solution object
$solution = Get-SPSolution -name $solutionName
}
}
}
}
else
{
Write-Verbose "No solution found for name `"$name`": nothing to wait for."
}
}
}
function Install-SPSolution
{
[CmdletBinding(SupportsShouldProcess=$true, DefaultParameterSetName="SolutionName")]
param
(
[Parameter(Mandatory=$true, Position=0, ParameterSetName="SolutionName", ValueFromPipeline=$true, ValueFromPipelineByPropertyName=$true, HelpMessage="Name of the solution")]
[Alias("SolutionName")]
[string[]]$Name, # name can contain wildcards,
[Parameter(Mandatory=$true, Position=0, ParameterSetName="Solution", ValueFromPipeline=$true, ValueFromPipelineByPropertyName=$true, HelpMessage="Solution")]
[Alias("Solution")]
[Microsoft.SharePoint.Administration.SPSolution[]]$SPSolution,
[Parameter(Mandatory=$false, ValueFromPipelineByPropertyName=$true, HelpMessage="Optional URL to retract the solution from")]
[string]$Url = "",
[Parameter(Mandatory=$false, HelpMessage="Optional to deploy the solution to all Content URLs")]
[switch]$AllContentUrls,
[Parameter(Mandatory=$false, HelpMessage="Optional to indicate that deployment to GAC is allowed")]
[switch]$AllowGACDeployment,
[Parameter(Mandatory=$false, HelpMessage="Optional to force deployment of the solution")]
[switch]$Force
)
begin
{
$dateToGuaranteeInstantAction = [datetime]::Now.AddDays(-2)
$whatif = ($PSBoundParameters["Whatif"] -eq $true)
}
process
{
if ($psCmdlet.ParameterSetName -eq "Solution")
{
$Name = $SPSolution | Select -ExpandProperty Name
}
$solutions = Get-SPSolution -name $name
foreach ($solution in $solutions)
{
if ($solution)
{
$solutionName = $solution.Name
# Construct a commandtext
$verboseCommand = "Install-SPSolution $solutionName"
if (!([string]::IsNullOrEmpty($url))) { $verboseCommand = ($verboseCommand + " to url=$url" ) }
elseif ($allContentUrls) { $verboseCommand = ($verboseCommand + " to all content urls" ) }
$verboseCommand = ($verboseCommand + ", allowGACDeployment=$allowGACDeployment, force=$force")
if ($PSCmdLet.ShouldProcess("Solution `"$($solution.Name)`" on url=$url, allcontenturls=$allContentUrls", "Install-SPSolution"))
{
if ($solution.ContainsWebApplicationResource)
{
$webApplicationsCollection = $null
$verboseText = ""
if ($allContentUrls)
{
# Get all content webapplications
$webApplicationsCollection = Get-SPWebApplicationCollection
$verboseText = "all content URLs"
}
elseif ([string]::IsNullOrEmpty($url))
{
throw "ERROR: Solution contains webapplication resources; please specify -url or -AllContentUrls"
}
else
{
# Get the webapplication for the specified url
$webApplicationsCollection = Get-SPWebApplicationCollection -url $url
if (!$webApplicationsCollection) { throw "ERROR: Cannot find webapplication with url `"$url`"" }
$verboseText = $url
}
Write-Host "Deploying $solutionName to $verboseText allowGACDeployment=$allowGACDeployment, force=$force..."
trap { Write-Host "ERROR: $($_.Exception.Message)"; if ($_.Exception.Message -like "Access denied*") { throw "ERROR: executing account does not have proper permissions" } else {continue} }
$solution.Deploy($dateToGuaranteeInstantAction, $allowGACDeployment, $webApplicationsCollection, $force)
}
else
{
Write-Host ("Deploying $solutionName globally; allowGACDeployment=$allowGACDeployment, force=$force...")
trap { Write-Host "ERROR: $($_.Exception.Message)"; if ($_.Exception.Message -like "Access denied*") { throw "ERROR: executing account does not have proper permissions" } else {continue} }
$solution.Deploy($dateToGuaranteeInstantAction, $allowGACDeployment, $force)
}
# Allways wait for the job to finish (or for a timeout)
Wait-SPSolutionJob -name $solutionName
# Now test if the deployment was successful:
$testsolution = Get-SPSolution -name $solutionName
if ($testsolution)
{
if ($testsolution.LastOperationResult -ne "DeploymentSucceeded")
{
throw "ERROR: solution `"$solutionName`" deployment failed; LastOperationResult is $($testsolution.LastOperationResult); Details: $($testsolution.LastOperationDetails)"
}
Write-Host $testsolution.LastOperationDetails
}
}
}
else
{
if ($whatif)
{
Write-Host "What if: cannot find any solutions with name `"$Name`"; deployment aborted"
}
else
{
throw "ERROR: cannot find any solutions with name `"$Name`"; deployment aborted"
}
}
}
}
}
##---------------------------------------------------------------------------------------------------------------------------------------------------
# Get-SPWebApplicationCollection gets a typed generic Collection<SPWebApplication>
function Get-SPWebApplicationCollection
{
[CmdletBinding(SupportsShouldProcess=$false)]
param
(
[Parameter(Mandatory=$false, Position=0, ValueFromPipeline=$true, ValueFromPipelineByPropertyName=$true, HelpMessage="URL of any zone in the SharePoint webapp to return the WebApplication object(s) for")]
[string]$url = ""
)
process
{
Enter
try
{
$coll = New-GenericObject2 -typename System.Collections.ObjectModel.Collection -typeParameters ([Microsoft.SharePoint.Administration.SPWebApplication])
# Copy collection...
Get-SPWebApplication -url $url | foreach { $coll.psbase.Add($_) }
#explanation of oddball return syntax lies here:
#http://stackoverflow.com/questions/695474
return @(,$coll)
}
finally
{
Leave
}
}
}
# http://www.leeholmes.com/blog/CreatingGenericTypesInPowerShell.aspx
function New-GenericObject2
{
param(
[string] $typeName = $(throw "Missing: a generic type name"),
[string[]] $typeParameters = $(throw "Missing: the type parameters"),
[object[]] $constructorParameters
)
## Create the generic type name
$genericTypeName = $typeName + '`' + $typeParameters.Count
$genericType = [Type] $genericTypeName
if(-not $genericType)
{
throw "Could not find generic type $genericTypeName"
}
## Bind the type arguments to it
[type[]] $typedParameters = $typeParameters
$closedType = $genericType.MakeGenericType($typedParameters)
if(-not $closedType)
{
throw "Could not make closed type $genericType"
}
## Create the closed version of the generic type
$instance = ,[Activator]::CreateInstance($closedType, $constructorParameters)
return $instance
}
function Remove-SPSolution
{
[CmdletBinding(SupportsShouldProcess=$true, DefaultParameterSetName="SolutionName")]
param
(
[Parameter(Mandatory=$true, Position=0, ParameterSetName="SolutionName", ValueFromPipeline=$true, ValueFromPipelineByPropertyName=$true, HelpMessage="Name of the solution")]
[Alias("SolutionName")]
[string[]]$Name, # name can contain wildcards,
[Parameter(Mandatory=$true, Position=0, ParameterSetName="Solution", ValueFromPipeline=$true, ValueFromPipelineByPropertyName=$true, HelpMessage="Solution")]
[Alias("Solution")]
[Microsoft.SharePoint.Administration.SPSolution[]]$SPSolution
)
process
{
$whatif = ($PSBoundParameters["Whatif"] -eq $true)
if ($psCmdlet.ParameterSetName -eq "Solution")
{
$Name = $SPSolution | Select -ExpandProperty Name
}
foreach ($solname in $Name)
{
$solutions = Get-SPSolution -name $solname
if ($solutions)
{
foreach ($solution in $solutions)
{
if ($solution)
{
if ($PSCmdLet.ShouldProcess($solution.Name, "Remove-SPSolution"))
{
Write-Host "Deleting SP Solution $($solution.Name)..."
trap { Write-Host "ERROR: $($_.Exception.Message)"; if ($_.Exception.Message -like "Access denied*") { throw "ERROR: executing account does not have proper permissions" } else {continue} }
$solution.Delete()
}
}
}
}
else
{
if ($whatif)
{
Write-Host "What if: cannot find any solutions with name `"$Name`"'; nothing is deleted"
}
else
{
throw "ERROR: No solution(s) found in SharePoint solution store with name `"$Name`""
}
}
}
}
}
function Uninstall-SPSolution
{
[CmdletBinding(SupportsShouldProcess=$true, DefaultParameterSetName="SolutionName")]
param
(
[Parameter(Mandatory=$true, Position=0, ParameterSetName="SolutionName", ValueFromPipeline=$true, ValueFromPipelineByPropertyName=$true, HelpMessage="Name of the solution")]
[Alias("SolutionName")]
[string[]]$Name, # name can contain wildcards,
[Parameter(Mandatory=$true, Position=0, ParameterSetName="Solution", ValueFromPipeline=$true, ValueFromPipelineByPropertyName=$true, HelpMessage="Solution")]
[Alias("Solution")]
[Microsoft.SharePoint.Administration.SPSolution[]]$SPSolution,
[Parameter(Mandatory=$false, ValueFromPipelineByPropertyName=$true, HelpMessage="Optional URL to retract the solution from")]
[string]$Url = "",
[Parameter(Mandatory=$false, HelpMessage="Optional to retract the solution from all Content URLs")]
[switch]$allContentUrls
)
begin
{
$dateToGuaranteeInstantAction = [datetime]::Now.AddDays(-2)
$whatif = ($PSBoundParameters["Whatif"] -eq $true)
}
process
{
if ($psCmdlet.ParameterSetName -eq "Solution")
{
$Name = $SPSolution | Select -ExpandProperty Name
}
#$solutions = [Microsoft.SharePoint.Administration.SPFarm]::Local.Solutions[$wspname]
$solutions = Get-SPSolution -name $Name
if ($solutions)
{
foreach ($solution in $solutions)
{
if ($solution)
{
$solutionName = $solution.Name
if ($PSCmdLet.ShouldProcess("Solution `"$($solution.Name)`" on url=$url, allcontenturls=$allContentUrls", "Retract-SPSolution"))
{
if ($solution.ContainsWebApplicationResource)
{
# retract from webapplications
$webApplicationsCollection = $null
$verboseText = ""
if ($allContentUrls)
{
# Get all content webapplications
$webApplicationsCollection = Get-SPWebApplicationCollection
$verboseText = "all content URLs"
}
elseif ([string]::IsNullOrEmpty($url))
{
throw "ERROR: Solution contains webapplication resources; please specify -url or -AllContentUrls"
}
else
{
# Get the webapplication for the specified url
$webApplicationsCollection = Get-SPWebApplicationCollection -url $url
if ($webApplicationsCollection -eq $null)
{
throw "ERROR: cannot find webapplication for $url; aborting retract"
}
$verboseText = $url
}
Write-Host "Retracting SP Solution `"$($solution.Name)`" from $verboseText..."
# Retract from the webapplication; SharePoint adds a job that is executed by the Timer service
trap { Write-Host "ERROR: $($_.Exception.Message)"; if ($_.Exception.Message -like "Access denied*") { throw "ERROR: executing account does not have proper permissions" } else {continue} }
$solution.Retract($dateToGuaranteeInstantAction, $webApplicationsCollection)
}
else
{
Write-Host "Retracting SP Solution `"$($solution.Name)`" globally..."
# Retract globally; SharePoint adds a job that is executed by the Timer service
trap { Write-Host "ERROR: $($_.Exception.Message)"; if ($_.Exception.Message -like "Access denied*") { throw "ERROR: executing account does not have proper permissions" } else {continue} }
$solution.Retract($dateToGuaranteeInstantAction)
}
# Always wait for the job to finish
Wait-SPSolutionJob -name $solutionName
# Now test if the retraction was successful:
$testsolution = Get-SPSolution -name $solutionName
if ($testsolution)
{
if ($testsolution.LastOperationResult -ne "RetractionSucceeded")
{
throw "ERROR: solution $solutionName retraction failed; LastOperationResult is $($testsolution.LastOperationResult); Details: $($testsolution.LastOperationDetails)"
}
Write-Host $testsolution.LastOperationDetails
}
}
else
{
Write-Verbose "Retract-SPSolution: ShouldProcess yielded false: solution `"$($solution.Name)`" was not retracted."
}
}
}
}
else
{
if ($Whatif)
{
Write-Host "What if: cannot find any solutions with name `"$Name`"'; nothing is retracted"
}
else
{
throw "ERROR: cannot find any solution for `"$Name`" in the solution store. Retract aborted"
}
}
}
}
function Get-SPWebApplication
{
[CmdletBinding(SupportsShouldProcess=$false)]
param
(
[Parameter(Mandatory=$false, Position=0, ValueFromPipeline=$true, ValueFromPipelineByPropertyName=$true, HelpMessage="URL of any zone in the SharePoint webapp to return the WebApplication object(s) for")]
[string]$url = ""
)
process
{
try
{
Write-Output ([Microsoft.SharePoint.Administration.SPWebService]::ContentService.WebApplications | where {
$url -eq "" -or (
$_.GetResponseUri([Microsoft.SharePoint.Administration.SPUrlZone]::Default) -eq $url -or
$_.GetResponseUri([Microsoft.SharePoint.Administration.SPUrlZone]::Intranet) -eq $url -or
$_.GetResponseUri([Microsoft.SharePoint.Administration.SPUrlZone]::Internet) -eq $url -or
$_.GetResponseUri([Microsoft.SharePoint.Administration.SPUrlZone]::Extranet) -eq $url -or
$_.GetResponseUri([Microsoft.SharePoint.Administration.SPUrlZone]::Custom) -eq $url)
})
}
catch
{
Write-Error "ERROR while getting SharePoint webapplication object for url `"$url`": $_"
Write-Error "Please check event log for errors, which may include problems logging in into the SharePoint databases"
}
}
}
##---------------------------------------------------------------------------------------------------------------------------------------------------
function Get-SPFeature
{
[CmdLetBinding(SupportsShouldProcess=$false, defaultParameterSetname="IdentityOnly")]
param
(
[Parameter(Position=0, Mandatory=$false, parameterSetName="IdentityOnly", ValueFromPipeline=$true, ValueFromPipelineByPropertyName=$true, HelpMessage="Id of the feature")]
[Parameter(Position=0, Mandatory=$false, parameterSetName="Farm", ValueFromPipeline=$true, ValueFromPipelineByPropertyName=$true, HelpMessage="Id of the feature")]
[Parameter(Position=0, Mandatory=$false, parameterSetName="Web", ValueFromPipeline=$true, ValueFromPipelineByPropertyName=$true, HelpMessage="Id of the feature")]
[Parameter(Position=0, Mandatory=$false, parameterSetName="Site", ValueFromPipeline=$true, ValueFromPipelineByPropertyName=$true, HelpMessage="Id of the feature")]
[Parameter(Position=0, Mandatory=$false, parameterSetName="WebApplication", ValueFromPipeline=$true, ValueFromPipelineByPropertyName=$true, HelpMessage="Id of the feature")]
[string]$Identity = "",
[Parameter(Mandatory=$false, parameterSetName="Farm", ValueFromPipelineByPropertyName=$true, HelpMessage="Specifies that if this parameter is used, only enabled farm Features are displayed.")]
[switch]$Farm,
[Parameter(Mandatory=$true, parameterSetName="Site", ValueFromPipelineByPropertyName=$true, HelpMessage="Specifies the SPSite to find the features for")]
[Microsoft.SharePoint.SPSite]$Site,
[Parameter(Mandatory=$true, parameterSetName="Web", ValueFromPipelineByPropertyName=$true, HelpMessage="Specifies the SPWeb to find the features for")]
[Microsoft.SharePoint.SPWeb]$Web,
[Parameter(Mandatory=$true, parameterSetName="WebApplication", ValueFromPipelineByPropertyName=$true, HelpMessage="Specifies the URL of the webapplication to get features for")]
[Alias("url")]
[string]$WebAppUrl,
[Parameter(Mandatory=$false, parameterSetName="IdentityOnly", ValueFromPipelineByPropertyName=$true, HelpMessage="Limits the display result; if 'all' is specified, all features are displayed; if a number, the number must be greater than 0; default value is 200")]
[Parameter(Mandatory=$false, parameterSetName="Farm", ValueFromPipelineByPropertyName=$true, HelpMessage="Limits the display result; if 'all' is specified, all features are displayed; if a number, the number must be greater than 0; default value is 200")]
[Parameter(Mandatory=$false, parameterSetName="Web", ValueFromPipelineByPropertyName=$true, HelpMessage="Limits the display result; if 'all' is specified, all features are displayed; if a number, the number must be greater than 0; default value is 200")]
[Parameter(Mandatory=$false, parameterSetName="Site", ValueFromPipelineByPropertyName=$true, HelpMessage="Limits the display result; if 'all' is specified, all features are displayed; if a number, the number must be greater than 0; default value is 200")]
[Parameter(Mandatory=$false, parameterSetName="WebApplication", ValueFromPipelineByPropertyName=$true, HelpMessage="Limits the display result; if 'all' is specified, all features are displayed; if a number, the number must be greater than 0; default value is 200")]
[ValidateScript({ $limitInt = 0; ($Limit -eq "All" -or ([int]::TryParse($Limit, [ref]$limitInt) -and $limitInt -gt 0 )) })]
[string]$Limit = "200"
)
# SPFarm.FeatureDefinitions Returns the list of all installed features in the server farm.
# SPWebApplication.Features Returns a list of activated virtual server-scoped features for the SharePoint Foundation Web application.
# SPWebService.Features Returns the administrative features that have been activated at the server farm scope.
# SPSite.Features Returns the list of activated features for the site collection.
# SPWeb.Features Returns the list of activated features for a site.
# SPFeatureDefinition.ActivationDependencies Returns the list of features upon which activation of another feature depends.
# QueryFeatures(Guid) Returns a list of all of the site collection-scoped and Web site-scoped features of the given GUID.
begin
{
$allFeatures = [Microsoft.SharePoint.Administration.SPFarm]::Local.FeatureDefinitions
$webapplicationFeatures = $null
switch ($PSCmdlet.ParameterSetName)
{
"Site" { $siteFeatures = $site.Features }
"web" { $webFeatures = $web.Features }
"webapplication"
{
$webapp = Get-SPWebApplication -url $WebAppUrl
if ($webapp)
{
$webapplicationFeatures = $webapp.Features
}
else
{
throw "Cannot find SharePoint WebApplication for URL `"$WebAppUrl`""
}
}
}
}
process
{
$limitInt = [int]::MaxValue
if ($Limit -ne "All")
{
$limitInt = [int]$Limit
}
switch ($PSCmdlet.ParameterSetName)
{
"IdentityOnly"
{
$allFeatures | where { $Identity -eq "" -or $_.Id -eq $Identity -or $_.DisplayName -eq $Identity } | select -First $limitInt
break;
}
"Farm"
{
$allFeatures | where { $_.Scope -eq "Farm" -and ($Identity -eq "" -or $_.Id -eq $Identity -or $_.DisplayName -eq $Identity) } | select -First $limitInt
break;
}
"Site"
{
$siteFeatures | select -ExpandProperty Definition | where { $Identity -eq "" -or $_.Id -eq $Identity -or $_.DisplayName -eq $Identity } | select -First $limitInt
break;
}
"Web"
{
$webFeatures | select -ExpandProperty Definition | where { $Identity -eq "" -or $_.Id -eq $Identity -or $_.DisplayName -eq $Identity } | select -First $limitInt
break;
}
"WebApplication"
{
$webapplicationFeatures | select -ExpandProperty Definition | where { $Identity -eq "" -or $_.Id -eq $Identity -or $_.DisplayName -eq $Identity } | select -First $limitInt
break;
}
default
{
throw "Cannot find parametersetName `"$($PSCmdlet.ParameterSetName)`""
}
}
}
}
##---------------------------------------------------------------------------------------------------------------------------------------------------
# Initialize PSaint
Initialize-TestFramework
##---------------------------------------------------------------------------------------------------------------------------------------------------
Test-Code "Solution `"framework_v1*.WSP`" is installed in SharePoint solution store" {
arrange {
$solutionName = "framework_v1*.WSP"
}
act {
$solution = Get-SPSolution $solutionName # NOTE: mijn Get-SPSolution voor SharePoint 2007 ondersteunt wildcards!
}
assert {
Assert-That { $solution –ne $null } -FailMessage "Solution `"$solutionName`" not found in solution store"
}
}
# Above Test-Code call will yield a TestResult object like this:
# Result Name FailMessage
# ------ ---- --------
# Fail Solution framework_v*.WSP is installed in solution store Solution "framework_v*.WSP" not found in solution store
##---------------------------------------------------------------------------------------------------------------------------------------------------
Test-Code "Feature `"Error Page control adapter`" is activated (at web application scope)" {
arrange {
$webAppUrl = "http://portal.nl"
$featureIdentity = "Feature-ErrorPageControlAdapter"
$featureIsInstalled = $false
$webAppScopedFeatureIsActivated = $false
}
act {
# Get the feature from the list of all installed features in the server farm
$feature = Get-SPFeature -Identity $featureIdentity
$featureIsInstalled = ($feature -ne $null -and $feature.Status -eq "Online")
if ($featureIsInstalled)
{
$webAppScopedFeatureIsActivated = ((Get-SPFeature -Identity $featureIdentity -WebAppUrl $webAppUrl) -ne $null)
}
}
assert {
Assert-That { $featureIsInstalled } -FailMessage "Feature `"$featureIdentity`" is not installed in the farm."
Assert-That { $webAppScopedFeatureIsActivated } -FailMessage "Feature `"$featureIdentity`" is not activated at webapplication `"$webAppUrl`"."
}
}
# Above Test-Code call will yield a TestResult object like this:
# Result Name FailMessage
# ------ ---- --------
# Fail Solution framework_v*.WSP is installed in solution store Solution "framework_v*.WSP" not found in solution store
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment