Implicit.Remoting.Tests.ps1

Describe "Implicit remoting and CIM cmdlets with AllSigned and Restricted policy" -tags "Feature" {

    BeforeAll {

        # Skip test for non-windows machines
        $skipTest = !$IsWindows

        if ($skipTest) { return }

        #
        # GET CERTIFICATE
        #

        $tempName = "$env:TEMP\signedscript_$(Get-Random).ps1"
        "123456" > $tempName
        $cert = $null
        foreach ($thisCertificate in (Get-ChildItem cert:\ -rec -codesigning))
        {
	        $null = Set-AuthenticodeSignature $tempName -Certificate $thisCertificate
	        if ((Get-AuthenticodeSignature $tempName).Status -eq "Valid")
	        {
		        $cert = $thisCertificate
		        break
	        }
        }

        # Skip the tests if we couldn't find a code sign certificate
        # This will happen in NanoServer and IoT
        if ($cert -eq $null)
        {
            $skipTest = $true
            return
        }

        # Ensure the cert is trusted
        if (-not (Test-Path "cert:\currentuser\TrustedPublisher\$($cert.Thumbprint)"))
        {
            $store = New-Object System.Security.Cryptography.X509Certificates.X509Store "TrustedPublisher"
            $store.Open("ReadWrite")
            $store.Add($cert)
            $store.Close()
        }

        #
        # Set process scope execution policy to 'AllSigned'
        #

        $oldExecutionPolicy = Get-ExecutionPolicy -Scope Process
        Set-ExecutionPolicy AllSigned -Scope Process

        #
        # Create a remote session
        #

        $session = New-RemoteSession
    }

    AfterAll {
        if ($skipTest) { return }

        if ($tempName -ne $null) { Remove-Item -Path $tempName -Force -ErrorAction SilentlyContinue }
        if ($oldExecutionPolicy -ne $null) { Set-ExecutionPolicy $oldExecutionPolicy -Scope Process }
        if ($session -ne $null) { Remove-PSSession $session -ErrorAction SilentlyContinue }
    }

    #
    # TEST - Verifying that Import-PSSession signs the files
    #

    It "Verifies that Import-PSSession works in AllSigned if Certificate is used" -Skip:$skipTest {
        try {
            $importedModule = Import-PSSession $session Get-Variable -Prefix Remote -Certificate $cert -AllowClobber
    	    $importedModule | Should Not Be $null
        } finally {
            $importedModule | Remove-Module -Force -ErrorAction SilentlyContinue
        }
    }

    It "Verifies security error when Certificate parameter is not used" -Skip:$skipTest {
        try {
            $importedModule = Import-PSSession $session Get-Variable -Prefix Remote -AllowClobber
            throw "expect Import-PSSession to throw"
        } catch {
            $_.FullyQualifiedErrorId | Should Be "InvalidOperation,Microsoft.PowerShell.Commands.ImportPSSessionCommand"
        }
    }
}

Describe "Tests Import-PSSession cmdlet works with types unavailable on the client" -tags "Feature" {

    BeforeAll {

        # Skip test for non-windows machines for now
        $skipTest = !$IsWindows

        if ($skipTest) { return }

        $typeDefinition = @"
            namespace MyTest
            {
	            public enum MyEnum
	            {
		            Value1 = 1,
		            Value2 = 2
	            }
            }
"@
        #
        # Create a remote session
        #

        $session = New-RemoteSession

        Invoke-Command -Session $session -Script { Add-Type -TypeDefinition $args[0] } -Args $typeDefinition
        Invoke-Command -Session $session -Script { function foo { param([MyTest.MyEnum][Parameter(Mandatory = $true)]$x) $x } }
    }

    AfterAll {
        if ($skipTest) { return }
        if ($session -ne $null) { Remove-PSSession $session -ErrorAction SilentlyContinue }
    }

    It "Verifies client-side unavailable enum is correctly handled" -Skip:$skipTest {
        try {
            $module = Import-PSSession -Session $session -CommandName foo -AllowClobber

            # The enum is treated as an int
            (foo -x "Value2") | Should Be 2
            # The enum is to-string-ed appropriately
            (foo -x "Value2").ToString() | Should Be "Value2"
        } finally {
            if ($module -ne $null) { Remove-Module $module -Force -ErrorAction SilentlyContinue }
        }
    }
}

