puppet 0.24.7 → 0.24.8

data/spec/unit/parser/collector.rb

@@ -240,10 +240,10 @@ describe Puppet::Parser::Collector, "when collecting exported resources" do
         one = stub 'one', :type => "Mytype", :virtual? => true, :exported? => true
         two = stub 'two', :type => "Mytype", :virtual? => true, :exported? => true
 
-        one.expects(:exported=).with(false)
-        one.expects(:virtual=).with(false)
-        two.expects(:exported=).with(false)
-        two.expects(:virtual=).with(false)
+        one.stubs(:exported=)
+        one.stubs(:virtual=)
+        two.stubs(:exported=)
+        two.stubs(:virtual=)
 
         @compiler.expects(:resources).returns([one, two])
 

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

@@ -0,0 +1,51 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../../../spec_helper'
+
+describe "the realize function" do
+
+    before :each do
+        @collector = stub_everything 'collector'
+        @scope = Puppet::Parser::Scope.new()
+        @compiler = stub 'compiler'
+        @compiler.stubs(:add_collection).with(@collector)
+        @scope.stubs(:compiler).returns(@compiler)
+    end
+
+    it "should exist" do
+        Puppet::Parser::Functions.function("realize").should == "function_realize"
+    end
+
+    it "should create a Collector when called" do
+
+        Puppet::Parser::Collector.expects(:new).returns(@collector)
+
+        @scope.function_realize("test")
+    end
+
+    it "should assign the passed-in resources to the collector" do
+        Puppet::Parser::Collector.stubs(:new).returns(@collector)
+
+        @collector.expects(:resources=).with(["test"])
+
+        @scope.function_realize("test")
+    end
+
+    it "should flatten the resources assigned to the collector" do
+        Puppet::Parser::Collector.stubs(:new).returns(@collector)
+
+        @collector.expects(:resources=).with(["test"])
+
+        @scope.function_realize([["test"]])
+    end
+
+    it "should let the compiler know this collector" do
+        Puppet::Parser::Collector.stubs(:new).returns(@collector)
+        @collector.stubs(:resources=).with(["test"])
+
+        @compiler.expects(:add_collection).with(@collector)
+
+        @scope.function_realize("test")
+    end
+
+end

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

@@ -0,0 +1,88 @@
+#! /usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../../../spec_helper'
+
+describe "the regsubst function" do
+
+    before :each do
+        @scope = Puppet::Parser::Scope.new()
+    end
+
+    it "should exist" do
+        Puppet::Parser::Functions.function("regsubst").should == "function_regsubst"
+    end
+
+    it "should raise a ParseError if there is less than 3 arguments" do
+        lambda { @scope.function_regsubst(["foo", "bar"]) }.should(
+		raise_error(Puppet::ParseError))
+    end
+
+    it "should raise a ParseError if there is more than 5 arguments" do
+        lambda { @scope.function_regsubst(["foo", "bar", "gazonk", "del", "x", "y"]) }.should(
+		raise_error(Puppet::ParseError))
+    end
+
+
+    it "should raise a ParseError when given a bad flag" do
+        lambda { @scope.function_regsubst(["foo", "bar", "gazonk", "X"]) }.should(
+		raise_error(Puppet::ParseError))
+    end
+
+    it "should handle groups" do
+	result = @scope.function_regsubst(
+		[ '130.236.254.10',
+		  '^([0-9]+)[.]([0-9]+)[.]([0-9]+)[.]([0-9]+)$',
+		  '\4-\3-\2-\1'
+		])
+	result.should(eql("10-254-236-130"))
+    end
+
+    it "should handle simple regexps" do
+	result = @scope.function_regsubst(
+		[ "the monkey breaks banana trees",
+		  "b[an]*a",
+		  "coconut"
+		])
+	result.should(eql("the monkey breaks coconut trees"))
+    end
+
+    it "should handle case-sensitive regexps" do
+	result = @scope.function_regsubst(
+		[ "the monkey breaks baNAna trees",
+		  "b[an]+a",
+		  "coconut"
+		])
+	result.should(eql("the monkey breaks baNAna trees"))
+    end
+
+    it "should handle case-insensitive regexps" do
+	result = @scope.function_regsubst(
+		[ "the monkey breaks baNAna trees",
+		  "b[an]+a",
+		  "coconut",
+		  "I"
+		])
+	result.should(eql("the monkey breaks coconut trees"))
+    end
+
+    it "should handle global substitutions" do
+	result = @scope.function_regsubst(
+		[ "the monkey breaks\tbanana trees",
+		  "[ \t]",
+		  "--",
+		  "G"
+		])
+	result.should(eql("the--monkey--breaks--banana--trees"))
+    end
+
+    it "should handle global substitutions with groups" do
+	result = @scope.function_regsubst(
+		[ '130.236.254.10',
+		  '([0-9]+)',
+		  '<\1>',
+		  'G'
+		])
+	result.should(eql('<130>.<236>.<254>.<10>'))
+    end
+
+end

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

