puppet 2.7.9 → 2.7.11

data/spec/unit/node/environment_spec.rb

@@ -7,6 +7,8 @@ require 'puppet/node/environment'
 require 'puppet/util/execution'
 
 describe Puppet::Node::Environment do
+  let(:env) { Puppet::Node::Environment.new("testing") }
+
   include PuppetSpec::Files
   after do
     Puppet::Node::Environment.clear
@@ -44,59 +46,57 @@ describe Puppet::Node::Environment do
 
   describe "when managing known resource types" do
     before do
-      @env = Puppet::Node::Environment.new("dev")
-      @collection = Puppet::Resource::TypeCollection.new(@env)
-      @env.stubs(:perform_initial_import).returns(Puppet::Parser::AST::Hostclass.new(''))
+      @collection = Puppet::Resource::TypeCollection.new(env)
+      env.stubs(:perform_initial_import).returns(Puppet::Parser::AST::Hostclass.new(''))
       Thread.current[:known_resource_types] = nil
     end
 
     it "should create a resource type collection if none exists" do
-      Puppet::Resource::TypeCollection.expects(:new).with(@env).returns @collection
-      @env.known_resource_types.should equal(@collection)
+      Puppet::Resource::TypeCollection.expects(:new).with(env).returns @collection
+      env.known_resource_types.should equal(@collection)
     end
 
     it "should reuse any existing resource type collection" do
-      @env.known_resource_types.should equal(@env.known_resource_types)
+      env.known_resource_types.should equal(env.known_resource_types)
     end
 
     it "should perform the initial import when creating a new collection" do
-      @env = Puppet::Node::Environment.new("dev")
-      @env.expects(:perform_initial_import).returns(Puppet::Parser::AST::Hostclass.new(''))
-      @env.known_resource_types
+      env.expects(:perform_initial_import).returns(Puppet::Parser::AST::Hostclass.new(''))
+      env.known_resource_types
     end
 
     it "should return the same collection even if stale if it's the same thread" do
       Puppet::Resource::TypeCollection.stubs(:new).returns @collection
-      @env.known_resource_types.stubs(:stale?).returns true
+      env.known_resource_types.stubs(:stale?).returns true
 
-      @env.known_resource_types.should equal(@collection)
+      env.known_resource_types.should equal(@collection)
     end
 
     it "should return the current thread associated collection if there is one" do
       Thread.current[:known_resource_types] = @collection
 
-      @env.known_resource_types.should equal(@collection)
+      env.known_resource_types.should equal(@collection)
     end
 
     it "should give to all threads using the same environment the same collection if the collection isn't stale" do
-      original_thread_type_collection = Puppet::Resource::TypeCollection.new(@env)
-      Puppet::Resource::TypeCollection.expects(:new).with(@env).returns original_thread_type_collection
-      @env.known_resource_types.should equal(original_thread_type_collection)
+      original_thread_type_collection = Puppet::Resource::TypeCollection.new(env)
+      Puppet::Resource::TypeCollection.expects(:new).with(env).returns original_thread_type_collection
+      env.known_resource_types.should equal(original_thread_type_collection)
 
       original_thread_type_collection.expects(:require_reparse?).returns(false)
-      Puppet::Resource::TypeCollection.stubs(:new).with(@env).returns @collection
+      Puppet::Resource::TypeCollection.stubs(:new).with(env).returns @collection
 
       t = Thread.new {
-        @env.known_resource_types.should equal(original_thread_type_collection)
+        env.known_resource_types.should equal(original_thread_type_collection)
       }
       t.join
     end
 
     it "should generate a new TypeCollection if the current one requires reparsing" do
-      old_type_collection = @env.known_resource_types
+      old_type_collection = env.known_resource_types
       old_type_collection.stubs(:require_reparse?).returns true
       Thread.current[:known_resource_types] = nil
-      new_type_collection = @env.known_resource_types
+      new_type_collection = env.known_resource_types
 
       new_type_collection.should be_a Puppet::Resource::TypeCollection
       new_type_collection.should_not equal(old_type_collection)
@@ -109,14 +109,11 @@ describe Puppet::Node::Environment do
 
     Puppet[:modulepath] = path
 
-    env = Puppet::Node::Environment.new("testing")
-
     env.modulepath.should == [real_file]
   end
 
   it "should prefix the value of the 'PUPPETLIB' environment variable to the module path if present" do
     Puppet::Util::Execution.withenv("PUPPETLIB" => %w{/l1 /l2}.join(File::PATH_SEPARATOR)) do
-      env = Puppet::Node::Environment.new("testing")
       module_path = %w{/one /two}.join(File::PATH_SEPARATOR)
       env.expects(:validate_dirs).with(%w{/l1 /l2 /one /two}).returns %w{/l1 /l2 /one /two}
       env.expects(:[]).with(:modulepath).returns module_path
