puppet 3.4.3 → 3.5.0.rc1

data/spec/unit/type/sshkey_spec.rb

@@ -1,67 +1,76 @@
 #! /usr/bin/env ruby
 require 'spec_helper'
 
-sshkey = Puppet::Type.type(:sshkey)
 
-describe sshkey do
-  before do
-    @class = sshkey
-  end
+describe Puppet::Type.type(:sshkey) do
 
-  it "should have :name its namevar" do
-    @class.key_attributes.should == [:name]
+  it "uses :name as its namevar" do
+    expect(described_class.key_attributes).to eq [:name]
   end
 
   describe "when validating attributes" do
     [:name, :provider].each do |param|
-      it "should have a #{param} parameter" do
-        @class.attrtype(param).should == :param
+      it "has a #{param} parameter" do
+        expect(described_class.attrtype(param)).to eq :param
       end
     end
 
     [:host_aliases, :ensure, :key, :type].each do |property|
-      it "should have a #{property} property" do
-        @class.attrtype(property).should == :property
+      it "has a #{property} property" do
+        expect(described_class.attrtype(property)).to eq :property
       end
     end
   end
 
   describe "when validating values" do
 
-    [:'ssh-dss', :'ssh-rsa', :rsa, :dsa, :'ecdsa-sha2-nistp256', :'ecdsa-sha2-nistp384', :'ecdsa-sha2-nistp521'].each do |keytype|
-      it "should support #{keytype} as a type value" do
-        proc { @class.new(:name => "foo", :type => keytype) }.should_not raise_error
+    [
+      :'ssh-dss', :dsa,
+      :'ssh-rsa', :rsa,
+      :'ecdsa-sha2-nistp256',
+      :'ecdsa-sha2-nistp384',
+      :'ecdsa-sha2-nistp521',
+      :'ssh-ed25519', :ed25519,
+    ].each do |keytype|
+      it "supports #{keytype} as a type value" do
+        described_class.new(:name => "foo", :type => keytype)
       end
     end
 
-    it "should alias :rsa to :ssh-rsa" do
-      key = @class.new(:name => "foo", :type => :rsa)
-      key.should(:type).should == :'ssh-rsa'
+    it "aliases :rsa to :ssh-rsa" do
+      key = described_class.new(:name => "foo", :type => :rsa)
+      expect(key.should(:type)).to eq :'ssh-rsa'
     end
 
-    it "should alias :dsa to :ssh-dss" do
-      key = @class.new(:name => "foo", :type => :dsa)
-      key.should(:type).should == :'ssh-dss'
+    it "aliases :dsa to :ssh-dss" do
+      key = described_class.new(:name => "foo", :type => :dsa)
+      expect(key.should(:type)).to eq :'ssh-dss'
     end
 
-    it "should not support values other than ssh-dss, ssh-rsa, dsa, rsa for type" do
-      proc { @class.new(:name => "whev", :type => :'ssh-dsa') }.should raise_error(Puppet::Error)
+    it "doesn't support values other than ssh-dss, ssh-rsa, dsa, rsa for type" do
+      expect {
+        described_class.new(:name => "whev", :type => :'ssh-dsa')
+      }.to raise_error(Puppet::Error, /Invalid value.*ssh-dsa/)
     end
 
-    it "should accept one host_alias" do
-      proc { @class.new(:name => "foo", :host_aliases => 'foo.bar.tld') }.should_not raise_error
+    it "accepts one host_alias" do
+      described_class.new(:name => "foo", :host_aliases => 'foo.bar.tld')
     end
 
-    it "should accept multiple host_aliases as an array" do
-      proc { @class.new(:name => "foo", :host_aliases => ['foo.bar.tld','10.0.9.9']) }.should_not raise_error
+    it "accepts multiple host_aliases as an array" do
+      described_class.new(:name => "foo", :host_aliases => ['foo.bar.tld','10.0.9.9'])
     end
 
