puppet 3.8.7-x64-mingw32 → 4.0.0.rc1-x64-mingw32

data/spec/integration/parser/undef_param_spec.rb

@@ -12,7 +12,7 @@ describe "Parameter passing" do
 
   def expect_the_message_to_be(message, node = Puppet::Node.new('the node'))
     catalog = compile_to_catalog(yield, node)
-    catalog.resource('Notify', 'something')[:message].should == message
+    expect(catalog.resource('Notify', 'something')[:message]).to eq(message)
   end
 
   def expect_puppet_error(message, node = Puppet::Node.new('the node'))
@@ -21,8 +21,8 @@ describe "Parameter passing" do
 
   it "overrides the default when a value is given" do
     expect_the_message_to_be('2') do <<-MANIFEST
-      define a($x=1) { notify { 'something': message => $x }}
-      a {'a': x => 2}
+      define a($x='1') { notify { 'something': message => $x }}
+      a {'a': x => '2'}
       MANIFEST
     end
   end
@@ -55,7 +55,7 @@ describe "Parameter passing" do
 
   it "uses the default when 'undef' is given'" do
     expect_the_message_to_be('1') do <<-MANIFEST
-        define a($x=1) { notify { 'something': message => $x }}
+        define a($x='1') { notify { 'something': message => $x }}
         a {'a': x => undef}
       MANIFEST
     end
@@ -63,7 +63,7 @@ describe "Parameter passing" do
 
   it "uses the default when no parameter is provided" do
     expect_the_message_to_be('1') do <<-MANIFEST
-        define a($x=1) { notify { 'something': message => $x }}
+        define a($x='1') { notify { 'something': message => $x }}
         a {'a': }
       MANIFEST
     end

data/spec/integration/provider/cron/crontab_spec.rb

@@ -36,7 +36,7 @@ describe Puppet::Type.type(:cron).provider(:crontab), '(integration)', :unless =
   end
 
   def expect_output(fixture_name)
-    File.read(crontab_user1).should == File.read(my_fixture(fixture_name))
+    expect(File.read(crontab_user1)).to eq(File.read(my_fixture(fixture_name)))
   end
 
   describe "when managing a cron entry" do
@@ -232,8 +232,8 @@ describe Puppet::Type.type(:cron).provider(:crontab), '(integration)', :unless =
             target       => '#{crontab_user2}',
         }
         MANIFEST
-        File.read(crontab_user1).should == File.read(my_fixture('moved_cronjob_input1'))
-        File.read(crontab_user2).should == File.read(my_fixture('moved_cronjob_input2'))
+        expect(File.read(crontab_user1)).to eq(File.read(my_fixture('moved_cronjob_input1')))
+        expect(File.read(crontab_user2)).to eq(File.read(my_fixture('moved_cronjob_input2')))
       end
     end
   end

data/spec/integration/provider/mount_spec.rb

@@ -20,6 +20,8 @@ describe "mount provider (integration)", :unless => Puppet.features.microsoft_wi
     @current_options = "local"
     @current_device = "/dev/disk1s1"
     Puppet::Type.type(:mount).defaultprovider.stubs(:default_target).returns(@fake_fstab)
+    Facter.stubs(:value).with(:hostname).returns('some_host')
+    Facter.stubs(:value).with(:domain).returns('some_domain')
     Facter.stubs(:value).with(:kernel).returns('Darwin')
     Facter.stubs(:value).with(:operatingsystem).returns('Darwin')
     Facter.stubs(:value).with(:osfamily).returns('Darwin')
@@ -33,8 +35,8 @@ describe "mount provider (integration)", :unless => Puppet.features.microsoft_wi
             ''
           end
         else
-          command.length.should == 4
-          command[1].should == '-o'
+          expect(command.length).to eq(4)
+          expect(command[1]).to eq('-o')
 
           # update is a special option, used on bsd's
           # strip it out and track as a local bool here
@@ -48,17 +50,17 @@ describe "mount provider (integration)", :unless => Puppet.features.microsoft_wi
           @current_options = tmp_options.join(",")
 
           if !update
-            @mounted.should == false # verify that we don't try to call "mount" redundantly
+            expect(@mounted).to eq(false) # verify that we don't try to call "mount" redundantly
           end
-          command[3].should == '/Volumes/foo_disk'
+          expect(command[3]).to eq('/Volumes/foo_disk')
           @current_device = check_fstab(true)
           @mounted = true
           ''
         end
       when %r{/s?bin/umount}
