vagrant-unbundled 2.1.2.0 → 2.1.4.0

data/vendor/bundle/ruby/2.5.0/bundler/gems/vagrant-spec-f3daedaac493/lib/vagrant-spec/acceptance/rspec/formatter.rb

@@ -0,0 +1,33 @@
+require "rspec/core/formatters/documentation_formatter"
+
+module Vagrant
+  module Spec
+    module Acceptance
+      class Formatter < RSpec::Core::Formatters::DocumentationFormatter
+        def example_failed(example)
+          super
+          @group_level -= 1
+        end
+
+        def example_passed(example)
+          super
+          @group_level -= 1
+        end
+
+        def example_pending(example)
+          super
+          @group_level -= 1
+        end
+
+        def example_started(example)
+          output.puts "#{current_indentation}#{example.description.strip}"
+          @group_level += 1
+        end
+
+        def message(message)
+          output.puts "#{current_indentation}#{message}"
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.5.0/bundler/gems/vagrant-spec-f3daedaac493/lib/vagrant-spec/acceptance/rspec/matcher_exit_with.rb

@@ -0,0 +1,12 @@
+# This verifies that the given subprocess command exits with the right code.
+RSpec::Matchers.define :exit_with do |code|
+  match do |actual|
+    actual.exit_code == code
+  end
+
+  failure_message_for_should do |actual|
+    "expected command to exit with #{code} but got exit code: #{actual.exit_code}\n\n" +
+      "stdout: #{actual.stdout}\n\n" +
+      "stderr: #{actual.stderr}"
+  end
+end

data/vendor/bundle/ruby/2.5.0/bundler/gems/vagrant-spec-f3daedaac493/lib/vagrant-spec/acceptance/rspec/matcher_match_output.rb

@@ -0,0 +1,15 @@
+require "vagrant-spec/acceptance/output"
+
+# This creates a matcher that is used to match against certain
+# Vagrant output. Vagrant output is not what is being tested,
+# so all that state is hidden away in Acceptance::Output.
+RSpec::Matchers.define :match_output do |expected, *args|
+  match do |actual|
+    Vagrant::Spec::OutputTester.matches?(actual, expected, *args)
+  end
+
+  failure_message_for_should do |actual|
+    "expected output to match: #{expected} #{args.inspect}\n\n" +
+      "output: #{actual}"
+  end
+end

data/vendor/bundle/ruby/2.5.0/bundler/gems/vagrant-spec-f3daedaac493/lib/vagrant-spec/acceptance/rspec/shared_provider_synced_folder.rb

@@ -0,0 +1,33 @@
+# This tests that synced folders work with a given provider.
+shared_examples "provider/synced_folder" do |provider, options|
+  if !options[:box_basic]
+    raise ArgumentError,
+      "box_basic option must be specified for provider: #{provider}"
+  end
+
+  include_context "acceptance"
+
+  before do
+    environment.skeleton("synced_folders")
+    assert_execute("vagrant", "box", "add", "basic", options[:box_basic])
+    assert_execute("vagrant", "up", "--provider=#{provider}")
+  end
+
+  after do
+    assert_execute("vagrant", "destroy", "--force")
+  end
+
+  # We put all of this in a single RSpec test so that we can test all
+  # the cases within a single VM rather than having to `vagrant up` many
+  # times.
+  it "properly configures synced folder types" do
+    status("Test: mounts the default /vagrant synced folder")
+    result = execute("vagrant", "ssh", "-c", "cat /vagrant/foo")
+    expect(result).to exit_with(0)
+    expect(result.stdout).to match(/hello$/)
+
+    status("Test: doesn't mount a disabled folder")
+    result = execute("vagrant", "ssh", "-c", "test -d /foo")
+    expect(result).to exit_with(1)
+  end
+end

data/vendor/bundle/ruby/2.5.0/bundler/gems/vagrant-spec-f3daedaac493/lib/vagrant-spec/acceptance/runner.rb

