V2 config supports the concept of an "UNSET" value when doing merges

This value should be used as a default, and allows the parent `merge`
method to "just work" most of the time.
This commit is contained in:
Mitchell Hashimoto 2012-11-14 20:14:44 -08:00
parent b6c6614fd8
commit 99c5cddb7d
8 changed files with 636 additions and 1 deletions

View File

@ -5,6 +5,13 @@ module Vagrant
# V2. Any configuration key plugins for V2 should inherit from this
# class.
class Config
# This constant represents an unset value. This is useful so it is
# possible to know the difference between a configuration value that
# was never set, and a value that is nil (explicitly). Best practice
# is to initialize all variables to this value, then the {#merge}
# method below will "just work" in many cases.
UNSET_VALUE = Object.new
# This is called as a last-minute hook that allows the configuration
# object to finalize itself before it will be put into use. This is
# a useful place to do some defaults in the case the user didn't
@ -43,7 +50,9 @@ module Vagrant
# configuration classes to still hold around internal state
# that isn't propagated.
if !key.to_s.start_with?("@__")
result.instance_variable_set(key, obj.instance_variable_get(key))
# Don't set the value if it is the unset value, either.
value = obj.instance_variable_get(key)
result.instance_variable_set(key, value) if value != UNSET_VALUE
end
end
end

View File

@ -0,0 +1,142 @@
require File.expand_path("../../../../base", __FILE__)
require 'optparse'
describe Vagrant::Plugin::V2::Command do
describe "parsing options" do
let(:klass) do
Class.new(described_class) do
# Make the method public since it is normally protected
public :parse_options
end
end
it "returns the remaining arguments" do
options = {}
opts = OptionParser.new do |o|
o.on("-f") do |f|
options[:f] = f
end
end
result = klass.new(["-f", "foo"], nil).parse_options(opts)
# Check the results
options[:f].should be
result.should == ["foo"]
end
it "creates an option parser if none is given" do
result = klass.new(["foo"], nil).parse_options(nil)
result.should == ["foo"]
end
["-h", "--help"].each do |help_string|
it "returns nil and prints the help if '#{help_string}' is given" do
instance = klass.new([help_string], nil)
instance.should_receive(:safe_puts)
instance.parse_options(OptionParser.new).should be_nil
end
end
it "raises an error if invalid options are given" do
instance = klass.new(["-f"], nil)
expect { instance.parse_options(OptionParser.new) }.
to raise_error(Vagrant::Errors::CLIInvalidOptions)
end
end
describe "target VMs" do
let(:klass) do
Class.new(described_class) do
# Make the method public since it is normally protected
public :with_target_vms
end
end
let(:environment) do
env = double("environment")
env.stub(:root_path => "foo")
env
end
let(:instance) { klass.new([], environment) }
it "should raise an exception if a root_path is not available" do
environment.stub(:root_path => nil)
expect { instance.with_target_vms }.
to raise_error(Vagrant::Errors::NoEnvironmentError)
end
it "should yield every VM in order is no name is given" do
foo_vm = double("foo")
foo_vm.stub(:name).and_return("foo")
bar_vm = double("bar")
bar_vm.stub(:name).and_return("bar")
environment.stub(:machine_names => [:foo, :bar])
environment.stub(:machine).with(:foo, :virtualbox).and_return(foo_vm)
environment.stub(:machine).with(:bar, :virtualbox).and_return(bar_vm)
vms = []
instance.with_target_vms do |vm|
vms << vm
end
vms.should == [foo_vm, bar_vm]
end
it "raises an exception if the named VM doesn't exist" do
environment.stub(:machine_names => [:default])
environment.stub(:machine).with(:foo, anything).and_return(nil)
expect { instance.with_target_vms("foo") }.
to raise_error(Vagrant::Errors::VMNotFoundError)
end
it "yields the given VM if a name is given" do
foo_vm = double("foo")
environment.stub(:machine).with(:foo, :virtualbox).and_return(foo_vm)
vms = []
instance.with_target_vms("foo") { |vm| vms << vm }
vms.should == [foo_vm]
end
end
describe "splitting the main and subcommand args" do
let(:instance) do
Class.new(described_class) do
# Make the method public since it is normally protected
public :split_main_and_subcommand
end.new(nil, nil)
end
it "should work when given all 3 parts" do
result = instance.split_main_and_subcommand(["-v", "status", "-h", "-v"])
result.should == [["-v"], "status", ["-h", "-v"]]
end
it "should work when given only a subcommand and args" do
result = instance.split_main_and_subcommand(["status", "-h"])
result.should == [[], "status", ["-h"]]
end
it "should work when given only main flags" do
result = instance.split_main_and_subcommand(["-v", "-h"])
result.should == [["-v", "-h"], nil, []]
end
it "should work when given only a subcommand" do
result = instance.split_main_and_subcommand(["status"])
result.should == [[], "status", []]
end
it "works when there are other non-flag args after the subcommand" do
result = instance.split_main_and_subcommand(["-v", "box", "add", "-h"])
result.should == [["-v"], "box", ["add", "-h"]]
end
end
end

