puppet 3.5.0.rc1-x86-mingw32

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

@@ -0,0 +1,107 @@
+#! /usr/bin/env ruby
+require 'spec_helper'
+
+describe "Puppet::Resource::Catalog::ActiveRecord", :if => can_use_scratch_database? do
+  include PuppetSpec::Files
+
+  before :each do
+    require 'puppet/indirector/catalog/active_record'
+    setup_scratch_database
+  end
+
+  after :each do
+    Puppet::Rails.teardown
+  end
+
+  let :terminus do
+    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/ }
+
+    Puppet::Resource::Catalog::ActiveRecord.new
+  end
+
+  it "should be a subclass of the ActiveRecord terminus class" do
+    Puppet::Resource::Catalog::ActiveRecord.ancestors.should be_include(Puppet::Indirector::ActiveRecord)
+  end
+
+  it "should use Puppet::Rails::Host as its ActiveRecord model" do
+    Puppet::Resource::Catalog::ActiveRecord.ar_model.should equal(Puppet::Rails::Host)
+  end
+
+  describe "when finding an instance" do
+    it "should return nil" do
+      r = stub 'request', :key => "foo", :options => {:cache_integration_hack => false}
+      terminus.find(r).should be_nil
+    end
+
+    # This used to make things go to the database, but that is code that is as
+    # dead as a doornail.  This just checks we don't blow up unexpectedly, and
+    # can go away after a few releases. --daniel 2012-02-27
+    it "should always return nil" do
+      r = stub 'request', :key => "foo", :options => {:cache_integration_hack => true}
+      terminus.find(r).should be_nil
+    end
+  end
+
+  describe "when saving an instance" do
+    let :catalog do Puppet::Resource::Catalog.new("foo") end
+    let :request do Puppet::Indirector::Request.new(:active_record, :save, nil, catalog) end
+    let :node do Puppet::Node.new("foo", :environment => "environment") end
+
+    before :each do
+      Puppet::Node.indirection.stubs(:find).with("foo").returns(node)
+    end
+
+    it "should find the Rails host with the same name" do
+      Puppet::Rails::Host.expects(:find_by_name).with("foo")
+      terminus.save(request)
+    end
+
+    it "should create a new Rails host if none can be found" do
+      Puppet::Rails::Host.find_by_name('foo').should be_nil
+      terminus.save(request)
+      Puppet::Rails::Host.find_by_name('foo').should be_valid
+    end
+
+    it "should set the catalog vertices as resources on the Rails host instance" do
+      # We need to stub this so we get the same object, not just the same
+      # content, otherwise the expect can't fire. :(
+      host = Puppet::Rails::Host.create!(:name => "foo")
+      Puppet::Rails::Host.expects(:find_by_name).with("foo").returns(host)
+      catalog.expects(:vertices).returns("foo")
+      host.expects(:merge_resources).with("foo")
+
+      terminus.save(request)
+    end
+
+    it "should set host ip if we could find a matching node" do
+      node.merge("ipaddress" => "192.168.0.1")
+      terminus.save(request)
+      Puppet::Rails::Host.find_by_name("foo").ip.should == '192.168.0.1'
+    end
+
+    it "should set host environment if we could find a matching node" do
+      terminus.save(request)
+      Puppet::Rails::Host.find_by_name("foo").environment.should == "environment"
+    end
+
+    it "should set the last compile time on the host" do
+      before = Time.now
+      terminus.save(request)
+      after = Time.now
+
+      Puppet::Rails::Host.find_by_name("foo").last_compile.should be_between(before, after)
+    end
+
+    it "should save the Rails host instance" do
+      host = Puppet::Rails::Host.create!(:name => "foo")
+      Puppet::Rails::Host.expects(:find_by_name).with("foo").returns(host)
+      host.expects(:save)
+
+      terminus.save(request)
+    end
+  end
+end

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

