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

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

@@ -0,0 +1,230 @@
+#
+# Author:: Lamont Granquist (<lamont@opscode.com>)
+# Copyright:: Copyright (c) 2013 Opscode, Inc.
+# 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::Content do
+
+  #
+  # mock setup
+  #
+
+  let(:current_resource) do
+    Chef::Resource::RemoteFile.new("remote-file-content-spec (current resource)")
+  end
+
+  let(:source) { [ "http://opscode.com/seattle.txt" ] }
+
+  let(:new_resource) do
+    r = Chef::Resource::RemoteFile.new("remote-file-content-spec (current resource)")
+    r.source(source)
+    r
+  end
+
+  let(:run_context) { mock("Chef::RunContext") }
+
+  #
+  # subject
+  #
+  let(:content) do
+    Chef::Provider::RemoteFile::Content.new(new_resource, current_resource, run_context)
+  end
+
+  describe "when the checksum of the current_resource matches the checksum set on the resource" do
+    before do
+      new_resource.stub!(:checksum).and_return("0fd012fdc96e96f8f7cf2046522a54aed0ce470224513e45da6bc1a17a4924aa")
+      current_resource.stub!(:checksum).and_return("0fd012fdc96e96f8f7cf2046522a54aed0ce470224513e45da6bc1a17a4924aa")
+    end
+
+    it "should return nil for the tempfile" do
+      content.tempfile.should be_nil
+    end
+
+    it "should not call any fetcher" do
+      Chef::Provider::RemoteFile::Fetcher.should_not_receive(:for_resource)
+    end
+  end
+
+  describe "when the checksum of the current_resource is a partial match for the checksum set on the resource" do
+    before do
+      new_resource.stub!(:checksum).and_return("0fd012fd")
+      current_resource.stub!(:checksum).and_return("0fd012fdc96e96f8f7cf2046522a54aed0ce470224513e45da6bc1a17a4924aa")
+    end
+
+    it "should return nil for the tempfile" do
+      content.tempfile.should be_nil
+    end
+
+    it "should not call any fetcher" do
+      Chef::Provider::RemoteFile::Fetcher.should_not_receive(:for_resource)
+    end
+  end
+
+  shared_examples_for "the resource needs fetching" do
+    before do
+      # FIXME: test one or the other nil, test both not nil and not equal, abuse the regexp a little
+      @uri = mock("URI")
+      URI.should_receive(:parse).with(new_resource.source[0]).and_return(@uri)
+    end
+
+    describe "when the fetcher returns nil for the tempfile" do
+      before do
+        http_fetcher = mock("Chef::Provider::RemoteFile::HTTP", :fetch => nil)
+        Chef::Provider::RemoteFile::Fetcher.should_receive(:for_resource).with(@uri, new_resource, current_resource).and_return(http_fetcher)
+      end
+
+      it "should return nil for the tempfile" do
+        content.tempfile.should be_nil
+      end
+    end
+
+    describe "when the fetcher returns a valid tempfile" do
+
+      let(:mtime) { Time.now }
+      let(:tempfile) { mock("Tempfile") }
+      let(:http_fetcher) { mock("Chef::Provider::RemoteFile::HTTP", :fetch => tempfile) }
+
+      before do
+        Chef::Provider::RemoteFile::Fetcher.should_receive(:for_resource).with(@uri, new_resource, current_resource).and_return(http_fetcher)
+      end
+
+      it "should return the tempfile object to the caller" do
+        content.tempfile.should == tempfile
+      end
+
+    end
+  end
+  describe "when the checksum are both nil" do
+    before do
+      new_resource.checksum.should be_nil
+      current_resource.checksum.should be_nil
+    end
+    it_behaves_like "the resource needs fetching"
+  end
+
+  describe "when the current_resource checksum is nil" do
+    before do
+      new_resource.stub!(:checksum).and_return("fd012fd")
+      current_resource.stub!(:checksum).and_return(nil)
+    end
+    it_behaves_like "the resource needs fetching"
+  end
+
+  describe "when the new_resource checksum is nil" do
+    before do
+      new_resource.stub!(:checksum).and_return(nil)
+      current_resource.stub!(:checksum).and_return("0fd012fdc96e96f8f7cf2046522a54aed0ce470224513e45da6bc1a17a4924aa")
+    end
+    it_behaves_like "the resource needs fetching"
+  end
+
+  describe "when the checksums are a partial match, but not to the leading portion" do
+    before do
+      new_resource.stub!(:checksum).and_return("fd012fd")
+      current_resource.stub!(:checksum).and_return("0fd012fdc96e96f8f7cf2046522a54aed0ce470224513e45da6bc1a17a4924aa")
+    end
+    it_behaves_like "the resource needs fetching"
+  end
+
+
+  describe "when the fetcher throws an exception" do
+    before do
+      new_resource.stub!(:checksum).and_return(nil)
+      current_resource.stub!(:checksum).and_return(nil)
+      @uri = mock("URI")
+      URI.should_receive(:parse).with(new_resource.source[0]).and_return(@uri)
+      http_fetcher = mock("Chef::Provider::RemoteFile::HTTP")
+      http_fetcher.should_receive(:fetch).and_raise(Errno::ECONNREFUSED)
+      Chef::Provider::RemoteFile::Fetcher.should_receive(:for_resource).with(@uri, new_resource, current_resource).and_return(http_fetcher)
+    end
+
+    it "should propagate the error back to the caller" do
+      lambda { content.tempfile }.should raise_error(Errno::ECONNREFUSED)
+    end
+  end
+
+  describe "when there is an array of sources and the first fails" do
+
+    let(:source) { [ "http://opscode.com/seattle.txt", "http://opscode.com/nyc.txt" ] }
+    before do
+      new_resource.stub!(:checksum).and_return(nil)
+      current_resource.stub!(:checksum).and_return(nil)
+      @uri0 = mock("URI0")
+      @uri1 = mock("URI1")
+      URI.should_receive(:parse).with(new_resource.source[0]).and_return(@uri0)
+      URI.should_receive(:parse).with(new_resource.source[1]).and_return(@uri1)
+      @http_fetcher_throws_exception = mock("Chef::Provider::RemoteFile::HTTP")
+      @http_fetcher_throws_exception.should_receive(:fetch).at_least(:once).and_raise(Errno::ECONNREFUSED)
+      Chef::Provider::RemoteFile::Fetcher.should_receive(:for_resource).with(@uri0, new_resource, current_resource).and_return(@http_fetcher_throws_exception)
+    end
+
+    describe "when the second url succeeds" do
+      before do
+        @tempfile = mock("Tempfile")
+        mtime = Time.now
+        http_fetcher_works = mock("Chef::Provider::RemoteFile::HTTP", :fetch => @tempfile)
+        Chef::Provider::RemoteFile::Fetcher.should_receive(:for_resource).with(@uri1, new_resource, current_resource).and_return(http_fetcher_works)
+      end
+
+      it "should return a valid tempfile" do
+        content.tempfile.should == @tempfile
+      end
+
+      it "should not mutate the new_resource" do
+        content.tempfile
+        new_resource.source.length.should == 2
+      end
+    end
+
+    describe "when both urls fail" do
+      before do
+        Chef::Provider::RemoteFile::Fetcher.should_receive(:for_resource).with(@uri1, new_resource, current_resource).and_return(@http_fetcher_throws_exception)
+      end
+
+      it "should propagate the error back to the caller" do
+        lambda { content.tempfile }.should raise_error(Errno::ECONNREFUSED)
+      end
+    end
+  end
+
+  describe "when there is an array of sources and the first succeeds" do
+    let(:source) { [ "http://opscode.com/seattle.txt", "http://opscode.com/nyc.txt" ] }
+    before do
+      new_resource.stub!(:checksum).and_return(nil)
+      current_resource.stub!(:checksum).and_return(nil)
+      @uri0 = mock("URI0")
+      URI.should_receive(:parse).with(new_resource.source[0]).and_return(@uri0)
+      URI.should_not_receive(:parse).with(new_resource.source[1])
+      @tempfile = mock("Tempfile")
+      mtime = Time.now
+      http_fetcher_works = mock("Chef::Provider::RemoteFile::HTTP", :fetch => @tempfile)
+      Chef::Provider::RemoteFile::Fetcher.should_receive(:for_resource).with(@uri0, new_resource, current_resource).and_return(http_fetcher_works)
+    end
+
+    it "should return a valid tempfile" do
+      content.tempfile.should == @tempfile
+    end
+
+    it "should not mutate the new_resource" do
+      content.tempfile
+      new_resource.source.length.should == 2
+    end
+  end
+
+end
+

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