Describe "Cmdlet help from remote session" -tags "Feature" {

    BeforeAll {

        # Skip test for non-windows machines for now
        $skipTest = !$IsWindows

        if ($skipTest) { return }
        $session = New-RemoteSession
    }

    AfterAll {
        if ($skipTest) { return }
        if ($session -ne $null) { Remove-PSSession $session -ErrorAction SilentlyContinue }
    }

    It "Verifies that get-help name for remote proxied commands matches the get-command name" -Skip:$skipTest {
        try {
            $module = Import-PSSession $session -Name Select-Object -prefix My -AllowClobber
            $gcmOutPut = (Get-Command Select-MyObject ).Name
            $getHelpOutPut = (Get-Help Select-MyObject).Name

            $gcmOutPut | Should Be $getHelpOutPut
        } finally {
            if ($module -ne $null) { Remove-Module $module -Force -ErrorAction SilentlyContinue }
        }
	}
}

Describe "Import-PSSession Cmdlet error handling" -tags "Feature" {

    BeforeAll {

        # Skip test for non-windows machines for now
        $skipTest = !$IsWindows

        if ($skipTest) { return }
        $session = New-RemoteSession
    }

    AfterAll {
        if ($skipTest) { return }
        if ($session -ne $null) { Remove-PSSession $session -ErrorAction SilentlyContinue }
    }


    It "Verifies that broken alias results in one error" -Skip:$skipTest {
        try {
            Invoke-Command $session { Set-Alias BrokenAlias NonExistantCommand }
            $module = Import-PSSession $session -CommandName:BrokenAlias -CommandType:All -ErrorAction SilentlyContinue -ErrorVariable expectedError -AllowClobber

            $expectedError | Should Not Be NullOrEmpty
            $expectedError[0].ToString().Contains("BrokenAlias") | Should Be $true
        } finally {
            if ($module -ne $null) { Remove-Module $module -Force -ErrorAction SilentlyContinue }
            Invoke-Command $session { Remove-Item alias:BrokenAlias }
        }
    }

    Context "Test content and format of proxied error message (Windows 7: #319080)" {

        BeforeAll {
            if ($skipTest) { return }
            $module = Import-PSSession -Session $session -Name Get-Variable -Prefix My -AllowClobber
        }

        AfterAll {
            if ($skipTest) { return }
            if ($module -ne $null) { Remove-Module $module -Force -ErrorAction SilentlyContinue }
        }

        It "Test non-terminating error" -Skip:$skipTest {
            $results = Get-MyVariable blah,pid 2>&1

            ($results[1]).Value | Should Not Be $PID  # Verifies that returned PID is not for this session

            $errorString = $results[0] | Out-String   # Verifies error message for variable blah
            ($errorString -like "*VariableNotFound*") | Should Be $true
        }

        It "Test terminating error" -Skip:$skipTest {
            $results = Get-MyVariable pid -Scope blah 2>&1

            $results.Count | Should Be 1              # Verifies that remote session pid is not returned

            $errorString = $results[0] | Out-String   # Verifes error message for incorrect Scope parameter argument
            ($errorString -like "*Argument*") | Should Be $true
        }
    }

    Context "Ordering of a sequence of error and output messages (Windows 7: #405065)" {

        BeforeAll {
            if ($skipTest) { return }

            Invoke-Command $session { function foo1{1; write-error 2; 3; write-error 4; 5; write-error 6} }
            $module = Import-PSSession $session -CommandName foo1 -AllowClobber

            $icmErr = $($icmOut = Invoke-Command $session { foo1 }) 2>&1
            $proxiedErr = $($proxiedOut = foo1) 2>&1
            $proxiedOut2 = foo1 2>$null

            $icmOut = "$icmOut"
            $icmErr = "$icmErr"
            $proxiedOut = "$proxiedOut"
            $proxiedOut2 = "$proxiedOut2"
            $proxiedErr = "$proxiedErr"
        }

        AfterAll {
            if ($skipTest) { return }
            if ($module -ne $null) { Remove-Module $module -Force -ErrorAction SilentlyContinue }
        }

        It "Verifies proxied output = proxied output 2" -Skip:$skipTest {
            $proxiedOut2 | Should Be $proxiedOut
        }

        It "Verifies proxied output = icm output (for mixed error and output results)" -Skip:$skipTest {
            $icmOut | Should Be $proxiedOut
        }

        It "Verifies proxied error = icm error (for mixed error and output results)" -Skip:$skipTest {
            $icmErr | Should Be $proxiedErr
        }

        It "Verifies proxied order = icm order (for mixed error and output results)" -Skip:$skipTest {
            $icmOrder = Invoke-Command $session { foo1 } 2>&1 | out-string
            $proxiedOrder = foo1 2>&1 | out-string

            $icmOrder | Should Be $proxiedOrder
        }
    }

    Context "WarningVariable parameter works with implicit remoting (Windows 8: #44861)" {

        BeforeAll {
            if ($skipTest) { return }
            $module = Import-PSSession $session -CommandName Write-Warning -Prefix Remote -AllowClobber
        }

        AfterAll {
            if ($skipTest) { return }
            if ($module -ne $null) { Remove-Module $module -Force -ErrorAction SilentlyContinue }
        }

        It "Verifies WarningVariable" -Skip:$skipTest {
            $global:myWarningVariable = @()
            Write-RemoteWarning MyWarning -WarningVariable global:myWarningVariable
            ([string]($myWarningVariable[0])) | Should Be 'MyWarning'
	    }
    }
}

