motherbrain 0.0.0.placeholder → 0.13.1

data/spec/unit/mb/gears/dynamic_service_spec.rb

@@ -0,0 +1,187 @@
+require 'spec_helper'
+
+describe MB::Gear::DynamicService do
+  let(:dynamic_service) { described_class.new('webapp', 'tomcat') }
+  let(:plugin) { double(MB::Plugin, name: "MyPlugin", component: component) }
+  let(:environment) { "prod" }
+  let(:state) { "start" }
+  let(:component) { double(get_service: service, group: group) }
+  let(:service) { double(service_group: "default", service_attribute: ["foo.bar"], service_recipe: ["tomcat_stop"]) }
+  let(:group) { double(nodes: nodes) }
+  let(:nodes) { [ node1, node2 ] }
+  let(:node1) { double(name: nil, reload: nil, set_chef_attribute: nil, save: nil) }
+  let(:node2) { double(name: nil, reload: nil, set_chef_attribute: nil, save: nil) }
+  let(:job) { MB::Job.new(:thejob) }
+  describe "ClassMethods" do
+    let(:service) { "webapp.tomcat" }
+
+    before do
+      dynamic_service.stub(:state_change)
+      MB::Job.should_receive(:new).and_return(job)
+    end
+
+    describe "::change_service_state" do
+      let(:change_service_state) { MB::Gear::DynamicService.change_service_state(service, plugin, environment, state) }
+
+      it "splits the service on a period" do
+        expect(MB::Gear::DynamicService).to receive(:new).with('webapp', 'tomcat').and_return(dynamic_service)
+        change_service_state
+      end
+
+      context "when the service is not formatted as 'COMPONENT.SERVICE'" do
+        let(:service) { "foo" }
+
+        it "raises an error" do
+          job.should_receive(:report_failure).with(kind_of(MB::InvalidDynamicService))
+          change_service_state
+        end
+      end
+    end
+  end
+
+  let(:job) { double(alive?: false, report_running: nil, set_status: nil, report_success: nil, ticket: nil) }
+
+  describe "#state_change" do
+    let(:state_change) { dynamic_service.state_change(job, plugin, environment, state, true, options) }
+    let(:node_querier) { double(bulk_chef_run: nil) }
+    let(:options) { Hash.new }
+
+    before do
+      dynamic_service.stub(:unset_environment_attribute)
+      dynamic_service.stub(:set_node_attributes)
+      dynamic_service.stub(:node_querier).and_return(node_querier)
+      MotherBrain::Job.stub(:new).and_return(job)
+    end
+
+    it "starts a bulk chef run" do
+      expect(node_querier).to receive(:bulk_chef_run).with(job, nodes, ["tomcat_stop"])
+      state_change
+    end
+
+    context "when you attempt to change to an unsupported state" do
+      let(:state) { "foobar" }
+      let(:log) { double( info: nil) }
+
+      before do
+        MB::Logging.stub(:logger).and_return(log)
+      end
+
+      it "logs a warning" do
+        expect(log).to receive(:warn)
+        state_change
+      end
+    end
+
+    context "when the cluster override flag is provided" do
+      let(:options) do
+        {
+          cluster_override: true
+        }
+      end
+
+      it "sets an attribute on the environment" do
+        expect(dynamic_service).to receive(:set_environment_attribute)
+        state_change
+      end
+    end
+  end
+
+  describe "#remove_node_state_change" do
+    subject              { MB::Gear::DynamicService.new(component_name, service_name) }
+    let(:service_name)   { "foo_service" }
+    let(:service)        { double(MB::Gear::Service,
+                                  service_attribute: ["foo.service_attr"],
+                                  service_recipe: service_recipe) }
+    let(:component_name) { "foo_component" }
+    let(:plugin)         { double(MB::Plugin) }
+    let(:component)      { double(MB::Component) }
+    let(:node_querier)   { double(MB::NodeQuerier) }
+    let(:node)           { double(Ridley::NodeObject) }
+    let(:service_recipe) { "recipe[foo::service]" }
+
+    before do
+      plugin.stub(:component).with(component_name).and_return(component)
+      component.stub(:get_service).with(service_name).and_return(service)
+      subject.stub(:node_querier).and_return(node_querier)
+      subject.stub(:unset_node_attributes).with(job, [node], service.service_attribute)
+      node_querier.stub(:bulk_chef_run).with(job, [node], service.service_recipe)
+    end
+    
+    it "should run chef by default" do
+      expect(node_querier).to receive(:bulk_chef_run).with(job, [node], service_recipe)
+      subject.remove_node_state_change(job, plugin, node)
+    end
+
+    it "should not run chef if told not to" do
+      expect(node_querier).not_to receive(:bulk_chef_run)
+      subject.remove_node_state_change(job, plugin, node, false)
+    end
+
+    it "should set the service node attributes to nil" do
+      expect(subject).to receive(:unset_node_attributes).with(job, [node], service.service_attribute)
+      subject.remove_node_state_change(job, plugin, node, false)
+    end
+  end
+
+  describe "#get_chef_environment" do
+    let(:get_chef_environment) { dynamic_service.get_chef_environment(environment) }
+    let(:result) { double() }
+
+    before do
+      dynamic_service.stub_chain(:chef_connection, :environment, :find).and_return(result)
+    end
+
+    it "returns the chef environment object" do
+      expect(get_chef_environment).to eql(result)
+    end
+  end
+
+  let(:attribute_keys) { ["foo.bar"] }
+  let(:state) { "start" }
+  let(:chef_environment_object) { double(set_override_attribute: nil, delete_override_attribute: nil, save: nil) }
+
+  describe "#set_environment_attribute" do
+
+    before do
+      dynamic_service.stub(:get_chef_environment).and_return(chef_environment_object)
+    end
+
+    let(:set_environment_attribute) { dynamic_service.set_environment_attribute(job, environment, attribute_keys, state) }
+
+    it "sets a chef attribute on the environment" do
+      expect(chef_environment_object).to receive(:set_override_attribute).with('foo.bar', 'start')
+      expect(chef_environment_object).to receive(:save)
+      set_environment_attribute
+    end
+  end
+
+  describe "#unset_environment_attribute" do
+    let(:unset_environment_attribute) { dynamic_service.unset_environment_attribute(job, environment, attribute_keys) }
+
+    before do
+      dynamic_service.stub(:get_chef_environment).and_return(chef_environment_object)
+    end
+
+    it "deletes a chef attribute on the environment" do
+      expect(chef_environment_object).to receive(:delete_override_attribute).with('foo.bar')
+      expect(chef_environment_object).to receive(:save)
+      unset_environment_attribute
+    end
+  end
+
+  describe "#set_node_attributes" do
+    let(:set_node_attribute) { dynamic_service.set_node_attributes(job, nodes, attribute_keys, state) }
+
+    it "sets a chef attribute on the node" do
+      expect(node1).to receive(:set_chef_attribute).with("foo.bar", "start")
+      expect(node2).to receive(:set_chef_attribute).with("foo.bar", "start")
+      set_node_attribute
+    end
+
+    it "saves the node" do
+      expect(node1).to receive(:save)
+      expect(node2).to receive(:save)
+      set_node_attribute
+    end
+  end
+end

