puppet 2.7.26 → 3.0.0.rc4

data/test/ral/providers/port/parsed.rb

@@ -1,232 +0,0 @@
-#!/usr/bin/env ruby
-
-require File.expand_path(File.dirname(__FILE__) + '/../../../lib/puppettest')
-
-require 'puppettest'
-#require 'puppettest/fileparsing'
-#require 'puppet/type/port'
-#require 'test/unit'
-#require 'facter'
-#
-#class TestParsedPort < Test::Unit::TestCase
-#    include PuppetTest
-#    include PuppetTest::FileParsing
-#
-#    def setup
-#        super
-#        @provider = Puppet::Type.type(:port).provider(:parsed)
-#        @oldfiletype = @provider.filetype
-#    end
-#
-#    def teardown
-#        Puppet::Util::FileType.filetype(:ram).clear
-#        @provider.filetype = @oldfiletype
-#        @provider.clear
-#        super
-#    end
-#
-#    # Generate a line from a hash.  The line might include '\n'.
-#    def genline(hash)
-#        line = [hash[:name], "#{hash[:number]}/%s"].join("\t\t")
-#        if hash[:alias]
-#            line += "\t\t" + hash[:alias].join(" ")
-#        end
-#        if hash[:description]
-#            line += "\t# " + hash[:description]
-#        end
-#
-#        return hash[:protocols].collect { |p| line % p }.join("\n")
-#    end
-#
-#    # Parse our sample data and make sure we regenerate it correctly.
-#    def test_portsparse
-#        files = fakedata("data/types/port")
-#        files.each do |file|
-#            oldtarget = @provider.default_target
-#            cleanup do
-#                @provider.default_target = oldtarget
-#            end
-#            @provider.default_target = file
-#
-#            assert_nothing_raised("failed to fetch #{file}") {
-#                @provider.prefetch
-#            }
-#
-#            hashes = @provider.target_records(file).find_all { |i| i.is_a? Hash }
-#            assert(hashes.length > 0, "Did not create any hashes")
-#            dns = hashes.find { |i| i[:name] == "domain" }
-#
-#            assert(dns, "Did not retrieve dns record")
-#            assert_equal("53", dns[:number], "dns number is wrong")
-#
-#            text = nil
-#            assert_nothing_raised("failed to generate #{file}") do
-#                text = @provider.to_file(@provider.target_records(file))
-#            end
-#
-#            oldlines = File.readlines(file)
-#            newlines = text.chomp.split "\n"
-#            regex = /^(\S+)\s+(\d+)\/(\w+)/
-#            oldlines.zip(newlines).each do |old, new|
-#                if omatch = regex.match(old)
-#                    assert(newmatch = regex.match(new),
-#                        "Lines were not equivalent: %s vs %s" %
-#                        [old.inspect, new.inspect]
-#                    )
-#                    oldfields = omatch.captures and
-#                    newfields = newmatch.captures
-#
-#                    assert_equal(oldfields, newfields,
-#                        "Lines were not equivalent: %s vs %s" %
-#                        [old.inspect, new.inspect]
-#                    )
-#                end
-#            #    assert_equal(old.chomp.gsub(/\s+/, ''),
-#            #        new.gsub(/\s+/, ''),
-#            #        "Lines are not equal in #{file}")
-#            end
-#        end
-#    end
-#
-#    # Try parsing the different forms of lines
-#    def test_parsing
-#        # Each of the different possible values for each field.
-#        options = {
-#            :name => "service",
-#            :number => "1",
-#            :alias => [nil, ["null"], %w{null sink}, %w{null sink other}],
-#            :description => [nil, "my description"],
-#            :protocols => [%w{tcp}, %w{udp}, %w{tcp udp}]
-#        }
-#
-#        # Now go through all of the different iterations and make sure we
-#        # parse them correctly.
-#        keys = options.keys
-#
-#        name = options[:name]
-#        number = options[:number]
-#        options[:alias].each do |al|
-#            options[:description].each do |desc|
-#                options[:protocols].each do |proto|
-#                    hash = {:name => name, :number => number, :alias => al,
-#                        :description => desc, :protocols => proto}
-#                    line = genline(hash)
-#
-#                    # Try parsing it
-#                    record = nil
-#                    assert_nothing_raised do
-#                        record = @provider.parse_line(line)
-#                    end
-#                    assert(record, "Did not get record returned")
-#                    hash.each do |param, value|
-#                        if value
-#                            assert_equal(value, record[param],
-#                                "did not get #{param} out of '#{line}'")
-#                        end
-#                    end
-#
-#                    # Now make sure it generates correctly
-#                    assert_equal(line, @provider.to_line(record),
-#                        "Did not generate #{line} correctly")
-#                end
-#            end
-#        end
-#    end
-#
-#    # Make sure we correctly join lines by name, so that they're considered
-#    # a single record.
-#    def test_lines
-#        result = nil
-#        assert_nothing_raised do
-#            result = @provider.lines(
-#"smtp        25/tcp      mail
-#time        37/tcp      timserver
-#time        37/udp      timserver
-#rlp     39/udp      resource    # resource location
-#tacacs      49/tcp              # Login Host Protocol (TACACS)
-#nameserver  42/tcp      name        # IEN 116
-#whois       43/tcp      nicname
-#tacacs      49/udp
-#re-mail-ck  50/tcp              # Remote Mail Checking Protocol
-#domain      53/tcp      nameserver  # name-domain server
-#re-mail-ck  50/udp
-#domain      53/udp      nameserver"
-#            )
-#        end
-#
-#        assert_equal([
-#"smtp        25/tcp      mail",
-#"time        37/tcp      timserver
-#time        37/udp      timserver",
-#"rlp     39/udp      resource    # resource location",
-#"tacacs      49/tcp              # Login Host Protocol (TACACS)
-#tacacs      49/udp",
-#"nameserver  42/tcp      name        # IEN 116",
-#"whois       43/tcp      nicname",
-#"re-mail-ck  50/tcp              # Remote Mail Checking Protocol
-#re-mail-ck  50/udp",
-#"domain      53/tcp      nameserver  # name-domain server
-#domain      53/udp      nameserver"
-#], result)
-#
-#    end
-#
-#    # Make sure we correctly handle port merging.
-#    def test_port_merge
-#        fields = [:name, :number, :protocols, :alias, :description]
-#        base = %w{a 1}
-#
-#        z = proc { |ary| h = {}; fields.zip(ary) { |p,v| h[p] = v if v }; h }
-#
-#        # Make sure our zipper is working
-#        assert_equal({:name => "a", :number => "1", :protocols => %w{tcp udp}},
-#            z.call(["a", "1", %w{tcp udp}])
-#        )
-#
-#        # Here we go through the different options, just testing each key
-#        # separately.
-#        {
-#            # The degenerate case - just two protocols
-#            [%w{tcp udp}] => [[%w{tcp}], [%w{udp}]],
-#
-#            # one alias
-#            [%w{tcp udp}, %w{A}] => [[%w{tcp}, %w{A}], [%w{udp}]],
-#
-#            # Other side
-#            [%w{tcp udp}, %w{A}] => [[%w{tcp}], [%w{udp}], %w{A}],
-#
-#            # Both
-#            [%w{tcp udp}, %w{A}] => [[%w{tcp}, %w{A}], [%w{udp}], %w{A}],
-#
-#            # Adding aliases
-#            [%w{tcp udp}, %w{A B}] => [[%w{tcp}, %w{A}], [%w{udp}], %w{B}],
-#
-#            # Merging aliases
-#            [%w{tcp udp}, %w{A B}] => [[%w{tcp}, %w{A B}], [%w{udp}], %w{B}],
-#
-#            # One description
-#            [%w{tcp udp}, nil, "desc"] => [[%w{tcp}, nil, "desc"], [%w{udp}] ],
-#
-#            # other side
-#            [%w{tcp udp}, nil, "desc"] => [[%w{tcp}], [%w{udp}, nil, "desc"] ],
-#
-#            # Conflicting -- first hash wins
-#            [%w{tcp udp}, nil, "first"] =>
-#                [[%w{tcp}, nil, "first"], [%w{udp}, nil, "desc"] ],
-#        }.each do |result, hashes|
-#            assert_equal(
-#                z.call(base + result),
-#                @provider.port_merge(
-#                    z.call(base + hashes[0]),
-#                    z.call(base + hashes[1])
-#                ),
-#                "Did not get %s out of %s + %s" % [
-#                    result.inspect,
-#                    hashes[0].inspect,
-#                    hashes[1].inspect
-#                ]
-#            )
-#        end
-#    end
-#end
-

