ovirt 0.5.0 → 0.6.0

data/spec/factories/template.rb

@@ -0,0 +1,37 @@
+FactoryGirl.define do
+  factory :template, :class => "Ovirt::Template" do
+    initialize_with { new(service, {}) }
+    service { build(:service) }
+  end
+
+  factory :template_full, :parent => :template do
+    initialize_with do
+      new(service,
+          :id                => "128f9ffd-b82c-41e4-8c00-9742ed173bac",
+          :href              => "/api/vms/128f9ffd-b82c-41e4-8c00-9742ed173bac",
+          :cluster           => {
+            :id   => "5be5d08a-a60b-11e2-bee6-005056a217db",
+            :href => "/api/clusters/5be5d08a-a60b-11e2-bee6-005056a217db"},
+          :template          => {
+            :id   => "00000000-0000-0000-0000-000000000000",
+            :href => "/api/templates/00000000-0000-0000-0000-000000000000"},
+          :name              => "bd-skeletal-clone-from-template",
+          :origin            => "rhev",
+          :type              => "server",
+          :memory            => 536_870_912,
+          :stateless         => false,
+          :creation_time     => "2013-09-04 16:24:20 -0400",
+          :status            => {:state => "down"},
+          :display           => {:type => "spice", :monitors => 1},
+          :usb               => {:enabled => false},
+          :cpu               => {:topology => {:sockets => 1, :cores => 1}},
+          :high_availability => {:priority => 1, :enabled => false},
+          :os                => {:type => "rhel5_64", :boot_order => [{:dev => "hd"}]},
+          :custom_attributes => [],
+          :placement_policy  => {:affinity => "migratable", :host => {}},
+          :memory_policy     => {:guaranteed => 536_870_912},
+          :guest_info        => {}
+         )
+    end
+  end
+end

data/spec/factories/vm.rb

@@ -7,7 +7,6 @@ FactoryGirl.define do
   factory :vm_full, :parent => :vm do
     initialize_with do
       new(service,
-        {
           :actions           => {:stop => '/api/vms/128f9ffd-b82c-41e4-8c00-9742ed173bac/stop'},
           :id                => "128f9ffd-b82c-41e4-8c00-9742ed173bac",
           :href              => "/api/vms/128f9ffd-b82c-41e4-8c00-9742ed173bac",
@@ -33,8 +32,7 @@ FactoryGirl.define do
           :placement_policy  => {:affinity => "migratable", :host => {}},
           :memory_policy     => {:guaranteed => 536_870_912},
           :guest_info        => {}
-        }
-      )
+         )
     end
   end
 end

data/spec/service_spec.rb

@@ -1,4 +1,3 @@
-require 'spec_helper'
 require 'rest-client'
 
 describe Ovirt::Service do
@@ -7,7 +6,7 @@ describe Ovirt::Service do
   context "#resource_post" do
     it "raises Ovirt::Error if HTTP 409 response code received" do
       error_detail = "API error"
-      return_data = <<-EOX.chomp
+      return_data  = <<-EOX.chomp
 <action>
     <fault>
         <detail>#{error_detail}</detail>
@@ -16,90 +15,90 @@ describe Ovirt::Service do
 EOX
 
       rest_client = double('rest_client').as_null_object
-      rest_client.should_receive(:post) do |&block|
-        return_data.stub(:code).and_return(409)
+      expect(rest_client).to receive(:post) do |&block|
+        allow(return_data).to receive(:code).and_return(409)
         block.call(return_data)
       end
 
-      service.stub(:create_resource).and_return(rest_client)
+      allow(service).to receive(:create_resource).and_return(rest_client)
       expect { service.resource_post('uri', 'data') }.to raise_error(Ovirt::Error, error_detail)
     end
 
     it "raises Ovirt::Error if HTTP 409 response code received" do
       error_detail = "Usage message"
-      return_data = <<-EOX.chomp
+      return_data  = <<-EOX.chomp
 <usage_message>
   <message>#{error_detail}</message>
 </usage_message>
 EOX
 
       rest_client = double('rest_client').as_null_object