@@ -0,0 +1,76 @@
+require "set"
+
+require "rspec"
+
+module Vagrant
+  module Spec
+    module Acceptance
+      # The runner configures RSpec to run the given components.
+      class Runner
+        def initialize(paths: nil)
+          @components = Components.new(paths || [])
+          prepare_components!
+        end
+
+        def components
+          @components.components
+        end
+
+        def run(components, **opts)
+          components = Set.new(components || [])
+          without_components = Set.new(opts[:without_components] || [])
+
+          args = [
+            "--color",
+            "--format", "Vagrant::Spec::Acceptance::Formatter",
+          ]
+          args += ["--example", opts[:example]] if opts[:example]
+
+          # Filter out the components
+          if !components.empty? || !without_components.empty?
+            bad = []
+            RSpec.world.example_groups.each do |g|
+              next if !g.metadata.has_key?(:component)
+              if !components.empty? && components.none?{|pattern| File.fnmatch?(pattern, g.metadata[:component])}
+                bad << g
+              else
+                if without_components.any?{|pattern| File.fnmatch?(pattern, g.metadata[:component])}
+                  bad << g
+                end
+              end
+            end
+
+            bad.each do |b|
+              puts "Skipping: #{b.metadata[:component]}"
+              RSpec.world.example_groups.delete(b)
+            end
+          end
+
+          RSpec::Core::Runner.run(args)
+        end
+
+        protected
+
+        def prepare_components!
+          # Define the provider example group
+          Acceptance.config.providers.each do |name, opts|
+            @components.provider_features.each do |feature|
+              component = "provider/#{name}/#{feature}"
+
+              g = RSpec::Core::ExampleGroup.describe(
+                component, component: component)
+
+              # Include any extra contexts defined
+              (opts[:contexts] || []).each do |context|
+                g.include_context(context)
+              end
+
+              g.it_should_behave_like("provider/#{feature}", name, opts)
+            end
+          end
+        end
+
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.5.0/bundler/gems/vagrant-spec-f3daedaac493/lib/vagrant-spec/cli.rb

@@ -0,0 +1,48 @@
+require "rspec"
+require "thor"
+
+require "vagrant-spec/acceptance"
+require "vagrant-spec/acceptance/runner"
+require "vagrant-spec/components"
+
+module Vagrant
+  module Spec
+    # This is the CLI that implements the "vagrant-spec" command.
+    class CLI < Thor
+      option :config, type: :string, default: "vagrant-spec.config.rb", desc: "path to config file to load"
+      desc "components", "output the components that can be tested"
+      def components
+        load_config
+
+        runner = Acceptance::Runner.new(paths: Acceptance.config.component_paths)
+        runner.components.sort.each do |c|
+          puts c
+        end
+      end
+
+      option :components, type: :array, desc: "components to test. defaults to all"
+      option :without_components, type: :array, desc: "components to not test"
+      option :config, type: :string, default: "vagrant-spec.config.rb", desc: "path to config file to load"
+      option :example, type: :string, default: nil, desc: "specific example to run"
+      desc "test", "runs the specs"
+      def test
+        load_config
+
+        Acceptance::Runner.new(paths: Acceptance.config.component_paths).
+          run(options[:components], example: options[:example], without_components: options[:without_components])
+      end
+
+      protected
+
+      def load_config
+        load options[:config]
+      rescue LoadError => e
+        $stderr.puts "Please create a vagrant-spec.config.rb file."
+        if ENV.fetch("DEBUG", "0").to_s != "0"
+          $stderr.puts "#{e.class}: #{e}\n#{e.backtrace.join("\n")}"
+        end
+        exit 1
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.5.0/bundler/gems/vagrant-spec-f3daedaac493/lib/vagrant-spec/components.rb

