pdk-akerl 1.8.0.1

data/lib/pdk/template_file.rb

@@ -0,0 +1,89 @@
+require 'ostruct'
+
+module PDK
+  class TemplateFile < OpenStruct
+    # Initialises the TemplateFile object with the path to the template file
+    # and the data to be used when rendering the template.
+    #
+    # @param template_file [String] The path on disk to the template file.
+    # @param data [Hash{Symbol => Object}] The data that should be provided to
+    # the template when rendering.
+    # @option data [Object] :configs The value of this key will be provided to
+    # the template as an instance variable `@configs` in order to maintain
+    # compatibility with modulesync.
+    #
+    # @api public
+    def initialize(template_file, data = {})
+      @template_file = template_file
+
+      if data.key?(:configs)
+        @configs = data[:configs]
+      end
+
+      super(data)
+    end
+
+    # Renders the template by calling the appropriate engine based on the file
+    # extension.
+    #
+    # If the template has an `.erb` extension, the content of the template
+    # file will be treated as an ERB template. All other extensions are treated
+    # as plain text.
+    #
+    # @return [String] The rendered template
+    #
+    # @raise (see #template_content)
+    #
+    # @api public
+    def render
+      case File.extname(@template_file)
+      when '.erb'
+        render_erb
+      else
+        render_plain
+      end
+    end
+
+    private
+
+    # Reads the content of the template file into memory.
+    #
+    # @return [String] The content of the template file.
+    #
+    # @raise [ArgumentError] If the template file does not exist or can not be
+    # read.
+    #
+    # @api private
+    def template_content
+      if File.file?(@template_file) && File.readable?(@template_file)
+        return File.read(@template_file)
+      end
+
+      raise ArgumentError, _("'%{template}' is not a readable file") % { template: @template_file }
+    end
+
+    # Renders the content of the template file as an ERB template.
+    #
+    # @return [String] The rendered template.
+    #
+    # @raise (see #template_content)
+    #
+    # @api private
+    def render_erb
+      renderer = ERB.new(template_content, nil, '-')
+      renderer.filename = @template_file
+      renderer.result(binding)
+    end
+
+    # Renders the content of the template file as plain text.
+    #
+    # @return [String] The rendered template.
+    #
+    # @raise (see #template_content)
+    #
+    # @api private
+    def render_plain
+      template_content
+    end
+  end
+end

data/lib/pdk/tests/unit.rb

