vagrant-aws-detiber 0.7.2.pre.2

data/vendor/bundle/ruby/2.3.0/bundler/gems/vagrant-419afb4dcffe/test/unit/vagrant/config/v2/loader_test.rb

@@ -0,0 +1,151 @@
+require "ostruct"
+
+require File.expand_path("../../../../base", __FILE__)
+
+describe Vagrant::Config::V2::Loader do
+  include_context "unit"
+
+  before(:each) do
+    # Force the V2 loader to believe that we are in V2
+    stub_const("Vagrant::Config::CURRENT_VERSION", "2")
+  end
+
+  describe "empty" do
+    it "returns an empty configuration object" do
+      result = described_class.init
+      expect(result).to be_kind_of(Vagrant::Config::V2::Root)
+    end
+  end
+
+  describe "finalizing" do
+    it "should call `#finalize` on the configuration object" do
+      # Register a plugin for our test
+      register_plugin("2") do |plugin|
+        plugin.config "foo" do
+          Class.new(Vagrant.plugin("2", "config")) do
+            attr_accessor :bar
+
+            def finalize!
+              @bar = "finalized"
+            end
+          end
+        end
+      end
+
+      # Create the proc we're testing
+      config_proc = Proc.new do |config|
+        config.foo.bar = "value"
+      end
+
+      # Test that it works properly
+      config = described_class.load(config_proc)
+      expect(config.foo.bar).to eq("value")
+
+      # Finalize it
+      described_class.finalize(config)
+      expect(config.foo.bar).to eq("finalized")
+    end
+  end
+
+  describe "loading" do
+    it "should configure with all plugin config keys loaded" do
+      # Register a plugin for our test
+      register_plugin("2") do |plugin|
+        plugin.config("foo") { OpenStruct }
+      end
+
+      # Create the proc we're testing
+      config_proc = Proc.new do |config|
+        config.foo.bar = "value"
+      end
+
+      # Test that it works properly
+      config = described_class.load(config_proc)
+      expect(config.foo.bar).to eq("value")
+    end
+  end
+
+  describe "merging" do
+    it "should merge available configuration keys" do
+      old = Vagrant::Config::V2::Root.new({ foo: Object })
+      new = Vagrant::Config::V2::Root.new({ bar: Object })
+      result = described_class.merge(old, new)
+      expect(result.foo).to be_kind_of(Object)
+      expect(result.bar).to be_kind_of(Object)
+    end
+
+    it "should merge instantiated objects" do
+      config_class = Class.new do
+        attr_accessor :value
+      end
+
+      old = Vagrant::Config::V2::Root.new({ foo: config_class })
+      old.foo.value = "old"
+
+      new = Vagrant::Config::V2::Root.new({ bar: config_class })
+      new.bar.value = "new"
+
+      result = described_class.merge(old, new)
+      expect(result.foo.value).to eq("old")
+      expect(result.bar.value).to eq("new")
+    end
+
+    it "should merge conflicting classes by calling `merge`" do
+      config_class = Class.new do
+        attr_accessor :value
+
+        def merge(new)
+          result       = self.class.new
+          result.value = @value + new.value
+          result
+        end
+      end
+
+      old = Vagrant::Config::V2::Root.new({ foo: config_class })
+      old.foo.value = 10
+
+      new = Vagrant::Config::V2::Root.new({ foo: config_class })
+      new.foo.value = 15
+
+      result = described_class.merge(old, new)
+      expect(result.foo.value).to eq(25)
+    end
+  end
+
+  describe "upgrading" do
+    it "should continue fine if the key doesn't implement upgrade" do
+      # Make an old V1 root object
+      old = Vagrant::Config::V1::Root.new({ foo: Class.new })
+
+      # It should work fine
+      expect { result = described_class.upgrade(old) }.to_not raise_error
+    end
+
+    it "should upgrade the config if it implements the upgrade method" do
+      # Create the old V1 class that will be upgraded
+      config_class = Class.new do
+        attr_accessor :value
+
+        def upgrade(new)
+          new.foo.value = value * 2
+
+          [["foo"], ["bar"]]
+        end
+      end
+
+      # Create the new V2 plugin it is writing to
+      register_plugin("2") do |p|
+        p.config("foo") { OpenStruct }
+      end
+
+      # Test it out!
+      old = Vagrant::Config::V1::Root.new({ foo: config_class })
+      old.foo.value = 5
+
+      data = described_class.upgrade(old)
+      expect(data[0].foo.value).to eq(10)
+      expect(data[1]).to eq(["foo"])
+      expect(data[2]).to eq(["bar"])
+    end
+  end
+end

