puppet 4.10.12 → 5.0.0

data/spec/unit/network/http/api/indirected_routes_spec.rb

@@ -255,49 +255,41 @@ describe Puppet::Network::HTTP::API::IndirectedRoutes do
     it "uses the first supported format for the response" do
       data = Puppet::IndirectorTesting.new("my data")
       indirection.save(data, "my data")
-      request = a_request_that_finds(data, :accept_header => "unknown, pson")
+      request = a_request_that_finds(data, :accept_header => "unknown, application/json")
 
       handler.call(request, response)
 
-      expect(response.body).to eq(data.render(:pson))
-      expect(response.type).to eq(Puppet::Network::FormatHandler.format(:pson))
+      expect(response.body).to eq(data.render(:json))
+      expect(response.type).to eq(Puppet::Network::FormatHandler.format(:json))
     end
 
-    it "raises not_acceptable_error when no accept header is provided" do
+    it "falls back to the next supported format" do
       data = Puppet::IndirectorTesting.new("my data")
       indirection.save(data, "my data")
-      request = a_request_that_finds(data, :accept_header => nil)
-
-      expect {
-        handler.call(request, response)
-      }.to raise_error(not_acceptable_error)
-    end
+      request = a_request_that_finds(data, :accept_header => "application/json, text/pson")
+      data.stubs(:to_json).raises(Puppet::Network::FormatHandler::FormatError, 'Could not render to Puppet::Network::Format[json]: source sequence is illegal/malformed utf-8')
 
-    it "raises not_acceptable_error when no accepted formats are known" do
-      data = Puppet::IndirectorTesting.new("my data")
-      indirection.save(data, "my data")
-      request = a_request_that_finds(data, :accept_header => "unknown, also/unknown")
+      handler.call(request, response)
 
-      expect {
-        handler.call(request, response)
-      }.to raise_error(not_acceptable_error)
+      expect(response.body).to eq(data.render(:pson))
+      expect(response.type).to eq(Puppet::Network::FormatHandler.format(:pson))
     end
 
     it "should pass the result through without rendering it if the result is a string" do
       data = Puppet::IndirectorTesting.new("my data")
       data_string = "my data string"
-      request = a_request_that_finds(data, :accept_header => "text/pson")
+      request = a_request_that_finds(data, :accept_header => "application/json")
       indirection.expects(:find).returns(data_string)
 
       handler.call(request, response)
 
       expect(response.body).to eq(data_string)
-      expect(response.type).to eq(Puppet::Network::FormatHandler.format(:pson))
+      expect(response.type).to eq(Puppet::Network::FormatHandler.format(:json))
     end
 
     it "should raise not_found_error when no model instance can be found" do
       data = Puppet::IndirectorTesting.new("my data")
