puppet 0.22.4 → 0.23.0

data/test/ral/providers/parsedfile.rb

@@ -29,25 +29,25 @@ class TestParsedFile < Test::Unit::TestCase
 
         # The target should always be a property, not a parameter.
         newproperty(:target) do
-            defaultto { @parent.class.defaultprovider.default_target }
+            defaultto { @resource.class.defaultprovider.default_target }
         end
     end
 
     # A simple block to skip the complexity of a full transaction.
-    def apply(model)
+    def apply(resource)
         [:one, :two, :ensure].each do |st|
             Puppet.info "Setting %s: %s => %s" %
-                [model[:name], st, model.should(st)]
-            model.provider.send(st.to_s + "=", model.should(st))
+                [resource[:name], st, resource.should(st)]
+            resource.provider.send(st.to_s + "=", resource.should(st))
         end
     end
 
-    def mkmodel(name, options = {})
+    def mkresource(name, options = {})
         options[:one] ||= "a"
         options[:two] ||= "c"
         options[:name] ||= name
 
-        model = @type.create(options)
+        resource = @type.create(options)
     end
 
     def mkprovider(name = :parsed)
@@ -76,7 +76,7 @@ class TestParsedFile < Test::Unit::TestCase
         end
     end
 
-    def test_model_attributes
+    def test_resource_attributes
         prov = nil
         assert_nothing_raised do
             prov = mkprovider
@@ -87,11 +87,12 @@ class TestParsedFile < Test::Unit::TestCase
         end
 
         # Now make sure they stay around
-        fakemodel = fakemodel(:testparsedfiletype, "yay")
+        fakeresource = fakeresource(:testparsedfiletype, "yay")
 
-        file = prov.new(fakemodel)
+        file = prov.new(fakeresource)
+        assert(file, "Could not make provider")
 
-        assert_nothing_raised do
+        assert_nothing_raised("Could not set provider name") do
             file.name = :yayness
         end
 
@@ -202,35 +203,34 @@ class TestParsedFile < Test::Unit::TestCase
 
         prov.target_object(:default).write "will b d"
 
-        # Create some models for some of those demo files
-        model = mkmodel "bill", :target => :file1
-        default = mkmodel "will", :target => :default
+        # Create some resources for some of those demo files
+        resource = mkresource "bill", :target => :file1
+        default = mkresource "will", :target => :default
+
+        resources = {"bill" => resource, "will" => default}
 
         assert_nothing_raised do
-            prov.prefetch
+            prov.prefetch(resources)
         end
 
-        # Make sure we prefetched our models.
-        assert_equal("b", model.provider.one)
-        assert_equal("b", default.provider.one)
-        assert_equal("d", default.provider.two)
+        # Make sure we prefetched our resources.
+        assert_equal("b", resource.provider.one, "did not prefetch resource from file1")
+        assert_equal("b", default.provider.one, "did not prefetch resource from default")
+        assert_equal("d", default.provider.two, "did not prefetch resource from default")
 
         # Now list all of them and make sure we get everything back
-        hashes = nil
+        providers = nil
         assert_nothing_raised do
-            hashes = prov.list
+            providers = prov.instances
         end
 
-        names = nil
-        assert_nothing_raised do
-            names = prov.list_by_name
+        providers.each do |provider|
+            assert_instance_of(prov, provider, "'instances' class method did not return providers")
         end
 
         %w{bill jill will}.each do |name|