data/spec/unit/mb/gears/jmx/action_spec.rb

@@ -0,0 +1,34 @@
+require 'spec_helper'
+
+describe MB::Gear::JMX::Action do
+  subject { described_class }
+  before { described_class.any_instance.stub(jruby?: true) }
+
+  describe "::new" do
+    let(:port) { 9001 }
+    let(:object_name) { "com.some.thing:name=thing" }
+
+    it "should set its attributes" do
+      obj = subject.new(port, object_name) do |mbean|
+        mbean.do_a_thing
+      end
+
+      obj.port.should == port
+      obj.object_name.should == object_name
+      obj.block.should be_a(Proc)
+    end
+
+    it "should be given a block" do
+      lambda do
+        obj = subject.new(port, object_name)
+      end.should raise_error(MB::ArgumentError)
+    end
+
+    it "should be given a block with 1 argument" do
+      lambda do
+        obj = subject.new(port, object_name) do
+        end
+      end.should raise_error(MB::ArgumentError)
+    end
+  end
+end

data/spec/unit/mb/gears/jmx_spec.rb

@@ -0,0 +1,32 @@
+require 'spec_helper'
+
+describe MB::Gear::JMX do
+  subject { described_class }
+
+  it "is registered with MB::Gear" do
+    MB::Gear.all.should include(subject)
+  end
+
+  it "has the inferred keyword ':jmx' from it's Class name" do
+    subject.keyword.should eql(:jmx)
+  end
+
+  describe "#action" do
+    subject { MB::Gear::JMX.new }
+    before { described_class.any_instance.stub(jruby?: true) }
+
+    it "returns a Gear::JMX::Action" do
+      expect(subject.action(9001, "com.some.thing:name=thing") { |bean| }).to be_a(MB::Gear::JMX::Action)
+    end
+
+    context "when not running under JRuby" do
+      before { described_class.any_instance.stub(jruby?: false) }
+
+      it "raises an ActionNotSupported error" do
+        expect {
+          subject.action(9001, "com.some.thing:name=thing")
+        }.to raise_error(MB::ActionNotSupported)
+      end
+    end
+  end
+end