@@ -0,0 +1,253 @@
+#! /usr/bin/env ruby
+require 'spec_helper'
+
+require 'puppet/indirector/catalog/compiler'
+require 'puppet/rails'
+
+describe Puppet::Resource::Catalog::Compiler do
+  before do
+    require 'puppet/rails'
+    Puppet::Rails.stubs(:init)
+    Facter.stubs(:to_hash).returns({})
+    Facter.stubs(:value).returns(Facter::Util::Fact.new("something"))
+  end
+
+  describe "when initializing" do
+    before do
+      Puppet.expects(:version).returns(1)
+      Facter.expects(:value).with('fqdn').returns("my.server.com")
+      Facter.expects(:value).with('ipaddress').returns("my.ip.address")
+    end
+
+    it "should gather data about itself" do
+      Puppet::Resource::Catalog::Compiler.new
+    end
+
+    it "should cache the server metadata and reuse it" do
+      Puppet[:node_terminus] = :memory
+      Puppet::Node.indirection.save(Puppet::Node.new("node1"))
+      Puppet::Node.indirection.save(Puppet::Node.new("node2"))
+
+      compiler = Puppet::Resource::Catalog::Compiler.new
+      compiler.stubs(:compile)
+
+      compiler.find(Puppet::Indirector::Request.new(:catalog, :find, 'node1', nil, :node => 'node1'))
+      compiler.find(Puppet::Indirector::Request.new(:catalog, :find, 'node2', nil, :node => 'node2'))
+    end
+  end
+
+  describe "when finding catalogs" do
+    before do
+      Facter.stubs(:value).returns("whatever")
+
+      @compiler = Puppet::Resource::Catalog::Compiler.new
+      @name = "me"
+      @node = Puppet::Node.new @name
+      @node.stubs(:merge)
+      Puppet::Node.indirection.stubs(:find).returns @node
+      @request = Puppet::Indirector::Request.new(:catalog, :find, @name, nil, :node => @name)
+    end
+
+    it "should directly use provided nodes for a local request" do
+      Puppet::Node.indirection.expects(:find).never
+      @compiler.expects(:compile).with(@node)
+      @request.stubs(:options).returns(:use_node => @node)
+      @request.stubs(:remote?).returns(false)
+      @compiler.find(@request)
+    end
+
+    it "rejects a provided node if the request is remote" do
+      @request.stubs(:options).returns(:use_node => @node)
+      @request.stubs(:remote?).returns(true)
+      expect {
+        @compiler.find(@request)
+      }.to raise_error Puppet::Error, /invalid option use_node/i
+    end
+
+    it "should use the authenticated node name if no request key is provided" do
+      @request.stubs(:key).returns(nil)
+      Puppet::Node.indirection.expects(:find).with(@name, anything).returns(@node)
+      @compiler.expects(:compile).with(@node)
+      @compiler.find(@request)
+    end
+
+    it "should use the provided node name by default" do
+      @request.expects(:key).returns "my_node"
+
+      Puppet::Node.indirection.expects(:find).with("my_node", anything).returns @node
+      @compiler.expects(:compile).with(@node)
+      @compiler.find(@request)
+    end
+
+    it "should fail if no node is passed and none can be found" do
+      Puppet::Node.indirection.stubs(:find).with(@name, anything).returns(nil)
+      proc { @compiler.find(@request) }.should raise_error(ArgumentError)
+    end
+
+    it "should fail intelligently when searching for a node raises an exception" do
+      Puppet::Node.indirection.stubs(:find).with(@name, anything).raises "eh"
+      proc { @compiler.find(@request) }.should raise_error(Puppet::Error)
+    end
+
+    it "should pass the found node to the compiler for compiling" do
+      Puppet::Node.indirection.expects(:find).with(@name, anything).returns(@node)
+      config = mock 'config'
+      Puppet::Parser::Compiler.expects(:compile).with(@node)
+      @compiler.find(@request)
+    end
+
+    it "should extract and save any facts from the request" do
+      Puppet::Node.indirection.expects(:find).with(@name, anything).returns @node
+      @compiler.expects(:extract_facts_from_request).with(@request)
+      Puppet::Parser::Compiler.stubs(:compile)
+      @compiler.find(@request)
+    end
+
+    it "requires `facts_format` option if facts are passed in" do
+      facts = Puppet::Node::Facts.new("mynode", :afact => "avalue")
+      request = Puppet::Indirector::Request.new(:catalog, :find, "mynode", nil, :facts => facts)
+      expect {
+        @compiler.find(request)
+      }.to raise_error ArgumentError, /no fact format provided for mynode/
+    end
+
+    it "rejects facts in the request from a different node" do
+      facts = Puppet::Node::Facts.new("differentnode", :afact => "avalue")
+      request = Puppet::Indirector::Request.new(
+        :catalog, :find, "mynode", nil, :facts => facts, :facts_format => "unused"
+      )
+      expect {
+        @compiler.find(request)
+      }.to raise_error Puppet::Error, /fact definition for the wrong node/i
+    end
+
+    it "should return the results of compiling as the catalog" do
+      Puppet::Node.indirection.stubs(:find).returns(@node)
+      config = mock 'config'
+      result = mock 'result'
+
+      Puppet::Parser::Compiler.expects(:compile).returns result
+      @compiler.find(@request).should equal(result)
+    end
+  end
+
+  describe "when extracting facts from the request" do
+    before do
+      Puppet::Node::Facts.indirection.terminus_class = :memory
+      Facter.stubs(:value).returns "something"
+      @compiler = Puppet::Resource::Catalog::Compiler.new
+
+      @facts = Puppet::Node::Facts.new('hostname', "fact" => "value", "architecture" => "i386")
+    end
+
+    def a_request_that_contains(facts)
+      request = Puppet::Indirector::Request.new(:catalog, :find, "hostname", nil)
+      request.options[:facts_format] = "pson"
+      request.options[:facts] = CGI.escape(facts.render(:pson))
+      request
+    end
+
+    it "should do nothing if no facts are provided" do
+      request = Puppet::Indirector::Request.new(:catalog, :find, "hostname", nil)
+      request.options[:facts] = nil
+
+      @compiler.extract_facts_from_request(request).should be_nil
+    end
+
+    it "deserializes the facts and timestamps them" do
+      @facts.timestamp = Time.parse('2010-11-01')
+      request = a_request_that_contains(@facts)
+      now = Time.parse('2010-11-02')
+      Time.stubs(:now).returns(now)
+
+      facts = @compiler.extract_facts_from_request(request)
+
+      facts.timestamp.should == now
+    end
+
+    it "should convert the facts into a fact instance and save it" do
+      request = a_request_that_contains(@facts)
+
+      Puppet::Node::Facts.indirection.expects(:save).with(equals(@facts))
+
+      @compiler.extract_facts_from_request(request)
+    end
+  end
+
+  describe "when finding nodes" do
+    it "should look node information up via the Node class with the provided key" do
+      Facter.stubs(:value).returns("whatever")
+      node = Puppet::Node.new('node')
+      compiler = Puppet::Resource::Catalog::Compiler.new
+      request = Puppet::Indirector::Request.new(:catalog, :find, "me", nil)
+      compiler.stubs(:compile)
+
+      Puppet::Node.indirection.expects(:find).with("me", anything).returns(node)
+
+      compiler.find(request)
+    end
+  end
+
+  describe "after finding nodes" do
+    before do
+      Puppet.expects(:version).returns(1)
+      Facter.expects(:value).with('fqdn').returns("my.server.com")
+      Facter.expects(:value).with('ipaddress').returns("my.ip.address")
+      @compiler = Puppet::Resource::Catalog::Compiler.new
+      @node = Puppet::Node.new("me")
+      @request = Puppet::Indirector::Request.new(:catalog, :find, "me", nil)
+      @compiler.stubs(:compile)
+      Puppet::Node.indirection.stubs(:find).with("me", anything).returns(@node)
+    end
+
+    it "should add the server's Puppet version to the node's parameters as 'serverversion'" do
+      @node.expects(:merge).with { |args| args["serverversion"] == "1" }
+      @compiler.find(@request)
+    end
+
+    it "should add the server's fqdn to the node's parameters as 'servername'" do
+      @node.expects(:merge).with { |args| args["servername"] == "my.server.com" }
+      @compiler.find(@request)
+    end
+
+    it "should add the server's IP address to the node's parameters as 'serverip'" do
+      @node.expects(:merge).with { |args| args["serverip"] == "my.ip.address" }
+      @compiler.find(@request)
+    end
+  end
+
+  describe "when filtering resources" do
+    before :each do
+      Facter.stubs(:value)
+      @compiler = Puppet::Resource::Catalog::Compiler.new
+      @catalog = stub_everything 'catalog'
+      @catalog.stubs(:respond_to?).with(:filter).returns(true)
+    end
+
+    it "should delegate to the catalog instance filtering" do
+      @catalog.expects(:filter)
+      @compiler.filter(@catalog)
+    end
+
+    it "should filter out virtual resources" do
+      resource = mock 'resource', :virtual? => true
+      @catalog.stubs(:filter).yields(resource)
+
+      @compiler.filter(@catalog)
+    end
+
+    it "should return the same catalog if it doesn't support filtering" do
+      @catalog.stubs(:respond_to?).with(:filter).returns(false)
+
+      @compiler.filter(@catalog).should == @catalog
+    end
+
+    it "should return the filtered catalog" do
+      catalog = stub 'filtered catalog'
+      @catalog.stubs(:filter).returns(catalog)
+
+      @compiler.filter(@catalog).should == catalog
+    end
+
+  end
+end

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

