puppet 0.25.0 → 0.25.1

data/spec/unit/parser/functions/require.rb

@@ -7,8 +7,10 @@ describe "the require function" do
     before :each do
         @catalog = stub 'catalog'
         @compiler = stub 'compiler', :catalog => @catalog
+
+        @resource = stub 'resource', :set_parameter => nil, :metaparam_compatibility_mode? => false
         @scope = Puppet::Parser::Scope.new()
-        @scope.stubs(:resource).returns("ourselves")
+        @scope.stubs(:resource).returns @resource
         @scope.stubs(:findresource)
         @scope.stubs(:compiler).returns(@compiler)
     end
@@ -18,19 +20,29 @@ describe "the require function" do
     end
 
     it "should delegate to the 'include' puppet function" do
-        @catalog.stubs(:add_edge)
         @scope.expects(:function_include).with("myclass")
 
         @scope.function_require("myclass")
     end
 
-    it "should add a catalog edge from our parent resource to the included one" do
-        @scope.stubs(:function_include).with("myclass")
-        @scope.stubs(:findresource).with(:class, "myclass").returns("includedclass")
-
-        @catalog.expects(:add_edge).with("ourselves","includedclass")
+    it "should set the 'require' prarameter on the resource to a resource reference" do
+        @resource.expects(:set_parameter).with { |name, value| name == :require and value.is_a?(Puppet::Parser::Resource::Reference) }
+        @scope.stubs(:function_include)
+        @scope.function_require("myclass")
+    end
 
+    it "should verify the 'include' function is loaded" do
+        Puppet::Parser::Functions.expects(:function).with(:include).returns(:function_include)
+        @scope.stubs(:function_include)
         @scope.function_require("myclass")
     end
 
+    it "should include the class but not add a dependency if used on a client not at least version 0.25" do
+        @resource.expects(:metaparam_compatibility_mode?).returns true
+        @scope.expects(:warning)
+        @resource.expects(:set_parameter).never
+        @scope.expects(:function_include)
+
+        @scope.function_require("myclass")
+    end
 end

data/spec/unit/parser/interpreter.rb

@@ -10,7 +10,7 @@ describe Puppet::Parser::Interpreter do
 
     describe "when creating parser instances" do
         it "should create a parser with code if there is code defined in the :code setting" do
-            Puppet.settings.stubs(:value).with(:code, :myenv).returns("mycode")
+            Puppet.settings.stubs(:uninterpolated_value).with(:code, :myenv).returns("mycode")
             @parser.expects(:string=).with("mycode")
             @parser.expects(:parse)
             Puppet::Parser::Parser.expects(:new).with(:environment => :myenv).returns(@parser)
@@ -18,7 +18,7 @@ describe Puppet::Parser::Interpreter do
         end
 
         it "should create a parser with the main manifest when the code setting is an empty string" do
-            Puppet.settings.stubs(:value).with(:code, :myenv).returns("")
+            Puppet.settings.stubs(:uninterpolated_value).with(:code, :myenv).returns("")
             Puppet.settings.stubs(:value).with(:manifest, :myenv).returns("/my/file")
             @parser.expects(:parse)
             @parser.expects(:file=).with("/my/file")

data/spec/unit/parser/lexer.rb

@@ -460,18 +460,43 @@ describe Puppet::Parser::Lexer::TOKENS[:REGEX] do
         @token.regex.should =~ '/this is a regex/'
     end
 
-    describe "when including escaped slashes" do
-        before { @lexer = Puppet::Parser::Lexer.new }
+    it 'should not match if there is \n in the regex' do
+        @token.regex.should_not =~ "/this is \n a regex/"
+    end
 
-        it "should not consider escaped slashes to be the end of a regex" do
-            @lexer.string = "/this \\/ foo/"
+    describe "when scanning" do
+        def tokens_scanned_from(s)
+            lexer = Puppet::Parser::Lexer.new
+            lexer.string = s
             tokens = []
-            @lexer.scan do |name, value|
+            lexer.scan do |name, value|
                 tokens << value
             end
-            tokens[0][:value].should == Regexp.new("this / foo")
+            tokens[0..-2]
         end
