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

data/spec/unit/network/authstore_spec.rb

@@ -12,39 +12,39 @@ describe Puppet::Network::AuthStore do
 
   describe "when checking if the acl has some entries" do
     it "should be empty if no ACE have been entered" do
-      @authstore.should be_empty
+      expect(@authstore).to be_empty
     end
 
     it "should not be empty if it is a global allow" do
       @authstore.allow('*')
 
-      @authstore.should_not be_empty
+      expect(@authstore).not_to be_empty
     end
 
     it "should not be empty if at least one allow has been entered" do
       @authstore.allow_ip('1.1.1.*')
 
-      @authstore.should_not be_empty
+      expect(@authstore).not_to be_empty
     end
 
     it "should not be empty if at least one deny has been entered" do
       @authstore.deny_ip('1.1.1.*')
 
-      @authstore.should_not be_empty
+      expect(@authstore).not_to be_empty
     end
   end
 
   describe "when checking global allow" do
     it "should not be enabled by default" do
-      @authstore.should_not be_globalallow
-      @authstore.should_not be_allowed('foo.bar.com', '192.168.1.1')
+      expect(@authstore).not_to be_globalallow
+      expect(@authstore).not_to be_allowed('foo.bar.com', '192.168.1.1')
     end
 
     it "should always allow when enabled" do
       @authstore.allow('*')
 
-      @authstore.should be_globalallow
-      @authstore.should be_allowed('foo.bar.com', '192.168.1.1')
+      expect(@authstore).to be_globalallow
+      expect(@authstore).to be_allowed('foo.bar.com', '192.168.1.1')
     end
   end
 
@@ -55,12 +55,12 @@ describe Puppet::Network::AuthStore do
     end
     ['host5.other-domain.com', 'test-host12.other-domain.net', 'foo.some-domain.com'].each { |name|
       it "should allow the host #{name}" do
-        @authstore.should be_allowed(name, @ip)
+        expect(@authstore).to be_allowed(name, @ip)
       end
     }
     ['host0.some-other-domain.com',''].each { |name|
       it "should not allow the host #{name}" do
-        @authstore.should_not be_allowed(name, @ip)
+        expect(@authstore).not_to be_allowed(name, @ip)
       end
     }
   end
@@ -74,10 +74,10 @@ describe Puppet::Network::AuthStore::Declaration do
         @declaration = Puppet::Network::AuthStore::Declaration.new(:allow_ip,ip)
       end
       it "should match the specified IP" do
-        @declaration.should be_match('www.testsite.org',ip)
+        expect(@declaration).to be_match('www.testsite.org',ip)
       end
       it "should not match other IPs" do
-        @declaration.should_not be_match('www.testsite.org','200.101.99.98')
+        expect(@declaration).not_to be_match('www.testsite.org','200.101.99.98')
       end
     end
 
@@ -88,15 +88,15 @@ describe Puppet::Network::AuthStore::Declaration do
           @declaration = Puppet::Network::AuthStore::Declaration.new(:allow_ip,@ip_pattern)
         end
         it "should match an IP in the range" do
-          @declaration.should be_match('www.testsite.org',ip)
+          expect(@declaration).to be_match('www.testsite.org',ip)
         end
         it "should not match other IPs" do
-          @declaration.should_not be_match('www.testsite.org','200.101.99.98')
+          expect(@declaration).not_to be_match('www.testsite.org','200.101.99.98')
         end
         it "should not match IPs that differ in the last non-wildcard segment" do
           other = ip.split('.')
           other[n-1].succ!
-          @declaration.should_not be_match('www.testsite.org',other.join('.'))
+          expect(@declaration).not_to be_match('www.testsite.org',other.join('.'))
         end
       end
     }
@@ -180,7 +180,7 @@ describe Puppet::Network::AuthStore::Declaration do
   ].each { |invalid_ip|
     describe "when the pattern is an invalid IPv6 address such as #{invalid_ip}" do
       it "should raise an exception" do
-        lambda { Puppet::Network::AuthStore::Declaration.new(:allow,invalid_ip) }.should raise_error
+        expect { Puppet::Network::AuthStore::Declaration.new(:allow,invalid_ip) }.to raise_error
       end
     end
   }
@@ -283,10 +283,10 @@ describe Puppet::Network::AuthStore::Declaration do
         @declaration = Puppet::Network::AuthStore::Declaration.new(:allow_ip,ip)
       end
       it "should match the specified IP" do
-        @declaration.should be_match('www.testsite.org',ip)
+        expect(@declaration).to be_match('www.testsite.org',ip)
       end
       it "should not match other IPs" do
