puppet 4.0.0 → 4.9.1

data/spec/unit/face/epp_face_spec.rb

@@ -102,9 +102,6 @@ describe Puppet::Face[:epp, :current] do
     end
   end
 
-  context "render" do
-
-  end
 
   context "dump" do
     it "prints the AST of a template given with the -e option" do
@@ -150,7 +147,7 @@ describe Puppet::Face[:epp, :current] do
       dir = dir_containing('templates', { template_name => "<% 1 2 3 %>" })
       template = File.join(dir, template_name)
       expect(eppface.dump(template, :validate => true)).to eq("")
-      expect(@logs.join).to match(/This Literal Integer has no effect.* line 1:4/)
+      expect(@logs.join).to match(/This Literal Integer has no effect.*\/template1.epp:1:4/)
     end
 
     it "validated content by default" do
@@ -158,7 +155,7 @@ describe Puppet::Face[:epp, :current] do
       dir = dir_containing('templates', { template_name => "<% 1 2 3 %>" })
       template = File.join(dir, template_name)
       expect(eppface.dump(template)).to eq("")
-      expect(@logs.join).to match(/This Literal Integer has no effect.* line 1:4/)
+      expect(@logs.join).to match(/This Literal Integer has no effect.*\/template1.epp:1:4/)
     end
 
     it "informs the user of files that don't exist" do
@@ -232,6 +229,28 @@ describe Puppet::Face[:epp, :current] do
         ).to eq("goodbye mr Y")
     end
 