Describe "Tests Export-PSSession" -tags "Feature" {

    BeforeAll {

        # Skip test for non-windows machines for now
        $skipTest = !$IsWindows

        if ($skipTest) { return }

        $sessionOption = New-PSSessionOption -ApplicationArguments @{myTest="MyValue"}
        $session = New-RemoteSession -SessionOption $sessionOption

        $file = [IO.Path]::Combine([IO.Path]::GetTempPath(), [Guid]::NewGuid().ToString())
        $results = Export-PSSession -Session $session -CommandName Get-Variable -AllowClobber -ModuleName $file
        $oldTimestamp = $($results | Select -First 1).LastWriteTime
    }

    AfterAll {
        if ($skipTest) { return }
        if ($file -ne $null) { Remove-Item $file -Force -Recurse -ErrorAction SilentlyContinue }
        if ($session -ne $null) { Remove-PSSession $session -ErrorAction SilentlyContinue }
    }

    It "Verifies Export-PSSession creates a file/directory" -Skip:$skipTest {
        @(Get-Item $file).Count | Should Be 1
    }

    It "Verifies Export-PSSession creates a psd1 file" -Skip:$skipTest {
        ($results | ?{ $_.Name -like "*$(Split-Path -Leaf $file).psd1" }) | Should Be $true
    }

    It "Verifies Export-PSSession creates a psm1 file" -Skip:$skipTest {
        ($results | ?{ $_.Name -like "*.psm1" }) | Should Be $true
    }

    It "Verifies Export-PSSession creates a ps1xml file" -Skip:$skipTest {
        ($results | ?{ $_.Name -like "*.ps1xml" }) | Should Be $true
    }

    It "Verifies that Export-PSSession fails when a module directory already exists" -Skip:$skipTest {
        try {
            Export-PSSession -Session $session -CommandName Get-Variable -AllowClobber -ModuleName $file -EA SilentlyContinue -ErrorVariable expectedError
        } catch { }

        $expectedError | Should Not Be NullOrEmpty
        # Error contains reference to the directory that already exists
        ([string]($expectedError[0]) -like "*$file*") | Should Be $true
    }

    It "Verifies that overwriting an existing directory succeeds with -Force" -Skip:$skipTest {
        $newResults = Export-PSSession -Session $session -CommandName Get-Variable -AllowClobber -ModuleName $file -Force

        # Verifies that Export-PSSession returns 4 files
        @($newResults).Count | Should Be 4

        # Verifies that Export-PSSession creates *new* files
        $newResults | % { $_.LastWriteTime | Should BeGreaterThan $oldTimestamp }
    }

    Context "The module is usable when the original runspace is still around" {

        BeforeAll {
            if ($skipTest) { return }
            $module = Import-Module $file -PassThru
        }

        AfterAll {
            if ($skipTest) { return }
            if ($module -ne $null) { Remove-Module $module -Force -ErrorAction SilentlyContinue }
        }

        It "Verifies that proxy returns remote pid" -Skip:$skipTest {
            (Get-Variable -Name pid).Value | Should Not Be $pid
        }

	    It "Verfies Remove-Module doesn't remove user's runspace" -Skip:$skipTest {
            Remove-Module $module -Force -ErrorAction SilentlyContinue
            (Get-PSSession -InstanceId $session.InstanceId) | Should Not Be NullOrEmpty
        }
    }
}