-        @declaration.should_not be_match('www.testsite.org','200.101.99.98')
+        expect(@declaration).not_to be_match('www.testsite.org','200.101.99.98')
       end
     end unless ip =~ /:.*\./ # Hybrid IPs aren't supported by ruby's ipaddr
   }
@@ -301,14 +301,13 @@ describe Puppet::Network::AuthStore::Declaration do
 
       issue_7477 = !(IPAddr.new(ip) rescue false)
 
-      it "should match the specified IP" do
-        pending "resolution of ruby issue [7477](http://goo.gl/Bb1LU)", :if => issue_7477
-        declaration.should be_match('www.testsite.org',ip)
-      end
-      it "should not match other IPs" do
-        pending "resolution of ruby issue [7477](http://goo.gl/Bb1LU)", :if => issue_7477
-        declaration.should_not be_match('www.testsite.org','200.101.99.98')
-      end
+      describe "on rubies with a fix for issue [7477](http://goo.gl/Bb1LU)", :if => issue_7477
+        it "should match the specified IP" do
+          expect(declaration).to be_match('www.testsite.org',ip)
+        end
+        it "should not match other IPs" do
+          expect(declaration).not_to be_match('www.testsite.org','200.101.99.98')
+        end
     end
   }
 
@@ -323,11 +322,11 @@ describe Puppet::Network::AuthStore::Declaration do
         @declaration = Puppet::Network::AuthStore::Declaration.new(:allow,@host)
       end
       it "should match the specified PQDN" do
-        @declaration.should be_match(@host,'200.101.99.98')
+        expect(@declaration).to be_match(@host,'200.101.99.98')
       end
       it "should not match a similar FQDN" do
         pending "FQDN consensus"
-        @declaration.should_not be_match(@host+'.','200.101.99.98')
+        expect(@declaration).not_to be_match(@host+'.','200.101.99.98')
       end
     end
   }
@@ -340,15 +339,15 @@ describe Puppet::Network::AuthStore::Declaration do
           @declaration = Puppet::Network::AuthStore::Declaration.new(:allow,@pattern)
         end
         it "should match #{host}" do
-          @declaration.should be_match(host,'1.2.3.4')
+          expect(@declaration).to be_match(host,'1.2.3.4')
         end
         it "should not match www.testsite.gov" do
-          @declaration.should_not be_match('www.testsite.gov','200.101.99.98')
+          expect(@declaration).not_to be_match('www.testsite.gov','200.101.99.98')
         end
         it "should not match hosts that differ in the first non-wildcard segment" do
           other = host.split('.')
           other[-n].succ!
-          @declaration.should_not be_match(other.join('.'),'1.2.3.4')
+          expect(@declaration).not_to be_match(other.join('.'),'1.2.3.4')
         end
       end
     }
@@ -361,10 +360,10 @@ describe Puppet::Network::AuthStore::Declaration do
     end
     it "should match the specified FQDN" do
       pending "FQDN consensus"
-      @declaration.should be_match(@host,'200.101.99.98')
+      expect(@declaration).to be_match(@host,'200.101.99.98')
     end
     it "should not match a similar PQDN" do
-      @declaration.should_not be_match(@host[0..-2],'200.101.99.98')
+      expect(@declaration).not_to be_match(@host[0..-2],'200.101.99.98')
     end
   end
 
@@ -377,7 +376,7 @@ describe Puppet::Network::AuthStore::Declaration do
       @declaration = Puppet::Network::AuthStore::Declaration.new(:allow,'$1')
     end
     it "should match an IP with the appropriate interpolation" do
-      @declaration.interpolate(@item.match(@pattern)).should be_match(@host,'10.0.0.5')
+      expect(@declaration.interpolate(@item.match(@pattern))).to be_match(@host,'10.0.0.5')
     end
   end
 
@@ -389,7 +388,7 @@ describe Puppet::Network::AuthStore::Declaration do
       @declaration = Puppet::Network::AuthStore::Declaration.new(:allow,'$1')
     end
     it "should match a name with the appropriate interpolation" do
-      @declaration.interpolate(@item.match(@pattern)).should be_match(@host,'10.0.0.5')
+      expect(@declaration.interpolate(@item.match(@pattern))).to be_match(@host,'10.0.0.5')
     end
   end
 
@@ -401,7 +400,7 @@ describe Puppet::Network::AuthStore::Declaration do
       @declaration = Puppet::Network::AuthStore::Declaration.new(:allow,'$1')
     end
     it "should match a name with the appropriate interpolation" do
