winrm-fs 0.3.2 → 0.4.0

data/spec/integration/tmp_zip_spec.rb

@@ -1,26 +1,26 @@
-# encoding: UTF-8
-require_relative '../../lib/winrm-fs/core/tmp_zip'
-
-describe WinRM::FS::Core::TmpZip do
-  let(:winrm_fs_dir) { File.expand_path('../../lib/winrm-fs', File.dirname(__FILE__)) }
-
-  subject { WinRM::FS::Core::TmpZip.new(winrm_fs_dir) }
-
-  context 'temp file creation' do
-    it 'should create a temp file on disk' do
-      path = subject.path
-      expect(File.exist?(path)).to be true
-      subject.unlink
-      expect(File.exist?(path)).to be false
-    end
-  end
-
-  context 'create zip' do
-    it 'should add all files in directory to the zip recursively' do
-      expect(subject).to contain_zip_entries([
-        'exceptions.rb',
-        'core/tmp_zip.rb',
-        'scripts/checksum.ps1.erb'])
-    end
-  end
-end
+# encoding: UTF-8
+require_relative '../../lib/winrm-fs/core/tmp_zip'
+
+describe WinRM::FS::Core::TmpZip do
+  let(:winrm_fs_dir) { File.expand_path('../../lib/winrm-fs', File.dirname(__FILE__)) }
+
+  subject { WinRM::FS::Core::TmpZip.new(winrm_fs_dir) }
+
+  context 'temp file creation' do
+    it 'should create a temp file on disk' do
+      path = subject.path
+      expect(File.exist?(path)).to be true
+      subject.unlink
+      expect(File.exist?(path)).to be false
+    end
+  end
+
+  context 'create zip' do
+    it 'should add all files in directory to the zip recursively' do
+      expect(subject).to contain_zip_entries([
+        'exceptions.rb',
+        'core/tmp_zip.rb',
+        'scripts/checksum.ps1.erb'])
+    end
+  end
+end

data/spec/matchers.rb

@@ -1,58 +1,58 @@
-# encoding: UTF-8
-require 'rspec/expectations'
-
-RSpec::Matchers.define :have_created do |remote_file|
-  match do |file_manager|
-    if @expected_content
-      downloaded_file = Tempfile.new('downloaded')
-      downloaded_file.close
-
-      subject.download(remote_file, downloaded_file.path)
-      @actual_content = File.read(downloaded_file.path)
-      downloaded_file.delete
-
-      file_manager.exists?(remote_file) && \
-        @actual_content == @expected_content
-    else
-      file_manager.exists?(remote_file)
-    end
-  end
-  chain :with_content do |expected_content|
-    expected_content = File.read(expected_content) if File.file?(expected_content)
-    @expected_content = expected_content
-  end
-  failure_message do
-    if @expected_content
-      <<-EOH
-Expected file '#{remote_file}' to exist with content:
-
-#{@expected_content}
-
-but instead got content:
-
-#{@actual_content}
-      EOH
-    else
-      "Expected file '#{remote_file}' to exist"
-    end
-  end
-end
-
-RSpec::Matchers.define :contain_zip_entries do |zip_entries|
-  match do |temp_zip_file|
-    zip_entries = [zip_entries] if zip_entries.is_a? String
-    @zip_file = Zip::File.open(temp_zip_file.path)
-    @missing_entries = []
-    zip_entries.each do |entry|
-      @missing_entries << entry unless @zip_file.find_entry(entry)
-    end
-    @missing_entries.empty?
-  end
-  failure_message do |temp_zip_file|
-    msg = "Expected #{temp_zip_file.path} to contain zip entries: #{@missing_entries}\n Got: "
-    @zip_file.each do |entry|
-      msg << entry.name << ', '
-    end
-    msg
-  end
-end
+# encoding: UTF-8
+require 'rspec/expectations'
+
+RSpec::Matchers.define :have_created do |remote_file|
+  match do |file_manager|
+    if @expected_content
+      downloaded_file = Tempfile.new('downloaded')
+      downloaded_file.close
+
+      subject.download(remote_file, downloaded_file.path)
+      @actual_content = File.read(downloaded_file.path)
+      downloaded_file.delete
+
+      file_manager.exists?(remote_file) && \
+        @actual_content == @expected_content
+    else
+      file_manager.exists?(remote_file)
+    end
+  end
+  chain :with_content do |expected_content|
+    expected_content = File.read(expected_content) if File.file?(expected_content)
+    @expected_content = expected_content
+  end
+  failure_message do
+    if @expected_content
+      <<-EOH
+Expected file '#{remote_file}' to exist with content:
+
+#{@expected_content}
+
+but instead got content:
+
+#{@actual_content}
+      EOH
+    else
+      "Expected file '#{remote_file}' to exist"
+    end
+  end
+end
+
+RSpec::Matchers.define :contain_zip_entries do |zip_entries|
+  match do |temp_zip_file|
+    zip_entries = [zip_entries] if zip_entries.is_a? String
+    @zip_file = Zip::File.open(temp_zip_file.path)
+    @missing_entries = []
+    zip_entries.each do |entry|
+      @missing_entries << entry unless @zip_file.find_entry(entry)
+    end
+    @missing_entries.empty?
+  end
+  failure_message do |temp_zip_file|
+    msg = "Expected #{temp_zip_file.path} to contain zip entries: #{@missing_entries}\n Got: "
+    @zip_file.each do |entry|
+      msg << entry.name << ', '
+    end
+    msg
+  end
+end

