vagrant-aws-detiber 0.7.2.pre.2

data/vendor/bundle/ruby/2.3.0/bundler/gems/vagrant-419afb4dcffe/test/unit/plugins/provisioners/docker/provisioner_test.rb

@@ -0,0 +1,79 @@
+require File.expand_path("../../../../base", __FILE__)
+
+require Vagrant.source_root.join("plugins/provisioners/docker/provisioner")
+
+describe VagrantPlugins::DockerProvisioner::Provisioner do
+  include_context "unit"
+  subject { described_class.new(machine, config, installer, client) }
+
+  let(:iso_env) do
+    # We have to create a Vagrantfile so there is a root path
+    env = isolated_environment
+    env.vagrantfile("")
+    env.create_vagrant_env
+  end
+
+  let(:machine) { iso_env.machine(iso_env.machine_names[0], :dummy) }
+  let(:config)       { double("config") }
+  let(:communicator) { double("comm") }
+  let(:guest)        { double("guest") }
+  let(:client)       { double("client") }
+  let(:installer)    { double("installer") }
+  let(:hook)         { double("hook") }
+
+  before do
+    allow(machine).to receive(:communicate).and_return(communicator)
+    allow(machine).to receive(:guest).and_return(guest)
+
+    allow(communicator).to receive(:execute).and_return(true)
+    allow(communicator).to receive(:upload).and_return(true)
+
+    allow(guest).to receive(:capability?).and_return(false)
+    allow(guest).to receive(:capability).and_return(false)
+
+    allow(client).to receive(:start_service).and_return(true)
+    allow(client).to receive(:daemon_running?).and_return(true)
+
+    allow(config).to receive(:images).and_return(Set.new)
+    allow(config).to receive(:build_images).and_return(Set.new)
+    allow(config).to receive(:containers).and_return(Hash.new)
+  end
+
+  describe "#provision" do
+    let(:provisioner) do
+      prov = VagrantPlugins::Kernel_V2::VagrantConfigProvisioner.new("spec-test", :shell)
+      prov.config = {}
+      prov
+    end
+
+    it "invokes a post_install_provisioner if defined and docker is installed" do
+      allow(installer).to receive(:ensure_installed).and_return(true)
+      allow(config).to receive(:post_install_provisioner).and_return(provisioner)
+      allow(machine).to receive(:env).and_return(iso_env)
+      allow(machine.env).to receive(:hook).and_return(true)
+
+      expect(machine.env).to receive(:hook).with(:run_provisioner, anything)
+      subject.provision()
+    end
+
+    it "does not invoke post_install_provisioner if not defined" do
+      allow(installer).to receive(:ensure_installed).and_return(true)
+      allow(config).to receive(:post_install_provisioner).and_return(nil)
+      allow(machine).to receive(:env).and_return(iso_env)
+      allow(machine.env).to receive(:hook).and_return(true)
+
+      expect(machine.env).not_to receive(:hook).with(:run_provisioner, anything)
+      subject.provision()
+    end
+
+    it "raises an error if docker daemon isn't running" do
+      allow(installer).to receive(:ensure_installed).and_return(false)
+      allow(client).to receive(:start_service).and_return(false)
+      allow(client).to receive(:daemon_running?).and_return(false)
+
+      expect { subject.provision() }.
+        to raise_error(VagrantPlugins::DockerProvisioner::DockerError)
+    end
+  end
+
+end

data/vendor/bundle/ruby/2.3.0/bundler/gems/vagrant-419afb4dcffe/test/unit/plugins/provisioners/file/config_test.rb

