vagrant-aws-mkubenka 0.7.2.pre.22 → 0.7.2.pre.24

data/vendor/bundle/ruby/2.3.0/bundler/gems/vagrant-f3fdbf414272/test/unit/plugins/provisioners/chef/config/chef_apply_test.rb

@@ -1,85 +0,0 @@
-require_relative "../../../../base"
-
-require Vagrant.source_root.join("plugins/provisioners/chef/config/chef_apply")
-
-describe VagrantPlugins::Chef::Config::ChefApply do
-  include_context "unit"
-
-  subject { described_class.new }
-
-  let(:machine) { double("machine") }
-
-  def chef_error(key, options = {})
-    I18n.t("vagrant.provisioners.chef.#{key}", options)
-  end
-
-  describe "#recipe" do
-    it "defaults to nil" do
-      subject.finalize!
-      expect(subject.recipe).to be(nil)
-    end
-  end
-
-  describe "#upload_path" do
-    it "defaults to /tmp/vagrant-chef-apply.rb" do
-      subject.finalize!
-      expect(subject.upload_path).to eq("/tmp/vagrant-chef-apply")
-    end
-  end
-
-  describe "#validate" do
-    before do
-      allow(machine).to receive(:env)
-        .and_return(double("env",
-          root_path: "",
-        ))
-
-      subject.recipe = <<-EOH
-        package "foo"
-      EOH
-    end
-
-    let(:result) { subject.validate(machine) }
-    let(:errors) { result["chef apply provisioner"] }
-
-    context "when the recipe is nil" do
-      it "returns an error" do
-        subject.recipe = nil
-        subject.finalize!
-        expect(errors).to include chef_error("recipe_empty")
-      end
-    end
-
-    context "when the recipe is empty" do
-      it "returns an error" do
-        subject.recipe = "  "
-        subject.finalize!
-        expect(errors).to include chef_error("recipe_empty")
-      end
-    end
-
-    context "when the log_level is an empty array" do
-      it "returns an error" do
-        subject.log_level = "  "
-        subject.finalize!
-        expect(errors).to include chef_error("log_level_empty")
-      end
-    end
-
-    context "when the upload_path is nil" do
-      it "returns an error" do
-        subject.upload_path = nil
-        subject.finalize!
-        expect(errors).to include chef_error("upload_path_empty")
-      end
-    end
-
-    context "when the upload_path is an empty array" do
-      it "returns an error" do
-        subject.upload_path = "  "
-        subject.finalize!
-        expect(errors).to include chef_error("upload_path_empty")
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.3.0/bundler/gems/vagrant-f3fdbf414272/test/unit/plugins/provisioners/chef/provisioner/base_test.rb

@@ -1,90 +0,0 @@
-require_relative "../../../../base"
-
-require Vagrant.source_root.join("plugins/provisioners/chef/provisioner/base")
-
-describe VagrantPlugins::Chef::Provisioner::Base 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") }
-
-  subject { described_class.new(machine, config) }
-
-  before do
-    allow(config).to receive(:node_name)
-    allow(config).to receive(:node_name=)
-  end
-
-  describe "#node_name" do
-    let(:env) { double("env") }
-    let(:root_path) { "/my/root" }
-
-    before do
-      allow(machine).to receive(:env).and_return(env)
-      allow(env).to receive(:root_path).and_return(root_path)
-    end
-
-    it "defaults to node_name if given" do
-      config = OpenStruct.new(node_name: "name")
-      instance = described_class.new(machine, config)
-      expect(instance.config.node_name).to eq("name")
-    end
-
-    it "defaults to hostname if given" do
-      machine.config.vm.hostname = "by.hostname"
-      instance = described_class.new(machine, OpenStruct.new)
-      expect(instance.config.node_name).to eq("by.hostname")
-    end
-
-    it "generates a random name if no hostname or node_name is given" do
-      config = OpenStruct.new(node_name: nil)
-      machine.config.vm.hostname = nil
-      instance = described_class.new(machine, OpenStruct.new)
-      expect(instance.config.node_name).to match(/vagrant\-.+/)
-    end
-  end
-
-  describe "#encrypted_data_bag_secret_key_path" do
-    let(:env) { double("env") }
-    let(:root_path) { "/my/root" }
-
-    before do
-      allow(machine).to receive(:env).and_return(env)
-      allow(env).to receive(:root_path).and_return(root_path)
-    end
-
-    it "returns absolute path as is" do
-      expect(config).to receive(:encrypted_data_bag_secret_key_path).
-        and_return("/foo/bar")
-      expect(subject.encrypted_data_bag_secret_key_path).to eq "/foo/bar"
-    end
-
-    it "returns relative path joined to root_path" do
-      expect(config).to receive(:encrypted_data_bag_secret_key_path).
-        and_return("secret")
-      expect(subject.encrypted_data_bag_secret_key_path).to eq "/my/root/secret"
-    end
-  end
-
-  describe "#guest_encrypted_data_bag_secret_key_path" do
-    it "returns nil if host path is not configured" do
-      allow(config).to receive(:encrypted_data_bag_secret_key_path).and_return(nil)
-      allow(config).to receive(:provisioning_path).and_return("/tmp/foo")
-      expect(subject.guest_encrypted_data_bag_secret_key_path).to be_nil
-    end
-
-    it "returns path under config.provisioning_path" do
-      allow(config).to receive(:encrypted_data_bag_secret_key_path).and_return("secret")
-      allow(config).to receive(:provisioning_path).and_return("/tmp/foo")
-      expect(File.dirname(subject.guest_encrypted_data_bag_secret_key_path)).
-        to eq "/tmp/foo"
-    end
-  end
-end