data/test/ral/providers/provider.rb

@@ -1,529 +0,0 @@
-#!/usr/bin/env ruby
-
-require File.expand_path(File.dirname(__FILE__) + '/../../lib/puppettest')
-
-require 'puppettest'
-require 'facter'
-
-class TestProvider < Test::Unit::TestCase
-  include PuppetTest
-
-  def echo
-    echo = Puppet::Util.which("echo")
-
-    raise "Could not find 'echo' binary; cannot complete test" unless echo
-
-    echo
-  end
-
-  def newprovider
-    # Create our provider
-    provider = Class.new(Puppet::Provider) do
-      @name = :fakeprovider
-    end
-    provider.initvars
-
-    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_defaults_to_suitable
-
-    provider = newprovider
-    assert(provider.suitable?, "Marked unsuitable with no confines")
-  end
-
-  def test_confine_results
-    {
-      {:true => true} => true,
-      {:true => false} => false,
-      {:false => false} => true,
-      {:false => true} => false,
-      {:operatingsystem => Facter.value(:operatingsystem)} => true,
-      {:operatingsystem => :yayness} => false,
-      {:nothing => :yayness} => false,
-      {:exists => echo} => true,
-      {:exists => "/this/file/does/not/exist"} => false,
-    }.each do |hash, result|
-      provider = newprovider
-
-      # First test :true
-      hash.each do |test, val|
-        assert_nothing_raised do
-          provider.confine test => val
-        end
-      end
-
-      assert_equal(result, provider.suitable?, "Failed for #{hash.inspect}")
-
-      provider.initvars
-    end
-  end
-
-  def test_multiple_confines_do_not_override
-    provider = newprovider
-
-    # Make sure multiple confines don't overwrite each other
-    provider.confine :true => false
-    assert(! provider.suitable?)
-    provider.confine :true => true
-    assert(! provider.suitable?)
-  end
-
-  def test_one_failed_confine_is_sufficient
-
-    provider = newprovider
-
-    # Make sure we test multiple of them, and that a single false wins
-    provider.confine :true => true, :false => false
-    assert(provider.suitable?)
-    provider.confine :true => false
-    assert(! provider.suitable?)
-  end
-
-  # #1197 - the binary should not be
-  def test_command_checks_for_binaries_each_time
-    provider = newprovider
-
-    provider.commands :testing => "/no/such/path"
-
-    provider.stubs(:which).returns "/no/such/path"
-
-    provider.command(:testing)
-    assert_equal("/no/such/path", provider.command(:testing), "Did not return correct binary path")
-  end
-
-  def test_command
-    {:echo => "echo", :echo_with_path => echo, :missing => "nosuchcommand", :missing_qualified => "/path/to/nosuchcommand"}.each do |name, command|
-      provider = newprovider
-      assert_nothing_raised("Could not define command #{name} with argument #{command} for provider") do
-        provider.commands(name => command)
-      end
-
-      if name.to_s =~ /missing/
-        assert_nil(provider.command(name), "Somehow got a response for missing commands")
-        assert(! provider.suitable?, "Provider was considered suitable with missing command")
-        next # skip, since we don't do any validity checking here.
-      end
-
-      assert_equal(echo, provider.command(name), "Did not get correct path for echo")
-      assert(provider.suitable?, "Provider was not considered suitable with 'echo'")
-
-      # Now make sure they both work
-      inst = provider.new(nil)
-      [provider, inst].each do |thing|
-        assert_nothing_raised("Could not call #{command} on #{thing}") do
-          out = thing.send(name, "some", "text")
-          assert_equal("some text\n", out)
-        end
-      end
-
-      assert(provider.suitable?, "Provider considered unsuitable")
-
-      # Now add an invalid command
-      assert_nothing_raised do
-        provider.commands :fake => "nosuchcommanddefinitely"
-      end
-      assert(! provider.suitable?, "Provider considered suitable")
-
-      assert_nil(provider.command(:fake), "Got a value for missing command")
-      assert_raise(Puppet::Error) do
-        provider.fake
-      end
-
-      Puppet[:trace] = false
-      assert_raise(Puppet::DevError) do
-        provider.command(:nosuchcmd)
-      end
-
-      # Lastly, verify that we can find our superclass commands
-      newprov = Class.new(provider)
-      newprov.initvars
-
-      assert_equal(echo, newprov.command(name))
-    end
-  end
-
-  def test_default?
-    provider = newprovider
-
-    assert(! provider.default?, "Was considered default with no settings")
-
-    assert_nothing_raised do
-      provider.defaultfor :operatingsystem => Facter.value(:operatingsystem)
-    end
-
-    assert(provider.default?, "Was not considered default")
-
-    # Make sure any true value is sufficient.
-    assert_nothing_raised do
-      provider.defaultfor :operatingsystem => [
-        :yayness, :rahness,
-        Facter.value(:operatingsystem)
-      ]
-    end
-
-    assert(provider.default?, "Was not considered default")
-
-    # Now make sure that a random setting returns false.
-    assert_nothing_raised do
-      provider.defaultfor :operatingsystem => :yayness
-    end
-
-    assert(! provider.default?, "Was considered default")
-  end
-
-  # Make sure that failed commands get their output in the error.
-  def test_outputonfailure
-    provider = newprovider
-
-    dir = tstdir
-    file = File.join(dir, "mycmd")
-    sh = Puppet::Util.which("sh")
-    File.open(file, "w") { |f|
-      f.puts %{#!#{sh}
-      echo A Failure >&2
-      exit 2
-      }
-    }
-    File.chmod(0755, file)
-
-    provider.commands :cmd => file
-
-    inst = provider.new(nil)
-
-    assert_raise(Puppet::ExecutionFailure) do
-      inst.cmd "some", "arguments"
-    end
-
-    out = nil
-    begin
-      inst.cmd "some", "arguments"
-    rescue Puppet::ExecutionFailure => detail
-      out = detail.to_s
-    end
-
-
-      assert(
-        out =~ /A Failure/,
-
-        "Did not receive command output on failure")
-
-
-          assert(
-            out =~ /Execution of/,
-
-        "Did not receive info wrapper on failure")
-  end
-
-  def test_mk_resource_methods
-    prov = newprovider
-    resourcetype = Struct.new(:validproperties, :parameters)
-    m = resourcetype.new([:prop1, :prop2], [:param1, :param2])
-    prov.resource_type = m
-
-    assert_nothing_raised("could not call mk_resource_methods") do
-      prov.mk_resource_methods
-    end
-
-    obj = prov.new(nil)
-
-    %w{prop1 prop2 param1 param2}.each do |param|
-      assert(prov.public_method_defined?(param), "no getter for #{param}")
-      assert(prov.public_method_defined?(param + "="), "no setter for #{param}")
-
-
-        assert_equal(
-          :absent, obj.send(param),
-
-          "%s did not default to :absent")
-      val = "testing #{param}"
-      assert_nothing_raised("Could not call setter for #{param}") do
-        obj.send(param + "=", val)
-      end
-
-        assert_equal(
-          val, obj.send(param),
-
-          "did not get correct value for #{param}")
-    end
-  end
-
-  # Make sure optional commands get looked up but don't affect suitability.
-  def test_optional_commands
-    type = Puppet::Type.newtype(:optional_commands) {}
-
-    cleanup { Puppet::Type.rmtype(:optional_commands) }
-
-    # Define a provider with mandatory commands
-    required = type.provide(:required) {
-      commands :missing => "/no/such/binary/definitely"
-    }
-
-    # And another with optional commands
-    optional = type.provide(:optional) {
-      optional_commands :missing => "/no/such/binary/definitely"
-    }
-
-    assert(! required.suitable?, "Provider with missing commands considered suitable")
-    assert_nil(required.command(:missing), "Provider returned non-nil from missing command")
-
-    assert(optional.suitable?, "Provider with optional commands considered unsuitable")
-    assert_nil(optional.command(:missing), "Provider returned non-nil from missing command")
-
-    assert_raise(Puppet::Error, "Provider did not fail when missing command was called") do
-      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.new :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
-  include PuppetTest
-
-  def setup
-    super
-    @type = Puppet::Type.newtype(:feature_test) do
-      newparam(:name) {}
-      ensurable
-    end
-    cleanup { Puppet::Type.rmtype(:feature_test) }
-
-    @features = {:numeric => [:one, :two], :alpha => [:a, :b]}
-
-    @features.each do |name, methods|
-      assert_nothing_raised("Could not define features") do
-        @type.feature(name, "boo", :methods => methods)
-      end
-    end
-  end
-
-  # Give them the basic run-through.
-  def test_method_features
-    @providers = {:numbers => @features[:numeric], :letters => @features[:alpha]}
-    @providers[:both] = @features[:numeric] + @features[:alpha]
-    @providers[:mixed] = [:one, :b]
-    @providers[:neither] = [:something, :else]
-
-    @providers.each do |name, methods|
-      assert_nothing_raised("Could not create provider #{name}") do
-        @type.provide(name) do
-          methods.each do |name|
-            define_method(name) {}
-          end
-        end
-      end
-    end
-
-    resource = @type.new(: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 }
-      provider = @type.provider(name)
-      assert(provider, "Could not find provider #{name}")
-      assert_equal(should, provider.features, "Provider #{name} has incorrect features")
-
-      inst = provider.new(resource)
-      # Make sure the boolean methods work on both the provider and
-      # instance.
-      @features.keys.each do |feature|
-        method = feature.to_s + "?"
-        assert(inst.respond_to?(method), "No boolean instance method for #{name} on #{feature}")
-        assert(provider.respond_to?(method), "No boolean class method for #{name} on #{feature}")
-
-        if should.include?(feature)
-          assert(provider.feature?(feature), "class missing feature? #{feature}")
-          assert(inst.feature?(feature), "instance missing feature? #{feature}")
-          assert(provider.send(method), "class missing feature #{feature}")
-          assert(inst.send(method), "instance missing feature #{feature}")
-          assert(inst.satisfies?(feature), "instance.satisfy #{feature} returned false")
-          else
-            assert(! provider.feature?(feature), "class has feature? #{feature}")
-            assert(! inst.feature?(feature), "instance has feature? #{feature}")
-            assert(! provider.send(method), "class has feature #{feature}")
-            assert(! inst.send(method), "instance has feature #{feature}")
-            assert(! inst.satisfies?(feature), "instance.satisfy #{feature} returned true")
-          end
-        end
-
-      end
-
-    Puppet[:trace] = true
-    Puppet::Type.loadall
-    Puppet::Type.eachtype do |type|
-      assert(type.respond_to?(:feature), "No features method defined for #{type.name}")
-    end
-  end
-
-  def test_has_feature
-    # Define a new feature that has no methods
-    @type.feature(:nomeths, "desc")
-
-    # Define a provider with nothing
-    provider = @type.provide(:nothing) {}
-
-
-      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
-      define_method(:one) {}
-      define_method(:two) {}
-    end
-
-    # Another with the numbers and a declaration
-    @type.provide(:both) do
-      define_method(:one) {}
-      define_method(:two) {}
-
-      has_feature :alpha
-    end
-
-    # And just the declaration
-    @type.provide(:letters) do
-      has_feature :alpha
-    end
-
-    # And a provider that declares it has our methodless feature.
-    @type.provide(:none) do
-      has_feature :nomeths
-    end
-
-    should = {:nothing => [], :both => [:numeric, :alpha],
-      :letters => [:alpha], :numbers => [:numeric],
-      :none => [:nomeths]}
-
-    should.each do |name, features|
-      provider_class = @type.provider(name)
-      provider = provider_class.new({})
-
-      assert(provider, "did not get provider named #{name}")
-      features.sort! { |a,b| a.to_s <=> b.to_s }
-      assert_equal(features, provider.features, "Got incorrect feature list for provider instance #{name}")
-      assert_equal(features, provider_class.features, "Got incorrect feature list for provider class #{name}")
-      features.each do |feat|
-        assert(provider.feature?(feat), "Provider instance #{name} did not have feature #{feat}")
-        assert(provider_class.feature?(feat), "Provider class #{name} did not have feature #{feat}")
-      end
-    end
-  end
-
-  def test_supports_parameter?
-    # Make some parameters for each setting
-    @type.newparam(:neither) {}
-    @type.newparam(:some, :required_features => :alpha)
-    @type.newparam(:both, :required_features => [:alpha, :numeric])
-
-    # and appropriate providers
-    nope = @type.provide(:nope) {}
-    maybe = @type.provide(:maybe) { has_feature(:alpha) }
-    yep = @type.provide(:yep) { has_features(:alpha, :numeric) }
-
-    # Now make sure our providers answer correctly.
-    [nope, maybe, yep].each do |prov|
-      assert(prov.respond_to?(:supports_parameter?), "#{prov.name} does not respond to :supports_parameter?")
-      case prov.name
-      when :nope
-        supported = [:neither]
-        un = [:some, :both]
-      when :maybe
-        supported = [:neither, :some]
-        un = [:both]
-      when :yep
-        supported = [:neither, :some, :both]
-        un = []
-      end
-
-      supported.each do |param|
-        assert(prov.supports_parameter?(param), "#{param} was not supported by #{prov.name}")
-      end
-      un.each do |param|
-        assert(! prov.supports_parameter?(param), "#{param} was incorrectly supported by #{prov.name}")
-      end
-    end
-  end
-end
-