@@ -0,0 +1,80 @@
+require_relative "../../../base"
+
+require Vagrant.source_root.join("plugins/provisioners/file/config")
+
+describe VagrantPlugins::FileUpload::Config do
+  include_context "unit"
+
+  subject { described_class.new }
+
+  let(:env) do
+    iso_env = isolated_environment
+    iso_env.vagrantfile("")
+    iso_env.create_vagrant_env
+  end
+
+  let(:machine) { double("machine", env: env) }
+
+  describe "#validate" do
+    it "returns an error if destination is not specified" do
+      existing_file = File.expand_path(__FILE__)
+
+      subject.source = existing_file
+      subject.finalize!
+
+      result = subject.validate(machine)
+      expect(result["File provisioner"]).to eql([
+        I18n.t("vagrant.provisioners.file.no_dest_file")
+      ])
+    end
+
+    it "returns an error if source is not specified" do
+      subject.destination = "/tmp/foo"
+      subject.finalize!
+
+      result = subject.validate(machine)
+      expect(result["File provisioner"]).to eql([
+        I18n.t("vagrant.provisioners.file.no_source_file")
+      ])
+    end
+
+    it "returns an error if source file does not exist" do
+      non_existing_file = "/this/does/not/exist"
+
+      subject.source = non_existing_file
+      subject.destination = "/tmp/foo"
+      subject.finalize!
+
+      result = subject.validate(machine)
+      expect(result["File provisioner"]).to eql([
+        I18n.t("vagrant.provisioners.file.path_invalid",
+               path: File.expand_path(non_existing_file))
+      ])
+    end
+
+    it "passes with absolute source path" do
+      existing_absolute_path = File.expand_path(__FILE__)
+
+      subject.source = existing_absolute_path
+      subject.destination = "/tmp/foo"
+      subject.finalize!
+
+      result = subject.validate(machine)
+      expect(result["File provisioner"]).to eql([])
+    end
+
+    it "passes with relative source path" do
+      path = env.root_path.join("foo")
+      path.open("w+") { |f| f.write("hello") }
+
+      existing_relative_path = "foo"
+
+      subject.source = existing_relative_path
+      subject.destination = "/tmp/foo"
+      subject.finalize!
+
+      result = subject.validate(machine)
+      expect(result["File provisioner"]).to eql([])
+    end
+  end
+end

data/vendor/bundle/ruby/2.3.0/bundler/gems/vagrant-419afb4dcffe/test/unit/plugins/provisioners/file/provisioner_test.rb