@@ -0,0 +1,213 @@
+require 'pdk'
+require 'pdk/cli/exec'
+require 'pdk/util/bundler'
+require 'json'
+
+module PDK
+  module Test
+    class Unit
+      def self.cmd(tests, opts = {})
+        rake_args = opts.key?(:parallel) ? 'parallel_spec_standalone' : 'spec_standalone'
+        rake_args += "[#{tests}]" unless tests.nil?
+        rake_args
+      end
+
+      def self.rake_bin
+        @rake ||= File.join(PDK::Util.module_root, 'bin', 'rake')
+      end
+
+      def self.rake(task, spinner_text, environment = {})
+        argv = [rake_bin, task]
+        argv.unshift(File.join(PDK::Util::RubyVersion.bin_path, 'ruby.exe')) if Gem.win_platform?
+
+        command = PDK::CLI::Exec::Command.new(*argv).tap do |c|
+          c.context = :module
+          c.add_spinner(spinner_text)
+          c.environment = environment
+        end
+
+        command.execute!
+      end
+
+      def self.parallel_with_no_tests?(ran_in_parallel, json_result, result)
+        ran_in_parallel && json_result.empty? &&
+          ((!result[:exit_code].zero? && result[:stderr].strip =~ %r{Pass files or folders to run$}) ||
+           result[:stderr].strip =~ %r{No files for parallel_spec to run against$})
+      end
+
+      def self.print_failure(result, exception)
+        $stderr.puts ''
+        result[:stdout].each_line { |line| $stderr.puts line.rstrip } unless result[:stdout].nil?
+        result[:stderr].each_line { |line| $stderr.puts line.rstrip } unless result[:stderr].nil?
+        $stderr.puts ''
+        raise PDK::CLI::FatalError, exception
+      end
+
+      def self.tear_down
+        result = rake('spec_clean', _('Cleaning up after running unit tests.'))
+
+        return if result[:exit_code].zero?
+
+        PDK.logger.error(_('The spec_clean rake task failed with the following error(s):'))
+        print_failure(result, _('Failed to clean up after running unit tests'))
+      end
+
+      def self.setup
+        result = rake('spec_prep', _('Preparing to run the unit tests.'))
+
+        return if result[:exit_code].zero?
+
+        tear_down
+
+        PDK.logger.error(_('The spec_prep rake task failed with the following error(s):'))
+        print_failure(result, _('Failed to prepare to run the unit tests.'))
+      end
+
+      def self.invoke(report, options = {})
+        PDK::Util::Bundler.ensure_binstubs!('rake', 'rspec-core')
+
+        setup
+
+        tests = options.fetch(:tests)
+
+        environment = { 'CI_SPEC_OPTIONS' => '--format j' }
+        environment['PUPPET_GEM_VERSION'] = options[:puppet] if options[:puppet]
+        spinner_msg = options.key?(:parallel) ? _('Running unit tests in parallel.') : _('Running unit tests.')
+        result = rake(cmd(tests, options), spinner_msg, environment)
+
+        json_result = if options.key?(:parallel)
+                        PDK::Util.find_all_json_in(result[:stdout])
+                      else
+                        PDK::Util.find_first_json_in(result[:stdout])
+                      end
+
+        if parallel_with_no_tests?(options.key?(:parallel), json_result, result)
+          json_result = [{ 'messages' => ['No examples found.'] }]
+          result[:exit_code] = 0
+        end
+
+        raise PDK::CLI::FatalError, _('Unit test output did not contain a valid JSON result: %{output}') % { output: result[:stdout] } if json_result.nil? || json_result.empty?
+
+        json_result = merge_json_results(json_result) if options.key?(:parallel)
+
+        parse_output(report, json_result, result[:duration])
+
+        result[:exit_code]
+      ensure
+        tear_down if options[:'clean-fixtures']
+      end
+
+      def self.parse_output(report, json_data, duration)
+        # Output messages to stderr.
+        json_data['messages'] && json_data['messages'].each { |msg| $stderr.puts msg }
+
+        example_results = {
+          # Only possibilities are passed, failed, pending:
+          # https://github.com/rspec/rspec-core/blob/master/lib/rspec/core/example.rb#L548
+          'passed' => [],
+          'failed' => [],
+          'pending' => [],
+        }
+
+        json_data['examples'] && json_data['examples'].each do |ex|
+          example_results[ex['status']] << ex if example_results.key?(ex['status'])
+        end
+
+        example_results.each do |result, examples|
+          # Translate rspec example results to JUnit XML testcase results
+          state = case result
+                  when 'passed' then :passed
+                  when 'failed' then :failure
+                  when 'pending' then :skipped
+                  end
+
+          examples.each do |ex|
+            report.add_event(
+              source: 'rspec',
+              state: state,
+              file: ex['file_path'],
+              line: ex['line_number'],
+              test: ex['full_description'],
+              severity: ex['status'],
+              message: ex['pending_message'] || (ex['exception'] && ex['exception']['message']) || nil,
+              trace: (ex['exception'] && ex['exception']['backtrace']) || nil,
+            )
+          end
+        end
+
+        return unless json_data['summary']
+
+        # TODO: standardize summary output
+        $stderr.puts '  ' << _('Evaluated %{total} tests in %{duration} seconds: %{failures} failures, %{pending} pending.') % {
+          total: json_data['summary']['example_count'],
+          duration: duration,
+          failures: json_data['summary']['failure_count'],
+          pending: json_data['summary']['pending_count'],
+        }
+      end
+
+      def self.merge_json_results(json_data)
+        merged_json_result = {}
+
+        # Merge messages
+        message_set = Set.new
+        json_data.each do |json|
+          next unless json['messages']
+          message_set |= json['messages']
+        end
+        merged_json_result['messages'] = message_set.to_a
+
+        # Merge examples
+        all_examples = []
+        json_data.each do |json|
+          next unless json['examples']
+          all_examples.concat json['examples']
+        end
+        merged_json_result['examples'] = all_examples
+
+        # Merge summaries
+        summary_hash = {
+          'example_count' => 0,
+          'failure_count' => 0,
+          'pending_count' => 0,
+        }
+        json_data.each do |json|
+          next unless json['summary']
+          summary_hash['example_count'] += json['summary']['example_count']
+          summary_hash['failure_count'] += json['summary']['failure_count']
+          summary_hash['pending_count'] += json['summary']['pending_count']
+        end
+        merged_json_result['summary'] = summary_hash
+
+        merged_json_result
+      end
+
+      # @return array of { :id, :full_description }
+      def self.list
+        PDK::Util::Bundler.ensure_binstubs!('rake')
+
+        command_argv = [File.join(PDK::Util.module_root, 'bin', 'rake'), 'spec_list_json']
+        command_argv.unshift(File.join(PDK::Util::RubyVersion.bin_path, 'ruby.exe')) if Gem.win_platform?
+
+        list_command = PDK::CLI::Exec::Command.new(*command_argv)
+        list_command.context = :module
+        output = list_command.execute!
+
+        rspec_json = PDK::Util.find_first_json_in(output[:stdout])
+        raise PDK::CLI::FatalError, _('Failed to find valid JSON in output from rspec: %{output}' % { output: output[:stdout] }) unless rspec_json
+        if rspec_json['examples'].empty?
+          rspec_message = rspec_json['messages'][0]
+          return [] if rspec_message == 'No examples found.'
+
+          raise PDK::CLI::FatalError, _('Unable to enumerate examples. rspec reported: %{message}' % { message: rspec_message })
+        else
+          examples = []
+          rspec_json['examples'].each do |example|
+            examples << { file_path: example['file_path'], id: example['id'], full_description: example['full_description'] }
+          end
+          examples
+        end
+      end
+    end
+  end
+end