Describe "Proxy module is usable when the original runspace is no longer around" -tags "Feature" {
    BeforeAll {
        # Run the tests only in FullCLR powershell because implicit credential doesn't work in AppVeyor builder
        $skipTest = !$IsWindows -or $IsCoreCLR

        if ($skipTest) { return }

        $sessionOption = New-PSSessionOption -ApplicationArguments @{myTest="MyValue"}
        $session = New-RemoteSession -SessionOption $sessionOption

        $file = [IO.Path]::Combine([IO.Path]::GetTempPath(), [Guid]::NewGuid().ToString())
        $null = Export-PSSession -Session $session -CommandName Get-Variable -AllowClobber -ModuleName $file

        # Close the session to test the behavior of proxy module
        if ($session -ne $null) { Remove-PSSession $session -ErrorAction SilentlyContinue; $session = $null }
    }

    AfterAll {
        if ($skipTest) { return }
        if ($file -ne $null) { Remove-Item $file -Force -Recurse -ErrorAction SilentlyContinue }
        if ($session -ne $null) { Remove-PSSession $session -ErrorAction SilentlyContinue }
    }

    ## It requires 'New-PSSession' to work with implicit credential to allow proxied command to create new session.
    ## Implicit credential doesn't work in AppVeyor builder, so mark all tests here '-pending'.

    Context "Proxy module should create a new session" {
        BeforeAll {
            if ($skipTest) { return }
            $module = import-Module $file -PassThru -Force
            $internalSession = & $module { $script:PSSession }
        }
        AfterAll {
            if ($skipTest) { return }
            if ($module -ne $null) { Remove-Module $module -Force -ErrorAction SilentlyContinue }
        }

        It "Verifies proxy should return remote pid" -Pending {
            (Get-Variable -Name PID).Value | Should Not Be $PID
        }

        It "Verifies ApplicationArguments got preserved correctly" -Pending {
            $(Invoke-Command $internalSession { $PSSenderInfo.ApplicationArguments.MyTest }) | Should Be "MyValue"
        }

        It "Verifies Remove-Module removed the runspace that was automatically created" -Pending {
            Remove-Module $module -Force
            ((Get-PSSession -InstanceId $internalSession.InstanceId -ErrorAction SilentlyContinue) -eq $null) | Should Be $true
        }

        It "Verifies Runspace is closed after removing module from Export-PSSession that got initialized with an internal r-space" -Pending {
            ($internalSession.Runspace.RunspaceStateInfo.ToString()) | Should Be "Closed"
        }
    }

    Context "Runspace created by the module with explicit session options" {
        BeforeAll {
            if ($skipTest) { return }
            $explicitSessionOption = New-PSSessionOption -Culture fr-FR -UICulture de-DE
            $module = import-Module $file -PassThru -Force -ArgumentList $null, $explicitSessionOption
            $internalSession = & $module { $script:PSSession }
        }
        AfterAll {
            if ($skipTest) { return }
            if ($module -ne $null) { Remove-Module $module -Force -ErrorAction SilentlyContinue }
        }

        It "Verifies proxy should return remote pid" -Pending {
            (Get-Variable -Name PID).Value | Should Not Be $PID
        }

        # culture settings should be taken from the explicitly passed session options
        It "Verifies proxy returns modified culture" -Pending {
            (Get-Variable -Name PSCulture).Value | Should Be "fr-FR"
        }
        It "Verifies proxy returns modified culture" -Pending {
            (Get-Variable -Name PSUICulture).Value | Should Be "de-DE"
        }

        # removing the module should remove the implicitly/magically created runspace
        It "Verifies Remove-Module removes automatically created runspace" -Pending {
            Remove-Module $module -Force
            ((Get-PSSession -InstanceId $internalSession.InstanceId -ErrorAction SilentlyContinue) -eq $null) | Should Be $true
        }
        It "Verifies Runspace is closed after removing module from Export-PSSession that got initialized with an internal r-space" -Pending {
            ($internalSession.Runspace.RunspaceStateInfo.ToString()) | Should Be "Closed"
        }
    }

    Context "Passing a runspace into proxy module" {
        BeforeAll {
            if ($skipTest) { return }

            $newSession = New-RemoteSession
            $module = import-Module $file -PassThru -Force -ArgumentList $newSession
            $internalSession = & $module { $script:PSSession }
        }
        AfterAll {
            if ($skipTest) { return }
            if ($module -ne $null) { Remove-Module $module -Force -ErrorAction SilentlyContinue }
            if ($newSession -ne $null) { Remove-PSSession $newSession -ErrorAction SilentlyContinue }
        }

        It "Verifies proxy returns remote pid" -Pending {
            (Get-Variable -Name PID).Value | Should Not Be $PID
        }

        It "Verifies switch parameters work" -Pending {
            (Get-Variable -Name PID -ValueOnly) | Should Not Be $PID
        }

        It "Verifies Adding a module affects runspace's state" -Pending {
            ($internalSession.Runspace.RunspaceStateInfo.ToString()) | Should Be "Opened"
        }

        It "Verifies Runspace stays opened after removing module from Export-PSSession that got initialized with an external runspace" -Pending {
            Remove-Module $module -Force
		    ($internalSession.Runspace.RunspaceStateInfo.ToString()) | Should Be "Opened"
	    }
    }
}

