motherbrain 0.0.0.placeholder → 0.13.1

data/spec/unit/mb/core_ext/dir_spec.rb

@@ -0,0 +1,92 @@
+require 'spec_helper'
+
+describe Dir do
+  describe "#has_mb_plugin?" do
+    let(:target) { tmp_path.join('some_directory') }
+    subject { described_class.has_mb_plugin?(target) }
+
+    context "when the directory does not exist" do
+      before { FileUtils.rm_f(target) }
+      it { should be_false }
+    end
+
+    context "when the directory exists" do
+      before { FileUtils.mkdir_p(target) }
+
+      before do
+        described_class.stub(:has_mb_file?).with(target).and_return(true)
+        described_class.stub(:has_chef_metadata?).with(target).and_return(true)
+      end
+
+      context "but does not contain a motherbrain file" do
+        before { described_class.stub(:has_mb_file?).with(target).and_return(false) }
+        it { should be_false }
+      end
+
+      context "but does not contain a Chef metadata file" do
+        before { described_class.stub(:has_mb_file?).with(target).and_return(false) }
+        it { should be_false }
+      end
+
+      context "and contains a motherbrain file and Chef metadata file" do
+        it { should be_true }
+      end
+    end
+  end
+
+  describe "#has_mb_file?" do
+    let(:target) { tmp_path.join('some_directory') }
+    subject { described_class.has_mb_file?(target) }
+
+    context "when the directory does not exist" do
+      before { FileUtils.rm_f(target) }
+      it { should be_false }
+    end
+
+    context "when the directory exists" do
+      before { FileUtils.mkdir_p(target) }
+
+      context "but does not contain a motherbrain file" do
+        before { FileUtils.rm_f(target.join(MB::Plugin::PLUGIN_FILENAME)) }
+        it { should be_false }
+      end
+
+      context "and has a motherbrain file" do
+        before { FileUtils.touch(target.join(MB::Plugin::PLUGIN_FILENAME)) }
+        it { should be_true }
+      end
+    end
+  end
+
+  describe "#has_chef_metadata?" do
+    let(:target) { tmp_path.join('some_directory') }
+    subject { described_class.has_chef_metadata?(target) }
+
+    context "when the directory does not exist" do
+      before { FileUtils.rm_f(target) }
+      it { should be_false }
+    end
+
+    context "when the directory exists" do
+      before { FileUtils.mkdir_p(target) }
+
+      context "but does not contain a Chef JSON or Ruby metadata file" do
+        before do
+          FileUtils.rm_f(target.join(MB::CookbookMetadata::RUBY_FILENAME))
+          FileUtils.rm_f(target.join(MB::CookbookMetadata::JSON_FILENAME))
+        end
+        it { should be_false }
+      end
+
+      context "and contains a Chef JSON metadata file" do
+        before { FileUtils.touch(target.join(MB::CookbookMetadata::JSON_FILENAME)) }
+        it { should be_true }
+      end
+
+      context "and contains a Chef Ruby metadata file" do
+        before { FileUtils.touch(target.join(MB::CookbookMetadata::RUBY_FILENAME)) }
+        it { should be_true }
+      end
+    end
+  end
+end

data/spec/unit/mb/core_ext/enumerable_spec.rb

@@ -0,0 +1,104 @@
+require 'spec_helper'
+
+describe Enumerable do
+  class ObjectClass
+    def foo
+      :result
+    end
+
+    def bar(one, two, three)
+      [one, two, three]
+    end
+  end
+
+  class ActorClass < ObjectClass
+    include Celluloid
+  end
+
+  let(:actors) { [ActorClass.new, ActorClass.new] }
+  let(:objects) { [ObjectClass.new, ObjectClass.new] }
+  let(:mixed) { [ActorClass.new, ObjectClass.new] }
+
+  let(:block) { proc { |item| item.foo } }
+
+  let(:array) { actors }
+
+  let(:foo_result) { [:result, :result] }
+  let(:bar_result) { [[1, 2, 3], [1, 2, 3]] }
+
+  describe "#concurrent_map" do
+    subject { concurrent_map }
+
+    context "when passed a method" do
+      let(:concurrent_map) { array.concurrent_map(:foo) }
+
+      context "with actors" do
+        let(:array) { actors }
+
+        it { should eq(foo_result) }
+      end
+
+      context "with objects" do
+        let(:array) { objects }
+
+        it { should eq(foo_result) }
+      end
+
+      context "with mixed actors and objects" do
+        let(:array) { mixed }
+
+        it { should eq(foo_result) }
+      end
+    end
+
+    context "when passed a method and arguments" do
+      let(:concurrent_map) { array.concurrent_map(:bar, 1, 2, 3) }
+
+      context "with actors" do
+        let(:array) { actors }
+
+        it { should eq(bar_result) }
+      end
+
+      context "with objects" do
+        let(:array) { objects }
+
+        it { should eq(bar_result) }
+      end
+
+      context "with mixed actors and objects" do
+        let(:array) { mixed }
+
+        it { should eq(bar_result) }
+      end
+    end
+
+    context "when passed a block" do
+      let(:concurrent_map) { array.concurrent_map(&block) }
+
+      context "with actors" do
+        let(:array) { actors }
+
+        it { should eq(foo_result) }
+      end
+
+      context "with objects" do
+        let(:array) { objects }
+
+        it { should eq(foo_result) }
+      end
+
+      context "with mixed actors and objects" do
+        let(:array) { mixed }
+
+        it { should eq(foo_result) }
+      end
+    end
+
+    context "with no arguments or block" do
+      let(:concurrent_map) { array.concurrent_map }
+
+      it { expect { concurrent_map }.to raise_error(ArgumentError) }
+    end
+  end
+end