data/vendor/bundle/ruby/2.3.0/bundler/gems/vagrant-419afb4dcffe/test/unit/vagrant/config/v2/root_test.rb

@@ -0,0 +1,126 @@
+require "set"
+
+require File.expand_path("../../../../base", __FILE__)
+
+describe Vagrant::Config::V2::Root do
+  include_context "unit"
+
+  it "should provide access to config objects" do
+    foo_class = Class.new
+    map       = { foo: foo_class }
+
+    instance  = described_class.new(map)
+    foo       = instance.foo
+    expect(foo).to be_kind_of(foo_class)
+    expect(instance.foo).to eql(foo)
+  end
+
+  it "record a missing key call if invalid key used" do
+    instance = described_class.new({})
+    expect { instance.foo }.to_not raise_error
+    expect(instance.__internal_state["missing_key_calls"].include?("foo")).to be
+  end
+
+  it "returns a dummy config for a missing key" do
+    instance = described_class.new({})
+    expect { instance.foo.foo = "bar" }.to_not raise_error
+  end
+
+  it "can be created with initial state" do
+    instance = described_class.new({}, { foo: "bar" })
+    expect(instance.foo).to eq("bar")
+  end
+
+  it "should return internal state" do
+    map      = { "foo" => Object, "bar" => Object }
+    instance = described_class.new(map)
+    expect(instance.__internal_state).to eq({
+      "config_map"        => map,
+      "keys"              => {},
+      "missing_key_calls" => Set.new
+    })
+  end
+
+  describe "#finalize!" do
+    it "should call #finalize!" do
+      foo_class = Class.new(Vagrant.plugin("2", "config")) do
+        attr_accessor :foo
+
+        def finalize!
+          @foo = "SET"
+        end
+      end
+
+      map = { foo: foo_class }
+      instance = described_class.new(map)
+      instance.finalize!
+
+      expect(instance.foo.foo).to eq("SET")
+    end
+
+    it "should call #_finalize!" do
+      klass = Class.new(Vagrant.plugin("2", "config"))
+
+      expect_any_instance_of(klass).to receive(:finalize!)
+      expect_any_instance_of(klass).to receive(:_finalize!)
+
+      map = { foo: klass }
+      instance = described_class.new(map)
+      instance.finalize!
+    end
+  end
+
+  describe "validation" do
+    let(:instance) do
+      map = { foo: Object, bar: Object }
+      described_class.new(map)
+    end
+
+    it "should return nil if valid" do
+      expect(instance.validate({})).to eq({})
+    end
+
+    it "should return errors if invalid" do
+      errors = { "foo" => ["errors!"] }
+      env    = { "errors" => errors }
+      foo    = instance.foo
+      def foo.validate(env)
+        env["errors"]
+      end
+
+      expect(instance.validate(env)).to eq(errors)
+    end
+
+    it "should merge errors via array concat if matching keys" do
+      errors = { "foo" => ["errors!"] }
+      env    = { "errors" => errors }
+      foo    = instance.foo
+      bar    = instance.bar
+      def foo.validate(env)
+        env["errors"]
+      end
+
+      def bar.validate(env)
+        env["errors"].merge({ "bar" => ["bar"] })
+      end
+
+      expected_errors = {
+        "foo" => ["errors!", "errors!"],
+        "bar" => ["bar"]
+      }
+
+      expect(instance.validate(env)).to eq(expected_errors)
+    end
+
+    it "shouldn't count empty keys" do
+      errors = { "foo" => [] }
+      env    = { "errors" => errors }
+      foo    = instance.foo
+      def foo.validate(env)
+        env["errors"]
+      end
+
+      expect(instance.validate(env)).to eq({})
+    end
+  end
+end