Describe "Import-PSSession with FormatAndTypes" -tags "Feature" {

    BeforeAll {
        # Skip test for non-windows machines for now
        $skipTest = !$IsWindows

        if ($skipTest) { return }
        $session = New-RemoteSession

        function CreateTempPs1xmlFile
        {
            do {
                $tmpFile = [IO.Path]::Combine([IO.Path]::GetTempPath(), [IO.Path]::GetRandomFileName()) + ".ps1xml";
            } while ([IO.File]::Exists($tmpFile))
            $tmpFile
        }

        function CreateTypeFile {
            $tmpFile = CreateTempPs1xmlFile
@"
    <Types>
	    <Type>
		<Name>System.Management.Automation.Host.Coordinates</Name>
		    <Members>
			    <NoteProperty>
				<Name>MyTestLabel</Name>
				<Value>123</Value>
			    </NoteProperty>
		    </Members>
	    </Type>
	    <Type>
		    <Name>MyTest.Root</Name>
		    <Members>
		    <MemberSet>
			<Name>PSStandardMembers</Name>
			<Members>
			    <NoteProperty>
				<Name>SerializationDepth</Name>
				<Value>1</Value>
			    </NoteProperty>
			</Members>
		        </MemberSet>
		    </Members>
	    </Type>
	    <Type>
		    <Name>MyTest.Son</Name>
		    <Members>
		    <MemberSet>
			<Name>PSStandardMembers</Name>
			<Members>
			    <NoteProperty>
				<Name>SerializationDepth</Name>
				<Value>1</Value>
			    </NoteProperty>
			</Members>
		        </MemberSet>
		    </Members>
	    </Type>
	    <Type>
		    <Name>MyTest.Grandson</Name>
		    <Members>
		    <MemberSet>
			<Name>PSStandardMembers</Name>
			<Members>
			    <NoteProperty>
				<Name>SerializationDepth</Name>
				<Value>1</Value>
			    </NoteProperty>
			</Members>
		        </MemberSet>
		    </Members>
	    </Type>
	</Types>
"@ | set-content $tmpFile
	        $tmpFile
        }

        function CreateFormatFile {
            $tmpFile = CreateTempPs1xmlFile
@"
    <Configuration>
	    <ViewDefinitions>
		<View>
		    <Name>MySizeView</Name>
		    <ViewSelectedBy>
			<TypeName>System.Management.Automation.Host.Size</TypeName>
		    </ViewSelectedBy>
		    <TableControl>
			<TableHeaders>
			    <TableColumnHeader>
				<Label>MyTestWidth</Label>
			    </TableColumnHeader>
			    <TableColumnHeader>
				<Label>MyTestHeight</Label>
			    </TableColumnHeader>
			</TableHeaders>
			<TableRowEntries>
			    <TableRowEntry>
				<TableColumnItems>
				    <TableColumnItem>
					<PropertyName>Width</PropertyName>
				    </TableColumnItem>
				    <TableColumnItem>
					<PropertyName>Height</PropertyName>
				    </TableColumnItem>
				</TableColumnItems>
			    </TableRowEntry>
			    </TableRowEntries>
		    </TableControl>
		</View>
	    </ViewDefinitions>
	</Configuration>
"@ | set-content $tmpFile
            $tmpFile
        }

        $formatFile = CreateFormatFile
        $typeFile = CreateTypeFile
    }

    AfterAll {
        if ($skipTest) { return }
        if ($session -ne $null) { Remove-PSSession $session -ErrorAction SilentlyContinue }
        if ($formatFile -ne $null) { Remove-Item $formatFile -Force -ErrorAction SilentlyContinue }
        if ($typeFile -ne $null) { Remove-Item $typeFile -Force -ErrorAction SilentlyContinue }
    }

    Context "Importing format file works" {
        BeforeAll {
            if ($skipTest) { return }

            $formattingScript = { new-object System.Management.Automation.Host.Size | %{ $_.Width = 123; $_.Height = 456; $_ } | Out-String }
            $originalLocalFormatting = & $formattingScript

            # Original local and remote formatting should be equal (sanity check)
            $originalRemoteFormatting = Invoke-Command $session $formattingScript
            $originalLocalFormatting | Should Be $originalRemoteFormatting

            Invoke-Command $session { param($file) Update-FormatData $file } -ArgumentList $formatFile

            # Original remote and modified remote formatting should not be equal (sanity check)
            $modifiedRemoteFormatting = Invoke-Command $session $formattingScript
            $originalRemoteFormatting | Should Not Be $modifiedRemoteFormatting

            $module = Import-PSSession -Session $session -CommandName @() -FormatTypeName * -AllowClobber
        }

        AfterAll {
            if ($skipTest) { return }
            if ($module -ne $null) { Remove-Module $module -Force -ErrorAction SilentlyContinue }
        }

        It "modified remote and imported local should be equal" -Skip:$skipTest {
            $importedLocalFormatting = & $formattingScript
            $modifiedRemoteFormatting | Should Be $importedLocalFormatting
        }

        It "original local and unimported local should be equal" -Skip:$skipTest {
            Remove-Module $module -Force
            $unimportedLocalFormatting = & $formattingScript
            $originalLocalFormatting | Should Be $unimportedLocalFormatting
        }
    }

    It "Updating type table in a middle of a command has effect on serializer" -Skip:$skipTest {
        $results = Invoke-Command $session -ArgumentList $typeFile -ScriptBlock {
            param($file)

            New-Object System.Management.Automation.Host.Coordinates
            Update-TypeData $file
            New-Object System.Management.Automation.Host.Coordinates
        }

        # Should get 2 deserialized S.M.A.H.Coordinates objects
        $results.Count | Should Be 2
        # First object shouldn't have the additional ETS note property
        $results[0].MyTestLabel -eq $null | Should Be $true
        # Second object should have the additional ETS note property
        $results[1].MyTestLabel | Should Be 123
    }

    Context "Implicit remoting works even when types.ps1xml is missing on the client" {
        BeforeAll {
            if ($skipTest) { return }

            $typeDefinition = @"
                namespace MyTest
                {
                    public class Root
                    {
        	            public Root(string s) { text = s; }
        	            public Son Son = new Son();
        	            public string text;
                    }

                    public class Son
                    {
                        public Grandson Grandson = new Grandson();
                    }

                    public class Grandson
                    {
                        public string text = "Grandson";
    	            }
                }
"@
            Invoke-Command -Session $session -Script { Add-Type -TypeDefinition $args[0] } -ArgumentList $typeDefinition
            Invoke-Command -Session $session -Script { function foo { New-Object MyTest.Root "root" } }
            Invoke-Command -Session $session -Script { function bar { param([Parameter(Mandatory = $true, ValueFromPipelineByPropertyName = $true)]$Son) $Son.Grandson.text } }

            $module = import-pssession $session foo,bar -AllowClobber
        }

        AfterAll {
            if ($skipTest) { return }
            if ($module -ne $null) { Remove-Module $module -Force -ErrorAction SilentlyContinue }
        }

        It "Serialization works for top-level properties" -Skip:$skipTest {
            $x = foo
            $x.text | Should Be "root"
        }

        It "Serialization settings works for deep properties" -Skip:$skipTest {
            $x = foo
            $x.Son.Grandson.text | Should Be "Grandson"
        }

        It "Serialization settings are preserved even if types.ps1xml is missing on the client" -Skip:$skipTest {
            $y = foo | bar
            $y | Should Be "Grandson"
        }
    }
}