@@ -132,8 +129,6 @@ describe Puppet::Node::Environment do
     end
 
     it "should not return non-directories" do
-      env = Puppet::Node::Environment.new("testing")
-
       FileTest.expects(:directory?).with(@path_one).returns true
       FileTest.expects(:directory?).with(@path_two).returns false
 
@@ -142,7 +137,6 @@ describe Puppet::Node::Environment do
 
     it "should use the current working directory to fully-qualify unqualified paths" do
       FileTest.stubs(:directory?).returns true
-      env = Puppet::Node::Environment.new("testing")
 
       two = File.expand_path(File.join(Dir.getwd, "two"))
       env.validate_dirs([@path_one, 'two']).should == [@path_one, two]
@@ -155,44 +149,75 @@ describe Puppet::Node::Environment do
     end
 
     it "should provide an array-like accessor method for returning any environment-specific setting" do
-      env = Puppet::Node::Environment.new("testing")
       env.should respond_to(:[])
     end
 
     it "should ask the Puppet settings instance for the setting qualified with the environment name" do
       Puppet.settings.expects(:value).with("myvar", :testing).returns("myval")
-      env = Puppet::Node::Environment.new("testing")
       env["myvar"].should == "myval"
     end
 
     it "should be able to return an individual module that exists in its module path" do
-      env = Puppet::Node::Environment.new("testing")
 
       mod = mock 'module'
-      Puppet::Module.expects(:new).with("one", env).returns mod
+      Puppet::Module.expects(:new).with("one", :environment => env).returns mod
       mod.expects(:exist?).returns true
 
       env.module("one").should equal(mod)
     end
 
     it "should return nil if asked for a module that does not exist in its path" do
-      env = Puppet::Node::Environment.new("testing")
 
       mod = mock 'module'
-      Puppet::Module.expects(:new).with("one", env).returns mod
+      Puppet::Module.expects(:new).with("one", :environment => env).returns mod
       mod.expects(:exist?).returns false
 
       env.module("one").should be_nil
     end
 
-    it "should be able to return its modules" do
-      Puppet::Node::Environment.new("testing").should respond_to(:modules)
+    describe ".modules_by_path" do
+      before do
+        dir = tmpdir("deep_path")
+
+        @first = File.join(dir, "first")
+        @second = File.join(dir, "second")
+        Puppet[:modulepath] = "#{@first}#{File::PATH_SEPARATOR}#{@second}"
+
+        FileUtils.mkdir_p(@first)
+        FileUtils.mkdir_p(@second)
+      end
+
+      it "should return an empty list if there are no modules" do
+        env.modules_by_path.should == {
+          @first  => [],
+          @second => []
+        }
+      end
+
+      it "should include modules even if they exist in multiple dirs in the modulepath" do
+        modpath1 = File.join(@first, "foo")
+        FileUtils.mkdir_p(modpath1)
+        modpath2 = File.join(@second, "foo")
+        FileUtils.mkdir_p(modpath2)
+
+        env.modules_by_path.should == {
+          @first  => [Puppet::Module.new('foo', :environment => env, :path => modpath1)],
+          @second => [Puppet::Module.new('foo', :environment => env, :path => modpath2)]
+        }
+      end
     end
 
     describe ".modules" do
+      it "should return an empty list if there are no modules" do
+        env.modulepath = %w{/a /b}
+        Dir.expects(:entries).with("/a").returns []
+        Dir.expects(:entries).with("/b").returns []
+
+        env.modules.should == []
+      end
+
       it "should return a module named for every directory in each module path" do
-        env = Puppet::Node::Environment.new("testing")
-        env.expects(:modulepath).at_least_once.returns %w{/a /b}
+        env.modulepath = %w{/a /b}
         Dir.expects(:entries).with("/a").returns %w{foo bar}
         Dir.expects(:entries).with("/b").returns %w{bee baz}
 
@@ -200,8 +225,7 @@ describe Puppet::Node::Environment do
       end
 
       it "should remove duplicates" do
-        env = Puppet::Node::Environment.new("testing")
-        env.expects(:modulepath).returns( %w{/a /b} ).at_least_once
+        env.modulepath = %w{/a /b}
         Dir.expects(:entries).with("/a").returns %w{foo}
         Dir.expects(:entries).with("/b").returns %w{foo}
 
@@ -209,8 +233,7 @@ describe Puppet::Node::Environment do
       end
 
       it "should ignore invalid modules" do
-        env = Puppet::Node::Environment.new("testing")
-        env.stubs(:modulepath).returns %w{/a}
+        env.modulepath = %w{/a}
         Dir.expects(:entries).with("/a").returns %w{foo bar}
 
         Puppet::Module.expects(:new).with { |name, env| name == "foo" }.returns mock("foomod", :name => "foo")
