puppet 3.1.0.rc1 → 3.1.0.rc2

data/spec/unit/dsl/resource_type_api_spec.rb

@@ -0,0 +1,53 @@
+#! /usr/bin/env ruby
+require 'spec_helper'
+
+require 'puppet/dsl/resource_type_api'
+
+describe Puppet::DSL::ResourceTypeAPI do
+  # Verify that the block creates a single AST node through the API,
+  # instantiate that AST node into a types, and return that type.
+  def test_api_call(&block)
+    main_object = Puppet::DSL::ResourceTypeAPI.new
+    main_object.instance_eval(&block)
+    created_ast_objects = main_object.instance_eval { @__created_ast_objects__ }
+    created_ast_objects.length.should == 1
+    new_types = created_ast_objects[0].instantiate('')
+    new_types.length.should == 1
+    new_types[0]
+  ensure
+    Thread.current[:ruby_file_parse_result] = nil
+  end
+
+  [:definition, :node, :hostclass].each do |type|
+    method = type == :definition ? "define" : type
+    it "should be able to create a #{type}" do
+      newtype = test_api_call { send(method, "myname").should == nil }
+      newtype.should be_a(Puppet::Resource::Type)
+      newtype.type.should == type
+    end
+
+    it "should use the provided name when creating a #{type}" do
+      newtype = test_api_call { send(method, "myname") }
+      newtype.name.should == "myname"
+    end
+
+    unless type == :definition
+      it "should pass in any provided options when creating a #{type}" do
+        newtype = test_api_call { send(method, "myname", :line => 200) }
+        newtype.line.should == 200
+      end
+    end
+
+    it "should set any provided block as the type's ruby code" do
+      newtype = test_api_call { send(method, "myname") { 'method_result' } }
+      newtype.ruby_code.call.should == 'method_result'
+    end
+  end
+
+  describe "when creating a definition" do
+    it "should use the provided options to define valid arguments for the resource type" do
+      newtype = test_api_call { define("myname", :arg1, :arg2) }
+      newtype.arguments.should == { 'arg1' => nil, 'arg2' => nil }
+    end
+  end
+end

data/spec/unit/module_tool_spec.rb

@@ -152,93 +152,126 @@ TREE
 TREE
     end
   end
+
   describe '.set_option_defaults' do
-    include PuppetSpec::Files
-    let (:setting) { {:environment => "foo", :modulepath => make_absolute("foo")} }
+    describe 'option :environment' do
+      context 'passed:' do
+        let (:environment) { "ahgkduerh" }
+        let (:options) { {:environment => environment} }
 
-    [:environment, :modulepath].each do |value|
-      describe "if #{value} is part of options" do
-        let (:options) { {} }
+        it 'Puppet[:environment] should be set to the value of the option' do
+          subject.set_option_defaults options
 
-        before(:each) do
-          options[value] = setting[value]
-          Puppet[value] = "bar"
+          Puppet[:environment].should == environment
         end
 
-        it "should set Puppet[#{value}] to the options[#{value}]" do
+        it 'the option value should not be overridden' do
+          Puppet[:environment] = :foo
           subject.set_option_defaults options
-          Puppet[value].should == options[value]
+
+          options[:environment].should == environment
+        end
+      end
+
+      context 'NOT passed:' do
+        it 'Puppet[:environment] should NOT be overridden' do
+          Puppet[:environment] = :foo
+
+          subject.set_option_defaults({})
+          Puppet[:environment].should == :foo
         end
 
-        it "should not override options[#{value}]" do
+        it 'the option should be set to the value of Puppet[:environment]' do
+          options_to_modify = Hash.new
+          Puppet[:environment] = :abcdefg
+
+          subject.set_option_defaults options_to_modify
+
+          options_to_modify[:environment].should == :abcdefg
+        end
+      end
+    end
+
+    describe 'option :modulepath' do
+      context 'passed:' do
+        let (:modulepath) { PuppetSpec::Files.make_absolute('/bar') }
+        let (:options) { {:modulepath => modulepath} }
+
+        it 'Puppet[:modulepath] should be set to the value of the option' do
+
           subject.set_option_defaults options
-          options[value].should == setting[value]
+
+          Puppet[:modulepath].should == modulepath
         end
 
+        it 'the option value should not be overridden' do
+          Puppet[:modulepath] = "/foo"
+
+          subject.set_option_defaults options
+
+          options[:modulepath].should == modulepath
+        end
       end
 
-      describe "if #{value} is not part of options" do
-        let (:options) { {} }
+      context 'NOT passed:' do
+        let (:options) { {:environment => :pmttestenv} }
 
         before(:each) do
