winrm-fs 0.3.1 → 0.3.2

data/lib/winrm-fs/scripts/check_files.ps1.erb

@@ -1,48 +1,48 @@
-$hash_file = "<%= hash_file %>"
-
-Function Cleanup($o) { if (($o -ne $null) -and ($o.GetType().GetMethod("Dispose") -ne $null)) { $o.Dispose() } }
-
-Function Decode-Base64File($src, $dst) {
-  Try {
-    $in = (Get-Item $src).OpenRead()
-    $b64 = New-Object -TypeName System.Security.Cryptography.FromBase64Transform
-    $m = [System.Security.Cryptography.CryptoStreamMode]::Read
-    $d = New-Object -TypeName System.Security.Cryptography.CryptoStream $in,$b64,$m
-    Copy-Stream $d ($out = [System.IO.File]::OpenWrite($dst))
-  } Finally { Cleanup $in; Cleanup $out; Cleanup $d }
-}
-
-Function Copy-Stream($src, $dst) { $b = New-Object Byte[] 4096; while (($i = $src.Read($b, 0, $b.Length)) -ne 0) { $dst.Write($b, 0, $i) } }
-
-Function Check-Files($h) {
-  return $h.GetEnumerator() | ForEach-Object {
-    $dst = Unresolve-Path $_.Key
-    New-Object psobject -Property @{
-      chk_exists = ($exists = Test-Path $dst -PathType Leaf)
-      src_md5 = ($sMd5 = $_.Value)
-      dst_md5 = ($dMd5 = if ($exists) { Get-MD5Sum $dst } else { $null })
-      chk_dirty = ($dirty = if ($sMd5 -ne $dMd5) { $true } else { $false })
-      verifies = if ($dirty -eq $false) { $true } else { $false }
-    }
-  } | Select-Object -Property chk_exists,src_md5,dst_md5,chk_dirty,verifies
-}
-
-Function Get-MD5Sum($src) {
-  Try {
-    $c = New-Object -TypeName System.Security.Cryptography.MD5CryptoServiceProvider
-    $bytes = $c.ComputeHash(($in = (Get-Item $src).OpenRead()))
-    return ([System.BitConverter]::ToString($bytes)).Replace("-", "").ToLower()
-  } Finally { Cleanup $c; Cleanup $in }
-}
-
-Function Invoke-Input($in) {
-  $in = Unresolve-Path $in
-  Decode-Base64File $in ($decoded = "$($in).ps1")
-  $expr = Get-Content $decoded | Out-String
-  Remove-Item $in,$decoded -Force
-  return Invoke-Expression "$expr"
-}
-
-Function Unresolve-Path($p) { if ($p -eq $null) { return $null } else { return $ExecutionContext.SessionState.Path.GetUnresolvedProviderPathFromPSPath($p) } }
-
-Check-Files (Invoke-Input $hash_file) | ConvertTo-Csv -NoTypeInformation
+$hash_file = "<%= hash_file %>"
+
+Function Cleanup($o) { if (($o -ne $null) -and ($o.GetType().GetMethod("Dispose") -ne $null)) { $o.Dispose() } }
+
+Function Decode-Base64File($src, $dst) {
+  Try {
+    $in = (Get-Item $src).OpenRead()
+    $b64 = New-Object -TypeName System.Security.Cryptography.FromBase64Transform
+    $m = [System.Security.Cryptography.CryptoStreamMode]::Read
+    $d = New-Object -TypeName System.Security.Cryptography.CryptoStream $in,$b64,$m
+    Copy-Stream $d ($out = [System.IO.File]::OpenWrite($dst))
+  } Finally { Cleanup $in; Cleanup $out; Cleanup $d }
+}
+
+Function Copy-Stream($src, $dst) { $b = New-Object Byte[] 4096; while (($i = $src.Read($b, 0, $b.Length)) -ne 0) { $dst.Write($b, 0, $i) } }
+
+Function Check-Files($h) {
+  return $h.GetEnumerator() | ForEach-Object {
+    $dst = Unresolve-Path $_.Key
+    New-Object psobject -Property @{
+      chk_exists = ($exists = Test-Path $dst -PathType Leaf)
+      src_md5 = ($sMd5 = $_.Value)
+      dst_md5 = ($dMd5 = if ($exists) { Get-MD5Sum $dst } else { $null })
+      chk_dirty = ($dirty = if ($sMd5 -ne $dMd5) { $true } else { $false })
+      verifies = if ($dirty -eq $false) { $true } else { $false }
+    }
+  } | Select-Object -Property chk_exists,src_md5,dst_md5,chk_dirty,verifies
+}
+
+Function Get-MD5Sum($src) {
+  Try {
+    $c = New-Object -TypeName System.Security.Cryptography.MD5CryptoServiceProvider
+    $bytes = $c.ComputeHash(($in = (Get-Item $src).OpenRead()))
+    return ([System.BitConverter]::ToString($bytes)).Replace("-", "").ToLower()
+  } Finally { Cleanup $c; Cleanup $in }
+}
+
+Function Invoke-Input($in) {
+  $in = Unresolve-Path $in
+  Decode-Base64File $in ($decoded = "$($in).ps1")
+  $expr = Get-Content $decoded | Out-String
+  Remove-Item $in,$decoded -Force
+  return Invoke-Expression "$expr"
+}
+
+Function Unresolve-Path($p) { if ($p -eq $null) { return $null } else { return $ExecutionContext.SessionState.Path.GetUnresolvedProviderPathFromPSPath($p) } }
+
+Check-Files (Invoke-Input $hash_file) | ConvertTo-Csv -NoTypeInformation