View File

@ -0,0 +1,9 @@
require File.expand_path("../../../../base", __FILE__)
describe Vagrant::Plugin::V2::Communicator do
let(:machine) { Object.new }
it "should not match by default" do
described_class.match?(machine).should_not be
end
end

View File

@ -0,0 +1,60 @@
require File.expand_path("../../../../base", __FILE__)
describe Vagrant::Plugin::V2::Config do
include_context "unit"
let(:foo_class) do
Class.new(described_class) do
attr_accessor :one
attr_accessor :two
end
end
let(:unset_value) { described_class.const_get("UNSET_VALUE") }
describe "merging" do
it "should merge by default by simply copying each instance variable" do
one = foo_class.new
one.one = 2
one.two = 1
two = foo_class.new
two.two = 5
result = one.merge(two)
result.one.should == 2
result.two.should == 5
end
it "prefers any set value over an UNSET_VALUE" do
one = foo_class.new
one.one = 1
one.two = 2
two = foo_class.new
two.one = unset_value
two.two = 5
result = one.merge(two)
result.one.should == 1
result.two.should == 5
end
it "doesn't merge values that start with a double underscore" do
one = foo_class.new
one.one = 1
one.two = 1
one.instance_variable_set(:@__bar, "one")
two = foo_class.new
two.two = 2
two.instance_variable_set(:@__bar, "two")
# Merge and verify
result = one.merge(two)
result.one.should == 1
result.two.should == 2
result.instance_variable_get(:@__bar).should be_nil
end
end
end

View File

@ -0,0 +1,5 @@
require File.expand_path("../../../../base", __FILE__)
describe Vagrant::Plugin::V2::Host do
# No tests.
end

View File

@ -0,0 +1,114 @@
require File.expand_path("../../../../base", __FILE__)
describe Vagrant::Plugin::V2::Manager do
include_context "unit"
let(:instance) { described_class.new }
def plugin
p = Class.new(Vagrant.plugin("2"))
yield p
p
end
it "should enumerate registered communicator classes" do
pA = plugin do |p|
p.communicator("foo") { "bar" }
end
pB = plugin do |p|
p.communicator("bar") { "baz" }
end
instance.register(pA)
instance.register(pB)
instance.communicators.length.should == 2
instance.communicators[:foo].should == "bar"
instance.communicators[:bar].should == "baz"
end
it "should enumerate registered configuration classes" do
pA = plugin do |p|
p.config("foo") { "bar" }
end
pB = plugin do |p|
p.config("bar") { "baz" }
end
instance.register(pA)
instance.register(pB)
instance.config.length.should == 2
instance.config[:foo].should == "bar"
instance.config[:bar].should == "baz"
end
it "should enumerate registered upgrade safe config classes" do
pA = plugin do |p|
p.config("foo", true) { "bar" }
end
pB = plugin do |p|
p.config("bar") { "baz" }
end
instance.register(pA)
instance.register(pB)
instance.config_upgrade_safe.length.should == 1
instance.config_upgrade_safe[:foo].should == "bar"
end
it "should enumerate registered guest classes" do
pA = plugin do |p|
p.guest("foo") { "bar" }
end
pB = plugin do |p|
p.guest("bar") { "baz" }
end
instance.register(pA)
instance.register(pB)
instance.guests.length.should == 2
instance.guests[:foo].should == "bar"
instance.guests[:bar].should == "baz"
end
it "should enumerate registered host classes" do
pA = plugin do |p|
p.host("foo") { "bar" }
end
pB = plugin do |p|
p.host("bar") { "baz" }
end
instance.register(pA)
instance.register(pB)
instance.hosts.length.should == 2
instance.hosts[:foo].should == "bar"
instance.hosts[:bar].should == "baz"
end
it "should enumerate registered provider classes" do
pA = plugin do |p|
p.provider("foo") { "bar" }
end
pB = plugin do |p|
p.provider("bar") { "baz" }
end
instance.register(pA)
instance.register(pB)
instance.providers.length.should == 2
instance.providers[:foo].should == "bar"
instance.providers[:bar].should == "baz"
end
end