@@ -220,16 +243,14 @@ describe Puppet::Node::Environment do
       end
 
       it "should create modules with the correct environment" do
-        env = Puppet::Node::Environment.new("testing")
-        env.expects(:modulepath).at_least_once.returns %w{/a}
+        env.modulepath = %w{/a}
         Dir.expects(:entries).with("/a").returns %w{foo}
 
         env.modules.each {|mod| mod.environment.should == env }
       end
 
       it "should cache the module list" do
-        env = Puppet::Node::Environment.new("testing")
-        env.expects(:modulepath).at_least_once.returns %w{/a}
+        env.modulepath = %w{/a}
         Dir.expects(:entries).once.with("/a").returns %w{foo}
 
         env.modules
@@ -244,20 +265,18 @@ describe Puppet::Node::Environment do
       @helper.extend(Puppet::Node::Environment::Helper)
     end
 
-    it "should be able to set and retrieve the environment" do
+    it "should be able to set and retrieve the environment as a symbol" do
       @helper.environment = :foo
       @helper.environment.name.should == :foo
     end
 
     it "should accept an environment directly" do
-      env = Puppet::Node::Environment.new :foo
-      @helper.environment = env
+      @helper.environment = Puppet::Node::Environment.new(:foo)
       @helper.environment.name.should == :foo
     end
 
     it "should accept an environment as a string" do
-      env = Puppet::Node::Environment.new "foo"
-      @helper.environment = env
+      @helper.environment = 'foo'
       @helper.environment.name.should == :foo
     end
   end
@@ -266,14 +285,13 @@ describe Puppet::Node::Environment do
     before do
       @parser = Puppet::Parser::Parser.new("test")
       Puppet::Parser::Parser.stubs(:new).returns @parser
-      @env = Puppet::Node::Environment.new("env")
     end
 
     it "should set the parser's string to the 'code' setting and parse if code is available" do
       Puppet.settings[:code] = "my code"
       @parser.expects(:string=).with "my code"
       @parser.expects(:parse)
-      @env.instance_eval { perform_initial_import }
+      env.instance_eval { perform_initial_import }
     end
 
     it "should set the parser's file to the 'manifest' setting and parse if no code is available and the manifest is available" do
@@ -282,7 +300,7 @@ describe Puppet::Node::Environment do
       Puppet.settings[:manifest] = filename
       @parser.expects(:file=).with filename
       @parser.expects(:parse)
-      @env.instance_eval { perform_initial_import }
+      env.instance_eval { perform_initial_import }
     end
 
     it "should pass the manifest file to the parser even if it does not exist on disk" do
@@ -291,15 +309,15 @@ describe Puppet::Node::Environment do
       Puppet.settings[:manifest] = filename
       @parser.expects(:file=).with(filename).once
       @parser.expects(:parse).once
-      @env.instance_eval { perform_initial_import }
+      env.instance_eval { perform_initial_import }
     end
 
     it "should fail helpfully if there is an error importing" do
       File.stubs(:exist?).returns true
-      @env.stubs(:known_resource_types).returns Puppet::Resource::TypeCollection.new(@env)
+      env.stubs(:known_resource_types).returns Puppet::Resource::TypeCollection.new(env)
       @parser.expects(:file=).once
       @parser.expects(:parse).raises ArgumentError
-      lambda { @env.instance_eval { perform_initial_import } }.should raise_error(Puppet::Error)
+      lambda { env.instance_eval { perform_initial_import } }.should raise_error(Puppet::Error)
     end
 
     it "should not do anything if the ignore_import settings is set" do
@@ -307,15 +325,15 @@ describe Puppet::Node::Environment do
       @parser.expects(:string=).never
       @parser.expects(:file=).never
       @parser.expects(:parse).never
-      @env.instance_eval { perform_initial_import }
+      env.instance_eval { perform_initial_import }
     end
 
     it "should mark the type collection as needing a reparse when there is an error parsing" do
       @parser.expects(:parse).raises Puppet::ParseError.new("Syntax error at ...")
-      @env.stubs(:known_resource_types).returns Puppet::Resource::TypeCollection.new(@env)
+      env.stubs(:known_resource_types).returns Puppet::Resource::TypeCollection.new(env)
 
-      lambda { @env.instance_eval { perform_initial_import } }.should raise_error(Puppet::Error, /Syntax error at .../)
-      @env.known_resource_types.require_reparse?.should be_true
+      lambda { env.instance_eval { perform_initial_import } }.should raise_error(Puppet::Error, /Syntax error at .../)
+      env.known_resource_types.require_reparse?.should be_true
     end
   end
 end

data/spec/unit/parser/ast/asthash_spec.rb

@@ -91,7 +91,6 @@ describe Puppet::Parser::AST::ASTHash do
 
   it "should return a valid string with to_s" do
     hash = Puppet::Parser::AST::ASTHash.new(:value => { "a" => "b", "c" => "d" })
