puppet 3.7.0-x64-mingw32

data/spec/unit/face/catalog_spec.rb

@@ -0,0 +1,7 @@
+#! /usr/bin/env ruby
+require 'spec_helper'
+require 'puppet/face'
+
+describe Puppet::Face[:catalog, '0.0.1'] do
+  it "should actually have some testing..."
+end

data/spec/unit/face/certificate_spec.rb

@@ -0,0 +1,223 @@
+#! /usr/bin/env ruby
+require 'spec_helper'
+require 'puppet/face'
+
+require 'puppet/ssl/host'
+
+describe Puppet::Face[:certificate, '0.0.1'] do
+  include PuppetSpec::Files
+
+  let(:ca) { Puppet::SSL::CertificateAuthority.instance }
+
+  before :each do
+    Puppet[:confdir] = tmpdir('conf')
+    Puppet::SSL::CertificateAuthority.stubs(:ca?).returns true
+
+    Puppet::SSL::Host.ca_location = :local
+
+    # We can't cache the CA between tests, because each one has its own SSL dir.
+    ca = Puppet::SSL::CertificateAuthority.new
+    Puppet::SSL::CertificateAuthority.stubs(:new).returns ca
+    Puppet::SSL::CertificateAuthority.stubs(:instance).returns ca
+  end
+
+  it "should have a ca-location option" do
+    subject.should be_option :ca_location
+  end
+
+  it "should set the ca location when invoked" do
+    Puppet::SSL::Host.expects(:ca_location=).with(:local)
+    ca.expects(:sign).with do |name,options|
+      name == "hello, friend"
+    end
+
+    subject.sign "hello, friend", :ca_location => :local
+  end
+
+  it "(#7059) should set the ca location when an inherited action is invoked" do
+    Puppet::SSL::Host.expects(:ca_location=).with(:local)
+    subject.indirection.expects(:find)
+    subject.find "hello, friend", :ca_location => :local
+  end
+
+  it "should validate the option as required" do
+    expect do
+      subject.find 'hello, friend'
+    end.to raise_exception ArgumentError, /required/i
+  end
+
+  it "should validate the option as a supported value" do
+    expect do
+      subject.find 'hello, friend', :ca_location => :foo
+    end.to raise_exception ArgumentError, /valid values/i
+  end
+
+  describe "#generate" do
+    let(:options) { {:ca_location => 'local'} }
+    let(:host) { Puppet::SSL::Host.new(hostname) }
+    let(:csr) { host.certificate_request }
+
+    before :each do
+      Puppet[:autosign] = false
+    end
+
+    describe "for the current host" do
+      let(:hostname) { Puppet[:certname] }
+
+      it "should generate a CSR for this host" do
+        subject.generate(hostname, options)
+
+        csr.content.subject.to_s.should == "/CN=#{Puppet[:certname]}"
+        csr.name.should == Puppet[:certname]
+      end
+
+      it "should add dns_alt_names from the global config if not otherwise specified" do
+        Puppet[:dns_alt_names] = 'from,the,config'
+
+        subject.generate(hostname, options)
+
+        expected = %W[DNS:from DNS:the DNS:config DNS:#{hostname}]
+
+        csr.subject_alt_names.should =~ expected
+      end
+
+      it "should add the provided dns_alt_names if they are specified" do
+        Puppet[:dns_alt_names] = 'from,the,config'
+
+        subject.generate(hostname, options.merge(:dns_alt_names => 'explicit,alt,names'))
+
+        expected = %W[DNS:explicit DNS:alt DNS:names DNS:#{hostname}]
+
+        csr.subject_alt_names.should =~ expected
+      end
+    end
+
+    describe "for another host" do
+      let(:hostname) { Puppet[:certname] + 'different' }
+
+      it "should generate a CSR for the specified host" do
+        subject.generate(hostname, options)
+
+        csr.content.subject.to_s.should == "/CN=#{hostname}"
+        csr.name.should == hostname
+      end
+
+      it "should fail if a CSR already exists for the host" do
+        subject.generate(hostname, options)
+
+        expect do
+          subject.generate(hostname, options)
+        end.to raise_error(RuntimeError, /#{hostname} already has a requested certificate; ignoring certificate request/)
+      end
+
+      it "should add not dns_alt_names from the config file" do
+        Puppet[:dns_alt_names] = 'from,the,config'
+
+        subject.generate(hostname, options)
+
+        csr.subject_alt_names.should be_empty
+      end
+
+      it "should add the provided dns_alt_names if they are specified" do
+        Puppet[:dns_alt_names] = 'from,the,config'
+
+        subject.generate(hostname, options.merge(:dns_alt_names => 'explicit,alt,names'))
+
+        expected = %W[DNS:explicit DNS:alt DNS:names DNS:#{hostname}]
+
+        csr.subject_alt_names.should =~ expected
+      end
+      
+      it "should use the global setting if set by CLI" do
+        Puppet.settings.set_value(:dns_alt_names, 'from,the,cli', :cli)
+        
+        subject.generate(hostname, options)
+        
+        expected = %W[DNS:from DNS:the DNS:cli DNS:#{hostname}]
+        
+        csr.subject_alt_names.should =~ expected
+      end
+      
+      it "should generate an error if both set on CLI" do
+        Puppet.settings.set_value(:dns_alt_names, 'from,the,cli', :cli)
+        expect do
+          subject.generate(hostname, options.merge(:dns_alt_names => 'explicit,alt,names'))
+        end.to raise_error ArgumentError, /Can't specify both/ 
+      end
+    end
+  end
+
+  describe "#sign" do
+    let(:options) { {:ca_location => 'local'} }
+    let(:host) { Puppet::SSL::Host.new(hostname) }
+    let(:hostname) { "foobar" }
+
+    it "should sign the certificate request if one is waiting", :unless => Puppet.features.microsoft_windows? do
+      subject.generate(hostname, options)
+
+      subject.sign(hostname, options)
+
+      host.certificate_request.should be_nil
+      host.certificate.should be_a(Puppet::SSL::Certificate)
+      host.state.should == 'signed'
+    end
+
+    it "should fail if there is no waiting certificate request" do
+      expect do
+        subject.sign(hostname, options)
+      end.to raise_error(ArgumentError, /Could not find certificate request for #{hostname}/)
+    end
+
+    describe "when ca_location is local", :unless => Puppet.features.microsoft_windows? do
+      describe "when the request has dns alt names" do
+        before :each do
+          subject.generate(hostname, options.merge(:dns_alt_names => 'some,alt,names'))
+        end
+
+        it "should refuse to sign the request if allow_dns_alt_names is not set" do
+          expect do
+            subject.sign(hostname, options)
+          end.to raise_error(Puppet::SSL::CertificateAuthority::CertificateSigningError,
+                             /CSR '#{hostname}' contains subject alternative names \(.*?\), which are disallowed. Use `puppet cert --allow-dns-alt-names sign #{hostname}` to sign this request./i)
+
+          host.state.should == 'requested'
+        end
+
+        it "should sign the request if allow_dns_alt_names is set" do
+          expect do
+            subject.sign(hostname, options.merge(:allow_dns_alt_names => true))
+          end.not_to raise_error
+
+          host.state.should == 'signed'
+        end
+      end
+
+      describe "when the request has no dns alt names" do
+        before :each do
+          subject.generate(hostname, options)
+        end
+
+        it "should sign the request if allow_dns_alt_names is set" do
+          expect { subject.sign(hostname, options.merge(:allow_dns_alt_names => true)) }.not_to raise_error
+
+          host.state.should == 'signed'
+        end
+
+        it "should sign the request if allow_dns_alt_names is not set" do
+          expect { subject.sign(hostname, options) }.not_to raise_error
+
+          host.state.should == 'signed'
+        end
+      end
+    end
+
+    describe "when ca_location is remote" do
+      let(:options) { {:ca_location => :remote} }
+      it "should fail if allow-dns-alt-names is specified" do
+        expect do
+          subject.sign(hostname, options.merge(:allow_dns_alt_names => true))
+        end
+      end
+    end
+  end
+end

data/spec/unit/face/config_spec.rb

@@ -0,0 +1,147 @@
+#! /usr/bin/env ruby
+require 'spec_helper'
+require 'puppet/face'
+
+module PuppetFaceSpecs 
+describe Puppet::Face[:config, '0.0.1'] do
+
+  FS = Puppet::FileSystem
+
+  it "prints a single setting without the name" do
+    Puppet[:trace] = true
+
+    expect { subject.print("trace") }.to have_printed('true')
+  end
+
+  it "prints multiple settings with the names" do
+    Puppet[:trace] = true
+    Puppet[:syslogfacility] = "file"
+
+    expect { subject.print("trace", "syslogfacility") }.to have_printed(<<-OUTPUT)
+trace = true
+syslogfacility = file
+    OUTPUT
+  end
+
+  it "prints the setting from the selected section" do
+    Puppet.settings.parse_config(<<-CONF)
+    [other]
+    syslogfacility = file
+    CONF
+
+    expect { subject.print("syslogfacility", :section => "other") }.to have_printed('file')
+  end
+
+  it "defaults to all when no arguments are given" do
+    subject.expects(:puts).times(Puppet.settings.to_a.length)
+
+    subject.print
+  end
+
+  it "prints out all of the settings when asked for 'all'" do
+    subject.expects(:puts).times(Puppet.settings.to_a.length)
+
+    subject.print('all')
+  end
+
+  shared_examples_for :config_printing_a_section do |section|
+
+    def add_section_option(args, section)
+      args << { :section => section } if section
+      args
+    end
+
+    it "prints directory env settings for an env that exists" do
+      FS.overlay(
+        FS::MemoryFile.a_directory(File.expand_path("/dev/null/environments"), [
+          FS::MemoryFile.a_directory("production", [
+            FS::MemoryFile.a_missing_file("environment.conf"),
+          ]),
+        ])
+      ) do
+        args = "environmentpath","manifest","modulepath","environment","basemodulepath"
+        expect { subject.print(*add_section_option(args, section)) }.to have_printed(<<-OUTPUT)
+environmentpath = #{File.expand_path("/dev/null/environments")}
+manifest = #{File.expand_path("/dev/null/environments/production/manifests")}
+modulepath = #{File.expand_path("/dev/null/environments/production/modules")}#{File::PATH_SEPARATOR}#{File.expand_path("/some/base")}
+environment = production
+basemodulepath = #{File.expand_path("/some/base")}
+        OUTPUT
+      end
+    end
+
+    it "interpolates settings in environment.conf" do
+      FS.overlay(
+        FS::MemoryFile.a_directory(File.expand_path("/dev/null/environments"), [
+          FS::MemoryFile.a_directory("production", [
+            FS::MemoryFile.a_regular_file_containing("environment.conf", <<-CONTENT),
+            modulepath=/custom/modules#{File::PATH_SEPARATOR}$basemodulepath
+            CONTENT
+          ]),
+        ])
+      ) do
+        args = "environmentpath","manifest","modulepath","environment","basemodulepath"
+        expect { subject.print(*add_section_option(args, section)) }.to have_printed(<<-OUTPUT)
+environmentpath = #{File.expand_path("/dev/null/environments")}
+manifest = #{File.expand_path("/dev/null/environments/production/manifests")}
+modulepath = #{File.expand_path("/custom/modules")}#{File::PATH_SEPARATOR}#{File.expand_path("/some/base")}
+environment = production
+basemodulepath = #{File.expand_path("/some/base")}
+        OUTPUT
+      end
+    end
+
+    it "prints the default configured env settings for an env that does not exist" do
+      pending "This case no longer exists because Application will through an error before we even get here because of the non-existent environment"
+      Puppet[:environment] = 'doesnotexist'
+
+      FS.overlay(
+        FS::MemoryFile.a_directory(File.expand_path("/dev/null/environments"), [
+          FS::MemoryFile.a_missing_file("doesnotexist")
+        ])
+      ) do
+        args = "environmentpath","manifest","modulepath","environment","basemodulepath"
+        expect { subject.print(*add_section_option(args, section)) }.to have_printed(<<-OUTPUT)
+environmentpath = #{File.expand_path("/dev/null/environments")}
+manifest = no_manifest
+modulepath = 
+environment = doesnotexist
+basemodulepath = #{File.expand_path("/some/base")}
+        OUTPUT
+      end
+    end
+  end
+
+  context "when printing environment settings" do
+    before(:each) do
+      Puppet.settings.stubs(:global_defaults_initialized?).returns(:true)
+    end
+
+    context "from main section" do
+      before(:each) do
+        Puppet.settings.parse_config(<<-CONF)
+        [main]
+        environmentpath=$confdir/environments
+        basemodulepath=/some/base
+        CONF
+      end
+
+      it_behaves_like :config_printing_a_section, nil
+    end
+
+    context "from master section" do
+
+      before(:each) do
+        Puppet.settings.parse_config(<<-CONF)
+        [master]
+        environmentpath=$confdir/environments
+        basemodulepath=/some/base
+        CONF
+        Puppet.settings.stubs(:global_defaults_initialized?).returns(:true)
+      end
+
+      it_behaves_like :config_printing_a_section, :master
+    end
+  end
+end
+end

data/spec/unit/face/facts_spec.rb

@@ -0,0 +1,23 @@
+#! /usr/bin/env ruby
+require 'spec_helper'
+require 'puppet/face'
+
+describe Puppet::Face[:facts, '0.0.1'] do
+  it "should define an 'upload' action" do
+    subject.should be_action(:upload)
+  end
+
+  describe "when uploading" do
+    it "should set the terminus_class to :facter"
+    it "should set the cache_class to :rest"
+    it "should find the current certname"
+  end
+
+  describe "#find" do
+    it { should be_action :find }
+
+    it "should fail without a key" do
+      expect { subject.find }.to raise_error ArgumentError, /wrong number of arguments/
+    end
+  end
+end

data/spec/unit/face/file_spec.rb

@@ -0,0 +1,12 @@
+#! /usr/bin/env ruby
+require 'spec_helper'
+require 'puppet/face'
+
+describe Puppet::Face[:file, '0.0.1'] do
+  it_should_behave_like "an indirector face"
+
+  [:download, :store].each do |action|
+    it { should be_action action }
+    it { should respond_to action }
+  end
+end

data/spec/unit/face/help_spec.rb

@@ -0,0 +1,144 @@
+#! /usr/bin/env ruby
+require 'spec_helper'
+require 'puppet/face'
+
+describe Puppet::Face[:help, '0.0.1'] do
+  it "has a help action" do
+    subject.should be_action :help
+  end
+
+  it "has a default action of help" do
+    subject.get_action('help').should 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
+    subject.help(:help, :version => :current).should ==
+      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]
+    subject.help(:huzzah, :version => face.version).
+      should == subject.help(:huzzah, :version => :current)
+  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
+      Puppet::Face.faces.should 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
+
+        subject.should =~ %r{ #{name} }
+        summary and subject.should =~ %r{ #{name} +#{summary}}
+      end
+    end
+
+    context "face summaries" do
+      it "can generate face summaries" do
+        faces = Puppet::Face.faces
+        faces.length.should > 0
+        faces.each do |name|
+          Puppet::Face[name, :current].should have_a_summary
+        end
+      end
+    end
+
+    it "lists all legacy applications" do
+      Puppet::Face[:help, :current].legacy_applications.each do |appname|
+        subject.should =~ %r{ #{appname} }
+
+        summary = Puppet::Face[:help, :current].horribly_extract_summary_from(appname)
+        summary and subject.should =~ %r{ #{summary}\b}
+      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 { should have_at_least(1).item }
+
+    # 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 { should_not 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)
+      help.should =~ /puppet-#{appname}/
+      %w{SYNOPSIS USAGE DESCRIPTION OPTIONS COPYRIGHT}.each do |heading|
+        help.should =~ /^#{heading}$/
+      end
+    end
+
+    it "fails when asked for an action on a legacy command" do
+      expect { subject.help(appname, :whatever) }.
+        to raise_error ArgumentError, /Legacy subcommands don't take actions/
+    end
+  end
+end