-    it "should not accept spaces in any host_alias" do
-      proc { @class.new(:name => "foo", :host_aliases => ['foo.bar.tld','foo bar']) }.should raise_error(Puppet::Error)
+    it "doesn't accept spaces in any host_alias" do
+      expect {
+        described_class.new(:name => "foo", :host_aliases => ['foo.bar.tld','foo bar'])
+      }.to raise_error(Puppet::Error, /cannot include whitespace/)
     end
 
-    it "should not accept aliases in the resourcename" do
-      proc { @class.new(:name => 'host,host.domain,ip') }.should raise_error(Puppet::Error)
+    it "doesn't accept aliases in the resourcename" do
+      expect {
+        described_class.new(:name => 'host,host.domain,ip')
+      }.to raise_error(Puppet::Error, /No comma in resourcename/)
     end
 
   end

data/spec/unit/type/tidy_spec.rb

@@ -14,10 +14,11 @@ describe tidy do
 
   it "should use :lstat when stating a file" do
     path = '/foo/bar'
-    resource = tidy.new :path => path, :age => "1d"
     stat = mock 'stat'
-    stub_file = stub(path, :lstat => stat)
-    Puppet::FileSystem::File.expects(:new).with(path).returns stub_file
+    Puppet::FileSystem.expects(:lstat).with(path).returns stat
+
+    resource = tidy.new :path => path, :age => "1d"
+
     resource.stat(path).should == stat
   end
 
@@ -128,8 +129,7 @@ describe tidy do
     before do
       @tidy = Puppet::Type.type(:tidy).new :path => @basepath
       @stat = stub 'stat', :ftype => "directory"
-      @stub_file = stub(@basepath, :lstat => @stat)
-      Puppet::FileSystem::File.stubs(:new).with(@basepath).returns @stub_file
+      lstat_is(@basepath, @stat)
     end
 
     describe "and generating files" do
@@ -159,7 +159,7 @@ describe tidy do
       end
 
       it "should do nothing if the targeted file does not exist" do
-        @stub_file.expects(:lstat).raises Errno::ENOENT
+        lstat_raises(@basepath, Errno::ENOENT)
 
         @tidy.generate.should == []
       end
@@ -310,33 +310,32 @@ describe tidy do
       before do
         @tidy = Puppet::Type.type(:tidy).new :path => @basepath
         @stat = stub 'stat', :ftype => "file"
-        @stub_file = stub(@basepath, :lstat => @stat)
-        Puppet::FileSystem::File.expects(:new).with(@basepath).returns @stub_file
+        lstat_is(@basepath, @stat)
       end
 
       it "should not try to recurse if the file does not exist" do
         @tidy[:recurse] = true
 
-        @stub_file.stubs(:lstat).returns nil
+        lstat_is(@basepath, nil)
 
         @tidy.generate.should == []
       end
 
       it "should not be tidied if the file does not exist" do
-        @stub_file.expects(:lstat).raises Errno::ENOENT
+        lstat_raises(@basepath, Errno::ENOENT)
 
         @tidy.should_not be_tidy(@basepath)
       end
 
       it "should not be tidied if the user has no access to the file" do
-        @stub_file.expects(:lstat).raises Errno::EACCES
+        lstat_raises(@basepath, Errno::EACCES)
 
         @tidy.should_not be_tidy(@basepath)
       end
 
       it "should not be tidied if it is a directory and rmdirs is set to false" do
         stat = mock 'stat', :ftype => "directory"
-        @stub_file.expects(:lstat).returns stat
+        lstat_is(@basepath, stat)
 
         @tidy.should_not be_tidy(@basepath)
       end
@@ -423,4 +422,12 @@ describe tidy do
       end
     end
   end
+
+  def lstat_is(path, stat)
+    Puppet::FileSystem.stubs(:lstat).with(path).returns(stat)
+  end
+
+  def lstat_raises(path, error_class)
+    Puppet::FileSystem.expects(:lstat).with(path).raises Errno::ENOENT
+  end
 end

data/spec/unit/type/user_spec.rb

@@ -5,7 +5,7 @@ require 'spec_helper'
 describe Puppet::Type.type(:user) do
   before :each do
     @provider_class = described_class.provide(:simple) do