-          Puppet[value] = setting[value]
+          Puppet[:modulepath] = "/no"
+          Puppet[:environment] = :pmttestenv
+          Puppet.settings.set_value(:modulepath,
+                                    ["/foo", "/bar", "/no"].join(File::PATH_SEPARATOR),
+                                    :pmttestenv)
         end
 
-        it "should populate options[#{value}] with the value of Puppet[#{value}]" do
+        it 'Puppet[:modulepath] should be reset to the module path of the current environment' do
           subject.set_option_defaults options
-          Puppet[value].should == options[value]
+
+          Puppet[:modulepath].should == Puppet.settings.value(:modulepath, :pmttestenv)
         end
 
-        it "should not override Puppet[#{value}]" do
+        it 'the option should be set to the module path of the current environment' do
           subject.set_option_defaults options
-          Puppet[value].should == setting[value]
+
+          options[:modulepath].should == Puppet.settings.value(:modulepath, :pmttestenv)
         end
       end
     end
 
-    describe ':target_dir' do
-      let (:sep) { File::PATH_SEPARATOR }
+    describe 'option :target_dir' do
+      let (:target_dir) { 'boo' }
 
-      let (:my_fake_path) {
-          ["/my/fake/dir", "/my/other/dir"].collect { |dir| make_absolute(dir) } .join(sep)
-      }
-      let (:options) { {:modulepath => my_fake_path}}
+      context 'passed:' do
+        let (:options) { {:target_dir => target_dir} }
 
-      describe "when not specified" do
+        it 'the option value should be prepended to the Puppet[:modulepath]' do
+          Puppet[:modulepath] = "/fuz"
+          original_modulepath = Puppet[:modulepath]
 
-        it "should set options[:target_dir]" do
           subject.set_option_defaults options
-          options[:target_dir].should_not be_nil
+
+          Puppet[:modulepath].should == options[:target_dir] + File::PATH_SEPARATOR + original_modulepath
         end
 
-        it "should be the first path of options[:modulepath]" do
+        it 'the option value should be turned into an absolute path' do
           subject.set_option_defaults options
-          options[:target_dir].should == my_fake_path.split(sep).first
-        end
-      end
 
-      describe "when specified" do
-        let (:my_target_dir) { make_absolute("/foo/bar") }
-        before(:each) do
-          options[:target_dir] = my_target_dir
+          options[:target_dir].should == File.expand_path(target_dir)
         end
+      end
 
-        it "should not be overridden" do
-          subject.set_option_defaults options
-          options[:target_dir].should == my_target_dir
+      describe 'NOT passed:' do
+        before :each do
+          Puppet[:modulepath] = 'foo' + File::PATH_SEPARATOR + 'bar'
         end
 
-        it "should be prepended to options[:modulepath]" do
+        it 'the option should be set to the first component of Puppet[:modulepath]' do
+          options = Hash.new
           subject.set_option_defaults options
-          options[:modulepath].split(sep).first.should == my_target_dir
-        end
 
-        it "should leave the remainder of options[:modulepath] untouched" do
-          subject.set_option_defaults options
-          options[:modulepath].split(sep).drop(1).join(sep).should == my_fake_path
+          options[:target_dir].should == Puppet[:modulepath].split(File::PATH_SEPARATOR)[0]
         end
       end
-
     end
   end
 end

data/spec/unit/network/formats_spec.rb

@@ -311,6 +311,10 @@ describe "Puppet Network Format" do
       end
     end
 
+    it "should render empty hashes as empty strings" do
+      subject.render({}).should == ''
+    end
+
     it "should render a non-trivially-keyed Hash as JSON" do
       hash = { [1,2] => 3, [2,3] => 5, [3,4] => 7 }
       subject.render(hash).should == json.render(hash).chomp

data/spec/unit/node/environment_spec.rb

@@ -441,19 +441,6 @@ describe Puppet::Node::Environment do
       env.instance_eval { perform_initial_import }
     end
 
-    it "should not do anything when using ruby dsl" do
-      Puppet[:manifest] = "test.rb"
-      @parser.expects(:parse).never
-      env.instance_eval { perform_initial_import }
-    end
-
-    it "returns empty hostclass when using Ruby DSL" do
-      Puppet[:manifest] = "test.rb"
-      env.instance_eval { perform_initial_import }.tap {|c|
-        c.should be_a Puppet::Parser::AST::Hostclass
-      }.code.should be nil
-    end
-
     it "should mark the type collection as needing a reparse when there is an error parsing" do
       @parser.expects(:parse).raises Puppet::ParseError.new("Syntax error at ...")
       env.stubs(:known_resource_types).returns Puppet::Resource::TypeCollection.new(env)

