vagrant-libvirt 0.4.1 → 0.5.0

data/spec/unit/action/forward_ports_spec.rb

@@ -0,0 +1,202 @@
+require 'spec_helper'
+require 'support/sharedcontext'
+require 'support/libvirt_context'
+
+require 'vagrant-libvirt/errors'
+require 'vagrant-libvirt/action/forward_ports'
+
+describe VagrantPlugins::ProviderLibvirt::Action::ForwardPorts do
+  subject { described_class.new(app, env) }
+
+  include_context 'unit'
+
+  let(:machine_config) { double("machine_config") }
+  let(:vm_config) { double("vm_config") }
+  let(:provider_config) { double("provider_config") }
+
+  before (:each) do
+    allow(machine).to receive(:config).and_return(machine_config)
+    allow(machine).to receive(:provider_config).and_return(provider_config)
+    allow(machine_config).to receive(:vm).and_return(vm_config)
+    allow(vm_config).to receive(:networks).and_return([])
+    allow(provider_config).to receive(:forward_ssh_port).and_return(false)
+  end
+
+  describe '#call' do
+    context 'with none defined' do
+      it 'should skip calling forward_ports' do
+        expect(subject).to_not receive(:forward_ports)
+        expect(subject.call(env)).to be_nil
+      end
+    end
+
+    context 'with network including one forwarded port' do
+      let(:networks) { [
+        [:private_network, {:ip=>"10.20.30.40", :protocol=>"tcp", :id=>"6b8175ed-3220-4b63-abaf-0bb8d7cdd723"}],
+        [:forwarded_port, port_options],
+      ]}
+
+      let(:port_options){ {guest: 80, host: 8080} }
+
+      it 'should compile a single port forward to set up' do
+        expect(vm_config).to receive(:networks).and_return(networks)
+        expect(ui).to_not receive(:warn)
+        expect(subject).to receive(:forward_ports).and_return(nil)
+
+        expect(subject.call(env)).to be_nil
+
+        expect(env[:forwarded_ports]).to eq([networks[1][1]])
+      end
+
+      context 'when host port in protected range' do
+        let(:port_options){ {guest: 8080, host: 80} }
+
+        it 'should emit a warning' do
+          expect(vm_config).to receive(:networks).and_return(networks)
+          expect(ui).to receive(:warn).with(include("You are trying to forward to privileged ports"))
+          expect(subject).to receive(:forward_ports).and_return(nil)
+
+          expect(subject.call(env)).to be_nil
+        end
+      end
+    end
+
+    context 'when udp protocol is selected' do
+      let(:port_options){ {guest: 80, host: 8080, protocol: "udp"} }
+
+      it 'should skip and emit warning' do
+        expect(vm_config).to receive(:networks).and_return([[:forwarded_port, port_options]])
+        expect(ui).to receive(:warn).with("Forwarding UDP ports is not supported. Ignoring.")
+        expect(subject).to_not receive(:forward_ports)
+
+        expect(subject.call(env)).to be_nil
+      end
+    end
+
+    context 'when default ssh port forward provided' do
+      let(:networks){ [
+        [:private_network, {:ip=>"10.20.30.40", :protocol=>"tcp", :id=>"6b8175ed-3220-4b63-abaf-0bb8d7cdd723"}],
+        [:forwarded_port, {guest: 80, host: 8080}],
+        [:forwarded_port, {guest: 22, host: 2222, host_ip: '127.0.0.1', id: 'ssh'}],
+      ]}
+
+      context 'with default config' do
+        it 'should not forward the ssh port' do
+          expect(vm_config).to receive(:networks).and_return(networks)
+          expect(subject).to receive(:forward_ports)
+
+          expect(subject.call(env)).to be_nil
+
+          expect(env[:forwarded_ports]).to eq([networks[1][1]])
+        end
+      end
+
+      context 'with forward_ssh_port enabled' do
+        before do
+          allow(provider_config).to receive(:forward_ssh_port).and_return(true)
+        end
+
+        it 'should forward the port' do
+          expect(vm_config).to receive(:networks).and_return(networks)
+          expect(subject).to receive(:forward_ports)
+
+          expect(subject.call(env)).to be_nil
+
+          expect(env[:forwarded_ports]).to eq(networks.drop(1).map { |_, opts| opts })
+        end
+      end
+    end
+  end
+
+  describe '#forward_ports' do
+    let(:pid_dir){ machine.data_dir.join('pids') }
+
+    before (:each) do
+      allow(env).to receive(:[]).and_call_original
+      allow(machine).to receive(:ssh_info).and_return(
+        {
+          :host => "localhost",
+          :username => "vagrant",
+          :port => 22,
+          :private_key_path => ["/home/test/.ssh/id_rsa"],
+        }
+      )
+      allow(provider_config).to receive(:proxy_command).and_return(nil)
+    end
+
+    context 'with port to forward' do
+      let(:port_options){ {guest: 80, host: 8080, guest_ip: "192.168.1.121"} }
+
+      it 'should spawn ssh to setup forwarding' do
+        expect(env).to receive(:[]).with(:forwarded_ports).and_return([port_options])
+        expect(ui).to receive(:info).with("#{port_options[:guest]} (guest) => #{port_options[:host]} (host) (adapter eth0)")
+        expect(subject).to receive(:spawn).with(/ssh -n -o User=vagrant -o Port=22.*-L \*:8080:192.168.1.121:80 -N localhost/, anything).and_return(9999)
+
+        expect(subject.forward_ports(env)).to eq([port_options])
+
+        expect(pid_dir.join('ssh_8080.pid')).to have_file_content("9999")
+      end
+    end
+
+    context 'with privileged host port' do
+      let(:port_options){ {guest: 80, host: 80, guest_ip: "192.168.1.121"} }
+
+      it 'should spawn ssh to setup forwarding' do
+        expect(env).to receive(:[]).with(:forwarded_ports).and_return([port_options])
+        expect(ui).to receive(:info).with("#{port_options[:guest]} (guest) => #{port_options[:host]} (host) (adapter eth0)")
+        expect(ui).to receive(:info).with('Requesting sudo for host port(s) <= 1024')
+        expect(subject).to receive(:system).with('sudo -v').and_return(true)
+        expect(subject).to receive(:spawn).with(/sudo ssh -n -o User=vagrant -o Port=22.*-L \*:80:192.168.1.121:80 -N localhost/, anything).and_return(10000)
+
+        expect(subject.forward_ports(env)).to eq([port_options])
+
+        expect(pid_dir.join('ssh_80.pid')).to have_file_content("10000")
+      end
+    end
+  end
+end
+
+describe VagrantPlugins::ProviderLibvirt::Action::ClearForwardedPorts do
+  subject { described_class.new(app, env) }
+
+  include_context 'unit'
+  include_context 'libvirt'
+
+  describe '#call' do
+    context 'no forwarded ports' do
+      it 'should skip checking if pids are running' do
+        expect(subject).to_not receive(:ssh_pid?)
+        expect(logger).to receive(:info).with('No ssh pids found')
+
+        expect(subject.call(env)).to be_nil
+      end
+    end
+
+    context 'multiple forwarded ports' do
+      before do
+        data_dir = machine.data_dir.join('pids')
+        data_dir.mkdir unless data_dir.directory?
+
+        [
+          {:port => '8080', :pid => '10001'},
+          {:port => '8081', :pid => '10002'},
+        ].each do |port_pid|
+          File.write(data_dir.to_s + "/ssh_#{port_pid[:port]}.pid", port_pid[:pid])
+        end
+      end
+      it 'should terminate each of the processes' do
+        expect(logger).to receive(:info).with(no_args) # don't know how to test translations from vagrant
+        expect(subject).to receive(:ssh_pid?).with("10001").and_return(true)
+        expect(subject).to receive(:ssh_pid?).with("10002").and_return(true)
+        expect(logger).to receive(:debug).with(/Killing pid/).twice()
+        expect(logger).to receive(:info).with('Removing ssh pid files')
+        expect(subject).to receive(:system).with("kill 10001")
+        expect(subject).to receive(:system).with("kill 10002")
+
+        expect(subject.call(env)).to be_nil
+
+        expect(Dir.entries(machine.data_dir.join('pids'))).to match_array(['.', '..'])
+      end
+    end
+  end
+end