@@ -0,0 +1,127 @@
+require_relative "../../../base"
+
+require Vagrant.source_root.join("plugins/provisioners/file/provisioner")
+
+describe VagrantPlugins::FileUpload::Provisioner do
+  include_context "unit"
+
+  subject { described_class.new(machine, config) }
+
+  let(:iso_env) do
+    # We have to create a Vagrantfile so there is a root path
+    env = isolated_environment
+    env.vagrantfile("")
+    env.create_vagrant_env
+  end
+
+  let(:machine) { iso_env.machine(iso_env.machine_names[0], :dummy) }
+  let(:config)       { double("config") }
+  let(:communicator) { double("comm") }
+  let(:guest)        { double("guest") }
+
+  before do
+    allow(machine).to receive(:communicate).and_return(communicator)
+    allow(machine).to receive(:guest).and_return(guest)
+
+    allow(communicator).to receive(:execute).and_return(true)
+    allow(communicator).to receive(:upload).and_return(true)
+
+    allow(guest).to receive(:capability?).and_return(false)
+  end
+
+  describe "#provision" do
+    it "creates the destination directory" do
+      allow(config).to receive(:source).and_return("/source")
+      allow(config).to receive(:destination).and_return("/foo/bar")
+
+      expect(communicator).to receive(:execute).with("mkdir -p \"/foo\"")
+
+      subject.provision
+    end
+
+    it "creates the destination directory with a space" do
+      allow(config).to receive(:source).and_return("/source")
+      allow(config).to receive(:destination).and_return("/foo bar/bar")
+
+      expect(communicator).to receive(:execute).with("mkdir -p \"/foo bar\"")
+
+      subject.provision
+    end
+
+    it "creates the destination directory above file" do
+      allow(config).to receive(:source).and_return("/source/file.sh")
+      allow(config).to receive(:destination).and_return("/foo/bar/file.sh")
+
+      expect(communicator).to receive(:execute).with("mkdir -p \"/foo/bar\"")
+
+      subject.provision
+    end
+
+    it "uploads the file" do
+      allow(config).to receive(:source).and_return("/source")
+      allow(config).to receive(:destination).and_return("/foo/bar")
+
+      expect(communicator).to receive(:upload).with("/source", "/foo/bar")
+
+      subject.provision
+    end
+
+    it "expands the source file path" do
+      allow(config).to receive(:source).and_return("source")
+      allow(config).to receive(:destination).and_return("/foo/bar")
+
+      expect(communicator).to receive(:upload).with(
+        File.expand_path("source"), "/foo/bar")
+
+      subject.provision
+    end
+
+    it "expands the destination file path if capable" do
+      allow(config).to receive(:source).and_return("/source")
+      allow(config).to receive(:destination).and_return("$HOME/foo")
+
+      expect(guest).to receive(:capability?).
+        with(:shell_expand_guest_path).and_return(true)
+      expect(guest).to receive(:capability).
+        with(:shell_expand_guest_path, "$HOME/foo").and_return("/home/foo")
+
+      expect(communicator).to receive(:upload).with("/source", "/home/foo")
+
+      subject.provision
+    end
+
+    it "appends a '/.' if the destination doesnt end with a file separator" do
+      allow(config).to receive(:source).and_return("/source")
+      allow(config).to receive(:destination).and_return("/foo/bar")
+      allow(File).to receive(:directory?).with("/source").and_return(true)
+
+      expect(guest).to receive(:capability?).
+        with(:shell_expand_guest_path).and_return(true)
+      expect(guest).to receive(:capability).
+        with(:shell_expand_guest_path, "/foo/bar").and_return("/foo/bar")
+
+      expect(communicator).to receive(:upload).with("/source/.", "/foo/bar")
+
+      subject.provision
+    end
+
+    it "sends an array of files and folders if winrm and destination doesn't end with file separator" do
+      files = ["/source/file.py", "/source/folder"]
+      allow(Dir).to receive(:[]).and_return(files)
+      allow(config).to receive(:source).and_return("/source")
+      allow(config).to receive(:destination).and_return("/foo/bar")
+      allow(File).to receive(:directory?).with("/source").and_return(true)
+      allow(machine.config.vm).to receive(:communicator).and_return(:winrm)
+
+      expect(guest).to receive(:capability?).
+        with(:shell_expand_guest_path).and_return(true)
+      expect(guest).to receive(:capability).
+        with(:shell_expand_guest_path, "/foo/bar").and_return("/foo/bar")
+
+      expect(communicator).to receive(:upload)
+        .with(files, "/foo/bar")
+
+      subject.provision
+    end
+  end
+end

data/vendor/bundle/ruby/2.3.0/bundler/gems/vagrant-419afb4dcffe/test/unit/plugins/provisioners/puppet/provisioner/puppet_test.rb

@@ -0,0 +1,51 @@
+require File.expand_path("../../../../../base", __FILE__)
+
+require Vagrant.source_root.join("plugins/provisioners/puppet/provisioner/puppet")
+
+describe VagrantPlugins::Puppet::Provisioner::Puppet do
+  include_context "unit"
+
+  let(:iso_env) do
+    # We have to create a Vagrantfile so there is a root path
+    env = isolated_environment
+    env.vagrantfile("")
+    env.create_vagrant_env
+  end
+
+  let(:machine) { iso_env.machine(iso_env.machine_names[0], :dummy) }
+  let(:config)       { double("config") }
+  let(:facts)        { [] }
+  let(:communicator) { double("comm") }
+  let(:guest)        { double("guest") }
+  let(:comm) { VagrantTests::DummyCommunicator::Communicator.new(machine) }
+  let(:module_paths) { ["etc/puppet/modules"] } # make this something real
+
+  subject { described_class.new(machine, config) }
+
+  before do
+    allow(machine).to receive(:communicate).and_return(comm)
+  end
+
+  describe "#run_puppet_apply" do
+    let(:options) { double("options") }
+    let(:binary_path) { "/opt/puppetlabs/bin" }
+    let(:manifest_file) { "default.pp" }
+
+    it "runs puppet on a manifest" do
+      allow(config).to receive(:options).and_return(options)
+      allow(config).to receive(:environment_path).and_return(false)
+      allow(config).to receive(:facter).and_return(facts)
+      allow(config).to receive(:binary_path).and_return(binary_path)
+      allow(config).to receive(:environment_variables).and_return(nil)
+      allow(config).to receive(:working_directory).and_return(false)
+      allow(config).to receive(:manifest_file).and_return(manifest_file)
+
+      allow_message_expectations_on_nil
+      allow(@module_paths).to receive(:map) { module_paths }
+      allow(@module_paths).to receive(:empty?).and_return(true)
+
+      expect(machine).to receive(:communicate).and_return(comm)
+      subject.run_puppet_apply()
+    end
+  end
+end

