derelict 0.0.1 → 0.1.0

data/spec/derelict/parser/status_spec.rb

@@ -0,0 +1,214 @@
+require "spec_helper"
+
+describe Derelict::Parser::Status do
+  subject { Derelict::Parser::Status.new output }
+  let(:output) { nil }
+
+  it "is autoloaded" do
+    should be_a Derelict::Parser::Status
+  end
+
+  context "with valid output" do
+    let(:output) {
+      <<-END.gsub /^ +/, ""
+        Current machine states:
+
+        foo                       not created (virtualbox)
+
+        The environment has not yet been created. Run `vagrant up` to
+        create the environment. If a machine is not created, only the
+        default provider will be shown. So if a provider is not listed,
+        then the machine is not created for that environment.
+      END
+    }
+
+    describe "#vm_names" do
+      subject { Derelict::Parser::Status.new(output).vm_names }
+      it { should eq Set[:foo] }
+
+      include_context "logged messages"
+      let(:expected_logs) {[
+        "DEBUG status: Successfully initialized Derelict::Parser::Status instance\n",
+        "DEBUG status: Parsing states from VM list using Derelict::Parser::Status instance\n",
+        "DEBUG status: Parsing VM list from output using Derelict::Parser::Status instance\n",
+      ]}
+    end
+
+    describe "#exists?" do
+      it "should return true for 'foo' VM" do
+        expect(subject.exists?(:foo)).to be true
+      end
+
+      it "should return false for unknown VM" do
+        expect(subject.exists?(:bar)).to be false
+      end
+
+      include_context "logged messages"
+      let(:expected_logs) {[
+        "DEBUG status: Successfully initialized Derelict::Parser::Status instance\n",
+      ]}
+    end
+
+    describe "#state" do
+      it "should return :not_created for 'foo' VM" do
+        expect(subject.state(:foo)).to be :not_created
+      end
+
+      it "should return :not_created for unknown VM" do
+        type = Derelict::VirtualMachine::NotFound
+        expect { subject.state(:bar) }.to raise_error type
+      end
+
+      include_context "logged messages"
+      let(:expected_logs) {[
+        "DEBUG status: Successfully initialized Derelict::Parser::Status instance\n",
+      ]}
+    end
+  end
+
+  context "with multi-machine output" do
+    let(:output) {
+      <<-END.gsub /^ +/, ""
+        Current machine states:
+
+        foo                       not created (virtualbox)
+        bar                       not created (virtualbox)
+
+        This environment represents multiple VMs. The VMs are all listed
+        above with their current state. For more information about a specific
+        VM, run `vagrant status NAME`.
+      END
+    }
+
+    describe "#vm_names" do
+      subject { Derelict::Parser::Status.new(output).vm_names }
+      it { should eq Set[:foo, :bar] }
+
+      include_context "logged messages"
+      let(:expected_logs) {[
+        "DEBUG status: Successfully initialized Derelict::Parser::Status instance\n",
+        "DEBUG status: Parsing states from VM list using Derelict::Parser::Status instance\n",
+        "DEBUG status: Parsing VM list from output using Derelict::Parser::Status instance\n",
+      ]}
+    end
+
+    describe "#exists?" do
+      it "should return true for 'foo' VM" do
+        expect(subject.exists?(:foo)).to be true
+      end
+
+      it "should return true for 'bar' VM" do
+        expect(subject.exists?(:bar)).to be true
+      end
+
+      it "should return false for unknown VM" do
+        expect(subject.exists?(:baz)).to be false
+      end
+
+      include_context "logged messages"
+      let(:expected_logs) {[
+        "DEBUG status: Successfully initialized Derelict::Parser::Status instance\n",
+      ]}
+    end
+
+    describe "#state" do
+      it "should return :not_created for 'foo' VM" do
+        expect(subject.state(:foo)).to be :not_created
+      end
+
+      it "should return :not_created for 'bar' VM" do
+        expect(subject.state(:bar)).to be :not_created
+      end
+
+      it "should return :not_created for unknown VM" do
+        type = Derelict::VirtualMachine::NotFound
+        expect { subject.state(:baz) }.to raise_error type
+      end
+
+      include_context "logged messages"
+      let(:expected_logs) {[
+        "DEBUG status: Successfully initialized Derelict::Parser::Status instance\n",
+      ]}
+    end
+  end
+
+
+  context "with invalid list format" do
+    let(:output) {
+      <<-END.gsub /^ +/, ""
+        This output is missing the list of virtual machines.
+      END
+    }
+
+    describe "#vm_names" do
+      subject { Derelict::Parser::Status.new(output).vm_names }
+      it "should raise InvalidFormat" do
+        type = Derelict::Parser::Status::InvalidFormat
+        message = [
+          "Output from 'vagrant status' was in an unexpected format: ",
+          "Couldn't find VM list",
+        ].join
+        expect { subject }.to raise_error type, message
+      end
+
+      include_context "logged messages"
+      let(:expected_logs) {[
+        "DEBUG status: Successfully initialized Derelict::Parser::Status instance\n",
+        "DEBUG status: Parsing states from VM list using Derelict::Parser::Status instance\n",
+        "DEBUG status: Parsing VM list from output using Derelict::Parser::Status instance\n",
+      ]}
+    end
+
+    describe "#state" do
+      subject { Derelict::Parser::Status.new(output).state(:foo) }
+      it "should raise InvalidFormat" do
+        type = Derelict::Parser::Status::InvalidFormat
+        message = [
+          "Output from 'vagrant status' was in an unexpected format: ",
+          "Couldn't find VM list",
+        ].join
+        expect { subject }.to raise_error type, message
+      end
+
+      include_context "logged messages"
+      let(:expected_logs) {[
+        "DEBUG status: Successfully initialized Derelict::Parser::Status instance\n",
+        "DEBUG status: Parsing states from VM list using Derelict::Parser::Status instance\n",
+        "DEBUG status: Parsing VM list from output using Derelict::Parser::Status instance\n",
+      ]}
+    end
+  end
+
+  context "with invalid VM format" do
+    let(:output) {
+      <<-END.gsub /^ +/, ""
+        Current machine states:
+
+        foo                       this line is missing brackets!
+        bar                       not created (virtualbox)
+
+        This environment represents multiple VMs. The VMs are all listed
+        above with their current state. For more information about a specific
+        VM, run `vagrant status NAME`.
+      END
+    }
+
+    describe "#vm_names" do
+      subject { Derelict::Parser::Status.new(output).vm_names }
+      it "should raise InvalidFormat" do
+        type = Derelict::Parser::Status::InvalidFormat
+        message = "Output from 'vagrant status' was in an unexpected format: Couldn't parse VM list"
+        expect { subject.parse! }.to raise_error type, message
+      end
+    end
+
+    describe "#state" do
+      subject { Derelict::Parser::Status.new(output).state(:foo) }
+      it "should raise InvalidFormat" do
+        type = Derelict::Parser::Status::InvalidFormat
+        message = "Output from 'vagrant status' was in an unexpected format: Couldn't parse VM list"
+        expect { subject }.to raise_error type, message
+      end
+    end
+  end
+end

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

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

