vagrant-libvirt 0.5.0 → 0.6.0

data/spec/unit/action/handle_box_image_spec.rb

@@ -1,8 +1,13 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
+require 'json'
 require 'support/sharedcontext'
 require 'support/libvirt_context'
 
 require 'vagrant-libvirt/action/destroy_domain'
+require 'vagrant-libvirt/util/byte_number'
+
 
 describe VagrantPlugins::ProviderLibvirt::Action::HandleBoxImage do
   subject { described_class.new(app, env) }
@@ -15,6 +20,41 @@ describe VagrantPlugins::ProviderLibvirt::Action::HandleBoxImage do
   let(:all) { double('all') }
   let(:box_volume) { double('box_volume') }
   let(:fog_volume) { double('fog_volume') }
+  let(:config) { double('config') }
+
+  qemu_json_return_5G = JSON.dump({
+    "virtual-size": 5368709120,
+    "filename": "/test/box.img",
+    "cluster-size": 65536,
+    "format": "qcow2",
+    "actual-size": 655360,
+    "dirty-flag": false
+  })
+  byte_number_5G = ByteNumber.new(5368709120)
+
+
+  qemu_json_return_10G = JSON.dump({
+    "virtual-size": 10737423360,
+    "filename": "/test/disk.qcow2",
+    "cluster-size": 65536,
+    "format": "qcow2",
+    "actual-size": 655360,
+    "dirty-flag": false
+  })
+  byte_number_10G = ByteNumber.new(10737423360)
+
+  qemu_json_return_20G = JSON.dump({
+    "virtual-size": 21474836480,
+    "filename": "/test/box_2.img",
+    "cluster-size": 65536,
+    "format": "qcow2",
+    "actual-size": 1508708352,
+    "dirty-flag": false
+  })
+  byte_number_20G = ByteNumber.new(21474836480)
+
+
+
 
   describe '#call' do
     before do
@@ -39,7 +79,7 @@ describe VagrantPlugins::ProviderLibvirt::Action::HandleBoxImage do
           ]
         }
         allow(env[:machine]).to receive_message_chain("box.directory.join") do |arg|
-          '/test/'.concat(arg.to_s)
+          '/test/' + arg.to_s
         end
       end
 
@@ -51,13 +91,53 @@ describe VagrantPlugins::ProviderLibvirt::Action::HandleBoxImage do
             {
               :path=>"/test/box.img",
               :name=>"test_vagrant_box_image_1.1.1_box.img",
-              :virtual_size=>5,
+              :virtual_size=>byte_number_5G,
               :format=>"qcow2"
             }
           ]
         )
       end
 
+      context 'When config.machine_virtual_size is set and smaller than box_virtual_size' do
+        before do
+          allow(env[:machine]).to receive_message_chain("provider_config.machine_virtual_size").and_return(1)
+        end
+        it 'should warning must be raise' do
+          expect(ui).to receive(:warn).with("Ignoring requested virtual disk size of '1' as it is below\nthe minimum box image size of '5'.")
+          expect(subject.call(env)).to be_nil
+          expect(env[:box_volumes]).to eq(
+            [
+              {
+                :path=>"/test/box.img",
+                :name=>"test_vagrant_box_image_1.1.1_box.img",
+                :virtual_size=>byte_number_5G,
+                :format=>"qcow2"
+              }
+            ]
+          )
+        end
+      end
+
+      context 'When config.machine_virtual_size is set and higher than box_virtual_size' do
+        before do
+          allow(env[:machine]).to receive_message_chain("provider_config.machine_virtual_size").and_return(20)
+        end
+        it 'should be use' do
+          expect(ui).to receive(:info).with("Created volume larger than box defaults, will require manual resizing of\nfilesystems to utilize.")
+          expect(subject.call(env)).to be_nil
+          expect(env[:box_volumes]).to eq(
+            [
+              {
+                :path=>"/test/box.img",
+                :name=>"test_vagrant_box_image_1.1.1_box.img",
+                :virtual_size=>byte_number_20G,
+                :format=>"qcow2"
+              }
+            ]
+          )
+        end
+      end
+
       context 'when disk image not in storage pool' do
         before do
           allow(File).to receive(:exist?).and_return(true)
