puppet-strings 2.4.0 → 2.5.0

data/spec/spec_helper.rb

@@ -1,49 +0,0 @@
-if ENV['COVERAGE'] == 'yes'
-  require 'simplecov'
-  require 'simplecov-console'
-  require 'codecov'
-
-  SimpleCov.formatters = [
-    SimpleCov::Formatter::HTMLFormatter,
-    SimpleCov::Formatter::Console,
-    SimpleCov::Formatter::Codecov,
-  ]
-  SimpleCov.start do
-    track_files 'lib/**/*.rb'
-
-    add_filter '/spec'
-  end
-end
-
-require 'mocha'
-require 'rspec'
-require 'json_spec'
-require 'puppet/version'
-require 'puppet-strings'
-require 'puppet-strings/markdown'
-require 'puppet-strings/markdown/base'
-require 'puppet-strings/yard'
-
-# Explicitly set up YARD once
-PuppetStrings::Yard.setup!
-
-# Enable testing of Puppet functions if running against 4.1+
-TEST_PUPPET_FUNCTIONS = Puppet::Util::Package.versioncmp(Puppet.version, "4.1.0") >= 0
-
-# Enable testing of Puppet language functions declared with return type if running against 4.8+
-TEST_FUNCTION_RETURN_TYPE = Puppet::Util::Package.versioncmp(Puppet.version, "4.8.0") >= 0
-
-# Enable testing of Plans if Puppet version is greater than 5.0.0
-TEST_PUPPET_PLANS = Puppet::Util::Package.versioncmp(Puppet.version, "5.0.0") >= 0
-
-# Enable testing of Data Types if Puppet version is greater than 4.1.0
-TEST_PUPPET_DATATYPES = Puppet::Util::Package.versioncmp(Puppet.version, "4.1.0") >= 0
-
-RSpec.configure do |config|
-  config.mock_with :mocha
-
-  config.before(:each) do
-    # Always clear the YARD registry before each example
-    YARD::Registry.clear
-  end
-end

data/spec/spec_helper_acceptance.rb

@@ -1,58 +0,0 @@
-require 'serverspec'
-require 'puppet_litmus'
-include PuppetLitmus # rubocop:disable Style/MixinUsage This is fine
-
-if ENV['TARGET_HOST'].nil? || ENV['TARGET_HOST'] == 'localhost'
-  puts 'Running tests against this machine !'
-  if Gem.win_platform?
-    set :backend, :cmd
-  else
-    set :backend, :exec
-  end
-else
-  # load inventory
-  inventory_hash = inventory_hash_from_inventory_file
-  node_config = config_from_node(inventory_hash, ENV['TARGET_HOST'])
-
-  if target_in_group(inventory_hash, ENV['TARGET_HOST'], 'docker_nodes')
-    host = ENV['TARGET_HOST']
-    set :backend, :docker
-    set :docker_container, host
-  elsif target_in_group(inventory_hash, ENV['TARGET_HOST'], 'ssh_nodes')
-    set :backend, :ssh
-    options = Net::SSH::Config.for(host)
-    options[:user] = node_config.dig('ssh', 'user') unless node_config.dig('ssh', 'user').nil?
-    options[:port] = node_config.dig('ssh', 'port') unless node_config.dig('ssh', 'port').nil?
-    options[:keys] = node_config.dig('ssh', 'private-key') unless node_config.dig('ssh', 'private-key').nil?
-    options[:password] = node_config.dig('ssh', 'password') unless node_config.dig('ssh', 'password').nil?
-    options[:verify_host_key] = Net::SSH::Verifiers::Never.new unless node_config.dig('ssh', 'host-key-check').nil?
-    host = if ENV['TARGET_HOST'].include?(':')
-             ENV['TARGET_HOST'].split(':').first
-           else
-             ENV['TARGET_HOST']
-           end
-    set :host,        options[:host_name] || host
-    set :ssh_options, options
-    set :request_pty, true
-  elsif target_in_group(inventory_hash, ENV['TARGET_HOST'], 'winrm_nodes')
-    require 'winrm'
-
-    set :backend, :winrm
-    set :os, family: 'windows'
-    user = node_config.dig('winrm', 'user') unless node_config.dig('winrm', 'user').nil?
-    pass = node_config.dig('winrm', 'password') unless node_config.dig('winrm', 'password').nil?
-    endpoint = "http://#{ENV['TARGET_HOST']}:5985/wsman"
-
-    opts = {
-      user: user,
-      password: pass,
-      endpoint: endpoint,
-      operation_timeout: 300,
-    }
-
-    winrm = WinRM::Connection.new opts
-    Specinfra.configuration.winrm = winrm
-  end
-end
-
-require 'spec_helper_acceptance_local' if File.file?(File.join(File.dirname(__FILE__), 'spec_helper_acceptance_local.rb'))

