motherbrain 0.0.0.placeholder → 0.13.1

data/spec/unit/mb/manifest_spec.rb

@@ -0,0 +1,105 @@
+require 'spec_helper'
+
+describe MB::Manifest do
+  subject { manifest }
+  let(:manifest) { described_class.new(attributes) }
+
+  let(:valid_json) do
+    <<-JSON
+      {
+        "nodes": [
+          {
+            "type": "m1.large",
+            "groups": ["activemq::master"]
+          },
+          {
+            "type": "m1.large",
+            "count": 2,
+            "groups": ["activemq::slave"]
+          },
+          {
+            "type": "m1.small",
+            "groups": ["nginx::master"]
+          }
+        ]
+      }
+    JSON
+  end
+
+  let(:valid_hash) {
+    {
+      nodes: [
+        {
+          type: "m1.large",
+          groups: ["activemq::master"]
+        },
+        {
+          type: "m1.large",
+          count: 2,
+          groups: ["activemq::slave"]
+        },
+        {
+          type: "m1.small",
+          groups: ["nginx::master"]
+        }
+      ]
+    }
+  }
+
+  let(:attributes) { valid_hash }
+
+  it { should == valid_hash }
+  it { should have_key(:nodes) }
+
+  its(:node_count) { should == 4 }
+
+  context "with an empty hash" do
+    let(:attributes) { Hash.new }
+
+    it { should be_empty }
+  end
+
+  describe "#[:nodes]" do
+    subject { manifest[:nodes] }
+
+    it { should have(3).items }
+    it { should =~ valid_hash[:nodes] }
+  end
+
+  describe ".from_file" do
+    pending
+  end
+
+  describe ".from_json" do
+    pending
+  end
+
+  describe "#from_json" do
+    subject { from_json }
+    let(:from_json) { described_class.new.from_json(json) }
+
+    let(:json) { valid_json }
+
+    it { should == valid_hash }
+
+    context "given an empty json string" do
+      let(:json) { "{}" }
+
+      it { should be_empty }
+    end
+
+    context "given an invalid JSON string" do
+      let(:json) { "sdf" }
+
+      it "raises" do
+        expect {
+          from_json
+        }.to raise_error(MB::InvalidManifest)
+      end
+    end
+  end
+
+  describe "#save" do
+    pending
+  end
+end

data/spec/unit/mb/mixin/attribute_setting_spec.rb