-      rest_client.should_receive(:post) do |&block|
-        return_data.stub(:code).and_return(409)
+      expect(rest_client).to receive(:post) do |&block|
+        allow(return_data).to receive(:code).and_return(409)
         block.call(return_data)
       end
 
-      service.stub(:create_resource).and_return(rest_client)
+      allow(service).to receive(:create_resource).and_return(rest_client)
       expect { service.resource_post('uri', 'data') }.to raise_error(Ovirt::UsageError, error_detail)
     end
   end
 
   it "#resource_get on exception" do
-    service.stub(:create_resource).and_raise(Exception, "BLAH")
+    allow(service).to receive(:create_resource).and_raise(Exception, "BLAH")
     expect { service.resource_get('api') }.to raise_error(Exception, "BLAH")
   end
 
   context ".ovirt?" do
     it "false when ResourceNotFound" do
-      described_class.any_instance.should_receive(:engine_ssh_public_key).and_raise(RestClient::ResourceNotFound)
-      described_class.ovirt?(:server => "127.0.0.1").should be false
+      expect_any_instance_of(described_class).to receive(:engine_ssh_public_key).and_raise(RestClient::ResourceNotFound)
+      expect(described_class.ovirt?(:server => "127.0.0.1")).to be false
     end
 
     it "true when key non-empty" do
       fake_key = "ssh-rsa " + ("A" * 372) + " ovirt-engine\n"
-      described_class.any_instance.should_receive(:engine_ssh_public_key).and_return(fake_key)
-      described_class.ovirt?(:server => "127.0.0.1").should be true
+      expect_any_instance_of(described_class).to receive(:engine_ssh_public_key).and_return(fake_key)
+      expect(described_class.ovirt?(:server => "127.0.0.1")).to be true
     end
 
     it "false when key empty" do
       fake_key = "\n"
-      described_class.any_instance.should_receive(:engine_ssh_public_key).and_return(fake_key)
-      described_class.ovirt?(:server => "127.0.0.1").should be false
+      expect_any_instance_of(described_class).to receive(:engine_ssh_public_key).and_return(fake_key)
+      expect(described_class.ovirt?(:server => "127.0.0.1")).to be false
     end
   end
 
   context "#base_uri" do
-    let(:defaults) { {:username => nil, :password => nil}}
+    let(:defaults) { {:username => nil, :password => nil} }
     subject { described_class.new(defaults.merge(@options)).send(:base_uri) }
 
     it "ipv4" do
       @options = {:server => "127.0.0.1"}
-      subject.should == "https://127.0.0.1:443"
+      expect(subject).to eq("https://127.0.0.1:443")
     end
 
     it "ipv6" do
       @options = {:server => "::1"}
-      subject.should == "https://[::1]:443"
+      expect(subject).to eq("https://[::1]:443")
     end
 
     it "hostname" do
       @options = {:server => "nobody.com"}
-      subject.should == "https://nobody.com:443"
+      expect(subject).to eq("https://nobody.com:443")
     end
 
     it "port 4443" do
       @options = {:server => "nobody.com", :port => 4443}
-      subject.should == "https://nobody.com:4443"
+      expect(subject).to eq("https://nobody.com:4443")
     end
 
     it "blank port" do
       @options = {:server => "nobody.com", :port => ""}
-      subject.should == "https://nobody.com"
+      expect(subject).to eq("https://nobody.com")
     end
 
     it "nil port uses defaults" do
       @options = {:server => "nobody.com", :port => nil}
-      subject.should == "https://nobody.com:443"
+      expect(subject).to eq("https://nobody.com:443")
     end
   end
 end

data/spec/spec_helper.rb

@@ -3,19 +3,99 @@ FactoryGirl.find_definitions
 
 # This file was generated by the `rspec --init` command. Conventionally, all
 # specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