Describe "Import-PSSession functional tests" -tags "Feature" {

    BeforeAll {
        # Skip test for non-windows machines for now
        $skipTest = !$IsWindows

        if ($skipTest) { return }
        $session = New-RemoteSession

        # Define a remote function
        Invoke-Command -Session $session { function MyFunction { param($x) "x = '$x'; args = '$args'" } }

        # Define a remote proxy script cmdlet
        $remoteCommandType = $ExecutionContext.InvokeCommand.GetCommand('Get-Variable', [System.Management.Automation.CommandTypes]::Cmdlet)
        $remoteProxyBody = [System.Management.Automation.ProxyCommand]::Create($remoteCommandType)
        $remoteProxyDeclaration = "function Get-VariableProxy { $remoteProxyBody }"
        Invoke-Command -Session $session { param($x) Invoke-Expression $x } -Arg $remoteProxyDeclaration
        $remoteAliasDeclaration = "set-alias gvalias Get-Variable"
        Invoke-Command -Session $session { param($x) Invoke-Expression $x } -Arg $remoteAliasDeclaration
        Remove-Item alias:gvalias -Force -ErrorAction silentlycontinue

        # Import a remote function, script cmdlet, cmdlet, native application, alias
        $module = Import-PSSession -Session $session -Name MyFunction,Get-VariableProxy,Get-Variable,gvalias,cmd -AllowClobber -Type All
    }

    AfterAll {
        if ($skipTest) { return }
        if ($module -ne $null) { Remove-Module $module -Force -ErrorAction SilentlyContinue }
        if ($session -ne $null) { Remove-PSSession $session -ErrorAction SilentlyContinue }
    }

    It "Import-PSSession should return a PSModuleInfo object" -Skip:$skipTest {
        $module | Should Not Be NullOrEmpty
    }

    It "Import-PSSession should return a PSModuleInfo object" -Skip:$skipTest {
        ($module -as [System.Management.Automation.PSModuleInfo]) | Should Not Be NullOrEmpty
    }

    It "Helper functions should not be imported" -Skip:$skipTest {
        ((Get-Item function:*PSImplicitRemoting* -ErrorAction SilentlyContinue) -eq $null) | Should Be $true
    }

    It "Calls implicit remoting proxies 'MyFunction'" -Skip:$skipTest {
        (MyFunction 1 2 3) | Should Be "x = '1'; args = '2 3'"
    }

    It "proxy should return remote pid" -Skip:$skipTest {
        (Get-VariableProxy -Name:pid).Value | Should Not Be $pid
    }

    It "proxy should return remote pid" -Skip:$skipTest {
        (Get-Variable -Name:pid).Value | Should Not Be $pid
    }

    It "proxy should return remote pid" -Skip:$skipTest {
        $(& (Get-Command gvalias -Type alias) -Name:pid).Value | Should Not Be $pid
    }

    It "NoName-c8aeb5c8-2388-4d64-98c1-a9c6c218d404" -Skip:$skipTest {
        Invoke-Command -Session $session { $env:TestImplicitRemotingVariable = 123 }
        (cmd.exe /c "echo TestImplicitRemotingVariable=%TestImplicitRemotingVariable%") | Should Be "TestImplicitRemotingVariable=123"
    }

    Context "Test what happens after the runspace is closed" {
        BeforeAll {
            if ($skipTest) { return }

            Remove-PSSession $session

            # The loop below works around the fact that PSEventManager uses threadpool worker to queue event handler actions to process later.
            # Usage of threadpool means that it is impossible to predict when the event handler will run (this is Windows 8 Bugs: #882977).
            $i = 0
            while ( ($i -lt 20) -and ($null -ne (Get-Module | ? { $_.Path -eq $module.Path })) )
            {
                $i++
                Start-Sleep -Milliseconds 50
            }
        }

        It "Temporary module should be automatically removed after runspace is closed" -Skip:$skipTest {
            ((Get-Module | ? { $_.Path -eq $module.Path }) -eq $null) | Should Be $true
        }

        It "Temporary psm1 file should be automatically removed after runspace is closed" -Skip:$skipTest {
            ((Get-Item $module.Path -ErrorAction SilentlyContinue) -eq $null) | Should Be $true
        }

        It "Event should be unregistered when the runspace is closed" -Skip:$skipTest {
            # Check that the implicit remoting event has been removed.
            $implicitEventCount = 0
            foreach ($item in $ExecutionContext.Events.Subscribers)
            {
                if ($item.SourceIdentifier -match "Implicit remoting event") { $implicitEventCount++ }
            }
            $implicitEventCount | Should Be 0
        }

        It "Private functions from the implicit remoting module shouldn't get imported into global scope" -Skip:$skipTest {
            @(Get-ChildItem function:*Implicit* -ErrorAction SilentlyContinue).Count | Should Be 0
        }
    }
}

