motherbrain 0.0.0.placeholder → 0.13.1

data/spec/unit/mb/bootstrap/worker_spec.rb

@@ -0,0 +1,194 @@
+require 'spec_helper'
+
+describe MB::Bootstrap::Worker do
+  let(:node_querier) { double('node_querier') }
+  let(:chef_connection) { double('chef_connection') }
+
+  let(:address) { "cloud-1.riotgames.com" }
+  let(:host) { described_class::Host.new(address) }
+
+  let(:options) { Hash.new }
+
+  let(:instance) { described_class.new }
+  subject { instance }
+
+  before { host.stub(node_name: nil) }
+
+  describe "#run" do
+    pending
+  end
+
+  describe "#full_bootstrap" do
+    let(:chef_connection) { double('chef_connection') }
+    let(:response) { Ridley::HostConnector::Response.new("cloud-1.riotgames.com", exit_code: 0) }
+
+    before do
+      subject.stub(chef_connection: chef_connection)
+      chef_connection.stub_chain(:node, :bootstrap).and_return(response)
+    end
+
+    let(:result) { subject.full_bootstrap(host) }
+
+    it "returns an Hash" do
+      expect(result).to be_a(Hash)
+    end
+
+    it "has a :node_name key" do
+      expect(result).to have_key(:node_name)
+    end
+
+    it "has a :hostname key" do
+      expect(result).to have_key(:hostname)
+    end
+
+    it "has a :bootstrap_type key with the value :full" do
+      expect(result).to have_key(:bootstrap_type)
+      expect(result[:bootstrap_type]).to eql(:full)
+    end
+
+    it "has a :message key" do
+      expect(result).to have_key(:message)
+    end
+
+    it "has a :status key" do
+      expect(result).to have_key(:status)
+    end
+
+    context "when response is a failure" do
+      before do
+        response.exit_code = -1
+        response.stderr = "OH NO AN ERROR"
+      end
+
+      it "sets the value of the :status key to :error" do
+        expect(result[:status]).to eql(:error)
+      end
+
+      it "has the value of STDERR for :message" do
+        expect(result[:message]).to eql(response.stderr)
+      end
+    end
+
+    context "when response is a success" do
+      before { response.exit_code = 0 }
+
+      it "sets the value of the :status key to :ok" do
+        expect(result[:status]).to eql(:ok)
+      end
+
+      it "has a blank value for :message" do
+        expect(result[:message]).to be_blank
+      end
+    end
+  end
+
+  describe "#partial_bootstrap" do
+    before { host.stub(node_name: "cloud-1") }
+
+    before(:each) do
+      subject.stub(node_querier: node_querier, chef_connection: chef_connection)
+      node_querier.stub(put_secret: nil, chef_run: nil)
+      chef_connection.stub_chain(:node, :merge_data)
+    end
+
+    let(:result) { subject.partial_bootstrap(host) }
+    let(:options) { Hash.new }
+
+    it "merges the given data with chef, puts the chef secret on the node, and then runs chef" do
+      chef_connection.node.should_receive(:merge_data).with(host.node_name, options)
+      node_querier.should_receive(:put_secret).with(host.hostname).ordered
+      node_querier.should_receive(:chef_run).with(host.hostname).ordered
+
+      subject.partial_bootstrap(host)
+    end
+
+    it "returns a Hash" do
+      expect(result).to be_a(Hash)
+    end
+
+    it "has a :node_name key" do
+      expect(result).to have_key(:node_name)
+    end
+
+    it "has a :hostname key" do
+      expect(result).to have_key(:hostname)
+    end
+
+    it "has a value of :partial for :bootstrap_type" do
+      expect(result[:bootstrap_type]).to eql(:partial)
+    end
+
+    it "has a value of :ok for :status" do
+      expect(result[:status]).to eql(:ok)
+    end
+
+    it "has a :message key" do
+      expect(result).to have_key(:message)
+    end
+
+    context "when placing the secret file on the node fails" do
+      let(:exception) { MB::RemoteFileCopyError.new("error in copy") }
+
+      before { node_querier.should_receive(:put_secret).and_raise(exception) }
+
+      it "sets the value of the :status key to :error" do
+        expect(result[:status]).to eql(:error)
+      end
+
+      it "has the string representation of the raised exception for :message" do
+        expect(result[:message]).to eql(exception.to_s)
+      end
+    end
+
+    context "when running chef on the node fails" do
+      let(:exception) { MB::RemoteCommandError.new("error in command") }
+
+      before { node_querier.should_receive(:chef_run).and_raise(exception) }
+
+      it "sets the value of the :status key to :error" do
+        expect(result[:status]).to eql(:error)
+      end
+
+      it "has the string representation of the raised exception for :message" do
+        expect(result[:message]).to eql(exception.to_s)
+      end
+    end
+
+    context "when the node does not have a node object in the Chef server" do
+      let(:node_resource) { double('node_resource') }
+      let(:options) { { run_list: "some_list", attributes: "some_attrs" } }
+      before do
+        chef_connection.stub(node: node_resource)
+        node_resource.should_receive(:merge_data).and_raise(Ridley::Errors::ResourceNotFound)
+      end
+
+      it "sets the response to error" do
+        expect(result[:status]).to eq(:error)
+      end
+    end
+  end
+end
+
+describe MB::Bootstrap::Worker::Host do
+  let(:address) { "reset.riotgames.com" }
+  subject { described_class.new(address) }
+
+  its(:hostname) { should eql(address) }
+
+  context "when the host is registered to Chef" do
+    before { MB::NodeQuerier.instance.stub(:registered_as).with(address).and_return(nil) }
+
+    its(:node_name) { should be_nil }
+    its(:partial_bootstrap?) { should be_false }
+    its(:full_bootstrap?) { should be_true }
+  end
+
+  context "when the host is not registered with Chef" do
+    let(:node_name) { "reset" }
+    before { MB::NodeQuerier.instance.stub(:registered_as).with(address).and_return(node_name) }
+
+    its(:node_name) { should eql(node_name) }
+    its(:partial_bootstrap?) { should be_true }
+    its(:full_bootstrap?) { should be_false }
+  end
+end

