puppet 3.0.2 → 3.1.0.rc1

data/spec/unit/application/agent_spec.rb

@@ -455,7 +455,6 @@ describe Puppet::Application::Agent do
 
     describe "when setting up listen" do
       before :each do
-        Puppet[:authconfig] = 'auth'
         FileTest.stubs(:exists?).with('auth').returns(true)
         File.stubs(:exist?).returns(true)
         @puppetd.options.stubs(:[]).with(:serve).returns([])

data/spec/unit/application/apply_spec.rb

@@ -208,7 +208,7 @@ describe Puppet::Application::Apply do
       it "should raise an error if we can't find the node" do
         Puppet::Node.indirection.expects(:find).returns(nil)
 
-        lambda { @apply.main }.should raise_error
+        lambda { @apply.main }.should raise_error(RuntimeError, /Could not find node/)
       end
 
       it "should load custom classes if loadclasses" do

data/spec/unit/application/face_base_spec.rb

@@ -58,9 +58,10 @@ describe Puppet::Application::FaceBase do
 
     it "should stop if the first thing found is not an action" do
       app.command_line.stubs(:args).returns %w{banana count_args}
+
       expect { app.run }.to exit_with 1
-      @logs.first.should_not be_nil
-      @logs.first.message.should =~ /has no 'banana' action/
+
+      @logs.map(&:message).should == ["'basetest' has no 'banana' action.  See `puppet help basetest`."]
     end
 
     it "should use the default action if not given any arguments" do
@@ -161,12 +162,18 @@ describe Puppet::Application::FaceBase do
 
     it "does not skip when a puppet global setting is given as one item" do
       app.command_line.stubs(:args).returns %w{--confdir=/tmp/puppet foo}
-      expect { app.preinit; app.parse_options }.not_to raise_error
+      app.preinit
+      app.parse_options
+      app.action.name.should == :foo
+      app.options.should == {}
     end
 
     it "does not skip when a puppet global setting is given as two items" do
       app.command_line.stubs(:args).returns %w{--confdir /tmp/puppet foo}