@@ -0,0 +1,75 @@
+#
+# Author:: Lamont Granquist (<lamont@opscode.com>)
+# Copyright:: Copyright (c) 2013 Opscode, Inc.
+# 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::Fetcher do
+
+  let(:current_resource) { mock("current resource") }
+  let(:new_resource) { mock("new resource") }
+  let(:fetcher_instance) { mock("fetcher") }
+
+  describe "when passed an http url" do
+    let(:uri) { mock("uri", :scheme => "http" ) }
+    before do
+      Chef::Provider::RemoteFile::HTTP.should_receive(:new).and_return(fetcher_instance)
+    end
+    it "returns an http fetcher" do
+      described_class.for_resource(uri, new_resource, current_resource).should == fetcher_instance
+    end
+  end
+
+  describe "when passed an https url" do
+    let(:uri) { mock("uri", :scheme => "https" ) }
+    before do
+      Chef::Provider::RemoteFile::HTTP.should_receive(:new).and_return(fetcher_instance)
+    end
+    it "returns an http fetcher" do
+      described_class.for_resource(uri, new_resource, current_resource).should == fetcher_instance
+    end
+  end
+
+  describe "when passed an ftp url" do
+    let(:uri) { mock("uri", :scheme => "ftp" ) }
+    before do
+      Chef::Provider::RemoteFile::FTP.should_receive(:new).and_return(fetcher_instance)
+    end
+    it "returns an ftp fetcher" do
+      described_class.for_resource(uri, new_resource, current_resource).should == fetcher_instance
+    end
+  end
+
+  describe "when passed a file url" do
+    let(:uri) { mock("uri", :scheme => "file" ) }
+    before do
+      Chef::Provider::RemoteFile::LocalFile.should_receive(:new).and_return(fetcher_instance)
+    end
+    it "returns a localfile fetcher" do
+      described_class.for_resource(uri, new_resource, current_resource).should == fetcher_instance
+    end
+  end
+
+  describe "when passed a url we do not recognize" do
+    let(:uri) { mock("uri", :scheme => "xyzzy" ) }
+    it "throws an ArgumentError exception" do
+      lambda { described_class.for_resource(uri, new_resource, current_resource) }.should raise_error(ArgumentError)
+    end
+  end
+
+end
+

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

