puppet 0.24.9 → 0.25.0

data/spec/unit/network/authconfig.rb

@@ -0,0 +1,292 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+require 'puppet/network/authconfig'
+
+describe Puppet::Network::AuthConfig do
+    before do
+        @rights = stubs 'rights'
+        Puppet::Network::Rights.stubs(:new).returns(@rights)
+        @rights.stubs(:each).returns([])
+
+        FileTest.stubs(:exists?).returns(true)
+        File.stubs(:stat).returns(stub('stat', :ctime => :now))
+        Time.stubs(:now).returns :now
+
+        @authconfig = Puppet::Network::AuthConfig.new("dummy", false)
+    end
+
+    describe "when initializing" do
+        before :each do
+            Puppet::Network::AuthConfig.any_instance.stubs(:read)
+        end
+
+        it "should use the authconfig default pathname if none provided" do
+            Puppet.expects(:[]).with(:authconfig).returns("dummy")
+
+            Puppet::Network::AuthConfig.new
+        end
+
+        it "should raise an error if no file is defined finally" do
+            Puppet.stubs(:[]).with(:authconfig).returns(nil)
+
+            lambda { Puppet::Network::AuthConfig.new }.should raise_error(Puppet::DevError)
+        end
+
+        it "should read and parse the file if parsenow is true" do
+            Puppet::Network::AuthConfig.any_instance.expects(:read)
+
+            Puppet::Network::AuthConfig.new("dummy", true)
+        end
+
+    end
+
+    describe "when checking authorization" do
+        before :each do
+            @authconfig.stubs(:read)
+            @call = stub 'call', :intern => "name"
+            @handler = stub 'handler', :intern => "handler"
+            @method = stub_everything 'method'
+            @request = stub 'request', :call => @call, :handler => @handler, :method => @method, :name => "me", :ip => "1.2.3.4"
+        end
+
+        it "should attempt to read the authconfig file" do
+            @rights.stubs(:include?)
+
+            @authconfig.expects(:read)
+
+            @authconfig.allowed?(@request)
+        end
+
+        it "should use a name right if it exists" do
+            right = stub 'right'
+
+            @rights.stubs(:include?).with("name").returns(true)
+            @rights.stubs(:[]).with("name").returns(right)
+
+            right.expects(:allowed?).with("me", "1.2.3.4")
+
+            @authconfig.allowed?(@request)
+        end
+
+        it "should use a namespace right otherwise" do
+            right = stub 'right'
+
+            @rights.stubs(:include?).with("name").returns(false)
+            @rights.stubs(:include?).with("handler").returns(true)
+            @rights.stubs(:[]).with("handler").returns(right)
+
+            right.expects(:allowed?).with("me", "1.2.3.4")
+
+            @authconfig.allowed?(@request)
+        end
+
+        it "should return whatever the found rights returns" do
+            right = stub 'right'
+
+            @rights.stubs(:include?).with("name").returns(true)
+            @rights.stubs(:[]).with("name").returns(right)
+
+            right.stubs(:allowed?).with("me", "1.2.3.4").returns(:returned)
+
+            @authconfig.allowed?(@request).should == :returned
+        end
+
+    end
+
+    describe "when parsing authconfig file" do
+        before :each do
+            @fd = stub 'fd'
+            File.stubs(:open).yields(@fd)
+            @rights.stubs(:include?).returns(false)
+            @rights.stubs(:[])
+        end
+
+        it "should skip comments" do
+            @fd.stubs(:each).yields('  # comment')
+
+            @rights.expects(:newright).never
+
+            @authconfig.read
+        end
+
+        it "should increment line number even on commented lines" do
+            @fd.stubs(:each).multiple_yields('  # comment','[puppetca]')
+
+            @rights.expects(:newright).with('[puppetca]', 2, 'dummy')
+
+            @authconfig.read
+        end
+
+        it "should skip blank lines" do
+            @fd.stubs(:each).yields('  ')
+
+            @rights.expects(:newright).never
+
+            @authconfig.read
+        end
+
+        it "should increment line number even on blank lines" do
+            @fd.stubs(:each).multiple_yields('  ','[puppetca]')
+
+            @rights.expects(:newright).with('[puppetca]', 2, 'dummy')
+
+            @authconfig.read
+        end
+
+        it "should throw an error if the current namespace right already exist" do
+            @fd.stubs(:each).yields('[puppetca]')
+
+            @rights.stubs(:include?).with("puppetca").returns(true)
+
+            lambda { @authconfig.read }.should raise_error
+        end
+
+        it "should not throw an error if the current path right already exist" do
+            @fd.stubs(:each).yields('path /hello')
+
+            @rights.stubs(:newright).with("/hello",1, 'dummy')
+            @rights.stubs(:include?).with("/hello").returns(true)
+
+            lambda { @authconfig.read }.should_not raise_error
+        end
+
+        it "should create a new right for found namespaces" do
+            @fd.stubs(:each).yields('[puppetca]')
+
+            @rights.expects(:newright).with("[puppetca]", 1, 'dummy')
+
+            @authconfig.read
+        end
+
+        it "should create a new right for each found namespace line" do
+            @fd.stubs(:each).multiple_yields('[puppetca]', '[fileserver]')
+
+            @rights.expects(:newright).with("[puppetca]", 1, 'dummy')
+            @rights.expects(:newright).with("[fileserver]", 2, 'dummy')
+
+            @authconfig.read
+        end
+
+        it "should create a new right for each found path line" do
+            @fd.stubs(:each).multiple_yields('path /certificates')
+
+            @rights.expects(:newright).with("/certificates", 1, 'dummy')
+
+            @authconfig.read
+        end
+
+        it "should create a new right for each found regex line" do
+            @fd.stubs(:each).multiple_yields('path ~ .rb$')
+
+            @rights.expects(:newright).with("~ .rb$", 1, 'dummy')
+
+            @authconfig.read
+        end
+
+        it "should create an allow ACE on each subsequent allow" do
+            acl = stub 'acl', :info
+
+            @fd.stubs(:each).multiple_yields('[puppetca]', 'allow 127.0.0.1')
+            @rights.stubs(:newright).with("[puppetca]", 1, 'dummy').returns(acl)
+
+            acl.expects(:allow).with('127.0.0.1')
+
+            @authconfig.read
+        end
+
+        it "should create a deny ACE on each subsequent deny" do
+            acl = stub 'acl', :info
+
+            @fd.stubs(:each).multiple_yields('[puppetca]', 'deny 127.0.0.1')
+            @rights.stubs(:newright).with("[puppetca]", 1, 'dummy').returns(acl)
+
+            acl.expects(:deny).with('127.0.0.1')
+
+            @authconfig.read
+        end
+
+        it "should inform the current ACL if we get the 'method' directive" do
+            acl = stub 'acl', :info
+            acl.stubs(:acl_type).returns(:regex)
+
+            @fd.stubs(:each).multiple_yields('path /certificates', 'method search,find')
+            @rights.stubs(:newright).with("/certificates", 1, 'dummy').returns(acl)
+
+            acl.expects(:restrict_method).with('search')
+            acl.expects(:restrict_method).with('find')
+
+            @authconfig.read
+        end
+
+        it "should raise an error if the 'method' directive is used in a right different than a path/regex one" do
+            acl = stub 'acl', :info
+            acl.stubs(:acl_type).returns(:regex)
+
+            @fd.stubs(:each).multiple_yields('[puppetca]', 'method search,find')
+            @rights.stubs(:newright).with("puppetca", 1, 'dummy').returns(acl)
+
+            lambda { @authconfig.read }.should raise_error
+        end
+
+        it "should inform the current ACL if we get the 'environment' directive" do
+            acl = stub 'acl', :info
+            acl.stubs(:acl_type).returns(:regex)
+
+            @fd.stubs(:each).multiple_yields('path /certificates', 'environment production,development')
+            @rights.stubs(:newright).with("/certificates", 1, 'dummy').returns(acl)
+
+            acl.expects(:restrict_environment).with('production')
+            acl.expects(:restrict_environment).with('development')
+
+            @authconfig.read
+        end
+
+        it "should raise an error if the 'environment' directive is used in a right different than a path/regex one" do
+            acl = stub 'acl', :info
+            acl.stubs(:acl_type).returns(:regex)
+
+            @fd.stubs(:each).multiple_yields('[puppetca]', 'environment env')
+            @rights.stubs(:newright).with("puppetca", 1, 'dummy').returns(acl)
+
+            lambda { @authconfig.read }.should raise_error
+        end
+
+        it "should inform the current ACL if we get the 'auth' directive" do
+            acl = stub 'acl', :info
+            acl.stubs(:acl_type).returns(:regex)
+
+            @fd.stubs(:each).multiple_yields('path /certificates', 'auth yes')
+            @rights.stubs(:newright).with("/certificates", 1, 'dummy').returns(acl)
+
+            acl.expects(:restrict_authenticated).with('yes')
+
+            @authconfig.read
+        end
+
+        it "should also allow the longest 'authenticated' directive" do
+            acl = stub 'acl', :info
+            acl.stubs(:acl_type).returns(:regex)
+
+            @fd.stubs(:each).multiple_yields('path /certificates', 'authenticated yes')
+            @rights.stubs(:newright).with("/certificates", 1, 'dummy').returns(acl)
+
+            acl.expects(:restrict_authenticated).with('yes')
+
+            @authconfig.read
+        end
+
+        it "should raise an error if the 'auth' directive is used in a right different than a path/regex one" do
+            acl = stub 'acl', :info
+            acl.stubs(:acl_type).returns(:regex)
+
+            @fd.stubs(:each).multiple_yields('[puppetca]', 'auth yes')
+            @rights.stubs(:newright).with("puppetca", 1, 'dummy').returns(acl)
+
+            lambda { @authconfig.read }.should raise_error
+        end
+
+    end
+
+end

