boxgrinder-build 0.9.2 → 0.9.3

data/spec/plugins/base-plugin-spec.rb

@@ -43,7 +43,7 @@ module BoxGrinder
 
       @plugin = BasePlugin.new
       @plugin.should_receive(:merge_plugin_config)
-      @plugin.init(@config, @appliance_config, :plugin_info => {:name => :plugin_name, :full_name => "Amazon Simple Storage Service (Amazon S3)"}, :log => @log)
+      @plugin.init(@config, @appliance_config, {:name => :plugin_name, :full_name => "Amazon Simple Storage Service (Amazon S3)"}, :log => @log)
     end
 
     it "should be initialized after running init method" do
@@ -81,26 +81,32 @@ module BoxGrinder
       @plugin.instance_variable_get(:@dir).tmp.should == "build/path/plugin_name-plugin/tmp"
     end
 
-    it "should check if deliverables exists and return true" do
-      @plugin.register_deliverable(:disk => "disk")
-      @plugin.register_deliverable(:abc => "def")
-      @plugin.register_deliverable(:file => "a/path")
+    describe ".deliverables_exists?" do
+      it "should check if deliverables exists and return true" do
+        @plugin.register_deliverable(:disk => "disk")
+        @plugin.register_deliverable(:abc => "def")
+        @plugin.register_deliverable(:file => "a/path")
 
-      File.should_receive(:exists?).exactly(3).times.with(any_args()).and_return(true)
+        File.should_receive(:exists?).exactly(3).times.with(any_args()).and_return(true)
 
-      @plugin.deliverables_exists?.should == true
-    end
+        @plugin.deliverables_exists?.should == true
+      end
+
+      it "should check if deliverables exists and return false" do
+        @plugin.register_deliverable(:disk => "disk")
+        @plugin.register_deliverable(:abc => "def")
+        @plugin.register_deliverable(:file => "a/path")
 
-    it "should check if deliverables exists and return false" do
-      @plugin.register_deliverable(:disk => "disk")
-      @plugin.register_deliverable(:abc => "def")
-      @plugin.register_deliverable(:file => "a/path")
+        File.should_receive(:exists?).once.with(any_args()).and_return(true)
+        File.should_receive(:exists?).once.with(any_args()).and_return(false)
+        File.should_not_receive(:exists?)
 
-      File.should_receive(:exists?).once.with(any_args()).and_return(true)
-      File.should_receive(:exists?).once.with(any_args()).and_return(false)
-      File.should_not_receive(:exists?)
+        @plugin.deliverables_exists?.should == false
+      end
 
-      @plugin.deliverables_exists?.should == false
+      it "should return false if no deliverables are registerd" do
+        @plugin.deliverables_exists?.should == false
+      end
     end
 
     describe ".run" do
@@ -111,12 +117,12 @@ module BoxGrinder
         FileUtils.should_receive(:rm_rf).with("build/path/plugin_name-plugin/tmp")
         FileUtils.should_receive(:mkdir_p).with("build/path/plugin_name-plugin/tmp")
 
-        @plugin.should_receive(:execute).with('a', 3)
+        @plugin.should_receive(:execute)
 
         FileUtils.should_receive(:mv).with("build/path/plugin_name-plugin/tmp/disk", "build/path/plugin_name-plugin/disk")
         FileUtils.should_receive(:rm_rf).with("build/path/plugin_name-plugin/tmp")
 
-        @plugin.run('a', 3)
+        @plugin.run
       end
 
       it "should fail if OS is not supported" do

data/spec/plugins/delivery/ebs/ebs-plugin-spec.rb

@@ -17,6 +17,7 @@
 # 02110-1301 USA, or see the FSF site: http://www.fsf.org.
 
 require 'rubygems'
+require 'ostruct'
 require 'logger'
 require 'boxgrinder-build/plugins/delivery/ebs/ebs-plugin'
 require 'hashery/opencascade'
@@ -33,11 +34,11 @@ module BoxGrinder
 
       yield @plugin if block_given?
 
-      @config = mock('Config')
-      @config.stub!(:delivery_config).and_return({})
-      plugins = mock('Plugins')
-      plugins.stub!(:[]).with('ebs').and_return({})
-      @config.stub!(:[]).with(:plugins).and_return(plugins)
+      @config = Config.new('plugins' => { 'ebs' => {
+        'access_key' => 'access_key',
+        'secret_access_key' => 'secret_access_key',
+        'account_number' => '0000-0000-0000'
+      }})
 
       @appliance_config = mock('ApplianceConfig')
 
@@ -48,75 +49,48 @@ module BoxGrinder
       @appliance_config.stub!(:hardware).and_return(OpenCascade.new({:arch => 'x86_64', :base_arch => 'x86_64'}))
       @appliance_config.stub!(:path).and_return(OpenCascade.new({:build => '/a/build/path'}))
 