-
-    hash.to_s.should == '{a => b, c => d}'
+    ["{a => b, c => d}", "{c => d, a => b}"].should be_include hash.to_s
   end
 end

data/spec/unit/parser/ast/leaf_spec.rb

@@ -151,6 +151,14 @@ describe Puppet::Parser::AST::HashOrArrayAccess do
       lambda { access.evaluate(@scope) }.should raise_error
     end
 
+    it "should be able to return :undef for an unknown array index" do
+      @scope.stubs(:lookupvar).with { |name,options| name == 'a'}.returns(["val1", "val2", "val3"])
+
+      access = Puppet::Parser::AST::HashOrArrayAccess.new(:variable => "a", :key => 6 )
+
+      access.evaluate(@scope).should == :undef
+    end
+
     it "should be able to return an hash value" do
       @scope.stubs(:lookupvar).with { |name,options| name == 'a'}.returns({ "key1" => "val1", "key2" => "val2", "key3" => "val3" })
 
@@ -159,6 +167,14 @@ describe Puppet::Parser::AST::HashOrArrayAccess do
       access.evaluate(@scope).should == "val2"
     end
 
+    it "should be able to return :undef for unknown hash keys" do
+      @scope.stubs(:lookupvar).with { |name,options| name == 'a'}.returns({ "key1" => "val1", "key2" => "val2", "key3" => "val3" })
+
+      access = Puppet::Parser::AST::HashOrArrayAccess.new(:variable => "a", :key => "key12" )
+
+      access.evaluate(@scope).should == :undef
+    end
+
     it "should be able to return an hash value with a numerical key" do
       @scope.stubs(:lookupvar).with { |name,options| name == "a"}.returns({ "key1" => "val1", "key2" => "val2", "45" => "45", "key3" => "val3" })
 

data/spec/unit/property/keyvalue_spec.rb

@@ -35,8 +35,11 @@ describe klass do
       @property.should_to_s({:foo => "baz", :bar => "boo"}) == "foo=baz;bar=boo"
     end
 
-    it "should return the passed in array values joined with the delimiter from is_to_s" do
-      @property.is_to_s({"foo" => "baz" , "bar" => "boo"}).should == "foo=baz;bar=boo"
+    it "should return the passed in hash values joined with the delimiter from is_to_s" do
+      s = @property.is_to_s({"foo" => "baz" , "bar" => "boo"})
+
+      # We can't predict the order the hash is processed in...
+      ["foo=baz;bar=boo", "bar=boo;foo=baz"].should be_include s
     end
 
     describe "when calling inclusive?" do

data/spec/unit/property_spec.rb

@@ -3,161 +3,152 @@ require 'spec_helper'
 require 'puppet/property'
 
 describe Puppet::Property do
-  before do
-    @class = Class.new(Puppet::Property) do
-      @name = :foo
-    end
-    @class.initvars
-    @provider = mock 'provider'
-    @resource = stub 'resource', :provider => @provider
-    @resource.stub_everything
-    @property = @class.new :resource => @resource
+  let :resource do Puppet::Type.type(:host).new :name => "foo" end
+
+  let :subclass do
+    # We need a completely fresh subclass every time, because we modify both
+    # class and instance level things inside the tests.
+    subclass = Class.new(Puppet::Property) do @name = :foo end
+    subclass.initvars
+    subclass
   end
 
-  it "should return its name as a string when converted to a string" do
-    @property.to_s.should == @property.name.to_s
-  end
+  let :property do subclass.new :resource => resource end
 
   it "should be able to look up the modified name for a given value" do
-    @class.newvalue(:foo)
-    @class.value_name("foo").should == :foo
+    subclass.newvalue(:foo)
+    subclass.value_name("foo").should == :foo
   end
 
   it "should be able to look up the modified name for a given value matching a regex" do
-    @class.newvalue(%r{.})
-    @class.value_name("foo").should == %r{.}
+    subclass.newvalue(%r{.})
+    subclass.value_name("foo").should == %r{.}
   end
 
   it "should be able to look up a given value option" do
-    @class.newvalue(:foo, :event => :whatever)
-    @class.value_option(:foo, :event).should == :whatever
+    subclass.newvalue(:foo, :event => :whatever)
+    subclass.value_option(:foo, :event).should == :whatever
   end
 
   it "should be able to specify required features" do
-    @class.should respond_to(:required_features=)
+    subclass.should respond_to(:required_features=)
   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
+      subclass.required_features = in_value
+      subclass.required_features.should == out_value
     end
   }
 
+  it "should return its name as a string when converted to a string" do
+    property.to_s.should == property.name.to_s
+  end
+
   it "should be able to shadow metaparameters" do