-# Require this file using `require "spec_helper"` to ensure that it is only
-# loaded once.
+# The generated `.rspec` file contains `--require spec_helper` which will cause
+# this file to always be loaded, without a need to explicitly require it in any
+# files.
+#
+# Given that it is always loaded, you are encouraged to keep this file as
+# light-weight as possible. Requiring heavyweight dependencies from this file
+# will add to the boot time of your test suite on EVERY test run, even for an
+# individual file that may not need all of that loaded. Instead, consider making
+# a separate helper file that requires the additional dependencies and performs
+# the additional setup, and require it from the spec files that actually need
+# it.
+#
+# The `.rspec` file also contains a few flags that are not defaults but that
+# users commonly want.
 #
 # See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
 RSpec.configure do |config|
-  config.treat_symbols_as_metadata_keys_with_true_values = true
-  config.run_all_when_everything_filtered = true
+  # rspec-expectations config goes here. You can use an alternate
+  # assertion/expectation library such as wrong or the stdlib/minitest
+  # assertions if you prefer.
+  config.expect_with :rspec do |expectations|
+    # This option will default to `true` in RSpec 4. It makes the `description`
+    # and `failure_message` of custom matchers include text for helper methods
+    # defined using `chain`, e.g.:
+    #     be_bigger_than(2).and_smaller_than(4).description
+    #     # => "be bigger than 2 and smaller than 4"
+    # ...rather than:
+    #     # => "be bigger than 2"
+    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
+  end
+
+  # rspec-mocks config goes here. You can use an alternate test double
+  # library (such as bogus or mocha) by changing the `mock_with` option here.
+  config.mock_with :rspec do |mocks|
+    # Prevents you from mocking or stubbing a method that does not exist on
+    # a real object. This is generally recommended, and will default to
+    # `true` in RSpec 4.
+    # TODO: Enable this and fix related failures
+    # mocks.verify_partial_doubles = true
+  end
 
-  # Run specs in random order to surface order dependencies. If you find an
-  # order dependency and want to debug it, you can fix the order by providing
-  # the seed, which is printed after each run.
-  #     --seed 1234
-  config.order = 'random'
+  # The settings below are suggested to provide a good initial experience
+  # with RSpec, but feel free to customize to your heart's content.
+  #   # These two settings work together to allow you to limit a spec run
+  #   # to individual examples or groups you care about by tagging them with
+  #   # `:focus` metadata. When nothing is tagged with `:focus`, all examples
+  #   # get run.
+  #   config.filter_run :focus
+  #   config.run_all_when_everything_filtered = true
+  #
+  #   # Allows RSpec to persist some state between runs in order to support
+  #   # the `--only-failures` and `--next-failure` CLI options. We recommend
+  #   # you configure your source control system to ignore this file.
+  #   config.example_status_persistence_file_path = "spec/examples.txt"
+  #
+  #   # Limits the available syntax to the non-monkey patched syntax that is
+  #   # recommended. For more details, see:
+  #   #   - http://myronmars.to/n/dev-blog/2012/06/rspecs-new-expectation-syntax
+  #   #   - http://www.teaisaweso.me/blog/2013/05/27/rspecs-new-message-expectation-syntax/
+  #   #   - http://myronmars.to/n/dev-blog/2014/05/notable-changes-in-rspec-3#new__config_option_to_disable_rspeccore_monkey_patching
+  #   config.disable_monkey_patching!
+  #
+  #   # This setting enables warnings. It's recommended, but in some cases may
+  #   # be too noisy due to issues in dependencies.
+  #   config.warnings = true
+  #
+  #   # Many RSpec users commonly either run the entire suite or an individual
+  #   # file, and it's useful to allow more verbose output when running an
+  #   # individual spec file.
+  #   if config.files_to_run.one?
+  #     # Use the documentation formatter for detailed output,
+  #     # unless a formatter has already been configured
+  #     # (e.g. via a command-line flag).
+  #     config.default_formatter = 'doc'
+  #   end
+  #
+  #   # Print the 10 slowest examples and example groups at the
+  #   # end of the spec run, to help surface which specs are running
+  #   # particularly slow.
+  #   config.profile_examples = 10
+  #
+  #   # Run specs in random order to surface order dependencies. If you find an
+  #   # order dependency and want to debug it, you can fix the order by providing
+  #   # the seed, which is printed after each run.
+  #   #     --seed 1234
+  #   config.order = :random
+  #
+  #   # Seed global randomization in this process using the `--seed` CLI option.
+  #   # Setting this allows you to use `--seed` to deterministically reproduce
+  #   # test failures related to randomization by passing the same `--seed` value
+  #   # as the one that triggered the failure.
+  #   Kernel.srand config.seed
+  config.order = :random
   config.include FactoryGirl::Syntax::Methods
 end
 

