puppet 2.6.18 → 2.7.1

data/spec/unit/module_spec.rb

@@ -1,8 +1,10 @@
-#!/usr/bin/env ruby
-
-require File.dirname(__FILE__) + '/../spec_helper'
+#!/usr/bin/env rspec
+require 'spec_helper'
+require 'puppet_spec/files'
 
 describe Puppet::Module do
+  include PuppetSpec::Files
+
   before do
     # This is necessary because of the extra checks we have for the deprecated
     # 'plugins' directory
@@ -267,17 +269,39 @@ describe Puppet::Module do
   end
 
   it "should return the path to the first found instance in its environment's module paths as its path" do
+    dir = tmpdir("deep_path")
+    first = File.join(dir, "first")
+    second = File.join(dir, "second")
+
+    FileUtils.mkdir_p(first)
+    FileUtils.mkdir_p(second)
+    Puppet[:modulepath] = "#{first}:#{second}"
+
+    modpath = File.join(first, "foo")
+    FileUtils.mkdir_p(modpath)
+
+    # Make a second one, which we shouldn't find
+    FileUtils.mkdir_p(File.join(second, "foo"))
+
     mod = Puppet::Module.new("foo")
-    env = mock 'environment'
-    mod.stubs(:environment).returns env
+    mod.path.should == modpath
+  end
+
+  it "should be able to find itself in a directory other than the first directory in the module path" do
+    dir = tmpdir("deep_path")
+    first = File.join(dir, "first")
+    second = File.join(dir, "second")
 
-    env.expects(:modulepath).returns %w{/a /b /c}
+    FileUtils.mkdir_p(first)
+    FileUtils.mkdir_p(second)
+    Puppet[:modulepath] = "#{first}:#{second}"
 
-    FileTest.expects(:exist?).with("/a/foo").returns false
-    FileTest.expects(:exist?).with("/b/foo").returns true
-    FileTest.expects(:exist?).with("/c/foo").never
+    modpath = File.join(second, "foo")
+    FileUtils.mkdir_p(modpath)
 
-    mod.path.should == "/b/foo"
+    mod = Puppet::Module.new("foo")
+    mod.should be_exist
+    mod.path.should == modpath
   end
 
   it "should be considered existent if it exists in at least one module path" do

data/spec/unit/network/authconfig_spec.rb

@@ -1,6 +1,5 @@
-#!/usr/bin/env ruby
-
-require File.dirname(__FILE__) + '/../../spec_helper'
+#!/usr/bin/env rspec
+require 'spec_helper'
 
 require 'puppet/network/authconfig'
 
@@ -12,7 +11,7 @@ describe Puppet::Network::AuthConfig do
 
     FileTest.stubs(:exists?).returns(true)
     File.stubs(:stat).returns(stub('stat', :ctime => :now))
-    Time.stubs(:now).returns :now
+    Time.stubs(:now).returns Time.now
 
     @authconfig = Puppet::Network::AuthConfig.new("dummy", false)
   end

data/spec/unit/network/authstore_spec.rb

@@ -1,6 +1,5 @@
-#!/usr/bin/env ruby
-
-require File.dirname(__FILE__) + '/../../spec_helper'
+#!/usr/bin/env rspec
+require 'spec_helper'
 
 require 'puppet/network/authconfig'
 