data/lib/winrm-fs/scripts/checksum.ps1.erb

@@ -1,13 +1,13 @@
-$p = $ExecutionContext.SessionState.Path
-$path = $p.GetUnresolvedProviderPathFromPSPath("<%= path %>")
-
-if (Test-Path $path -PathType Leaf) {
-  $cryptoProv = New-Object -TypeName System.Security.Cryptography.MD5CryptoServiceProvider
-  $file = [System.IO.File]::Open($path,
-      [System.IO.Filemode]::Open, [System.IO.FileAccess]::Read)
-  $md5 = ([System.BitConverter]::ToString($cryptoProv.ComputeHash($file)))
-  $md5 = $md5.Replace("-","").ToLower()
-  $file.Close()
-
-  Write-Output $md5
-}
+$p = $ExecutionContext.SessionState.Path
+$path = $p.GetUnresolvedProviderPathFromPSPath("<%= path %>")
+
+if (Test-Path $path -PathType Leaf) {
+  $cryptoProv = New-Object -TypeName System.Security.Cryptography.MD5CryptoServiceProvider
+  $file = [System.IO.File]::Open($path,
+      [System.IO.Filemode]::Open, [System.IO.FileAccess]::Read)
+  $md5 = ([System.BitConverter]::ToString($cryptoProv.ComputeHash($file)))
+  $md5 = $md5.Replace("-","").ToLower()
+  $file.Close()
+
+  Write-Output $md5
+}

data/lib/winrm-fs/scripts/create_dir.ps1.erb

@@ -1,6 +1,6 @@
-$p = $ExecutionContext.SessionState.Path
-$path = $p.GetUnresolvedProviderPathFromPSPath("<%= path %>")
-if (!(Test-Path $path)) {
-  New-Item -ItemType Directory -Force -Path $path | Out-Null
-}
-exit 0
+$p = $ExecutionContext.SessionState.Path
+$path = $p.GetUnresolvedProviderPathFromPSPath("<%= path %>")
+if (!(Test-Path $path)) {
+  New-Item -ItemType Directory -Force -Path $path | Out-Null
+}
+exit 0

data/lib/winrm-fs/scripts/decode_files.ps1.erb

