vagrant-softlayer 0.3.3 → 0.4.0

data/lib/vagrant-softlayer/util/load_balancer.rb

@@ -1,103 +1,96 @@
-module VagrantPlugins
-  module SoftLayer
-    module Util
-      # This mixin contains utility methods for load balancer management.
-      module LoadBalancer
-        # Whether load balancer management is enabled or not.
-        def enabled?
-          if @env[:machine].provider_config.load_balancers.empty?
-            @logger.debug("No load balancer has been defined. Going ahead.")
-            return false
-          end
-
-          # Currently we don't do load balancing for private machines.
-          if @env[:machine].provider_config.private_only
-            @logger.info("Load balancing doesn't work for private machines. Going ahead.")
-            return false
-          end
-          true
-        end
-
-        # Get existing stuff.
-        def read_load_balancers
-          mask    = [
-            "id",
-            "ipAddress.ipAddress",
-            "virtualServers.serviceGroups.services.groupReferences",
-            "virtualServers.serviceGroups.services.healthChecks"
-          ]
-          @logger.debug("Looking for existing load balancers.")
-          @load_balancers = sl_warden { @services["Account"].object_mask(mask).getAdcLoadBalancers }
-          @logger.debug("Got load balancer configuration:")
-          @logger.debug("-- #{@load_balancers}")
-        end
-
-        # For each load balancer, check if total connections
-        # are less than 100% and, if so, rebalance the allocations.
-        def rebalance!
-          read_load_balancers
-          
-          @load_balancers.each do |load_balancer|
-            next if load_balancer["virtualServers"].empty?
-            next if 100 == load_balancer["virtualServers"].inject(0) { |sum, vs| sum += vs["allocation"] }
-
-            # Create allocation slots.
-            count      = load_balancer["virtualServers"].count
-            allocation = [100 / count] * count
-            (100 % count).times { |i| allocation[i] += 1 }
-
-            # Rebalance allocations.
-            load_balancer["virtualServers"].each do |vs|
-              vs["allocation"] = allocation.pop
-            end
-
-            # Update the VIP object.
-            @logger.debug("Rebalancing VIP #{load_balancer['id']}")
-            @logger.debug("-- #{load_balancer}")
-            @services["VirtualIpAddress"].object_with_id(load_balancer["id"]).editObject("virtualServers" => load_balancer["virtualServers"])
-          end
-        end
-
-        # Initial setup.
-        def setup
-          # A plethora of service objects is required for managing
-          # load balancers. We instanciate'em all here.
-          @services = {
-            "Account" => ::SoftLayer::Service.new("SoftLayer_Account", @env[:sl_credentials])
-          }
-          [
-            "Health_Check_Type",
-            "Routing_Method",
-            "Routing_Type",
-            "Service",
-            "Service_Group",
-            "VirtualIpAddress",
-            "VirtualServer"
-          ].each do |service|
-            @services[service] = ::SoftLayer::Service.new(
-              "SoftLayer_Network_Application_Delivery_Controller_LoadBalancer_#{service}",
-              @env[:sl_credentials]
-            )
-          end
-
-          # We create enumerations for the various configurables.
-          @enums = {}
-          [
-            "Health_Check_Type",
-            "Routing_Method",
-            "Routing_Type"
-          ].each do |service|
-            {}.tap do |enum|
-              sl_warden { @services[service].getAllObjects }.each do |record|
-                enum[record["name"].upcase] = record["id"]
-              end
-              @enums[service] = enum
-            end
-          end
-
-          read_load_balancers
-        end
-      end
-    end
-  end
-end
+module VagrantPlugins
+  module SoftLayer
+    module Util
+      # This mixin contains utility methods for load balancer management.
+      module LoadBalancer
+        # Whether load balancer management is enabled or not.
+        def enabled?
+          if @env[:machine].provider_config.load_balancers.empty?
+            @logger.debug("No load balancer has been defined. Going ahead.")
+            return false
+          end
+
+          # Currently we don't do load balancing for private machines.
+          if @env[:machine].provider_config.private_only
+            @logger.info("Load balancing doesn't work for private machines. Going ahead.")
+            return false
+          end
+          true
+        end
+
+        # Get existing stuff.
+        def read_load_balancers
+          mask    = [
+            "id",
+            "ipAddress.ipAddress",
+            "virtualServers.serviceGroups.services.groupReferences",
+            "virtualServers.serviceGroups.services.healthChecks"
+          ].join(",")
+          @logger.debug("Looking for existing load balancers.")
+          @load_balancers = sl_warden { @services["Account"].object_mask("mask[#{mask}]").getAdcLoadBalancers }
+          @logger.debug("Got load balancer configuration:")
+          @logger.debug("-- #{@load_balancers}")
+        end
+
+        # For each load balancer, check if total connections
+        # are less than 100% and, if so, rebalance the allocations.
+        def rebalance!
+          read_load_balancers
+          
+          @load_balancers.each do |load_balancer|
+            next if load_balancer["virtualServers"].empty?
+            next if 100 == load_balancer["virtualServers"].inject(0) { |sum, vs| sum += vs["allocation"] }
+
+            # Create allocation slots.
+            count      = load_balancer["virtualServers"].count
+            allocation = [100 / count] * count
+            (100 % count).times { |i| allocation[i] += 1 }
+
+            # Rebalance allocations.
+            load_balancer["virtualServers"].each do |vs|
+              vs["allocation"] = allocation.pop
+            end
+
+            # Update the VIP object.
+            @logger.debug("Rebalancing VIP #{load_balancer['id']}")
+            @logger.debug("-- #{load_balancer}")
+            @services["VirtualIpAddress"].object_with_id(load_balancer["id"]).editObject("virtualServers" => load_balancer["virtualServers"])
+          end
+        end
+
+        # Initial setup.
+        def setup
+          # A plethora of service objects is required for managing
+          # load balancers. We instanciate'em all here.
+          @services = { "Account" => @env[:sl_client]["SoftLayer_Account"] }
+          [
+            "Health_Check_Type",
+            "Routing_Method",
+            "Routing_Type",
+            "Service",
+            "Service_Group",
+            "VirtualIpAddress",
+            "VirtualServer"
+          ].each { |service| @services[service] = @env[:sl_client]["SoftLayer_Network_Application_Delivery_Controller_LoadBalancer_#{service}"] }
+
+          # We create enumerations for the various configurables.
+          @enums = {}
+          [
+            "Health_Check_Type",
+            "Routing_Method",
+            "Routing_Type"
+          ].each do |service|
+            {}.tap do |enum|
+              sl_warden { @services[service].getAllObjects }.each do |record|
+                enum[record["name"].upcase] = record["id"]
+              end
+              @enums[service] = enum
+            end
+          end
+
+          read_load_balancers
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-softlayer/util/network.rb

