motherbrain 0.0.0.placeholder → 0.13.1

data/spec/unit/mb/provisioners/environment_factory_spec.rb

@@ -0,0 +1,108 @@
+require 'spec_helper'
+
+describe MB::Provisioner::EnvironmentFactory do
+  let(:manifest) {
+    MB::Provisioner::Manifest.new.from_json(manifest_hash.to_json)
+  }
+  let(:manifest_hash) {
+    {
+      nodes: [
+        {
+          type: "m1.large",
+          count: 4,
+          components: ["activemq::master"]
+        },
+        {
+          type: "m1.large",
+          count: 2,
+          components: ["activemq::slave"]
+        },
+        {
+          type: "m1.small",
+          count: 2,
+          components: ["nginx::server"]
+        }
+      ]
+    }
+  }
+
+  describe "ClassMethods" do
+    subject { described_class }
+
+    describe "::convert_manifest" do
+      it "returns an array of hashes" do
+        subject.convert_manifest(manifest).should be_a(Array)
+        subject.convert_manifest(manifest).should each be_a(Hash)
+      end
+
+      it "contains an element for the amount of each node group and instance type" do
+        subject.convert_manifest(manifest).should have(8).items
+      end
+
+      describe "with different ordering" do
+        let(:manifest_hash) {
+          {
+            nodes: [
+              { groups: "default", type: "none" },
+              { type: "none", groups: "default", count: 2 }
+            ]
+          }
+        }
+
+        it "it still works" do
+          subject.convert_manifest(manifest).should be_a(Array)
+        end
+      end
+    end
+  end
+
+  let(:options) do
+    {
+      api_url: "https://ef.riotgames.com",
+      api_key: "58dNU5xBxDKjR15W71Lp",
+      ssl: {
+        verify: false
+      }
+    }
+  end
+
+  subject { described_class.new(options) }
+
+  describe "#up" do
+    let(:job) { MB::Job.new(:provision) }
+    let(:env_name) { "mbtest" }
+    let(:plugin) { double('plugin') }
+    let(:options) { Hash.new }
+
+    it "skips the bootstrap process" do
+      connection         = double('connection')
+      environment        = double('environment')
+      converted_manifest = Hash.new
+
+      subject.should_receive(:new_connection).and_return(connection)
+      described_class.should_receive(:convert_manifest).with(manifest).and_return(converted_manifest)
+      described_class.should_receive(:handle_created).with(environment).and_return(Array.new)
+      described_class.should_receive(:validate_create).and_return(true)
+      connection.stub_chain(:environment, :create).with(env_name, converted_manifest).and_return(Hash.new)
+      connection.stub_chain(:environment, :created?).with(env_name).and_return(true)
+      connection.stub_chain(:environment, :find).with(env_name, force: true).and_return(environment)
+
+      subject.up(job, env_name, manifest, plugin, options)
+    end
+  end
+
+  describe "#down" do
+    let(:job) { MB::Job.new(:destroy) }
+    let(:env_name) { "mbtest" }
+
+    it "sends a destroy command to environment factory with the given environment" do
+      connection = double('connection')
+
+      subject.should_receive(:new_connection).and_return(connection)
+      subject.should_receive(:destroyed?).with(connection, env_name).and_return(true)
+      connection.stub_chain(:environment, :destroy).with(env_name).and_return(Hash.new)
+
+      subject.down(job, env_name, options)
+    end
+  end
+end

data/spec/unit/mb/rest_gateway_spec.rb

@@ -0,0 +1,13 @@
+require 'spec_helper'
+
+describe MB::RestGateway do
+  include Rack::Test::Methods
+
+  after { subject.terminate }
+
+  describe "#app" do
+    it "returns MB::API::Application" do
+      subject.app.should be_a(MB::API::Application)
+    end
+  end
+end

data/spec/unit/mb/ridley_ext/cookbook_object_spec.rb