-      @declaration.interpolate(@item.match(@pattern)).should be_match(@host,'10.0.0.5')
+      expect(@declaration.interpolate(@item.match(@pattern))).to be_match(@host,'10.0.0.5')
     end
   end
 
@@ -412,13 +411,13 @@ describe Puppet::Network::AuthStore::Declaration do
       @opaque    = Puppet::Network::AuthStore::Declaration.new(:allow,'hey_dude')
     end
     it "should consider ip addresses before host names" do
-      (@ip < @host_name).should be_true
+      expect(@ip < @host_name).to be_truthy
     end
     it "should consider ip addresses before opaque strings" do
-      (@ip < @opaque).should be_true
+      expect(@ip < @opaque).to be_truthy
     end
     it "should consider host_names before opaque strings" do
-      (@host_name < @opaque).should be_true
+      expect(@host_name < @opaque).to be_truthy
     end
   end
 end

data/spec/unit/network/format_handler_spec.rb

@@ -18,7 +18,7 @@ describe Puppet::Network::FormatHandler do
       format = Puppet::Network::FormatHandler.create(:test_format) do
         def asdfghjkl; end
       end
-      format.should respond_to(:asdfghjkl)
+      expect(format).to respond_to(:asdfghjkl)
     end
   end
 
@@ -26,27 +26,27 @@ describe Puppet::Network::FormatHandler do
     let!(:format) { Puppet::Network::FormatHandler.create(:the_format, :extension => "foo", :mime => "foo/bar") }
 
     it "should be able to retrieve a format by name" do
-      Puppet::Network::FormatHandler.format(:the_format).should equal(format)
+      expect(Puppet::Network::FormatHandler.format(:the_format)).to equal(format)
     end
 
     it "should be able to retrieve a format by extension" do
-      Puppet::Network::FormatHandler.format_by_extension("foo").should equal(format)
+      expect(Puppet::Network::FormatHandler.format_by_extension("foo")).to equal(format)
     end
 
     it "should return nil if asked to return a format by an unknown extension" do
-      Puppet::Network::FormatHandler.format_by_extension("yayness").should be_nil
+      expect(Puppet::Network::FormatHandler.format_by_extension("yayness")).to be_nil
     end
 
     it "should be able to retrieve formats by name irrespective of case" do
-      Puppet::Network::FormatHandler.format(:The_Format).should equal(format)
+      expect(Puppet::Network::FormatHandler.format(:The_Format)).to equal(format)
     end
 
     it "should be able to retrieve a format by mime type" do
-      Puppet::Network::FormatHandler.mime("foo/bar").should equal(format)
+      expect(Puppet::Network::FormatHandler.mime("foo/bar")).to equal(format)
     end
 
     it "should be able to retrieve a format by mime type irrespective of case" do
-      Puppet::Network::FormatHandler.mime("Foo/Bar").should equal(format)
+      expect(Puppet::Network::FormatHandler.mime("Foo/Bar")).to equal(format)
     end
   end
 
@@ -64,31 +64,31 @@ describe Puppet::Network::FormatHandler do
     end
 
     it "finds the most preferred format when anything is acceptable" do
-      Puppet::Network::FormatHandler.most_suitable_format_for(["*/*"], [:two, :one]).should == format_two
+      expect(Puppet::Network::FormatHandler.most_suitable_format_for(["*/*"], [:two, :one])).to eq(format_two)
     end
 
     it "finds no format when none are acceptable" do
-      suitable_in_setup_formats(["three"]).should be_nil
+      expect(suitable_in_setup_formats(["three"])).to be_nil
     end
 
     it "skips unsupported, but accepted, formats" do
-      suitable_in_setup_formats(["three", "two"]).should == format_two
+      expect(suitable_in_setup_formats(["three", "two"])).to eq(format_two)
     end
 
     it "gives the first acceptable and suitable format" do
-      suitable_in_setup_formats(["three", "one", "two"]).should == format_one
+      expect(suitable_in_setup_formats(["three", "one", "two"])).to eq(format_one)
     end
 
     it "allows specifying acceptable formats by mime type" do
-      suitable_in_setup_formats(["text/one"]).should == format_one
+      expect(suitable_in_setup_formats(["text/one"])).to eq(format_one)
     end
 
     it "ignores quality specifiers" do
-      suitable_in_setup_formats(["two;q=0.8", "text/one;q=0.9"]).should == format_two
+      expect(suitable_in_setup_formats(["two;q=0.8", "text/one;q=0.9"])).to eq(format_two)
     end
 
     it "allows specifying acceptable formats by canonical name" do