-      has_features :manages_expiry, :manages_password_age, :manages_passwords, :manages_solaris_rbac
+      has_features :manages_expiry, :manages_password_age, :manages_passwords, :manages_solaris_rbac, :manages_shell
       mk_resource_methods
       def create; end
       def delete; end
@@ -48,6 +48,10 @@ describe Puppet::Type.type(:user) do
     described_class.provider_feature(:system_users).should_not be_nil
   end
 
+  it "should have a manages_shell feature" do
+    described_class.provider_feature(:manages_shell).should_not be_nil
+  end
+
   describe :managehome do
     let (:provider) { @provider_class.new(:name => 'foo', :ensure => :absent) }
     let (:instance) { described_class.new(:name => 'foo', :provider => provider) }
@@ -62,7 +66,7 @@ describe Puppet::Type.type(:user) do
 
     it "cannot be set to true for a provider that does not manage homedirs" do
       provider.class.stubs(:manages_homedir?).returns false
-      expect { instance[:managehome] = 'yes' }.to raise_error Puppet::Error
+      expect { instance[:managehome] = 'yes' }.to raise_error(Puppet::Error, /can not manage home directories/)
     end
 
     it "can be set to true for a provider that does manage homedirs" do
@@ -371,4 +375,45 @@ describe Puppet::Type.type(:user) do
       rel.target.ref.should == testuser.ref
     end
   end
+
+  describe "when setting shell" do
+    before :each do
+      @shell_provider_class = described_class.provide(:shell_manager) do
+        has_features :manages_shell
+        mk_resource_methods
+        def create; check_valid_shell;end
+        def shell=(value); check_valid_shell; end
+        def delete; end
+        def exists?; get(:ensure) != :absent; end
+        def flush; end
+        def self.instances; []; end
+        def check_valid_shell; end
+      end
+
+      described_class.stubs(:defaultprovider).returns @shell_provider_class
+    end
+
+      it "should call :check_valid_shell on the provider when changing shell value" do
+        @provider = @shell_provider_class.new(:name => 'foo', :shell => '/bin/bash', :ensure => :present)
+        @provider.expects(:check_valid_shell)
+        resource = described_class.new(:name => 'foo', :shell => '/bin/zsh', :provider => @provider)
+        Puppet::Util::Storage.stubs(:load)
+        Puppet::Util::Storage.stubs(:store)
+        catalog = Puppet::Resource::Catalog.new
+        catalog.add_resource resource
+        catalog.apply
+      end
+
+      it "should call :check_valid_shell on the provider when changing ensure from present to absent" do
+        @provider = @shell_provider_class.new(:name => 'foo', :shell => '/bin/bash', :ensure => :absent)
+        @provider.expects(:check_valid_shell)
+        resource = described_class.new(:name => 'foo', :shell => '/bin/zsh', :provider => @provider)
+        Puppet::Util::Storage.stubs(:load)
+        Puppet::Util::Storage.stubs(:store)
+        catalog = Puppet::Resource::Catalog.new
+        catalog.add_resource resource
+        catalog.apply
+      end
+
+  end
 end

data/spec/unit/type/whit_spec.rb

@@ -1,10 +1,10 @@
 #! /usr/bin/env ruby
 require 'spec_helper'
 
-whit = Puppet::Type.type(:whit).new(:name => "Foo::Bar")
+whit = Puppet::Type.type(:whit)
 
 describe whit do
   it "should stringify in a way that users will regognise" do
-    whit.to_s.should == "Foo::Bar"
+    whit.new(:name => "Foo::Bar").to_s.should == "Foo::Bar"
   end
 end

data/spec/unit/type/yumrepo_spec.rb

@@ -1,18 +1,23 @@
-#! /usr/bin/env ruby
-
 require 'spec_helper'
+require 'puppet'
 
 describe Puppet::Type.type(:yumrepo) do
-  include PuppetSpec::Files
+  let(:yumrepo) {
+    Puppet::Type.type(:yumrepo).new(
+      :name => "puppetlabs"
+    )
+  }
 
   describe "When validating attributes" do
     it "should have a 'name' parameter'" do
