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

data/spec/unit/network/format_support_spec.rb

@@ -31,13 +31,13 @@ describe Puppet::Network::FormatHandler do
     end
 
     it "should return all supported formats in decreasing order of weight" do
-      FormatTester.supported_formats.should == [:two, :three, :one]
+      expect(FormatTester.supported_formats).to eq([:two, :three, :one])
     end
   end
 
   it "should return the first format as the default format" do
     FormatTester.expects(:supported_formats).returns [:one, :two]
-    FormatTester.default_format.should == :one
+    expect(FormatTester.default_format).to eq(:one)
   end
 
   describe "with a preferred serialization format setting" do
@@ -54,7 +54,7 @@ describe Puppet::Network::FormatHandler do
       end
 
       it "should return the preferred serialization format first" do
-        FormatTester.supported_formats.should == [:one, :two]
+        expect(FormatTester.supported_formats).to eq([:one, :two])
       end
     end
 
@@ -64,7 +64,7 @@ describe Puppet::Network::FormatHandler do
       end
 
       it "should return the default format first" do
-        FormatTester.supported_formats.should == [:two, :one]
+        expect(FormatTester.supported_formats).to eq([:two, :one])
       end
 
       it "should log a debug message" do
@@ -140,7 +140,7 @@ describe Puppet::Network::FormatHandler do
 
     it "should list as supported a format that reports itself supported" do
       format.expects(:supported?).returns true
-      FormatTester.new.support_format?(:foo).should be_true
+      expect(FormatTester.new.support_format?(:foo)).to be_truthy
     end
 
     it "should raise a FormatError when a rendering error is encountered" do
@@ -156,21 +156,21 @@ describe Puppet::Network::FormatHandler do
       tester = FormatTester.new
       format.expects(:render).with(tester).returns "foo"
 
-      tester.render(:foo).should == "foo"
+      expect(tester.render(:foo)).to eq("foo")
     end
 
     it "should call the format-specific converter when asked to convert to a given format by mime-type" do
       tester = FormatTester.new
       format.expects(:render).with(tester).returns "foo"
 
-      tester.render("text/foo").should == "foo"
+      expect(tester.render("text/foo")).to eq("foo")
     end
 
     it "should call the format converter when asked to convert to a given format instance" do
       tester = FormatTester.new
       format.expects(:render).with(tester).returns "foo"
 
-      tester.render(format).should == "foo"
+      expect(tester.render(format)).to eq("foo")
     end
 
     it "should render to the default format if no format is provided when rendering" do
@@ -185,7 +185,7 @@ describe Puppet::Network::FormatHandler do
       tester = FormatTester.new
       format.expects(:mime).returns "text/foo"
 
-      tester.mime(:foo).should == "text/foo"
+      expect(tester.mime(:foo)).to eq("text/foo")
     end
 
     it "should return the default format mime-type if no format is provided" do
@@ -193,7 +193,7 @@ describe Puppet::Network::FormatHandler do
       tester = FormatTester.new
 
       format.expects(:mime).returns "text/foo"
-      tester.mime.should == "text/foo"
+      expect(tester.mime).to eq("text/foo")
     end
   end
 end

data/spec/unit/network/formats_spec.rb

@@ -27,7 +27,7 @@ end
 
 describe "Puppet Network Format" do
   it "should include a msgpack format", :if => Puppet.features.msgpack? do
-    Puppet::Network::FormatHandler.format(:msgpack).should_not be_nil
+    expect(Puppet::Network::FormatHandler.format(:msgpack)).not_to be_nil
   end
 
   describe "msgpack", :if => Puppet.features.msgpack? do
@@ -36,11 +36,11 @@ describe "Puppet Network Format" do
     end
 
     it "should have its mime type set to application/x-msgpack" do
-      @msgpack.mime.should == "application/x-msgpack"
+      expect(@msgpack.mime).to eq("application/x-msgpack")
     end
 
     it "should have a weight of 20" do
-      @msgpack.weight.should == 20
+      expect(@msgpack.weight).to eq(20)
     end
 
     it "should fail when one element does not have a from_data_hash" do
@@ -53,7 +53,7 @@ describe "Puppet Network Format" do
       cat = Puppet::Resource::Catalog.new('foo', Puppet::Node::Environment.create(:testing, []))
       cat.add_resource(Puppet::Resource.new(:file, 'my_file'))
       catunpack = MessagePack.unpack(cat.to_msgpack)