-    @property.must respond_to(:shadow)
+    property.must respond_to(:shadow)
   end
 
   describe "when returning the default event name" do
-    before do
-      @resource = stub 'resource'
-      @instance = @class.new(:resource => @resource)
-      @instance.stubs(:should).returns "myval"
-    end
-
     it "should use the current 'should' value to pick the event name" do
-      @instance.expects(:should).returns "myvalue"
-      @class.expects(:value_option).with('myvalue', :event).returns :event_name
+      property.expects(:should).returns "myvalue"
+      subclass.expects(:value_option).with('myvalue', :event).returns :event_name
 
-      @instance.event_name
+      property.event_name
     end
 
     it "should return any event defined with the specified value" do
-      @instance.expects(:should).returns :myval
-      @class.expects(:value_option).with(:myval, :event).returns :event_name
+      property.expects(:should).returns :myval
+      subclass.expects(:value_option).with(:myval, :event).returns :event_name
 
-      @instance.event_name.should == :event_name
+      property.event_name.should == :event_name
     end
 
     describe "and the property is 'ensure'" do
-      before do
-        @instance.stubs(:name).returns :ensure
-        @resource.expects(:type).returns :mytype
+      before :each do
+        property.stubs(:name).returns :ensure
+        resource.expects(:type).returns :mytype
       end
 
       it "should use <type>_created if the 'should' value is 'present'" do
-        @instance.expects(:should).returns :present
-        @instance.event_name.should == :mytype_created
+        property.expects(:should).returns :present
+        property.event_name.should == :mytype_created
       end
 
       it "should use <type>_removed if the 'should' value is 'absent'" do
-        @instance.expects(:should).returns :absent
-        @instance.event_name.should == :mytype_removed
+        property.expects(:should).returns :absent
+        property.event_name.should == :mytype_removed
       end
 
       it "should use <type>_changed if the 'should' value is not 'absent' or 'present'" do
-        @instance.expects(:should).returns :foo
-        @instance.event_name.should == :mytype_changed
+        property.expects(:should).returns :foo
+        property.event_name.should == :mytype_changed
       end
 
       it "should use <type>_changed if the 'should value is nil" do
-        @instance.expects(:should).returns nil
-        @instance.event_name.should == :mytype_changed
+        property.expects(:should).returns nil
+        property.event_name.should == :mytype_changed
       end
     end
 
     it "should use <property>_changed if the property is not 'ensure'" do
-      @instance.stubs(:name).returns :myparam
-      @instance.expects(:should).returns :foo
-      @instance.event_name.should == :myparam_changed
+      property.stubs(:name).returns :myparam
+      property.expects(:should).returns :foo
+      property.event_name.should == :myparam_changed
     end
 
     it "should use <property>_changed if no 'should' value is set" do
-      @instance.stubs(:name).returns :myparam
-      @instance.expects(:should).returns nil
-      @instance.event_name.should == :myparam_changed
+      property.stubs(:name).returns :myparam
+      property.expects(:should).returns nil
+      property.event_name.should == :myparam_changed
     end
   end
 
   describe "when creating an event" do
-    before do
-      @event = Puppet::Transaction::Event.new
-
-      # Use a real resource so we can test the event creation integration
-      @resource = Puppet::Type.type(:host).new :name => "foo"
-      @instance = @class.new(:resource => @resource)
-      @instance.stubs(:should).returns "myval"
+    before :each do
+      property.stubs(:should).returns "myval"
     end
 
     it "should use an event from the resource as the base event" do
       event = Puppet::Transaction::Event.new
-      @resource.expects(:event).returns event
+      resource.expects(:event).returns event
 
-      @instance.event.should equal(event)
+      property.event.should equal(event)
     end
 
     it "should have the default event name" do
-      @instance.expects(:event_name).returns :my_event
-      @instance.event.name.should == :my_event
+      property.expects(:event_name).returns :my_event
+      property.event.name.should == :my_event
     end
 
     it "should have the property's name" do
-      @instance.event.property.should == @instance.name.to_s
+      property.event.property.should == property.name.to_s
     end
 
     it "should have the 'should' value set" do
-      @instance.stubs(:should).returns "foo"
-      @instance.event.desired_value.should == "foo"
+      property.stubs(:should).returns "foo"
+      property.event.desired_value.should == "foo"
     end
 
     it "should provide its path as the source description" do
-      @instance.stubs(:path).returns "/my/param"
-      @instance.event.source_description.should == "/my/param"
+      property.stubs(:path).returns "/my/param"
+      property.event.source_description.should == "/my/param"
     end
   end
 
   describe "when shadowing metaparameters" do
-    before do
-      @shadow_class = Class.new(Puppet::Property) do
+    let :shadow_class do
+      shadow_class = Class.new(Puppet::Property) do
         @name = :alias
       end