-      Puppet::Type.type(:yumrepo).new(:name => "puppetlabs")[:name].should == "puppetlabs"
+      yumrepo[:name].should == "puppetlabs"
     end
 
-    [:baseurl, :cost, :descr, :enabled, :enablegroups, :exclude, :failovermethod, :gpgcheck, :gpgkey, :http_caching, 
-       :include, :includepkgs, :keepalive, :metadata_expire, :mirrorlist, :priority, :protect, :proxy, :proxy_username, :proxy_password, :timeout, 
-       :sslcacert, :sslverify, :sslclientcert, :sslclientkey, :s3_enabled].each do |param|
+    [:baseurl, :cost, :descr, :enabled, :enablegroups, :exclude, :failovermethod,
+     :gpgcheck, :repo_gpgcheck, :gpgkey, :http_caching, :include, :includepkgs, :keepalive,
+     :metadata_expire, :mirrorlist, :priority, :protect, :proxy, :proxy_username,
+     :proxy_password, :timeout, :sslcacert, :sslverify, :sslclientcert,
+     :sslclientkey, :s3_enabled, :metalink].each do |param|
       it "should have a '#{param}' parameter" do
         Puppet::Type.type(:yumrepo).attrtype(param).should == :property
       end
@@ -20,204 +25,54 @@ describe Puppet::Type.type(:yumrepo) do
   end
 
   describe "When validating attribute values" do
-    [:cost, :enabled, :enablegroups, :failovermethod, :gpgcheck, :http_caching, :keepalive, :metadata_expire, :priority, :protect, :timeout].each do |param|
+    [:cost, :enabled, :enablegroups, :failovermethod, :gpgcheck, :repo_gpgcheck, :http_caching,
+     :keepalive, :metadata_expire, :priority, :protect, :timeout].each do |param|
       it "should support :absent as a value to '#{param}' parameter" do
-        Puppet::Type.type(:yumrepo).new(:name => "puppetlabs.repo", param => :absent)
+        Puppet::Type.type(:yumrepo).new(:name => 'puppetlabs', param => :absent)
       end
     end
 
-    [:cost, :enabled, :enablegroups, :gpgcheck, :keepalive, :metadata_expire, :priority, :protect, :timeout].each do |param|
-      it "should fail if '#{param}' is not a number" do
-        lambda { Puppet::Type.type(:yumrepo).new(:name => "puppetlabs", param => "notanumber") }.should raise_error
+    [:cost, :enabled, :enablegroups, :gpgcheck, :repo_gpgcheck, :keepalive, :metadata_expire,
+     :priority, :protect, :timeout].each do |param|
+      it "should fail if '#{param}' is not true/false, 0/1, or yes/no" do
+        expect { Puppet::Type.type(:yumrepo).new(:name => "puppetlabs", param => "notanumber") }.to raise_error
       end
     end
 
-    [:enabled, :enabledgroups, :gpgcheck, :keepalive, :protect, :s3_enabled].each do |param|
+    [:enabled, :enabledgroups, :gpgcheck, :repo_gpgcheck, :keepalive, :protect, :s3_enabled].each do |param|
       it "should fail if '#{param}' does not have one of the following values (0|1)" do
-        lambda { Puppet::Type.type(:yumrepo).new(:name => "puppetlabs", param => "2") }.should raise_error
+        expect { Puppet::Type.type(:yumrepo).new(:name => "puppetlabs", param => "2") }.to raise_error
       end
     end
 
     it "should fail if 'failovermethod' does not have one of the following values (roundrobin|priority)" do
-      lambda { Puppet::Type.type(:yumrepo).new(:name => "puppetlabs", :failovermethod => "notavalidvalue") }.should raise_error
+      expect { Puppet::Type.type(:yumrepo).new(:name => "puppetlabs", :failovermethod => "notavalidvalue") }.to raise_error
     end
 
     it "should fail if 'http_caching' does not have one of the following values (packages|all|none)" do
