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

data/spec/unit/agent/disabler_spec.rb

@@ -20,7 +20,7 @@ describe Puppet::Agent::Disabler do
   ##  the tests. --cprice 2012-04-16
 
   it "should use an JsonLockfile instance as its disable_lockfile" do
-    @disabler.send(:disable_lockfile).should be_instance_of(Puppet::Util::JsonLockfile)
+    expect(@disabler.send(:disable_lockfile)).to be_instance_of(Puppet::Util::JsonLockfile)
   end
 
   it "should use puppet's :agent_disabled_lockfile' setting to determine its lockfile path" do
@@ -33,7 +33,7 @@ describe Puppet::Agent::Disabler do
   end
 
   it "should reuse the same lock file each time" do
-    @disabler.send(:disable_lockfile).should equal(@disabler.send(:disable_lockfile))
+    expect(@disabler.send(:disable_lockfile)).to equal(@disabler.send(:disable_lockfile))
   end
 
   it "should lock the file when disabled" do
@@ -59,6 +59,6 @@ describe Puppet::Agent::Disabler do
 
     msg = "I'm busy, go away"
     @disabler.disable(msg)
-    @disabler.disable_message.should == msg
+    expect(@disabler.disable_message).to eq(msg)
   end
 end

data/spec/unit/agent/locker_spec.rb

@@ -20,7 +20,7 @@ describe Puppet::Agent::Locker do
   ##  the tests.   --cprice 2012-04-16
 
   it "should use a Pidlock instance as its lockfile" do
-    @locker.send(:lockfile).should be_instance_of(Puppet::Util::Pidlock)
+    expect(@locker.send(:lockfile)).to be_instance_of(Puppet::Util::Pidlock)
   end
 
   it "should use puppet's agent_catalog_run_lockfile' setting to determine its lockfile path" do
@@ -35,11 +35,11 @@ describe Puppet::Agent::Locker do
   it "#lockfile_path provides the path to the lockfile" do
     lockfile = File.expand_path("/my/lock")
     Puppet[:agent_catalog_run_lockfile] = lockfile
-    @locker.lockfile_path.should == File.expand_path("/my/lock")
+    expect(@locker.lockfile_path).to eq(File.expand_path("/my/lock"))
   end
 
   it "should reuse the same lock file each time" do
-    @locker.send(:lockfile).should equal(@locker.send(:lockfile))
+    expect(@locker.send(:lockfile)).to equal(@locker.send(:lockfile))
   end
 
   it "should have a method that yields when a lock is attained" do
@@ -49,19 +49,19 @@ describe Puppet::Agent::Locker do
     @locker.lock do
       yielded = true
     end
-    yielded.should be_true
+    expect(yielded).to be_truthy
   end
 
   it "should return the block result when the lock method successfully locked" do
     @locker.send(:lockfile).expects(:lock).returns true
 
-    @locker.lock { :result }.should == :result
+    expect(@locker.lock { :result }).to eq(:result)
   end
 
   it "should return nil when the lock method does not receive the lock" do
     @locker.send(:lockfile).expects(:lock).returns false
 
-    @locker.lock {}.should be_nil
+    expect(@locker.lock {}).to be_nil
   end
 
   it "should not yield when the lock method does not receive the lock" do
@@ -69,7 +69,7 @@ describe Puppet::Agent::Locker do
 
     yielded = false
     @locker.lock { yielded = true }
-    yielded.should be_false
+    expect(yielded).to be_falsey
   end
 
   it "should not unlock when a lock was not received" do
@@ -90,11 +90,11 @@ describe Puppet::Agent::Locker do
     @locker.send(:lockfile).stubs(:lock).returns true
     @locker.send(:lockfile).expects(:unlock)
 
-    lambda { @locker.lock { raise "foo" } }.should raise_error(RuntimeError)
+    expect { @locker.lock { raise "foo" } }.to raise_error(RuntimeError)
   end
 
   it "should be considered running if the lockfile is locked" do
     @locker.send(:lockfile).expects(:locked?).returns true
-    @locker.should be_running
+    expect(@locker).to be_running
   end
 end

data/spec/unit/agent_spec.rb

@@ -45,11 +45,11 @@ describe Puppet::Agent do
   end
 
   it "should set its client class at initialization" do
-    Puppet::Agent.new("foo", false).client_class.should == "foo"
+    expect(Puppet::Agent.new("foo", false).client_class).to eq("foo")
   end
 
   it "should include the Locker module" do
