motherbrain 0.0.0.placeholder → 0.13.1

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

@@ -0,0 +1,44 @@
+require 'spec_helper'
+
+describe MB::Gear::Service::Action do
+  let(:component) { double('component', name: 'test-component') }
+  let(:job) { double('job', set_status: nil) }
+  let(:klass) { described_class }
+
+  let(:environment) { "rspec-test" }
+  let(:node_1) { double('node_1', name: 'reset', public_hostname: 'reset.riotgames.com') }
+  let(:node_2) { double('node_2', name: 'jwinsor', public_hostname: 'jwinsor.riotgames.com') }
+  let(:node_3) { double('node_3', name: 'jwinsor-2', public_hostname: 'jwinsor-2.riotgames.com') }
+  let(:nodes) { [ node_1, node_2, node_3 ] }
+
+  describe "#run" do
+    subject do
+      klass.new(:start, component) do
+        # block
+      end
+    end
+
+    let(:runner) { double('action_runner', reset: nil, run: nil, service_recipe: nil) }
+    let(:key) { "some.attr" }
+    let(:value) { "val" }
+    let(:chef_success) { double('success-response', error?: false, host: nil) }
+    let(:chef_run_options) { { override_recipe: nil } }
+    let(:node_querier) { double('node_querier', bulk_chef_run: nil) }
+
+    before(:each) do
+      MB::Gear::Service::ActionRunner.stub(:new).and_return(runner)
+      MB::Gear::Service::Action.any_instance.stub(:node_querier).and_return(node_querier)
+    end
+
+    it "runs Chef on every node" do
+      expect(node_querier).to receive(:bulk_chef_run).with(job, nodes, nil)
+      subject.run(job, environment, nodes)
+    end
+
+    it "resets the ActionRunner" do
+      runner.should_receive(:reset)
+
+      subject.run(job, environment, [])
+    end
+  end
+end

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

@@ -0,0 +1,124 @@
+require 'spec_helper'
+
+describe MB::Gear::Service do
+  let(:component) { double('component', name: 'test-component') }
+  let(:job) { double('job', set_status: nil) }
+
+  describe "Class" do
+    subject { MB::Gear::Service }
+
+    it "is registered with MB::Gear" do
+      MB::Gear.all.should include(subject)
+    end
+
+    it "has the inferred keyword ':service' from it's Class name" do
+      subject.keyword.should eql(:service)
+    end
+
+    describe "::new" do
+      it "sets the given name attribute" do
+        obj = subject.new(component, "activemq") do
+          # block
+        end
+
+        obj.name.should eql("activemq")
+      end
+    end
+  end
+
+  subject do
+    MB::Gear::Service.new("service", component) do
+      # block
+    end
+  end
+
+  describe "#actions" do
+    subject do
+      MB::Gear::Service.new("service", component) do
+        action :start do
+          node_attribute("key.one", true)
+        end
+
+        action :stop do
+          # block
+        end
+      end
+    end
+
+    it "returns a Set of Gear::Action::Service objects for each defined action" do
+      subject.actions.should be_a(Set)
+      subject.actions.should have(2).items
+      subject.actions.should each be_a(MB::Gear::Service::Action)
+    end
+  end
+
+  describe "#action!" do
+    subject do
+      MB::Gear::Service.new("activemq", component) do
+        action :start do
+          node_attribute("key.one", true)
+        end
+      end
+    end
+
+    it "returns a Gear::Service::Action" do
+      subject.action!(:start).should be_a(MB::Gear::Service::Action)
+    end
+
+    context "given an action that does not exist" do
+      it "raises an ActionNotFound error" do
+        lambda {
+          subject.action!(:stop)
+        }.should raise_error(MB::ActionNotFound)
+      end
+    end
+  end
+
+  describe "#action" do
+    subject do
+      MB::Gear::Service.new("activemq", component) do
+        action :start do
+          node_attribute("key.one", true)
+        end
+      end
+    end
+
+    it "returns a Gear::Service::Action" do
+      subject.action(:start).should be_a(MB::Gear::Service::Action)
+    end
+
+    context "given an action that does not exist" do
+      it "returns nil" do
+        expect(subject.action(:stop)).to be_nil
+      end
+
+      it "does not raise an ActionNotFound error" do
+        lambda {
+          subject.action(:stop)
+        }.should_not raise_error
+      end
+    end
+  end
+
+  describe "#add_action" do
+    let(:action_1) { double('action_1', name: "start") }
+    let(:action_2) { double('action_2', name: "stop") }
+
+    it "adds the given action to the set of actions" do
+      subject.add_action(action_1)
+
+      subject.actions.should have(1).item
+      subject.action!("start").should eql(action_1)
+    end
+
+    context "when an action of the given name has already been defined" do
+      it "raises a DuplicateAction error" do
+        lambda {
+          subject.add_action(action_1)
+          subject.add_action(action_1)
+        }.should raise_error(MB::DuplicateAction)
+      end
+    end
+  end
+
+end