-      @plugin = @plugin.init(
+      @plugin.stub!(:validate)
+
+      @plugin.init(
           @config,
           @appliance_config,
-          :log => Logger.new('/dev/null'),
-          :plugin_info => {:class => BoxGrinder::EBSPlugin, :type => :delivery, :name => :ebs, :full_name => "Elastic Block Storage"},
-          :config_file => "#{File.dirname(__FILE__)}/ebs.yaml"
-      )
-
-      @plugin_config = @plugin.instance_variable_get(:@plugin_config).merge(
-          {
-              'access_key' => 'access_key',
-              'secret_access_key' => 'secret_access_key',
-              'bucket' => 'bucket',
-              'account_number' => '0000-0000-0000',
-              'cert_file' => '/path/to/cert/file',
-              'key_file' => '/path/to/key/file'
-          }
+          {:class => BoxGrinder::EBSPlugin, :type => :delivery, :name => :ebs, :full_name => "Elastic Block Storage"},
+          :log => LogHelper.new(:level => :trace, :type => :stdout)
       )
 
-      @plugin.instance_variable_set(:@plugin_config, @plugin_config)
+      @plugin_config = @config.plugins['ebs']
     end
 
     it "should register all operating systems with specific versions" do
-      Resolv.stub!(:getname).with("169.254.169.254").and_return([".ec2.internal"])
-
       prepare_plugin do |plugin|
-        avaibility_zone = mock('AZ')
-        avaibility_zone.should_receive(:string).and_return('avaibility-zone1')
-
-        plugin.should_receive(:open).with('http://169.254.169.254/latest/meta-data/placement/availability-zone').and_return(avaibility_zone)
+        plugin.instance_variable_set(:@current_availability_zone, 'us-east-1a')
       end
 
-      supportes_oses = @plugin.instance_variable_get(:@supported_oses)
+      supported_oses = @plugin.instance_variable_get(:@supported_oses)
 
-      supportes_oses.size.should == 2
-      supportes_oses.keys.sort.should == ['fedora', 'rhel']
-      supportes_oses['rhel'].should == ['6']
-      supportes_oses['fedora'].should == ['13', '14', '15']
+      supported_oses.size.should == 3
+      supported_oses.keys.sort.should == ['fedora', 'rhel', 'centos'].sort
+      supported_oses['rhel'].should == ['6']
+      supported_oses['fedora'].should == ['13', '14', '15']
+      supported_oses['centos'].should == ['5']
     end
 
     describe ".after_init" do
-      it "should set default avaibility zone to current one" do
-        Resolv.stub!(:getname).with("169.254.169.254").and_return([".ec2.internal"])
-
+      it "should set the region" do
         prepare_plugin do |plugin|
-          avaibility_zone = mock('AZ')
-          avaibility_zone.should_receive(:string).and_return('avaibility-zone1')
-
-          plugin.should_receive(:open).with('http://169.254.169.254/latest/meta-data/placement/availability-zone').and_return(avaibility_zone)
+          plugin.instance_variable_set(:@current_availability_zone, 'us-east-1a')
         end
 
-        @plugin.instance_variable_get(:@plugin_config)['availability_zone'].should == 'avaibility-zone1'
-      end
-
-      it "should not set default avaibility zone because we're not on EC2" do
-        Resolv.stub!(:getname).with("169.254.169.254").and_return(["bleh"])
-
-        prepare_plugin
-
-        @plugin.instance_variable_get(:@plugin_config)['availability_zone'].should == nil
+        @plugin.instance_variable_get(:@region).should == 'us-east-1'
       end
     end
 
-    describe '.already_registered?' do
+    describe '.ami_info' do
 
       it "should check if image is already registered and return false if there are no images registered for this account" do
         prepare_plugin { |plugin| plugin.stub!(:after_init) }
 
-        plugin_config = mock('PluginConfiig')
+        plugin_config = mock('PluginConfig')
         plugin_config.should_receive(:[]).with('account_number').and_return('0000-0000-0000')
 
         @plugin.instance_variable_set(:@plugin_config, plugin_config)
@@ -126,13 +100,13 @@ module BoxGrinder
 
         @plugin.instance_variable_set(:@ec2, ec2)
 
-        @plugin.already_registered?('aname').should == false
+        @plugin.ami_info('aname').should == false
       end
 
       it "should check if image is already registered and return false if there are no images with name aname_new" do
         prepare_plugin { |plugin| plugin.stub!(:after_init) }
 
-        plugin_config = mock('PluginConfiig')
+        plugin_config = mock('PluginConfig')
         plugin_config.should_receive(:[]).with('account_number').and_return('0000-0000-0000')
 
         @plugin.instance_variable_set(:@plugin_config, plugin_config)
@@ -142,15 +116,33 @@ module BoxGrinder
 
         @plugin.instance_variable_set(:@ec2, ec2)
 
-        @plugin.already_registered?('aname_new').should == false
+        @plugin.ami_info('aname_new').should == false
       end
 
-      it "should check if image is already registered and return true image is registered" do
-        Resolv.stub!(:getname).with("169.254.169.254").and_return([".ec2.internal"])
+      it "should return valid AMI information map for a single matching image when a valid imageId exists" do
+        prepare_plugin { |plugin| plugin.stub!(:after_init) }
+
+        plugin_config = mock('PluginConfig')
+        plugin_config.should_receive(:[]).with('account_number').and_return('0000-0000-0000')
+
+        @plugin.instance_variable_set(:@plugin_config, plugin_config)
+
+        ec2 = mock('EC2')
+        ec2.should_receive(:describe_images).with(:owner_id => '000000000000').and_return({'imagesSet' => {'item' => [{'name' => 'abc', 'imageId' => '1'}, {'name' => 'aname', 'imageId' => '2'}]}})
+
+        @plugin.instance_variable_set(:@ec2, ec2)
+
+        @plugin.ami_info('aname').should == {'name' => 'aname', 'imageId' => '2'}
+      end
+
+    end
 
+    describe '.already_registered?' do
+
+      it "should check if image is already registered and return true image is registered" do
         prepare_plugin { |plugin| plugin.stub!(:after_init) }
 
-        plugin_config = mock('PluginConfiig')
+        plugin_config = mock('PluginConfig')
         plugin_config.should_receive(:[]).with('account_number').and_return('0000-0000-0000')
 
         @plugin.instance_variable_set(:@plugin_config, plugin_config)
@@ -162,6 +154,7 @@ module BoxGrinder
 
         @plugin.already_registered?('aname').should == '2'
       end
+
     end
 
     it "should adjust fstab" do
@@ -195,20 +188,33 @@ module BoxGrinder
       @plugin.free_device_suffix.should == "g"
     end
 
-    it "should return true if on EC2" do
-      Resolv.stub!(:getname).with("169.254.169.254").and_return([".ec2.internal"])
-
-      prepare_plugin { |plugin| plugin.stub!(:after_init) }
-
-      @plugin.valid_platform?.should == true
-    end
+    describe ".valid_platform?" do
+      it "should return true if on EC2" do
+        prepare_plugin do |plugin|
+          plugin.stub!(:after_init)
+          plugin.stub!(:get_ec2_availability_zone).and_return("eu-west-1a")
+          plugin.stub!(:availability_zone_to_region).and_return("eu-west-1")
+        end
+        @plugin.valid_platform?.should == true
+      end
 
-    it "should return false if NOT on EC2" do
-      Resolv.stub!(:getname).with("169.254.169.254").and_return(["bleh"])
+      it "should return false if NOT on EC2" do
+        prepare_plugin do |plugin|
+          plugin.stub!(:after_init)
+          plugin.stub!(:get_ec2_availability_zone).and_raise(Timeout::Error)
+        end
+        @plugin.valid_platform?.should == false
+      end
 
-      prepare_plugin { |plugin| plugin.stub!(:after_init) }
+      it "should return false if the EC2 zone returned is not supported" do
+        prepare_plugin do |plugin|
+          plugin.stub!(:after_init)
+          plugin.stub!(:get_ec2_availability_zone).and_return("moon-west-7a")
+          plugin.stub!(:availability_zone_to_region).and_return("moon-west-7")
+        end
+        @plugin.valid_platform?.should == false
+      end
 
-      @plugin.valid_platform?.should == false
     end
 
     describe ".ebs_appliance_name" do
@@ -217,6 +223,25 @@ module BoxGrinder
         @plugin.ebs_appliance_name.should == "appliance_name/fedora/14/1.0/x86_64"
       end
 
+      it "should always return basic appliance name when overwrite is enabled, but snapshot is disabled" do
+        prepare_plugin { |plugin| plugin.stub!(:after_init) }
+        @plugin_config.merge!('overwrite' => true, 'snapshot' => false)
+        @plugin.ebs_appliance_name.should == "appliance_name/fedora/14/1.0/x86_64"
+      end
+
+      it "should still return a valid _initial_ snapshot appliance name, even if overwrite and snapshot are enabled on first ever run" do
+        prepare_plugin { |plugin| plugin.stub!(:after_init) }
+
+        @plugin_config.merge!('overwrite' => true, 'snapshot' => true)
+
+        ec2 = mock('EC2')
+        ec2.should_receive(:describe_images).once.with(:owner_id => '000000000000').and_return(nil)#should be nothing
+
+        @plugin.instance_variable_set(:@ec2, ec2)
+
+        @plugin.ebs_appliance_name.should == "appliance_name/fedora/14/1.0-SNAPSHOT-1/x86_64"
+      end
+
       it "should return 2nd snapshot of appliance" do
         prepare_plugin { |plugin| plugin.stub!(:after_init) }
 
@@ -232,6 +257,120 @@ module BoxGrinder
 
         @plugin.ebs_appliance_name.should == "appliance_name/fedora/14/1.0-SNAPSHOT-2/x86_64"
       end
+
+      it "should return the last snapshot name again when OVERWRITE is enabled" do
+        prepare_plugin { |plugin| plugin.stub!(:after_init) }
+
+        @plugin_config.merge!('snapshot' => true, 'overwrite' => true)
+
+        ec2 = mock('EC2')
+        ec2.should_receive(:describe_images).twice.with(:owner_id => '000000000000').and_return({'imagesSet' => {'item' => [
+            {'imageId' => '1', 'name' => 'appliance_name/fedora/14/1.0/x86_64'},
+            {'imageId' => '2', 'name' => 'appliance_name/fedora/14/1.0-SNAPSHOT-1/x86_64'}
+        ]}})
+
+        @plugin.instance_variable_set(:@ec2, ec2)
+
+        @plugin.ebs_appliance_name.should == "appliance_name/fedora/14/1.0-SNAPSHOT-1/x86_64"
+      end
+
+    end
+
+    describe ".stomp_ebs" do
+
+      before(:each) do
+        @ami_info =  recursive_ostruct({'imageId' => 'sleepy', 'blockDeviceMapping' => {'item' => [{'deviceName' => '/dev/sda1', 'ebs' => {'snapshotId' => 'bashful'}}]}})
+        @dummy_instances = recursive_ostruct([{'instanceId' => 'grumpy'},
+                             {'instanceId' => 'sneezy'}])
+        @dummy_snapshot = recursive_ostruct({'snapshotId' => 'bashful', 'volumeId' => 'snow-white'})
+        @dummy_volume_attached = recursive_ostruct({'volumeId' => 'snow-white', 'status' => 'attached'})
+        @dummy_volume_detached = recursive_ostruct({'volumeId' => 'snow-white', 'status' => 'detached'})
+      end
+
+      it "should return false if there was no block device found" do
+        prepare_plugin do |plugin|
+          plugin.stub!(:after_init)
+          plugin.stub!(:block_device_from_ami).and_return(nil)
+        end
+        @plugin.stomp_ebs(@ami_info).should == false
+      end
+
+
+      it "should throw an exception if there is still an EBS instance[s] running when an overwrite is requested" do
+        prepare_plugin do |plugin|
+          plugin.stub!(:after_init)
+          plugin.stub!(:snapshot_info).and_return(@dummy_snapshot)
+          plugin.stub!(:get_instances).and_return(@dummy_instances)
+          plugin.stub!(:get_volume_info).and_return(nil)
+        end
+       lambda { @plugin.stomp_ebs(@ami_info) }.should raise_error(RuntimeError)
+      end
+
+      it "should detach and delete the block store, remove the snapshot and deregister the image" do
+        prepare_plugin do |plugin|
+          plugin.stub!(:after_init)
+          plugin.stub!(:snapshot_info).and_return(@dummy_snapshot)
+          plugin.stub!(:get_instances).and_return(false)
+          plugin.stub!(:get_volume_info).and_return(@dummy_volume_attached, @dummy_volume_detached)
+          plugin.stub!(:wait_for_volume_delete)
+          plugin.stub!(:wait_for_snapshot_status)
+          plugin.stub!(:wait_for_volume_status)
+        end
+
+        ec2 = mock('EC2')
+        ec2.should_receive(:detach_volume).with(:volume_id => 'snow-white', :force => true)
+        ec2.should_receive(:delete_volume).with(:volume_id => 'snow-white')
+        ec2.should_receive(:deregister_image).with(:image_id => 'sleepy')
+        ec2.should_receive(:delete_snapshot).with(:snapshot_id => 'bashful')
+
+
+        @plugin.instance_variable_set(:@ec2, ec2)
+        @plugin.stomp_ebs(@ami_info)
+      end
+
+      it "should not delete AWS snapshots when preserve_snapshots is set" do
+        prepare_plugin do |plugin|
+          plugin.stub!(:after_init)
+          plugin.stub!(:snapshot_info).and_return(@dummy_snapshot)
+          plugin.stub!(:get_instances).and_return(false)
+          plugin.stub!(:get_volume_info).and_return(@dummy_volume_attached, @dummy_volume_detached)
+          plugin.stub!(:wait_for_volume_delete)
+          plugin.stub!(:wait_for_snapshot_status)
+          plugin.stub!(:wait_for_volume_status)
+        end
+
+        @plugin_config.merge!('preserve_snapshots' => true)
+
+        ec2 = mock('EC2')
+        ec2.should_receive(:detach_volume).with(:volume_id => 'snow-white', :force => true)
+        ec2.should_receive(:delete_volume).with(:volume_id => 'snow-white')
+        ec2.should_receive(:deregister_image).with(:image_id => 'sleepy')
+        ec2.should_not_receive(:delete_snapshot).with(:snapshot_id => 'bashful')
+
+        @plugin.instance_variable_set(:@ec2, ec2)
+        @plugin.stomp_ebs(@ami_info)
+      end
+
+    end
+
+    #Amazon-EC2 gem uses recursive ostructs, and wont work with opencascade
+    #this replicates the format to avoid breaking the code in tests.
+    def recursive_ostruct(initial)
+      clone = initial.clone
+      ostruct = case initial.class
+        when Array
+          clone.collect! do |v|
+            recursive_ostruct v
+          end
+        when Hash
+           clone.each_pair do |k,v| #follow down until reach terminal
+            clone[k] = recursive_ostruct v
+           end
+          return OpenStruct.new clone
+        else
+          return clone
+        end
+      ostruct
     end
   end
 end

data/spec/plugins/delivery/elastichosts/elastichosts-plugin-spec.rb

@@ -23,18 +23,15 @@ require 'hashery/opencascade'
 module BoxGrinder
   describe ElasticHostsPlugin do
 
-    def merge_config(config = {})
-      @plugin_config = @plugin.instance_variable_get(:@plugin_config).merge(config)
-      @plugin.instance_variable_set(:@plugin_config, @plugin_config)
-    end
-
-    before(:each) do
-      @config = mock('Config')
-      @config.stub!(:delivery_config).and_return({})
-      @config.stub!(:file).and_return('configfile')
-      plugins = mock('Plugins')
-      plugins.stub!(:[]).with('elastichosts').and_return({})
-      @config.stub!(:[]).with(:plugins).and_return(plugins)
+    def prepare(options = {})
+      @config = Config.new(
+          'plugins' => {
+              'elastichosts' => {
+                  'username' => '12345',
+                  'password' => 'secret_access_key',
+                  'endpoint' => 'one.endpoint.somewhere.com'
+              }
+          })
 
       @appliance_config = mock('ApplianceConfig')
 
@@ -46,299 +43,305 @@ module BoxGrinder
       @appliance_config.stub!(:os).and_return(OpenCascade.new({:name => :fedora, :version => '13'}))
       @appliance_config.stub!(:hardware).and_return(OpenCascade.new(:cpus => 1, :arch => 'x86_64', :partitions => {'/' => {'size' => 1}, '/home' => {'size' => 2}}, :memory => 512))
 
+      options = {:log => LogHelper.new(:level => :trace, :type => :stdout), :previous_plugin => OpenCascade.new(:plugin_info => {:type => :os})}.merge(options)
+
       @plugin = ElasticHostsPlugin.new.init(@config, @appliance_config,
-                                            :log => LogHelper.new(:level => :trace, :type => :stdout),
-                                            :plugin_info => {:class => BoxGrinder::ElasticHostsPlugin, :type => :delivery, :name => :elastichosts, :full_name => "ElasticHosts"}
-      )
+                                            {:class => BoxGrinder::ElasticHostsPlugin, :type => :delivery, :name => :elastichosts, :full_name => "ElasticHosts"},
+                                            options
 
-      @plugin.instance_variable_set(:@previous_plugin_info, :type => :os)
+      )
 