@@ -0,0 +1,180 @@
+require 'spec_helper'
+
+describe MB::Mixin::AttributeSetting do
+  subject do
+    Class.new do
+      include MB::Mixin::AttributeSetting
+    end.new
+  end
+
+  let(:environment) { "test-env" }
+
+  describe "#set_component_versions" do
+    let(:plugin) { double('plugin', name: "rspec") }
+    let(:component) { double('component') }
+
+    context "when the component exists" do
+      before(:each) { plugin.stub(:component!).with(plugin.name).and_return(component) }
+
+      context "without a version_attribute" do
+        before(:each) { component.stub(version_attribute: nil) }
+
+        it "raises a MB::ComponentNotVersioned error" do
+          expect {
+            subject.set_component_versions(environment, plugin, plugin.name => "1.2.3")
+          }.to raise_error(MB::ComponentNotVersioned)
+        end
+      end
+    end
+
+    context "when the component does not exist" do
+      before(:each) do
+        plugin.stub(:component!).with(plugin.name).and_raise(MB::ComponentNotFound.new(component, plugin))
+      end
+
+      it "raises a MB::ComponentNotFound error" do
+        expect {
+          subject.set_component_versions(environment, plugin, plugin.name => "1.2.3")
+        }.to raise_error(MB::ComponentNotFound)
+      end
+    end
+  end
+
+  describe "#set_cookbook_versions" do
+    before(:each) do
+      subject.stub(satisfies_constraints?: true)
+    end
+
+    context "successful" do
+      let(:hash) { Hash.new }
+      before(:each) do
+        env = double('environment', name: "foo")
+        chef_connection = subject.chef_connection
+        chef_connection.stub_chain(:environment, :find).and_return(env)
+        chef_connection.stub_chain(:cookbook, :latest_version).and_return("1.2.4")
+        env.should_receive(:cookbook_versions).and_return(hash)
+        env.stub(:save)
+      end
+
+      it "saves the cookbook versions to the environment" do
+        subject.set_cookbook_versions "foo", {"some_book" => "= 1.2.3"}
+        hash["some_book"].should_not be_nil
+        hash["some_book"].should eq("= 1.2.3")
+      end
+
+      it "converts 'latest' to a (=) constraint of the latest" do
+        subject.set_cookbook_versions "foo", {"some_book" => "latest"}
+        hash["some_book"].should_not be_nil
+        hash["some_book"].should eq("= 1.2.4")
+      end
+    end
+
+    context "given incomplete version constraints" do
+      let(:constraints) do
+        { "some_cook" => "123" }
+      end
+
+      let(:env) { double('environment', name: "foo") }
+
+      before(:each) do
+        subject.stub(expand_latest_versions: constraints)
+        chef_connection = subject.chef_connection
+        chef_connection.stub_chain(:environment, :find).and_return(env)
+        env.stub(:save)
+      end
+
+      it "expands them to a fully qualified constraint format" do
+        env.stub_chain(:cookbook_versions, :merge!).with("some_cook" => "= 123.0.0")
+        subject.set_cookbook_versions "foo", constraints
+      end
+    end
+
+    context "when constraints could not be satisfiied" do
+      let(:constraints) do
+        { "rspec_test" => "= 1.2.3", "rspec_fail_test" => ">= 2.0.0" }
+      end
+
+      before(:each) do
+        subject.stub(expand_latest_versions: constraints)
+        subject.stub(:satisfies_constraints?).with(constraints).and_raise
+      end
+
+      it "raises an error" do
+
+        expect {
+          subject.set_cookbook_versions "foo", constraints
+        }.to raise_error
+      end
+    end
+  end
+
+  describe "#set_environment_attributes" do
+    context "successful" do
+      let(:hash) { Hash.new }
+      before(:each) do
+        env = double('environment', name: "foo")
+        chef_connection = subject.chef_connection
+        chef_connection.stub_chain(:environment, :find).and_return(env)
+        env.should_receive(:default_attributes).and_return(hash)
+        env.stub(:save)
+      end
+
+      it "should save the attributes to the environment" do
+        subject.set_environment_attributes "foo", {"bar.baz" => "quux"}
+        hash["bar"].should_not be_nil
+        hash["bar"]["baz"].should eq("quux")
+      end
+    end
+  end
+
+  describe "#set_environment_attributes_from_file" do
+    let(:env) { double }
+    let(:filepath) { tmp_path.join('attr-test-file') }
+    let(:contents) { double }
+
+    before(:each) { FileUtils.touch(filepath) }
+
+    context "given the type :json" do
+      it "delegates to set_environment_attributes_from_json" do
+        subject.should_receive(:set_environment_attributes_from_json).with(env, anything)
+
+        subject.set_environment_attributes_from_file(env, filepath, :json)
+      end
+
+      it "raises an InvalidAttributesFile error if there was a problem decoding json" do
+        subject.should_receive(:set_environment_attributes_from_json).and_raise(MultiJson::DecodeError)
+
+        expect {
+          subject.set_environment_attributes_from_file(env, filepath, :json)
+        }.to raise_error(MB::InvalidAttributesFile)
+      end
+    end
+
+    it "raises an MB::ArgumentError when given an unknown type" do
+      expect {
+        subject.set_environment_attributes_from_file(env, filepath, :not_known)
+      }.to raise_error(MB::ArgumentError)
+    end
+  end
+
+  describe "#set_environment_attributes_from_json" do
+    let(:env) { double }
+    let(:data) { double }
+
+    before(:each) { subject.stub(:set_environment_attributes_from_hash) }
+
+    it "decodes the given string to json" do
+      MultiJson.should_receive(:decode).with(data)
+
+      subject.set_environment_attributes_from_json(env, data)
+    end
+
+    it "delegates to #set_environment_attributes_from_hash with the environment and decoded json" do
+      decoded_json = double
+      MultiJson.should_receive(:decode).and_return(decoded_json)
+      subject.should_receive(:set_environment_attributes_from_hash).with(env, decoded_json)
+
+      subject.set_environment_attributes_from_json(env, data)
+    end
+  end
+end

