derelict_m 0.6.2a

data/lib/derelict/virtual_machine/invalid.rb

@@ -0,0 +1,14 @@
+module Derelict
+  class VirtualMachine
+    # Represents an invalid virtual machine, which Derelict can't use
+    class Invalid < ::Derelict::Exception
+      include Derelict::Exception::OptionalReason
+
+      private
+        # Retrieves the default error message
+        def default_message
+          "Invalid Derelict virtual machine"
+        end
+    end
+  end
+end

data/lib/derelict/virtual_machine/not_found.rb

@@ -0,0 +1,18 @@
+module Derelict
+  class VirtualMachine
+    # The requested virtual machine isn't defined in the Vagrantfile
+    class NotFound < Invalid
+      # Initializes a new instance of this exception for a given name
+      #
+      #   * name:       The requested name of the virtual machine
+      #   * connection: The Derelict connection used for this VM
+      def initialize(name, connection = nil)
+        if connection.respond_to? :path
+          super "Virtual machine #{name} not found in #{connection.path}"
+        else
+          super "Virtual machine #{name} not found"
+        end
+      end
+    end
+  end
+end

data/spec/coverage_helper.rb

@@ -0,0 +1,19 @@
+if ENV['TRAVIS']
+  # Running on Travis CI: initialize Coveralls to submit coverage data
+  require "coveralls"
+  Coveralls.wear!
+else
+  # Not running on Travis CI: Run SimpleCov locally for coverage data
+  # Since SimpleCov requires Ruby 1.9+, only include it if we're
+  # running on a compatible version.
+  version_major = RbConfig::CONFIG["MAJOR"].to_i
+  version_minor = RbConfig::CONFIG["MINOR"].to_i
+  if version_major >= 2 or (version_major == 1 and version_minor >= 9)
+    require "simplecov"
+    SimpleCov.start do
+      add_filter "/spec/"
+      add_filter "/vendor/"
+    end
+  end
+end
+

data/spec/derelict/box/manager_spec.rb

