resync-client 0.1.2 → 0.2.1

data/spec/unit/resync/client/client_spec.rb

@@ -3,17 +3,21 @@ require 'spec_helper'
 module Resync
   describe Client do
     before(:each) do
-      @helper = instance_double(HTTPHelper)
+      @helper = instance_double(Client::HTTPHelper)
       @client = Client.new(helper: @helper)
     end
 
-    describe '#get' do
+    describe '#get_and_parse' do
       it 'retrieves a CapabilityList' do
         uri = URI('http://example.org/capability-list.xml')
         data = File.read('spec/data/examples/capability-list.xml')
         expect(@helper).to receive(:fetch).with(uri: uri).and_return(data)
         doc = @client.get_and_parse(uri)
         expect(doc).to be_a(Resync::CapabilityList)
+        doc.resources.each do |r|
+          expect(r.client_delegate).to be(doc)
+          expect(r.client).to be(@client)
+        end
       end
 
       it 'retrieves a ChangeDump' do
@@ -22,6 +26,10 @@ module Resync
         expect(@helper).to receive(:fetch).with(uri: uri).and_return(data)
         doc = @client.get_and_parse(uri)
         expect(doc).to be_a(Resync::ChangeDump)
+        doc.resources.each do |r|
+          expect(r.client_delegate).to be(doc)
+          expect(r.client).to be(@client)
+        end
       end
 
       it 'retrieves a ChangeDumpManifest' do
@@ -30,6 +38,10 @@ module Resync
         expect(@helper).to receive(:fetch).with(uri: uri).and_return(data)
         doc = @client.get_and_parse(uri)
         expect(doc).to be_a(Resync::ChangeDumpManifest)
+        doc.resources.each do |r|
+          expect(r.client_delegate).to be(doc)
+          expect(r.client).to be(@client)
+        end
       end
 
       it 'retrieves a ChangeList' do
@@ -38,6 +50,10 @@ module Resync
         expect(@helper).to receive(:fetch).with(uri: uri).and_return(data)
         doc = @client.get_and_parse(uri)
         expect(doc).to be_a(Resync::ChangeList)
+        doc.resources.each do |r|
+          expect(r.client_delegate).to be(doc)
+          expect(r.client).to be(@client)
+        end
       end
 
       it 'retrieves a ResourceDump' do
@@ -46,6 +62,10 @@ module Resync
         expect(@helper).to receive(:fetch).with(uri: uri).and_return(data)
         doc = @client.get_and_parse(uri)
         expect(doc).to be_a(Resync::ResourceDump)
+        doc.resources.each do |r|
+          expect(r.client_delegate).to be(doc)
+          expect(r.client).to be(@client)
+        end
       end
 
       it 'retrieves a ResourceDumpManifest' do
@@ -54,6 +74,10 @@ module Resync
         expect(@helper).to receive(:fetch).with(uri: uri).and_return(data)
         doc = @client.get_and_parse(uri)
         expect(doc).to be_a(Resync::ResourceDumpManifest)
+        doc.resources.each do |r|
+          expect(r.client_delegate).to be(doc)
+          expect(r.client).to be(@client)
+        end
       end
 
       it 'retrieves a ResourceList' do
@@ -62,6 +86,10 @@ module Resync
         expect(@helper).to receive(:fetch).with(uri: uri).and_return(data)
         doc = @client.get_and_parse(uri)
         expect(doc).to be_a(Resync::ResourceList)
+        doc.resources.each do |r|
+          expect(r.client_delegate).to be(doc)
+          expect(r.client).to be(@client)
+        end
       end
 
       it 'retrieves a SourceDescription' do
@@ -70,6 +98,10 @@ module Resync
         expect(@helper).to receive(:fetch).with(uri: uri).and_return(data)
         doc = @client.get_and_parse(uri)
         expect(doc).to be_a(Resync::SourceDescription)
+        doc.resources.each do |r|
+          expect(r.client_delegate).to be(doc)
+          expect(r.client).to be(@client)
+        end
       end
 
       it 'retrieves a ChangeListIndex' do
@@ -78,6 +110,10 @@ module Resync
         expect(@helper).to receive(:fetch).with(uri: uri).and_return(data)
         doc = @client.get_and_parse(uri)
         expect(doc).to be_a(Resync::ChangeListIndex)