data/spec/spec_helper_acceptance_local.rb

@@ -1,10 +0,0 @@
-def sut_module_path(module_regex)
-  modules = JSON.parse(PuppetLitmus::PuppetHelpers.run_shell('puppet module list --render-as json').stdout)
-  test_module_info = modules['modules_by_path'].values.flatten.find { |mod_info| mod_info =~ module_regex }
-  test_module_info.match(/\(([^)]*)\)/)[1]
-end
-
-def sut_tmp_path
-  # TODO: Linux only
-  '/tmp/'
-end

data/spec/unit/puppet-strings/describe_spec.rb

@@ -1,141 +0,0 @@
-require 'spec_helper'
-require 'puppet-strings/describe'
-require 'tempfile'
-
-#TODO:
-#basic describe
-#params from other files (e.g. file content)
-#--providers - list providers in detail
-#X--list - list all providers summary
-#--meta - List all metaparameters
-#--short - only list params
-
-describe PuppetStrings::Describe do
-  before :each do
-    # Populate the YARD registry with both Puppet and Ruby source
-
-
-    YARD::Parser::SourceParser.parse_string(<<-SOURCE, :ruby)
-Puppet::Type.newtype(:database) do
-  desc 'An example database server resource type.'
-end
-    SOURCE
-
-    YARD::Parser::SourceParser.parse_string(<<-SOURCE, :ruby)
-Puppet::ResourceApi.register_type(
-  name: 'apt_key',
-  docs: <<-EOS,
-@summary Example resource type using the new API.
-@raise SomeError
-This type provides Puppet with the capabilities to manage GPG keys needed
-by apt to perform package validation. Apt has it's own GPG keyring that can
-be manipulated through the `apt-key` command.
-@example here's an example
-  apt_key { '6F6B15509CF8E59E6E469F327F438280EF8D349F':
-    source => 'http://apt.puppetlabs.com/pubkey.gpg'
-  }
-
-**Autorequires**:
-If Puppet is given the location of a key file which looks like an absolute
-path this type will autorequire that file.
-  EOS
-)
-    SOURCE
-
-    YARD::Parser::SourceParser.parse_string(<<-SOURCE, :ruby)
-  Puppet::Type.type(:file).newproperty(:content) do
-    include Puppet::Util::Checksums
-    include Puppet::DataSync
-
-    attr_reader :actual_content
-
-    desc <<-'EOT'
-      The desired contents of a file, as a string. This attribute is mutually
-      exclusive with `source` and `target`.
-    EOT
-  end
-    SOURCE
-
-    YARD::Parser::SourceParser.parse_string(<<-SOURCE, :ruby)
-  Puppet::Type.newtype(:file) do
-    include Puppet::Util::Checksums
-    include Puppet::Util::Backups
-    include Puppet::Util::SymbolicFileMode
-
-    @doc = "Manages files, including their content, ownership, and permissions.
-
-      The `file` type can manage normal files, directories, and symlinks; the
-      type should be specified in the `ensure` attribute."
-
-    newparam(:path) do
-      desc <<-'EOT'
-        The path to the file to manage.  Must be fully qualified.
-
-        On Windows, the path should include the drive letter and should use `/` as
-        the separator character (rather than `\\`).
-      EOT
-      isnamevar
-    end
-
-  end
-    SOURCE
-
-    YARD::Parser::SourceParser.parse_string(<<-SOURCE, :ruby)
-Puppet::Type.type(:file).newproperty(:source) do
-  include Puppet::Util::Checksums
-  include Puppet::DataSync
-
-  attr_reader :actual_content
-
-  desc <<-'EOT'
-    The desired contents of a file, as a string. This attribute is mutually
-    exclusive with `source` and `target`.
-  EOT
-end
-    SOURCE
-  end
-
-  describe 'rendering DESCRIBE to stdout' do
-    it 'should output the expected describe content for the list of types' do
-      output = <<-DATA
-These are the types known to puppet:
-apt_key         - This type provides Puppet with the capabiliti ...
-database        - An example database server resource type.
-file            - Manages files, including their content, owner ...
-      DATA
-      expect{ PuppetStrings::Describe.render(nil, true) }.to output(output).to_stdout
-    end
-    it 'should output the expected describe content for a type' do
-      output = <<-DATA
-
-file
-====
-Manages files, including their content, ownership, and permissions.
-
-The `file` type can manage normal files, directories, and symlinks; the
-type should be specified in the `ensure` attribute.
-
-Parameters
-----------
-
-- **content**
-The desired contents of a file, as a string. This attribute is mutually
-exclusive with `source` and `target`.
-
-- **path**
-The path to the file to manage.  Must be fully qualified.
-
-On Windows, the path should include the drive letter and should use `/` as
-the separator character (rather than `\\`).
-
-- **source**
-The desired contents of a file, as a string. This attribute is mutually
-exclusive with `source` and `target`.
-
-Providers
----------
-      DATA
-      expect{ PuppetStrings::Describe.render(['file']) }.to output(output).to_stdout
-    end
-  end
-end