data/vendor/bundle/ruby/2.3.0/bundler/gems/vagrant-419afb4dcffe/test/unit/plugins/provisioners/salt/config_test.rb

@@ -0,0 +1,160 @@
+require File.expand_path("../../../../base", __FILE__)
+
+require Vagrant.source_root.join("plugins/provisioners/salt/config")
+
+describe VagrantPlugins::Salt::Config do
+  include_context "unit"
+
+  subject { described_class.new }
+
+  let(:iso_env) do
+    # We have to create a Vagrantfile so there is a root path
+    env = isolated_environment
+    env.vagrantfile("")
+    env.create_vagrant_env
+  end
+
+  let(:machine) { iso_env.machine(iso_env.machine_names[0], :dummy) }
+
+  describe "validate" do
+    let(:error_key) { "salt provisioner" }
+
+    it "passes by default" do
+      subject.finalize!
+      result = subject.validate(machine)
+      expect(result[error_key]).to be_empty
+    end
+
+    context "minion_config" do
+      it "fails if minion_config is set and missing" do
+        subject.minion_config = "/nope/nope/i/dont/exist"
+        subject.finalize!
+
+        result = subject.validate(machine)
+        expect(result[error_key]).to_not be_empty
+      end
+
+      it "is valid if is set and not missing" do
+        subject.minion_config = File.expand_path(__FILE__)
+        subject.finalize!
+
+        result = subject.validate(machine)
+        expect(result[error_key]).to be_empty
+      end
+    end
+
+    context "master_config" do
+      it "fails if master_config is set and missing" do
+        subject.master_config = "/ceci/nest/pas/une/path"
+        subject.finalize!
+
+        result = subject.validate(machine)
+        expect(result[error_key]).to_not be_empty
+      end
+
+      it "is valid if is set and not missing" do
+        subject.master_config = File.expand_path(__FILE__)
+        subject.finalize!
+
+        result = subject.validate(machine)
+        expect(result[error_key]).to be_empty
+      end
+    end
+
+    context "grains_config" do
+      it "fails if grains_config is set and missing" do
+        subject.grains_config = "/nope/still/not/here"
+        subject.finalize!
+
+        result = subject.validate(machine)
+        expect(result[error_key]).to_not be_empty
+      end
+
+      it "is valid if is set and not missing" do
+        subject.grains_config = File.expand_path(__FILE__)
+        subject.finalize!
+
+        result = subject.validate(machine)
+        expect(result[error_key]).to be_empty
+      end
+    end
+
+    context "salt_call_args" do
+      it "fails if salt_call_args is not an array" do
+        subject.salt_call_args = "--flags"
+        subject.finalize!
+
+        result = subject.validate(machine)
+        expect(result[error_key]).to_not be_empty
+      end
+
+      it "is valid if is set and not missing" do
+        subject.salt_call_args = ["--flags"]
+        subject.finalize!
+
+        result = subject.validate(machine)
+        expect(result[error_key]).to be_empty
+      end
+    end
+
+    context "salt_args" do
+      it "fails if not an array" do
+        subject.salt_args = "--flags"
+        subject.finalize!
+
+        result = subject.validate(machine)
+        expect(result[error_key]).to_not be_empty
+      end
+
+      it "is valid if is set and not missing" do
+        subject.salt_args = ["--flags"]
+        subject.finalize!
+
+        result = subject.validate(machine)
+        expect(result[error_key]).to be_empty
+      end
+    end
+
+    context "python_version" do
+      it "is valid if is set and not missing" do
+        subject.python_version = "2"
+        subject.finalize!
+
+        result = subject.validate(machine)
+        expect(result[error_key]).to be_empty
+      end
+
+      it "can be a string" do
+        subject.python_version = "2"
+        subject.finalize!
+
+        result = subject.validate(machine)
+        expect(result[error_key]).to be_empty
+      end
+
+      it "can be an integer" do
+        subject.python_version = 2
+        subject.finalize!
+
+        result = subject.validate(machine)
+        expect(result[error_key]).to be_empty
+      end
+
+      it "is not a number that is not an integer" do
+        subject.python_version = 2.7
+        subject.finalize!
+
+        result = subject.validate(machine)
+        expect(result[error_key]).to_not be_empty
+      end
+
+      it "is not a string that does not parse to an integer" do
+        subject.python_version = '2.7'
+        subject.finalize!
+
+        result = subject.validate(machine)
+        expect(result[error_key]).to_not be_empty
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.3.0/bundler/gems/vagrant-419afb4dcffe/test/unit/plugins/provisioners/salt/provisioner_test.rb

