puppet-strings 2.1.0 → 2.5.0

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

@@ -1,283 +0,0 @@
-require 'spec_helper'
-require 'puppet-strings/markdown'
-require 'puppet-strings/markdown/table_of_contents'
-require 'tempfile'
-
-describe PuppetStrings::Markdown do
-  before :each do
-    # Populate the YARD registry with both Puppet and Ruby source
-    YARD::Parser::SourceParser.parse_string(<<-SOURCE, :puppet)
-# An overview for a simple class.
-# @summary A simple class.
-# @todo Do a thing
-# @note some note
-# @since 1.0.0
-# @see www.puppet.com
-# @example This is an example
-#  class { 'klass':
-#    param1 => 1,
-#    param3 => 'foo',
-#  }
-# @example This is another example
-#  class { 'klass':
-#    param1 => 1,
-#    param3 => 'foo',
-#  }
-# @raise SomeError
-# @param param1 First param.
-# @param param2 Second param.
-# @option param2 [String] :opt1 something about opt1
-# @option param2 [Hash] :opt2 a hash of stuff
-# @param param3 Third param.
-#
-class klass (
-  Integer $param1 = 1,
-  $param2 = undef,
-  String $param3 = 'hi'
-) inherits foo::bar {
-}
-
-# Overview for class noparams
-# @api private
-class noparams () {}
-
-# An overview for a simple defined type.
-# @summary A simple defined type.
-# @since 1.1.0
-# @see www.puppet.com
-# @example Here's an example of this type:
-#  klass::dt { 'foo':
-#    param1 => 33,
-#    param4 => false,
-#  }
-# @return shouldn't return squat
-# @raise SomeError
-# @param param1 First param.
-# @param param2 Second param.
-# @option param2 [String] :opt1 something about opt1
-# @option param2 [Hash] :opt2 a hash of stuff
-# @param param3 Third param.
-# @param param4 Fourth param.
-define klass::dt (
-  Integer $param1 = 44,
-  $param2,
-  String $param3 = 'hi',
-  Boolean $param4 = true
-) {
-}
-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
-
-    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, :puppet)
-# A simple Puppet function.
-# @param param1 First param.
-# @param param2 Second param.
-# @param param3 Third param.
-# @option param3 [Array] :param3opt Something about this option
-# @raise SomeError this is some error
-# @return [Undef] Returns nothing.
-function func(Integer $param1, $param2, String $param3 = hi) {
-}
-SOURCE
-
-    YARD::Parser::SourceParser.parse_string(<<-SOURCE, :ruby)
-# An example 4.x function.
-Puppet::Functions.create_function(:func4x) do
-  # An overview for the first overload.
-  # @raise SomeError this is some error
-  # @param param1 The first parameter.
-  # @param param2 The second parameter.
-  # @option param2 [String] :option an option
-  # @option param2 [String] :option2 another option
-  # @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
-
-  # An overview for the second overload.
-  # @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
-
-# An example 3.x function
-Puppet::Parser::Functions.newfunction(:func3x, doc: <<-DOC
- Documentation for an example 3.x function.
- @param param1 [String] The first parameter.
- @param param2 [Integer] The second parameter.
- @return [Undef]
- @example Calling the function.
-   func3x('hi', 10)
- DOC
- ) do |*args|
-   #...
-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 <<-DESC
-An example database server type.
-@option opts :foo bar
-@raise SomeError
-@example here's an example
- database { 'foo':
-   address => 'qux.baz.bar',
- }
-DESC
-  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
-
-  let(:filename) do
-    if TEST_PUPPET_PLANS
-      'output_with_plan.md'
-    else
-      'output.md'
-    end
-  end
-  let(:baseline_path) { File.join(File.dirname(__FILE__), "../../fixtures/unit/markdown/#{filename}") }
-  let(:baseline) { File.read(baseline_path) }
-
-  describe 'rendering markdown to a file' do
-    it 'should output the expected markdown content' do
-      Tempfile.open('md') do |file|
-        PuppetStrings::Markdown.render(file.path)
-        expect(File.read(file.path)).to eq(baseline)
-      end
-    end
-  end
-end

data/spec/unit/puppet-strings/yard/code_objects/task_spec.rb