data/spec/unit/mb/mixin/coded_exit_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+
+describe MB::Mixin::CodedExit do
+  subject do
+    Class.new do
+      include MB::Mixin::CodedExit
+    end.new
+  end
+
+  describe "#exit_with" do
+    let(:constant) { MB::MBError }
+
+    it "exits with the status code for the given constant" do
+      expect {
+        subject.exit_with(constant)
+      }.to exit_with(constant)
+    end
+  end
+
+  describe "#exit_code_for" do
+    it "returns the exit status for the given constant" do
+      subject.exit_code_for("MBError").should eql(1)
+    end
+  end
+end

data/spec/unit/mb/mixin/locks_spec.rb

@@ -0,0 +1,32 @@
+require 'spec_helper'
+
+describe MB::Mixin::Locks do
+  subject do
+    Class.new do
+      include MB::Mixin::Locks
+    end.new
+  end
+
+  let(:lock_manager) { MB::LockManager.instance }
+
+  before(:each) { lock_manager.reset }
+
+  describe "#chef_locks" do
+    it "returns a Set" do
+      subject.chef_locks.should be_a(Set)
+    end
+  end
+
+  describe "#find_lock" do
+    it "returns a Chef::Mutex if a mutex with the given name is registered" do
+      mutex = double('mutex', type: :chef_environment, name: "my_environment")
+      lock_manager.stub(:locks).and_return([mutex])
+
+      subject.find_lock(chef_environment: "my_environment").should eql(mutex)
+    end
+
+    it "returns nil if a mutex with the given name is not registered" do
+      subject.find_lock(chef_environment: "not-there-lock").should be_nil
+    end
+  end
+end

data/spec/unit/mb/mixin/services_spec.rb

@@ -0,0 +1,75 @@
+require 'spec_helper'
+
+describe MB::Mixin::Services do
+  subject do
+    Class.new do
+      include MB::Mixin::Services
+    end.new
+  end
+
+  describe "#bootstrap_manager" do
+    it "returns an instance of MB::Bootstrap::Manager" do
+      subject.bootstrap_manager.should be_a(MB::Bootstrap::Manager)
+    end
+  end
+
+  describe "#command_invoker" do
+    it "returns an instance of MB::CommandInvoker" do
+      subject.command_invoker.should be_a(MB::CommandInvoker)
+    end
+  end
+
+  describe "#config_manager" do
+    it "returns an instance of MB::ConfigManager" do
+      subject.config_manager.should be_a(MB::ConfigManager)
+    end
+  end
+
+  describe "#environment_manager" do
+    it "returns an instance of MB::EnvironmentManager" do
+      subject.environment_manager.should be_a(MB::EnvironmentManager)
+    end
+  end
+
+  describe "#job_manager" do
+    it "returns an instance of MB::JobManager" do
+      subject.job_manager.should be_a(MB::JobManager)
+    end
+  end
+
+  describe "#provisioner_manager" do
+    it "returns an instance of MB::Provisioner::Manager" do
+      subject.provisioner_manager.should be_a(MB::Provisioner::Manager)
+    end
+  end
+
+  describe "#node_querier" do
+    it "returns an instance of MB::NodeQuerier" do
+      subject.node_querier.should be_a(MB::NodeQuerier)
+    end
+  end
+
+  describe "#plugin_manager" do
+    it "returns an instance of MB::PluginManager" do
+      subject.plugin_manager.should be_a(MB::PluginManager)
+    end
+  end
+
+  describe "#provisioner_manager" do
+    it "returns an instance of MB::Provisioner::Manager" do
+      subject.provisioner_manager.should be_a(MB::Provisioner::Manager)
+    end
+  end
+
+  describe "#upgrade_manager" do
+    it "returns an instance of MB::Upgrade::Manager" do
+      subject.upgrade_manager.should be_a(MB::Upgrade::Manager)
+    end
+  end
+
+  describe "#ridley" do
+    it "returns an instance of Ridley::Client" do
+      subject.ridley.should be_a(Ridley::Client)
+    end
+  end
+end

