motherbrain 0.0.0.placeholder → 0.13.1

data/spec/unit/mb/error_handler_spec.rb

@@ -0,0 +1,173 @@
+require 'spec_helper'
+
+describe MotherBrain::ErrorHandler do
+  subject { error_handler }
+
+  let(:error_handler) { klass.new error, options }
+
+  let(:error) { ZeroDivisionError.new }
+  let(:options) {
+    {
+      backtrace: backtrace,
+      method_name: method_name,
+      plugin_name: plugin_name,
+      file_path: file_path,
+      plugin_version: plugin_version,
+      text: text
+    }
+  }
+
+  let(:backtrace) { nil }
+  let(:method_name) { nil }
+  let(:plugin_name) { nil }
+  let(:file_path) { nil }
+  let(:plugin_version) { nil }
+  let(:text) { nil }
+
+  it { should be_a klass }
+
+  context "when passed an error class" do
+    let(:error) { ZeroDivisionError }
+
+    its(:error) { should be_instance_of error }
+  end
+
+  describe "#message" do
+    subject(:message) { error_handler.message }
+
+    it { should be_a String }
+
+    context "with all options" do
+      let(:backtrace) {
+        ["(eval):123:in `block in from_file'"]
+      }
+      let(:method_name) { :wat }
+      let(:plugin_name) { "abc" }
+      let(:file_path) { "/a/b/c.rb" }
+      let(:plugin_version) { "1.2.3" }
+      let(:text) { "There was an error" }
+
+      it {
+        message.should == <<-MESSAGE.gsub(/^\s+/, '')
+         abc (1.2.3)
+         /a/b/c.rb, on line 123, in 'wat'
+         There was an error
+        MESSAGE
+      }
+    end
+
+    context "with a caller array" do
+      let(:backtrace) {
+        ["(eval):123:in `block in from_file'"]
+      }
+
+      it { should include "line 123" }
+    end
+
+    context "with a method name" do
+      let(:method_name) { :wat }
+
+      it { should include method_name.to_s }
+    end
+
+    context "with a name and version" do
+      let(:plugin_name) { "abc" }
+      let(:plugin_version) { "1.2.3" }
+
+      it { should include "abc (1.2.3)" }
+    end
+
+    context "with a path" do
+      let(:file_path) { "/a/b/c.rb" }
+
+      it { should include file_path }
+    end
+
+    context "with text" do
+      let(:text) { "There was an error" }
+
+      it { should include text }
+    end
+  end
+
+  describe ".wrap" do
+    subject { klass.wrap error, options }
+
+    it { -> { subject }.should raise_error error.class }
+  end
+
+  describe "#line_number" do
+    subject { error_handler.line_number }
+
+    let(:backtrace) { [line] }
+
+    context "with an eval'd line" do
+      let(:line) { "(eval):123:in `block in from_file'" }
+
+      it { should == 123 }
+    end
+
+    context "with a sourced line" do
+      let(:line) { "/Users/JohnDoe/a/b/c.rb:123:in `method'" }
+
+      it { should == 123 }
+    end
+  end
+
+  describe "#file_contents" do
+    subject { error_handler.file_contents }
+
+    let(:file_contents) { "abc123" }
+    let(:file_path) { "/a/b/c.rb" }
+
+    before :each do
+      File.stub(:exist?).with(file_path).and_return(true)
+      File.stub(:read).with(file_path).and_return(file_contents)
+    end
+
+    it { should == file_contents }
+
+    context "with no file_path" do
+      let(:file_path) { nil }
+
+      it { should be_nil }
+    end
+  end
+
+  describe "#relevant_source_lines" do
+    subject { error_handler.relevant_source_lines }
+
+    let(:backtrace) { ["something:6:something"] }
+    let(:file_contents) {
+      <<-FILE.gsub(/^\s{8}/, '')
+        require 'motherbrain'
+
+        module MyModule
+          class MyClass
+            def my_method
+              do :one
+              do :two
+              do :three
+            end
+          end
+        end
+      FILE
+    }
+    let(:file_path) { "/a/b/c.rb" }
+
+    before :each do
+      File.stub(:exist?).with(file_path).and_return(true)
+      File.stub(:read).with(file_path).and_return(file_contents)
+    end
+
+    it {
+      should == <<-OUTPUT.gsub(/^\s{8}/, '').rstrip
+         4:     def my_method
+         5:       do :one
+         6>>      do :two
+         7:       do :three
+         8:     end
+      OUTPUT
+    }
+  end
+end