@@ -0,0 +1,171 @@
+require "spec_helper"
+
+describe Derelict::Box::Manager do
+  let(:instance) { double("instance", :description => "test instance") }
+  let(:manager) { Derelict::Box::Manager.new instance }
+  subject { manager }
+
+  it "is autoloaded" do
+    should be_a Derelict::Box::Manager
+  end
+
+  include_context "logged messages"
+  let(:expected_logs) {[
+    "DEBUG manager: Successfully initialized Derelict::Box::Manager for test instance\n"
+  ]}
+
+  describe "#list" do
+    let(:stdout) { "stdout\n" }
+    let(:result) { double("result", :stdout => stdout) }
+    let(:parser) { double("parser", :boxes => boxes) }
+    let(:boxes) { [:foo, :bar] }
+
+    subject { manager.list }
+
+    before do
+      expect(instance).to receive(:execute!).with(:box, "list").and_return(result)
+      expect(Derelict::Parser::BoxList).to receive(:new).with(stdout).and_return(parser)
+    end
+
+    it { should be boxes }
+
+    include_context "logged messages"
+    let(:expected_logs) {[
+      "DEBUG manager: Successfully initialized Derelict::Box::Manager for test instance\n",
+      " INFO manager: Retrieving Vagrant box list for Derelict::Box::Manager for test instance\n",
+    ]}
+  end
+
+  describe "#present?" do
+    let(:box_name) { double("box_name") }
+    let(:box) { double("box", :provider => box_provider) }
+    let(:box_provider) { nil }
+    let(:provider) { nil }
+    subject { manager.present? box_name, provider }
+
+    context "with known box" do
+      before { expect(manager).to receive(:fetch).with(box_name, provider).and_return(box) }
+
+      let(:provider) { "provider_one" }
+      let(:box_provider) { "provider_one" }
+      it { should be true }
+    end
+
+    context "with unknown box" do
+      before { expect(manager).to receive(:fetch).with(box_name, provider).and_raise(Derelict::Box::NotFound.new box_name, provider) }
+      it { should be false }
+    end
+
+    include_context "logged messages"
+    let(:expected_logs) {[
+      "DEBUG manager: Successfully initialized Derelict::Box::Manager for test instance\n",
+      " INFO manager: Retrieving Vagrant box list for Derelict::Box::Manager for test instance\n",
+    ]}
+  end
+
+  describe "#add" do
+    let(:log) { true }
+    let(:box_name) { double("box_name", :to_s => "test box") }
+    let(:source) { double("source", :to_s => "test source") }
+    let(:result) { double("result") }
+    let(:options) { {:log => log} }
+    subject { manager.add box_name, source, options }
+
+    context "with force disabled" do
+      before do
+        expect(instance).to receive(:execute!).with(:box, "add", box_name, source).and_yield("test", nil).and_return(result)
+      end
+
+      it { should be result }
+
+      context "with logging enabled" do
+        include_context "logged messages"
+        let(:expected_logs) {[
+          "DEBUG manager: Successfully initialized Derelict::Box::Manager for test instance\n",
+          " INFO manager: Adding box 'test box' from 'test source' using Derelict::Box::Manager for test instance\n",
+          " INFO external: test\n",
+        ]}
+      end
+
+      context "with logging disabled" do
+        let(:log) { false }
+        include_context "logged messages"
+        let(:expected_logs) {[
+          "DEBUG manager: Successfully initialized Derelict::Box::Manager for test instance\n",
+          " INFO manager: Adding box 'test box' from 'test source' using Derelict::Box::Manager for test instance\n",
+        ]}
+      end
+    end
+
+    context "with force enabled" do
+      before do
+        expect(instance).to receive(:execute!).with(:box, "add", box_name, source, "--force").and_return(result)
+      end
+
+      let(:options) { {:force => true} }
+      it { should be result }
+    end
+  end
+
+  describe "#remove" do
+    let(:log) { true }
+    let(:box_name) { "test_box" }
+    let(:provider) { "provider_one" }
+    let(:result) { double("result") }
+    subject { manager.remove box_name, :provider => provider, :log => log }
+
+    before do
+      expect(instance).to receive(:execute!).with(:box, "remove", box_name, provider).and_yield("test", nil).and_return(result)
+    end
+
+    it { should be result }
+
+    context "with logging enabled" do
+      include_context "logged messages"
+      let(:expected_logs) {[
+        "DEBUG manager: Successfully initialized Derelict::Box::Manager for test instance\n",
+        " INFO manager: Removing box 'test_box' for 'provider_one' using Derelict::Box::Manager for test instance\n",
+        " INFO external: test\n",
+      ]}
+    end
+
+    context "with logging disabled" do
+      let(:log) { false }
+      include_context "logged messages"
+      let(:expected_logs) {[
+        "DEBUG manager: Successfully initialized Derelict::Box::Manager for test instance\n",
+        " INFO manager: Removing box 'test_box' for 'provider_one' using Derelict::Box::Manager for test instance\n",
+      ]}
+    end
+  end
+
+  describe "#fetch" do
+    let(:foo) { double("foo", :name => "foo", :provider => "provider_one") }
+    let(:bar) { double("bar", :name => "bar", :provider => "provider_two") }
+    let(:boxes) { [foo, bar] }
+
+    let(:box_name) { double("box_name") }
+    let(:box_provider) { double("box_provider") }
+    subject { manager.fetch box_name, box_provider }
+    before { expect(manager).to receive(:list).and_return(boxes) }
+
+    context "with known box" do
+      let(:box_name) { "foo" }
+      let(:box_provider) { "provider_one" }
+      it { should be foo }
+    end
+
+    context "with unknown box" do
+      let(:box_name) { "qux" }
+      it "should raise NotFound" do
+        expect { subject }.to raise_error Derelict::Box::NotFound
+      end
+    end
+
+    include_context "logged messages"
+    let(:expected_logs) {[
+      "DEBUG manager: Successfully initialized Derelict::Box::Manager for test instance\n",
+    ]}
+  end
+
+end