data/spec/unit/mb/chef/config_spec.rb

@@ -0,0 +1,33 @@
+require 'spec_helper'
+
+describe MotherBrain::Chef::Config do
+  subject(:chef_config) { described_class.new(path) }
+
+  let(:path) { nil }
+  let(:file_contents) {
+    <<-CHEF_CONFIG
+      user "root"
+      pass "secret"
+      mode :none
+      variable = 123
+    CHEF_CONFIG
+  }
+
+  before do
+    chef_config.stub(
+      file_contents: file_contents
+    )
+  end
+
+  describe "#parse" do
+    before { chef_config.parse }
+
+    it "parses each line and creates a key in the hash" do
+      expect(chef_config[:user]).to eq("root")
+      expect(chef_config[:pass]).to eq("secret")
+      expect(chef_config[:mode]).to eq(:none)
+
+      expect(chef_config[:variable]).to be_nil
+    end
+  end
+end

data/spec/unit/mb/chef/run_list_item_spec.rb

@@ -0,0 +1,34 @@
+require 'spec_helper'
+
+describe MotherBrain::Chef::RunListItem do
+  describe "#cookbook_name" do
+    context "recipe item" do
+      shared_examples "a recipe item" do
+        it "should return the cookbook" do
+          expect(subject.cookbook_name).to eq("foo")
+        end
+      end
+
+      context do
+        subject { described_class.new("recipe[foo::server]") }
+        it_behaves_like "a recipe item"
+      end
+
+      context do
+        subject { described_class.new("recipe[foo::server@1.1.2]") }
+        it_behaves_like "a recipe item"
+      end
+
+      context do
+        subject { described_class.new("recipe[foo]") }
+        it_behaves_like "a recipe item"
+      end
+    end
+    context "role item" do
+      subject { described_class.new("role[foo]") }
+      it "should return nil" do
+        expect(subject.cookbook_name).to be_nil
+      end
+    end
+  end
+end

