puppet 3.8.7 → 4.0.0

data/spec/unit/application/resource_spec.rb

@@ -8,13 +8,12 @@ describe Puppet::Application::Resource do
   before :each do
     @resource_app = Puppet::Application[:resource]
     Puppet::Util::Log.stubs(:newdestination)
-    Puppet::Resource.indirection.stubs(:terminus_class=)
   end
 
   describe "in preinit" do
     it "should init extra_params to empty array" do
       @resource_app.preinit
-      @resource_app.extra_params.should == []
+      expect(@resource_app.extra_params).to eq([])
     end
   end
 
@@ -26,11 +25,6 @@ describe Puppet::Application::Resource do
       end
     end
 
-    it "should set options[:host] to given host" do
-      @resource_app.handle_host(:whatever)
-      @resource_app.host.should == :whatever
-    end
-
     it "should load a display all types with types option" do
       type1 = stub_everything 'type1', :name => :type1
       type2 = stub_everything 'type2', :name => :type2
@@ -44,7 +38,7 @@ describe Puppet::Application::Resource do
       @resource_app.extra_params = [ :param1 ]
       @resource_app.handle_param("whatever")
 
-      @resource_app.extra_params.should == [ :param1, :whatever ]
+      expect(@resource_app.extra_params).to eq([ :param1, :whatever ])
     end
 
     it "should get a parameter in the printed data if extra_params are passed" do
@@ -74,14 +68,14 @@ describe Puppet::Application::Resource do
     it "should set log level to debug if --debug was passed" do
       @resource_app.options.stubs(:[]).with(:debug).returns(true)
       @resource_app.setup
-      Puppet::Log.level.should == :debug
+      expect(Puppet::Log.level).to eq(:debug)
     end
 
     it "should set log level to info if --verbose was passed" do
       @resource_app.options.stubs(:[]).with(:debug).returns(false)
       @resource_app.options.stubs(:[]).with(:verbose).returns(true)
       @resource_app.setup
-      Puppet::Log.level.should == :info
+      expect(Puppet::Log.level).to eq(:info)
     end
 
   end
@@ -95,89 +89,43 @@ describe Puppet::Application::Resource do
       @res = stub_everything "resource"
       @res.stubs(:prune_parameters).returns(@res)
       @report = stub_everything "report"
+
+      @resource_app.stubs(:puts)
+
+      Puppet::Resource.indirection.stubs(:find  ).never
+      Puppet::Resource.indirection.stubs(:search).never
+      Puppet::Resource.indirection.stubs(:save  ).never
     end
 
     it "should raise an error if no type is given" do
       @resource_app.command_line.stubs(:args).returns([])
-      lambda { @resource_app.main }.should raise_error(RuntimeError, "You must specify the type to display")
-    end
-
-    it "should raise an error when editing a remote host" do
-      @resource_app.options.stubs(:[]).with(:edit).returns(true)
-      @resource_app.host = 'host'
-
-      lambda { @resource_app.main }.should raise_error(RuntimeError, "You cannot edit a remote host")
+      expect { @resource_app.main }.to raise_error(RuntimeError, "You must specify the type to display")
     end
 
     it "should raise an error if the type is not found" do
       Puppet::Type.stubs(:type).returns(nil)
 
-      lambda { @resource_app.main }.should raise_error(RuntimeError, 'Could not find type mytype')
+      expect { @resource_app.main }.to raise_error(RuntimeError, 'Could not find type mytype')
     end
 
-    describe "with a host" do
-      before :each do
-        @resource_app.stubs(:puts)
-        @resource_app.host = 'host'
-
-        Puppet::Resource.indirection.stubs(:find  ).never
-        Puppet::Resource.indirection.stubs(:search).never
-        Puppet::Resource.indirection.stubs(:save  ).never
-      end
-
-      it "should search for resources" do
-        @resource_app.command_line.stubs(:args).returns(['type'])
-        Puppet::Resource.indirection.expects(:search).with('https://host:8139/production/resources/type/', {}).returns([])
-        @resource_app.main
-      end
-
-      it "should describe the given resource" do
-        @resource_app.command_line.stubs(:args).returns(['type', 'name'])
-        Puppet::Resource.indirection.expects(:find).with('https://host:8139/production/resources/type/name').returns(@res)
-        @resource_app.main
-      end
-
-      it "should add given parameters to the object" do
-        @resource_app.command_line.stubs(:args).returns(['type','name','param=temp'])
-
-        Puppet::Resource.indirection.expects(:save).
-          with(@res, 'https://host:8139/production/resources/type/name').
-          returns([@res, @report])
-        Puppet::Resource.expects(:new).with('type', 'name', :parameters => {'param' => 'temp'}).returns(@res)
-
-        @resource_app.main
-      end
+    it "should search for resources" do
+      Puppet::Resource.indirection.expects(:search).with('mytype/', {}).returns([])
+      @resource_app.main
     end
 