data/spec/template_spec.rb

@@ -1,42 +1,13 @@
-require 'spec_helper'
-
 describe Ovirt::Template do
-  let(:service) { build(:service) }
-  before do
-    @template = Ovirt::Template.new(service, {
-       :id                => "128f9ffd-b82c-41e4-8c00-9742ed173bac",
-       :href              => "/api/vms/128f9ffd-b82c-41e4-8c00-9742ed173bac",
-       :cluster           => {
-         :id   => "5be5d08a-a60b-11e2-bee6-005056a217db",
-         :href => "/api/clusters/5be5d08a-a60b-11e2-bee6-005056a217db"},
-       :template          => {
-         :id   => "00000000-0000-0000-0000-000000000000",
-         :href => "/api/templates/00000000-0000-0000-0000-000000000000"},
-       :name              => "bd-skeletal-clone-from-template",
-       :origin            => "rhev",
-       :type              => "server",
-       :memory            => 536870912,
-       :stateless         => false,
-       :creation_time     => "2013-09-04 16:24:20 -0400",
-       :status            => {:state => "down"},
-       :display           => {:type => "spice", :monitors => 1},
-       :usb               => {:enabled => false},
-       :cpu               => {:topology => {:sockets => 1, :cores => 1}},
-       :high_availability => {:priority => 1, :enabled => false},
-       :os                => {:type => "rhel5_64", :boot_order => [{:dev => "hd"}]},
-       :custom_attributes => [],
-       :placement_policy  => {:affinity => "migratable", :host => {}},
-       :memory_policy     => {:guaranteed => 536870912},
-       :guest_info        => {}
-    })
-  end
+  let(:service)  { template.service }
+  let(:template) { build(:template_full) }
 
   context "#create_vm" do
     it "clones properties for skeletal clones" do
-      options = {:clone_type => :skeletal}
+      options       = {:clone_type => :skeletal}
       expected_data = {
         :clone_type        => :linked,
-        :memory            => 536870912,
+        :memory            => 536_870_912,
         :stateless         => false,
         :type              => "server",
         :display           => {:type => "spice", :monitors => 1},
@@ -44,11 +15,11 @@ describe Ovirt::Template do
         :cpu               => {:topology => {:sockets => 1, :cores => 1}},
         :high_availability => {:priority => 1, :enabled => false},
         :os_type           => "rhel5_64"}
-      @template.stub(:nics).and_return([])
-      @template.stub(:disks).and_return([])
-      service.stub(:blank_template).and_return(double('blank template'))
-      service.blank_template.should_receive(:create_vm).once.with(expected_data)
-      @template.create_vm(options)
+      allow(template).to receive(:nics).and_return([])
+      allow(template).to receive(:disks).and_return([])
+      allow(service).to  receive(:blank_template).and_return(double('blank template'))
+      expect(service.blank_template).to receive(:create_vm).once.with(expected_data)
+      template.create_vm(options)
     end
 
     it "overrides properties for linked clones" do
@@ -90,19 +61,17 @@ EOX
         :name       => 'new name',
         :cluster    => 'fb27f9a0-cb75-4e0f-8c07-8dec0c5ab483',
         :os_type    => 'test'}