@@ -1,92 +0,0 @@
-require 'spec_helper'
-require 'puppet-strings/yard/code_objects/task'
-require 'puppet-strings/yard/parsers/json/task_statement'
-
-describe PuppetStrings::Yard::CodeObjects::Task do
-  let(:source) { <<-SOURCE
-{
-  "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
-  }
-  let(:json) { JSON.parse(source) }
-  let(:statement) { PuppetStrings::Yard::Parsers::JSON::TaskStatement.new(json, source, "test.json") }
-  subject { PuppetStrings::Yard::CodeObjects::Task.new(statement) }
-
-  describe '#type' do
-    it 'returns the correct type' do
-      expect(subject.type).to eq(:puppet_task)
-    end
-  end
-
-  describe '#source' do
-    it 'returns the source' do
-      expect(subject.source).to eq(source)
-    end
-  end
-
-  describe '#to_hash' do
-    let(:expected) do
-      {
-        :name => "test",
-        :supports_noop => false,
-        :docstring => {
-          :text=>"Allows you to backup your database to local file.",
-          :tags=> [
-            {
-              :name=>"database",
-              :tag_name=>"param",
-              :text=>"Database to connect to",
-              :types=> ["Optional[String[1]]"]
-            },
-            {
-              :name=>"user",
-              :tag_name=>"param",
-              :text=>"The user",
-              :types=> ["Optional[String[1]]"]
-            },
-            {
-              :name=>"password",
-              :tag_name=>"param",
-              :text=>"The password",
-              :types=> ["Optional[String[1]]"]
-            },
-            {
-              :name=>"sql",
-              :tag_name=>"param",
-              :text=>"Path to file you want backup to",
-              :types=>["String[1]"]
-            }
-          ]
-        },
-        :file => "test.json",
-        :input_method => "stdin",
-        :line => 0,
-        :source => "{\n  \"description\": \"Allows you to backup your database to local file.\",\n  \"input_method\": \"stdin\",\n  \"parameters\": {\n    \"database\": {\n      \"description\": \"Database to connect to\",\n      \"type\": \"Optional[String[1]]\"\n    },\n    \"user\": {\n      \"description\": \"The user\",\n      \"type\": \"Optional[String[1]]\"\n    },\n    \"password\": {\n      \"description\": \"The password\",\n      \"type\": \"Optional[String[1]]\"\n    },\n     \"sql\": {\n      \"description\": \"Path to file you want backup to\",\n      \"type\": \"String[1]\"\n    }\n  }\n}\n"
-      }
-    end
-
-    it 'returns the correct hash' do
-      expect(subject.to_hash).to eq(expected)
-    end
-  end
-end

data/spec/unit/puppet-strings/yard/handlers/json/task_handler_spec.rb

@@ -1,124 +0,0 @@
-require 'spec_helper'
-require 'puppet-strings/yard'
-
-describe PuppetStrings::Yard::Handlers::JSON::TaskHandler do
-  subject {
-    YARD::Parser::SourceParser.parse_string(source, :json)
-    YARD::Registry.all(:puppet_task)
-  }
-
-  describe 'parsing source without a task definition' do
-    let(:source) { 'notice hi' }
-
-    it 'no defined types should be in the registry' do
-      expect(subject.empty?).to eq(true)
-    end
-  end
-
-  describe 'parsing source with a syntax error' do
-    let(:source) { <<-SOURCE
-{
-  "input_method": "stdin",
-  "parameters":
-    "database": {
-      "description": "Database to connect to",
-      "type": "Optional[String[1]]"
-    }
-  }
-}
-SOURCE
-    }
-
-    it 'should log an error' do
-      expect{ subject }.to output(/\[error\]: Failed to parse \(stdin\):/).to_stdout_from_any_process
-      expect(subject.empty?).to eq(true)
-    end
-  end
-
-  describe 'parsing a defined type with a missing docstring' do
-    let(:source) { <<-SOURCE
-{
-  "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
-    }
-
-    it 'should log a warning' do
-      expect{ subject }.to output(/\[warn\]: Missing a description for Puppet Task \(stdin\)/).to_stdout_from_any_process
-    end
-  end
-
-  describe 'parsing a defined type with a docstring' do
-    let(:source) { <<-SOURCE
-{
-  "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
-    }
-
-    it 'should register a task object' do
-      expect(subject.size).to eq(1)
-      object = subject.first
-      expect(object).to be_a(PuppetStrings::Yard::CodeObjects::Task)
-      expect(object.namespace).to eq(PuppetStrings::Yard::CodeObjects::Tasks.instance)
-    end
-  end
-
-  describe 'parsing a Task with a missing parameter description' do
-    let(:source) { <<-SOURCE
-{
-  "description": "Allows you to backup your database to local file.",
-  "input_method": "stdin",
-  "parameters": {
-    "database": {
-      "type": "Optional[String[1]]"
-    }
-  }
-}
-SOURCE
-    }
-
-    it 'should output a warning' do
-      expect{ subject }.to output(/\[warn\]: Missing description for param 'database' in Puppet Task \(stdin\)/).to_stdout_from_any_process
-    end
-  end
-
-end