motherbrain 0.0.0.placeholder → 0.13.1

data/spec/unit/mb/command_runner_spec.rb

@@ -0,0 +1,299 @@
+require 'spec_helper'
+
+describe MB::CommandRunner do
+  subject { command_runner }
+
+  let(:command_runner) {
+    described_class.new(job, environment, scope, command_block, node_filter)
+  }
+
+  let(:scope) { MB::Plugin.new(double(valid?: true)) }
+
+  let(:action_1) { double('action_1', name: "action 1", run: nil) }
+  let(:action_2) { double('action_2', name: "action 2", run: nil) }
+
+  let(:actions) { [action_1, action_2] }
+
+  let(:node_1) { double('node_1', name: 'a.riotgames.com', public_hostname: 'a.riotgames.com') }
+  let(:node_2) { double('node_2', name: 'b.riotgames.com', public_hostname: 'b.riotgames.com') }
+  let(:node_3) { double('node_3', name: 'c.riotgames.com', public_hostname: 'c.riotgames.com') }
+  let(:nodes) { [node_1, node_2, node_3] }
+  let(:node_filter) { nil }
+
+  let(:master_group) { double('master_group', nodes: [node_1, node_2]) }
+  let(:slave_group) { double('slave_group', nodes: [node_3]) }
+
+  let(:environment) { "rspec-test" }
+  let(:job) { double('job', set_status: nil) }
+  let(:component) { double('component', name: "foo") }
+  let(:args) { }
+  let(:command_block) {
+    proc {
+      on("master_group") do
+        # block
+      end
+    }
+  }
+
+  before(:each) do
+    MB::CommandRunner::CleanRoom.stub_chain(:new, :actions).and_return(actions)
+
+    scope.stub(:group!).with("master_group").and_return(master_group)
+  end
+
+  describe "#on" do
+    context "with no block" do
+      let(:command_block) {
+        proc { on("master_group") }
+      }
+
+      it "should raise an exception" do
+        -> { command_runner }.should raise_error(MB::PluginSyntaxError)
+      end
+    end
+
+    it "has a single group" do
+      scope.should_receive(:group!).with("master_group").and_return(master_group)
+
+      actions.each do |action|
+        action.
+          should_receive(:run).
+          with(job, environment, master_group.nodes, true)
+      end
+
+      command_runner
+    end
+
+    context "with multiple groups" do
+      let(:command_block) {
+        proc {
+          on("master_group", "slave_group") do
+            # block
+          end
+        }
+      }
+
+      it "works" do
+        scope.should_receive(:group!).with("master_group").and_return(master_group)
+        scope.should_receive(:group!).with("slave_group").and_return(slave_group)
+
+        actions.each do |action|
+          action.should_receive(:run).with(job, environment, nodes, true)
+        end
+
+        command_runner
+      end
+    end
+
+    context "with multiple groups and an option" do
+      let(:command_block) {
+        proc {
+          on("master_group", "slave_group", max_concurrent: 1) do
+            # block
+          end
+        }
+      }
+
+      it "works" do
+        scope.should_receive(:group!).with("master_group").and_return(master_group)
+        scope.should_receive(:group!).with("slave_group").and_return(slave_group)
+
+        actions.each do |action|
+          action.should_receive(:run).with(job, environment, [anything()], true).exactly(3).times
+        end
+
+        command_runner
+      end
+    end
+
+    context "with any: 1" do
+      let(:command_block) {
+        proc {
+          on("master_group", any: 1) do
+            # block
+          end
+        }
+      }
+
+      it "works" do
+        scope.should_receive(:group!).with("master_group").and_return(master_group)
+
+        actions.each do |action|
+          action.should_receive(:run).with(job, environment, [anything()], true)
+        end
+
+        command_runner
+      end
+    end
+
+    context "with max_concurrent: 1" do
+      let(:command_block) {
+        proc {
+          on("master_group", max_concurrent: 1) do
+            # block
+          end
+        }
+      }
+
+      it "runs only on one node at a time" do
+        scope.should_receive(:group!).with("master_group").and_return(master_group)
+
+        actions.each do |action|
+          action.should_receive(:run).with(job, environment, [node_1], true)
+          action.should_receive(:run).with(job, environment, [node_2], true)
+        end
+
+        command_runner
+      end
+    end
+
+    context "with multiple on blocks" do
+      let(:command_block) {
+        proc {
+          on("master_group", max_concurrent: 1) do
+            # block
+          end
+
+          on("slave_group") do
+            # block
+          end
+        }
+      }
+
+      it "works" do
+        scope.should_receive(:group!).with("master_group").and_return(master_group)
+        scope.should_receive(:group!).with("slave_group").and_return(slave_group)
+
+        actions.each do |action|
+          action.should_receive(:run).with(job, environment, [node_1], true).once
+          action.should_receive(:run).with(job, environment, [node_2], true).once
+          action.should_receive(:run).with(job, environment, [node_3], true).once
+        end
+
+        command_runner
+      end
+    end
+  end
+
+  describe "#async" do
+    let(:command_block) {
+      proc {
+        async do
+          on("master_group", max_concurrent: 1) do
+            # block
+          end
+
+          on("slave_group") do
+            # block
+          end
+        end
+      }
+    }
+
+    it "is ran asynchronously" do
+      scope.should_receive(:group!).with("master_group").and_return(master_group)
+      scope.should_receive(:group!).with("slave_group").and_return(slave_group)
+
+      actions.each { |action| action.should_receive(:run).exactly(3).times }
+
+      node_querier.should_receive(:bulk_chef_run)
+
+      command_runner
+    end
+
+    context "when there are no nodes in the target groups" do
+      let(:empty_group) { double('empty_group', nodes: Array.new) }
+      let(:command_block) {
+        proc {
+          async do
+            on("empty_group") do
+              # block
+            end
+          end
+        }
+      }
+
+      it "runs no actions" do
+        scope.should_receive(:group!).with("empty_group").and_return(empty_group)
+
+        actions.each { |action| action.should_not_receive(:run) }
+
+        command_runner
+      end
+    end
+
+    context "with a wait command" do
+      let(:empty_group) { double('empty_group', nodes: Array.new) }
+      let(:command_block) {
+        proc {
+          on("empty_group") do
+            wait 1
+          end
+        }
+      }
+
+      it "sleeps" do
+        pending "Unsure which mock is receiving #wait"
+
+        Celluloid.should_receive(:sleep).with(1)
+
+        command_runner
+      end
+    end
+  end
+
+  describe "#component" do
+    let(:proxy) { command_runner.component("foo") }
+
+    before do
+      scope.should_receive(:component).with("foo").and_return(component)
+    end
+
+    it "returns a proxy" do
+      proxy.should be_an_instance_of(MB::CommandRunner::InvokableComponent)
+    end
+
+    it "sets the component on the proxy" do
+      proxy.component.should eq(component)
+    end
+
+    it "invokes the real component" do
+      component.should_receive(:invoke).with(job, environment, "bar", [])
+      proxy.invoke("bar")
+    end
+  end
+
+  describe "#command" do
+    let(:command) do
+      MB::Command.new("foo", scope) do
+        description "test command"
+        execute do
+          # nothing
+        end
+      end
+    end
+
+    it "is invoked" do
+      scope.should_receive(:group!).with("master_group").and_return(master_group)
+      scope.should_receive(:command!).with("foo").and_return(command)
+
+      command_runner.command("foo")
+    end
+  end
+
+  describe MB::CommandRunner::InvokableComponent do
+    subject { invokable_component }
+
+    let(:invokable_component) {
+      MB::CommandRunner::InvokableComponent.new(job, environment, component)
+    }
+
+    describe "#invoke" do
+      it "invokes the component" do
+        component.should_receive :invoke
+
+        invokable_component.invoke("test")
+      end
+    end
+  end
+end

