puppet 2.6.16 → 2.6.17

data/spec/integration/file_serving/content_spec.rb

@@ -9,12 +9,5 @@ require 'puppet/file_serving/content'
 require 'shared_behaviours/file_serving'
 
 describe Puppet::FileServing::Content, " when finding files" do
-  it_should_behave_like "Puppet::FileServing::Files"
-
-  before do
-    @test_class = Puppet::FileServing::Content
-    @indirection = Puppet::FileServing::Content.indirection
-  end
-
-  after { Puppet::Util::Cacher.expire }
+  it_should_behave_like "a file_serving model"
 end

data/spec/integration/file_serving/metadata_spec.rb

@@ -10,12 +10,5 @@ require 'shared_behaviours/file_serving'
 require 'puppet/indirector/file_metadata/file_server'
 
 describe Puppet::FileServing::Metadata, " when finding files" do
-  it_should_behave_like "Puppet::FileServing::Files"
-
-  before do
-    @test_class = Puppet::FileServing::Metadata
-    @indirection = Puppet::FileServing::Metadata.indirection
-  end
-
-  after { Puppet::Util::Cacher.expire }
+  it_should_behave_like "a file_serving model"
 end

data/spec/integration/indirector/file_content/file_server_spec.rb

@@ -38,8 +38,8 @@ describe Puppet::Indirector::FileContent::FileServer, " when finding files" do
 
     result.should_not be_nil
     result.length.should == 2
-    result[1].should be_instance_of(Puppet::FileServing::Content)
-    result[1].content.should == "1\n"
+    result.map {|x| x.should be_instance_of(Puppet::FileServing::Content) }
+    result.find {|x| x.relative_path == 'file.rb' }.content.should == "1\n"
   end
 
   it "should find file content in modules" do

data/spec/shared_behaviours/file_serving.rb

@@ -1,71 +1,80 @@
-#!/usr/bin/env ruby
-#
-#  Created by Luke Kanies on 2007-10-18.
-#  Copyright (c) 2007. All rights reserved.
-
-shared_examples_for "Puppet::FileServing::Files" do
-  it "should use the rest terminus when the 'puppet' URI scheme is used and a host name is present" do
-    uri = "puppet://myhost/fakemod/my/file"
-
-    # It appears that the mocking somehow interferes with the caching subsystem.
-    # This mock somehow causes another terminus to get generated.
-    term = @indirection.terminus(:rest)
-    @indirection.stubs(:terminus).with(:rest).returns term
-    term.expects(:find)
-    @test_class.find(uri)
-  end
+#!/usr/bin/env rspec
 
-  it "should use the rest terminus when the 'puppet' URI scheme is used, no host name is present, and the process name is not 'puppet' or 'apply'" do
-    uri = "puppet:///fakemod/my/file"
-    Puppet.settings.stubs(:value).returns "foo"
-    Puppet.settings.stubs(:value).with(:name).returns("puppetd")
-    Puppet.settings.stubs(:value).with(:modulepath).returns("")
-    @indirection.terminus(:rest).expects(:find)
-    @test_class.find(uri)
-  end
+shared_examples_for "Puppet::FileServing::Files" do |indirection|
+  %w[find search].each do |method|
+    let(:request) { Puppet::Indirector::Request.new(indirection, method, 'foo') }
 
-  it "should use the file_server terminus when the 'puppet' URI scheme is used, no host name is present, and the process name is 'puppet'" do
-    uri = "puppet:///fakemod/my/file"
-    Puppet::Node::Environment.stubs(:new).returns(stub("env", :name => "testing", :module => nil, :modulepath => []))
-    Puppet.settings.stubs(:value).returns ""
-    Puppet.settings.stubs(:value).with(:name).returns("puppet")
-    Puppet.settings.stubs(:value).with(:fileserverconfig).returns("/whatever")
-    @indirection.terminus(:file_server).expects(:find)
-    @indirection.terminus(:file_server).stubs(:authorized?).returns(true)
-    @test_class.find(uri)
-  end
+    before :each do
+      # Stub this so we can set the :name setting
+      Puppet::Util::Settings::ReadOnly.stubs(:include?)
+    end
 
