puppet 8.4.0-x64-mingw32 → 8.5.0-x64-mingw32

data/spec/unit/face/generate_spec.rb

@@ -1,293 +0,0 @@
-require 'spec_helper'
-require 'puppet_spec/files'
-
-require 'puppet/face'
-
-describe Puppet::Face[:generate, :current] do
-  include PuppetSpec::Files
-
-  let(:genface) { Puppet::Face[:generate, :current] }
-
-  # * Format is 'pcore' by default
-  # * Format is accepted as 'pcore'
-  # * Any format expect 'pcore' is an error
-  # * Produces output to '<envroot>/.resource_types'
-  # * Produces all types found on the module path (that are not in puppet core)
-  # * Output files match input
-  # * Removes files for which there is no input
-  # * Updates a pcore file if it is out of date
-  # * The --force flag overwrite the output even if it is up to date
-  # * Environment is set with --environment (setting) (not tested explicitly)
-  # Writes output for:
-  #   - isomorphic
-  #   - parameters
-  #   - properties
-  #   - title patterns
-  #   - type information is written when the type is X, Y, or Z
-  #
-  # Additional features
-  #   - blacklist? whitelist? types to exclude/include
-  #   - generate one resource type (somewhere on modulepath)
-  #   - output to directory of choice
-  #   - clean, clean the output directory (similar to force)
-  #
-
-  [:types].each do |action|
-    it { is_expected.to be_action(action) }
-    it { is_expected.to respond_to(action) }
-  end
-
-  context "when used from an interactive terminal" do
-    before :each do
-      from_an_interactive_terminal
-    end
-
-    context "in an environment with two modules containing resource types" do
-      let(:dir) do
-        dir_containing('environments', { 'testing_generate' => {
-          'environment.conf' => "modulepath = modules",
-          'manifests' => { 'site.pp' => "" },
-          'modules' => {
-            'm1' => {
-              'lib' => { 'puppet' => { 'type' => {
-                'test1.rb' => <<-EOF
-                module Puppet
-                Type.newtype(:test1) do
-                  @doc = "Docs for resource"
-                  newproperty(:message) do
-                    desc "Docs for 'message' property"
-                  end
-                  newparam(:name) do
-                    desc "Docs for 'name' parameter"
-                    isnamevar
-                  end
-                end; end
-                EOF
-               } }
-            },
-          },
-          'm2' => { 
-            'lib' => { 'puppet' => { 'type' => {
-              'test2.rb' => <<-EOF
-              module Puppet
-              Type.newtype(:test2) do
-                @doc = "Docs for resource"
-                newproperty(:message) do
-                  desc "Docs for 'message' property"
-                end
-                newparam(:name) do
-                  desc "Docs for 'name' parameter"
-                  isnamevar
-                end
-              end;end
-              EOF
-             } } },
-          }
-        }}})
-      end
-
-      let(:modulepath) do
-        File.join(dir, 'testing_generate', 'modules')
-      end
-
-      let(:m1) do
-        File.join(modulepath, 'm1')
-      end
-
-      let(:m2) do
-        File.join(modulepath, 'm2')
-      end
-
-      let(:outputdir) do
-        File.join(dir, 'testing_generate', '.resource_types')
-      end
-
-      around(:each) do |example|
-        Puppet.settings.initialize_global_settings
-        Puppet[:manifest] = ''
-        loader = Puppet::Environments::Directories.new(dir, [])
-        Puppet.override(:environments => loader) do
-          Puppet.override(:current_environment => loader.get('testing_generate')) do
-            example.run
-          end
-        end
-      end
-
-      it 'error if format is given as something other than pcore' do
-        expect {
-          genface.types(:format => 'json')
-        }.to raise_exception(ArgumentError, /'json' is not a supported format for type generation/)
-      end
-
-      it 'accepts --format pcore as a format' do
-        expect {
-          genface.types(:format => 'pcore')
-        }.not_to raise_error
-      end
-
-      it 'sets pcore as the default format' do
-        expect(Puppet::Generate::Type).to receive(:find_inputs).with(:pcore).and_return([])
-        genface.types()
-      end
-
-      it 'finds all files to generate types for' do
-        # using expects and returning what the side effect should have been
-        # (There is no way to call the original when mocking expected parameters).
-        input1 = Puppet::Generate::Type::Input.new(m1, File.join(m1, 'lib', 'puppet', 'type', 'test1.rb'), :pcore)
-        input2 = Puppet::Generate::Type::Input.new(m1, File.join(m2, 'lib', 'puppet', 'type', 'test2.rb'), :pcore)
-        expect(Puppet::Generate::Type::Input).to receive(:new).with(m1, File.join(m1, 'lib', 'puppet', 'type', 'test1.rb'), :pcore).and_return(input1)
-        expect(Puppet::Generate::Type::Input).to receive(:new).with(m2, File.join(m2, 'lib', 'puppet', 'type', 'test2.rb'), :pcore).and_return(input2)
-        genface.types
-      end
-
-      it 'creates output directory <env>/.resource_types/ if it does not exist' do
-        expect(Puppet::FileSystem.exist?(outputdir)).to be(false)
-        genface.types
-        expect(Puppet::FileSystem.dir_exist?(outputdir)).to be(true)
-      end
-
-      it 'creates output with matching names for each input' do
-        expect(Puppet::FileSystem.exist?(outputdir)).to be(false)
-        genface.types
-        children = Puppet::FileSystem.children(outputdir).map {|p| Puppet::FileSystem.basename_string(p) }
-        expect(children.sort).to eql(['test1.pp', 'test2.pp'])
-      end
-
-      it 'tolerates that <env>/.resource_types/ directory exists' do
-        Puppet::FileSystem.mkpath(outputdir)
-        expect(Puppet::FileSystem.exist?(outputdir)).to be(true)
-        genface.types
-        expect(Puppet::FileSystem.dir_exist?(outputdir)).to be(true)
-      end
-
-      it 'errors if <env>/.resource_types exists and is not a directory' do
-        expect(Puppet::FileSystem.exist?(outputdir)).to be(false) # assert it is not already there
-        Puppet::FileSystem.touch(outputdir)
-        expect(Puppet::FileSystem.exist?(outputdir)).to be(true)
-        expect(Puppet::FileSystem.directory?(outputdir)).to be(false)
-        expect {
-          genface.types
-        }.to raise_error(ArgumentError, /The output directory '#{outputdir}' exists and is not a directory/)
-      end
-
-      it 'does not overwrite if files exists and are up to date' do
-        # create them (first run)
-        genface.types
-        stats_before = [Puppet::FileSystem.stat(File.join(outputdir, 'test1.pp')), Puppet::FileSystem.stat(File.join(outputdir, 'test2.pp'))]
-        # generate again
-        genface.types
-        stats_after = [Puppet::FileSystem.stat(File.join(outputdir, 'test1.pp')), Puppet::FileSystem.stat(File.join(outputdir, 'test2.pp'))]
-        expect(stats_before <=> stats_after).to be(0)
-      end
-
-      it 'overwrites if files exists that are not up to date while keeping up to date files' do
-        # create them (first run)
-        genface.types
-        stats_before = [Puppet::FileSystem.stat(File.join(outputdir, 'test1.pp')), Puppet::FileSystem.stat(File.join(outputdir, 'test2.pp'))]
-        # fake change in input test1 - sorry about the sleep (which there was a better way to change the modtime
-        sleep(1)
-        Puppet::FileSystem.touch(File.join(m1, 'lib', 'puppet', 'type', 'test1.rb'))
-        # generate again
-        genface.types
-        # assert that test1 was overwritten (later) but not test2 (same time)
-        stats_after = [Puppet::FileSystem.stat(File.join(outputdir, 'test1.pp')), Puppet::FileSystem.stat(File.join(outputdir, 'test2.pp'))]
-        expect(stats_before[1] <=> stats_after[1]).to be(0)
-        expect(stats_before[0] <=> stats_after[0]).to be(-1)
-      end
-
-      it 'overwrites all files when called with --force' do
-        # create them (first run)
-        genface.types
-        stats_before = [Puppet::FileSystem.stat(File.join(outputdir, 'test1.pp')), Puppet::FileSystem.stat(File.join(outputdir, 'test2.pp'))]
-        # generate again
-        sleep(1) # sorry, if there is no delay the stats will be the same
-        genface.types(:force => true)
-        stats_after = [Puppet::FileSystem.stat(File.join(outputdir, 'test1.pp')), Puppet::FileSystem.stat(File.join(outputdir, 'test2.pp'))]
-        expect(stats_before <=> stats_after).to be(-1)
-      end
-
-      it 'removes previously generated files from output when there is no input for it' do
-        # create them (first run)
-        genface.types
-        stat_before = Puppet::FileSystem.stat(File.join(outputdir, 'test2.pp'))
-        # remove input
-        Puppet::FileSystem.unlink(File.join(m1, 'lib', 'puppet', 'type', 'test1.rb'))
-        # generate again
-        genface.types
-        # assert that test1 was deleted but not test2 (same time)
-        expect(Puppet::FileSystem.exist?(File.join(outputdir, 'test1.pp'))).to be(false)
-        stats_after = Puppet::FileSystem.stat(File.join(outputdir, 'test2.pp'))
-        expect(stat_before <=> stats_after).to be(0)
-      end
-
-    end
-
-    context "in an environment with a faulty type" do
-      let(:dir) do
-        dir_containing('environments', { 'testing_generate2' => {
-          'environment.conf' => "modulepath = modules",
-          'manifests' => { 'site.pp' => "" },
-          'modules' => {
-            'm3' => {
-              'lib' => { 'puppet' => { 'type' => {
-                'test3.rb' => <<-EOF
-                module Puppet
-                Type.newtype(:test3) do
-                  @doc = "Docs for resource"
-                  def self.title_patterns
-                    identity = lambda {|x| x}
-                    [
-                      [
-                      /^(.*)_(.*)$/,
-                        [
-                          [:name, identity ]
-                        ]
-                      ]
-                    ]
-                  end
-                  newproperty(:message) do
-                    desc "Docs for 'message' property"
-                  end
-                  newparam(:name) do
-                    desc "Docs for 'name' parameter"
-                    isnamevar
-                  end
-                end; end
-                EOF
-               } }
-            }
-          }
-        }}})
-      end
-
-      let(:modulepath) do
-        File.join(dir, 'testing_generate2', 'modules')
-      end
-
-      let(:m3) do
-        File.join(modulepath, 'm3')
-      end
-
-      around(:each) do |example|
-        Puppet.settings.initialize_global_settings
-        Puppet[:manifest] = ''
-        loader = Puppet::Environments::Directories.new(dir, [])
-        Puppet.override(:environments => loader) do
-          Puppet.override(:current_environment => loader.get('testing_generate2')) do
-            example.run
-          end
-        end
-      end
-
-      it 'fails when using procs for title patterns' do
-        expect {
-          genface.types(:format => 'pcore')
-        }.to exit_with(1)
-      end
-    end
-  end
-
-  def from_an_interactive_terminal
-    allow(STDIN).to receive(:tty?).and_return(true)
-  end
-end