-    end
+
+        it "should not consider escaped slashes to be the end of a regex" do
+            tokens_scanned_from("$x =~ /this \\/ foo/").last[:value].should == Regexp.new("this / foo")
+        end
+
+        it "should not lex chained division as a regex" do
+            tokens_scanned_from("$x = $a/$b/$c").any? {|t| t[:value].class == Regexp }.should == false
+        end
+
+        it "should accept a regular expression after NODE" do
+            tokens_scanned_from("node /www.*\.mysite\.org/").last[:value].should == Regexp.new("www.*\.mysite\.org")
+        end
+
+        it "should accept regular expressions in a CASE" do
+            s = %q{case $variable {
+                "something": {$othervar = 4096 / 2}
+                /regex/: {notice("this notably sucks")}
+                }
+            }
+            tokens_scanned_from(s)[12][:value].should == Regexp.new("regex")
+        end
+ 
+   end
 
 
     it "should return the REGEX token and a Regexp" do

data/spec/unit/parser/loaded_code.rb

@@ -156,7 +156,24 @@ describe Puppet::Parser::LoadedCode do
             nameout = Puppet::Parser::AST::HostName.new(:value => "foo")
 
             @loader.add_node(namein, "bar")
-            @loader.node(nameout) == "bar"
+            @loader.node(nameout).should == "bar"
+        end
+
+        it "should be able to find node by HostName strict equality" do
+            namein = Puppet::Parser::AST::HostName.new(:value => "foo")
+            nameout = Puppet::Parser::AST::HostName.new(:value => "foo")
+
+            @loader.add_node(namein, "bar")
+            @loader.node_exists?(nameout).should == "bar"
+        end
+
+        it "should not use node name matching when finding with strict node HostName" do
+            name1 = Puppet::Parser::AST::HostName.new(:value => "foo")
+            name2 = Puppet::Parser::AST::HostName.new(:value => Puppet::Parser::AST::Regex.new(:value => /foo/))
+
+            @loader.add_node(name1, "bar")
+            @loader.add_node(name2, "baz")
+            @loader.node_exists?(name1).should == "bar"
         end
 
         it "should return the first matching regex nodename" do

data/spec/unit/parser/parser.rb

@@ -253,7 +253,7 @@ describe Puppet::Parser do
         end
 
         it "should raise an error if the node already exists" do
-            @loaded_code.stubs(:node).with(@nodename).returns(@node)
+            @loaded_code.stubs(:node_exists?).with(@nodename).returns(@node)
 
             lambda { @parser.newnode(@nodename) }.should raise_error
         end
@@ -324,9 +324,17 @@ describe Puppet::Parser do
         it "should use the output of the config_version setting if one is provided" do
             Puppet.settings.stubs(:[]).with(:config_version).returns("/my/foo")
 