data/spec/unit/parser/compiler_spec.rb

@@ -247,32 +247,6 @@ describe Puppet::Parser::Compiler do
       @compiler.compile
     end
 
-    it "should evaluate ruby code on main object when using ruby dsl" do
-      compile_stub(:evaluate_main)
-      Puppet::Util::ManifestFiletypeHelper.expects(:is_ruby_filename?).at_least_once.returns true
-      @compiler.expects :assign_ruby_code
-
-      @compiler.compile
-    end
-
-    it "should create a new Puppet::DSL::Parser when using ruby dsl" do
-      compile_stub(:evaluate_main)
-      File.stubs(:read).returns("test code")
-      Puppet[:manifest] = "test.rb"
-      Puppet::DSL::Parser.expects(:prepare_for_evaluation).with {|main, code, filename| code == "test code" and main.is_a? Puppet::Resource::Type}.returns stub(:evaluate)
-
-      @compiler.compile
-    end
-
-    it "should call evaluate on DSL Parser instance when using ruby dsl" do
-      compile_stub(:evaluate_main)
-      Puppet::Util::ManifestFiletypeHelper.expects(:is_ruby_filename?).at_least_once.returns true
-      File.stubs(:read).returns("")
-      Puppet::DSL::Parser.expects :prepare_for_evaluation
-
-      @compiler.compile
-    end
-
     it "should create a new, empty 'main' if no main class exists" do
       compile_stub(:evaluate_main)
       @compiler.compile

data/spec/unit/parser/parser_spec.rb

@@ -49,6 +49,20 @@ describe Puppet::Parser do
     end
   end
 
+  describe "when parsing files" do
+    before do
+      FileTest.stubs(:exist?).returns true
+      File.stubs(:read).returns ""
+      @parser.stubs(:watch_file)
+    end
+
+    it "should treat files ending in 'rb' as ruby files" do
+      @parser.expects(:parse_ruby_file)
+      @parser.file = "/my/file.rb"
+      @parser.parse
+    end
+  end
+
   describe "when parsing append operator" do
 
     it "should not raise syntax errors" do

data/spec/unit/parser/type_loader_spec.rb

@@ -11,6 +11,7 @@ describe Puppet::Parser::TypeLoader do
 
   before do
     @loader = Puppet::Parser::TypeLoader.new(:myenv)
+    Puppet.expects(:deprecation_warning).never
   end
 
   it "should support an environment" do
@@ -92,20 +93,6 @@ describe Puppet::Parser::TypeLoader do
       # This will fail if it tries to reimport the file.
       @loader.import("myfile")
     end
-
-    it "checks the type of DSL to import" do
-      Puppet::Parser::Files.expects(:find_manifests).returns ["modname", [make_absolute("/one")]]
-      Puppet::Util::ManifestFiletypeHelper.expects(:is_ruby_filename?).at_least_once.returns false
-
-      @loader.import("myfile")
-    end
-
-    it "evaluates loaded Ruby code" do
-      File.stubs(:read).returns("hostclass(:asdf) {}")
-      Puppet::Parser::Files.stubs(:find_manifests).returns ["modname", [make_absolute("/one.rb")]]
-
-      @loader.import("myfile").map(&:name).should include "asdf"
-    end
   end
 
   describe "when importing all" do
@@ -136,7 +123,7 @@ describe Puppet::Parser::TypeLoader do
 
         # write out the class
         if type == "ruby"
-          File.open(path, "w") { |f| f.print "hostclass :'#{name}' do; end" }
+          File.open(path, "w") { |f| f.print "hostclass '#{name}' do\nend" }
         else
           File.open(path, "w") { |f| f.print "class #{name} {}" }
         end
@@ -160,6 +147,8 @@ describe Puppet::Parser::TypeLoader do
     end
 
     it "should load all ruby manifests from all modules in the specified environment" do
+      Puppet.expects(:deprecation_warning).at_least(1)
+
       @module1 = mk_module(@modulebase1, "one")
       @module2 = mk_module(@modulebase2, "two")
 

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

@@ -5,11 +5,36 @@ require 'stringio'
 provider_class = Puppet::Type.type(:package).provider(:openbsd)
 
 describe provider_class do
-  subject { provider_class }
+  let(:package) { Puppet::Type.type(:package).new(:name => 'bash', :provider => 'openbsd') }
+  let(:provider) { provider_class.new(package) }
 