@@ -1,75 +1,75 @@
-module VagrantPlugins
-  module SoftLayer
-    module Util
-      module Network
-        # Gets hostname of the instance starting from the environment.
-        def hostname(env)
-          env[:machine].provider_config.hostname || env[:machine].config.vm.hostname
-        end
-
-        # Gets IP address of the instance starting from the environment.
-        #
-        # Returns the private IP address if the instance has been
-        # defined as private only, the public IP address otherwise.
-        def ip_address(env)
-          ip_address_record(env)[:address]
-        end
-
-        # Gets IP address ID of the instance starting from the environment.
-        #
-        # Returns the private IP address ID if the instance has been
-        # defined as private only, the public IP address ID otherwise.
-        def ip_address_id(env)
-          ip_address_record(env)[:id]
-        end
-
-        # Gets IP address record of the instance starting from the environment.
-        #
-        # Returns an hash with the following structure:
-        #
-        # :address
-        # :id
-        #
-        # Returns the private IP address record if the instance has been
-        # defined as private only, the public IP address record otherwise
-        # unless the force_private_ip override is true.
-        def ip_address_record(env)
-          data_type = env[:machine].provider_config.private_only ? "primaryBackendNetworkComponent" : "primaryNetworkComponent"
-          data_type = "primaryBackendNetworkComponent" if env[:machine].provider_config.force_private_ip
-          mask      = { data_type => { "primaryIpAddressRecord" => ["id", "ipAddress"] } }
-          record    = sl_warden { env[:sl_machine].object_mask(mask).getObject }
-          return {
-            :address => record[data_type]["primaryIpAddressRecord"]["ipAddress"],
-            :id      => record[data_type]["primaryIpAddressRecord"]["id"]
-          }
-        end
-
-        # Returns SSH keys starting from the configuration parameter.
-        #
-        # In the configuration, each key could be passed either as an
-        # id or as a label. The routine will detect this and lookup
-        # the id if needed.
-        #
-        # The first parameter is the current environment.
-        #
-        # The second parameter is useful for returning: if it is set
-        # the routine will return just the array of ids (this is needed,
-        # as an example, for reloading OS), otherwise an hash is
-        # returned (this latter case is needed instead for creating
-        # an instance).
-        def ssh_keys(env, ids_only = false)
-          account  = ::SoftLayer::Service.new("SoftLayer_Account", env[:sl_credentials])
-          acc_keys = sl_warden { account.object_mask("id", "label").getSshKeys }
-          key_ids  = []
-          Array(env[:machine].provider_config.ssh_key).each do |key|
-            pattern = key.is_a?(String) ? "label" : "id"
-            key_hash = acc_keys.find { |acc_key| acc_key[pattern] == key }
-            raise Errors::SLSshKeyNotFound, :key => key unless key_hash
-            key_ids << key_hash["id"]
-          end
-          return (ids_only ? key_ids : key_ids.map { |key_id| { :id => key_id } })
-        end
-      end
-    end
-  end
-end
+module VagrantPlugins
+  module SoftLayer
+    module Util
+      module Network
+        # Gets hostname of the instance starting from the environment.
+        def hostname(env)
+          env[:machine].provider_config.hostname || env[:machine].config.vm.hostname
+        end
+
+        # Gets IP address of the instance starting from the environment.
+        #
+        # Returns the private IP address if the instance has been
+        # defined as private only, the public IP address otherwise.
+        def ip_address(env)
+          ip_address_record(env)[:address]
+        end
+
+        # Gets IP address ID of the instance starting from the environment.
+        #
+        # Returns the private IP address ID if the instance has been
+        # defined as private only, the public IP address ID otherwise.
+        def ip_address_id(env)
+          ip_address_record(env)[:id]
+        end
+
+        # Gets IP address record of the instance starting from the environment.
+        #
+        # Returns an hash with the following structure:
+        #
+        # :address
+        # :id
+        #
+        # Returns the private IP address record if the instance has been
+        # defined as private only, the public IP address record otherwise
+        # unless the force_private_ip override is true.
+        def ip_address_record(env)
+          data_type = env[:machine].provider_config.private_only ? "primaryBackendNetworkComponent" : "primaryNetworkComponent"
+          data_type = "primaryBackendNetworkComponent" if env[:machine].provider_config.force_private_ip
+          mask      = "#{data_type}.primaryIpAddressRecord.id,#{data_type}.primaryIpAddressRecord.ipAddress"
+          record    = sl_warden { env[:sl_machine].object_mask("mask[#{mask}]").getObject }
+          return {
+            :address => record[data_type]["primaryIpAddressRecord"]["ipAddress"],
+            :id      => record[data_type]["primaryIpAddressRecord"]["id"]
+          }
+        end
+
+        # Returns SSH keys starting from the configuration parameter.
+        #
+        # In the configuration, each key could be passed either as an
+        # id or as a label. The routine will detect this and lookup
+        # the id if needed.
+        #
+        # The first parameter is the current environment.
+        #
+        # The second parameter is useful for returning: if it is set
+        # the routine will return just the array of ids (this is needed,
+        # as an example, for reloading OS), otherwise an hash is
+        # returned (this latter case is needed instead for creating
+        # an instance).
+        def ssh_keys(env, ids_only = false)
+          account  = env[:sl_client]["SoftLayer_Account"]
+          acc_keys = sl_warden { account.object_mask("mask[id,label]").getSshKeys }
+          key_ids  = []
+          Array(env[:machine].provider_config.ssh_key).each do |key|
+            pattern = key.is_a?(String) ? "label" : "id"
+            key_hash = acc_keys.find { |acc_key| acc_key[pattern] == key }
+            raise Errors::SLSshKeyNotFound, :key => key unless key_hash
+            key_ids << key_hash["id"]
+          end
+          return (ids_only ? key_ids : key_ids.map { |key_id| { :id => key_id } })
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-softlayer/util/warden.rb

