motherbrain 0.0.0.placeholder → 0.13.1

data/spec/unit/mb/plugin_spec.rb

@@ -0,0 +1,247 @@
+require 'spec_helper'
+
+describe MB::Plugin do
+  let(:metadata) do
+    MB::CookbookMetadata.new do
+      name             "motherbrain"
+      maintainer       "Jamie Winsor"
+      maintainer_email "jamie@vialstudios.com"
+      license          "Apache 2.0"
+      description      "Installs/Configures motherbrain"
+      long_description "Installs/Configures motherbrain"
+      version          "0.1.0"
+    end
+  end
+
+  describe "ClassMethods" do
+    subject { MB::Plugin }
+
+    describe "::load" do
+      subject(:plugin) do
+        described_class.load(metadata) do
+          # blank plugin
+        end
+      end
+
+      its(:name) { should eql('motherbrain') }
+      its(:maintainer) { should eql('Jamie Winsor') }
+      its(:maintainer_email) { should eql('jamie@vialstudios.com') }
+      its(:license) { should eql('Apache 2.0') }
+      its(:description) { should eql('Installs/Configures motherbrain') }
+      its(:long_description) { should eql('Installs/Configures motherbrain') }
+      its(:version) { subject.to_s.should eql('motherbrain (0.1.0)') }
+      its(:components) { should be_empty }
+      its(:commands) { should be_empty }
+      its(:bootstrap_routine) { should be_nil }
+
+      context "when a stack_order block is present" do
+        subject do
+          described_class.load(metadata) do
+            stack_order do
+              # empty routine
+            end
+          end
+        end
+
+        it "has a Bootstrap::Routine for the value of bootstrap_routine" do
+          subject.bootstrap_routine.should be_a(MB::Bootstrap::Routine)
+        end
+      end
+
+      context "when a command keyword is present" do
+        subject do
+          described_class.load(metadata) do
+            command "start" do
+              description "Start all services"
+
+              execute do
+                component("activemq").invoke("start")
+              end
+            end
+          end
+        end
+
+        it { subject.commands.should have(1).item }
+        it { subject.command("start").should_not be_nil }
+      end
+
+      context "when a component keyword is present" do
+        subject do
+          described_class.load(metadata) do
+            component "activemq" do
+              description "do stuff to AMQ"
+            end
+          end
+        end
+
+        it { subject.components.should have(1).item }
+        it { subject.component("activemq").should_not be_nil }
+      end
+
+      context "when the metadata contains invalid values for attributes" do
+        let(:metadata) do
+          MB::CookbookMetadata.new do
+            name 1
+          end
+        end
+
+        it { -> { plugin }.should raise_error MB::InvalidCookbookMetadata }
+      end
+
+      context "when the plugin contains an unknown keyword" do
+        subject(:plugin) do
+          described_class.load(metadata) do
+            unknown_keyword
+          end
+        end
+
+        it { -> { plugin }.should raise_error MB::PluginSyntaxError }
+      end
+    end
+
+    describe "#from_path" do
+      let(:cb_path) { fixtures_path.join('myface-0.1.0') }
+
+      subject { described_class.from_path(cb_path) }
+
+      it "returns a MB::Plugin from the given directory" do
+        subject.should be_a(MB::Plugin)
+      end
+    end
+  end
+
+  subject { described_class.new(metadata) }
+
+  describe "#to_s" do
+    it "returns the name and version of the plugin" do
+      subject.to_s.should eql("motherbrain (0.1.0)")
+    end
+  end
+
+  describe "comparing plugins" do
+    let(:one) do
+      metadata = MB::CookbookMetadata.new do
+        name 'apple'
+        version '1.0.0'
+      end
+      described_class.new(metadata)
+    end
+    let(:two) do
+      metadata = MB::CookbookMetadata.new do
+        name 'apple'
+        version '2.0.0'
+      end
+      described_class.new(metadata)
+    end
+    let(:three) do
+      metadata = MB::CookbookMetadata.new do
+        name 'cherry'
+        version '1.0.0'
+      end
+      described_class.new(metadata)
+    end
+    let(:four) do
+      metadata = MB::CookbookMetadata.new do
+        name 'cherry'
+        version '2.0.0'
+      end
+      described_class.new(metadata)
+    end
+    let(:five) do
+      metadata = MB::CookbookMetadata.new do
+        name 'orange'
+        version '1.0.0'
+      end
+      described_class.new(metadata)
+    end
+    let(:six) do
+      metadata = MB::CookbookMetadata.new do
+        name 'orange'
+        version '2.0.0'
+      end
+      described_class.new(metadata)
+    end
+
+    let(:list) do
+      [
+        one,
+        two,
+        three,
+        four,
+        five,
+        six
+      ]
+    end
+
+    it "returns the list in the proper order" do
+      list.shuffle.sort.should eql(list)
+    end
+  end
+
+  describe "#to_hash" do
+    subject do
+      described_class.new(metadata).to_hash
+    end
+
+    it "includes a 'name' field and value" do
+      subject[:name].should_not be_nil
+    end
+
+    it "includes a 'version' field and value" do
+      subject[:version].should_not be_nil
+    end
+
+    it "includes a 'description' field and value" do
+      subject[:description].should_not be_nil
+    end
+
+    it "includes a 'long_description' field and value" do
+      subject[:long_description].should_not be_nil
+    end
+
+    it "includes a 'maintainer' field and value" do
+      subject[:maintainer].should_not be_nil
+    end
+
+    it "includes a 'maintainer_email' field and value" do
+      subject[:maintainer_email].should_not be_nil
+    end
+  end
+
+  describe "#command" do
+    let(:plugin) do
+      described_class.new(metadata) do
+        command "existing" do
+          # block
+        end
+      end
+    end
+
+    subject { plugin.command(name) }
+
+    context "when the component has a command matching the given name" do
+      let(:name) { "existing" }
+
+      it { should be_a(MB::Command) }
+      it { name.should eql("existing") }
+    end
+
+    context "when the component does not have a command matching the given name" do
+      let(:name) { "not-there" }
+
+      it { should be_nil }
+    end
+  end
+
+  describe "#command!" do
+    before do
+      subject.stub(command: nil)
+    end
+
+    it "raises a CommandNotFound error when no matching command is present" do
+      expect {
+        subject.command!("stop")
+      }.to raise_error(MB::CommandNotFound)
+    end
+  end
+end

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