data/spec/derelict/box/not_found_spec.rb

@@ -0,0 +1,13 @@
+require "spec_helper"
+
+describe Derelict::Box::NotFound do
+  subject { Derelict::Box::NotFound.new "test", "provider_one" }
+
+  it "is autoloaded" do
+    should be_a Derelict::Box::NotFound
+  end
+
+  its(:message) {
+    should eq "Box 'test' for provider 'provider_one' missing"
+  }
+end

data/spec/derelict/box_spec.rb

@@ -0,0 +1,37 @@
+require "spec_helper"
+
+describe Derelict::Box do
+  let(:name) { double("name") }
+  let(:provider) { double("provider") }
+  let(:box) { Derelict::Box.new name, provider }
+  subject { box }
+
+  it "is autoloaded" do
+    should be_a Derelict::Box
+  end
+
+  its(:name) { should be name }
+  its(:provider) { should be provider }
+
+  context "when comparing to an equivalent" do
+    let(:other) { box.dup }
+
+    it { should eq other }
+    its(:hash) { should eq other.hash }
+
+    specify "#eql?(other) should be true" do
+      expect(subject.eql? other).to be true
+    end
+  end
+
+  context "when comparing to a non-equivalent" do
+    let(:other) { box.class.new "not_foo", "other_provider" }
+
+    it { should_not eq other }
+    its(:hash) { should_not eq other.hash }
+
+    specify "#eql?(other) should be false" do
+      expect(subject.eql? other).to be false
+    end
+  end
+end

data/spec/derelict/connection/invalid_spec.rb

@@ -0,0 +1,16 @@
+require "spec_helper"
+
+describe Derelict::Connection::Invalid do
+  it "is autoloaded" do
+    should be_a Derelict::Connection::Invalid
+  end
+
+  context "when using default reason" do
+    its(:message) { should eq "Invalid Derelict connection" }
+  end
+
+  context "when using custom reason" do
+    subject { Derelict::Connection::Invalid.new "reason" }
+    its(:message) { should eq "Invalid Derelict connection: reason" }
+  end
+end

data/spec/derelict/connection/not_found_spec.rb

@@ -0,0 +1,13 @@
+require "spec_helper"
+
+describe Derelict::Connection::NotFound do
+  subject { Derelict::Connection::NotFound.new "/foo/bar" }
+
+  it "is autoloaded" do
+    should be_a Derelict::Connection::NotFound
+  end
+
+  its(:message) {
+    should eq "Invalid Derelict connection: Vagrantfile not found for /foo/bar"
+  }
+end

data/spec/derelict/connection_spec.rb