-    describe "without a host" do
-      before :each do
-        @resource_app.stubs(:puts)
-        @resource_app.host = nil
-
-        Puppet::Resource.indirection.stubs(:find  ).never
-        Puppet::Resource.indirection.stubs(:search).never
-        Puppet::Resource.indirection.stubs(:save  ).never
-      end
-
-      it "should search for resources" do
-        Puppet::Resource.indirection.expects(:search).with('mytype/', {}).returns([])
-        @resource_app.main
-      end
-
-      it "should describe the given resource" do
-        @resource_app.command_line.stubs(:args).returns(['type','name'])
-        Puppet::Resource.indirection.expects(:find).with('type/name').returns(@res)
-        @resource_app.main
-      end
+    it "should describe the given resource" do
+      @resource_app.command_line.stubs(:args).returns(['type','name'])
+      Puppet::Resource.indirection.expects(:find).with('type/name').returns(@res)
+      @resource_app.main
+    end
 
-      it "should add given parameters to the object" do
-        @resource_app.command_line.stubs(:args).returns(['type','name','param=temp'])
+    it "should add given parameters to the object" do
+      @resource_app.command_line.stubs(:args).returns(['type','name','param=temp'])
 
-        Puppet::Resource.indirection.expects(:save).with(@res, 'type/name').returns([@res, @report])
-        Puppet::Resource.expects(:new).with('type', 'name', :parameters => {'param' => 'temp'}).returns(@res)
+      Puppet::Resource.indirection.expects(:save).with(@res, 'type/name').returns([@res, @report])
+      Puppet::Resource.expects(:new).with('type', 'name', :parameters => {'param' => 'temp'}).returns(@res)
 
-        @resource_app.main
-      end
+      @resource_app.main
     end
   end
 
@@ -190,7 +138,7 @@ describe Puppet::Application::Resource do
     it "should raise an exception if no file specified" do
       @resource_app.command_line.stubs(:args).returns(['file'])
 
-      lambda { @resource_app.main }.should raise_error(RuntimeError, /Listing all file instances is not supported/)
+      expect { @resource_app.main }.to raise_error(RuntimeError, /Listing all file instances is not supported/)
     end
 
     it "should output a file resource when given a file path" do
@@ -200,7 +148,7 @@ describe Puppet::Application::Resource do
 
       @resource_app.command_line.stubs(:args).returns(['file', path])
       @resource_app.expects(:puts).with do |args|