-    Puppet::Agent.ancestors.should be_include(Puppet::Agent::Locker)
+    expect(Puppet::Agent.ancestors).to be_include(Puppet::Agent::Locker)
   end
 
   it "should create an instance of its client class and run it when asked to run" do
@@ -69,7 +69,7 @@ describe Puppet::Agent do
     @agent.expects(:lockfile).returns(lockfile)
     lockfile.expects(:locked?).returns true
 
-    @agent.should be_running
+    expect(@agent).to be_running
   end
 
   describe "when being run" do
@@ -149,7 +149,7 @@ describe Puppet::Agent do
       client = AgentTestClient.new
       AgentTestClient.expects(:new).returns client
 
-      client.expects(:run).with { @agent.client.should equal(client); true }
+      client.expects(:run).with { expect(@agent.client).to equal(client); true }
       @agent.run
     end
 
@@ -166,10 +166,10 @@ describe Puppet::Agent do
       AgentTestClient.expects(:new).returns client
 
       @agent.expects(:lock).returns(:result)
-      @agent.run.should == :result
+      expect(@agent.run).to eq(:result)
     end
 
-    describe "when should_fork is true", :as_platform => :posix do
+    describe "when should_fork is true", :if => Puppet.features.posix? do
       before do
         @agent = Puppet::Agent.new(AgentTestClient, true)
 
@@ -204,17 +204,17 @@ describe Puppet::Agent do
 
       it "should re-raise exit happening in the child" do
         Process.stubs(:waitpid2).returns [123, (stub 'process::status', :exitstatus => -1)]
-        lambda { @agent.run }.should raise_error(SystemExit)
+        expect { @agent.run }.to raise_error(SystemExit)
       end
 
       it "should re-raise NoMoreMemory happening in the child" do
         Process.stubs(:waitpid2).returns [123, (stub 'process::status', :exitstatus => -2)]
-        lambda { @agent.run }.should raise_error(NoMemoryError)
+        expect { @agent.run }.to raise_error(NoMemoryError)
       end
 
       it "should return the child exit code" do
         Process.stubs(:waitpid2).returns [123, (stub 'process::status', :exitstatus => 777)]
-        @agent.run.should == 777
+        expect(@agent.run).to eq(777)
       end
 
       it "should return the block exit code as the child exit code" do
@@ -226,10 +226,10 @@ describe Puppet::Agent do
       end
     end
 
-    describe "on Windows", :as_platform => :windows do
+    describe "on Windows", :if => Puppet.features.microsoft_windows? do
       it "should never fork" do
         agent = Puppet::Agent.new(AgentTestClient, true)
-        expect(agent.should_fork).to be_false
+        expect(agent.should_fork).to be_falsey
       end
     end
   end
@@ -268,7 +268,7 @@ describe Puppet::Agent do
     it "should mark that it has splayed" do
       @agent.stubs(:sleep)
       @agent.splay
-      @agent.should be_splayed
+      expect(@agent).to be_splayed
     end
   end
 
@@ -282,11 +282,11 @@ describe Puppet::Agent do
       end
 
       it 'should be false for :stopping?' do
-        @agent.stopping?.should be_false
+        expect(@agent.stopping?).to be_falsey
       end
 
       it 'should be false for :needing_restart?' do
-        @agent.needing_restart?.should be_false
+        expect(@agent.needing_restart?).to be_falsey
       end
     end
 
@@ -299,11 +299,11 @@ describe Puppet::Agent do
       end
 
       it 'should be true for :stopping?' do
-        @agent.stopping?.should be_true
+        expect(@agent.stopping?).to be_truthy
       end
 
       it 'should be false for :needing_restart?' do
-        @agent.needing_restart?.should be_false
+        expect(@agent.needing_restart?).to be_falsey
       end
     end
 
@@ -316,11 +316,11 @@ describe Puppet::Agent do
       end
 
       it 'should be false for :stopping?' do
-        @agent.stopping?.should be_false
+        expect(@agent.stopping?).to be_falsey
       end
 
       it 'should be true for :needing_restart?' do
-        @agent.needing_restart?.should be_true
+        expect(@agent.needing_restart?).to be_truthy
       end
     end
   end

data/spec/unit/application/agent_spec.rb

@@ -38,23 +38,23 @@ describe Puppet::Application::Agent do
   end
 
   it "should operate in agent run_mode" do
-    @puppetd.class.run_mode.name.should == :agent
+    expect(@puppetd.class.run_mode.name).to eq(:agent)
   end
 
   it "should declare a main command" do
