motherbrain 0.0.0.placeholder → 0.13.1

data/spec/unit/mb/api/validators/sem_ver_spec.rb

@@ -0,0 +1,5 @@
+require 'spec_helper'
+
+describe MB::API::Validators::SemVer do
+  pending
+end

data/spec/unit/mb/application_spec.rb

@@ -0,0 +1,19 @@
+require 'spec_helper'
+
+describe MB::Application do
+  describe "ClassMethods" do
+    subject { described_class }
+
+    describe "::registry" do
+      it "returns an instance of Celluloid::Registry" do
+        subject.registry.should be_a(Celluloid::Registry)
+      end
+    end
+
+    describe "::config" do
+      it "returns an instance of MB::Config" do
+        subject.config.should be_a(MB::Config)
+      end
+    end
+  end
+end

data/spec/unit/mb/berkshelf_spec.rb

@@ -0,0 +1,38 @@
+require 'spec_helper'
+
+describe MB::Berkshelf do
+  describe "::cookbooks_path" do
+    subject { described_class.cookbooks_path }
+
+    it "returns a Pathname" do
+      subject.should be_a(Pathname)
+    end
+
+    it "is in the Berkshelf path" do
+      subject.to_s.should include(MB::Berkshelf.path.to_s)
+    end
+  end
+
+  describe "::default_path" do
+    subject { described_class.default_path }
+
+    it "returns a String" do
+      subject.should be_a(String)
+    end
+
+    it "returns the value of ENV['BERKSHELF_PATH'] if present" do
+      target = "/tmp/berkshelf"
+      ENV.stub(:[]).with("BERKSHELF_PATH").and_return(target)
+
+      subject.should eql(target)
+    end
+  end
+
+  describe "::path" do
+    subject { described_class.path }
+
+    it "returns a Pathname" do
+      subject.should be_a(Pathname)
+    end
+  end
+end

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