data/spec/spec_helper.rb

@@ -1,72 +1,72 @@
-# encoding: UTF-8
-require 'rubygems'
-require 'bundler/setup'
-require 'winrm-fs'
-require 'json'
-require_relative 'matchers'
-
-# Creates a WinRM connection for integration tests
-module ConnectionHelper
-  # rubocop:disable AbcSize
-  def winrm_connection
-    WinRM::WinRMWebService.new(
-      config[:endpoint], config[:auth_type].to_sym, config[:options])
-  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
-      merge_environment!(cfg)
-      cfg
-    end
-  end
-
-  def merge_environment!(config)
-    merge_config_option_from_environment(config, 'user')
-    merge_config_option_from_environment(config, 'pass')
-    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']
-  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]
-  end
-
-  def winrm_config_path
-    # Copy config-example.yml to config.yml and edit for your local configuration
-    path = File.expand_path("#{File.dirname(__FILE__)}/config.yml")
-    unless File.exist?(path)
-      # user hasn't done this, so use sane defaults for unit tests
-      path = File.expand_path("#{File.dirname(__FILE__)}/config-example.yml")
-    end
-    path
-  end
-
-  # rubocop:disable Metrics/MethodLength
-  def symbolize_keys(hash)
-    hash.each_with_object({}) do |(key, value), result|
-      new_key = case key
-                when String then key.to_sym
-                else key
-                end
-      new_value = case value
-                  when Hash then symbolize_keys(value)
-                  else value
-                  end
-      result[new_key] = new_value
-      result
-    end
-  end
-  # rubocop:enable Metrics/MethodLength
-end
-
-RSpec.configure do |config|
-  config.include(ConnectionHelper)
-end
+# encoding: UTF-8
+require 'rubygems'
+require 'bundler/setup'
+require 'winrm-fs'
+require 'json'
+require_relative 'matchers'
+
+# Creates a WinRM connection for integration tests
+module ConnectionHelper
+  # rubocop:disable AbcSize
+  def winrm_connection
+    WinRM::WinRMWebService.new(
+      config[:endpoint], config[:auth_type].to_sym, config[:options])
+  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
+      merge_environment!(cfg)
+      cfg
+    end
+  end
+
+  def merge_environment!(config)
+    merge_config_option_from_environment(config, 'user')
+    merge_config_option_from_environment(config, 'pass')
+    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']
+  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]
+  end
+
+  def winrm_config_path
+    # Copy config-example.yml to config.yml and edit for your local configuration
+    path = File.expand_path("#{File.dirname(__FILE__)}/config.yml")
+    unless File.exist?(path)
+      # user hasn't done this, so use sane defaults for unit tests
+      path = File.expand_path("#{File.dirname(__FILE__)}/config-example.yml")
+    end
+    path
+  end
+
+  # rubocop:disable Metrics/MethodLength
+  def symbolize_keys(hash)
+    hash.each_with_object({}) do |(key, value), result|
+      new_key = case key
+                when String then key.to_sym
+                else key
+                end
+      new_value = case value
+                  when Hash then symbolize_keys(value)
+                  else value
+                  end
+      result[new_key] = new_value
+      result
+    end
+  end
+  # rubocop:enable Metrics/MethodLength
+end
+
+RSpec.configure do |config|
+  config.include(ConnectionHelper)
+end

data/spec/unit/file_transporter_spec.rb

@@ -1,819 +1,839 @@
-# -*- 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)
-          @{
-            "#{dst}" = "#{src_md5}"
-          }
-        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" = "#{dst}"
-            }
-          }
-        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'         => dst,
-            '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)
-        @{
-          "#{ps_tmpzip}" = "#{src_md5}"
-        }
-      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}/#{File.basename(send("local#{i}"))}" }
-      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)
-        @{
-          "#{dst1}" = "#{src1_md5}";
-          "#{dst2}" = "#{src2_md5}";
-          "#{dst3}" = "#{src3_md5}"
-        }
-      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
+# -*- 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