-            assert(hashes.find { |r| r[:name] == name},
+            assert(providers.find { |provider| provider.name == name},
                 "Did not return %s in list" % name)
-            assert(names.include?(name),
-                "Did not return %s in list_by_name" % name)
         end
     end
 
@@ -242,25 +242,27 @@ class TestParsedFile < Test::Unit::TestCase
         target = :yayness
         prov.target_object(target).write "yay b d"
 
-        model = mkmodel "yay", :target => :yayness
-
+        records = nil
         assert_nothing_raised do
-            prov.prefetch_target(:yayness)
+            records = prov.prefetch_target(:yayness)
         end
 
         # Now make sure we correctly got the hash
-        mprov = model.provider
-        assert_equal("b", mprov.one)
-        assert_equal("d", mprov.two)
+        record = records.find { |r| r[:name] == "yay" }
+        assert(record, "Did not get record in prefetch_target")
+        assert_equal("b", record[:one])
+        assert_equal("d", record[:two])
     end
 
     def test_prefetch_match
         prov = mkprovider
 
-        prov.meta_def(:match) do |record|
+        prov.meta_def(:match) do |record, resources|
             # Look for matches on :one
-            self.model.find do |m|
-                m.should(:one).to_s == record[:one].to_s
+            if res = resources.find { |name, resource| resource.should(:one).to_s == record[:one].to_s }
+                res[1]
+            else
+                nil
             end
         end
 
@@ -268,22 +270,22 @@ class TestParsedFile < Test::Unit::TestCase
         target = :yayness
         prov.target_object(target).write "foo b d"
 
-        model = mkmodel "yay", :target => :yayness, :one => "b"
+        resource = mkresource "yay", :target => :yayness, :one => "b"
 
         assert_nothing_raised do
-            prov.prefetch_target(:yayness)
+            prov.prefetch("yay" => resource)
         end
 
         # Now make sure we correctly got the hash
-        mprov = model.provider
-        assert_equal("yay", model[:name])
+        mprov = resource.provider
+        assert_equal("yay", resource[:name])
         assert_equal("b", mprov.one)
         assert_equal("d", mprov.two)
     end
 
     # We need to test that we're retrieving files from all three locations:
     # from any existing target_objects, from the default file location, and
-    # from any existing model instances.
+    # from any existing resource instances.
     def test_targets
         prov = mkprovider
 
@@ -299,24 +301,37 @@ class TestParsedFile < Test::Unit::TestCase
         files[:inmemory] = inmem
         prov.target_object(inmem).write("inmem yay ness")
 
-        # Lastly, create a model with separate is and should values
+        # Lastly, create a resource with separate is and should values
         mtarget = tempfile()
-        istarget = tempfile()
-        files[:models] = mtarget
-        files[:ismodels] = istarget
-        model = mkmodel "yay", :target => mtarget
-        model.is = [:target, istarget]
+        files[:resources] = mtarget
+        resource = mkresource "yay", :target => mtarget
 
-        assert(model.should(:target), "Did not get a value for target")
-        assert(model.is(:target), "Did not get a value for target")
+        assert(resource.should(:target), "Did not get a value for target")
 
         list = nil
+
+        # First run it without the resource
         assert_nothing_raised do
             list = prov.targets
         end
 
+        # Make sure it got the first two, but not the resources file
+        files.each do |name, file|
+            if name == :resources
+                assert(! list.include?(file), "Provider somehow found resource target when no resource was passed")
+            else
+                assert(list.include?(file), "Provider did not find %s file" % name)
+            end
+        end
+
+        # Now list with the resource passed
+        assert_nothing_raised do
+            list = prov.targets("yay" => resource)
+        end
+
+        # And make sure we get all three files
         files.each do |name, file|
-            assert(list.include?(file), "Provider did not find %s file" % name)
+            assert(list.include?(file), "Provider did not find %s file when resource was passed" % name)
         end
     end
 
@@ -328,22 +343,23 @@ class TestParsedFile < Test::Unit::TestCase
         prov.filetype = :ram
         prov.default_target = :yayness
 
-        # Create some models.
-        one = mkmodel "one", :one => "a", :two => "c", :target => :yayness
-        two = mkmodel "two", :one => "b", :two => "d", :target => :yayness
+        # Create some resources.
+        one = mkresource "one", :one => "a", :two => "c", :target => :yayness
+        two = mkresource "two", :one => "b", :two => "d", :target => :yayness
+        resources = {"one" => one, "two" => two}
 
         # Write out a file with different data.
         prov.target_object(:yayness).write "one b d\ntwo a c"
 
-        prov.prefetch
+        prov.prefetch(resources)
 
-        # Apply and flush the first model.
+        # Apply and flush the first resource.
         assert_nothing_raised do
             apply(one)
         end
         assert_nothing_raised { one.flush }
 
-        # Make sure it changed our file
+        # Make sure it didn't clear out our property hash
         assert_equal(:a, one.provider.one)
         assert_equal(:c, one.provider.two)
 
@@ -351,56 +367,58 @@ class TestParsedFile < Test::Unit::TestCase
         assert(prov.target_object(:yayness).read.include?("one a c"),
             "Did not write out correct data")
 
-        # Make sure the second model has not been modified
+        # Make sure the second resource has not been modified
         assert_equal("a", two.provider.one, "Two was flushed early")
         assert_equal("c", two.provider.two, "Two was flushed early")
 
         # And on disk
         assert(prov.target_object(:yayness).read.include?("two a c"),
-            "Wrote out other model")
+            "Wrote out other resource")
 
         # Now fetch the data again and make sure we're still right