@@ -0,0 +1,105 @@
+require 'spec_helper'
+
+describe Ridley::CookbookObject do
+  let(:client) { double('client') }
+
+  describe "#has_motherbrain_plugin?" do
+    context "when a metadata.rb, metadata.json, and motherbrain.rb file are present in root_files" do
+      subject do
+        described_class.new(client,
+          root_files: [
+            {
+              name: "metadata.rb",
+              url: "https://s3.amazonaws.com/opscode-platform-production-data/organization-(...)",
+              checksum: "967087a09f48f234028d3aa27a094882",
+              path: "metadata.rb",
+              specificity: "default"
+            },
+            {
+              name: "motherbrain.rb",
+              url: "https://s3.amazonaws.com/opscode-platform-production-data/organization-(...)",
+              checksum: "d18c630c8a68ffa4852d13214d0525a6",
+              path: "motherbrain.rb",
+              specificity: "default"
+            }
+          ]
+        )
+      end
+
+      it { should have_motherbrain_plugin }
+    end
+
+    context "when a motherbrain.rb is present" do
+      let(:root_files) do
+        [
+          {
+            name: "motherbrain.rb",
+            url: "https://s3.amazonaws.com/opscode-platform-production-data/organization-(...)",
+            checksum: "d18c630c8a68ffa4852d13214d0525a6",
+            path: "motherbrain.rb",
+            specificity: "default"
+          }
+        ]
+      end
+
+      subject { described_class.new(client, root_files: root_files) }
+
+      context "when a metadata.rb is present in the root_files" do
+        before do
+          root_files << {
+            name: "metadata.rb",
+            url: "https://s3.amazonaws.com/opscode-platform-production-data/organization-(...)",
+            checksum: "967087a09f48f234028d3aa27a094882",
+            path: "metadata.rb",
+            specificity: "default"
+          }
+        end
+
+        it { should have_motherbrain_plugin }
+      end
+
+      context "when a metadata.json is present in the root_files" do
+        before do
+          root_files << {
+            name: "metadata.json",
+            url: "https://s3.amazonaws.com/opscode-platform-production-data/organization-(...)",
+            checksum: "44ca6f96d3f0a7299cfff2f69295bc55",
+            path: "metadata.json",
+            specificity: "default"
+          }
+        end
+
+        it { should have_motherbrain_plugin }
+      end
+
+      context "when there is no metadata.rb or metadata.json in the root_files" do
+        it { should_not have_motherbrain_plugin }
+      end
+    end
+
+    context "when missing a motherbrain.rb file" do
+      let(:root_files) do
+        [
+          {
+            name: "metadata.rb",
+            url: "https://s3.amazonaws.com/opscode-platform-production-data/organization-(...)",
+            checksum: "967087a09f48f234028d3aa27a094882",
+            path: "metadata.rb",
+            specificity: "default"
+          },
+          {
+            name: "metadata.json",
+            url: "https://s3.amazonaws.com/opscode-platform-production-data/organization-(...)",
+            checksum: "44ca6f96d3f0a7299cfff2f69295bc55",
+            path: "metadata.json",
+            specificity: "default"
+          }
+        ]
+      end
+
+      subject { described_class.new(client, root_files: root_files) }
+
+      it { should_not have_motherbrain_plugin }
+    end
+  end
+end

data/spec/unit/mb/srv_ctl_spec.rb

