motherbrain 0.0.0.placeholder → 0.13.1

data/spec/unit/mb/job_manager_spec.rb

@@ -0,0 +1,56 @@
+require 'spec_helper'
+
+describe MB::JobManager do
+  let(:fake_job) do
+    Class.new do
+      include Celluloid
+
+      attr_reader :id, :type, :state, :status, :status_buffer, :result
+      attr_reader :time_start, :time_end
+
+      @id = 1
+      @type = 'fake'
+      @state = :pending
+      @status = ""
+      @status_buffer = [""]
+      @result = nil
+    end
+  end
+
+  before(:each) { @fake_job = fake_job.new }
+
+  describe "#add" do
+    it "adds a job to the active jobs list" do
+      subject.add(@fake_job)
+
+      subject.active.should have(1).item
+      subject.active[0].id.should == @fake_job.id
+      subject.active[0].should be_a(MB::JobRecord)
+    end
+
+    it "monitors the given job" do
+      subject.add(@fake_job)
+
+      subject.should be_monitoring(@fake_job)
+    end
+  end
+
+  describe "#find" do
+    it "returns a record of the job" do
+      subject.add(@fake_job)
+
+      subject.find(@fake_job.id).should be_a(MB::JobRecord)
+    end
+  end
+
+  describe "#complete_job" do
+    before(:each) do
+      subject.add(@fake_job)
+      subject.complete_job(@fake_job)
+    end
+
+    it "removes the given job from the active job list" do
+      subject.active.should have(0).items
+    end
+  end
+end

data/spec/unit/mb/job_record_spec.rb

@@ -0,0 +1,60 @@
+require 'spec_helper'
+
+describe MB::JobRecord do
+  let(:job) do
+    double('job',
+      id: '123',
+      type: 'bootstrap',
+      state: 'pending',
+      status: 'just starting',
+      status_buffer: ['just starting'],
+      result: 'finished',
+      time_start: Time.now,
+      time_end: Time.now
+    )
+  end
+
+  describe "#to_hash" do
+    subject { described_class.new(job).to_hash }
+
+    it "has the 'id' of the given Job" do
+      subject[:id].should eql(job.id)
+    end
+
+    it "has the 'type' of the given Job" do
+      subject[:type].should eql(job.type)
+    end
+
+    it "has the 'state' of the given Job" do
+      subject[:state].should eql(job.state)
+    end
+
+    it "has the 'status' of the given Job" do
+      subject[:status].should eql(job.status)
+    end
+
+    it "has the 'result' of the given Job" do
+      subject[:result].should eql(job.result)
+    end
+
+    it "has the 'time_start' of the given Job" do
+      subject[:time_start].should eql(job.time_start)
+    end
+
+    it "has the 'time_end' of the given Job" do
+      subject[:time_end].should eql(job.time_end)
+    end
+  end
+
+  describe "#to_json" do
+    subject { described_class.new(job).to_json }
+
+    it { should have_json_path("id") }
+    it { should have_json_path("type") }
+    it { should have_json_path("state") }
+    it { should have_json_path("status") }
+    it { should have_json_path("result") }
+    it { should have_json_path("time_start") }
+    it { should have_json_path("time_end") }
+  end
+end

data/spec/unit/mb/job_spec.rb