data/spec/derelict/parser/version_spec.rb

@@ -0,0 +1,31 @@
+require "spec_helper"
+
+describe Derelict::Parser::Version do
+  let(:parser) { Derelict::Parser::Version.new stdout }
+
+  describe "#version" do
+    subject { parser.version }
+
+    context "on Vagrant 1.0.7" do
+      let(:stdout) { "Vagrant version 1.0.7\n" }
+      it { should eq "1.0.7" }
+
+      include_context "logged messages"
+      let(:expected_logs) {[
+        "DEBUG version: Successfully initialized Derelict::Parser::Version instance\n",
+        "DEBUG version: Parsing version from output using Derelict::Parser::Version instance\n",
+      ]}
+    end
+
+    context "on Vagrant 1.3.4" do
+      let(:stdout) { "Vagrant v1.3.4\n" }
+      it { should eq "1.3.4" }
+
+      include_context "logged messages"
+      let(:expected_logs) {[
+        "DEBUG version: Successfully initialized Derelict::Parser::Version instance\n",
+        "DEBUG version: Parsing version from output using Derelict::Parser::Version instance\n",
+      ]}
+    end
+  end
+end

data/spec/derelict/parser_spec.rb

@@ -0,0 +1,24 @@
+require "spec_helper"
+
+describe Derelict::Parser do
+  let(:output) { nil }
+  subject { Derelict::Parser.new output }
+
+  it "is autoloaded" do
+    should be_a Derelict::Parser
+  end
+
+  describe "#initialize" do
+    let(:output) { "the output" }
+    let(:description) { "test parser" }
+
+    it "should store output" do
+      expect(subject.output).to eq "the output"
+    end
+
+    include_context "logged messages"
+    let(:expected_logs) {[
+      "DEBUG parser: Successfully initialized Derelict::Parser (unknown type)\n",
+    ]}
+  end
+end

