vagrant-unbundled 2.0.0.1 → 2.0.1.0

data/vendor/bundle/ruby/2.4.0/gems/winrm-fs-1.1.1/lib/winrm-fs/scripts/scripts.rb

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

data/vendor/bundle/ruby/2.4.0/gems/winrm-fs-1.1.1/lib/winrm-fs.rb

@@ -0,0 +1,28 @@
+# encoding: UTF-8
+#
+# Copyright 2015 Shawn Neal <sneal@sneal.net>
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+require 'winrm'
+require 'logger'
+require 'pathname'
+require_relative 'winrm-fs/exceptions'
+require_relative 'winrm-fs/file_manager'
+
+module WinRM
+  # WinRM File System
+  module FS
+    # Top level module code
+  end
+end

data/vendor/bundle/ruby/2.4.0/gems/winrm-fs-1.1.1/spec/config-example.yml

@@ -0,0 +1,3 @@
+endpoint: "http://localhost:55985/wsman"
+user: vagrant
+password: vagrant

data/vendor/bundle/ruby/2.4.0/gems/winrm-fs-1.1.1/spec/integration/file_manager_spec.rb

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

data/vendor/bundle/ruby/2.4.0/gems/winrm-fs-1.1.1/spec/integration/tmp_zip_spec.rb

@@ -0,0 +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

data/vendor/bundle/ruby/2.4.0/gems/winrm-fs-1.1.1/spec/matchers.rb

@@ -0,0 +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

data/vendor/bundle/ruby/2.4.0/gems/winrm-fs-1.1.1/spec/spec_helper.rb

@@ -0,0 +1,71 @@
+# 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::Connection.new(config)
+  end
+  # rubocop:enable AbcSize
+
+  def config
+    @config ||= begin
+      cfg = symbolize_keys(YAML.load(File.read(winrm_config_path)))
+      cfg.merge!(basic_auth_only: true) unless cfg[:transport].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, '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[:transport] = ENV['winrm_transport'] if ENV['winrm_transport']
+  end
+
+  def merge_config_option_from_environment(config, key)
+    env_key = 'winrm_' + key
+    config[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