+        doc.resources.each do |r|
+          expect(r.client_delegate).to be(doc)
+          expect(r.client).to be(@client)
+        end
       end
 
       it 'retrieves a ResourceListIndex' do
@@ -86,6 +122,10 @@ module Resync
         expect(@helper).to receive(:fetch).with(uri: uri).and_return(data)
         doc = @client.get_and_parse(uri)
         expect(doc).to be_a(Resync::ResourceListIndex)
+        doc.resources.each do |r|
+          expect(r.client_delegate).to be(doc)
+          expect(r.client).to be(@client)
+        end
       end
 
       it 'injects the client into the returned document' do
@@ -94,6 +134,27 @@ module Resync
         expect(@helper).to receive(:fetch).with(uri: uri).and_return(data)
         doc = @client.get_and_parse(uri)
         expect(doc.client).to be(@client)
+        doc.resources.each do |r|
+          expect(r.client_delegate).to be(doc)
+          expect(r.client).to be(@client)
+        end
+      end
+
+      it 'injects the client recursively' do
+        uri = URI('http://example.org/resource-list-index.xml')
+        data = File.read('spec/data/examples/resource-list-index.xml')
+        resource_list_xml = File.read('spec/data/examples/resource-list.xml')
+        expect(@helper).to receive(:fetch).with(uri: uri).and_return(data)
+        doc = @client.get_and_parse(uri)
+        doc.resources.each do |r|
+          expect(r.client).to be(@client)
+          expect(@helper).to receive(:fetch).with(uri: r.uri).and_return(resource_list_xml)
+          resource_doc = r.get_and_parse
+          expect(resource_doc.client).to be(@client)
+          resource_doc.resources.each do |r2|
+            expect(r2.client).to be(@client)
+          end
+        end
       end
     end
 
@@ -101,7 +162,7 @@ module Resync
       it 'creates its own connection if none is provided' do
         uri = URI('http://example.org/capability-list.xml')
         data = File.read('spec/data/examples/capability-list.xml')
-        expect(HTTPHelper).to receive(:new).and_return(@helper)
+        expect(Client::HTTPHelper).to receive(:new).and_return(@helper)
         expect(@helper).to receive(:fetch).with(uri: uri).and_return(data)
         client = Client.new
         client.get_and_parse(uri)

data/spec/unit/resync/client/{resync_extensions_spec.rb → extensions_spec.rb}

@@ -1,6 +1,7 @@
 require 'spec_helper'
 
 module Resync
+
   describe 'extensions' do
 
     # ------------------------------------------------------------
@@ -53,12 +54,6 @@ module Resync
           expect(l.client).to be(client2)
         end
       end
-
-      it 'defaults to a new client' do
-        client = instance_double(Resync::Client)
-        expect(Resync::Client).to receive(:new) { client }
-        expect(@list.client).to be(client)
-      end
     end
 
     describe Resource do

data/spec/unit/resync/client/http_helper_spec.rb

@@ -1,235 +1,237 @@
 require 'spec_helper'
 
 module Resync
-  describe HTTPHelper do
+  class Client # rubocop:disable Metrics/ClassLength
+    describe HTTPHelper do
 
-    # ------------------------------------------------------------
-    # Fixture
-
-    attr_writer :user_agent
-
-    def user_agent
-      @user_agent ||= 'elvis'
-    end
-
-    attr_writer :helper
-
-    def helper
-      @helper ||= HTTPHelper.new(user_agent: user_agent)
-    end
+      # ------------------------------------------------------------
+      # Fixture
 
-    # ------------------------------------------------------------
-    # Tests
+      attr_writer :user_agent
 
-    describe '#fetch' do
+      def user_agent
+        @user_agent ||= 'elvis'
+      end
 
-      # ------------------------------
-      # Fixture
+      attr_writer :helper
 
-      before(:each) do
-        @http = instance_double(Net::HTTP)
-        allow(Net::HTTP).to receive(:new).and_return(@http)
-        allow(@http).to receive(:start).and_yield(@http)
-        @success = Net::HTTPOK.allocate
-        @body = 'I am the body of the response'
-        allow(@success).to receive(:body).and_return(@body)
+      def helper
+        @helper ||= HTTPHelper.new(user_agent: user_agent)
       end
 
-      # ------------------------------
+      # ------------------------------------------------------------
       # Tests
 
-      it 'requests the specified URI' do
-        uri = URI('http://example.org/')
-        expect(@http).to receive(:request).with(request_for(uri: uri)).and_yield(@success)
-        helper.fetch(uri: uri)
-      end
+      describe '#fetch' do
 