data/spec/unit/action/halt_domain_spec.rb

@@ -0,0 +1,90 @@
+require 'spec_helper'
+require 'support/sharedcontext'
+require 'support/libvirt_context'
+require 'vagrant-libvirt/action/destroy_domain'
+
+describe VagrantPlugins::ProviderLibvirt::Action::HaltDomain do
+  subject { described_class.new(app, env) }
+
+  include_context 'unit'
+  include_context 'libvirt'
+
+  let(:libvirt_domain) { double('libvirt_domain') }
+  let(:servers) { double('servers') }
+
+  describe '#call' do
+    before do
+      allow_any_instance_of(VagrantPlugins::ProviderLibvirt::Driver)
+        .to receive(:connection).and_return(connection)
+      allow(connection).to receive(:servers).and_return(servers)
+      allow(servers).to receive(:get).and_return(domain)
+      # always see this at the start of #call
+      expect(ui).to receive(:info).with('Halting domain...')
+    end
+
+    context 'with graceful timeout' do
+      it "should shutdown" do
+        expect(guest).to receive(:capability).with(:halt).and_return(true)
+        expect(domain).to receive(:wait_for).with(60).and_return(false)
+        expect(subject.call(env)).to be_nil
+      end
+
+      context 'when halt fails' do
+        before do
+          expect(logger).to receive(:info).with('Trying Libvirt graceful shutdown.')
+          expect(guest).to receive(:capability).with(:halt).and_raise(IOError)
+          expect(domain).to receive(:state).and_return('running')
+        end
+
+        it "should call shutdown" do
+          expect(domain).to receive(:shutdown)
+          expect(domain).to receive(:wait_for).with(60).and_return(false)
+          expect(subject.call(env)).to be_nil
+        end
+
+        context 'when shutdown fails' do
+          it "should call power off" do
+            expect(logger).to receive(:error).with('Failed to shutdown cleanly. Calling force poweroff.')
+            expect(domain).to receive(:shutdown).and_raise(IOError)
+            expect(domain).to receive(:poweroff)
+            expect(subject.call(env)).to be_nil
+          end
+        end
+
+        context 'when shutdown exceeds the timeout' do
+          it "should call poweroff" do
+            expect(logger).to receive(:info).with('VM is still running. Calling force poweroff.')
+            expect(domain).to receive(:shutdown).and_raise(Timeout::Error)
+            expect(domain).to receive(:poweroff)
+            expect(subject.call(env)).to be_nil
+          end
+        end
+      end
+
+      context 'when halt exceeds the timeout' do
+        before do
+          expect(logger).to_not receive(:info).with('Trying Libvirt graceful shutdown.')
+          expect(guest).to receive(:capability).with(:halt).and_raise(Timeout::Error)
+        end
+
+        it "should call poweroff" do
+          expect(logger).to receive(:info).with('VM is still running. Calling force poweroff.')
+          expect(domain).to receive(:poweroff)
+          expect(subject.call(env)).to be_nil
+        end
+      end
+    end
+
+    context 'with force halt enabled' do
+      before do
+        allow(env).to receive(:[]).and_call_original
+        expect(env).to receive(:[]).with(:force_halt).and_return(true)
+      end
+
+      it "should just call poweroff" do
+        expect(domain).to receive(:poweroff)
+        expect(subject.call(env)).to be_nil
+      end
+    end
+  end
+end