@@ -74,7 +154,7 @@ describe VagrantPlugins::ProviderLibvirt::Action::HandleBoxImage do
             hash_including(
               :name => "test_vagrant_box_image_1.1.1_box.img",
               :allocation => "5120M",
-              :capacity => "5G",
+              :capacity => "5368709120B",
             )
           )
           expect(subject).to receive(:upload_image)
@@ -119,17 +199,17 @@ describe VagrantPlugins::ProviderLibvirt::Action::HandleBoxImage do
           ],
         ]}
         allow(env[:machine]).to receive_message_chain("box.directory.join") do |arg|
-          '/test/'.concat(arg.to_s)
+          '/test/' + arg.to_s
         end
         allow(status).to receive(:success?).and_return(true)
-        allow(Open3).to receive(:capture3).with('qemu-img', 'info', '/test/box.img').and_return([
-            "image: /test/box.img\nfile format: qcow2\nvirtual size: 5 GiB (5368709120 bytes)\ndisk size: 1.45 GiB\n", "", status
+        allow(Open3).to receive(:capture3).with('qemu-img', 'info', '--output=json', '/test/box.img').and_return([
+          qemu_json_return_5G, "", status
         ])
-        allow(Open3).to receive(:capture3).with('qemu-img', 'info', '/test/disk.qcow2').and_return([
-          "image: /test/disk.qcow2\nfile format: qcow2\nvirtual size: 10 GiB (10737418240 bytes)\ndisk size: 1.45 GiB\n", "", status
+        allow(Open3).to receive(:capture3).with('qemu-img', 'info', '--output=json', '/test/disk.qcow2').and_return([
+          qemu_json_return_10G, "", status
         ])
-        allow(Open3).to receive(:capture3).with('qemu-img', 'info', '/test/box_2.img').and_return([
-          "image: /test/box_2.img\nfile format: qcow2\nvirtual size: 20 GiB (21474836480 bytes)\ndisk size: 1.45 GiB\n", "", status
+        allow(Open3).to receive(:capture3).with('qemu-img', 'info', '--output=json', '/test/box_2.img').and_return([
+          qemu_json_return_20G, "", status
         ])
       end
 
@@ -141,19 +221,19 @@ describe VagrantPlugins::ProviderLibvirt::Action::HandleBoxImage do
             {
               :path=>"/test/box.img",
               :name=>"test_vagrant_box_image_1.1.1_send_box_name.img",
-              :virtual_size=>5,
+              :virtual_size=>byte_number_5G,
               :format=>"qcow2"
             },
             {
               :path=>"/test/disk.qcow2",
               :name=>"test_vagrant_box_image_1.1.1_disk.img",
-              :virtual_size=>10,
+              :virtual_size=>byte_number_10G,
               :format=>"qcow2"
             },
             {
               :path=>"/test/box_2.img",
               :name=>"test_vagrant_box_image_1.1.1_box_2.img",
-              :virtual_size=>20,
+              :virtual_size=>byte_number_20G,
               :format=>"qcow2"
             }
           ]
@@ -176,7 +256,7 @@ describe VagrantPlugins::ProviderLibvirt::Action::HandleBoxImage do
             hash_including(
               :name => "test_vagrant_box_image_1.1.1_send_box_name.img",
               :allocation => "5120M",
-              :capacity => "5G",
+              :capacity => "5368709120B",
             )
           )
           expect(subject).to receive(:upload_image)
@@ -186,7 +266,7 @@ describe VagrantPlugins::ProviderLibvirt::Action::HandleBoxImage do
             hash_including(
               :name => "test_vagrant_box_image_1.1.1_disk.img",
               :allocation => "10240M",
-              :capacity => "10G",
+              :capacity => "10737423360B",
             )
           )
           expect(subject).to receive(:upload_image)
@@ -196,7 +276,7 @@ describe VagrantPlugins::ProviderLibvirt::Action::HandleBoxImage do
             hash_including(
               :name => "test_vagrant_box_image_1.1.1_box_2.img",
               :allocation => "20480M",
-              :capacity => "20G",
+              :capacity => "21474836480B",
             )
           )
           expect(subject).to receive(:upload_image)
@@ -256,7 +336,7 @@ describe VagrantPlugins::ProviderLibvirt::Action::HandleBoxImage do
           ]
         }
         allow(env[:machine]).to receive_message_chain("box.directory.join") do |arg|