data/spec/unit/puppet-strings/json_spec.rb

@@ -1,302 +0,0 @@
-require 'spec_helper'
-require 'puppet-strings/json'
-require 'tempfile'
-
-describe PuppetStrings::Json do
-  before :each do
-    # Populate the YARD registry with both Puppet and Ruby source
-    YARD::Parser::SourceParser.parse_string(<<-SOURCE, :puppet)
-# A simple class.
-# @todo Do a thing
-# @note Some note
-# @param param1 First param.
-# @param param2 Second param.
-# @param param3 Third param.
-class klass(Integer $param1, $param2, String $param3 = hi) inherits foo::bar {
-}
-
-# A simple defined type.
-# @param param1 First param.
-# @param param2 Second param.
-# @param param3 Third param.
-define dt(Integer $param1, $param2, String $param3 = hi) {
-}
-    SOURCE
-
-    YARD::Parser::SourceParser.parse_string(<<-SOURCE, :puppet) if TEST_PUPPET_PLANS
-# A simple plan.
-# @param param1 First param.
-# @param param2 Second param.
-# @param param3 Third param.
-plan plann(String $param1, $param2, Integer $param3 = 1) {
-}
-    SOURCE
-
-    # Only include Puppet functions for 4.1+
-    YARD::Parser::SourceParser.parse_string(<<-SOURCE, :puppet) if TEST_PUPPET_FUNCTIONS
-# A simple function.
-# @param param1 First param.
-# @param param2 Second param.
-# @param param3 Third param.
-# @return [Undef] Returns nothing.
-function func(Integer $param1, $param2, String $param3 = hi) {
-}
-    SOURCE
-
-    # Only include Puppet types for 5.0+
-    YARD::Parser::SourceParser.parse_string(<<-SOURCE, :ruby) if TEST_PUPPET_DATATYPES
-# Basic Puppet Data Type in Ruby
-#
-# @param msg A message parameter
-Puppet::DataTypes.create_type('RubyDataType') do
-  interface <<-PUPPET
-    attributes => {
-      msg => String[1]
-    }
-    PUPPET
-end
-SOURCE
-
-    YARD::Parser::SourceParser.parse_string(<<-SOURCE, :json)
-{
-  "description": "Allows you to backup your database to local file.",
-  "input_method": "stdin",
-  "parameters": {
-    "database": {
-      "description": "Database to connect to",
-      "type": "Optional[String[1]]"
-    },
-    "user": {
-      "description": "The user",
-      "type": "Optional[String[1]]"
-    },
-    "password": {
-      "description": "The password",
-      "type": "Optional[String[1]]"
-    },
-     "sql": {
-      "description": "Path to file you want backup to",
-      "type": "String[1]"
-    }
-  }
-}
-    SOURCE
-
-    YARD::Parser::SourceParser.parse_string(<<-SOURCE, :ruby)
-Puppet::Parser::Functions.newfunction(:func3x, doc: <<-DOC
-An example 3.x function.
-@param [String] first The first parameter.
-@param second The second parameter.
-@return [Undef] Returns nothing.
-DOC
-) do |*args|
-end
-
-# An example 4.x function.
-Puppet::Functions.create_function(:func4x) do
-  # The first overload.
-  # @param param1 The first parameter.
-  # @param param2 The second parameter.
-  # @param param3 The third parameter.
-  # @return Returns nothing.
-  dispatch :foo do
-    param          'Integer',       :param1
-    param          'Any',           :param2
-    optional_param 'Array[String]', :param3
-    return_type 'Undef'
-  end
-
-  # @param param The first parameter.
-  # @param block The block parameter.
-  # @return Returns a string.
-  dispatch :other do
-    param 'Boolean', :param
-    block_param
-    return_type 'String'
-  end
-end
-
-# An example 4.x function with only one signature.
-Puppet::Functions.create_function(:func4x_1) do
-  # @param param1 The first parameter.
-  # @return [Undef] Returns nothing.
-  dispatch :foobarbaz do
-    param          'Integer',       :param1
-  end
-end
-
-Puppet::Type.type(:database).provide :linux do
-  desc 'An example provider on Linux.'
-  confine kernel: 'Linux'
-  confine osfamily: 'RedHat'
-  defaultfor :kernel => 'Linux'
-  defaultfor :osfamily => 'RedHat', :operatingsystemmajrelease => '7'
-  has_feature :implements_some_feature
-  has_feature :some_other_feature
-  commands foo: '/usr/bin/foo'
-end
-
-Puppet::Type.newtype(:database) do
-  desc 'An example database server resource type.'
-  feature :encryption, 'The provider supports encryption.', methods: [:encrypt]
-  ensurable do
-    desc 'What state the database should be in.'
-    defaultvalues
-    aliasvalue(:up, :present)
-    aliasvalue(:down, :absent)
-    defaultto :up
-  end
-
-  newparam(:address) do
-    isnamevar
-    desc 'The database server name.'
-  end
-
-  newparam(:encryption_key, required_features: :encryption) do
-    desc 'The encryption key to use.'
-  end
-
-  newparam(:encrypt, :parent => Puppet::Parameter::Boolean) do
-    desc 'Whether or not to encrypt the database.'
-    defaultto false
-  end
-
-  newproperty(:file) do
-    desc 'The database file to use.'
-  end
-
-  newproperty(:log_level) do
-    desc 'The log level to use.'
-    newvalue(:debug)
-    newvalue(:warn)
-    newvalue(:error)
-    defaultto 'warn'
-  end
-end
-
-Puppet::ResourceApi.register_type(
-  name: 'apt_key',
-  docs: <<-EOS,
-@summary Example resource type using the new API.
-@raise SomeError
-This type provides Puppet with the capabilities to manage GPG keys needed
-by apt to perform package validation. Apt has it's own GPG keyring that can
-be manipulated through the `apt-key` command.
-@example here's an example
-  apt_key { '6F6B15509CF8E59E6E469F327F438280EF8D349F':
-    source => 'http://apt.puppetlabs.com/pubkey.gpg'
-  }
-
-**Autorequires**:
-If Puppet is given the location of a key file which looks like an absolute
-path this type will autorequire that file.
-  EOS
-  attributes:   {
-    ensure:      {
-      type: 'Enum[present, absent]',
-      desc: 'Whether this apt key should be present or absent on the target system.'
-    },
-    id:          {
-      type:      'Variant[Pattern[/\A(0x)?[0-9a-fA-F]{8}\Z/], Pattern[/\A(0x)?[0-9a-fA-F]{16}\Z/], Pattern[/\A(0x)?[0-9a-fA-F]{40}\Z/]]',
-      behaviour: :namevar,
-      desc:      'The ID of the key you want to manage.',
-    },
-    # ...
-    created:     {
-      type:      'String',
-      behaviour: :read_only,
-      desc:      'Date the key was created, in ISO format.',
-    },
-  },
-  autorequires: {
-    file:    '$source', # will evaluate to the value of the `source` attribute
-    package: 'apt',
-  },
-)
-    SOURCE
-  end
-
-  RSpec.shared_examples "correct JSON" do
-    it 'should include data for Puppet Classes' do
-      puppet_class_json = YARD::Registry.all(:puppet_class).sort_by!(&:name).map!(&:to_hash).to_json
-
-      expect(json_output).to include_json(puppet_class_json)
-    end
-
-    it 'should include data for Puppet Data Types' do
-      data_types_json = YARD::Registry.all(:puppet_data_type).sort_by!(&:name).map!(&:to_hash).to_json
-      expect(json_output).to include_json(data_types_json)
-    end
-
-    it 'should include data for Puppet Defined Types' do
-      defined_types_json = YARD::Registry.all(:puppet_defined_type).sort_by!(&:name).map!(&:to_hash).to_json
-
-      expect(json_output).to include_json(defined_types_json)
-    end
-
-    it 'should include data for Puppet Resouce Types' do
-      resource_types_json = YARD::Registry.all(:puppet_type).sort_by!(&:name).map!(&:to_hash).to_json
-
-      expect(json_output).to include_json(resource_types_json)
-    end
-
-    it 'should include data for Puppet Providers' do
-      providers_json = YARD::Registry.all(:puppet_provider).sort_by!(&:name).map!(&:to_hash).to_json
-
-      expect(json_output).to include_json(providers_json)
-    end
-
-    it 'should include data for Puppet Functions', if: TEST_PUPPET_FUNCTIONS do
-      puppet_functions_json = YARD::Registry.all(:puppet_function).sort_by!(&:name).map!(&:to_hash).to_json
-
-      expect(json_output).to include_json(puppet_functions_json)
-    end
-
-    it 'should include data for Puppet Tasks' do
-      puppet_tasks_json = YARD::Registry.all(:puppet_task).sort_by!(&:name).map!(&:to_hash).to_json
-
-      expect(json_output).to include_json(puppet_tasks_json)
-    end
-
-    it 'should include data for Puppet Plans', if: TEST_PUPPET_PLANS do
-      puppet_plans_json = YARD::Registry.all(:puppet_plan).sort_by!(&:name).map!(&:to_hash).to_json
-
-      expect(json_output).to include_json(puppet_plans_json)
-    end
-  end
-
-  describe 'rendering JSON to a file' do
-    let(:json_output) do
-      json_output = nil
-
-      Tempfile.open('json') do |file|
-        PuppetStrings::Json.render(file.path)
-
-        json_output = File.read(file.path)
-      end
-
-      json_output
-    end
-
-    include_examples "correct JSON"
-  end
-
-  describe 'rendering JSON to stdout' do
-    let(:json_output) { @json_output }
-
-    before(:each) do
-      output = StringIO.new
-
-      old_stdout = $stdout
-      $stdout = output
-
-      PuppetStrings::Json.render(nil)
-
-      $stdout = old_stdout
-
-      @json_output = output.string
-    end
-
-    include_examples "correct JSON"
-  end
-end