data/lib/pdk/util.rb

@@ -0,0 +1,271 @@
+require 'tmpdir'
+require 'tempfile'
+
+require 'pdk/util/version'
+require 'pdk/util/windows'
+require 'pdk/util/vendored_file'
+require 'pdk/util/filesystem'
+
+module PDK
+  module Util
+    MODULE_FOLDERS = %w[
+      manifests
+      lib
+      tasks
+      facts.d
+      functions
+      types
+    ].freeze
+
+    # Searches upwards from current working directory for the given target file.
+    #
+    # @param target [String] Name of file to search for.
+    # @param start_dir [String] Directory to start searching from, defaults to Dir.pwd
+    #
+    # @return [String, nil] Fully qualified path to the given target file if found,
+    #   nil if the target file could not be found.
+    def find_upwards(target, start_dir = nil)
+      previous = nil
+      current  = File.expand_path(start_dir || Dir.pwd)
+
+      until !File.directory?(current) || current == previous
+        filename = File.join(current, target)
+        return filename if File.file?(filename)
+        previous = current
+        current = File.expand_path('..', current)
+      end
+    end
+    module_function :find_upwards
+
+    # Generate a name for a temporary directory.
+    #
+    # @param base [String] A string to base the name generation off.
+    #
+    # @return [String] The temporary directory path.
+    def make_tmpdir_name(base)
+      t = Time.now.strftime('%Y%m%d')
+      name = "#{base}#{t}-#{Process.pid}-#{rand(0x100000000).to_s(36)}"
+      File.join(Dir.tmpdir, name)
+    end
+    module_function :make_tmpdir_name
+
+    # Return an expanded, absolute path
+    #
+    # @param path [String] Existing path that may not be canonical
+    #
+    # @return [String] Canonical path
+    def canonical_path(path)
+      if Gem.win_platform?
+        unless File.exist?(path)
+          raise PDK::CLI::FatalError, _("Cannot resolve a full path to '%{path}', as it does not currently exist.") % { path: path }
+        end
+        PDK::Util::Windows::File.get_long_pathname(path)
+      else
+        File.expand_path(path)
+      end
+    end
+    module_function :canonical_path
+
+    def package_install?
+      !PDK::Util::Version.version_file.nil?
+    end
+    module_function :package_install?
+
+    def development_mode?
+      (!PDK::Util::Version.git_ref.nil? || PDK::VERSION.end_with?('.pre'))
+    end
+    module_function :development_mode?
+
+    def gem_install?
+      !(package_install? || development_mode?)
+    end
+    module_function :gem_install?
+
+    def pdk_package_basedir
+      raise PDK::CLI::FatalError, _('Package basedir requested for non-package install.') unless package_install?
+
+      File.dirname(PDK::Util::Version.version_file)
+    end
+    module_function :pdk_package_basedir
+
+    def package_cachedir
+      File.join(pdk_package_basedir, 'share', 'cache')
+    end
+    module_function :package_cachedir
+
+    # Returns the fully qualified path to a per-user PDK cachedir.
+    #
+    # @return [String] Fully qualified path to per-user PDK cachedir.
+    def cachedir
+      if Gem.win_platform?
+        File.join(ENV['LOCALAPPDATA'], 'PDK', 'cache')
+      else
+        File.join(Dir.home, '.pdk', 'cache')
+      end
+    end
+    module_function :cachedir
+
+    # Returns path to the root of the module being worked on.
+    #
+    # @return [String, nil] Fully qualified base path to module, or nil if
+    #   the current working dir does not appear to be within a module.
+    def module_root
+      metadata_path = find_upwards('metadata.json')
+      if metadata_path
+        File.dirname(metadata_path)
+      elsif in_module_root?
+        Dir.pwd
+      else
+        nil
+      end
+    end
+    module_function :module_root
+
+    # Returns true or false depending on if any of the common directories in a module
+    # are found in the current directory
+    #
+    # @return [boolean] True if any folders from MODULE_FOLDERS are found in the current dir,
+    #   false otherwise.
+    def in_module_root?
+      PDK::Util::MODULE_FOLDERS.any? { |dir| File.directory?(dir) }
+    end
+    module_function :in_module_root?
+
+    # Iterate through possible JSON documents until we find one that is valid.
+    #
+    # @param [String] text the text in which to find a JSON document
+    # @return [Hash, nil] subset of text as Hash of first valid JSON found, or nil if no valid
+    #   JSON found in the text
+    def find_first_json_in(text)
+      find_valid_json_in(text)
+    end
+    module_function :find_first_json_in
+
+    # Iterate through possible JSON documents for all valid JSON
+    #
+    # @param [String] text the text in which to find JSON document(s)
+    # @return [Array<Hash>] subset of text as Array of all JSON object found, empty Array if none are found
+    #   JSON found in the text
+    def find_all_json_in(text)
+      find_valid_json_in(text, break_on_first: false)
+    end
+    module_function :find_all_json_in
+
+    # Iterate through possible JSON documents until we find one that is valid.
+    #
+    # @param [String] text the text in which to find a JSON document
+    # @param [Hash] opts options
+    # @option opts [Boolean] :break_on_first Whether or not to break after valid JSON is found, defaults to true
+    #
+    # @return [Hash, Array<Hash>, nil] subset of text as Hash of first valid JSON found, array of all valid JSON found, or nil if no valid
+    #   JSON found in the text
+    #
+    # @private
+    def find_valid_json_in(text, opts = {})
+      break_on_first = opts.key?(:break_on_first) ? opts[:break_on_first] : true
+
+      json_result = break_on_first ? nil : []
+
+      text.scan(%r{\{(?:[^{}]|(?:\g<0>))*\}}x) do |str|
+        begin
+          if break_on_first
+            json_result = JSON.parse(str)
+            break
+          else
+            json_result.push(JSON.parse(str))
+          end
+        rescue JSON::ParserError
+          next
+        end
+      end
+
+      json_result
+    end
+    module_function :find_valid_json_in
+
+    # Returns the targets' paths relative to the working directory
+    #
+    # @return [Array<String>] The absolute or path to the target
+    def targets_relative_to_pwd(targets)
+      targets.map do |t|
+        if Pathname.new(t).absolute?
+          Pathname.new(t).relative_path_from(Pathname.pwd)
+        else
+          t
+        end
+      end
+    end
+    module_function :targets_relative_to_pwd
+
+    def default_template_url
+      answer_file_url = PDK.answers['template-url']
+
+      return puppetlabs_template_url if answer_file_url.nil?
+
+      # Ignore answer file template-url if the value is the old or new default.
+      return puppetlabs_template_url if answer_file_url == 'https://github.com/puppetlabs/pdk-module-template'
+      return puppetlabs_template_url if answer_file_url == puppetlabs_template_url
+
+      unless PDK::Util::Git.repo?(answer_file_url)
+        PDK.logger.warn(_("Unable to access the previously used template '%{template}', using the default template instead.") % { template: answer_file_url })
+        PDK.answers.update!('template-url' => nil)
+        return puppetlabs_template_url
+      end
+
+      answer_file_url
+    end
+    module_function :default_template_url
+
+    def puppetlabs_template_url
+      if package_install?
+        'file://' + File.join(package_cachedir, 'pdk-templates.git')
+      else
+        'https://github.com/puppetlabs/pdk-templates'
+      end
+    end
+    module_function :puppetlabs_template_url
+
+    def default_template_ref
+      # TODO: This should respect a --template-ref option if we add that
+      return 'origin/master' if default_template_url != puppetlabs_template_url
+
+      puppetlabs_template_ref
+    end
+    module_function :default_template_ref
+
+    def puppetlabs_template_ref
+      if PDK::Util.development_mode?
+        'origin/master'
+      else
+        PDK::TEMPLATE_REF
+      end
+    end
+    module_function :puppetlabs_template_ref
+
+    # TO-DO: Refactor replacement of lib/pdk/module/build.rb:metadata to use this function instead
+    def module_metadata
+      PDK::Module::Metadata.from_file(File.join(module_root, 'metadata.json')).data
+    end
+    module_function :module_metadata
+
+    # TO-DO: Refactor replacement of lib/pdk/module/build.rb:module_pdk_compatible? to use this function instead
+    def module_pdk_compatible?
+      ['pdk-version', 'template-url'].any? { |key| module_metadata.key?(key) }
+    end
+    module_function :module_pdk_compatible?
+
+    def module_pdk_version
+      metadata = module_metadata
+
+      if metadata.nil? || metadata.fetch('pdk-version', nil).nil?
+        nil
+      else
+        metadata['pdk-version'].split.first
+      end
+    rescue ArgumentError => e
+      PDK.logger.error(e)
+      nil
+    end
+    module_function :module_pdk_version
+  end
+end