-      lambda { Puppet::Type.type(:yumrepo).new(:name => "puppetlabs", :http_caching => "notavalidvalue") }.should raise_error
+      expect { Puppet::Type.type(:yumrepo).new(:name => "puppetlabs", :http_caching => "notavalidvalue") }.to raise_error
     end
 
     it "should fail if 'sslverify' does not have one of the following values (True|False)" do
-      lambda { Puppet::Type.type(:yumrepo).new(:name => "puppetlabs", :sslverify => "notavalidvalue") }.should raise_error
+      expect { Puppet::Type.type(:yumrepo).new(:name => "puppetlabs", :sslverify => "notavalidvalue") }.to raise_error
     end
 
     it "should succeed if 'sslverify' has one of the following values (True|False)" do
       Puppet::Type.type(:yumrepo).new(:name => "puppetlabs", :sslverify => "True")[:sslverify].should == "True"
       Puppet::Type.type(:yumrepo).new(:name => "puppetlabs", :sslverify => "False")[:sslverify].should == "False"
     end
-  end
-
-  # these tests were ported from the old spec/unit/type/yumrepo_spec.rb, pretty much verbatim
-  describe "When manipulating config file" do
-    def make_repo(name, hash={})
-      hash[:name] = name
-      Puppet::Type.type(:yumrepo).new(hash)
-    end
 