@@ -0,0 +1,42 @@
+#! /usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../../../spec_helper'
+
+describe "the sprintf function" do
+
+    before :each do
+        @scope = Puppet::Parser::Scope.new()
+    end
+
+    it "should exist" do
+        Puppet::Parser::Functions.function("sprintf").should == "function_sprintf"
+    end
+
+    it "should raise a ParseError if there is less than 1 argument" do
+        lambda { @scope.function_sprintf([]) }.should(
+		raise_error(Puppet::ParseError))
+    end
+
+    it "should format integers" do
+	result = @scope.function_sprintf(["%+05d", "23"])
+	result.should(eql("+0023"))
+    end
+
+    it "should format floats" do
+	result = @scope.function_sprintf(["%+.2f", "2.7182818284590451"])
+	result.should(eql("+2.72"))
+    end
+
+    it "should format large floats" do
+	result = @scope.function_sprintf(["%+.2e", "27182818284590451"])
+	result.should(eql("+2.72e+16"))
+    end
+
+    it "should perform more complex formatting" do
+	result = @scope.function_sprintf(
+		[ "<%.8s:%#5o %#8X (%-8s)>",
+		  "overlongstring", "23", "48879", "foo" ])
+	result.should(eql("<overlong:  027   0XBEEF (foo     )>"))
+    end
+
+end

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

@@ -0,0 +1,29 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../../../spec_helper'
+
+describe "the versioncmp function" do
+
+    before :each do
+        @scope = Puppet::Parser::Scope.new()
+    end
+
+    it "should exist" do
+        Puppet::Parser::Functions.function("versioncmp").should == "function_versioncmp"
+    end
+
+    it "should raise a ParseError if there is less than 2 arguments" do
+        lambda { @scope.function_versioncmp(["1.2"]) }.should raise_error(Puppet::ParseError)
+    end
+    
+    it "should raise a ParseError if there is more than 2 arguments" do
+        lambda { @scope.function_versioncmp(["1.2", "2.4.5", "3.5.6"]) }.should raise_error(Puppet::ParseError)
+    end
+    
+    it "should call Puppet::Util::Package.versioncmp (included in scope)" do
+        Puppet::Util::Package.expects(:versioncmp).with("1.2", "1.3").returns(-1)
+
+        @scope.function_versioncmp(["1.2", "1.3"])
+    end
+
+end

data/spec/unit/parser/resource.rb

@@ -44,6 +44,10 @@ describe Puppet::Parser::Resource do
         end
     end
 
+    it "should use the file lookup module" do
+        Puppet::Parser::Resource.ancestors.should be_include(Puppet::FileCollection::Lookup)
+    end
+
     it "should be isomorphic if it is builtin and models an isomorphic type" do
         Puppet::Type.type(:file).expects(:isomorphic?).returns(true)
         @resource = Puppet::Parser::Resource.new(:type => "file", :title => "whatever", :scope => @scope, :source => @source).isomorphic?.should be_true

data/spec/unit/parser/resource/reference.rb

@@ -7,6 +7,10 @@ describe Puppet::Parser::Resource::Reference do
         @type = Puppet::Parser::Resource::Reference
     end
 
+    it "should use the file lookup module" do
+        Puppet::Parser::Resource::Reference.ancestors.should be_include(Puppet::FileCollection::Lookup)
+    end
+
     it "should require a type" do
         proc { @type.new(:title => "yay") }.should raise_error(Puppet::DevError)
     end

data/spec/unit/parser/scope.rb

@@ -81,7 +81,21 @@ describe Puppet::Parser::Scope do
             Puppet::Parser::Scope.number?("0755").should == 0755
         end
 