-        command.length.should == 2
-        command[1].should == '/Volumes/foo_disk'
-        @mounted.should == true # "umount" doesn't work when device not mounted (see #6632)
+        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
@@ -75,12 +77,12 @@ describe "mount provider (integration)", :unless => Puppet.features.microsoft_wi
     # 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
-      fstab_contents.length().should == 1
+      expect(fstab_contents.length()).to eq(1)
       device, rest_of_line = fstab_contents[0].split(/\t/,2)
-      rest_of_line.should == "/Volumes/foo_disk\tmsdos\t#{@desired_options}\t0\t0"
+      expect(rest_of_line).to eq("/Volumes/foo_disk\tmsdos\t#{@desired_options}\t0\t0")
       device
     else
-      fstab_contents.length().should == 0
+      expect(fstab_contents.length()).to eq(0)
       nil
     end
   end
@@ -124,22 +126,25 @@ describe "mount provider (integration)", :unless => Puppet.features.microsoft_wi
               ["local", "journaled"].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
-                    pending("Solaris: The mock :operatingsystem value does not get changed in lib/puppet/provider/mount/parsed.rb", :if => family == "Solaris")
-                    @desired_options = options_setting
-                    run_in_catalog(:ensure=>ensure_setting, :options => options_setting)
-                    @mounted.should == expected_final_state
-                    if expected_fstab_data
-                      check_fstab(expected_fstab_data).should == "/dev/disk1s1"
+                    if family == "Solaris"
+                      skip("Solaris: The mock :operatingsystem value does not get changed in lib/puppet/provider/mount/parsed.rb")
                     else
-                      check_fstab(expected_fstab_data).should == nil
-                    end
-                    if @mounted
-                      if ![:defined, :present].include?(ensure_setting)
-                        @current_options.should == @desired_options
-                      elsif initial_fstab_entry
-                        @current_options.should == @desired_options
+                      @desired_options = options_setting
+                      run_in_catalog(:ensure=>ensure_setting, :options => options_setting)
+                      expect(@mounted).to eq(expected_final_state)
+                      if expected_fstab_data
+                        expect(check_fstab(expected_fstab_data)).to eq("/dev/disk1s1")
                       else
-                        @current_options.should == 'local' #Workaround for #6645
+                        expect(check_fstab(expected_fstab_data)).to eq(nil)
+                      end
+                      if @mounted
+                        if ![:defined, :present].include?(ensure_setting)
+                          expect(@current_options).to eq(@desired_options)
+                        elsif initial_fstab_entry
+                          expect(@current_options).to eq(@desired_options)
+                        else
+                          expect(@current_options).to eq('local') #Workaround for #6645
+                        end
                       end
                     end
                   end
@@ -160,10 +165,10 @@ describe "mount provider (integration)", :unless => Puppet.features.microsoft_wi
       create_fake_fstab(true)
       @desired_options = "local"
       run_in_catalog(:ensure=>:mounted, :options=>'local')
-      @current_device.should=="/dev/disk1s1"
-      @mounted.should==true
-      @current_options.should=='local'
-      check_fstab(true).should == "/dev/disk1s1"
+      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/package_spec.rb

@@ -9,24 +9,13 @@ describe "Package provider" do
 
     describe name, :if => provider.suitable? do
       it "should fail when asked to install an invalid package" do
-        pending("This test hangs forever with recent versions of RubyGems") if provider.name == :gem
-
         options = {:name => "nosuch#{provider.name}", :provider => provider.name}
-        # The MSI provider requires that source be specified as it is
-        # what actually determines if the package exists.
-        if provider.name == :msi
-          options[:source] = tmpfile("msi_package")
-        end
 
         pkg = Puppet::Type.newpackage(options)
-        lambda { pkg.provider.install }.should raise_error
+        expect { pkg.provider.install }.to raise_error
       end
 
       it "should be able to get a list of existing packages" do
-        if provider.name == :msi
-          Puppet[:vardir] = tmpdir('msi_package_var_dir')
-        end
-
         # the instances method requires root priviledges on gentoo
         # if the eix cache is outdated (to run eix-update) so make
         # sure we dont actually run eix-update
@@ -35,8 +24,8 @@ describe "Package provider" do
         end
 
         provider.instances.each do |package|
-          package.should be_instance_of(provider)
-          package.properties[:provider].should == provider.name
+          expect(package).to be_instance_of(provider)
+          expect(package.properties[:provider]).to eq(provider.name)
         end
       end
     end

data/spec/integration/provider/service/init_spec.rb

@@ -10,7 +10,7 @@ describe provider do
     end
 
     it "should set its default path to include /etc/rc.d and /usr/local/etc/rc.d" do