@@ -1,59 +1,58 @@
-trap {$e = $_.Exception; $e.InvocationInfo.ScriptName; do {$e.Message; $e = $e.InnerException} while ($e); break;}
-$progresspreference = 'SilentlyContinue'
-function Decode-Base64File($src, $dst) {folder (split-path $dst);sc -force -Encoding Byte -Path $dst -Value ([Convert]::FromBase64String([IO.File]::ReadAllLines($src)))}
-function Copy-Stream($src, $dst) {$b = New-Object Byte[] 4096; while (($i = $src.Read($b, 0, $b.Length)) -ne 0) { $dst.Write($b, 0, $i) } }
-function Resolve-ProviderPath{ $input | % {if ($_){(Resolve-Path $_).ProviderPath} else{$null}} }
-function Get-FrameworkVersion { "Full", "Client" | % {([version](gp "HKLM:\Software\Microsoft\NET Framework Setup\NDP\v4\$_").Version)} | select -first 1}
-function Test-NETStack($Version){ Get-FrameworkVersion -ge $Version }
-function Test-IOCompression {($PSVersionTable.PSVersion.Major -ge 3) -and (Test-NETStack '4.5')}
-function folder($path){ $path | ? {-not (test-path $_)} | % {$null = mkdir $_}}
-function disposable($o){($o -is [IDisposable]) -and (($o | gm | %{$_.name}) -contains 'Dispose')}
-function use($obj, [scriptblock]$sb){try {& $sb} catch [exception]{throw $_} finally {if (disposable $obj) {$obj.Dispose()}} }
-set-alias RPP -Value Resolve-ProviderPath
-
-Function Decode-Files($hash) {
-  foreach ($key in $hash.keys) {
-    $value = $hash[$key]
-    $tmp, $tzip, $dst = $Key, $Value["tmpzip"], $Value["dst"]
-    if($tmp -ne "") {
-      $sMd5 = (gi $tmp).BaseName.Replace("b64-", "")
-      $decoded = if ($tzip -ne $null) { $tzip } else { $dst }
-      Decode-Base64File $tmp $decoded
-      rm $tmp -Force
-      $dMd5 = Get-MD5Sum $decoded
-      $verifies = $sMd5 -like $dMd5
-    }
-    if ($tzip) {Unzip-File $tzip $dst}
-    New-Object psobject -Property @{dst=$dst;verifies=$verifies;src_md5=$sMd5;dst_md5=$dMd5;tmpfile=$tmp;tmpzip=$tzip}
-  }
-}
-
-Function Get-MD5Sum($src) {
-  if ($src -and (test-path $src)) {
-  use ($c = New-Object -TypeName Security.Cryptography.MD5CryptoServiceProvider) {
-    use ($in = (gi $src).OpenRead()) {([BitConverter]::ToString($c.ComputeHash($in))).Replace("-", "").ToLower()}}
-  }
-}
-
-Function Invoke-Input($in) {
-  $in = $in | rpp
-  $d = "$($in).ps1"
-  Decode-Base64File $in $d
-  $expr = gc $d | Out-String
-  rm $in,$d -Force
-  iex "$expr"
-}
-
-Function Unzip-File($src, $dst) {
-  $unpack = $src -replace '\.zip'
-  $dst_parent = Split-Path -Path $dst -Parent
-  if(!(Test-Path $dst_parent)) { $dst = $dst_parent }
-  folder $unpack, $dst
-  if (Test-IOCompression) {Add-Type -AN System.IO.Compression.FileSystem; [IO.Compression.ZipFile]::ExtractToDirectory($src, $unpack)}
-  else {Try {$s = New-Object -ComObject Shell.Application; ($s.NameSpace($unpack)).CopyHere(($s.NameSpace($src)).Items(), 0x610)} Finally {[void][Runtime.Interopservices.Marshal]::ReleaseComObject($s)}}
-  dir $unpack | cp -dest "$dst/" -force -recurse
-  rm $unpack -recurse -force
-}
-
-$hash_file = "<%= hash_file %>"
-Decode-Files (Invoke-Input $hash_file) | ConvertTo-Csv -NoTypeInformation
+trap {$e = $_.Exception; $e.InvocationInfo.ScriptName; do {$e.Message; $e = $e.InnerException} while ($e); break;}
+function Decode-Base64File($src, $dst) {folder (split-path $dst);sc -force -Encoding Byte -Path $dst -Value ([Convert]::FromBase64String([IO.File]::ReadAllLines($src)))}
+function Copy-Stream($src, $dst) {$b = New-Object Byte[] 4096; while (($i = $src.Read($b, 0, $b.Length)) -ne 0) { $dst.Write($b, 0, $i) } }
+function Resolve-ProviderPath{ $input | % {if ($_){(Resolve-Path $_).ProviderPath} else{$null}} }
+function Get-FrameworkVersion { "Full", "Client" | % {([version](gp "HKLM:\Software\Microsoft\NET Framework Setup\NDP\v4\$_").Version)} | select -first 1}
+function Test-NETStack($Version){ Get-FrameworkVersion -ge $Version }
+function Test-IOCompression {($PSVersionTable.PSVersion.Major -ge 3) -and (Test-NETStack '4.5')}
+function folder($path){ $path | ? {-not (test-path $_)} | % {$null = mkdir $_}}
+function disposable($o){($o -is [IDisposable]) -and (($o | gm | %{$_.name}) -contains 'Dispose')}
+function use($obj, [scriptblock]$sb){try {& $sb} catch [exception]{throw $_} finally {if (disposable $obj) {$obj.Dispose()}} }
+set-alias RPP -Value Resolve-ProviderPath
+
+Function Decode-Files($hash) {
+  foreach ($key in $hash.keys) {
+    $value = $hash[$key]
+    $tmp, $tzip, $dst = $Key, $Value["tmpzip"], $Value["dst"]
+    if(!$tmp.StartsWith("clean")) {
+      $sMd5 = (gi $tmp).BaseName.Replace("b64-", "")
+      $decoded = if ($tzip -ne $null) { $tzip } else { $dst }
+      Decode-Base64File $tmp $decoded
+      rm $tmp -Force
+      $dMd5 = Get-MD5Sum $decoded
+      $verifies = $sMd5 -like $dMd5
+    }
+    if ($tzip) {Unzip-File $tzip $dst}
+    New-Object psobject -Property @{dst=$dst;verifies=$verifies;src_md5=$sMd5;dst_md5=$dMd5;tmpfile=$tmp;tmpzip=$tzip}
+  }
+}
+
+Function Get-MD5Sum($src) {
+  if ($src -and (test-path $src)) {
+  use ($c = New-Object -TypeName Security.Cryptography.MD5CryptoServiceProvider) {
+    use ($in = (gi $src).OpenRead()) {([BitConverter]::ToString($c.ComputeHash($in))).Replace("-", "").ToLower()}}
+  }
+}
+
+Function Invoke-Input($in) {
+  $in = $in | rpp
+  $d = "$($in).ps1"
+  Decode-Base64File $in $d
+  $expr = gc $d | Out-String
+  rm $in,$d -Force
+  iex "$expr"
+}
+
+Function Unzip-File($src, $dst) {
+  $unpack = $src -replace '\.zip'
+  $dst_parent = Split-Path -Path $dst -Parent
+  if(!(Test-Path $dst_parent)) { $dst = $dst_parent }
+  folder $unpack, $dst
+  if (Test-IOCompression) {Add-Type -AN System.IO.Compression.FileSystem; [IO.Compression.ZipFile]::ExtractToDirectory($src, $unpack)}
+  else {Try {$s = New-Object -ComObject Shell.Application; ($s.NameSpace($unpack)).CopyHere(($s.NameSpace($src)).Items(), 0x610)} Finally {[void][Runtime.Interopservices.Marshal]::ReleaseComObject($s)}}
+  dir $unpack | cp -dest "$dst/" -force -recurse
+  rm $unpack -recurse -force
+}
+
+$hash_file = "<%= hash_file %>"
+Decode-Files (Invoke-Input $hash_file) | ConvertTo-Csv -NoTypeInformation