-      it 'gets a response' do
-        expect(@http).to receive(:request).and_yield(@success)
-        expect(helper.fetch(uri: URI('http://example.org/'))).to be(@body)
-      end
+        # ------------------------------
+        # Fixture
 
-      it 'sets the User-Agent header' do
-        agent = 'Not Elvis'
-        helper = HTTPHelper.new(user_agent: agent)
-        expect(@http).to receive(:request).with(request_for(headers: { 'User-Agent' => agent })).and_yield(@success)
-        helper.fetch(uri: URI('http://example.org/'))
-      end
+        before(:each) do
+          @http = instance_double(Net::HTTP)
+          allow(Net::HTTP).to receive(:new).and_return(@http)
+          allow(@http).to receive(:start).and_yield(@http)
+          @success = Net::HTTPOK.allocate
+          @body = 'I am the body of the response'
+          allow(@success).to receive(:body).and_return(@body)
+        end
 
-      it 'uses SSL for https requests' do
-        uri = URI('https://example.org/')
-        expect(Net::HTTP).to receive(:start).with(uri.hostname, uri.port, use_ssl: true).and_call_original
-        expect(@http).to receive(:request).and_yield(@success)
-        helper.fetch(uri: uri)
-      end
+        # ------------------------------
+        # Tests
 
-      it 're-requests on receiving a 1xx' do
-        uri = URI('http://example.org/')
-        @info = Net::HTTPContinue.allocate
+        it 'requests the specified URI' do
+          uri = URI('http://example.org/')
+          expect(@http).to receive(:request).with(request_for(uri: uri)).and_yield(@success)
+          helper.fetch(uri: uri)
+        end
 
-        expected = [@info, @success]
-        expect(@http).to receive(:request).twice.with(request_for(uri: uri, headers: { 'User-Agent' => user_agent })) do |&block|
-          block.call(expected.shift)
+        it 'gets a response' do
+          expect(@http).to receive(:request).and_yield(@success)
+          expect(helper.fetch(uri: URI('http://example.org/'))).to be(@body)
         end
 
-        expect(helper.fetch(uri: uri)).to be(@body)
-      end
+        it 'sets the User-Agent header' do
+          agent = 'Not Elvis'
+          helper = HTTPHelper.new(user_agent: agent)
+          expect(@http).to receive(:request).with(request_for(headers: { 'User-Agent' => agent })).and_yield(@success)
+          helper.fetch(uri: URI('http://example.org/'))
+        end
 
-      it 'redirects on receiving a 3xx' do
-        uri = URI('http://example.org/')
-        uri2 = URI('http://example.org/new')
-        @redirect = Net::HTTPMovedPermanently.allocate
-        allow(@redirect).to receive(:[]).with('location').and_return(uri2.to_s)
-        expect(@http).to receive(:request).with(request_for(uri: uri, headers: { 'User-Agent' => user_agent })).and_yield(@redirect)
-        expect(@http).to receive(:request).with(request_for(uri: uri2, headers: { 'User-Agent' => user_agent })).and_yield(@success)
-        expect(helper.fetch(uri: uri)).to be(@body)
-      end
+        it 'uses SSL for https requests' do
+          uri = URI('https://example.org/')
+          expect(Net::HTTP).to receive(:start).with(uri.hostname, uri.port, use_ssl: true).and_call_original
+          expect(@http).to receive(:request).and_yield(@success)
+          helper.fetch(uri: uri)
+        end
 
-      it 'only redirects a limited number of times' do
-        uri = URI('http://example.org/')
-        @redirect = Net::HTTPMovedPermanently.allocate
-        allow(@redirect).to receive(:[]).with('location').and_return(uri.to_s)
-        expect(@http).to receive(:request).with(request_for(uri: uri, headers: { 'User-Agent' => user_agent })).exactly(HTTPHelper::DEFAULT_MAX_REDIRECTS).times.and_yield(@redirect)
-        expect { helper.fetch(uri: uri) }.to raise_error
-      end
+        it 're-requests on receiving a 1xx' do
+          uri = URI('http://example.org/')
+          @info = Net::HTTPContinue.allocate
 