data/vendor/bundle/ruby/2.3.0/bundler/gems/vagrant-f3fdbf414272/test/unit/plugins/provisioners/docker/config_test.rb

@@ -1,163 +0,0 @@
-require File.expand_path("../../../../base", __FILE__)
-
-require Vagrant.source_root.join("plugins/provisioners/docker/config")
-require Vagrant.source_root.join("plugins/provisioners/docker/provisioner")
-require Vagrant.source_root.join("plugins/kernel_v2/config/vm")
-
-describe VagrantPlugins::DockerProvisioner::Config do
-  subject { described_class.new }
-
-  describe "#build_image" do
-    it "stores them" do
-      subject.build_image("foo")
-      subject.build_image("bar", foo: :bar)
-      subject.finalize!
-      expect(subject.build_images.length).to eql(2)
-      expect(subject.build_images[0]).to eql(["foo", {}])
-      expect(subject.build_images[1]).to eql(["bar", { foo: :bar }])
-    end
-  end
-
-  describe "#images" do
-    it "stores them in a set" do
-      subject.images = ["1", "1", "2"]
-      subject.finalize!
-      expect(subject.images.to_a.sort).to eql(["1", "2"])
-    end
-
-    it "overrides previously set images" do
-      subject.images = ["3"]
-      subject.images = ["1", "1", "2"]
-      subject.finalize!
-      expect(subject.images.to_a.sort).to eql(["1", "2"])
-    end
-  end
-
-  describe "#merge" do
-    it "has all images to pull" do
-      subject.pull_images("1")
-
-      other = described_class.new
-      other.pull_images("2", "3")
-
-      result = subject.merge(other)
-      expect(result.images.to_a.sort).to eq(
-        ["1", "2", "3"])
-    end
-
-    it "has all the containers to run" do
-      subject.run("foo", image: "bar", daemonize: false)
-      subject.run("bar")
-
-      other = described_class.new
-      other.run("foo", image: "foo")
-
-      result = subject.merge(other)
-      result.finalize!
-
-      cs     = result.containers
-      expect(cs.length).to eq(2)
-      expect(cs["foo"]).to eq({
-        auto_assign_name: true,
-        image: "foo",
-        daemonize: false,
-        restart: "always",
-      })
-      expect(cs["bar"]).to eq({
-        auto_assign_name: true,
-        image: "bar",
-        daemonize: true,
-        restart: "always",
-      })
-    end
-
-    it "has all the containers to build" do
-      subject.build_image("foo")
-
-      other = described_class.new
-      other.build_image("bar")
-
-      result = subject.merge(other)
-      result.finalize!
-
-      images = result.build_images
-      expect(images.length).to eq(2)
-      expect(images[0]).to eq(["foo", {}])
-      expect(images[1]).to eq(["bar", {}])
-    end
-  end
-
-  describe "#pull_images" do
-    it "adds images to the list of images to build" do
-      subject.pull_images("1")
-      subject.pull_images("2", "3")
-      subject.finalize!
-      expect(subject.images.to_a.sort).to eql(["1", "2", "3"])
-    end
-  end
-
-  describe "#run" do
-    it "runs the given image" do
-      subject.run("foo")
-
-      subject.finalize!
-      expect(subject.containers).to eql({
-        "foo" => {
-          auto_assign_name: true,
-          daemonize: true,
-          image: "foo",
-          restart: "always",
-        }
-      })
-    end
-
-    it "can not auto assign name" do
-      subject.run("foo", auto_assign_name: false)
-
-      subject.finalize!
-      expect(subject.containers).to eql({
-        "foo" => {
-          auto_assign_name: false,
-          daemonize: true,
-          image: "foo",
-          restart: "always",
-        }
-      })
-    end
-
-    it "can not daemonize" do
-      subject.run("foo", daemonize: false)
-
-      subject.finalize!
-      expect(subject.containers).to eql({
-        "foo" => {
-          auto_assign_name: true,
-          daemonize: false,
-          image: "foo",
-          restart: "always",
-        }
-      })
-    end
-  end
-
-  describe "#post_install_provision" do
-    it "raises an error if 'docker' provisioner was provided" do
-      expect {subject.post_install_provision("myprov", :type=>"docker", :inline=>"echo 'hello'")}
-        .to raise_error(VagrantPlugins::DockerProvisioner::DockerError)
-    end
-
-    it "setups a basic provisioner" do
-      prov = double()
-      mock_provisioner = "mock"
-      mock_provisioners = [mock_provisioner]
-
-      allow(VagrantPlugins::Kernel_V2::VMConfig).to receive(:new).
-        and_return(prov)
-      allow(prov).to receive(:provision).and_return(mock_provisioners)
-      allow(prov).to receive(:provisioners).and_return(mock_provisioners)
-
-      subject.post_install_provision("myprov", :inline=>"echo 'hello'")
-      expect(subject.post_install_provisioner).to eq(mock_provisioner)
-    end
-  end
-end

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

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