-  it "should use the file_server terminus when the 'puppet' URI scheme is used, no host name is present, and the process name is 'apply'" do
-    uri = "puppet:///fakemod/my/file"
-    Puppet::Node::Environment.stubs(:new).returns(stub("env", :name => "testing", :module => nil, :modulepath => []))
-    Puppet.settings.stubs(:value).returns ""
-    Puppet.settings.stubs(:value).with(:name).returns("apply")
-    Puppet.settings.stubs(:value).with(:fileserverconfig).returns("/whatever")
-    @indirection.terminus(:file_server).expects(:find)
-    @indirection.terminus(:file_server).stubs(:authorized?).returns(true)
-    @test_class.find(uri)
-  end
+    describe "##{method}" do
+      it "should proxy to file terminus if the path is absolute" do
+        request.key = '/tmp/foo'
 
-  it "should use the file terminus when the 'file' URI scheme is used" do
-    uri = "file:///fakemod/my/file"
-    @indirection.terminus(:file).expects(:find)
-    @test_class.find(uri)
-  end
+        described_class.indirection.terminus(:file).class.any_instance.expects(method).with(request)
 
-  it "should use the file terminus when a fully qualified path is provided" do
-    uri = "/fakemod/my/file"
-    @indirection.terminus(:file).expects(:find)
-    @test_class.find(uri)
-  end
+        subject.send(method, request)
+      end
+
+      it "should proxy to file terminus if the protocol is file" do
+        request.protocol = 'file'
+
+        described_class.indirection.terminus(:file).class.any_instance.expects(method).with(request)
+
+        subject.send(method, request)
+      end
+
+      describe "when the protocol is puppet" do
+        before :each do
+          request.protocol = 'puppet'
+        end
+
+        describe "and a server is specified" do
+          before :each do
+            request.server = 'puppet_server'
+          end
+
+          it "should proxy to rest terminus if we're 'apply'" do
+            Puppet[:name] = 'apply'
+
+            described_class.indirection.terminus(:rest).class.any_instance.expects(method).with(request)
+
+            subject.send(method, request)
+          end
+
+          it "should proxy to rest terminus if we aren't 'apply'" do
+            Puppet[:name] = 'not_apply'
+
+            described_class.indirection.terminus(:rest).class.any_instance.expects(method).with(request)
+
+            subject.send(method, request)
+          end
+        end
+
+        describe "and no server is specified" do
+          before :each do
+            request.server = nil
+          end
+
+          it "should proxy to file_server if we're 'apply'" do
+            Puppet[:name] = 'apply'
+
+            described_class.indirection.terminus(:file_server).class.any_instance.expects(method).with(request)
+
+            subject.send(method, request)
+          end
+
+          it "should proxy to rest if we're not 'apply'" do
+            Puppet[:name] = 'not_apply'
 
-  it "should use the configuration to test whether the request is allowed" do
-    uri = "fakemod/my/file"
-    mount = mock 'mount'
-    config = stub 'configuration', :split_path => [mount, "eh"]
-    @indirection.terminus(:file_server).stubs(:configuration).returns config
+            described_class.indirection.terminus(:rest).class.any_instance.expects(method).with(request)
 
-    @indirection.terminus(:file_server).expects(:find)
-    mount.expects(:allowed?).returns(true)
-    @test_class.find(uri, :node => "foo", :ip => "bar")
+            subject.send(method, request)
+          end
+        end
+      end
+    end
   end
 end

data/spec/shared_behaviours/file_serving_model.rb

@@ -0,0 +1,73 @@
+#!/usr/bin/env rspec
+
+shared_examples_for "a file_serving model" do
+  include PuppetSpec::Files
+
+  describe "#indirection" do
+    before :each do
+      # Never connect to the network, no matter what
+      described_class.indirection.terminus(:rest).class.any_instance.stubs(:find)
+    end
+
+    describe "when running the master application" do
+      before :each do
+        Puppet::Application[:master].setup_terminuses
+      end
+
+      {
+       "/etc/sudoers"                    => :file_server,
+       "file:///etc/sudoers"             => :file_server,
+       "puppet:///modules/foo/bar"       => :file_server,
+       "puppet://server/modules/foo/bar" => :file_server,
+      }.each do |key, terminus|
+        it "should use the #{terminus} terminus when requesting #{key.inspect}" do
+          described_class.indirection.terminus(terminus).class.any_instance.expects(:find)
+
+          described_class.indirection.find(key)
+        end
+      end
+    end
+
+    describe "when running the apply application" do
+      before :each do
+        # Stub this so we can set the 'name' setting
+        Puppet::Util::Settings::ReadOnly.stubs(:include?)
+        Puppet[:name] = 'apply'
+      end
+
+      {
+       "/etc/sudoers"                    => :file,
+       "file:///etc/sudoers"             => :file,
+       "puppet:///modules/foo/bar"       => :file_server,
+       "puppet://server/modules/foo/bar" => :rest,
+      }.each do |key, terminus|
+        it "should use the #{terminus} terminus when requesting #{key.inspect}" do
+          described_class.indirection.terminus(terminus).class.any_instance.expects(:find)
+
+          described_class.indirection.find(key)
+        end
+      end
+    end
+
+    describe "when running another application" do
+      before :each do
+        # Stub this so we can set the 'name' setting
+        Puppet::Util::Settings::ReadOnly.stubs(:include?)
+        Puppet[:name] = 'agent'
+      end
+
+      {
+       "/etc/sudoers"                    => :file,
+       "file:///etc/sudoers"             => :file,
+       "puppet:///modules/foo/bar"       => :rest,
+       "puppet://server/modules/foo/bar" => :rest,
+      }.each do |key, terminus|
+        it "should use the #{terminus} terminus when requesting #{key.inspect}" do
+          described_class.indirection.terminus(terminus).class.any_instance.expects(:find)
+
+          described_class.indirection.find(key)
+        end
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -63,8 +63,26 @@ RSpec.configure do |config|
       $tmpfiles.clear
     end
 