-    def all_sections(inifile)
-      sections = []
-      inifile.each_section { |section| sections << section.name }
-      sections.sort
-    end
-
-    def create_data_files()
-      File.open(File.join(@yumdir, "fedora.repo"), "w") do |f|
-        f.print(FEDORA_REPO_FILE)
+    [:mirrorlist, :baseurl, :gpgkey, :include, :proxy, :metalink].each do |param|
+      it "should succeed if '#{param}' uses one of the following protocols (file|http|https|ftp)" do
+        Puppet::Type.type(:yumrepo).new(:name => "puppetlabs", param => "file:///srv/example/")[param].should =~ %r{\Afile://}
+        Puppet::Type.type(:yumrepo).new(:name => "puppetlabs", param => "http://example.com/")[param].should =~ %r{\Ahttp://}
+        Puppet::Type.type(:yumrepo).new(:name => "puppetlabs", param => "https://example.com/")[param].should =~ %r{\Ahttps://}
+        Puppet::Type.type(:yumrepo).new(:name => "puppetlabs", param => "ftp://example.com/")[param].should =~ %r{\Aftp://}
       end
 
-      File.open(File.join(@yumdir, "fedora-devel.repo"), "w") do |f|
-        f.print(FEDORA_DEVEL_REPO_FILE)
+      it "should fail if '#{param}' does not use one of the following protocols (file|http|https|ftp)" do
+        expect { Puppet::Type.type(:yumrepo).new(:name => "puppetlabs", param => "gopher://example.com/") }.to raise_error
       end
     end
-
-    before(:each) do
-      @yumdir = tmpdir("yumrepo_spec_tmpdir")
-      @yumconf = File.join(@yumdir, "yum.conf")
-      File.open(@yumconf, "w") do |f|
-        f.print "[main]\nreposdir=#{@yumdir} /no/such/dir\n"
-      end
-      Puppet::Type.type(:yumrepo).yumconf = @yumconf
-
-      # It needs to be reset each time, otherwise the cache is used.
-      Puppet::Type.type(:yumrepo).inifile = nil
-    end
-
-    it "should be able to create a valid config file" do
-      values = {
-          :descr => "Fedora Core $releasever - $basearch - Base",
-          :baseurl => "http://example.com/yum/$releasever/$basearch/os/",
-          :enabled => "1",
-          :gpgcheck => "1",
-          :includepkgs => "absent",
-          :gpgkey => "file:///etc/pki/rpm-gpg/RPM-GPG-KEY-fedora",
-          :proxy => "http://proxy.example.com:80/",
-          :proxy_username => "username",
-          :proxy_password => "password"
-      }
-      repo = make_repo("base", values)
-
-      catalog = Puppet::Resource::Catalog.new
-      # Stop Puppet from doing a bunch of magic; might want to think about a util for specs that handles this
-      catalog.host_config = false
-      catalog.add_resource(repo)
-      catalog.apply
-
-      inifile = Puppet::Type.type(:yumrepo).read
-      sections = all_sections(inifile)
-      sections.should == ['base', 'main']
-      text = inifile["base"].format
-      text.should == EXPECTED_CONTENTS_FOR_CREATED_FILE
-    end
-
-    # Modify one existing section
-    it "should be able to modify an existing config file" do
-      create_data_files
-
-      devel = make_repo("development", { :descr => "New description" })
-      current_values = devel.retrieve
-
-      devel[:name].should == "development"
-      current_values[devel.property(:descr)].should == 'Fedora Core $releasever - Development Tree'
-      devel[:descr].should == 'New description'
-
-      catalog = Puppet::Resource::Catalog.new
-      # Stop Puppet from doing a bunch of magic; might want to think about a util for specs that handles this
-      catalog.host_config = false
-      catalog.add_resource(devel)
-      catalog.apply
-
-      inifile = Puppet::Type.type(:yumrepo).read
-      inifile['development']['name'].should == 'New description'
-      inifile['base']['name'].should == 'Fedora Core $releasever - $basearch - Base'
-      inifile['base']['exclude'].should == "foo\n  bar\n  baz"
-      all_sections(inifile).should == ['base', 'development', 'main']
-    end
-
-    # Delete mirrorlist by setting it to :absent and enable baseurl
-    it "should support 'absent' value" do
-      create_data_files
-
-      baseurl = 'http://example.com/'
-
-      devel = make_repo(
-          "development",
-          { :mirrorlist => 'absent',
-
-            :baseurl => baseurl })
-      devel.retrieve
-
-      catalog = Puppet::Resource::Catalog.new
-      # Stop Puppet from doing a bunch of magic; might want to think about a util for specs that handles this
-      catalog.host_config = false
-      catalog.add_resource(devel)
-      catalog.apply
-
-      inifile = Puppet::Type.type(:yumrepo).read
-      sec = inifile["development"]
-      sec["mirrorlist"].should == nil
-      sec["baseurl"].should == baseurl
-    end
   end
 end
-
-EXPECTED_CONTENTS_FOR_CREATED_FILE = <<'EOF'
-[base]
-name=Fedora Core $releasever - $basearch - Base
-baseurl=http://example.com/yum/$releasever/$basearch/os/
-enabled=1
-gpgcheck=1
-gpgkey=file:///etc/pki/rpm-gpg/RPM-GPG-KEY-fedora
-proxy=http://proxy.example.com:80/
-proxy_username=username
-proxy_password=password
-EOF
-
-FEDORA_REPO_FILE = <<END
-[base]
-name=Fedora Core $releasever - $basearch - Base
-mirrorlist=http://fedora.redhat.com/download/mirrors/fedora-core-$releasever
-enabled=1
-gpgcheck=1
-gpgkey=file:///etc/pki/rpm-gpg/RPM-GPG-KEY-fedora
-exclude=foo
-  bar
-  baz
-END
-
-FEDORA_DEVEL_REPO_FILE = <<END
-[development]
-# These packages are untested and still under development. This
-# repository is used for updates to test releases, and for
-# development of new releases.
-#
-# This repository can see significant daily turn over and can see major
-# functionality changes which cause unexpected problems with other
-# development packages. Please use these packages if you want to work
-# with the Fedora developers by testing these new development packages.
-#
-# fedora-test-list@redhat.com is available as a discussion forum for
-# testing and troubleshooting for development packages in conjunction
-# with new test releases.
-#
-# fedora-devel-list@redhat.com is available as a discussion forum for
-# testing and troubleshooting for development packages in conjunction
-# with developing new releases.
-#
-# Reportable issues should be filed at bugzilla.redhat.com
-# Product: Fedora Core
-# Version: devel
-name=Fedora Core $releasever - Development Tree
-#baseurl=http://download.fedora.redhat.com/pub/fedora/linux/core/development/$basearch/
-mirrorlist=http://fedora.redhat.com/download/mirrors/fedora-core-rawhide
-enabled=0
-gpgcheck=0
-END