data/spec/unit/mb/group_spec.rb

@@ -0,0 +1,280 @@
+require 'spec_helper'
+
+describe MB::Group do
+  let(:environment) { "mb-test" }
+
+  describe "ClassMethods" do
+    subject { MB::Group }
+
+    describe "::new" do
+      context "given a block with multiple recipe calls" do
+        it "adds each recipe to the array of recipes on the instantiated Group" do
+          obj = subject.new("bacon") do
+            recipe "bacon::default"
+            recipe "bacon::database"
+          end
+
+          obj.recipes.should have(2).items
+          obj.recipes.should include("bacon::default")
+          obj.recipes.should include("bacon::database")
+        end
+      end
+
+      context "given a block with multiple role calls" do
+        it "adds each role to the array of roles on the instantiated Group" do
+          obj = subject.new("roles_are_poopy") do
+            role "roles_are_evil"
+            role "stop_using_roles"
+          end
+
+          obj.roles.should have(2).items
+          obj.roles.should include("roles_are_evil")
+          obj.roles.should include("stop_using_roles")
+        end
+      end
+
+      context "when an attribute of the same name is defined" do
+        it "raises a DuplicateGroup error" do
+          lambda {
+            subject.new("db_master") do
+              chef_attribute "pvpnet.database.master", true
+              chef_attribute "pvpnet.database.master", false
+            end
+          }.should raise_error(MB::DuplicateChefAttribute)
+        end
+      end
+    end
+  end
+
+  describe "#name" do
+    subject do
+      MB::Group.new("master_database") do
+        # block
+      end
+    end
+
+    it "returns the name of the Group" do
+      subject.name.should eql("master_database")
+    end
+  end
+
+  describe "#recipes" do
+    subject do
+      MB::Group.new("pvpnet") do
+        recipe "pvpnet::default"
+        recipe "pvpnet::database"
+        recipe "pvpnet::app"
+      end
+    end
+
+    it "returns a Set of recipes" do
+      subject.recipes.should be_a(Set)
+    end
+
+    it "includes all of the recipes from the block passed to Group.new" do
+      subject.recipes.should have(3).items
+      subject.recipes.should include("pvpnet::default")
+      subject.recipes.should include("pvpnet::database")
+      subject.recipes.should include("pvpnet::app")
+    end
+
+    context "when a recipe of the same name is defined" do
+      subject do
+        MB::Group.new("pvpnet") do
+          recipe "pvpnet::default"
+          recipe "pvpnet::default"
+        end
+      end
+
+      it "does not add a duplicate recipe" do
+        subject.recipes.should have(1).item
+      end
+    end
+  end
+
+  describe "#roles" do
+    subject do
+      MB::Group.new("roles_are_poopy") do
+        role "stop"
+        role "fucking"
+        role "using"
+        role "roles"
+      end
+    end
+
+    it "returns a Set of roles" do
+      subject.roles.should be_a(Set)
+    end
+
+    it "includes all of the roles from the block passed to Group.new" do
+      subject.roles.should have(4).items
+      subject.roles.should include("stop")
+      subject.roles.should include("fucking")
+      subject.roles.should include("using")
+      subject.roles.should include("roles")
+    end
+
+    context "when a role of the same name is defined" do
+      subject do
+        MB::Group.new("roles_are_poopy") do
+          role "asshole_role"
+          role "asshole_role"
+        end
+      end
+
+      it "does not add a duplicate role" do
+        subject.roles.should have(1).item
+      end
+    end
+  end
+
+  describe "#chef_attributes" do
+    subject do
+      MB::Group.new("db_master") do
+        chef_attribute "pvpnet.database.master", true
+        chef_attribute "pvpnet.database.slave", false
+      end
+    end
+
+    it "returns a Hash" do
+      subject.chef_attributes.should be_a(Hash)
+    end
+
+    it "has a key for every chef_attribute" do
+      subject.chef_attributes.should have_key("pvpnet.database.master")
+      subject.chef_attributes.should have_key("pvpnet.database.slave")
+    end
+
+    it "has the value for every chef_attribute" do
+      subject.chef_attributes["pvpnet.database.master"].should eql(true)
+      subject.chef_attributes["pvpnet.database.slave"].should eql(false)
+    end
+  end
+
+  describe "#search_query" do
+    let(:group) { double('group') }
+    subject { group.search_query(environment) }
+
+    context "with one chef attribute" do
+      let(:group) do
+        MB::Group.new("db_master") do
+          chef_attribute "pvpnet.database.master", true
+        end
+      end
+
+      it "returns one key:value search string" do
+        expect(subject).to eql("chef_environment:#{environment} AND pvpnet_database_master:true")
+      end
+    end
+
+    context "with multiple chef attributes" do
+      let(:group) do
+        MB::Group.new("db_master") do
+          chef_attribute "pvpnet.database.master", true
+          chef_attribute "pvpnet.database.slave", false
+        end
+      end
+
+      it "returns them escaped and joined together by AND" do
+        expect(subject).to eql("chef_environment:#{environment} AND pvpnet_database_master:true AND pvpnet_database_slave:false")
+      end
+    end
+
+    context "with multiple recipes" do
+      let(:group) do
+        MB::Group.new("pvpnet") do
+          recipe "pvpnet::default"
+          recipe "pvpnet::database"
+        end
+      end
+
+      it "returns them escaped and joined together by AND" do
+        expect(subject).to eql("chef_environment:#{environment} AND recipes:pvpnet\\:\\:default AND recipes:pvpnet\\:\\:database")
+      end
+    end
+
+    context "with dash-separated recipes" do
+      let(:group) do
+        MB::Group.new("pvpnet") do
+          recipe "build-essential"
+        end
+      end
+
+      it "does not escape the dash" do
+        expect(subject).to eql("chef_environment:#{environment} AND recipes:build-essential")
+      end
+    end
+
+    context "with multiple roles" do
+      let(:group) do
+        MB::Group.new("roles") do
+          role "app_server"
+          role "database_server"
+        end
+      end
+
+      it "returns them escaped and joined together by AND" do
+        expect(subject).to eql("chef_environment:#{environment} AND roles:app_server AND roles:database_server")
+      end
+    end
+  end
+
+  subject { MB::Group.new("test-group") }
+
+  describe "#run_list" do
+    subject do
+      MB::Group.new("test-group") do
+        role "role_one"
+        role "role_two"
+        recipe "test::default"
+        recipe "test::special"
+      end
+    end
+
+    it "returns an array" do
+      subject.run_list.should be_a(Array)
+    end
+
+    it "contains an item for each role and recipe on the group" do
+      subject.run_list.should have(4).items
+    end
+
+    describe "each role element" do
+      it "is wrapped in the string 'role[]'" do
+        subject.run_list[0].should eql("role[role_one]")
+        subject.run_list[1].should eql("role[role_two]")
+      end
+    end
+
+    describe "each recipe element" do
+      it "is wrapped in the string 'recipe[]'" do
+        subject.run_list[2].should eql("recipe[test::default]")
+        subject.run_list[3].should eql("recipe[test::special]")
+      end
+    end
+  end
+
+  describe "#includes_recipe?" do
+    subject do
+      MB::Group.new("test-group") do
+        role "role_one"
+        role "role_two"
+        recipe "test::default"
+        recipe "test::special"
+      end
+    end
+
+    it "should return true when the recipe is included directly" do
+      expect(subject.includes_recipe?("recipe[test::default]")).to be_true
+    end
+
+    it "should return true when the recipe is included in a role" do
+      pending "write role expansion"
+      expect(subject.includes_recipe?("recipe[role_one_recipe::default]")).to be_true
+    end
+
+    it "should return false when the recipe is not included" do
+      expect(subject.includes_recipe?("recipe[test::doesnt_exist]")).to be_false
+    end
+  end
+end