@@ -0,0 +1,142 @@
+require 'spec_helper'
+
+describe MB::SrvCtl do
+  describe "ClassMethods" do
+    describe "::parse" do
+      let(:args) { Array.new }
+      let(:filename) { "mbsrv" }
+
+      subject { described_class.parse(args, filename) }
+
+      it "returns a hash" do
+        subject.should be_a(Hash)
+      end
+
+      context "given -c" do
+        let(:args) { ["-c", "/tmp/config.json"] }
+
+        it "sets :config to the given value" do
+          subject[:config].should eql("/tmp/config.json")
+        end
+      end
+
+      context "given -k" do
+        let(:args) { ["-k"] }
+
+        it "sets :kill to true" do
+          subject[:kill].should be_true
+        end
+      end
+
+      context "given -v" do
+        let(:args) { ["-v"] }
+
+        it "sets :log_level to Logger::DEBUG" do
+          subject[:log_level].should eql(Logger::DEBUG)
+        end
+      end
+
+      context "given -d" do
+        let(:args) { ["-d"] }
+
+        it "sets :daemonize to true" do
+          subject[:daemonize].should be_true
+        end
+      end
+
+      context "given -P" do
+        let(:args) { ["-P", "/var/run/some.pid"] }
+
+        it "sets :pid_file to the given value" do
+          subject[:pid_file].should eql("/var/run/some.pid")
+        end
+      end
+
+      context "given -P and -d" do
+        let(:args) { ["-P", "/var/run/some.pid", "-d"] }
+
+        it "sets :pid_file to the given value" do
+          subject[:pid_file].should eql("/var/run/some.pid")
+        end
+      end
+    end
+
+    describe "::new" do
+      before(:each) do
+        generate_valid_config(MB::Config.default_path)
+      end
+
+      let(:options) { Hash.new }
+      subject { described_class.new(options) }
+
+      context "given no options" do
+        it "sets a default value for :config" do
+          subject.config.should_not be_nil
+        end
+      end
+
+      context "given :daemonize is true" do
+        let(:options) { { daemonize: true } }
+
+        it "sets config.server.daemonize to true" do
+          subject.config.server.daemonize.should be_true
+        end
+      end
+
+      context "given a value for :pid_file" do
+        let(:options) { { pid_file: "/tmp/some.pid" } }
+
+        it "sets config.server.pid to the value" do
+          subject.config.server.pid.should eql("/tmp/some.pid")
+        end
+      end
+
+      context "given a value for :log_level" do
+        let(:options) { { log_level: 'INFO' } }
+
+        it "sets config.log.level to the value" do
+          subject.config.log.level.should eql("INFO")
+        end
+      end
+
+      context "given a value for :log_location" do
+        let(:options) { { log_location: "/tmp/logs" } }
+
+        it "sets config.log.location to the value" do
+          subject.config.log.location.should eql("/tmp/logs")
+        end
+      end
+    end
+  end
+
+  describe "#daemonize" do
+    let(:config) { double("config", :to_logger => nil) }
+    let(:ui) { double("ui", :say => nil) }
+
+    before do
+      MB::Config.stub(:from_file).and_return(config)
+      MB::Logging.stub(:setup)
+      MB::SrvCtl.stub(:ui).and_return(ui)
+    end
+
+    let(:srv_ctl) { described_class.new }
+    let(:daemonize) { srv_ctl.send(:daemonize) }
+
+    context "when the pid directory does not exist" do
+
+      before do
+        File.stub(:exist?).and_return(false)
+        FileUtils.stub(:mkdir_p)
+        srv_ctl.stub(:pid_directory).and_return("")
+        File.stub(:writable?).and_return(true)
+        Process.stub(:daemon)
+        srv_ctl.stub(:create_pid)
+      end
+
+      it "attempts to make the directory" do
+        FileUtils.should_receive(:mkdir_p).and_return(nil)
+        daemonize
+      end
+    end
+  end
+end

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

@@ -0,0 +1,37 @@
+require 'spec_helper'
+
+describe MB::Upgrade::Manager do
+  let(:environment) { "environment" }
+  let(:plugin) { double('plugin') }
+  let(:options) { Hash.new }
+
+  subject { described_class.new }
+
+  describe "#async_upgrade" do
+    let(:ticket) { double('ticket') }
+    let(:job) { double('job', ticket: ticket) }
+
+    before(:each) do
+      MB::Job.should_receive(:new).with(:upgrade).and_return(job)
+      subject.should_receive(:async).with(:upgrade, job, environment, plugin, options).and_return(ticket)
+    end
+
+    it "returns a job ticket" do
+      subject.async_upgrade(environment, plugin, options).should eql(ticket)
+    end
+  end
+
+  describe "#upgrade" do
+    let(:job) { double('job', alive?: true) }
+    let(:worker) { double('worker', alive?: true) }
+
+    it "runs the request in a worker and then terminates the job and worker" do
+      MB::Upgrade::Worker.should_receive(:new).with(job, environment, plugin, options).and_return(worker)
+      job.should_receive(:terminate)
+      worker.should_receive(:terminate)
+      worker.should_receive(:run)
+
+      subject.upgrade(job, environment, plugin, options)
+    end
+  end
+end

data/spec/unit/mb/upgrade/worker_spec.rb