data/spec/unit/face/help_spec.rb

@@ -1,208 +0,0 @@
-require 'spec_helper'
-require 'puppet/face'
-
-describe Puppet::Face[:help, '0.0.1'] do
-  it 'has a help action' do
-    expect(subject).to be_action :help
-  end
-
-  it 'has a default action of help' do
-    expect(subject.get_action('help')).to be_default
-  end
-
-  it 'accepts a call with no arguments' do
-    expect {
-      subject.help()
-    }.to_not raise_error
-  end
-
-  it 'accepts a face name' do
-    expect { subject.help(:help) }.to_not raise_error
-  end
-
-  it 'accepts a face and action name' do
-    expect { subject.help(:help, :help) }.to_not raise_error
-  end
-
-  it 'fails if more than a face and action are given' do
-    expect { subject.help(:help, :help, :for_the_love_of_god) }.to raise_error ArgumentError
-  end
-
-  it "treats :current and 'current' identically" do
-    expect(subject.help(:help, :version => :current)).to eq(
-      subject.help(:help, :version => 'current')
-    )
-  end
-
-  it 'raises an error when the face is unavailable' do
-    expect {
-      subject.help(:huzzah, :bar, :version => '17.0.0')
-    }.to raise_error(ArgumentError, /Could not find version 17\.0\.0/)
-  end
-
-  it 'finds a face by version' do
-    face = Puppet::Face[:huzzah, :current]
-    expect(subject.help(:huzzah, :version => face.version)).
-      to eq(subject.help(:huzzah, :version => :current))
-  end
-
-  context 'rendering has an error' do
-    it 'raises an ArgumentError if the face raises a StandardError' do
-      face = Puppet::Face[:module, :current]
-      allow(face).to receive(:short_description).and_raise(StandardError, 'whoops')
-
-      expect {
-        subject.help(:module)
-      }.to raise_error(ArgumentError, /Detail: "whoops"/)
-    end
-
-    it 'raises an ArgumentError if the face raises a LoadError' do
-      face = Puppet::Face[:module, :current]
-      allow(face).to receive(:short_description).and_raise(LoadError, 'cannot load such file -- yard')
-
-      expect {
-        subject.help(:module)
-      }.to raise_error(ArgumentError, /Detail: "cannot load such file -- yard"/)
-    end
-
-    context 'with face actions' do
-      it 'returns an error if we can not get an action for the module' do
-        face = Puppet::Face[:module, :current]
-        allow(face).to receive(:get_action).and_return(nil)
-
-        expect {subject.help('module', 'list')}.to raise_error(ArgumentError, /Unable to load action list from Puppet::Face/)
-      end
-    end
-  end
-
-  context 'when listing subcommands' do
-    subject { Puppet::Face[:help, :current].help }
-
-    RSpec::Matchers.define :have_a_summary do
-      match do |instance|
-        instance.summary.is_a?(String)
-      end
-    end
-
-    # Check a precondition for the next block; if this fails you have
-    # something odd in your set of face, and we skip testing things that
-    # matter. --daniel 2011-04-10
-    it 'has at least one face with a summary' do
-      expect(Puppet::Face.faces).to be_any do |name|
-        Puppet::Face[name, :current].summary
-      end
-    end
-
-    it 'lists all faces which are runnable from the command line' do
-      help_face = Puppet::Face[:help, :current]
-      # The main purpose of the help face is to provide documentation for
-      #  command line users.  It shouldn't show documentation for faces
-      #  that can't be run from the command line, so, rather than iterating
-      #  over all available faces, we need to iterate over the subcommands
-      #  that are available from the command line.
-      Puppet::Application.available_application_names.each do |name|
-        next unless help_face.is_face_app?(name)
-        next if help_face.exclude_from_docs?(name)
-        face = Puppet::Face[name, :current]
-        summary = face.summary
-
-        expect(subject).to match(%r{ #{name} })
-        summary and expect(subject).to match(%r{ #{name} +#{summary}})
-      end
-    end
-
-    context 'face summaries' do
-      it 'can generate face summaries' do
-        faces = Puppet::Face.faces
-        expect(faces.length).to be > 0
-        faces.each do |name|
-          expect(Puppet::Face[name, :current]).to have_a_summary
-        end
-      end
-    end
-
-    it 'lists all legacy applications' do
-      Puppet::Face[:help, :current].legacy_applications.each do |appname|
-        expect(subject).to match(%r{ #{appname} })
-
-        summary = Puppet::Face[:help, :current].horribly_extract_summary_from(appname)
-        summary_regex = Regexp.escape(summary)
-        summary and expect(subject).to match(%r{ #{summary_regex}$})
-      end
-    end
-  end
-
-  context 'deprecated faces' do
-    it 'prints a deprecation warning for deprecated faces' do
-      allow(Puppet::Face[:module, :current]).to receive(:deprecated?).and_return(true)
-      expect(Puppet::Face[:help, :current].help(:module)).to match(/Warning: 'puppet module' is deprecated/)
-    end
-  end
-
-  context '#all_application_summaries' do
-    it 'appends a deprecation warning for deprecated faces' do
-      # Stub the module face as deprecated
-      expect(Puppet::Face[:module, :current]).to receive(:deprecated?).and_return(true)
-      Puppet::Face[:help, :current].all_application_summaries.each do |appname,summary|
-        expect(summary).to match(/Deprecated/) if appname == 'module'
-      end
-    end
-  end
-
-  context '#legacy_applications' do
-    subject { Puppet::Face[:help, :current].legacy_applications }
-
-    # If we don't, these tests are ... less than useful, because they assume
-    # it.  When this breaks you should consider ditching the entire feature
-    # and tests, but if not work out how to fake one. --daniel 2011-04-11
-    it { expect(subject.count).to be > 1 }
-
-    # Meh.  This is nasty, but we can't control the other list; the specific
-    # bug that caused these to be listed is annoyingly subtle and has a nasty
-    # fix, so better to have a "fail if you do something daft" trigger in
-    # place here, I think. --daniel 2011-04-11
-    %w{face_base indirection_base}.each do |name|
-      it { is_expected.not_to include name }
-    end
-  end
-
-  context 'help for legacy applications' do
-    subject { Puppet::Face[:help, :current] }
-    let :appname do subject.legacy_applications.first end
-
-    # This test is purposely generic, so that as we eliminate legacy commands
-    # we don't get into a loop where we either test a face-based replacement
-    # and fail to notice breakage, or where we have to constantly rewrite this
-    # test and all. --daniel 2011-04-11
-    it 'returns the legacy help when given the subcommand' do
-      help = subject.help(appname)
-      expect(help).to match(/puppet-#{appname}/)
-      %w{SYNOPSIS USAGE DESCRIPTION OPTIONS COPYRIGHT}.each do |heading|
-        expect(help).to match(/^#{heading}$/)
-      end
-    end
-
-    it 'fails when asked for an action on a legacy command' do
-      expect { subject.help(appname, :whatever) }.
-        to raise_error(ArgumentError, /The legacy subcommand '#{appname}' does not support supplying an action/)
-    end
-
-    context 'rendering has an error' do
-      it 'raises an ArgumentError if a legacy application raises a StandardError' do
-        allow_any_instance_of(Puppet::Application[appname].class).to receive(:help).and_raise(StandardError, 'whoops')
-
-        expect {
-          subject.help(appname)
-        }.to raise_error(ArgumentError, /Detail: "whoops"/)
-      end
-
-      it 'raises an ArgumentError if a legacy application raises a LoadError' do
-        allow_any_instance_of(Puppet::Application[appname].class).to receive(:help).and_raise(LoadError, 'cannot load such file -- yard')
-
-        expect {
-          subject.help(appname)
-        }.to raise_error(ArgumentError, /Detail: "cannot load such file -- yard"/)
-      end
-    end
-  end
-end

data/spec/unit/face/module/install_spec.rb

@@ -1,40 +0,0 @@
-require 'spec_helper'
-require 'puppet/face'
-require 'puppet/module_tool'
-
-describe "puppet module install" do
-  include PuppetSpec::Files
-
-  describe "action" do
-    let(:name)        { double(:name) }
-    let(:target_dir)  { tmpdir('module install face action') }
-    let(:options)     { { :target_dir => target_dir } }
-
-    it 'should invoke the Installer app' do
-      expect(Puppet::ModuleTool).to receive(:set_option_defaults).with(options)
-      expect(Puppet::ModuleTool::Applications::Installer).to receive(:run) do |mod, target, opts|
-        expect(mod).to eql(name)
-        expect(opts).to eql(options)
-        expect(target).to be_a(Puppet::ModuleTool::InstallDirectory)
-        expect(target.target).to eql(Pathname.new(target_dir))
-      end
-
-      Puppet::Face[:module, :current].install(name, options)
-    end
-  end
-
-  describe "inline documentation" do
-    subject { Puppet::Face.find_action(:module, :install) }
-
-    its(:summary)     { should =~ /install.*module/im }
-    its(:description) { should =~ /install.*module/im }
-    its(:returns)     { should =~ /pathname/i }
-    its(:examples)    { should_not be_empty }
-
-    %w{ license copyright summary description returns examples }.each do |doc|
-      context "of the" do
-        its(doc.to_sym) { should_not =~ /(FIXME|REVISIT|TODO)/ }
-      end
-    end
-  end
-end