data/lib/winrm-fs/scripts/delete.ps1.erb

@@ -1,6 +1,6 @@
-$p = $ExecutionContext.SessionState.Path
-$path = $p.GetUnresolvedProviderPathFromPSPath("<%= path %>")
-if (Test-Path $path) {
-  Remove-Item $path -Force -Recurse
-}
-exit 0
+$p = $ExecutionContext.SessionState.Path
+$path = $p.GetUnresolvedProviderPathFromPSPath("<%= path %>")
+if (Test-Path $path) {
+  Remove-Item $path -Force -Recurse
+}
+exit 0

data/lib/winrm-fs/scripts/download.ps1.erb

@@ -1,8 +1,8 @@
-$p = $ExecutionContext.SessionState.Path
-$path = $p.GetUnresolvedProviderPathFromPSPath("<%= path %>")
-if (Test-Path $path -PathType Leaf) {
-  $bytes = [System.convert]::ToBase64String([System.IO.File]::ReadAllBytes($path))
-  Write-Host $bytes
-  exit 0
-}
-exit 1
+$p = $ExecutionContext.SessionState.Path
+$path = $p.GetUnresolvedProviderPathFromPSPath("<%= path %>")
+if (Test-Path $path -PathType Leaf) {
+  $bytes = [System.convert]::ToBase64String([System.IO.File]::ReadAllBytes($path))
+  Write-Host $bytes
+  exit 0
+}
+exit 1

data/lib/winrm-fs/scripts/exists.ps1.erb

@@ -1,8 +1,8 @@
-$p = $ExecutionContext.SessionState.Path
-$path = $p.GetUnresolvedProviderPathFromPSPath("<%= path %>")
-if (Test-Path $path) {
-  exit 0
-}
-else {
-  exit 1
-}
+$p = $ExecutionContext.SessionState.Path
+$path = $p.GetUnresolvedProviderPathFromPSPath("<%= path %>")
+if (Test-Path $path) {
+  exit 0
+}
+else {
+  exit 1
+}