data/spec/unit/mb/chef_mutex_spec.rb

@@ -0,0 +1,314 @@
+require 'spec_helper'
+
+describe MB::ChefMutex do
+  describe "ClassMethods" do
+    subject { described_class }
+
+    describe "::new" do
+      before { MB::LockManager.instance.reset }
+
+      it "adds the new lock to the lock manager" do
+        mutex = subject.new
+        expect(MB::LockManager.instance.locks).to have(1).item
+        expect(MB::LockManager.instance.locks.first).to eq(mutex)
+      end
+    end
+
+    describe "::synchronize" do
+      before { MB::LockManager.instance.reset }
+      let(:probe) { double('test-probe', test: nil) }
+
+      it "executes the given block" do
+        probe.should_receive(:test)
+
+        subject.synchronize(options) do
+          probe.test
+        end
+      end
+
+      it "removes the lock from the lock manager" do
+        subject.synchronize(options) do
+          probe.test
+        end
+
+        expect(MB::LockManager.instance.locks).to have(0).items
+      end
+
+      context "when the block encounters an error" do
+        before { probe.should_receive(:test).and_raise(RuntimeError) }
+
+        it "removes the lock from the lock manager" do
+          expect {
+            subject.synchronize(options) do
+              probe.test
+            end
+          }.to raise_error(RuntimeError)
+
+          expect(MB::LockManager.instance.locks).to have(0).items
+        end
+      end
+    end
+  end
+
+  subject { chef_mutex }
+
+  let(:chef_mutex) { klass.new(options.merge lockset) }
+
+  let(:client_name) { "johndoe" }
+  let(:lockset) { { chef_environment: "my_environment" } }
+  let(:options) { lockset }
+
+  let(:chef_connection_stub) { double client_name: client_name }
+  let(:locks_stub) { double(
+      delete: true,
+      find: nil,
+      new: double(save: true)
+  ) }
+  let(:job_stub) { double(
+    report_boolean: nil,
+    report_running: nil
+  ) }
+
+  before do
+    chef_mutex.stub locks: locks_stub
+  end
+
+  its(:type) { should == lockset.keys.first }
+  its(:name) { should == lockset.values.first }
+
+  its(:to_s) { should == "#{chef_mutex.type}:#{chef_mutex.name}" }
+  its(:data_bag_id) { should == "#{chef_mutex.type}-#{chef_mutex.name}" }
+
+  describe "#lock" do
+    subject(:lock) { chef_mutex.lock }
+
+    it "attempts a lock" do
+      chef_mutex.should_receive :attempt_lock
+
+      lock
+    end
+
+    context "with no existing lock" do
+      before { chef_mutex.stub read: false, write: true }
+
+      it { should be_true }
+
+      context "and the lock attempt fails" do
+        before { chef_mutex.stub write: false }
+
+        it { should be_false }
+      end
+    end
+
+    context "with an existing lock" do
+      before { chef_mutex.stub read: {}, write: true }
+
+      it { should be_false }
+
+      context "and force enabled" do
+        let(:options) { { force: true } }
+
+        it { should be_true }
+      end
+    end
+
+    context "without a valid lock type" do
+      let(:lockset) { { something: "something" } }
+
+      it { -> { lock }.should raise_error MB::InvalidLockType }
+    end
+
+    context "when passed a job" do
+      let(:options) { { job: job_stub } }
+
+      it "sets the job status" do
+        job_stub.should_receive(:set_status).with(
+          "Locking chef_environment:my_environment"
+        )
+
+        lock
+      end
+    end
+  end
+
+  describe "#locked?" do
+    subject(:locked?) { chef_mutex.locked? }
+
+    it { should be_false }
+
+    context "when the environment is locked" do
+      before do
+        chef_mutex.stub read: true
+      end
+
+      it { should be_true }
+    end
+  end
+
+  describe "#synchronize" do
+    subject(:synchronize) { chef_mutex.synchronize(&test_block) }
+
+    TestProbe = Object.new
+
+    let(:test_block) { -> { TestProbe.testing } }
+
+    before do
+      chef_mutex.stub lock: true, unlock: true
+
+      TestProbe.stub :testing
+    end
+
+    it "runs the block" do
+      TestProbe.should_receive :testing
+
+      synchronize
+    end
+
+    it "obtains a lock" do
+      chef_mutex.should_receive :lock
+
+      synchronize
+    end
+
+    it "releases the lock" do
+      chef_mutex.should_receive :unlock
+
+      synchronize
+    end
+
+    context "when the lock is unobtainable" do
+      before do
+        chef_mutex.stub lock: false, read: {}
+      end
+
+      it "raises a ResourceLocked error" do
+        chef_mutex.should_not_receive :unlock
+
+        expect {
+          synchronize
+        }.to raise_error(MB::ResourceLocked)
+      end
+
+      context "and force enabled" do
+        let(:options) { { force: true } }
+
+        it "locks with force" do
+          chef_mutex.should_receive(:lock).and_return(true)
+
+          synchronize
+        end
+      end
+    end
+
+    context "on block failure" do
+      before do
+        TestProbe.stub(:testing).and_raise(RuntimeError)
+      end
+
+      it "raises the error" do
+        expect { synchronize }.to raise_error(RuntimeError)
+      end
+
+      it "releases the lock" do
+        chef_mutex.should_receive(:unlock)
+
+        expect { synchronize }.to raise_error(RuntimeError)
+      end
+
+      it "does not crash the mutex actor" do
+        expect { chef_mutex.synchronize(&test_block) }.to raise_error(RuntimeError)
+
+        expect { chef_mutex.to_s }.to_not raise_error
+      end
+
+      context "and passed unlock_on_failure: false" do
+        before do
+          chef_mutex.stub(unlock_on_failure: false)
+        end
+
+        it "does not release the lock" do
+          chef_mutex.should_not_receive :unlock
+
+          expect { synchronize }.to raise_error(RuntimeError)
+        end
+      end
+    end
+  end
+
+  describe "#unlock" do
+    subject(:unlock) { chef_mutex.unlock }
+
+    it "attempts an unlock" do
+      chef_mutex.should_receive :attempt_unlock
+
+      unlock
+    end
+
+    it "returns true" do
+      expect(unlock).to be_true
+    end
+
+    context "when passed a job" do
+      let(:options) { { job: job_stub } }
+
+      it "sets the job status" do
+        job_stub.should_receive(:set_status).with(
+          "Unlocking chef_environment:my_environment"
+        )
+
+        unlock
+      end
+    end
+  end
+
+  describe "#our_lock?" do
+    before do
+      chef_mutex.class.class_eval { public :our_lock? }
+      chef_mutex.stub(:client_name).and_return("johndoe")
+    end
+
+    after do
+      chef_mutex.class.class_eval { private :our_lock? }
+    end
+
+    subject(:our_lock?) { chef_mutex.our_lock?(current_lock) }
+    let(:current_lock) { { id: "_chef_environment_:my_environment"} }
+
+    context "when current_lock is not from our client" do
+      before { current_lock['client_name'] = "janedoe" }
+
+      it { should be_false }
+    end
+
+    context "when current_lock is from our client" do
+      before { current_lock['client_name'] = "johndoe" }
+
+      context "when process_id is our process" do
+        before do
+          Process.stub(:pid).and_return(12345)
+          current_lock['process_id'] = 12345
+        end
+        it { should be_true }
+      end
+
+      context "when process_id is not our process" do
+        before do
+          Process.stub(:pid).and_return(12345)
+          current_lock['process_id'] = 23456
+        end
+        it { should be_false }
+      end
+    end
+  end
+
+  describe "#terminate" do
+    before { MB::LockManager.instance.reset }
+
+    it "removes the mutex from the lock manager" do
+      mutex = described_class.new(options)
+      expect(MB::LockManager.instance.locks).to have(1).item
+      mutex.terminate
+      expect(MB::LockManager.instance.locks).to have(0).items
+    end
+  end
+end