-      @config = @plugin.instance_variable_get(:@config)
-      @appliance_config = @plugin.instance_variable_get(:@appliance_config)
+      @plugin_config = @config.plugins['elastichosts']
       @exec_helper = @plugin.instance_variable_get(:@exec_helper)
       @log = @plugin.instance_variable_get(:@log)
       @dir = @plugin.instance_variable_get(:@dir)
+    end
 
-      merge_config('username' => '12345', 'password' => 'secret_access_key', 'endpoint' => 'one.endpoint.somewhere.com')
+    context "validation" do
+      describe ".validate" do
+        it "should fail because we try to upload a non-base appliance" do
+          lambda {
+            prepare(:previous_plugin => OpenCascade.new(:plugin_info => {:type => :platform}))
+          }.should raise_error(PluginValidationError, 'You can use ElasticHosts plugin with base appliances (appliances created with operating system plugins) only, see http://boxgrinder.org/tutorials/boxgrinder-build-plugins/#ElasticHosts_Delivery_Plugin.')
+        end
+      end
     end
 
-    describe ".elastichosts_api_url" do
-      it "should return valid url for default schema" do
-        @plugin.api_url('/drive/1').should == 'http://12345:secret_access_key@one.endpoint.somewhere.com/drive/1'
+    context "after validation" do
+      before(:each) do
+        prepare
+        @plugin.validate
       end
 