-      service.should_receive(:resource_post).once.with(:vms, expected_data).and_return(response_xml)
-      @template.create_vm(options)
+      expect(service).to receive(:resource_post).once.with(:vms, expected_data).and_return(response_xml)
+      template.create_vm(options)
     end
 
     context "#create_new_disks_from_template" do
       before do
-        @disk = Ovirt::Disk.new(service, {
-          :id=>"01eae62b-90df-424d-978c-beaa7eb2f7f6",
-          :href=>"/api/templates/54f1b9f4-0e89-4c72-9a26-f94dcb857264/disks/01eae62b-90df-424d-978c-beaa7eb2f7f6",
-          :name=>"clone_Disk1",
-          :storage_domains=>[{:id=>"aa7e70e5-40d0-43e2-a605-92ce6ba652a8"}]
-        })
-        @template.stub(:disks).and_return([@disk])
+        @disk = Ovirt::Disk.new(service, :id              => "01eae62b-90df-424d-978c-beaa7eb2f7f6",
+                                         :href            => "/api/templates/54f1b9f4-0e89-4c72-9a26-f94dcb857264/disks/01eae62b-90df-424d-978c-beaa7eb2f7f6",
+                                         :name            => "clone_Disk1",
+                                         :storage_domains => [{:id => "aa7e70e5-40d0-43e2-a605-92ce6ba652a8"}])
+        allow(template).to receive(:disks).and_return([@disk])
 
         @vm = double('rhevm_vm')
       end
@@ -111,24 +80,24 @@ EOX
         expected_data = @disk.attributes.dup
         expected_data[:storage] = expected_data[:storage_domains].first[:id]
 
-        @vm.should_receive(:create_disk).once.with(expected_data)
-        @template.send(:create_new_disks_from_template, @vm, {})
+        expect(@vm).to receive(:create_disk).once.with(expected_data)
+        template.send(:create_new_disks_from_template, @vm, {})
       end
 
       it "with a storage override" do
         expected_data = @disk.attributes.dup
-        options = {:storage => "xxxxxxxx-40d0-43e2-a605-92ce6ba652a8"}
+        options       = {:storage => "xxxxxxxx-40d0-43e2-a605-92ce6ba652a8"}
         expected_data.merge!(options)
 
-        @vm.should_receive(:create_disk).once.with(expected_data)
-        @template.send(:create_new_disks_from_template, @vm, options)
+        expect(@vm).to receive(:create_disk).once.with(expected_data)
+        template.send(:create_new_disks_from_template, @vm, options)
       end
     end
 
     context "build_clone_xml" do
       it "Properly sets vm/cpu/topology attributes" do
-        Ovirt::Base.stub(:object_to_id)
-        xml     = @template.send(:build_clone_xml, :name => "Blank", :cluster => "6b8f1c1e-3eb0-11e4-8420-56847afe9799")
+        allow(Ovirt::Base).to receive(:object_to_id)
+        xml     = template.send(:build_clone_xml, :name => "Blank", :cluster => "6b8f1c1e-3eb0-11e4-8420-56847afe9799")
         nodeset = Nokogiri::XML.parse(xml).xpath("//vm/cpu/topology")
         node    = nodeset.first
 

data/spec/vm_spec.rb

@@ -1,5 +1,3 @@
-require 'spec_helper'
-
 describe Ovirt::Vm do
   let(:service) { vm.service }
   let(:vm)      { build(:vm_full) }