@@ -86,7 +85,7 @@ describe Puppet::Network::AuthStore::Declaration do
   [
     "02001:0000:1234:0000:0000:C1C0:ABCD:0876",
     "2001:0000:1234:0000:00001:C1C0:ABCD:0876",
-    " 2001:0000:1234:0000:0000:C1C0:ABCD:0876  0",
+    " 2001:0000:1234:0000:0000:C1C0:ABCD:0876  0",
     "2001:0000:1234: 0000:0000:C1C0:ABCD:0876",
     "3ffe:0b00:0000:0001:0000:0000:000a",
     "FF02:0000:0000:0000:0000:0000:0000:0000:0001",

data/spec/unit/network/client_spec.rb

@@ -0,0 +1,45 @@
+#!/usr/bin/env rspec
+#
+#  Created by Luke Kanies on 2008-3-24.
+#  Copyright (c) 2008. All rights reserved.
+
+require 'spec_helper'
+
+require 'puppet/network/client'
+
+describe Puppet::Network::Client do
+  before do
+    Puppet.settings.stubs(:use).returns(true)
+    Puppet::Network::HttpPool.stubs(:cert_setup)
+  end
+
+  describe "when keep-alive is enabled" do
+    before do
+      Puppet::Network::HttpPool.stubs(:keep_alive?).returns true
+    end
+    it "should start the http client up on creation" do
+      http = mock 'http'
+      http.stub_everything
+      http.expects(:start)
+      Net::HTTP.stubs(:new).returns http
+
+      # Pick a random subclass...
+      Puppet::Network::Client.runner.new :Server => Puppet[:server]
+    end
+  end
+
+  describe "when keep-alive is disabled" do
+    before do
+      Puppet::Network::HttpPool.stubs(:keep_alive?).returns false
+    end
+    it "should not start the http client up on creation" do
+      http = mock 'http'
+      http.stub_everything
+      http.expects(:start).never
+      Net::HTTP.stubs(:new).returns http
+
+      # Pick a random subclass...
+      Puppet::Network::Client.runner.new :Server => Puppet[:server]
+    end
+  end
+end

data/spec/unit/network/format_handler_spec.rb

@@ -1,6 +1,5 @@
-#!/usr/bin/env ruby
-
-require File.dirname(__FILE__) + '/../../spec_helper'
+#!/usr/bin/env rspec
+require 'spec_helper'
 
 require 'puppet/network/format_handler'
 

data/spec/unit/network/format_spec.rb

@@ -1,6 +1,5 @@
-#!/usr/bin/env ruby
-
-require File.dirname(__FILE__) + '/../../spec_helper'
+#!/usr/bin/env rspec
+require 'spec_helper'
 
 require 'puppet/network/format'
 

data/spec/unit/network/formats_spec.rb

@@ -1,6 +1,5 @@
-#!/usr/bin/env ruby
-
-require File.dirname(__FILE__) + '/../../spec_helper'
+#!/usr/bin/env rspec
+require 'spec_helper'
 
 require 'puppet/network/formats'
 
@@ -163,6 +162,49 @@ describe "Puppet Network Format" do
 
   end
 
+  it "should include a marshal format" do
+    Puppet::Network::FormatHandler.format(:marshal).should_not be_nil
+  end
+
+  describe "marshal" do
+    before do
+      @marshal = Puppet::Network::FormatHandler.format(:marshal)
+    end
+
+    it "should have its mime type set to text/marshal" do
+      Puppet::Network::FormatHandler.format(:marshal).mime.should == "text/marshal"
+    end
+
+    it "should be supported on Strings" do
+      @marshal.should be_supported(String)
+    end
+
+    it "should render by calling 'Marshal.dump' on the instance" do
+      instance = mock 'instance'
+      Marshal.expects(:dump).with(instance).returns "foo"
+      @marshal.render(instance).should == "foo"
+    end
+
+    it "should render multiple instances by calling 'to_marshal' on the array" do
+      instances = [mock('instance')]
+
+      Marshal.expects(:dump).with(instances).returns "foo"
+      @marshal.render_multiple(instances).should == "foo"
+    end
+
+    it "should intern by calling 'Marshal.load'" do
+      text = "foo"
+      Marshal.expects(:load).with("foo").returns "bar"
+      @marshal.intern(String, text).should == "bar"
+    end
+
+    it "should intern multiples by calling 'Marshal.load'" do
+      text = "foo"
+      Marshal.expects(:load).with("foo").returns "bar"
+      @marshal.intern_multiple(String, text).should == "bar"
+    end
+  end
+
   describe "plaintext" do
     before do
       @text = Puppet::Network::FormatHandler.format(:s)
@@ -288,4 +330,66 @@ describe "Puppet Network Format" do
       end
     end
   end
+
+  describe ":console format" do
+    subject { Puppet::Network::FormatHandler.format(:console) }
+    it { should be_an_instance_of Puppet::Network::Format }
+    let :json do Puppet::Network::FormatHandler.format(:pson) end
+
+    [:intern, :intern_multiple].each do |method|
+      it "should not implement #{method}" do
+        expect { subject.send(method, String, 'blah') }.to raise_error NotImplementedError
+      end
+    end
+
+    ["hello", 1, 1.0].each do |input|
+      it "should just return a #{input.inspect}" do
+        subject.render(input).should == input
+      end
+    end
+
+    [[1, 2], ["one"], [{ 1 => 1 }]].each do |input|
+      it "should render #{input.inspect} as JSON" do
+        subject.render(input).should == json.render(input).chomp
+      end
+    end
+
+    it "should render a non-trivially-keyed Hash as JSON" do
+      hash = { [1,2] => 3, [2,3] => 5, [3,4] => 7 }
+      subject.render(hash).should == json.render(hash).chomp
+    end
+
+    it "should render a {String,Numeric}-keyed Hash into a table" do
+      object = Object.new
+      hash = { "one" => 1, "two" => [], "three" => {}, "four" => object,
+        5 => 5, 6.0 => 6 }
+
+      # Gotta love ASCII-betical sort order.  Hope your objects are better
+      # structured for display than my test one is. --daniel 2011-04-18
+      subject.render(hash).should == <<EOT
+5      5
+6.0    6
+four   #{json.render(object).chomp}
+one    1
+three  {}
+two    []
+EOT
+    end
+
+    it "should render a hash nicely with a multi-line value" do
+      pending "Moving to PSON rather than PP makes this unsupportable."
+      hash = {
+        "number" => { "1" => '1' * 40, "2" => '2' * 40, '3' => '3' * 40 },
+        "text"   => { "a" => 'a' * 40, 'b' => 'b' * 40, 'c' => 'c' * 40 }
+      }
+      subject.render(hash).should == <<EOT
+number  {"1"=>"1111111111111111111111111111111111111111",
+         "2"=>"2222222222222222222222222222222222222222",
+         "3"=>"3333333333333333333333333333333333333333"}
+text    {"a"=>"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
+         "b"=>"bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb",
+         "c"=>"cccccccccccccccccccccccccccccccccccccccc"}
+EOT
+    end
+  end
 end

data/spec/unit/network/handler/fileserver_spec.rb

@@ -1,6 +1,5 @@
-#!/usr/bin/env ruby
-
-require File.dirname(__FILE__) + '/../../../spec_helper'
+#!/usr/bin/env rspec
+require 'spec_helper'
 
 require 'puppet/network/handler/fileserver'
 
@@ -124,7 +123,7 @@ describe Puppet::Network::Handler::FileServer do
     list.sort.should == [ ["/aFile", "file"], ["/", "directory"] ].sort
   end
 
-  describe Puppet::Network::Handler::FileServer::PluginMount do
+  describe Puppet::Network::Handler::FileServer::PluginMount, :'fails_on_ruby_1.9.2' => true do
     PLUGINS = Puppet::Network::Handler::FileServer::PLUGINS
 
     # create a module plugin hierarchy

data/spec/unit/network/http/api/v1_spec.rb

@@ -1,6 +1,5 @@
-#!/usr/bin/env ruby
-
-Dir.chdir(File.dirname(__FILE__)) { (s = lambda { |f| File.exist?(f) ? require(f) : Dir.chdir("..") { s.call(f) } }).call("spec/spec_helper.rb") }
+#!/usr/bin/env rspec
+require 'spec_helper'
 
 require 'puppet/network/http/api/v1'
 
@@ -32,7 +31,7 @@ describe Puppet::Network::HTTP::API::V1 do
     end
 
     it "should use the first field of the URI as the environment" do
-      @tester.uri2indirection("GET", "/env/foo/bar", {}).environment.should == Puppet::Node::Environment.new("env")
+      @tester.uri2indirection("GET", "/env/foo/bar", {})[3][:environment].to_s.should == "env"
     end
 
     it "should fail if the environment is not alphanumeric" do
@@ -40,19 +39,15 @@ describe Puppet::Network::HTTP::API::V1 do
     end
 
     it "should use the environment from the URI even if one is specified in the parameters" do
-      @tester.uri2indirection("GET", "/env/foo/bar", {:environment => "otherenv"}).environment.should == Puppet::Node::Environment.new("env")
-    end
-
-    it "should not pass a buck_path parameter through (See Bugs #13553, #13518, #13511)" do
-      @tester.uri2indirection("GET", "/env/foo/bar", { :bucket_path => "/malicious/path" }).options.should_not include({ :bucket_path => "/malicious/path" })
+      @tester.uri2indirection("GET", "/env/foo/bar", {:environment => "otherenv"})[3][:environment].to_s.should == "env"
     end
 
-    it "should pass allowed parameters through" do
-      @tester.uri2indirection("GET", "/env/foo/bar", { :allowed_param => "value" }).options.should include({ :allowed_param => "value" })
+    it "should return the environment as a Puppet::Node::Environment" do
+      @tester.uri2indirection("GET", "/env/foo/bar", {})[3][:environment].should be_a Puppet::Node::Environment
     end
 
     it "should use the second field of the URI as the indirection name" do
-      @tester.uri2indirection("GET", "/env/foo/bar", {}).indirection_name.should == :foo
+      @tester.uri2indirection("GET", "/env/foo/bar", {})[0].should == "foo"
     end
 
     it "should fail if the indirection name is not alphanumeric" do
@@ -60,11 +55,11 @@ describe Puppet::Network::HTTP::API::V1 do
     end
 
     it "should use the remainder of the URI as the indirection key" do
-      @tester.uri2indirection("GET", "/env/foo/bar", {}).key.should == "bar"
+      @tester.uri2indirection("GET", "/env/foo/bar", {})[2].should == "bar"
     end
 
     it "should support the indirection key being a /-separated file path" do
-      @tester.uri2indirection("GET", "/env/foo/bee/baz/bomb", {}).key.should == "bee/baz/bomb"
+      @tester.uri2indirection("GET", "/env/foo/bee/baz/bomb", {})[2].should == "bee/baz/bomb"
     end
 
     it "should fail if no indirection key is specified" do
@@ -73,51 +68,67 @@ describe Puppet::Network::HTTP::API::V1 do
     end
 
     it "should choose 'find' as the indirection method if the http method is a GET and the indirection name is singular" do
-      @tester.uri2indirection("GET", "/env/foo/bar", {}).method.should == :find
+      @tester.uri2indirection("GET", "/env/foo/bar", {})[1].should == :find
+    end
+
+    it "should choose 'find' as the indirection method if the http method is a POST and the indirection name is singular" do
+      @tester.uri2indirection("POST", "/env/foo/bar", {})[1].should == :find
     end
 
     it "should choose 'head' as the indirection method if the http method is a HEAD and the indirection name is singular" do
-      @tester.uri2indirection("HEAD", "/env/foo/bar", {}).method.should == :head
+      @tester.uri2indirection("HEAD", "/env/foo/bar", {})[1].should == :head
     end
 
     it "should choose 'search' as the indirection method if the http method is a GET and the indirection name is plural" do
-      @tester.uri2indirection("GET", "/env/foos/bar", {}).method.should == :search
+      @tester.uri2indirection("GET", "/env/foos/bar", {})[1].should == :search
     end
 
     it "should choose 'find' as the indirection method if the http method is a GET and the indirection name is facts" do
-      @tester.uri2indirection("GET", "/env/facts/bar", {}).method.should == :find
+      @tester.uri2indirection("GET", "/env/facts/bar", {})[1].should == :find
     end
 
     it "should choose 'save' as the indirection method if the http method is a PUT and the indirection name is facts" do
-      @tester.uri2indirection("PUT", "/env/facts/bar", {}).method.should == :save
+      @tester.uri2indirection("PUT", "/env/facts/bar", {})[1].should == :save
     end
 
     it "should choose 'search' as the indirection method if the http method is a GET and the indirection name is inventory" do
-      @tester.uri2indirection("GET", "/env/inventory/search", {}).method.should == :search
+      @tester.uri2indirection("GET", "/env/inventory/search", {})[1].should == :search
+    end
+
+    it "should choose 'find' as the indirection method if the http method is a GET and the indirection name is facts" do
+      @tester.uri2indirection("GET", "/env/facts/bar", {})[1].should == :find
+    end
+
+    it "should choose 'save' as the indirection method if the http method is a PUT and the indirection name is facts" do
+      @tester.uri2indirection("PUT", "/env/facts/bar", {})[1].should == :save
+    end
+
+    it "should choose 'search' as the indirection method if the http method is a GET and the indirection name is inventory" do
+      @tester.uri2indirection("GET", "/env/inventory/search", {})[1].should == :search
     end
 
     it "should choose 'search' as the indirection method if the http method is a GET and the indirection name is facts_search" do
-      @tester.uri2indirection("GET", "/env/facts_search/bar", {}).method.should == :search
+      @tester.uri2indirection("GET", "/env/facts_search/bar", {})[1].should == :search
     end
 
     it "should change indirection name to 'facts' if the http method is a GET and the indirection name is facts_search" do
-      @tester.uri2indirection("GET", "/env/facts_search/bar", {}).indirection_name.should == :facts
+      @tester.uri2indirection("GET", "/env/facts_search/bar", {})[0].should == 'facts'
     end
 
     it "should not change indirection name from 'facts' if the http method is a GET and the indirection name is facts" do
-      @tester.uri2indirection("GET", "/env/facts/bar", {}).indirection_name.should == :facts
+      @tester.uri2indirection("GET", "/env/facts/bar", {})[0].should == 'facts'
     end
 
     it "should change indirection name to 'status' if the http method is a GET and the indirection name is statuses" do
-      @tester.uri2indirection("GET", "/env/statuses/bar", {}).indirection_name.should == :status
+      @tester.uri2indirection("GET", "/env/statuses/bar", {})[0].should == 'status'
     end
 
     it "should choose 'delete' as the indirection method if the http method is a DELETE and the indirection name is singular" do
-      @tester.uri2indirection("DELETE", "/env/foo/bar", {}).method.should == :destroy
+      @tester.uri2indirection("DELETE", "/env/foo/bar", {})[1].should == :destroy
     end
 
     it "should choose 'save' as the indirection method if the http method is a PUT and the indirection name is singular" do
-      @tester.uri2indirection("PUT", "/env/foo/bar", {}).method.should == :save
+      @tester.uri2indirection("PUT", "/env/foo/bar", {})[1].should == :save
     end
 
     it "should fail if an indirection method cannot be picked" do
@@ -126,7 +137,8 @@ describe Puppet::Network::HTTP::API::V1 do
 
     it "should URI unescape the indirection key" do
       escaped = URI.escape("foo bar")
-      @tester.uri2indirection("GET", "/env/foo/#{escaped}", {}).key.should == "foo bar"
+      indirection_name, method, key, params = @tester.uri2indirection("GET", "/env/foo/#{escaped}", {})
+      key.should == "foo bar"
     end
   end
 
@@ -159,4 +171,26 @@ describe Puppet::Network::HTTP::API::V1 do
     end
   end
 
+  describe "when converting a request into a URI with body" do
+    before :each do
+      @request = Puppet::Indirector::Request.new(:foo, :find, "with spaces", :foo => :bar, :environment => "myenv")
+    end
+
+    it "should use the environment as the first field of the URI" do
+      @tester.request_to_uri_and_body(@request).first.split("/")[1].should == "myenv"
+    end
+
+    it "should use the indirection as the second field of the URI" do
+      @tester.request_to_uri_and_body(@request).first.split("/")[2].should == "foo"
+    end
+
+    it "should use the escaped key as the remainder of the URI" do
+      escaped = URI.escape("with spaces")
+      @tester.request_to_uri_and_body(@request).first.split("/")[3].sub(/\?.+/, '').should == escaped
+    end
+
+    it "should return the URI and body separately" do
+      @tester.request_to_uri_and_body(@request).should == ["/myenv/foo/with%20spaces", "foo=bar"]
+    end
+  end
 end