data/spec/unit/network/authstore.rb

@@ -0,0 +1,94 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+require 'puppet/network/authconfig'
+
+describe Puppet::Network::AuthStore::Declaration do
+
+    describe "when the pattern is simple numeric IP" do
+        before :each do
+            @ip = '100.101.99.98'
+            @declaration = Puppet::Network::AuthStore::Declaration.new(:allow,@ip)
+        end
+        it "should match the specified IP" do
+            @declaration.should be_match('www.testsite.org',@ip)
+        end
+        it "should not match other IPs" do
+            @declaration.should_not be_match('www.testsite.org','200.101.99.98')
+        end
+    end
+
+    describe "when the pattern is a numeric IP with a back reference" do
+        before :each do
+            @ip = '100.101.$1'
+            @declaration = Puppet::Network::AuthStore::Declaration.new(:allow,@ip).interpolate('12.34'.match(/(.*)/))
+        end
+        it "should match an IP with the apropriate interpolation" do
+            @declaration.should be_match('www.testsite.org',@ip.sub(/\$1/,'12.34'))
+        end
+        it "should not match other IPs" do
+            @declaration.should_not be_match('www.testsite.org',@ip.sub(/\$1/,'66.34'))
+        end
+    end
+
+    describe "when the pattern is a PQDN" do
+        before :each do
+            @host = 'spirit.mars.nasa.gov'
+            @declaration = Puppet::Network::AuthStore::Declaration.new(:allow,@host)
+        end
+        it "should match the specified PQDN" do
+            pending "FQDN consensus"
+            @declaration.should be_match(@host,'200.101.99.98')
+        end
+        it "should not match a similar FQDN" do
+            pending "FQDN consensus"
+            @declaration.should_not be_match(@host+'.','200.101.99.98')
+        end
+    end
+
+    describe "when the pattern is a FQDN" do
+        before :each do
+            @host = 'spirit.mars.nasa.gov.'
+            @declaration = Puppet::Network::AuthStore::Declaration.new(:allow,@host)
+        end
+        it "should match the specified FQDN" do
+            pending "FQDN consensus"
+            @declaration.should be_match(@host,'200.101.99.98')
+        end
+        it "should not match a similar PQDN" do
+            #pending "FQDN consensus"
+            @declaration.should_not be_match(@host[0..-2],'200.101.99.98')
+        end
+    end
+
+
+    describe "when the pattern is an opaque string with a back reference" do
+        before :each do
+            @host = 'c216f41a-f902-4bfb-a222-850dd957bebb'
+            @item = "/catalog/#{@host}"
+            @pattern = %{^/catalog/([^/]+)$}
+            @declaration = Puppet::Network::AuthStore::Declaration.new(:allow,'$1')
+        end
+        it "should match an IP with the apropriate interpolation" do
+            @declaration.interpolate(@item.match(@pattern)).should be_match(@host,'10.0.0.5')
+        end
+    end
+
+    describe "when comparing patterns" do
+        before :each do
+            @ip        = Puppet::Network::AuthStore::Declaration.new(:allow,'127.0.0.1')
+            @host_name = Puppet::Network::AuthStore::Declaration.new(:allow,'www.hard_knocks.edu')
+            @opaque    = Puppet::Network::AuthStore::Declaration.new(:allow,'hey_dude')
+        end
+        it "should consider ip addresses before host names" do
+            (@ip < @host_name).should be_true
+        end
+        it "should consider ip addresses before opaque strings" do
+            (@ip < @opaque).should be_true
+        end
+        it "should consider host_names before opaque strings" do
+            (@host_name < @opaque).should be_true
+        end
+    end
+end