data/spec/unit/mb/core_ext/file_spec.rb

@@ -0,0 +1,58 @@
+require 'spec_helper'
+
+describe File do
+  describe "#is_chef_metadata?" do
+    let(:filename) { 'metadata.rb' }
+    let(:target) { tmp_path.join(filename) }
+    subject { described_class.is_chef_metadata?(target) }
+
+    context "when the file does not exist" do
+      before { FileUtils.rm_f(target) }
+      it { should be_false }
+    end
+
+    context "when the file exists" do
+      before { FileUtils.touch(target) }
+
+      context "and the basename matches the Chef Ruby metadata filename" do
+        let(:filename) { MB::CookbookMetadata::RUBY_FILENAME }
+        it { should be_true }
+      end
+
+      context "and the basename matches the Chef JSON metadata filename" do
+        let(:filename) { MB::CookbookMetadata::JSON_FILENAME }
+        it { should be_true }
+      end
+
+      context "and the basename does not match a Chef metadata filename" do
+        let(:filename) { 'nothing.at.all' }
+        it { should be_false }
+      end
+    end
+  end
+
+  describe "#is_mb_plugin?" do
+    let(:filename) { 'motherbrain.rb' }
+    let(:target) { tmp_path.join(filename) }
+    subject { described_class.is_mb_plugin?(target) }
+
+    context "when the file does not exist" do
+      before { FileUtils.rm_f(target) }
+      it { should be_false }
+    end
+
+    context "when the file exists" do
+      before { FileUtils.touch(target) }
+
+      context "and the basename matches a motherbrain plugin filename" do
+        let(:filename) { MB::Plugin::PLUGIN_FILENAME }
+        it { should be_true }
+      end
+
+      context "and the basename does not match a motherbrain plugin filename" do
+        let(:filename) { 'something.not.real' }
+        it { should be_false }
+      end
+    end
+  end
+end

data/spec/unit/mb/core_ext/signal_spec.rb

@@ -0,0 +1,24 @@
+require 'spec_helper'
+
+describe Signal do
+  describe "#supported?" do
+    let(:signal_name) { "HUP" }
+    subject { described_class.supported?(signal_name) }
+
+    context "when the signal is in the list of signals" do
+      before do
+        Signal.stub(list: { "HUP" => 1 })
+      end
+
+      it { should be_true }
+    end
+
+    context "when the signal is not in the list of supported signals" do
+      before do
+        Signal.stub(list: Hash.new)
+      end
+
+      it { should be_false }
+    end
+  end
+end

data/spec/unit/mb/environment_manager_spec.rb