+        it "should return nil on malformed integers" do
+            Puppet::Parser::Scope.number?("0.24.5").should be_nil
+        end
+
+        it "should convert strings with leading 0 to integer if they are not octal" do
+            Puppet::Parser::Scope.number?("0788").should == 788
+        end
 
+        it "should convert strings of negative integers" do
+            Puppet::Parser::Scope.number?("-0788").should == -788
+        end
+
+        it "should return nil on malformed hexadecimal numbers" do
+            Puppet::Parser::Scope.number?("0x89g").should be_nil
+        end
     end
 
 end

data/spec/unit/property/list.rb

@@ -36,6 +36,10 @@ describe list_class do
             @property.is_to_s(["foo","bar"]).should == "foo,bar"
         end
 
+        it "should be able to correctly convert ':absent' to a string" do
+            @property.is_to_s(:absent).should == "absent"
+        end
+
         describe "when adding should to current" do
             it "should add the arrays when current is an array" do
                 @property.add_should_with_current(["foo"], ["bar"]).should == ["foo", "bar"]

data/spec/unit/provider/augeas/augeas.rb

@@ -10,229 +10,356 @@ describe provider_class do
             provider = provider_class.new()
             tokens = provider.parse_commands("set /Jar/Jar Binks")
             tokens.size.should == 1
-            tokens[0].size.should == 3      
+            tokens[0].size.should == 3
             tokens[0][0].should == "set"
             tokens[0][1].should == "/Jar/Jar"
-            tokens[0][2].should == "Binks"            
+            tokens[0][2].should == "Binks"
         end
-        
+
         it "should break apart a multiple line into six tokens" do
             provider = provider_class.new()
             tokens = provider.parse_commands("set /Jar/Jar Binks\nrm anakin skywalker")
             tokens.size.should == 2
-            tokens[0].size.should == 3      
-            tokens[1].size.should == 3            
+            tokens[0].size.should == 3
+            tokens[1].size.should == 3
             tokens[0][0].should == "set"
             tokens[0][1].should == "/Jar/Jar"
-            tokens[0][2].should == "Binks"            
+            tokens[0][2].should == "Binks"
             tokens[1][0].should == "rm"
             tokens[1][1].should == "anakin"
-            tokens[1][2].should == "skywalker"                
-        end        
-        
+            tokens[1][2].should == "skywalker"
+        end
+
         it "should handle arrays" do
             provider = provider_class.new()
             commands = ["set /Jar/Jar Binks", "rm anakin skywalker"]
             tokens = provider.parse_commands(commands)
             tokens.size.should == 2
-            tokens[0].size.should == 3      
-            tokens[1].size.should == 3            
+            tokens[0].size.should == 3
+            tokens[1].size.should == 3
             tokens[0][0].should == "set"
             tokens[0][1].should == "/Jar/Jar"
-            tokens[0][2].should == "Binks"            
+            tokens[0][2].should == "Binks"
             tokens[1][0].should == "rm"
             tokens[1][1].should == "anakin"
-            tokens[1][2].should == "skywalker"                
-        end                
-        
+            tokens[1][2].should == "skywalker"
+        end
+
         it "should concat the last values" do
             provider = provider_class.new()
             tokens = provider.parse_commands("set /Jar/Jar Binks is my copilot")
             tokens.size.should == 1
-            tokens[0].size.should == 3      
+            tokens[0].size.should == 3
             tokens[0][0].should == "set"
             tokens[0][1].should == "/Jar/Jar"