data/spec/unit/network/client.rb

@@ -24,7 +24,7 @@ describe Puppet::Network::Client do
             Net::HTTP.stubs(:new).returns http
 
             # Pick a random subclass...
-            Puppet::Network::Client.master.new :Server => Puppet[:server]
+            Puppet::Network::Client.runner.new :Server => Puppet[:server]
         end
     end
 
@@ -39,7 +39,7 @@ describe Puppet::Network::Client do
             Net::HTTP.stubs(:new).returns http
 
             # Pick a random subclass...
-            Puppet::Network::Client.master.new :Server => Puppet[:server]
+            Puppet::Network::Client.runner.new :Server => Puppet[:server]
         end
     end
 end

data/spec/unit/network/client/dipper.rb

@@ -0,0 +1,16 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../../../spec_helper'
+
+describe Puppet::Network::Client.dipper do
+    it "should fail in an informative way when there are failures backing up to the server" do
+        FileTest.stubs(:exists?).returns true
+        File.stubs(:read).returns "content"
+
+        @dipper = Puppet::Network::Client::Dipper.new(:Path => "/my/bucket")
+
+        @dipper.driver.expects(:addfile).raises ArgumentError
+
+        lambda { @dipper.backup("/my/file") }.should raise_error(Puppet::Error)
+    end
+end

