beaker 2.7.1 → 2.8.0

data/spec/beaker/dsl/{helpers_spec.rb → helpers/puppet_helpers_spec.rb}

@@ -25,288 +25,6 @@ describe ClassMixedWithDSLHelpers do
   let( :db )     { make_host( 'db',       :roles => %w( database agent )  ) }
   let( :hosts )  { [ master, agent, dash, db, custom ] }
 
-  describe '#on' do
-
-    before :each do
-      result.stdout = 'stdout'
-      result.stderr = 'stderr'
-      result.exit_code = 0
-    end
-
-    it 'allows the environment the command is run within to be specified' do
-      allow( subject ).to receive( :hosts ).and_return( hosts )
-
-      expect( Beaker::Command ).to receive( :new ).
-        with( 'ls ~/.bin', [], {'ENV' => { :HOME => '/tmp/test_home' }} )
-
-      subject.on( host, 'ls ~/.bin', :environment => {:HOME => '/tmp/test_home' } )
-    end
-
-    it 'if the host is a String Object, finds the matching hosts with that String as role' do
-      allow( subject ).to receive( :hosts ).and_return( hosts )
-
-      expect( master ).to receive( :exec ).once
-
-      subject.on( 'master', 'echo hello')
-
-    end
-
-    it 'if the host is a Symbol Object, finds the matching hsots with that Symbol as role' do
-      allow( subject ).to receive( :hosts ).and_return( hosts )
-
-      expect( master ).to receive( :exec ).once
-
-      subject.on( :master, 'echo hello')
-
-    end
-
-    it 'delegates to itself for each host passed' do
-      allow( subject ).to receive( :hosts ).and_return( hosts )
-      expected = []
-      hosts.each_with_index do |host, i|
-        expected << i
-        expect( host ).to receive( :exec ).and_return( i )
-      end
-
-      results = subject.on( hosts, command )
-      expect( results ).to be == expected
-    end
-
-    context 'upon command completion' do
-      before :each do
-        allow( subject ).to receive( :hosts ).and_return( hosts )
-        expect( host ).to receive( :exec ).and_return( result )
-        @res = subject.on( host, command )
-      end
-
-      it 'returns the result of the action' do
-        expect( @res ).to be == result
-      end
-
-      it 'provides access to stdout' do
-        expect( @res.stdout ).to be == 'stdout'
-      end
-
-      it 'provides access to stderr' do
-        expect( @res.stderr ).to be == 'stderr'
-      end
-
-      it 'provides access to exit_code' do
-        expect( @res.exit_code ).to be == 0
-      end
-    end
-
-    context 'when passed a block with arity of 1' do
-      before :each do
-        allow( subject ).to receive( :hosts ).and_return( hosts )
-        expect( host ).to receive( :exec ).and_return( result )
-      end
-
-      it 'yields result' do
-        subject.on host, command do |containing_class|
-          expect( containing_class ).
-            to be_an_instance_of( Beaker::Result )
-        end
-      end
-
-      it 'provides access to stdout' do
-        subject.on host, command do |containing_class|
-          expect( containing_class.stdout ).to be == 'stdout'
-        end
-      end
-
-      it 'provides access to stderr' do
-        subject.on host, command do |containing_class|
-          expect( containing_class.stderr ).to be == 'stderr'
-        end
-      end
-
-      it 'provides access to exit_code' do
-        subject.on host, command do |containing_class|
-          expect( containing_class.exit_code ).to be == 0
-        end
-      end
-    end
-
-    context 'when passed a block with arity of 0' do
-      before :each do
-        allow( subject ).to receive( :hosts ).and_return( hosts )
-        expect( host ).to receive( :exec ).and_return( result )
-      end
-
-      it 'yields self' do
-        subject.on host, command do
-          expect( subject ).
-            to be_an_instance_of( ClassMixedWithDSLHelpers )
-        end
-      end
-
-      it 'provides access to stdout' do
-        subject.on host, command do
-          expect( subject.stdout ).to be == 'stdout'
-        end
-      end
-
-      it 'provides access to stderr' do
-        subject.on host, command do
-          expect( subject.stderr ).to be == 'stderr'
-        end
-      end
-
-      it 'provides access to exit_code' do
-        subject.on host, command do
-          expect( subject.exit_code ).to be == 0
-        end
-      end
-    end
-
-  end
-
-  describe "#retry_on" do
-    it 'fails correctly when command never succeeds' do
-      result.stdout = 'stdout'
-      result.stderr = 'stderr'
-      result.exit_code = 1
-
-      retries = 5
-
-      opts = {
-        :max_retries    => retries,
-        :retry_interval => 0.0001,
-      }
-
-      allow( subject ).to receive(:on).and_return(result)
-      expect( subject ).to receive(:on).exactly(retries+2)
-      expect { subject.retry_on(host, command, opts) }.to raise_error(RuntimeError)
-    end
-
-    it 'will return success correctly if it succeeds the first time' do
-      result.stdout = 'stdout'
-      result.stderr = 'stderr'
-      result.exit_code = 0
-
-      opts = {
-        :max_retries    => 5,
-        :retry_interval => 0.0001,
-      }
-
-      allow( subject ).to receive(:on).and_return(result)
-      expect( subject ).to receive(:on).once
-
-      result_given = subject.retry_on(host, command, opts)
-      expect(result_given.exit_code).to be === 0
-    end
-
-    it 'will return success correctly if it succeeds after failing a few times' do
-      result.stdout = 'stdout'
-      result.stderr = 'stderr'
-
-      opts = {
-        :max_retries    => 10,
-        :retry_interval => 0.1,
-      }
-
-      reps_num = 4
-      count = 0
-      allow( subject ).to receive(:on) do
-        result.exit_code = count > reps_num ? 0 : 1
-        count += 1
-        result
-      end
-      expect( subject ).to receive(:on).exactly(reps_num + 2)
-
-      result_given = subject.retry_on(host, command, opts)
-      expect(result_given.exit_code).to be === 0
-    end
-  end
-
-  describe "shell" do
-    it 'delegates to #on with the default host' do
-      allow( subject ).to receive( :hosts ).and_return( hosts )
-
-      expect( subject ).to receive( :on ).with( master, "echo hello", {}).once
-
-      subject.shell( "echo hello" )
-    end
-  end
-
-  describe '#scp_from' do
-    it 'delegates to the host' do
-      allow( subject ).to receive( :hosts ).and_return( hosts )
-      expect( subject ).to receive( :logger ).exactly( hosts.length ).times
-      expect( result ).to receive( :log ).exactly( hosts.length ).times
-
-      hosts.each do |host|
-        expect( host ).to receive( :do_scp_from ).and_return( result )
-      end
-
-      subject.scp_from( hosts, '/var/log/my.log', 'log/my.log' )
-    end
-  end
-
-  describe '#scp_to' do
-    it 'delegates to the host' do
-      allow( subject ).to receive( :hosts ).and_return( hosts )
-      expect( subject ).to receive( :logger ).exactly( hosts.length ).times
-      expect( result ).to receive( :log ).exactly( hosts.length ).times
-
-      hosts.each do |host|
-        expect( host ).to receive( :do_scp_to ).and_return( result )
-      end
-
-      subject.scp_to( hosts, '/var/log/my.log', 'log/my.log' )
-    end
-  end
-
-  describe '#rsync_to' do
-    it 'delegates to the host' do
-      allow( subject ).to receive( :hosts ).and_return( hosts )
-
-      hosts.each do |host|
-        expect( host ).to receive( :do_rsync_to ).and_return( result )
-      end
-
-      subject.rsync_to( hosts, '/var/log/my.log', 'log/my.log' )
-    end
-  end
-
-  describe '#create_remote_file using scp' do
-    it 'scps the contents passed in to the hosts' do
-      my_opts = { :silent => true }
-      tmpfile = double
-
-      expect( tmpfile ).to receive( :path ).exactly( 2 ).times.
-        and_return( '/local/path/to/blah' )
-
-      expect( Tempfile ).to receive( :open ).and_yield( tmpfile )
-
-      expect( File ).to receive( :open )
-
-      expect( subject ).to receive( :scp_to ).
-        with( hosts, '/local/path/to/blah', '/remote/path', my_opts )
-
-      subject.create_remote_file( hosts, '/remote/path', 'blah', my_opts )
-    end
-  end
-
-  describe '#create_remote_file using rsync' do
-    it 'scps the contents passed in to the hosts' do
-      my_opts = { :silent => true, :protocol => 'rsync' }
-      tmpfile = double
-
-      expect( tmpfile ).to receive( :path ).exactly( 2 ).times.
-        and_return( '/local/path/to/blah' )
-
-      expect( Tempfile ).to receive( :open ).and_yield( tmpfile )
-
-      expect( File ).to receive( :open )
-
-      expect( subject ).to receive( :rsync_to ).
-        with( hosts, '/local/path/to/blah', '/remote/path', my_opts )
-
-      subject.create_remote_file( hosts, '/remote/path', 'blah', my_opts )
-    end
-  end
 
   describe '#create_tmpdir_for_user' do
     let(:host) { {} }
