derelict 0.0.1 → 0.1.0

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

data/spec/derelict/exception_spec.rb

@@ -0,0 +1,11 @@
+require "spec_helper"
+
+describe Derelict::Exception do
+  it "is autoloaded" do
+    should be_a Derelict::Exception
+  end
+
+  it "inherits from ::Exception" do
+    should be_a ::Exception
+  end
+end

data/spec/derelict/instance/command_failed_spec.rb

@@ -0,0 +1,40 @@
+require "spec_helper"
+
+describe Derelict::Instance::CommandFailed do
+  it "is autoloaded" do
+    should be_a Derelict::Instance::CommandFailed
+  end
+
+  describe "#initialize" do
+    let(:command) { nil }
+    let(:result) { nil }
+    subject { Derelict::Instance::CommandFailed.new command, result }
+
+    context "with no arguments" do
+      its(:message) { should eq "Error executing Vagrant command" }
+    end
+
+    context "with custom command" do
+      let(:command) { "my_command" }
+      its(:message) { should eq "Error executing Vagrant command 'my_command'" }
+    end
+
+    context "with custom result" do
+      let(:result) { double("result", :stderr => "my_stderr") }
+      its(:message) {
+        should eq "Error executing Vagrant command, STDERR output:\nmy_stderr"
+      }
+    end
+
+    context "with custom command and result" do
+      let(:command) { "my_command" }
+      let(:result) { double("result", :stderr => "my_stderr") }
+      its(:message) {
+        should eq [
+          "Error executing Vagrant command 'my_command', ",
+          "STDERR output:\nmy_stderr"
+        ].join
+      }
+    end
+  end
+end

data/spec/derelict/instance/invalid_spec.rb

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

data/spec/derelict/instance/missing_binary_spec.rb

@@ -0,0 +1,13 @@
+require "spec_helper"
+
+describe Derelict::Instance::MissingBinary do
+  subject { Derelict::Instance::MissingBinary.new "/foo/bar" }
+
+  it "is autoloaded" do
+    should be_a Derelict::Instance::MissingBinary
+  end
+
+  its(:message) {
+    should eq "Invalid Derelict instance: 'vagrant' binary not found at /foo/bar"
+  }
+end

data/spec/derelict/instance/non_directory_spec.rb

@@ -0,0 +1,13 @@
+require "spec_helper"
+
+describe Derelict::Instance::NonDirectory do
+  subject { Derelict::Instance::NonDirectory.new "/foo/bar" }
+
+  it "is autoloaded" do
+    should be_a Derelict::Instance::NonDirectory
+  end
+
+  its(:message) {
+    should eq "Invalid Derelict instance: expected directory, found file: /foo/bar"
+  }
+end

data/spec/derelict/instance/not_found_spec.rb

@@ -0,0 +1,13 @@
+require "spec_helper"
+
+describe Derelict::Instance::NotFound do
+  subject { Derelict::Instance::NotFound.new "/foo/bar" }
+
+  it "is autoloaded" do
+    should be_a Derelict::Instance::NotFound
+  end
+
+  its(:message) {
+    should eq "Invalid Derelict instance: directory doesn't exist: /foo/bar"
+  }
+end

data/spec/derelict/instance_spec.rb

