puppet 3.0.0.rc5 → 3.0.0.rc7

data/spec/unit/hiera/scope_spec.rb

@@ -0,0 +1,62 @@
+require 'spec_helper'
+require 'hiera/scope'
+
+describe Hiera::Scope do
+  describe "#initialize" do
+    it "should store the supplied puppet scope" do
+      real = {}
+      scope = Hiera::Scope.new(real)
+      scope.real.should == real
+    end
+  end
+
+  describe "#[]" do
+    it "should treat '' as nil" do
+      real = mock
+      real.expects(:lookupvar).with("foo").returns("")
+
+      scope = Hiera::Scope.new(real)
+      scope["foo"].should == nil
+    end
+
+    it "sould return found data" do
+      real = mock
+      real.expects(:lookupvar).with("foo").returns("bar")
+
+      scope = Hiera::Scope.new(real)
+      scope["foo"].should == "bar"
+    end
+
+    it "should get calling_class and calling_module from puppet scope" do
+      real = mock
+      resource = mock
+      resource.expects(:name).returns("Foo::Bar").twice
+
+      real.expects(:resource).returns(resource).twice
+
+      scope = Hiera::Scope.new(real)
+      scope["calling_class"].should == "foo::bar"
+      scope["calling_module"].should == "foo"
+    end
+  end
+
+  describe "#include?" do
+    it "should correctly report missing data" do
+      real = mock
+      real.expects(:lookupvar).with("foo").returns("")
+
+      scope = Hiera::Scope.new(real)
+      scope.include?("foo").should == false
+    end
+
+    it "should always return true for calling_class and calling_module" do
+      real = mock
+      real.expects(:lookupvar).with("calling_class").never
+      real.expects(:lookupvar).with("calling_module").never
+
+      scope = Hiera::Scope.new(real)
+      scope.include?("calling_class").should == true
+      scope.include?("calling_module").should == true
+    end
+  end
+end

data/spec/unit/hiera_puppet_spec.rb