data/spec/unit/network/format.rb

@@ -0,0 +1,191 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+require 'puppet/network/format'
+
+# A class with all of the necessary
+# hooks.
+class FormatRenderer
+    def self.to_multiple_my_format(list)
+    end
+
+    def self.from_multiple_my_format(text)
+    end
+
+    def self.from_my_format(text)
+    end
+
+    def to_my_format
+    end
+end
+
+describe Puppet::Network::Format do
+    describe "when initializing" do
+        it "should require a name" do
+            lambda { Puppet::Network::Format.new }.should raise_error(ArgumentError)
+        end
+
+        it "should be able to provide its name" do
+            Puppet::Network::Format.new(:my_format).name.should == :my_format
+        end
+
+        it "should always convert its name to a downcased symbol" do
+            Puppet::Network::Format.new(:My_Format).name.should == :my_format
+        end
+
+        it "should be able to set its downcased mime type at initialization" do
+            format = Puppet::Network::Format.new(:my_format, :mime => "Foo/Bar")
+            format.mime.should == "foo/bar"
+        end
+
+        it "should default to text plus the name of the format as the mime type" do
+            Puppet::Network::Format.new(:my_format).mime.should == "text/my_format"
+        end
+
+        it "should fail if unsupported options are provided" do
+            lambda { Puppet::Network::Format.new(:my_format, :foo => "bar") }.should raise_error(ArgumentError)
+        end
+    end
+
+    describe "instances" do
+        before do
+            @format = Puppet::Network::Format.new(:my_format)
+        end
+
+        it "should support being confined" do
+            @format.should respond_to(:confine)
+        end
+
+        it "should not be considered suitable if confinement conditions are not met" do
+            @format.confine :true => false
+            @format.should_not be_suitable
+        end
+
+        it "should be able to determine if a class is supported" do
+            @format.should respond_to(:supported?)
+        end
+
+        it "should consider a class to be supported if it has the individual and multiple methods for rendering and interning" do
+            @format.should be_supported(FormatRenderer)
+        end
+
+        it "should default to its required methods being the individual and multiple methods for rendering and interning" do
+            Puppet::Network::Format.new(:foo).required_methods.sort { |a,b| a.to_s <=> b.to_s }.should ==  [:intern_method, :intern_multiple_method, :render_multiple_method, :render_method].sort { |a,b| a.to_s <=> b.to_s }
+        end
+
+        it "should consider a class supported if the provided class has all required methods present" do
+            format = Puppet::Network::Format.new(:foo)
+            [:intern_method, :intern_multiple_method, :render_multiple_method, :render_method].each do |method|
+                format.expects(:required_method_present?).with { |name, klass, type| name == method and klass == String }.returns true
+            end
+
+            format.should be_required_methods_present(String)
+        end
+
+        it "should consider a class not supported if any required methods are missing from the provided class" do
+            format = Puppet::Network::Format.new(:foo)
+            format.stubs(:required_method_present?).returns true
+            format.expects(:required_method_present?).with { |name, *args| name == :intern_method }.returns false
+            format.should_not be_required_methods_present(String)
+        end
+
+        it "should be able to specify the methods required for support" do
+            Puppet::Network::Format.new(:foo, :required_methods => [:render_method, :intern_method]).required_methods.should == [:render_method, :intern_method]
+        end
+
+        it "should only test for required methods if specific methods are specified as required" do
+            format = Puppet::Network::Format.new(:foo, :required_methods => [:intern_method])
+            format.expects(:required_method_present?).with { |name, klass, type| name == :intern_method }
+
+            format.required_methods_present?(String)
+        end
+
+        it "should not consider a class supported unless the format is suitable" do
+            @format.expects(:suitable?).returns false
+            @format.should_not be_supported(FormatRenderer)
+        end
+
+        it "should always downcase mimetypes" do
+            @format.mime = "Foo/Bar"
+            @format.mime.should == "foo/bar"
+        end
+
+        it "should support having a weight" do
+            @format.should respond_to(:weight)
+        end
+
+        it "should default to a weight of of 5" do
+            @format.weight.should == 5
+        end
+
+        it "should be able to override its weight at initialization" do
+            Puppet::Network::Format.new(:foo, :weight => 1).weight.should == 1
+        end
+
+        [:intern_method, :intern_multiple_method, :render_multiple_method, :render_method].each do |method|
+            it "should allow assignment of the #{method}" do
+                Puppet::Network::Format.new(:foo, method => :foo).send(method).should == :foo
+            end
+        end
+    end
+
+    describe "when converting between instances and formatted text" do
+        before do
+            @format = Puppet::Network::Format.new(:my_format)
+            @instance = FormatRenderer.new
+        end
+
+        it "should have a method for rendering a single instance" do
+            @format.should respond_to(:render)
+        end
+
+        it "should have a method for rendering multiple instances" do
+            @format.should respond_to(:render_multiple)
+        end
+
+        it "should have a method for interning text" do
+            @format.should respond_to(:intern)
+        end
+
+        it "should have a method for interning text into multiple instances" do
+            @format.should respond_to(:intern_multiple)
+        end
+
+        it "should return the results of calling the instance-specific render method if the method is present" do
+            @instance.expects(:to_my_format).returns "foo"
+            @format.render(@instance).should == "foo"
+        end
+
+        it "should return the results of calling the class-specific render_multiple method if the method is present" do
+            @instance.class.expects(:to_multiple_my_format).returns ["foo"]
+            @format.render_multiple([@instance]).should == ["foo"]
+        end
+
+        it "should return the results of calling the class-specific intern method if the method is present" do
+            FormatRenderer.expects(:from_my_format).with("foo").returns @instance
+            @format.intern(FormatRenderer, "foo").should equal(@instance)
+        end
+
+        it "should return the results of calling the class-specific intern_multiple method if the method is present" do
+            FormatRenderer.expects(:from_multiple_my_format).with("foo").returns [@instance]
+            @format.intern_multiple(FormatRenderer, "foo").should == [@instance]
+        end
+
+        it "should fail if asked to render and the instance does not respond to 'to_<format>'" do
+            lambda { @format.render("foo") }.should raise_error(NotImplementedError)
+        end
+
+        it "should fail if asked to intern and the class does not respond to 'from_<format>'" do
+            lambda { @format.intern(String, "foo") }.should raise_error(NotImplementedError)
+        end
+
+        it "should fail if asked to intern multiple and the class does not respond to 'from_multiple_<format>'" do
+            lambda { @format.intern_multiple(String, "foo") }.should raise_error(NotImplementedError)
+        end
+
+        it "should fail if asked to render multiple and the instance does not respond to 'to_multiple_<format>'" do
+            lambda { @format.render_multiple(["foo", "bar"]) }.should raise_error(NotImplementedError)
+        end
+    end
+end