beaker 3.18.0 → 3.19.0

data/lib/beaker/dsl/install_utils/module_utils.rb

@@ -1,244 +0,0 @@
-module Beaker
-  module DSL
-    module InstallUtils
-      #
-      # This module contains methods to help install puppet modules
-      #
-      # To mix this is into a class you need the following:
-      # * a method *hosts* that yields any hosts implementing
-      #   {Beaker::Host}'s interface to act upon.
-      # * a method *options* that provides an options hash, see {Beaker::Options::OptionsHash}
-      # * the module {Beaker::DSL::Roles} that provides access to the various hosts implementing
-      #   {Beaker::Host}'s interface to act upon
-      # * the module {Beaker::DSL::Wrappers} the provides convenience methods for {Beaker::DSL::Command} creation
-      module ModuleUtils
-
-        # The directories in the module directory that will not be scp-ed to the test system when using
-        # `copy_module_to`
-        PUPPET_MODULE_INSTALL_IGNORE = ['.bundle', '.git', '.idea', '.vagrant', '.vendor', 'vendor', 'acceptance',
-                                        'bundle', 'spec', 'tests', 'log', '.svn', 'junit', 'pkg', 'example']
-
-        # Install the desired module on all hosts using either the PMT or a
-        #   staging forge
-        #
-        # @see install_dev_puppet_module
-        def install_dev_puppet_module_on( host, opts )
-          if options[:forge_host]
-            with_forge_stubbed_on( host ) do
-              install_puppet_module_via_pmt_on( host, opts )
-            end
-          else
-            copy_module_to( host, opts )
-          end
-        end
-        alias :puppet_module_install_on :install_dev_puppet_module_on
-
-        # Install the desired module on all hosts using either the PMT or a
-        #   staging forge
-        #
-        # Passes options through to either `install_puppet_module_via_pmt_on`
-        #   or `copy_module_to`
-        #
-        # @param opts [Hash]
-        #
-        # @example Installing a module from the local directory
-        #   install_dev_puppet_module( :source => './', :module_name => 'concat' )
-        #
-        # @example Installing a module from a staging forge
-        #   options[:forge_host] = 'my-forge-api.example.com'
-        #   install_dev_puppet_module( :source => './', :module_name => 'concat' )
-        #
-        # @see install_puppet_module_via_pmt
-        # @see copy_module_to
-        def install_dev_puppet_module( opts )
-          block_on( hosts ) {|h| install_dev_puppet_module_on( h, opts ) }
-        end
-        alias :puppet_module_install :install_dev_puppet_module
-
-        # Install the desired module with the PMT on a given host
-        #
-        # @param opts [Hash]
-        # @option opts [String] :module_name The short name of the module to be installed
-        # @option opts [String] :version The version of the module to be installed
-        def install_puppet_module_via_pmt_on( host, opts = {} )
-          block_on host do |h|
-            version_info = opts[:version] ? "-v #{opts[:version]}" : ""
-            if opts[:source]
-              author_name, module_name = parse_for_modulename( opts[:source] )
-              modname = "#{author_name}-#{module_name}"
-            else
-              modname = opts[:module_name]
-            end
-
-            puppet_opts = {}
-            if host[:default_module_install_opts].respond_to? :merge
-              puppet_opts = host[:default_module_install_opts].merge( puppet_opts )
-            end
-
-            on h, puppet("module install #{modname} #{version_info}", puppet_opts)
-          end
-        end
-
-        # Install the desired module with the PMT on all known hosts
-        # @see #install_puppet_module_via_pmt_on
-        def install_puppet_module_via_pmt( opts = {} )
-          install_puppet_module_via_pmt_on(hosts, opts)
-        end
-
-        # Install local module for acceptance testing
-        # should be used as a presuite to ensure local module is copied to the hosts you want, particularly masters
-        # @param [Host, Array<Host>, String, Symbol] one_or_more_hosts
-        #                   One or more hosts to act upon,
-        #                   or a role (String or Symbol) that identifies one or more hosts.
-        # @option opts [String] :source ('./')
-        #                   The current directory where the module sits, otherwise will try
-        #                         and walk the tree to figure out
-        # @option opts [String] :module_name (nil)
-        #                   Name which the module should be installed under, please do not include author,
-        #                     if none is provided it will attempt to parse the metadata.json and then the Module file to determine
-        #                     the name of the module
-        # @option opts [String] :target_module_path (host['distmoduledir']/modules)
-        #                   Location where the module should be installed, will default
-        #                    to host['distmoduledir']/modules
-        # @option opts [Array] :ignore_list
-        # @option opts [String] :protocol
-        #                   Name of the underlying transfer method. Valid options are 'scp' or 'rsync'.
-        # @raise [ArgumentError] if not host is provided or module_name is not provided and can not be found in Modulefile
-        #
-        def copy_module_to(one_or_more_hosts, opts = {})
-          block_on one_or_more_hosts do |host|
-            opts = {:source => './',
-                    :target_module_path => host['distmoduledir'],
-                    :ignore_list => PUPPET_MODULE_INSTALL_IGNORE}.merge(opts)
-
-            ignore_list = build_ignore_list(opts)
-            target_module_dir = on( host, "echo #{opts[:target_module_path]}" ).stdout.chomp
-            source_path = File.expand_path( opts[:source] )
-            source_dir = File.dirname(source_path)
-            source_name = File.basename(source_path)
-            if opts.has_key?(:module_name)
-              module_name = opts[:module_name]
-            else
-              _, module_name = parse_for_modulename( source_path )
-            end
-
-            target_path = File.join(target_module_dir, module_name)
-            if host.is_powershell? #make sure our slashes are correct
-              target_path = target_path.gsub(/\//,'\\')
-            end
-
-            opts[:protocol] ||= 'scp'
-            case opts[:protocol]
-            when 'scp'
-              #move to the host
-              logger.debug "Using scp to transfer #{source_path} to #{target_path}"
-              scp_to host, source_path, target_module_dir, {:ignore => ignore_list}
-
-              #rename to the selected module name, if not correct
-              cur_path = File.join(target_module_dir, source_name)
-              if host.is_powershell? #make sure our slashes are correct
-                cur_path = cur_path.gsub(/\//,'\\')
-              end
-              host.mv cur_path, target_path unless cur_path == target_path
-            when 'rsync'
-              logger.debug "Using rsync to transfer #{source_path} to #{target_path}"
-              rsync_to host, source_path, target_path, {:ignore => ignore_list}
-            else
-              logger.debug "Unsupported transfer protocol, returning nil"
-              nil
-            end
-          end
-        end
-        alias :copy_root_module_to :copy_module_to
-
-        #Recursive method for finding the module root
-        # Assumes that a Modulefile exists
-        # @param [String] possible_module_directory
-        #                   will look for Modulefile and if none found go up one level and try again until root is reached
-        #
-        # @return [String,nil]
-        def parse_for_moduleroot(possible_module_directory)
-          if File.exists?("#{possible_module_directory}/Modulefile") || File.exists?("#{possible_module_directory}/metadata.json")
-            possible_module_directory
-          elsif possible_module_directory === '/'
-            logger.error "At root, can't parse for another directory"
-            nil
-          else
-            logger.debug "No Modulefile or metadata.json found at #{possible_module_directory}, moving up"
-            parse_for_moduleroot File.expand_path(File.join(possible_module_directory,'..'))
-          end
-        end
-
-        #Parse root directory of a module for module name
-        # Searches for metadata.json and then if none found, Modulefile and parses for the Name attribute
-        # @param [String] root_module_dir
-        # @return [String] module name
-        def parse_for_modulename(root_module_dir)
-          author_name, module_name = nil, nil
-          if File.exists?("#{root_module_dir}/metadata.json")
-            logger.debug "Attempting to parse Modulename from metadata.json"
-            module_json = JSON.parse(File.read "#{root_module_dir}/metadata.json")
-            if(module_json.has_key?('name'))
-              author_name, module_name = get_module_name(module_json['name'])
-            end
-          end
-          if !module_name && File.exists?("#{root_module_dir}/Modulefile")
-            logger.debug "Attempting to parse Modulename from Modulefile"
-            if /^name\s+'?(\w+-\w+)'?\s*$/i.match(File.read("#{root_module_dir}/Modulefile"))
-              author_name, module_name = get_module_name(Regexp.last_match[1])
-            end
-          end
-          if !module_name && !author_name
-            logger.debug "Unable to determine name, returning null"
-          end
-          return author_name, module_name
-        end
-
-        #Parse modulename from the pattern 'Auther-ModuleName'
-        #
-        # @param [String] author_module_name <Author>-<ModuleName> pattern
-        #
-        # @return [String,nil]
-        #
-        def get_module_name(author_module_name)
-          split_name = split_author_modulename(author_module_name)
-          if split_name
-            return split_name[:author], split_name[:module]
-          end
-        end
-
-        #Split the Author-Name into a hash
-        # @param [String] author_module_attr
-        #
-        # @return [Hash<Symbol,String>,nil] :author and :module symbols will be returned
-        #
-        def split_author_modulename(author_module_attr)
-          result = /(\w+)-(\w+)/.match(author_module_attr)
-          if result
-            {:author => result[1], :module => result[2]}
-          else
-            nil
-          end
-        end
-
-        # Build an array list of files/directories to ignore when pushing to remote host
-        # Automatically adds '..' and '.' to array.  If not opts of :ignore list is provided
-        # it will use the static variable PUPPET_MODULE_INSTALL_IGNORE
-        #
-        # @param opts [Hash]
-        # @option opts [Array] :ignore_list A list of files/directories to ignore
-        def build_ignore_list(opts = {})
-          ignore_list = opts[:ignore_list] || PUPPET_MODULE_INSTALL_IGNORE
-          if !ignore_list.kind_of?(Array) || ignore_list.nil?
-            raise ArgumentError "Ignore list must be an Array"
-          end
-          ignore_list << '.' unless ignore_list.include? '.'
-          ignore_list << '..' unless ignore_list.include? '..'
-          ignore_list
-        end
-
-      end
-    end
-
-  end
-end

data/lib/beaker/dsl/install_utils/puppet_utils.rb

@@ -1,157 +0,0 @@
-module Beaker
-  module DSL
-    module InstallUtils
-      #
-      # This module contains methods useful for both foss and pe installs
-      #
-      module PuppetUtils
-
-        #Given a type return an understood host type
-        #@param [String] type The host type to be normalized
-        #@return [String] The normalized type
-        #
-        #@example
-        #  normalize_type('pe-aio')
-        #    'pe'
-        #@example
-        #  normalize_type('git')
-        #    'foss'
-        #@example
-        #  normalize_type('foss-internal')
-        #    'foss'
-        def normalize_type type
-          case type
-          when /(\A|-)(git)|(foss)(\Z|-)/
-            'foss'
-          when /(\A|-)pe(\Z|-)/
-            'pe'
-          when /(\A|-)aio(\Z|-)/
-            'aio'
-          else
-            nil
-          end
-        end
-
-        #Given a host construct a PATH that includes puppetbindir, facterbindir and hierabindir
-        # @param [Host] host    A single host to construct pathing for
-        def construct_puppet_path(host)
-          path = (%w(puppetbindir facterbindir hierabindir)).compact.reject(&:empty?)
-          #get the PATH defaults
-          path.map! { |val| host[val] }
-          path = path.compact.reject(&:empty?)
-          #run the paths through echo to see if they have any subcommands that need processing
-          path.map! { |val| echo_on(host, val) }
-
-          separator = host['pathseparator']
-          if not host.is_powershell?
-            separator = ':'
-          end
-          path.join(separator)
-        end
-
-        #Append puppetbindir, facterbindir and hierabindir to the PATH for each host
-        # @param [Host, Array<Host>, String, Symbol] hosts    One or more hosts to act upon,
-        #                            or a role (String or Symbol) that identifies one or more hosts.
-        def add_puppet_paths_on(hosts)
-          block_on hosts do | host |
-            puppet_path = construct_puppet_path(host)
-            host.add_env_var('PATH', puppet_path)
-            host.add_env_var('PATH', 'PATH') # don't destroy the path!
-          end
-        end
-
-        #Remove puppetbindir, facterbindir and hierabindir to the PATH for each host
-        #
-        # @param [Host, Array<Host>, String, Symbol] hosts    One or more hosts to act upon,
-        #                            or a role (String or Symbol) that identifies one or more hosts.
-        def remove_puppet_paths_on(hosts)
-          block_on hosts do | host |
-            puppet_path = construct_puppet_path(host)
-            host.delete_env_var('PATH', puppet_path)
-            host.add_env_var('PATH', 'PATH') # don't destroy the path!
-          end
-        end
-
-        #Configure the provided hosts to be of the provided type (one of foss, aio, pe), if the host
-        #is already associated with a type then remove the previous settings for that type
-        # @param [Host, Array<Host>, String, Symbol] hosts    One or more hosts to act upon,
-        #                            or a role (String or Symbol) that identifies one or more hosts.
-        # @param [String] type One of 'aio', 'pe' or 'foss'
-        def configure_defaults_on( hosts, type )
-          block_on hosts do |host|
-
-            # check to see if the host already has a type associated with it
-            remove_defaults_on(host)
-
-            add_method = "add_#{type}_defaults_on"
-            if self.respond_to?(add_method, host)
-              self.send(add_method, host)
-            else
-              raise "cannot add defaults of type #{type} for host #{host.name} (#{add_method} not present)"
-            end
-            # add pathing env
-            add_puppet_paths_on(host)
-          end
-        end
-
-        # Configure the provided hosts to be of their host[:type], it host[type] == nil do nothing
-        def configure_type_defaults_on( hosts )
-          block_on hosts do |host|
-            has_defaults = false
-            if host[:type]
-              host_type = host[:type]
-              # clean up the naming conventions here (some teams use foss-package, git-whatever, we need
-              # to correctly handle that
-              # don't worry about aio, that happens in the aio_version? check
-              host_type = normalize_type(host_type)
-              if host_type and host_type !~ /aio/
-                add_method = "add_#{host_type}_defaults_on"
-                if self.respond_to?(add_method, host)
-                  self.send(add_method, host)
-                else
-                  raise "cannot add defaults of type #{host_type} for host #{host.name} (#{add_method} not present)"
-                end
-                has_defaults = true
-              end
-            end
-            if aio_version?(host)
-              add_aio_defaults_on(host)
-              has_defaults = true
-            end
-            # add pathing env
-            if has_defaults
-              add_puppet_paths_on(host)
-            end
-          end
-        end
-        alias_method :configure_foss_defaults_on, :configure_type_defaults_on
-        alias_method :configure_pe_defaults_on, :configure_type_defaults_on
-
-        #If the host is associated with a type remove all defaults and environment associated with that type.
-        # @param [Host, Array<Host>, String, Symbol] hosts    One or more hosts to act upon,
-        #                            or a role (String or Symbol) that identifies one or more hosts.
-        def remove_defaults_on( hosts )
-          block_on hosts do |host|
-            if host['type']
-              # clean up the naming conventions here (some teams use foss-package, git-whatever, we need
-              # to correctly handle that
-              # don't worry about aio, that happens in the aio_version? check
-              host_type = normalize_type(host['type'])
-              remove_puppet_paths_on(hosts)
-              remove_method = "remove_#{host_type}_defaults_on"
-              if self.respond_to?(remove_method, host)
-                self.send(remove_method, host)
-              else
-                raise "cannot remove defaults of type #{host_type} associated with host #{host.name} (#{remove_method} not present)"
-              end
-              if aio_version?(host)
-                remove_aio_defaults_on(host)
-              end
-            end
-          end
-        end
-
-      end
-    end
-  end
-end

data/spec/beaker/dsl/helpers/facter_helpers_spec.rb

@@ -1,59 +0,0 @@
-require 'spec_helper'
-
-class ClassMixedWithDSLHelpers
-  include Beaker::DSL::Helpers
-  include Beaker::DSL::Wrappers
-  include Beaker::DSL::Roles
-  include Beaker::DSL::Patterns
-
-  def logger
-    RSpec::Mocks::Double.new('logger').as_null_object
-  end
-
-end
-
-describe ClassMixedWithDSLHelpers do
-  let( :command ){ 'ls' }
-  let( :host )   { double.as_null_object }
-  let( :result ) { Beaker::Result.new( host, command ) }
-
-  let( :master ) { make_host( 'master',   :roles => %w( master agent default)    ) }
-  let( :agent )  { make_host( 'agent',    :roles => %w( agent )           ) }
-  let( :custom ) { make_host( 'custom',   :roles => %w( custom agent )    ) }
-  let( :dash )   { make_host( 'console',  :roles => %w( dashboard agent ) ) }
-  let( :db )     { make_host( 'db',       :roles => %w( database agent )  ) }
-  let( :hosts )  { [ master, agent, dash, db, custom ] }
-
-
-  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
-
-end