puppet 5.5.22-universal-darwin → 6.0.0-universal-darwin

data/spec/integration/provider/mailalias/aliases_spec.rb

@@ -1,9 +0,0 @@
-require 'spec_helper'
-require 'shared_behaviours/all_parsedfile_providers'
-
-provider_class = Puppet::Type.type(:mailalias).provider(:aliases)
-
-describe provider_class do
-  # #1560, in which we corrupt the format of complex mail aliases.
-  it_should_behave_like "all parsedfile providers", provider_class
-end

data/spec/integration/provider/mount_spec.rb

@@ -1,163 +0,0 @@
-require 'spec_helper'
-
-require 'puppet/file_bucket/dipper'
-
-describe "mount provider (integration)", :unless => Puppet.features.microsoft_windows? do
-  include PuppetSpec::Files
-
-  family = Facter.value(:osfamily)
-
-  def create_fake_fstab(initially_contains_entry)
-    File.open(@fake_fstab, 'w') do |f|
-      if initially_contains_entry
-        f.puts("/dev/disk1s1\t/Volumes/foo_disk\tmsdos\tlocal\t0\t0")
-      end
-    end
-  end
-
-  before :each do
-    @fake_fstab = tmpfile('fstab')
-    @current_options = "local"
-    @current_device = "/dev/disk1s1"
-    Puppet[:digest_algorithm] = 'md5' 
-    allow(Puppet::Type.type(:mount).defaultprovider).to receive(:default_target).and_return(@fake_fstab)
-    allow(Facter).to receive(:value).with(:hostname).and_return('some_host')
-    allow(Facter).to receive(:value).with(:domain).and_return('some_domain')
-    allow(Facter).to receive(:value).with(:kernel).and_return('Linux')
-    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(:fips_enabled).and_return(false)
-    Puppet::Util::ExecutionStub.set do |command, options|
-      case command[0]
-      when %r{/s?bin/mount}
-        if command.length == 1
-          if @mounted
-            "#{@current_device} on /Volumes/foo_disk (msdos, #{@current_options})\n"
-          else
-            ''
-          end
-        else
-          expect(command.last).to eq('/Volumes/foo_disk')
-          @current_device = check_fstab(true)
-          @mounted = true
-          ''
-        end
-      when %r{/s?bin/umount}
-        expect(command.length).to eq(2)
-        expect(command[1]).to eq('/Volumes/foo_disk')
-        expect(@mounted).to eq(true) # "umount" doesn't work when device not mounted (see #6632)
-        @mounted = false
-        ''
-      else
-        fail "Unexpected command #{command.inspect} executed"
-      end
-    end
-  end
-
-  after :each do
-    Puppet::Type::Mount::ProviderParsed.clear # Work around bug #6628
-  end
-
-  def check_fstab(expected_to_be_present)
-    # Verify that the fake fstab has the expected data in it
-    fstab_contents = File.read(@fake_fstab).split("\n").reject { |x| x =~ /^#|^$/ }
-    if expected_to_be_present
-      expect(fstab_contents.length()).to eq(1)
-      device, rest_of_line = fstab_contents[0].split(/\t/,2)
-      expect(rest_of_line).to eq("/Volumes/foo_disk\tmsdos\t#{@desired_options}\t0\t0")
-      device
-    else
-      expect(fstab_contents.length()).to eq(0)
-      nil
-    end
-  end
-
-  def run_in_catalog(settings)
-    resource = Puppet::Type.type(:mount).new(settings.merge(:name => "/Volumes/foo_disk",
-                                             :device => "/dev/disk1s1", :fstype => "msdos"))
-    allow_any_instance_of(Puppet::FileBucket::Dipper).to receive(:backup) # Don't backup to the filebucket
-    expect(resource).not_to receive(:err)
-    catalog = Puppet::Resource::Catalog.new
-    catalog.host_config = false # Stop Puppet from doing a bunch of magic
-    catalog.add_resource resource
-    catalog.apply
-  end
-
-  [false, true].each do |initial_state|
-    describe "When initially #{initial_state ? 'mounted' : 'unmounted'}" do
-      before :each do
-        @mounted = initial_state
-      end
-
-      [false, true].each do |initial_fstab_entry|
-        describe "When there is #{initial_fstab_entry ? 'an' : 'no'} initial fstab entry" do
-          before :each do
-            create_fake_fstab(initial_fstab_entry)
-          end
-
-          [:defined, :present, :mounted, :unmounted, :absent].each do |ensure_setting|
-            expected_final_state = case ensure_setting
-              when :mounted
-                true
-              when :unmounted, :absent
-                false
-              when :defined, :present
-                initial_state
-              else
-                fail "Unknown ensure_setting #{ensure_setting}"
-            end
-            expected_fstab_data = (ensure_setting != :absent)
-            describe "When setting ensure => #{ensure_setting}" do
-              ["local", "journaled", "", nil].each do |options_setting|
-                describe "When setting options => '#{options_setting}'" do
-                  it "should leave the system in the #{expected_final_state ? 'mounted' : 'unmounted'} state, #{expected_fstab_data ? 'with' : 'without'} data in /etc/fstab" do
-                    if family == "Solaris"
-                      skip("Solaris: The mock :operatingsystem value does not get changed in lib/puppet/provider/mount/parsed.rb")
-                    else
-                      if options_setting && options_setting.empty?
-                        expect { run_in_catalog(:ensure=>ensure_setting, :options => options_setting) }.to raise_error Puppet::ResourceError
-                      else
-                        if options_setting
-                          @desired_options = options_setting
-                          run_in_catalog(:ensure=>ensure_setting, :options => options_setting)
-                        else
-                          if initial_fstab_entry
-                            @desired_options = @current_options
-                          else
-                            @desired_options = 'defaults'
-                          end
-                          run_in_catalog(:ensure=>ensure_setting)
-                        end
-                        expect(@mounted).to eq(expected_final_state)
-                        if expected_fstab_data
-                          expect(check_fstab(expected_fstab_data)).to eq("/dev/disk1s1")
-                        else
-                          expect(check_fstab(expected_fstab_data)).to eq(nil)
-                        end
-                      end
-                    end
-                  end
-                end
-              end
-            end
-          end
-        end
-      end
-    end
-  end
-
-  describe "When the wrong device is mounted" do
-    it "should remount the correct device" do
-      pending "Due to bug 6309"
-      @mounted = true
-      @current_device = "/dev/disk2s2"
-      create_fake_fstab(true)
-      @desired_options = "local"
-      run_in_catalog(:ensure=>:mounted, :options=>'local')
-      expect(@current_device).to eq("/dev/disk1s1")
-      expect(@mounted).to eq(true)
-      expect(@current_options).to eq('local')
-      expect(check_fstab(true)).to eq("/dev/disk1s1")
-    end
-  end
-end

data/spec/integration/provider/ssh_authorized_key_spec.rb

@@ -1,217 +0,0 @@
-require 'spec_helper'
-require 'puppet/file_bucket/dipper'
-
-describe Puppet::Type.type(:ssh_authorized_key).provider(:parsed), '(integration)', :unless => Puppet.features.microsoft_windows? do
-  include PuppetSpec::Files
-
-  let :fake_userfile do
-    tmpfile('authorized_keys.user')
-  end
-
-  let :fake_rootfile do
-    tmpfile('authorized_keys.root')
-  end
-
-  let :sample_rsa_keys do
-    [
-      'AAAAB3NzaC1yc2EAAAADAQABAAAAgQCi18JBZOq10X3w4f67nVhO0O3s5Y1vHH4UgMSM3ZnQwbC5hjGyYSi9UULOoQQoQynI/a0I9NL423/Xk/XJVIKCHcS8q6V2Wmjd+fLNelOjxxoW6mbIytEt9rDvwgq3Mof3/m21L3t2byvegR00a+ikKbmInPmKwjeWZpexCIsHzQ==', # 1024 bit
-      'AAAAB3NzaC1yc2EAAAADAQABAAAAgQDLClyvi3CsJw5Id6khZs2/+s11qOH4Gdp6iDioDsrIp0m8kSiPr71VGyQYAfPzzvHemHS7Xg0NkG1Kc8u9tRqBQfTvz7ubq0AT/g01+4P2hQ/soFkuwlUG/HVnnaYb6N0Qp5SHWvD5vBE2nFFQVpP5GrSctPtHSjzJq/i+6LYhmQ==', # 1024 bit
-      'AAAAB3NzaC1yc2EAAAADAQABAAABAQDLygAO6txXkh9FNV8xSsBkATeqLbHzS7sFjGI3gt0Dx6q3LjyKwbhQ1RLf28kd5G6VWiXmClU/RtiPdUz8nrGuun++2mrxzrXrvpR9dq1lygLQ2wn2cI35dN5bjRMtXy3decs6HUhFo9MoNwX250rUWfdCyNPhGIp6OOfmjdy+UeLGNxq9wDx6i4bT5tVVSqVRtsEfw9+ICXchzl85QudjneVVpP+thriPZXfXA5eaGwAo/dmoKOIhUwF96gpdLqzNtrGQuxPbV80PTbGv9ZtAtTictxaDz8muXO7he9pXmchUpxUKtMFjHkL0FAZ9tRPmv3RA30sEr2fZ8+LKvnE50w0' #2048 Bit
-    ]
-  end
-
-  let :sample_dsa_keys do
-    [
-      'AAAAB3NzaC1kc3MAAACBAOPck2O8MIDSqxPSnvENt6tzRrKJ5oOhB6Nc6oEcWm+VEH1gvuxdiRqwoMgRwyEf1yUd+UAcLw3a6Jn+EtFyEBN/5WF+4Tt4xTxZ0Pfik2Wc5uqHbQ2dkmOoXiAOYPiD3JUQ1Xwm/J0CgetjitoLfzAGdCNhMqguqAuHcVJ78ZZbAAAAFQCIBKFYZ+I18I+dtgteirXh+VVEEwAAAIEAs1yvQ/wnLLrRCM660pF4kBiw3D6dJfMdCXWQpn0hZmkBQSIzZv4Wuk3giei5luxscDxNc+y3CTXtnyG4Kt1Yi2sOdvhRI3rX8tD+ejn8GHazM05l5VIo9uu4AQPIE32iV63IqgApSBbJ6vDJW91oDH0J492WdLCar4BS/KE3cRwAAACBAN0uSDyJqYLRsfYcFn4HyVf6TJxQm1IcwEt6GcJVzgjri9VtW7FqY5iBqa9B9Zdh5XXAYJ0XLsWQCcrmMHM2XGHGpA4gL9VlCJ/0QvOcXxD2uK7IXwAVUA7g4V4bw8EVnFv2Flufozhsp+4soo1xiYc5jiFVHwVlk21sMhAtKAeF' # 1024 Bit
-    ]
-  end
-
-  let :sample_lines do
-    [
-      "ssh-rsa #{sample_rsa_keys[1]} root@someotherhost",
-      "ssh-dss #{sample_dsa_keys[0]} root@anywhere",
-      "ssh-rsa #{sample_rsa_keys[2]} paul",
-      "ssh-rsa #{sample_rsa_keys[2]} dummy"
-    ]
-  end
-
-  let :dummy do
-    Puppet::Type.type(:ssh_authorized_key).new(
-      :name   => 'dummy',
-      :target => fake_userfile,
-      :user   => 'nobody',
-      :ensure => :absent
-    )
-  end
-
-  before :each do
-    allow(File).to receive(:chown)
-    allow(File).to receive(:chmod)
-    allow(Puppet::Util::SUIDManager).to receive(:asuser).and_yield
-  end
-
-  after :each do
-    described_class.clear # Work around bug #6628
-  end
-
-  def create_fake_key(username, content)
-    filename = (username == :root ? fake_rootfile : fake_userfile )
-    File.open(filename, 'w') do |f|
-      content.each do |line|
-        f.puts line
-      end
-    end
-  end
-
-  def check_fake_key(username, expected_content)
-    filename = (username == :root ? fake_rootfile : fake_userfile )
-    content = File.readlines(filename).map(&:chomp).sort.reject{ |x| x =~ /^# HEADER:/ }
-    expect(content.join("\n")).to eq(expected_content.sort.join("\n"))
-  end
-
-  def run_in_catalog(*resources)
-    allow_any_instance_of(Puppet::FileBucket::Dipper).to receive(:backup) # Don't backup to the filebucket
-    catalog = Puppet::Resource::Catalog.new
-    catalog.host_config = false
-    resources.each do |resource|
-      expect(resource).not_to receive(:err)
-      catalog.add_resource(resource)
-    end
-    catalog.apply
-  end
-
-  it "should not complain about empty lines and comments" do
-    expect(described_class).not_to receive(:flush)
-    sample = ['',sample_lines[0],'   ',sample_lines[1],'# just a comment','#and another']
-    create_fake_key(:user,sample)
-    run_in_catalog(dummy)
-    check_fake_key(:user, sample)
-  end
-
-  it "should keep empty lines and comments when modifying a file" do
-    create_fake_key(:user, ['',sample_lines[0],'   ',sample_lines[3],'# just a comment','#and another'])
-    run_in_catalog(dummy)
-    check_fake_key(:user, ['',sample_lines[0],'   ','# just a comment','#and another'])
-  end
-
-  describe "when managing one resource" do
-
-    describe "with ensure set to absent" do
-      let :resource do
-        Puppet::Type.type(:ssh_authorized_key).new(
-          :name     => 'root@hostname',
-          :type     => :rsa,
-          :key      => sample_rsa_keys[0],
-          :target   => fake_rootfile,
-          :user     => 'root',
-          :ensure   => :absent
-        )
-      end
-
-      it "should not modify root's keyfile if resource is currently not present" do
-        create_fake_key(:root, sample_lines)
-        run_in_catalog(resource)
-        check_fake_key(:root, sample_lines)
-      end
-
-      it "remove the key from root's keyfile if resource is currently present" do
-        create_fake_key(:root, sample_lines + ["ssh-rsa #{sample_rsa_keys[0]} root@hostname"])
-        run_in_catalog(resource)
-        check_fake_key(:root, sample_lines)
-      end
-    end
-
-    describe "when ensure is present" do
-      let :resource do
-        Puppet::Type.type(:ssh_authorized_key).new(
-          :name     => 'root@hostname',
-          :type     => :rsa,
-          :key      => sample_rsa_keys[0],
-          :target   => fake_rootfile,
-          :user     => 'root',
-          :ensure   => :present
-        )
-      end
-
-      # just a dummy so the parsedfile provider is aware
-      # of the user's authorized_keys file
-
-      it "should add the key if it is not present" do
-        create_fake_key(:root, sample_lines)
-        run_in_catalog(resource)
-        check_fake_key(:root, sample_lines + ["ssh-rsa #{sample_rsa_keys[0]} root@hostname" ])
-      end
-
-      it "should modify the type if type is out of sync" do
-        create_fake_key(:root,sample_lines + [ "ssh-dss #{sample_rsa_keys[0]} root@hostname" ])
-        run_in_catalog(resource)
-        check_fake_key(:root, sample_lines + [ "ssh-rsa #{sample_rsa_keys[0]} root@hostname" ])
-      end
-
-      it "should modify the key if key is out of sync" do
-        create_fake_key(:root,sample_lines + [ "ssh-rsa #{sample_rsa_keys[1]} root@hostname" ])
-        run_in_catalog(resource)
-        check_fake_key(:root, sample_lines + [ "ssh-rsa #{sample_rsa_keys[0]} root@hostname" ])
-      end
-
-      it "should remove the key from old file if target is out of sync" do
-        create_fake_key(:user, [ sample_lines[0], "ssh-rsa #{sample_rsa_keys[0]} root@hostname" ])
-        create_fake_key(:root, [ sample_lines[1], sample_lines[2] ])
-        run_in_catalog(resource, dummy)
-        check_fake_key(:user, [ sample_lines[0] ])
-        #check_fake_key(:root, [ sample_lines[1], sample_lines[2], "ssh-rsa #{sample_rsa_keys[0]} root@hostname" ])
-      end
-
-      it "should add the key to new file if target is out of sync" do
-        create_fake_key(:user, [ sample_lines[0], "ssh-rsa #{sample_rsa_keys[0]} root@hostname" ])
-        create_fake_key(:root, [ sample_lines[1], sample_lines[2] ])
-        run_in_catalog(resource, dummy)
-        #check_fake_key(:user, [ sample_lines[0] ])
-        check_fake_key(:root, [ sample_lines[1], sample_lines[2], "ssh-rsa #{sample_rsa_keys[0]} root@hostname" ])
-      end
-
-      it "should modify options if options are out of sync" do
-        resource[:options]=[ 'from="*.domain1,host1.domain2"', 'no-port-forwarding', 'no-pty' ]
-        create_fake_key(:root, sample_lines + [ "from=\"*.false,*.false2\",no-port-forwarding,no-pty ssh-rsa #{sample_rsa_keys[0]} root@hostname"])
-        run_in_catalog(resource)
-        check_fake_key(:root, sample_lines + [ "from=\"*.domain1,host1.domain2\",no-port-forwarding,no-pty ssh-rsa #{sample_rsa_keys[0]} root@hostname"] )
-      end
-    end
-  end
-
-  describe "when managing two resource" do
-    let :examples do
-      resources = []
-      resources << Puppet::Type.type(:ssh_authorized_key).new(
-        :name     => 'root@hostname',
-        :type     => :rsa,
-        :key      => sample_rsa_keys[0],
-        :target   => fake_rootfile,
-        :user     => 'root',
-        :ensure   => :present
-      )
-      resources << Puppet::Type.type(:ssh_authorized_key).new(
-        :name   => 'user@hostname',
-        :key    => sample_rsa_keys[1],
-        :type   => :rsa,
-        :target => fake_userfile,
-        :user   => 'nobody',
-        :ensure => :present
-      )
-      resources
-    end
-
-    describe "and both keys are absent" do
-      before :each do
-        create_fake_key(:root, sample_lines)
-        create_fake_key(:user, sample_lines)
-      end
-
-      it "should add both keys" do
-        run_in_catalog(*examples)
-        check_fake_key(:root, sample_lines + [ "ssh-rsa #{sample_rsa_keys[0]} root@hostname" ])
-        check_fake_key(:user, sample_lines + [ "ssh-rsa #{sample_rsa_keys[1]} user@hostname" ])
-      end
-    end
-  end
-end

data/spec/integration/provider/sshkey_spec.rb

@@ -1,153 +0,0 @@
-require 'spec_helper'
-require 'puppet/file_bucket/dipper'
-require 'puppet_spec/files'
-require 'puppet_spec/compiler'
-
-describe Puppet::Type.type(:sshkey).provider(:parsed), '(integration)',
-  :unless => Puppet.features.microsoft_windows? do
-  include PuppetSpec::Files
-  include PuppetSpec::Compiler
-
-  before :each do
-    # Don't backup to filebucket
-    allow_any_instance_of(Puppet::FileBucket::Dipper).to receive(:backup)
-    # We don't want to execute anything
-    allow(described_class).to receive(:filetype).
-      and_return(Puppet::Util::FileType::FileTypeFlat)
-
-    @sshkey_file = tmpfile('sshkey_integration_specs')
-    FileUtils.cp(my_fixture('sample'), @sshkey_file)
-  end
-
-  after :each do
-    # sshkey provider class
-    described_class.clear
-  end
-
-  let(:type_under_test) { 'sshkey' }
-
-  describe "when managing a ssh known hosts file it..." do
-
-    let(:super_unique) { "my.super.unique.host" }
-    it "should create a new known_hosts file with mode 0644" do
-      target   = tmpfile('ssh_known_hosts')
-      manifest = "#{type_under_test} { '#{super_unique}':
-                    ensure => 'present',
-                    type   => 'rsa',
-                    key    => 'TESTKEY',
-                    target => '#{target}' }"
-      apply_with_error_check(manifest)
-      expect_file_mode(target, "644")
-    end
-
-    it "should create an SSH host key entry (ensure present)" do
-      manifest = "#{type_under_test} { '#{super_unique}':
-                    ensure => 'present',
-                    type   => 'rsa',
-                    key    => 'mykey',
-                    target => '#{@sshkey_file}' }"
-      apply_with_error_check(manifest)
-      expect(File.read(@sshkey_file)).to match(/#{super_unique}.*mykey/)
-    end
-
-    let(:sshkey_name) { 'kirby.madstop.com' }
-    it "should delete an entry for an SSH host key" do
-      manifest = "#{type_under_test} { '#{sshkey_name}':
-                    ensure => 'absent',
-                    target => '#{@sshkey_file}' }"
-      apply_with_error_check(manifest)
-      expect(File.read(@sshkey_file)).not_to match(/#{sshkey_name}.*Yqk0=/)
-    end
-
-    it "should update an entry for an SSH host key" do
-      manifest = "#{type_under_test} { '#{sshkey_name}':
-                    ensure => 'present',
-                    type   => 'rsa',
-                    key    => 'mynewshinykey',
-                    target => '#{@sshkey_file}' }"
-      apply_with_error_check(manifest)
-      expect(File.read(@sshkey_file)).to match(/#{sshkey_name}.*mynewshinykey/)
-      expect(File.read(@sshkey_file)).not_to match(/#{sshkey_name}.*Yqk0=/)
-    end
-
-    # test all key types
-    types = ["ssh-dss",     "dsa",
-             "ssh-ed25519", "ed25519",
-             "ssh-rsa",     "rsa",
-             "ecdsa-sha2-nistp256",
-             "ecdsa-sha2-nistp384",
-             "ecdsa-sha2-nistp521"]
-    # these types are treated as aliases for sshkey <ahem> type
-    #   so they are populated as the *values* below
-    aliases = {"dsa"     => "ssh-dss",
-               "ed25519" => "ssh-ed25519",
-               "rsa"     => "ssh-rsa"}
-    types.each do |type|
-      it "should update an entry with #{type} type" do
-        manifest = "#{type_under_test} { '#{sshkey_name}':
-                      ensure => 'present',
-                      type   => '#{type}',
-                      key    => 'mynewshinykey',
-                      target => '#{@sshkey_file}' }"
-
-        apply_with_error_check(manifest)
-        if aliases.has_key?(type)
-          full_type = aliases[type]
-          expect(File.read(@sshkey_file)).
-            to match(/#{sshkey_name}.*#{full_type}.*mynew/)
-        else
-          expect(File.read(@sshkey_file)).
-            to match(/#{sshkey_name}.*#{type}.*mynew/)
-        end
-      end
-    end
-
-    # test unknown key type fails
-    let(:invalid_type) { 'ssh-er0ck' }
-    it "should raise an error with an unknown type" do
-      manifest = "#{type_under_test} { '#{sshkey_name}':
-                    ensure => 'present',
-                    type   => '#{invalid_type}',
-                    key    => 'mynewshinykey',
-                    target => '#{@sshkey_file}' }"
-      expect {
-      apply_compiled_manifest(manifest)
-      }.to raise_error(Puppet::ResourceError, /Invalid value "#{invalid_type}"/)
-    end
-
-    #single host_alias
-    let(:host_alias) { 'r0ckdata.com' }
-    it "should update an entry with new host_alias" do
-      manifest = "#{type_under_test} { '#{sshkey_name}':
-                    ensure       => 'present',
-                    host_aliases => '#{host_alias}',
-                    target       => '#{@sshkey_file}' }"
-      apply_with_error_check(manifest)
-      expect(File.read(@sshkey_file)).to match(/#{sshkey_name},#{host_alias}\s/)
-      expect(File.read(@sshkey_file)).not_to match(/#{sshkey_name}\s/)
-    end
-
-    #array host_alias
-    let(:host_aliases) { "r0ckdata.com,erict.net" }
-    it "should update an entry with new host_alias" do
-      manifest = "#{type_under_test} { '#{sshkey_name}':
-                    ensure       => 'present',
-                    host_aliases => '#{host_alias}',
-                    target       => '#{@sshkey_file}' }"
-      apply_with_error_check(manifest)
-      expect(File.read(@sshkey_file)).to match(/#{sshkey_name},#{host_alias}\s/)
-      expect(File.read(@sshkey_file)).not_to match(/#{sshkey_name}\s/)
-    end
-
-    #puppet resource sshkey
-    it "should fetch an entry from resources" do
-      @resource_app = Puppet::Application[:resource]
-      @resource_app.preinit
-      allow(@resource_app.command_line).to receive(:args).
-        and_return([type_under_test, sshkey_name, "target=#{@sshkey_file}"])
-
-      expect(@resource_app).to receive(:puts).with(/#{sshkey_name}/)
-      @resource_app.main
-    end
-  end
-end