data/spec/unit/mb/node_filter_spec.rb

@@ -0,0 +1,86 @@
+require 'spec_helper'
+
+describe MB::NodeFilter do
+  let(:nodes) do
+    (1..10).to_a.collect do |i|
+      double("node#{i}").tap do |d|
+        d.stub(:public_hostname).and_return("node#{i}.test.riotgames.com")
+        d.stub(:public_ipv4).and_return("192.168.1.#{i}")
+      end
+    end
+  end
+
+  describe "ClassMethods" do
+    describe "::filter" do
+      let(:segments) { [["192.168.1.3-5"]] }
+      subject(:filter) { described_class.filter(segments, nodes) }
+
+      context "given an array of arrays of segments" do
+        it "returns the correct number of nodes" do
+          expect(filter).to have(3).items
+        end
+      end
+    end
+  end
+
+  subject { MB::NodeFilter.new(filter) }
+  let(:filtered) { subject.filter(nodes) }
+  let(:filter) {[]}
+
+  describe ":expand_iprange" do
+    let(:expand_ipranges) { described_class.expand_ipranges(nodes) }
+    let(:nodes) { ["192.168.0.2", "192.168.0.5-8"] }
+
+    it "expands any ipranges" do
+      expect(expand_ipranges).to eq(["192.168.0.2", "192.168.0.5", "192.168.0.6", "192.168.0.7", "192.168.0.8"])
+    end
+  end
+
+  describe "#ipaddress?" do
+    it "is true for valid ipaddresses" do
+       expect(subject.ipaddress?("192.168.1.1")).to be_true
+    end
+
+    it "is false for invalid ipaddresses" do
+      expect(subject.ipaddress?("invalid")).to be_false
+      expect(subject.ipaddress?("192.168.1.3-5")).to be_false
+    end
+  end
+
+  describe "#iprange" do
+    it "expands the range" do
+      expect(subject.iprange("192.168.1.1-2")).to eq(["192.168.1.1", "192.168.1.2"])
+    end
+
+    it "is nil when not an iprange" do
+      expect(subject.iprange("192.168.1.1")).to be_nil
+      expect(subject.iprange("invalid")).to be_nil
+    end
+  end
+
+  describe "#filter" do
+    context "when an ipaddress range is given" do
+      let(:filter) { ["192.168.1.3-5"] }
+
+      it "filters the nodes" do
+        expect(filtered.collect(&:public_ipv4)).to eq(["192.168.1.3", "192.168.1.4", "192.168.1.5"])
+      end
+    end
+
+    context "when a full hostname is given" do
+      let(:filter) { ["node2.test.riotgames.com"] }
+
+      it "filters the nodes by their full hostname" do
+        expect(filtered.collect(&:public_hostname)).to eq(["node2.test.riotgames.com"])
+      end
+    end
+
+    context "when just the hostname is given" do
+      let(:filter) { ["node2"] }
+
+      it "filters the nodes by their full hostname" do
+        expect(filtered.collect(&:public_hostname)).to eq(["node2.test.riotgames.com"])
+      end
+    end
+  end
+end