data/spec/unit/mb/command_spec.rb

@@ -0,0 +1,76 @@
+require 'spec_helper'
+
+describe MB::Command do
+  describe "ClassMethods" do
+    subject { described_class }
+
+    describe "::new" do
+      let(:name) { "stop" }
+      let(:scope) { double }
+      let(:plugin) { MB::Plugin.new(double(valid?: true)) }
+      let(:component) { MB::Component.new("default", plugin) }
+
+      subject { described_class.new(name, scope) }
+
+      context "given an instance of MB::Component for scope" do
+        let(:scope) { component }
+
+        it "has a command type of :component" do
+          subject.type.should eql(:component)
+        end
+
+        it "has a plugin matching the component's plugin" do
+          subject.plugin.should eql(component.plugin)
+        end
+      end
+
+      context "given an instance of MB::Plugin for scope" do
+        let(:scope) { plugin }
+
+        it "has a command type of :plugin" do
+          subject.type.should eql(:plugin)
+        end
+
+        it "has a plugin matching the given scope" do
+          subject.plugin.should eql(plugin)
+        end
+      end
+
+      context "given an instance of an object that does not fit into a scope type" do
+        let(:scope) { double }
+
+        it "raises a RuntimeError" do
+          expect {
+            subject
+          }.to raise_error(RuntimeError)
+        end
+      end
+    end
+  end
+
+  subject { command }
+
+  let(:command) do
+    described_class.new("start", scope) do
+      description "start all services"
+      execute do; true; end
+    end
+  end
+
+  let(:metadata) do
+    double('metadata',
+      name: "rspec-test",
+      version: "1.2.3"
+    )
+  end
+
+  let(:scope) { MB::Plugin.new(metadata) }
+
+  its(:name) { should eql("start") }
+  its(:description) { should eql("start all services") }
+  its(:execute) { should be_a Proc }
+
+  describe "#invoke" do
+    pending
+  end
+end