@@ -0,0 +1,12 @@
+#! /usr/bin/env ruby
+require 'spec_helper'
+require 'puppet/resource/catalog'
+require 'puppet/indirector/catalog/json'
+
+describe Puppet::Resource::Catalog::Json do
+  # This is it for local functionality: we don't *do* anything else.
+  it "should be registered with the catalog store indirection" do
+    Puppet::Resource::Catalog.indirection.terminus(:json).
+      should be_an_instance_of described_class
+  end
+end

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

@@ -0,0 +1,12 @@
+#! /usr/bin/env ruby
+require 'spec_helper'
+require 'puppet/resource/catalog'
+require 'puppet/indirector/catalog/msgpack'
+
+describe Puppet::Resource::Catalog::Msgpack, :if => Puppet.features.msgpack? do
+  # This is it for local functionality: we don't *do* anything else.
+  it "should be registered with the catalog store indirection" do
+    Puppet::Resource::Catalog.indirection.terminus(:msgpack).
+      should be_an_instance_of described_class
+  end
+end

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

@@ -0,0 +1,19 @@
+#! /usr/bin/env ruby
+require 'spec_helper'
+
+require 'puppet/indirector/catalog/queue'
+
+describe Puppet::Resource::Catalog::Queue do
+  it 'should be a subclass of the Queue terminus' do
+    Puppet::Resource::Catalog::Queue.superclass.should equal(Puppet::Indirector::Queue)
+  end
+
+  it 'should be registered with the catalog store indirection' do
+    indirection = Puppet::Indirector::Indirection.instance(:catalog)
+    Puppet::Resource::Catalog::Queue.indirection.should equal(indirection)
+  end
+
+  it 'shall be dubbed ":queue"' do
+    Puppet::Resource::Catalog::Queue.name.should == :queue
+  end
+end

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