-      catunpack.should include(
+      expect(catunpack).to include(
         "tags"=>[],
         "name"=>"foo",
         "version"=>nil,
@@ -61,58 +61,54 @@ describe "Puppet Network Format" do
         "edges"=>[],
         "classes"=>[]
       )
-      catunpack["resources"][0].should include(
+      expect(catunpack["resources"][0]).to include(
         "type"=>"File",
         "title"=>"my_file",
         "exported"=>false
       )
-      catunpack["resources"][0]["tags"].should include(
+      expect(catunpack["resources"][0]["tags"]).to include(
         "file",
         "my_file"
       )
     end
   end
 
-  it "should include a yaml format" do
-    Puppet::Network::FormatHandler.format(:yaml).should_not be_nil
-  end
-
   describe "yaml" do
     before do
       @yaml = Puppet::Network::FormatHandler.format(:yaml)
     end
 
     it "should have its mime type set to text/yaml" do
-      @yaml.mime.should == "text/yaml"
+      expect(@yaml.mime).to eq("text/yaml")
     end
 
     it "should be supported on Strings" do
-      @yaml.should be_supported(String)
+      expect(@yaml).to be_supported(String)
     end
 
     it "should render by calling 'to_yaml' on the instance" do
       instance = mock 'instance'
       instance.expects(:to_yaml).returns "foo"
-      @yaml.render(instance).should == "foo"
+      expect(@yaml.render(instance)).to eq("foo")
     end
 
     it "should render multiple instances by calling 'to_yaml' on the array" do
       instances = [mock('instance')]
       instances.expects(:to_yaml).returns "foo"
-      @yaml.render_multiple(instances).should == "foo"
+      expect(@yaml.render_multiple(instances)).to eq("foo")
     end
 
     it "should deserialize YAML" do
-      @yaml.intern(String, YAML.dump("foo")).should == "foo"
+      expect(@yaml.intern(String, YAML.dump("foo"))).to eq("foo")
     end
 
     it "should deserialize symbols as strings" do
-      @yaml.intern(String, YAML.dump(:foo)).should == "foo"
+      expect { @yaml.intern(String, YAML.dump(:foo))}.to raise_error(Puppet::Network::FormatHandler::FormatError)
     end
 
     it "should load from yaml when deserializing an array" do
       text = YAML.dump(["foo"])
-      @yaml.intern_multiple(String, text).should == ["foo"]
+      expect(@yaml.intern_multiple(String, text)).to eq(["foo"])
     end
 
     it "fails intelligibly instead of calling to_pson with something other than a hash" do
@@ -134,105 +130,17 @@ describe "Puppet Network Format" do
     end
   end
 
-  describe "base64 compressed yaml", :if => Puppet.features.zlib? do
-    before do
-      @yaml = Puppet::Network::FormatHandler.format(:b64_zlib_yaml)
-    end
-
-    it "should have its mime type set to text/b64_zlib_yaml" do
-      @yaml.mime.should == "text/b64_zlib_yaml"
-    end
-
-    it "should render by calling 'to_yaml' on the instance" do
-      instance = mock 'instance'
-      instance.expects(:to_yaml).returns "foo"
-      @yaml.render(instance)
-    end
-
-    it "should encode generated yaml on render" do
-      instance = mock 'instance', :to_yaml => "foo"
-
-      @yaml.expects(:encode).with("foo").returns "bar"
-
-      @yaml.render(instance).should == "bar"
-    end
-
-    it "should render multiple instances by calling 'to_yaml' on the array" do
-      instances = [mock('instance')]
-      instances.expects(:to_yaml).returns "foo"
-      @yaml.render_multiple(instances)
-    end
-
-    it "should encode generated yaml on render" do
-      instances = [mock('instance')]
-      instances.stubs(:to_yaml).returns "foo"
-
-      @yaml.expects(:encode).with("foo").returns "bar"
-
-      @yaml.render(instances).should == "bar"
-    end
-
-    it "should round trip data" do
-      @yaml.intern(String, @yaml.encode("foo")).should == "foo"
-    end
-
-    it "should round trip multiple data elements" do
-      data = @yaml.render_multiple(["foo", "bar"])
-      @yaml.intern_multiple(String, data).should == ["foo", "bar"]
-    end
-
-    it "should intern by base64 decoding, uncompressing and safely Yaml loading" do
-      input = Base64.encode64(Zlib::Deflate.deflate(YAML.dump("data in")))
-
-      @yaml.intern(String, input).should == "data in"
-    end
-
-    it "should render by compressing and base64 encoding" do
-      output = @yaml.render("foo")
-
-      YAML.load(Zlib::Inflate.inflate(Base64.decode64(output))).should == "foo"
-    end
-
-    describe "when zlib is disabled" do
-      before do
-        Puppet[:zlib] = false
-      end
-
-      it "use_zlib? should return false" do
-        @yaml.use_zlib?.should == false
-      end
-
-      it "should refuse to encode" do
-        expect { @yaml.render("foo") }.to raise_error(Puppet::Error, /zlib library is not installed/)
-      end
-
-      it "should refuse to decode" do
-        expect { @yaml.intern(String, "foo") }.to raise_error(Puppet::Error, /zlib library is not installed/)
-      end
-    end
-
-    describe "when zlib is not installed" do
-      it "use_zlib? should return false" do
-        Puppet[:zlib] = true
-        Puppet.features.expects(:zlib?).returns(false)
-
-        @yaml.use_zlib?.should == false
-      end
-    end
-
-  end
-
   describe "plaintext" do
     before do
       @text = Puppet::Network::FormatHandler.format(:s)
     end
 
     it "should have its mimetype set to text/plain" do
-      @text.mime.should == "text/plain"
+      expect(@text.mime).to eq("text/plain")
     end
 
     it "should use 'txt' as its extension" do
-      @text.extension.should == "txt"
+      expect(@text.extension).to eq("txt")
     end
   end
 
@@ -242,42 +150,42 @@ describe "Puppet Network Format" do
     end
 
     it "should have its mimetype set to text/dot" do
-      @dot.mime.should == "text/dot"
+      expect(@dot.mime).to eq("text/dot")
     end
   end
 
-  describe Puppet::Network::FormatHandler.format(:raw) do
+  describe Puppet::Network::FormatHandler.format(:binary) do
     before do
-      @format = Puppet::Network::FormatHandler.format(:raw)
+      @format = Puppet::Network::FormatHandler.format(:binary)
     end
 
     it "should exist" do
-      @format.should_not be_nil
+      expect(@format).not_to be_nil
     end
 
-    it "should have its mimetype set to application/x-raw" do
-      @format.mime.should == "application/x-raw"
+    it "should have its mimetype set to application/octet-stream" do
+      expect(@format.mime).to eq("application/octet-stream")
     end
 
     it "should always be supported" do
-      @format.should be_supported(String)
+      expect(@format).to be_supported(String)
     end
 
     it "should fail if its multiple_render method is used" do
-      lambda { @format.render_multiple("foo") }.should raise_error(NotImplementedError)
+      expect { @format.render_multiple("foo") }.to raise_error(NotImplementedError)
     end
 
     it "should fail if its multiple_intern method is used" do
-      lambda { @format.intern_multiple(String, "foo") }.should raise_error(NotImplementedError)
+      expect { @format.intern_multiple(String, "foo") }.to raise_error(NotImplementedError)
     end
 
     it "should have a weight of 1" do
-      @format.weight.should == 1
+      expect(@format.weight).to eq(1)
     end
   end
 
   it "should include a pson format" do
-    Puppet::Network::FormatHandler.format(:pson).should_not be_nil
+    expect(Puppet::Network::FormatHandler.format(:pson)).not_to be_nil
   end
 
   describe "pson" do
@@ -286,26 +194,26 @@ describe "Puppet Network Format" do
     end
 
     it "should have its mime type set to text/pson" do
-      Puppet::Network::FormatHandler.format(:pson).mime.should == "text/pson"
+      expect(Puppet::Network::FormatHandler.format(:pson).mime).to eq("text/pson")
     end
 
     it "should require the :render_method" do
-      Puppet::Network::FormatHandler.format(:pson).required_methods.should be_include(:render_method)
+      expect(Puppet::Network::FormatHandler.format(:pson).required_methods).to be_include(:render_method)
     end
 
     it "should require the :intern_method" do
-      Puppet::Network::FormatHandler.format(:pson).required_methods.should be_include(:intern_method)
+      expect(Puppet::Network::FormatHandler.format(:pson).required_methods).to be_include(:intern_method)
     end
 
     it "should have a weight of 10" do
-      @pson.weight.should == 10
+      expect(@pson.weight).to eq(10)
     end
 
     describe "when supported" do
       it "should render by calling 'to_pson' on the instance" do
         instance = PsonTest.new("foo")
         instance.expects(:to_pson).returns "foo"
-        @pson.render(instance).should == "foo"
+        expect(@pson.render(instance)).to eq("foo")
       end
 
       it "should render multiple instances by calling 'to_pson' on the array" do
@@ -313,14 +221,14 @@ describe "Puppet Network Format" do
 
         instances.expects(:to_pson).returns "foo"
 
-        @pson.render_multiple(instances).should == "foo"
+        expect(@pson.render_multiple(instances)).to eq("foo")
       end
 
       it "should intern by calling 'PSON.parse' on the text and then using from_data_hash to convert the data into an instance" do
         text = "foo"
         PSON.expects(:parse).with("foo").returns("type" => "PsonTest", "data" => "foo")
         PsonTest.expects(:from_data_hash).with("foo").returns "parsed_pson"
-        @pson.intern(PsonTest, text).should == "parsed_pson"
+        expect(@pson.intern(PsonTest, text)).to eq("parsed_pson")
       end
 
       it "should not render twice if 'PSON.parse' creates the appropriate instance" do
@@ -328,14 +236,14 @@ describe "Puppet Network Format" do
         instance = PsonTest.new("foo")
         PSON.expects(:parse).with("foo").returns(instance)
         PsonTest.expects(:from_data_hash).never
-        @pson.intern(PsonTest, text).should equal(instance)
+        expect(@pson.intern(PsonTest, text)).to equal(instance)
       end
 
       it "should intern by calling 'PSON.parse' on the text and then using from_data_hash to convert the actual into an instance if the pson has no class/data separation" do
         text = "foo"
         PSON.expects(:parse).with("foo").returns("foo")
         PsonTest.expects(:from_data_hash).with("foo").returns "parsed_pson"
-        @pson.intern(PsonTest, text).should == "parsed_pson"
+        expect(@pson.intern(PsonTest, text)).to eq("parsed_pson")
       end
 
       it "should intern multiples by parsing the text and using 'class.intern' on each resulting data structure" do
@@ -343,7 +251,7 @@ describe "Puppet Network Format" do
         PSON.expects(:parse).with("foo").returns ["bar", "baz"]
         PsonTest.expects(:from_data_hash).with("bar").returns "BAR"
         PsonTest.expects(:from_data_hash).with("baz").returns "BAZ"
-        @pson.intern_multiple(PsonTest, text).should == %w{BAR BAZ}
+        expect(@pson.intern_multiple(PsonTest, text)).to eq(%w{BAR BAZ})
       end
 
       it "fails intelligibly when given invalid data" do
@@ -356,7 +264,7 @@ describe "Puppet Network Format" do
 
   describe ":console format" do
     subject { Puppet::Network::FormatHandler.format(:console) }
-    it { should be_an_instance_of Puppet::Network::Format }
+    it { is_expected.to be_an_instance_of Puppet::Network::Format }
     let :json do Puppet::Network::FormatHandler.format(:pson) end
 
     [:intern, :intern_multiple].each do |method|
@@ -367,23 +275,29 @@ describe "Puppet Network Format" do
 
     ["hello", 1, 1.0].each do |input|
       it "should just return a #{input.inspect}" do
-        subject.render(input).should == input
+        expect(subject.render(input)).to eq(input)
+      end
+    end
+
+    [true, false, nil, Object.new].each do |input|
+      it "renders #{input.class} using PSON" do
+        expect(subject.render(input)).to eq(input.to_pson)
       end
     end
 
     [[1, 2], ["one"], [{ 1 => 1 }]].each do |input|
       it "should render #{input.inspect} as one item per line" do
-        subject.render(input).should == input.collect { |item| item.to_s + "\n" }.join('')
+        expect(subject.render(input)).to eq(input.collect { |item| item.to_s + "\n" }.join(''))
       end
     end
 
     it "should render empty hashes as empty strings" do
-      subject.render({}).should == ''
+      expect(subject.render({})).to eq('')
     end
 
-    it "should render a non-trivially-keyed Hash as JSON" do
+    it "should render a non-trivially-keyed Hash as pretty printed PSON" do
       hash = { [1,2] => 3, [2,3] => 5, [3,4] => 7 }
-      subject.render(hash).should == json.render(hash).chomp
+      expect(subject.render(hash)).to eq(PSON.pretty_generate(hash).chomp)
     end
 
     it "should render a {String,Numeric}-keyed Hash into a table" do
@@ -393,7 +307,7 @@ describe "Puppet Network Format" do
 
       # Gotta love ASCII-betical sort order.  Hope your objects are better
       # structured for display than my test one is. --daniel 2011-04-18
-      subject.render(hash).should == <<EOT
+      expect(subject.render(hash)).to eq <<EOT
 5      5
 6.0    6
 four   #{json.render(object).chomp}
@@ -409,7 +323,7 @@ EOT
         "number" => { "1" => '1' * 40, "2" => '2' * 40, '3' => '3' * 40 },
         "text"   => { "a" => 'a' * 40, 'b' => 'b' * 40, 'c' => 'c' * 40 }
       }
-      subject.render(hash).should == <<EOT
+      expect(subject.render(hash)).to eq <<EOT
 number  {"1"=>"1111111111111111111111111111111111111111",
          "2"=>"2222222222222222222222222222222222222222",
          "3"=>"3333333333333333333333333333333333333333"}