-      suitable_in_setup_formats([:one]).should == format_one
+      expect(suitable_in_setup_formats([:one])).to eq(format_one)
     end
   end
 end

data/spec/unit/network/format_spec.rb

@@ -22,28 +22,28 @@ end
 describe Puppet::Network::Format do
   describe "when initializing" do
     it "should require a name" do
-      lambda { Puppet::Network::Format.new }.should raise_error(ArgumentError)
+      expect { Puppet::Network::Format.new }.to raise_error(ArgumentError)
     end
 
     it "should be able to provide its name" do
-      Puppet::Network::Format.new(:my_format).name.should == :my_format
+      expect(Puppet::Network::Format.new(:my_format).name).to eq(:my_format)
     end
 
     it "should always convert its name to a downcased symbol" do
-      Puppet::Network::Format.new(:My_Format).name.should == :my_format
+      expect(Puppet::Network::Format.new(:My_Format).name).to eq(:my_format)
     end
 
     it "should be able to set its downcased mime type at initialization" do
       format = Puppet::Network::Format.new(:my_format, :mime => "Foo/Bar")
-      format.mime.should == "foo/bar"
+      expect(format.mime).to eq("foo/bar")
     end
 
     it "should default to text plus the name of the format as the mime type" do
-      Puppet::Network::Format.new(:my_format).mime.should == "text/my_format"
+      expect(Puppet::Network::Format.new(:my_format).mime).to eq("text/my_format")
     end
 
     it "should fail if unsupported options are provided" do
-      lambda { Puppet::Network::Format.new(:my_format, :foo => "bar") }.should raise_error(ArgumentError)
+      expect { Puppet::Network::Format.new(:my_format, :foo => "bar") }.to raise_error(ArgumentError)
     end
   end
 
@@ -53,24 +53,24 @@ describe Puppet::Network::Format do
     end
 
     it "should support being confined" do
-      @format.should respond_to(:confine)
+      expect(@format).to respond_to(:confine)
     end
 
     it "should not be considered suitable if confinement conditions are not met" do
       @format.confine :true => false
-      @format.should_not be_suitable
+      expect(@format).not_to be_suitable
     end
 
     it "should be able to determine if a class is supported" do
-      @format.should respond_to(:supported?)
+      expect(@format).to respond_to(:supported?)
     end
 
     it "should consider a class to be supported if it has the individual and multiple methods for rendering and interning" do
-      @format.should be_supported(FormatRenderer)
+      expect(@format).to be_supported(FormatRenderer)
     end
 
     it "should default to its required methods being the individual and multiple methods for rendering and interning" do
-      Puppet::Network::Format.new(:foo).required_methods.sort { |a,b| a.to_s <=> b.to_s }.should ==  [:intern_method, :intern_multiple_method, :render_multiple_method, :render_method].sort { |a,b| a.to_s <=> b.to_s }
+      expect(Puppet::Network::Format.new(:foo).required_methods.sort { |a,b| a.to_s <=> b.to_s }).to eq([:intern_method, :intern_multiple_method, :render_multiple_method, :render_method].sort { |a,b| a.to_s <=> b.to_s })
     end
 
     it "should consider a class supported if the provided class has all required methods present" do
@@ -79,18 +79,18 @@ describe Puppet::Network::Format do
         format.expects(:required_method_present?).with { |name, klass, type| name == method and klass == String }.returns true
       end
 
-      format.should be_required_methods_present(String)
+      expect(format).to be_required_methods_present(String)
     end
 
     it "should consider a class not supported if any required methods are missing from the provided class" do
       format = Puppet::Network::Format.new(:foo)
       format.stubs(:required_method_present?).returns true
       format.expects(:required_method_present?).with { |name, *args| name == :intern_method }.returns false
-      format.should_not be_required_methods_present(String)
+      expect(format).not_to be_required_methods_present(String)
     end
 
     it "should be able to specify the methods required for support" do
-      Puppet::Network::Format.new(:foo, :required_methods => [:render_method, :intern_method]).required_methods.should == [:render_method, :intern_method]
+      expect(Puppet::Network::Format.new(:foo, :required_methods => [:render_method, :intern_method]).required_methods).to eq([:render_method, :intern_method])
     end
 
     it "should only test for required methods if specific methods are specified as required" do
@@ -102,36 +102,36 @@ describe Puppet::Network::Format do
 
     it "should not consider a class supported unless the format is suitable" do
       @format.expects(:suitable?).returns false
-      @format.should_not be_supported(FormatRenderer)
+      expect(@format).not_to be_supported(FormatRenderer)
     end
 
     it "should always downcase mimetypes" do
       @format.mime = "Foo/Bar"