data/spec/unit/action/handle_box_image_spec.rb

@@ -0,0 +1,363 @@
+require 'spec_helper'
+require 'support/sharedcontext'
+require 'support/libvirt_context'
+
+require 'vagrant-libvirt/action/destroy_domain'
+
+describe VagrantPlugins::ProviderLibvirt::Action::HandleBoxImage do
+  subject { described_class.new(app, env) }
+
+  include_context 'unit'
+  include_context 'libvirt'
+
+  let(:libvirt_client) { double('libvirt_client') }
+  let(:volumes) { double('volumes') }
+  let(:all) { double('all') }
+  let(:box_volume) { double('box_volume') }
+  let(:fog_volume) { double('fog_volume') }
+
+  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(connection).to receive(:volumes).and_return(volumes)
+      allow(volumes).to receive(:all).and_return(all)
+      allow(env[:ui]).to receive(:clear_line)
+
+    end
+
+    context 'when one disk in metadata.json' do
+      before do
+        allow(all).to receive(:first).and_return(box_volume)
+        allow(box_volume).to receive(:id).and_return(1)
+        allow(env[:machine]).to receive_message_chain("box.name") { 'test' }
+        allow(env[:machine]).to receive_message_chain("box.version") { '1.1.1' }
+        allow(env[:machine]).to receive_message_chain("box.metadata") { Hash[
+          'virtual_size'=> 5,
+          'format' => 'qcow2'
+          ]
+        }
+        allow(env[:machine]).to receive_message_chain("box.directory.join") do |arg|
+          '/test/'.concat(arg.to_s)
+        end
+      end
+
+      it 'should have one disk in machine env' do
+        expect(subject.call(env)).to be_nil
+        expect(env[:box_volume_number]).to eq(1)
+        expect(env[:box_volumes]).to eq(
+          [
+            {
+              :path=>"/test/box.img",
+              :name=>"test_vagrant_box_image_1.1.1_box.img",
+              :virtual_size=>5,
+              :format=>"qcow2"
+            }
+          ]
+        )
+      end
+
+      context 'when disk image not in storage pool' do
+        before do
+          allow(File).to receive(:exist?).and_return(true)
+          allow(File).to receive(:size).and_return(5*1024*1024*1024)
+          allow(all).to receive(:first).and_return(nil)
+          allow(subject).to receive(:upload_image).and_return(true)
+          allow(volumes).to receive(:create).and_return(fog_volume)
+        end
+
+        it 'should upload disk' do
+          expect(ui).to receive(:info).with('Uploading base box image as volume into Libvirt storage...')
+          expect(logger).to receive(:info).with('Creating volume test_vagrant_box_image_1.1.1_box.img in storage pool default.')
+          expect(volumes).to receive(:create).with(
+            hash_including(
+              :name => "test_vagrant_box_image_1.1.1_box.img",
+              :allocation => "5120M",
+              :capacity => "5G",
+            )
+          )
+          expect(subject).to receive(:upload_image)
+          expect(subject.call(env)).to be_nil
+        end
+      end
+
+      context 'when disk image already in storage pool' do
+        before do
+          allow(all).to receive(:first).and_return(box_volume)
+          allow(box_volume).to receive(:id).and_return(1)
+        end
+
+        it 'should skip disk upload' do
+          expect(volumes).not_to receive(:create)
+          expect(subject).not_to receive(:upload_image)
+          expect(subject.call(env)).to be_nil
+        end
+      end
+    end
+
+    context 'when three disks in metadata.json' do
+      let(:status) { double }
+
+      before do
+        allow(all).to receive(:first).and_return(box_volume)
+        allow(box_volume).to receive(:id).and_return(1)
+        allow(env[:machine]).to receive_message_chain("box.name") { 'test' }
+        allow(env[:machine]).to receive_message_chain("box.version") { '1.1.1' }
+        allow(env[:machine]).to receive_message_chain("box.metadata") { Hash[
+          'disks' => [
+            {
+              'path' => 'box.img',
+              'name' => 'send_box_name',
+            },
+            {
+              'path' => 'disk.qcow2',
+            },
+            {
+              'path' => 'box_2.img',
+            },
+          ],
+        ]}
+        allow(env[:machine]).to receive_message_chain("box.directory.join") do |arg|
+          '/test/'.concat(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', '/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', '/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
+        ])
+      end
+
+      it 'should have three disks in machine env' do
+        expect(subject.call(env)).to be_nil
+        expect(env[:box_volume_number]).to eq(3)
+        expect(env[:box_volumes]).to eq(
+          [
+            {
+              :path=>"/test/box.img",
+              :name=>"test_vagrant_box_image_1.1.1_send_box_name.img",
+              :virtual_size=>5,
+              :format=>"qcow2"
+            },
+            {
+              :path=>"/test/disk.qcow2",
+              :name=>"test_vagrant_box_image_1.1.1_disk.img",
+              :virtual_size=>10,
+              :format=>"qcow2"
+            },
+            {
+              :path=>"/test/box_2.img",
+              :name=>"test_vagrant_box_image_1.1.1_box_2.img",
+              :virtual_size=>20,
+              :format=>"qcow2"
+            }
+          ]
+        )
+      end
+
+      context 'when none of the disks in storage pool' do
+        before do
+          allow(File).to receive(:exist?).and_return(true)
+          allow(File).to receive(:size).and_return(5*1024*1024*1024, 10*1024*1024*1024, 20*1024*1024*1024)
+          allow(all).to receive(:first).and_return(nil)
+          allow(subject).to receive(:upload_image).and_return(true)
+          allow(volumes).to receive(:create).and_return(fog_volume)
+        end
+
+        it 'should upload all 3 disks' do
+          expect(ui).to receive(:info).with('Uploading base box image as volume into Libvirt storage...')
+          expect(logger).to receive(:info).with('Creating volume test_vagrant_box_image_1.1.1_send_box_name.img in storage pool default.')
+          expect(volumes).to receive(:create).with(
+            hash_including(
+              :name => "test_vagrant_box_image_1.1.1_send_box_name.img",
+              :allocation => "5120M",
+              :capacity => "5G",
+            )
+          )
+          expect(subject).to receive(:upload_image)
+          expect(ui).to receive(:info).with('Uploading base box image as volume into Libvirt storage...')
+          expect(logger).to receive(:info).with('Creating volume test_vagrant_box_image_1.1.1_disk.img in storage pool default.')
+          expect(volumes).to receive(:create).with(
+            hash_including(
+              :name => "test_vagrant_box_image_1.1.1_disk.img",
+              :allocation => "10240M",
+              :capacity => "10G",
+            )
+          )
+          expect(subject).to receive(:upload_image)
+          expect(ui).to receive(:info).with('Uploading base box image as volume into Libvirt storage...')
+          expect(logger).to receive(:info).with('Creating volume test_vagrant_box_image_1.1.1_box_2.img in storage pool default.')
+          expect(volumes).to receive(:create).with(
+            hash_including(
+              :name => "test_vagrant_box_image_1.1.1_box_2.img",
+              :allocation => "20480M",
+              :capacity => "20G",
+            )
+          )
+          expect(subject).to receive(:upload_image)
+
+          expect(subject.call(env)).to be_nil
+        end
+      end
+
+      context 'when only disk 0 in storage pool' do
+        before do
+          allow(File).to receive(:exist?).and_return(true)
+          allow(File).to receive(:size).and_return(10*1024*1024*1024, 20*1024*1024*1024)
+          allow(all).to receive(:first).and_return(box_volume, nil, nil)
+          allow(box_volume).to receive(:id).and_return(1)
+          allow(subject).to receive(:upload_image).and_return(true)
+          allow(volumes).to receive(:create).and_return(fog_volume)
+        end
+
+        it 'upload disks 1 and 2 only' do
+          expect(ui).to receive(:info).with('Uploading base box image as volume into Libvirt storage...')
+          expect(logger).to receive(:info).with('Creating volume test_vagrant_box_image_1.1.1_disk.img in storage pool default.')
+          expect(volumes).to receive(:create).with(hash_including(:name => "test_vagrant_box_image_1.1.1_disk.img"))
+          expect(subject).to receive(:upload_image)
+          expect(ui).to receive(:info).with('Uploading base box image as volume into Libvirt storage...')
+          expect(logger).to receive(:info).with('Creating volume test_vagrant_box_image_1.1.1_box_2.img in storage pool default.')
+          expect(volumes).to receive(:create).with(hash_including(:name => "test_vagrant_box_image_1.1.1_box_2.img"))
+          expect(subject).to receive(:upload_image)
+
+          expect(subject.call(env)).to be_nil
+        end
+      end
+
+      context 'when has all disks on storage pool' do
+        before do
+          allow(all).to receive(:first).and_return(box_volume)
+          allow(box_volume).to receive(:id).and_return(1)
+        end
+
+        it 'should skip disk upload' do
+          expect(ui).not_to receive(:info).with('Uploading base box image as volume into Libvirt storage...')
+          expect(volumes).not_to receive(:create)
+          expect(subject).not_to receive(:upload_image)
+          expect(subject.call(env)).to be_nil
+        end
+      end
+    end
+
+    context 'when wrong box format in metadata.json' do
+      before do
+        allow(all).to receive(:first).and_return(box_volume)
+        allow(box_volume).to receive(:id).and_return(1)
+        allow(env[:machine]).to receive_message_chain("box.name") { 'test' }
+        allow(env[:machine]).to receive_message_chain("box.version") { '1.1.1' }
+        allow(env[:machine]).to receive_message_chain("box.metadata") { Hash[
+          'virtual_size'=> 5,
+          'format' => 'wrongFormat'
+          ]
+        }
+        allow(env[:machine]).to receive_message_chain("box.directory.join") do |arg|
+          '/test/'.concat(arg.to_s)
+        end
+      end
+
+      it 'should raise WrongBoxFormatSet exception' do
+        expect{ subject.call(env) }.to raise_error(VagrantPlugins::ProviderLibvirt::Errors::WrongBoxFormatSet)
+      end
+
+    end
+
+    context 'when invalid format in metadata.json' do
+      let(:status) { double }
+
+      before do
+        allow(all).to receive(:first).and_return(box_volume)
+        allow(box_volume).to receive(:id).and_return(1)
+        allow(env[:machine]).to receive_message_chain("box.name") { 'test' }
+        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)
+        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', '/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', '/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
+        ])
+      end
+
+      context 'with one disk having wrong disk format' do
+        let(:box_metadata) {
+          Hash[
+            'disks' => [
+              {
+                'path'   => 'box.img',
+                'name'   =>'send_box_name.img',
+                'format' => 'wrongFormat'
+              },
+              {
+                'path' => 'disk.qcow2',
+              },
+              {
+                'path' => 'box_2.img',
+              },
+            ],
+          ]
+        }
+
+        it 'should be ignored' do
+          expect(subject.call(env)).to be_nil
+        end
+      end
+
+      context 'with one disk missing path' do
+        let(:box_metadata) {
+          Hash[
+            'disks' => [
+              {
+                'path' => 'box.img',
+              },
+              {
+                'name' => 'send_box_name',
+              },
+              {
+                'path' => 'box_2.img',
+              },
+            ],
+          ]
+        }
+
+        it 'should raise an exception' do
+          expect{ subject.call(env) }.to raise_error(VagrantPlugins::ProviderLibvirt::Errors::BoxFormatMissingAttribute, /: 'disks\[1\]\['path'\]'/)
+        end
+      end
+
+      context 'with one disk name duplicating a path of another' do
+        let(:box_metadata) {
+          Hash[
+            'disks' => [
+              {
+                'path' => 'box.img',
+                'name' => 'box_2',
+              },
+              {
+                'path' => 'disk.qcow2',
+              },
+              {
+                'path' => 'box_2.img',
+              },
+            ],
+          ]
+        }
+
+        it 'should raise an exception' do
+          expect{ subject.call(env) }.to raise_error(VagrantPlugins::ProviderLibvirt::Errors::BoxFormatDuplicateVolume, /test_vagrant_box_image_1.1.1_box_2.img.*'disks\[2\]'.*'disks\[0\]'/)
+        end
+      end
+    end
+  end
+end