chef 10.34.6-x86-mingw32 → 11.6.2-x86-mingw32

data/spec/unit/provider/remote_file/http_spec.rb

@@ -0,0 +1,319 @@
+#
+# Author:: Lamont Granquist (<lamont@opscode.com>)
+# Copyright:: Copyright (c) 2013 Lamont Granquist
+# License:: Apache License, Version 2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+require 'spec_helper'
+
+describe Chef::Provider::RemoteFile::HTTP do
+
+  let(:uri) { URI.parse("http://opscode.com/seattle.txt") }
+
+  let(:existing_file_source) { nil }
+
+  let(:current_resource_checksum) { "41e78735319af11327e9d2ca8535ea1c191e5ac1f76bb08d88fe6c3f93a8c8e5" }
+
+  let(:current_resource) do
+    current_resource = Chef::Resource::RemoteFile.new("/tmp/foo.txt")
+    current_resource.source(existing_file_source) if existing_file_source
+    current_resource.checksum(current_resource_checksum)
+    current_resource
+  end
+
+  let(:new_resource) do
+    Chef::Resource::RemoteFile.new("/tmp/foo.txt")
+  end
+
+  subject(:fetcher) do
+    Chef::Provider::RemoteFile::HTTP.new(uri, new_resource, current_resource)
+  end
+
+  let(:cache_control_data) { Chef::Provider::RemoteFile::CacheControlData.new(uri) }
+
+  describe "generating cache control headers" do
+
+    context "and there is no valid cache control data for this URI on disk" do
+
+      before do
+        Chef::Provider::RemoteFile::CacheControlData.should_receive(:load_and_validate).with(uri, current_resource_checksum).and_return(cache_control_data)
+      end
+
+      it "does not add conditional GET headers" do
+        fetcher.conditional_get_headers.should == {}
+      end
+
+      context "and the resource specifies custom headers" do
+        before do
+          new_resource.headers("x-myapp-header" => "custom-header-value")
+        end
+
+        it "has the user-specified custom headers" do
+          fetcher.headers.should == {"x-myapp-header" => "custom-header-value"}
+        end
+      end
+
+    end
+
+    context "and the cache control data matches the existing file" do
+
+      # http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html#sec14.26
+      let(:etag) { "\"a-strong-unique-identifier\"" }
+
+      # http://www.w3.org/Protocols/rfc2616/rfc2616-sec3.html#sec3.3
+      let(:mtime) { "Tue, 21 May 2013 19:19:23 GMT" }
+
+      before do
+        cache_control_data.etag = etag
+        cache_control_data.mtime = mtime
+
+        Chef::Provider::RemoteFile::CacheControlData.should_receive(:load_and_validate).with(uri, current_resource_checksum).and_return(cache_control_data)
+      end
+
+      context "and no conditional get features are enabled" do
+        before do
+          new_resource.use_conditional_get(false)
+        end
+
+        it "does not add headers to the request" do
+          fetcher.headers.should == {}
+        end
+      end
+
+      context "and conditional get is enabled" do
+        before do
+          new_resource.use_conditional_get(true)
+        end
+
+        it "adds If-None-Match and If-Modified-Since headers to the request" do
+          headers = fetcher.headers
+          headers["if-none-match"].should == etag
+          headers["if-modified-since"].should == mtime
+        end
+
+        context "and custom headers are provided" do
+          before do
+            new_resource.headers("x-myapp-header" => "app-specific-header",
+                                 "if-none-match" => "custom-etag",
+                                 "if-modified-since" => "custom-last-modified")
+          end
+
+          it "preserves non-conflicting headers" do
+            fetcher.headers["x-myapp-header"].should == "app-specific-header"
+          end
+
+          it "prefers user-supplied cache control headers" do
+            headers = fetcher.headers
+            headers["if-none-match"].should == "custom-etag"
+            headers["if-modified-since"].should == "custom-last-modified"
+          end
+        end
+
+      end
+
+      context "and etag support is enabled" do
+        before do
+          new_resource.use_conditional_get(false)
+          new_resource.use_etags(true)
+        end
+
+        it "only adds If-None-Match headers to the request" do
+          headers = fetcher.headers
+          headers["if-none-match"].should == etag
+          headers.should_not have_key("if-modified-since")
+        end
+      end
+
+      context "and mtime support is enabled" do
+        before do
+          new_resource.use_conditional_get(false)
+          new_resource.use_last_modified(true)
+        end
+
+        it "only adds If-Modified-Since headers to the request" do
+          headers = fetcher.headers
+          headers["if-modified-since"].should == mtime
+          headers.should_not have_key("if-none-match")
+        end
+      end
+    end
+
+  end
+
+  describe "when fetching the uri" do
+
+    let(:expected_http_opts) { {} }
+    let(:expected_http_args) { [uri, nil, nil, expected_http_opts] }
+
+    let(:tempfile_path) { "/tmp/chef-mock-tempfile-abc123" }
+
+    let(:tempfile) { mock(Tempfile, :path => tempfile_path) }
+
+    let(:last_response) { {} }
+
+    let(:rest) do
+      rest = mock(Chef::REST)
+      rest.stub!(:streaming_request).and_return(tempfile)
+      rest.stub!(:last_response).and_return(last_response)
+      rest
+    end
+
+    before do
+      new_resource.headers({})
+      new_resource.use_last_modified(false)
+      Chef::Provider::RemoteFile::CacheControlData.should_receive(:load_and_validate).with(uri, current_resource_checksum).and_return(cache_control_data)
+
+      Chef::REST.should_receive(:new).with(*expected_http_args).and_return(rest)
+    end
+
+
+    describe "and the request does not return new content" do
+
+      it "should propagate non-304 exceptions to the caller" do
+        r = Net::HTTPBadRequest.new("one", "two", "three")
+        e = Net::HTTPServerException.new("fake exception", r)
+        rest.stub!(:streaming_request).and_raise(e)
+        lambda { fetcher.fetch }.should raise_error(Net::HTTPServerException)
+      end
+
+      it "should return HTTPRetriableError when Chef::REST returns a 301" do
+        r = Net::HTTPMovedPermanently.new("one", "two", "three")
+        e = Net::HTTPRetriableError.new("301", r)
+        rest.stub!(:streaming_request).and_raise(e)
+        lambda { fetcher.fetch }.should raise_error(Net::HTTPRetriableError)
+      end
+
+      it "should return a nil tempfile for a 304 HTTPNotModifed" do
+        r = Net::HTTPNotModified.new("one", "two", "three")
+        e = Net::HTTPRetriableError.new("304", r)
+        rest.stub!(:streaming_request).and_raise(e)
+        result = fetcher.fetch
+        result.should be_nil
+      end
+
+    end
+
+    describe "and the request returns new content" do
+
+      let(:fetched_content_checksum) { "e2a8938cc31754f6c067b35aab1d0d4864272e9bf8504536ef3e79ebf8432305" }
+
+      before do
+        cache_control_data.should_receive(:save)
+        Chef::Digester.should_receive(:checksum_for_file).with(tempfile_path).and_return(fetched_content_checksum)
+      end
+
+      it "should return a tempfile" do
+        result = fetcher.fetch
+        result.should == tempfile
+        cache_control_data.etag.should be_nil
+        cache_control_data.mtime.should be_nil
+        cache_control_data.checksum.should == fetched_content_checksum
+      end
+
+      context "and the response does not contain an etag" do
+        let(:last_response) { {"etag" => nil} }
+        it "does not include an etag in the result" do
+          fetcher.fetch
+          cache_control_data.etag.should be_nil
+          cache_control_data.mtime.should be_nil
+          cache_control_data.checksum.should == fetched_content_checksum
+        end
+      end
+
+      context "and the response has an etag header" do
+        let(:last_response) { {"etag" => "abc123"} }
+
+        it "includes the etag value in the response" do
+          fetcher.fetch
+          cache_control_data.etag.should == "abc123"
+          cache_control_data.mtime.should be_nil
+          cache_control_data.checksum.should == fetched_content_checksum
+        end
+
+      end
+
+      context "and the response has no Date or Last-Modified header" do
+        let(:last_response) { {"date" => nil, "last_modified" => nil} }
+        it "does not set an mtime in the result" do
+          # RFC 2616 suggests that servers that do not set a Date header do not
+          # have a reliable clock, so no use in making them deal with dates.
+          fetcher.fetch
+          cache_control_data.etag.should be_nil
+          cache_control_data.mtime.should be_nil
+          cache_control_data.checksum.should == fetched_content_checksum
+        end
+      end
+
+      context "and the response has a Last-Modified header" do
+        let(:last_response) do
+          # Last-Modified should be preferred to Date if both are set
+          {"date" => "Fri, 17 May 2013 23:23:23 GMT", "last_modified" => "Fri, 17 May 2013 11:11:11 GMT"}
+        end
+
+        it "sets the mtime to the Last-Modified time in the response" do
+          fetcher.fetch
+          cache_control_data.etag.should be_nil
+          cache_control_data.mtime.should == last_response["last_modified"]
+        end
+      end
+
+      context "and the response has a Date header but no Last-Modified header" do
+        let(:last_response) do
+          {"date" => "Fri, 17 May 2013 23:23:23 GMT", "last_modified" => nil}
+        end
+
+        it "sets the mtime to the Date in the response" do
+          fetcher.fetch
+          cache_control_data.etag.should be_nil
+          cache_control_data.mtime.should == last_response["date"]
+          cache_control_data.checksum.should == fetched_content_checksum
+        end
+
+      end
+
+      context "and the target file is a tarball [CHEF-3140]" do
+
+        let(:uri) { URI.parse("http://opscode.com/tarball.tgz") }
+        let(:expected_http_opts) { {:disable_gzip => true} }
+
+        # CHEF-3140
+        # Some servers return tarballs as content type tar and encoding gzip, which
+        # is totally wrong. When this happens and gzip isn't disabled, Chef::REST
+        # will decompress the file for you, which is not at all what you expected
+        # to happen (you end up with an uncomressed tar archive instead of the
+        # gzipped tar archive you expected). To work around this behavior, we
+        # detect when users are fetching gzipped files and turn off gzip in
+        # Chef::REST.
+
+        it "should disable gzip compression in the client" do
+          # Before block in the parent context has set an expectation on
+          # Chef::REST.new() being called with expected arguments. Here we fufil
+          # that expectation, so that we can explicitly set it for this test.
+          # This is intended to provide insurance that refactoring of the parent
+          # context does not negate the value of this particular example.
+          Chef::REST.new(*expected_http_args)
+          Chef::REST.should_receive(:new).once.with(*expected_http_args).and_return(rest)
+          fetcher.fetch
+          cache_control_data.etag.should be_nil
+          cache_control_data.mtime.should be_nil
+          cache_control_data.checksum.should == fetched_content_checksum
+        end
+      end
+    end
+
+  end
+
+end
+