-      it "should return valid url for SSL" do
-        merge_config('ssl' => true)
-        @plugin.api_url('/drive/1').should == 'https://12345:secret_access_key@one.endpoint.somewhere.com/drive/1'
+      describe ".elastichosts_api_url" do
+        it "should return valid url for default schema" do
+          @plugin.api_url('/drive/1').should == 'http://12345:secret_access_key@one.endpoint.somewhere.com/drive/1'
+        end
+
+        it "should return valid url for SSL" do
+          @plugin_config.merge!('ssl' => true)
+          @plugin.api_url('/drive/1').should == 'https://12345:secret_access_key@one.endpoint.somewhere.com/drive/1'
+        end
       end
-    end
 
-    it "should return valid disk_size" do
-      @plugin.disk_size.should == 3
-    end
+      it "should return valid disk_size" do
+        @plugin.disk_size.should == 3
+      end
 
-    describe ".execute" do
-      it "should fail because we try to upload a non-base appliance" do
-        @plugin.instance_variable_set(:@previous_plugin_info, :type => :platform)
-        @plugin.should_not_receive(:upload)
-        @plugin.should_not_receive(:create_server)
 
-        lambda {
+      describe ".execute" do
+        it "should upload the appliance" do
+          @plugin.should_receive(:upload)
+          @plugin.should_receive(:create_server)
           @plugin.execute
-        }.should raise_error(PluginValidationError, 'You can use ElasticHosts plugin with base appliances (appliances created with operating system plugins) only, see http://boxgrinder.org/tutorials/boxgrinder-build-plugins/#ElasticHosts_Delivery_Plugin.')
+        end
       end
 
