From c8f38b7fee12eefb2bed00681b4952ac7ad3f14f Mon Sep 17 00:00:00 2001
From: luke <luke@980ebf18-57e1-0310-9a29-db15c13687c0>
Date: Wed, 31 Jan 2007 19:38:02 +0000
Subject: Renaming "pelement" to "resource".  The old name is a holdover from
 before we had settled on "resource" as a term.

git-svn-id: https://reductivelabs.com/svn/puppet/trunk@2137 980ebf18-57e1-0310-9a29-db15c13687c0
---
 test/client/pelement.rb |  96 ----------------
 test/client/resource.rb |  96 ++++++++++++++++
 test/server/pelement.rb | 297 ------------------------------------------------
 test/server/resource.rb | 297 ++++++++++++++++++++++++++++++++++++++++++++++++
 4 files changed, 393 insertions(+), 393 deletions(-)
 delete mode 100755 test/client/pelement.rb
 create mode 100755 test/client/resource.rb
 delete mode 100755 test/server/pelement.rb
 create mode 100755 test/server/resource.rb

(limited to 'test')

diff --git a/test/client/pelement.rb b/test/client/pelement.rb
deleted file mode 100755
index 8c8e76963..000000000
--- a/test/client/pelement.rb
+++ /dev/null
@@ -1,96 +0,0 @@
-#!/usr/bin/env ruby
-
-$:.unshift("../lib").unshift("../../lib") if __FILE__ =~ /\.rb$/
-
-require 'puppet'
-require 'puppet/client/pelement'
-require 'puppet/server'
-require 'puppettest'
-
-# $Id$
-
-class TestPElementClient < Test::Unit::TestCase
-    include PuppetTest::ServerTest
-
-    def mkpelementserver
-        handlers = {
-            :CA => {}, # so that certs autogenerate
-            :PElement => {},
-        }
-
-        return mkserver(handlers)
-    end
-
-    def mkclient
-        client = nil
-        assert_nothing_raised {
-            client = Puppet::Client::PElement.new(:Server => "localhost",
-                :Port => @@port)
-        }
-
-        return client
-    end
-
-    def test_pelements
-        file = tempfile()
-        text = "yayness\n"
-        File.open(file, "w") { |f| f.print text }
-
-        mkpelementserver()
-
-        client = mkclient()
-
-        # Test describing
-        tobj = nil
-        assert_nothing_raised {
-            tobj = client.describe("file", file)
-        }
-
-        assert(tobj, "Did not get response")
-
-        assert_instance_of(Puppet::TransObject, tobj)
-
-        obj = nil
-        assert_nothing_raised {
-            obj = tobj.to_type
-        }
-        assert_events([], obj)
-        File.unlink(file)
-        assert_events([:file_created], obj)
-        File.unlink(file)
-
-        # Now test applying
-        result = nil
-        assert_nothing_raised {
-            result = client.apply(tobj)
-        }
-        assert(FileTest.exists?(file), "File was not created on apply")
-
-        # Lastly, test "list"
-        list = nil
-        assert_nothing_raised {
-            list = client.list("user")
-        }
-
-        assert_instance_of(Puppet::TransBucket, list)
-
-        count = 0
-        list.each do |tobj|
-            break if count > 3
-            assert_instance_of(Puppet::TransObject, tobj)
-
-            tobj2 = nil
-            assert_nothing_raised {
-                tobj2 = client.describe(tobj.type, tobj.name)
-            }
-
-            obj = nil
-            assert_nothing_raised {
-                obj = tobj2.to_type
-            }
-            assert_events([], obj)
-
-            count += 1
-        end
-    end
-end
diff --git a/test/client/resource.rb b/test/client/resource.rb
new file mode 100755
index 000000000..51fe7ba7e
--- /dev/null
+++ b/test/client/resource.rb
@@ -0,0 +1,96 @@
+#!/usr/bin/env ruby
+
+$:.unshift("../lib").unshift("../../lib") if __FILE__ =~ /\.rb$/
+
+require 'puppet'
+require 'puppet/client/resource'
+require 'puppet/server'
+require 'puppettest'
+
+# $Id$
+
+class TestResourceClient < Test::Unit::TestCase
+    include PuppetTest::ServerTest
+
+    def mkresourceserver
+        handlers = {
+            :CA => {}, # so that certs autogenerate
+            :Resource => {},
+        }
+
+        return mkserver(handlers)
+    end
+
+    def mkclient
+        client = nil
+        assert_nothing_raised {
+            client = Puppet::Client::Resource.new(:Server => "localhost",
+                :Port => @@port)
+        }
+
+        return client
+    end
+
+    def test_resources
+        file = tempfile()
+        text = "yayness\n"
+        File.open(file, "w") { |f| f.print text }
+
+        mkresourceserver()
+
+        client = mkclient()
+
+        # Test describing
+        tobj = nil
+        assert_nothing_raised {
+            tobj = client.describe("file", file)
+        }
+
+        assert(tobj, "Did not get response")
+
+        assert_instance_of(Puppet::TransObject, tobj)
+
+        obj = nil
+        assert_nothing_raised {
+            obj = tobj.to_type
+        }
+        assert_events([], obj)
+        File.unlink(file)
+        assert_events([:file_created], obj)
+        File.unlink(file)
+
+        # Now test applying
+        result = nil
+        assert_nothing_raised {
+            result = client.apply(tobj)
+        }
+        assert(FileTest.exists?(file), "File was not created on apply")
+
+        # Lastly, test "list"
+        list = nil
+        assert_nothing_raised {
+            list = client.list("user")
+        }
+
+        assert_instance_of(Puppet::TransBucket, list)
+
+        count = 0
+        list.each do |tobj|
+            break if count > 3
+            assert_instance_of(Puppet::TransObject, tobj)
+
+            tobj2 = nil
+            assert_nothing_raised {
+                tobj2 = client.describe(tobj.type, tobj.name)
+            }
+
+            obj = nil
+            assert_nothing_raised {
+                obj = tobj2.to_type
+            }
+            assert_events([], obj)
+
+            count += 1
+        end
+    end
+end
diff --git a/test/server/pelement.rb b/test/server/pelement.rb
deleted file mode 100755
index c86dadc11..000000000
--- a/test/server/pelement.rb
+++ /dev/null
@@ -1,297 +0,0 @@
-#!/usr/bin/env ruby
-
-$:.unshift("../lib").unshift("../../lib") if __FILE__ =~ /\.rb$/
-
-require 'puppet'
-require 'puppet/server/pelement'
-require 'puppettest'
-require 'base64'
-require 'cgi'
-
-class TestPElementServer < Test::Unit::TestCase
-    include PuppetTest::ServerTest
-
-    def verify_described(type, described)
-        described.each do |name, trans|
-            type.clear
-            obj = nil
-            assert_nothing_raised do
-                obj = trans.to_type
-            end
-
-            assert(obj, "Could not create object")
-            assert_nothing_raised do
-                obj.retrieve
-            end
-
-            if trans.type == :package
-                assert_equal(Puppet::Type.type(:package).defaultprovider.name, obj[:provider])
-            end
-        end
-        type.clear
-    end
-
-    def test_describe_file
-        # Make a file to describe
-        file = tempfile()
-        str = "yayness\n"
-
-        server = nil
-
-        assert_nothing_raised do
-            server = Puppet::Server::PElement.new()
-        end
-
-        # The first run we create the file on the copy, the second run
-        # the file is already there so the object should be in sync
-        2.times do |i|
-            [   [nil],
-                [[:content, :mode], []],
-                [[], [:content]],
-                [[:content], [:mode]]
-            ].each do |ary|
-                retrieve = ary[0] || []
-                ignore = ary[1] || []
-
-                File.open(file, "w") { |f| f.print str }
-
-                result = nil
-                assert_nothing_raised do
-                    result = server.describe("file", file, *ary)
-                end
-
-                assert(result, "Could not retrieve file information")
-
-                assert_instance_of(Puppet::TransObject, result)
-
-                # Now we have to clear, so that the server's object gets removed
-                Puppet::Type.type(:file).clear
-
-                # And remove the file, so we can verify it gets recreated
-                if i == 0
-                    File.unlink(file)
-                end
-
-                object = nil
-                assert_nothing_raised do
-                    object = result.to_type
-                end
-
-                assert(object, "Could not create type")
-
-                retrieve.each do |state|
-                    assert(object.should(state), "Did not retrieve %s" % state)
-                end
-
-                ignore.each do |state|
-                    assert(! object.should(state), "Incorrectly retrieved %s" % state)
-                end
-
-                if i == 0
-                    assert_events([:file_created], object)
-                else
-                    assert_nothing_raised {
-                        object.retrieve
-                    }
-                    assert(object.insync?, "Object was not in sync")
-                end
-
-                assert(FileTest.exists?(file), "File did not get recreated")
-
-                if i == 0
-                if object.should(:content)
-                    assert_equal(str, File.read(file), "File contents are not the same")
-                else
-                    assert_equal("", File.read(file), "File content was incorrectly made")
-                end
-                end
-                if FileTest.exists? file
-                    File.unlink(file)
-                end
-            end
-        end
-    end
-
-    def test_describe_directory
-        # Make a file to describe
-        file = tempfile()
-
-        server = nil
-
-        assert_nothing_raised do
-            server = Puppet::Server::PElement.new()
-        end
-
-        [   [nil],
-            [[:ensure, :checksum, :mode], []],
-            [[], [:checksum]],
-            [[:ensure, :checksum], [:mode]]
-        ].each do |ary|
-            retrieve = ary[0] || []
-            ignore = ary[1] || []
-
-            Dir.mkdir(file)
-
-            result = nil
-            assert_nothing_raised do
-                result = server.describe("file", file, *ary)
-            end
-
-            assert(result, "Could not retrieve file information")
-
-            assert_instance_of(Puppet::TransObject, result)
-
-            # Now we have to clear, so that the server's object gets removed
-            Puppet::Type.type(:file).clear
-
-            # And remove the file, so we can verify it gets recreated
-            Dir.rmdir(file)
-
-            object = nil
-            assert_nothing_raised do
-                object = result.to_type
-            end
-
-            assert(object, "Could not create type")
-
-            retrieve.each do |state|
-                assert(object.should(state), "Did not retrieve %s" % state)
-            end
-
-            ignore.each do |state|
-                assert(! object.should(state), "Incorrectly retrieved %s" % state)
-            end
-
-            assert_events([:directory_created], object)
-
-            assert(FileTest.directory?(file), "Directory did not get recreated")
-            Dir.rmdir(file)
-        end
-    end
-
-    def test_describe_alltypes
-        # Systems get pretty retarded, so I'm going to set the path to some fake
-        # data for ports
-        #Puppet::Type::ParsedType::Port.path = File.join(basedir,
-        #    "test/data/types/ports/1")
-        #Puppet.err Puppet::Type::ParsedType::Port.path
-        server = nil
-        assert_nothing_raised do
-            server = Puppet::Server::PElement.new()
-        end
-
-        require 'etc'
-
-        # Make the example schedules, for testing
-        Puppet::Type.type(:schedule).mkdefaultschedules
-
-        Puppet::Type.eachtype do |type|
-            unless type.respond_to? :list
-                Puppet.warning "%s does not respond to :list" % type.name
-                next
-            end
-            next unless type.name == :package
-            Puppet.info "Describing each %s" % type.name
-
-            # First do a listing from the server
-            bucket = nil
-            assert_nothing_raised {
-                bucket = server.list(type.name)
-            }
-
-            #type.clear
-
-            count = 0
-            described = {}
-            bucket.each do |obj|
-                assert_instance_of(Puppet::TransObject, obj)
-                break if count > 5
-                described[obj.name] = server.describe(obj.type, obj.name)
-                count += 1
-            end
-
-            verify_described(type, described)
-
-            count = 0
-            described = {}
-            Puppet.info "listing again"
-            type.list.each do |obj|
-                assert_instance_of(type, obj)
-
-                break if count > 5
-                trans = nil
-                assert_nothing_raised do
-                    described[obj.name] = server.describe(type.name, obj.name)
-                end
-
-                count += 1
-            end
-
-            if described.empty?
-                Puppet.notice "Got no example objects for %s" % type.name
-            end
-
-            # We separate these, in case the list operation creates objects
-            verify_described(type, described)
-        end
-    end
-
-    def test_apply
-        server = nil
-        assert_nothing_raised do
-            server = Puppet::Server::PElement.new()
-        end
-
-        file = tempfile()
-        str = "yayness\n"
-
-        File.open(file, "w") { |f| f.print str }
-
-        filetrans = nil
-        assert_nothing_raised {
-            filetrans = server.describe("file", file)
-        }
-
-        Puppet::Type.type(:file).clear
-
-        bucket = Puppet::TransBucket.new
-        bucket.type = "file"
-        bucket.push filetrans
-
-        oldbucket = bucket.dup
-        File.unlink(file)
-        assert_nothing_raised {
-            server.apply(bucket)
-        }
-
-        assert(FileTest.exists?(file), "File did not get recreated")
-
-        # Now try it as a "nonlocal" server
-        server.local = false
-        yaml = nil
-        assert_nothing_raised {
-            yaml = Base64.encode64(YAML::dump(bucket))
-        }
-
-        Puppet::Type.type(:file).clear
-        File.unlink(file)
-
-        if Base64.decode64(yaml) =~ /(.{20}Loglevel.{20})/
-            Puppet.warning "YAML is broken on this machine"
-            return
-        end
-        # puts Base64.decode64(yaml)
-        objects = nil
-        assert_nothing_raised("Could not reload yaml") {
-            YAML::load(Base64.decode64(yaml))
-        }
-
-        # The server is supposed to accept yaml and execute it.
-        assert_nothing_raised {
-            server.apply(yaml)
-        }
-        assert(FileTest.exists?(file), "File did not get recreated from YAML")
-    end
-end
-
-# $Id$
diff --git a/test/server/resource.rb b/test/server/resource.rb
new file mode 100755
index 000000000..218b65f74
--- /dev/null
+++ b/test/server/resource.rb
@@ -0,0 +1,297 @@
+#!/usr/bin/env ruby
+
+$:.unshift("../lib").unshift("../../lib") if __FILE__ =~ /\.rb$/
+
+require 'puppet'
+require 'puppet/server/resource'
+require 'puppettest'
+require 'base64'
+require 'cgi'
+
+class TestResourceServer < Test::Unit::TestCase
+    include PuppetTest::ServerTest
+
+    def verify_described(type, described)
+        described.each do |name, trans|
+            type.clear
+            obj = nil
+            assert_nothing_raised do
+                obj = trans.to_type
+            end
+
+            assert(obj, "Could not create object")
+            assert_nothing_raised do
+                obj.retrieve
+            end
+
+            if trans.type == :package
+                assert_equal(Puppet::Type.type(:package).defaultprovider.name, obj[:provider])
+            end
+        end
+        type.clear
+    end
+
+    def test_describe_file
+        # Make a file to describe
+        file = tempfile()
+        str = "yayness\n"
+
+        server = nil
+
+        assert_nothing_raised do
+            server = Puppet::Server::Resource.new()
+        end
+
+        # The first run we create the file on the copy, the second run
+        # the file is already there so the object should be in sync
+        2.times do |i|
+            [   [nil],
+                [[:content, :mode], []],
+                [[], [:content]],
+                [[:content], [:mode]]
+            ].each do |ary|
+                retrieve = ary[0] || []
+                ignore = ary[1] || []
+
+                File.open(file, "w") { |f| f.print str }
+
+                result = nil
+                assert_nothing_raised do
+                    result = server.describe("file", file, *ary)
+                end
+
+                assert(result, "Could not retrieve file information")
+
+                assert_instance_of(Puppet::TransObject, result)
+
+                # Now we have to clear, so that the server's object gets removed
+                Puppet::Type.type(:file).clear
+
+                # And remove the file, so we can verify it gets recreated
+                if i == 0
+                    File.unlink(file)
+                end
+
+                object = nil
+                assert_nothing_raised do
+                    object = result.to_type
+                end
+
+                assert(object, "Could not create type")
+
+                retrieve.each do |state|
+                    assert(object.should(state), "Did not retrieve %s" % state)
+                end
+
+                ignore.each do |state|
+                    assert(! object.should(state), "Incorrectly retrieved %s" % state)
+                end
+
+                if i == 0
+                    assert_events([:file_created], object)
+                else
+                    assert_nothing_raised {
+                        object.retrieve
+                    }
+                    assert(object.insync?, "Object was not in sync")
+                end
+
+                assert(FileTest.exists?(file), "File did not get recreated")
+
+                if i == 0
+                if object.should(:content)
+                    assert_equal(str, File.read(file), "File contents are not the same")
+                else
+                    assert_equal("", File.read(file), "File content was incorrectly made")
+                end
+                end
+                if FileTest.exists? file
+                    File.unlink(file)
+                end
+            end
+        end
+    end
+
+    def test_describe_directory
+        # Make a file to describe
+        file = tempfile()
+
+        server = nil
+
+        assert_nothing_raised do
+            server = Puppet::Server::Resource.new()
+        end
+
+        [   [nil],
+            [[:ensure, :checksum, :mode], []],
+            [[], [:checksum]],
+            [[:ensure, :checksum], [:mode]]
+        ].each do |ary|
+            retrieve = ary[0] || []
+            ignore = ary[1] || []
+
+            Dir.mkdir(file)
+
+            result = nil
+            assert_nothing_raised do
+                result = server.describe("file", file, *ary)
+            end
+
+            assert(result, "Could not retrieve file information")
+
+            assert_instance_of(Puppet::TransObject, result)
+
+            # Now we have to clear, so that the server's object gets removed
+            Puppet::Type.type(:file).clear
+
+            # And remove the file, so we can verify it gets recreated
+            Dir.rmdir(file)
+
+            object = nil
+            assert_nothing_raised do
+                object = result.to_type
+            end
+
+            assert(object, "Could not create type")
+
+            retrieve.each do |state|
+                assert(object.should(state), "Did not retrieve %s" % state)
+            end
+
+            ignore.each do |state|
+                assert(! object.should(state), "Incorrectly retrieved %s" % state)
+            end
+
+            assert_events([:directory_created], object)
+
+            assert(FileTest.directory?(file), "Directory did not get recreated")
+            Dir.rmdir(file)
+        end
+    end
+
+    def test_describe_alltypes
+        # Systems get pretty retarded, so I'm going to set the path to some fake
+        # data for ports
+        #Puppet::Type::ParsedType::Port.path = File.join(basedir,
+        #    "test/data/types/ports/1")
+        #Puppet.err Puppet::Type::ParsedType::Port.path
+        server = nil
+        assert_nothing_raised do
+            server = Puppet::Server::Resource.new()
+        end
+
+        require 'etc'
+
+        # Make the example schedules, for testing
+        Puppet::Type.type(:schedule).mkdefaultschedules
+
+        Puppet::Type.eachtype do |type|
+            unless type.respond_to? :list
+                Puppet.warning "%s does not respond to :list" % type.name
+                next
+            end
+            next unless type.name == :package
+            Puppet.info "Describing each %s" % type.name
+
+            # First do a listing from the server
+            bucket = nil
+            assert_nothing_raised {
+                bucket = server.list(type.name)
+            }
+
+            #type.clear
+
+            count = 0
+            described = {}
+            bucket.each do |obj|
+                assert_instance_of(Puppet::TransObject, obj)
+                break if count > 5
+                described[obj.name] = server.describe(obj.type, obj.name)
+                count += 1
+            end
+
+            verify_described(type, described)
+
+            count = 0
+            described = {}
+            Puppet.info "listing again"
+            type.list.each do |obj|
+                assert_instance_of(type, obj)
+
+                break if count > 5
+                trans = nil
+                assert_nothing_raised do
+                    described[obj.name] = server.describe(type.name, obj.name)
+                end
+
+                count += 1
+            end
+
+            if described.empty?
+                Puppet.notice "Got no example objects for %s" % type.name
+            end
+
+            # We separate these, in case the list operation creates objects
+            verify_described(type, described)
+        end
+    end
+
+    def test_apply
+        server = nil
+        assert_nothing_raised do
+            server = Puppet::Server::Resource.new()
+        end
+
+        file = tempfile()
+        str = "yayness\n"
+
+        File.open(file, "w") { |f| f.print str }
+
+        filetrans = nil
+        assert_nothing_raised {
+            filetrans = server.describe("file", file)
+        }
+
+        Puppet::Type.type(:file).clear
+
+        bucket = Puppet::TransBucket.new
+        bucket.type = "file"
+        bucket.push filetrans
+
+        oldbucket = bucket.dup
+        File.unlink(file)
+        assert_nothing_raised {
+            server.apply(bucket)
+        }
+
+        assert(FileTest.exists?(file), "File did not get recreated")
+
+        # Now try it as a "nonlocal" server
+        server.local = false
+        yaml = nil
+        assert_nothing_raised {
+            yaml = Base64.encode64(YAML::dump(bucket))
+        }
+
+        Puppet::Type.type(:file).clear
+        File.unlink(file)
+
+        if Base64.decode64(yaml) =~ /(.{20}Loglevel.{20})/
+            Puppet.warning "YAML is broken on this machine"
+            return
+        end
+        # puts Base64.decode64(yaml)
+        objects = nil
+        assert_nothing_raised("Could not reload yaml") {
+            YAML::load(Base64.decode64(yaml))
+        }
+
+        # The server is supposed to accept yaml and execute it.
+        assert_nothing_raised {
+            server.apply(yaml)
+        }
+        assert(FileTest.exists?(file), "File did not get recreated from YAML")
+    end
+end
+
+# $Id$
-- 
cgit