-      @shadow_class.initvars
+      shadow_class.initvars
+      shadow_class
     end
 
     it "should create an instance of the metaparameter at initialization" do
-      Puppet::Type.metaparamclass(:alias).expects(:new).with(:resource => @resource)
+      Puppet::Type.metaparamclass(:alias).expects(:new).with(:resource => resource)
 
-      @shadow_class.new :resource => @resource
+      shadow_class.new :resource => resource
     end
 
     it "should munge values using the shadow's munge method" do
@@ -166,244 +157,354 @@ describe Puppet::Property do
 
       shadow.expects(:munge).with "foo"
 
-      property = @shadow_class.new :resource => @resource
+      property = shadow_class.new :resource => resource
       property.munge("foo")
     end
   end
 
   describe "when defining new values" do
     it "should define a method for each value created with a block that's not a regex" do
-      @class.newvalue(:foo) { }
-      @property.must respond_to(:set_foo)
+      subclass.newvalue(:foo) { }
+      property.must respond_to(:set_foo)
     end
   end
 
   describe "when assigning the value" do
     it "should just set the 'should' value" do
-      @property.value = "foo"
-      @property.should.must == "foo"
+      property.value = "foo"
+      property.should.must == "foo"
     end
 
     it "should validate each value separately" do
-      @property.expects(:validate).with("one")
-      @property.expects(:validate).with("two")
+      property.expects(:validate).with("one")
+      property.expects(:validate).with("two")
 
-      @property.value = %w{one two}
+      property.value = %w{one two}
     end
 
     it "should munge each value separately and use any result as the actual value" do
-      @property.expects(:munge).with("one").returns :one
-      @property.expects(:munge).with("two").returns :two
+      property.expects(:munge).with("one").returns :one
+      property.expects(:munge).with("two").returns :two
 
       # Do this so we get the whole array back.
-      @class.array_matching = :all
+      subclass.array_matching = :all
 
-      @property.value = %w{one two}
-      @property.should.must == [:one, :two]
+      property.value = %w{one two}
+      property.should.must == [:one, :two]
     end
 
     it "should return any set value" do
-      (@property.value = :one).should == :one
+      (property.value = :one).should == :one
     end
   end
 
   describe "when returning the value" do
     it "should return nil if no value is set" do
-      @property.should.must be_nil
+      property.should.must be_nil
     end
 
     it "should return the first set 'should' value if :array_matching is set to :first" do
-      @class.array_matching = :first
-      @property.should = %w{one two}
-      @property.should.must == "one"
+      subclass.array_matching = :first
+      property.should = %w{one two}
+      property.should.must == "one"
     end
 
     it "should return all set 'should' values as an array if :array_matching is set to :all" do
-      @class.array_matching = :all
-      @property.should = %w{one two}
-      @property.should.must == %w{one two}
+      subclass.array_matching = :all
+      property.should = %w{one two}
+      property.should.must == %w{one two}
     end
 
     it "should default to :first array_matching" do
-      @class.array_matching.should == :first
+      subclass.array_matching.should == :first
     end
 
     it "should unmunge the returned value if :array_matching is set to :first" do
-      @property.class.unmunge do |v| v.to_sym end
-      @class.array_matching = :first
-      @property.should = %w{one two}
+      property.class.unmunge do |v| v.to_sym end
+      subclass.array_matching = :first
+      property.should = %w{one two}
 
-      @property.should.must == :one
+      property.should.must == :one
     end
 
     it "should unmunge all the returned values if :array_matching is set to :all" do
-      @property.class.unmunge do |v| v.to_sym end
-      @class.array_matching = :all
-      @property.should = %w{one two}
+      property.class.unmunge do |v| v.to_sym end
+      subclass.array_matching = :all
+      property.should = %w{one two}
 
-      @property.should.must == [:one, :two]
+      property.should.must == [:one, :two]
     end
   end
 
   describe "when validating values" do
     it "should do nothing if no values or regexes have been defined" do
-      lambda { @property.should = "foo" }.should_not raise_error
+      lambda { property.should = "foo" }.should_not raise_error
     end
 
     it "should fail if the value is not a defined value or alias and does not match a regex" do
-      @class.newvalue(:foo)
+      subclass.newvalue(:foo)
 
-      lambda { @property.should = "bar" }.should raise_error
+      lambda { property.should = "bar" }.should raise_error
     end
 
     it "should succeeed if the value is one of the defined values" do
-      @class.newvalue(:foo)
+      subclass.newvalue(:foo)
 
-      lambda { @property.should = :foo }.should_not raise_error
+      lambda { property.should = :foo }.should_not raise_error
     end
 
     it "should succeeed if the value is one of the defined values even if the definition uses a symbol and the validation uses a string" do
-      @class.newvalue(:foo)
+      subclass.newvalue(:foo)
 
