puppet 5.5.22-x86-mingw32 → 6.0.0-x86-mingw32

data/spec/unit/provider/naginator_spec.rb

@@ -1,78 +0,0 @@
-require 'spec_helper'
-
-require 'puppet/provider/naginator'
-
-describe Puppet::Provider::Naginator do
-  before do
-    @resource_type = double('resource_type', :name => :nagios_test)
-    @class = Class.new(Puppet::Provider::Naginator)
-
-    allow(@class).to receive(:resource_type).and_return(@resource_type)
-  end
-
-  it "should be able to look up the associated Nagios type" do
-    nagios_type = double("nagios_type")
-    allow(nagios_type).to receive(:attr_accessor)
-    expect(Nagios::Base).to receive(:type).with(:test).and_return(nagios_type)
-
-    expect(@class.nagios_type).to equal(nagios_type)
-  end
-
-  it "should use the Nagios type to determine whether an attribute is valid" do
-    nagios_type = double("nagios_type")
-    allow(nagios_type).to receive(:attr_accessor)
-    expect(Nagios::Base).to receive(:type).with(:test).and_return(nagios_type)
-
-    expect(nagios_type).to receive(:parameters).and_return([:foo, :bar])
-
-    expect(@class.valid_attr?(:test, :foo)).to be_truthy
-  end
-
-  it "should use Naginator to parse configuration snippets" do
-    parser = double('parser')
-    expect(parser).to receive(:parse).with("my text").and_return("my instances")
-    expect(Nagios::Parser).to receive(:new).and_return(parser)
-
-    expect(@class.parse("my text")).to eq("my instances")
-  end
-
-  it "should join Nagios::Base records with '\\n' when asked to convert them to text" do
-    expect(@class).to receive(:header).and_return("myheader\n")
-
-    expect(@class.to_file([:one, :two])).to eq("myheader\none\ntwo")
-  end
-
-  it "should be able to prefetch instance from configuration files" do
-    expect(@class).to respond_to(:prefetch)
-  end
-
-  it "should be able to generate a list of instances" do
-    expect(@class).to respond_to(:instances)
-  end
-
-  it "should never skip records" do
-    expect(@class).not_to be_skip_record("foo")
-  end
-end
-
-describe Nagios::Base do
-  it "should not turn set parameters into arrays #17871" do
-    obj = Nagios::Base.create('host')
-    obj.host_name = "my_hostname"
-    expect(obj.host_name).to eq("my_hostname")
-  end
-end
-
-describe Nagios::Parser do
-  include PuppetSpec::Files
-
-  subject do
-    described_class.new
-  end
-
-  let(:config) { File.new( my_fixture('define_empty_param') ).read }
-
-  it "should handle empty parameter values" do
-    expect { subject.parse(config) }.to_not raise_error
-  end
-end

data/spec/unit/provider/network_device_spec.rb