-      it "should upload the appliance" do
-        @plugin.should_receive(:upload)
-        @plugin.should_receive(:create_server)
-        @plugin.execute
+      it "should convert hash to request" do
+        @plugin.hash_to_request('abc' => 'def', 'one' => 1234).should == "abc def\none 1234\n"
       end
-    end
-
-    it "should convert hash to request" do
-      @plugin.hash_to_request('abc' => 'def', 'one' => 1234).should == "abc def\none 1234\n"
-    end
 
-    describe ".create_remote_disk" do
-      it "should create remote disk with default name" do
-        @plugin.should_receive(:hash_to_request).with('size' => 3221225472, 'name' => 'appliance').and_return("json")
+      describe ".create_remote_disk" do
+        it "should create remote disk with default name" do
+          @plugin.should_receive(:hash_to_request).with('size' => 3221225472, 'name' => 'appliance').and_return("json")
 
-        RestClient.should_receive(:post).with("http://12345:secret_access_key@one.endpoint.somewhere.com/drives/create",
-                                              "json").and_return("drive abc-1234567890-abc\n")
-        @plugin.create_remote_disk.should == 'abc-1234567890-abc'
-      end
+          RestClient.should_receive(:post).with("http://12345:secret_access_key@one.endpoint.somewhere.com/drives/create",
+                                                "json").and_return("drive abc-1234567890-abc\n")
+          @plugin.create_remote_disk.should == 'abc-1234567890-abc'
+        end
 
-      it "should create remote disk with custom name" do
-        merge_config('drive_name' => 'thisisadrivename')
+        it "should create remote disk with custom name" do
+          @plugin_config.merge!('drive_name' => 'thisisadrivename')
 
-        @plugin.should_receive(:hash_to_request).with('size' => 3221225472, 'name' => 'thisisadrivename').and_return("json")
+          @plugin.should_receive(:hash_to_request).with('size' => 3221225472, 'name' => 'thisisadrivename').and_return("json")
 
-        RestClient.should_receive(:post).with("http://12345:secret_access_key@one.endpoint.somewhere.com/drives/create",
-                                              "json").and_return("drive abc-1234567890-abc\n")
-        @plugin.create_remote_disk.should == 'abc-1234567890-abc'
-      end
+          RestClient.should_receive(:post).with("http://12345:secret_access_key@one.endpoint.somewhere.com/drives/create",
+                                                "json").and_return("drive abc-1234567890-abc\n")
+          @plugin.create_remote_disk.should == 'abc-1234567890-abc'
+        end
 
-      it "should catch remote disk creation error" do
-        @plugin.should_receive(:hash_to_request).with('size' => 3221225472, 'name' => 'appliance').and_return("json")
+        it "should catch remote disk creation error" do
+          @plugin.should_receive(:hash_to_request).with('size' => 3221225472, 'name' => 'appliance').and_return("json")
 
-        RestClient.should_receive(:post).with("http://12345:secret_access_key@one.endpoint.somewhere.com/drives/create",
-                                              "json").and_raise('boom')
+          RestClient.should_receive(:post).with("http://12345:secret_access_key@one.endpoint.somewhere.com/drives/create",
+                                                "json").and_raise('boom')
 
-        lambda {
-          @plugin.create_remote_disk
-        }.should raise_error(PluginError, 'An error occured while creating the drive, boom. See logs for more info.')
+          lambda {
+            @plugin.create_remote_disk
+          }.should raise_error(PluginError, 'An error occured while creating the drive, boom. See logs for more info.')
+        end
       end
-    end
 
-    describe ".upload" do
-      it "create the disk and upload" do
-        @plugin.should_receive(:create_remote_disk)
-        @plugin.should_receive(:upload_chunks)
-        @plugin.upload
-      end
+      describe ".upload" do
+        it "create the disk and upload" do
+          @plugin.should_receive(:create_remote_disk)
+          @plugin.should_receive(:upload_chunks)
+          @plugin.upload
+        end
 
-      it "upload using existing disk" do
-        merge_config('drive_uuid' => 'thisisadrivename')
+        it "upload using existing disk" do
+          @plugin_config.merge!('drive_uuid' => 'thisisadrivename')
 
-        @plugin.should_not_receive(:create_remote_disk)
-        @plugin.should_receive(:upload_chunks)
-        @plugin.upload
+          @plugin.should_not_receive(:create_remote_disk)
+          @plugin.should_receive(:upload_chunks)
+          @plugin.upload
+        end
       end
-    end
 
