motherbrain 0.0.0.placeholder → 0.13.1

data/spec/unit/mb/cli_gateway_spec.rb

@@ -0,0 +1,386 @@
+require 'spec_helper'
+
+describe MB::CliGateway do
+  let(:ui) { described_class.ui }
+
+  before do
+    ui.stub :error
+    ui.stub :info
+    ui.stub :say
+  end
+
+  describe "ClassMethods" do
+    subject { described_class }
+
+    describe "::new" do
+      describe "specifying a configuration file" do
+        let(:location) { tmp_path.join('config.json').to_s }
+
+        before(:each) do
+          generate_valid_config(location)
+        end
+
+        it "loads the specified config file into the ConfigManager" do
+          config = MB::Config.from_file(location)
+          invoker = subject.new([], config: location)
+
+          MB::ConfigManager.instance.config._attributes_.should eql(config._attributes_)
+        end
+
+        it "exits with a ConfigNotFound error when the specified path does not exist" do
+          lambda {
+            invoker = subject.new([], config: tmp_path.join("not_there.json"))
+          }.should exit_with(MB::ConfigNotFound)
+        end
+
+        it "exits with a ConfigNotFound error when the specified path is a directory" do
+          lambda {
+            invoker = subject.new([], config: tmp_path)
+          }.should exit_with(MB::ConfigNotFound)
+        end
+      end
+    end
+
+    describe "::requires_environment?" do
+      context "no arguments" do
+        it "should not require an environment" do
+          subject.requires_environment?([]).should be_false
+        end
+      end
+
+      context "base command" do
+        it "should not require an environment for versions" do
+          subject.requires_environment?(["versions"]).should be_false
+        end
+      end
+
+      context "plugin argument" do
+        it "should not require an environment for a plugin" do
+          subject.requires_environment?(["myface"]).should be_false
+        end
+      end
+
+      context "plugin command" do
+        it "should require an environment for bootstrap" do
+          subject.requires_environment?(["myface", "bootstrap"]).should be_true
+        end
+
+        it "should not require an environment for help" do
+          subject.requires_environment?(["myface", "help"]).should be_false
+        end
+
+        it "should not require an environment for subtask help" do
+          subject.requires_environment?(["myface", "help", "bootstrap"]).should be_false
+        end
+      end
+    end
+
+    describe "::start_mb_application?" do
+      let(:args) {["myface"]}
+
+      context "not a config task" do
+        it "should be true" do
+          subject.start_mb_application?(args).should be_true
+        end
+      end
+
+      context "is a config task" do
+        it "should be false" do
+          subject::SKIP_CONFIG_TASKS.each do |config_task|
+            args = [config_task]
+            subject.start_mb_application?(args)
+          end
+        end
+      end
+    end
+
+    describe "::register_plugin" do
+      let(:name) { "myface" }
+      let(:description) { "Ivey should use SublimeText 2" }
+      let(:plugin) { MB::Plugin.new(metadata) }
+      let(:metadata) do
+        double('metadata',
+          name: name,
+          description: description
+        )
+      end
+
+      it "registers a subcommand with self" do
+        subcommand = double
+        MB::Cli::SubCommand.should_receive(:new).with(plugin).and_return(subcommand)
+        subject.should_receive(:register_subcommand).with(subcommand)
+
+        subject.register_plugin(plugin)
+      end
+
+      it "returns a subcommand with the plugin set as #plugin" do
+        subject.register_plugin(plugin).plugin.should eql(plugin)
+      end
+
+      it "has a name matching the plugin" do
+        subject.register_plugin(plugin).name.should eql(name)
+      end
+
+      it "has a description matching the plugin" do
+        subject.register_plugin(plugin).description.should eql(description)
+      end
+    end
+
+    describe "::find_plugin" do
+      let(:plugin_manager) { double('plugin_manager') }
+      let(:name) { "myface" }
+      let(:options) do
+        {
+          plugin_version: nil,
+          environment: nil
+        }
+      end
+      let(:plugin) { double('asdf') }
+
+      subject { described_class.find_plugin(name, options) }
+
+      before do
+        described_class.stub(plugin_manager: plugin_manager)
+        described_class.stub(local_plugin?: false)
+      end
+
+      context "given no value for :plugin_version or :environment" do
+        before do
+          options[:plugin_version] = nil
+          options[:environment] = nil
+        end
+
+        it "finds the installed or remote latest version of the plugin with the given name" do
+          plugin_manager.should_receive(:latest).with(name, remote: true).and_return(plugin)
+
+          subject.should eql(plugin)
+        end
+
+        it "prints an error to the UI and exits if no plugin is found" do
+          plugin_manager.should_receive(:latest).with(name, remote: true).and_return(nil)
+          ui.should_receive(:error).with(anything)
+
+          expect {
+            subject
+          }.to raise_error(SystemExit)
+        end
+      end
+
+      context "given a value for :plugin_version" do
+        let(:plugin_version) { "1.2.3" }
+        before { options[:plugin_version] = plugin_version }
+
+        it "finds a plugin on local and remote of the given name and version" do
+          plugin_manager.should_receive(:find).with(name, plugin_version, remote: true).and_return(plugin)
+
+          subject.should eql(plugin)
+        end
+
+        it "prints an error to the UI and exits if no plugin is found" do
+          plugin_manager.should_receive(:find).with(name, plugin_version, remote: true).and_return(nil)
+          ui.should_receive(:error).with(anything)
+
+          expect {
+            subject
+          }.to raise_error(SystemExit)
+        end
+      end
+
+      context "given a value for :environment" do
+        let(:environment) { "rspec-test" }
+        before { options[:environment] = environment }
+
+        it "finds the best suitable plugin for the environment" do
+          plugin_manager.should_receive(:for_environment).with(name, environment, remote: true).and_return(plugin)
+
+          subject.should eql(plugin)
+        end
+
+        context "when an environment of the given name is not found" do
+          before do
+            plugin_manager.should_receive(:for_environment).and_raise(MB::EnvironmentNotFound.new(environment))
+          end
+
+          it "finds the latest plugin on local and remote of the given name" do
+            plugin_manager.should_receive(:latest).with(name, remote: true).and_return(plugin)
+
+            subject.should eql(plugin)
+          end
+
+          it "prints an error to the UI and exits if no plugin is found" do
+            plugin_manager.should_receive(:latest).with(name, remote: true).and_return(nil)
+
+            expect {
+              subject
+            }.to raise_error(SystemExit)
+          end
+        end
+      end
+
+      context "given both a plugin version and environment" do
+        let(:environment) { "rspec-test" }
+        let(:plugin_version) { "1.2.3" }
+
+        before do
+          options[:environment] = environment
+          options[:plugin_version] = plugin_version
+        end
+
+        it "finds a plugin on local and remote of the given name and version" do
+          plugin_manager.should_receive(:find).with(name, plugin_version, remote: true).and_return(plugin)
+
+          subject.should eql(plugin)
+        end
+      end
+
+      context "given a local plugin" do
+        before { described_class.stub(local_plugin?: true) }
+
+        it "should prefer the local plugin if no version was specified" do
+          plugin_manager.should_receive(:load_installed).and_return(plugin)
+
+          subject.should eql(plugin)
+        end
+
+        it "should use the version specified version of the plugin if a version is specified" do
+          options[:plugin_version] = '1.2.3'
+          plugin_manager.should_not_receive(:load_installed)
+          plugin_manager.should_receive(:find).with('myface', '1.2.3', remote: true).and_return(plugin)
+
+          subject.should eql(plugin)
+        end
+
+        it "should use the local version if the environment is specified" do
+          options[:environment] = "abc"
+          plugin_manager.should_receive(:load_installed).and_return(plugin)
+
+          subject.should eql(plugin)
+        end
+      end
+    end
+  end
+
+  describe "#validate_environment" do
+    subject(:validate_environment) { cli_gateway.send(:validate_environment) }
+    let(:cli_gateway) { described_class.new(args, options, config) }
+
+    let(:args) { Array.new }
+    let(:config) { { current_command: double('Config', name: "help") } }
+    let(:environment_name) { "my_env" }
+    let(:options) { { environment: environment_name } }
+    let(:environment_manager) { MB::EnvironmentManager.instance.wrapped_object }
+
+    before do
+      cli_gateway.stub :ask
+      cli_gateway.stub testing?: false
+      cli_gateway.stub(environment_manager: environment_manager)
+
+      environment_manager.stub(:find).and_return(Hash.new)
+    end
+
+    it "doesn't ask the user" do
+      cli_gateway.should_not_receive(:ask)
+
+      validate_environment
+    end
+
+    context "without an environment" do
+      let(:options) { Hash.new }
+
+      it "doesn't ask the user" do
+        cli_gateway.should_not_receive(:ask)
+
+        validate_environment
+      end
+    end
+
+    context "if the environment does not exist" do
+      before do
+        environment_manager.stub(:find).and_raise(
+          MB::EnvironmentNotFound.new("nope")
+        )
+      end
+
+      it "doesn't ask the user and raises an error" do
+        cli_gateway.should_not_receive(:ask)
+
+        -> { validate_environment }.should raise_error(MB::EnvironmentNotFound)
+      end
+    end
+
+    context "if the environment does not exist and given a create task" do
+      let(:args) { ["bootstrap"] }
+
+      before do
+        environment_manager.stub(:find).and_raise(
+          MB::EnvironmentNotFound.new("nope")
+        )
+      end
+
+      context "and it should 'quit' on missing environments" do
+        let(:options) { { environment: environment_name, on_environment_missing: "quit" } }
+
+        it "should quit without asking" do
+          cli_gateway.should_not_receive(:ask)
+          cli_gateway.should_receive(:abort)
+
+          validate_environment
+        end
+      end
+
+      context "and it should 'create' on missing environments" do
+        let(:options) { { environment: environment_name, on_environment_missing: "create" } }
+
+        it "should create the environment without asking" do
+          cli_gateway.should_not_receive(:ask)
+          cli_gateway.should_receive(:create_environment).with(environment_name)
+
+          validate_environment
+        end
+
+      end
+
+
+      context "and it should 'prompt' on missing environments" do
+
+        let(:options) { { environment: environment_name, on_environment_missing: "prompt" } }
+
+        context "if the user responds yes" do
+          before do
+            cli_gateway.stub ask: "y"
+          end
+
+          it "creates an environment" do
+            cli_gateway.should_receive(:create_environment).with(environment_name)
+
+            validate_environment
+          end
+        end
+
+        context "if the user responds no" do
+          before do
+            cli_gateway.stub ask: "n"
+          end
+
+          it "doesn't create an environment" do
+            environment_manager.should_not_receive(:create).with(environment_name)
+
+            validate_environment
+          end
+        end
+
+        context "if the user responds quit" do
+          before do
+            cli_gateway.stub ask: "q"
+          end
+
+          it "exits the cli" do
+            cli_gateway.should_receive(:abort)
+
+            validate_environment
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,43 @@
+require 'spec_helper'
+
+describe MB::CommandInvoker::Worker do
+  let(:component) { double('component', name: 'chat') }
+  let(:command) { double('command', name: 'stop', type: :component, scope: component) }
+  let(:environment) { "rspec-env" }
+
+  subject { described_class.new(command, environment) }
+
+  describe "#run" do
+    let(:job) { double('job') }
+    let(:arguments) { Array.new }
+
+    before do
+      job.stub(set_status: nil)
+      command.stub(invoke: nil)
+    end
+
+    let(:run) { subject.run(job, arguments) }
+
+    it "sets a status message" do
+      job.should_receive(:set_status)
+
+      run
+    end
+
+    it "invokes the command" do
+      command.should_receive(:invoke).with(job, environment, nil)
+
+      run
+    end
+
+    context "when given additional arguments" do
+      let(:arguments) { [1,2,3] }
+
+      it "invokes the command with the additional arguments" do
+        command.should_receive(:invoke).with(job, environment, nil, *arguments)
+
+        run
+      end
+    end
+  end
+end