@@ -1,152 +0,0 @@
-require 'spec_helper'
-
-require 'puppet/provider/network_device'
-require 'ostruct'
-
-Puppet::Type.type(:vlan).provide :test, :parent => Puppet::Provider::NetworkDevice do
-  mk_resource_methods
-  def self.lookup(device, name)
-  end
-
-  def self.device(url)
-    :device
-  end
-end
-
-provider_class = Puppet::Type.type(:vlan).provider(:test)
-
-describe provider_class do
-  before do
-    @resource = double("resource", :name => "test")
-    @provider = provider_class.new(@resource)
-  end
-
-  it "should be able to prefetch instances from the device" do
-    expect(provider_class).to respond_to(:prefetch)
-  end
-
-  it "should have an instances method" do
-    expect(provider_class).to respond_to(:instances)
-  end
-
-  describe "when prefetching" do
-    before do
-      @resource = double('resource')
-      allow(@resource).to receive(:[])
-      @resources = {"200" => @resource}
-      allow(provider_class).to receive(:lookup)
-    end
-
-    it "should lookup an entry for each passed resource" do
-      expect(provider_class).to receive(:lookup).with(anything, "200").and_return(nil)
-
-      allow(provider_class).to receive(:new)
-      allow(@resource).to receive(:provider=)
-      provider_class.prefetch(@resources)
-    end
-
-    describe "resources that do not exist" do
-      it "should create a provider with :ensure => :absent" do
-        allow(provider_class).to receive(:lookup).and_return(nil)
-        expect(provider_class).to receive(:new).with(:device, :ensure => :absent).and_return("myprovider")
-        expect(@resource).to receive(:provider=).with("myprovider")
-        provider_class.prefetch(@resources)
-      end
-    end
-
-    describe "resources that exist" do
-      it "should create a provider with the results of the find and ensure at present" do
-        allow(provider_class).to receive(:lookup).and_return({ :name => "200", :description => "myvlan"})
-
-        expect(provider_class).to receive(:new).with(:device, :name => "200", :description => "myvlan", :ensure => :present).and_return("myprovider")
-        expect(@resource).to receive(:provider=).with("myprovider")
-
-        provider_class.prefetch(@resources)
-      end
-    end
-  end
-
-  describe "when being initialized" do
-    describe "with a hash" do
-      before do
-        @resource_class = double('resource_class')
-        allow(provider_class).to receive(:resource_type).and_return(@resource_class)
-
-        @property_class = double('property_class', :array_matching => :all, :superclass => Puppet::Property)
-        allow(@resource_class).to receive(:attrclass).with(:one).and_return(@property_class)
-        allow(@resource_class).to receive(:valid_parameter?).and_return(true)
-      end
-
-      it "should store a copy of the hash as its vlan_properties" do
-        instance = provider_class.new(:device, :one => :two)
-        expect(instance.former_properties).to eq({:one => :two})
-      end
-    end
-  end
-
-  describe "when an instance" do
-    before do
-      @instance = provider_class.new(:device)
-
-      @property_class = double('property_class', :array_matching => :all, :superclass => Puppet::Property)
-      @resource_class = double('resource_class', :attrclass => @property_class, :valid_parameter? => true, :validproperties => [:description])
-      allow(provider_class).to receive(:resource_type).and_return(@resource_class)
-    end
-
-    it "should have a method for creating the instance" do
-      expect(@instance).to respond_to(:create)
-    end
-
-    it "should have a method for removing the instance" do
-      expect(@instance).to respond_to(:destroy)
-    end
-
-    it "should indicate when the instance already exists" do
-      @instance = provider_class.new(:device, :ensure => :present)
-      expect(@instance.exists?).to be_truthy
-    end
-
-    it "should indicate when the instance does not exist" do
-      @instance = provider_class.new(:device, :ensure => :absent)
-      expect(@instance.exists?).to be_falsey
-    end
-
-    describe "is being flushed" do
-      it "should flush properties" do
-        @instance = provider_class.new(:ensure => :present, :name => "200", :description => "myvlan")
-        @instance.flush
-        expect(@instance.properties).to be_empty
-      end
-    end
-
-    describe "is being created" do
-      before do
-        @rclass = double('resource_class')
-        allow(@rclass).to receive(:validproperties).and_return([:description])
-        @resource = double('resource')
-        allow(@resource).to receive(:class).and_return(@rclass)
-        allow(@resource).to receive(:should).and_return(nil)
-        allow(@instance).to receive(:resource).and_return(@resource)
-      end
-
-      it "should set its :ensure value to :present" do
-        @instance.create
-        expect(@instance.properties[:ensure]).to eq(:present)
-      end
-
-      it "should set all of the other attributes from the resource" do
-        expect(@resource).to receive(:should).with(:description).and_return("myvlan")
-
-        @instance.create
-        expect(@instance.properties[:description]).to eq("myvlan")
-      end
-    end
-
-    describe "is being destroyed" do
-      it "should set its :ensure value to :absent" do
-        @instance.destroy
-        expect(@instance.properties[:ensure]).to eq(:absent)
-      end
-    end
-  end
-end

data/spec/unit/provider/package/dnfmodule_spec.rb

