derelict_m 0.6.2a

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/plugin/manager_spec.rb

@@ -0,0 +1,208 @@
+require "spec_helper"
+
+describe Derelict::Plugin::Manager do
+  let(:instance) { double("instance", :description => "test instance") }
+  let(:manager) { Derelict::Plugin::Manager.new instance }
+  subject { manager }
+
+  it "is autoloaded" do
+    should be_a Derelict::Plugin::Manager
+  end
+
+  include_context "logged messages"
+  let(:expected_logs) {[
+    "DEBUG manager: Successfully initialized Derelict::Plugin::Manager for test instance\n"
+  ]}
+
+  describe "#list" do
+    let(:stdout) { "stdout\n" }
+    let(:result) { double("result", :stdout => stdout) }
+    let(:parser) { double("parser", :plugins => plugins) }
+    let(:plugins) { [:foo, :bar] }
+
+    subject { manager.list }
+
+    before do
+      expect(instance).to receive(:execute!).with(:plugin, "list").and_return(result)
+      expect(Derelict::Parser::PluginList).to receive(:new).with(stdout).and_return(parser)
+    end
+
+    it { should be plugins }
+
+    include_context "logged messages"
+    let(:expected_logs) {[
+      "DEBUG manager: Successfully initialized Derelict::Plugin::Manager for test instance\n",
+      " INFO manager: Retrieving Vagrant plugin list for Derelict::Plugin::Manager for test instance\n",
+    ]}
+  end
+
+  describe "#installed?" do
+    let(:plugin_name) { double("plugin_name") }
+    let(:plugin) { double("plugin", :version => plugin_version) }
+    let(:plugin_version) { nil }
+    let(:version) { nil }
+    subject { manager.installed? plugin_name, version }
+
+    context "with known plugin" do
+      before { expect(manager).to receive(:fetch).with(plugin_name).and_return(plugin) }
+
+      context "with version" do
+        let(:version) { "1.2.3" }
+        let(:plugin_version) { "1.2.3" }
+        it { should be true }
+      end
+
+      context "with wrong version" do
+        let(:version) { "1.2.3" }
+        let(:plugin_version) { "2.3.4" }
+        it { should be false }
+      end
+
+      context "without version" do
+        it { should be true }
+      end
+    end
+
+    context "with unknown plugin" do
+      before { expect(manager).to receive(:fetch).with(plugin_name).and_raise(Derelict::Plugin::NotFound.new plugin_name) }
+
+      context "with version" do
+        let(:version) { "3.4.5" }
+        it { should be false }
+      end
+
+      context "without version" do
+        it { should be false }
+      end
+    end
+
+    include_context "logged messages"
+    let(:expected_logs) {[
+      "DEBUG manager: Successfully initialized Derelict::Plugin::Manager for test instance\n",
+      " INFO manager: Retrieving Vagrant plugin list for Derelict::Plugin::Manager for test instance\n",
+    ]}
+  end
+
+  describe "#install" do
+    let(:log) { true }
+    let(:plugin_name) { double("plugin_name", :to_s => "test plugin") }
+    let(:version) { double("version") }
+    let(:result) { double("result") }
+    subject { manager.install plugin_name, :version => version, :log => log }
+
+    before do
+      expect(instance).to receive(:execute!).with(:plugin, "install", plugin_name, '--plugin-version', version).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::Plugin::Manager for test instance\n",
+        " INFO manager: Installing plugin 'test plugin' using Derelict::Plugin::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::Plugin::Manager for test instance\n",
+        " INFO manager: Installing plugin 'test plugin' using Derelict::Plugin::Manager for test instance\n",
+      ]}
+    end
+  end
+
+  describe "#uninstall" do
+    let(:log) { true }
+    let(:plugin_name) { double("plugin_name", :to_s => "test plugin") }
+    let(:result) { double("result") }
+    subject { manager.uninstall plugin_name, :log => log }
+
+    before do
+      expect(instance).to receive(:execute!).with(:plugin, "uninstall", plugin_name).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::Plugin::Manager for test instance\n",
+        " INFO manager: Uninstalling plugin 'test plugin' using Derelict::Plugin::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::Plugin::Manager for test instance\n",
+        " INFO manager: Uninstalling plugin 'test plugin' using Derelict::Plugin::Manager for test instance\n",
+      ]}
+    end
+  end
+
+  describe "#update" do
+    let(:log) { true }
+    let(:plugin_name) { double("plugin_name", :to_s => "test plugin") }
+    let(:result) { double("result") }
+    subject { manager.update plugin_name, :log => log }
+
+    before do
+      expect(instance).to receive(:execute!).with(:plugin, "update", plugin_name).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::Plugin::Manager for test instance\n",
+        " INFO manager: Updating plugin 'test plugin' using Derelict::Plugin::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::Plugin::Manager for test instance\n",
+        " INFO manager: Updating plugin 'test plugin' using Derelict::Plugin::Manager for test instance\n",
+      ]}
+    end
+  end
+
+
+  describe "#fetch" do
+    let(:foo) { double("foo", :name => "foo") }
+    let(:bar) { double("bar", :name => "bar") }
+    let(:plugins) { [foo, bar] }
+
+    let(:plugin_name) { double("plugin_name") }
+    subject { manager.fetch plugin_name }
+    before { expect(manager).to receive(:list).and_return(plugins) }
+
+    context "with known plugin" do
+      let(:plugin_name) { "foo" }
+      it { should be foo }
+    end
+
+    context "with unknown plugin" do
+      let(:plugin_name) { "qux" }
+      it "should raise NotFound" do
+        expect { subject }.to raise_error Derelict::Plugin::NotFound
+      end
+    end
+
+    include_context "logged messages"
+    let(:expected_logs) {[
+      "DEBUG manager: Successfully initialized Derelict::Plugin::Manager for test instance\n",
+    ]}
+  end
+
+end

data/spec/derelict/plugin/not_found_spec.rb

@@ -0,0 +1,13 @@
+require "spec_helper"
+
+describe Derelict::Plugin::NotFound do
+  subject { Derelict::Plugin::NotFound.new "test" }
+
+  it "is autoloaded" do
+    should be_a Derelict::Plugin::NotFound
+  end
+
+  its(:message) {
+    should eq "Plugin 'test' is not currently installed"
+  }
+end

data/spec/derelict/plugin_spec.rb

@@ -0,0 +1,37 @@
+require "spec_helper"
+
+describe Derelict::Plugin do
+  let(:name) { double("name") }
+  let(:version) { double("version") }
+  let(:plugin) { Derelict::Plugin.new name, version }
+  subject { plugin }
+
+  it "is autoloaded" do
+    should be_a Derelict::Plugin
+  end
+
+  its(:name) { should be name }
+  its(:version) { should be version }
+
+  context "when comparing to an equivalent" do
+    let(:other) { plugin.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) { plugin.class.new "not_foo", "1.0" }
+
+    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/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