data/spec/unit/mb/component_spec.rb

@@ -0,0 +1,185 @@
+require 'spec_helper'
+
+describe MB::Component do
+  let(:environment) { 'mb-test' }
+  let(:chef_conn) { double('chef_conn') }
+  let(:plugin) { double(MB::Plugin) }
+
+  subject { component }
+
+  let(:component) {
+    MB::Component.new("activemq", plugin) do
+      group "masters" do
+        # block
+      end
+    end
+  }
+
+  describe "#command" do
+    let(:component) do
+      MB::Component.new("activemq", plugin) do
+        command "existing" do
+          # block
+        end
+      end
+    end
+
+    subject { component.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
+
+  describe "#description" do
+    subject { component.description }
+
+    it { should eq("activemq component commands") }
+
+    context "with a description" do
+      let(:component) {
+        MB::Component.new("activemq", plugin) do
+          description "ActiveMQ"
+        end
+      }
+
+      it { should eq("ActiveMQ") }
+    end
+  end
+
+  describe "#groups" do
+    subject do
+      MB::Component.new("activemq", plugin) do
+        group "masters" do
+          # block
+        end
+      end
+    end
+
+    it "returns a Set of Group objects" do
+      subject.groups.should be_a(Set)
+      subject.groups.should each be_a(MB::Group)
+    end
+  end
+
+  describe "#group" do
+    subject do
+      MB::Component.new("activemq", plugin) do
+        group "masters" do
+          # block
+        end
+      end
+    end
+
+    it "returns the group matching the given name" do
+      subject.group("masters").name.should eql("masters")
+    end
+  end
+
+  describe "#group!" do
+    subject do
+      MB::Component.new("activemq", plugin) do
+        group "masters" do
+          # block
+        end
+      end
+    end
+
+    it "returns the group matching the given name" do
+      subject.group!("masters").name.should eql("masters")
+    end
+
+    it "raises an exception on a missing group" do
+      lambda { subject.group!("slaves") }.should raise_error(MB::GroupNotFound)
+    end
+  end
+
+  describe "#nodes" do
+    pending
+  end
+
+  describe "#add_group" do
+    pending
+  end
+
+  describe "#service" do
+    subject { MB::Component }
+
+    it "returns a Set of services" do
+      component = subject.new("activemq", plugin) do
+        service "masters" do
+          # block
+        end
+      end
+
+      component.gears(MB::Gear::Service).should be_a(Set)
+    end
+
+    it "contains each service defined" do
+      component = subject.new("activemq", plugin) do
+        service "masters" do
+          # block
+        end
+      end
+
+      component.gears(MB::Gear::Service).should have(1).item
+    end
+
+    it "does not allow duplicate services" do
+      lambda do
+        subject.new("activemq", plugin) do
+          service "masters" do
+            # block
+          end
+
+          service "masters" do
+            # block
+          end
+        end
+      end.should raise_error(MB::DuplicateGear)
+    end
+  end
+
+  describe "#versioned" do
+    context "when passed nothing" do
+      subject {
+        klass.new("component_name", plugin) do
+          versioned
+        end
+      }
+
+      its(:version_attribute) { should == "component_name.version" }
+    end
+
+    context "when passed an attribute name" do
+      subject {
+        klass.new("versioned_component", plugin) do
+          versioned_with "my.custom.attribute"
+        end
+      }
+
+      its(:version_attribute) { should == "my.custom.attribute" }
+    end
+  end
+end