beaker 3.13.0 → 3.14.0

data/spec/beaker/logger_spec.rb

@@ -5,6 +5,7 @@ module Beaker
   describe Logger do
     let(:my_io)     { StringIO.new                         }
     let(:logger)    { Logger.new(my_io, :quiet => true)  }
+    let(:basic_logger)    { Logger.new(:quiet => true)  }
     let(:test_dir)  { 'tmp/tests' }
     let(:dummy_prefix)  { 'dummy' }
 
@@ -424,5 +425,6 @@ module Beaker
       end
 
     end
+
   end
 end

data/spec/beaker/options/parser_spec.rb

@@ -146,6 +146,7 @@ module Beaker
                               :user_known_hosts_file => 'hosts123'
                             }                                
           } }
+          let(:subcommand_file) {@subcommand_file || {:level => 'fifth'}}
           let(:presets) { {:level => 'lowest',
                             :ssh => {
                               :config => 'config123',
@@ -173,10 +174,12 @@ module Beaker
 
             allow(OptionsFileParser).to receive(:parse_options_file).and_return(opt_file)
             allow(parser).to receive(:parse_hosts_options).and_return(host_file)
+
+            allow(SubcommandOptionsParser).to receive(:parse_subcommand_options).and_return(subcommand_file)
           end
 
           it 'presets have the lowest priority' do
-            @env = @argv = @host_file = @opt_file = {}
+            @env = @argv = @host_file = @opt_file = @subcommand_file = {}
             mock_out_parsing
 
             opts = parser.parse_args([])
@@ -185,6 +188,16 @@ module Beaker
             expect(attribution[:level]).to be == 'preset'
           end
 
+          it 'subcommand_options should have fifth priority' do
+            @env = @argv = @host_file = @opt_file = {}
+            mock_out_parsing
+
+            opts = parser.parse_args([])
+            attribution = parser.attribution
+            expect(opts[:level]).to be == 'fifth'
+            expect(attribution[:level]).to be == 'subcommand'
+          end
+
           it 'options file has fourth priority' do
             @env = @argv = @host_file = {}
             mock_out_parsing

data/spec/beaker/options/subcommand_options_parser_spec.rb

@@ -0,0 +1,33 @@
+require 'spec_helper'
+
+module Beaker
+  module Options
+    describe '#parse_subcommand_options' do
+      let( :parser ) {Beaker::Options::SubcommandOptionsParser.parse_subcommand_options(argv)}
+      let( :argv ) {[]}
+
+      it 'returns an empty OptionsHash if not executing a subcommand' do
+        expect(parser).to be_kind_of(OptionsHash)
+        expect(parser).to be_empty
+      end
+
+      describe 'when the subcommand is init' do
+        let( :argv ) {['init']}
+        it 'returns an empty OptionsHash' do
+          expect(parser).to be_kind_of(OptionsHash)
+          expect(parser).to be_empty
+        end
+      end
+
+      describe 'when the subcommand is not init' do
+        let( :argv ) {['provision']}
+        it 'checks for file existence and loads the YAML file' do
+          expect(Beaker::Subcommands::SubcommandUtil::SUBCOMMAND_OPTIONS).to receive(:exist?).and_return(true)
+          allow(YAML).to receive(:load_file).and_return({})
+          expect(parser).to be_kind_of(Hash)
+          expect(parser).not_to be_kind_of(OptionsHash)
+        end
+      end
+    end
+  end
+end

data/spec/beaker/subcommand/subcommand_util_spec.rb

@@ -24,15 +24,37 @@ module Beaker
         double("host")
       }
 
-      describe 'reset_argv' do
-        it "resets argv" do
-          args = ["test1", "test2"]
-          expect(ARGV).to receive(:clear).exactly(1).times
-          subject.reset_argv(args)
-          expect(ARGV[0]).to eq(args[0])
-          expect(ARGV[1]).to eq(args[1])
-        end
-      end
+      let(:hypervisors) {
+        double("hypervisors")
+      }
+
+      let(:hosts) {
+        double("hosts")
+      }
+
+      let(:hypervisors_object) {
+        double("hypervisors_object")
+      }
+
+      let(:hosts_object) {
+        double("hosts_object")
+      }
+
+      let(:network_manager){
+        double("network_manager")
+      }
+
+      let(:save_object){
+        double("save_object")
+      }
+
+      let(:load_object){
+        double("load_object")
+      }
+
+      let(:yaml_object){
+        double("yaml_object")
+      }
 
       describe 'execute_subcommand' do
         it "determines if we should execute the init subcommand" do
@@ -52,15 +74,6 @@ module Beaker
         end
       end
 
-      describe 'execute_beaker' do
-        it "executes beaker with arguments" do
-          allow(cli).to receive(:execute!).and_return(true)
-          allow(Beaker::CLI).to receive(:new).and_return(cli)
-          expect(subject).to receive(:reset_argv).exactly(1).times
-          expect(cli).to receive(:execute!).exactly(1).times
-          subject.execute_beaker(['args'])
-        end
-      end
 
       describe 'error_with' do
         it "the exit value should default to 1" do
@@ -91,192 +104,6 @@ module Beaker
         end
       end
 
-      describe 'init_vmpooler' do
-        it "executes the vmpooler quick task" do
-          expect(subject).to receive(:execute_rake_task).with("beaker_quickstart:gen_hosts[vmpooler]").exactly(1).times
-          subject.init_vmpooler
-        end
-      end
-
-      describe 'init_vagrant' do
-        it "executes the vmpooler quick task" do
-          expect(subject).to receive(:execute_rake_task).with("beaker_quickstart:gen_hosts[vagrant]").exactly(1).times
-          subject.init_vagrant
-        end
-      end
-
-      describe 'init_hypervisor' do
-        it "calls init_vagrant" do
-          expect(subject).to receive(:init_vagrant).with(no_args).exactly(1).times
-          expect(subject).to receive(:init_vmpooler).with(no_args).exactly(0).times
-          subject.init_hypervisor('vagrant')
-        end
-
-        it "calls init_vmpooler" do
-          expect(subject).to receive(:init_vagrant).with(no_args).exactly(0).times
-          expect(subject).to receive(:init_vmpooler).with(no_args).exactly(1).times
-          subject.init_hypervisor('vmpooler')
-        end
-
-        it "fails to call init for a hypervisor" do
-          expect(subject).to receive(:init_vagrant).with(no_args).exactly(0).times
-          expect(subject).to receive(:init_vmpooler).with(no_args).exactly(0).times
-          subject.init_hypervisor('invalid')
-        end
-      end
-
-      describe 'execute_rake_task' do
-
-        it "executes the rake task" do
-          allow(Rake).to receive(:application).and_return(rake)
-          expect(ARGV).to receive(:clear).exactly(1).times
-          expect(rake).to receive(:init).and_return(true).exactly(1).times
-          expect(rake).to receive(:load_rakefile).and_return(true).exactly(1).times
-          expect(rake).to receive(:invoke_task).with("mytask").exactly(1).times
-          subject.execute_rake_task("mytask")
-        end
-      end
-
-      describe "determine_rake_file" do
-
-        it "uses Rakefile if no rakefile exists" do
-          allow(subject).to receive(:rake_app).and_return(rake)
-          allow(rake).to receive(:find_rakefile_location).and_return(nil)
-          expect subject.determine_rake_file == "Rakefile"
-        end
-
-        it "uses Rakefile if Rakefile exists" do
-          allow(subject).to receive(:rake_app).and_return(rake)
-          allow(rake).to receive(:find_rakefile_location).and_return("Rakefile")
-          expect subject.determine_rake_file == "Rakefile"
-        end
-
-        it "uses rakefile if rakefile exists" do
-          allow(subject).to receive(:rake_app).and_return(rake)
-          allow(rake).to receive(:find_rakefile_location).and_return("rakefile")
-          expect subject.determine_rake_file == "rakefile"
-        end
-
-        it "uses Rakefile.rb if Rakefile.rb exists" do
-          allow(subject).to receive(:rake_app).and_return(rake)
-          allow(rake).to receive(:find_rakefile_location).and_return("Rakefile.rb")
-          expect subject.determine_rake_file == "Rakefile.rb"
-        end
-
-        it "uses rakefile.rb if rakefile.rb exists" do
-          allow(subject).to receive(:rake_app).and_return(rake)
-          allow(rake).to receive(:find_rakefile_location).and_return("rakefile.rb")
-          expect subject.determine_rake_file == "rakefile.rb"
-        end
-      end
-
-      describe "require_tasks" do
-        it "appends the require if it isn't contained in the Rakefile" do
-          allow(subject).to receive(:determine_rake_file).and_return("Rakefile")
-          allow(File).to receive(:readlines).with("Rakefile").and_return([""])
-          allow(File).to receive(:open).with("Rakefile", "a+").and_yield(file)
-          allow(File).to receive(:puts).with("require 'beaker/tasks/quick_start'").and_return(true)
-          expect(FileUtils).to receive(:touch).with("Rakefile").exactly(1).times
-          expect(File).to receive(:open).with("Rakefile", "a+").and_yield(file).exactly(1).times
-          expect(file).to receive(:puts).with("require 'beaker/tasks/quick_start'").exactly(1).times
-          subject.require_tasks
-        end
-
-        it "does't append the require if it is contained in the Rakefile" do
-          allow(subject).to receive(:determine_rake_file).and_return("Rakefile")
-          allow(File).to receive(:readlines).with("Rakefile").and_return(["require 'beaker/tasks/quick_start'"])
-          allow(File).to receive(:open).with("Rakefile", "a+").and_yield(file)
-          allow(File).to receive(:puts).with("require 'beaker/tasks/quick_start'").and_return(true)
-          expect(FileUtils).to receive(:touch).with("Rakefile").exactly(1).times
-          expect(File).to receive(:open).with("Rakefile", "a+").and_yield(file).exactly(0).times
-          expect(file).to receive(:puts).with("require 'beaker/tasks/quick_start'").exactly(0).times
-          subject.require_tasks
-        end
-      end
-
-      describe "init_config" do
-        it "creates a .beaker folder and loads the config" do
-          expect(FileUtils).to receive(:mkdir_p).with(".beaker").exactly(1).times
-          expect(YAML::Store).to receive(:new).with(".beaker/config").exactly(1).times
-          subject.init_config
-        end
-      end
-
-      describe "store_config" do
-        before(:each) { SubcommandUtil.class_variable_set :@@store, store} 
-
-        it "stores some values in the YAML store" do
-          options = { :hypervisor => "vmpooler", :test => "abc", :provisioned => true}
-          allow(store).to receive(:transaction).and_yield
-          expect(store).to receive(:[]=).with(:hypervisor, "vmpooler").exactly(1).times
-          expect(store).to receive(:[]=).with(:test, "abc").exactly(0).times
-          expect(store).to receive(:[]=).with(:provisioned, true).exactly(1).times
-          subject.store_config(options)
-        end
-
-        it "stores all values in the YAML store" do
-          options = { :hypervisor => "vmpooler", :provisioned => true}
-          allow(store).to receive(:transaction).and_yield
-          expect(store).to receive(:[]=).with(:hypervisor, "vmpooler").exactly(1).times
-          expect(store).to receive(:[]=).with(:provisioned, true).exactly(1).times
-          subject.store_config(options)
-        end
-
-        it "stores no values in the YAML store" do
-          options = {:test => "abc"}
-          allow(store).to receive(:transaction).and_yield
-          expect(store).to receive(:[]=).with(:hypervisor, anything).exactly(0).times
-          expect(store).to receive(:[]=).with(:provisioned, anything).exactly(0).times
-          subject.store_config(options)
-        end
-      end
-
-      describe "delete_config" do
-        before(:each) { SubcommandUtil.class_variable_set :@@store, store} 
-        it "deletes keys from the YAML store" do
-          keys = [ :hypervisor, :test, :provisioned ]
-          allow(store).to receive(:transaction).and_yield
-          expect(store).to receive(:delete).with(:hypervisor).exactly(1).times
-          expect(store).to receive(:delete).with(:test).exactly(1).times
-          expect(store).to receive(:delete).with(:provisioned).exactly(1).times
-          subject.delete_config(keys)
-        end
-      end
-
-      describe "provision" do
-        it "provisions, validates, and configures with vmpooler" do
-          options = {:validate => true, :configure => true}
-          expect(cli).to receive(:provision).and_return(true)
-          expect(cli).to receive(:preserve_hosts_file).exactly(1).times
-          allow(Beaker::CLI).to receive(:new).and_return(cli)
-          allow(cli).to receive(:parse_options).and_return(cli)
-          hypervisor = "vmpooler"
-          expect(subject).to receive(:reset_argv).with(["--hosts",".beaker/acceptance/config/default_#{hypervisor}_hosts.yaml", "--validate", true, "--configure", true]).exactly(1).times
-          subject.provision(hypervisor, options)
-        end
-
-        it "provisions and validates with vmpooler" do
-          options = {:validate => true, :configure => false }
-          expect(cli).to receive(:provision).and_return(true)
-          expect(cli).to receive(:preserve_hosts_file).exactly(1).times
-          allow(Beaker::CLI).to receive(:new).and_return(cli)
-          allow(cli).to receive(:parse_options).and_return(cli)
-          hypervisor = "vmpooler"
-          expect(subject).to receive(:reset_argv).with(["--hosts",".beaker/acceptance/config/default_#{hypervisor}_hosts.yaml", "--validate", true, "--configure", false]).exactly(1).times
-          subject.provision(hypervisor, options)
-        end
-
-        it "only provisions with vmpooler" do
-          options = {:validate => false, :configure => false }
-          expect(cli).to receive(:provision).and_return(true)
-          expect(cli).to receive(:preserve_hosts_file).exactly(1).times
-          allow(Beaker::CLI).to receive(:new).and_return(cli)
-          allow(cli).to receive(:parse_options).and_return(cli)
-          hypervisor = "vmpooler"
-          expect(subject).to receive(:reset_argv).with(["--hosts",".beaker/acceptance/config/default_#{hypervisor}_hosts.yaml", "--validate", false, "--configure", false]).exactly(1).times
-          subject.provision(hypervisor, options)
-        end
-      end
     end
   end
 end

data/spec/beaker/subcommand_spec.rb

@@ -0,0 +1,146 @@
+require 'spec_helper'
+
+module Beaker
+  SubcommandUtil = Beaker::Subcommands::SubcommandUtil
+  describe Subcommand do
+    let( :subcommand ) {
+      Beaker::Subcommand.new
+    }
+
+    context '#initialize' do
+      it 'creates a cli object' do
+        expect(Beaker::CLI).to receive(:new).once
+        subcommand
+      end
+      describe 'File operation initialization for subcommands' do
+        it 'checks to ensure subcommand file resources exist' do
+          expect(FileUtils).to receive(:mkdir_p).with(SubcommandUtil::CONFIG_DIR)
+          expect(SubcommandUtil::SUBCOMMAND_OPTIONS).to receive(:exist?).and_return(true)
+          expect(SubcommandUtil::SUBCOMMAND_STATE).to receive(:exist?).and_return(true)
+          subcommand
+        end
+
+        it 'touches the files when they do not exist' do
+          expect(FileUtils).to receive(:mkdir_p).with(SubcommandUtil::CONFIG_DIR)
+          allow(SubcommandUtil::SUBCOMMAND_OPTIONS).to receive(:exist?).and_return(false)
+          allow(SubcommandUtil::SUBCOMMAND_STATE).to receive(:exist?).and_return(false)
+          expect(FileUtils).to receive(:touch).with(SubcommandUtil::SUBCOMMAND_OPTIONS)
+          expect(FileUtils).to receive(:touch).with(SubcommandUtil::SUBCOMMAND_STATE)
+          subcommand
+        end
+
+      end
+    end
+
+    context '#init' do
+      let( :cli ) { subcommand.instance_variable_get(:@cli) }
+      let( :mock_options ) { {:timestamp => 'noon', :other_key => 'cordite'}}
+      let( :yaml_store_mock ) { double('yaml_store_mock') }
+      it 'calculates options and writes them to disk and deletes the' do
+        expect(cli).to receive(:parse_options)
+        allow(cli).to receive(:configured_options).and_return(mock_options)
+
+        allow(File).to receive(:open)
+        allow(YAML::Store).to receive(:new).with(SubcommandUtil::SUBCOMMAND_STATE).and_return(yaml_store_mock)
+        allow(yaml_store_mock).to receive(:transaction).and_yield
+        expect(yaml_store_mock).to receive(:[]=).with('provisioned', false)
+        subcommand.init
+        expect(mock_options).not_to have_key(:timestamp)
+      end
+    end
+
+    context '#provision' do
+      let ( :cli ) { subcommand.instance_variable_get(:@cli) }
+      let( :yaml_store_mock ) { double('yaml_store_mock') }
+      let ( :host_hash ) { {'mynode.net' => {:name => 'mynode', :platform => Beaker::Platform.new('centos-6-x86_64')}}}
+      let ( :cleaned_hosts ) {double()}
+      let ( :yielded_host_hash ) {double()}
+      let ( :yielded_host_name) {double()}
+      let ( :network_manager) {double('network_manager')}
+      let ( :hosts) {double('hosts')}
+      let ( :hypervisors) {double('hypervisors')}
+      let (:options) {double ('options')}
+      it 'provisions the host and saves the host info' do
+        expect(YAML::Store).to receive(:new).with(SubcommandUtil::SUBCOMMAND_STATE).and_return(yaml_store_mock)
+        allow(yaml_store_mock).to receive(:[]).and_return(false)
+        allow(cli).to receive(:preserve_hosts_file).and_return("/path/to/ho")
+        allow(cli).to receive(:network_manager).and_return(network_manager)
+        allow(cli).to receive(:options).and_return(options)
+        allow(options).to receive(:[]).with(:hosts_preserved_yaml_file).and_return("/path/to/hosts")
+        allow(network_manager).to receive(:hosts).and_return(hosts)
+        allow(network_manager).to receive(:hypervisors).and_return(hypervisors)
+        expect(cli).to receive(:parse_options).and_return(cli)
+        expect(cli).to receive(:provision)
+        expect(cli).to receive(:combined_instance_and_options_hosts).and_return(host_hash)
+        expect(SubcommandUtil).to receive(:sanitize_options_for_save).and_return(cleaned_hosts)
+        expect(cleaned_hosts).to receive(:each).and_yield(yielded_host_name, yielded_host_hash)
+        expect(yielded_host_hash).to receive(:[]=).with('provision', false)
+        expect(YAML::Store).to receive(:new).with(SubcommandUtil::SUBCOMMAND_OPTIONS).and_return(yaml_store_mock)
+
+        expect(yaml_store_mock).to receive(:transaction).and_yield.exactly(3).times
+        expect(yaml_store_mock).to receive(:[]=).with('HOSTS', cleaned_hosts)
+        expect(yaml_store_mock).to receive(:[]=).with('hosts_preserved_yaml_file', "/path/to/hosts")
+
+        expect(yaml_store_mock).to receive(:[]=).with('provisioned', true)
+        subcommand.provision
+      end
+    end
+
+
+    context 'exec' do
+      it 'calls execute! when no resource is given' do
+        expect_any_instance_of(Pathname).to_not receive(:directory?)
+        expect_any_instance_of(Pathname).to_not receive(:exist?)
+        expect_any_instance_of(Beaker::CLI).to receive(:parse_options).once
+        expect_any_instance_of(Beaker::CLI).to receive(:initialize_network_manager).once
+        expect_any_instance_of(Beaker::CLI).to receive(:execute!).once
+        expect{subcommand.exec}.to_not raise_error
+      end
+
+      it 'checks to to see if the resource is a file_resource' do
+
+        expect_any_instance_of(Pathname).to receive(:exist?).and_return(true)
+        expect_any_instance_of(Pathname).to receive(:directory?).and_return(false)
+        expect_any_instance_of(Pathname).to receive(:expand_path).once
+        expect_any_instance_of(Beaker::CLI).to receive(:execute!).once
+        expect{subcommand.exec('resource')}.to_not raise_error
+      end
+
+      it 'checks to see if the resource is a directory' do
+        expect_any_instance_of(Pathname).to receive(:exist?).and_return(true)
+        expect_any_instance_of(Pathname).to receive(:directory?).and_return(true)
+        expect(Dir).to receive(:glob)
+        expect_any_instance_of(Pathname).to receive(:expand_path).once
+        expect_any_instance_of(Beaker::CLI).to receive(:execute!).once
+        expect{subcommand.exec('resource')}.to_not raise_error
+      end
+
+      it 'allows a hard coded suite name to be specified' do
+
+        allow_any_instance_of(Pathname).to receive(:exist?).and_return(false)
+        expect_any_instance_of(Beaker::CLI).to receive(:execute!).once
+        expect{subcommand.exec('tests')}.to_not raise_error
+      end
+
+      it 'errors when a resource is neither a valid file resource or suite name' do
+        allow_any_instance_of(Pathname).to receive(:exist?).and_return(false)
+        expect{subcommand.exec('blahblahblah')}.to raise_error(ArgumentError)
+      end
+    end
+
+    context 'destroy' do
+      let( :cli ) { subcommand.instance_variable_get(:@cli) }
+      let( :mock_options ) { {:timestamp => 'noon', :other_key => 'cordite'}}
+      let( :yaml_store_mock ) { double('yaml_store_mock') }
+      it 'calls destroy and updates the yaml store' do
+        expect(YAML::Store).to receive(:new).with(SubcommandUtil::SUBCOMMAND_STATE).and_return(yaml_store_mock)
+        allow(SubcommandUtil).to receive(:cleanup).with(cli).and_return(true)
+        allow(yaml_store_mock).to receive(:transaction).and_yield
+        allow(yaml_store_mock).to receive(:[]).with('provisioned').and_return(true)
+        allow(yaml_store_mock).to receive(:delete).with('provisioned').and_return(true)
+        expect(SubcommandUtil).to receive(:error_with).with("Please provision an environment").exactly(0).times
+        subcommand.destroy
+      end
+    end
+  end
+end