vagrant-unbundled 2.2.19.0 → 2.3.3.0

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

@@ -1,33 +0,0 @@
-# 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/3.0.0/bundler/gems/vagrant-spec-b6b56c8b8135/lib/vagrant-spec/acceptance/rspec.rb

@@ -1,17 +0,0 @@
-# The RSpec helpers
-require_relative "rspec/context"
-require_relative "rspec/formatter"
-require_relative "rspec/matcher_exit_with"
-require_relative "rspec/matcher_match_output"
-
-RSpec.configure do |c|
-  c.add_formatter Vagrant::Spec::Acceptance::Formatter
-
-  if ENV["VAGRANT_SPEC_GUEST_PLATFORM"].to_s == "windows"
-    c.filter_run_excluding :skip_windows_guest
-  end
-
-  if RUBY_PLATFORM.match(/linux/)
-    c.filter_run_excluding :skip_linux_hosts
-  end
-end

data/vendor/bundle/ruby/3.0.0/bundler/gems/vagrant-spec-b6b56c8b8135/lib/vagrant-spec/acceptance/runner.rb

@@ -1,76 +0,0 @@
-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/3.0.0/bundler/gems/vagrant-spec-b6b56c8b8135/lib/vagrant-spec/acceptance.rb

@@ -1,29 +0,0 @@
-# This file should be required as the base for all acceptance related
-# tests. It configures the test runner as well if it can detect one.
-
-require_relative "acceptance/configuration"
-require_relative "acceptance/isolated_environment"
-require_relative "acceptance/output"
-
-if defined?(RSpec)
-  # Define the rspec helpers for us and configure RSpec a bit
-  require_relative "acceptance/rspec"
-end
-
-module Vagrant
-  module Spec
-    module Acceptance
-      # This returns the configuration for the acceptance tests.
-      #
-      # @return [Configuration]
-      def self.config
-        @config ||= Configuration.new
-      end
-
-      # This allows users to configure the acceptance tests.
-      def self.configure
-        yield config
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/3.0.0/bundler/gems/vagrant-spec-b6b56c8b8135/lib/vagrant-spec/cli.rb

@@ -1,48 +0,0 @@
-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/3.0.0/bundler/gems/vagrant-spec-b6b56c8b8135/lib/vagrant-spec/components.rb

@@ -1,57 +0,0 @@
-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/3.0.0/bundler/gems/vagrant-spec-b6b56c8b8135/lib/vagrant-spec/isolated_environment.rb

@@ -1,44 +0,0 @@
-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/3.0.0/bundler/gems/vagrant-spec-b6b56c8b8135/lib/vagrant-spec/server.rb

@@ -1,37 +0,0 @@
-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/3.0.0/bundler/gems/vagrant-spec-b6b56c8b8135/lib/vagrant-spec/subprocess.rb

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

data/vendor/bundle/ruby/3.0.0/bundler/gems/vagrant-spec-b6b56c8b8135/lib/vagrant-spec/unit/dummy_provider.rb

@@ -1,51 +0,0 @@
-require "vagrant"
-
-module Vagrant
-  module Spec
-    class DummyProviderPlugin < Vagrant.plugin("2")
-      name "Dummy Provider"
-      description <<-EOF
-      This creates a provider named "dummy" which does nothing, so that
-      the unit tests aren't reliant on VirtualBox (or any other real
-      provider for that matter).
-      EOF
-
-      provider(:dummy) { DummyProvider }
-    end
-
-    class DummyProvider < Vagrant.plugin("2", :provider)
-      def initialize(machine)
-        @machine = machine
-      end
-
-      def action(name)
-        lambda do |env|
-          # Do nothing
-        end
-      end
-
-      def state=(id)
-        state_file.open("w+") do |f|
-          f.write(id.to_s)
-        end
-      end
-
-      def state
-        if !state_file.file?
-          new_state = @machine.id
-          new_state = Vagrant::MachineState::NOT_CREATED_ID if !new_state
-          self.state = new_state
-        end
-
-        state_id = state_file.read.to_sym
-        Vagrant::MachineState.new(state_id, state_id.to_s, state_id.to_s)
-      end
-
-      protected
-
-      def state_file
-        @machine.data_dir.join("dummy_state")
-      end
-    end
-  end
-end