@@ -8,23 +6,23 @@ describe Ovirt::Vm do
     before do
       @resource_url = "#{vm.attributes[:href]}/disks"
       @base_options = {
-        :storage            => "aa7e70e5-abcd-1234-a605-92ce6ba652a8",
-        :id                 => "01eae62b-90df-424d-978c-beaa7eb2f7f6",
-        :href               => "/api/templates/54f1b9f4-0e89-4c72-9a26-f94dcb857264/disks/01eae62b-90df-424d-978c-beaa7eb2f7f6",
-        :name               => "bd-clone_Disk1",
-        :interface          => "virtio",
-        :format             => "raw",
-        :image_id           => "a791ba77-8cc1-44de-9945-69f0a291cc47",
-        :size               => 10737418240,
-        :provisioned_size   => 10737418240,
-        :actual_size        => 1316855808,
-        :sparse             => true,
-        :bootable           => true,
-        :wipe_after_delete  => true,
-        :propagate_errors   => true,
-        :status             => {:state => "ok"},
-        :storage_domains    => [{:id => "aa7e70e5-40d0-43e2-a605-92ce6ba652a8"}],
-        :storage_domain_id  => "aa7e70e5-40d0-43e2-a605-92ce6ba652a8"
+        :storage           => "aa7e70e5-abcd-1234-a605-92ce6ba652a8",
+        :id                => "01eae62b-90df-424d-978c-beaa7eb2f7f6",
+        :href              => "/api/templates/54f1b9f4-0e89-4c72-9a26-f94dcb857264/disks/01eae62b-90df-424d-978c-beaa7eb2f7f6",
+        :name              => "bd-clone_Disk1",
+        :interface         => "virtio",
+        :format            => "raw",
+        :image_id          => "a791ba77-8cc1-44de-9945-69f0a291cc47",
+        :size              => 10_737_418_240,
+        :provisioned_size  => 10_737_418_240,
+        :actual_size       => 1_316_855_808,
+        :sparse            => true,
+        :bootable          => true,
+        :wipe_after_delete => true,
+        :propagate_errors  => true,
+        :status            => {:state => "ok"},
+        :storage_domains   => [{:id => "aa7e70e5-40d0-43e2-a605-92ce6ba652a8"}],
+        :storage_domain_id => "aa7e70e5-40d0-43e2-a605-92ce6ba652a8"
       }
       @base_data = <<-EOX.chomp
 <disk>
@@ -44,29 +42,29 @@ EOX
     end
 
     [:sparse, :bootable, :wipe_after_delete, :propagate_errors].each do |boolean_key|
-      context "xml #{boolean_key.to_s} value" do
+      context "xml #{boolean_key} value" do
         it "set to true" do
           expected_data = @base_data
-          options = @base_options.merge(boolean_key => true)
+          options       = @base_options.merge(boolean_key => true)
 
-          service.should_receive(:resource_post).once.with(@resource_url, expected_data)
+          expect(service).to receive(:resource_post).once.with(@resource_url, expected_data)
           vm.create_disk(options)
         end
 
         it "set to false" do
-          expected_data = @base_data.gsub("<#{boolean_key.to_s}>true</#{boolean_key.to_s}>", "<#{boolean_key.to_s}>false</#{boolean_key.to_s}>")
-          options = @base_options.merge(boolean_key => false)
+          expected_data = @base_data.gsub("<#{boolean_key}>true</#{boolean_key}>", "<#{boolean_key}>false</#{boolean_key}>")
+          options       = @base_options.merge(boolean_key => false)
 
-          service.should_receive(:resource_post).once.with(@resource_url, expected_data)
+          expect(service).to receive(:resource_post).once.with(@resource_url, expected_data)
           vm.create_disk(options)
         end
 
         it "unset" do
-          expected_data = @base_data.gsub("  <#{boolean_key.to_s}>true</#{boolean_key.to_s}>\n", "")
-          options = @base_options.dup
+          expected_data = @base_data.gsub("  <#{boolean_key}>true</#{boolean_key}>\n", "")
+          options       = @base_options.dup
           options.delete(boolean_key)
 
-          service.should_receive(:resource_post).once.with(@resource_url, expected_data)
+          expect(service).to receive(:resource_post).once.with(@resource_url, expected_data)
           vm.create_disk(options)
         end
       end
@@ -81,7 +79,7 @@ EOX
     end
 
     def expected_data(element)
-       return <<-EOX.chomp
+      <<-EOX.chomp
 <nic>
   <name>#{@name}</name>
   #{element}