-      it 'fails on a 4xx' do
-        @error = Net::HTTPForbidden
-        allow(@error).to receive(:code).and_return(403)
-        allow(@error).to receive(:message).and_return('Forbidden')
-        expect(@http).to receive(:request).and_yield(@error)
-        uri = URI('http://example.org/')
-        expect { helper.fetch(uri: uri) }.to raise_error
-      end
+          expected = [@info, @success]
+          expect(@http).to receive(:request).twice.with(request_for(uri: uri, headers: { 'User-Agent' => user_agent })) do |&block|
+            block.call(expected.shift)
+          end
 
-      it 'fails on a 5xx' do
-        @error = Net::HTTPServerError
-        allow(@error).to receive(:code).and_return(500)
-        allow(@error).to receive(:message).and_return('Internal Server Error')
-        expect(@http).to receive(:request).and_yield(@error)
-        uri = URI('http://example.org/')
-        expect { helper.fetch(uri: uri) }.to raise_error
-      end
-    end
+          expect(helper.fetch(uri: uri)).to be(@body)
+        end
 
-    describe '#fetch_to_file' do
+        it 'redirects on receiving a 3xx' do
+          uri = URI('http://example.org/')
+          uri2 = URI('http://example.org/new')
+          @redirect = Net::HTTPMovedPermanently.allocate
+          allow(@redirect).to receive(:[]).with('location').and_return(uri2.to_s)
+          expect(@http).to receive(:request).with(request_for(uri: uri, headers: { 'User-Agent' => user_agent })).and_yield(@redirect)
+          expect(@http).to receive(:request).with(request_for(uri: uri2, headers: { 'User-Agent' => user_agent })).and_yield(@success)
+          expect(helper.fetch(uri: uri)).to be(@body)
+        end
 
-      # ------------------------------
-      # Fixture
+        it 'only redirects a limited number of times' do
+          uri = URI('http://example.org/')
+          @redirect = Net::HTTPMovedPermanently.allocate
+          allow(@redirect).to receive(:[]).with('location').and_return(uri.to_s)
+          expect(@http).to receive(:request).with(request_for(uri: uri, headers: { 'User-Agent' => user_agent })).exactly(HTTPHelper::DEFAULT_MAX_REDIRECTS).times.and_yield(@redirect)
+          expect { helper.fetch(uri: uri) }.to raise_error
+        end
 
-      before(:each) do
-        @path = nil
-        @http = instance_double(Net::HTTP)
-        allow(Net::HTTP).to receive(:new).and_return(@http)
-        allow(@http).to receive(:start).and_yield(@http)
+        it 'fails on a 4xx' do
+          @error = Net::HTTPForbidden
+          allow(@error).to receive(:code).and_return(403)
+          allow(@error).to receive(:message).and_return('Forbidden')
+          expect(@http).to receive(:request).and_yield(@error)
+          uri = URI('http://example.org/')
+          expect { helper.fetch(uri: uri) }.to raise_error
+        end
 
-        @data = (0...100).map { ('a'..'z').to_a[rand(26)] }.join
-        @success = Net::HTTPOK.allocate
-        allow(@success).to receive(:[]).with('Content-Type').and_return('text/plain')
-        stub = allow(@success).to receive(:read_body)
-        (0...10).each do |i|
-          chunk = @data[10 * i, 10]
-          stub = stub.and_yield(chunk)
+        it 'fails on a 5xx' do
+          @error = Net::HTTPServerError
+          allow(@error).to receive(:code).and_return(500)
+          allow(@error).to receive(:message).and_return('Internal Server Error')
+          expect(@http).to receive(:request).and_yield(@error)
+          uri = URI('http://example.org/')
+          expect { helper.fetch(uri: uri) }.to raise_error
         end
       end
 
-      after(:each) do
-        File.delete(@path) if @path
-      end
+      describe '#fetch_to_file' do
 
-      # ------------------------------
-      # Tests
+        # ------------------------------
+        # Fixture
 
-      it 'requests the specified URI' do
-        uri = URI('http://example.org/')
-        expect(@http).to receive(:request).with(request_for(uri: uri)).and_yield(@success)
-        @path = helper.fetch_to_file(uri: uri)
-      end
+        before(:each) do
+          @path = nil
+          @http = instance_double(Net::HTTP)
+          allow(Net::HTTP).to receive(:new).and_return(@http)
+          allow(@http).to receive(:start).and_yield(@http)
 