data/spec/derelict/utils/logger/array_outputter_spec.rb

@@ -0,0 +1,40 @@
+require "spec_helper"
+
+describe Derelict::Utils::Logger::ArrayOutputter do
+  let(:logger) { Log4r::Logger.new "test::array_outputter_spec" }
+  let(:outputter) { Derelict::Utils::Logger::ArrayOutputter.new "test" }
+  before { logger.outputters = [outputter] }
+  subject { outputter }
+
+  describe "#level" do
+    subject { outputter.level }
+    it { should be Log4r::ALL }
+  end
+
+  context "with no data" do
+    describe "#messages" do
+      subject { outputter.messages }
+      it { should eq [] }
+    end
+
+    describe "#flush" do
+      subject { outputter.flush }
+      it { should eq [] }
+    end
+  end
+
+  context "after INFO level log" do
+    before { logger.info "test info message" }
+    let(:message) { " INFO array_outputter_spec: test info message\n" }
+
+    describe "#messages" do
+      subject { outputter.messages }
+      it { should eq [message] }
+    end
+
+    context "then #flush" do
+      subject { outputter.flush }
+      it { should eq [message] }
+    end
+  end
+end

data/spec/derelict/utils/logger/invalid_type_spec.rb

@@ -0,0 +1,13 @@
+require "spec_helper"
+
+describe Derelict::Utils::Logger::InvalidType do
+  subject { Derelict::Utils::Logger::InvalidType.new "test type" }
+
+  it "is autoloaded" do
+    should be_a Derelict::Utils::Logger::InvalidType
+  end
+
+  its(:message) {
+    should eq "Invalid logger type 'test type'"
+  }
+end

data/spec/derelict/utils/logger/raw_formatter_spec.rb

@@ -0,0 +1,17 @@
+require "spec_helper"
+
+describe Derelict::Utils::Logger::RawFormatter do
+  let(:formatter) { Derelict::Utils::Logger::RawFormatter.new }
+  subject { formatter }
+
+  it "is autoloaded" do
+    should be_a Derelict::Utils::Logger::RawFormatter
+  end
+
+  describe "#format" do
+    let(:data) { double("data") }
+    let(:event) { double("event", :data => data) }
+    subject { formatter.format event }
+    it { should be data }
+  end
+end

data/spec/derelict/utils/logger_spec.rb

@@ -0,0 +1,35 @@
+require "spec_helper"
+
+describe Derelict::Utils::Logger do
+  let(:logger) do
+    Module.new do
+      extend Derelict::Utils::Logger
+      private
+        def self.logger_name
+          "test"
+        end
+    end
+  end
+
+  describe "#logger" do
+    subject { logger.logger options }
+    let(:options) { {:type => type} }
+    let(:type) { :nil }
+
+    context "internal type" do
+      let(:type) { :internal }
+      it { should be_a Log4r::Logger }
+    end
+
+    context "external type" do
+      let(:type) { :external }
+      it { should be_a Log4r::Logger }
+    end
+
+    context "invalid type" do
+      it "should raise InvalidType" do
+        expect { subject }.to raise_error Derelict::Utils::Logger::InvalidType
+      end
+    end
+  end
+end

data/spec/derelict/virtual_machine/invalid_spec.rb

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

data/spec/derelict/virtual_machine/not_found_spec.rb

@@ -0,0 +1,34 @@
+require "spec_helper"
+
+describe Derelict::VirtualMachine::NotFound do
+  let(:connection) { double("connection") }
+  let(:name) { "foo" }
+  let(:exception) { Derelict::VirtualMachine::NotFound.new name, connection }
+  subject { exception }
+
+  it "is autoloaded" do
+    should be_a Derelict::VirtualMachine::NotFound
+  end
+
+  describe "#message" do
+    subject { exception.message }
+
+    context "with invalid connection" do
+      let(:expected) {
+        "Invalid Derelict virtual machine: Virtual machine foo not found"
+      }
+      it { should eq expected }
+    end
+
+    context "with invalid connection" do
+      let(:connection) { double("connection", :path => "/foo") }
+      let(:expected) {
+        [
+          "Invalid Derelict virtual machine: Virtual machine ",
+          "foo not found in /foo",
+        ].join
+      }
+      it { should eq expected }
+    end
+  end
+end