-    it "should compress data chunk" do
-      stringio = mock(StringIO)
-      stringio.should_receive(:string).and_return("compressed_data")
-      stringio.should_receive(:size).and_return(2048)
+      it "should compress data chunk" do
+        stringio = mock(StringIO)
+        stringio.should_receive(:string).and_return("compressed_data")
+        stringio.should_receive(:size).and_return(2048)
 
-      gzipwriter = mock(Zlib::GzipWriter)
-      gzipwriter.should_receive(:write).with("data")
-      gzipwriter.should_receive(:close)
+        gzipwriter = mock(Zlib::GzipWriter)
+        gzipwriter.should_receive(:write).with("data")
+        gzipwriter.should_receive(:close)
 
-      StringIO.should_receive(:new).and_return(stringio)
-      Zlib::GzipWriter.should_receive(:new).with(stringio, Zlib::DEFAULT_COMPRESSION, Zlib::FINISH).and_return(gzipwriter)
+        StringIO.should_receive(:new).and_return(stringio)
+        Zlib::GzipWriter.should_receive(:new).with(stringio, Zlib::DEFAULT_COMPRESSION, Zlib::FINISH).and_return(gzipwriter)
 
-      @plugin.compress("data").should == "compressed_data"
-    end
+        @plugin.compress("data").should == "compressed_data"
+      end
 
-    describe ".upload_chunks" do
-      it "should upload chunks in 2 parts" do
-        @plugin.instance_variable_set(:@previous_deliverables, {:disk => 'a/disk'})
+      describe ".upload_chunks" do
+        it "should upload chunks in 2 parts" do
+          @plugin.instance_variable_set(:@previous_deliverables, {:disk => 'a/disk'})
 
-        f = mock(File)
-        f.should_receive(:eof?).ordered.and_return(false)
-        f.should_receive(:seek).ordered.with(0, File::SEEK_SET)
-        f.should_receive(:read).ordered.with(67108864).and_return("data")
+          f = mock(File)
+          f.should_receive(:eof?).ordered.and_return(false)
+          f.should_receive(:seek).ordered.with(0, File::SEEK_SET)
+          f.should_receive(:read).ordered.with(67108864).and_return("data")
 
-        @plugin.should_receive(:compress).ordered.with("data").and_return("compressed_data")
-        @plugin.should_receive(:upload_chunk).ordered.with("compressed_data", 0)
+          @plugin.should_receive(:compress).ordered.with("data").and_return("compressed_data")
+          @plugin.should_receive(:upload_chunk).ordered.with("compressed_data", 0)
 
-        f.should_receive(:eof?).ordered.and_return(false)
-        f.should_receive(:seek).ordered.with(67108864, File::SEEK_SET)
-        f.should_receive(:read).ordered.with(67108864).and_return("data")
+          f.should_receive(:eof?).ordered.and_return(false)
+          f.should_receive(:seek).ordered.with(67108864, File::SEEK_SET)
+          f.should_receive(:read).ordered.with(67108864).and_return("data")
 
-        @plugin.should_receive(:compress).ordered.with("data").and_return("compressed_data")
-        @plugin.should_receive(:upload_chunk).ordered.with("compressed_data", 1)
+          @plugin.should_receive(:compress).ordered.with("data").and_return("compressed_data")
+          @plugin.should_receive(:upload_chunk).ordered.with("compressed_data", 1)
 
-        f.should_receive(:eof?).ordered.and_return(true)
+          f.should_receive(:eof?).ordered.and_return(true)
 
-        File.should_receive(:open).with('a/disk', 'rb').and_yield(f)
-        @plugin.upload_chunks
-      end
+          File.should_receive(:open).with('a/disk', 'rb').and_yield(f)
+          @plugin.upload_chunks
+        end
 
-      it "should upload 1 chunk with custom chunk size" do
-        merge_config('chunk' => 128)
-        @plugin.instance_variable_set(:@previous_deliverables, {:disk => 'a/disk'})
+        it "should upload 1 chunk with custom chunk size" do
+          @plugin_config.merge!('chunk' => 128)
+          @plugin.instance_variable_set(:@previous_deliverables, {:disk => 'a/disk'})
 
-        f = mock(File)
-        f.should_receive(:eof?).ordered.and_return(false)
-        f.should_receive(:seek).ordered.with(0, File::SEEK_SET)
-        f.should_receive(:read).ordered.with(134217728).and_return("data")
+          f = mock(File)
+          f.should_receive(:eof?).ordered.and_return(false)
+          f.should_receive(:seek).ordered.with(0, File::SEEK_SET)
+          f.should_receive(:read).ordered.with(134217728).and_return("data")
 
-        @plugin.should_receive(:compress).ordered.with("data").and_return("compressed_data")
-        @plugin.should_receive(:upload_chunk).ordered.with("compressed_data", 0)
+          @plugin.should_receive(:compress).ordered.with("data").and_return("compressed_data")
+          @plugin.should_receive(:upload_chunk).ordered.with("compressed_data", 0)
 
-        f.should_receive(:eof?).ordered.and_return(true)
+          f.should_receive(:eof?).ordered.and_return(true)
 
-        File.should_receive(:open).with('a/disk', 'rb').and_yield(f)
-        @plugin.upload_chunks
-      end
+          File.should_receive(:open).with('a/disk', 'rb').and_yield(f)
+          @plugin.upload_chunks
+        end
 
-      it "should not compress the data before uploading the chunks if we use CloudSigma" do
-        merge_config('endpoint' => 'api.cloudsigma.com')
-        @plugin.instance_variable_set(:@previous_deliverables, {:disk => 'a/disk'})
+        it "should not compress the data before uploading the chunks if we use CloudSigma" do
+          @plugin_config.merge!('endpoint' => 'api.cloudsigma.com')
+          @plugin.instance_variable_set(:@previous_deliverables, {:disk => 'a/disk'})
 