@@ -0,0 +1,111 @@
+require 'spec_helper'
+require 'hiera_puppet'
+
+describe 'HieraPuppet' do
+  describe 'HieraPuppet#hiera_config' do
+    let(:hiera_config_data) do
+      { :backend => 'yaml' }
+    end
+
+    context "when the hiera_config_file exists" do
+      before do
+        Hiera::Config.expects(:load).returns(hiera_config_data)
+        HieraPuppet.expects(:hiera_config_file).returns(true)
+      end
+
+      it "should return a configuration hash" do
+        expected_results = {
+          :backend => 'yaml',
+          :logger  => 'puppet'
+        }
+        HieraPuppet.send(:hiera_config).should == expected_results
+      end
+    end
+
+    context "when the hiera_config_file does not exist" do
+      before do
+        Hiera::Config.expects(:load).never
+        HieraPuppet.expects(:hiera_config_file).returns(nil)
+      end
+
+      it "should return a configuration hash" do
+        HieraPuppet.send(:hiera_config).should == { :logger => 'puppet' }
+      end
+    end
+  end
+
+  describe 'HieraPuppet#hiera_config_file' do
+    it "should return nil when we cannot derive the hiera config file form Puppet.settings" do
+      begin
+        Puppet.settings[:hiera_config] = nil
+      rescue ArgumentError => detail
+        raise unless detail.message =~ /unknown configuration parameter/
+      end
+      HieraPuppet.send(:hiera_config_file).should be_nil
+    end
+
+    it "should use Puppet.settings[:hiera_config] as the hiera config file" do
+      begin
+        Puppet.settings[:hiera_config] = "/dev/null/my_hiera.yaml"
+      rescue ArgumentError => detail
+        raise unless detail.message =~ /unknown configuration parameter/
+        pending("This example does not apply to Puppet #{Puppet.version} because it does not have this setting")
+      end
+
+      File.stubs(:exist?).with(Puppet[:hiera_config]).returns(true)
+      HieraPuppet.send(:hiera_config_file).should == Puppet[:hiera_config]
+    end
+
+    it "should use Puppet.settings[:confdir] as the base directory when hiera_config is not set" do
+      begin
+        Puppet.settings[:hiera_config] = nil
+      rescue ArgumentError => detail
+        raise unless detail.message =~ /unknown configuration parameter/
+      end
+      Puppet.settings[:confdir] = "/dev/null/puppet"
+      hiera_config = File.join(Puppet[:confdir], 'hiera.yaml')
+      File.stubs(:exist?).with(hiera_config).returns(true)
+
+      HieraPuppet.send(:hiera_config_file).should == hiera_config
+    end
+  end
+
+  describe 'HieraPuppet#lookup' do
+    let :scope do Puppet::Parser::Scope.new_for_test_harness('foo') end
+
+    before :each do
+      Puppet[:hiera_config] = PuppetSpec::Files.tmpfile('hiera_config')
+    end
+
+    it "should return the value from Hiera" do
+      Hiera.any_instance.stubs(:lookup).returns('8080')
+      HieraPuppet.lookup('port', nil, scope, nil, :priority).should == '8080'
+
+      Hiera.any_instance.stubs(:lookup).returns(['foo', 'bar'])
+      HieraPuppet.lookup('ntpservers', nil, scope, nil, :array).should == ['foo', 'bar']
+
+      Hiera.any_instance.stubs(:lookup).returns({'uid' => '1000'})
+      HieraPuppet.lookup('user', nil, scope, nil, :hash).should == {'uid' => '1000'}
+    end
+
+    it "should raise a useful error when the answer is nil" do
+      Hiera.any_instance.stubs(:lookup).returns(nil)
+      expect do
+        HieraPuppet.lookup('port', nil, scope, nil, :priority)
+      end.to raise_error(Puppet::ParseError,
+        /Could not find data item port in any Hiera data file and no default supplied/)
+    end
+  end
+
+  describe 'HieraPuppet#parse_args' do
+    it 'should return a 3 item array' do
+      args = ['foo', '8080', nil, nil]
+      HieraPuppet.parse_args(args).should == ['foo', '8080', nil]
+    end
+
+    it 'should raise a useful error when no key is supplied' do
+      expect { HieraPuppet.parse_args([]) }.to raise_error(Puppet::ParseError,
+        /Please supply a parameter to perform a Hiera lookup/)
+    end
+  end
+end

data/spec/unit/indirector/catalog/active_record_spec.rb

@@ -15,6 +15,10 @@ describe "Puppet::Resource::Catalog::ActiveRecord", :if => can_use_scratch_datab
     Puppet::Resource::Catalog::ActiveRecord.new
   end
 
+  it "should issue a deprecation warning" do
+    Puppet.expects(:deprecation_warning).with() { |msg| msg =~ /ActiveRecord-based storeconfigs and inventory are deprecated/ }
+    terminus
+  end
 
   it "should be a subclass of the ActiveRecord terminus class" do
     Puppet::Resource::Catalog::ActiveRecord.ancestors.should be_include(Puppet::Indirector::ActiveRecord)

data/spec/unit/indirector/catalog/static_compiler_spec.rb