-  def package(args = {})
-    defaults = { :name => 'bash', :provider => 'openbsd' }
-    Puppet::Type.type(:package).new(defaults.merge(args))
+  def expect_read_from_pkgconf(lines)
+    pkgconf = stub(:readlines => lines)
+    File.expects(:exist?).with('/etc/pkg.conf').returns(true)
+    File.expects(:open).with('/etc/pkg.conf', 'rb').returns(pkgconf)
+  end
+
+  def expect_pkgadd_with_source(source)
+    provider.expects(:pkgadd).with do |fullname|
+      ENV.should_not be_key 'PKG_PATH'
+      fullname.should == source
+    end
+  end
+
+  def expect_pkgadd_with_env_and_name(source, &block)
+    ENV.should_not be_key 'PKG_PATH'
+
+    provider.expects(:pkgadd).with do |fullname|
+      ENV.should be_key 'PKG_PATH'
+      ENV['PKG_PATH'].should == source
+
+      fullname.should == provider.resource[:name]
+    end
+    provider.expects(:execpipe).with(['/bin/pkg_info', '-I', provider.resource[:name]]).yields('')
+
+    yield
+
+    ENV.should_not be_key 'PKG_PATH'
   end
 
   before :each do
@@ -22,78 +47,167 @@ describe provider_class do
 
   context "::instances" do
     it "should return nil if execution failed" do
-      subject.expects(:execpipe).raises(Puppet::ExecutionFailure, 'wawawa')
-      subject.instances.should be_nil
+      provider_class.expects(:execpipe).raises(Puppet::ExecutionFailure, 'wawawa')
+      provider_class.instances.should be_nil
     end
 
     it "should return the empty set if no packages are listed" do
-      subject.expects(:execpipe).with(%w{/bin/pkg_info -a}).yields(StringIO.new(''))
-      subject.instances.should be_empty
+      provider_class.expects(:execpipe).with(%w{/bin/pkg_info -a}).yields(StringIO.new(''))
+      provider_class.instances.should be_empty
     end
 
     it "should return all packages when invoked" do
       fixture = File.read(my_fixture('pkginfo.list'))
-      subject.expects(:execpipe).with(%w{/bin/pkg_info -a}).yields(fixture)
-      subject.instances.map(&:name).sort.should ==
+      provider_class.expects(:execpipe).with(%w{/bin/pkg_info -a}).yields(fixture)
+      provider_class.instances.map(&:name).sort.should ==
         %w{bash bzip2 expat gettext libiconv lzo openvpn python vim wget}.sort
     end
   end
 
   context "#install" do
     it "should fail if the resource doesn't have a source" do
-      provider = subject.new(package())
-      expect { provider.install }.
-        to raise_error Puppet::Error, /must specify a package source/
+      File.expects(:exist?).with('/etc/pkg.conf').returns(false)
+
+      expect {
+        provider.install
+      }.to raise_error Puppet::Error, /must specify a package source/
     end
 
-    it "should install correctly when given a directory-unlike source" do
-      ENV.should_not be_key 'PKG_PATH'
+    it "should fail if /etc/pkg.conf exists, but is not readable" do
+      File.expects(:exist?).with('/etc/pkg.conf').returns(true)
+      File.expects(:open).with('/etc/pkg.conf', 'rb').raises(Errno::EACCES)
 
+      expect {
+        provider.install
+      }.to raise_error Errno::EACCES, /Permission denied/
+    end
+
+    it "should fail if /etc/pkg.conf exists, but there is no installpath" do
+      expect_read_from_pkgconf([])
+      expect {
+        provider.install
+      }.to raise_error Puppet::Error, /No valid installpath found in \/etc\/pkg\.conf and no source was set/
+    end
+
+    it "should install correctly when given a directory-unlike source" do
       source = '/whatever.pkg'
-      provider = subject.new(package(:source => source))
-      provider.expects(:pkgadd).with do |name|
-        ENV.should_not be_key 'PKG_PATH'
-        name == source
-      end
+      provider.resource[:source] = source
+      expect_pkgadd_with_source(source)
 
       provider.install
-      ENV.should_not be_key 'PKG_PATH'
     end
 
     it "should install correctly when given a directory-like source" do
-      ENV.should_not be_key 'PKG_PATH'
-
       source = '/whatever/'
-      provider = subject.new(package(:source => source))
-      provider.expects(:pkgadd).with do |name|
-        ENV.should be_key 'PKG_PATH'
-        ENV['PKG_PATH'].should == source
+      provider.resource[:source] = source
+      expect_pkgadd_with_env_and_name(source) do
+        provider.install
+      end
+    end
 