+
+    # Some tests can cause us to connect, in which case the lingering
+    # connection is a resource that can cause unexpected failure in later
+    # tests, as well as sharing state accidentally.
+    # We're testing if ActiveRecord::Base is defined because some test cases
+    # may stub Puppet.features.rails? which is how we should normally
+    # introspect for this functionality.
+    ActiveRecord::Base.remove_connection if defined?(ActiveRecord::Base)
+
     @logs.clear
     Puppet::Util::Log.close_all
+
+    # Restore the terminuses to the defaults in case they were changed
+    indirections = Puppet::Indirector::Indirection.send(:class_variable_get, :@@indirections)
+    indirections.each do |indirector|
+      $saved_indirection_state.fetch(indirector.name, {}).each do |variable, value|
+        indirector.instance_variable_set(variable, value)
+      end
+    end
+    $saved_indirection_state = nil
   end
 
   config.before :each do
@@ -73,6 +91,17 @@ RSpec.configure do |config|
     $puppet_application_name = nil
     Signal.stubs(:trap)
 
+    # Save off the current terminuses so we can restore them afterward
+    $saved_indirection_state = {}
+    indirections = Puppet::Indirector::Indirection.send(:class_variable_get, :@@indirections)
+    indirections.each do |indirector|
+      $saved_indirection_state[indirector.name] = {
+          :@terminus_class => indirector.instance_variable_get(:@terminus_class),
+          :@cache_class    => indirector.instance_variable_get(:@cache_class)
+      }
+    end
+
+
     # Set the confdir and vardir to gibberish so that tests
     # have to be correctly mocked.
     Puppet[:confdir] = "/dev/null"

data/spec/unit/file_serving/configuration_spec.rb

@@ -170,80 +170,88 @@ describe Puppet::FileServing::Configuration do
     end
   end
 
-  describe "when finding the mount name and relative path in a request key" do
-    before do
-      @config = Puppet::FileServing::Configuration.create
-      @config.stubs(:find_mount)
+  describe "#split_path" do
+    let(:config) { Puppet::FileServing::Configuration.create }
+    let(:request) { stub 'request', :key => "foo/bar/baz", :options => {}, :node => nil, :environment => mock("env") }
 
-      @request = stub 'request', :key => "foo/bar/baz", :options => {}, :node => nil, :environment => mock("env")
+    before do
+      config.stubs(:find_mount)
     end
 
     it "should reread the configuration" do
-      @config.expects(:readconfig)
+      config.expects(:readconfig)
 
-      @config.split_path(@request)
+      config.split_path(request)
     end
 
     it "should treat the first field of the URI path as the mount name" do
-      @config.expects(:find_mount).with { |name, node| name == "foo" }
+      config.expects(:find_mount).with { |name, node| name == "foo" }
 
-      @config.split_path(@request)
+      config.split_path(request)
     end
 
     it "should fail if the mount name is not alpha-numeric" do
-      @request.expects(:key).returns "foo&bar/asdf"
+      request.expects(:key).returns "foo&bar/asdf"
 
-      lambda { @config.split_path(@request) }.should raise_error(ArgumentError)
+      lambda { config.split_path(request) }.should raise_error(ArgumentError)
     end
 
     it "should support dashes in the mount name" do
-      @request.expects(:key).returns "foo-bar/asdf"
+      request.expects(:key).returns "foo-bar/asdf"
 