data/spec/unit/provider/remote_file/local_file_spec.rb

@@ -0,0 +1,60 @@
+#
+# Author:: Jesse Campbell (<hikeit@gmail.com>)
+# Copyright:: Copyright (c) 2013 Jesse Campbell
+# License:: Apache License, Version 2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+require 'spec_helper'
+
+describe Chef::Provider::RemoteFile::LocalFile do
+
+  let(:uri) { URI.parse("file:///nyan_cat.png") }
+
+  let(:new_resource) { Chef::Resource::RemoteFile.new("local file backend test (new_resource)") }
+  let(:current_resource) { Chef::Resource::RemoteFile.new("local file backend test (current_resource)") }
+  subject(:fetcher) { Chef::Provider::RemoteFile::LocalFile.new(uri, new_resource, current_resource) }
+
+  context "when first created" do
+
+    it "stores the uri it is passed" do
+      fetcher.uri.should == uri
+    end
+
+    it "stores the new_resource" do
+      fetcher.new_resource.should == new_resource
+    end
+
+  end
+
+  describe "when fetching the object" do
+
+    let(:tempfile) { mock("Tempfile", :path => "/tmp/foo/bar/nyan.png") }
+    let(:chef_tempfile) { mock("Chef::FileContentManagement::Tempfile", :tempfile => tempfile) }
+
+    before do
+      current_resource.source("file:///nyan_cat.png")
+    end
+
+    it "stages the local file to a temporary file" do
+      Chef::FileContentManagement::Tempfile.should_receive(:new).with(new_resource).and_return(chef_tempfile)
+      ::FileUtils.should_receive(:cp).with(uri.path, tempfile.path)
+
+      result = fetcher.fetch
+      result.should == tempfile
+    end
+
+  end
+
+end

