vagrant-windows 1.6.0 → 1.7.0.pre.2

data/lib/vagrant-windows/communication/winrmshell.rb

@@ -53,42 +53,23 @@ module VagrantWindows
         execute_shell(command, :cmd, &block)
       end
       
-      def wql(query)
-        execute_wql(query)
+      def wql(query, &block)
+        execute_shell(query, :wql, &block)
       end
-      
+
       def upload(from, to)
-        @logger.debug("Uploading: #{from} to #{to}")
-        file_name = (cmd("echo %TEMP%\\winrm-upload-#{rand()}"))[:data][0][:stdout].chomp
-        powershell <<-EOH
-          if(Test-Path #{to}) {
-            rm #{to}
-          }
-        EOH
-        Base64.encode64(IO.binread(from)).gsub("\n",'').chars.to_a.each_slice(8000-file_name.size) do |chunk|
-          out = cmd("echo #{chunk.join} >> \"#{file_name}\"")
-        end
-        powershell <<-EOH
-          mkdir $([System.IO.Path]::GetDirectoryName(\"#{to}\"))
-          $base64_string = Get-Content \"#{file_name}\"
-          $bytes  = [System.Convert]::FromBase64String($base64_string) 
-          $new_file = [System.IO.Path]::GetFullPath(\"#{to}\")
-          [System.IO.File]::WriteAllBytes($new_file,$bytes)
-        EOH
+        WinRMFileManager.new(self).upload(from, to)
       end
 
       def download(from, to)
-        @logger.debug("Downloading: #{from} to #{to}")
-        output = powershell("[System.convert]::ToBase64String([System.IO.File]::ReadAllBytes(\"#{from}\"))")
-        contents = output[:data].map!{|line| line[:stdout]}.join.gsub("\\n\\r", '')
-        out = Base64.decode64(contents)
-        IO.binwrite(to, out)
+        WinRMFileManager.new(self).download(from, to)
       end
 
+
       protected
       
       def execute_shell(command, shell=:powershell, &block)
-        raise Errors::WinRMInvalidShell, :shell => shell unless shell == :cmd || shell == :powershell
+        raise Errors::WinRMInvalidShell, :shell => shell unless [:powershell, :cmd, :wql].include?(shell)
         begin
           execute_shell_with_retry(command, shell, &block)
         rescue => e
@@ -103,20 +84,9 @@ module VagrantWindows
             block.call(:stdout, out) if block_given? && out
             block.call(:stderr, err) if block_given? && err
           end
-          @logger.debug("Exit status: #{output[:exitcode].inspect}")
-          return output
-        end
-      end
-      
-      def execute_wql(query)
-        retryable(:tries => @max_tries, :on => @@exceptions_to_retry_on, :sleep => 10) do
-          @logger.debug("#executing wql: #{query}")
-          output = session.wql(query)
-          @logger.debug("wql result: #{output.inspect}")
+          @logger.debug("Output: #{output.inspect}")
           return output
         end
-      rescue => e
-        raise_winrm_exception(e, :wql, query)
       end
       
       def raise_winrm_exception(winrm_exception, shell, command)

data/lib/vagrant-windows/config/windows.rb

@@ -17,16 +17,16 @@ module VagrantWindows
       def validate(machine)
         errors = []
 
-        errors << "windows.halt_timeout cannot be nil."        if machine.config.windows.halt_timeout.nil?
-        errors << "windows.halt_check_interval cannot be nil." if machine.config.windows.halt_check_interval.nil?
+        errors << "windows.halt_timeout cannot be nil." if @halt_timeout.nil?
+        errors << "windows.halt_check_interval cannot be nil." if @halt_check_interval.nil?
+        errors << "windows.set_work_network cannot be nil." if @set_work_network.nil?
 
-        errors << "windows.set_work_network cannot be nil." if machine.config.windows.set_work_network.nil?
         { "Windows Guest" => errors }
       end
 
       def finalize!
-        @halt_timeout = 30       if @halt_timeout == UNSET_VALUE
-        @halt_check_interval = 1 if @halt_check_interval == UNSET_VALUE
+        @halt_timeout = 30        if @halt_timeout == UNSET_VALUE
+        @halt_check_interval = 1  if @halt_check_interval == UNSET_VALUE
         @set_work_network = false if @set_work_network == UNSET_VALUE
       end
 

data/lib/vagrant-windows/errors.rb

@@ -21,7 +21,11 @@ module VagrantWindows
     
     class WinRMAuthorizationError < VagrantWindowsError
       error_key(:winrm_auth_error)
-    end    
+    end
+
+    class WinRMFileTransferError < VagrantWindowsError
+      error_key(:winrm_file_transfer_error)
+    end
 
   end
 end

data/lib/vagrant-windows/guest/cap/configure_networks.rb

@@ -16,7 +16,7 @@ module VagrantWindows
           @@logger.debug("networks: #{networks.inspect}")
           
           windows_machine = VagrantWindows::WindowsMachine.new(machine)
-          guest_network = VagrantWindows::Communication::GuestNetwork.new(windows_machine.winrmshell)
+          guest_network = VagrantWindows::Communication::GuestNetwork.new(machine.communicate)
           if windows_machine.is_vmware?()
             @@logger.warn('Configuring secondary network adapters through VMware is not yet supported.')
             @@logger.warn('You will need to manually configure the network adapter.')

data/lib/vagrant-windows/monkey_patches/plugins/provisioners/chef/provisioner/chef_client.rb

@@ -34,11 +34,8 @@ module VagrantPlugins
           end
 
           #################### START - monkey patched code ####################
-          command_builder = ::VagrantWindows::Provisioners::ChefCommandBuilder.new(
-            @windows_machine, @config, :client)
-          
-          command_builder.prepare_for_chef_run()
-          command = command_builder.run_chef_command()
+          command = ::VagrantWindows::Provisioners::ChefCommandBuilder.new(
+            @windows_machine, @config, :client).run_chef_command()
           ###################### END - monkey patched code ####################
 
           @config.attempts.times do |attempt|

data/lib/vagrant-windows/monkey_patches/plugins/provisioners/chef/provisioner/chef_solo.rb

@@ -32,11 +32,8 @@ module VagrantPlugins
         def run_chef_solo_on_windows
           
           #################### START - monkey patched code ####################
-          command_builder = ::VagrantWindows::Provisioners::ChefCommandBuilder.new(
-            @windows_machine, @config, :solo)
-          
-          command_builder.prepare_for_chef_run()
-          command = command_builder.run_chef_command()
+          command = ::VagrantWindows::Provisioners::ChefCommandBuilder.new(
+            @windows_machine, @config, :solo).run_chef_command()
           ###################### END - monkey patched code ####################
 
           @config.attempts.times do |attempt|

data/lib/vagrant-windows/monkey_patches/plugins/provisioners/shell/provisioner.rb

@@ -34,12 +34,19 @@ module VagrantPlugins
               end
               comm.upload(path.to_s, fixed_upload_path)
 
-              command = <<-EOH
-              $old = Get-ExecutionPolicy;
-              Set-ExecutionPolicy Unrestricted -force;
-              #{win_friendly_path(fixed_upload_path)}#{args};
-              Set-ExecutionPolicy $old -force
-              EOH
+              # if powershell script we need to bypass the execution policy
+              command = "#{win_friendly_path(fixed_upload_path)}#{args}"
+              command = "powershell -executionpolicy bypass -file #{command}" if
+                File.extname(fixed_upload_path).downcase == '.ps1'
+
+              # for priviliged scripts we need wrap it in a scheduled task
+              if config.privileged
+                command = VagrantWindows.load_script_template('elevated_shell.ps1', :options => {
+                  :command => command,
+                  :username => windows_machine.winrm_config.username,
+                  :password => windows_machine.winrm_config.password
+                })
+              end
               
               # Execute it with sudo
               comm.sudo(command) do |type, data|

data/lib/vagrant-windows/provisioners/chef_command_builder.rb

@@ -22,58 +22,16 @@ module VagrantWindows
         @client_type = client_type
       end
 
-      def prepare_for_chef_run()
-        options = create_chef_options()
-
-        # create cheftaskrun.ps1 that the scheduled task will invoke when run
-        render_file_and_upload('cheftaskrun.ps1', options[:chef_task_run_ps1],
-          :options => options)
-
-        # create cheftask.xml that the scheduled task will be created with
-        render_file_and_upload('cheftask.xml', options[:chef_task_xml],
-          :options => options)
-
-        # create cheftask.ps1 that will immediately invoke the scheduled task and wait for completion
-        render_file_and_upload('cheftask.ps1', options[:chef_task_ps1],
-          :options => options)
-      end
-
       def run_chef_command()
-        return <<-EOH
-        $old = Get-ExecutionPolicy;
-        Set-ExecutionPolicy Unrestricted -force;
-        #{chef_task_ps1_path};
-        Set-ExecutionPolicy $old -force
-        EOH
-      end
-
-
-
-      def render_file_and_upload(script_name, dest_file, options)
-        # render the script file to a local temp file and then upload
-        script_local = Tempfile.new(script_name)
-        IO.write(script_local, VagrantWindows.load_script_template(script_name, options))
-        @windows_machine.winrmshell.upload(script_local, dest_file)
-      end
-      
-      def create_chef_options
-        command_env = @config.binary_env ? "#{@config.binary_env} " : ''
-        return {
-          :user => @windows_machine.winrm_config.username,
-          :pass => @windows_machine.winrm_config.password,
-          :chef_arguments => create_chef_arguments(),
-          :chef_task_xml => provisioning_path('cheftask.xml'),
-          :chef_task_running => provisioning_path('cheftask.running'),
-          :chef_task_exitcode => provisioning_path('cheftask.exitcode'),
-          :chef_task_ps1 => chef_task_ps1_path(),
-          :chef_task_run_ps1 => provisioning_path('cheftaskrun.ps1'),
-          :chef_stdout_log => provisioning_path("chef-#{@client_type}.log"),
-          :chef_stderr_log => provisioning_path("chef-#{@client_type}.err.log"),
-          :chef_binary_path => win_friendly_path("#{command_env}#{chef_binary_path}")
+        options = {
+          :command => "#{chef_binary_path} #{chef_arguments}",
+          :username => @windows_machine.winrm_config.username,
+          :password => @windows_machine.winrm_config.password
         }
+        return VagrantWindows.load_script_template('elevated_shell.ps1', :options => options)
       end
 
-      def create_chef_arguments()
+      def chef_arguments()
         command_args = @config.arguments ? @config.arguments : ''
         chef_path = provisioning_path("#{@client_type}.rb")
         chef_dna_path = provisioning_path('dna.json')
@@ -84,10 +42,6 @@ module VagrantWindows
         chef_arguments.strip
       end
 
-      def chef_task_ps1_path()
-        provisioning_path('cheftask.ps1')
-      end
-
       # Returns the path to the Chef binary, taking into account the
       # `binary_path` configuration option.
       def chef_binary_path()
@@ -102,4 +56,4 @@ module VagrantWindows
 
     end
   end
-end
+end

data/lib/vagrant-windows/scripts/elevated_shell.ps1.erb

@@ -0,0 +1,95 @@
+$command = "<%= options[:command] %>"
+$user = "<%= options[:username] %>"
+$password = "<%= options[:password] %>"
+
+$task_name = "WinRM_Elevated_Shell"
+$out_file = "$env:SystemRoot\Temp\WinRM_Elevated_Shell.log"
+
+if (Test-Path $out_file) {
+  del $out_file
+}
+
+$task_xml = @'
+<?xml version="1.0" encoding="UTF-16"?>
+<Task version="1.2" xmlns="http://schemas.microsoft.com/windows/2004/02/mit/task">
+  <Principals>
+    <Principal id="Author">
+      <UserId>{user}</UserId>
+      <LogonType>Password</LogonType>
+      <RunLevel>HighestAvailable</RunLevel>
+    </Principal>
+  </Principals>
+  <Settings>
+    <MultipleInstancesPolicy>IgnoreNew</MultipleInstancesPolicy>
+    <DisallowStartIfOnBatteries>false</DisallowStartIfOnBatteries>
+    <StopIfGoingOnBatteries>false</StopIfGoingOnBatteries>
+    <AllowHardTerminate>true</AllowHardTerminate>
+    <StartWhenAvailable>false</StartWhenAvailable>
+    <RunOnlyIfNetworkAvailable>false</RunOnlyIfNetworkAvailable>
+    <IdleSettings>
+      <StopOnIdleEnd>true</StopOnIdleEnd>
+      <RestartOnIdle>false</RestartOnIdle>
+    </IdleSettings>
+    <AllowStartOnDemand>true</AllowStartOnDemand>
+    <Enabled>true</Enabled>
+    <Hidden>false</Hidden>
+    <RunOnlyIfIdle>false</RunOnlyIfIdle>
+    <WakeToRun>false</WakeToRun>
+    <ExecutionTimeLimit>PT2H</ExecutionTimeLimit>
+    <Priority>4</Priority>
+  </Settings>
+  <Actions Context="Author">
+    <Exec>
+      <Command>cmd</Command>
+      <Arguments>{arguments}</Arguments>
+    </Exec>
+  </Actions>
+</Task>
+'@
+
+$bytes = [System.Text.Encoding]::Unicode.GetBytes($command)
+$encoded_command = [Convert]::ToBase64String($bytes)
+$arguments = "/c powershell.exe -EncodedCommand $encoded_command &gt; $out_file 2&gt;&amp;1"
+
+$task_xml = $task_xml.Replace("{arguments}", $arguments)
+$task_xml = $task_xml.Replace("{user}", $user)
+
+$schedule = New-Object -ComObject "Schedule.Service"
+$schedule.Connect()
+$task = $schedule.NewTask($null)
+$task.XmlText = $task_xml
+$folder = $schedule.GetFolder("\")
+$folder.RegisterTaskDefinition($task_name, $task, 6, $user, $password, 1, $null) | Out-Null
+
+$registered_task = $folder.GetTask("\$task_name")
+$registered_task.Run($null) | Out-Null
+
+$timeout = 10
+$sec = 0
+while ( (!($registered_task.state -eq 4)) -and ($sec -lt $timeout) ) {
+  Start-Sleep -s 1
+  $sec++
+}
+
+# Read the entire file, but only write out new lines we haven't seen before
+$numLinesRead = 0
+do {
+  Start-Sleep -m 100
+  
+  if (Test-Path $out_file) {
+    $text = (get-content $out_file)
+    $numLines = ($text | Measure-Object -line).lines    
+    $numLinesToRead = $numLines - $numLinesRead
+    
+    if ($numLinesToRead -gt 0) {
+      $text | select -first $numLinesToRead -skip $numLinesRead | ForEach {
+        Write-Host "$_"
+      }
+      $numLinesRead += $numLinesToRead
+    }
+  }
+} while (!($registered_task.state -eq 3))
+
+$exit_code = $registered_task.LastTaskResult
+[System.Runtime.Interopservices.Marshal]::ReleaseComObject($schedule) | Out-Null
+exit $exit_code

data/lib/vagrant-windows/version.rb

@@ -1,3 +1,3 @@
 module VagrantWindows
-  VERSION = "1.6.0"
+  VERSION = "1.7.0.pre.2"
 end

data/locales/en.yml

@@ -24,3 +24,10 @@ en:
         Password: %{password}
         Endpoint: %{endpoint}
         Message: %{message}
+
+      winrm_file_transfer_error: |-
+        Failed to transfer a file between the host and guest
+
+        From: %{from}
+        To: %{to}
+        Message: %{message}

data/spec/vagrant-windows/chef_command_builder_spec.rb

@@ -32,70 +32,24 @@ describe VagrantWindows::Provisioners::ChefCommandBuilder, :unit => true do
     end
   end
 
-  describe 'create_chef_arguments' do
+  describe 'chef_arguments' do
     it 'should include paths to client.rb and dna.json' do
       expected = '-c c:\tmp\vagrant-chef-1\client.rb -j c:\tmp\vagrant-chef-1\dna.json'
-      @chef_cmd_builder.create_chef_arguments().should eql expected
+      @chef_cmd_builder.chef_arguments().should eql expected
     end
 
     it 'should include Chef arguments if specified' do
       @chef_config.stubs(:arguments).returns('-l DEBUG')
       expected = '-c c:\tmp\vagrant-chef-1\client.rb -j c:\tmp\vagrant-chef-1\dna.json -l DEBUG'
-      @chef_cmd_builder.create_chef_arguments().should eql expected
+      @chef_cmd_builder.chef_arguments().should eql expected
     end
   end
 
-  describe 'create_chef_options' do
-    it "should include winrm username and password" do
-      options = @chef_cmd_builder.create_chef_options()
-      options[:user].should eql 'vagrant'
-      options[:pass].should eql 'secret'
+  describe 'run chef command' do
+    it "should include chef-client cmd line" do
+      expect(@chef_cmd_builder.run_chef_command()).to include(
+        'chef-client -c c:\\tmp\\vagrant-chef-1\\client.rb -j c:\\tmp\\vagrant-chef-1\\dna.json')
     end
-
-    it 'should include paths to scripts' do
-      options = @chef_cmd_builder.create_chef_options()
-      options[:chef_task_xml].should eql 'c:\tmp\vagrant-chef-1\cheftask.xml'
-      options[:chef_task_ps1].should eql 'c:\tmp\vagrant-chef-1\cheftask.ps1'
-      options[:chef_task_run_ps1].should eql 'c:\tmp\vagrant-chef-1\cheftaskrun.ps1'
-    end
-
-    it 'should include paths to process flow files' do
-      options = @chef_cmd_builder.create_chef_options()
-      options[:chef_task_running].should eql 'c:\tmp\vagrant-chef-1\cheftask.running'
-      options[:chef_task_exitcode].should eql 'c:\tmp\vagrant-chef-1\cheftask.exitcode'
-    end
-
-    it 'should include paths to logs' do
-      options = @chef_cmd_builder.create_chef_options()
-      options[:chef_stdout_log].should eql 'c:\tmp\vagrant-chef-1\chef-client.log'
-      options[:chef_stderr_log].should eql 'c:\tmp\vagrant-chef-1\chef-client.err.log'
-    end
-
-    it 'should include path to chef binary' do
-      options = @chef_cmd_builder.create_chef_options()
-      options[:chef_binary_path].should eql 'chef-client'
-    end
-
-    it 'should include full path to chef binary when binary_path is set' do
-      @chef_config.stubs(:binary_path).returns('c:/opscode/chef/bin')
-      options = @chef_cmd_builder.create_chef_options()
-      options[:chef_binary_path].should eql 'c:\opscode\chef\bin\chef-client'
-    end
-
-  end
-
-  describe 'prepare_for_chef_run' do
-    it 'should upload cheftask scripts' do
-      winrmshell = double()
-      @windows_machine.stubs(:winrmshell).returns(winrmshell)
-
-      winrmshell.should_receive(:upload).with(anything(), 'c:\tmp\vagrant-chef-1\cheftaskrun.ps1')
-      winrmshell.should_receive(:upload).with(anything(), 'c:\tmp\vagrant-chef-1\cheftask.xml')
-      winrmshell.should_receive(:upload).with(anything(), 'c:\tmp\vagrant-chef-1\cheftask.ps1')
-
-      @chef_cmd_builder.prepare_for_chef_run()
-    end
-
   end
 
 end

data/spec/vagrant-windows/guestnetwork_spec.rb

@@ -2,11 +2,16 @@ require 'spec_helper'
 
 describe VagrantWindows::Communication::GuestNetwork , :integration => true do
   
-  before(:all) do
-    # This test requires you already have a running Windows Server 2008 R2 Vagrant VM
-    # Not ideal, but you have to start somewhere
-    @shell = VagrantWindows::Communication::WinRMShell.new("127.0.0.1", "vagrant", "vagrant")
-    @guestnetwork = VagrantWindows::Communication::GuestNetwork.new(@shell)
+  before(:each) do
+    port = (ENV['WINRM_PORT'] || 5985).to_i
+
+    @machine = stub()
+    @shell = VagrantWindows::Communication::WinRMShell.new(
+      "127.0.0.1", "vagrant", "vagrant", { port: port })
+
+    @communicator = VagrantWindows::Communication::WinRMCommunicator.new(@machine)
+    @communicator.winrmshell = @shell
+    @guestnetwork = VagrantWindows::Communication::GuestNetwork.new(@communicator)
   end
   
   describe "wsman_version" do

data/spec/vagrant-windows/linux_command_filter_spec.rb

@@ -0,0 +1,73 @@
+require 'spec_helper'
+require 'vagrant-windows/communication/linux_command_filter'
+
+describe VagrantWindows::Communication::LinuxCommandFilter, :unit => true do
+
+  before(:each) do
+    @cmd_filter = VagrantWindows::Communication::LinuxCommandFilter.new()
+  end
+
+  describe 'command filters' do
+    it 'should initialize all command filters in command filters directory' do
+      expect(@cmd_filter.command_filters()).not_to be_empty
+    end
+  end
+
+  describe 'filter' do
+    it 'should filter out uname commands' do
+      expect(@cmd_filter.filter('uname -s stuff')).to eq('')
+    end
+
+    it 'should filter out which commands' do
+      expect(@cmd_filter.filter('which ruby')).to include(
+        '[Array](Get-Command ruby -errorAction SilentlyContinue)')
+    end
+
+    it 'should filter out test -d commands' do
+      expect(@cmd_filter.filter('test -d /tmp/dir')).to eq(
+        "if ((Test-Path '/tmp/dir') -and (get-item '/tmp/dir').PSIsContainer) { exit 0 } exit 1")
+    end
+
+    it 'should filter out test -f commands' do
+      expect(@cmd_filter.filter('test -f /tmp/file.txt')).to eq(
+        "if ((Test-Path '/tmp/file.txt') -and (!(get-item '/tmp/file.txt').PSIsContainer)) { exit 0 } exit 1")
+    end
+
+    it 'should filter out test -x commands' do
+      expect(@cmd_filter.filter('test -x /tmp/file.txt')).to eq(
+        "if ((Test-Path '/tmp/file.txt') -and (!(get-item '/tmp/file.txt').PSIsContainer)) { exit 0 } exit 1")
+    end
+
+    it 'should filter out other test commands' do
+      expect(@cmd_filter.filter('test -L /tmp/file.txt')).to eq(
+        "if (Test-Path '/tmp/file.txt') { exit 0 } exit 1")
+    end
+
+    it 'should filter out rm -Rf commands' do
+      expect(@cmd_filter.filter('rm -Rf /some/dir')).to eq(
+        "rm '/some/dir' -recurse -force")
+    end
+
+    it 'should filter out rm commands' do
+      expect(@cmd_filter.filter('rm /some/dir')).to eq(
+        "rm '/some/dir' -force")
+    end
+
+    it 'should filter out chown commands' do
+      expect(@cmd_filter.filter("chown -R root '/tmp/dir'")).to eq('')
+    end
+
+    it 'should filter out chmod commands' do
+      expect(@cmd_filter.filter("chmod 0600 ~/.ssh/authorized_keys")).to eq('')
+    end
+
+    it 'should filter out certain cat commands' do
+      expect(@cmd_filter.filter("cat /etc/release | grep -i OmniOS")).to eq('')
+    end
+
+    it 'should not filter out other cat commands' do
+      expect(@cmd_filter.filter("cat /tmp/somefile")).to eq('cat /tmp/somefile')
+    end
+  end
+
+end

data/spec/vagrant-windows/winrmcommunicator_spec.rb

@@ -3,10 +3,10 @@ require 'spec_helper'
 describe VagrantWindows::Communication::WinRMCommunicator, :integration => true do
   
   before(:all) do
-    # This test requires you already have a running Windows Server 2008 R2 Vagrant VM
-    # Not ideal, but you have to start somewhere
     @communicator = VagrantWindows::Communication::WinRMCommunicator.new({})
-    @communicator.winrmshell = VagrantWindows::Communication::WinRMShell.new("127.0.0.1", "vagrant", "vagrant")
+    port = (ENV['WINRM_PORT'] || 5985).to_i
+    @communicator.winrmshell = VagrantWindows::Communication::WinRMShell.new(
+      "127.0.0.1", "vagrant", "vagrant", { port: port })
   end
   
   describe "execute" do
@@ -28,20 +28,69 @@ describe VagrantWindows::Communication::WinRMCommunicator, :integration => true
     it "should upload the file and overwrite it if it exists" do
       test_file = Tempfile.new("uploadtest")
       IO.write(test_file, "hello world")
-      @communicator.upload(test_file, "c:\\vagrantuploadtest.txt")
+      @communicator.upload(test_file, "c:/tmp/winrm-test/vagrantuploadtest.txt")
       
       # ensure we can overwrite
       IO.write(test_file, "goodbye cruel world")
-      @communicator.upload(test_file, "c:\\vagrantuploadtest.txt")
+      @communicator.upload(test_file, "c:/tmp/winrm-test/vagrantuploadtest.txt")
       
       # get the uploaded file's contents to ensure it uploaded properly
       uploaded_file_content = ''
-      @communicator.execute("cat c:\\vagrantuploadtest.txt", {}) do |type, line|
+      @communicator.execute("cat c:/tmp/winrm-test/vagrantuploadtest.txt", {}) do |type, line|
         uploaded_file_content = uploaded_file_content + line
       end
       
       expect(uploaded_file_content.chomp).to eq("goodbye cruel world")
     end
+
+    it "should recursively upload directories" do
+      # create a some test data
+      host_src_dir = Dir.mktmpdir("winrm_comm")
+
+      begin
+        IO.write(File.join(host_src_dir, 'root.txt'), "root\n")
+
+        subdir2 = File.join(host_src_dir, '/subdir1/subdir2')
+        FileUtils.mkdir_p(subdir2)
+
+        IO.write(File.join(subdir2, 'leaf1.txt'), "leaf1\n")
+        IO.write(File.join(subdir2, 'leaf2.txt'), "leaf2\n")
+
+        @communicator.upload(host_src_dir, '/tmp/winrm-test-upload') #c:\tmp\winrm-test-upload
+
+        @communicator.execute <<-EOH
+          function AssertExists($p) {
+            if (!(Test-Path $p)) {
+              exit 1
+            }
+          }
+
+          AssertExists 'c:/tmp/winrm-test-upload/root.txt'
+          AssertExists 'c:/tmp/winrm-test-upload/subdir1/subdir2/leaf2.txt'
+          AssertExists 'c:/tmp/winrm-test-upload/subdir1/subdir2/leaf1.txt'
+        EOH
+      ensure
+        FileUtils.remove_entry_secure host_src_dir
+      end
+    end
+  end
+
+  describe 'test' do
+    it "should return true if directory exists" do
+      @communicator.execute('mkdir -p /tmp/winrm-test/1')
+      expect(@communicator.test('test -d /tmp/winrm-test/1')).to be_true
+    end
+
+    it "should return false if directory does not exist" do
+      expect(@communicator.test('test -d /tmp/winrm-test/doesnotexit')).to be_false
+    end
+
+    it "should differentiate between directories and files" do
+      @communicator.execute('mkdir -p /tmp/winrm-test/2')
+      @communicator.execute('Add-Content /tmp/winrm-test/2/file.txt "The content"')
+      expect(@communicator.test('test -d /tmp/winrm-test/2/file.txt')).to be_false
+      expect(@communicator.test('test -f /tmp/winrm-test/2/file.txt')).to be_true
+    end
   end
 
 end