@@ -337,9 +55,7 @@ describe ClassMixedWithDSLHelpers do
             cmd = "the command"
             expect(Beaker::Command).to receive(:new).with(/puppet master --configprint user/, [], {"ENV"=>{}, :cmdexe=>true}).and_return(cmd)
             expect(subject).to receive(:on).with(host, cmd).and_return(result)
-            expect(subject).to receive(:on).with(host, /^getent passwd puppet/).and_return(result)
-            expect(host).to receive(:tmpdir).with(/\/tmp\/beaker.*/)
-            expect(subject).to receive(:on).with(host, /chown puppet.puppet.*/)
+            expect(subject).to receive(:create_tmpdir_on).with(host, /\/tmp\/beaker/, /puppet/)
             subject.create_tmpdir_for_user(host)
           end
         end
@@ -350,162 +66,15 @@ describe ClassMixedWithDSLHelpers do
           cmd = "the command"
           expect(Beaker::Command).to receive(:new).with(/puppet master --configprint user/, [], {"ENV"=>{}, :cmdexe=>true}).and_return(cmd)
           expect(subject).to receive(:on).with(host, cmd).and_return(result)
-          expect(subject).to receive(:on).with(host, /^getent passwd puppet/).and_return(result)
-          expect(host).to receive(:tmpdir).with(/\/tmp\/bogus.*/).and_return("/tmp/bogus")
-          expect(subject).to receive(:on).with(host, /chown puppet.puppet \/tmp\/bogus.*/)
+          expect(subject).to receive(:create_tmpdir_on).with(host, /\/tmp\/bogus/, /puppet/)
           subject.create_tmpdir_for_user(host, "/tmp/bogus")
         end
       end
 
     end
 
