puppet 7.28.0-x64-mingw32 → 7.29.0-x64-mingw32

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

@@ -1,256 +0,0 @@
-# encoding: UTF-8
-
-require 'spec_helper'
-require 'puppet/face'
-require 'puppet/module_tool'
-require 'puppet_spec/modules'
-
-describe "puppet module list" do
-  include PuppetSpec::Files
-
-  around do |example|
-    dir = tmpdir("deep_path")
-
-    FileUtils.mkdir_p(@modpath1 = File.join(dir, "modpath1"))
-    FileUtils.mkdir_p(@modpath2 = File.join(dir, "modpath2"))
-    FileUtils.mkdir_p(@modpath3 = File.join(dir, "modpath3"))
-
-    env = Puppet::Node::Environment.create(:env, [@modpath1, @modpath2])
-    Puppet.override(:current_environment => env) do
-      example.run
-    end
-  end
-
-  it "should return an empty list per dir in path if there are no modules" do
-    expect(Puppet::Face[:module, :current].list[:modules_by_path]).to eq({
-      @modpath1 => [],
-      @modpath2 => []
-    })
-  end
-
-  it "should include modules separated by the environment's modulepath" do
-    foomod1 = PuppetSpec::Modules.create('foo', @modpath1)
-    barmod1 = PuppetSpec::Modules.create('bar', @modpath1)
-    foomod2 = PuppetSpec::Modules.create('foo', @modpath2)
-
-    usedenv = Puppet::Node::Environment.create(:useme, [@modpath1, @modpath2, @modpath3])
-
-    Puppet.override(:environments => Puppet::Environments::Static.new(usedenv)) do
-      expect(Puppet::Face[:module, :current].list(:environment => 'useme')[:modules_by_path]).to eq({
-        @modpath1 => [
-          Puppet::Module.new('bar', barmod1.path, usedenv),
-          Puppet::Module.new('foo', foomod1.path, usedenv)
-        ],
-        @modpath2 => [Puppet::Module.new('foo', foomod2.path, usedenv)],
-        @modpath3 => [],
-      })
-    end
-  end
-
-  it "should use the specified environment" do
-    foomod = PuppetSpec::Modules.create('foo', @modpath1)
-    barmod = PuppetSpec::Modules.create('bar', @modpath1)
-
-    usedenv = Puppet::Node::Environment.create(:useme, [@modpath1, @modpath2, @modpath3])
-
-    Puppet.override(:environments => Puppet::Environments::Static.new(usedenv)) do
-      expect(Puppet::Face[:module, :current].list(:environment => 'useme')[:modules_by_path]).to eq({
-        @modpath1 => [
-          Puppet::Module.new('bar', barmod.path, usedenv),
-          Puppet::Module.new('foo', foomod.path, usedenv)
-        ],
-        @modpath2 => [],
-        @modpath3 => [],
-      })
-    end
-  end
-
-  it "should use the specified modulepath" do
-    foomod = PuppetSpec::Modules.create('foo', @modpath1)
-    barmod = PuppetSpec::Modules.create('bar', @modpath2)
-
-    modules = Puppet::Face[:module, :current].list(:modulepath => "#{@modpath1}#{File::PATH_SEPARATOR}#{@modpath2}")[:modules_by_path]
-
-    expect(modules[@modpath1].first.name).to eq('foo')
-    expect(modules[@modpath1].first.path).to eq(foomod.path)
-    expect(modules[@modpath1].first.environment.modulepath).to eq([@modpath1, @modpath2])
-
-    expect(modules[@modpath2].first.name).to eq('bar')
-    expect(modules[@modpath2].first.path).to eq(barmod.path)
-    expect(modules[@modpath2].first.environment.modulepath).to eq([@modpath1, @modpath2])
-  end
-
-  it "prefers a given modulepath over the modulepath from the given environment" do
-    foomod = PuppetSpec::Modules.create('foo', @modpath1)
-    barmod = PuppetSpec::Modules.create('bar', @modpath2)
-
-    modules = Puppet::Face[:module, :current].list(:environment => 'myenv', :modulepath => "#{@modpath1}#{File::PATH_SEPARATOR}#{@modpath2}")[:modules_by_path]
-
-    expect(modules[@modpath1].first.name).to eq('foo')
-    expect(modules[@modpath1].first.path).to eq(foomod.path)
-    expect(modules[@modpath1].first.environment.modulepath).to eq([@modpath1, @modpath2])
-    expect(modules[@modpath1].first.environment.name).to_not eq(:myenv)
-
-    expect(modules[@modpath2].first.name).to eq('bar')
-    expect(modules[@modpath2].first.path).to eq(barmod.path)
-    expect(modules[@modpath2].first.environment.modulepath).to eq([@modpath1, @modpath2])
-    expect(modules[@modpath2].first.environment.name).to_not eq(:myenv)
-  end
-
-  describe "inline documentation" do
-    subject { Puppet::Face[:module, :current].get_action(:list) }
-
-    its(:summary)     { should =~ /list.*module/im }
-    its(:description) { should =~ /list.*module/im }
-    its(:returns)     { should =~ /hash of paths to module objects/i }
-    its(:examples)    { should_not be_empty }
-  end
-
-  describe "when rendering to console" do
-    let(:face) { Puppet::Face[:module, :current] }
-    let(:action) { face.get_action(:list) }
-
-    def console_output(options={})
-      result = face.list(options)
-      action.when_rendering(:console).call(result, options)
-    end
-
-    it "should explicitly state when a modulepath is empty" do
-      empty_modpath = tmpdir('empty')
-
-      expected = <<-HEREDOC.gsub('        ', '')
-        #{empty_modpath} (no modules installed)
-      HEREDOC
-
-      expect(console_output(:modulepath => empty_modpath)).to eq(expected)
-    end
-
-    it "should print both modules with and without metadata" do
-      modpath = tmpdir('modpath')
-
-      PuppetSpec::Modules.create('nometadata', modpath)
-      PuppetSpec::Modules.create('metadata', modpath, :metadata => {:author => 'metaman'})
-
-      env = Puppet::Node::Environment.create(:environ, [modpath])
-      Puppet.override(:current_environment => env) do
-        expected = <<-HEREDOC.gsub('          ', '')
-          #{modpath}
-          ├── metaman-metadata (\e[0;36mv9.9.9\e[0m)
-          └── nometadata (\e[0;36m???\e[0m)
-        HEREDOC
-
-        expect(console_output).to eq(expected)
-      end
-    end
-
-    it "should print the modulepaths in the order they are in the modulepath setting" do
-      path1 = tmpdir('b')
-      path2 = tmpdir('c')
-      path3 = tmpdir('a')
-
-      env = Puppet::Node::Environment.create(:environ, [path1, path2, path3])
-      Puppet.override(:current_environment => env) do
-        expected = <<-HEREDOC.gsub('          ', '')
-          #{path1} (no modules installed)
-          #{path2} (no modules installed)
-          #{path3} (no modules installed)
-        HEREDOC
-
-        expect(console_output).to eq(expected)
-      end
-    end
-
-    it "should print dependencies as a tree" do
-      PuppetSpec::Modules.create('dependable', @modpath1, :metadata => { :version => '0.0.5'})
-      PuppetSpec::Modules.create(
-        'other_mod',
-        @modpath1,
-        :metadata => {
-          :version => '1.0.0',
-          :dependencies => [{
-            "version_requirement" => ">= 0.0.5",
-            "name"                => "puppetlabs/dependable"
-          }]
-        }
-      )
-
-      expected = <<-HEREDOC.gsub('        ', '')
-        #{@modpath1}
-        └─┬ puppetlabs-other_mod (\e[0;36mv1.0.0\e[0m)
-          └── puppetlabs-dependable (\e[0;36mv0.0.5\e[0m)
-        #{@modpath2} (no modules installed)
-      HEREDOC
-
-      expect(console_output(:tree => true)).to eq(expected)
-    end
-
-    it "should print both modules with and without metadata as a tree" do
-      PuppetSpec::Modules.create('nometadata', @modpath1)
-      PuppetSpec::Modules.create('metadata', @modpath1, :metadata => {:author => 'metaman'})
-
-      expected = <<-HEREDOC.gsub('        ', '')
-        #{@modpath1}
-        ├── metaman-metadata (\e[0;36mv9.9.9\e[0m)
-        └── nometadata (\e[0;36m???\e[0m)
-        #{@modpath2} (no modules installed)
-      HEREDOC
-
-      expect(console_output).to eq(expected)
-    end
-
-    it "should warn about missing dependencies" do
-      PuppetSpec::Modules.create('depender', @modpath1, :metadata => {
-        :version => '1.0.0',
-        :dependencies => [{
-          "version_requirement" => ">= 0.0.5",
-          "name"                => "puppetlabs/dependable"
-        }]
-      })
-
-      expect(Puppet).to receive(:warning).with(match(/Missing dependency 'puppetlabs-dependable'/).and match(/'puppetlabs-depender' \(v1\.0\.0\) requires 'puppetlabs-dependable' \(>= 0\.0\.5\)/))
-
-      console_output(:tree => true)
-    end
-
-    it "should warn about out of range dependencies" do
-      PuppetSpec::Modules.create('dependable', @modpath1, :metadata => { :version => '0.0.1'})
-      PuppetSpec::Modules.create('depender', @modpath1, :metadata => {
-        :version => '1.0.0',
-        :dependencies => [{
-          "version_requirement" => ">= 0.0.5",
-          "name"                => "puppetlabs/dependable"
-        }]
-      })
-
-      expect(Puppet).to receive(:warning).with(match(/Module 'puppetlabs-dependable' \(v0\.0\.1\) fails to meet some dependencies/).and match(/'puppetlabs-depender' \(v1\.0\.0\) requires 'puppetlabs-dependable' \(>= 0\.0\.5\)/))
-
-      console_output(:tree => true)
-    end
-  end
-
-  describe "when rendering as json" do
-    let(:face) { Puppet::Face[:module, :current] }
-    let(:action) { face.get_action(:list) }
-
-    it "should warn about missing dependencies" do
-      PuppetSpec::Modules.create('depender', @modpath1, :metadata => {
-        :version => '1.0.0',
-        :dependencies => [{
-          "version_requirement" => ">= 0.0.5",
-          "name"                => "puppetlabs/dependable"
-        }]
-      })
-
-      result = face.list
-      expect(result.dig(:unmet_dependencies, :missing)).to include(
-        "puppetlabs/dependable" => {
-          errors: ["'puppetlabs-depender' (v1.0.0) requires 'puppetlabs-dependable' (>= 0.0.5)"],
-          parent: {
-            name: "puppetlabs/depender", :version=>"v1.0.0"
-          },
-          version: nil
-        }
-      )
-    end
-  end
-end

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

@@ -1,45 +0,0 @@
-require 'spec_helper'
-require 'puppet/face'
-require 'puppet/module_tool'
-
-describe "puppet module uninstall" do
-  include PuppetSpec::Files
-
-  describe "action" do
-    let(:name)    { 'module-name' }
-    let(:options) { Hash.new }
-
-    it 'should invoke the Uninstaller app' do
-      expect(Puppet::ModuleTool).to receive(:set_option_defaults).with(options)
-      expect(Puppet::ModuleTool::Applications::Uninstaller).to receive(:run).with(name, options)
-
-      Puppet::Face[:module, :current].uninstall(name, options)
-    end
-
-    context 'slash-separated module name' do
-      let(:name) { 'module/name' }
-
-      it 'should invoke the Uninstaller app' do
-        expect(Puppet::ModuleTool).to receive(:set_option_defaults).with(options)
-        expect(Puppet::ModuleTool::Applications::Uninstaller).to receive(:run).with('module-name', options)
-
-        Puppet::Face[:module, :current].uninstall(name, options)
-      end
-    end
-  end
-
-  describe "inline documentation" do
-    subject { Puppet::Face.find_action(:module, :uninstall) }
-
-    its(:summary)     { should =~ /uninstall.*module/im }
-    its(:description) { should =~ /uninstall.*module/im }
-    its(:returns)     { should =~ /uninstalled modules/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

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

@@ -1,26 +0,0 @@
-require 'spec_helper'
-require 'puppet/face'
-require 'puppet/module_tool'
-
-describe "puppet module upgrade" do
-  subject { Puppet::Face[:module, :current] }
-
-  let(:options) do
-    {}
-  end
-
-  describe "inline documentation" do
-    subject { Puppet::Face[:module, :current].get_action :upgrade }
-
-    its(:summary)     { should =~ /upgrade.*module/im }
-    its(:description) { should =~ /upgrade.*module/im }
-    its(:returns)     { should =~ /hash/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

data/spec/unit/face/node_spec.rb

@@ -1,129 +0,0 @@
-require 'spec_helper'
-require 'puppet/face'
-
-describe Puppet::Face[:node, '0.0.1'] do
-  describe '#cleanup' do
-    it "should clean everything" do
-      {
-        "cert"         => ['hostname'],
-        "cached_facts" => ['hostname'],
-        "cached_node"  => ['hostname'],
-        "reports"      => ['hostname'],
-      }.each { |k, v| expect(subject).to receive("clean_#{k}".to_sym).with(*v) }
-      subject.cleanup('hostname')
-    end
-  end
-
-  describe 'when running #clean' do
-    it 'should invoke #cleanup' do
-      expect(subject).to receive(:cleanup).with('hostname')
-      subject.clean('hostname')
-    end
-  end
-
-  describe "clean action" do
-    before :each do
-      allow(subject).to receive(:cleanup)
-    end
-
-    it "should have a clean action" do
-      expect(subject).to be_action :clean
-    end
-
-    it "should not accept a call with no arguments" do
-      expect { subject.clean() }.to raise_error(RuntimeError, /At least one node should be passed/)
-    end
-
-    it "should accept a node name" do
-      expect { subject.clean('hostname') }.to_not raise_error
-    end
-
-    it "should accept more than one node name" do
-      expect do
-        subject.clean('hostname', 'hostname2', {})
-      end.to_not raise_error
-
-      expect do
-        subject.clean('hostname', 'hostname2', 'hostname3')
-      end.to_not raise_error
-    end
-
-    context "clean action" do
-      subject { Puppet::Face[:node, :current] }
-      before :each do
-        allow(Puppet::Util::Log).to receive(:newdestination)
-        allow(Puppet::Util::Log).to receive(:level=)
-      end
-
-      describe "during setup" do
-        it "should set facts terminus and cache class to yaml" do
-          expect(Puppet::Node::Facts.indirection).to receive(:terminus_class=).with(:yaml)
-          expect(Puppet::Node::Facts.indirection).to receive(:cache_class=).with(:yaml)
-
-          subject.clean('hostname')
-        end
-
-        it "should run in server mode" do
-          subject.clean('hostname')
-          expect(Puppet.run_mode).to be_server
-        end
-
-        it "should set node cache as yaml" do
-          expect(Puppet::Node.indirection).to receive(:terminus_class=).with(:yaml)
-          expect(Puppet::Node.indirection).to receive(:cache_class=).with(:yaml)
-
-          subject.clean('hostname')
-        end
-      end
-
-      describe "when cleaning certificate", :if => Puppet.features.puppetserver_ca? do
-        it "should call the CA CLI gem's clean action" do
-          expect_any_instance_of(Puppetserver::Ca::Action::Clean).
-            to receive(:clean_certs).
-            with(['hostname'], anything).
-            and_return(:success)
-
-          if Puppet[:cadir].start_with?(Puppet[:ssldir])
-            expect_any_instance_of(LoggerIO).
-              to receive(:warn).
-              with(/cadir is currently configured to be inside/)
-          end
-
-          expect(Puppet).not_to receive(:warning)
-          result = subject.clean_cert('hostname')
-          expect(result).to eq(0)
-        end
-
-        it "should not call the CA CLI gem's clean action if the gem is missing" do
-          expect(Puppet.features).to receive(:puppetserver_ca?).and_return(false)
-          expect_any_instance_of(Puppetserver::Ca::Action::Clean).not_to receive(:run)
-          subject.clean_cert("hostname")
-        end
-      end
-
-      describe "when cleaning cached facts" do
-        it "should destroy facts" do
-          @host = 'node'
-          expect(Puppet::Node::Facts.indirection).to receive(:destroy).with(@host)
-
-          subject.clean_cached_facts(@host)
-        end
-      end
-
-      describe "when cleaning cached node" do
-        it "should destroy the cached node" do
-          expect(Puppet::Node.indirection).to receive(:destroy).with(@host)
-          subject.clean_cached_node(@host)
-        end
-      end
-
-      describe "when cleaning archived reports" do
-        it "should tell the reports to remove themselves" do
-          allow(Puppet::Transaction::Report.indirection).to receive(:destroy).with(@host)
-
-          subject.clean_reports(@host)
-        end
-      end
-    end
-  end
-end