-        assert_nothing_raised { prov.prefetch }
+        assert_nothing_raised { prov.prefetch(resources) }
         assert_equal("a", one.provider.one)
         assert_equal("a", two.provider.one)
 
-        # Now flush the second model and make sure it goes well
+        # Now flush the second resource and make sure it goes well
         assert_nothing_raised { apply(two) }
         assert_nothing_raised { two.flush }
 
+        # And make sure it didn't clear our hash
         assert_equal(:b, two.provider.one)
     end
 
+    # Make sure it works even if the file does not currently exist
     def test_creating_file
         prov = mkprovider
         prov.clear
 
         prov.default_target = :basic
 
-        model = mkmodel "yay", :target => :basic, :one => "a", :two => "c"
+        resource = mkresource "yay", :target => :basic, :one => "a", :two => "c"
 
-        assert_equal(:present, model.should(:ensure))
+        assert_equal(:present, resource.should(:ensure))
 
-        apply(model)
+        apply(resource)
 
         assert_nothing_raised do
-            model.flush
+            resource.flush
         end
 
-        assert(prov.target_object(:basic).read.include?("yay a c"),
+        assert_equal("yay a c\n", prov.target_object(:basic).read,
             "Did not create file")
 
         # Make a change
-        model.provider.one = "b"
+        resource.provider.one = "b"
 
         # Flush it
         assert_nothing_raised do
-            model.flush
+            resource.flush
         end
 
-        # And make sure our model doesn't appear twice in the file.
-        assert_equal("yay b c\n",
-            prov.target_object(:basic).read)
+        # And make sure our resource doesn't appear twice in the file.
+        assert_equal("yay b c\n", prov.target_object(:basic).read,
+            "Wrote record to file twice")
     end
 
     # Make sure a record can switch targets.
@@ -410,10 +428,10 @@ class TestParsedFile < Test::Unit::TestCase
         prov.filetype = :ram
         prov.default_target = :first
 
-        # Make three models, one for each target and one to switch
-        first = mkmodel "first", :target => :first
-        second = mkmodel "second", :target => :second
-        mover = mkmodel "mover", :target => :first
+        # Make three resources, one for each target and one to switch
+        first = mkresource "first", :target => :first
+        second = mkresource "second", :target => :second
+        mover = mkresource "mover", :target => :first
 
         [first, second, mover].each do |m|
             assert_nothing_raised("Could not apply %s" % m[:name]) do
@@ -467,12 +485,12 @@ class TestParsedFile < Test::Unit::TestCase
         prov.filetype = :ram
         prov.default_target = :first
 
-        # Make two models, one that starts on disk and one that doesn't
-        ondisk = mkmodel "ondisk", :target => :first
-        notdisk = mkmodel "notdisk", :target => :first
+        # Make two resources, one that starts on disk and one that doesn't
+        ondisk = mkresource "ondisk", :target => :first
+        notdisk = mkresource "notdisk", :target => :first
 
         prov.target_object(:first).write "ondisk a c\n"
-        prov.prefetch
+        prov.prefetch("ondisk" => ondisk, "notdisk" => notdisk)
 
         assert_equal(:present, notdisk.should(:ensure),
             "Did not get default ensure value")
@@ -496,7 +514,7 @@ class TestParsedFile < Test::Unit::TestCase
         assert(prov.target_object(:first).read =~ /^ondisk/,
             "Lost object on disk")
 
-        # Make sure our on-disk model behaves appropriately.
+        # Make sure our on-disk resource behaves appropriately.
         assert_equal(:present, ondisk.provider.ensure)
 
         # Now destroy the object
@@ -544,7 +562,7 @@ class TestParsedFile < Test::Unit::TestCase
 
         prov.target_object(:yayness).write "bill a c\njill b d"
 
-        list = @type.list
+        list = @type.instances
 
         bill = list.find { |r| r[:name] == "bill" }
         jill = list.find { |r| r[:name] == "jill" }
@@ -559,15 +577,23 @@ class TestParsedFile < Test::Unit::TestCase
 
         # First make sure we can retrieve values multiple times from the
         # provider
-        assert(bill.is(:one), "Bill does not have a value for 'one'")
-        assert(bill.is(:one), "Bill does not have a value for 'one' on second try")
+        bills_values = nil
+        assert_nothing_raised do
+            bills_values = bill.retrieve
+        end
+
+        assert(bills_values[bill.property(:one)], 
+               "Bill does not have a value for 'one'")
+        assert(bills_values[bill.property(:one)], 
+               "Bill does not have a value for 'one' on second try")
         assert_nothing_raised do
             bill.retrieve
         end
-        assert(bill.is(:one), "bill's value for 'one' disappeared")
+        assert(bills_values[bill.property(:one)], 
+               "bill's value for 'one' disappeared")
     end
 
-    # Make sure that creating a new model finds existing records in memory
+    # Make sure that creating a new resource finds existing records in memory
     def test_initialize_finds_records
         prov = mkprovider
         prov.default_target = :yayness
@@ -576,7 +602,7 @@ class TestParsedFile < Test::Unit::TestCase
 
         prov.prefetch
 
-        # Now make a model
+        # Now make a resource
         bill = nil
         assert_nothing_raised do
             bill = @type.create :name => "bill"
@@ -603,11 +629,12 @@ class TestParsedFile < Test::Unit::TestCase
         assert_apply(bill)
 
         prov.prefetch
+        current_value = nil
         assert_nothing_raised do
-            bill.retrieve
+            current_value = bill.retrieve
         end
 
-        assert(bill.insync?,
+        assert(bill.insync?(current_value),
             "An invalid field marked the record out of sync")
     end
 
@@ -630,7 +657,6 @@ class TestParsedFile < Test::Unit::TestCase
         targeted = {:target => "target"}
         prov.send(:instance_variable_set, "@records", records)
         prov.expects(:retrieve).with(target).returns([targeted])
-        prov.expects(:target_records).with(target).returns([targeted])
 
         prov.expects(:prefetch_hook).with([targeted]).returns([targeted])
 
@@ -664,5 +690,5 @@ class TestParsedFile < Test::Unit::TestCase
     end
 end
 
-# $Id: parsedfile.rb 2290 2007-03-18 18:00:26Z luke $
+# $Id: parsedfile.rb 2551 2007-06-04 20:37:14Z luke $
 

data/test/ral/providers/{parsedport.rb → port/parsed.rb}

@@ -230,4 +230,4 @@ require 'puppettest'
 #    end
 #end
 
-# $Id: parsedport.rb 2178 2007-02-07 23:56:59Z luke $
+# $Id: parsed.rb 2501 2007-05-09 23:08:42Z luke $

data/test/ral/providers/provider.rb

@@ -28,6 +28,15 @@ class TestProvider < Test::Unit::TestCase
         return provider
     end
 
+    def setup
+        super
+        @type = Puppet::Type.newtype(:provider_test) do
+            newparam(:name) {}
+            ensurable
+        end
+        cleanup { Puppet::Type.rmtype(:provider_test) }
+    end
+
     def test_confine
         provider = newprovider
 
@@ -190,14 +199,14 @@ class TestProvider < Test::Unit::TestCase
                "Did not receive info wrapper on failure")
     end
 
-    def test_mkmodelmethods
+    def test_mk_resource_methods
         prov = newprovider
-        modeltype = Struct.new(:validproperties, :parameters)
-        m = modeltype.new([:prop1, :prop2], [:param1, :param2])
-        prov.model = m
+        resourcetype = Struct.new(:validproperties, :parameters)
+        m = resourcetype.new([:prop1, :prop2], [:param1, :param2])
+        prov.resource_type = m
 
-        assert_nothing_raised("could not call mkmodelmethods") do
-            prov.mkmodelmethods
+        assert_nothing_raised("could not call mk_resource_methods") do
+            prov.mk_resource_methods
         end
 
         obj = prov.new(nil)
@@ -243,6 +252,75 @@ class TestProvider < Test::Unit::TestCase
             optional.missing
         end
     end
+
+    # Disabling, since I might not keep this interface
+    def disabled_test_read_and_each
+        # Create a new provider
+        provider = @type.provide(:testing)
+
+        assert_raise(Puppet::DevError, "Did not fail when :read was not overridden") do
+            provider.read
+        end
+
+        children = [:one, :two]
+        provider.meta_def(:read) do
+            children
+        end
+
+        result = []
+        assert_nothing_raised("could not call 'each' on provider class") do
+            provider.each { |i| result << i }
+        end
+
+        assert_equal(children, result, "did not get correct list from each")
+
+        assert_equal(children, provider.collect { |i| i }, "provider does not include enumerable")
+    end
+
+    def test_source
+        base = @type.provide(:base)
+
+        assert_equal(:base, base.source, "source did not default correctly")
+        assert_equal(:base, base.source, "source did not default correctly")
+
+        sub = @type.provide(:sub, :parent => :base)
+
+        assert_equal(:sub, sub.source, "source did not default correctly for sub class")
+        assert_equal(:sub, sub.source, "source did not default correctly for sub class")
+
+        other = @type.provide(:other, :parent => :base, :source => :base)
+
+        assert_equal(:base, other.source, "source did not override")
+        assert_equal(:base, other.source, "source did not override")
+    end
+
+    # Make sure we can initialize with either a resource or a hash, or none at all.
+    def test_initialize
+        test = @type.provide(:test)
+
+        inst = @type.create :name => "boo"
+        prov = nil
+        assert_nothing_raised("Could not init with a resource") do
+            prov = test.new(inst)
+        end
+        assert_equal(prov.resource, inst, "did not set resource correctly")
+        assert_equal(inst.name, prov.name, "did not get resource name")
+
+        params = {:name => :one, :ensure => :present}
+        assert_nothing_raised("Could not init with a hash") do
+            prov = test.new(params)
+        end
+        assert_equal(params, prov.send(:instance_variable_get, "@property_hash"), "did not set resource correctly")
+        assert_equal(:one, prov.name, "did not get name from hash")
+
+        assert_nothing_raised("Could not init with no argument") do
+            prov = test.new()
+        end
+
+        assert_raise(Puppet::DevError, "did not fail when no name is present") do
+            prov.name
+        end
+    end
 end
 
 class TestProviderFeatures < Test::Unit::TestCase
@@ -282,7 +360,7 @@ class TestProviderFeatures < Test::Unit::TestCase
             end
         end
 
-        model = @type.create(:name => "foo")
+        resource = @type.create(:name => "foo")
         {:numbers => [:numeric], :letters => [:alpha], :both => [:numeric, :alpha],
             :mixed => [], :neither => []}.each do |name, should|
                 should.sort! { |a,b| a.to_s <=> b.to_s }
@@ -291,7 +369,7 @@ class TestProviderFeatures < Test::Unit::TestCase
                 assert_equal(should, provider.features,
                     "Provider %s has incorrect features" % name)
 
-                inst = provider.new(model)
+                inst = provider.new(resource)
                 # Make sure the boolean methods work on both the provider and
                 # instance.
                 @features.keys.each do |feature|
@@ -346,6 +424,8 @@ class TestProviderFeatures < Test::Unit::TestCase
 
         assert(provider.respond_to?(:has_features),
             "Provider did not get 'has_features' method added")
+        assert(provider.respond_to?(:has_feature),
+            "Provider did not get the 'has_feature' alias method")
 
         # One with the numeric methods and nothing else
         @type.provide(:numbers) do
@@ -358,17 +438,17 @@ class TestProviderFeatures < Test::Unit::TestCase
             define_method(:one) {}
             define_method(:two) {}
 
-            has_features :alpha
+            has_feature :alpha
         end
         
         # And just the declaration
         @type.provide(:letters) do
-            has_features :alpha
+            has_feature :alpha
         end
 
         # And a provider that declares it has our methodless feature.
         @type.provide(:none) do
-            has_features :nomeths
+            has_feature :nomeths
         end
 
         should = {:nothing => [], :both => [:numeric, :alpha],
@@ -392,7 +472,7 @@ class TestProviderFeatures < Test::Unit::TestCase
 
         # and appropriate providers
         nope = @type.provide(:nope) {}
-        maybe = @type.provide(:maybe) { has_features(:alpha) }
+        maybe = @type.provide(:maybe) { has_feature(:alpha) }
         yep = @type.provide(:yep) { has_features(:alpha, :numeric) }
 
         # Now make sure our providers answer correctly.
@@ -420,4 +500,4 @@ class TestProviderFeatures < Test::Unit::TestCase
     end
 end
 
-# $Id: provider.rb 2444 2007-05-01 03:14:09Z luke $
+# $Id: provider.rb 2551 2007-06-04 20:37:14Z luke $