-            tokens[0][2].should == "Binks is my copilot"            
+            tokens[0][2].should == "Binks is my copilot"
+        end
+
+        it "should accept spaces and and single ticks" do
+            provider = provider_class.new()
+            tokens = provider.parse_commands("set 'Jar Jar' Binks")
+            tokens.size.should == 1
+            tokens[0].size.should == 3
+            tokens[0][0].should == "set"
+            tokens[0][1].should == "Jar Jar"
+            tokens[0][2].should == "Binks"
+        end
+
+        it "should accept spaces in the value and and single ticks" do
+            provider = provider_class.new()
+            tokens = provider.parse_commands("set 'Jar Jar' 'Binks is my copilot'")
+            tokens.size.should == 1
+            tokens[0].size.should == 3
+            tokens[0][0].should == "set"
+            tokens[0][1].should == "Jar Jar"
+            tokens[0][2].should == "Binks is my copilot"
+        end
+
+        it "should accept spaces and and double ticks" do
+            provider = provider_class.new()
+            tokens = provider.parse_commands('set "Jar Jar" Binks')
+            tokens.size.should == 1
+            tokens[0].size.should == 3
+            tokens[0][0].should == "set"
+            tokens[0][1].should == 'Jar Jar'
+            tokens[0][2].should == 'Binks'
+        end
+
+        it "should accept spaces in the value and and double ticks" do
+            provider = provider_class.new()
+            tokens = provider.parse_commands('set "Jar Jar" "Binks is my copilot"')
+            tokens.size.should == 1
+            tokens[0].size.should == 3
+            tokens[0][0].should == "set"
+            tokens[0][1].should == 'Jar Jar'
+            tokens[0][2].should == 'Binks is my copilot'
+        end
+
+        it "should accept mixed ticks" do
+            provider = provider_class.new()
+            tokens = provider.parse_commands('set "Jar Jar" "Some \'Test\'"')
+            tokens.size.should == 1
+            tokens[0].size.should == 3
+            tokens[0][0].should == "set"
+            tokens[0][1].should == 'Jar Jar'
+            tokens[0][2].should == "Some \'Test\'"
+        end
+
+        it "should accept only the last value using ticks" do
+            provider = provider_class.new()
+            tokens = provider.parse_commands('set /Jar/Jar "Binks is my copilot"')
+            tokens.size.should == 1
+            tokens[0].size.should == 3
+            tokens[0][0].should == "set"
+            tokens[0][1].should == '/Jar/Jar'
+            tokens[0][2].should == "Binks is my copilot"
+        end
+
+        it "should accept only the first value using ticks" do
+            provider = provider_class.new()
+            tokens = provider.parse_commands('set "Jar Jar" copilot')
+            tokens.size.should == 1
+            tokens[0].size.should == 3
+            tokens[0][0].should == "set"
+            tokens[0][1].should == 'Jar Jar'
+            tokens[0][2].should == "copilot"
+        end
+
+        it "should accept only the first value using ticks and the last values being concatenated" do
+            provider = provider_class.new()
+            tokens = provider.parse_commands('set "Jar Jar" Binks is my copilot')
+            tokens.size.should == 1
+            tokens[0].size.should == 3
+            tokens[0][0].should == "set"
+            tokens[0][1].should == 'Jar Jar'
+            tokens[0][2].should == "Binks is my copilot"
         end
     end
-    
+
     describe "get filters" do
         before do
             augeas_stub = stub("augeas", :get => "value")
-            @provider = provider_class.new()        
-            @provider.stubs(:open_augeas).returns(augeas_stub)        
+            @provider = provider_class.new()
+            @provider.aug= augeas_stub
         end
-        
+
         it "should return false for a = nonmatch" do
             command = ["get", "fake value", "==", "value"]
             @provider.process_get(command).should == true
         end
-        
+
         it "should return true for a != match" do
             command = ["get", "fake value", "!=", "value"]
             @provider.process_get(command).should == false
-        end        
-        
+        end
+
         it "should return true for a =~ match" do
             command = ["get", "fake value", "=~", "val*"]
             @provider.process_get(command).should == true
-        end           
-        
+        end
+
         it "should return false for a == nonmatch" do
             command = ["get", "fake value", "=~", "num*"]
             @provider.process_get(command).should == false
-        end 
+        end
     end
-    
+
     describe "match filters" do
         before do
             augeas_stub = stub("augeas", :match => ["set", "of", "values"])
-            @provider = provider_class.new()        
-            @provider.stubs(:open_augeas).returns(augeas_stub)        
+            @provider = provider_class.new()
+            @provider.aug= augeas_stub
         end
-        
+
         it "should return true for size match" do
             command = ["match", "fake value", "size", "==", "3"]
             @provider.process_match(command).should == true
         end
-        
+
         it "should return false for a size non match" do
             command = ["match", "fake value", "size", "<", "3"]
             @provider.process_match(command).should == false
-        end    
-        
+        end
+
         it "should return true for includes match" do
             command = ["get", "fake value", "include", "values"]
             @provider.process_match(command).should == true
-        end           
-        
+        end
+
         it "should return false for includes non match" do
             command = ["get", "fake value", "include", "JarJar"]
             @provider.process_match(command).should == false