-      @format.mime.should == "foo/bar"
+      expect(@format.mime).to eq("foo/bar")
     end
 
     it "should support having a weight" do
-      @format.should respond_to(:weight)
+      expect(@format).to respond_to(:weight)
     end
 
     it "should default to a weight of of 5" do
-      @format.weight.should == 5
+      expect(@format.weight).to eq(5)
     end
 
     it "should be able to override its weight at initialization" do
-      Puppet::Network::Format.new(:foo, :weight => 1).weight.should == 1
+      expect(Puppet::Network::Format.new(:foo, :weight => 1).weight).to eq(1)
     end
 
     it "should default to its extension being equal to its name" do
-      Puppet::Network::Format.new(:foo).extension.should == "foo"
+      expect(Puppet::Network::Format.new(:foo).extension).to eq("foo")
     end
 
     it "should support overriding the extension" do
-      Puppet::Network::Format.new(:foo, :extension => "bar").extension.should == "bar"
+      expect(Puppet::Network::Format.new(:foo, :extension => "bar").extension).to eq("bar")
     end
     [:intern_method, :intern_multiple_method, :render_multiple_method, :render_method].each do |method|
       it "should allow assignment of the #{method}" do
-        Puppet::Network::Format.new(:foo, method => :foo).send(method).should == :foo
+        expect(Puppet::Network::Format.new(:foo, method => :foo).send(method)).to eq(:foo)
       end
     end
   end
@@ -143,55 +143,55 @@ describe Puppet::Network::Format do
     end
 
     it "should have a method for rendering a single instance" do
-      @format.should respond_to(:render)
+      expect(@format).to respond_to(:render)
     end
 
     it "should have a method for rendering multiple instances" do
-      @format.should respond_to(:render_multiple)
+      expect(@format).to respond_to(:render_multiple)
     end
 
     it "should have a method for interning text" do
-      @format.should respond_to(:intern)
+      expect(@format).to respond_to(:intern)
     end
 
     it "should have a method for interning text into multiple instances" do
-      @format.should respond_to(:intern_multiple)
+      expect(@format).to respond_to(:intern_multiple)
     end
 
     it "should return the results of calling the instance-specific render method if the method is present" do
       @instance.expects(:to_my_format).returns "foo"
-      @format.render(@instance).should == "foo"
+      expect(@format.render(@instance)).to eq("foo")
     end
 
     it "should return the results of calling the class-specific render_multiple method if the method is present" do
       @instance.class.expects(:to_multiple_my_format).returns ["foo"]
-      @format.render_multiple([@instance]).should == ["foo"]
+      expect(@format.render_multiple([@instance])).to eq(["foo"])
     end
 
     it "should return the results of calling the class-specific intern method if the method is present" do
       FormatRenderer.expects(:from_my_format).with("foo").returns @instance
-      @format.intern(FormatRenderer, "foo").should equal(@instance)
+      expect(@format.intern(FormatRenderer, "foo")).to equal(@instance)
     end
 
     it "should return the results of calling the class-specific intern_multiple method if the method is present" do
       FormatRenderer.expects(:from_multiple_my_format).with("foo").returns [@instance]
-      @format.intern_multiple(FormatRenderer, "foo").should == [@instance]
+      expect(@format.intern_multiple(FormatRenderer, "foo")).to eq([@instance])
     end
 
     it "should fail if asked to render and the instance does not respond to 'to_<format>'" do
-      lambda { @format.render("foo") }.should raise_error(NotImplementedError)
+      expect { @format.render("foo") }.to raise_error(NotImplementedError)
     end
 
     it "should fail if asked to intern and the class does not respond to 'from_<format>'" do
-      lambda { @format.intern(String, "foo") }.should raise_error(NotImplementedError)
+      expect { @format.intern(String, "foo") }.to raise_error(NotImplementedError)
     end
 
     it "should fail if asked to intern multiple and the class does not respond to 'from_multiple_<format>'" do
-      lambda { @format.intern_multiple(String, "foo") }.should raise_error(NotImplementedError)
+      expect { @format.intern_multiple(String, "foo") }.to raise_error(NotImplementedError)
     end
 
     it "should fail if asked to render multiple and the instance does not respond to 'to_multiple_<format>'" do
-      lambda { @format.render_multiple(["foo", "bar"]) }.should raise_error(NotImplementedError)
+      expect { @format.render_multiple(["foo", "bar"]) }.to raise_error(NotImplementedError)
     end
   end
 end