Describe "Implicit remoting parameter binding" -tags "Feature" {

    BeforeAll {
        # Skip test for non-windows machines for now
        $skipTest = !$IsWindows

        if ($skipTest) { return }
        $session = New-RemoteSession
    }

    AfterAll {
        if ($skipTest) { return }
        if ($session -ne $null) { Remove-PSSession $session -ErrorAction SilentlyContinue }
    }

    It "Binding of ValueFromPipeline should work" -Skip:$skipTest {
        try {
            $module = Import-PSSession -Session $session -Name Get-Random -AllowClobber
            $x = 1..20 | Get-Random -Count 5
            $x.Count | Should Be 5
        } finally {
            Remove-Module $module -Force
        }
    }

    Context "Pipeline-based parameter binding works even when client has no type constraints (Windows 7: #391157)" {
        BeforeAll {
            if ($skipTest) { return }

            Invoke-Command -Session $session -ScriptBlock {
                function foo {
                    [cmdletbinding(defaultparametersetname="string")]
                    param(
                        [string]
                        [parameter(ParameterSetName="string", ValueFromPipeline = $true)]
                        $string,

                        [ipaddress]
                        [parameter(ParameterSetName="ipaddress", ValueFromPipeline = $true)]
                        $ipaddress
                    )

                    "Bound parameter: $($myInvocation.BoundParameters.Keys | sort)"
                }
            }

            # Sanity checks.
            Invoke-Command $session {"s" | foo} | Should Be "Bound parameter: string"
            Invoke-Command $session {[ipaddress]::parse("127.0.0.1") | foo} | Should Be "Bound parameter: ipaddress"

            $module = Import-PSSession $session foo -AllowClobber
        }

        AfterAll {
            if ($skipTest) { return }
            if ($module -ne $null) { Remove-Module $module -Force -ErrorAction SilentlyContinue }
        }

        It "Pipeline binding works even if it relies on type constraints" -Skip:$skipTest {
            ("s" | foo) | Should Be "Bound parameter: string"
        }

        It "Pipeline binding works even if it relies on type constraints" -Skip:$skipTest {
            ([ipaddress]::parse("127.0.0.1") | foo) | Should Be "Bound parameter: ipaddress"
        }
    }

    Context "Pipeline-based parameter binding works even when client has no type constraints and parameterset is ambiguous (Windows 7: #430379)" {
        BeforeAll {
            if ($skipTest) { return }

            Invoke-Command -Session $session -ScriptBlock {
                function foo {
                    param(
                        [string]
                        [parameter(ParameterSetName="string", ValueFromPipeline = $true)]
                        $string,

                        [ipaddress]
                        [parameter(ParameterSetName="ipaddress", ValueFromPipeline = $true)]
                        $ipaddress
                    )

                    "Bound parameter: $($myInvocation.BoundParameters.Keys)"
                }
            }

            # Sanity checks.
            Invoke-Command $session {"s" | foo} | Should Be "Bound parameter: string"
            Invoke-Command $session {[ipaddress]::parse("127.0.0.1") | foo} | Should Be "Bound parameter: ipaddress"

            $module = Import-PSSession $session foo -AllowClobber
        }

        AfterAll {
            if ($skipTest) { return }
            if ($module -ne $null) { Remove-Module $module -Force -ErrorAction SilentlyContinue }
        }

        It "Pipeline binding works even if it relies on type constraints and parameter set is ambiguous" -Skip:$skipTest {
            ("s" | foo) | Should Be "Bound parameter: string"
        }

        It "Pipeline binding works even if it relies on type constraints and parameter set is ambiguous" -Skip:$skipTest {
            ([ipaddress]::parse("127.0.0.1") | foo) | Should Be "Bound parameter: ipaddress"
        }
    }

    Context "pipeline-based parameter binding works even when one of parameters that can be bound by pipeline gets bound by name" {
        BeforeAll {
            if ($skipTest) { return }

            Invoke-Command -Session $session -ScriptBlock {
                function foo {
                    param(
                        [DateTime]
                        [parameter(ValueFromPipeline = $true)]
                        $date,

                        [ipaddress]
                        [parameter(ValueFromPipeline = $true)]
                        $ipaddress
                    )

                    "Bound parameter: $($myInvocation.BoundParameters.Keys | sort)"
                }
            }

            # Sanity checks.
            Invoke-Command $session {Get-Date | foo} | Should Be "Bound parameter: date"
            Invoke-Command $session {[ipaddress]::parse("127.0.0.1") | foo} | Should Be "Bound parameter: ipaddress"
            Invoke-Command $session {[ipaddress]::parse("127.0.0.1") | foo -date (get-date)} | Should Be "Bound parameter: date ipaddress"
            Invoke-Command $session {Get-Date | foo -ipaddress ([ipaddress]::parse("127.0.0.1"))} | Should Be "Bound parameter: date ipaddress"

            $module = Import-PSSession $session foo -AllowClobber
        }

        AfterAll {
            if ($skipTest) { return }
            if ($module -ne $null) { Remove-Module $module -Force -ErrorAction SilentlyContinue }
        }

        It "Pipeline binding works even when also binding by name" -Skip:$skipTest {
            (Get-Date | foo) | Should Be "Bound parameter: date"
        }

        It "Pipeline binding works even when also binding by name" -Skip:$skipTest {
            ([ipaddress]::parse("127.0.0.1") | foo) | Should Be "Bound parameter: ipaddress"
        }

        It "Pipeline binding works even when also binding by name" -Skip:$skipTest {
            ([ipaddress]::parse("127.0.0.1") | foo -date $(Get-Date)) | Should Be "Bound parameter: date ipaddress"
        }

        It "Pipeline binding works even when also binding by name" -Skip:$skipTest {
    	    (Get-Date | foo -ipaddress ([ipaddress]::parse("127.0.0.1"))) | Should Be "Bound parameter: date ipaddress"
        }
    }

    Context "value from pipeline by property name - multiple parameters" {
        BeforeAll {
            if ($skipTest) { return }

            Invoke-Command -Session $session -ScriptBlock {
                function foo {
                    param(
                        [System.TimeSpan]