data/lib/winrm-fs/scripts/scripts.rb

@@ -1,31 +1,31 @@
-# encoding: UTF-8
-#
-# Copyright 2015 Shawn Neal <sneal@sneal.net>
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-require 'erubis'
-
-module WinRM
-  module FS
-    # PS1 scripts
-    module Scripts
-      def self.render(template, context)
-        template_path = File.expand_path(
-          "#{File.dirname(__FILE__)}/#{template}.ps1.erb")
-        template = File.read(template_path)
-        Erubis::Eruby.new(template).result(context)
-      end
-    end
-  end
-end
+# encoding: UTF-8
+#
+# Copyright 2015 Shawn Neal <sneal@sneal.net>
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+require 'erubis'
+
+module WinRM
+  module FS
+    # PS1 scripts
+    module Scripts
+      def self.render(template, context)
+        template_path = File.expand_path(
+          "#{File.dirname(__FILE__)}/#{template}.ps1.erb")
+        template = File.read(template_path)
+        Erubis::Eruby.new(template).result(context)
+      end
+    end
+  end
+end

data/spec/config-example.yml

@@ -1,5 +1,5 @@
-auth_type: plaintext
-endpoint: "http://192.168.137.20:5985/wsman"
-options:
-  user: vagrant
+auth_type: plaintext
+endpoint: "http://192.168.137.20:5985/wsman"
+options:
+  user: vagrant
   pass: vagrant

data/spec/integration/file_manager_spec.rb