-      it 'returns the path to a file containing the response' do
-        uri = URI('http://example.org/')
-        expect(@http).to receive(:request).with(request_for(uri: uri)).and_yield(@success)
-        @path = helper.fetch_to_file(uri: uri)
-        expect(File.read(@path)).to eq(@data)
-      end
+          @data = (0...100).map { ('a'..'z').to_a[rand(26)] }.join
+          @success = Net::HTTPOK.allocate
+          allow(@success).to receive(:[]).with('Content-Type').and_return('text/plain')
+          stub = allow(@success).to receive(:read_body)
+          (0...10).each do |i|
+            chunk = @data[10 * i, 10]
+            stub = stub.and_yield(chunk)
+          end
+        end
 
-      it 'sets the User-Agent header' do
-        agent = 'Not Elvis'
-        helper = HTTPHelper.new(user_agent: agent)
-        expect(@http).to receive(:request).with(request_for(headers: { 'User-Agent' => agent })).and_yield(@success)
-        @path = helper.fetch_to_file(uri: URI('http://example.org/'))
-      end
+        after(:each) do
+          File.delete(@path) if @path
+        end
 
-      it 'uses SSL for https requests' do
-        uri = URI('https://example.org/')
-        expect(Net::HTTP).to receive(:start).with(uri.hostname, uri.port, use_ssl: true).and_call_original
-        expect(@http).to receive(:request).and_yield(@success)
-        @path = helper.fetch_to_file(uri: uri)
-      end
+        # ------------------------------
+        # Tests
 
-      it 're-requests on receiving a 1xx' do
-        uri = URI('http://example.org/')
-        @info = Net::HTTPContinue.allocate
+        it 'requests the specified URI' do
+          uri = URI('http://example.org/')
+          expect(@http).to receive(:request).with(request_for(uri: uri)).and_yield(@success)
+          @path = helper.fetch_to_file(uri: uri)
+        end
 
-        expected = [@info, @success]
-        expect(@http).to receive(:request).twice.with(request_for(uri: uri, headers: { 'User-Agent' => user_agent })) do |&block|
-          block.call(expected.shift)
+        it 'returns the path to a file containing the response' do
+          uri = URI('http://example.org/')
+          expect(@http).to receive(:request).with(request_for(uri: uri)).and_yield(@success)
+          @path = helper.fetch_to_file(uri: uri)
+          expect(File.read(@path)).to eq(@data)
         end
 
-        @path = helper.fetch_to_file(uri: uri)
-        expect(File.read(@path)).to eq(@data)
-      end
+        it 'sets the User-Agent header' do
+          agent = 'Not Elvis'
+          helper = HTTPHelper.new(user_agent: agent)
+          expect(@http).to receive(:request).with(request_for(headers: { 'User-Agent' => agent })).and_yield(@success)
+          @path = helper.fetch_to_file(uri: URI('http://example.org/'))
+        end
 
-      it 'redirects on receiving a 3xx' do
-        uri = URI('http://example.org/')
-        uri2 = URI('http://example.org/new')
-        @redirect = Net::HTTPMovedPermanently.allocate
-        allow(@redirect).to receive(:[]).with('location').and_return(uri2.to_s)
-        expect(@http).to receive(:request).with(request_for(uri: uri, headers: { 'User-Agent' => user_agent })).and_yield(@redirect)
-        expect(@http).to receive(:request).with(request_for(uri: uri2, headers: { 'User-Agent' => user_agent })).and_yield(@success)
-        @path = helper.fetch_to_file(uri: uri)
-        expect(File.read(@path)).to eq(@data)
-      end
+        it 'uses SSL for https requests' do
+          uri = URI('https://example.org/')
+          expect(Net::HTTP).to receive(:start).with(uri.hostname, uri.port, use_ssl: true).and_call_original
+          expect(@http).to receive(:request).and_yield(@success)
+          @path = helper.fetch_to_file(uri: uri)
+        end
 
-      it 'only redirects a limited number of times' do
-        uri = URI('http://example.org/')
-        @redirect = Net::HTTPMovedPermanently.allocate
-        allow(@redirect).to receive(:[]).with('location').and_return(uri.to_s)
-        expect(@http).to receive(:request).with(request_for(uri: uri, headers: { 'User-Agent' => user_agent })).exactly(HTTPHelper::DEFAULT_MAX_REDIRECTS).times.and_yield(@redirect)
-        expect { @path = helper.fetch_to_file(uri: uri) }.to raise_error
-        expect(@path).to be_nil
-      end
+        it 're-requests on receiving a 1xx' do
+          uri = URI('http://example.org/')
+          @info = Net::HTTPContinue.allocate
 