-            @parser.expects(:`).with("/my/foo").returns "output\n"
+            Puppet::Util.expects(:execute).with(["/my/foo"]).returns "output\n"
             @parser.version.should == "output"
         end
+
+        it "should raise a puppet parser error if executing config_version fails" do
+            Puppet.settings.stubs(:[]).with(:config_version).returns("test")
+            Puppet::Util.expects(:execute).raises(Puppet::ExecutionFailure.new("msg"))
+
+            lambda { @parser.version }.should raise_error(Puppet::ParseError)
+        end
+
     end
 
     describe Puppet::Parser,"when looking up definitions" do

data/spec/unit/parser/resource.rb

@@ -25,7 +25,7 @@ describe Puppet::Parser::Resource do
         params = args[:params] || {:one => "yay", :three => "rah"}
         if args[:params] == :none
             args.delete(:params)
-        else
+        elsif not args[:params].is_a? Array
             args[:params] = paramify(args[:source], params)
         end
 
@@ -170,6 +170,24 @@ describe Puppet::Parser::Resource do
             @resource[:owner].should == "other"
         end
 
+        it "should be running in metaparam compatibility mode if running a version below 0.25" do
+            catalog = stub 'catalog', :client_version => "0.24.8"
+            @resource.stubs(:catalog).returns catalog
+            @resource.should be_metaparam_compatibility_mode
+        end
+
+        it "should be running in metaparam compatibility mode if running no client version is available" do
+            catalog = stub 'catalog', :client_version => nil
+            @resource.stubs(:catalog).returns catalog
+            @resource.should be_metaparam_compatibility_mode
+        end
+
+        it "should not be running in metaparam compatibility mode if running a version at or above 0.25" do
+            catalog = stub 'catalog', :client_version => "0.25.0"
+            @resource.stubs(:catalog).returns catalog
+            @resource.should_not be_metaparam_compatibility_mode
+        end
+
         it "should copy metaparams from its scope" do
             @scope.setvar("noop", "true")
 
@@ -187,14 +205,34 @@ describe Puppet::Parser::Resource do
             @resource["noop"].should == "false"
         end
 
-        it "should not copy relationship metaparams" do
+        it "should not copy relationship metaparams when not in metaparam compatibility mode" do
             @scope.setvar("require", "bar")
 
+            @resource.stubs(:metaparam_compatibility_mode?).returns false
             @resource.class.publicize_methods(:add_metaparams)  { @resource.add_metaparams }
 
             @resource["require"].should be_nil
         end
 
+        it "should copy relationship metaparams when in metaparam compatibility mode" do
+            @scope.setvar("require", "bar")
+
+            @resource.stubs(:metaparam_compatibility_mode?).returns true
+            @resource.class.publicize_methods(:add_metaparams)  { @resource.add_metaparams }
+
+            @resource["require"].should == "bar"
+        end
+
+        it "should stack relationship metaparams when in metaparam compatibility mode" do
+            @resource.set_parameter("require", "foo")
+            @scope.setvar("require", "bar")
+
+            @resource.stubs(:metaparam_compatibility_mode?).returns true
+            @resource.class.publicize_methods(:add_metaparams)  { @resource.add_metaparams }
+
+            @resource["require"].should == ["foo", "bar"]
+        end
+
         it "should copy all metaparams that it finds" do
             @scope.setvar("noop", "foo")
             @scope.setvar("schedule", "bar")
@@ -445,5 +483,18 @@ describe Puppet::Parser::Resource do
             result = @parser_resource.to_resource
             result[:fee].should == ["a", Puppet::Resource::Reference.new(:file, "/my/file1"), Puppet::Resource::Reference.new(:file, "/my/file2")]
         end
+
+        it "should fail if the same param is declared twice" do
+            lambda do 
+                @parser_resource = mkresource :source => @source, :params => [
+                    Puppet::Parser::Resource::Param.new(
+                        :name => :foo, :value => "bar", :source => @source
+                    ),
+                    Puppet::Parser::Resource::Param.new(
+                        :name => :foo, :value => "baz", :source => @source
+                    )
+                ]
+            end.should raise_error(Puppet::ParseError)
+        end
     end
 end

data/spec/unit/parser/scope.rb

@@ -43,7 +43,7 @@ describe Puppet::Parser::Scope do
         describe "and the variable is qualified" do
             before do
                 @parser = Puppet::Parser::Parser.new()
-                @compiler = Puppet::Parser::Compiler.new(stub("node", :name => "foonode"), @parser)
+                @compiler = Puppet::Parser::Compiler.new(stub("node", :name => "foonode", :classes => []), @parser)
                 @scope.compiler = @compiler
                 @scope.parser = @parser
             end

data/spec/unit/property.rb

@@ -34,10 +34,12 @@ describe Puppet::Property do
         @class.should respond_to(:required_features=)
     end
 
-    it "should always convert required features into an array of symbols" do
-        @class.required_features = %w{one two}
-        @class.required_features.should == [:one, :two]
-    end
+    {"one" => [:one],:one => [:one],%w{a} => [:a],[:b] => [:b],%w{one two} => [:one,:two],[:a,:b] => [:a,:b]}.each { |in_value,out_value|
+        it "should always convert required features into an array of symbols (e.g. #{in_value.inspect} --> #{out_value.inspect})" do
+            @class.required_features = in_value
+            @class.required_features.should == out_value
+        end
+    }
 
     it "should be able to shadow metaparameters" do
         @property.must respond_to(:shadow)
@@ -200,6 +202,14 @@ describe Puppet::Property do
             lambda { @property.should = :foo }.should raise_error(Puppet::Error)
         end
 
+        it "should internally raise an ArgumentError if required features are missing" do
+            @class.newvalue(:foo, :required_features => [:a, :b])
+
+            @provider.expects(:satisfies?).with([:a, :b]).returns false
+
+            lambda { @property.validate_features_per_value :foo }.should raise_error(ArgumentError)
+        end
+
         it "should validate that all required features are present for regexes" do
             value = @class.newvalue(/./, :required_features => [:a, :b])
 

data/spec/unit/provider/package/dpkg.rb

@@ -149,6 +149,13 @@ describe provider do
             @provider.expects(:warning)
             @provider.latest
         end
+
+        it "should cope with names containing ++" do
+            @resource = stub 'resource', :[] => "asdf++"
+            @provider = provider.new(@resource)
+            @provider.expects(:dpkg_deb).returns "asdf++\t1.0"
+            @provider.latest.should == "1.0"
+        end
     end
 
     it "should use 'dpkg -r' to uninstall" do

data/spec/unit/provider/service/daemontools.rb

@@ -65,7 +65,7 @@ describe provider_class do
 
     describe "when starting" do
         it "should use 'svc' to start the service" do
-            @provider.stubs(:enabled?).returns true
+            @provider.stubs(:enabled?).returns :true
             @provider.expects(:svc).with("-u", "/etc/service/myservice")
 
             @provider.start
@@ -74,7 +74,7 @@ describe provider_class do
         it "should enable the service if it is not enabled" do
             @provider.stubs(:svc)
 
-            @provider.expects(:enabled?).returns false
+            @provider.expects(:enabled?).returns :false
             @provider.expects(:enable)
 
             @provider.start
@@ -124,6 +124,23 @@ describe provider_class do
         end
     end
 
+    describe "when checking if the service is enabled?" do
+        it "should return true if it is running" do
+            @provider.stubs(:status).returns(:running)
+
+            @provider.enabled?.should == :true
+        end
+
+        [true, false].each do |t|
+            it "should return #{t} if the symlink exists" do
+                @provider.stubs(:status).returns(:stopped)
+                FileTest.stubs(:symlink?).returns(t)
+
+                @provider.enabled?.should == "#{t}".to_sym
+            end
+        end
+    end
+
     describe "when checking status" do
         it "should call the external command 'svstat /etc/service/myservice'" do
             @provider.expects(:svstat).with(File.join(@servicedir,"myservice"))

data/spec/unit/provider/service/redhat.rb

@@ -16,6 +16,8 @@ describe provider_class do
 
         @provider = provider_class.new
         @provider.resource = @resource
+        FileTest.stubs(:file?).with('/sbin/service').returns true
+        FileTest.stubs(:executable?).with('/sbin/service').returns true
     end
 
     it "should have an enabled? method" do

data/spec/unit/provider/service/runit.rb

@@ -35,6 +35,10 @@ describe provider_class do
         @provider.stubs(:resource).returns @resource
     end
 
+    it "should have a restart method" do
+        @provider.should respond_to(:restart)
+    end
+
     it "should have a restartcmd method" do
         @provider.should respond_to(:restartcmd)
     end
@@ -62,27 +66,34 @@ describe provider_class do
     describe "when starting" do
         it "should enable the service if it is not enabled" do
             @provider.stubs(:sv)
-            @provider.stubs(:ucommand)
 
-            @provider.expects(:enabled?).returns false
+            @provider.expects(:enabled?).returns :false
             @provider.expects(:enable)
 
             @provider.start
         end
 
         it "should execute external command 'sv start /etc/service/myservice'" do
-            @provider.expects(:ucommand).with(:start).returns("")
+            @provider.stubs(:enabled?).returns :true
+            @provider.expects(:sv).with("start", "/etc/service/myservice")
             @provider.start
         end
     end
 
     describe "when stopping" do
         it "should execute external command 'sv stop /etc/service/myservice'" do
-            @provider.expects(:ucommand).with(:stop).returns("")
+            @provider.expects(:sv).with("stop", "/etc/service/myservice")
             @provider.stop
         end
     end
 
+    describe "when restarting" do
+        it "should call 'sv restart /etc/service/myservice'" do
+            @provider.expects(:sv).with("restart","/etc/service/myservice")
+            @provider.restart
+        end
+    end
+
     describe "when enabling" do
         it "should create a symlink between daemon dir and service dir" do
             FileTest.stubs(:symlink?).returns(false)

data/spec/unit/provider/ssh_authorized_key/parsed.rb

@@ -41,12 +41,12 @@ describe provider_class do
         return text
     end
 
-    it "should be able to parse each example" do
-        fakedata("data/providers/ssh_authorized_key/parsed").each { |file|
+    PuppetTest.fakedata("data/providers/ssh_authorized_key/parsed").each { |file|
+        it "should be able to parse example data in #{file}" do
             puts "Parsing %s" % file
             fakedataparse(file)
-        }
-    end
+        end
+    }
 
     it "should be able to generate a basic authorized_keys file" do
         key = mkkey({
@@ -95,85 +95,61 @@ describe provider_class do
             File.stubs(:chown)
         end
 
-        describe "and a user has been specified" do
+        describe "and both a user and a target have been specified" do
             before :each do
-                @resource.stubs(:should).with(:user).returns "nobody"
-                target = File.expand_path("~nobody/.ssh/authorized_keys")
+                Puppet::Util.stubs(:uid).with("random_bob").returns 12345
+                @resource.stubs(:should).with(:user).returns "random_bob"
+                target = "/tmp/.ssh_dir/place_to_put_authorized_keys"
                 @resource.stubs(:should).with(:target).returns target
            end
 
             it "should create the directory" do
-                Dir.expects(:mkdir).with(File.expand_path("~nobody/.ssh"), 0700)
+                File.stubs(:exist?).with("/tmp/.ssh_dir").returns false
+                Dir.expects(:mkdir).with("/tmp/.ssh_dir", 0700)
                 @provider.flush
             end
 
             it "should chown the directory to the user" do
-                uid = Puppet::Util.uid("nobody")
-                File.expects(:chown).with(uid, nil, File.expand_path("~nobody/.ssh"))
+                uid = Puppet::Util.uid("random_bob")
+                File.expects(:chown).with(uid, nil, "/tmp/.ssh_dir")
                 @provider.flush
             end
 
             it "should chown the key file to the user" do
-                uid = Puppet::Util.uid("nobody")
-                File.expects(:chown).with(uid, nil, File.expand_path("~nobody/.ssh/authorized_keys"))
+                uid = Puppet::Util.uid("random_bob")
+                File.expects(:chown).with(uid, nil, "/tmp/.ssh_dir/place_to_put_authorized_keys")
                 @provider.flush
             end
 
             it "should chmod the key file to 0600" do
-                File.expects(:chmod).with(0600, File.expand_path("~nobody/.ssh/authorized_keys"))
-                @provider.flush
-            end
-        end
-
-        describe "and a target has been specified" do
-            before :each do
-                @resource.stubs(:should).with(:user).returns nil
-                @resource.stubs(:should).with(:target).returns "/tmp/.ssh/authorized_keys"
-            end
-
-            it "should make the directory" do
-                Dir.expects(:mkdir).with("/tmp/.ssh", 0755)
-                @provider.flush
-            end
-
-            it "should chmod the key file to 0644" do
-                File.expects(:chmod).with(0644, "/tmp/.ssh/authorized_keys")
+                File.expects(:chmod).with(0600, "/tmp/.ssh_dir/place_to_put_authorized_keys")
                 @provider.flush
             end
         end
 
-    end
-end
-
-describe provider_class do
-    before :each do
-        @resource = stub("resource", :name => "foo")
-        @resource.stubs(:[]).returns "foo"
-        @provider = provider_class.new(@resource)
-    end
-
-    describe "when flushing" do
-        before :each do
-            # Stub file and directory operations
-            Dir.stubs(:mkdir)
-            File.stubs(:chmod)
-            File.stubs(:chown)
-        end
-
-        describe "and a user has been specified" do
+        describe "and a user has been specified with no target" do
             before :each do
                 @resource.stubs(:should).with(:user).returns "nobody"
                 @resource.stubs(:should).with(:target).returns nil
+                # 
+                # I'd like to use random_bob here and something like
+                #
+                #    File.stubs(:expand_path).with("~random_bob/.ssh").returns "/users/r/random_bob/.ssh"
+                #
+                # but mocha objects strenuously to stubbing File.expand_path
+                # so I'm left with using nobody.
+                @dir = File.expand_path("~nobody/.ssh")
            end
 
             it "should create the directory" do
-                Dir.expects(:mkdir).with(File.expand_path("~nobody/.ssh"), 0700)
+                File.stubs(:exist?).with(@dir).returns false
+                Dir.expects(:mkdir).with(@dir,0700)
                 @provider.flush
             end
 
             it "should chown the directory to the user" do
                 uid = Puppet::Util.uid("nobody")
-                File.expects(:chown).with(uid, nil, File.expand_path("~nobody/.ssh"))
+                File.expects(:chown).with(uid, nil, @dir)
                 @provider.flush
             end
 
@@ -189,19 +165,20 @@ describe provider_class do
             end
         end
 
-        describe "and a target has been specified" do
+        describe "and a target has been specified with no user" do
             before :each do
                 @resource.stubs(:should).with(:user).returns nil
-                @resource.stubs(:should).with(:target).returns "/tmp/.ssh/authorized_keys"
+                @resource.stubs(:should).with(:target).returns("/tmp/.ssh_dir/place_to_put_authorized_keys")
             end
 
             it "should make the directory" do
-                Dir.expects(:mkdir).with("/tmp/.ssh", 0755)
+                File.stubs(:exist?).with("/tmp/.ssh_dir").returns false
+                Dir.expects(:mkdir).with("/tmp/.ssh_dir", 0755)
                 @provider.flush
             end
 
             it "should chmod the key file to 0644" do
-                File.expects(:chmod).with(0644, "/tmp/.ssh/authorized_keys")
+                File.expects(:chmod).with(0644, "/tmp/.ssh_dir/place_to_put_authorized_keys")
                 @provider.flush
             end
         end