@@ -0,0 +1,201 @@
+require 'spec_helper'
+
+describe MB::Job do
+  let(:type) { :provision }
+
+  describe "ClassMethods" do
+    subject { described_class }
+
+    describe "::new" do
+      subject { described_class.new(type) }
+
+      before(:each) { subject }
+      after(:each) { subject.terminate if subject.alive? }
+
+      it "starts in PENDING state" do
+        subject.should be_pending
+      end
+
+      it "starts with a nil result" do
+        subject.result.should be_nil
+      end
+
+      it "has a value for id" do
+        subject.id.should_not be_nil
+      end
+
+      it "registers a job with JobManager" do
+        MB::JobManager.instance.active.should have(1).item
+        MB::JobManager.instance.active[0].id.should == subject.id
+      end
+    end
+  end
+
+  subject { described_class.new(type) }
+
+  describe "#completed?" do
+    it "should be completed if status is 'success'" do
+      subject.transition(:running)
+      subject.transition(:success)
+
+      subject.should be_completed
+    end
+
+    it "should be completed if status is 'failure'" do
+      subject.transition(:running)
+      subject.transition(:failure)
+
+      subject.should be_completed
+    end
+
+    it "should not be completed if status is 'pending'" do
+      subject.should_not be_completed
+    end
+
+    it "should not be completed if status is 'running'" do
+      subject.transition(:running)
+
+      subject.should_not be_completed
+    end
+  end
+
+  describe "#failure?" do
+    it "should be a failure if status is 'failure'" do
+      subject.transition(:running)
+      subject.transition(:failure)
+
+      subject.should be_failure
+    end
+
+    it "should not be a failure if status is not 'failure'" do
+      subject.transition(:running)
+      subject.transition(:success)
+
+      subject.should_not be_failure
+    end
+  end
+
+  describe "#pending?" do
+    it "should be pending if status is 'pending'" do
+      subject.should be_pending
+    end
+
+    it "should not be a pending if status is not 'pending'" do
+      subject.transition(:running)
+
+      subject.should_not be_pending
+    end
+  end
+
+  describe "#running?" do
+    it "should be running if status is 'running'" do
+      subject.transition(:running)
+
+      subject.should be_running
+    end
+
+    it "should not be running if status is not 'running'" do
+      subject.transition(:running)
+      subject.transition(:success)
+
+      subject.should_not be_running
+    end
+  end
+
+  describe "#success?" do
+    it "should be a success if status is 'success'" do
+      subject.transition(:running)
+      subject.transition(:success)
+
+      subject.should be_success
+    end
+
+    it "should not be success if status is not 'success'" do
+      subject.transition(:running)
+      subject.transition(:failure)
+
+      subject.should_not be_success
+    end
+  end
+
+  describe "#transition" do
+    it "returns self" do
+      expect(subject.transition(:running)).to eq(subject)
+    end
+
+    it "accepts and sets a result/reason" do
+      subject.transition(:running, "a reason")
+
+      subject.result.should eql("a reason")
+      subject.should be_running
+    end
+
+    describe "to pending" do
+      it "has a nil time_start field" do
+        subject.transition(:pending)
+
+        subject.time_start.should be_nil
+      end
+
+      it "has a nil time_end field" do
+        subject.transition(:pending)
+
+        subject.time_end.should be_nil
+      end
+    end
+
+    describe "to running" do
+      before(:each) { subject.transition(:pending) }
+
+      it "has a Time value for time_start" do
+        subject.transition(:running)
+
+        subject.time_start.should be_a(Time)
+      end
+
+      it "has a nil time_end field" do
+        subject.time_end.should be_nil
+      end
+    end
+
+    describe "to success" do
+      before(:each) do
+        subject.transition(:pending)
+        subject.transition(:running)
+        @time_start = subject.time_start
+      end
+
+      it "doesn't modify the value for time_start" do
+        subject.transition(:success)
+
+        subject.time_start.should eql(@time_start)
+      end
+
+      it "has a Time value for time_end" do
+        subject.transition(:success)
+
+        subject.time_end.should be_a(Time)
+      end
+    end
+
+    describe "to failure" do
+      before(:each) do
+        subject.transition(:pending)
+        subject.transition(:running)
+        @time_start = subject.time_start
+      end
+
+      it "doesn't modify the value for time_start" do
+        subject.transition(:failure)
+
+        subject.time_start.should eql(@time_start)
+      end
+
+      it "has a Time value for time_end" do
+        subject.transition(:failure)
+
+        subject.time_end.should be_a(Time)
+      end
+    end
+  end
+end

data/spec/unit/mb/locks_manager_spec.rb

@@ -0,0 +1,88 @@
+require 'spec_helper'
+
+describe MB::LockManager do
+  subject { described_class.new }
+
+  describe "#locks" do
+    it "returns a Set" do
+      subject.locks.should be_a(Set)
+    end
+  end
+
+  describe "#find" do
+    it "returns a Chef::Mutex if a mutex is registered" do
+      mutex = double('mutex', type: :chef_environment, name: "my_environment")
+      subject.stub(:locks).and_return([mutex])
+
+      subject.find(chef_environment: "my_environment").should eql(mutex)
+    end
+
+    it "returns nil if a mutex with the given name is not registered" do
+      subject.find(chef_environment: "not-there-lock").should be_nil
+    end
+  end
+
+  describe "#register_lock" do
+    let(:mutex) { double('lock') }
+
+    it "adds the given lock to the list of locks" do
+      subject.register(mutex)
+
+      subject.locks.should have(1).item
+      subject.locks.should include(mutex)
+    end
+  end
+
+  describe "#unregister_lock" do
+    let(:mutex) { double('lock') }
+    before(:each) { subject.register(mutex) }
+
+    it "removes the given lock from the list of locks" do
+      subject.unregister(mutex)
+
+      subject.locks.should have(0).items
+    end
+  end
+
+  describe "#lock" do
+    let(:environment) { "rspec-test" }
+    let(:job) { MB::Job.new(:lock) }
+
+    it "creates a new ChefMutex and locks it" do
+      mutex = double('mutex')
+      mutex.should_receive(:lock)
+      MB::ChefMutex.should_receive(:new).and_return(mutex)
+
+      subject.lock(job, environment)
+    end
+  end
+
+  describe "#async_lock" do
+    let(:environment) { "rspec-test" }
+
+    it "returns a JobRecord" do
+      expect(subject.async_lock(environment)).to be_a(MB::JobRecord)
+    end
+  end
+
+  describe "unlock" do
+    let(:environment) { "rspec-test" }
+    let(:job) { MB::Job.new(:unlock) }
+
+    it "creates a new ChefMutex and unlocks it" do
+      mutex = double('mutex')
+      mutex.should_receive(:unlock)
+      MB::ChefMutex.should_receive(:new).and_return(mutex)
+
+      subject.unlock(job, environment)
+    end
+  end
+
+  describe "#async_unlock" do
+    let(:environment) { "rspec-test" }
+
+    it "returns a JobRecord" do
+      expect(subject.async_unlock(environment)).to be_a(MB::JobRecord)
+    end
+  end
+end