-    @puppetd.should respond_to(:main)
+    expect(@puppetd).to respond_to(:main)
   end
 
   it "should declare a onetime command" do
-    @puppetd.should respond_to(:onetime)
+    expect(@puppetd).to respond_to(:onetime)
   end
 
   it "should declare a fingerprint command" do
-    @puppetd.should respond_to(:fingerprint)
+    expect(@puppetd).to respond_to(:fingerprint)
   end
 
   it "should declare a preinit block" do
-    @puppetd.should respond_to(:preinit)
+    expect(@puppetd).to respond_to(:preinit)
   end
 
   describe "in preinit" do
@@ -64,40 +64,34 @@ describe Puppet::Application::Agent do
       @puppetd.preinit
     end
 
-    it "should init client to true" do
-      @puppetd.preinit
-
-      @puppetd.options[:client].should be_true
-    end
-
     it "should init fqdn to nil" do
       @puppetd.preinit
 
-      @puppetd.options[:fqdn].should be_nil
+      expect(@puppetd.options[:fqdn]).to be_nil
     end
 
     it "should init serve to []" do
       @puppetd.preinit
 
-      @puppetd.options[:serve].should == []
+      expect(@puppetd.options[:serve]).to eq([])
     end
 
     it "should use SHA256 as default digest algorithm" do
       @puppetd.preinit
 
-      @puppetd.options[:digest].should == 'SHA256'
+      expect(@puppetd.options[:digest]).to eq('SHA256')
     end
 
     it "should not fingerprint by default" do
       @puppetd.preinit
 
-      @puppetd.options[:fingerprint].should be_false
+      expect(@puppetd.options[:fingerprint]).to be_falsey
     end
 
     it "should init waitforcert to nil" do
       @puppetd.preinit
 
-      @puppetd.options[:waitforcert].should be_nil
+      expect(@puppetd.options[:waitforcert]).to be_nil
     end
   end
 
@@ -108,13 +102,13 @@ describe Puppet::Application::Agent do
 
     [:enable, :debug, :fqdn, :test, :verbose, :digest].each do |option|
       it "should declare handle_#{option} method" do
-        @puppetd.should respond_to("handle_#{option}".to_sym)
+        expect(@puppetd).to respond_to("handle_#{option}".to_sym)
       end
 
       it "should store argument value when calling handle_#{option}" do
         @puppetd.send("handle_#{option}".to_sym, 'arg')
 
-        @puppetd.options[option].should == 'arg'
+        expect(@puppetd.options[option]).to eq('arg')
       end
     end
 
@@ -122,22 +116,16 @@ describe Puppet::Application::Agent do
       it "should set disable to true" do
         @puppetd.handle_disable('')
 
-        @puppetd.options[:disable].should == true
+        expect(@puppetd.options[:disable]).to eq(true)
       end
 
       it "should store disable message" do
         @puppetd.handle_disable('message')
 
-        @puppetd.options[:disable_message].should == 'message'
+        expect(@puppetd.options[:disable_message]).to eq('message')
       end
     end
 
-    it "should set client to false with --no-client" do
-      @puppetd.handle_no_client(nil)
-
-      @puppetd.options[:client].should be_false
-    end
-
     it "should set waitforcert to 0 with --onetime and if --waitforcert wasn't given" do
       @agent.stubs(:run).returns(2)
       Puppet[:onetime] = true
@@ -179,7 +167,7 @@ describe Puppet::Application::Agent do
     it "should put the setdest options to true" do
       @puppetd.handle_logdest("console")
 
-      @puppetd.options[:setdest].should == true
+      expect(@puppetd.options[:setdest]).to eq(true)
     end
 
     it "should parse the log destination from the command line" do
@@ -193,7 +181,7 @@ describe Puppet::Application::Agent do
     it "should store the waitforcert options with --waitforcert" do
       @puppetd.handle_waitforcert("42")
 
-      @puppetd.options[:waitforcert].should == 42
+      expect(@puppetd.options[:waitforcert]).to eq(42)
     end
   end
 
@@ -220,17 +208,17 @@ describe Puppet::Application::Agent do
       it "should set options[:verbose] to true" do
         @puppetd.setup_test
 
-        @puppetd.options[:verbose].should == true
+        expect(@puppetd.options[:verbose]).to eq(true)
       end
       it "should set options[:onetime] to true" do
         Puppet[:onetime] = false
         @puppetd.setup_test