@@ -1,38 +1,38 @@
-module VagrantPlugins
-  module SoftLayer
-    module Util
-      module Warden
-        # Handles gracefully SoftLayer API calls.
-        #
-        # The block code is executed, catching both common
-        # connection errors and API exceptions.
-        #
-        # Optionally, in the not-so-uncommon case when
-        # the object (e.g. the SoftLayer instance) is not
-        # found, executes a proc and/or retry the API call
-        # after some seconds.
-        #
-        # A future version of the method will add a retry timeout.
-        def sl_warden(rescue_proc = nil, retry_interval = 0, &block)
-          begin
-            yield
-          rescue ::OpenSSL::SSL::SSLError
-            raise Errors::SLCertificateError
-          rescue SocketError, ::SoftLayer::SoftLayerAPIException => e
-            if e.class == ::SoftLayer::SoftLayerAPIException && (e.message.start_with?("Unable to find object") || e.message.start_with?("Object does not exist"))
-              out = rescue_proc.call if rescue_proc
-              if retry_interval > 0
-                sleep retry_interval
-                retry
-              else
-                return out
-              end
-            else
-              raise Errors::SLApiError, :class => e.class, :message => e.message
-            end
-          end
-        end
-      end
-    end
-  end
-end
+module VagrantPlugins
+  module SoftLayer
+    module Util
+      module Warden
+        # Handles gracefully SoftLayer API calls.
+        #
+        # The block code is executed, catching both common
+        # connection errors and API exceptions.
+        #
+        # Optionally, in the not-so-uncommon case when
+        # the object (e.g. the SoftLayer instance) is not
+        # found, executes a proc and/or retry the API call
+        # after some seconds.
+        #
+        # A future version of the method will add a retry timeout.
+        def sl_warden(rescue_proc = nil, retry_interval = 0, &block)
+          begin
+            yield
+          rescue ::OpenSSL::SSL::SSLError
+            raise Errors::SLCertificateError
+          rescue Exception => e
+            if e.class != SocketError && (e.message.start_with?("Unable to find object") || e.message.start_with?("Object does not exist"))
+              out = rescue_proc.call if rescue_proc
+              if retry_interval > 0
+                sleep retry_interval
+                retry
+              else
+                return out
+              end
+            else
+              raise Errors::SLApiError, :class => e.class, :message => e.message
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-softlayer/version.rb