-        f = mock(File)
-        f.should_receive(:eof?).ordered.and_return(false)
-        f.should_receive(:seek).ordered.with(0, File::SEEK_SET)
-        f.should_receive(:read).ordered.with(67108864).and_return("data")
-        f.should_receive(:eof?).ordered.and_return(true)
+          f = mock(File)
+          f.should_receive(:eof?).ordered.and_return(false)
+          f.should_receive(:seek).ordered.with(0, File::SEEK_SET)
+          f.should_receive(:read).ordered.with(67108864).and_return("data")
+          f.should_receive(:eof?).ordered.and_return(true)
 
-        @plugin.should_not_receive(:compress)
-        @plugin.should_receive(:upload_chunk).ordered.with("data", 0)
+          @plugin.should_not_receive(:compress)
+          @plugin.should_receive(:upload_chunk).ordered.with("data", 0)
 
-        File.should_receive(:open).with('a/disk', 'rb').and_yield(f)
-        @plugin.upload_chunks
-      end
-    end
-
-    describe ".upload_chunk" do
-      before :each do
-        merge_config('drive_uuid' => 'drive-uuid')
-        @plugin.instance_variable_set(:@step, 134217728)
+          File.should_receive(:open).with('a/disk', 'rb').and_yield(f)
+          @plugin.upload_chunks
+        end
       end
 
-      it "should upload a chunk of data" do
-        @plugin.should_receive(:api_url).with('/drives/drive-uuid/write/134217728').and_return('url')
-        RestClient.should_receive(:post).with('url', 'data', :content_type=>"application/octet-stream", "Content-Encoding"=>"gzip")
-        @plugin.upload_chunk("data", 1)
-      end
-
-      it "should upload a chunk of data and be succesful after 1 retry" do
-        @plugin.should_receive(:api_url).with('/drives/drive-uuid/write/0').and_return('url')
-        RestClient.should_receive(:post).with('url', 'data', :content_type=>"application/octet-stream", "Content-Encoding"=>"gzip").and_raise('boom')
-        @plugin.should_receive(:sleep).with(5)
-        RestClient.should_receive(:post).with('url', 'data', :content_type=>"application/octet-stream", "Content-Encoding"=>"gzip")
+      describe ".upload_chunk" do
+        before :each do
+          @plugin_config.merge!('drive_uuid' => 'drive-uuid')
+          @plugin.instance_variable_set(:@step, 134217728)
+        end
 
-        @plugin.upload_chunk("data", 0)
-      end
+        it "should upload a chunk of data" do
+          @plugin.should_receive(:api_url).with('/drives/drive-uuid/write/134217728').and_return('url')
+          RestClient.should_receive(:post).with('url', 'data', :content_type=>"application/octet-stream", "Content-Encoding"=>"gzip")
+          @plugin.upload_chunk("data", 1)
+        end
 
-      it "should fail the upload after 3 retries" do
-        @plugin.should_receive(:api_url).with('/drives/drive-uuid/write/0').and_return('url')
-        RestClient.should_receive(:post).exactly(3).times.with('url', 'data', :content_type=>"application/octet-stream", "Content-Encoding"=>"gzip").and_raise('boom')
-        @plugin.should_receive(:sleep).exactly(2).times.with(5)
+        it "should upload a chunk of data and be succesful after 1 retry" do
+          @plugin.should_receive(:api_url).with('/drives/drive-uuid/write/0').and_return('url')
+          RestClient.should_receive(:post).with('url', 'data', :content_type=>"application/octet-stream", "Content-Encoding"=>"gzip").and_raise('boom')
+          @plugin.should_receive(:sleep).with(5)
+          RestClient.should_receive(:post).with('url', 'data', :content_type=>"application/octet-stream", "Content-Encoding"=>"gzip")
 
-        lambda {
           @plugin.upload_chunk("data", 0)
-        }.should raise_error(PluginError, "Couldn't upload appliance, boom.")
-      end
+        end
 
-      it "should fail the upload after custom sleep time and retry count" do
-        merge_config('retry' => 5, 'wait' => 30)
+        it "should fail the upload after 3 retries" do
+          @plugin.should_receive(:api_url).with('/drives/drive-uuid/write/0').and_return('url')
+          RestClient.should_receive(:post).exactly(3).times.with('url', 'data', :content_type=>"application/octet-stream", "Content-Encoding"=>"gzip").and_raise('boom')
+          @plugin.should_receive(:sleep).exactly(2).times.with(5)
 
-        @plugin.should_receive(:api_url).with('/drives/drive-uuid/write/0').and_return('url')
-        RestClient.should_receive(:post).exactly(5).times.with('url', 'data', :content_type=>"application/octet-stream", "Content-Encoding"=>"gzip").and_raise('boom')
-        @plugin.should_receive(:sleep).exactly(4).times.with(30)
+          lambda {
+            @plugin.upload_chunk("data", 0)
+          }.should raise_error(PluginError, "Couldn't upload appliance, boom.")
+        end
 
-        lambda {
-          @plugin.upload_chunk("data", 0)
-        }.should raise_error(PluginError, "Couldn't upload appliance, boom.")
-      end
+        it "should fail the upload after custom sleep time and retry count" do
+          @plugin_config.merge!('retry' => 5, 'wait' => 30)
 
-      it "should not specify add content-encoding header if uplaoding to cloudsigma" do
-        merge_config('endpoint' => 'api.cloudsigma.com')
+          @plugin.should_receive(:api_url).with('/drives/drive-uuid/write/0').and_return('url')
+          RestClient.should_receive(:post).exactly(5).times.with('url', 'data', :content_type=>"application/octet-stream", "Content-Encoding"=>"gzip").and_raise('boom')
+          @plugin.should_receive(:sleep).exactly(4).times.with(30)
 
-        @plugin.should_receive(:api_url).with('/drives/drive-uuid/write/0').and_return('url')
-        RestClient.should_receive(:post).with('url', 'data', :content_type=>"application/octet-stream")
+          lambda {
+            @plugin.upload_chunk("data", 0)
+          }.should raise_error(PluginError, "Couldn't upload appliance, boom.")
+        end
 
