vcloud-core 0.5.0 → 0.6.0

data/spec/vcloud/core/vapp_template_spec.rb

@@ -7,11 +7,11 @@ module Vcloud
       before(:each) do
         @id = 'vappTemplate-12345678-1234-1234-1234-000000234121'
         @mock_fog_interface = StubFogInterface.new
-        Vcloud::Fog::ServiceInterface.stub(:new).and_return(@mock_fog_interface)
+        allow(Vcloud::Fog::ServiceInterface).to receive(:new).and_return(@mock_fog_interface)
       end
 
       context "Class public interface" do
-        it { VappTemplate.should respond_to(:get) }
+        it { expect(VappTemplate).to respond_to(:get) }
       end
 
       context "Instance public interface" do
@@ -47,8 +47,8 @@ module Vcloud
         it 'should raise a RuntimeError if there is no template' do
           q_results = [ ]
           mock_query = double(:query_runner)
-          Vcloud::Core::QueryRunner.should_receive(:new).and_return(mock_query)
-          mock_query.should_receive(:run).
+          expect(Vcloud::Core::QueryRunner).to receive(:new).and_return(mock_query)
+          expect(mock_query).to receive(:run).
             with('vAppTemplate', :filter => "name==test_template;catalogName==test_catalog").
             and_return(q_results)
           expect { VappTemplate.get('test_template', 'test_catalog') }.
@@ -63,8 +63,8 @@ module Vcloud
               :href => "/vappTemplate-12345678-90ab-cdef-0123-4567890ab002" },
           ]
           mock_query = double(:query_runner)
-          Vcloud::Core::QueryRunner.should_receive(:new).and_return(mock_query)
-          mock_query.should_receive(:run).
+          expect(Vcloud::Core::QueryRunner).to receive(:new).and_return(mock_query)
+          expect(mock_query).to receive(:run).
             with('vAppTemplate', :filter => "name==test_template;catalogName==test_catalog").
             and_return(q_results)
           expect { VappTemplate.get('test_template', 'test_catalog') }.
@@ -77,12 +77,12 @@ module Vcloud
               :href => "/vappTemplate-12345678-90ab-cdef-0123-4567890abcde" }
           ]
           mock_query = double(:query)
-          Vcloud::Core::QueryRunner.should_receive(:new).and_return(mock_query)
-          mock_query.should_receive(:run).
+          expect(Vcloud::Core::QueryRunner).to receive(:new).and_return(mock_query)
+          expect(mock_query).to receive(:run).
             with('vAppTemplate', :filter => "name==test_template;catalogName==test_catalog").
             and_return(q_results)
           test_template = VappTemplate.get('test_template', 'test_catalog')
-          test_template.id.should == 'vappTemplate-12345678-90ab-cdef-0123-4567890abcde'
+          expect(test_template.id).to eq('vappTemplate-12345678-90ab-cdef-0123-4567890abcde')
         end
 
       end

data/spec/vcloud/core/vdc_spec.rb

@@ -7,11 +7,11 @@ module Vcloud
       before(:each) do
         @vdc_id = '12345678-1234-1234-1234-000000111232'
         @mock_fog_interface = StubFogInterface.new
-        Vcloud::Fog::ServiceInterface.stub(:new).and_return(@mock_fog_interface)
+        allow(Vcloud::Fog::ServiceInterface).to receive(:new).and_return(@mock_fog_interface)
       end
 
       context "Class public interface" do
-        it { Vdc.should respond_to(:get_by_name) }
+        it { expect(Vdc).to respond_to(:get_by_name) }
       end
 
       context "Instance public interface" do
@@ -47,8 +47,8 @@ module Vcloud
             { :name => 'vdc-test-1', :href => @vdc_id }
           ]
           mock_query = double(:query_runner)