@@ -1,247 +0,0 @@
-require 'spec_helper'
-
-describe Puppet::Type.type(:package).provider(:dnfmodule) do
-  include PuppetSpec::Fixtures
-
-  let(:dnf_version) do
-    <<-DNF_OUTPUT
-    4.0.9
-      Installed: dnf-0:4.0.9.2-5.el8.noarch at Wed 29 May 2019 07:05:05 AM GMT
-      Built    : Red Hat, Inc. <http://bugzilla.redhat.com/bugzilla> at Thu 14 Feb 2019 12:04:07 PM GMT
-
-      Installed: rpm-0:4.14.2-9.el8.x86_64 at Wed 29 May 2019 07:04:33 AM GMT
-      Built    : Red Hat, Inc. <http://bugzilla.redhat.com/bugzilla> at Thu 20 Dec 2018 01:30:03 PM GMT
-    DNF_OUTPUT
-  end
-
-  let(:execute_options) do
-    {:failonfail => true, :combine => true, :custom_environment => {}}
-  end
-
-  let(:packages) { File.read(my_fixture("dnf-module-list.txt")) }
-  let(:dnf_path) { '/usr/bin/dnf' }
-
-  before(:each) { allow(Puppet::Util).to receive(:which).with('/usr/bin/dnf').and_return(dnf_path) }
-
-  it "should have lower specificity" do
-    allow(Facter).to receive(:value).with(:osfamily).and_return(:redhat)
-    allow(Facter).to receive(:value).with(:operatingsystem).and_return(:redhat)
-    allow(Facter).to receive(:value).with(:operatingsystemmajrelease).and_return('8')
-    expect(described_class.specificity).to be < 200
-  end
-
-  describe "should be an opt-in provider" do
-    Array(4..8).each do |ver|
-      it "should not be default for redhat #{ver}" do
-        allow(Facter).to receive(:value).with(:operatingsystem).and_return('redhat')
-        allow(Facter).to receive(:value).with(:osfamily).and_return('redhat')
-        allow(Facter).to receive(:value).with(:operatingsystemmajrelease).and_return(ver.to_s)
-        expect(described_class).not_to be_default
-      end
-    end
-  end
-
-  describe "handling dnf versions" do
-    before(:each) do
-      expect(Puppet::Type::Package::ProviderDnfmodule).to receive(:execute)
-          .with(["/usr/bin/dnf", "--version"])
-          .and_return(dnf_version).at_most(:once)
-      expect(Puppet::Util::Execution).to receive(:execute)
-          .with(["/usr/bin/dnf", "--version"], execute_options)
-          .and_return(Puppet::Util::Execution::ProcessOutput.new(dnf_version, 0))
-    end
-
-    describe "with a supported dnf version" do
-      it "correctly parses the version" do
-        expect(described_class.current_version).to eq('4.0.9')
-      end
-    end
-
-    describe "with an unsupported dnf version" do
-      let(:dnf_version) do
-        <<-DNF_OUTPUT
-        2.7.5
-          Installed: dnf-0:2.7.5-12.fc28.noarch at Mon 13 Aug 2018 11:05:27 PM GMT
-          Built    : Fedora Project at Wed 18 Apr 2018 02:29:51 PM GMT
-
-          Installed: rpm-0:4.14.1-7.fc28.x86_64 at Mon 13 Aug 2018 11:05:25 PM GMT
-          Built    : Fedora Project at Mon 19 Feb 2018 09:29:01 AM GMT
-        DNF_OUTPUT
-      end
-
-      before(:each) { described_class.instance_variable_set("@current_version", nil) }
-
-      it "correctly parses the version" do
-        expect(described_class.current_version).to eq('2.7.5')
-      end
-
-      it "raises an error when attempting prefetch" do
-        expect { described_class.prefetch('anything') }.to raise_error(Puppet::Error, "Modules are not supported on DNF versions lower than 3.0.1")
-      end
-    end
-  end
-
-  describe "when ensuring a module" do
-    let(:name) { 'baz' }
-
-    let(:resource) do
-      Puppet::Type.type(:package).new(
-        :name => name,
-        :provider => 'dnfmodule',
-      )
-    end
-
-    let(:provider) do
-      provider = described_class.new
-      provider.resource = resource
-      provider
-    end
-
-    describe 'provider features' do
-      it { is_expected.to be_versionable }
-      it { is_expected.to be_installable }
-      it { is_expected.to be_uninstallable }
-    end
-
-    context "when installing a new module" do
-      before do
-        provider.instance_variable_get('@property_hash')[:ensure] = :absent
-      end
-
-      it "should not reset the module stream when package is absent" do
-        resource[:ensure] = :present
-        expect(provider).not_to receive(:uninstall)
-        expect(provider).to receive(:execute)
-        provider.install
-      end
-
-      it "should not reset the module stream when package is purged" do
-        provider.instance_variable_get('@property_hash')[:ensure] = :purged
-        resource[:ensure] = :present
-        expect(provider).not_to receive(:uninstall)
-        expect(provider).to receive(:execute)
-        provider.install
-      end
-
-      it "should just enable the module if it has no default profile" do
-        dnf_exception = Puppet::ExecutionFailure.new("Error: Problems in request:\nmissing groups or modules: #{resource[:name]}")
-        allow(provider).to receive(:execute).with(array_including('install')).and_raise(dnf_exception)
-        resource[:ensure] = :present
-        expect(provider).to receive(:execute).with(array_including('install')).ordered
-        expect(provider).to receive(:execute).with(array_including('enable')).ordered
-        provider.install
-      end
-
-      it "should just enable the module if enable_only = true" do
-        resource[:ensure] = :present
-        resource[:enable_only] = true
-        expect(provider).to receive(:execute).with(array_including('enable'))
-        expect(provider).not_to receive(:execute).with(array_including('install'))
-        provider.install
-      end
-
-      it "should install the default stream and flavor" do
-        resource[:ensure] = :present
-        expect(provider).to receive(:execute).with(array_including('baz'))
-        provider.install
-      end
-
-      it "should install a specific stream" do
-        resource[:ensure] = '9.6'
-        expect(provider).to receive(:execute).with(array_including('baz:9.6'))
-        provider.install
-      end
-
-      it "should install a specific flavor" do
-        resource[:ensure] = :present
-        resource[:flavor] = 'minimal'
-        expect(provider).to receive(:execute).with(array_including('baz/minimal'))
-        provider.install
-      end
-
-      it "should install a specific flavor and stream" do
-        resource[:ensure] = '9.6'
-        resource[:flavor] = 'minimal'
-        expect(provider).to receive(:execute).with(array_including('baz:9.6/minimal'))
-        provider.install
-      end
-    end
-
-    context "when ensuring a specific version on top of another stream" do
-      before do
-        provider.instance_variable_get('@property_hash')[:ensure] = '9.6'
-      end
-
-      it "should remove existing packages and reset the module stream before installing" do
-        resource[:ensure] = '10'
-        expect(provider).to receive(:execute).thrice.with(array_including(/remove|reset|install/))
-        provider.install
-      end
-    end
-
-    context "with an installed flavor" do
-      before do
-        provider.instance_variable_get('@property_hash')[:flavor] = 'minimal'
-      end
-
-      it "should remove existing packages and reset the module stream before installing another flavor" do
-        resource[:flavor] = 'common'
-        expect(provider).to receive(:execute).thrice.with(array_including(/remove|reset|install/))
-        provider.flavor = resource[:flavor]
-      end
-
-      it "should not do anything if the flavor doesn't change" do
-        resource[:flavor] = 'minimal'
-        expect(provider).not_to receive(:execute)
-        provider.flavor = resource[:flavor]
-      end
-
-      it "should return the existing flavor" do
-        expect(provider.flavor).to eq('minimal')
-      end
-    end
-
-    context "when disabling a module" do
-
-      it "executed the disable command" do
-        resource[:ensure] = :disabled
-        expect(provider).to receive(:execute).with(array_including('disable'))
-        provider.disable
-      end
-
-      it "does not try to disable if package is already disabled" do
-        allow(described_class).to receive(:command).with(:dnf).and_return(dnf_path)
-        allow(Puppet::Util::Execution).to receive(:execute)
-          .with("/usr/bin/dnf module list -d 0 -e 1")
-          .and_return("baz 1.2 [d][x] common [d], complete  Package Description")
-        resource[:ensure] = :disabled
-        expect(provider).to be_insync(:disabled)
-      end
-    end
-  end
-
-  context "parsing the output of module list" do
-    before { allow(described_class).to receive(:command).with(:dnf).and_return(dnf_path) }
-
-    it "returns an array of enabled modules" do
-      allow(Puppet::Util::Execution).to receive(:execute)
-        .with("/usr/bin/dnf module list -d 0 -e 1")
-        .and_return(packages)
-
-      enabled_packages = described_class.instances.map { |package| package.properties }
-      expected_packages = [{name: "389-ds", ensure: "1.4", flavor: :absent, provider: :dnfmodule},
-                           {name: "gimp", ensure: "2.8", flavor: "devel", provider: :dnfmodule},
-                           {name: "mariadb", ensure: "10.3", flavor: "client", provider: :dnfmodule},
-                           {name: "nodejs", ensure: "10", flavor: "minimal", provider: :dnfmodule},
-                           {name: "perl", ensure: "5.26", flavor: "minimal", provider: :dnfmodule},
-                           {name: "postgresql", ensure: "10", flavor: "server", provider: :dnfmodule},
-                           {name: "ruby", ensure: "2.5", flavor: :absent, provider: :dnfmodule},
-                           {name: "rust-toolset", ensure: "rhel8", flavor: "common", provider: :dnfmodule},
-                           {name: "subversion", ensure: "1.10", flavor: "server", provider: :dnfmodule},
-                           {name: "swig", ensure: :disabled, flavor: :absent, provider: :dnfmodule},
-                           {name: "virt", ensure: :disabled, flavor: :absent, provider: :dnfmodule}]
-
-      expect(enabled_packages).to eql(expected_packages)
-    end
-  end
-end