-        name == provider.resource[:name]
+    it "should install correctly when given a CDROM installpath" do
+      dir = '/mnt/cdrom/5.2/packages/amd64/'
+      expect_read_from_pkgconf(["installpath = #{dir}"])
+      expect_pkgadd_with_env_and_name(dir) do
+        provider.install
       end
-      provider.expects(:execpipe).with(%w{/bin/pkg_info -I bash}).yields('')
+    end
+
+    it "should install correctly when given a ftp mirror" do
+      url = 'ftp://your.ftp.mirror/pub/OpenBSD/5.2/packages/amd64/'
+      expect_read_from_pkgconf(["installpath = #{url}"])
+      expect_pkgadd_with_env_and_name(url) do
+        provider.install
+      end
+    end
+
+    it "should set the resource's source parameter" do
+      url = 'ftp://your.ftp.mirror/pub/OpenBSD/5.2/packages/amd64/'
+      expect_read_from_pkgconf(["installpath = #{url}"])
+      expect_pkgadd_with_env_and_name(url) do
+        provider.install
+      end
+
+      provider.resource[:source].should == url
+    end
+
+    it "should strip leading whitespace in installpath" do
+      dir = '/one/'
+      lines = ["# Notice the extra spaces after the ='s\n",
+               "installpath =   #{dir}\n",
+               "# And notice how each line ends with a newline\n"]
+
+      expect_read_from_pkgconf(lines)
+      expect_pkgadd_with_env_and_name(dir) do
+        provider.install
+      end
+    end
+
+    it "should not require spaces around the equals" do
+      dir = '/one/'
+      lines = ["installpath=#{dir}"]
+
+      expect_read_from_pkgconf(lines)
+      expect_pkgadd_with_env_and_name(dir) do
+        provider.install
+      end
+    end
+
+    it "should be case-insensitive" do
+      dir = '/one/'
+      lines = ["INSTALLPATH = #{dir}"]
+
+      expect_read_from_pkgconf(lines)
+      expect_pkgadd_with_env_and_name(dir) do
+        provider.install
+      end
+    end
+
+    it "should ignore unknown keywords" do
+      dir = '/one/'
+      lines = ["foo = bar\n",
+               "installpath = #{dir}\n"]
+
+      expect_read_from_pkgconf(lines)
+      expect_pkgadd_with_env_and_name(dir) do
+        provider.install
+      end
+    end
+
+    it "should preserve trailing spaces" do
+      dir = '/one/   '
+      lines = ["installpath = #{dir}"]
+
+      expect_read_from_pkgconf(lines)
+      expect_pkgadd_with_source(dir)
 
       provider.install
-      ENV.should_not be_key 'PKG_PATH'
+    end
+
+    %w{ installpath installpath= }.each do |line|
+      it "should reject '#{line}'" do
+        expect_read_from_pkgconf([line])
+        expect {
+          provider.install
+        }.to raise_error(Puppet::Error, /No valid installpath found in \/etc\/pkg\.conf and no source was set/)
+      end
     end
   end
 
   context "#get_version" do
     it "should return nil if execution fails" do
-      provider = subject.new(package)
       provider.expects(:execpipe).raises(Puppet::ExecutionFailure, 'wawawa')
       provider.get_version.should be_nil
     end
 
     it "should return the package version if in the output" do
       fixture = File.read(my_fixture('pkginfo.list'))
-      provider = subject.new(package(:name => 'bash'))
       provider.expects(:execpipe).with(%w{/bin/pkg_info -I bash}).yields(fixture)
       provider.get_version.should == '3.1.17'
     end
 
     it "should return the empty string if the package is not present" do
-      provider = subject.new(package(:name => 'zsh'))
+      provider.resource[:name] = 'zsh'
       provider.expects(:execpipe).with(%w{/bin/pkg_info -I zsh}).yields(StringIO.new(''))
       provider.get_version.should == ''
     end
@@ -102,13 +216,12 @@ describe provider_class do
   context "#query" do
     it "should return the installed version if present" do
       fixture = File.read(my_fixture('pkginfo.detail'))
-      provider = subject.new(package(:name => 'bash'))
       provider.expects(:pkginfo).with('bash').returns(fixture)
       provider.query.should == { :ensure => '3.1.17' }
     end
 
     it "should return nothing if not present" do
-      provider = subject.new(package(:name => 'zsh'))
+      provider.resource[:name] = 'zsh'
       provider.expects(:pkginfo).with('zsh').returns('')
       provider.query.should be_nil
     end