-        @plugin.upload_chunk("data", 0)
-      end
-    end
+        it "should not specify add content-encoding header if uplaoding to cloudsigma" do
+          @plugin_config.merge!('endpoint' => 'api.cloudsigma.com')
 
-    describe ".create_server" do
-      before(:each) do
-        merge_config('drive_uuid' => '12345-asdf')
-
-        @plugin.should_receive(:hash_to_request).with(
-            'name' => "appliance-1.0",
-            'cpu' => 1000,
-            'smp' => 'auto',
-            'mem' => 512,
-            'persistent' => 'true',
-            'ide:0:0' => '12345-asdf',
-            'boot' => 'ide:0:0',
-            'nic:0:model' => 'e1000',
-            'nic:0:dhcp' => 'auto',
-            'vnc:ip' => 'auto',
-            'vnc:password' => an_instance_of(String)
-        ).and_return("json")
-      end
-
-      it "should create the server without issues" do
-        RestClient.should_receive(:post).with("http://12345:secret_access_key@one.endpoint.somewhere.com/servers/create/stopped",
-                                              "json").and_return("server abc-1234567890-abc\nname appliance-1.0\n")
+          @plugin.should_receive(:api_url).with('/drives/drive-uuid/write/0').and_return('url')
+          RestClient.should_receive(:post).with('url', 'data', :content_type=>"application/octet-stream")
 
-        @plugin.create_server
+          @plugin.upload_chunk("data", 0)
+        end
       end
 
-      it "should create the server with 512 MB of ram for instances to be uploaded to cloudsigma" do
-        merge_config('endpoint' => 'api.cloudsigma.com')
+      describe ".create_server" do
+        before(:each) do
+          @plugin_config.merge!('drive_uuid' => '12345-asdf')
+
+          @plugin.should_receive(:hash_to_request).with(
+              'name' => "appliance-1.0",
+              'cpu' => 1000,
+              'smp' => 'auto',
+              'mem' => 512,
+              'persistent' => 'true',
+              'ide:0:0' => '12345-asdf',
+              'boot' => 'ide:0:0',
+              'nic:0:model' => 'e1000',
+              'nic:0:dhcp' => 'auto',
+              'vnc:ip' => 'auto',
+              'vnc:password' => an_instance_of(String)
+          ).and_return("json")
+        end
+
+        it "should create the server without issues" do
+          RestClient.should_receive(:post).with("http://12345:secret_access_key@one.endpoint.somewhere.com/servers/create/stopped",
+                                                "json").and_return("server abc-1234567890-abc\nname appliance-1.0\n")
 
-        @appliance_config.stub!(:hardware).and_return(OpenCascade.new(:cpus => 1, :arch => 'x86_64', :partitions => {'/' => {'size' => 1}, '/home' => {'size' => 2}}, :memory => 256))
+          @plugin.create_server
+        end
 
-        RestClient.should_receive(:post).with("http://12345:secret_access_key@api.cloudsigma.com/servers/create",
-                                              "json").and_return("server abc-1234567890-abc\nname appliance-1.0\n")
+        it "should create the server with 512 MB of ram for instances to be uploaded to cloudsigma" do
+          @plugin_config.merge!('endpoint' => 'api.cloudsigma.com')
 
-        @plugin.create_server
-      end
+          @appliance_config.stub!(:hardware).and_return(OpenCascade.new(:cpus => 1, :arch => 'x86_64', :partitions => {'/' => {'size' => 1}, '/home' => {'size' => 2}}, :memory => 256))
 
-      it "should create the server without issues for cloudsigma cloud" do
-        merge_config('endpoint' => 'api.cloudsigma.com')
+          RestClient.should_receive(:post).with("http://12345:secret_access_key@api.cloudsigma.com/servers/create",
+                                                "json").and_return("server abc-1234567890-abc\nname appliance-1.0\n")
 
-        RestClient.should_receive(:post).with("http://12345:secret_access_key@api.cloudsigma.com/servers/create",
-                                              "json").and_return("server abc-1234567890-abc\nname appliance-1.0\n")
+          @plugin.create_server
+        end
 
-        @plugin.create_server
-      end
+        it "should create the server without issues for cloudsigma cloud" do
+          @plugin_config.merge!('endpoint' => 'api.cloudsigma.com')
 
-      it "should catch remote disk creation error" do
-        RestClient.should_receive(:post).with("http://12345:secret_access_key@one.endpoint.somewhere.com/servers/create/stopped",
-                                              "json").and_raise('boom')
+          RestClient.should_receive(:post).with("http://12345:secret_access_key@api.cloudsigma.com/servers/create",
+                                                "json").and_return("server abc-1234567890-abc\nname appliance-1.0\n")
 
-        lambda {
           @plugin.create_server
-        }.should raise_error(PluginError, 'An error occured while creating the server, boom. See logs for more info.')
-      end
-    end
+        end
 
-    describe ".is_cloudsigma?" do
-      it "should return true if we're talking to cloudsigma endpoint" do
-        merge_config('endpoint' => 'api.cloudsigma.com')
-        @plugin.is_cloudsigma?.should == true
+        it "should catch remote disk creation error" do
+          RestClient.should_receive(:post).with("http://12345:secret_access_key@one.endpoint.somewhere.com/servers/create/stopped",
+                                                "json").and_raise('boom')
+
+          lambda {
+            @plugin.create_server
+          }.should raise_error(PluginError, 'An error occured while creating the server, boom. See logs for more info.')
+        end
       end
 
-      it "should return false if we're NOT talking to cloudsigma endpoint" do
-        @plugin.is_cloudsigma?.should == false
+      describe ".is_cloudsigma?" do
+        it "should return true if we're talking to cloudsigma endpoint" do
+          @plugin_config.merge!('endpoint' => 'api.cloudsigma.com')
+          @plugin.is_cloudsigma?.should == true
+        end
+
+        it "should return false if we're NOT talking to cloudsigma endpoint" do
+          @plugin.is_cloudsigma?.should == false
+        end
       end
     end
   end