-        end           
-        
+        end
+
         it "should return true for an array match" do
             command = ["get", "fake value", "==", "['set', 'of', 'values']"]
             @provider.process_match(command).should == true
-        end  
-        
+        end
+
         it "should return false for an array non match" do
             command = ["get", "fake value", "==", "['this', 'should', 'not', 'match']"]
             @provider.process_match(command).should == false
-        end                 
-    end    
-    
-    describe "need_to_run" do
+        end
+    end
+
+    describe "need to run" do
         it "should handle no filters" do
-            resource = stub("resource", :[] => "")
+            resource = stub("resource")
+            resource.stubs(:[]).returns(false).then.returns("")
+            augeas_stub = stub("augeas", :match => ["set", "of", "values"])
+            augeas_stub.stubs("close")
             provider = provider_class.new(resource)
-            provider.need_to_run?.should == true        
+            provider.stubs(:get_augeas_version).returns("0.3.5")
+            provider.need_to_run?.should == true
         end
-        
+
         it "should return true when a get filter matches" do
-            resource = stub("resource", :[] => "get path == value")
+            resource = stub("resource")
+            resource.stubs(:[]).returns(false).then.returns("get path == value")
             provider = provider_class.new(resource)
             augeas_stub = stub("augeas", :get => "value")
-            provider.stubs(:open_augeas).returns(augeas_stub)              
-            provider.need_to_run?.should == true       
-        end       
-        
+            augeas_stub.stubs("close")
+            provider.aug= augeas_stub
+            provider.stubs(:get_augeas_version).returns("0.3.5")
+            provider.need_to_run?.should == true
+        end
+
         it "should return false when a get filter does not match" do
-            resource = stub("resource", :[] => "get path == another value")
+            resource = stub("resource")
+            resource.stubs(:[]).returns(false).then.returns("get path == another value")
             provider = provider_class.new(resource)
             augeas_stub = stub("augeas", :get => "value")
-            provider.stubs(:open_augeas).returns(augeas_stub)              
-            provider.need_to_run?.should == false       
-        end            
-        
+            augeas_stub.stubs("close")
+            provider.aug= augeas_stub
+            provider.stubs(:get_augeas_version).returns("0.3.5")
+            provider.need_to_run?.should == false
+        end
+
         it "should return true when a match filter matches" do
-            resource = stub("resource", :[] => "match path size == 3")
+            resource = stub("resource")
+            resource.stubs(:[]).returns(false).then.returns("match path size == 3")
             provider = provider_class.new(resource)
             augeas_stub = stub("augeas", :match => ["set", "of", "values"])
-            provider.stubs(:open_augeas).returns(augeas_stub)              
-            provider.need_to_run?.should == true       
-        end       
-        
+            augeas_stub.stubs("close")
+            provider.aug= augeas_stub
+            provider.stubs(:get_augeas_version).returns("0.3.5")
+            provider.need_to_run?.should == true
+        end
+
         it "should return false when a match filter does not match" do
-            resource = stub("resource", :[] => "match path size == 2")
+            resource = stub("resource")
+            resource.stubs(:[]).returns(false).then.returns("match path size == 2")
             provider = provider_class.new(resource)
             augeas_stub = stub("augeas", :match => ["set", "of", "values"])
-            provider.stubs(:open_augeas).returns(augeas_stub)              
-            provider.need_to_run?.should == false       
-        end       
+            augeas_stub.stubs("close")
+            provider.aug= augeas_stub
+            provider.stubs(:get_augeas_version).returns("0.3.5")
+            provider.need_to_run?.should == false
+        end
+
+        #This is a copy of the last one, with setting the force to true
+        it "setting force should not change the above logic" do
+            resource = stub("resource")
+            resource.stubs(:[]).returns(true).then.returns("match path size == 2")
+            provider = provider_class.new(resource)
+            augeas_stub = stub("augeas", :match => ["set", "of", "values"])
+            augeas_stub.stubs("close")
+            provider.aug= augeas_stub
+            provider.stubs(:get_augeas_version).returns("0.3.5")
+            provider.need_to_run?.should == false
+        end
     end
-    
-    describe "augeas integration" do
-        
+
+    describe "augeas execution integration" do
+
         before do
             @resource = stub("resource")
             @provider = provider_class.new(@resource)
             @augeas = stub("augeas")