-      request = a_request_that_finds(data, :accept_header => "unknown, text/pson")
+      request = a_request_that_finds(data, :accept_header => "unknown, application/json")
 
       expect {
         handler.call(request, response)
@@ -309,7 +301,19 @@ describe Puppet::Network::HTTP::API::IndirectedRoutes do
     it "uses the first supported format for the response" do
       data = Puppet::IndirectorTesting.new("my data")
       indirection.save(data, "my data")
-      request = a_request_that_searches(Puppet::IndirectorTesting.new("my"), :accept_header => "unknown, text/pson")
+      request = a_request_that_searches(Puppet::IndirectorTesting.new("my"), :accept_header => "unknown, application/json")
+
+      handler.call(request, response)
+
+      expect(response.type).to eq(Puppet::Network::FormatHandler.format(:json))
+      expect(response.body).to eq(Puppet::IndirectorTesting.render_multiple(:json, [data]))
+    end
+
+    it "falls back to the next supported format" do
+      data = Puppet::IndirectorTesting.new("my data")
+      indirection.save(data, "my data")
+      request = a_request_that_searches(Puppet::IndirectorTesting.new("my"), :accept_header => "application/json, text/pson")
+      data.stubs(:to_json).raises(Puppet::Network::FormatHandler::FormatError, 'Could not render to Puppet::Network::Format[json]: source sequence is illegal/malformed utf-8')
 
       handler.call(request, response)
 
@@ -317,17 +321,29 @@ describe Puppet::Network::HTTP::API::IndirectedRoutes do
       expect(response.body).to eq(Puppet::IndirectorTesting.render_multiple(:pson, [data]))
     end
 
+    it "raises 406 not acceptable if no formats are accceptable" do
+      data = Puppet::IndirectorTesting.new("my data")
+      indirection.save(data, "my data")
+      request = a_request_that_searches(Puppet::IndirectorTesting.new("my"), :accept_header => "application/json, text/pson")
+      data.stubs(:to_json).raises(Puppet::Network::FormatHandler::FormatError, 'Could not render to Puppet::Network::Format[json]: source sequence is illegal/malformed utf-8')
+      data.stubs(:to_pson).raises(Puppet::Network::FormatHandler::FormatError, 'Could not render to Puppet::Network::Format[pson]: source sequence is illegal/malformed utf-8')
+
+      expect {
+        handler.call(request, response)
+      }.to raise_error(Puppet::Network::HTTP::Error::HTTPNotAcceptableError, /No supported formats are acceptable/)
+    end
+
     it "should return [] when searching returns an empty array" do
-      request = a_request_that_searches(Puppet::IndirectorTesting.new("nothing"), :accept_header => "unknown, text/pson")
+      request = a_request_that_searches(Puppet::IndirectorTesting.new("nothing"), :accept_header => "unknown, application/json")
 
       handler.call(request, response)
 
       expect(response.body).to eq("[]")
-      expect(response.type).to eq(Puppet::Network::FormatHandler.format(:pson))
+      expect(response.type).to eq(Puppet::Network::FormatHandler.format(:json))
     end
 
     it "should raise not_found_error when searching returns nil" do
-      request = a_request_that_searches(Puppet::IndirectorTesting.new("nothing"), :accept_header => "unknown, text/pson")
+      request = a_request_that_searches(Puppet::IndirectorTesting.new("nothing"), :accept_header => "unknown, application/json")
       indirection.expects(:search).returns(nil)
 
       expect {
@@ -347,26 +363,15 @@ describe Puppet::Network::HTTP::API::IndirectedRoutes do
       expect(Puppet::IndirectorTesting.indirection.find("my data")).to be_nil
     end
 
-    it "responds with pson when no Accept header is given" do
-      data = Puppet::IndirectorTesting.new("my data")
-      indirection.save(data, "my data")
-      request = a_request_that_destroys(data, :accept_header => nil)
-
-      handler.call(request, response)
-
-      expect(response.body).to eq(data.render(:pson))
-      expect(response.type).to eq(Puppet::Network::FormatHandler.format(:pson))
-    end
-
     it "uses the first supported format for the response" do
       data = Puppet::IndirectorTesting.new("my data")
       indirection.save(data, "my data")
-      request = a_request_that_destroys(data, :accept_header => "unknown, text/pson")
+      request = a_request_that_destroys(data, :accept_header => "unknown, application/json")
 
       handler.call(request, response)
 
-      expect(response.body).to eq(data.render(:pson))
-      expect(response.type).to eq(Puppet::Network::FormatHandler.format(:pson))
+      expect(response.body).to eq(data.render(:json))
+      expect(response.type).to eq(Puppet::Network::FormatHandler.format(:json))
     end
 
     it "raises an error and does not destroy when no accepted formats are known" do
@@ -399,12 +404,8 @@ describe Puppet::Network::HTTP::API::IndirectedRoutes do
 
       handler.call(request, response)
 
-      # PUP-3272 this test fails when yaml is removed and pson is used. Instead of returning an
-      # empty string, the a string '""' is returned - Don't know what the expecation is, if this is
-      # corrent or not.
-      # (helindbe)
-      #
-      expect(Puppet::IndirectorTesting.indirection.find("test").name).to eq('')
+      saved = Puppet::IndirectorTesting.indirection.find("test")
+      expect(saved.name).to eq('')
     end
 
     it "saves the data sent in the request" do
@@ -417,24 +418,33 @@ describe Puppet::Network::HTTP::API::IndirectedRoutes do
       expect(saved.name).to eq(data.name)
     end
 
-    it "responds with pson when no Accept header is given" do
+    it "responds with bad request when failing to parse the body" do
       data = Puppet::IndirectorTesting.new("my data")
-      request = a_request_that_submits(data, :accept_header => nil)
+      request = a_request_that_submits(data, :content_type_header => 'application/json', :body => "this is invalid json content")
 
-      handler.call(request, response)
+      expect {
+        handler.call(request, response)
+      }.to raise_error(bad_request_error, /The request body is invalid: Could not intern from json/)
+    end
 
-      expect(response.body).to eq(data.render(:pson))
-      expect(response.type).to eq(Puppet::Network::FormatHandler.format(:pson))
+    it "responds with unsupported media type error when submitted content is known, but not supported by the model" do
+      data = Puppet::IndirectorTesting.new("my data")
+      request = a_request_that_submits(data, :content_type_header => 's')
+      expect(data).to_not be_support_format('s')
+
+      expect {
+        handler.call(request, response)
+      }.to raise_error(unsupported_media_type_error, /Client sent a mime-type \(s\) that doesn't correspond to a format we support/)
     end
 
     it "uses the first supported format for the response" do
       data = Puppet::IndirectorTesting.new("my data")
-      request = a_request_that_submits(data, :accept_header => "unknown, text/pson")
+      request = a_request_that_submits(data, :accept_header => "unknown, application/json")
 
       handler.call(request, response)
 
-      expect(response.body).to eq(data.render(:pson))
-      expect(response.type).to eq(Puppet::Network::FormatHandler.format(:pson))
+      expect(response.body).to eq(data.render(:json))
+      expect(response.type).to eq(Puppet::Network::FormatHandler.format(:json))
     end
 
     it "raises an error and does not save when no accepted formats are known" do

data/spec/unit/network/http/api/master/v3/environment_spec.rb

@@ -5,10 +5,18 @@ require 'puppet/network/http'
 describe Puppet::Network::HTTP::API::Master::V3::Environment do
   let(:response) { Puppet::Network::HTTP::MemoryResponse.new }
 
+  let(:environment) { Puppet::Node::Environment.create(:production, [], '/manifests') }
+  let(:loader) { Puppet::Environments::Static.new(environment) }
+
   around :each do |example|
-    environment = Puppet::Node::Environment.create(:production, [], '/manifests')
-    loader = Puppet::Environments::Static.new(environment)
+    Puppet[:app_management] = true
     Puppet.override(:environments => loader) do
+      Puppet::Type.newtype :sql, :is_capability => true do
+        newparam :name, :namevar => true
+      end
+      Puppet::Type.newtype :http, :is_capability => true do
+        newparam :name, :namevar => true
+      end
       example.run
     end
   end
@@ -25,6 +33,124 @@ describe Puppet::Network::HTTP::API::Master::V3::Environment do
     expect(catalog['applications']).to eq({})
   end
 
+  describe "processing the environment catalog" do
+    def compile_site_to_catalog(site, code_id=nil)
+      Puppet[:code] = <<-MANIFEST
+      define db() { }
+      Db produces Sql { }
+
+      define web() { }
+      Web consumes Sql { }
+      Web produces Http { }
+
+      application myapp() {
+        db { $name:
+          export => Sql[$name],
+        }
+        web { $name:
+          consume => Sql[$name],
+          export => Http[$name],
+        }
+      }
+      site {
+        #{site}
+      }
+      MANIFEST
+      Puppet::Parser::EnvironmentCompiler.compile(environment, code_id).filter { |r| r.virtual? }
+    end
+
+
+    it "includes specified applications" do
+      catalog = compile_site_to_catalog <<-MANIFEST
+      myapp { 'test':
+        nodes => {
+          Node['foo.example.com'] => Db['test'],
+          Node['bar.example.com'] => Web['test'],
+        },
+      }
+      MANIFEST
+
+      result = subject.build_environment_graph(catalog)
+
+      expect(result[:applications]).to eq({'Myapp[test]' =>
+                                            {'Db[test]' => {:produces => ['Sql[test]'], :consumes => [], :node => 'foo.example.com'},
+                                             'Web[test]' => {:produces => ['Http[test]'], :consumes => ['Sql[test]'], :node => 'bar.example.com'}}})
+    end
+
+    it "fails if a component isn't mapped to a node" do
+      catalog = compile_site_to_catalog <<-MANIFEST
+      myapp { 'test':
+        nodes => {
+          Node['foo.example.com'] => Db['test'],
+        }
+      }
+      MANIFEST
+
+      expect { subject.build_environment_graph(catalog) }.to raise_error(Puppet::ParseError, /has components without assigned nodes/)
+    end
+
+    it "fails if a non-existent component is mapped to a node" do
+      catalog = compile_site_to_catalog <<-MANIFEST
+      myapp { 'test':
+        nodes => {
+          Node['foo.example.com'] => [ Db['test'], Web['test'], Web['foobar'] ],
+        }
+      }
+      MANIFEST
+
+      expect { subject.build_environment_graph(catalog) }.to raise_error(Puppet::ParseError, /assigns nodes to non-existent components/)
+    end
+
+    it "fails if a component is mapped twice" do
+      catalog = compile_site_to_catalog <<-MANIFEST
+      myapp { 'test':
+        nodes => {
+          Node['foo.example.com'] => [ Db['test'], Web['test'] ],
+          Node['bar.example.com'] => [ Web['test'] ],
+        }
+      }
+      MANIFEST
+
+      expect { subject.build_environment_graph(catalog) }.to raise_error(Puppet::ParseError, /assigns multiple nodes to component/)
+    end
+
+    it "fails if an application maps components from other applications" do
+      catalog = compile_site_to_catalog <<-MANIFEST
+      myapp { 'test':
+        nodes => {
+          Node['foo.example.com'] => [ Db['test'], Web['test'] ],
+        }
+      }
+      myapp { 'other':
+        nodes => {
+          Node['foo.example.com'] => [ Db['other'], Web['other'], Web['test'] ],
+        }
+      }
+      MANIFEST
+
+      expect { subject.build_environment_graph(catalog) }.to raise_error(Puppet::ParseError, /assigns nodes to non-existent components/)
+    end
+
+    it "doesn't fail if the catalog contains a node cycle" do
+      catalog = compile_site_to_catalog <<-MANIFEST
+      myapp { 'test':
+        nodes => {
+          Node['foo.example.com'] => [ Db['test'] ],
+          Node['bar.example.com'] => [ Web['test'] ],
+        }
+      }
+      myapp { 'other':
+        nodes => {
+          Node['foo.example.com'] => [ Web['other'] ],
+          Node['bar.example.com'] => [ Db['other'] ],
+        }
+      }
+      MANIFEST
+
+      expect { subject.build_environment_graph(catalog) }.not_to raise_error
+    end
+  end
+
   it "returns 404 if the environment doesn't exist" do
     request = Puppet::Network::HTTP::Request.from_hash(:routing_path => "environment/development")
 

data/spec/unit/network/http/api/master/v3_spec.rb

@@ -41,7 +41,7 @@ describe Puppet::Network::HTTP::API::Master::V3 do
     request = Puppet::Network::HTTP::Request.
         from_hash(:path => "#{master_url_prefix}/node/foo",
                   :params => {:environment => "production"},
-                  :headers => {"accept" => "text/pson"})
+                  :headers => {"accept" => "application/json"})
     master_routes.process(request, response)
 
     expect(response.code).to eq(200)

data/spec/unit/network/http/api_spec.rb

@@ -79,7 +79,7 @@ describe Puppet::Network::HTTP::API do
       it "responds to v3 indirector requests" do
         req = Puppet::Network::HTTP::Request.from_hash(:path => "#{master_prefix}/v3/node/foo",
                                                        :params => {:environment => "production"},
-                                                       :headers => {'accept' => "pson"})
+                                                       :headers => {'accept' => "application/json"})
         res = {}
         handler.process(req, res)
         expect(res[:status]).to eq(200)

data/spec/unit/network/http/compression_spec.rb

@@ -2,6 +2,20 @@
 require 'spec_helper'
 
 describe "http compression" do
+  let(:data)            { "uncompresseddata" }
+  let(:response)        { stub 'response' }
+  let(:compressed_zlib) { Zlib::Deflate.deflate(data) }
+  let(:compressed_gzip) do
+    str = StringIO.new
+    writer = Zlib::GzipWriter.new(str)
+    writer.write(data)
+    writer.close.string
+  end
+
+  def stubs_response_with(response, content_encoding, body)
+    response.stubs(:[]).with('content-encoding').returns(content_encoding)
+    response.stubs(:body).returns(body)
+  end
 
   describe "when zlib is not available" do
     before(:each) do
@@ -24,8 +38,8 @@ describe "http compression" do
     end
 
     it "should not tamper the body" do
-      response = stub 'response', :body => "data"
-      expect(@uncompressor.uncompress_body(response)).to eq("data")
+      response = stub 'response', :body => data
+      expect(@uncompressor.uncompress_body(response)).to eq(data)
     end
 
     it "should yield an identity uncompressor" do
@@ -37,23 +51,19 @@ describe "http compression" do
   end
 
   describe "when zlib is available" do
-    before(:each) do
-      Puppet.features.stubs(:zlib?).returns true
-
-      require 'puppet/network/http/compression'
-      class HttpUncompressor
-        include Puppet::Network::HTTP::Compression::Active
-      end
-
-      @uncompressor = HttpUncompressor.new
+    require 'puppet/network/http/compression'
+    class ActiveUncompressor
+      include Puppet::Network::HTTP::Compression::Active
     end
 
+    let(:uncompressor) { ActiveUncompressor.new }
+
     it "should have a module function that returns the Active underlying module" do
       expect(Puppet::Network::HTTP::Compression.module).to eq(Puppet::Network::HTTP::Compression::Active)
     end
 
     it "should add an Accept-Encoding header supporting compression" do
-      headers = @uncompressor.add_accept_encoding({})
+      headers = uncompressor.add_accept_encoding({})
       expect(headers).to have_key('accept-encoding')
       expect(headers['accept-encoding']).to match(/gzip/)
       expect(headers['accept-encoding']).to match(/deflate/)
@@ -61,43 +71,34 @@ describe "http compression" do
     end
 
     describe "when uncompressing response body" do
-      before do
-        @response = stub 'response'
-        @response.stubs(:[]).with('content-encoding')
-        @response.stubs(:body).returns("mydata")
-      end
+      context "without compression" do
+        it "should return untransformed response body with no content-encoding" do
+          stubs_response_with(response, nil, data)
 
-      it "should return untransformed response body with no content-encoding" do
-        expect(@uncompressor.uncompress_body(@response)).to eq("mydata")
-      end
+          expect(uncompressor.uncompress_body(response)).to eq(data)
+        end
+
+        it "should return untransformed response body with 'identity' content-encoding" do
+          stubs_response_with(response, 'identity', data)
 
-      it "should return untransformed response body with 'identity' content-encoding" do
-        @response.stubs(:[]).with('content-encoding').returns('identity')
-        expect(@uncompressor.uncompress_body(@response)).to eq("mydata")
+          expect(uncompressor.uncompress_body(response)).to eq(data)
+        end
       end
 
-      it "should use a Zlib inflater with 'deflate' content-encoding" do
-        @response.stubs(:[]).with('content-encoding').returns('deflate')
+      context "with 'zlib' content-encoding" do
+        it "should use a Zlib inflater" do
+          stubs_response_with(response, 'deflate', compressed_zlib)
 
-        inflater = stub 'inflater'
-        Zlib::Inflate.expects(:new).returns(inflater)
-        inflater.expects(:inflate).with("mydata").returns "uncompresseddata"
+          expect(uncompressor.uncompress_body(response)).to eq(data)
+        end
 
-        expect(@uncompressor.uncompress_body(@response)).to eq("uncompresseddata")
       end
 
       context "with 'gzip' content-encoding" do
         it "should use a GzipReader" do
-          @response.stubs(:[]).with('content-encoding').returns('gzip')
+          stubs_response_with(response, 'gzip', compressed_gzip)
 
-          io = stub 'io'
-          StringIO.expects(:new).with("mydata").returns io
-
-          reader = stub 'gzip reader'
-          Zlib::GzipReader.expects(:new).with(io, :encoding => Encoding::BINARY).returns(reader)
-          reader.expects(:read).returns "uncompresseddata"
-
-          expect(@uncompressor.uncompress_body(@response)).to eq("uncompresseddata")
+          expect(uncompressor.uncompress_body(response)).to eq(data)
         end
 
         it "should correctly decompress PSON containing UTF-8 in Binary Encoding" do
@@ -117,10 +118,9 @@ describe "http compression" do
             default_external = Encoding.default_external
             Encoding.default_external = Encoding::ISO_8859_1
 
-            @response.stubs(:[]).with('content-encoding').returns('gzip')
-            @response.stubs(:body).returns(compressed_body)
+            stubs_response_with(response, 'gzip', compressed_body)
 
-            uncompressed = @uncompressor.uncompress_body(@response)
+            uncompressed = uncompressor.uncompress_body(response)
             # By default Zlib::GzipReader decompresses into Encoding.default_external, and we want to ensure our result is BINARY too
             expect(uncompressed.encoding).to eq(Encoding::BINARY)
             expect(uncompressed).to eq("\"foo\xDB\xBF\xE1\x9A\xA0\xF0\xA0\x9C\x8E\"".force_encoding(Encoding::BINARY))
@@ -132,89 +132,106 @@ describe "http compression" do
     end
 
     describe "when uncompressing by chunk" do
-      before do
-        @response = stub 'response'
-        @response.stubs(:[]).with('content-encoding')
+      it "should yield an identity uncompressor with no content-encoding" do
+        stubs_response_with(response, nil, data)
 
-        @inflater = stub_everything 'inflater'
-        Zlib::Inflate.stubs(:new).returns(@inflater)
+        expect { |b|
+          uncompressor.uncompress(response).yield_once_with(Puppet::Network::HTTP::Compression::IdentityAdapter, &b)
+        }
       end
 
-      it "should yield an identity uncompressor with no content-encoding" do
-        @uncompressor.uncompress(@response) { |u|
-          expect(u).to be_instance_of(Puppet::Network::HTTP::Compression::IdentityAdapter)
+      it "should yield an identity uncompressor with 'identity' content-encoding" do
+        stubs_response_with(response, 'identity', data)
+
+        expect { |b|
+          uncompressor.uncompress(response).yield_once_with(Puppet::Network::HTTP::Compression::IdentityAdapter, &b)
         }
       end
 
-      it "should yield an identity uncompressor with 'identity' content-encoding" do
-        @response.stubs(:[]).with('content-encoding').returns 'identity'
-        @uncompressor.uncompress(@response) { |u|
-          expect(u).to be_instance_of(Puppet::Network::HTTP::Compression::IdentityAdapter)
+      it "should yield a Zlib uncompressor with 'gzip' content-encoding" do
+        stubs_response_with(response, 'gzip', compressed_gzip)
+
+        expect { |b|
+          uncompressor.uncompress(response).yield_once_with(Puppet::Network::HTTP::Compression::ZlibAdapter, &b)
         }
       end
 
-      %w{gzip deflate}.each do |c|
-        it "should yield a Zlib uncompressor with '#{c}' content-encoding" do
-          @response.stubs(:[]).with('content-encoding').returns c
-          @uncompressor.uncompress(@response) { |u|
-            expect(u).to be_instance_of(Puppet::Network::HTTP::Compression::Active::ZlibAdapter)
-          }
-        end
+      it "should yield a Zlib uncompressor with 'deflate' content-encoding" do
+        stubs_response_with(response, 'deflate', compressed_zlib)
+
+        expect { |b|
+          uncompressor.uncompress(response).yield_once_with(Puppet::Network::HTTP::Compression::ZlibAdapter, &b)
+        }
       end
 
       it "should close the underlying adapter" do
+        stubs_response_with(response, 'identity', data)
         adapter = stub_everything 'adapter'
         Puppet::Network::HTTP::Compression::IdentityAdapter.expects(:new).returns(adapter)
 
         adapter.expects(:close)
-        @uncompressor.uncompress(@response) { |u| }
+        uncompressor.uncompress(response) { |u| }
       end
-    end
 
-    describe "zlib adapter" do
-      before do
-        @inflater = stub_everything 'inflater'
-        Zlib::Inflate.stubs(:new).returns(@inflater)
-        @adapter = Puppet::Network::HTTP::Compression::Active::ZlibAdapter.new
+      it "should close the underlying adapter if the yielded block raises" do
+        stubs_response_with(response, 'identity', data)
+        adapter = stub_everything 'adapter'
+        Puppet::Network::HTTP::Compression::IdentityAdapter.expects(:new).returns(adapter)
+
+        adapter.expects(:close)
+        expect {
+          uncompressor.uncompress(response) { |u| raise ArgumentError, "whoops" }
+        }.to raise_error(ArgumentError, "whoops")
       end
+    end
 
+    describe "zlib adapter" do
       it "should initialize the underlying inflater with gzip/zlib header parsing" do
         Zlib::Inflate.expects(:new).with(15+32)
+
         Puppet::Network::HTTP::Compression::Active::ZlibAdapter.new
       end
 
-      it "should inflate the given chunk" do
-        @inflater.expects(:inflate).with("chunk")
-        @adapter.uncompress("chunk")
-      end
+      it "should return the given chunk" do
+        adapter = Puppet::Network::HTTP::Compression::Active::ZlibAdapter.new
 
-      it "should return the inflated chunk" do
-        @inflater.stubs(:inflate).with("chunk").returns("uncompressed")
-        expect(@adapter.uncompress("chunk")).to eq("uncompressed")
+        expect(adapter.uncompress(compressed_zlib)).to eq(data)
       end
 
       it "should try a 'regular' inflater on Zlib::DataError" do
-        @inflater.expects(:inflate).raises(Zlib::DataError.new("not a zlib stream"))
-        inflater = stub_everything 'inflater2'
-        inflater.expects(:inflate).with("chunk").returns("uncompressed")
-        Zlib::Inflate.expects(:new).with.returns(inflater)
-        @adapter.uncompress("chunk")
+        inflater = Zlib::Inflate.new(15 + 32)
+        inflater.expects(:inflate).raises(Zlib::DataError.new("not a zlib stream"))
+        adapter = Puppet::Network::HTTP::Compression::Active::ZlibAdapter.new(inflater)
+
+        expect(adapter.uncompress(compressed_zlib)).to eq(data)
       end
 
       it "should raise the error the second time" do
-        @inflater.stubs(:inflate).raises(Zlib::DataError.new("not a zlib stream"))
-        Zlib::Inflate.expects(:new).with.returns(@inflater)
-        expect { @adapter.uncompress("chunk") }.to raise_error(Zlib::DataError, /not a zlib stream/)
+        inflater = Zlib::Inflate.new(15 + 32)
+        inflater.expects(:inflate).raises(Zlib::DataError.new("not a zlib stream"))
+        adapter = Puppet::Network::HTTP::Compression::Active::ZlibAdapter.new(inflater)
+
+        expect { adapter.uncompress("this is not compressed data") }.to raise_error(Zlib::DataError, /incorrect header check/)
       end
 
-      it "should finish the stream on close" do
-        @inflater.expects(:finish)
-        @adapter.close
+      it "should finish and close the stream" do
+        inflater = stub 'inflater'
+        inflater.expects(:finish)
+        inflater.expects(:close)
+        adapter = Puppet::Network::HTTP::Compression::Active::ZlibAdapter.new(inflater)
+
+        adapter.close
       end
 
-      it "should close the stream on close" do
-        @inflater.expects(:close)
-        @adapter.close
+      it "should close the stream even if finish raises" do
+        inflater = stub 'inflater'
+        inflater.expects(:finish).raises(Zlib::BufError)
+        inflater.expects(:close)
+
+        adapter = Puppet::Network::HTTP::Compression::Active::ZlibAdapter.new(inflater)
+        expect {
+          adapter.close
+        }.to raise_error(Zlib::BufError)
       end
     end
   end