-      lambda { @config.split_path(@request) }.should_not raise_error(ArgumentError)
+      lambda { config.split_path(request) }.should_not raise_error(ArgumentError)
     end
 
     it "should use the mount name and environment to find the mount" do
-      @config.expects(:find_mount).with { |name, env| name == "foo" and env == @request.environment }
-      @request.stubs(:node).returns("mynode")
+      config.expects(:find_mount).with { |name, env| name == "foo" and env == request.environment }
+      request.stubs(:node).returns("mynode")
 
-      @config.split_path(@request)
+      config.split_path(request)
     end
 
     it "should return nil if the mount cannot be found" do
-      @config.expects(:find_mount).returns nil
+      config.expects(:find_mount).returns nil
 
-      @config.split_path(@request).should be_nil
+      config.split_path(request).should be_nil
     end
 
     it "should return the mount and the relative path if the mount is found" do
       mount = stub 'mount', :name => "foo"
-      @config.expects(:find_mount).returns mount
+      config.expects(:find_mount).returns mount
 
-      @config.split_path(@request).should == [mount, "bar/baz"]
+      config.split_path(request).should == [mount, "bar/baz"]
     end
 
     it "should remove any double slashes" do
-      @request.stubs(:key).returns "foo/bar//baz"
+      request.stubs(:key).returns "foo/bar//baz"
       mount = stub 'mount', :name => "foo"
-      @config.expects(:find_mount).returns mount
+      config.expects(:find_mount).returns mount
+
+      config.split_path(request).should == [mount, "bar/baz"]
+    end
+
+    it "should fail if the path contains .." do
+      request.stubs(:key).returns 'module/foo/../../bar'
 
-      @config.split_path(@request).should == [mount, "bar/baz"]
+      expect do
+        config.split_path(request)
+      end.to raise_error(ArgumentError, /Invalid relative path/)
     end
 
     it "should return the relative path as nil if it is an empty string" do
-      @request.expects(:key).returns "foo"
+      request.expects(:key).returns "foo"
       mount = stub 'mount', :name => "foo"
-      @config.expects(:find_mount).returns mount
+      config.expects(:find_mount).returns mount
 
-      @config.split_path(@request).should == [mount, nil]
+      config.split_path(request).should == [mount, nil]
     end
 
     it "should add 'modules/' to the relative path if the modules mount is used but not specified, for backward compatibility" do
-      @request.expects(:key).returns "foo/bar"
+      request.expects(:key).returns "foo/bar"
       mount = stub 'mount', :name => "modules"
-      @config.expects(:find_mount).returns mount
+      config.expects(:find_mount).returns mount
 
-      @config.split_path(@request).should == [mount, "foo/bar"]
+      config.split_path(request).should == [mount, "foo/bar"]
     end
   end
 end

data/spec/unit/file_serving/content_spec.rb

@@ -13,10 +13,6 @@ describe Puppet::FileServing::Content do
     Puppet::FileServing::Content.indirection.name.should == :file_content
   end
 
-  it "should should include the IndirectionHooks module in its indirection" do
-    Puppet::FileServing::Content.indirection.singleton_class.included_modules.should include(Puppet::FileServing::IndirectionHooks)
-  end
-
   it "should only support the raw format" do
     Puppet::FileServing::Content.supported_formats.should == [:raw]
   end

data/spec/unit/file_serving/metadata_spec.rb

@@ -13,10 +13,6 @@ describe Puppet::FileServing::Metadata do
     Puppet::FileServing::Metadata.indirection.name.should == :file_metadata
   end
 
-  it "should should include the IndirectionHooks module in its indirection" do
-    Puppet::FileServing::Metadata.indirection.singleton_class.included_modules.should include(Puppet::FileServing::IndirectionHooks)
-  end
-
   it "should have a method that triggers attribute collection" do
     Puppet::FileServing::Metadata.new("/foo/bar").should respond_to(:collect)
   end

data/spec/unit/file_serving/mount/modules_spec.rb

@@ -12,6 +12,10 @@ describe Puppet::FileServing::Mount::Modules do
   end
 
   describe "when finding files" do
+    it "should fail if no module is specified" do
+      expect { @mount.find("", @request) }.to raise_error(/No module specified/)
+    end
+
     it "should use the provided environment to find the module" do
       @environment.expects(:module)
 
@@ -37,6 +41,10 @@ describe Puppet::FileServing::Mount::Modules do
   end
 
   describe "when searching for files" do
+    it "should fail if no module is specified" do
+      expect { @mount.find("", @request) }.to raise_error(/No module specified/)
+    end
+
     it "should use the node's environment to search the module" do
       @environment.expects(:module)