@@ -0,0 +1,347 @@
+require 'spec_helper'
+
+describe MB::Bootstrap::Manager do
+  subject { manager }
+  let(:manager) { described_class.new }
+
+  let(:cookbook_metadata) {
+    MB::CookbookMetadata.from_file(fixtures_path.join('cb_metadata.rb'))
+  }
+
+  let(:plugin) {
+    MB::Plugin.new(cookbook_metadata) do
+      component "activemq" do
+        group "master"
+        group "slave"
+      end
+
+      component "nginx" do
+        group "master"
+      end
+
+      stack_order do
+        async do
+          bootstrap("activemq::master")
+          bootstrap("activemq::slave")
+        end
+
+        bootstrap("nginx::master")
+      end
+    end
+  }
+
+  let(:manifest) {
+    MB::Bootstrap::Manifest.new({
+      nodes: [
+        {
+          groups: ["activemq::master"],
+          hosts: [
+            "amq1.riotgames.com",
+            "amq2.riotgames.com"
+          ]
+        },
+        {
+          groups: ["activemq::slave"],
+          hosts: [
+            "amqs1.riotgames.com",
+            "amqs2.riotgames.com"
+          ]
+        },
+        {
+          groups: ["nginx::master"],
+          hosts: [
+            "nginx1.riotgames.com"
+          ]
+        }
+      ]
+    })
+  }
+
+  let(:environment) { "test" }
+  let(:server_url) { MB::Application.config.chef.api_url }
+
+  before do
+    stub_request(:get, File.join(server_url, "nodes")).
+      to_return(status: 200, body: {})
+    stub_request(:get, File.join(server_url, "environments/test")).
+      to_return(status: 200, body: {})
+
+    manager.stub(async: manager)
+  end
+
+  describe "#async_bootstrap" do
+    it "delegates asynchronously to {#bootstrap}" do
+      options = double('options')
+      manager.should_receive(:async).with(
+        :bootstrap,
+        kind_of(MB::Job),
+        environment,
+        manifest,
+        plugin,
+        options
+      )
+
+      manager.async_bootstrap(environment, manifest, plugin, options)
+    end
+
+    it "returns a JobRecord" do
+      manager.async_bootstrap(environment, manifest, plugin).should be_a(MB::JobRecord)
+    end
+  end
+
+  describe "#bootstrap" do
+    let(:job) { MB::Job.new(:bootstrap) }
+    let(:options) { Hash.new }
+
+    before(:each) do
+      manager.stub(concurrent_bootstrap: {})
+    end
+
+    let(:run) { manager.bootstrap(job, environment, manifest, plugin, options) }
+
+    context "when the validatiom key is not on disk" do
+      it "fails the job before locking the environment" do
+        config_manager.stub_chain(:config).and_return(chef: {validation_key: '/this/file/doesnt/exist.pem'})
+        manager.should_not_receive(:chef_synchronize)
+        job.should_receive(:report_failure)
+
+        run
+      end
+    end
+
+    context "when the environment cannot be found" do
+      before(:each) do
+        manager.stub_chain(:chef_connection, :environment, :find).with(environment).and_return(nil)
+      end
+
+      it "sets the job to failed before locking the environment" do
+        manager.should_not_receive(:chef_synchronize)
+        job.should_receive(:report_failure)
+
+        run
+      end
+    end
+
+    context "when the given bootstrap manifest is invalid" do
+      it "sets the job to failed before locking the environment" do
+        manifest.should_receive(:validate!).with(plugin).and_raise(MB::InvalidBootstrapManifest)
+        manager.should_not_receive(:chef_synchronize)
+        job.should_receive(:report_failure)
+
+        run
+      end
+    end
+
+    context "when :environment_attributes_file is passed as an option" do
+      let(:filepath) { double }
+
+      before do
+        options[:environment_attributes_file] = filepath
+      end
+
+      it "sets environment attributes on the environment with the contents of the file" do
+        manager.should_receive(:set_environment_attributes_from_file).with(environment, filepath)
+        run
+      end
+
+      context "when the environment attributes file is invalid" do
+        it "sets the job to failed before running #concurrent_bootstrap" do
+          manager.should_receive(:set_environment_attributes_from_file).and_raise(MB::InvalidAttributesFile)
+          manager.should_not_receive(:concurrent_bootstrap)
+          job.should_receive(:report_failure)
+
+          run
+        end
+      end
+    end
+
+    context "when :environment_attributes_file is not passed as an option" do
+      before do
+        options[:environment_attributes_file] = nil
+      end
+
+      it "does not set the environment attributes on the environment" do
+        manager.should_not_receive(:set_environment_attributes_file)
+        run
+      end
+    end
+
+    context "when all nodes bootstrap successfully" do
+      let(:host_one) { "euca-10-20-37-171.eucalyptus.cloud.riotgames.com" }
+      let(:host_two) { "euca-10-20-37-172.eucalyptus.cloud.riotgames.com" }
+
+      let(:response) do
+        {
+          host_one => {
+            groups: ["activemq::master"],
+            result: {
+              status: :ok,
+              message: "",
+              bootstrap_type: :full
+            }
+          },
+          host_two => {
+            groups: ["activemq::master"],
+            result: {
+              status: :ok,
+              message: "",
+              bootstrap_type: :partial
+            }
+          }
+        }
+      end
+
+      let(:manifest) do
+        MB::Bootstrap::Manifest.new(nodes: [
+          {
+            groups: ["activemq::master"],
+            hosts: [ host_one, host_two ]
+          }
+        ])
+      end
+
+      it "sets the job to success" do
+        manager.should_receive(:concurrent_bootstrap).and_return(response)
+        job.should_receive(:report_success)
+
+        run
+      end
+    end
+
+    context "when there is an error in one or more nodes bootstrapped" do
+      let(:host_one) { "euca-10-20-37-171.eucalyptus.cloud.riotgames.com" }
+      let(:host_two) { "euca-10-20-37-172.eucalyptus.cloud.riotgames.com" }
+
+      let(:response) do
+        {
+          host_one => {
+            groups: ["activemq::master"],
+            result: {
+              status: :error,
+              message: "something helpful",
+              bootstrap_type: :full
+            }
+          },
+          host_two => {
+            groups: ["activemq::master"],
+            result: {
+              status: :ok,
+              message: "",
+              bootstrap_type: :partial
+            }
+          }
+        }
+      end
+
+      let(:manifest) do
+        MB::Bootstrap::Manifest.new(nodes: [
+          {
+            groups: ["activemq::master"],
+            hosts: [ host_one, host_two ]
+          }
+        ])
+      end
+
+      it "sets the job to success" do
+        manager.should_receive(:concurrent_bootstrap).and_return(response)
+        job.should_receive(:report_failure)
+
+        run
+      end
+    end
+  end
+
+  describe "#concurrent_bootstrap" do
+    let(:job) { MB::Job.new(:bootstrap) }
+    let(:tasks) { Array.new }
+    let(:instructions) { MB::Bootstrap::Routine.map_instructions(tasks, manifest) }
+    let(:worker_pool) { double('worker-pool') }
+    let(:result) { manager.concurrent_bootstrap(job, manifest, instructions) }
+
+    before { subject.stub(worker_pool: worker_pool) }
+
+    context "with a manifest containing a node group with two groups and a task for each" do
+      let(:tasks) do
+        [
+          MB::Bootstrap::Routine::Task.new("app_server::default",
+            run_list: [ "recipe[one]", "recipe[two]" ],
+            chef_attributes: { deep: { one: "val" } }
+          ),
+          MB::Bootstrap::Routine::Task.new("database_master::default",
+            run_list: [ "recipe[three]" ],
+            chef_attributes: { deep: { two: "val" } }
+          )
+        ]
+      end
+
+      let(:host_one) { "euca-10-20-37-171.eucalyptus.cloud.riotgames.com" }
+      let(:host_two) { "euca-10-20-37-172.eucalyptus.cloud.riotgames.com" }
+
+      let(:response_one) do
+        double('future-one', value: {
+          node:  host_one,
+          status: :ok,
+          message: "",
+          bootstrap_type: :full
+        })
+      end
+
+      let(:response_two) do
+        double('future-two', value: {
+          node: host_two,
+          status: :error,
+          message: "client verification error",
+          bootstrap_type: :partial
+        })
+      end
+
+      let(:manifest) do
+        MB::Bootstrap::Manifest.new(
+          nodes: [
+            {
+              groups: ["app_server::default", "database_master::default"],
+              hosts: [ host_one, host_two ]
+            }
+          ]
+        )
+      end
+
+      it "bootstraps a node only one time" do
+        worker_pool.should_receive(:future).with(:run, host_one, anything).once.and_return(response_one)
+        worker_pool.should_receive(:future).with(:run, host_two, anything).once.and_return(response_two)
+        result
+      end
+
+      it "bootstraps each node with a merged run list from each task" do
+        options = { chef_attributes: anything, run_list: ["recipe[one]", "recipe[two]", "recipe[three]"]}
+        worker_pool.should_receive(:future).with(:run, host_one, options).once.and_return(response_one)
+        worker_pool.should_receive(:future).with(:run, host_two, options).once.and_return(response_two)
+        result
+      end
+
+      it "bootstraps each node with merged chef attributes from each task" do
+        chef_attributes = Hashie::Mash.new(deep: { one: "val", two: "val" })
+        options = { chef_attributes: chef_attributes, run_list: anything }
+        worker_pool.should_receive(:future).with(:run, host_one, options).once.and_return(response_one)
+        worker_pool.should_receive(:future).with(:run, host_two, options).once.and_return(response_two)
+        result
+      end
+    end
+
+    context "when there are no nodes in the manifest" do
+      let(:manifest) { MB::Bootstrap::Manifest.new }
+
+      it "returns an empty Hash" do
+        expect(result).to be_empty
+      end
+    end
+
+    context "given an empty array of tasks" do
+      let(:tasks) { Array.new }
+
+      it "returns an empty Hash" do
+        expect(result).to be_empty
+      end
+    end
+  end
+end

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