@@ -0,0 +1,226 @@
+require "spec_helper"
+
+describe Derelict::Instance do
+  let(:instance) { Derelict::Instance.new path }
+  let(:path) { nil }
+
+  subject { instance }
+
+  it "is autoloaded" do
+    should be_a Derelict::Instance
+  end
+
+  describe "#version" do
+    let(:result) { double("result", :stdout => stdout) }
+    let(:stdout) { double("stdout") }
+    let(:parser) { double("parser", :version => "the version") }
+    subject { instance.version }
+    before {
+      expect(instance).to receive(:execute!).with("--version").and_return(result)
+      expect(Derelict::Parser::Version).to receive(:new).with(stdout).and_return(parser)
+    }
+
+    it "should execute --version and parse the result" do
+      expect(subject).to eq "the version"
+    end
+  end
+
+  context "with path parameter" do
+    let(:path) { "/foo/bar" }
+
+    describe "#initialize" do
+      its(:path) { should eq "/foo/bar" }
+    end
+
+    describe "#validate!" do
+      subject { instance.validate! }
+
+      context "with valid path" do
+        before {
+          expect(File).to receive(:exists?).with("/foo/bar").and_return(true)
+          expect(File).to receive(:directory?).with("/foo/bar").and_return(true)
+          expect(File).to receive(:exists?).with("/foo/bar/bin/vagrant").and_return(true)
+          expect(File).to receive(:executable?).with("/foo/bar/bin/vagrant").and_return(true)
+        }
+
+        it "shouldn't raise any exceptions" do
+          expect { subject }.to_not raise_error
+        end
+
+        it "should be chainable" do
+          expect(subject).to be_a Derelict::Instance
+        end
+
+        include_context "logged messages"
+        let(:expected_logs) {[
+          "DEBUG instance: Successfully initialized Derelict::Instance at '/foo/bar'\n",
+          "DEBUG instance: Starting validation for Derelict::Instance at '/foo/bar'\n",
+          "DEBUG instance: Vagrant binary for Derelict::Instance at '/foo/bar' is '/foo/bar/bin/vagrant'\n",
+          " INFO instance: Successfully validated Derelict::Instance at '/foo/bar'\n",
+        ]}
+      end
+
+      context "with non-existent path" do
+        before {
+          expect(File).to receive(:exists?).with("/foo/bar").and_return(false)
+        }
+
+        it "should raise NotFound" do
+          expect { subject }.to raise_error Derelict::Instance::NotFound
+        end
+
+        include_context "logged messages"
+        let(:expected_logs) {[
+          "DEBUG instance: Successfully initialized Derelict::Instance at '/foo/bar'\n",
+          "DEBUG instance: Starting validation for Derelict::Instance at '/foo/bar'\n",
+        ]}
+      end
+
+      context "with path pointing to a file" do
+        before {
+          expect(File).to receive(:exists?).with("/foo/bar").and_return(true)
+          expect(File).to receive(:directory?).with("/foo/bar").and_return(false)
+        }
+
+        it "should raise NonDirectory" do
+          expect { subject }.to raise_error Derelict::Instance::NonDirectory
+        end
+
+        include_context "logged messages"
+        let(:expected_logs) {[
+          "DEBUG instance: Successfully initialized Derelict::Instance at '/foo/bar'\n",
+          "DEBUG instance: Starting validation for Derelict::Instance at '/foo/bar'\n",
+        ]}
+      end
+
+      context "with vagrant binary missing" do
+        before {
+          expect(File).to receive(:exists?).with("/foo/bar").and_return(true)
+          expect(File).to receive(:directory?).with("/foo/bar").and_return(true)
+          expect(File).to receive(:exists?).with("/foo/bar/bin/vagrant").and_return(false)
+        }
+
+        it "should raise MissingBinary" do
+          expect { subject }.to raise_error Derelict::Instance::MissingBinary
+        end
+
+        include_context "logged messages"
+        let(:expected_logs) {[
+          "DEBUG instance: Successfully initialized Derelict::Instance at '/foo/bar'\n",
+          "DEBUG instance: Starting validation for Derelict::Instance at '/foo/bar'\n",
+          "DEBUG instance: Vagrant binary for Derelict::Instance at '/foo/bar' is '/foo/bar/bin/vagrant'\n",
+        ]}
+      end
+
+      context "with vagrant binary non-executable" do
+        before {
+          expect(File).to receive(:exists?).with("/foo/bar").and_return(true)
+          expect(File).to receive(:directory?).with("/foo/bar").and_return(true)
+          expect(File).to receive(:exists?).with("/foo/bar/bin/vagrant").and_return(true)
+          expect(File).to receive(:executable?).with("/foo/bar/bin/vagrant").and_return(false)
+        }
+
+        it "should raise MissingBinary" do
+          expect { subject }.to raise_error Derelict::Instance::MissingBinary
+        end
+
+        include_context "logged messages"
+        let(:expected_logs) {[
+          "DEBUG instance: Successfully initialized Derelict::Instance at '/foo/bar'\n",
+          "DEBUG instance: Starting validation for Derelict::Instance at '/foo/bar'\n",
+          "DEBUG instance: Vagrant binary for Derelict::Instance at '/foo/bar' is '/foo/bar/bin/vagrant'\n",
+        ]}
+      end
+    end
+
+    describe "#connect" do
+      let(:connection) { double("connection") }
+      let(:connection_path) { double("connection_path", :inspect => "connection_path") }
+      subject { instance.connect connection_path }
+      before do
+        con = Derelict::Connection
+        args = [instance, connection_path]
+        expect(con).to receive(:new).with(*args).and_return(connection)
+        expect(connection).to receive(:validate!).and_return(connection)
+      end
+
+      it { should be connection }
+
+      include_context "logged messages"
+      let(:expected_logs) {[
+        "DEBUG instance: Successfully initialized Derelict::Instance at '/foo/bar'\n",
+        " INFO instance: Creating connection for 'connection_path' by Derelict::Instance at '/foo/bar'\n",
+      ]}
+    end
+
+    context "with mock Shell" do
+      before do
+        cmd = "/foo/bar/bin/vagrant test arg\\ 1"
+        expect(Shell).to receive(:execute).with(cmd).and_return(result)
+      end
+
+      let(:result) do
+        double("result", {
+          :stdout => "stdout\n",
+          :stderr => "stderr\n",
+          :success? => success,
+        })
+      end
+
+      let(:success) { double("success") }
+
+      describe "#execute" do
+        subject { instance.execute :test, "arg 1" }
+        its(:stdout) { should eq "stdout\n" }
+        its(:stderr) { should eq "stderr\n" }
+        its(:success?) { should be success }
+
+        include_context "logged messages"
+        let(:expected_logs) {[
+          "DEBUG instance: Successfully initialized Derelict::Instance at '/foo/bar'\n",
+          "DEBUG instance: Vagrant binary for Derelict::Instance at '/foo/bar' is '/foo/bar/bin/vagrant'\n",
+          "DEBUG instance: Generated command '/foo/bar/bin/vagrant test arg\\ 1' from subcommand 'test' with arguments [\"arg 1\"]\n",
+          "DEBUG instance: Executing /foo/bar/bin/vagrant test arg\\ 1 using Derelict::Instance at '/foo/bar'\n",
+        ]}
+      end
+
+      describe "#execute!" do
+        subject { instance.execute! :test, "arg 1" }
+
+        context "on success" do
+          let(:success) { true }
+
+          its(:stdout) { should eq "stdout\n" }
+          its(:stderr) { should eq "stderr\n" }
+          its(:success?) { should be true }
+
+          include_context "logged messages"
+          let(:expected_logs) {[
+            "DEBUG instance: Successfully initialized Derelict::Instance at '/foo/bar'\n",
+            "DEBUG instance: Vagrant binary for Derelict::Instance at '/foo/bar' is '/foo/bar/bin/vagrant'\n",
+            "DEBUG instance: Generated command '/foo/bar/bin/vagrant test arg\\ 1' from subcommand 'test' with arguments [\"arg 1\"]\n",
+            "DEBUG instance: Executing /foo/bar/bin/vagrant test arg\\ 1 using Derelict::Instance at '/foo/bar'\n",
+          ]}
+        end
+
+        context "on failure" do
+          let(:success) { false }
+
+          it "should raise CommandFailed" do
+            expect { subject }.to raise_error Derelict::Instance::CommandFailed
+          end
+
+          include_context "logged messages"
+          let(:expected_logs) {[
+            "DEBUG instance: Successfully initialized Derelict::Instance at '/foo/bar'\n",
+            "DEBUG instance: Vagrant binary for Derelict::Instance at '/foo/bar' is '/foo/bar/bin/vagrant'\n",
+            "DEBUG instance: Generated command '/foo/bar/bin/vagrant test arg\\ 1' from subcommand 'test' with arguments [\"arg 1\"]\n",
+            "DEBUG instance: Executing /foo/bar/bin/vagrant test arg\\ 1 using Derelict::Instance at '/foo/bar'\n",
+            "DEBUG instance: Generated command '/foo/bar/bin/vagrant test arg\\ 1' from subcommand 'test' with arguments [\"arg 1\"]\n",
+            " WARN instance: Command /foo/bar/bin/vagrant test arg\\ 1 failed: Error executing Vagrant command '/foo/bar/bin/vagrant test arg\\ 1'\n",
+          ]}
+        end
+      end
+    end
+  end
+end

data/spec/derelict/parser/status/invalid_format_spec.rb

@@ -0,0 +1,16 @@
+require "spec_helper"
+
+describe Derelict::Parser::Status::InvalidFormat do
+  it "is autoloaded" do
+    should be_a Derelict::Parser::Status::InvalidFormat
+  end
+
+  context "when using default reason" do
+    its(:message) { should eq "Output from 'vagrant status' was in an unexpected format" }
+  end
+
+  context "when using custom reason" do
+    subject { Derelict::Parser::Status::InvalidFormat.new "reason" }
+    its(:message) { should eq "Output from 'vagrant status' was in an unexpected format: reason" }
+  end
+end