data/spec/unit/mb/errors_spec.rb

@@ -0,0 +1,132 @@
+require 'spec_helper'
+
+describe MB::Errors do
+  subject { described_class }
+
+  describe "::error_codes" do
+    subject { described_class.error_codes }
+
+    it "returns a Hash" do
+      subject.should be_a(Hash)
+    end
+  end
+
+  describe "::register" do
+    let(:err_class) do
+      double('error', error_code: -999)
+    end
+
+    before(:each) { subject.unregister(err_class) }
+
+    it "adds the error to the errors hash identified by the error_code" do
+      subject.register(err_class)
+
+      subject.error_codes[-999].should eql(err_class)
+    end
+
+    it "raises a RuntimeError if an exception attempts to register with an in-use error code" do
+      subject.register(err_class)
+
+      expect {
+        subject.register(err_class)
+      }.to raise_error(RuntimeError)
+    end
+  end
+end
+
+describe MB::MBError do
+  let(:error) { described_class.new("rspec test message") }
+
+  describe "#exit_code" do
+    subject { error.exit_code }
+
+    it { should be_a(Integer) }
+  end
+
+  describe "#error_code" do
+    subject { error.error_code }
+
+    it { should be_a(Integer) }
+  end
+
+  describe "#message" do
+    subject { error.message }
+
+    it { should be_a(String) }
+  end
+
+  describe "#to_s" do
+    subject { error.to_s }
+
+    it "includes the error code" do
+      subject.should include("[err_code]: #{error.error_code}")
+    end
+
+    it "includes the error message" do
+      subject.should include("[message]: #{error.message}")
+    end
+  end
+
+  describe "#to_hash" do
+    subject { error.to_hash }
+
+    it "contains an :code key with the exceptions error_code for it's value" do
+      subject.should have_key(:code)
+      subject[:code].should eql(error.error_code)
+    end
+
+    it "contains a :message key with the exceptions message for it's value" do
+      subject.should have_key(:message)
+      subject[:message].should eql(error.message)
+    end
+  end
+
+  describe "#to_json" do
+    subject { error.to_json }
+
+    it { should have_json_path("code") }
+    it { should have_json_path("message") }
+  end
+end
+
+describe MB::GroupBootstrapError do
+  let(:bootstrap_response) do
+    {
+      "euca-10-20-37-171.eucalyptus.cloud.riotgames.com" => {
+        groups: ["activemq::master"],
+        result: {
+          status: :error, message: "something helpful", bootstrap_type: :full
+        }
+      },
+      "euca-10-20-37-172.eucalyptus.cloud.riotgames.com" => {
+        groups: ["activemq::master"],
+        result: {
+          status: :error, message: "something helpful", bootstrap_type: :partial
+        }
+      }
+    }
+  end
+
+  subject { described_class.new(bootstrap_response) }
+
+  its(:groups) { should have(1).item }
+  its(:host_errors) { should have(2).item }
+  its(:message) { should be_a(String) }
+end
+
+describe MB::ServiceRunListNotFound do
+  describe "with string" do
+    subject { described_class.new("abc") }
+    
+    it "should use the string" do
+      expect(subject.message).to match(/abc/)
+    end
+  end
+  describe "with array" do
+    subject { described_class.new(["a", "b", "c"]) }
+
+    it "should join the array and use the resulting string" do
+      expect(subject.message).to match(/a, b, c/)
+    end
+  end
+end

data/spec/unit/mb/file_system/tempfile_spec.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+
+describe MB::FileSystem::Tempfile do
+  subject { described_class }
+
+  describe "::new" do
+    it "creates a new temp file within MB's temp file system" do
+      file = subject.new
+      file.close
+
+      file.path.should include(MB::FileSystem.tmp.to_s)
+    end
+  end
+end

data/spec/unit/mb/file_system_spec.rb