data/vendor/bundle/ruby/2.3.0/bundler/gems/vagrant-419afb4dcffe/test/unit/vagrant/config/v2/util_test.rb

@@ -0,0 +1,21 @@
+require File.expand_path("../../../../base", __FILE__)
+
+require "vagrant/config/v2/util"
+
+describe Vagrant::Config::V2::Util do
+  describe "merging errors" do
+    it "should merge matching keys and leave the rest alone" do
+      first  = { "one" => ["foo"], "two" => ["two"] }
+      second = { "one" => ["bar"], "three" => ["three"] }
+
+      expected = {
+        "one" => ["foo", "bar"],
+        "two" => ["two"],
+        "three" => ["three"]
+      }
+
+      result = described_class.merge_errors(first, second)
+      expect(result).to eq(expected)
+    end
+  end
+end

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

@@ -0,0 +1,91 @@
+require File.expand_path("../../base", __FILE__)
+
+describe Vagrant::Config do
+  it "should not execute the proc on configuration" do
+    described_class.run do
+      raise Exception, "Failure."
+    end
+  end
+
+  it "should capture calls to `Vagrant.configure`" do
+    receiver = double()
+
+    procs = described_class.capture_configures do
+      Vagrant.configure("1") do
+        receiver.one
+      end
+
+      Vagrant.configure("2") do
+        receiver.two
+      end
+    end
+
+    expect(procs).to be_kind_of(Array)
+    expect(procs.length).to eq(2)
+    expect(procs[0][0]).to eq("1")
+    expect(procs[1][0]).to eq("2")
+
+    # Verify the proper procs were captured
+    expect(receiver).to receive(:one).once.ordered
+    expect(receiver).to receive(:two).once.ordered
+    procs[0][1].call
+    procs[1][1].call
+  end
+
+  it "should work with integer configurations "do
+    receiver = double()
+
+    procs = described_class.capture_configures do
+      Vagrant.configure(1) do
+        receiver.one
+      end
+
+      Vagrant.configure("2") do
+        receiver.two
+      end
+    end
+
+    expect(procs).to be_kind_of(Array)
+    expect(procs.length).to eq(2)
+    expect(procs[0][0]).to eq("1")
+    expect(procs[1][0]).to eq("2")
+
+    # Verify the proper procs were captured
+    expect(receiver).to receive(:one).once.ordered
+    expect(receiver).to receive(:two).once.ordered
+    procs[0][1].call
+    procs[1][1].call
+  end
+
+  it "should capture configuration procs" do
+    receiver = double()
+
+    procs = described_class.capture_configures do
+      described_class.run do
+        receiver.hello!
+      end
+    end
+
+    # Verify the structure of the result
+    expect(procs).to be_kind_of(Array)
+    expect(procs.length).to eq(1)
+
+    # Verify that the proper proc was captured
+    expect(receiver).to receive(:hello!).once
+    expect(procs[0][0]).to eq("1")
+    procs[0][1].call
+  end
+
+  it "should capture the proper version" do
+    procs = described_class.capture_configures do
+      described_class.run("1") {}
+      described_class.run("2") {}
+    end
+
+    # Verify the structure of the result
+    expect(procs).to be_kind_of(Array)
+    expect(procs.length).to eq(2)
+    expect(procs[0][0]).to eq("1")
+    expect(procs[1][0]).to eq("2")
+  end
+end