@@ -0,0 +1,135 @@
+require_relative "../../../base"
+
+require Vagrant.source_root.join("plugins/provisioners/salt/provisioner")
+
+describe VagrantPlugins::Salt::Provisioner do
+  include_context "unit"
+
+  subject { described_class.new(machine, config) }
+
+  let(:iso_env) do
+    # We have to create a Vagrantfile so there is a root path
+    env = isolated_environment
+    env.vagrantfile("")
+    env.create_vagrant_env
+  end
+
+  let(:machine) { iso_env.machine(iso_env.machine_names[0], :dummy) }
+  let(:config)       { double("config") }
+  let(:communicator) { double("comm") }
+  let(:guest)        { double("guest") }
+
+  before do
+    allow(machine).to receive(:communicate).and_return(communicator)
+    allow(machine).to receive(:guest).and_return(guest)
+
+    allow(communicator).to receive(:execute).and_return(true)
+    allow(communicator).to receive(:upload).and_return(true)
+
+    allow(guest).to receive(:capability?).and_return(false)
+  end
+
+  describe "#provision" do
+    context "minion" do
+      it "does not add linux-only bootstrap flags when on windows" do
+        additional_windows_options = "-only -these options -should -remain"
+        allow(config).to receive(:seed_master).and_return(true)
+        allow(config).to receive(:install_master).and_return(true)
+        allow(config).to receive(:install_syndic).and_return(true)
+        allow(config).to receive(:no_minion).and_return(true)
+        allow(config).to receive(:install_type).and_return('stable')
+        allow(config).to receive(:install_args).and_return('develop')
+        allow(config).to receive(:verbose).and_return(true)
+        allow(machine.config.vm).to receive(:communicator).and_return(:winrm)
+        allow(config).to receive(:bootstrap_options).and_return(additional_windows_options)
+        result = subject.bootstrap_options(true, true, "C:\\salttmp")
+        expect(result.strip).to eq(additional_windows_options)
+      end
+    end
+  end
+
+  describe "#call_highstate" do
+    context "master" do
+      it "passes along extra cli flags" do
+        allow(config).to receive(:run_highstate).and_return(true)
+        allow(config).to receive(:verbose).and_return(true)
+        allow(config).to receive(:masterless?).and_return(false)
+        allow(config).to receive(:masterless).and_return(false)
+        allow(config).to receive(:minion_id).and_return(nil)
+        allow(config).to receive(:log_level).and_return(nil)
+        allow(config).to receive(:colorize).and_return(false)
+        allow(config).to receive(:pillar_data).and_return([])
+        allow(config).to receive(:install_master).and_return(true)
+
+        allow(config).to receive(:salt_args).and_return(["--async"])
+        allow(machine.communicate).to receive(:sudo)
+        allow(machine.config.vm).to receive(:communicator).and_return(:notwinrm)
+
+        expect(machine.communicate).to receive(:sudo).with("salt '*' state.highstate --verbose --log-level=debug --no-color --async", {:error_key=>:ssh_bad_exit_status_muted})
+        subject.call_highstate()
+      end
+
+      it "has no additional cli flags if not included" do
+        allow(config).to receive(:run_highstate).and_return(true)
+        allow(config).to receive(:verbose).and_return(true)
+        allow(config).to receive(:masterless?).and_return(false)
+        allow(config).to receive(:masterless).and_return(false)
+        allow(config).to receive(:minion_id).and_return(nil)
+        allow(config).to receive(:log_level).and_return(nil)
+        allow(config).to receive(:colorize).and_return(false)
+        allow(config).to receive(:pillar_data).and_return([])
+        allow(config).to receive(:install_master).and_return(true)
+
+        allow(config).to receive(:salt_args).and_return(nil)
+        allow(machine.communicate).to receive(:sudo)
+        allow(machine.config.vm).to receive(:communicator).and_return(:notwinrm)
+
+        expect(machine.communicate).to receive(:sudo).with("salt '*' state.highstate --verbose --log-level=debug --no-color ", {:error_key=>:ssh_bad_exit_status_muted})
+        subject.call_highstate()
+      end
+    end
+
+    context "with masterless" do
+      it "passes along extra cli flags" do
+        allow(config).to receive(:run_highstate).and_return(true)
+        allow(config).to receive(:verbose).and_return(true)
+        allow(config).to receive(:masterless?).and_return(true)
+        allow(config).to receive(:masterless).and_return(true)
+        allow(config).to receive(:minion_id).and_return(nil)
+        allow(config).to receive(:log_level).and_return(nil)
+        allow(config).to receive(:colorize).and_return(false)
+        allow(config).to receive(:pillar_data).and_return([])
+
+        allow(config).to receive(:salt_args).and_return(["--async"])
+        allow(config).to receive(:salt_call_args).and_return(["--output-dif"])
+        allow(machine.communicate).to receive(:sudo)
+        allow(machine.config.vm).to receive(:communicator).and_return(:notwinrm)
+        allow(config).to receive(:install_master).and_return(false)
+
+        expect(machine.communicate).to receive(:sudo).with("salt-call state.highstate --retcode-passthrough --local --log-level=debug --no-color --output-dif", {:error_key=>:ssh_bad_exit_status_muted})
+        subject.call_highstate()
+      end
+
+      it "has no additional cli flags if not included" do
+        allow(config).to receive(:run_highstate).and_return(true)
+        allow(config).to receive(:verbose).and_return(true)
+        allow(config).to receive(:masterless?).and_return(true)
+        allow(config).to receive(:masterless).and_return(true)
+        allow(config).to receive(:minion_id).and_return(nil)
+        allow(config).to receive(:log_level).and_return(nil)
+        allow(config).to receive(:colorize).and_return(false)
+        allow(config).to receive(:pillar_data).and_return([])
+
+        allow(config).to receive(:salt_call_args).and_return(nil)
+        allow(config).to receive(:salt_args).and_return(nil)
+        allow(machine.communicate).to receive(:sudo)
+        allow(machine.config.vm).to receive(:communicator).and_return(:notwinrm)
+        allow(config).to receive(:install_master).and_return(false)
+
+        expect(machine.communicate).to receive(:sudo).with("salt-call state.highstate --retcode-passthrough --local --log-level=debug --no-color ", {:error_key=>:ssh_bad_exit_status_muted})
+        subject.call_highstate()
+      end
+    end
+  end
+
+end