@@ -1,5 +1,5 @@
-module VagrantPlugins
-  module SoftLayer
-    VERSION = "0.3.3"
-  end
-end
+module VagrantPlugins
+  module SoftLayer
+    VERSION = "0.4.0"
+  end
+end

data/spec/vagrant-softlayer/config_spec.rb

@@ -1,267 +1,271 @@
-require "spec_helper"
-
-describe VagrantPlugins::SoftLayer::Config do
-  let(:config)  { described_class.new }
-  let(:machine) { double("machine") }
-
-  describe "defaults" do
-    subject do
-      config.tap do |o|
-        o.finalize!
-      end
-    end
-
-    its("api_key")      { should be_nil }
-    its("endpoint_url") { should eq VagrantPlugins::SoftLayer::API_PUBLIC_ENDPOINT }
-    its("username")     { should be_nil }
-
-    its("datacenter")        { should be_nil }
-    its("dedicated")         { should be_false }
-    its("disk_capacity")     { should be_nil }
-    its("domain")            { should be_nil }
-    its("force_private_ip")  { should be_false }
-    its("hostname")          { should be_nil }
-    its("hourly_billing")    { should be_true }
-    its("image_guid")        { should be_nil }
-    its("local_disk")        { should be_true }
-    its("max_memory")        { should eq 1024 }
-    its("network_speed")     { should eq 10 }
-    its("operating_system")  { should eq "UBUNTU_LATEST" }
-    its("post_install")      { should be_nil }
-    its("private_only")      { should be_false }
-    its("provision_timeout") { should eq 1200 }
-    its("rebuild_timeout")   { should eq 1200 }
-    its("ssh_key")           { should be_nil }
-    its("start_cpus")        { should eq 1 }
-    its("user_data")         { should be_nil }
-    its("vlan_private")      { should be_nil }
-    its("vlan_public")       { should be_nil }
-
-    its("load_balancers") { should eq [] }
-    its("manage_dns")     { should be_false }
-  end
-
-  describe "overriding defaults" do
-    context "booleans" do
-      [true, false].each do |bool|
-        [:dedicated, :force_private_ip, :hourly_billing, :local_disk, :manage_dns, :private_only].each do |attribute|
-          it "should accept both true and false for #{attribute}" do
-            config.send("#{attribute}=".to_sym, bool)
-            config.finalize!
-            expect(config.send(attribute)).to eq bool
-          end
-        end
-      end
-    end
-
-    context "integers" do
-      [:max_memory, :network_speed, :provision_timeout, :rebuild_timeout, :ssh_key, :start_cpus, :vlan_private, :vlan_public].each do |attribute|
-        it "should not default #{attribute} if overridden" do
-          config.send("#{attribute}=".to_sym, 999)
-          config.finalize!
-          expect(config.send(attribute)).to eq 999
-        end
-      end
-    end
-
-    context "strings" do
-      [:api_key, :datacenter, :endpoint_url, :username, :domain, :hostname, :image_guid, :operating_system, :post_install, :ssh_key, :user_data, :vlan_private, :vlan_public].each do |attribute|
-        it "should not default #{attribute} if overridden" do
-          config.send("#{attribute}=".to_sym, "foo")
-          config.finalize!
-          expect(config.send(attribute)).to eq "foo"
-        end
-      end
-    end
-
-    context "int hash" do
-      it "should not default disk_capacity if overriden" do
-        config.send("disk_capacity=".to_sym, { 0 => 100, 2 => 25 } )
-        config.finalize!
-        expect(config.send("disk_capacity")).to eq { 0 => 100, 2 => 25 }
-      end
-    end
-  end
-
-  describe "joining load balancer" do
-    it "should set weight to 1 by default" do
-      config.join_load_balancer :port => 443, :vip => "1.1.1.1"
-      config.finalize!
-      expect(config.load_balancers.first[:service].weight).to eq(1)
-    end
-
-    it "should set passed options" do
-      config.join_load_balancer :foo => "bar", :port => 443, :vip => "1.1.1.1"
-      config.finalize!
-      expect(config.load_balancers.first[:foo]).to eq("bar")
-    end
-
-    it "should set service parameters" do
-      config.join_load_balancer :port => 443, :vip => "1.1.1.1" do |srv|
-        srv.destination_port = 443
-        srv.health_check     = "DNS"
-        srv.notes            = "Some notes"
-        srv.weight           = 9
-      end
-      config.finalize!
-      expect(config.load_balancers.first[:service].destination_port).to eq(443)
-      expect(config.load_balancers.first[:service].health_check).to eq("DNS")
-      expect(config.load_balancers.first[:service].notes).to eq("Some notes")
-      expect(config.load_balancers.first[:service].weight).to eq(9)
-    end
-  end
-
-  describe "using SL_ environment variables" do
-    before :each do
-      ENV.stub(:[]).with("SL_API_KEY").and_return("env_api_key")
-      ENV.stub(:[]).with("SL_USERNAME").and_return("env_username")
-    end
-
-    subject do
-      config.tap do |o|
-        o.finalize!
-      end
-    end
-
-    its("api_key")  { should eq "env_api_key" }
-    its("username") { should eq "env_username" }
-  end
-
-  describe "validation" do
-    before :each do
-      # Setup some good configuration values
-      config.api_key  = "An API key"
-      config.username = "An username"
-
-      config.datacenter        = "ams01"
-      config.dedicated         = false
-      config.domain            = "example.com"
-      config.disk_capacity     = { 0 => 25 }
-      config.force_private_ip  = false
-      config.hostname          = "vagrant"
-      config.hourly_billing    = true
-      config.image_guid        = nil
-      config.local_disk        = true
-      config.max_memory        = 1024
-      config.network_speed     = 10
-      config.operating_system  = "UBUNTU_LATEST"
-      config.post_install      = "http://example.com/foo"
-      config.provision_timeout = 1200
-      config.rebuild_timeout   = 1200
-      config.ssh_key           = ["First key", "Second key"]
-      config.start_cpus        = 1
-      config.user_data         = "some metadata"
-      config.vlan_private      = 111
-      config.vlan_public       = 222
-
-      config.manage_dns        = false
-
-      machine.stub_chain(:config, :vm, :hostname).and_return(nil)
-    end
-
-    it "should validate" do
-      config.finalize!
-      expect(config.validate(machine)["SoftLayer"]).to have(:no).item
-    end
-
-    it "should fail if API key is not given" do
-      config.api_key = nil
-      config.finalize!
-      expect(config.validate(machine)["SoftLayer"]).to have(1).item
-    end
-
-    it "should fail if username is not given" do
-      config.username = nil
-      config.finalize!
-      expect(config.validate(machine)["SoftLayer"]).to have(1).item
-    end
-
-    it "should fail if domain is not given" do
-      config.domain = nil
-      config.finalize!
-      expect(config.validate(machine)["SoftLayer"]).to have(1).item
-    end
-
-    it "should fail if hostname is not given" do
-      config.hostname = nil
-      config.finalize!
-      expect(config.validate(machine)["SoftLayer"]).to have(1).item
-    end
-
-    it "should validate if hostname is not given but config.vm.hostname is set" do
-      config.hostname = nil
-      config.finalize!
-      machine.stub_chain(:config, :vm, :hostname).and_return("vagrant")
-      expect(config.validate(machine)["SoftLayer"]).to have(:no).item
-    end
-
-    it "should fail if ssh key is not given" do
-      config.ssh_key = nil
-      config.finalize!
-      expect(config.validate(machine)["SoftLayer"]).to have(1).item
-    end
-
-    it "should fail if a load balancer is specified without vip" do
-      config.join_load_balancer :port => 443 do |srv|
-        srv.destination_port = 443
-      end
-      config.finalize!
-      expect(config.validate(machine)["SoftLayer"]).to have(1).item
-    end
-
-    it "should fail if a load balancer is specified without port" do
-      config.join_load_balancer :vip => "1.1.1.1" do |srv|
-        srv.destination_port = 443
-      end
-      config.finalize!
-      expect(config.validate(machine)["SoftLayer"]).to have(1).item
-    end
-
-    it "should fail if a load balancer is specified without destination port" do
-      config.join_load_balancer :port => 443, :vip => "1.1.1.1"
-      config.finalize!
-      expect(config.validate(machine)["SoftLayer"]).to have(1).item
-    end
-
-    it "should fail if two load balancers han been defined with same vip and port" do
-      config.join_load_balancer :port => 443, :vip => "1.1.1.1" do |srv|
-        srv.destination_port = 443
-      end
-      config.join_load_balancer :port => 443, :vip => "1.1.1.1" do |srv|
-        srv.destination_port = 8443
-      end
-      config.finalize!
-      expect(config.validate(machine)["SoftLayer"]).to have(1).item
-    end
-
-    it "should validate if a load balancer if specified with vip, port and destination port" do
-      config.join_load_balancer :port => 443, :vip => "1.1.1.1" do |srv|
-        srv.destination_port = 443
-      end
-      config.finalize!
-      expect(config.validate(machine)["SoftLayer"]).to have(:no).item
-    end
-
-    it "should fail if disk_capacity and image_guid are both specified" do
-      config.disk_capacity = { 0 => 25 }
-      config.image_guid = "AAAAAAAA-BBBB-CCCC-DDDD-EEEEEEEEEEEE"
-      config.operating_system = nil
-      config.finalize!
-      expect(config.validate(machine)["SoftLayer"]).to have(1).item
-    end
-
-    it "should fail if operating system and image_guid are both specified" do
-      config.image_guid = "AAAAAAAA-BBBB-CCCC-DDDD-EEEEEEEEEEEE"
-      config.operating_system = "UBUNTU_LATEST"
-      config.finalize!
-      expect(config.validate(machine)["SoftLayer"]).to have(1).item
-    end
-
-    it "should validate if operating_system and disk_capacity are both specified" do
-      config.operating_system = "UBUNTU_LATEST"
-      config.disk_capacity = { 0 => 25 }
-      config.finalize!
-      expect(config.validate(machine)["SoftLayer"]).to have(:no).item
-    end
-  end
-end
+require "spec_helper"
+
+describe VagrantPlugins::SoftLayer::Config do
+  let(:config)  { described_class.new }
+  let(:machine) { double("machine") }
+
+  describe "defaults" do
+    subject do
+      config.tap do |o|
+        o.finalize!
+      end
+    end
+
+    its("api_key")      { should be_nil }
+    its("api_timeout")  { should eq 60 }
+    its("endpoint_url") { should eq VagrantPlugins::SoftLayer::API_PUBLIC_ENDPOINT }
+    its("username")     { should be_nil }
+
+    its("datacenter")        { should be_nil }
+    its("dedicated")         { should be_false }
+    its("disk_capacity")     { should be_nil }
+    its("domain")            { should be_nil }
+    its("force_private_ip")  { should be_false }
+    its("hostname")          { should be_nil }
+    its("hourly_billing")    { should be_true }
+    its("image_guid")        { should be_nil }
+    its("local_disk")        { should be_true }
+    its("max_memory")        { should eq 1024 }
+    its("network_speed")     { should eq 10 }
+    its("operating_system")  { should eq "UBUNTU_LATEST" }
+    its("post_install")      { should be_nil }
+    its("private_only")      { should be_false }
+    its("provision_timeout") { should eq 1200 }
+    its("rebuild_timeout")   { should eq 1200 }
+    its("ssh_key")           { should be_nil }
+    its("start_cpus")        { should eq 1 }
+    its("transaction_wait")  { should be_true }
+    its("user_data")         { should be_nil }
+    its("vlan_private")      { should be_nil }
+    its("vlan_public")       { should be_nil }
+
+    its("load_balancers") { should eq [] }
+    its("manage_dns")     { should be_false }
+  end
+
+  describe "overriding defaults" do
+    context "booleans" do
+      [true, false].each do |bool|
+        [:dedicated, :force_private_ip, :hourly_billing, :local_disk, :manage_dns, :private_only, :transaction_wait].each do |attribute|
+          it "should accept both true and false for #{attribute}" do
+            config.send("#{attribute}=".to_sym, bool)
+            config.finalize!
+            expect(config.send(attribute)).to eq bool
+          end
+        end
+      end
+    end
+
+    context "integers" do
+      [:api_timeout, :max_memory, :network_speed, :provision_timeout, :rebuild_timeout, :ssh_key, :start_cpus, :vlan_private, :vlan_public].each do |attribute|
+        it "should not default #{attribute} if overridden" do
+          config.send("#{attribute}=".to_sym, 999)
+          config.finalize!
+          expect(config.send(attribute)).to eq 999
+        end
+      end
+    end
+
+    context "strings" do
+      [:api_key, :datacenter, :endpoint_url, :username, :domain, :hostname, :image_guid, :operating_system, :post_install, :ssh_key, :user_data, :vlan_private, :vlan_public].each do |attribute|
+        it "should not default #{attribute} if overridden" do
+          config.send("#{attribute}=".to_sym, "foo")
+          config.finalize!
+          expect(config.send(attribute)).to eq "foo"
+        end
+      end
+    end
+
+    context "int hash" do
+      it "should not default disk_capacity if overriden" do
+        config.send("disk_capacity=".to_sym, { 0 => 100, 2 => 25 } )
+        config.finalize!
+        expect(config.send("disk_capacity")).to eq { 0 => 100, 2 => 25 }
+      end
+    end
+  end
+
+  describe "joining load balancer" do
+    it "should set weight to 1 by default" do
+      config.join_load_balancer :port => 443, :vip => "1.1.1.1"
+      config.finalize!
+      expect(config.load_balancers.first[:service].weight).to eq(1)
+    end
+
+    it "should set passed options" do
+      config.join_load_balancer :foo => "bar", :port => 443, :vip => "1.1.1.1"
+      config.finalize!
+      expect(config.load_balancers.first[:foo]).to eq("bar")
+    end
+
+    it "should set service parameters" do
+      config.join_load_balancer :port => 443, :vip => "1.1.1.1" do |srv|
+        srv.destination_port = 443
+        srv.health_check     = "DNS"
+        srv.notes            = "Some notes"
+        srv.weight           = 9
+      end
+      config.finalize!
+      expect(config.load_balancers.first[:service].destination_port).to eq(443)
+      expect(config.load_balancers.first[:service].health_check).to eq("DNS")
+      expect(config.load_balancers.first[:service].notes).to eq("Some notes")
+      expect(config.load_balancers.first[:service].weight).to eq(9)
+    end
+  end
+
+  describe "using SL_ environment variables" do
+    before :each do
+      ENV.stub(:[]).with("SL_API_KEY").and_return("env_api_key")
+      ENV.stub(:[]).with("SL_USERNAME").and_return("env_username")
+    end
+
+    subject do
+      config.tap do |o|
+        o.finalize!
+      end
+    end
+
+    its("api_key")  { should eq "env_api_key" }
+    its("username") { should eq "env_username" }
+  end
+
+  describe "validation" do
+    before :each do
+      # Setup some good configuration values
+      config.api_key     = "An API key"
+      config.api_timeout = 60
+      config.username    = "An username"
+
+      config.datacenter        = "ams01"
+      config.dedicated         = false
+      config.domain            = "example.com"
+      config.disk_capacity     = { 0 => 25 }
+      config.force_private_ip  = false
+      config.hostname          = "vagrant"
+      config.hourly_billing    = true
+      config.image_guid        = nil
+      config.local_disk        = true
+      config.max_memory        = 1024
+      config.network_speed     = 10
+      config.operating_system  = "UBUNTU_LATEST"
+      config.post_install      = "http://example.com/foo"
+      config.provision_timeout = 1200
+      config.rebuild_timeout   = 1200
+      config.ssh_key           = ["First key", "Second key"]
+      config.start_cpus        = 1
+      config.transaction_wait  = true
+      config.user_data         = "some metadata"
+      config.vlan_private      = 111
+      config.vlan_public       = 222
+
+      config.manage_dns        = false
+
+      machine.stub_chain(:config, :vm, :hostname).and_return(nil)
+    end
+
+    it "should validate" do
+      config.finalize!
+      expect(config.validate(machine)["SoftLayer"]).to have(:no).item
+    end
+
+    it "should fail if API key is not given" do
+      config.api_key = nil
+      config.finalize!
+      expect(config.validate(machine)["SoftLayer"]).to have(1).item
+    end
+
+    it "should fail if username is not given" do
+      config.username = nil
+      config.finalize!
+      expect(config.validate(machine)["SoftLayer"]).to have(1).item
+    end
+
+    it "should fail if domain is not given" do
+      config.domain = nil
+      config.finalize!
+      expect(config.validate(machine)["SoftLayer"]).to have(1).item
+    end
+
+    it "should fail if hostname is not given" do
+      config.hostname = nil
+      config.finalize!
+      expect(config.validate(machine)["SoftLayer"]).to have(1).item
+    end
+
+    it "should validate if hostname is not given but config.vm.hostname is set" do
+      config.hostname = nil
+      config.finalize!
+      machine.stub_chain(:config, :vm, :hostname).and_return("vagrant")
+      expect(config.validate(machine)["SoftLayer"]).to have(:no).item
+    end
+
+    it "should fail if ssh key is not given" do
+      config.ssh_key = nil
+      config.finalize!
+      expect(config.validate(machine)["SoftLayer"]).to have(1).item
+    end
+
+    it "should fail if a load balancer is specified without vip" do
+      config.join_load_balancer :port => 443 do |srv|
+        srv.destination_port = 443
+      end
+      config.finalize!
+      expect(config.validate(machine)["SoftLayer"]).to have(1).item
+    end
+
+    it "should fail if a load balancer is specified without port" do
+      config.join_load_balancer :vip => "1.1.1.1" do |srv|
+        srv.destination_port = 443
+      end
+      config.finalize!
+      expect(config.validate(machine)["SoftLayer"]).to have(1).item
+    end
+
+    it "should fail if a load balancer is specified without destination port" do
+      config.join_load_balancer :port => 443, :vip => "1.1.1.1"
+      config.finalize!
+      expect(config.validate(machine)["SoftLayer"]).to have(1).item
+    end
+
+    it "should fail if two load balancers han been defined with same vip and port" do
+      config.join_load_balancer :port => 443, :vip => "1.1.1.1" do |srv|
+        srv.destination_port = 443
+      end
+      config.join_load_balancer :port => 443, :vip => "1.1.1.1" do |srv|
+        srv.destination_port = 8443
+      end
+      config.finalize!
+      expect(config.validate(machine)["SoftLayer"]).to have(1).item
+    end
+
+    it "should validate if a load balancer if specified with vip, port and destination port" do
+      config.join_load_balancer :port => 443, :vip => "1.1.1.1" do |srv|
+        srv.destination_port = 443
+      end
+      config.finalize!
+      expect(config.validate(machine)["SoftLayer"]).to have(:no).item
+    end
+
+    it "should fail if disk_capacity and image_guid are both specified" do
+      config.disk_capacity = { 0 => 25 }
+      config.image_guid = "AAAAAAAA-BBBB-CCCC-DDDD-EEEEEEEEEEEE"
+      config.operating_system = nil
+      config.finalize!
+      expect(config.validate(machine)["SoftLayer"]).to have(1).item
+    end
+
+    it "should fail if operating system and image_guid are both specified" do
+      config.image_guid = "AAAAAAAA-BBBB-CCCC-DDDD-EEEEEEEEEEEE"
+      config.operating_system = "UBUNTU_LATEST"
+      config.finalize!
+      expect(config.validate(machine)["SoftLayer"]).to have(1).item
+    end
+
+    it "should validate if operating_system and disk_capacity are both specified" do
+      config.operating_system = "UBUNTU_LATEST"
+      config.disk_capacity = { 0 => 25 }
+      config.finalize!
+      expect(config.validate(machine)["SoftLayer"]).to have(:no).item
+    end
+  end
+end