@@ -0,0 +1,194 @@
+#! /usr/bin/env ruby -S rspec
+require 'spec_helper'
+require 'puppet/indirector/catalog/static_compiler'
+require 'puppet/file_serving/metadata'
+require 'puppet/file_serving/content'
+require 'yaml'
+
+describe Puppet::Resource::Catalog::StaticCompiler do
+  before :all do
+    @num_file_resources = 10
+  end
+
+  let(:request) do
+    Puppet::Indirector::Request.new(:the_indirection_named_foo,
+                                    :find,
+                                    "the-node-named-foo",
+                                    :environment => "production")
+  end
+
+  describe "#find" do
+    it "returns a catalog" do
+      subject.find(request).should be_a_kind_of(Puppet::Resource::Catalog)
+    end
+
+    it "returns nil if there is no compiled catalog" do
+      compiler = mock('compiler indirection')
+      compiler.expects(:find).with(request).returns(nil)
+
+      subject.expects(:compiler).returns(compiler)
+      subject.find(request).should be_nil
+    end
+
+    describe "a catalog with file resources containing source parameters with puppet:// URIs" do
+      it "filters file resource source URI's to checksums" do
+        stub_the_compiler
+        resource_catalog = subject.find(request)
+        resource_catalog.resources.each do |resource|
+          next unless resource.type == "File"
+          resource[:content].should == "{md5}361fadf1c712e812d198c4cab5712a79"
+          resource[:source].should be_nil
+        end
+      end
+
+      it "does not modify file resources with non-puppet:// URI's" do
+        uri = "/this/is/not/a/puppet/uri.txt"
+        stub_the_compiler(:source => uri)
+        resource_catalog = subject.find(request)
+        resource_catalog.resources.each do |resource|
+          next unless resource.type == "File"
+          resource[:content].should be_nil
+          resource[:source].should == uri
+        end
+      end
+
+      it "copies the owner, group and mode from the fileserer" do
+        stub_the_compiler
+        resource_catalog = subject.find(request)
+        resource_catalog.resources.each do |resource|
+          next unless resource.type == "File"
+          resource[:owner].should == 0
+          resource[:group].should == 0
+          resource[:mode].should  == 420
+        end
+      end
+    end
+  end
+
+  describe "(#15193) when storing content to the filebucket" do
+    it "explicitly uses the indirection method" do
+      # Do not stub the store_content method which is stubbed by default in the
+      # value of the stub_methods option.
+      stub_the_compiler(:stub_methods => false)
+
+      # We expect the content to be retrieved from the FileServer ...
+      fake_content = mock('FileServer Content')
+      fake_content.expects(:content).returns("HELLO WORLD")
+
+      # Mock the FileBucket to behave as if the file content does not exist.
+      # NOTE, we're simulating the first call returning false, indicating the
+      # file is not present, then all subsequent calls returning true.  This
+      # mocked behavior is intended to replicate the real behavior of the same
+      # file being stored to the filebucket multiple times.
+      Puppet::FileBucket::File.indirection.
+        expects(:find).times(@num_file_resources).
+        returns(false).then.returns(true)
+
+      Puppet::FileServing::Content.indirection.
+        expects(:find).once.
+        returns(fake_content)
+
+      # Once retrived from the FileServer, we expect the file to be stored into
+      # the FileBucket only once.  All of the file resources in the fake
+      # catalog have the same content.
+      Puppet::FileBucket::File.indirection.expects(:save).once.with do |file|
+        file.contents == "HELLO WORLD"
+      end
+
+      # Obtain the Static Catalog
+      resource_catalog = subject.find(request)
+
+      # Ensure all of the file resources were filtered
+      resource_catalog.resources.each do |resource|
+        next unless resource.type == "File"
+        resource[:content].should == "{md5}361fadf1c712e812d198c4cab5712a79"
+        resource[:source].should be_nil
+      end
+    end
+  end
+
+  # Spec helper methods
+
+  def stub_the_compiler(options = {:stub_methods => [:store_content]})
+    # Build a resource catalog suitable for specifying the behavior of the
+    # static compiler.
+    compiler = mock('indirection terminus compiler')
+    compiler.stubs(:find).returns(build_catalog(options))
+    subject.stubs(:compiler).returns(compiler)
+    # Mock the store content method to prevent copying the contents to the
+    # file bucket.
+    (options[:stub_methods] || []).each do |mthd|
+      subject.stubs(mthd)
+    end
+  end
+
+  def build_catalog(options = {})
+    options = options.dup
+    options[:source] ||= 'puppet:///modules/mymodule/config_file.txt'
+    options[:request] ||= request
+
+    # Build a catalog suitable for the static compiler to operate on
+    catalog = Puppet::Resource::Catalog.new("#{options[:request].key}")
+
+    # Mock out the fileserver, otherwise converting the catalog to a
+    fake_fileserver_metadata = fileserver_metadata(options)
+
+    # Stub the call to the FileServer metadata API so we don't have to have
+    # a real fileserver initialized for testing.
+    Puppet::FileServing::Metadata.
+      indirection.stubs(:find).
+      with() { |*args| args[0] == options[:source].sub('puppet:///','') }.
+      returns(fake_fileserver_metadata)
+
+    # I want a resource that all the file resources require and another
+    # that requires them.
+    resources = Array.new
+    resources << Puppet::Resource.new("notify", "alpha")
+    resources << Puppet::Resource.new("notify", "omega")
+
+    # Create some File resources with source parameters.
+    1.upto(@num_file_resources) do |idx|
+      parameters = {
+        :ensure  => 'file',
+        :source  => options[:source],
+        :require => "Notify[alpha]",
+        :before  => "Notify[omega]"
+      }
+      # The static compiler does not operate on a RAL catalog, so we're
+      # using Puppet::Resource to produce a resource catalog.
+      agnostic_path = File.expand_path("/tmp/file_#{idx}.txt") # Windows Friendly
+      rsrc = Puppet::Resource.new("file", agnostic_path, :parameters => parameters)
+      rsrc.file = 'site.pp'
+      rsrc.line = idx
+      resources << rsrc
+    end
+
+    resources.each do |rsrc|
+      catalog.add_resource(rsrc)
+    end
+
+    # Return the resource catalog
+    catalog
+  end
+
+  def fileserver_metadata(options = {})
+    yaml = <<EOFILESERVERMETADATA
+--- !ruby/object:Puppet::FileServing::Metadata
+  checksum: "{md5}361fadf1c712e812d198c4cab5712a79"
+  checksum_type: md5
+  destination: 
+  expiration: #{Time.now + 1800}
+  ftype: file
+  group: 0
+  links: !ruby/sym manage
+  mode: 420
+  owner: 0
+  path: #{File.expand_path('/etc/puppet/modules/mymodule/files/config_file.txt')}
+  source: #{options[:source]}
+  stat_method: !ruby/sym lstat
+EOFILESERVERMETADATA
+    # Return a deserialized metadata object suitable for returning from a stub.
+    YAML.load(yaml)
+  end
+end
+