@@ -0,0 +1,141 @@
+require 'spec_helper'
+
+describe MB::Provisioner::Manager do
+  subject { provisioner_manager }
+
+  let(:provisioner_manager) { described_class.new }
+
+  let(:job) { double(MB::Job, alive?: true) }
+  let(:environment) { "production" }
+  let(:manifest) { double(MB::Manifest, to_hash: { 'a' => 1 }, provisioner: nil, options: nil) }
+  let(:plugin) { double(MB::Plugin, name: "MyPlugin") }
+
+  subject { described_class.new }
+
+  describe "#async_provision" do
+    let(:environment) { double('environment') }
+    let(:manifest) { double('manifest') }
+    let(:plugin) { double('plugin') }
+
+    it "delegates asynchronously to {#provision}" do
+      subject.should_receive(:async).with(
+        :provision,
+        kind_of(MB::Job),
+        environment,
+        manifest,
+        plugin,
+        anything()
+      )
+
+      subject.async_provision(environment, manifest, plugin)
+    end
+
+    it "returns a JobRecord" do
+      subject.async_provision(environment, manifest, plugin).should be_a(MB::JobRecord)
+    end
+  end
+
+  describe "#provision" do
+    let(:bootstrapper) { double('bootstrapper') }
+    let(:default_provisioner) { provisioner_manager.provisioner_registry[MB::Provisioner.default_id] }
+    let(:options) { Hash.new }
+
+    let!(:job) { MB::Job.new(:provision) }
+    let!(:ticket) { job.ticket }
+
+    subject(:provision) do
+      provisioner_manager.stub(bootstrapper: bootstrapper)
+      provisioner_manager.provision(job, environment, manifest, plugin, options)
+    end
+
+    context "when the manifest defines a provisioner that is started and registered" do
+      before { manifest.stub(provisioner: MB::Provisioner.default_id) }
+
+      it "successfully provisions and bootstraps" do
+        response           = double('provision-response')
+        bootstrap_manifest = double('bootstrap-manifest')
+
+        manifest.should_receive(:validate!).with(plugin)
+        default_provisioner.should_receive(:up).with(job, environment, manifest, plugin, anything).and_return(response)
+        MB::Bootstrap::Manifest.should_receive(:from_provisioner).with(response, manifest).
+          and_return(bootstrap_manifest)
+
+        provisioner_manager.should_receive(:write_bootstrap_manifest)
+        bootstrapper.should_receive(:bootstrap)
+
+        provision
+        expect(ticket.state).to eql(:success)
+      end
+    end
+
+    context "with skip_bootstrap: true" do
+      before { options[:skip_bootstrap] = true }
+
+      it "successfully provisions but skips bootstrap" do
+        response = double('provision-response')
+
+        manifest.should_receive(:validate!).with(plugin)
+        default_provisioner.should_receive(:up).with(job, environment, manifest, plugin, anything).and_return(response)
+
+        bootstrapper.should_not_receive(:bootstrap)
+
+        provision
+        expect(ticket.state).to eql(:success)
+      end
+    end
+  end
+
+  describe "#write_bootstrap_manifest" do
+    subject(:write_bootstrap_manifest) do
+      provisioner_manager.send(:write_bootstrap_manifest, job, environment, manifest, plugin)
+    end
+
+    it "writes the manifest" do
+      job.should_receive :set_status
+
+      expect {
+        write_bootstrap_manifest
+      }.to change { MB::FileSystem.manifests.opendir.count }.by 1
+
+      filename = MB::FileSystem.manifests.opendir.to_a.select { |filename|
+        filename.end_with?(".json")
+      }.last
+
+      expect(filename).to include(plugin.name)
+      expect(filename).to include(environment)
+
+      contents = File.read(MB::FileSystem.manifests.join(filename))
+
+      expect(JSON.parse(contents)).to eq(manifest.to_hash)
+    end
+  end
+
+  describe "#choose_provisioner" do
+    let(:id) { nil }
+    let(:provisioner) { subject.choose_provisioner(id) }
+
+    context "when the given id is nil" do
+      let(:id) { nil }
+
+      it "returns the running default provisioner" do
+        expect(provisioner).to be_a(MB::Provisioner.default)
+      end
+    end
+
+    context "when the given id matches a registered provisioner" do
+      let(:id) { :aws }
+
+      it "returns the matching running provisioner" do
+        expect(provisioner).to be_a(MB::Provisioner::AWS)
+      end
+    end
+
+    context "when there is no provisioner registered with the given id" do
+      let(:id) { :not_existent }
+
+      it "raises ProvisionerNotRegistered if a provisioner with the given ID has not been registered" do
+        expect { provisioner }.to raise_error(MB::ProvisionerNotStarted)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,182 @@
+require 'spec_helper'
+
+describe MB::Provisioner::Manifest do
+  subject { described_class.new(valid_manifest) }
+
+  let(:plugin) {
+    metadata = MB::CookbookMetadata.new {
+      name "motherbrain"
+      version "0.1.0"
+    }
+
+    MB::Plugin.new(metadata)
+  }
+
+  let(:activemq) { MB::Component.new('activemq', plugin) }
+  let(:nginx) { MB::Component.new('nginx', plugin) }
+
+  let(:amq_master) { MB::Group.new('master') }
+  let(:amq_slave) { MB::Group.new('slave') }
+  let(:nginx_master) { MB::Group.new('master') }
+
+  let(:valid_manifest) {
+    {
+      provisioner: "magic",
+      options: {
+        image_id: "emi-1234ABCD",
+        key_name: "mb",
+        security_groups: ["foo", "bar"]
+      },
+      nodes: [
+        {
+          type: "m1.large",
+          groups: ["activemq::master"]
+        },
+        {
+          type: "m1.large",
+          count: 2,
+          groups: ["activemq::slave"]
+        },
+        {
+          type: "m1.small",
+          groups: ["nginx::master"]
+        }
+      ]
+    }
+  }
+
+  before(:each) do
+    plugin.stub(:components).and_return([activemq, nginx])
+    activemq.stub(:groups).and_return([amq_master, amq_slave])
+    nginx.stub(:groups).and_return([nginx_master])
+  end
+
+  its(:node_count) { should == 4 }
+  its(:provisioner) { should == "magic" }
+
+  describe "ClassMethods" do
+    subject { described_class }
+
+    describe "::validate!" do
+      it "returns true if the manifest is valid" do
+        subject.validate!(valid_manifest, plugin).should be_true
+      end
+
+      it "accepts a Provisioner::Manifest" do
+        subject.validate!(described_class.new({ nodes: [] }), plugin).should be_true
+      end
+
+      it "raises InvalidProvisionManifest if given a non-hash value" do
+        expect {
+          subject.validate!(1, plugin)
+        }.to raise_error(MB::InvalidProvisionManifest)
+      end
+
+      context "when manifest contains a group that is not part of the plugin" do
+        before(:each) do
+          plugin.stub(:has_component?).with("activemq").and_return(false)
+          plugin.stub(:has_component?).with("nginx").and_return(false)
+        end
+
+        it "raises an InvalidProvisionManifest error" do
+          lambda {
+            subject.validate!(valid_manifest, plugin)
+          }.should raise_error(MB::InvalidProvisionManifest)
+        end
+      end
+
+      context "when manifest contains a group that is not part of a group" do
+        before(:each) do
+          activemq.stub(:has_group?).with("master").and_return(false)
+        end
+
+        it "raises an InvalidProvisionManifest error" do
+          lambda {
+            subject.validate!(valid_manifest, plugin)
+          }.should raise_error(MB::InvalidProvisionManifest)
+        end
+      end
+
+      context "when groups is not in {group}::{group} format" do
+        let(:invalid_manifest) {
+          {
+            nodes: [
+              {
+                type: "m1.large",
+                count: 1,
+                groups: [
+                  "activemq",
+                  "activemq::slave"
+                ]
+              }
+            ]
+          }
+        }
+
+        it "raises an InvalidProvisionManifest error" do
+          lambda {
+            subject.validate!(invalid_manifest, plugin)
+          }.should raise_error(MB::InvalidProvisionManifest)
+        end
+      end
+
+      context "when groups is not an array" do
+        let(:invalid_manifest) {
+          {
+            nodes: [
+              {
+                type: "m1.large",
+                count: 1,
+                groups: "activemq::slave"
+              }
+            ]
+          }
+        }
+
+        it "raises an InvalidProvisionManifest error" do
+          lambda {
+            subject.validate!(invalid_manifest, plugin)
+          }.should raise_error(MB::InvalidProvisionManifest)
+        end
+      end
+
+      context "when type is not provided or nil" do
+        let(:invalid_manifest) {
+          {
+            nodes: [
+              {
+                count: 1,
+                groups: "activemq::slave"
+              }
+            ]
+          }
+        }
+
+        it "raises an InvalidProvisionManifest error" do
+          expect {
+            subject.validate!(invalid_manifest, plugin)
+          }.to raise_error(MB::InvalidProvisionManifest)
+        end
+      end
+
+      context "when group is nil" do
+        let(:invalid_manifest) {
+          {
+            nodes: [
+              {
+                type: "m1.large",
+                count: 1
+              }
+            ]
+          }
+        }
+
+        it "raises an InvalidProvisionManifest error" do
+          expect {
+            subject.validate!(invalid_manifest, plugin)
+          }.to raise_error(MB::InvalidProvisionManifest)
+        end
+      end
+    end
+  end
+end