-          Vcloud::Core::QueryRunner.should_receive(:new).and_return(mock_query)
-          mock_query.should_receive(:run).with('orgVdc', :filter => "name==vdc-test-1").and_return(q_results)
+          expect(Vcloud::Core::QueryRunner).to receive(:new).and_return(mock_query)
+          expect(mock_query).to receive(:run).with('orgVdc', :filter => "name==vdc-test-1").and_return(q_results)
           obj = Vdc.get_by_name('vdc-test-1')
           expect(obj.class).to be(Vcloud::Core::Vdc)
         end
@@ -56,8 +56,8 @@ module Vcloud
         it "should raise an error if no vDC with that name exists" do
           q_results = [ ]
           mock_query = double(:query_runner)
-          Vcloud::Core::QueryRunner.should_receive(:new).and_return(mock_query)
-          mock_query.should_receive(:run).with('orgVdc', :filter => "name==vdc-test-1").and_return(q_results)
+          expect(Vcloud::Core::QueryRunner).to receive(:new).and_return(mock_query)
+          expect(mock_query).to receive(:run).with('orgVdc', :filter => "name==vdc-test-1").and_return(q_results)
           expect{ Vdc.get_by_name('vdc-test-1') }.to raise_exception(RuntimeError, "vDc vdc-test-1 not found")
         end
 

data/spec/vcloud/core/vm_spec.rb

@@ -21,8 +21,8 @@ module Vcloud
         @mock_vm_cpu_count = 1
         @fog_interface = StubFogInterface.new
         @mock_vapp = double(:vappm, :name => @vapp_name, :id => @vapp_id)