@@ -0,0 +1,69 @@
+require 'spec_helper'
+
+describe MB::FileSystem do
+  describe ".init" do
+    subject(:init) { described_class.init }
+
+    it "creates the directory structure" do
+      FileUtils.should_receive(:mkdir_p).exactly(5).times
+
+      init
+    end
+  end
+
+  describe ".logs" do
+    subject(:logs) { described_class.logs }
+
+    it { should be_a(Pathname) }
+
+    it "is a path within the root of the motherbrain filesystem" do
+      expect(logs.to_s).to include(MB::FileSystem.root.to_s)
+    end
+  end
+
+  describe ".manifests" do
+    subject(:manifests) { described_class.manifests }
+
+    it { should be_a(Pathname) }
+
+    it "is a path within the root of the motherbrain filesystem" do
+      expect(manifests.to_s).to include(MB::FileSystem.root.to_s)
+    end
+  end
+
+  describe ".root" do
+    subject(:root) { described_class.root }
+
+    it { should be_a(Pathname) }
+  end
+
+  describe ".tmp" do
+    subject(:tmp) { described_class.tmp }
+
+    it { should be_a(Pathname) }
+
+    it "is a path within the root of the motherbrain filesystem" do
+      expect(tmp.to_s).to include(MB::FileSystem.root.to_s)
+    end
+  end
+
+  describe ".tmpdir" do
+    subject(:tmpdir) { described_class.tmpdir }
+
+    it { should be_a(String) }
+
+    it "creates a temporary directory in the motherbrain temp filesystem" do
+      expect(tmpdir).to include(MB::FileSystem.tmp.to_s)
+    end
+
+    context "when given a prefix" do
+      subject(:tmpdir) { described_class.tmpdir(prefix) }
+
+      let(:prefix) { "test" }
+
+      it "creates a directory with that prefix" do
+        expect(tmpdir.split(?/).last).to be_start_with(prefix)
+      end
+    end
+  end
+end

data/spec/unit/mb/gear_spec.rb

@@ -0,0 +1,125 @@
+require 'spec_helper'
+
+describe MB::Gear::Base do
+  subject do
+    Class.new(described_class).new
+  end
+
+  describe "#run" do
+    it "raises an AbstractFunction error when not implemented" do
+      lambda {
+        subject.run(double('job'), double('environment'))
+      }.should raise_error(MB::AbstractFunction)
+    end
+  end
+end
+
+describe MB::Gear do
+  before(:each) do
+    @original = MB::Gear.all
+    MB::Gear.clear!
+  end
+
+  after(:each) do
+    MB::Gear.clear!
+    @original.each do |k|
+      MB::Gear.register(k)
+    end
+  end
+
+  describe "ClassMethods" do
+    subject { MB::Gear }
+
+    describe "::all" do
+      it "returns a Set" do
+        subject.all.should be_a(Set)
+      end
+
+      context "when no gears are registered" do
+        before(:each) { subject.clear! }
+
+        it "returns an empty Set" do
+          subject.all.should be_empty
+        end
+      end
+
+      context "when a gear is registered" do
+        before(:each) do
+          @gear_1 = Class.new(MB::Gear::Base) do
+            register_gear :fake_one
+          end
+
+          @gear_2 = Class.new(MB::Gear::Base) do
+            register_gear :fake_two
+          end
+        end
+
+        it "returns an array with the registered gears" do
+          subject.all.should have(2).item
+          subject.all.should include(@gear_1)
+          subject.all.should include(@gear_2)
+        end
+      end
+    end
+
+    describe "::clear!" do
+      it "sets ::all to an empty Set" do
+        subject.clear!
+
+        subject.all.should be_empty
+      end
+    end
+
+    describe "::find_by_keyword" do
+      before(:each) do
+        @klass = Class.new(MB::Gear::Base) do
+          register_gear :fake_gear
+        end
+      end
+
+      it "returns the class with the registered keyword" do
+        subject.find_by_keyword(:fake_gear).should eql(@klass)
+      end
+
+      it "returns nil if a class with the given keyword is not registered" do
+        subject.find_by_keyword(:not_registered).should be_nil
+      end
+    end
+  end
+
+  describe "::register_gear" do
+    it "sets the keyword class attribute" do
+      @klass = Class.new(MB::Gear::Base) do
+        register_gear :racer
+      end
+
+      @klass.keyword.should eql(:racer)
+    end
+
+    context "when registering a keyword that has already been used" do
+      it "raises a DuplicateGearKeyword error" do
+        Class.new(MB::Gear::Base) do
+          register_gear :racer
+        end
+
+        lambda {
+          Class.new(MB::Gear::Base) do
+            register_gear :racer
+          end
+        }.should raise_error(MB::DuplicateGearKeyword)
+      end
+    end
+
+    context "when registering a RESERVED_KEYWORD" do
+      it "raises a ReservedGearKeyword error" do
+        MB::Gear::RESERVED_KEYWORDS.each do |key|
+          lambda {
+            Class.new(MB::Gear::Base) do
+              register_gear key
+            end
+          }.should raise_error(MB::ReservedGearKeyword)
+        end
+      end
+    end
+  end
+end