RubyGems - puppet - Versions diffs - 7.28.0-universal-darwin → 7.29.0-universal-darwin - Mend

puppet 7.28.0-universal-darwin → 7.29.0-universal-darwin

Files changed (1257) hide show

data/spec/unit/provider_spec.rb DELETED Viewed

@@ -1,904 +0,0 @@
-require 'spec_helper'
-def existing_command
-  Puppet::Util::Platform.windows? ? "cmd" : "echo"
-end
-describe Puppet::Provider do
-  before :each do
-    Puppet::Type.newtype(:test) do
-      newparam(:name) { isnamevar }
-    end
-  end
-  after :each do
-    Puppet::Type.type(:test).provider_hash.clear
-    Puppet::Type.rmtype(:test)
-  end
-  let :type do Puppet::Type.type(:test) end
-  let :provider do type.provide(:default) {} end
-  subject { provider }
-  describe "has command" do
-    it "installs a method to run the command specified by the path" do
-      echo_command = expect_command_executed(:echo, "/bin/echo", "an argument")
-      allow_creation_of(echo_command)
-      provider = provider_of do
-        has_command(:echo, "/bin/echo")
-      end
-      provider.echo("an argument")
-    end
-    it "installs a command that is run with a given environment" do
-      echo_command = expect_command_executed(:echo, "/bin/echo", "an argument")
-      allow_creation_of(echo_command, {
-        :EV => "value",
-        :OTHER => "different"
-      })
-      provider = provider_of do
-        has_command(:echo, "/bin/echo") do
-          environment :EV => "value", :OTHER => "different"
-        end
-      end
-      provider.echo("an argument")
-    end
-    it "is required by default" do
-      provider = provider_of do
-        has_command(:does_not_exist, "/does/not/exist")
-      end
-      expect(provider).not_to be_suitable
-    end
-    it "is required by default" do
-      provider = provider_of do
-        has_command(:does_exist, File.expand_path("/exists/somewhere"))
-      end
-      file_exists_and_is_executable(File.expand_path("/exists/somewhere"))
-      expect(provider).to be_suitable
-    end
-    it "can be specified as optional" do
-      provider = provider_of do
-        has_command(:does_not_exist, "/does/not/exist") do
-          is_optional
-        end
-      end
-      expect(provider).to be_suitable
-    end
-  end
-  describe "has required commands" do
-    it "installs methods to run executables by path" do
-      echo_command = expect_command_executed(:echo, "/bin/echo", "an argument")
-      ls_command = expect_command_executed(:ls, "/bin/ls")
-      allow_creation_of(echo_command)
-      allow_creation_of(ls_command)
-      provider = provider_of do
-        commands :echo => "/bin/echo", :ls => "/bin/ls"
-      end
-      provider.echo("an argument")
-      provider.ls
-    end
-    it "allows the provider to be suitable if the executable is present" do
-      provider = provider_of do
-        commands :always_exists => File.expand_path("/this/command/exists")
-      end
-      file_exists_and_is_executable(File.expand_path("/this/command/exists"))
-      expect(provider).to be_suitable
-    end
-    it "does not allow the provider to be suitable if the executable is not present" do
-      provider = provider_of do
-        commands :does_not_exist => "/this/command/does/not/exist"
-      end
-      expect(provider).not_to be_suitable
-    end
-  end
-  describe "has optional commands" do
-    it "installs methods to run executables" do
-      echo_command = expect_command_executed(:echo, "/bin/echo", "an argument")
-      ls_command = expect_command_executed(:ls, "/bin/ls")
-      allow_creation_of(echo_command)
-      allow_creation_of(ls_command)
-      provider = provider_of do
-        optional_commands :echo => "/bin/echo", :ls => "/bin/ls"
-      end
-      provider.echo("an argument")
-      provider.ls
-    end
-    it "allows the provider to be suitable even if the executable is not present" do
-      provider = provider_of do
-        optional_commands :does_not_exist => "/this/command/does/not/exist"
-      end
-      expect(provider).to be_suitable
-    end
-  end
-  it "should have a specifity class method" do
-    expect(Puppet::Provider).to respond_to(:specificity)
-  end
-  it "should be Comparable" do
-    res = Puppet::Type.type(:notify).new(:name => "res")
-    # Normally I wouldn't like the stubs, but the only way to name a class
-    # otherwise is to assign it to a constant, and that hurts more here in
-    # testing world. --daniel 2012-01-29
-    a = Class.new(Puppet::Provider).new(res)
-    allow(a.class).to receive(:name).and_return("Puppet::Provider::Notify::A")
-    b = Class.new(Puppet::Provider).new(res)
-    allow(b.class).to receive(:name).and_return("Puppet::Provider::Notify::B")
-    c = Class.new(Puppet::Provider).new(res)
-    allow(c.class).to receive(:name).and_return("Puppet::Provider::Notify::C")
-    [[a, b, c], [a, c, b], [b, a, c], [b, c, a], [c, a, b], [c, b, a]].each do |this|
-      expect(this.sort).to eq([a, b, c])
-    end
-    expect(a).to be < b
-    expect(a).to be < c
-    expect(b).to be > a
-    expect(b).to be < c
-    expect(c).to be > a
-    expect(c).to be > b
-    [a, b, c].each {|x| expect(a).to be <= x }
-    [a, b, c].each {|x| expect(c).to be >= x }
-    expect(b).to be_between(a, c)
-  end
-  context "when creating instances" do
-    context "with a resource" do
-      let :resource do type.new(:name => "fred") end
-      subject { provider.new(resource) }
-      it "should set the resource correctly" do
-        expect(subject.resource).to equal resource
-      end
-      it "should set the name from the resource" do
-        expect(subject.name).to eq(resource.name)
-      end
-    end
-    context "with a hash" do
-      subject { provider.new(:name => "fred") }
-      it "should set the name" do
-        expect(subject.name).to eq("fred")
-      end
-      it "should not have a resource" do expect(subject.resource).to be_nil end
-    end
-    context "with no arguments" do
-      subject { provider.new }
-      it "should raise an internal error if asked for the name" do
-        expect { subject.name }.to raise_error Puppet::DevError
-      end
-      it "should not have a resource" do expect(subject.resource).to be_nil end
-    end
-  end
-  context "when confining" do
-    it "should be suitable by default" do
-      expect(subject).to be_suitable
-    end
-    it "should not be default by default" do
-      expect(subject).not_to be_default
-    end
-    { { :true => true } => true,
-      { :true => false } => false,
-      { :false => false } => true,
-      { :false => true } => false,
-      { :operatingsystem => Puppet.runtime[:facter].value(:operatingsystem) } => true,
-      { :operatingsystem => :yayness } => false,
-      { :nothing => :yayness } => false,
-      { :exists => Puppet::Util.which(existing_command) } => true,
-      { :exists => "/this/file/does/not/exist" } => false,
-      { :true => true, :exists => Puppet::Util.which(existing_command) } => true,
-      { :true => true, :exists => "/this/file/does/not/exist" } => false,
-      { :operatingsystem => Puppet.runtime[:facter].value(:operatingsystem),
-        :exists => Puppet::Util.which(existing_command) } => true,
-      { :operatingsystem => :yayness,
-        :exists => Puppet::Util.which(existing_command) } => false,
-      { :operatingsystem => Puppet.runtime[:facter].value(:operatingsystem),
-        :exists => "/this/file/does/not/exist" } => false,
-      { :operatingsystem => :yayness,
-        :exists => "/this/file/does/not/exist" } => false,
-    }.each do |confines, result|
-      it "should confine #{confines.inspect} to #{result}" do
-        confines.each {|test, value| subject.confine test => value }
-        if result
-          expect(subject).to be_suitable
-        else
-          expect(subject).to_not be_suitable
-        end
-      end
-    end
-    it "should not override a confine even if a second has the same type" do
-      subject.confine :true => false
-      expect(subject).not_to be_suitable
-      subject.confine :true => true
-      expect(subject).not_to be_suitable
-    end
-    it "should not be suitable if any confine fails" do
-      subject.confine :true => false
-      expect(subject).not_to be_suitable
-      10.times do
-        subject.confine :true => true
-        expect(subject).not_to be_suitable
-      end
-    end
-  end
-  context "default providers" do
-    let :os do Puppet.runtime[:facter].value(:operatingsystem) end
-    it { is_expected.to respond_to :specificity }
-    it "should find the default provider" do
-      type.provide(:nondefault) {}
-      subject.defaultfor :operatingsystem => os
-      expect(subject.name).to eq(type.defaultprovider.name)
-    end
-    describe "regex matches" do
-      it "should match a singular regex" do
-        expect(Facter).to receive(:value).with(:osfamily).at_least(:once).and_return("solaris")
-        one = type.provide(:one) do
-          defaultfor :osfamily => /solaris/
-        end
-        expect(one).to be_default
-      end
-      it "should not match a non-matching regex " do
-        expect(Facter).to receive(:value).with(:osfamily).at_least(:once).and_return("redhat")
-        one = type.provide(:one) do
-          defaultfor :osfamily => /solaris/
-        end
-        expect(one).to_not be_default
-      end
-      it "should allow a mix of regex and string" do
-        expect(Facter).to receive(:value).with(:operatingsystem).at_least(:once).and_return("fedora")
-        expect(Facter).to receive(:value).with(:operatingsystemmajrelease).at_least(:once).and_return("24")
-        one = type.provide(:one) do
-          defaultfor :operatingsystem => "fedora", :operatingsystemmajrelease => /^2[2-9]$/
-        end
-        two = type.provide(:two) do
-          defaultfor :operatingsystem => /fedora/, :operatingsystemmajrelease => '24'
-        end
-        expect(one).to be_default
-        expect(two).to be_default
-      end
-    end
-    describe "when there are multiple defaultfor's of equal specificity" do
-      before :each do
-        subject.defaultfor :operatingsystem => :os1
-        subject.defaultfor :operatingsystem => :os2
-      end
-      let(:alternate) { type.provide(:alternate) {} }
-      it "should be default for the first defaultfor" do
-        expect(Facter).to receive(:value).with(:operatingsystem).at_least(:once).and_return(:os1)
-        expect(provider).to be_default
-        expect(alternate).not_to be_default
-      end
-      it "should be default for the last defaultfor" do
-        expect(Facter).to receive(:value).with(:operatingsystem).at_least(:once).and_return(:os2)
-        expect(provider).to be_default
-        expect(alternate).not_to be_default
-      end
-    end
-    describe "when there are multiple defaultfor's with different specificity" do
-      before :each do
-        subject.defaultfor :operatingsystem => :os1
-        subject.defaultfor :operatingsystem => :os2, :operatingsystemmajrelease => "42"
-        subject.defaultfor :operatingsystem => :os3, :operatingsystemmajrelease => /^4[2-9]$/
-      end
-      let(:alternate) { type.provide(:alternate) {} }
-      it "should be default for a more specific, but matching, defaultfor" do
-        expect(Facter).to receive(:value).with(:operatingsystem).at_least(:once).and_return(:os2)
-        expect(Facter).to receive(:value).with(:operatingsystemmajrelease).at_least(:once).and_return("42")
-        expect(provider).to be_default
-        expect(alternate).not_to be_default
-      end
-      it "should be default for a more specific, but matching, defaultfor with regex" do
-        expect(Facter).to receive(:value).with(:operatingsystem).at_least(:once).and_return(:os3)
-        expect(Facter).to receive(:value).with(:operatingsystemmajrelease).at_least(:once).and_return("42")
-        expect(provider).to be_default
-        expect(alternate).not_to be_default
-      end
-      it "should be default for a less specific, but matching, defaultfor" do
-        expect(Facter).to receive(:value).with(:operatingsystem).at_least(:once).and_return(:os1)
-        expect(provider).to be_default
-        expect(alternate).not_to be_default
-      end
-    end
-    it "should consider any true value enough to be default" do
-      alternate = type.provide(:alternate) {}
-      subject.defaultfor :operatingsystem => [:one, :two, :three, os]
-      expect(subject.name).to eq(type.defaultprovider.name)
-      expect(subject).to be_default
-      expect(alternate).not_to be_default
-    end
-    it "should not be default if the defaultfor doesn't match" do
-      expect(subject).not_to be_default
-      subject.defaultfor :operatingsystem => :one
-      expect(subject).not_to be_default
-    end
-    it "should not be default if the notdefaultfor does match" do
-      expect(Facter).to receive(:value).with(:operatingsystem).at_least(:once).and_return("fedora")
-      expect(Facter).to receive(:value).with(:operatingsystemmajrelease).at_least(:once).and_return("24")
-      one = type.provide(:one) do
-        defaultfor :operatingsystem => "fedora"
-        notdefaultfor :operatingsystem => "fedora", :operatingsystemmajrelease => 24
-      end
-      expect(one).not_to be_default
-    end
-    it "should be default if the notdefaultfor doesn't match" do
-      expect(Facter).to receive(:value).with(:operatingsystem).at_least(:once).and_return("fedora")
-      expect(Facter).to receive(:value).with(:operatingsystemmajrelease).at_least(:once).and_return("24")
-      one = type.provide(:one) do
-        defaultfor :operatingsystem => "fedora"
-        notdefaultfor :operatingsystem => "fedora", :operatingsystemmajrelease => 42
-      end
-      expect(one).to be_default
-    end
-    # Key: spec has 4 required and 1 optional part:
-    # one-defaultfor, one-notdefaultfor, two-defaultfor, two-notdefaultfor
-    # d = defaultfor, n = notdefaultfor,
-    # d2 - two clauses in defaultfor constraint,
-    # ! = constraint exists but doesn't match
-    # none = no constraint
-    # d+/!d+/none+ - provider class has deeper inheritence
-    context "defaultfor/notdefaultfor configurable tests" do
-      [
-        # Two default? group - ties go to first to register
-        %w{d    none d     none pickone},
-        # Two default? group - second is selected for specificity
-        %w{d    !n   d2     !n         },
-        %w{d    !n   d2     none       },
-        # Two default? group - second is selected for inheritence
-        %w{d    !n   d+     !n         },
-        %w{d    !n   d+     none       },
-        # One default? group - second (only default?) always is selected
-        %w{!d   !n   d     none        },
-        %w{!d   !n   d     !n          },
-        %w{!d   n    d     none        },
-        %w{!d   n    d     !n          },
-        %w{d    n    d     none        },
-        %w{d    n    d     !n          },
-        # No default? group:
-        %w{d    !n   d     !n   pickone},
-        %w{d    !n   d     none pickone},
-        %w{!d   !n   !d    !n   pickone},
-        %w{!d   !n   !d    none pickone},
-        %w{!d   none !d    none pickone},
-        %w{none !n   none  !n   pickone},
-        %w{none none none  none pickone},
-        # No default? but deeper class inheritence group:
-        %w{!d   !n   !d+   !n          },
-        %w{!d   !n   !d+   none        },
-        %w{!d   none !d+   none        },
-        %w{none !n   none+ !n          },
-        %w{none none none+ none        },
-      ].each do |thisspec|
-        defaultforspec = {
-          :one => {},
-          :two => {},
-          :expect_one => false #Default expectation is to expect provider two for these tests
-        }
-        fail "Inheritence not supported on first provider" if thisspec[0].end_with?('+')
-        case thisspec[0] # First provider defaultfor spec
-        when 'd'
-          defaultforspec[:one][:defaultfor] = true
-        when '!d'
-          defaultforspec[:one][:defaultfor] = false
-        when 'none'
-          # Do not include a defaultfor constraint
-        else
-          fail "Did not understand first spec: %{spec}" % { spec: thisspec[0] }
-        end
-        case thisspec[1] # First provider notdefaultfor spec
-        when 'n'
-          defaultforspec[:one][:notdefaultfor] = true
-        when '!n'
-          defaultforspec[:one][:notdefaultfor] = false
-        when 'none'
-          # Do not include a notdefaultfor constraint
-        else
-          fail "Did not understand second spec: %{spec}" % { spec: thisspec[1] }
-        end
-        if thisspec[2].end_with?('+') then # d+ !d+ none+
-          defaultforspec[:two][:derived] = true
-          thisspec[2] = thisspec[2][0 .. -2]
-        end
-        case thisspec[2]
-        when 'd'
-          defaultforspec[:two][:defaultfor] = true
-        when 'd2'
-          defaultforspec[:two][:extradefaultfor] = true
-        when '!d'
-          defaultforspec[:two][:defaultfor] = false
-        when 'none'
-          # Do not include a defaultfor constraint
-        else
-          fail "Did not understand third spec: %{spec}" % { spec: thisspec[2] }
-        end
-        case thisspec[3] # Second provider notdefaultfor spec
-        when 'n'
-          defaultforspec[:two][:notdefaultfor] = true
-        when '!n'
-          defaultforspec[:two][:notdefaultfor] = false
-        when 'none'
-          # Do not include a notdefaultfor constraint
-        else
-          fail "Did not understand fourth spec: %{spec}" % { spec: thisspec[3] }
-        end
-        if thisspec.length == 5 && thisspec[4] == "pickone" then
-          defaultforspec[:expect_one] = true
-        end
-        it "with the specification: %{spec}" % { spec: thisspec.join(', ') } do
-          allow(Facter).to receive(:value).with(:osfamily).and_return("redhat")
-          allow(Facter).to receive(:value).with(:operatingsystem).and_return("centos")
-          allow(Facter).to receive(:value).with(:operatingsystemrelease).and_return("27")
-          one = type.provide(:one) do
-            if defaultforspec[:one].key?(:defaultfor)
-              defaultfor    :osfamily               => "redhat" if  defaultforspec[:one][:defaultfor]
-              defaultfor    :osfamily               => "ubuntu" if !defaultforspec[:one][:defaultfor]
-            end
-            if defaultforspec[:one].key?(:notdefaultfor)
-              notdefaultfor :operatingsystem        => "centos" if  defaultforspec[:one][:notdefaultfor]
-              notdefaultfor :operatingsystem        => "ubuntu" if !defaultforspec[:one][:notdefaultfor]
-            end
-          end
-          provider_options = {}
-          provider_options[:parent] = one if defaultforspec[:two][:derived] # :two inherits from one, if spec'd
-          two = type.provide(:two, provider_options) do
-            if defaultforspec[:two].key?(:defaultfor) || defaultforspec[:two].key?(:extradefaultfor)
-              defaultfor    :osfamily               => "redhat" if  defaultforspec[:two][:defaultfor]
-              defaultfor    :osfamily               => "redhat",#   defaultforspec[:two][:extradefaultfor] has two parts
-                            :operatingsystem        => "centos" if  defaultforspec[:two][:extradefaultfor]
-              defaultfor    :osfamily               => "ubuntu" if !defaultforspec[:two][:defaultfor]
-            end
-            if defaultforspec[:two].key?(:notdefaultfor)
-              notdefaultfor :operatingsystemrelease => "27" if  defaultforspec[:two][:notdefaultfor]
-              notdefaultfor :operatingsystemrelease => "99" if !defaultforspec[:two][:notdefaultfor]
-            end
-          end
-          if defaultforspec[:expect_one] then
-            expect(Puppet).to receive(:warning).with(/Found multiple default providers/)
-            expect(type.defaultprovider).to eq(one)
-          else
-            expect(type.defaultprovider).to eq(two)
-          end
-        end
-      end
-    end
-    describe "using a :feature key" do
-      before :each do
-        Puppet.features.add(:yay) do true end
-        Puppet.features.add(:boo) do false end
-      end
-      it "is default for an available feature" do
-        one = type.provide(:one) do
-          defaultfor :feature => :yay
-        end
-        expect(one).to be_default
-      end
-      it "is not default for a missing feature" do
-        two = type.provide(:two) do
-          defaultfor :feature => :boo
-        end
-        expect(two).not_to be_default
-      end
-    end
-  end
-  context "provider commands" do
-    it "should raise for unknown commands" do
-      expect { subject.command(:something) }.to raise_error(Puppet::DevError)
-    end
-    it "should handle command inheritance" do
-      parent = type.provide("parent")
-      child  = type.provide("child", :parent => parent.name)
-      command = Puppet::Util.which('sh') || Puppet::Util.which('cmd.exe')
-      parent.commands :sh => command
-      expect(Puppet::FileSystem.exist?(parent.command(:sh))).to be_truthy
-      expect(parent.command(:sh)).to match(/#{Regexp.escape(command)}$/)
-      expect(Puppet::FileSystem.exist?(child.command(:sh))).to be_truthy
-      expect(child.command(:sh)).to match(/#{Regexp.escape(command)}$/)
-    end
-    it "#1197: should find commands added in the same run" do
-      subject.commands :testing => "puppet-bug-1197"
-      expect(subject.command(:testing)).to be_nil
-      allow(subject).to receive(:which).with("puppet-bug-1197").and_return("/puppet-bug-1197")
-      expect(subject.command(:testing)).to eq("/puppet-bug-1197")
-      # Ideally, we would also test that `suitable?` returned the right thing
-      # here, but it is impossible to get access to the methods that do that
-      # without digging way down into the implementation. --daniel 2012-03-20
-    end
-    context "with optional commands" do
-      before :each do
-        subject.optional_commands :cmd => "/no/such/binary/exists"
-      end
-      it { is_expected.to be_suitable }
-      it "should not be suitable if a mandatory command is also missing" do
-        subject.commands :foo => "/no/such/binary/either"
-        expect(subject).not_to be_suitable
-      end
-      it "should define a wrapper for the command" do
-        expect(subject).to respond_to(:cmd)
-      end
-      it "should return nil if the command is requested" do
-        expect(subject.command(:cmd)).to be_nil
-      end
-      it "should raise if the command is invoked" do
-        expect { subject.cmd }.to raise_error(Puppet::Error, /Command cmd is missing/)
-      end
-    end
-  end
-  context "execution" do
-    before :each do
-      expect(Puppet).not_to receive(:deprecation_warning)
-    end
-    it "delegates instance execute to Puppet::Util::Execution" do
-      expect(Puppet::Util::Execution).to receive(:execute).with("a_command", { :option => "value" })
-      provider.new.execute("a_command", { :option => "value" })
-    end
-    it "delegates class execute to Puppet::Util::Execution" do
-      expect(Puppet::Util::Execution).to receive(:execute).with("a_command", { :option => "value" })
-      provider.execute("a_command", { :option => "value" })
-    end
-    it "delegates instance execpipe to Puppet::Util::Execution" do
-      allow(Puppet::Util::Execution).to receive(:execpipe).with("a_command", true).and_yield('some output')
-      expect { |b| provider.new.execpipe("a_command", true, &b) }.to yield_with_args('some output')
-    end
-    it "delegates class execpipe to Puppet::Util::Execution" do
-      allow(Puppet::Util::Execution).to receive(:execpipe).with("a_command", true).and_yield('some output')
-      expect { |b| provider.execpipe("a_command", true, &b) }.to yield_with_args('some output')
-    end
-  end
-  context "mk_resource_methods" do
-    before :each do
-      type.newproperty(:prop)
-      type.newparam(:param)
-      provider.mk_resource_methods
-    end
-    let(:instance) { provider.new(nil) }
-    it "defaults to :absent" do
-      expect(instance.prop).to eq(:absent)
-      expect(instance.param).to eq(:absent)
-    end
-    it "should update when set" do
-      instance.prop = 'hello'
-      instance.param = 'goodbye'
-      expect(instance.prop).to eq('hello')
-      expect(instance.param).to eq('goodbye')
-    end
-    it "treats nil the same as absent" do
-      instance.prop = "value"
-      instance.param = "value"
-      instance.prop = nil
-      instance.param = nil
-      expect(instance.prop).to eq(:absent)
-      expect(instance.param).to eq(:absent)
-    end
-    it "preserves false as false" do
-      instance.prop = false
-      instance.param = false
-      expect(instance.prop).to eq(false)
-      expect(instance.param).to eq(false)
-    end
-  end
-  context "source" do
-    it "should default to the provider name" do
-      expect(subject.source).to eq(:default)
-    end
-    it "should default to the provider name for a child provider" do
-      expect(type.provide(:sub, :parent => subject.name).source).to eq(:sub)
-    end
-    it "should override if requested" do
-      provider = type.provide(:sub, :parent => subject.name, :source => subject.source)
-      expect(provider.source).to eq(subject.source)
-    end
-    it "should override to anything you want" do
-      expect { subject.source = :banana }.to change { subject.source }.
-        from(:default).to(:banana)
-    end
-  end
-  context "features" do
-    before :each do
-      type.feature :numeric,   '', :methods => [:one, :two]
-      type.feature :alpha,     '', :methods => [:a, :b]
-      type.feature :nomethods, ''
-    end
-    { :no      => { :alpha => false, :numeric => false, :methods => [] },
-      :numeric => { :alpha => false, :numeric => true,  :methods => [:one, :two] },
-      :alpha   => { :alpha => true,  :numeric => false, :methods => [:a, :b] },
-      :all     => {
-        :alpha => true,  :numeric => true,
-        :methods => [:a, :b, :one, :two]
-      },
-      :alpha_and_partial   => {
-        :alpha => true, :numeric => false,
-        :methods => [:a, :b, :one]
-      },
-      :numeric_and_partial => {
-        :alpha => false, :numeric => true,
-        :methods => [:a, :one, :two]
-      },
-      :all_partial    => { :alpha => false, :numeric => false, :methods => [:a, :one] },
-      :other_and_none => { :alpha => false, :numeric => false, :methods => [:foo, :bar] },
-      :other_and_alpha => {
-        :alpha => true, :numeric => false,
-        :methods => [:foo, :bar, :a, :b]
-      },
-    }.each do |name, setup|
-      context "with #{name.to_s.gsub('_', ' ')} features" do
-        let :provider do
-          provider = type.provide(name)
-          setup[:methods].map do |method|
-            provider.send(:define_method, method) do true end
-          end
-          type.provider(name)
-        end
-        context "provider class" do
-          subject { provider }
-          it { is_expected.to respond_to(:has_features) }
-          it { is_expected.to respond_to(:has_feature) }
-          it { is_expected.to respond_to(:nomethods?) }
-          it { is_expected.not_to be_nomethods }
-          it { is_expected.to respond_to(:numeric?) }
-          if setup[:numeric]
-            it { is_expected.to be_numeric }
-            it { is_expected.to be_satisfies(:numeric) }
-          else
-            it { is_expected.not_to be_numeric }
-            it { is_expected.not_to be_satisfies(:numeric) }
-          end
-          it { is_expected.to respond_to(:alpha?) }
-          if setup[:alpha]
-            it { is_expected.to be_alpha }
-            it { is_expected.to be_satisfies(:alpha) }
-          else
-            it { is_expected.not_to be_alpha }
-            it { is_expected.not_to be_satisfies(:alpha) }
-          end
-        end
-        context "provider instance" do
-          subject { provider.new }
-          it { is_expected.to respond_to(:numeric?) }
-          if setup[:numeric]
-            it { is_expected.to be_numeric }
-            it { is_expected.to be_satisfies(:numeric) }
-          else
-            it { is_expected.not_to be_numeric }
-            it { is_expected.not_to be_satisfies(:numeric) }
-          end
-          it { is_expected.to respond_to(:alpha?) }
-          if setup[:alpha]
-            it { is_expected.to be_alpha }
-            it { is_expected.to be_satisfies(:alpha) }
-          else
-            it { is_expected.not_to be_alpha }
-            it { is_expected.not_to be_satisfies(:alpha) }
-          end
-        end
-      end
-    end
-    context "feature with no methods" do
-      before :each do
-        type.feature :undemanding, ''
-      end
-      it { is_expected.to respond_to(:undemanding?) }
-      context "when the feature is not declared" do
-        it { is_expected.not_to be_undemanding }
-        it { is_expected.not_to be_satisfies(:undemanding) }
-      end
-      context "when the feature is declared" do
-        before :each do
-          subject.has_feature :undemanding
-        end
-        it { is_expected.to be_undemanding }
-        it { is_expected.to be_satisfies(:undemanding) }
-      end
-    end
-    context "supports_parameter?" do
-      before :each do
-        type.newparam(:no_feature)
-        type.newparam(:one_feature,  :required_features => :alpha)
-        type.newparam(:two_features, :required_features => [:alpha, :numeric])
-      end
-      let :providers do
-        {
-          :zero => type.provide(:zero),
-          :one  => type.provide(:one) do has_features :alpha end,
-          :two  => type.provide(:two) do has_features :alpha, :numeric end
-        }
-      end
-      { :zero => { :yes => [:no_feature], :no => [:one_feature, :two_features] },
-        :one  => { :yes => [:no_feature, :one_feature], :no => [:two_features] },
-        :two  => { :yes => [:no_feature, :one_feature, :two_features], :no => [] }
-      }.each do |name, data|
-        data[:yes].each do |param|
-          it "should support #{param} with provider #{name}" do
-            expect(providers[name]).to be_supports_parameter(param)
-          end
-        end
-        data[:no].each do |param|
-          it "should not support #{param} with provider #{name}" do
-            expect(providers[name]).not_to be_supports_parameter(param)
-          end
-        end
-      end
-    end
-  end
-  def provider_of(options = {}, &block)
-    type = Puppet::Type.newtype(:dummy) do
-      provide(:dummy, options, &block)
-    end
-    type.provider(:dummy)
-  end
-  def expect_command_executed(name, path, *args)
-    command = Puppet::Provider::Command.new(name, path, Puppet::Util, Puppet::Util::Execution)
-    args = [no_args] if args.empty?
-    expect(command).to receive(:execute).with(*args)
-    command
-  end
-  def allow_creation_of(command, environment = {})
-      allow(Puppet::Provider::Command).to receive(:new).with(command.name, command.executable, Puppet::Util, Puppet::Util::Execution, { :failonfail => true, :combine => true, :custom_environment => environment }).and_return(command)
-  end
-  def file_exists_and_is_executable(path)
-    expect(FileTest).to receive(:file?).with(path).and_return(true)
-    expect(FileTest).to receive(:executable?).with(path).and_return(true)
-  end
-end