-      lambda { @property.should = "foo" }.should_not raise_error
+      lambda { property.should = "foo" }.should_not raise_error
     end
 
     it "should succeeed if the value is one of the defined values even if the definition uses a string and the validation uses a symbol" do
-      @class.newvalue("foo")
+      subclass.newvalue("foo")
 
-      lambda { @property.should = :foo }.should_not raise_error
+      lambda { property.should = :foo }.should_not raise_error
     end
 
     it "should succeed if the value is one of the defined aliases" do
-      @class.newvalue("foo")
-      @class.aliasvalue("bar", "foo")
+      subclass.newvalue("foo")
+      subclass.aliasvalue("bar", "foo")
 
-      lambda { @property.should = :bar }.should_not raise_error
+      lambda { property.should = :bar }.should_not raise_error
     end
 
     it "should succeed if the value matches one of the regexes" do
-      @class.newvalue(/./)
+      subclass.newvalue(/./)
 
-      lambda { @property.should = "bar" }.should_not raise_error
+      lambda { property.should = "bar" }.should_not raise_error
     end
 
     it "should validate that all required features are present" do
-      @class.newvalue(:foo, :required_features => [:a, :b])
+      subclass.newvalue(:foo, :required_features => [:a, :b])
 
-      @provider.expects(:satisfies?).with([:a, :b]).returns true
+      resource.provider.expects(:satisfies?).with([:a, :b]).returns true
 
-      @property.should = :foo
+      property.should = :foo
     end
 
     it "should fail if required features are missing" do
-      @class.newvalue(:foo, :required_features => [:a, :b])
+      subclass.newvalue(:foo, :required_features => [:a, :b])
 
-      @provider.expects(:satisfies?).with([:a, :b]).returns false
+      resource.provider.expects(:satisfies?).with([:a, :b]).returns false
 
-      lambda { @property.should = :foo }.should raise_error(Puppet::Error)
+      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])
+      subclass.newvalue(:foo, :required_features => [:a, :b])
 
-      @provider.expects(:satisfies?).with([:a, :b]).returns false
+      resource.provider.expects(:satisfies?).with([:a, :b]).returns false
 
-      lambda { @property.validate_features_per_value :foo }.should raise_error(ArgumentError)
+      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])
+      value = subclass.newvalue(/./, :required_features => [:a, :b])
 
-      @provider.expects(:satisfies?).with([:a, :b]).returns true
+      resource.provider.expects(:satisfies?).with([:a, :b]).returns true
 
-      @property.should = "foo"
+      property.should = "foo"
     end
 
     it "should support specifying an individual required feature" do
-      value = @class.newvalue(/./, :required_features => :a)
+      value = subclass.newvalue(/./, :required_features => :a)
 
-      @provider.expects(:satisfies?).returns true
+      resource.provider.expects(:satisfies?).returns true
 
-      @property.should = "foo"
+      property.should = "foo"
     end
   end
 
   describe "when munging values" do
     it "should do nothing if no values or regexes have been defined" do
-      @property.munge("foo").should == "foo"
+      property.munge("foo").should == "foo"
     end
 
     it "should return return any matching defined values" do
-      @class.newvalue(:foo)
-      @property.munge("foo").should == :foo
+      subclass.newvalue(:foo)
+      property.munge("foo").should == :foo
     end
 
     it "should return any matching aliases" do
-      @class.newvalue(:foo)
-      @class.aliasvalue(:bar, :foo)
-      @property.munge("bar").should == :foo
+      subclass.newvalue(:foo)
+      subclass.aliasvalue(:bar, :foo)
+      property.munge("bar").should == :foo
     end
 
     it "should return the value if it matches a regex" do
-      @class.newvalue(/./)
-      @property.munge("bar").should == "bar"
+      subclass.newvalue(/./)
+      property.munge("bar").should == "bar"
     end
 
     it "should return the value if no other option is matched" do
-      @class.newvalue(:foo)
-      @property.munge("bar").should == "bar"
+      subclass.newvalue(:foo)
+      property.munge("bar").should == "bar"
     end
   end
 
   describe "when syncing the 'should' value" do
     it "should set the value" do
-      @class.newvalue(:foo)
-      @property.should = :foo
-      @property.expects(:set).with(:foo)
-      @property.sync
+      subclass.newvalue(:foo)
+      property.should = :foo
+      property.expects(:set).with(:foo)
+      property.sync
     end
   end
 
   describe "when setting a value" do
     it "should catch exceptions and raise Puppet::Error" do
-      @class.newvalue(:foo) { raise "eh" }
-      lambda { @property.set(:foo) }.should raise_error(Puppet::Error)
+      subclass.newvalue(:foo) { raise "eh" }
+      lambda { property.set(:foo) }.should raise_error(Puppet::Error)
     end
 
     describe "that was defined without a block" do
       it "should call the settor on the provider" do