-      it 'fails on a 4xx' do
-        @error = Net::HTTPForbidden
-        allow(@error).to receive(:code).and_return(403)
-        allow(@error).to receive(:message).and_return('Forbidden')
-        expect(@http).to receive(:request).and_yield(@error)
-        uri = URI('http://example.org/')
-        expect { @path = helper.fetch_to_file(uri: uri) }.to raise_error
-        expect(@path).to be_nil
-      end
+          expected = [@info, @success]
+          expect(@http).to receive(:request).twice.with(request_for(uri: uri, headers: { 'User-Agent' => user_agent })) do |&block|
+            block.call(expected.shift)
+          end
 
-      it 'fails on a 5xx' do
-        @error = Net::HTTPServerError
-        allow(@error).to receive(:code).and_return(500)
-        allow(@error).to receive(:message).and_return('Internal Server Error')
-        expect(@http).to receive(:request).and_yield(@error)
-        uri = URI('http://example.org/')
-        expect { helper.fetch_to_file(uri: uri) }.to raise_error
-      end
+          @path = helper.fetch_to_file(uri: uri)
+          expect(File.read(@path)).to eq(@data)
+        end
 
-      it 'accepts a file path argument' do
-        Dir.mktmpdir do |dir|
-          expect(Dir.exist?(dir)).to be(true)
-          path = "#{dir}/http_helper_spec.out"
+        it 'redirects on receiving a 3xx' do
           uri = URI('http://example.org/')
-          expect(@http).to receive(:request).with(request_for(uri: uri)).and_yield(@success)
-          helper.fetch_to_file(uri: uri, path: path)
-          expect(File.read(path)).to eq(@data)
+          uri2 = URI('http://example.org/new')
+          @redirect = Net::HTTPMovedPermanently.allocate
+          allow(@redirect).to receive(:[]).with('location').and_return(uri2.to_s)
+          expect(@http).to receive(:request).with(request_for(uri: uri, headers: { 'User-Agent' => user_agent })).and_yield(@redirect)
+          expect(@http).to receive(:request).with(request_for(uri: uri2, headers: { 'User-Agent' => user_agent })).and_yield(@success)
+          @path = helper.fetch_to_file(uri: uri)
+          expect(File.read(@path)).to eq(@data)
+        end
+
+        it 'only redirects a limited number of times' do
+          uri = URI('http://example.org/')
+          @redirect = Net::HTTPMovedPermanently.allocate
+          allow(@redirect).to receive(:[]).with('location').and_return(uri.to_s)
+          expect(@http).to receive(:request).with(request_for(uri: uri, headers: { 'User-Agent' => user_agent })).exactly(HTTPHelper::DEFAULT_MAX_REDIRECTS).times.and_yield(@redirect)
+          expect { @path = helper.fetch_to_file(uri: uri) }.to raise_error
+          expect(@path).to be_nil
+        end
+
+        it 'fails on a 4xx' do
+          @error = Net::HTTPForbidden
+          allow(@error).to receive(:code).and_return(403)
+          allow(@error).to receive(:message).and_return('Forbidden')
+          expect(@http).to receive(:request).and_yield(@error)
+          uri = URI('http://example.org/')
+          expect { @path = helper.fetch_to_file(uri: uri) }.to raise_error
+          expect(@path).to be_nil
+        end
+
+        it 'fails on a 5xx' do
+          @error = Net::HTTPServerError
+          allow(@error).to receive(:code).and_return(500)
+          allow(@error).to receive(:message).and_return('Internal Server Error')
+          expect(@http).to receive(:request).and_yield(@error)
+          uri = URI('http://example.org/')
+          expect { helper.fetch_to_file(uri: uri) }.to raise_error
+        end
+
+        it 'accepts a file path argument' do
+          Dir.mktmpdir do |dir|
+            expect(Dir.exist?(dir)).to be(true)
+            path = "#{dir}/http_helper_spec.out"
+            uri = URI('http://example.org/')
+            expect(@http).to receive(:request).with(request_for(uri: uri)).and_yield(@success)
+            helper.fetch_to_file(uri: uri, path: path)
+            expect(File.read(path)).to eq(@data)
+          end
         end
       end
-    end
 
+    end
   end
 end