View File

@ -0,0 +1,278 @@
require File.expand_path("../../../../base", __FILE__)
describe Vagrant::Plugin::V2::Plugin do
after(:each) do
# We want to make sure that the registered plugins remains empty
# after each test.
described_class.manager.reset!
end
it "should be able to set and get the name" do
plugin = Class.new(described_class) do
name "foo"
end
plugin.name.should == "foo"
end
it "should be able to set and get the description" do
plugin = Class.new(described_class) do
description "bar"
end
plugin.description.should == "bar"
end
describe "action hooks" do
it "should register action hooks" do
plugin = Class.new(described_class) do
action_hook("foo") { "bar" }
end
hooks = plugin.action_hook("foo")
hooks.length.should == 1
hooks[0].call.should == "bar"
end
end
describe "commands" do
it "should register command classes" do
plugin = Class.new(described_class) do
command("foo") { "bar" }
end
plugin.command[:foo].should == "bar"
end
["spaces bad", "sym^bols"].each do |bad|
it "should not allow bad command name: #{bad}" do
plugin = Class.new(described_class)
expect { plugin.command(bad) {} }.
to raise_error(Vagrant::Plugin::V2::InvalidCommandName)
end
end
it "should lazily register command classes" do
# Below would raise an error if the value of the command class was
# evaluated immediately. By asserting that this does not raise an
# error, we verify that the value is actually lazily loaded
plugin = nil
expect {
plugin = Class.new(described_class) do
command("foo") { raise StandardError, "FAIL!" }
end
}.to_not raise_error
# Now verify when we actually get the command key that
# a proper error is raised.
expect {
plugin.command[:foo]
}.to raise_error(StandardError)
end
end
describe "communicators" do
it "should register communicator classes" do
plugin = Class.new(described_class) do
communicator("foo") { "bar" }
end
plugin.communicator[:foo].should == "bar"
end
it "should lazily register communicator classes" do
# Below would raise an error if the value of the class was
# evaluated immediately. By asserting that this does not raise an
# error, we verify that the value is actually lazily loaded
plugin = nil
expect {
plugin = Class.new(described_class) do
communicator("foo") { raise StandardError, "FAIL!" }
end
}.to_not raise_error
# Now verify when we actually get the configuration key that
# a proper error is raised.
expect {
plugin.communicator[:foo]
}.to raise_error(StandardError)
end
end
describe "configuration" do
it "should register configuration classes" do
plugin = Class.new(described_class) do
config("foo") { "bar" }
end
plugin.config[:foo].should == "bar"
end
it "should lazily register configuration classes" do
# Below would raise an error if the value of the config class was
# evaluated immediately. By asserting that this does not raise an
# error, we verify that the value is actually lazily loaded
plugin = nil
expect {
plugin = Class.new(described_class) do
config("foo") { raise StandardError, "FAIL!" }
end
}.to_not raise_error
# Now verify when we actually get the configuration key that
# a proper error is raised.
expect {
plugin.config[:foo]
}.to raise_error(StandardError)
end
end
describe "easy commands" do
it "should register with the commands" do
plugin = Class.new(described_class) do
easy_command("foo") {}
end
# Check that the command class subclasses the easy command base
plugin.command[:foo].should < Vagrant::Easy::CommandBase
end
end
describe "guests" do
it "should register guest classes" do
plugin = Class.new(described_class) do
guest("foo") { "bar" }
end
plugin.guest[:foo].should == "bar"
end
it "should lazily register guest classes" do
# Below would raise an error if the value of the guest class was
# evaluated immediately. By asserting that this does not raise an
# error, we verify that the value is actually lazily loaded
plugin = nil
expect {
plugin = Class.new(described_class) do
guest("foo") { raise StandardError, "FAIL!" }
end
}.to_not raise_error
# Now verify when we actually get the guest key that
# a proper error is raised.
expect {
plugin.guest[:foo]
}.to raise_error(StandardError)
end
end
describe "hosts" do
it "should register host classes" do
plugin = Class.new(described_class) do
host("foo") { "bar" }
end
plugin.host[:foo].should == "bar"
end
it "should lazily register host classes" do
# Below would raise an error if the value of the host class was
# evaluated immediately. By asserting that this does not raise an
# error, we verify that the value is actually lazily loaded
plugin = nil
expect {
plugin = Class.new(described_class) do
host("foo") { raise StandardError, "FAIL!" }
end
}.to_not raise_error
# Now verify when we actually get the host key that
# a proper error is raised.
expect {
plugin.host[:foo]
}.to raise_error(StandardError)
end
end
describe "providers" do
it "should register provider classes" do
plugin = Class.new(described_class) do
provider("foo") { "bar" }
end
plugin.provider[:foo].should == "bar"
end
it "should lazily register provider classes" do
# Below would raise an error if the value of the config class was
# evaluated immediately. By asserting that this does not raise an
# error, we verify that the value is actually lazily loaded
plugin = nil
expect {
plugin = Class.new(described_class) do
provider("foo") { raise StandardError, "FAIL!" }
end
}.to_not raise_error
# Now verify when we actually get the configuration key that
# a proper error is raised.
expect {
plugin.provider[:foo]
}.to raise_error(StandardError)
end
end
describe "provisioners" do
it "should register provisioner classes" do
plugin = Class.new(described_class) do
provisioner("foo") { "bar" }
end
plugin.provisioner[:foo].should == "bar"
end
it "should lazily register provisioner classes" do
# Below would raise an error if the value of the config class was
# evaluated immediately. By asserting that this does not raise an
# error, we verify that the value is actually lazily loaded
plugin = nil
expect {
plugin = Class.new(described_class) do
provisioner("foo") { raise StandardError, "FAIL!" }
end
}.to_not raise_error
# Now verify when we actually get the configuration key that
# a proper error is raised.
expect {
plugin.provisioner[:foo]
}.to raise_error(StandardError)
end
end
describe "plugin registration" do
let(:manager) { described_class.manager }
it "should have no registered plugins" do
manager.registered.should be_empty
end
it "should register a plugin when a name is set" do
plugin = Class.new(described_class) do
name "foo"
end
manager.registered.should == [plugin]
end
it "should register a plugin only once" do
plugin = Class.new(described_class) do
name "foo"
name "bar"
end
manager.registered.should == [plugin]
end
end
end

View File

@ -0,0 +1,18 @@
require File.expand_path("../../../../base", __FILE__)
describe Vagrant::Plugin::V2::Provider do
let(:machine) { Object.new }
let(:instance) { described_class.new(machine) }
it "should return nil by default for actions" do
instance.action(:whatever).should be_nil
end
it "should return nil by default for ssh info" do
instance.ssh_info.should be_nil
end
it "should return nil by default for state" do
instance.state.should be_nil
end
end