-        @class.newvalue(:bar)
-        @provider.expects(:foo=).with :bar
-        @property.set(:bar)
+        subclass.newvalue(:bar)
+        resource.provider.expects(:foo=).with :bar
+        property.set(:bar)
       end
     end
 
     describe "that was defined with a block" do
       it "should call the method created for the value if the value is not a regex" do
-        @class.newvalue(:bar) {}
-        @property.expects(:set_bar)
-        @property.set(:bar)
+        subclass.newvalue(:bar) {}
+        property.expects(:set_bar)
+        property.set(:bar)
       end
 
       it "should call the provided block if the value is a regex" do
-        @class.newvalue(/./) { self.test }
-        @property.expects(:test)
-        @property.set("foo")
+        subclass.newvalue(/./) { self.test }
+        property.expects(:test)
+        property.set("foo")
       end
     end
   end
 
   describe "when producing a change log" do
     it "should say 'defined' when the current value is 'absent'" do
-      @property.change_to_s(:absent, "foo").should =~ /^defined/
+      property.change_to_s(:absent, "foo").should =~ /^defined/
     end
 
     it "should say 'undefined' when the new value is 'absent'" do
-      @property.change_to_s("foo", :absent).should =~ /^undefined/
+      property.change_to_s("foo", :absent).should =~ /^undefined/
     end
 
     it "should say 'changed' when neither value is 'absent'" do
-      @property.change_to_s("foo", "bar").should =~ /changed/
+      property.change_to_s("foo", "bar").should =~ /changed/
+    end
+  end
+
+  shared_examples_for "#insync?" do
+    # We share a lot of behaviour between the all and first matching, so we
+    # use a shared behaviour set to emulate that.  The outside world makes
+    # sure the class, etc, point to the right content.
+    [[], [12], [12, 13]].each do |input|
+      it "should return true if should is empty with is => #{input.inspect}" do
+        property.should = []
+        property.must be_insync(input)
+      end
+    end
+  end
+
+  describe "#insync?" do
+    context "array_matching :all" do
+      # `@should` is an array of scalar values, and `is` is an array of scalar values.
+      before :each do
+        property.class.array_matching = :all
+      end
+
+      it_should_behave_like "#insync?"
+
+      context "if the should value is an array" do
+        before :each do property.should = [1, 2] end
+
+        it "should match if is exactly matches" do
+          property.must be_insync [1, 2]
+        end
+
+        it "should match if it matches, but all stringified" do
+          property.must be_insync ["1", "2"]
+        end
+
+        it "should not match if some-but-not-all values are stringified" do
+          property.must_not be_insync ["1", 2]
+          property.must_not be_insync [1, "2"]
+        end
+
+        it "should not match if order is different but content the same" do
+          property.must_not be_insync [2, 1]
+        end
+
+        it "should not match if there are more items in should than is" do
+          property.must_not be_insync [1]
+        end
+
+        it "should not match if there are less items in should than is" do
+          property.must_not be_insync [1, 2, 3]
+        end
+
+        it "should not match if `is` is empty but `should` isn't" do
+          property.must_not be_insync []
+        end
+      end
+    end
+
+    context "array_matching :first" do
+      # `@should` is an array of scalar values, and `is` is a scalar value.
+      before :each do
+        property.class.array_matching = :first
+      end
+
+      it_should_behave_like "#insync?"
+
+      [[1],                     # only the value
+       [1, 2],                  # matching value first
+       [2, 1],                  # matching value last
+       [0, 1, 2],               # matching value in the middle
+      ].each do |input|
+        it "should by true if one unmodified should value of #{input.inspect} matches what is" do
+          property.should = input
+          property.must be_insync 1
+        end
+
+        it "should be true if one stringified should value of #{input.inspect} matches what is" do
+          property.should = input
+          property.must be_insync "1"
+        end
+      end
+
+      it "should not match if we expect a string but get the non-stringified value" do
+        property.should = ["1"]
+        property.must_not be_insync 1
+      end
+
+      [[0], [0, 2]].each do |input|
+        it "should not match if no should values match what is" do
+          property.should = input
+          property.must_not be_insync 1
+          property.must_not be_insync "1" # shouldn't match either.
+        end
+      end
+    end
+  end
+
+  describe "#property_matches?" do
+    [1, "1", [1], :one].each do |input|
+      it "should treat two equal objects as equal (#{input.inspect})" do
+        property.property_matches?(input, input).should be_true
+      end
+    end
+
+    it "should treat two objects as equal if the first argument is the stringified version of the second" do
+      property.property_matches?("1", 1).should be_true
+    end
+
+    it "should NOT treat two objects as equal if the first argument is not a string, and the second argument is a string, even if it stringifies to the first" do
+      property.property_matches?(1, "1").should be_false
     end
   end
 end