@@ -0,0 +1,219 @@
+require 'spec_helper'
+
+describe MB::Upgrade::Worker do
+  subject { worker }
+
+  let(:worker) { klass.new(job, environment_name, plugin, options).wrapped_object }
+
+  let(:component1) { MB::Component.new(component_name, plugin) }
+  let(:component_name) { "component1" }
+  let(:component_versions) { { component_name => "1.2.3" } }
+  let(:components) { [component1] }
+  let(:cookbook_versions) { { "ohai" => "1.2.3" } }
+  let(:environment) { double }
+  let(:environment_name) { "rspec-test" }
+  let(:job) { job_double }
+  let(:options) { Hash.new }
+  let(:nodes) { %w[node1 node2 node3] }
+  let(:plugin) { double MB::Plugin, name: plugin_name }
+  let(:plugin_name) { "plugin_name" }
+
+  before do
+    worker.stub(
+      assert_environment_exists: true,
+      nodes: nodes,
+      set_component_versions: nil,
+      set_cookbook_versions: nil,
+      save_environment: true,
+      run_chef: true
+    )
+    plugin.stub(:component!).with(component_name).and_return(component1)
+  end
+
+  its(:environment_name) { should == environment_name }
+  its(:plugin) { should == plugin }
+  its(:options) { should == options }
+
+  describe "#run" do
+    subject(:run) { worker.run }
+
+    it "wraps the upgrade in a lock" do
+      MB::ChefMutex.any_instance.should_receive :synchronize
+
+      run
+    end
+
+    it "marks the job as 'running' and then 'success' if successful" do
+      job.should_receive(:report_running).ordered
+      job.should_receive(:report_success).ordered
+
+      run
+    end
+
+    context "when an environment does not exist" do
+      before do
+        worker.stub(:assert_environment_exists).and_raise(MB::EnvironmentNotFound.new(environment_name))
+      end
+
+      it "should set the job state to :failure" do
+        job.should_receive(:report_failure)
+        run
+      end
+    end
+
+    context "when only cookbook_versions is passed as an option" do
+      before do
+        options[:cookbook_versions] = cookbook_versions
+        options[:component_versions] = nil
+      end
+
+      it "updates only the cookbook versions and runs chef" do
+        worker.should_receive(:set_cookbook_versions).ordered
+        worker.should_receive(:run_chef).ordered
+
+        worker.should_not_receive :set_component_versions
+
+        run
+      end
+    end
+
+    context "when only component_versions is passed as an option" do
+      before do
+        options[:cookbook_versions] = nil
+        options[:component_versions] = component_versions
+      end
+
+      it "updates only the component versions and runs chef" do
+        worker.should_receive(:set_component_versions).ordered
+        worker.should_receive(:run_chef).ordered
+
+        worker.should_not_receive :set_cookbook_versions
+
+        run
+      end
+    end
+
+    context "when both component_versions and cookbook_versions are passed as options" do
+      before do
+        options[:cookbook_versions] = cookbook_versions
+        options[:component_versions] = component_versions
+      end
+
+      it "updates the versions and runs chef" do
+        worker.should_receive(:set_component_versions).ordered
+        worker.should_receive(:set_cookbook_versions).ordered
+        worker.should_receive(:run_chef).ordered
+
+        run
+      end
+    end
+
+    context "when no nodes exist in the environment" do
+      before do
+        options[:cookbook_versions] = cookbook_versions
+        options[:component_versions] = component_versions
+
+        worker.stub nodes: []
+      end
+
+      it "updates the versions and does not run chef" do
+        worker.should_receive(:set_component_versions).ordered
+        worker.should_receive(:set_cookbook_versions).ordered
+
+        worker.should_not_receive :run_chef
+
+        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
+        worker.should_receive(:set_environment_attributes_from_file).with(environment_name, filepath).ordered
+
+        run
+      end
+
+      context "when the environment attributes file is invalid" do
+        it "sets the job to failed" do
+          worker.should_receive(:set_environment_attributes_from_file).and_raise(MB::InvalidAttributesFile)
+          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
+        worker.should_not_receive(:set_environment_attributes_file)
+
+        run
+      end
+    end
+
+    context "when environment_attributes is passed as an option" do
+      let(:env_attributes) do
+        {
+          "foo" => "bar",
+          "baz.quux" => 42
+        }
+      end
+
+      before do
+        options[:environment_attributes] = env_attributes
+      end
+
+      it "sets environment attributes on the environment" do
+        worker.should_receive(:set_environment_attributes).with(environment_name, env_attributes).ordered
+
+        run
+      end
+    end
+
+    context "when environment_attributes is not passed as an option" do
+      before do
+        options[:environment_attributes] = nil
+      end
+
+      it "does not set the environment attributes on the environment" do
+        worker.should_not_receive(:set_environment_attributes)
+
+        run
+      end
+    end
+  end
+
+  describe "#nodes" do
+    pending "This should not be the responsibility of MB::Upgrade"
+  end
+
+  describe "#run_chef" do
+    subject(:run_chef) { worker.send :run_chef }
+
+    let(:nodes) { %w[node1 node2 node3] }
+
+    before do
+      worker.unstub :run_chef
+
+      worker.stub nodes: nodes
+    end
+
+    it "runs chef on the nodes" do
+      nodes.each do |node|
+        MB::Application.node_querier.should_receive(:chef_run).with(node)
+      end
+
+      run_chef
+    end
+  end
+end