derelict_m 0.6.2a

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/executer_spec.rb

@@ -0,0 +1,129 @@
+require "spec_helper"
+
+describe Derelict::Executer do
+  let(:executer) { described_class.new }
+  let(:command) { double("command") }
+  let(:options) { Hash.new }
+  let(:block) { Proc.new do end }
+  let(:result) { double("result") }
+
+  describe ".execute" do
+    before do
+      expect(described_class).to receive(:new).with(options).and_return(executer)
+      expect(executer).to receive(:execute).with(command, &block).and_return(result)
+    end
+
+    subject { described_class.execute command, options, &block }
+    it { should be result }
+  end
+
+  describe "#initialize" do
+    subject { described_class.new options }
+    it { should be_a described_class }
+    its(:stdout) { should eq "" }
+    its(:stderr) { should eq "" }
+    its(:success?) { should be_nil }
+    its(:status) { should be_nil }
+
+    context "with :chars mode specified" do
+      let(:options) { {:mode => :chars} }
+      it { should be_a described_class }
+    end
+  end
+
+  # The way #execute is tested is much slower than a unit test
+  # (obviously), but I ran into some difficulty implementing a proper
+  # unit test for this method.
+  #
+  # TODO: rewrite as a unit test
+  describe "#execute" do
+    subject { executer.execute command, &block }
+
+    context "without a block" do
+      let(:command) { "echo 'test 1'" }
+      its(:stdout) { should eq "test 1\n" }
+      its(:stderr) { should eq "" }
+      its(:success?) { should be_true }
+      its(:status) { should be 0 }
+
+      context "with non-existent command" do
+        let(:command) { "not_actually_a_command" }
+        it "should raise ENOENT" do
+          expect { subject }.to raise_error(Errno::ENOENT)
+        end
+      end
+
+      context "with unsuccessful command" do
+        let(:command) { "false" }
+        its(:success?) { should be_false }
+        its(:status) { should be 1 }
+      end
+
+      # Unfortunately this part is even worse. It seems to work though!
+      # The basic idea is for a thread to kill *this* process once the
+      # sub-process has started. It's still relatively fast, and is at
+      # least an accurate way to model the real-world use.
+      context "when main process is receives a signal" do
+        subject {
+          Thread.new do
+            # Wait for the sub-process to start
+            sleep 0.01 while executer.pid.nil?
+
+            # Send SIGINT to this process, it should get forwarded on
+            # to the sub-process
+            Process.kill "INT", Process.pid
+          end
+
+          # Start the sub-process
+          executer.execute "sleep 10"
+        }
+
+        specify "the sub-process should get killed" do
+          expect(subject.success?).to be_false
+          expect(subject.status).to be nil
+        end
+      end
+    end
+
+    context "with a block" do
+      context "with one argument" do
+        let(:command) { "echo 'test 2'" }
+        let(:block) do
+          @buffer = ""
+          Proc.new do |stdout|
+            @buffer << stdout
+          end
+        end
+
+        its(:stdout) { should eq "test 2\n" }
+        its(:stderr) { should eq "" }
+        its(:success?) { should be_true }
+        its(:status) { should be 0 }
+        specify "the block should get called" do
+          subject; expect(@buffer).to eq executer.stdout
+        end
+      end
+
+      context "with two arguments" do
+        let(:command) { "echo 'test 3'; echo 'test 4' 1>&2" }
+        let(:block) do
+          @stdout = ""; @stderr = ""
+          Proc.new do |stdout, stderr|
+            @stdout << stdout unless stdout.nil?
+            @stderr << stderr unless stderr.nil?
+          end
+        end
+
+        its(:stdout) { should eq "test 3\n" }
+        its(:stderr) { should eq "test 4\n" }
+        its(:success?) { should be_true }
+        its(:status) { should be 0 }
+        specify "the block should get called" do
+          subject
+          expect(@stdout).to eq executer.stdout
+          expect(@stderr).to eq executer.stderr
+        end
+      end
+    end
+  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,258 @@
+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
+
+  describe "#plugins" do
+    subject { instance.plugins }
+    it { should be_a Derelict::Plugin::Manager }
+    its(:instance) { should be instance }
+  end
+
+  describe "#boxes" do
+    subject { instance.boxes }
+    it { should be_a Derelict::Box::Manager }
+    its(:instance) { should be instance }
+  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 Executer" do
+      let(:expected_command) { "/foo/bar/bin/vagrant test arg\\ 1" }
+      before do
+        expect(Derelict::Executer).to receive(:execute).with(expected_command, options).and_return(result)
+      end
+
+      let(:options) { Hash.new }
+
+      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",
+        ]}
+
+        context "with options hash" do
+          let(:options) { {:foo => :bar} }
+          subject { instance.execute :test, "arg 1", options }
+          its(:stdout) { should eq "stdout\n" }
+          its(:stderr) { should eq "stderr\n" }
+          its(:success?) { should be success }
+        end
+
+        context "with :sudo option enabled" do
+          let(:options_argument) { {:sudo => true} }
+          let(:options) { Hash.new } # Don't pass sudo opt to Executer.execute
+          let(:expected_command) { "sudo -- /foo/bar/bin/vagrant test arg\\ 1" }
+          subject { instance.execute :test, "arg 1", options_argument }
+          its(:stdout) { should eq "stdout\n" }
+          its(:stderr) { should eq "stderr\n" }
+          its(:success?) { should be success }
+        end
+      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', STDERR output:\nstderr\n\n",
+          ]}
+        end
+      end
+    end
+  end
+end