data/spec/unit/mb/command_invoker_spec.rb

@@ -0,0 +1,230 @@
+require 'spec_helper'
+
+describe MB::CommandInvoker do
+  let(:plugin_id) { "rspec-test" }
+  let(:command_id) { "start" }
+  let(:component_id) { "default" }
+  let(:environment) { "rspec-testenv" }
+
+  let(:options) do
+    {
+      version: "1.0.0"
+    }
+  end
+
+  subject { described_class.new }
+
+  describe "#async_invoke" do
+    let(:job_ticket) { double(MB::JobRecord) }
+    let(:job) { double(MB::Job, ticket: job_ticket) }
+    let(:command_name) { "stop" }
+    let(:options) { Hash.new }
+
+    before do
+      MB::Job.stub(:new).and_return(job)
+    end
+
+    it "asynchronously calls {#invoke}" do
+      subject.should_receive(:async).with(:invoke, job, command_name, options)
+
+      subject.async_invoke(command_name, options)
+    end
+
+    it "returns a JobRecord" do
+      subject.stub(:async).with(:invoke, job, command_name, options)
+
+      subject.async_invoke(command_name, options).should eql(job_ticket)
+    end
+  end
+
+  describe "#find" do
+    let(:command) { "stop" }
+    let(:plugin) { "test-plugin" }
+    let(:options) do
+      {
+        version: nil,
+        component: nil,
+        environment: nil
+      }
+    end
+
+    let(:run) { subject.find(command, plugin, options) }
+
+    it "delegates to #find_latest" do
+      subject.should_receive(:find_latest).with(command, plugin, options[:component])
+      run
+    end
+
+    context "when given a value for :version" do
+      before do
+        options[:version] = "1.2.3"
+      end
+
+      it "delegates to #for_version" do
+        subject.should_receive(:for_version).with(options[:version], command, plugin, options[:component])
+        run
+      end
+    end
+
+    context "when given a value for :environment" do
+      before do
+        options[:environment] = "test-env"
+      end
+
+      it "delegates to #for_environment" do
+        subject.should_receive(:for_environment).with(options[:environment], command, plugin, options[:component])
+        run
+      end
+    end
+  end
+
+  describe "#invoke" do
+    let(:command_name) { "stop" }
+    let(:command) { double(invoke: nil) }
+    let(:plugin) { "chat" }
+    let(:component) { "default" }
+    let(:environment) { "rspec-test" }
+    let(:version) { "1.2.3" }
+    let(:job) { double(MB::Job, alive?: true, set_status: nil, terminate: nil) }
+    let(:worker) { double('worker', alive?: true, terminate: nil) }
+    let(:environment_manager) { double('env-man') }
+    let(:options) do
+      {
+        plugin: plugin,
+        component: component,
+        environment: environment,
+        version: version,
+        arguments: Array.new
+      }
+    end
+
+    let(:run) { subject.invoke(job, command_name, options) }
+
+    before(:each) do
+      MB::CommandInvoker::Worker.stub(:new).and_return(worker)
+      subject.stub(find: command, environment_manager: environment_manager, plugin_manager: plugin_manager)
+      job.stub(set_status: nil, report_running: nil, report_failure: nil, report_success: nil)
+      environment_manager.stub(find: nil)
+      worker.stub(run: nil)
+    end
+
+    it "wraps the invocation in a lock" do
+      MB::ChefMutex.any_instance.should_receive :synchronize
+
+      run
+    end
+
+    it "marks the job as running and then a success on success" do
+      job.should_receive(:report_running).ordered
+      job.should_receive(:report_success).ordered
+
+      run
+    end
+
+    it "terminates the running job on completion" do
+      job.should_receive(:terminate).once
+
+      run
+    end
+
+    it "creates a new worker to run the command in" do
+      MB::CommandInvoker::Worker.should_receive(:new).with(command, environment, nil).and_return(worker)
+
+      run
+    end
+
+    it "runs the worker with the job and given arguments" do
+      worker.should_receive(:run).with(job, options[:arguments])
+
+      run
+    end
+
+    it "shuts the worker down after completion" do
+      worker.should_receive(:terminate).once
+
+      run
+    end
+
+    context "when the plugin option is nil" do
+      before { options[:plugin] = nil }
+
+      it "sets the job to failure" do
+        job.should_receive(:report_failure)
+        run
+      end
+    end
+
+    context "when the environment option is nil" do
+      before { options[:environment] = nil }
+
+      it "sets the job to failure" do
+        job.should_receive(:report_failure)
+        run
+      end
+    end
+
+    context "when the target environment does not exist" do
+      let(:exception) { MB::EnvironmentNotFound.new(environment) }
+
+      before do
+        subject.should_receive(:find).
+          with(command_name, plugin, component: component, environment: environment, version: version).
+          and_raise(exception)
+      end
+
+      it "should set the job state to :failure" do
+        job.should_receive(:report_failure).with(exception)
+
+        run
+      end
+    end
+
+    context "when a plugin of the given name is not found" do
+      let(:exception) { MB::PluginNotFound.new(plugin) }
+
+      before do
+        subject.should_receive(:find).
+          with(command_name, plugin, component: component, environment: environment, version: version).
+          and_raise(exception)
+      end
+
+      it "sets the job to failure with a command not found message" do
+        job.should_receive(:report_failure).with(exception)
+
+        run
+      end
+    end
+
+    context "when a component of the given name is not found" do
+      let(:exception) { MB::ComponentNotFound.new(component, plugin) }
+
+      before do
+        subject.should_receive(:find).
+          with(command_name, plugin, component: component, environment: environment, version: version).
+          and_raise(exception)
+      end
+
+      it "sets the job to failure with a command not found message" do
+        job.should_receive(:report_failure).with(exception)
+
+        run
+      end
+    end
+
+    context "when a plugin command for the given plugin is not found" do
+      let(:exception) { MB::CommandNotFound.new(component, plugin) }
+
+      before do
+        subject.should_receive(:find).
+          with(command_name, plugin, component: component, environment: environment, version: version).
+          and_raise(exception)
+      end
+
+      it "completes the job as a failure with a command not found message" do
+        job.should_receive(:report_failure).with(exception)
+
+        run
+      end
+    end
+  end
+end