@@ -0,0 +1,10 @@
+#! /usr/bin/env ruby
+require 'spec_helper'
+
+require 'puppet/indirector/catalog/rest'
+
+describe Puppet::Resource::Catalog::Rest do
+  it "should be a sublcass of Puppet::Indirector::REST" do
+    Puppet::Resource::Catalog::Rest.superclass.should equal(Puppet::Indirector::REST)
+  end
+end

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

@@ -0,0 +1,225 @@
+#! /usr/bin/env ruby
+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
+
+  before :each do
+    Facter.stubs(:to_hash).returns({})
+    Facter.stubs(:value)
+  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
+      subject.expects(:compile).returns(nil)
+      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
+
+      # 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
+      subject.stubs(:compile).returns(build_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 do |uri, opts|
+        expect(uri).to eq options[:source].sub('puppet:///','')
+        expect(opts[:links]).to eq :manage
+        expect(opts[:environment]).to eq nil
+      end.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
+
+  describe "(#22744) when filtering resources" do
+    let(:catalog) { stub_everything 'catalog' }
+
+    it "should delegate to the catalog instance filtering" do
+      catalog.expects(:filter)
+      subject.filter(catalog)
+    end
+
+    it "should filter out virtual resources" do
+      resource = mock 'resource', :virtual? => true
+      catalog.stubs(:filter).yields(resource)
+
+      subject.filter(catalog)
+    end
+
+    it "should return the same catalog if it doesn't support filtering" do
+      catalog.stubs(:respond_to?).with(:filter)
+      subject.filter(catalog).should == catalog
+    end
+
+    it "should return the filtered catalog" do
+      filtered_catalog = stub 'filtered catalog'
+      catalog.stubs(:filter).returns(filtered_catalog)
+
+      subject.filter(catalog).should == filtered_catalog
+    end
+
+  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
+