-          '/test/'.concat(arg.to_s)
+          '/test/' + arg.to_s
         end
       end
 
@@ -276,17 +356,17 @@ describe VagrantPlugins::ProviderLibvirt::Action::HandleBoxImage do
         allow(env[:machine]).to receive_message_chain("box.version") { '1.1.1' }
         allow(env[:machine]).to receive_message_chain("box.metadata") { box_metadata }
         allow(env[:machine]).to receive_message_chain("box.directory.join") do |arg|
-          '/test/'.concat(arg.to_s)
+          '/test/' + arg.to_s
         end
         allow(status).to receive(:success?).and_return(true)
-        allow(Open3).to receive(:capture3).with('qemu-img', 'info', '/test/box.img').and_return([
-            "image: /test/box.img\nfile format: qcow2\nvirtual size: 5 GiB (5368709120 bytes)\ndisk size: 1.45 GiB\n", "", status
+        allow(Open3).to receive(:capture3).with('qemu-img', 'info', "--output=json", '/test/box.img').and_return([
+          qemu_json_return_5G, "", status
         ])
-        allow(Open3).to receive(:capture3).with('qemu-img', 'info', '/test/disk.qcow2').and_return([
-          "image: /test/disk.qcow2\nfile format: qcow2\nvirtual size: 10 GiB (10737418240 bytes)\ndisk size: 1.45 GiB\n", "", status
+        allow(Open3).to receive(:capture3).with('qemu-img', 'info', "--output=json", '/test/disk.qcow2').and_return([
+          qemu_json_return_10G, "", status
         ])
-        allow(Open3).to receive(:capture3).with('qemu-img', 'info', '/test/box_2.img').and_return([
-          "image: /test/box_2.img\nfile format: qcow2\nvirtual size: 20 GiB (21474836480 bytes)\ndisk size: 1.45 GiB\n", "", status
+        allow(Open3).to receive(:capture3).with('qemu-img', 'info', "--output=json", '/test/box_2.img').and_return([
+          qemu_json_return_20G, "", status
         ])
       end
 

data/spec/unit/action/package_domain_spec.rb

@@ -0,0 +1,304 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'support/sharedcontext'
+
+require 'vagrant-libvirt/action/clean_machine_folder'
+
+describe VagrantPlugins::ProviderLibvirt::Action::PackageDomain do
+  subject { described_class.new(app, env) }
+
+  include_context 'unit'
+  include_context 'libvirt'
+  include_context 'temporary_dir'
+
+  let(:libvirt_client) { double('libvirt_client') }
+  let(:libvirt_domain) { double('libvirt_domain') }
+  let(:servers) { double('servers') }
+  let(:volumes) { double('volumes') }
+  let(:metadata_file) { double('file') }
+  let(:vagrantfile_file) { double('file') }
+
+  describe '#call' do
+    before do
+      allow_any_instance_of(VagrantPlugins::ProviderLibvirt::Driver)
+        .to receive(:connection).and_return(connection)
+      allow(connection).to receive(:client).and_return(libvirt_client)
+      allow(libvirt_client).to receive(:lookup_domain_by_uuid).and_return(libvirt_domain)
+
+      allow(connection).to receive(:servers).and_return(servers)
+      allow(servers).to receive(:get).and_return(domain)
+
+      allow(connection).to receive(:volumes).and_return(volumes)
+
+      allow(logger).to receive(:info)
+
+      env["package.directory"] = temp_dir
+    end
+
+    context 'with defaults' do
+      let(:root_disk) { double('libvirt_domain_disk') }
+      before do
+        allow(root_disk).to receive(:name).and_return('default_domain.img')
+        allow(domain).to receive(:volumes).and_return([root_disk])
+        allow(libvirt_domain).to receive(:name).and_return('default_domain')
+        allow(subject).to receive(:download_image).and_return(true)
+      end
+
+      it 'should succeed' do
+        expect(ui).to receive(:info).with('Packaging domain...')
+        expect(ui).to receive(:info).with(/Downloading default_domain.img to .*\/box.img/)
+        expect(ui).to receive(:info).with('Image has backing image, copying image and rebasing ...')
+        expect(subject).to receive(:`).with(/qemu-img info .*\/box.img | grep 'backing file:' | cut -d ':' -f2/).and_return("some image")
+        expect(subject).to receive(:`).with(/qemu-img rebase -p -b "" .*\/box.img/)
+        expect(subject).to receive(:`).with(/virt-sysprep --no-logfile --operations .* -a .*\/box.img .*/)
+        expect(subject).to receive(:`).with(/virt-sparsify --in-place .*\/box.img/)
+        expect(subject).to receive(:`).with(/qemu-img info --output=json .*\/box.img/).and_return(
+          { 'virtual-size': 5*1024*1024*1024 }.to_json
+        )
+        expect(File).to receive(:write).with(
+          /.*\/metadata.json/,
+          <<-EOF.unindent
+          {
+            "provider": "libvirt",
+            "format": "qcow2",
+            "virtual_size": 5
+          }
+          EOF
+        )
+        expect(File).to receive(:write).with(/.*\/Vagrantfile/, /.*/)
+
+        expect(subject.call(env)).to be_nil
+      end
+    end
+
+    context 'with nil volume' do
+      let(:root_disk) { double('libvirt_domain_disk') }
+      before do
+        allow(root_disk).to receive(:name).and_return('default_domain.img')
+        allow(domain).to receive(:volumes).and_return([nil, root_disk])
+        allow(libvirt_domain).to receive(:name).and_return('default_domain')
+        allow(subject).to receive(:download_image).and_return(true)
+      end
+
+      it 'should succeed' do
+        expect(ui).to receive(:info).with('Packaging domain...')
+        expect(ui).to receive(:info).with(/Downloading default_domain.img to .*\/box.img/)
+        expect(ui).to receive(:info).with('Image has backing image, copying image and rebasing ...')
+        expect(subject).to receive(:`).with(/qemu-img info .*\/box.img | grep 'backing file:' | cut -d ':' -f2/).and_return("some image")
+        expect(subject).to receive(:`).with(/qemu-img rebase -p -b "" .*\/box.img/)
+        expect(subject).to receive(:`).with(/virt-sysprep --no-logfile --operations .* -a .*\/box.img .*/)
+        expect(subject).to receive(:`).with(/virt-sparsify --in-place .*\/box.img/)
+        expect(subject).to receive(:`).with(/qemu-img info --output=json .*\/box.img/).and_return(
+          { 'virtual-size': 5*1024*1024*1024 }.to_json
+        )
+
+        expect(subject.call(env)).to be_nil
+      end
+    end
+
+    context 'when detecting the format' do
+      let(:root_disk) { double('libvirt_domain_disk') }
+      let(:disk2) { double('libvirt_additional_disk') }
+      let(:fake_env) { Hash.new }
+
+      before do
+        allow(root_disk).to receive(:name).and_return('default_domain.img')
+        allow(disk2).to receive(:name).and_return('disk2.img')
+        allow(libvirt_domain).to receive(:name).and_return('default_domain')
+      end
+
+      context 'with two disks' do
+        before do
+          allow(domain).to receive(:volumes).and_return([root_disk, disk2])
+        end
+
+        it 'should emit a warning' do
+          expect(ui).to receive(:info).with('Packaging domain...')
+          expect(ui).to receive(:warn).with(/Detected more than one volume for machine.*\n.*/)
+          expect(subject).to receive(:package_v1)
+
+          expect(subject.call(env)).to be_nil
+        end
+      end
+
+      context 'with format set to v1' do
+        before do
+          allow(domain).to receive(:volumes).and_return([root_disk])
+          stub_const("ENV", fake_env)
+          fake_env['VAGRANT_LIBVIRT_BOX_FORMAT_VERSION'] = "v1"
+        end
+
+        it 'should call v1 packaging' do
+          expect(ui).to receive(:info).with('Packaging domain...')
+          expect(subject).to receive(:package_v1)
+
+          expect(subject.call(env)).to be_nil
+        end
+      end
+
+      context 'with format set to v2' do
+        before do
+          allow(domain).to receive(:volumes).and_return([root_disk])
+          stub_const("ENV", fake_env)
+          fake_env['VAGRANT_LIBVIRT_BOX_FORMAT_VERSION'] = "v2"
+        end
+
+        it 'should call v1 packaging' do
+          expect(ui).to receive(:info).with('Packaging domain...')
+          expect(subject).to receive(:package_v2)
+
+          expect(subject.call(env)).to be_nil
+        end
+      end
+
+      context 'with invalid format' do
+        before do
+          allow(domain).to receive(:volumes).and_return([root_disk])
+          stub_const("ENV", fake_env)
+          fake_env['VAGRANT_LIBVIRT_BOX_FORMAT_VERSION'] = "bad format"
+        end
+
+        it 'should emit a warning and default to v1' do
+          expect(ui).to receive(:info).with('Packaging domain...')
+          expect(ui).to receive(:warn).with(/Unrecognized value for.*defaulting to v1/)
+          expect(subject).to receive(:package_v1)
+
+          expect(subject.call(env)).to be_nil
+        end
+      end
+    end
+
+    context 'with v2 format' do
+      let(:disk1) { double('libvirt_domain_disk') }
+      let(:disk2) { double('libvirt_additional_disk') }
+      let(:fake_env) { Hash.new }
+
+      before do
+        allow(disk1).to receive(:name).and_return('default_domain.img')
+        allow(disk2).to receive(:name).and_return('disk2.img')
+        allow(libvirt_domain).to receive(:name).and_return('default_domain')
+        allow(subject).to receive(:download_image).and_return(true).twice()
+
+        stub_const("ENV", fake_env)
+        fake_env['VAGRANT_LIBVIRT_BOX_FORMAT_VERSION'] = "v2"
+      end
+
+      context 'with 2 disks' do
+        before do
+          allow(domain).to receive(:volumes).and_return([disk1, disk2])
+        end
+
+        it 'should succeed' do
+          expect(ui).to receive(:info).with('Packaging domain...')
+          expect(ui).to receive(:info).with(/Downloading default_domain.img to .*\/box_1.img/)
+          expect(ui).to receive(:info).with('Image has backing image, copying image and rebasing ...')
+          expect(subject).to receive(:`).with(/qemu-img info .*\/box_1.img | grep 'backing file:' | cut -d ':' -f2/).and_return("some image")
+          expect(subject).to receive(:`).with(/qemu-img rebase -p -b "" .*\/box_1.img/)
+          expect(subject).to receive(:`).with(/virt-sysprep --no-logfile --operations .* -a .*\/box_1.img .*/)
+          expect(subject).to receive(:`).with(/virt-sparsify --in-place .*\/box_1.img/)
+          expect(ui).to receive(:info).with(/Downloading disk2.img to .*\/box_2.img/)
+          expect(ui).to receive(:info).with('Image has backing image, copying image and rebasing ...')
+          expect(subject).to receive(:`).with(/qemu-img info .*\/box_2.img | grep 'backing file:' | cut -d ':' -f2/).and_return("some image")
+          expect(subject).to receive(:`).with(/qemu-img rebase -p -b "" .*\/box_2.img/)
+          expect(subject).to receive(:`).with(/virt-sparsify --in-place .*\/box_2.img/)
+
+          expect(File).to receive(:write).with(
+            /.*\/metadata.json/,
+            <<-EOF.unindent.rstrip()
+            {
+              "provider": "libvirt",
+              "format": "qcow2",
+              "disks": [
+                {
+                  "path": "box_1.img"
+                },
+                {
+                  "path": "box_2.img"
+                }
+              ]
+            }
+            EOF
+          )
+          expect(File).to receive(:write).with(/.*\/Vagrantfile/, /.*/)
+
+          expect(subject.call(env)).to be_nil
+        end
+      end
+
+      context 'with 1 disk' do
+        before do
+          allow(domain).to receive(:volumes).and_return([disk1])
+        end
+
+        it 'should succeed' do
+          expect(ui).to receive(:info).with('Packaging domain...')
+          expect(ui).to receive(:info).with(/Downloading default_domain.img to .*\/box_1.img/)
+          expect(ui).to receive(:info).with('Image has backing image, copying image and rebasing ...')
+          expect(subject).to receive(:`).with(/qemu-img info .*\/box_1.img | grep 'backing file:' | cut -d ':' -f2/).and_return("some image")
+          expect(subject).to receive(:`).with(/qemu-img rebase -p -b "" .*\/box_1.img/)
+          expect(subject).to receive(:`).with(/virt-sysprep --no-logfile --operations .* -a .*\/box_1.img .*/)
+          expect(subject).to receive(:`).with(/virt-sparsify --in-place .*\/box_1.img/)
+
+          expect(File).to receive(:write).with(
+            /.*\/metadata.json/,
+            <<-EOF.unindent.rstrip()
+            {
+              "provider": "libvirt",
+              "format": "qcow2",
+              "disks": [
+                {
+                  "path": "box_1.img"
+                }
+              ]
+            }
+            EOF
+          )
+          expect(File).to receive(:write).with(/.*\/Vagrantfile/, /.*/)
+
+          expect(subject.call(env)).to be_nil
+        end
+      end
+    end
+  end
+
+  describe '#vagrantfile_content' do
+    context 'with defaults' do
+      it 'should output expected content' do
+        expect(subject.vagrantfile_content(env)).to eq(
+          <<-EOF.unindent
+          Vagrant.configure("2") do |config|
+            config.vm.provider :libvirt do |libvirt|
+              libvirt.driver = "kvm"
+            end
+
+          end
+          EOF
+        )
+      end
+    end
+
+    context 'with custom user vagrantfile' do
+      before do
+        env["package.vagrantfile"] = "_Vagrantfile"
+      end
+      it 'should output Vagrantfile containing reference' do
+        expect(subject.vagrantfile_content(env)).to eq(
+          <<-EOF.unindent
+          Vagrant.configure("2") do |config|
+            config.vm.provider :libvirt do |libvirt|
+              libvirt.driver = "kvm"
+            end
+
+            # Load include vagrant file if it exists after the auto-generated
+            # so it can override any of the settings
+            include_vagrantfile = File.expand_path("../include/_Vagrantfile", __FILE__)
+            load include_vagrantfile if File.exist?(include_vagrantfile)
+
+          end
+          EOF
+        )
+      end
+    end
+  end
+end

data/spec/unit/action/set_name_of_domain_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe VagrantPlugins::ProviderLibvirt::Action::SetNameOfDomain do

data/spec/unit/action/shutdown_domain_spec.rb

@@ -0,0 +1,131 @@
+require 'spec_helper'
+require 'support/sharedcontext'
+require 'support/libvirt_context'
+require 'vagrant-libvirt/action/shutdown_domain'
+
+describe VagrantPlugins::ProviderLibvirt::Action::ShutdownDomain do
+  subject { described_class.new(app, env, target_state, current_state) }
+
+  include_context 'unit'
+  include_context 'libvirt'
+
+  let(:driver) { double('driver') }
+  let(:libvirt_domain) { double('libvirt_domain') }
+  let(:servers) { double('servers') }
+  let(:current_state) { :running }
+  let(:target_state) { :shutoff }
+
+  before do
+    allow(machine.provider).to receive('driver').and_return(driver)
+    allow(driver).to receive(:created?).and_return(true)
+    allow(driver).to receive(:connection).and_return(connection)
+  end
+
+  describe '#call' do
+    before do
+      allow(connection).to receive(:servers).and_return(servers)
+      allow(servers).to receive(:get).and_return(domain)
+      allow(ui).to receive(:info).with('Attempting direct shutdown of domain...')
+    end
+
+    context "when state is shutoff" do
+      before do
+        allow(driver).to receive(:state).and_return(:shutoff)
+      end
+
+      it "should not shutdown" do
+        expect(domain).not_to receive(:shutoff)
+        subject.call(env)
+      end
+
+      it "should not print shutdown message" do
+        expect(ui).not_to receive(:info)
+        subject.call(env)
+      end
+
+      it "should provide a true result" do
+        subject.call(env)
+        expect(env[:result]).to be_truthy
+      end
+    end
+
+    context "when state is running" do
+      before do
+        allow(driver).to receive(:state).and_return(:running)
+      end
+
+      it "should shutdown" do
+        expect(domain).to receive(:wait_for)
+        expect(domain).to receive(:shutdown)
+        subject.call(env)
+      end
+
+      it "should print shutdown message" do
+        expect(domain).to receive(:wait_for)
+        expect(domain).to receive(:shutdown)
+        expect(ui).to receive(:info).with('Attempting direct shutdown of domain...')
+        subject.call(env)
+      end
+
+      context "when final state is not shutoff" do
+        before do
+          expect(driver).to receive(:state).and_return(:running).exactly(3).times
+          expect(domain).to receive(:wait_for)
+          expect(domain).to receive(:shutdown)
+        end
+
+        it "should provide a false result" do
+          subject.call(env)
+          expect(env[:result]).to be_falsey
+        end
+      end
+
+      context "when final state is shutoff" do
+        before do
+          expect(driver).to receive(:state).and_return(:running).exactly(2).times
+          expect(driver).to receive(:state).and_return(:shutoff).exactly(1).times
+          expect(domain).to receive(:wait_for)
+          expect(domain).to receive(:shutdown)
+        end
+
+        it "should provide a true result" do
+          subject.call(env)
+          expect(env[:result]).to be_truthy
+        end
+      end
+
+      context "when timeout exceeded" do
+        before do
+          expect(machine).to receive_message_chain('config.vm.graceful_halt_timeout').and_return(1)
+          expect(app).to receive(:call) { sleep 1.5 }
+          expect(driver).to receive(:state).and_return(:running).exactly(1).times
+          expect(domain).to_not receive(:wait_for)
+          expect(domain).to_not receive(:shutdown)
+        end
+
+        it "should provide a false result" do
+          subject.call(env)
+          expect(env[:result]).to be_falsey
+        end
+      end
+
+      context "when timeout not exceeded" do
+        before do
+          expect(machine).to receive_message_chain('config.vm.graceful_halt_timeout').and_return(2)
+          expect(app).to receive(:call) { sleep 1 }
+          expect(driver).to receive(:state).and_return(:running).exactly(3).times
+          expect(domain).to receive(:wait_for) do |time|
+            expect(time).to be < 1
+            expect(time).to be > 0
+          end
+          expect(domain).to receive(:shutdown)
+        end
+
+        it "should wait for the reduced time" do
+          subject.call(env)
+          expect(env[:result]).to be_falsey
+        end
+      end
+    end
+  end
+end