@@ -91,30 +89,30 @@ EOX
 
     it "populates the interface" do
       interface = 'interface'
-      service.should_receive(:resource_post).once.with(
-          @resource_url, expected_data("<interface>#{interface}</interface>"))
-      vm.create_nic(@base_options.merge({:interface => interface}))
+      expect(service).to receive(:resource_post).once.with(
+        @resource_url, expected_data("<interface>#{interface}</interface>"))
+      vm.create_nic(@base_options.merge(:interface => interface))
     end
 
     it "populates the network id" do
       network_id = 'network_id'
-      service.should_receive(:resource_post).once.with(
-          @resource_url, expected_data("<network id=\"#{network_id}\"/>"))
-      vm.create_nic(@base_options.merge({:network_id => network_id}))
+      expect(service).to receive(:resource_post).once.with(
+        @resource_url, expected_data("<network id=\"#{network_id}\"/>"))
+      vm.create_nic(@base_options.merge(:network_id => network_id))
     end
 
     it "populates the MAC address" do
       mac_address = 'mac_address'
-      service.should_receive(:resource_post).once.with(
-          @resource_url, expected_data("<mac address=\"#{mac_address}\"/>"))
-      vm.create_nic(@base_options.merge({:mac_address => mac_address}))
+      expect(service).to receive(:resource_post).once.with(
+        @resource_url, expected_data("<mac address=\"#{mac_address}\"/>"))
+      vm.create_nic(@base_options.merge(:mac_address => mac_address))
     end
   end
 
   context "#memory_reserve" do
     it "updates the memory policy guarantee" do
       memory_reserve = 1.gigabyte
-      expected_data = <<-EOX.chomp
+      expected_data  = <<-EOX.chomp
 <vm>
   <memory_policy>
     <guaranteed>#{memory_reserve}</guaranteed>
@@ -131,9 +129,9 @@ EOX
 </vm>
 EOX
 
-      service.should_receive(:resource_put).once.with(
-          vm.attributes[:href],
-          expected_data).and_return(return_data)
+      expect(service).to receive(:resource_put).once.with(
+        vm.attributes[:href],
+        expected_data).and_return(return_data)
       vm.memory_reserve = memory_reserve
     end
   end
@@ -149,12 +147,12 @@ EOX
 EOX
 
       rest_client = double('rest_client').as_null_object
-      rest_client.should_receive(:post) do |&block|
-        return_data.stub(:code).and_return(409)
+      expect(rest_client).to receive(:post) do |&block|
+        allow(return_data).to receive(:code).and_return(409)
         block.call(return_data)
       end
 
-      service.stub(:create_resource).and_return(rest_client)
+      allow(service).to receive(:create_resource).and_return(rest_client)
       expect { vm.stop }.to raise_error Ovirt::VmIsNotRunning
     end
   end
@@ -194,8 +192,8 @@ EOX
   </memory_policy>
 </vm>
 EOX
-        service.should_receive(:version).twice.and_return(:major=>"3", :minor=>"0", :build=>"0", :revision=>"0")
-        service.should_receive(:resource_put).once.with(vm.attributes[:href], expected_data).and_return(return_data)
+        expect(service).to receive(:version).twice.and_return(:major => "3", :minor => "0", :build => "0", :revision => "0")
+        expect(service).to receive(:resource_put).once.with(vm.attributes[:href], expected_data).and_return(return_data)
         vm.detach_floppy
       end
 
@@ -224,8 +222,8 @@ EOX
   </memory_policy>
 </vm>
 EOX
-        service.should_receive(:version).and_return(:major=>"3", :minor=>"3", :build=>"0", :revision=>"0")
-        service.should_receive(:resource_put).once.with(vm.attributes[:href], expected_data).and_return(return_data)
+        expect(service).to receive(:version).and_return(:major => "3", :minor => "3", :build => "0", :revision => "0")
+        expect(service).to receive(:resource_put).once.with(vm.attributes[:href], expected_data).and_return(return_data)
         vm.detach_floppy
       end
     end