data/spec/unit/provider/remote_file_spec.rb

@@ -1,6 +1,7 @@
 #
 # Author:: Adam Jacob (<adam@opscode.com>)
-# Copyright:: Copyright (c) 2008 Opscode, Inc.
+# Author:: Lamont Granquist (<lamont@opscode.com>)
+# Copyright:: Copyright (c) 2008-2013 Opscode, Inc.
 # License:: Apache License, Version 2.0
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -18,271 +19,44 @@
 
 require 'spec_helper'
 
-describe Chef::Provider::RemoteFile, "action_create" do
-  before(:each) do
-    @resource = Chef::Resource::RemoteFile.new("seattle")
-    @resource.path(File.expand_path(File.join(CHEF_SPEC_DATA, "seattle.txt")))
-    @resource.source("http://foo")
-    @node = Chef::Node.new
-    @node.name "latte"
+require 'support/shared/unit/provider/file'
 
-    @events = Chef::EventDispatch::Dispatcher.new
-    @run_context = Chef::RunContext.new(@node, {}, @events)
 
-    @provider = Chef::Provider::RemoteFile.new(@resource, @run_context)
-    #To prevent the current_resource.checksum from being overridden.
-    @provider.stub!(:load_current_resource)
+describe Chef::Provider::RemoteFile do
+  let(:resource) do
+    resource = Chef::Resource::RemoteFile.new("seattle", @run_context)
+    resource.path(resource_path)
+    resource.source("http://foo")
+    resource.cookbook_name = "monkey"
+    resource
   end
 