data/spec/unit/indirector/certificate/disabled_ca_spec.rb

@@ -0,0 +1,33 @@
+#! /usr/bin/env ruby -S rspec
+require 'spec_helper'
+require 'puppet/indirector/certificate/disabled_ca'
+
+describe Puppet::SSL::Certificate::DisabledCa do
+  def request(type, remote)
+    r = Puppet::Indirector::Request.new(:certificate, type, "foo.com", nil)
+    if remote
+      r.ip   = '10.0.0.1'
+      r.node = 'agent.example.com'
+    end
+    r
+  end
+
+  context "when not a CA" do
+    before :each do
+      Puppet[:ca] = false
+      Puppet::SSL::Host.ca_location = :none
+    end
+
+    [:find, :head, :search, :save, :destroy].each do |name|
+      it "should fail remote #{name} requests" do
+        expect { subject.send(name, request(name, true)) }.
+          to raise_error Puppet::Error, /is not a CA/
+      end
+
+      it "should forward local #{name} requests" do
+        Puppet::SSL::Certificate.indirection.terminus(:file).expects(name)
+        subject.send(name, request(name, false))
+      end
+    end
+  end
+end

data/spec/unit/indirector/certificate_request/disabled_ca_spec.rb

@@ -0,0 +1,33 @@
+#! /usr/bin/env ruby -S rspec
+require 'spec_helper'
+require 'puppet/indirector/certificate_request/disabled_ca'
+
+describe Puppet::SSL::CertificateRequest::DisabledCa do
+  def request(type, remote)
+    r = Puppet::Indirector::Request.new(:certificate_request, type, "foo.com", nil)
+    if remote
+      r.ip   = '10.0.0.1'
+      r.node = 'agent.example.com'
+    end
+    r
+  end
+
+  context "when not a CA" do
+    before :each do
+      Puppet[:ca] = false
+      Puppet::SSL::Host.ca_location = :none
+    end
+
+    [:find, :head, :search, :save, :destroy].each do |name|
+      it "should fail remote #{name} requests" do
+        expect { subject.send(name, request(name, true)) }.
+          to raise_error Puppet::Error, /is not a CA/
+      end
+
+      it "should forward local #{name} requests" do
+        Puppet::SSL::CertificateRequest.indirection.terminus(:file).expects(name)
+        subject.send(name, request(name, false))
+      end
+    end
+  end
+end