@@ -0,0 +1,333 @@
+require 'spec_helper'
+
+describe MB::Bootstrap::Manifest do
+  subject { manifest }
+  let(:manifest) { described_class.new(attributes) }
+
+  let(:attributes) {
+    {
+      nodes: [
+        {
+          groups: ["activemq::master"],
+          hosts: ["amq1.riotgames.com"]
+        },
+
+        {
+          groups: ["nginx::master"],
+          hosts: ["nginx1.riotgames.com"]
+        },
+      ]
+    }
+  }
+  describe "#hosts_for_group" do
+    subject { manifest.hosts_for_group(group) }
+
+    let(:group) { "activemq::master" }
+
+    it { should == manifest[:nodes].first[:hosts] }
+  end
+
+  describe "#validate!" do
+    subject(:validate!) { manifest.validate!(plugin) }
+
+    let(:plugin) {
+      metadata = MB::CookbookMetadata.new do
+        name "pvpnet"
+        version "1.2.3"
+      end
+
+      MB::Plugin.new(metadata) do
+        component "activemq" do
+          group "master"
+        end
+
+        component "nginx" do
+          group "master"
+        end
+
+        stack_order do
+          bootstrap("activemq::master")
+          bootstrap("nginx::master")
+        end
+      end
+    }
+
+    it "does not raise if the manifest is well formed and contains only node groups from the given plugin" do
+      expect { validate! }.to_not raise_error
+    end
+
+    context "when manifest contains a node group that is not part of the plugin" do
+      let(:attributes) {
+        {
+          nodes: [
+            {
+              groups: ["not::defined"],
+              hosts: ["one.riotgames.com"]
+            }
+          ]
+        }
+      }
+
+      it "raises an InvalidBootstrapManifest error" do
+        expect {
+          validate!
+        }.to raise_error(
+          MB::InvalidBootstrapManifest,
+            "Manifest describes the node group 'not::defined' which is not found in the given routine for 'pvpnet (1.2.3)'"
+        )
+      end
+    end
+
+    context "when a key is not in proper node group format: '{component}::{group}'" do
+      let(:attributes) {
+      {
+        nodes: [
+          {
+            groups: ["activemq"],
+            hosts: ["amq1.riotgames.com"]
+          },
+
+          {
+            groups: ["nginx::master"],
+            hosts: ["nginx1.riotgames.com"]
+          },
+        ]
+      }
+      }
+
+      it "raises an InvalidBootstrapManifest error" do
+        expect {
+          validate!
+        }.to raise_error(
+          MB::InvalidBootstrapManifest,
+            "Manifest contained the entry: 'activemq' which is not in the proper node group format: 'component::group'"
+        )
+      end
+    end
+
+    context "when there is no nodes key" do
+      let(:attributes) { { "component::group" => ["box1"] } }
+
+      it "raises an InvalidBootstrapManifest error" do
+        expect {
+          validate!
+        }.to raise_error(
+          MB::InvalidBootstrapManifest
+        )
+      end
+    end
+  end
+
+  describe "::from_provisioner" do
+    let(:manifest) {
+      described_class.from_provisioner(provisioner_response, provisioner_manifest, path)
+    }
+
+    let(:provisioner_response) {
+      [
+        {
+          instance_type: "m1.large",
+          public_hostname: "cloud-1.riotgames.com"
+        },
+        {
+          instance_type: "m1.small",
+          public_hostname: "cloud-2.riotgames.com"
+        },
+        {
+          instance_type: "m1.small",
+          public_hostname: "cloud-3.riotgames.com"
+        }
+      ]
+    }
+
+    let(:provisioner_manifest) {
+      MB::Provisioner::Manifest.new(
+        {
+          options: {
+            ssh: {
+              user: "root",
+              password: "secret"
+            }
+          },
+          nodes: [
+            {
+              type: "m1.large",
+              count: 1,
+              groups: ["activemq::master"]
+            },
+            {
+              type: "m1.small",
+              count: 2,
+              groups: ["activemq::slave"]
+            }
+          ]
+        }
+      )
+    }
+
+    let(:path) { nil }
+
+    it { should be_a(MB::Bootstrap::Manifest) }
+
+    it "has a 'nodes' key" do
+      subject.should have_key(:nodes)
+    end
+
+    it "has a node group for each node group in the provisioner manifest" do
+      subject.node_groups.should have(provisioner_manifest[:nodes].length).items
+    end
+
+    it "each node group contains two keys: 'groups' and 'hosts'" do
+      subject.node_groups.each do |node_group|
+        node_group.keys.should have(2).items
+        node_group.should have_key(:groups)
+        node_group.should have_key(:hosts)
+      end
+    end
+
+    it "has an appropriate number of hosts for the desired count" do
+      subject[:nodes].should =~ [
+        {
+          groups: ["activemq::master"],
+          hosts: [
+            "cloud-1.riotgames.com"
+          ]
+        },
+        {
+          groups: ["activemq::slave"],
+          hosts: [
+            "cloud-2.riotgames.com",
+            "cloud-3.riotgames.com"
+          ]
+        }
+      ]
+    end
+
+    it "copies the options key" do
+      subject[:options].should == {
+        ssh: {
+          user: "root",
+          password: "secret"
+        }
+      }
+    end
+
+    context "multiple nodes of the same type returned by the provisioner" do
+      let(:provisioner_response) do
+        [
+          {
+            instance_type: "m1.large",
+            public_hostname: "cloud-1.riotgames.com"
+          },
+          {
+            instance_type: "m1.large",
+            public_hostname: "cloud-2.riotgames.com"
+          },
+          {
+            instance_type: "m1.large",
+            public_hostname: "cloud-3.riotgames.com"
+          }
+        ]
+      end
+
+      let(:provisioner_manifest) do
+        MB::Provisioner::Manifest.new(
+          nodes: [
+            {
+              type: "m1.large",
+              count: 1,
+              groups: ["activemq::master"]
+            },
+            {
+              type: "m1.large",
+              count: 2,
+              groups: ["activemq::slave"]
+            }
+          ]
+        )
+      end
+
+      subject do
+        described_class.from_provisioner(provisioner_response, provisioner_manifest)
+      end
+
+      it "has an appropriate number of hosts for the desired count" do
+        subject[:nodes].should =~ [
+          {
+            groups: ["activemq::master"],
+            hosts: [
+              "cloud-1.riotgames.com"
+            ]
+          },
+          {
+            groups: ["activemq::slave"],
+            hosts: [
+              "cloud-2.riotgames.com",
+              "cloud-3.riotgames.com"
+            ]
+          }
+        ]
+      end
+    end
+
+    context "given a value for the path argument" do
+      let(:path) { '/tmp/path' }
+
+      it "sets the path value" do
+        manifest.path.should eql('/tmp/path')
+      end
+    end
+
+    context "given one node returned by the provisioner and a manifest containing with multiple groups" do
+      let(:response) do
+        [
+          {
+            instance_type: "m1.large",
+            public_hostname: "cloud-1.riotgames.com"
+          }
+        ]
+      end
+
+      let(:provisioner_manifest) do
+        MB::Provisioner::Manifest.new(
+          {
+            nodes: [
+              {
+                type: "m1.large",
+                groups: ["activemq::master", "activemq::slave"],
+                count: 1
+              }
+            ]
+          }
+        )
+      end
+
+      subject do
+        described_class.from_provisioner(response, provisioner_manifest)
+      end
+
+      it "contains one node group" do
+        subject.node_groups.should have(1).item
+      end
+
+      it "has one host in that node group" do
+        subject.node_groups.first[:hosts].should have(1).item
+      end
+
+      it "has two groups in that node group" do
+        subject.node_groups.first[:groups].should have(2).items
+      end
+
+      it "has an appropriate number of hosts for the desired count" do
+        subject.node_groups.should =~ [
+          {
+            groups: ["activemq::master", "activemq::slave"],
+            hosts: [
+              "cloud-1.riotgames.com"
+            ]
+          }
+        ]
+      end
+    end
+  end
+end