data/spec/unit/mb/gears/mysql/action_spec.rb

@@ -0,0 +1,118 @@
+require 'spec_helper'
+
+describe MB::Gear::MySQL::Action do
+  subject { described_class }
+  let(:environment) { "rspec-test" }
+  let(:sql) { "select * from boxes" }
+  let(:base_options) { {data_bag: {name: "creds"}} }
+
+  describe "::new" do
+    it "should set its attributes" do
+      obj = subject.new(sql, base_options)
+
+      obj.sql.should == sql
+      obj.options.should == base_options
+    end
+  end
+
+  describe "options" do
+    it "should describe a data bag" do
+      options = {}
+      expect { subject.new(sql, options) }.to raise_error(MB::ArgumentError)
+    end
+
+    it "should have a data bag name" do
+      options = {data_bag: {}}
+      expect { subject.new(sql, options) }.to raise_error(MB::ArgumentError)
+
+      options = {data_bag: {name: "creds"}}
+      expect { subject.new(sql, options) }.not_to raise_error
+    end
+  end
+
+  describe "#connection_info" do
+    let(:node) { double("node", public_hostname: "some.node.com") }
+    let(:data_bag_item) { double("data_bag_item") }
+    let(:data_bag) { double("data_bag") }
+    subject { described_class.new(sql, base_options) }
+
+    before(:each) do
+      subject.ridley.stub_chain(:data_bag, :find).and_return(data_bag)
+      data_bag.stub_chain(:item, :find).and_return(data_bag_item)
+    end
+
+    context "the data bag is empty" do
+      before(:each) do
+        data_bag_item.stub(:decrypt).and_return({})
+      end
+
+      it "should raise a GearError" do
+        expect { subject.connection_info(environment, node) }.to raise_error(MB::GearError)
+      end
+    end
+
+    context "the data bag is not empty" do
+      before(:each) do
+        data_bag_hash = {username: "user", password: "pass", database: "db", port: 3306}
+        data_bag_item.stub(:decrypt).and_return(data_bag_hash)
+      end
+
+      it "should have a host" do
+        connection_info = subject.connection_info(environment, node)
+
+        connection_info[:host].should == "some.node.com"
+      end
+
+      it "should retrieve the credentials from the data bag" do
+        connection_info = subject.connection_info(environment, node)
+
+        connection_info[:username].should == "user"
+        connection_info[:password].should == "pass"
+        connection_info[:database].should == "db"
+        connection_info[:port].should == 3306
+      end
+    end
+
+    context "when the data bag does not exist" do
+      before do
+        subject.should_receive(:credentials).with(environment).and_raise(MB::DataBagNotFound.new("kittens"))
+      end
+
+      it "raises a GearError" do
+        expect {
+          subject.connection_info(environment, node)
+        }.to raise_error
+      end
+    end
+
+    context "when the data bag item does not exist" do
+      before do
+        subject.should_receive(:credentials).with(environment).
+          and_raise(MB::DataBagItemNotFound.new("kittens", "puppies"))
+      end
+
+      it "raises a GearError" do
+        expect {
+          subject.connection_info(environment, node)
+        }.to raise_error
+      end
+    end
+  end
+
+  describe "#data_bag_keys" do
+    let(:keys) { [:username, :password, :database, :port] }
+
+    it "should have all of the keys" do
+      obj = subject.new(sql, base_options)
+      keys.each { |key| obj.data_bag_keys.should have_key(key) }
+    end
+
+    it "should prepend the base hash" do
+      options = base_options.dup
+      options[:data_bag][:location] = {hash: "some.hash"}
+      obj = subject.new(sql, options)
+
+      keys.each { |key| obj.data_bag_keys[key].should start_with("some.hash.") }
+    end
+  end
+end