@@ -0,0 +1,57 @@
+require "rspec"
+
+require "vagrant-spec"
+
+module Vagrant
+  module Spec
+    class Components
+      def initialize(paths)
+        @paths = paths
+        reload!
+      end
+
+      # Loads the components from the given paths
+      def reload!
+        # Delete the existing example groups
+        RSpec.world.example_groups.clear
+
+        @paths.each do |path|
+          Dir.glob(File.join(path, "**/*_{output,spec}.rb")).each do |single|
+            load single
+          end
+        end
+      end
+
+      # Returns the defined components that are runnable.
+      #
+      # @return [Array<String>]
+      def components
+        [].tap do |result|
+          RSpec.world.example_groups.each do |group|
+            next if !group.metadata.has_key?(:component)
+            result << group.metadata[:component]
+          end
+        end
+      end
+
+      # Returns the defined provider features.
+      def provider_features
+        [].tap do |result|
+          groups = RSpec.world.shared_example_group_registry.send(:shared_example_groups)
+          groups[:main].each do |name, _|
+            match = /^provider\/(.+?)$/.match(name)
+            result << match[1] if match
+          end
+        end
+      end
+
+      protected
+
+      # This loads the default components that are packaged with
+      # the vagrant-spec gem.
+      def self.load_default!
+        load_from!(Vagrant::Spec.source_root.join("acceptance"))
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.5.0/bundler/gems/vagrant-spec-f3daedaac493/lib/vagrant-spec/isolated_environment.rb

@@ -0,0 +1,44 @@
+require "fileutils"
+require "pathname"
+require "tmpdir"
+
+module Vagrant
+  module Spec
+    # This class manages an isolated environment for Vagrant to
+    # run in. It creates a temporary directory to act as the
+    # working directory as well as sets a custom home directory.
+    #
+    # This is a base class that is shared among unit and acceptance tests.
+    # Each type of tests adds its own methods to interact with this
+    # environment.
+    class IsolatedEnvironment
+      attr_reader :homedir
+      attr_reader :workdir
+
+      # Initializes an isolated environment. You can pass in some
+      # options here to configure runing custom applications in place
+      # of others as well as specifying environmental variables.
+      #
+      # @param [Hash] apps A mapping of application name (such as "vagrant")
+      #   to an alternate full path to the binary to run.
+      # @param [Hash] env Additional environmental variables to inject
+      #   into the execution environments.
+      def initialize
+        # Create a temporary directory for our work
+        @tempdir = Pathname.new(Dir.mktmpdir)
+
+        # Setup the home and working directories
+        @homedir = @tempdir.join("home")
+        @workdir = @tempdir.join("work")
+
+        @homedir.mkdir
+        @workdir.mkdir
+      end
+
+      # This closes the environment by cleaning it up.
+      def close
+        FileUtils.rm_rf(@tempdir)
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.5.0/bundler/gems/vagrant-spec-f3daedaac493/lib/vagrant-spec/server.rb

@@ -0,0 +1,37 @@
+require "tempfile"
+require "thread"
+require "webrick"
+
+module Vagrant
+  module Spec
+    module Server
+      # Starts a temporary web server that serves a document root.
+      # This knows how to serve proper mime types for JSON so it can
+      # be used for box metadata and such.
+      #
+      # @param [String] path The document root
+      def with_web_server(path, **opts)
+        tf = Tempfile.new("vagrant")
+        tf.close
+
+        opts[:json_type] ||= "application/json"
+
+        mime_types = WEBrick::HTTPUtils::DefaultMimeTypes
+        mime_types.store "json", opts[:json_type]
+
+        port   = opts[:port] || 3838
+        server = WEBrick::HTTPServer.new(
+          AccessLog: [],
+          Logger: WEBrick::Log.new(tf.path, 7),
+          Port: port,
+          DocumentRoot: path.dirname.to_s,
+          MimeTypes: mime_types)
+        thr = Thread.new { server.start }
+        yield port
+      ensure
+        server.shutdown rescue nil
+        thr.join rescue nil
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.5.0/bundler/gems/vagrant-spec-f3daedaac493/lib/vagrant-spec/subprocess.rb