data/spec/unit/mb/logging_spec.rb

@@ -0,0 +1,133 @@
+require 'spec_helper'
+
+describe MB::Logging do
+  before :each do
+    klass.reset
+  end
+
+  describe "ClassMethods" do
+    subject { MB::Logging }
+
+    describe "::logger" do
+      it "returns a Logger class" do
+        subject.logger.should be_a(Logger)
+      end
+    end
+
+    describe "::setup" do
+      subject(:logger) { MB::Logging.logger }
+
+      let(:options) { Hash.new }
+
+      it "remembers options when called multiple times" do
+        klass.setup level: Logger::DEBUG, location: STDERR
+        klass.setup Hash.new
+
+        logger.instance_variable_get(:@logdev).dev.should == STDERR
+        logger.debug?.should be_true
+      end
+
+      before :each do
+        klass.setup options
+      end
+
+      it "defaults to WARN" do
+        logger.warn?.should be_true
+      end
+
+      context "with level: INFO" do
+        let(:options) { { level: Logger::INFO } }
+
+        its(:info?) { should be_true }
+      end
+
+      context "when passed 'INFO' as string" do
+        let(:options) { { level: 'INFO' } }
+
+        its(:info?) { should be_true }
+      end
+
+      context "with level: Logger::DEBUG" do
+        let(:options) { { level: Logger::DEBUG } }
+
+        its(:debug?) { should be_true }
+      end
+
+      context "when passed 'DEBUG' as string" do
+        let(:options) { { level: 'DEBUG' } }
+
+        its(:debug?) { should be_true }
+      end
+
+      context "when passed 'WARN' as string" do
+        let(:options) { { level: 'WARN' } }
+
+        its(:warn?) { should be_true }
+      end
+
+      context "when passed 'ERROR' as string" do
+        let(:options) { { level: 'ERROR' } }
+
+        its(:error?) { should be_true }
+      end
+
+      context "when passed 'FATAL' as string" do
+        let(:options) { { level: 'FATAL' } }
+
+        its(:fatal?) { should be_true }
+      end
+
+      it "defaults to 'application.log' in the MB Logs directory" do
+        logger.instance_variable_get(:@logdev).dev.path.should == MB::FileSystem.logs.join('application.log').to_s
+      end
+
+      context "when passed STDOUT as a string" do
+        let(:options) { { location: "STDOUT" } }
+
+        it "constantizes STDOUT" do
+          logger.instance_variable_get(:@logdev).dev.should == STDOUT
+        end
+      end
+
+      context "when passed STDERR as a string" do
+        let(:options) { { location: "STDERR" } }
+
+        it "constantizes STDERR" do
+          logger.instance_variable_get(:@logdev).dev.should == STDERR
+        end
+      end
+
+      context "with a path" do
+        let(:location) { File.join tmp_path, "log.txt" }
+        let(:options) { { location: location } }
+
+        it "logs to the path" do
+          logger.instance_variable_get(:@logdev).dev.path.should == location
+        end
+      end
+    end
+
+    describe "::set_logger" do
+      it "sets the logger to the given instance" do
+        new_logger = Logger.new('/dev/null')
+        subject.set_logger(new_logger)
+
+        subject.logger.should eql(new_logger)
+      end
+    end
+  end
+
+  subject do
+    Class.new do
+      include MB::Logging
+    end.new
+  end
+
+  describe "#logger" do
+    it "delegates to MB::Logging.logger" do
+      MB::Logging.should_receive(:logger)
+
+      subject.logger
+    end
+  end
+end