-        Vcloud::Fog::ServiceInterface.stub(:new).and_return(@fog_interface)
-        @fog_interface.stub(:get_vapp).with(@vm_id).and_return({
+        allow(Vcloud::Fog::ServiceInterface).to receive(:new).and_return(@fog_interface)
+        allow(@fog_interface).to receive(:get_vapp).with(@vm_id).and_return({
             :name => "#{@vm_name}",
             :href => "vm-href/#{@vm_id}",
             :'ovf:VirtualHardwareSection' => {
@@ -58,7 +58,6 @@ module Vcloud
         it { should respond_to(:add_extra_disks) }
         it { should respond_to(:configure_network_interfaces) }
         it { should respond_to(:configure_guest_customization_section) }
-        it { should respond_to(:generate_preamble) }
       end
 
       context "#initialize" do
@@ -82,144 +81,77 @@ module Vcloud
 
       context "update memory in VM" do
         it "should not allow memory size < 64MB" do
-          @fog_interface.should_not_receive(:put_memory)
+          expect(@fog_interface).not_to receive(:put_memory)
           @vm.update_memory_size_in_mb(63)
         end
         it "should not update memory if is size has not changed" do
-          @fog_interface.should_not_receive(:put_memory)
+          expect(@fog_interface).not_to receive(:put_memory)
           @vm.update_memory_size_in_mb(@mock_vm_memory_size)
         end
         it "should gracefully handle a nil memory size" do
-          @fog_interface.should_not_receive(:put_memory)
+          expect(@fog_interface).not_to receive(:put_memory)
           @vm.update_memory_size_in_mb(nil)
         end
         it "should set memory size 64MB" do
-          @fog_interface.should_receive(:put_memory).with(@vm_id, 64)
+          expect(@fog_interface).to receive(:put_memory).with(@vm_id, 64)
           @vm.update_memory_size_in_mb(64)
         end
         it "should set memory size 4096MB" do
-          @fog_interface.should_receive(:put_memory).with(@vm_id, 4096)
+          expect(@fog_interface).to receive(:put_memory).with(@vm_id, 4096)
           @vm.update_memory_size_in_mb(4096)
         end
       end
 
       context "update the number of cpus in vm" do
         it "should gracefully handle nil cpu count" do
-          @fog_interface.should_not_receive(:put_cpu)
+          expect(@fog_interface).not_to receive(:put_cpu)
           @vm.update_cpu_count(nil)
         end
         it "should not update cpu if is count has not changed" do
-          @fog_interface.should_not_receive(:put_cpu)
+          expect(@fog_interface).not_to receive(:put_cpu)
           @vm.update_cpu_count(@mock_vm_cpu_count)
         end
         it "should not allow a zero cpu count" do
-          @fog_interface.should_not_receive(:put_cpu)
+          expect(@fog_interface).not_to receive(:put_cpu)
           @vm.update_cpu_count(0)
         end
         it "should update cpu count in input is ok" do
-          @fog_interface.should_receive(:put_cpu).with(@vm_id, 2)
+          expect(@fog_interface).to receive(:put_cpu).with(@vm_id, 2)
           @vm.update_cpu_count(2)
         end
       end
 
       context '#configure_guest_customization_section' do
-
-        it "should handle complete configuration" do
-          name = 'test-vm'
-          bootstrap_config = {
-            script_path: 'hello_world.erb',
-            script_post_processor: 'remove_hello.rb',
-            vars: { bob: 'hello', mary: 'hello' },
-          }
-          extra_disks = []
-          @vm.should_receive(:generate_preamble).
-            with('hello_world.erb', 'remove_hello.rb', {
-              bob: "hello",
-              mary: "hello",
-              extra_disks: [] }).
-            and_return('RETURNED_PREAMBLE')
-          @fog_interface.should_receive(:put_guest_customization_section).
-            with(@vm_id, 'test-vm', 'RETURNED_PREAMBLE')
-          @vm.configure_guest_customization_section(name, bootstrap_config, extra_disks)
-        end
-
-        it "should handle nil configuration" do
-          name = 'test-vm'
-          bootstrap_config = nil
-          extra_disks = nil
-          @vm.should_not_receive(:generate_preamble)
-          @fog_interface.should_receive(:put_guest_customization_section).
-            with(@vm_id, 'test-vm', '')
-          @vm.configure_guest_customization_section(name, bootstrap_config, extra_disks)
-        end
-
-        it "should handle empty configuration" do
-          name = 'test-vm'
-          bootstrap_config = {}
-          extra_disks = nil
-          @vm.should_not_receive(:generate_preamble)
-          @fog_interface.should_receive(:put_guest_customization_section).
-            with(@vm_id, 'test-vm', '')
-          @vm.configure_guest_customization_section(name, bootstrap_config, extra_disks)
+        let(:preamble) do
+          <<-'EOF'
+          #!/usr/bin/env bash
+          echo "Hello World"
+          EOF
         end
 
-        it "should handle bootstrap vars being missing" do
-          name = 'test-vm'
-          bootstrap_config = {
-            script_path: 'hello_world.erb',
-            script_post_processor: 'remove_hello.rb',
-          }
-          extra_disks = []
-          @vm.should_receive(:generate_preamble).
-            with('hello_world.erb', 'remove_hello.rb', { extra_disks: [] }).
-            and_return('RETURNED_PREAMBLE')
-          @fog_interface.should_receive(:put_guest_customization_section).
-            with(@vm_id, 'test-vm', 'RETURNED_PREAMBLE')
-          @vm.configure_guest_customization_section(name, bootstrap_config, extra_disks)
-        end
-
-      end
-
-      context '#generate_preamble' do
-        it "should interpolate vars hash, ENV, and vapp_name into template" do
-          vars = {
-            :message => 'hello world',
-            :array_test => [ 'foo', 'bar' ],
-          }
-          stub_const('ENV', {'TEST_INTERPOLATED_ENVVAR' => 'test_interpolated_env'})
-          erbfile = "#{@data_dir}/basic_preamble_test.erb"
-          expected_output = File.read("#{erbfile}.OUT")
-          @vm.generate_preamble(erbfile, nil, vars).should == expected_output
-        end
+        it 'passes a pre-generated preamble to fog' do
+          expect(@fog_interface).to receive(:put_guest_customization_section).with(@vm_id, @vapp_name, preamble)
 
-        it "passes the output of ERB through an optional post-processor tool" do
-          # we use 'wc' as post processor since it will give us the character
-          # count in the file, which we can easily match on, and is common
-          # across most OSes.
-          vars = {}
-          erbfile = "#{@data_dir}/preamble_post_processor_test_input.erb"
-          characters_in_file = File.read(erbfile).size
-          expect(@vm.generate_preamble(erbfile, '/usr/bin/wc', vars)).
-            to match(/^\s+\d+\s+\d+\s+#{characters_in_file}\s/)
+          @vm.configure_guest_customization_section(preamble)
         end
       end
 
       context "update metadata" do
         it "should handle empty metadata hash" do
-          @fog_interface.should_not_receive(:put_vapp_metadata_value)
+          expect(@fog_interface).not_to receive(:put_vapp_metadata_value)
           @vm.update_metadata(nil)
         end
         it "should handle metadata of multiple types" do
-          @fog_interface.should_receive(:put_vapp_metadata_value).with(@vm_id, :foo, 'bar')
-          @fog_interface.should_receive(:put_vapp_metadata_value).with(@vm_id, :false_thing, false)
-          @fog_interface.should_receive(:put_vapp_metadata_value).with(@vm_id, :true_thing, true)
-          @fog_interface.should_receive(:put_vapp_metadata_value).with(@vm_id, :number, 53)
-          @fog_interface.should_receive(:put_vapp_metadata_value).with(@vm_id, :zero, 0)
-          @fog_interface.should_receive(:put_vapp_metadata_value).with(@vapp_id, :foo, 'bar')
-          @fog_interface.should_receive(:put_vapp_metadata_value).with(@vapp_id, :false_thing, false)
-          @fog_interface.should_receive(:put_vapp_metadata_value).with(@vapp_id, :true_thing, true)
-          @fog_interface.should_receive(:put_vapp_metadata_value).with(@vapp_id, :number, 53)
-          @fog_interface.should_receive(:put_vapp_metadata_value).with(@vapp_id, :zero, 0)
+          expect(@fog_interface).to receive(:put_vapp_metadata_value).with(@vm_id, :foo, 'bar')
+          expect(@fog_interface).to receive(:put_vapp_metadata_value).with(@vm_id, :false_thing, false)
+          expect(@fog_interface).to receive(:put_vapp_metadata_value).with(@vm_id, :true_thing, true)
+          expect(@fog_interface).to receive(:put_vapp_metadata_value).with(@vm_id, :number, 53)
+          expect(@fog_interface).to receive(:put_vapp_metadata_value).with(@vm_id, :zero, 0)
+          expect(@fog_interface).to receive(:put_vapp_metadata_value).with(@vapp_id, :foo, 'bar')
+          expect(@fog_interface).to receive(:put_vapp_metadata_value).with(@vapp_id, :false_thing, false)
+          expect(@fog_interface).to receive(:put_vapp_metadata_value).with(@vapp_id, :true_thing, true)
+          expect(@fog_interface).to receive(:put_vapp_metadata_value).with(@vapp_id, :number, 53)
+          expect(@fog_interface).to receive(:put_vapp_metadata_value).with(@vapp_id, :zero, 0)
           @vm.update_metadata(@mock_metadata)
         end
       end
@@ -227,7 +159,7 @@ module Vcloud
       context "configure vm network interfaces" do
         it "should configure single nic without an IP" do
           network_config = [{:name => 'Default'}]
-          @fog_interface.should_receive(:put_network_connection_system_section_vapp).with(@vm_id, {
+          expect(@fog_interface).to receive(:put_network_connection_system_section_vapp).with(@vm_id, {
               :PrimaryNetworkConnectionIndex => 0,
               :NetworkConnection => [
                   {
@@ -243,7 +175,7 @@ module Vcloud
 
         it "should configure nic from pool" do
           network_config = [{:name => 'Default', :allocation_mode => 'pool'}]
-          @fog_interface.should_receive(:put_network_connection_system_section_vapp).with(@vm_id, {
+          expect(@fog_interface).to receive(:put_network_connection_system_section_vapp).with(@vm_id, {
               :PrimaryNetworkConnectionIndex => 0,
               :NetworkConnection => [
                   {
@@ -259,7 +191,7 @@ module Vcloud
 
         it "should prefer configuring nic with static address" do
           network_config = [{:name => 'Default', :allocation_mode => 'dhcp', :ip_address => '192.168.1.1'}]
-          @fog_interface.should_receive(:put_network_connection_system_section_vapp).with(@vm_id, {
+          expect(@fog_interface).to receive(:put_network_connection_system_section_vapp).with(@vm_id, {
               :PrimaryNetworkConnectionIndex => 0,
               :NetworkConnection => [
                   {
@@ -276,7 +208,7 @@ module Vcloud
 
         it "should configure single nic" do
           network_config = [{:name => 'Default', :ip_address => '192.168.1.1'}]
-          @fog_interface.should_receive(:put_network_connection_system_section_vapp).with(@vm_id, {
+          expect(@fog_interface).to receive(:put_network_connection_system_section_vapp).with(@vm_id, {
               :PrimaryNetworkConnectionIndex => 0,
               :NetworkConnection => [
                   {
@@ -297,7 +229,7 @@ module Vcloud
               {:name => 'Monitoring', :ip_address => '192.168.2.1'}
           ]
 
-          @fog_interface.should_receive(:put_network_connection_system_section_vapp).with(@vm_id, {
+          expect(@fog_interface).to receive(:put_network_connection_system_section_vapp).with(@vm_id, {
               :PrimaryNetworkConnectionIndex => 0,
               :NetworkConnection => [
                   {
@@ -322,7 +254,7 @@ module Vcloud
 
         it "should configure no nics" do
           network_config = nil
-          @fog_interface.should_not_receive(:put_network_connection_system_section_vapp)
+          expect(@fog_interface).not_to receive(:put_network_connection_system_section_vapp)
           @vm.configure_network_interfaces(network_config)
         end
 
@@ -341,16 +273,16 @@ module Vcloud
           ]
           mock_sp_query = double(:query_runner)
 
-          Vcloud::Core::QueryRunner.should_receive(:new).and_return(mock_vdc_query)
-          mock_vdc_query.should_receive(:run).with('vApp', :filter => "name==#{@vapp_name}").and_return(vdc_results)
-          Vcloud::Core::QueryRunner.should_receive(:new).and_return(mock_sp_query)
-          mock_sp_query.should_receive(:run).
+          expect(Vcloud::Core::QueryRunner).to receive(:new).and_return(mock_vdc_query)
+          expect(mock_vdc_query).to receive(:run).with('vApp', :filter => "name==#{@vapp_name}").and_return(vdc_results)
+          expect(Vcloud::Core::QueryRunner).to receive(:new).and_return(mock_sp_query)
+          expect(mock_sp_query).to receive(:run).
             with('orgVdcStorageProfile', :filter => "name==storage_profile_name;vdcName==vdc-test-1").
             and_return(storage_profile_results)
 
           generated_storage_profile = { name: 'storage_profile_name', href: 'test-href' }
-          @fog_interface.should_receive(:put_vm).with(@vm_id, @vm_name, { :StorageProfile => generated_storage_profile} ).and_return(true)
-          @vm.update_storage_profile(storage_profile).should == true
+          expect(@fog_interface).to receive(:put_vm).with(@vm_id, @vm_name, { :StorageProfile => generated_storage_profile} ).and_return(true)
+          expect(@vm.update_storage_profile(storage_profile)).to eq(true)
         end
 
         it "should raise an error if storage profile is not found" do
@@ -363,10 +295,10 @@ module Vcloud
           storage_profile_results = []
           mock_sp_query = double(:query_runner)
 
-          Vcloud::Core::QueryRunner.should_receive(:new).and_return(mock_vdc_query)
-          mock_vdc_query.should_receive(:run).with('vApp', :filter => "name==#{@vapp_name}").and_return(vdc_results)
-          Vcloud::Core::QueryRunner.should_receive(:new).and_return(mock_sp_query)
-          mock_sp_query.should_receive(:run).
+          expect(Vcloud::Core::QueryRunner).to receive(:new).and_return(mock_vdc_query)
+          expect(mock_vdc_query).to receive(:run).with('vApp', :filter => "name==#{@vapp_name}").and_return(vdc_results)
+          expect(Vcloud::Core::QueryRunner).to receive(:new).and_return(mock_sp_query)
+          expect(mock_sp_query).to receive(:run).
             with('orgVdcStorageProfile', :filter => "name==storage_profile_name;vdcName==vdc-test-1").
             and_return(storage_profile_results)
 
@@ -383,10 +315,10 @@ module Vcloud
           storage_profile_results = [ { :id => 'test-href'  }]
           mock_sp_query = double(:query_runner)
 
-          Vcloud::Core::QueryRunner.should_receive(:new).and_return(mock_vdc_query)
-          mock_vdc_query.should_receive(:run).with('vApp', :filter => "name==#{@vapp_name}").and_return(vdc_results)
-          Vcloud::Core::QueryRunner.should_receive(:new).and_return(mock_sp_query)
-          mock_sp_query.should_receive(:run).
+          expect(Vcloud::Core::QueryRunner).to receive(:new).and_return(mock_vdc_query)
+          expect(mock_vdc_query).to receive(:run).with('vApp', :filter => "name==#{@vapp_name}").and_return(vdc_results)
+          expect(Vcloud::Core::QueryRunner).to receive(:new).and_return(mock_sp_query)
+          expect(mock_sp_query).to receive(:run).
             with('orgVdcStorageProfile', :filter => "name==storage_profile_name;vdcName==vdc-test-1").
             and_return(storage_profile_results)
 

data/spec/vcloud/fog/fog_model_interface_spec.rb

@@ -12,14 +12,14 @@ describe Vcloud::Fog::ModelInterface do
     org = double(:hr, :name => 'HR ORG', :vdcs => [vdc])
 
     vcloud = double(:mock_vcloud, :org_name => 'HR', :organizations => double(:orgs, :get_by_name => org))
-    vcloud.should_receive(:get_vms_in_lease_from_query).with({:filter => "href==#{vm_href}"}).and_return(
+    expect(vcloud).to receive(:get_vms_in_lease_from_query).with({:filter => "href==#{vm_href}"}).and_return(
         double(
             :vm_query_record,
             :body => {:VMRecord => [{:href => vm_href, :containerName => 'vapp-1', :vdc => vdc_href}]}
         )
     )
-    Fog::Compute::VcloudDirector.should_receive(:new).and_return(vcloud)
+    expect(Fog::Compute::VcloudDirector).to receive(:new).and_return(vcloud)
 
-    Vcloud::Fog::ModelInterface.new.get_vm_by_href(vm_href).should == vm
+    expect(Vcloud::Fog::ModelInterface.new.get_vm_by_href(vm_href)).to eq(vm)
   end
 end

data/spec/vcloud/fog/service_interface_spec.rb

@@ -10,8 +10,8 @@ module Vcloud
       it 'should raise a exception if named vdc not found in the data returned' do
 
         fog_facade = double(:FogFacade)
-        expect(fog_facade).to receive(:session).and_return { FOG_SESSION_RESPONSE }
-        expect(fog_facade).to receive(:get_organization).and_return { FOG_ORGANIZATION_RESPONSE }
+        expect(fog_facade).to receive(:session) { FOG_SESSION_RESPONSE }
+        expect(fog_facade).to receive(:get_organization) { FOG_ORGANIZATION_RESPONSE }
 
         service_interface = ServiceInterface.new(fog_facade)
 
@@ -22,25 +22,25 @@ module Vcloud
         before(:each) do
           @config = { :Blah => 'TestData' }
           @vcloud = double(:vcloud)
-          ::Fog::Compute::VcloudDirector.should_receive(:new).and_return(@vcloud)
+          expect(::Fog::Compute::VcloudDirector).to receive(:new).and_return(@vcloud)
         end
 
         it "should configure firewall for given edge gateway id" do
           task = double(:task)
-          Vcloud::Core::logger.should_receive(:info).with("Updating EdgeGateway 1234")
-          @vcloud.should_receive(:post_configure_edge_gateway_services).with("1234", @config).
+          expect(Vcloud::Core::logger).to receive(:info).with("Updating EdgeGateway 1234")
+          expect(@vcloud).to receive(:post_configure_edge_gateway_services).with("1234", @config).
               and_return(double(:response, :body =>  task ))
-          @vcloud.should_receive(:process_task).with(task)
+          expect(@vcloud).to receive(:process_task).with(task)
 
           ServiceInterface.new.post_configure_edge_gateway_services "1234", @config
         end
 
 
         it "should log and return exceptions without swallowing" do
-          Vcloud::Core::logger.should_receive(:info).with("Updating EdgeGateway 1234")
+          expect(Vcloud::Core::logger).to receive(:info).with("Updating EdgeGateway 1234")
           runtime_error = RuntimeError.new('Test Error')
-          Vcloud::Core::logger.should_receive(:error).with("Could not update EdgeGateway 1234 : #{runtime_error}")
-          @vcloud.should_receive(:post_configure_edge_gateway_services).with("1234", @config).
+          expect(Vcloud::Core::logger).to receive(:error).with("Could not update EdgeGateway 1234 : #{runtime_error}")
+          expect(@vcloud).to receive(:post_configure_edge_gateway_services).with("1234", @config).
               and_raise(runtime_error)
           expect{ ServiceInterface.new.post_configure_edge_gateway_services("1234", @config) }.to raise_error("Test Error")
         end

data/vcloud-core.gemspec

@@ -12,7 +12,7 @@ Gem::Specification.new do |s|
   s.email       = ['anna.shipman@digital.cabinet-office.gov.uk']
   s.summary     = 'Core tools for interacting with VMware vCloud Director'
   s.description = 'Core tools for interacting with VMware vCloud Director. Includes VCloud Query, a light wrapper round the vCloud Query API.'
-  s.homepage    = 'http://github.com/alphagov/vcloud-core'
+  s.homepage    = 'http://github.com/gds-operations/vcloud-core'
   s.license     = 'MIT'
 
   s.files         = `git ls-files`.split($/)
@@ -20,15 +20,15 @@ Gem::Specification.new do |s|
   s.test_files    = s.files.grep(%r{^(test|spec|features)/})
   s.require_paths = ['lib']
 
-  s.required_ruby_version = '>= 1.9.2'
+  s.required_ruby_version = '>= 1.9.3'
 
   s.add_runtime_dependency 'fog', '>= 1.22.0'
   s.add_runtime_dependency 'mustache'
+  s.add_development_dependency 'gem_publisher', '1.2.0'
   s.add_development_dependency 'pry'
   s.add_development_dependency 'rake'
   s.add_development_dependency 'rspec', '~> 2.14.1'
-  s.add_development_dependency 'rubocop'
-  s.add_development_dependency 'simplecov', '~> 0.8.2'
-  s.add_development_dependency 'gem_publisher', '1.2.0'
-  s.add_development_dependency 'vcloud-tools-tester', '0.0.3'
+  s.add_development_dependency 'rubocop', '~> 0.23.0'
+  s.add_development_dependency 'simplecov', '~> 0.7.1'
+  s.add_development_dependency 'vcloud-tools-tester', '~> 0.1.0'
 end