-      provider.defpath.should == ["/etc/rc.d", "/usr/local/etc/rc.d"]
+      expect(provider.defpath).to eq(["/etc/rc.d", "/usr/local/etc/rc.d"])
     end
   end
 
@@ -20,7 +20,7 @@ describe provider do
     end
 
     it "should set its default path to include /sbin/init.d" do
-      provider.defpath.should == "/sbin/init.d"
+      expect(provider.defpath).to eq("/sbin/init.d")
     end
   end
 
@@ -30,7 +30,7 @@ describe provider do
     end
 
     it "should set its default path to include /etc/rc.d" do
-      provider.defpath.should == "/etc/rc.d"
+      expect(provider.defpath).to eq("/etc/rc.d")
     end
   end
 
@@ -40,7 +40,7 @@ describe provider do
     end
 
     it "should set its default path to include /etc/init.d" do
-      provider.defpath.should == "/etc/init.d"
+      expect(provider.defpath).to eq("/etc/init.d")
     end
   end
 end

data/spec/integration/provider/service/systemd_spec.rb

@@ -6,15 +6,15 @@ describe Puppet::Type.type(:service).provider(:systemd), '(integration)' do
   # TODO: Unfortunately there does not seem a way to stub the executable
   #       checks in the systemd provider because they happen at load time.
   it "should be considered suitable if /bin/systemctl is present", :if => File.executable?('/bin/systemctl') do
-    described_class.should be_suitable
+    expect(described_class).to be_suitable
   end
 
   it "should be considered suitable if /usr/bin/systemctl is present", :if => File.executable?('/usr/bin/systemctl')  do
-    described_class.should be_suitable
+    expect(described_class).to be_suitable
   end
 
   it "should not be cosidered suitable if systemctl is absent",
     :unless => (File.executable?('/bin/systemctl') or File.executable?('/usr/bin/systemctl')) do
-    described_class.should_not be_suitable
+    expect(described_class).not_to be_suitable
   end
 end

data/spec/integration/provider/ssh_authorized_key_spec.rb

@@ -68,7 +68,7 @@ describe Puppet::Type.type(:ssh_authorized_key).provider(:parsed), '(integration
   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:/ }
-    content.join("\n").should == expected_content.sort.join("\n")
+    expect(content.join("\n")).to eq(expected_content.sort.join("\n"))
   end
 
   def run_in_catalog(*resources)
@@ -99,7 +99,7 @@ describe Puppet::Type.type(:ssh_authorized_key).provider(:parsed), '(integration
   describe "when managing one resource" do
 
     describe "with ensure set to absent" do
-      let :example do
+      let :resource do
         Puppet::Type.type(:ssh_authorized_key).new(
           :name     => 'root@hostname',
           :type     => :rsa,
@@ -112,19 +112,19 @@ describe Puppet::Type.type(:ssh_authorized_key).provider(:parsed), '(integration
 
       it "should not modify root's keyfile if resource is currently not present" do
         create_fake_key(:root, sample_lines)
-        run_in_catalog(example)
+        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(example)
+        run_in_catalog(resource)
         check_fake_key(:root, sample_lines)
       end
     end
 
     describe "when ensure is present" do
-      let :example do
+      let :resource do
         Puppet::Type.type(:ssh_authorized_key).new(
           :name     => 'root@hostname',
           :type     => :rsa,
@@ -140,26 +140,26 @@ describe Puppet::Type.type(:ssh_authorized_key).provider(:parsed), '(integration
 
       it "should add the key if it is not present" do
         create_fake_key(:root, sample_lines)
-        run_in_catalog(example)
+        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(example)
+        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(example)
+        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(example, dummy)
+        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
@@ -167,15 +167,15 @@ describe Puppet::Type.type(:ssh_authorized_key).provider(:parsed), '(integration
       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(example, dummy)
+        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
-        example[:options]=[ 'from="*.domain1,host1.domain2"', 'no-port-forwarding', 'no-pty' ]
+        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(example)
+        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

data/spec/integration/provider/sshkey_spec.rb

@@ -0,0 +1,159 @@
+#!/usr/bin/env ruby
+
+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
+    Puppet::FileBucket::Dipper.any_instance.stubs(:backup)
+    # We don't want to execute anything
+    described_class.stubs(:filetype).
+      returns 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
+      @resource_app.command_line.stubs(:args).
+        returns([type_under_test, sshkey_name, "target=#{@sshkey_file}"])
+
+      @resource_app.expects(:puts).with do |args|
+        expect(args).to match(/#{sshkey_name}/)
+      end
+      @resource_app.main
+    end
+
+  end
+
+end