+    it "sets $facts" do
+      expect(eppface.render({ :e => 'facts is hash: <%= $facts =~ Hash %>' })).to eql("facts is hash: true")
+    end
+
+    it "sets $trusted" do
+      expect(eppface.render({ :e => 'trusted is hash: <%= $trusted =~ Hash %>' })).to eql("trusted is hash: true")
+    end
+
+    it "facts can be added to" do
+      expect(eppface.render({
+        :facts => {'the_crux' => 'biscuit'},
+        :e     => '<%= $facts[the_crux] %>', 
+      })).to eql("biscuit")
+    end
+
+    it "facts can be overridden" do
+      expect(eppface.render({
+        :facts => {'operatingsystem' => 'Merwin'},
+        :e     => '<%= $facts[operatingsystem] %>', 
+      })).to eql("Merwin")
+    end
+
     context "in an environment with templates" do
       let(:dir) do
         dir_containing('environments', { 'production' => { 'modules' => {

data/spec/unit/face/file_spec.rb

@@ -7,4 +7,8 @@ describe Puppet::Face[:file, '0.0.1'] do
     it { is_expected.to be_action action }
     it { is_expected.to respond_to action }
   end
+
+  it "should be deprecated" do
+    expect(subject.deprecated?).to be_truthy
+  end
 end

data/spec/unit/face/generate_spec.rb

@@ -0,0 +1,230 @@
+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
+        Puppet::Generate::Type.expects(:find_inputs).with(:pcore).returns([])
+        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)
+        Puppet::Generate::Type::Input.expects(:new).with(m1, File.join(m1, 'lib', 'puppet', 'type', 'test1.rb'), :pcore).returns(input1)
+        Puppet::Generate::Type::Input.expects(:new).with(m2, File.join(m2, 'lib', 'puppet', 'type', 'test2.rb'), :pcore).returns(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
+  end
+
+  def from_an_interactive_terminal
+    STDIN.stubs(:tty?).returns(true)
+  end
+
+end

data/spec/unit/face/help_spec.rb

@@ -48,6 +48,24 @@ describe Puppet::Face[:help, '0.0.1'] do
       to eq(subject.help(:huzzah, :version => :current))
   end
 
+  it "raises an ArgumentError if the face raises a StandardError" do
+    face = Puppet::Face[:module, :current]
+    face.stubs(:short_description).raises(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]
+    face.stubs(:short_description).raises(LoadError, "cannot load such file -- yard")
+
+    expect {
+      subject.help(:module)
+    }.to raise_error(ArgumentError, /Detail: "cannot load such file -- yard"/)
+  end
+
   context "when listing subcommands" do
     subject { Puppet::Face[:help, :current].help }
 
@@ -84,6 +102,18 @@ describe Puppet::Face[:help, '0.0.1'] do
       end
     end
 
+    it "returns an 'unavailable' summary if the 'agent' application fails to generate help" do
+      Puppet::Application['agent'].class.any_instance.stubs(:help).raises(ArgumentError, "whoops")
+
+      expect(subject).to match(/agent\s+! Subcommand unavailable due to error\. Check error logs\./)
+    end
+
+    it "returns an 'unavailable' summary if the legacy application raises a LoadError" do
+      Puppet::Application['agent'].class.any_instance.stubs(:help).raises(LoadError, "cannot load such file -- yard")
+
+      expect(subject).to match(/agent\s+! Subcommand unavailable due to error\. Check error logs\./)
+    end
+
     context "face summaries" do
       it "can generate face summaries" do
         faces = Puppet::Face.faces
@@ -92,6 +122,13 @@ describe Puppet::Face[:help, '0.0.1'] do
           expect(Puppet::Face[name, :current]).to have_a_summary
         end
       end
+
+      it "returns an 'unavailable' summary if the face application raises a LoadError" do
+        face = Puppet::Face[:module, :current]
+        face.stubs(:summary).raises(LoadError, "cannot load such file -- yard")
+
+        expect(Puppet::Face[:help, :current].help).to match(/module\s+! Subcommand unavailable due to error\. Check error logs\./)
+      end
     end
 
     it "lists all legacy applications" do
@@ -104,6 +141,23 @@ describe Puppet::Face[:help, '0.0.1'] do
     end
   end
 
+  context "deprecated faces" do
+    it "prints a deprecation warning for deprecated faces" do
+      Puppet::Face[:module, :current].stubs(:deprecated?).returns(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
+      Puppet::Face[:module, :current].expects(:deprecated?).returns(true)
+      result = 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 }
 
@@ -141,5 +195,21 @@ describe Puppet::Face[:help, '0.0.1'] do
       expect { subject.help(appname, :whatever) }.
         to raise_error ArgumentError, /Legacy subcommands don't take actions/
     end
+
+    it "raises an ArgumentError if a legacy application raises a StandardError" do
+      Puppet::Application[appname].class.any_instance.stubs(:help).raises(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
+      Puppet::Application[appname].class.any_instance.stubs(:help).raises(LoadError, "cannot load such file -- yard")
+
+      expect {
+        subject.help(appname)
+      }.to raise_error ArgumentError, /Detail: "cannot load such file -- yard"/
+    end
   end
 end

data/spec/unit/face/key_spec.rb

@@ -0,0 +1,10 @@
+#! /usr/bin/env ruby
+require 'spec_helper'
+require 'puppet/face'
+
+describe Puppet::Face[:key, '0.0.1'] do
+  it "should be deprecated" do
+    expect(subject.deprecated?).to be_truthy
+  end
+end
+

data/spec/unit/face/node_spec.rb

@@ -47,7 +47,7 @@ describe Puppet::Face[:node, '0.0.1'] do
     end
 
     it "should not accept a call with no arguments" do
-      expect { subject.clean() }.to raise_error
+      expect { subject.clean() }.to raise_error(RuntimeError, /At least one node should be passed/)
     end
 
     it "should accept a node name" do

data/spec/unit/face/parser_spec.rb

@@ -14,6 +14,12 @@ describe Puppet::Face[:parser, :current] do
         from_an_interactive_terminal
       end
 
+      after(:each) do
+        # Reset cache of loaders (many examples run in the *root* environment
+        # which exists in "eternity")
+        Puppet.lookup(:current_environment).loaders = nil
+      end
+
       it "validates the configured site manifest when no files are given" do
         manifest = file_containing('site.pp', "{ invalid =>")
 
@@ -30,9 +36,25 @@ describe Puppet::Face[:parser, :current] do
       end
 
       it "runs error free when there are no validation errors" do
-        manifest = file_containing('site.pp', "notify { valid: }")
+        expect {
+            manifest = file_containing('site.pp', "notify { valid: }")
+            parser.validate(manifest)
+        }.to_not raise_error
+      end
 
-        parser.validate(manifest)
+      it "runs error free when there is a puppet function in manifest being validated" do
+        expect {
+          manifest = file_containing('site.pp', "function valid() { 'valid' } notify{ valid(): }")
+          parser.validate(manifest)
+        }.to_not raise_error
+      end
+
+      it "runs error free when there is a type alias in a manifest that requires type resolution" do
+        expect {
+          manifest = file_containing('site.pp',
+            "type A = String; type B = Array[A]; function valid(B $x) { $x } notify{ valid([valid]): }")
+          parser.validate(manifest)
+        }.to_not raise_error
       end
 
       it "reports missing files" do
@@ -98,6 +120,31 @@ describe Puppet::Face[:parser, :current] do
       expect(@logs[0].message).to eq("Syntax error at end of file")
       expect(@logs[0].level).to eq(:err)
     end
+
+    it "logs an error if the input begins with a UTF-8 BOM (Byte Order Mark)" do
+      utf8_bom_manifest = file_containing('utf8_bom.pp', "\uFEFFnotice hi")
+
+      output = parser.dump(utf8_bom_manifest)
+
+      expect(output).to eq("")
+      expect(@logs[1].message).to eq("Illegal UTF-8 Byte Order mark at beginning of input: [EF BB BF] - remove these from the puppet source")
+      expect(@logs[1].level).to eq(:err)
+    end
+
+    it "runs error free when there is a puppet function in manifest being dumped" do
+      expect {
+        manifest = file_containing('site.pp', "function valid() { 'valid' } notify{ valid(): }")
+        parser.dump(manifest)
+      }.to_not raise_error
+    end
+
+    it "runs error free when there is a type alias in a manifest that requires type resolution" do
+      expect {
+        manifest = file_containing('site.pp',
+          "type A = String; type B = Array[A]; function valid(B $x) { $x } notify{ valid([valid]): }")
+        parser.dump(manifest)
+      }.to_not raise_error
+    end
   end
 
   def from_an_interactive_terminal

data/spec/unit/face/plugin_spec.rb

@@ -2,9 +2,34 @@
 require 'spec_helper'
 require 'puppet/face'
 
-describe Puppet::Face[:plugin, '0.0.1'] do
-  [:download].each do |action|
-    it { is_expected.to be_action action }
-    it { is_expected.to respond_to action }
+describe Puppet::Face[:plugin, :current] do
+
+  let(:pluginface) { described_class }
+  let(:action) { pluginface.get_action(:download) }
+
+  def render(result)
+    action.when_rendering(:console).call(result)
+  end
+
+  context "download" do
+    it "downloads plugins and external facts" do
+      Puppet::Configurer::Downloader.any_instance.expects(:evaluate).twice.returns([])
+
+      pluginface.download
+    end
+
+    it "renders 'No plugins downloaded' if nothing was downloaded" do
+      Puppet::Configurer::Downloader.any_instance.expects(:evaluate).twice.returns([])
+
+      result = pluginface.download
+      expect(render(result)).to eq('No plugins downloaded.')
+    end
+
+    it "renders comma separate list of downloaded file names" do
+      Puppet::Configurer::Downloader.any_instance.expects(:evaluate).twice.returns(%w[/a]).then.returns(%w[/b])
+
+      result = pluginface.download
+      expect(render(result)).to eq('Downloaded these plugins: /a, /b')
+    end
   end
 end

data/spec/unit/face/status_spec.rb

@@ -0,0 +1,10 @@
+#! /usr/bin/env ruby
+require 'spec_helper'
+require 'puppet/face'
+
+describe Puppet::Face[:status, '0.0.1'] do
+  it "should be deprecated" do
+    expect(subject.deprecated?).to be_truthy
+  end
+end
+