-    context 'with an invalid user argument' do
-      it 'executes chown once' do
-        allow(result).to receive(:stdout).and_return('curiousgeorge')
-        expect(subject).to receive(:on).with(host, /^getent passwd curiousgeorge/).and_return(result)
-        expect(host).to receive(:tmpdir).with(/\/tmp\/bogus.*/).and_return("/tmp/bogus")
-        expect(subject).to receive(:on).with(host, /chown curiousgeorge.curiousgeorge \/tmp\/bogus.*/)
-        subject.create_tmpdir_for_user(host, "/tmp/bogus", "curiousgeorge")
-      end
-    end
-
-    context 'with a valid user argument' do
-      it 'executes chown once' do
-        allow(result).to receive(:exit_code).and_return(1)
-        expect(subject).to receive(:on).with(host, /^getent passwd curiousgeorge/).and_return(result)
-        expect{
-          subject.create_tmpdir_for_user(host, "/tmp/bogus", "curiousgeorge")
-        }.to raise_error(RuntimeError, /User curiousgeorge does not exist on/)
-      end
-    end
-
   end
 
-  describe '#run_script_on' do
-    it 'scps the script to a tmpdir and executes it on host(s)' do
-      expect( subject ).to receive( :scp_to )
-      expect( subject ).to receive( :on )
-      subject.run_script_on( 'host', '~/.bin/make-enterprisy' )
-    end
-  end
-
-  describe '#run_script' do
-    it 'delegates to #run_script_on with the default host' do
-      allow( subject ).to receive( :hosts ).and_return( hosts )
-
-      expect( subject ).to receive( :run_script_on ).with( master, "/tmp/test.sh", {}).once
-
-      subject.run_script( '/tmp/test.sh' )
-    end
-  end
-
-  describe 'confine' do
-    let(:logger) { double.as_null_object }
-    before do
-      allow( subject ).to receive( :logger ).and_return( logger )
-    end
-
-    it 'skips the test if there are no applicable hosts' do
-      allow( subject ).to receive( :hosts ).and_return( [] )
-      allow( subject ).to receive( :hosts= )
-      expect( logger ).to receive( :warn )
-      expect( subject ).to receive( :skip_test ).
-        with( 'No suitable hosts found' )
-
-      subject.confine( :to, {} )
-    end
-
-    it 'raises when given mode is not :to or :except' do
-      allow( subject ).to receive( :hosts )
-      allow( subject ).to receive( :hosts= )
-
-      expect {
-        subject.confine( :regardless, {:thing => 'value'} )
-      }.to raise_error( 'Unknown option regardless' )
-    end
-
-    it 'rejects hosts that do not meet simple hash criteria' do
-      hosts = [ {'thing' => 'foo'}, {'thing' => 'bar'} ]
-
-      expect( subject ).to receive( :hosts ).and_return( hosts )
-      expect( subject ).to receive( :hosts= ).
-        with( [ {'thing' => 'foo'} ] )
-
-      subject.confine :to, :thing => 'foo'
-    end
-
-    it 'rejects hosts that match a list of criteria' do
-      hosts = [ {'thing' => 'foo'}, {'thing' => 'bar'}, {'thing' => 'baz'} ]
-
-      expect( subject ).to receive( :hosts ).and_return( hosts )
-      expect( subject ).to receive( :hosts= ).
-        with( [ {'thing' => 'bar'} ] )
-
-      subject.confine :except, :thing => ['foo', 'baz']
-    end
-
-    it 'rejects hosts when a passed block returns true' do
-      host1 = {'platform' => 'solaris'}
-      host2 = {'platform' => 'solaris'}
-      host3 = {'platform' => 'windows'}
-      ret1 = (Struct.new('Result1', :stdout)).new(':global')
-      ret2 = (Struct.new('Result2', :stdout)).new('a_zone')
-      hosts = [ host1, host2, host3 ]
-
-      expect( subject ).to receive( :hosts ).and_return( hosts )
-      expect( subject ).to receive( :on ).
-        with( host1, '/sbin/zonename' ).
-        and_return( ret1 )
-      expect( subject ).to receive( :on ).
-        with( host1, '/sbin/zonename' ).
-        and_return( ret2 )
-
-      expect( subject ).to receive( :hosts= ).with( [ host1 ] )
-
-      subject.confine :to, :platform => 'solaris' do |host|
-        subject.on( host, '/sbin/zonename' ).stdout =~ /:global/
-      end
-    end
-  end
-
-  describe '#select_hosts' do
-    let(:logger) { double.as_null_object }
-    before do
-      allow( subject ).to receive( :logger ).and_return( logger )
-    end
-
-    it 'it returns an empty array if there are no applicable hosts' do
-      hosts = [ {'thing' => 'foo'}, {'thing' => 'bar'} ]
-
-      expect(subject.select_hosts( {'thing' => 'nope'}, hosts )).to be == []
-    end
-
-    it 'selects hosts that match a list of criteria' do
-      hosts = [ {'thing' => 'foo'}, {'thing' => 'bar'}, {'thing' => 'baz'} ]
-
-      expect(subject.select_hosts( {:thing => ['foo', 'baz']}, hosts )).to be == [ {'thing' => 'foo'}, {'thing' => 'baz'} ]
-    end
-
-    it 'selects hosts when a passed block returns true' do
-      host1 = {'platform' => 'solaris1'}
-      host2 = {'platform' => 'solaris2'}
-      host3 = {'platform' => 'windows'}
-      ret1 = double('result1')
-      allow( ret1 ).to receive( :stdout ).and_return(':global')
-      ret2 = double('result2')
-      allow( ret2 ).to receive( :stdout ).and_return('a_zone')
-      hosts = [ host1, host2, host3 ]
-      expect( subject ).to receive( :hosts ).and_return( hosts )
-
-      expect( subject ).to receive( :on ).with( host1, '/sbin/zonename' ).once.and_return( ret1 )
-      expect( subject ).to receive( :on ).with( host2, '/sbin/zonename' ).once.and_return( ret2 )
-
-      selected_hosts = subject.select_hosts 'platform' => 'solaris' do |host|
-                             subject.on(host, '/sbin/zonename').stdout =~ /:global/
-      end
-      expect( selected_hosts ).to be == [ host1 ]
-    end
-  end
 
   describe '#apply_manifest_on' do
     it 'calls puppet' do