-        args.should =~ /file \{ '#{Regexp.escape(path)}'/m
+        expect(args).to match(/file \{ '#{Regexp.escape(path)}'/m)
       end
 
       @resource_app.main

data/spec/unit/application_spec.rb

@@ -9,7 +9,6 @@ require 'timeout'
 describe Puppet::Application do
 
   before(:each) do
-    Puppet::Util::Instrumentation.stubs(:init)
     @app = Class.new(Puppet::Application).new
     @appclass = @app.class
 
@@ -26,8 +25,8 @@ describe Puppet::Application do
       args[0] = 'different_subcommand'
       args[1] = '--other-arg'
 
-      app.command_line.subcommand_name.should == 'subcommand'
-      app.command_line.args.should == ['--arg']
+      expect(app.command_line.subcommand_name).to eq('subcommand')
+      expect(app.command_line.args).to eq(['--arg'])
     end
   end
 
@@ -37,7 +36,7 @@ describe Puppet::Application do
       Puppet.expects(:err).with(regexp_matches(/missing required app default setting/))
       expect {
         @app.run
-      }.to exit_with 1
+      }.to exit_with(1)
     end
   end
 
@@ -48,7 +47,7 @@ describe Puppet::Application do
     end
 
     it "should find classes in the namespace" do
-      @klass.find("Agent").should == @klass::Agent
+      expect(@klass.find("Agent")).to eq(@klass::Agent)
     end
 
     it "should not find classes outside the namespace" do
@@ -69,8 +68,8 @@ describe Puppet::Application do
 
     it "#12114: should prevent File namespace collisions" do
       # have to require the file face once, then the second time around it would fail
-      @klass.find("File").should == Puppet::Application::File
-      @klass.find("File").should == Puppet::Application::File
+      expect(@klass.find("File")).to eq(Puppet::Application::File)
+      expect(@klass.find("File")).to eq(Puppet::Application::File)
     end
   end
 
@@ -79,30 +78,30 @@ describe Puppet::Application 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
+      expect(Puppet::Application.available_application_names).to match_array(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 }
+      expect(Puppet::Application.available_application_names).to match_array(%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 }
+      expect(Puppet::Application.available_application_names).to eq(%w{ foo })
     end
   end
 
   describe ".run_mode" do
     it "should default to user" do
-      @appclass.run_mode.name.should == :user
+      expect(@appclass.run_mode.name).to eq(:user)
     end
 
     it "should set and get a value" do
       @appclass.run_mode :agent
-      @appclass.run_mode.name.should == :agent
+      expect(@appclass.run_mode.name).to eq(:agent)
     end
   end
 
@@ -127,16 +126,16 @@ describe Puppet::Application do
       app = TestApp.new
       app.initialize_app_defaults
 
-      Puppet.run_mode.should be_master
+      expect(Puppet.run_mode).to be_master
     end
 
     it "should sadly and frighteningly allow run_mode to change at runtime via #run" do
       app = TestApp.new
       app.run
 
-      app.class.run_mode.name.should == :master
+      expect(app.class.run_mode.name).to eq(:master)
 
-      Puppet.run_mode.should be_master
+      expect(Puppet.run_mode).to be_master
     end
   end
 
@@ -152,23 +151,23 @@ describe Puppet::Application do
   end
 
   it "should have a run entry-point" do
-    @app.should respond_to(:run)
+    expect(@app).to respond_to(:run)
   end
 
   it "should have a read accessor to options" do
-    @app.should respond_to(:options)
+    expect(@app).to respond_to(:options)
   end
 
   it "should include a default setup method" do
-    @app.should respond_to(:setup)
+    expect(@app).to respond_to(:setup)
   end
 
   it "should include a default preinit method" do
-    @app.should respond_to(:preinit)
+    expect(@app).to respond_to(:preinit)
   end
 
   it "should include a default run_command method" do
-    @app.should respond_to(:run_command)
+    expect(@app).to respond_to(:run_command)
   end
 
   it "should invoke main as the default" do
@@ -176,22 +175,6 @@ describe Puppet::Application do
     @app.run_command
   end
 
-  it "should initialize the Puppet Instrumentation layer early in the life cycle" do
-    # Not proud of this, but the fact that we are stubbing init_app_defaults
-    #  below means that we will get errors if anyone tries to access any
-    #  settings that depend on app_defaults.  In general this whole test
-    #  seems to be testing too many implementation details rather than
-    #  functionality, but, hey.
-    Puppet[:route_file] = "/dev/null"
-
-    startup_sequence = sequence('startup')
-    @app.expects(:initialize_app_defaults).in_sequence(startup_sequence)
-    Puppet::Util::Instrumentation.expects(:init).in_sequence(startup_sequence)
-    @app.expects(:preinit).in_sequence(startup_sequence)
-
-    expect { @app.run }.to exit_with(1)
-  end
-
   describe 'when invoking clear!' do
     before :each do
       Puppet::Application.run_status = :stop_requested
@@ -199,23 +182,23 @@ describe Puppet::Application do
     end
 
     it 'should have nil run_status' do
-      Puppet::Application.run_status.should be_nil
+      expect(Puppet::Application.run_status).to be_nil
     end
 
     it 'should return false for restart_requested?' do
-      Puppet::Application.restart_requested?.should be_false
+      expect(Puppet::Application.restart_requested?).to be_falsey
     end
 
     it 'should return false for stop_requested?' do
-      Puppet::Application.stop_requested?.should be_false
+      expect(Puppet::Application.stop_requested?).to be_falsey
     end
 
     it 'should return false for interrupted?' do
-      Puppet::Application.interrupted?.should be_false
+      expect(Puppet::Application.interrupted?).to be_falsey
     end
 
     it 'should return true for clear?' do
-      Puppet::Application.clear?.should be_true
+      expect(Puppet::Application.clear?).to be_truthy
     end
   end
 
@@ -230,23 +213,23 @@ describe Puppet::Application do
     end
 
     it 'should have run_status of :stop_requested' do
-      Puppet::Application.run_status.should == :stop_requested
+      expect(Puppet::Application.run_status).to eq(:stop_requested)
     end
 
     it 'should return true for stop_requested?' do
-      Puppet::Application.stop_requested?.should be_true
+      expect(Puppet::Application.stop_requested?).to be_truthy
     end
 
     it 'should return false for restart_requested?' do
-      Puppet::Application.restart_requested?.should be_false
+      expect(Puppet::Application.restart_requested?).to be_falsey
     end
 
     it 'should return true for interrupted?' do
-      Puppet::Application.interrupted?.should be_true
+      expect(Puppet::Application.interrupted?).to be_truthy
     end
 
     it 'should return false for clear?' do
-      Puppet::Application.clear?.should be_false
+      expect(Puppet::Application.clear?).to be_falsey
     end
   end
 
@@ -261,23 +244,23 @@ describe Puppet::Application do
     end
 
     it 'should have run_status of :restart_requested' do
-      Puppet::Application.run_status.should == :restart_requested
+      expect(Puppet::Application.run_status).to eq(:restart_requested)
     end
 
     it 'should return true for restart_requested?' do
-      Puppet::Application.restart_requested?.should be_true
+      expect(Puppet::Application.restart_requested?).to be_truthy
     end
 
     it 'should return false for stop_requested?' do
-      Puppet::Application.stop_requested?.should be_false
+      expect(Puppet::Application.stop_requested?).to be_falsey
     end
 
     it 'should return true for interrupted?' do
-      Puppet::Application.interrupted?.should be_true
+      expect(Puppet::Application.interrupted?).to be_truthy
     end
 
     it 'should return false for clear?' do
-      Puppet::Application.clear?.should be_false
+      expect(Puppet::Application.clear?).to be_falsey
     end
   end
 
@@ -371,7 +354,7 @@ describe Puppet::Application do
 
     describe "when using --version" do
       it "should declare a version option" do
-        @app.should respond_to(:handle_version)
+        expect(@app).to respond_to(:handle_version)
       end
 
       it "should exit after printing the version" do
@@ -413,7 +396,7 @@ describe Puppet::Application do
         @app.options.stubs(:[]).with(level).returns(true)
         Puppet::Util::Log.stubs(:newdestination)
         @app.setup
-        Puppet::Util::Log.level.should == (level == :verbose ? :info : :debug)
+        expect(Puppet::Util::Log.level).to eq(level == :verbose ? :info : :debug)
       end
     end
 
@@ -425,6 +408,19 @@ describe Puppet::Application do
       @app.setup
     end
 
+    it "does not downgrade the loglevel when --verbose is specified" do
+      Puppet[:log_level] = :debug
+      @app.options.stubs(:[]).with(:verbose).returns(true)
+      @app.setup_logs
+
+      expect(Puppet::Util::Log.level).to eq(:debug)
+    end
+
+    it "allows the loglevel to be specified as an argument" do
+      @app.set_log_level(:debug => true)
+
+      expect(Puppet::Util::Log.level).to eq(:debug)
+    end
   end
 
   describe "when configuring routes" do
@@ -455,7 +451,7 @@ describe Puppet::Application do
 
       @app.configure_indirector_routes
 
-      Puppet::Node.indirection.terminus_class.should == 'exec'
+      expect(Puppet::Node.indirection.terminus_class).to eq('exec')
     end
 
     it "should not fail if the route file doesn't exist" do
@@ -545,21 +541,21 @@ describe Puppet::Application do
         @app.class.option("--test1","-t") do
         end
 
-        @app.should respond_to(:handle_test1)
+        expect(@app).to respond_to(:handle_test1)
       end
 
       it "should transpose in option name any '-' into '_'" do
         @app.class.option("--test-dashes-again","-t") do
         end
 
-        @app.should respond_to(:handle_test_dashes_again)
+        expect(@app).to respond_to(:handle_test_dashes_again)
       end
 
       it "should create a new method called handle_test2 with option(\"--[no-]test2\")" do
         @app.class.option("--[no-]test2","-t") do
         end
 
-        @app.should respond_to(:handle_test2)
+        expect(@app).to respond_to(:handle_test2)
       end
 
       describe "when a block is passed" do
@@ -638,7 +634,7 @@ describe Puppet::Application do
     it "should set the flag that a destination is set in the options hash" do
       Puppet::Util::Log.stubs(:newdestination).with(test_arg)
       @app.handle_logdest_arg(test_arg)
-      @app.options[:setdest].should be_true
+      expect(@app.options[:setdest]).to be_truthy
     end
   end
 

data/spec/unit/configurer/downloader_spec.rb

@@ -11,18 +11,18 @@ describe Puppet::Configurer::Downloader do
   let(:source) { 'puppet://puppet/plugins' }
 
   it "should require a name" do
-    lambda { Puppet::Configurer::Downloader.new }.should raise_error(ArgumentError)
+    expect { Puppet::Configurer::Downloader.new }.to raise_error(ArgumentError)
   end
 
   it "should require a path and a source at initialization" do
-    lambda { Puppet::Configurer::Downloader.new("name") }.should raise_error(ArgumentError)
+    expect { Puppet::Configurer::Downloader.new("name") }.to raise_error(ArgumentError)
   end
 
   it "should set the name, path and source appropriately" do
     dler = Puppet::Configurer::Downloader.new("facts", "path", "source")
-    dler.name.should == "facts"
-    dler.path.should == "path"
-    dler.source.should == "source"
+    expect(dler.name).to eq("facts")
+    expect(dler.path).to eq("path")
+    expect(dler.source).to eq("source")
   end
 
   def downloader(options = {})
@@ -55,19 +55,25 @@ describe Puppet::Configurer::Downloader do
     it "should always recurse" do
       file = generate_file_resource
 
-      expect(file[:recurse]).to be_true
+      expect(file[:recurse]).to be_truthy
+    end
+
+    it "should follow links by default" do
+      file = generate_file_resource
+
+      expect(file[:links]).to eq(:follow)
     end
 
     it "should always purge" do
       file = generate_file_resource
 
-      expect(file[:purge]).to be_true
+      expect(file[:purge]).to be_truthy
     end
 
     it "should never be in noop" do
       file = generate_file_resource
 
-      expect(file[:noop]).to be_false
+      expect(file[:noop]).to be_falsey
     end
 
     it "should set source_permissions to ignore by default" do
@@ -82,7 +88,7 @@ describe Puppet::Configurer::Downloader do
       expect(file[:source_permissions]).to eq(:use)
     end
 
-    describe "on POSIX", :as_platform => :posix do
+    describe "on POSIX", :if => Puppet.features.posix? do
       it "should always set the owner to the current UID" do
         Process.expects(:uid).returns 51
 
@@ -98,7 +104,7 @@ describe Puppet::Configurer::Downloader do
       end
     end
 
-    describe "on Windows", :as_platform => :windows do
+    describe "on Windows", :if => Puppet.features.microsoft_windows? do
       it "should omit the owner" do
         file = generate_file_resource(:path => 'C:/path')
 
@@ -115,13 +121,13 @@ describe Puppet::Configurer::Downloader do
     it "should always force the download" do
       file = generate_file_resource
 
-      expect(file[:force]).to be_true
+      expect(file[:force]).to be_truthy
     end
 
     it "should never back up when downloading" do
       file = generate_file_resource
 
-      expect(file[:backup]).to be_false
+      expect(file[:backup]).to be_falsey
     end
 
     it "should support providing an 'ignore' parameter" do
@@ -145,13 +151,13 @@ describe Puppet::Configurer::Downloader do
 
     it "should create a catalog and add the file to it" do
       catalog = @dler.catalog
-      catalog.resources.size.should == 1
-      catalog.resources.first.class.should == Puppet::Type::File
-      catalog.resources.first.name.should == @path
+      expect(catalog.resources.size).to eq(1)
+      expect(catalog.resources.first.class).to eq(Puppet::Type::File)
+      expect(catalog.resources.first.name).to eq(@path)
     end
 
     it "should specify that it is not managing a host catalog" do
-      @dler.catalog.host_config.should == false
+      expect(@dler.catalog.host_config).to eq(false)
     end
 
   end
@@ -169,7 +175,7 @@ describe Puppet::Configurer::Downloader do
       Puppet[:tags] = 'maytag'
       @dler.evaluate
 
-      Puppet::FileSystem.exist?(@dl_name).should be_true
+      expect(Puppet::FileSystem.exist?(@dl_name)).to be_truthy
     end
 
     it "should log that it is downloading" do
@@ -190,7 +196,7 @@ describe Puppet::Configurer::Downloader do
 
       trans.expects(:changed?).returns([resource])
 
-      @dler.evaluate.should == %w{/changed/file}
+      expect(@dler.evaluate).to eq(%w{/changed/file})
     end
 
     it "should yield the resources if a block is given" do
@@ -207,7 +213,7 @@ describe Puppet::Configurer::Downloader do
 
       yielded = nil
       @dler.evaluate { |r| yielded = r }
-      yielded.should == resource
+      expect(yielded).to eq(resource)
     end
 
     it "should catch and log exceptions" do
@@ -216,7 +222,7 @@ describe Puppet::Configurer::Downloader do
       # that it is possible to stub for the purpose of generating a puppet error
       Puppet::Resource::Catalog.any_instance.stubs(:apply).raises(Puppet::Error, "testing")
 
-      lambda { @dler.evaluate }.should_not raise_error
+      expect { @dler.evaluate }.not_to raise_error
     end
   end
 end