data/spec/unit/mb/gears/mysql_spec.rb

@@ -0,0 +1,21 @@
+require 'spec_helper'
+
+describe MB::Gear::MySQL do
+  subject { described_class }
+
+  it "is registered with MB::Gear" do
+    MB::Gear.all.should include(subject)
+  end
+
+  it "has the inferred keyword ':mysql' from it's Class name" do
+    subject.keyword.should eql(:mysql)
+  end
+
+  describe "#action" do
+    subject { described_class.new }
+
+    it "returns a Gear::MySQL::Action" do
+      subject.action("select * from boxes", data_bag: {name: "creds"}).should be_a(MB::Gear::MySQL::Action)
+    end
+  end
+end

data/spec/unit/mb/gears/service/action_runner_spec.rb

@@ -0,0 +1,182 @@
+require 'spec_helper'
+
+describe MB::Gear::Service::ActionRunner do
+  let(:environment) { "rspec" }
+  let(:node_one) { double(name: 'node-one', save: nil) }
+  let(:node_two) { double(name: 'node-two', save: nil) }
+  let(:node_three) { Ridley::NodeObject.new(nil) }
+  let(:job) { double(set_status: nil) }
+  let(:nodes) { [ node_one, node_two ] }
+
+  subject { action_runner }
+
+  let(:action_runner) { MB::Gear::Service::ActionRunner.new(environment, nodes) }
+
+  before do
+    node_three.stub(:reload)
+    node_three.stub(:save)
+  end
+
+  context "when an action describes a node attribute" do
+    let(:action_runner) {
+      MB::Gear::Service::ActionRunner.new(environment, nodes) do
+        node_attribute('tester', true, toggle: true)
+      end
+    }
+
+    it "has an item in the list of node attributes" do
+      expect(action_runner.node_attributes).to have(1).item
+
+      node_attribute = action_runner.node_attributes[0]
+      expect(node_attribute).to be_a(Hash)
+      expect(node_attribute[:key]).to eql('tester')
+    end
+  end
+
+  context "when an action describes an environment attribute" do
+    let(:action_runner) {
+      MB::Gear::Service::ActionRunner.new(environment, nodes) do
+        environment_attribute('tester', true, toggle: true)
+      end      
+    }
+
+    it "has an item in the list of environment attributes" do
+      expect(action_runner.environment_attributes).to have(1).item
+
+      environment_attribute = action_runner.environment_attributes[0]
+      expect(environment_attribute).to be_a(Hash)
+      expect(environment_attribute[:key]).to eql('tester')
+    end
+  end
+
+  context "when an action describes a service recipe" do
+    let(:action_runner) {
+      MB::Gear::Service::ActionRunner.new(environment, nodes) do
+        service_recipe 'my_recipe'
+      end
+    }
+
+    it "has a service recipe set" do
+      expect(action_runner.service_recipe).to eql('my_recipe')
+    end
+  end
+
+  describe "#add_environment_attribute" do
+    let(:key) { "ruby.application.version" }
+    let(:value) { "1.2.3" }
+    let(:options) { Hash.new }
+
+    it "adds an item to the list of #environment_attributes to set" do
+      subject.add_environment_attribute(key, value, options)
+      expect(subject.environment_attributes).to have(1).item
+    end
+  end
+
+  describe "#add_node_attribute" do
+    let(:key) { "ruby.application.version" }
+    let(:value) { "1.2.3" }
+    let(:options) { Hash.new }
+
+    it "adds an item to the list of #node_attributes to set" do
+      subject.add_node_attribute(key, value, options)
+      expect(subject.node_attributes).to have(1).item
+    end
+  end
+
+  describe "#set_node_attributes" do
+    let(:nodes) { [ node_three ] }
+
+    let(:set_node_attributes) { subject.send(:set_node_attributes, job) }
+
+    context "when force_value_to and toggle are sent" do
+
+      before do
+        subject.add_node_attribute('some.attr', 123, toggle: true, force_value_to: 789)
+      end
+
+      it "sets the node attribute" do
+        node_three.should_receive(:set_chef_attribute).with('some.attr', 123)
+        set_node_attributes
+      end
+
+      it "adds a callback" do
+        set_node_attributes
+        expect(subject.toggle_callbacks.size).to eql(1)
+      end
+    end
+  end
+
+  describe "#set_environment_attributes" do
+    let(:environment) { Ridley::EnvironmentObject.new(nil) }
+    let(:ridley) { double( 'foo', environment: environment_resource) }
+    let(:environment_resource) { double(find: environment) }
+    let(:set_environment_attributes) { subject.send(:set_environment_attributes, job) }
+
+    before do
+      subject.add_environment_attribute('some.env.attr', 123, toggle: true)
+      MB::Application.stub(:[]).and_return(ridley)
+      environment.stub(:save)
+    end
+
+    it "sets the environment attribute" do
+      environment.should_receive(:set_default_attribute).with('some.env.attr', 123)
+      set_environment_attributes
+    end
+
+    it "adds a callback" do
+      set_environment_attributes
+      expect(subject.toggle_callbacks.size).to eql(1)
+    end
+  end
+
+  describe "#reset" do
+    let(:nodes) { [ node_three ] }
+
+    let(:reset) { subject.reset(job) }
+
+    context "when the callback toggles a node attribute" do
+
+      before do
+        subject.add_node_attribute('some.attr', 123, toggle: true)
+        subject.send(:set_node_attributes, job)
+      end
+
+      it "resets the original value" do
+        node_three.should_receive(:set_chef_attribute).with('some.attr', nil)
+        reset
+      end
+    end
+
+    context "when the callback uses force_value_to on a node attribute" do
+
+      before do
+        subject.add_node_attribute('some.attr', 123, toggle: true, force_value_to: 789)
+        subject.send(:set_node_attributes, job)
+      end
+
+      it "sets the attribute to the forced value" do
+        node_three.should_receive(:set_chef_attribute).with('some.attr', 789)
+        reset
+      end
+    end
+
+    context "when the callback toggles an environment attribute" do
+      let(:environment) { Ridley::EnvironmentObject.new(nil) }
+      let(:ridley) { double( 'foo', environment: environment_resource) }
+      let(:environment_resource) { double(find: environment) }
+
+
+      before do
+        MB::Application.stub(:[]).and_return(ridley)
+        environment.stub(:save)
+        subject.add_environment_attribute('some.env.attr', 123, toggle: true)
+        subject.send(:set_environment_attributes, job)
+      end
+
+      it "removes the attribute key" do
+        environment.should_receive(:delete_default_attribute).with('some.env.attr')
+        reset
+      end
+    end
+  end
+end