-        Puppet[:onetime].should == true
+        expect(Puppet[:onetime]).to eq(true)
       end
       it "should set options[:detailed_exitcodes] to true" do
         @puppetd.setup_test
 
-        @puppetd.options[:detailed_exitcodes].should == true
+        expect(@puppetd.options[:detailed_exitcodes]).to eq(true)
       end
     end
 
@@ -247,13 +235,13 @@ describe Puppet::Application::Agent do
       it "should set log level to debug if --debug was passed" do
         @puppetd.options[:debug] = true
         @puppetd.setup_logs
-        Puppet::Util::Log.level.should == :debug
+        expect(Puppet::Util::Log.level).to eq(:debug)
       end
 
       it "should set log level to info if --verbose was passed" do
         @puppetd.options[:verbose] = true
         @puppetd.setup_logs
-        Puppet::Util::Log.level.should == :info
+        expect(Puppet::Util::Log.level).to eq(:info)
       end
 
       [:verbose, :debug].each do |level|
@@ -325,12 +313,12 @@ describe Puppet::Application::Agent do
 
     it "should default catalog_terminus setting to 'rest'" do
       @puppetd.initialize_app_defaults
-      Puppet[:catalog_terminus].should ==  :rest
+      expect(Puppet[:catalog_terminus]).to eq(:rest)
     end
 
     it "should default node_terminus setting to 'rest'" do
       @puppetd.initialize_app_defaults
-      Puppet[:node_terminus].should ==  :rest
+      expect(Puppet[:node_terminus]).to eq(:rest)
     end
 
     it "has an application default :catalog_cache_terminus setting of 'json'" do
@@ -358,7 +346,7 @@ describe Puppet::Application::Agent do
 
     it "should default facts_terminus setting to 'facter'" do
       @puppetd.initialize_app_defaults
-      Puppet[:facts_terminus].should == :facter
+      expect(Puppet[:facts_terminus]).to eq(:facter)
     end
 
     it "should create an agent" do
@@ -407,15 +395,7 @@ describe Puppet::Application::Agent do
 
       execute_agent
 
-      @daemon.agent.should == @agent
-    end
-
-    it "should not inform the daemon about our agent if :client is set to 'false'" do
-      @puppetd.options[:client] = false
-
-      execute_agent
-
-      @daemon.agent.should be_nil
+      expect(@daemon.agent).to eq(@agent)
     end
 
     it "should daemonize if needed" do
@@ -449,43 +429,6 @@ describe Puppet::Application::Agent do
       execute_agent
     end
 
-    describe "when setting up listen" do
-      before :each do
-        Puppet::FileSystem.stubs(:exist?).with(Puppet[:rest_authconfig]).returns(true)
-        @puppetd.options[:serve] = []
-        @server = stub_everything 'server'
-        Puppet::Network::Server.stubs(:new).returns(@server)
-      end
-
-
-      it "should exit if no authorization file" do
-        Puppet[:listen] = true
-        Puppet.stubs(:err)
-        Puppet::FileSystem.stubs(:exist?).with(Puppet[:rest_authconfig]).returns(false)
-
-        expect do
-          execute_agent
-        end.to exit_with 14
-      end
-
-      it "should use puppet default port" do
-        Puppet[:puppetport] = 32768
-        Puppet[:listen] = true
-
-        Puppet::Network::Server.expects(:new).with(anything, 32768)
-
-        execute_agent
-      end
-
-      it "should issue a warning that listen is deprecated" do
-        Puppet[:listen] = true
-
-        Puppet.expects(:warning).with() { |msg| msg =~ /kick is deprecated/ }
-
-        execute_agent
-      end
-    end
-
     describe "when setting up for fingerprint" do
       before(:each) do
         @puppetd.options[:fingerprint] = true
@@ -558,15 +501,6 @@ describe Puppet::Application::Agent do
         Puppet[:onetime] = true
         @puppetd.options[:client] = :client
         @puppetd.options[:detailed_exitcodes] = false
-        Puppet.stubs(:newservice)
-      end
-
-      it "should exit if no defined --client" do
-        @puppetd.options[:client] = nil
-
-        Puppet.expects(:err).with('onetime is specified but there is no client')
-
-        expect { execute_agent }.to exit_with 43
       end
 
       it "should setup traps" do
@@ -638,7 +572,6 @@ describe Puppet::Application::Agent do
     describe "without --onetime and --fingerprint" do
       before :each do
         Puppet.stubs(:notice)
-        @puppetd.options[:client] = nil
       end
 
       it "should start our daemon" do