@@ -0,0 +1,166 @@
+require 'spec_helper'
+
+describe MB::EnvironmentManager do
+  subject { environment_manager }
+
+  let(:environment_manager) { described_class.new }
+  let(:environment_name) { "rspec-test" }
+
+  describe "#async_configure" do
+    let(:options) { Hash.new }
+
+    it "asynchronously calls #configure and returns a JobRecord" do
+      subject.should_receive(:async).with(:configure, kind_of(MB::Job), environment_name, options)
+
+      subject.async_configure(environment_name, options).should be_a(MB::JobRecord)
+    end
+  end
+
+  describe "#configure" do
+    let!(:job) { MB::Job.new(:environment_configure) }
+    let!(:ticket) { job.ticket }
+    let(:options) { Hash.new }
+
+    context "when the environment exists" do
+      before { chef_environment(environment_name) }
+
+      it "sets the job to success" do
+        subject.configure(job, environment_name, options)
+        expect(ticket).to be_success
+      end
+    end
+
+    context "when the environment does not exist" do
+      before { MB::RSpec::ChefServer.clear_data }
+
+      it "sets the job to failure because of EnvironmentNotFound" do
+        subject.configure(job, environment_name, options)
+        expect(ticket).to be_failure
+        expect(ticket.result).to be_a(MB::EnvironmentNotFound)
+      end
+    end
+
+    context "when there are nodes in the environment" do
+      let(:job) { double(set_status: nil, report_running: nil, report_success: nil, report_failure: nil, alive?: false) }
+      let(:ticket) { nil }
+      let(:node_one) { double(name: "surfing", public_hostname: "surfing.riotgames.com") }
+      let(:node_two) { double(name: "football", public_hostname: "football.riotgames.com") }
+      let(:response_one) { double(value: double(host: "surfing.riotgames.com")) }
+      let(:response_two) { double(value: double(host: "football.riotgames.com")) }
+
+      let(:nodes) { [node_one, node_two] }
+
+      before do
+        chef_environment(environment_name)
+        environment_manager.stub(:nodes_for_environment).and_return(nodes)
+        nodes.stub(:collect).and_return([response_one, response_two])
+      end
+
+      it "attempts to run chef" do
+        subject.configure(job, environment_name, options)
+        expect(job).to have_received(:report_success).with(
+          "Finished chef client run on 2 node(s) - surfing.riotgames.com, football.riotgames.com")
+      end
+
+      context "when nodes fail" do
+
+        before do
+          response_one.stub(:value).and_raise(MB::RemoteCommandError.new(nil, "surfing.riotgames.com"))
+          response_two.stub(:value).and_raise(MB::RemoteCommandError.new(nil, "football.riotgames.com"))
+        end
+
+        it "describes the unsuccessful nodes" do
+          subject.configure(job, environment_name, options)
+          expect(job).to have_received(:report_failure).with(
+            "chef client run failed on 2 node(s) - surfing.riotgames.com, football.riotgames.com")
+        end
+      end
+    end
+  end
+
+  describe "#find" do
+    before { chef_environment(environment_name) }
+
+    it "returns a Ridley::EnvironmentObject" do
+      expect(subject.find(environment_name)).to be_a(Ridley::EnvironmentObject)
+    end
+
+    context "when the environment is not present on the remote Chef server" do
+      before { MB::RSpec::ChefServer.clear_data }
+
+      it "aborts an EnvironmentNotFound error" do
+        expect { subject.find(environment_name) }.to raise_error(MB::EnvironmentNotFound)
+      end
+    end
+  end
+
+  describe "#list" do
+    before do
+      chef_environment("rspec-one")
+      chef_environment("rspec-two")
+      chef_environment("rspec-three")
+    end
+
+    it "has an item for every environment on the Chef server +1 for _default" do
+      expect(subject.list).to have(4).items
+    end
+
+    it "includes the _default environment" do
+      expect(subject.list.find { |e| e.chef_id }).to_not be_nil
+    end
+  end
+
+  describe "#create" do
+    it "creates an environment" do
+      environment_manager.create environment_name
+
+      expect(ridley.environment.find(environment_name)).to be_true
+    end
+  end
+  
+  describe "#create_from_file" do
+    it "creates an environment" do
+      test_file = File.join(fixtures_path, 'test_env.json')
+      environment_manager.create_from_file test_file
+      
+      env = ridley.environment.find('test_env')
+      expect(env['default_attributes']['motherbrain']).to be_true
+    end
+    
+    it "handles a missing file" do
+      test_file = File.join(fixtures_path, 'no_such_env.json')
+      expect { environment_manager.create_from_file(test_file) }.to raise_error
+    end
+  end
+
+  describe "#destroy" do
+    before { chef_environment(environment_name) }
+
+    it "destroys the environment" do
+      environment_manager.destroy environment_name
+
+      expect(ridley.environment.find(environment_name)).to be_nil
+    end
+  end
+
+  describe "#purge_nodes" do
+    before do
+      chef_environment(environment_name)
+      ridley.node.create(name: "test", chef_environment: environment_name)
+    end
+
+    it "removes the nodes" do
+      environment_manager.purge_nodes environment_name
+
+      expect(ridley.search(:node, "chef_environment:#{environment_name}")).to be_empty
+    end
+
+    it "does not remove nodes in other environments" do
+      ridley.node.create(name: "test2", chef_environment: "other")
+
+      environment_manager.purge_nodes environment_name
+
+      expect(ridley.search(:node, "chef_environment:other")).to_not be_empty
+    end
+  end
+end