@@ -1,191 +1,203 @@
-# encoding: UTF-8
-require 'pathname'
-
-describe WinRM::FS::FileManager do
-  let(:dest_dir) { File.join(subject.temp_dir, "winrm_#{rand(2**16)}") }
-  let(:temp_upload_dir) { '$env:TEMP/winrm-upload' }
-  let(:spec_dir) { File.expand_path(File.dirname(File.dirname(__FILE__))) }
-  let(:this_file) { __FILE__ }
-  let(:service) { winrm_connection }
-
-  subject { WinRM::FS::FileManager.new(service) }
-
-  before(:each) do
-    expect(subject.delete(dest_dir)).to be true
-    expect(subject.delete(temp_upload_dir)).to be true
-  end
-
-  context 'exists?' do
-    it 'should exist' do
-      expect(subject.exists?('c:/windows')).to be true
-      expect(subject.exists?('c:/foobar')).to be false
-    end
-  end
-
-  context 'create and delete dir' do
-    it 'should create the directory recursively' do
-      subdir = File.join(dest_dir, 'subdir1', 'subdir2')
-      expect(subject.create_dir(subdir)).to be true
-      expect(subject.exists?(subdir)).to be true
-      expect(subject.create_dir(subdir)).to be true
-      expect(subject.delete(subdir)).to be true
-      expect(subject.exists?(subdir)).to be false
-    end
-  end
-
-  context 'temp_dir' do
-    it 'should return the remote users temp dir' do
-      expect(subject.temp_dir).to match(%r{C:/Users/\S+/AppData/Local/Temp})
-    end
-  end
-
-  context 'upload file' do
-    let(:dest_file) { File.join(dest_dir, File.basename(this_file)) }
-
-    before(:each) do
-      expect(subject.delete(dest_dir)).to be true
-    end
-
-    it 'should upload the specified file' do
-      subject.upload(this_file, dest_file)
-      expect(subject).to have_created(dest_file).with_content(this_file)
-    end
-
-    it 'should upload to root of the c: drive' do
-      subject.upload(this_file, 'c:/winrmtest.rb')
-      expect(subject).to have_created('c:/winrmtest.rb').with_content(this_file)
-      subject.delete('c:/winrmtest.rb')
-    end
-
-    it 'should upload using relative file path' do
-      subject.upload('./spec/integration/file_manager_spec.rb', dest_file)
-      expect(subject).to have_created(dest_file).with_content(this_file)
-    end
-
-    it 'should upload to the specified directory' do
-      subject.upload(this_file, dest_dir)
-      expect(subject).to have_created(dest_file).with_content(this_file)
-    end
-
-    it 'should upload to the specified directory with env var' do
-      subject.upload(this_file, '$env:Temp')
-      expected_dest_file = File.join(subject.temp_dir, File.basename(this_file))
-      expect(subject).to have_created(expected_dest_file).with_content(this_file)
-    end
-
-    it 'should upload to Program Files sub dir' do
-      subject.upload(this_file, '$env:ProgramFiles/foo')
-      expect(subject).to have_created('c:/Program Files/foo/file_manager_spec.rb') \
-        .with_content(this_file)
-    end
-
-    it 'should upload to the specified nested directory' do
-      dest_sub_dir = File.join(dest_dir, 'subdir')
-      dest_sub_dir_file = File.join(dest_sub_dir, File.basename(this_file))
-      subject.upload(this_file, dest_sub_dir)
-      expect(subject).to have_created(dest_sub_dir_file).with_content(this_file)
-    end
-
-    it 'yields progress data' do
-      block_called = false
-      total_bytes_copied = 0
-      total = subject.upload(this_file, dest_file) do \
-        |bytes_copied, total_bytes, local_path, remote_path|
-        expect(total_bytes).to be > 0
-        total_bytes_copied = bytes_copied
-        expect(local_path).to eq(this_file)
-        expect(remote_path).to eq(dest_file)
-        block_called = true
-      end
-      expect(total_bytes_copied).to eq(total)
-      expect(block_called).to be true
-      expect(total).to be > 0
-    end
-
-    it 'should not upload when content matches' do
-      subject.upload(this_file, dest_dir)
-      bytes_uploaded = subject.upload(this_file, dest_dir)
-      expect(bytes_uploaded).to eq 0
-    end
-
-    it 'should upload when content differs' do
-      matchers_file = File.join(spec_dir, 'matchers.rb')
-      subject.upload(matchers_file, dest_file)
-      bytes_uploaded = subject.upload(this_file, dest_file)
-      expect(bytes_uploaded).to be > 0
-    end
-
-    it 'raises WinRMUploadError when a bad source path is specified' do
-      expect { subject.upload('c:/some/non-existant/path/foo', dest_file) }.to raise_error
-    end
-  end
-
-  context 'upload empty file' do
-    let(:empty_src_file) { Tempfile.new('empty') }
-    let(:dest_file) { File.join(dest_dir, 'emptyfile.txt') }
-
-    it 'creates a new empty file' do
-      expect(subject.upload(empty_src_file.path, dest_file)).to be 0
-      expect(subject).to have_created(dest_file).with_content('')
-    end
-
-    it 'overwrites an existing file' do
-      expect(subject.upload(this_file, dest_file)).to be > 0
-      expect(subject.upload(empty_src_file.path, dest_file)).to be 0
-      expect(subject).to have_created(dest_file).with_content('')
-    end
-  end
-
-  context 'upload directory' do
-    let(:root_dir) { File.expand_path('../../', File.dirname(__FILE__)) }
-    let(:winrm_fs_dir) { File.join(root_dir, 'lib/winrm-fs') }
-    let(:core_dir) { File.join(root_dir, 'lib/winrm-fs/core') }
-
-    it 'copies the directory contents recursively when directory does not exist' do
-      bytes_uploaded = subject.upload(winrm_fs_dir, dest_dir)
-      expect(bytes_uploaded).to be > 0
-
-      Dir.glob(winrm_fs_dir + '/**/*.rb').each do |host_file|
-        host_file_rel = Pathname.new(host_file).relative_path_from(
-          Pathname.new(winrm_fs_dir)
-        ).to_s
-        remote_file = File.join(dest_dir, host_file_rel)
-        expect(subject).to have_created(remote_file).with_content(host_file)
-      end
-    end
-
-    it 'copies the directory recursively when directory does exist' do
-      subject.create_dir(dest_dir)
-      bytes_uploaded = subject.upload(winrm_fs_dir, dest_dir)
-      expect(bytes_uploaded).to be > 0
-
-      Dir.glob(winrm_fs_dir + '/**/*.rb').each do |host_file|
-        host_file_rel = Pathname.new(host_file).relative_path_from(
-          Pathname.new(winrm_fs_dir).dirname
-        ).to_s
-        remote_file = File.join(dest_dir, host_file_rel)
-        expect(subject).to have_created(remote_file).with_content(host_file)
-      end
-    end
-
-    it 'does not copy the directory when content is the same' do
-      subject.upload(winrm_fs_dir, dest_dir)
-      bytes_uploaded = subject.upload(winrm_fs_dir, dest_dir)
-      expect(bytes_uploaded).to eq 0
-    end
-
-    it 'unzips the directory when cached content is the same' do
-      subject.upload(winrm_fs_dir, dest_dir)
-      subject.delete(dest_dir)
-      expect(subject.exists?(dest_dir)).to be false
-      subject.upload(winrm_fs_dir, dest_dir)
-      expect(subject.exists?(dest_dir)).to be true
-    end
-
-    it 'copies the directory when content differs' do
-      subject.upload(winrm_fs_dir, dest_dir)
-      bytes_uploaded = subject.upload(core_dir, dest_dir)
-      expect(bytes_uploaded).to be > 0
-    end
-  end
-end
+# encoding: UTF-8
+require 'pathname'
+
+describe WinRM::FS::FileManager do
+  let(:dest_dir) { File.join(subject.temp_dir, "winrm_#{rand(2**16)}") }
+  let(:temp_upload_dir) { '$env:TEMP/winrm-upload' }
+  let(:spec_dir) { File.expand_path(File.dirname(File.dirname(__FILE__))) }
+  let(:this_file) { __FILE__ }
+  let(:service) { winrm_connection }
+
+  subject { WinRM::FS::FileManager.new(service) }
+
+  before(:each) do
+    expect(subject.delete(dest_dir)).to be true
+    expect(subject.delete(temp_upload_dir)).to be true
+  end
+
+  context 'exists?' do
+    it 'should exist' do
+      expect(subject.exists?('c:/windows')).to be true
+      expect(subject.exists?('c:/foobar')).to be false
+    end
+  end
+
+  context 'create and delete dir' do
+    it 'should create the directory recursively' do
+      subdir = File.join(dest_dir, 'subdir1', 'subdir2')
+      expect(subject.create_dir(subdir)).to be true
+      expect(subject.exists?(subdir)).to be true
+      expect(subject.create_dir(subdir)).to be true
+      expect(subject.delete(subdir)).to be true
+      expect(subject.exists?(subdir)).to be false
+    end
+  end
+
+  context 'temp_dir' do
+    it 'should return the remote users temp dir' do
+      expect(subject.temp_dir).to match(%r{C:/Users/\S+/AppData/Local/Temp})
+    end
+  end
+
+  context 'upload file' do
+    let(:dest_file) { File.join(dest_dir, File.basename(this_file)) }
+
+    before(:each) do
+      expect(subject.delete(dest_dir)).to be true
+    end
+
+    it 'should upload the specified file' do
+      subject.upload(this_file, dest_file)
+      expect(subject).to have_created(dest_file).with_content(this_file)
+    end
+
+    it 'should upload to root of the c: drive' do
+      subject.upload(this_file, 'c:/winrmtest.rb')
+      expect(subject).to have_created('c:/winrmtest.rb').with_content(this_file)
+      subject.delete('c:/winrmtest.rb')
+    end
+
+    it 'should upload using relative file path' do
+      subject.upload('./spec/integration/file_manager_spec.rb', dest_file)
+      expect(subject).to have_created(dest_file).with_content(this_file)
+    end
+
+    it 'should upload to the specified directory' do
+      subject.upload(this_file, dest_dir)
+      expect(subject).to have_created(dest_file).with_content(this_file)
+    end
+
+    it 'should upload to the specified directory with env var' do
+      subject.upload(this_file, '$env:Temp')
+      expected_dest_file = File.join(subject.temp_dir, File.basename(this_file))
+      expect(subject).to have_created(expected_dest_file).with_content(this_file)
+    end
+
+    it 'should upload to Program Files sub dir' do
+      subject.upload(this_file, '$env:ProgramFiles/foo')
+      expect(subject).to have_created('c:/Program Files/foo/file_manager_spec.rb') \
+        .with_content(this_file)
+    end
+
+    it 'should upload to the specified nested directory' do
+      dest_sub_dir = File.join(dest_dir, 'subdir')
+      dest_sub_dir_file = File.join(dest_sub_dir, File.basename(this_file))
+      subject.upload(this_file, dest_sub_dir)
+      expect(subject).to have_created(dest_sub_dir_file).with_content(this_file)
+    end
+
+    it 'yields progress data' do
+      block_called = false
+      total_bytes_copied = 0
+      total = subject.upload(this_file, dest_file) do \
+        |bytes_copied, total_bytes, local_path, remote_path|
+        expect(total_bytes).to be > 0
+        total_bytes_copied = bytes_copied
+        expect(local_path).to eq(this_file)
+        expect(remote_path).to eq(dest_file)
+        block_called = true
+      end
+      expect(total_bytes_copied).to eq(total)
+      expect(block_called).to be true
+      expect(total).to be > 0
+    end
+
+    it 'should not upload when content matches' do
+      subject.upload(this_file, dest_dir)
+      bytes_uploaded = subject.upload(this_file, dest_dir)
+      expect(bytes_uploaded).to eq 0
+    end
+
+    it 'should upload when content differs' do
+      matchers_file = File.join(spec_dir, 'matchers.rb')
+      subject.upload(matchers_file, dest_file)
+      bytes_uploaded = subject.upload(this_file, dest_file)
+      expect(bytes_uploaded).to be > 0
+    end
+
+    it 'raises WinRMUploadError when a bad source path is specified' do
+      expect { subject.upload('c:/some/non-existant/path/foo', dest_file) }.to raise_error
+    end
+  end
+
+  context 'upload empty file' do
+    let(:empty_src_file) { Tempfile.new('empty') }
+    let(:dest_file) { File.join(dest_dir, 'emptyfile.txt') }
+
+    it 'creates a new empty file' do
+      expect(subject.upload(empty_src_file.path, dest_file)).to be 0
+      expect(subject).to have_created(dest_file).with_content('')
+    end
+
+    it 'overwrites an existing file' do
+      expect(subject.upload(this_file, dest_file)).to be > 0
+      expect(subject.upload(empty_src_file.path, dest_file)).to be 0
+      expect(subject).to have_created(dest_file).with_content('')
+    end
+  end
+
+  context 'upload directory' do
+    let(:root_dir) { File.expand_path('../../', File.dirname(__FILE__)) }
+    let(:winrm_fs_dir) { File.join(root_dir, 'lib/winrm-fs') }
+    let(:core_dir) { File.join(root_dir, 'lib/winrm-fs/core') }
+    let(:scripts_dir) { File.join(root_dir, 'lib/winrm-fs/scripts') }
+
+    it 'copies the directory contents recursively when directory does not exist' do
+      bytes_uploaded = subject.upload(winrm_fs_dir, dest_dir)
+      expect(bytes_uploaded).to be > 0
+
+      Dir.glob(winrm_fs_dir + '/**/*.rb').each do |host_file|
+        host_file_rel = Pathname.new(host_file).relative_path_from(
+          Pathname.new(winrm_fs_dir)
+        ).to_s
+        remote_file = File.join(dest_dir, host_file_rel)
+        expect(subject).to have_created(remote_file).with_content(host_file)
+      end
+    end
+
+    it 'copies the directory recursively when directory does exist' do
+      subject.create_dir(dest_dir)
+      bytes_uploaded = subject.upload(winrm_fs_dir, dest_dir)
+      expect(bytes_uploaded).to be > 0
+
+      Dir.glob(winrm_fs_dir + '/**/*.rb').each do |host_file|
+        host_file_rel = Pathname.new(host_file).relative_path_from(
+          Pathname.new(winrm_fs_dir).dirname
+        ).to_s
+        remote_file = File.join(dest_dir, host_file_rel)
+        expect(subject).to have_created(remote_file).with_content(host_file)
+      end
+    end
+
+    it 'does not copy the directory when content is the same' do
+      subject.upload(winrm_fs_dir, dest_dir)
+      bytes_uploaded = subject.upload(winrm_fs_dir, dest_dir)
+      expect(bytes_uploaded).to eq 0
+    end
+
+    it 'unzips the directory when cached content is the same' do
+      subject.upload(winrm_fs_dir, dest_dir)
+      subject.delete(dest_dir)
+      expect(subject.exists?(dest_dir)).to be false
+      subject.upload(winrm_fs_dir, dest_dir)
+      expect(subject.exists?(dest_dir)).to be true
+    end
+
+    it 'unzips multiple directories when cached content is the same for all' do
+      subject.create_dir(dest_dir)
+      subject.upload([core_dir, scripts_dir], dest_dir)
+      subject.delete(dest_dir)
+      expect(subject.exists?(dest_dir)).to be false
+      subject.create_dir(dest_dir)
+      subject.upload([core_dir, scripts_dir], dest_dir)
+      expect(subject.exists?(File.join(dest_dir, 'core'))).to be true
+      expect(subject.exists?(File.join(dest_dir, 'scripts'))).to be true
+    end
+
+    it 'copies the directory when content differs' do
+      subject.upload(winrm_fs_dir, dest_dir)
+      bytes_uploaded = subject.upload(core_dir, dest_dir)
+      expect(bytes_uploaded).to be > 0
+    end
+  end
+end