winrm-fs 0.4.3 → 1.0.0

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

@@ -1,20 +1,11 @@
-$host.ui.RawUI.WindowSize.Width=256
-$hash_file = "<%= hash_file %>"
+$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 Cleanup($disposable) {
+  if (($disposable -ne $null) -and ($disposable.GetType().GetMethod("Dispose") -ne $null)) {
+    $disposable.Dispose()
+  }
 }
 
-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 $_.Value.target
@@ -36,25 +27,23 @@ Function Check-Files($h) {
 
 Function Get-MD5Sum($src) {
   Try {
-    $c = New-Object -TypeName System.Security.Cryptography.MD5CryptoServiceProvider
+    $c = [System.Security.Cryptography.MD5]::Create()
     $bytes = $c.ComputeHash(($in = (Get-Item $src).OpenRead()))
     return ([System.BitConverter]::ToString($bytes)).Replace("-", "").ToLower()
-  } Finally { Cleanup $c; Cleanup $in }
+  } 
+  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
-  try {
-    return Invoke-Expression "$expr"
+Function Unresolve-Path($path) {
+  if ($path -eq $null) {
+    return $null
   }
-  catch {
-    throw "There was an error invoking '$expr': `n$($_ | Out-String)"
+  else {
+    return $ExecutionContext.SessionState.Path.GetUnresolvedProviderPathFromPSPath($path)
   }
 }
 
-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
+Check-Files $hash_file | ConvertTo-Csv -NoTypeInformation

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

@@ -2,7 +2,7 @@ $p = $ExecutionContext.SessionState.Path
 $path = $p.GetUnresolvedProviderPathFromPSPath("<%= path %>")
 
 if (Test-Path $path -PathType Leaf) {
-  $cryptoProv = New-Object -TypeName System.Security.Cryptography.MD5CryptoServiceProvider
+  $cryptoProv = [System.Security.Cryptography.MD5]::Create()
   $file = [System.IO.File]::Open($path,
       [System.IO.Filemode]::Open, [System.IO.FileAccess]::Read)
   $md5 = ([System.BitConverter]::ToString($cryptoProv.ComputeHash($file)))

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

@@ -0,0 +1,52 @@
+trap {
+  $e = $_.Exception
+  $e.InvocationInfo.ScriptName
+  do {
+    $e.Message
+    $e = $e.InnerException
+  } while ($e)
+  break
+}
+
+function folder($path){
+  $path | ? {-not (test-path $_)} | % {$null = mkdir $_}
+}
+
+Function Decode-Files($hash) {
+  foreach ($key in $hash.keys) {
+    $value = $hash[$key]
+    $tzip, $dst = $Value["tmpzip"], $Value["dst"]
+    if ($tzip) {Unzip-File $tzip $dst}
+    New-Object psobject -Property @{dst=$dst;src_md5=$key;tmpzip=$tzip}
+  }
+}
+
+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
+  try {
+    try{
+      [IO.Compression.ZipFile]::ExtractToDirectory($src, $unpack)
+    }
+    catch {
+      Add-Type -AssemblyName System.IO.Compression.FileSystem -ErrorAction Stop
+      [IO.Compression.ZipFile]::ExtractToDirectory($src, $unpack)
+    }
+  }
+  catch {
+    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 $hash_file | ConvertTo-Csv -NoTypeInformation

data/spec/config-example.yml

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

data/spec/integration/file_manager_spec.rb

@@ -5,7 +5,7 @@ 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(:this_file) { Pathname.new(__FILE__) }
   let(:service) { winrm_connection }
 
   subject { WinRM::FS::FileManager.new(service) }
@@ -40,7 +40,7 @@ describe WinRM::FS::FileManager do
   end
 
   context 'upload file' do
-    let(:dest_file) { File.join(dest_dir, File.basename(this_file)) }
+    let(:dest_file) { Pathname.new(File.join(dest_dir, File.basename(this_file))) }
 
     before(:each) do
       expect(subject.delete(dest_dir)).to be true
@@ -57,6 +57,12 @@ describe WinRM::FS::FileManager do
       subject.delete('c:/winrmtest.rb')
     end
 
+    it 'should upload just filename' do
+      subject.upload(this_file, 'winrmtest.rb')
+      expect(subject).to have_created('winrmtest.rb').with_content(this_file)
+      subject.delete('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)
@@ -108,8 +114,8 @@ describe WinRM::FS::FileManager 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)
+        expect(local_path).to eq(this_file.to_s)
+        expect(remote_path).to eq(dest_file.to_s)
         block_called = true
       end
       expect(total_bytes_copied).to eq(total)

data/spec/spec_helper.rb

@@ -9,15 +9,14 @@ require_relative 'matchers'
 module ConnectionHelper
   # rubocop:disable AbcSize
   def winrm_connection
-    WinRM::WinRMWebService.new(
-      config[:endpoint], config[:auth_type].to_sym, config[:options])
+    WinRM::Connection.new(config)
   end
   # rubocop:enable AbcSize
 
   def config
     @config ||= begin
       cfg = symbolize_keys(YAML.load(File.read(winrm_config_path)))
-      cfg[:options].merge!(basic_auth_only: true) unless cfg[:auth_type].eql? :kerberos
+      cfg.merge!(basic_auth_only: true) unless cfg[:transport].eql? :kerberos
       merge_environment!(cfg)
       cfg
     end
@@ -25,18 +24,18 @@ module ConnectionHelper
 
   def merge_environment!(config)
     merge_config_option_from_environment(config, 'user')
-    merge_config_option_from_environment(config, 'pass')
+    merge_config_option_from_environment(config, 'password')
     merge_config_option_from_environment(config, 'no_ssl_peer_verification')
     if ENV['use_ssl_peer_fingerprint']
       config[:options][:ssl_peer_fingerprint] = ENV['winrm_cert']
     end
     config[:endpoint] = ENV['winrm_endpoint'] if ENV['winrm_endpoint']
-    config[:auth_type] = ENV['winrm_auth_type'] if ENV['winrm_auth_type']
+    config[:transport] = ENV['winrm_transport'] if ENV['winrm_transport']
   end
 
   def merge_config_option_from_environment(config, key)
     env_key = 'winrm_' + key
-    config[:options][key.to_sym] = ENV[env_key] if ENV[env_key]
+    config[key.to_sym] = ENV[env_key] if ENV[env_key]
   end
 
   def winrm_config_path

data/winrm-fs.gemspec

@@ -29,7 +29,7 @@ Gem::Specification.new do |s|
   s.add_runtime_dependency 'erubis', '~> 2.7'
   s.add_runtime_dependency 'logging', ['>= 1.6.1', '< 3.0']
   s.add_runtime_dependency 'rubyzip', '~> 1.1'
-  s.add_runtime_dependency 'winrm', '~> 1.5'
+  s.add_runtime_dependency 'winrm', '~> 2.0'
   s.add_development_dependency 'pry'
   s.add_development_dependency 'rspec', '~> 3.0.0'
   s.add_development_dependency 'rake', '~> 10.3.2'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: winrm-fs
 version: !ruby/object:Gem::Version
-  version: 0.4.3
+  version: 1.0.0
 platform: ruby
 authors:
 - Shawn Neal
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-06-21 00:00:00.000000000 Z
+date: 2016-08-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: erubis
@@ -65,14 +65,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.5'
+        version: '2.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.5'
+        version: '2.0'
 - !ruby/object:Gem::Dependency
   name: pry
   requirement: !ruby/object:Gem::Requirement
@@ -129,8 +129,7 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: 0.28.0
-description: |2
-      Ruby library for file system operations via Windows Remote Management
+description: "    Ruby library for file system operations via Windows Remote Management\n"
 email:
 - sneal@sneal.net
 - matt@mattwrock.com
@@ -162,17 +161,16 @@ files:
 - lib/winrm-fs/scripts/check_files.ps1.erb
 - lib/winrm-fs/scripts/checksum.ps1.erb
 - lib/winrm-fs/scripts/create_dir.ps1.erb
-- lib/winrm-fs/scripts/decode_files.ps1.erb
 - lib/winrm-fs/scripts/delete.ps1.erb
 - lib/winrm-fs/scripts/download.ps1.erb
 - lib/winrm-fs/scripts/exists.ps1.erb
+- lib/winrm-fs/scripts/extract_files.ps1.erb
 - lib/winrm-fs/scripts/scripts.rb
 - spec/config-example.yml
 - spec/integration/file_manager_spec.rb
 - spec/integration/tmp_zip_spec.rb
 - spec/matchers.rb
 - spec/spec_helper.rb
-- spec/unit/file_transporter_spec.rb
 - spec/unit/tmp_zip_spec.rb
 - winrm-fs.gemspec
 homepage: http://github.com/WinRb/winrm-fs
@@ -198,7 +196,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.6.4
+rubygems_version: 2.6.6
 signing_key: 
 specification_version: 4
 summary: WinRM File System

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

@@ -1,58 +0,0 @@
-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/spec/unit/file_transporter_spec.rb

@@ -1,839 +0,0 @@
-# -*- encoding: utf-8 -*-
-#
-# Author:: Fletcher (<fnichol@nichol.ca>)
-#
-# Copyright (C) 2015, Fletcher Nichol
-#
-# 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 'base64'
-require 'csv'
-require 'stringio'
-require 'logger'
-require 'winrm'
-
-require 'winrm-fs/core/file_transporter'
-
-describe WinRM::FS::Core::FileTransporter do
-  CheckEntry = Struct.new(
-    :chk_exists, :src_md5, :dst_md5, :chk_dirty, :verifies)
-  DecodeEntry = Struct.new(
-    :dst, :verifies, :src_md5, :dst_md5, :tmpfile, :tmpzip)
-
-  let(:logged_output) { StringIO.new }
-  let(:logger)        { Logger.new(logged_output) }
-
-  let(:randomness)    { %w(alpha beta charlie delta).each }
-  let(:id_generator)  { -> { randomness.next } }
-  let(:winrm_service) { double('winrm_service', logger: logger) }
-  let(:service) { double('command_executor', service: winrm_service) }
-  let(:transporter) do
-    WinRM::FS::Core::FileTransporter.new(
-      service,
-      id_generator: id_generator
-    )
-  end
-
-  before { @tempfiles = [] }
-
-  after { @tempfiles.each(&:unlink) }
-
-  describe 'when uploading a single file' do
-    let(:content)     { '.' * 12_003 }
-    let(:local)       { create_tempfile('input.txt', content) }
-    let(:remote)      { 'C:\\dest' }
-    let(:dst)         { "#{remote}/#{File.basename(local)}" }
-    let(:src_md5)     { md5sum(local) }
-    let(:size)        { File.size(local) }
-    let(:cmd_tmpfile) { "%TEMP%\\b64-#{src_md5}.txt" }
-    let(:ps_tmpfile)  { "$env:TEMP\\b64-#{src_md5}.txt" }
-
-    let(:upload) { transporter.upload(local, remote) }
-
-    # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
-    def self.common_specs_for_all_single_file_types
-      it 'truncates a zero-byte hash_file for check_files' do
-        expect(service).to receive(:run_cmd).with(
-          regexify(%(echo|set /p=>"%TEMP%\\hash-alpha.txt")))
-          .and_return(cmd_output)
-
-        upload
-      end
-
-      it 'uploads the hash_file in chunks for check_files' do
-        hash = outdent!(<<-HASH.chomp)
-          @{
-            "#{src_md5}" = @{
-              "target" = "#{remote}";
-              "src_basename" = "#{File.basename(local)}";
-              "dst" = "#{remote}"
-            }
-          }
-        HASH
-
-        expect(service).to receive(:run_cmd)
-          .with(%(echo #{base64(hash)} >> "%TEMP%\\hash-alpha.txt"))
-          .and_return(cmd_output).once
-
-        upload
-      end
-
-      it 'sets hash_file and runs the check_files powershell script' do
-        expect(service).to receive(:run_powershell_script).with(
-          regexify(%($hash_file = "$env:TEMP\\hash-alpha.txt")) &&
-            regexify(
-              'Check-Files (Invoke-Input $hash_file) | ' \
-              'ConvertTo-Csv -NoTypeInformation')
-        ).and_return(check_output)
-
-        upload
-      end
-    end
-    # rubocop:enable Metrics/MethodLength, Metrics/AbcSize
-
-    # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
-    def self.common_specs_for_all_single_dirty_file_types
-      it 'truncates a zero-byte tempfile' do
-        expect(service).to receive(:run_cmd).with(
-          regexify(%(echo|set /p=>"#{cmd_tmpfile}"))
-        ).and_return(cmd_output)
-
-        upload
-      end
-
-      it 'ploads the file in 8k chunks' do
-        expect(service).to receive(:run_cmd)
-          .with(%(echo #{base64('.' * 6000)} >> "#{cmd_tmpfile}"))
-          .and_return(cmd_output).twice
-        expect(service).to receive(:run_cmd)
-          .with(%(echo #{base64('.' * 3)} >> "#{cmd_tmpfile}"))
-          .and_return(cmd_output).once
-
-        upload
-      end
-
-      describe 'with a small file' do
-        let(:content) { 'hello, world' }
-
-        it 'uploads the file in base64 encoding' do
-          expect(service).to receive(:run_cmd)
-            .with(%(echo #{base64(content)} >> "#{cmd_tmpfile}"))
-            .and_return(cmd_output)
-
-          upload
-        end
-      end
-
-      it 'truncates a zero-byte hash_file for decode_files' do
-        expect(service).to receive(:run_cmd).with(
-          regexify(%(echo|set /p=>"%TEMP%\\hash-beta.txt"))
-        ).and_return(cmd_output)
-
-        upload
-      end
-
-      it 'uploads the hash_file in chunks for decode_files' do
-        hash = outdent!(<<-HASH.chomp)
-          @{
-            "#{ps_tmpfile}" = @{
-              "dst" = "#{remote}"
-            }
-          }
-        HASH
-
-        expect(service).to receive(:run_cmd)
-          .with(%(echo #{base64(hash)} >> "%TEMP%\\hash-beta.txt"))
-          .and_return(cmd_output).once
-
-        upload
-      end
-
-      it 'sets hash_file and runs the decode_files powershell script' do
-        expect(service).to receive(:run_powershell_script).with(
-          regexify(%($hash_file = "$env:TEMP\\hash-beta.txt")) &&
-            regexify(
-              'Decode-Files (Invoke-Input $hash_file) | ' \
-              'ConvertTo-Csv -NoTypeInformation')
-        ).and_return(check_output)
-
-        upload
-      end
-    end
-    # rubocop:enable Metrics/MethodLength, Metrics/AbcSize
-
-    describe 'for a new file' do
-      # let(:check_output) do
-      def check_output
-        create_check_output([
-          CheckEntry.new('False', src_md5, nil, 'True', 'False')
-        ])
-      end
-
-      let(:cmd_output) do
-        o = ::WinRM::Output.new
-        o[:exitcode] = 0
-        o
-      end
-
-      # let(:decode_output) do
-      def decode_output
-        create_decode_output([
-          DecodeEntry.new(dst, 'True', src_md5, src_md5, ps_tmpfile, nil)
-        ])
-      end
-
-      before do
-        allow(service).to receive(:run_cmd)
-          .and_return(cmd_output)
-
-        allow(service).to receive(:run_powershell_script)
-          .with(/^Check-Files .+ \| ConvertTo-Csv/)
-          .and_return(check_output)
-
-        allow(service).to receive(:run_powershell_script)
-          .with(/^Decode-Files .+ \| ConvertTo-Csv/)
-          .and_return(decode_output)
-      end
-
-      common_specs_for_all_single_file_types
-
-      common_specs_for_all_single_dirty_file_types
-
-      it 'returns a report hash' do
-        expect(upload[1]).to eq(
-          src_md5 => {
-            'src'         => local,
-            'dst'         => dst,
-            'tmpfile'     => ps_tmpfile,
-            'tmpzip'      => nil,
-            'src_md5'     => src_md5,
-            'dst_md5'     => src_md5,
-            'chk_exists'  => 'False',
-            'chk_dirty'   => 'True',
-            'verifies'    => 'True',
-            'size'        => size,
-            'xfered'      => size / 3 * 4,
-            'chunks'      => (size / 6000.to_f).ceil
-          }
-        )
-      end
-
-      describe 'when a failed check command is returned' do
-        def check_output
-          o = ::WinRM::Output.new
-          o[:exitcode] = 10
-          o[:data].concat([{ stderr: 'Oh noes\n' }])
-          o
-        end
-
-        it 'raises a FileTransporterFailed error' do
-          expect { upload }.to raise_error(
-            WinRM::FS::Core::FileTransporterFailed, /Upload failed \(exitcode: 10\)/)
-        end
-      end
-
-      describe 'when a failed decode command is returned' do
-        def decode_output
-          o = ::WinRM::Output.new
-          o[:exitcode] = 10
-          o[:data].concat([{ stderr: 'Oh noes\n' }])
-          o
-        end
-
-        it 'raises a FileTransporterFailed error' do
-          expect { upload }.to raise_error(
-            WinRM::FS::Core::FileTransporterFailed, /Upload failed \(exitcode: 10\)/)
-        end
-      end
-    end
-
-    describe 'for an out of date (dirty) file' do
-      let(:check_output) do
-        create_check_output([
-          CheckEntry.new('True', src_md5, 'aabbcc', 'True', 'False')
-        ])
-      end
-
-      let(:cmd_output) do
-        o = ::WinRM::Output.new
-        o[:exitcode] = 0
-        o
-      end
-
-      let(:decode_output) do
-        create_decode_output([
-          DecodeEntry.new(dst, 'True', src_md5, src_md5, ps_tmpfile, nil)
-        ])
-      end
-
-      before do
-        allow(service).to receive(:run_cmd)
-          .and_return(cmd_output)
-
-        allow(service).to receive(:run_powershell_script)
-          .with(/^Check-Files .+ \| ConvertTo-Csv/)
-          .and_return(check_output)
-
-        allow(service).to receive(:run_powershell_script)
-          .with(/^Decode-Files .+ \| ConvertTo-Csv/)
-          .and_return(decode_output)
-      end
-
-      common_specs_for_all_single_file_types
-
-      common_specs_for_all_single_dirty_file_types
-
-      it 'returns a report hash' do
-        expect(upload[1]).to eq(
-          src_md5 => {
-            'src'         => local,
-            'dst'         => dst,
-            'tmpfile'     => ps_tmpfile,
-            'tmpzip'      => nil,
-            'src_md5'     => src_md5,
-            'dst_md5'     => src_md5,
-            'chk_exists'  => 'True',
-            'chk_dirty'   => 'True',
-            'verifies'    => 'True',
-            'size'        => size,
-            'xfered'      => size / 3 * 4,
-            'chunks'      => (size / 6000.to_f).ceil
-          }
-        )
-      end
-    end
-
-    describe 'for an up to date (clean) file' do
-      let(:check_output) do
-        create_check_output([
-          CheckEntry.new('True', src_md5, src_md5, 'False', 'True')
-        ])
-      end
-
-      let(:cmd_output) do
-        o = ::WinRM::Output.new
-        o[:exitcode] = 0
-        o
-      end
-
-      before do
-        allow(service).to receive(:run_cmd)
-          .and_return(cmd_output)
-
-        allow(service).to receive(:run_powershell_script)
-          .with(/^Check-Files .+ \| ConvertTo-Csv/)
-          .and_return(check_output)
-      end
-
-      common_specs_for_all_single_file_types
-
-      it 'uploads nothing' do
-        expect(service).not_to receive(:run_cmd).with(/#{remote}/)
-
-        upload
-      end
-
-      it 'skips the decode_files powershell script' do
-        expect(service).not_to receive(:run_powershell_script).with(regexify(
-            'Decode-Files $files | ConvertTo-Csv -NoTypeInformation')
-        )
-
-        upload
-      end
-
-      it 'returns a report hash' do
-        expect(upload[1]).to eq(
-          src_md5 => {
-            'src'         => local,
-            'dst'         => remote,
-            'size'        => size,
-            'src_md5'     => src_md5,
-            'dst_md5'     => src_md5,
-            'chk_exists'  => 'True',
-            'chk_dirty'   => 'False',
-            'verifies'    => 'True'
-          }
-        )
-      end
-    end
-  end
-
-  describe 'when uploading a single directory' do
-    let(:content)     { "I'm a fake zip file" }
-    let(:local)       { Dir.mktmpdir('input') }
-    let(:remote)      { 'C:\\dest' }
-    let(:src_zip)     { create_tempfile('fake.zip', content) }
-    let(:dst)         { remote }
-    let(:src_md5)     { md5sum(src_zip) }
-    let(:size)        { File.size(src_zip) }
-    let(:cmd_tmpfile) { "%TEMP%\\b64-#{src_md5}.txt" }
-    let(:ps_tmpfile)  { "$env:TEMP\\b64-#{src_md5}.txt" }
-    let(:ps_tmpzip)   { "$env:TEMP\\winrm-upload\\tmpzip-#{src_md5}.zip" }
-
-    let(:tmp_zip) { double('tmp_zip') }
-
-    let(:cmd_output) do
-      o = ::WinRM::Output.new
-      o[:exitcode] = 0
-      o
-    end
-
-    let(:check_output) do
-      create_check_output([
-        CheckEntry.new('False', src_md5, nil, 'True', 'False')
-      ])
-    end
-
-    let(:decode_output) do
-      create_decode_output([
-        DecodeEntry.new(dst, 'True', src_md5, src_md5, ps_tmpfile, ps_tmpzip)
-      ])
-    end
-
-    before do
-      allow(tmp_zip).to receive(:path).and_return(Pathname(src_zip))
-      allow(tmp_zip).to receive(:unlink)
-      allow(WinRM::FS::Core::TmpZip).to receive(:new).with("#{local}/", logger)
-        .and_return(tmp_zip)
-
-      allow(service).to receive(:run_cmd)
-        .and_return(cmd_output)
-
-      allow(service).to receive(:run_powershell_script)
-        .with(/^Check-Files .+ \| ConvertTo-Csv/)
-        .and_return(check_output)
-
-      allow(service).to receive(:run_powershell_script)
-        .with(/^Decode-Files .+ \| ConvertTo-Csv/)
-        .and_return(decode_output)
-    end
-
-    after do
-      FileUtils.rm_rf(local)
-    end
-
-    let(:upload) { transporter.upload("#{local}/", remote) }
-
-    it 'truncates a zero-byte hash_file for check_files' do
-      expect(service).to receive(:run_cmd).with(regexify(%(echo|set /p=>"%TEMP%\\hash-alpha.txt"))
-      ).and_return(cmd_output)
-
-      upload
-    end
-
-    it 'uploads the hash_file in chunks for check_files' do
-      hash = outdent!(<<-HASH.chomp)
-        @{
-          "#{src_md5}" = @{
-            "target" = "#{ps_tmpzip}";
-            "src_basename" = "#{File.basename(local)}";
-            "dst" = "#{dst}\\#{File.basename(local)}"
-          }
-        }
-      HASH
-
-      expect(service).to receive(:run_cmd)
-        .with(%(echo #{base64(hash)} >> "%TEMP%\\hash-alpha.txt"))
-        .and_return(cmd_output).once
-
-      upload
-    end
-
-    it 'sets hash_file and runs the check_files powershell script' do
-      expect(service).to receive(:run_powershell_script).with(
-        regexify(%($hash_file = "$env:TEMP\\hash-alpha.txt")) &&
-          regexify(
-            'Check-Files (Invoke-Input $hash_file) | ' \
-            'ConvertTo-Csv -NoTypeInformation')
-      ).and_return(check_output)
-
-      upload
-    end
-
-    it 'truncates a zero-byte tempfile' do
-      expect(service).to receive(:run_cmd).with(regexify(%(echo|set /p=>"#{cmd_tmpfile}"))
-      ).and_return(cmd_output)
-
-      upload
-    end
-
-    it 'uploads the zip file in base64 encoding' do
-      expect(service).to receive(:run_cmd)
-        .with(%(echo #{base64(content)} >> "#{cmd_tmpfile}"))
-        .and_return(cmd_output)
-
-      upload
-    end
-
-    it 'truncates a zero-byte hash_file for decode_files' do
-      expect(service).to receive(:run_cmd).with(regexify(%(echo|set /p=>"%TEMP%\\hash-beta.txt"))
-      ).and_return(cmd_output)
-
-      upload
-    end
-
-    it 'uploads the hash_file in chunks for decode_files' do
-      hash = outdent!(<<-HASH.chomp)
-        @{
-          "#{ps_tmpfile}" = @{
-            "dst" = "#{dst}\\#{File.basename(local)}";
-            "tmpzip" = "#{ps_tmpzip}"
-          }
-        }
-      HASH
-
-      expect(service).to receive(:run_cmd)
-        .with(%(echo #{base64(hash)} >> "%TEMP%\\hash-beta.txt"))
-        .and_return(cmd_output).once
-
-      upload
-    end
-
-    it 'sets hash_file and runs the decode_files powershell script' do
-      expect(service).to receive(:run_powershell_script).with(
-        regexify(%($hash_file = "$env:TEMP\\hash-beta.txt")) &&
-          regexify(
-            'Decode-Files (Invoke-Input $hash_file) | ' \
-            'ConvertTo-Csv -NoTypeInformation')
-      ).and_return(check_output)
-
-      upload
-    end
-
-    it 'returns a report hash' do
-      expect(upload[1]).to eq(
-        src_md5 => {
-          'src'         => "#{local}/",
-          'src_zip'     => src_zip,
-          'dst'         => dst,
-          'tmpfile'     => ps_tmpfile,
-          'tmpzip'      => ps_tmpzip,
-          'src_md5'     => src_md5,
-          'dst_md5'     => src_md5,
-          'chk_exists'  => 'False',
-          'chk_dirty'   => 'True',
-          'verifies'    => 'True',
-          'size'        => size,
-          'xfered'      => size / 3 * 4,
-          'chunks'      => (size / 6000.to_f).ceil
-        }
-      )
-    end
-
-    it 'cleans up the zip file' do
-      expect(tmp_zip).to receive(:unlink)
-
-      upload
-    end
-
-    describe 'when a failed check command is returned' do
-      def check_output
-        o = ::WinRM::Output.new
-        o[:exitcode] = 10
-        o[:data].concat([{ stderr: 'Oh noes\n' }])
-        o
-      end
-
-      it 'raises a FileTransporterFailed error' do
-        expect { upload }.to raise_error(
-          WinRM::FS::Core::FileTransporterFailed, /Upload failed \(exitcode: 10\)/)
-      end
-    end
-
-    describe 'when a failed decode command is returned' do
-      def decode_output
-        o = ::WinRM::Output.new
-        o[:exitcode] = 10
-        o[:data].concat([{ stderr: 'Oh noes\n' }])
-        o
-      end
-
-      it 'raises a FileTransporterFailed error' do
-        expect { upload }.to raise_error(
-          WinRM::FS::Core::FileTransporterFailed, /Upload failed \(exitcode: 10\)/)
-      end
-    end
-  end
-
-  describe 'when uploading multiple files' do
-    let(:remote) { 'C:\\Program Files' }
-
-    1.upto(3).each do |i|
-      let(:"local#{i}") { create_tempfile("input#{i}.txt", "input#{i}") }
-      let(:"src#{i}_md5") { md5sum(send("local#{i}")) }
-      let(:"dst#{i}") { "#{remote}" }
-      let(:"size#{i}") { File.size(send("local#{i}")) }
-      let(:"cmd#{i}_tmpfile") { "%TEMP%\\b64-#{send("src#{i}_md5")}.txt" }
-      let(:"ps#{i}_tmpfile") { "$env:TEMP\\b64-#{send("src#{i}_md5")}.txt" }
-    end
-
-    let(:check_output) do
-      create_check_output([
-        # new
-        CheckEntry.new('False', src1_md5, nil, 'True', 'False'),
-        # out-of-date
-        CheckEntry.new('True', src2_md5, 'aabbcc', 'True', 'False'),
-        # current
-        CheckEntry.new('True', src3_md5, src3_md5, 'False', 'True')
-      ])
-    end
-
-    let(:cmd_output) do
-      o = ::WinRM::Output.new
-      o[:exitcode] = 0
-      o
-    end
-
-    let(:decode_output) do
-      create_decode_output([
-        DecodeEntry.new(dst1, 'True', src1_md5, src1_md5, ps1_tmpfile, nil),
-        DecodeEntry.new(dst2, 'True', src2_md5, src2_md5, ps2_tmpfile, nil)
-      ])
-    end
-
-    let(:upload) { transporter.upload([local1, local2, local3], remote) }
-
-    before do
-      allow(service).to receive(:run_cmd)
-        .and_return(cmd_output)
-
-      allow(service).to receive(:run_powershell_script)
-        .with(/^Check-Files .+ \| ConvertTo-Csv/)
-        .and_return(check_output)
-
-      allow(service).to receive(:run_powershell_script)
-        .with(/^Decode-Files .+ \| ConvertTo-Csv/)
-        .and_return(decode_output)
-    end
-
-    it 'truncates a zero-byte hash_file for check_files' do
-      expect(service).to receive(:run_cmd).with(regexify(%(echo|set /p=>"%TEMP%\\hash-alpha.txt"))
-      ).and_return(cmd_output)
-
-      upload
-    end
-
-    it 'uploads the hash_file in chunks for check_files' do
-      hash = outdent!(<<-HASH.chomp)
-        @{
-          "#{src1_md5}" = @{
-            "target" = "#{dst1}";
-            "src_basename" = "#{File.basename(local1)}";
-            "dst" = "#{dst1}"
-          };
-          "#{src2_md5}" = @{
-            "target" = "#{dst2}";
-            "src_basename" = "#{File.basename(local2)}";
-            "dst" = "#{dst2}"
-          };
-          "#{src3_md5}" = @{
-            "target" = "#{dst3}";
-            "src_basename" = "#{File.basename(local3)}";
-            "dst" = "#{dst3}"
-          }
-        }
-      HASH
-
-      expect(service).to receive(:run_cmd)
-        .with(%(echo #{base64(hash)} >> "%TEMP%\\hash-alpha.txt"))
-        .and_return(cmd_output).once
-
-      upload
-    end
-
-    it 'sets hash_file and runs the check_files powershell script' do
-      expect(service).to receive(:run_powershell_script).with(
-        regexify(%($hash_file = "$env:TEMP\\hash-alpha.txt")) &&
-          regexify(
-            'Check-Files (Invoke-Input $hash_file) | ' \
-            'ConvertTo-Csv -NoTypeInformation')
-      ).and_return(check_output)
-
-      upload
-    end
-
-    it 'only uploads dirty files' do
-      expect(service).to receive(:run_cmd)
-        .with(%(echo #{base64(IO.read(local1))} >> "#{cmd1_tmpfile}"))
-      expect(service).to receive(:run_cmd)
-        .with(%(echo #{base64(IO.read(local2))} >> "#{cmd2_tmpfile}"))
-      expect(service).not_to receive(:run_cmd)
-        .with(%(echo #{base64(IO.read(local3))} >> "#{cmd3_tmpfile}"))
-
-      upload
-    end
-
-    it 'truncates a zero-byte hash_file for decode_files' do
-      expect(service).to receive(:run_cmd).with(regexify(%(echo|set /p=>"%TEMP%\\hash-beta.txt"))
-      ).and_return(cmd_output)
-
-      upload
-    end
-
-    it 'uploads the hash_file in chunks for decode_files' do
-      hash = outdent!(<<-HASH.chomp)
-        @{
-          "#{ps1_tmpfile}" = @{
-            "dst" = "#{dst1}"
-          };
-          "#{ps2_tmpfile}" = @{
-            "dst" = "#{dst2}"
-          }
-        }
-      HASH
-
-      expect(service).to receive(:run_cmd)
-        .with(%(echo #{base64(hash)} >> "%TEMP%\\hash-beta.txt"))
-        .and_return(cmd_output).once
-
-      upload
-    end
-
-    it 'sets hash_file and runs the decode_files powershell script' do
-      expect(service).to receive(:run_powershell_script).with(
-        regexify(%($hash_file = '$env:TEMP\\hash-beta.txt')) &&
-          regexify(
-            'Decode-Files (Invoke-Input $hash_file) | ' \
-            'ConvertTo-Csv -NoTypeInformation')
-      ).and_return(check_output)
-
-      upload
-    end
-
-    it 'returns a report hash' do
-      report = upload[1]
-
-      expect(report.fetch(src1_md5)).to eq(
-        'src'         => local1,
-        'dst'         => dst1,
-        'tmpfile'     => ps1_tmpfile,
-        'tmpzip'      => nil,
-        'src_md5'     => src1_md5,
-        'dst_md5'     => src1_md5,
-        'chk_exists'  => 'False',
-        'chk_dirty'   => 'True',
-        'verifies'    => 'True',
-        'size'        => size1,
-        'xfered'      => size1 / 3 * 4,
-        'chunks'      => (size1 / 6000.to_f).ceil
-      )
-      expect(report.fetch(src2_md5)).to eq(
-        'src'         => local2,
-        'dst'         => dst2,
-        'tmpfile'     => ps2_tmpfile,
-        'tmpzip'      => nil,
-        'src_md5'     => src2_md5,
-        'dst_md5'     => src2_md5,
-        'chk_exists'  => 'True',
-        'chk_dirty'   => 'True',
-        'verifies'    => 'True',
-        'size'        => size2,
-        'xfered'      => size2 / 3 * 4,
-        'chunks'      => (size2 / 6000.to_f).ceil
-      )
-      expect(report.fetch(src3_md5)).to eq(
-        'src'         => local3,
-        'dst'         => dst3,
-        'src_md5'     => src3_md5,
-        'dst_md5'     => src3_md5,
-        'chk_exists'  => 'True',
-        'chk_dirty'   => 'False',
-        'verifies'    => 'True',
-        'size'        => size3
-      )
-    end
-
-    describe 'when a failed check command is returned' do
-      def check_output
-        o = ::WinRM::Output.new
-        o[:exitcode] = 10
-        o[:data].concat([{ stderr: "Oh noes\n" }])
-        o
-      end
-
-      it 'raises a FileTransporterFailed error' do
-        expect { upload }.to raise_error(
-          WinRM::FS::Core::FileTransporterFailed, /Upload failed \(exitcode: 10\)/)
-      end
-    end
-
-    describe 'when a failed decode command is returned' do
-      def decode_output
-        o = ::WinRM::Output.new
-        o[:exitcode] = 10
-        o[:data].concat([{ stderr: "Oh noes\n" }])
-        o
-      end
-
-      it 'raises a FileTransporterFailed error' do
-        expect { upload }.to raise_error(
-          WinRM::FS::Core::FileTransporterFailed, /Upload failed \(exitcode: 10\)/)
-      end
-    end
-  end
-
-  it 'raises an exception when local file or directory is not found' do
-    expect { transporter.upload('/a/b/c/nope', 'C:\\nopeland') }.to raise_error Errno::ENOENT
-  end
-
-  def base64(string)
-    Base64.strict_encode64(string)
-  end
-
-  def create_check_output(entries)
-    csv = CSV.generate(force_quotes: true) do |rows|
-      rows << CheckEntry.new.members.map(&:to_s)
-      entries.each { |entry| rows << entry.to_a }
-    end
-
-    o = ::WinRM::Output.new
-    o[:exitcode] = 0
-    o[:data].concat(csv.lines.map { |line| { stdout: line } })
-    o
-  end
-
-  def create_decode_output(entries)
-    csv = CSV.generate(force_quotes: true) do |rows|
-      rows << DecodeEntry.new.members.map(&:to_s)
-      entries.each { |entry| rows << entry.to_a }
-    end
-
-    o = ::WinRM::Output.new
-    o[:exitcode] = 0
-    o[:data].concat(csv.lines.map { |line| { stdout: line } })
-    o
-  end
-
-  def create_tempfile(name, content)
-    pre, _, ext = name.rpartition('.')
-    file = Tempfile.open(["#{pre}-", ".#{ext}"])
-    @tempfiles << file
-    file.write(content)
-    file.close
-    file.path
-  end
-
-  def md5sum(local)
-    Digest::MD5.file(local).hexdigest
-  end
-
-  def outdent!(string)
-    string.gsub!(/^ {#{string.index(/[^ ]/)}}/, '')
-  end
-
-  def regexify(str, line = :whole_line)
-    r = Regexp.escape(str)
-    r = "^#{r}$" if line == :whole_line
-    Regexp.new(r)
-  end
-end