@@ -0,0 +1,224 @@
+#
+# 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::FTP do
+  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")))
+  }
+
+  let(:new_resource) do
+    r = Chef::Resource::RemoteFile.new("remote file ftp backend test (new resource)")
+    r.ftp_active_mode(false)
+    r.path(resource_path)
+    r
+  end
+
+  let(:current_resource) do
+    Chef::Resource::RemoteFile.new("remote file ftp backend test (current resource)'")
+  end
+
+  let(:ftp) do
+    ftp = mock(Net::FTP, { })
+    ftp.stub!(:connect)
+    ftp.stub!(:login)
+    ftp.stub!(:voidcmd)
+    ftp.stub!(:mtime).and_return(Time.now)
+    ftp.stub!(:getbinaryfile)
+    ftp.stub!(:close)
+    ftp.stub!(:passive=)
+    ftp
+  end
+
+  let(:tempfile_path) { "/tmp/somedir/remote-file-ftp-backend-spec-test" }
+
+  let(:tempfile) do
+    t = StringIO.new
+    t.stub(:path).and_return(tempfile_path)
+    t
+  end
+
+  let(:uri) { URI.parse("ftp://opscode.com/seattle.txt") }
+
+  before(:each) do
+    Net::FTP.stub!(:new).with().and_return(ftp)
+    Tempfile.stub!(:new).and_return(tempfile)
+  end
+
+  describe "when first created" do
+
+    it "throws an argument exception when no path is given" do
+      uri.path = ""
+      lambda { Chef::Provider::RemoteFile::FTP.new(uri, new_resource, current_resource) }.should raise_error(ArgumentError)
+    end
+
+    it "throws an argument exception when only a / is given" do
+      uri.path = "/"
+      lambda { Chef::Provider::RemoteFile::FTP.new(uri, new_resource, current_resource) }.should raise_error(ArgumentError)
+    end
+
+    it "throws an argument exception when no filename is given" do
+      uri.path = "/the/whole/path/"
+      lambda { Chef::Provider::RemoteFile::FTP.new(uri, new_resource, current_resource) }.should raise_error(ArgumentError)
+    end
+
+    it "throws an argument exception when the typecode is invalid" do
+      uri.typecode = "d"
+      lambda { Chef::Provider::RemoteFile::FTP.new(uri, new_resource, current_resource) }.should raise_error(ArgumentError)
+    end
+
+    it "does not use passive mode when new_resource sets ftp_active_mode to true" do
+      new_resource.ftp_active_mode(true)
+      fetcher = Chef::Provider::RemoteFile::FTP.new(uri, new_resource, current_resource)
+      fetcher.use_passive_mode?.should be_false
+    end
+
+    it "uses passive mode when new_resource sets ftp_active_mode to false" do
+      new_resource.ftp_active_mode(false)
+      fetcher = Chef::Provider::RemoteFile::FTP.new(uri, new_resource, current_resource)
+      fetcher.use_passive_mode?.should be_true
+    end
+  end
+
+  describe "when fetching the object" do
+
+    let(:cache_control_data) { Chef::Provider::RemoteFile::CacheControlData.new(uri) }
+    let(:current_resource_checksum) { "e2a8938cc31754f6c067b35aab1d0d4864272e9bf8504536ef3e79ebf8432305" }
+
+    subject(:fetcher) { Chef::Provider::RemoteFile::FTP.new(uri, new_resource, current_resource) }
+
+    before do
+      current_resource.checksum(current_resource_checksum)
+      #Chef::Provider::RemoteFile::CacheControlData.should_receive(:load_and_validate).with(uri, current_resource_checksum).and_return(cache_control_data)
+    end
+
+    it "should connect to the host from the uri on the default port 21" do
+      ftp.should_receive(:connect).with("opscode.com", 21)
+      fetcher.fetch
+    end
+
+    it "should set passive true when ftp_active_mode is false" do
+      new_resource.ftp_active_mode(false)
+      ftp.should_receive(:passive=).with(true)
+      fetcher.fetch
+    end
+
+    it "should set passive false when ftp_active_mode is false" do
+      new_resource.ftp_active_mode(true)
+      ftp.should_receive(:passive=).with(false)
+      fetcher.fetch
+    end
+
+    it "should use anonymous ftp when no userinfo is provided" do
+      ftp.should_receive(:login).with("anonymous", nil)
+      fetcher.fetch
+    end
+
+    context "and the URI specifies an alternate port" do
+      let(:uri) { URI.parse("ftp://opscode.com:8021/seattle.txt") }
+
+      it "should connect on an alternate port when one is provided" do
+        uri = URI.parse("ftp://opscode.com:8021/seattle.txt")
+        ftp.should_receive(:connect).with("opscode.com", 8021)
+        fetcher.fetch
+      end
+
+    end
+
+    context "and the URI contains a username and password" do
+      let(:uri) { URI.parse("ftp://the_user:the_password@opscode.com/seattle.txt") }
+
+      it "should use authenticated ftp when userinfo is provided" do
+        ftp.should_receive(:login).with("the_user", "the_password")
+        fetcher.fetch
+      end
+    end
+
+    context "and the uri sets the typecode to ascii" do
+      let(:uri) { URI.parse("ftp://the_user:the_password@opscode.com/seattle.txt;type=a") }
+
+      it "fetches the file with ascii typecode set" do
+        ftp.should_receive(:voidcmd).with("TYPE A").once
+        fetcher.fetch
+      end
+
+    end
+
+    context "and the uri sets the typecode to image" do
+      let(:uri) { URI.parse("ftp://the_user:the_password@opscode.com/seattle.txt;type=i") }
+
+      it "should accept image for the typecode" do
+        ftp.should_receive(:voidcmd).with("TYPE I").once
+        fetcher.fetch
+      end
+
+    end
+
+    context "and the uri specifies a nested path" do
+      let(:uri) { URI.parse("ftp://opscode.com/the/whole/path/seattle.txt") }
+
+      it "should fetch the file from the correct path" do
+        ftp.should_receive(:voidcmd).with("CWD the").once
+        ftp.should_receive(:voidcmd).with("CWD whole").once
+        ftp.should_receive(:voidcmd).with("CWD path").once
+        ftp.should_receive(:getbinaryfile).with("seattle.txt", tempfile.path)
+        fetcher.fetch
+      end
+
+    end
+
+    context "when not using last modified based conditional fetching" do
+      before do
+        new_resource.use_last_modified(false)
+      end
+
+      it "should return a tempfile in the result" do
+        result = fetcher.fetch
+        result.should equal(tempfile)
+      end
+
+    end
+
+    context "and proxying is enabled" do
+      before do
+        @original_config = Chef::Config.hash_dup
+        Chef::Config[:ftp_proxy] = "socks5://socks.example.com:5000"
+        Chef::Config[:ftp_proxy_user] = "bill"
+        Chef::Config[:ftp_proxy_pass] = "ted"
+      end
+
+      after do
+        Chef::Config.configuration = @original_config
+      end
+
+      it "fetches the file via the proxy" do
+        current_socks_server = ENV["SOCKS_SERVER"]
+        ENV.should_receive(:[]=).with("SOCKS_SERVER", "socks5://bill:ted@socks.example.com:5000").ordered
+        ENV.should_receive(:[]=).with("SOCKS_SERVER", current_socks_server).ordered
+        result = fetcher.fetch
+        result.should equal(tempfile)
+      end
+
+    end
+
+  end
+end