379 lines
11 KiB
Ruby
379 lines
11 KiB
Ruby
# Copyright (c) HashiCorp, Inc.
|
|
# SPDX-License-Identifier: BUSL-1.1
|
|
|
|
require File.expand_path("../../../../base", __FILE__)
|
|
|
|
describe Vagrant::Action::Builtin::BoxRemove do
|
|
include_context "unit"
|
|
|
|
let(:app) { lambda { |env| } }
|
|
let(:env) { {
|
|
box_collection: box_collection,
|
|
home_path: home_path,
|
|
machine_index: machine_index,
|
|
ui: Vagrant::UI::Silent.new,
|
|
} }
|
|
|
|
subject { described_class.new(app, env) }
|
|
|
|
let(:box_collection) { double("box_collection") }
|
|
let(:home_path) { double("home-path") }
|
|
let(:machine_index) { [] }
|
|
let(:iso_env) { isolated_environment }
|
|
|
|
let(:box) do
|
|
box_dir = iso_env.box3("foo", "1.0", :virtualbox)
|
|
Vagrant::Box.new("foo", :virtualbox, "1.0", box_dir)
|
|
end
|
|
|
|
it "deletes the box if it is the only option" do
|
|
allow(box_collection).to receive(:all).and_return([["foo", "1.0", :virtualbox, nil]])
|
|
|
|
env[:box_name] = "foo"
|
|
|
|
expect(box_collection).to receive(:find).with(
|
|
"foo", :virtualbox, "1.0", nil).and_return(box)
|
|
expect(box_collection).to receive(:clean).with(box.name)
|
|
.and_return(true)
|
|
expect(box).to receive(:destroy!).once
|
|
expect(app).to receive(:call).with(env).once
|
|
|
|
subject.call(env)
|
|
|
|
expect(env[:box_removed]).to equal(box)
|
|
end
|
|
|
|
it "deletes the box with the specified provider if given" do
|
|
allow(box_collection).to receive(:all)
|
|
.and_return([
|
|
["foo", "1.0", :virtualbox],
|
|
["foo", "1.0", :vmware],
|
|
])
|
|
|
|
env[:box_name] = "foo"
|
|
env[:box_provider] = "virtualbox"
|
|
|
|
expect(box_collection).to receive(:find).with(
|
|
"foo", :virtualbox, "1.0", nil).and_return(box)
|
|
expect(box_collection).to receive(:clean).with(box.name)
|
|
.and_return(false)
|
|
expect(box).to receive(:destroy!).once
|
|
expect(app).to receive(:call).with(env).once
|
|
|
|
subject.call(env)
|
|
|
|
expect(env[:box_removed]).to equal(box)
|
|
end
|
|
|
|
it "deletes the box with the specified version if given" do
|
|
allow(box_collection).to receive(:all)
|
|
.and_return([
|
|
["foo", "1.0", :virtualbox],
|
|
["foo", "1.1", :virtualbox],
|
|
])
|
|
|
|
env[:box_name] = "foo"
|
|
env[:box_version] = "1.0"
|
|
|
|
expect(box_collection).to receive(:find).with(
|
|
"foo", :virtualbox, "1.0", nil).and_return(box)
|
|
expect(box_collection).to receive(:clean).with(box.name)
|
|
.and_return(false)
|
|
expect(box).to receive(:destroy!).once
|
|
expect(app).to receive(:call).with(env).once
|
|
|
|
subject.call(env)
|
|
|
|
expect(env[:box_removed]).to equal(box)
|
|
end
|
|
|
|
context "with architecture" do
|
|
let(:architecture) { "test-arch" }
|
|
let(:box) do
|
|
box_dir = iso_env.box3("foo", "1.0", :virtualbox, architecture: architecture)
|
|
Vagrant::Box.new("foo", :virtualbox, "1.0", box_dir, architecture: architecture)
|
|
end
|
|
|
|
it "deletes the box if it is the only option" do
|
|
allow(box_collection).to receive(:all).and_return([["foo", "1.0", :virtualbox, architecture]])
|
|
|
|
env[:box_name] = "foo"
|
|
|
|
expect(box_collection).to receive(:find).
|
|
with("foo", :virtualbox, "1.0", architecture).
|
|
and_return(box)
|
|
expect(box_collection).to receive(:clean).
|
|
with(box.name).
|
|
and_return(true)
|
|
expect(box).to receive(:destroy!).once
|
|
expect(app).to receive(:call).with(env).once
|
|
|
|
subject.call(env)
|
|
|
|
expect(env[:box_removed]).to equal(box)
|
|
end
|
|
|
|
it "deletes the box with the specified provider if given" do
|
|
allow(box_collection).to receive(:all)
|
|
.and_return([
|
|
["foo", "1.0", :virtualbox, architecture],
|
|
["foo", "1.0", :vmware, architecture],
|
|
])
|
|
|
|
env[:box_name] = "foo"
|
|
env[:box_provider] = "virtualbox"
|
|
|
|
expect(box_collection).to receive(:find).with(
|
|
"foo", :virtualbox, "1.0", architecture).and_return(box)
|
|
expect(box_collection).to receive(:clean).with(box.name)
|
|
.and_return(false)
|
|
expect(box).to receive(:destroy!).once
|
|
expect(app).to receive(:call).with(env).once
|
|
|
|
subject.call(env)
|
|
|
|
expect(env[:box_removed]).to equal(box)
|
|
end
|
|
|
|
it "deletes the box with the specified version if given" do
|
|
allow(box_collection).to receive(:all)
|
|
.and_return([
|
|
["foo", "1.0", :virtualbox, architecture],
|
|
["foo", "1.1", :virtualbox, architecture],
|
|
])
|
|
|
|
env[:box_name] = "foo"
|
|
env[:box_version] = "1.0"
|
|
|
|
expect(box_collection).to receive(:find).with(
|
|
"foo", :virtualbox, "1.0", architecture).and_return(box)
|
|
expect(box_collection).to receive(:clean).with(box.name)
|
|
.and_return(false)
|
|
expect(box).to receive(:destroy!).once
|
|
expect(app).to receive(:call).with(env).once
|
|
|
|
subject.call(env)
|
|
|
|
expect(env[:box_removed]).to equal(box)
|
|
end
|
|
|
|
it "deletes the box with the specificed version and architecture" do
|
|
allow(box_collection).to receive(:all)
|
|
.and_return([
|
|
["foo", "1.0", :virtualbox, architecture],
|
|
["foo", "1.0", :virtualbox, "other-arch"],
|
|
])
|
|
|
|
env[:box_name] = "foo"
|
|
env[:box_version] = "1.0"
|
|
env[:box_architecture] = architecture
|
|
|
|
expect(box_collection).to receive(:find).with(
|
|
"foo", :virtualbox, "1.0", architecture).and_return(box)
|
|
expect(box_collection).to receive(:clean).with(box.name)
|
|
.and_return(false)
|
|
expect(box).to receive(:destroy!).once
|
|
expect(app).to receive(:call).with(env).once
|
|
|
|
subject.call(env)
|
|
|
|
expect(env[:box_removed]).to equal(box)
|
|
end
|
|
|
|
it "errors when box with specified version does not included specified architecture" do
|
|
allow(box_collection).to receive(:all)
|
|
.and_return([
|
|
["foo", "1.0", :virtualbox, architecture],
|
|
["foo", "1.0", :virtualbox, "other-arch"],
|
|
])
|
|
|
|
env[:box_name] = "foo"
|
|
env[:box_version] = "1.0"
|
|
env[:box_architecture] = "unknown-arch"
|
|
|
|
expect {
|
|
subject.call(env)
|
|
}.to raise_error(Vagrant::Errors::BoxRemoveArchitectureNotFound)
|
|
end
|
|
|
|
it "errors when box with specified version has multiple architectures" do
|
|
allow(box_collection).to receive(:all)
|
|
.and_return([
|
|
["foo", "1.0", :virtualbox, architecture],
|
|
["foo", "1.0", :virtualbox, "other-arch"],
|
|
])
|
|
|
|
env[:box_name] = "foo"
|
|
env[:box_version] = "1.0"
|
|
|
|
expect {
|
|
subject.call(env)
|
|
}.to raise_error(Vagrant::Errors::BoxRemoveMultiArchitecture)
|
|
end
|
|
end
|
|
|
|
context "checking if a box is in use" do
|
|
def new_entry(name, provider, version, valid=true)
|
|
Vagrant::MachineIndex::Entry.new.tap do |entry|
|
|
entry.extra_data["box"] = {
|
|
"name" => "foo",
|
|
"provider" => "virtualbox",
|
|
"version" => "1.0",
|
|
}
|
|
|
|
allow(entry).to receive(:valid?).and_return(valid)
|
|
end
|
|
end
|
|
|
|
let(:action_runner) { double("action_runner") }
|
|
|
|
before do
|
|
env[:action_runner] = action_runner
|
|
|
|
allow(box_collection).to receive(:all)
|
|
.and_return([
|
|
["foo", "1.0", :virtualbox],
|
|
["foo", "1.1", :virtualbox],
|
|
])
|
|
|
|
env[:box_name] = "foo"
|
|
env[:box_version] = "1.0"
|
|
end
|
|
|
|
it "does delete if the box is not in use" do
|
|
expect(box_collection).to receive(:find).with(
|
|
"foo", :virtualbox, "1.0", nil).and_return(box)
|
|
expect(box).to receive(:destroy!).once
|
|
expect(box_collection).to receive(:clean).with(box.name)
|
|
.and_return(true)
|
|
|
|
subject.call(env)
|
|
end
|
|
|
|
it "does delete if the box is in use and user confirms" do
|
|
machine_index << new_entry("foo", "virtualbox", "1.0")
|
|
|
|
result = { result: true }
|
|
expect(action_runner).to receive(:run).
|
|
with(anything, env).and_return(result)
|
|
|
|
expect(box_collection).to receive(:find).with(
|
|
"foo", :virtualbox, "1.0", nil).and_return(box)
|
|
expect(box_collection).to receive(:clean).with(box.name)
|
|
.and_return(true)
|
|
expect(box).to receive(:destroy!).once
|
|
|
|
subject.call(env)
|
|
end
|
|
|
|
it "doesn't delete if the box is in use" do
|
|
machine_index << new_entry("foo", "virtualbox", "1.0")
|
|
|
|
result = { result: false }
|
|
expect(action_runner).to receive(:run).
|
|
with(anything, env).and_return(result)
|
|
|
|
expect(box_collection).to receive(:find).with(
|
|
"foo", :virtualbox, "1.0", nil).and_return(box)
|
|
expect(box).to receive(:destroy!).never
|
|
|
|
subject.call(env)
|
|
end
|
|
|
|
it "doesn't delete if the box is in use and keep_used_boxes is set" do
|
|
env[:keep_used_boxes] = true
|
|
machine_index << new_entry("foo", "virtualbox", "1.0")
|
|
|
|
result = { result: true }
|
|
expect(action_runner).to receive(:run).
|
|
with(anything, env).and_return(result)
|
|
|
|
expect(box_collection).to receive(:find).with(
|
|
"foo", :virtualbox, "1.0", nil).and_return(box)
|
|
expect(box).to receive(:destroy!).never
|
|
|
|
subject.call(env)
|
|
end
|
|
|
|
it "deletes if the box is in use and force is used" do
|
|
machine_index << new_entry("foo", "virtualbox", "1.0")
|
|
|
|
result = { result: true }
|
|
expect(action_runner).to receive(:run).
|
|
with(anything, env).and_return(result)
|
|
|
|
expect(box_collection).to receive(:find).with(
|
|
"foo", :virtualbox, "1.0", nil).and_return(box)
|
|
expect(box_collection).to receive(:clean).with(box.name)
|
|
.and_return(true)
|
|
expect(box).to receive(:destroy!)
|
|
|
|
subject.call(env)
|
|
end
|
|
end
|
|
|
|
it "errors if the box doesn't exist" do
|
|
allow(box_collection).to receive(:all).and_return([])
|
|
|
|
expect(app).to receive(:call).never
|
|
|
|
expect { subject.call(env) }.
|
|
to raise_error(Vagrant::Errors::BoxRemoveNotFound)
|
|
end
|
|
|
|
it "errors if the specified provider doesn't exist" do
|
|
env[:box_name] = "foo"
|
|
env[:box_provider] = "bar"
|
|
|
|
allow(box_collection).to receive(:all).and_return([["foo", "1.0", :virtualbox]])
|
|
|
|
expect(app).to receive(:call).never
|
|
|
|
expect { subject.call(env) }.
|
|
to raise_error(Vagrant::Errors::BoxRemoveProviderNotFound)
|
|
end
|
|
|
|
it "errors if there are multiple providers" do
|
|
env[:box_name] = "foo"
|
|
|
|
allow(box_collection).to receive(:all)
|
|
.and_return([
|
|
["foo", "1.0", :virtualbox],
|
|
["foo", "1.0", :vmware],
|
|
])
|
|
|
|
expect(app).to receive(:call).never
|
|
|
|
expect { subject.call(env) }.
|
|
to raise_error(Vagrant::Errors::BoxRemoveMultiProvider)
|
|
end
|
|
|
|
it "errors if the specified provider has multiple versions" do
|
|
env[:box_name] = "foo"
|
|
env[:box_provider] = "virtualbox"
|
|
|
|
allow(box_collection).to receive(:all)
|
|
.and_return([
|
|
["foo", "1.0", :virtualbox],
|
|
["foo", "1.1", :virtualbox],
|
|
])
|
|
|
|
expect(app).to receive(:call).never
|
|
|
|
expect { subject.call(env) }.
|
|
to raise_error(Vagrant::Errors::BoxRemoveMultiVersion)
|
|
end
|
|
|
|
it "errors if the specified version doesn't exist" do
|
|
env[:box_name] = "foo"
|
|
env[:box_version] = "1.1"
|
|
|
|
allow(box_collection).to receive(:all).and_return([["foo", "1.0", :virtualbox]])
|
|
|
|
expect(app).to receive(:call).never
|
|
|
|
expect { subject.call(env) }.
|
|
to raise_error(Vagrant::Errors::BoxRemoveVersionNotFound)
|
|
end
|
|
end
|