@@ -783,33 +352,6 @@ describe ClassMixedWithDSLHelpers do
     end
   end
 
-  describe 'version_is_less' do
-
-    it 'reports 3.0.0-160-gac44cfb is not less than 3.0.0' do
-      expect( subject.version_is_less( '3.0.0-160-gac44cfb', '3.0.0' ) ).to be === false
-    end
-
-    it 'reports 3.0.0-160-gac44cfb is not less than 2.8.2' do
-      expect( subject.version_is_less( '3.0.0-160-gac44cfb', '2.8.2' ) ).to be === false
-    end
-
-    it 'reports 3.0.0 is less than 3.0.0-160-gac44cfb' do
-      expect( subject.version_is_less( '3.0.0', '3.0.0-160-gac44cfb' ) ).to be === true
-    end
-
-    it 'reports 2.8.2 is less than 3.0.0-160-gac44cfb' do
-      expect( subject.version_is_less( '2.8.2', '3.0.0-160-gac44cfb' ) ).to be === true
-    end
-
-    it 'reports 2.8 is less than 3.0.0-160-gac44cfb' do
-      expect( subject.version_is_less( '2.8', '3.0.0-160-gac44cfb' ) ).to be === true
-    end
-
-    it 'reports 2.8 is less than 2.9' do
-      expect( subject.version_is_less( '2.8', '2.9' ) ).to be === true
-    end
-  end
-
   describe "#stop_agent_on" do
     let( :result_fail ) { Beaker::Result.new( [], "" ) }
     let( :result_pass ) { Beaker::Result.new( [], "" ) }