-      expect { app.preinit; app.parse_options }.not_to raise_error
+      app.preinit
+      app.parse_options
+      app.action.name.should == :foo
+      app.options.should == {}
     end
 
     { "boolean options before" => %w{--trace foo},

data/spec/unit/application/indirection_base_spec.rb

@@ -1,5 +1,6 @@
 #! /usr/bin/env ruby
 require 'spec_helper'
+require 'puppet/util/command_line'
 require 'puppet/application/indirection_base'
 require 'puppet/indirector/face'
 
@@ -20,8 +21,6 @@ Puppet::Face.register(face)
 ########################################################################
 
 describe Puppet::Application::IndirectionBase do
-  subject { Puppet::Application::TestIndirection.new }
-
   it "should accept a terminus command line option" do
     # It would be nice not to have to stub this, but whatever... writing an
     # entire indirection stack would cause us more grief. --daniel 2011-03-31
@@ -35,14 +34,11 @@ describe Puppet::Application::IndirectionBase do
     Puppet::Indirector::Indirection.expects(:instance).
       with(:test_indirection).returns(terminus)
 
-    subject.command_line.instance_variable_set('@args', %w{--terminus foo save bar})
-
-    # Not a very nice thing. :(
-    $stderr.stubs(:puts)
-    Puppet.stubs(:err)
+    command_line = Puppet::Util::CommandLine.new("puppet", %w{test_indirection --terminus foo save bar})
+    application = Puppet::Application::TestIndirection.new(command_line)
 
     expect {
-      subject.run
+      application.run
     }.to exit_with 0
   end
 end

data/spec/unit/application/kick_spec.rb

@@ -14,8 +14,11 @@ describe Puppet::Application::Kick, :if => Puppet.features.posix? do
 
   describe ".new" do
     it "should take a command-line object as an argument" do
-      command_line = stub_everything "command_line"
-      lambda{ Puppet::Application::Kick.new( command_line ) }.should_not raise_error
+      command_line = Puppet::Util::CommandLine.new("puppet", ['kick', 'myhost'])
+      app = Puppet::Application::Kick.new(command_line)
+
+      app.command_line.subcommand_name.should == "kick"
+      app.command_line.args.should == ['myhost']
     end
   end
 

data/spec/unit/application/master_spec.rb

@@ -242,12 +242,6 @@ describe Puppet::Application::Master, :unless => Puppet.features.microsoft_windo
         Puppet[:manifest] = "site.pp"
         Puppet.stubs(:err)
         @master.stubs(:jj)
-        Puppet.features.stubs(:pson?).returns true
-      end
-
-      it "should fail if pson isn't available" do
-        Puppet.features.expects(:pson?).returns false
-        lambda { @master.compile }.should raise_error
       end
 
       it "should compile a catalog for the specified node" do

data/spec/unit/application_spec.rb

@@ -17,6 +17,20 @@ describe Puppet::Application do
 
   end
 
+  describe "application commandline" do
+    it "should not pick up changes to the array of arguments" do
+      args = %w{subcommand --arg}
+      command_line = Puppet::Util::CommandLine.new('puppet', args)
+      app = Puppet::Application.new(command_line)
+
+      args[0] = 'different_subcommand'
+      args[1] = '--other-arg'
+
+      app.command_line.subcommand_name.should == 'subcommand'
+      app.command_line.args.should == ['--arg']
+    end
+  end
+
   describe "application defaults" do
     it "should fail if required app default values are missing" do
       @app.stubs(:app_defaults).returns({ :foo => 'bar' })
@@ -48,7 +62,9 @@ describe Puppet::Application do
           value =~ /no such file to load|cannot load such file/
       end
 
-      expect { @klass.find("ThisShallNeverEverEverExist") }.to raise_error(LoadError)
+      expect {
+        @klass.find("ThisShallNeverEverEverExist")
+      }.to raise_error(LoadError)
     end
 
     it "#12114: should prevent File namespace collisions" do
@@ -58,6 +74,27 @@ describe Puppet::Application do
     end
   end
 
+  describe "#available_application_names" do
+    it 'should be able to find available application names' do
+      apps =  %w{describe filebucket kick queue resource agent cert apply doc master}
+      Puppet::Util::Autoload.expects(:files_to_load).returns(apps)
+
+      Puppet::Application.available_application_names.should =~ apps
+    end
+
+    it 'should find applications from multiple paths' do
+      Puppet::Util::Autoload.expects(:files_to_load).with('puppet/application').returns(%w{ /a/foo.rb /b/bar.rb })
+
+      Puppet::Application.available_application_names.should =~ %w{ foo bar }
+    end
+
+    it 'should return unique application names' do
+      Puppet::Util::Autoload.expects(:files_to_load).with('puppet/application').returns(%w{ /a/foo.rb /b/foo.rb })
+
+      Puppet::Application.available_application_names.should == %w{ foo }
+    end
+  end
+
   describe ".run_mode" do
     it "should default to user" do
       @appclass.run_mode.name.should == :user
@@ -103,19 +140,6 @@ describe Puppet::Application do
     end
   end
 
-
-  it "it should not allow initialize_app_defaults to be called multiple times" do
-    app = Puppet::Application.new
-    expect {
-      app.initialize_app_defaults
-    }.to_not raise_error
-
-    expect {
-      app.initialize_app_defaults
-    }.to raise_error
-  end
-
-
   it "should explode when an invalid run mode is set at runtime, for great victory" do
     expect {
       class InvalidRunModeTestApp < Puppet::Application

data/spec/unit/dsl/actions_spec.rb

@@ -0,0 +1,402 @@
+require 'spec_helper'
+require 'puppet_spec/dsl'
+
+require 'puppet/dsl/actions'
+
+include PuppetSpec::DSL
+
+describe Puppet::DSL::Actions do
+  prepare_compiler_and_scope_for_evaluation
+  subject { Puppet::DSL::Actions.new :undefined }
+
+  describe "#type_reference" do
+    it "returns a type reference object" do
+      evaluate_in_scope do
+        subject.type_reference("file").should be_a Puppet::DSL::TypeReference
+      end
+    end
+
+    it "returns a type reference for a given type" do
+      evaluate_in_scope do
+        subject.type_reference("file").type_name.should == "File"
+      end
+    end
+  end
+
+  describe "#is_resource_type?" do
+
+    it "should return true when type is a class" do
+      evaluate_in_scope do
+        subject.is_resource_type?(:class).should be true
+      end
+    end
+
+    it "should return true when type is a node" do
+      evaluate_in_scope do
+        subject.is_resource_type?(:node).should be true
+      end
+    end
+
+    it "should return true when type is a builtin type" do
+      evaluate_in_scope do
+        subject.is_resource_type?(:file).should be true
+      end
+    end
+
+    it "should return true when type is defined in manifests" do
+      evaluate_in_context { define(:foo) {} }
+      evaluate_in_scope do
+        subject.is_resource_type?(:foo).should be true
+      end
+    end
+
+    it "should return false otherwise" do
+      evaluate_in_scope do
+        subject.is_resource_type?(:asdasdasfasf).should be false
+      end
+    end
+
+  end
+
+  describe "#is_function?" do
+    it "should return true when a puppet function exists" do
+      subject.is_function?("notice").should be true
+    end
+
+    it "should return false otherwise" do
+      subject.is_function?("asdfasdf").should be false
+    end
+  end
+
+  describe "#get_resource" do
+
+    it "should return the reference if it's already a resource" do
+      ref = Puppet::Resource.new "foo", "bar"
+      subject.send(:get_resource, ref).should == ref
+    end
+
+    it "should get a resource from Puppet::DSL::ResourceReference" do
+      res = evaluate_in_context { file "foo" }.first
+      ref = evaluate_in_context { type("file")["foo"] }
+      subject.send(:get_resource, ref).should == res
+    end
+
+    it "should get a resource from a string" do
+      res = evaluate_in_context { file "foo" }.first
+      evaluate_in_scope { subject.send(:get_resource, "File[foo]").should == res }
+    end
+
+    it "should return a string when the string reference doesn't exist" do
+      reference = "File[foo]"
+      evaluate_in_scope { subject.send(:get_resource, reference).should == reference }
+    end
+
+    it "should stringify the parameter when resource can't be found" do
+      evaluate_in_scope { subject.send(:get_resource, 3).should == "3" }
+    end
+  end
+
+  describe "#params" do
+    it "returns current scope" do
+      evaluate_in_scope do
+        subject.params.should == Puppet::DSL::Parser.current_scope
+      end
+    end
+
+  end
+
+  describe "#create_node" do
+    it "raises NoMethodError when called from invalid nesting" do
+      lambda do
+        subject.create_node "foo", {}, 1 do
+        end
+      end.should raise_error NoMethodError
+    end
+
+    it "raises ArgumentError when code is nil" do
+      lambda do
+        subject.create_node "foo", {}, nil, 0
+      end.should raise_error ArgumentError
+    end
+
+    it "creates a new puppet node" do
+      evaluate_in_scope do
+        subject.create_node("foo", {}, 0) {}.tap do |r|
+          r.type.should == :node
+          r.name.should == "foo"
+        end.should be_a Puppet::Resource::Type
+      end
+    end
+
+    it "allows to pass a regex instead of name" do
+      evaluate_in_scope do
+        subject.create_node(/foo/, {}, 0) {}.tap do |r|
+          r.name_is_regex?.should be true
+        end.should be_a Puppet::Resource::Type
+      end
+    end
+
+    it "sets options for puppet node" do
+      evaluate_in_scope do
+        subject.create_node("foo", {:inherits => "bar"}, 0) {}.parent.should == "bar"
+      end
+    end
+
+    it "adds the node to known resource types" do
+      evaluate_in_scope do
+        resource_types = mock
+        resource_types.expects(:add_node).with {|n| n.type == :node }
+        resource_types.stubs(:hostclass).returns nil
+        Puppet::DSL::Parser.stubs(:known_resource_types).returns resource_types
+
+        subject.create_node "foo", {}, 0 do
+        end
+      end
+    end
+
+    it "sets ruby code for the node" do
+      block   = proc {}
+      context = mock "Context"
+      Puppet::DSL::Context.expects(:new).with {|code, _| code == block}.returns context
+      evaluate_in_scope do
+        subject.create_node("foo", {}, 0, &block).ruby_code.should include context
+      end
+    end
+  end
+
+  describe "#create_hostclass" do
+    it "raises NoMethodError when called from invalid nesting" do
+      lambda do
+        subject.create_hostclass :foo, {}, 1 do
+        end
+      end.should raise_error NoMethodError
+    end
+
+    it "raises ArgumentError when code is nil" do
+      lambda do
+        subject.create_hostclass :foo, {}, nil, 0
+      end.should raise_error ArgumentError
+    end
+
+    it "creates a new puppet hostclass" do
+      evaluate_in_scope do
+        subject.create_hostclass(:foo, {}, 0) {}.tap do |r|
+          r.type.should == :hostclass
+          r.name.should == "foo"
+        end.should be_a Puppet::Resource::Type
+      end
+    end
+
+    it "sets options for puppet hostclass" do
+      evaluate_in_scope do
+        subject.create_hostclass(:foo, {:inherits => :bar, :arguments => {:myparam => 3}}, 0) {}.tap do |r|
+          r.parent.should    == "bar"
+          r.arguments.should == {"myparam" => 3}
+        end
+      end
+    end
+
+    it "adds the hostclass to resource type collection" do
+      evaluate_in_scope do
+        resource_types = mock
+        resource_types.expects(:add_hostclass).with {|n| n.type == :hostclass }
+        Puppet::DSL::Parser.stubs(:known_resource_types).returns resource_types
+
+        subject.create_hostclass :foo, {}, 0 do
+        end
+      end
+    end
+
+    it "sets ruby code for hostclass" do
+      block   = proc {}
+      context = mock "Context"
+      Puppet::DSL::Context.expects(:new).with {|code, _| code == block}.returns context
+      evaluate_in_scope do
+        subject.create_hostclass(:foo, {}, 0, &block).ruby_code.should include context
+      end
+    end
+  end
+
+  describe "#create_definition" do
+    it "raises NoMethodError when called from invalid nesting" do
+      lambda do
+        subject.create_definition :foo, {}, 1 do
+        end
+      end.should raise_error NoMethodError
+    end
+
+    it "raises ArgumentError when code is nil" do
+      lambda do
+        subject.create_definition :foo, {}, nil, 0
+      end.should raise_error ArgumentError
+    end
+
+    it "creates new definition" do
+      evaluate_in_scope do
+        subject.create_definition(:foo, {}, 0) {}.tap do |r|
+          r.should be_a Puppet::Resource::Type
+          r.type.should == :definition
+          r.name.should == "foo"
+        end
+      end
+
+    end
+
+    it "set options for the definition" do
+      evaluate_in_scope do
+        subject.create_definition(:foo, {:arguments => {:param => 42}}, 0) {}.arguments.should == {"param" => 42}
+      end
+    end
+
+    it "adds definition to known resource types" do
+      evaluate_in_scope do
+        resource_types = mock
+        resource_types.expects(:add_definition).with {|n| n.type == :definition }
+        Puppet::DSL::Parser.stubs(:known_resource_types).returns resource_types
+
+        subject.create_definition :foo, {}, 0 do
+        end
+      end
+
+    end
+
+    it "sets ruby code for definition" do
+      block   = proc {}
+      context = mock "Context"
+      Puppet::DSL::Context.expects(:new).with {|code, _| code == block}.returns context
+      evaluate_in_scope do
+        subject.create_definition(:foo, {}, 0, &block).ruby_code.should include context
+      end
+    end
+  end
+
+  describe "#create_resource" do
+    it "raises NoMethodError when importing" do
+      scope = mock
+      scope.stubs(:nil?).returns true
+      scope.stubs(:known_resource_types).returns nil
+      evaluate_in_scope :scope => scope do
+        lambda { subject.create_resource :notify, "message", {}, nil }.should raise_error NoMethodError
+      end
+    end
+
+    it "creates the resource when the type exists" do
+      scope.compiler.expects(:add_resource).with { |s, r| s == scope and r.is_a? Puppet::Parser::Resource }
+
+      evaluate_in_scope do
+        subject.create_resource :notify, "foo", {}, nil
+      end
+    end
+
+    it "returns an array of created resources" do
+      evaluate_in_scope do
+        subject.create_resource(:notify, ["foo", "bar"], {}, nil).map(&:title).should == ["foo", "bar"]
+      end
+    end
+
+    it "sets the passed options to it" do
+      evaluate_in_scope do
+        resource = subject.create_resource(:file, "/tmp/test", {:ensure => :present, :mode => "0666"}, nil).first
+        resource[:ensure].should == "present"
+        resource[:mode].should   == "0666"
+      end
+    end
+
+    it "evaluates options passed in block" do
+      evaluate_in_scope do
+        block = proc do |resource|
+          resource.ensure = :present
+          resource.mode   = "0666"
+        end
+
+        resource = subject.create_resource(:file, "/tmp/foo", {}, block).first
+        resource[:ensure].should == "present"
+        resource[:mode].should   == "0666"
+      end
+    end
+
+    context "when virtualizing" do
+      it "creates virtual resource when called from virtual scope" do
+        evaluate_in_scope do
+          subject.virtualizing = true
+
+          subject.create_resource(:notify, "foo", {}, nil).first.virtual.should be true
+        end
+      end
+
+      it "creates virtual resource when passed virtual option" do
+        evaluate_in_scope do
+          subject.create_resource(:notify, "foo", {:virtual => true}, nil).first.virtual.should be true
+        end
+      end
+    end
+
+    context "when exporting" do
+      it "creates exported resource when called from exporting scope" do
+        evaluate_in_scope do
+          subject.exporting = true
+
+          subject.create_resource(:notify, "foo", {}, nil).first.exported.should be true
+        end
+      end
+
+      it "creates exported resource when passed export option" do
+        evaluate_in_scope do
+          subject.create_resource(:notify, "foo", {:export => true}, nil).first.exported.should be true
+        end
+      end
+    end
+  end
+
+  describe "#call_function" do
+    it "raises NoMethodError when importing" do
+      scope = mock
+      scope.stubs(:nil?).returns true
+      scope.stubs(:known_resource_types).returns nil
+      evaluate_in_scope :scope => scope do
+        lambda { subject.call_function "notice", [] }.should raise_error NoMethodError
+      end
+    end
+
+    it "calls the function and passes the array of arguments when it exists" do
+      scope.expects(:notice).with(["foo", "bar"])
+      evaluate_in_scope do
+        subject.call_function "notice", ["foo", "bar"]
+      end
+    end
+  end
+
+  describe "#validate_options" do
+    let(:attributes) { {:foo => "bar"} }
+
+    it "raises ArgumentError when invalid options are passed" do
+      lambda do
+        subject.validate_options [:asdf], attributes
+      end.should raise_error ArgumentError
+    end
+
+    it "does nothing when all attributes are valid" do
+      lambda do
+        subject.validate_options [:foo], attributes
+      end.should_not raise_error ArgumentError
+    end
+  end
+
+  it "allows to read and set exporting setting" do
+    subject.exporting?.should be false
+    subject.exporting = true
+    subject.exporting?.should be true
+    subject.exporting = false
+    subject.exporting?.should be false
+  end
+
+  it "allows to read and set virtualizing setting" do
+    subject.virtualizing?.should be false
+    subject.virtualizing = true
+    subject.virtualizing?.should be true
+    subject.virtualizing = false
+    subject.virtualizing?.should be false
+  end
+
+end
+