@@ -0,0 +1,107 @@
+require "spec_helper"
+
+describe Derelict::Connection do
+  let(:description) { "the test instance" }
+  let(:instance) { double("instance", :description => description) }
+  let(:path) { "/baz/qux" }
+  let(:connection) { Derelict::Connection.new instance, path }
+  subject { connection }
+
+  it "is autoloaded" do
+    should be_a Derelict::Connection
+  end
+
+  include_context "logged messages"
+  let(:expected_logs) {[
+    "DEBUG connection: Successfully initialized Derelict::Connection at '/baz/qux' using the test instance\n"
+  ]}
+
+  describe "#validate!" do
+    subject { connection.validate! }
+    let(:exists?) { double("exists?") }
+    before do
+      expect(File).to receive(:exists?).with(path).and_return(exists?)
+    end
+
+    context "with valid data" do
+      let(:exists?) { true }
+      it { should be connection }
+
+      include_context "logged messages"
+      let(:expected_logs) {[
+        "DEBUG connection: Successfully initialized Derelict::Connection at '/baz/qux' using the test instance\n",
+        "DEBUG connection: Starting validation for Derelict::Connection at '/baz/qux' using the test instance\n",
+        " INFO connection: Successfully validated Derelict::Connection at '/baz/qux' using the test instance\n",
+      ]}
+    end
+
+    context "with invalid data" do
+      let(:exists?) { false }
+      it "should raise NotFound" do
+        expect { subject }.to raise_error Derelict::Connection::NotFound
+      end
+
+      include_context "logged messages"
+      let(:expected_logs) {[
+        "DEBUG connection: Successfully initialized Derelict::Connection at '/baz/qux' using the test instance\n",
+        "DEBUG connection: Starting validation for Derelict::Connection at '/baz/qux' using the test instance\n",
+      ]}
+    end
+  end
+
+  describe "#execute" do
+    subject { connection.execute :test, "arg 1" }
+
+    it "should change current working directory first" do
+      expect(Dir).to receive(:chdir).with(path).and_return(:foo) # no yield
+      expect(instance).to_not receive(:execute)
+      expect(subject).to be :foo
+    end
+
+    it "should delegate to @instance#execute" do
+      expect(Dir).to receive(:chdir).with(path).and_yield
+      expect(instance).to receive(:execute).with(:test, "arg 1").and_return(:bar)
+      expect(subject).to be :bar
+    end
+
+    include_context "logged messages"
+    let(:expected_logs) {[
+      "DEBUG connection: Successfully initialized Derelict::Connection at '/baz/qux' using the test instance\n",
+      "DEBUG connection: Executing test [\"arg 1\"] on Derelict::Connection at '/baz/qux' using the test instance\n",
+    ]}
+  end
+
+  describe "#execute!" do
+    subject { connection.execute! :test, "arg 1" }
+
+    it "should change current working directory first" do
+      expect(Dir).to receive(:chdir).with(path).and_return(:foo) # no yield
+      expect(instance).to_not receive(:execute!)
+      expect(subject).to be :foo
+    end
+
+    it "should delegate to @instance#execute!" do
+      expect(Dir).to receive(:chdir).with(path).and_yield
+      expect(instance).to receive(:execute!).with(:test, "arg 1").and_return(:bar)
+      expect(subject).to be :bar
+    end
+  end
+
+  describe "#vm" do
+    let(:name) { :test }
+    let(:vm) { double("vm") }
+    before do
+      c = Derelict::VirtualMachine
+      expect(c).to receive(:new).with(connection, name).and_return(vm)
+      expect(vm).to receive(:validate!).and_return(vm)
+    end
+    subject { connection.vm name }
+    it { should be vm }
+
+    include_context "logged messages"
+    let(:expected_logs) {[
+      "DEBUG connection: Successfully initialized Derelict::Connection at '/baz/qux' using the test instance\n",
+      "DEBUG connection: Retrieving VM 'test' from Derelict::Connection at '/baz/qux' using the test instance\n",
+    ]}
+  end
+end

data/spec/derelict/exception/optional_reason_spec.rb

@@ -0,0 +1,41 @@
+require "spec_helper"
+
+describe Derelict::Exception::OptionalReason do
+  context "with #default_message left unimplemented" do
+    let(:exception) do
+      Class.new ::Exception do
+        include Derelict::Exception::OptionalReason
+      end
+    end
+
+    describe "#initialize" do
+      subject { exception.new reason }
+      let(:reason) { "test reason" }
+
+      it "should raise NotImplementedError" do
+        expect { subject }.to raise_error NotImplementedError
+      end
+    end
+  end
+
+  context "with #default_message implemented" do
+    let(:exception) do
+      Class.new ::Exception do
+        include Derelict::Exception::OptionalReason
+        private
+          def default_message
+            "test"
+          end
+      end
+    end
+
+    describe "#initialize" do
+      subject { exception.new reason }
+      let(:reason) { "test reason" }
+
+      it "should raise NotImplementedError" do
+        expect { subject }.to_not raise_error
+      end
+    end
+  end
+end