-  describe "when checking if the file is at the target version" do
-    it "considers the current file to be at the target version if it exists and matches the user-provided checksum" do
-      @provider.current_resource = @resource.dup
-      @resource.checksum("0fd012fdc96e96f8f7cf2046522a54aed0ce470224513e45da6bc1a17a4924aa")
-      @provider.current_resource.checksum("0fd012fdc96e96f8f7cf2046522a54aed0ce470224513e45da6bc1a17a4924aa")
-      @provider.current_resource_matches_target_checksum?.should be_true
-    end
+  let(:content) do
+    content = mock('Chef::Provider::File::Content::RemoteFile')
   end
 
-  describe "when fetching the file from the remote" do
-    before(:each) do
-      @tempfile = Tempfile.new("chef-rspec-remote_file_spec-line#{__LINE__}--")
-
-      @rest = mock(Chef::REST, { })
-      Chef::REST.stub!(:new).and_return(@rest)
-      @rest.stub!(:streaming_request).and_return(@tempfile)
-      @rest.stub!(:create_url) { |url| url } 
-      @resource.cookbook_name = "monkey"
-
-      @provider.stub!(:checksum).and_return("0fd012fdc96e96f8f7cf2046522a54aed0ce470224513e45da6bc1a17a4924aa")
-      @provider.current_resource = @resource.clone
-      @provider.current_resource.checksum("0fd012fdc96e96f8f7cf2046522a54aed0ce470224513e45da6bc1a17a4924aa")
-      File.stub!(:exists?).and_return(true)
-      FileUtils.stub!(:cp).and_return(true)
-      Chef::Platform.stub!(:find_platform_and_version).and_return([ :mac_os_x, "10.5.1" ])
-    end
-
-    after do
-      @tempfile.close!
-    end
-
-    before do
-      @resource.source("http://opscode.com/seattle.txt")
-    end
-
-    describe "and the target location's enclosing directory does not exist" do
-      before do
-        @resource.path("/tmp/this/path/does/not/exist/file.txt")
-      end
-
-      it "raises a specific error describing the problem" do
-        lambda {@provider.run_action(:create)}.should raise_error(Chef::Exceptions::EnclosingDirectoryDoesNotExist)
-      end
-    end
-
-    describe "and the resource specifies a checksum" do
-
-      describe "and the existing file matches the checksum exactly" do
-        before do
-          @resource.checksum("0fd012fdc96e96f8f7cf2046522a54aed0ce470224513e45da6bc1a17a4924aa")
-        end
-
-        it "does not download the file" do
-          @rest.should_not_receive(:fetch).with("http://opscode.com/seattle.txt").and_return(@tempfile)
-          @provider.run_action(:create)
-        end
-
-        it "does not update the resource" do
-          @provider.run_action(:create)
-          @provider.new_resource.should_not be_updated
-        end
-
-      end
-
-      describe "and the existing file matches the given partial checksum" do
-        before do
-          @resource.checksum("0fd012fd")
-        end
-
-        it "should not download the file if the checksum is a partial match from the beginning" do
-          @rest.should_not_receive(:fetch).with("http://opscode.com/seattle.txt").and_return(@tempfile)
-          @provider.run_action(:create)
-        end
-
-        it "does not update the resource" do
-          @provider.run_action(:create)
-          @provider.new_resource.should_not be_updated
-        end
-
-      end
-
-      describe "and the existing file doesn't match the given checksum" do
-        it "downloads the file" do
-          @resource.checksum("this hash doesn't match")
-          @rest.should_receive(:streaming_request).with("http://opscode.com/seattle.txt", {}).and_return(@tempfile)
-          @provider.stub!(:update_new_file_state)
-          @provider.run_action(:create)
-        end
-
-        it "does not consider the checksum a match if the matching string is offset" do
-          # i.e., the existing file is      "0fd012fdc96e96f8f7cf2046522a54aed0ce470224513e45da6bc1a17a4924aa"
-          @resource.checksum("fd012fd")
-          @rest.should_receive(:streaming_request).with("http://opscode.com/seattle.txt", {}).and_return(@tempfile)
-          @provider.stub!(:update_new_file_state)
-          @provider.run_action(:create)
-        end
-      end
-
-    end
-
-    describe "and the resource doesn't specify a checksum" do
-      it "should download the file from the remote URL" do
-        @resource.checksum(nil)
-        @rest.should_receive(:streaming_request).with("http://opscode.com/seattle.txt", {}).and_return(@tempfile)
-        @provider.run_action(:create)
-      end
-    end
-
-    # CHEF-3140
-    # Some servers return tarballs as content type tar and encoding gzip, which
-    # is totally wrong. When this happens and gzip isn't disabled, Chef::REST
-    # will decompress the file for you, which is not at all what you expected
-    # to happen (you end up with an uncomressed tar archive instead of the
-    # gzipped tar archive you expected). To work around this behavior, we
-    # detect when users are fetching gzipped files and turn off gzip in
-    # Chef::REST.
-
-    context "and the target file is a tarball" do
-      before do
-        @resource.path(File.expand_path(File.join(CHEF_SPEC_DATA, "seattle.tar.gz")))
-        Chef::REST.should_receive(:new).with("http://opscode.com/seattle.txt", nil, nil, :disable_gzip => true).and_return(@rest)
-      end
-
-      it "disables gzip in the http client" do
-        @provider.action_create
-      end
-
-    end
-
-    context "and the source appears to be a tarball" do
-      before do
-        @resource.source("http://example.com/tarball.tgz")
-        Chef::REST.should_receive(:new).with("http://example.com/tarball.tgz", nil, nil, :disable_gzip => true).and_return(@rest)
-      end
-
-      it "disables gzip in the http client" do
-        @provider.action_create
-      end
-    end
-
-    it "should raise an exception if it's any other kind of retriable response than 304" do
-      r = Net::HTTPMovedPermanently.new("one", "two", "three")
-      e = Net::HTTPRetriableError.new("301", r)
-      @rest.stub!(:streaming_request).and_raise(e)
-      lambda { @provider.run_action(:create) }.should raise_error(Net::HTTPRetriableError)
-    end
-
-    it "should raise an exception if anything else happens" do
-      r = Net::HTTPBadRequest.new("one", "two", "three")
-      e = Net::HTTPServerException.new("fake exception", r)
-      @rest.stub!(:streaming_request).and_raise(e)
-      lambda { @provider.run_action(:create) }.should raise_error(Net::HTTPServerException)
-    end
-
-    it "should checksum the raw file" do
-      @provider.should_receive(:checksum).with(@tempfile.path).and_return("0fd012fdc96e96f8f7cf2046522a54aed0ce470224513e45da6bc1a17a4924aa")
-      @provider.run_action(:create)
-    end
-
-    describe "when the target file does not exist" do
-      before do
-        ::File.stub!(:exists?).with(@resource.path).and_return(false)
-        @provider.stub!(:get_from_server).and_return(@tempfile)
-      end
-
-      it "should copy the raw file to the new resource" do
-        FileUtils.should_receive(:cp).with(@tempfile.path, @resource.path).and_return(true)
-        @provider.stub!(:update_new_file_state)
-        @provider.run_action(:create)
-      end
-
-      it "should set the new resource to updated" do
-        @provider.stub!(:update_new_file_state)
-        @provider.run_action(:create)
-        @resource.should be_updated
-      end
-
-      describe "and create_if_missing is invoked" do
-        it "should invoke action_create" do
-          @provider.should_receive(:action_create)
-          @provider.run_action(:create_if_missing)
-        end
-      end
-    end
-
-    describe "when the target file already exists" do
-      before do
-        ::File.stub!(:exists?).with(@resource.path).and_return(true)
-        @provider.stub!(:diff_current).and_return([
-         "--- /tmp/foo  2012-08-30 21:28:17.632782551 +0000",
-         "+++ /tmp/bar 2012-08-30 21:28:20.816975437 +0000",
-         "@@ -1 +1 @@",
-         "-foo bar",
-         "+bar foo"
-        ])
-        @provider.stub!(:get_from_server).and_return(@tempfile)
-      end
-
-      describe "and create_if_missing is invoked" do
-        it "should take no action" do
-          @provider.should_not_receive(:action_create) 
-          @provider.run_action(:create_if_missing)
-        end
-      end
-
-      describe "and the file downloaded from the remote is identical to the current" do
-        it "shouldn't backup the original file" do
-          @provider.should_not_receive(:backup).with(@resource.path)
-          @provider.run_action(:create)
-        end
-
-        it "doesn't mark the resource as updated" do
-          @provider.run_action(:create)
-          @provider.new_resource.should_not be_updated
-        end
-      end
-
-      describe "and the checksum doesn't match" do
-        before do
-          sha2_256 = "0fd012fdc96e96f8f7cf2046522a54aed0ce470224513e45da6bc1a17a4924aa-NO_MATCHY"
-          @provider.current_resource.checksum(sha2_256)
-        end
-
-        it "should backup the original file" do
-          @provider.stub!(:update_new_file_state)
-          @provider.should_receive(:backup).with(@resource.path).and_return(true)
-          @provider.run_action(:create)
-        end
-
-        it "should copy the raw file to the new resource" do
-          @provider.stub!(:update_new_file_state)
-          FileUtils.should_receive(:cp).with(@tempfile.path, @resource.path).and_return(true)
-          @provider.run_action(:create)
-        end
-
-        it "should set the new resource to updated" do
-          @provider.stub!(:update_new_file_state)
-          @provider.run_action(:create)
-          @resource.should be_updated
-        end
-      end
-
-      it "should set permissions" do
-        @provider.should_receive(:set_all_access_controls).and_return(true)
-        @provider.run_action(:create)
-      end
+  let(:node) { double('Chef::Node') }
+  let(:events) { double('Chef::Events').as_null_object }  # mock all the methods
+  let(:run_context) { double('Chef::RunContext', :node => node, :events => events) }
+  let(:enclosing_directory) {
+    canonicalize_path(File.expand_path(File.join(CHEF_SPEC_DATA, "templates")))
+  }
+  let(:resource_path) {
+    canonicalize_path(File.expand_path(File.join(enclosing_directory, "seattle.txt")))
+  }
+
+  subject(:provider) do
+    provider = described_class.new(resource, run_context)
+    provider.stub!(:content).and_return(content)
+    provider.stub!(:update_new_resource_checksum).and_return(nil) # Otherwise it doesn't behave like a File provider
+    provider
+  end
 
+  before do
+    Chef::FileCache.stub!(:load).with("remote_file/#{resource.name}").and_raise(Chef::Exceptions::FileNotFound)
+  end
 
-    end
+  it_behaves_like Chef::Provider::File
 
-  end
 end
+