@@ -1257,156 +799,5 @@ describe ClassMixedWithDSLHelpers do
     end
   end
 
-  describe '#fact_on' do
-    it 'retrieves a fact on a single host' do
-      result.stdout = "family\n"
-      expect( subject ).to receive(:facter).with('osfamily',{}).once
-      expect( subject ).to receive(:on).and_return(result)
-
-      expect( subject.fact_on('host','osfamily') ).to be === result.stdout.chomp
-    end
-
-    it 'retrieves an array of facts from multiple hosts' do
-      allow( subject ).to receive( :hosts ).and_return( hosts )
-      times = hosts.length
-      result.stdout = "family\n"
-      hosts.each do |host|
-        expect( host ).to receive(:exec).and_return(result)
-      end
-
-      expect( subject.fact_on(hosts,'osfamily') ).to be === [result.stdout.chomp] * hosts.length
-
-    end
-  end
-
-  describe '#fact' do
-    it 'delegates to #fact_on with the default host' do
-      allow( subject ).to receive(:hosts).and_return(hosts)
-      expect( subject ).to receive(:fact_on).with(master,"osfamily",{}).once
-
-      subject.fact('osfamily')
-    end
-  end
-
-  describe 'modify_tk_config' do
-    let(:host) { double.as_null_object }
-    let(:config_file_path) { 'existing-file-path'}
-    let(:invalid_config_file_path) { 'nonexisting-file-path'}
-    let(:options_hash) { {:key => 'value'} }
-    let(:replace) { true }
-
-    shared_examples 'modify-tk-config-without-error' do
-      it 'dumps to the SUT config file path' do
-        allow( JSON ).to receive(:dump)
-        allow( subject ).to receive(:create_remote_file).with(host, config_file_path, anything())
-        subject.modify_tk_config(host, config_file_path, options_hash, replace)
-      end
-    end
-
-    before do
-      allow( host ).to receive(:file_exist?).with(invalid_config_file_path).and_return(false)
-      allow( host ).to receive(:file_exist?).with(config_file_path).and_return(true)
-    end
-
-    describe 'if file does not exist on SUT' do
-      it 'raises Runtime error' do
-        expect do
-          subject.modify_tk_config(host, invalid_config_file_path, options_hash)
-        end.to raise_error(RuntimeError, /.* does not exist on .*/)
-      end
-    end
-
-    describe 'given an empty options hash' do
-      it 'returns nil' do
-        expect(subject.modify_tk_config(host, 'blahblah', {})).to eq(nil)
-      end
-    end
-
-    describe 'given a non-empty options hash' do
-
-      describe 'given a false value to its `replace` parameter' do
-        let(:replace) { false }
-        before do
-          expect( subject ).to receive(:read_tk_config_string).with(anything())
-        end
-        include_examples('modify-tk-config-without-error')
-      end
-
-      describe 'given a true value to its `replace` parameter' do
-        before do
-          expect( JSON ).to receive(:dump)
-          expect( subject ).to receive(:create_remote_file).with(host, config_file_path, anything())
-        end
-        include_examples('modify-tk-config-without-error')
-      end
-    end
-  end
-
-  describe "#write_hiera_config_on" do
-    let(:hierarchy) { [ 'nodes/%{::fqdn}', 'common' ] }
-    it 'on FOSS host' do
-      host = make_host('testhost', { :platform => 'ubuntu' } )
-      expect(subject).to receive(:create_remote_file).with(host, host.puppet['hiera_config'], /#{host[:hieradatadir]}/)
-      subject.write_hiera_config_on(host, hierarchy)
-    end
-
-    it 'on PE host' do
-      host = make_host('testhost', { :platform => 'ubuntu', :type => 'pe' } )
-      expect(subject).to receive(:create_remote_file).with(host, host.puppet['hiera_config'], /#{host[:hieradatadir]}/)
-      subject.write_hiera_config_on(host, hierarchy)
-    end
-
-  end
-
-  describe "#write_hiera_config" do
-    let(:hierarchy) { [ 'nodes/%{::fqdn}', 'common' ] }
-    it 'delegates to #write_hiera_config_on with the default host' do
-      allow( subject ).to receive( :hosts ).and_return( hosts )
-      expect( subject ).to receive( :write_hiera_config_on ).with( master, hierarchy).once
-      subject.write_hiera_config( hierarchy )
-    end
-
-  end
-
-  describe "#copy_hiera_data_to" do
-    let(:path) { 'spec/fixtures/hieradata' }
-    it 'on FOSS host' do
-      host = make_host('testhost', { :platform => 'ubuntu' } )
-      expect(subject).to receive(:scp_to).with(host, File.expand_path(path), host[:hieradatadir])
-      subject.copy_hiera_data_to(host, path)
-    end
-
-    it 'on PE host' do
-      host = make_host('testhost', { :platform => 'ubuntu', :type => 'pe' } )
-      expect(subject).to receive(:scp_to).with(host, File.expand_path(path), host[:hieradatadir])
-      subject.copy_hiera_data_to(host, path)
-    end
-  end
-
-  describe "#copy_hiera_data" do
-    let(:path) { 'spec/fixtures/hieradata' }
-    it 'delegates to #copy_hiera_data_to with the default host' do
-      allow( subject ).to receive( :hosts ).and_return( hosts )
-      expect( subject ).to receive( :copy_hiera_data_to ).with( master, path).once
-      subject.copy_hiera_data( path )
-    end
-
-  end
-
-  describe '#hiera_datadir' do
-    it 'returns the codedir based hieradatadir for AIO' do
-      host = hosts[0]
-      host['type'] = :aio
-      correct_answer = File.join(host.puppet['codedir'], 'hieradata')
-      expect( subject.hiera_datadir(host) ).to be === correct_answer
-    end
-
-    it 'returns the hieradata host value for anything not AIO (backwards compatible)' do
-      host_hieradatadir_value = '/home/fishing/man/pants'
-      host = hosts[0]
-      host[:hieradatadir] = host_hieradatadir_value
-      expect( subject.hiera_datadir(host) ).to be === host_hieradatadir_value
-    end
-  end
 
 end