-            @provider.stubs(:open_augeas).returns(@augeas)
+            @provider.aug= @augeas
+            @provider.stubs(:get_augeas_version).returns("0.3.5")
         end
-    
+
         it "should handle set commands" do
             command = [["set", "/Jar/Jar", "Binks"]]
             context = "/some/path"
             @resource.expects(:[]).times(2).returns(command).then.returns(context)
             @augeas.expects(:set).with("/some/path/Jar/Jar", "Binks")
             @augeas.expects(:save).returns(true)
+            @augeas.expects(:close)
             @provider.execute_changes.should == :executed
         end
-        
+
         it "should handle rm commands" do
             command = [["rm", "/Jar/Jar"]]
             context = ""
             @resource.expects(:[]).times(2).returns(command).then.returns(context)
             @augeas.expects(:rm).with("/Jar/Jar")
             @augeas.expects(:save).returns(true)
+            @augeas.expects(:close)
             @provider.execute_changes.should == :executed
-        end        
-        
+        end
+
         it "should handle remove commands" do
             command = [["remove", "Jar/Jar"]]
             context = ""
             @resource.expects(:[]).times(2).returns(command).then.returns(context)
             @augeas.expects(:rm).with("/Jar/Jar")
             @augeas.expects(:save).returns(true)
+            @augeas.expects(:close)
             @provider.execute_changes.should == :executed
-        end              
-        
+        end
+
         it "should handle clear commands" do
             command = [["clear", "/Jar/Jar"]]
             context = "/foo"
             @resource.expects(:[]).times(2).returns(command).then.returns(context)
             @augeas.expects(:clear).with("/foo/Jar/Jar")
             @augeas.expects(:save).returns(true)
+            @augeas.expects(:close)
             @provider.execute_changes.should == :executed
-        end        
-        
-        it "should handle insert commands" do
-            command = [["insert", "/Jar/Jar"]]
+        end
+
+
+        it "should handle ins commands with before" do
+            command = [["ins", "Binks", "before /Jar/Jar"]]
             context = "/foo"
             @resource.expects(:[]).times(2).returns(command).then.returns(context)
-            @augeas.expects(:insert).with("/foo/Jar/Jar")
+            @augeas.expects(:insert).with("/foo/Jar/Jar", "Binks", true)
             @augeas.expects(:save).returns(true)
+            @augeas.expects(:close)
             @provider.execute_changes.should == :executed
-        end     
-        
-        it "should handle ins commands" do
-            command = [["ins", "/Jar/Jar"]]
+        end
+
+        it "should handle ins commands with before" do
+            command = [["ins", "Binks", "after /Jar/Jar"]]
             context = "/foo"
             @resource.expects(:[]).times(2).returns(command).then.returns(context)
-            @augeas.expects(:insert).with("/foo/Jar/Jar")
+            @augeas.expects(:insert).with("/foo/Jar/Jar", "Binks", false)
+            @augeas.expects(:save).returns(true)
+            @augeas.expects(:close)
+            @provider.execute_changes.should == :executed
+        end
+
+        it "should handle ins with no context" do
+            command = [["ins", "Binks", "after /Jar/Jar"]]
+            context = "" # this is the default
+            @resource.expects(:[]).times(2).returns(command).then.returns(context)
+            @augeas.expects(:insert).with("/Jar/Jar", "Binks", false)
             @augeas.expects(:save).returns(true)
+            @augeas.expects(:close)
             @provider.execute_changes.should == :executed
-        end      
-        
+        end
+
         it "should handle multiple commands" do
-            command = [["ins", "/Jar/Jar"], ["clear", "/Jar/Jar"]]
+            command = [["ins", "Binks", "after /Jar/Jar"], ["clear", "/Jar/Jar"]]
             context = "/foo"
             @resource.expects(:[]).times(2).returns(command).then.returns(context)
-            @augeas.expects(:insert).with("/foo/Jar/Jar")
-            @augeas.expects(:clear).with("/foo/Jar/Jar")            
+            @augeas.expects(:insert).with("/foo/Jar/Jar", "Binks", false)
+            @augeas.expects(:clear).with("/foo/Jar/Jar")
             @augeas.expects(:save).returns(true)
+            @augeas.expects(:close)
             @provider.execute_changes.should == :executed
-        end    
+        end
     end
 end