@@ -0,0 +1,259 @@
+require 'rbconfig'
+require 'thread'
+
+require 'childprocess'
+require 'log4r'
+
+module Vagrant
+  module Spec
+    # Execute a command in a subprocess, gathering the results and
+    # exit status.
+    #
+    # This class also allows you to read the data as it is outputted
+    # from the subprocess in real time, by simply passing a block to
+    # the execute method.
+    #
+    # This class was copied directly from Vagrant, because it has a stable
+    # Subprocess library and because we can't directly depend on Vagrant
+    # because we can't depend on the library we're testing.
+    class Subprocess
+      # The chunk size for reading from subprocess IO.
+      READ_CHUNK_SIZE = 4096
+
+      # Convenience method for executing a method.
+      def self.execute(command, *args, &block)
+        new(command, *args).execute(&block)
+      end
+
+      def initialize(command, *args, **options)
+        @command = [command.dup].concat(args)
+        @options = options
+        @logger  = Log4r::Logger.new("vagrant::spec::subprocess")
+      end
+
+      def execute
+        # Get the timeout, if we have one
+        timeout = @options[:timeout]
+
+        # Get the working directory
+        workdir = @options[:workdir] || Dir.pwd
+
+        # Get what we're interested in being notified about
+        notify  = @options[:notify] || []
+        notify  = [notify] if !notify.is_a?(Array)
+        if notify.empty? && block_given?
+          # If a block is given, subscribers must be given, otherwise the
+          # block is never called. This is usually NOT what you want, so this
+          # is an error.
+          message = "A list of notify subscriptions must be given if a block is given"
+          raise ArgumentError, message
+        end
+
+        # Let's get some more useful booleans that we access a lot so
+        # we're not constantly calling an `include` check
+        notify_table = {}
+        notify_table[:stderr] = notify.include?(:stderr)
+        notify_table[:stdout] = notify.include?(:stdout)
+        notify_stdin  = notify.include?(:stdin)
+
+        # Build the ChildProcess
+        @logger.info("Starting process: #{@command.inspect}")
+        process = ChildProcess.build(*@command)
+        process.cwd = workdir
+
+        # Create the pipes so we can read the output in real time as
+        # we execute the command.
+        stdout, stdout_writer = IO.pipe
+        stderr, stderr_writer = IO.pipe
+        process.io.stdout = stdout_writer
+        process.io.stderr = stderr_writer
+        process.duplex = true
+
+        # Set the environment on the process if we must
+        if @options[:env]
+          @options[:env].each do |k, v|
+            process.environment[k] = v
+          end
+        end
+
+        # Start the process
+        process.start
+
+        # Make sure the stdin does not buffer
+        process.io.stdin.sync = true
+
+        # Create a dictionary to store all the output we see.
+        io_data = { :stdout => "", :stderr => "" }
+
+        # Record the start time for timeout purposes
+        start_time = Time.now.to_i
+
+        @logger.debug("Selecting on IO")
+        while true
+          writers = notify_stdin ? [process.io.stdin] : []
+          results = IO.select([stdout, stderr], writers, nil, timeout || 0.1)
+          results ||= []
+          readers = results[0]
+          writers = results[1]
+
+          # Check if we have exceeded our timeout
+          raise TimeoutExceeded, process.pid if timeout && (Time.now.to_i - start_time) > timeout
+
+          # Check the readers to see if they're ready
+          if readers && !readers.empty?
+            readers.each do |r|
+              # Read from the IO object
+              data = read_io(r)
+
+              # We don't need to do anything if the data is empty
+              next if data.empty?
+
+              io_name = r == stdout ? :stdout : :stderr
+              @logger.debug("#{io_name}: #{data.chomp}")
+
+              io_data[io_name] += data
+              yield io_name, data if block_given? && notify_table[io_name]
+            end
+          end
+
+          # Break out if the process exited. We have to do this before
+          # attempting to write to stdin otherwise we'll get a broken pipe
+          # error.
+          break if process.exited?
+
+          # Check the writers to see if they're ready, and notify any listeners
+          if writers && !writers.empty?
+            yield :stdin, process.io.stdin if block_given?
+          end
+        end
+
+        # Wait for the process to end.
+        begin
+          remaining = (timeout || 32000) - (Time.now.to_i - start_time)
+          remaining = 0 if remaining < 0
+          @logger.debug("Waiting for process to exit. Remaining to timeout: #{remaining}")
+
+          process.poll_for_exit(remaining)
+        rescue ChildProcess::TimeoutError
+          raise TimeoutExceeded, process.pid
+        end
+
+        @logger.debug("Exit status: #{process.exit_code}")
+
+        # Read the final output data, since it is possible we missed a small
+        # amount of text between the time we last read data and when the
+        # process exited.
+        [stdout, stderr].each do |io|
+          # Read the extra data, ignoring if there isn't any
+          extra_data = read_io(io)
+          next if extra_data == ""
+
+          # Log it out and accumulate
+          io_name = io == stdout ? :stdout : :stderr
+          io_data[io_name] += extra_data
+          @logger.debug("#{io_name}: #{extra_data.chomp}")
+
+          # Yield to any listeners any remaining data
+          yield io_name, extra_data if block_given?
+        end
+
+        # Return an exit status container
+        return Result.new(process.exit_code, io_data[:stdout], io_data[:stderr])
+      end
+
+      protected
+
+      # Reads data from an IO object while it can, returning the data it reads.
+      # When it encounters a case when it can't read anymore, it returns the
+      # data.
+      #
+      # @return [String]
+      def read_io(io)
+        data = ""
+
+        while true
+          begin
+            if windows?
+              # Windows doesn't support non-blocking reads on
+              # file descriptors or pipes so we have to get
+              # a bit more creative.
+
+              # Check if data is actually ready on this IO device.
+              # We have to do this since `readpartial` will actually block
+              # until data is available, which can cause blocking forever
+              # in some cases.
+              results = IO.select([io], nil, nil, 0.1)
+              break if !results || results[0].empty?
+
+              # Read!
+              data << io.readpartial(READ_CHUNK_SIZE)
+            else
+              # Do a simple non-blocking read on the IO object
+              data << io.read_nonblock(READ_CHUNK_SIZE)
+            end
+          rescue Exception => e
+            # The catch-all rescue here is to support multiple Ruby versions,
+            # since we use some Ruby 1.9 specific exceptions.
+
+            breakable = false
+            if e.is_a?(EOFError)
+              # An `EOFError` means this IO object is done!
+              breakable = true
+            elsif defined?(IO::WaitReadable) && e.is_a?(IO::WaitReadable)
+              # IO::WaitReadable is only available on Ruby 1.9+
+
+              # An IO::WaitReadable means there may be more IO but this
+              # IO object is not ready to be read from yet. No problem,
+              # we read as much as we can, so we break.
+              breakable = true
+            elsif e.is_a?(Errno::EAGAIN)
+              # Otherwise, we just look for the EAGAIN error which should be
+              # all that IO::WaitReadable does in Ruby 1.9.
+              breakable = true
+            end
+
+            # Break out if we're supposed to. Otherwise re-raise the error
+            # because it is a real problem.
+            break if breakable
+            raise
+          end
+        end
+
+        data
+      end
+
+      def windows?
+        platform = RbConfig::CONFIG["host_os"].downcase
+        %W[mingw mswin].each do |text|
+          return true if platform.include?(text)
+        end
+
+        false
+      end
+
+      # An error which occurs when the process doesn't end within
+      # the given timeout.
+      class TimeoutExceeded < StandardError
+        attr_reader :pid
+
+        def initialize(pid)
+          super()
+          @pid = pid
+        end
+      end
+
+      # Container class to store the results of executing a subprocess.
+      class Result
+        attr_reader :exit_code
+        attr_reader :stdout
+        attr_reader :stderr
+
+        def initialize(exit_code, stdout, stderr)
+          @exit_code = exit_code
+          @stdout    = stdout
+          @stderr    = stderr
+        end
+      end
+    end
+  end
+end