chef 18.8.11 → 18.8.54

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

@@ -1,253 +0,0 @@
-#
-# Author:: Lamont Granquist (<lamont@chef.io>)
-# Copyright:: Copyright (c) Chef Software 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) { double("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
-      allow(new_resource).to receive(:checksum).and_return("0fd012fdc96e96f8f7cf2046522a54aed0ce470224513e45da6bc1a17a4924aa")
-      allow(current_resource).to receive(:checksum).and_return("0fd012fdc96e96f8f7cf2046522a54aed0ce470224513e45da6bc1a17a4924aa")
-    end
-
-    it "should return nil for the tempfile" do
-      expect(content.tempfile).to be_nil
-    end
-
-    it "should not call any fetcher" do
-      expect(Chef::Provider::RemoteFile::Fetcher).not_to 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
-      allow(new_resource).to receive(:checksum).and_return("0fd012fd")
-      allow(current_resource).to receive(:checksum).and_return("0fd012fdc96e96f8f7cf2046522a54aed0ce470224513e45da6bc1a17a4924aa")
-    end
-
-    it "should return nil for the tempfile" do
-      expect(content.tempfile).to be_nil
-    end
-
-    it "should not call any fetcher" do
-      expect(Chef::Provider::RemoteFile::Fetcher).not_to 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 = double("URI")
-      expect(URI).to 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 = double("Chef::Provider::RemoteFile::HTTP", fetch: nil)
-        expect(Chef::Provider::RemoteFile::Fetcher).to receive(:for_resource).with(@uri, new_resource, current_resource).and_return(http_fetcher)
-      end
-
-      it "should return nil for the tempfile" do
-        expect(content.tempfile).to be_nil
-      end
-    end
-
-    describe "when the fetcher returns a valid tempfile" do
-
-      let(:mtime) { Time.now }
-      let(:tempfile) { double("Tempfile") }
-      let(:http_fetcher) { double("Chef::Provider::RemoteFile::HTTP", fetch: tempfile) }
-
-      before do
-        expect(Chef::Provider::RemoteFile::Fetcher).to receive(:for_resource).with(@uri, new_resource, current_resource).and_return(http_fetcher)
-      end
-
-      it "should return the tempfile object to the caller" do
-        expect(content.tempfile).to eq(tempfile)
-      end
-
-    end
-  end
-  describe "when the checksum are both nil" do
-    before do
-      expect(new_resource.checksum).to be_nil
-      expect(current_resource.checksum).to be_nil
-    end
-    it_behaves_like "the resource needs fetching"
-  end
-
-  describe "when the current_resource checksum is nil" do
-    before do
-      allow(new_resource).to receive(:checksum).and_return("fd012fd")
-      allow(current_resource).to receive(:checksum).and_return(nil)
-    end
-    it_behaves_like "the resource needs fetching"
-  end
-
-  describe "when the new_resource checksum is nil" do
-    before do
-      allow(new_resource).to receive(:checksum).and_return(nil)
-      allow(current_resource).to receive(: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
-      allow(new_resource).to receive(:checksum).and_return("fd012fd")
-      allow(current_resource).to receive(:checksum).and_return("0fd012fdc96e96f8f7cf2046522a54aed0ce470224513e45da6bc1a17a4924aa")
-    end
-    it_behaves_like "the resource needs fetching"
-  end
-
-  describe "when the fetcher throws an exception" do
-    before do
-      allow(new_resource).to receive(:checksum).and_return(nil)
-      allow(current_resource).to receive(:checksum).and_return(nil)
-      @uri = double("URI")
-      expect(URI).to receive(:parse).with(new_resource.source[0]).and_return(@uri)
-      http_fetcher = double("Chef::Provider::RemoteFile::HTTP")
-      expect(http_fetcher).to receive(:fetch).and_raise(Errno::ECONNREFUSED)
-      expect(Chef::Provider::RemoteFile::Fetcher).to receive(:for_resource).with(@uri, new_resource, current_resource).and_return(http_fetcher)
-    end
-
-    it "should propagate the error back to the caller" do
-      expect { content.tempfile }.to raise_error(Errno::ECONNREFUSED)
-    end
-  end
-
-  describe "when there is an array of sources and the first fails" do
-
-    # https://github.com/chef/chef/pull/1358#issuecomment-40853299
-    def create_exception(exception_class)
-      if [ Net::HTTPClientException, Net::HTTPFatalError ].include? exception_class
-        exception_class.new("message", { "something" => 1 })
-      else
-        exception_class.new
-      end
-    end
-
-    let(:source) { [ "http://opscode.com/seattle.txt", "http://opscode.com/nyc.txt" ] }
-
-    ### Test each exception we care about and make sure they all behave properly
-    [
-      SocketError,
-      Errno::ECONNREFUSED,
-      Errno::ENOENT,
-      Errno::EACCES,
-      Timeout::Error,
-      Net::HTTPClientException,
-      Net::HTTPFatalError,
-      Net::FTPError,
-      Errno::ETIMEDOUT,
-    ].each do |exception|
-      describe "with an exception of #{exception}" do
-        before do
-          allow(new_resource).to receive(:checksum).and_return(nil)
-          allow(current_resource).to receive(:checksum).and_return(nil)
-          @uri0 = double("URI0")
-          @uri1 = double("URI1")
-          expect(URI).to receive(:parse).with(new_resource.source[0]).and_return(@uri0)
-          expect(URI).to receive(:parse).with(new_resource.source[1]).and_return(@uri1)
-          @http_fetcher_throws_exception = double("Chef::Provider::RemoteFile::HTTP")
-          expect(@http_fetcher_throws_exception).to receive(:fetch).at_least(:once).and_raise(create_exception(exception))
-          expect(Chef::Provider::RemoteFile::Fetcher).to receive(:for_resource).with(@uri0, new_resource, current_resource).and_return(@http_fetcher_throws_exception)
-        end
-
-        describe "the second url should succeed" do
-          before do
-            @tempfile = double("Tempfile")
-            mtime = Time.now
-            http_fetcher_works = double("Chef::Provider::RemoteFile::HTTP", fetch: @tempfile)
-            expect(Chef::Provider::RemoteFile::Fetcher).to receive(:for_resource).with(@uri1, new_resource, current_resource).and_return(http_fetcher_works)
-          end
-
-          it "should return a valid tempfile" do
-            expect(content.tempfile).to eq(@tempfile)
-          end
-
-          it "should not mutate the new_resource" do
-            content.tempfile
-            expect(new_resource.source.length).to eq(2)
-          end
-        end
-
-        describe "when both urls fail" do
-          before do
-            expect(Chef::Provider::RemoteFile::Fetcher).to 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
-            expect { content.tempfile }.to raise_error(exception)
-          end
-        end
-      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
-      allow(new_resource).to receive(:checksum).and_return(nil)
-      allow(current_resource).to receive(:checksum).and_return(nil)
-      @uri0 = double("URI0")
-      expect(URI).to receive(:parse).with(new_resource.source[0]).and_return(@uri0)
-      expect(URI).not_to receive(:parse).with(new_resource.source[1])
-      @tempfile = double("Tempfile")
-      mtime = Time.now
-      http_fetcher_works = double("Chef::Provider::RemoteFile::HTTP", fetch: @tempfile)
-      expect(Chef::Provider::RemoteFile::Fetcher).to receive(:for_resource).with(@uri0, new_resource, current_resource).and_return(http_fetcher_works)
-    end
-
-    it "should return a valid tempfile" do
-      expect(content.tempfile).to eq(@tempfile)
-    end
-
-    it "should not mutate the new_resource" do
-      content.tempfile
-      expect(new_resource.source.length).to eq(2)
-    end
-  end
-
-end

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

@@ -1,95 +0,0 @@
-#
-# Author:: Lamont Granquist (<lamont@chef.io>)
-# Copyright:: Copyright (c) Chef Software 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) { double("current resource") }
-  let(:new_resource) { double("new resource") }
-  let(:fetcher_instance) { double("fetcher") }
-
-  describe "when passed a network share" do
-    before do
-      expect(Chef::Provider::RemoteFile::NetworkFile).to receive(:new).and_return(fetcher_instance)
-      allow(ChefUtils).to receive(:windows?).and_return(true)
-    end
-
-    context "when host is a name" do
-      let(:source) { "\\\\foohost\\fooshare\\Foo.tar.gz" }
-      it "returns a network file fetcher" do
-        expect(described_class.for_resource(source, new_resource, current_resource)).to eq(fetcher_instance)
-      end
-    end
-
-    context "when host is an ip" do
-      let(:source) { "\\\\127.0.0.1\\fooshare\\Foo.tar.gz" }
-      it "returns a network file fetcher" do
-        expect(described_class.for_resource(source, new_resource, current_resource)).to eq(fetcher_instance)
-      end
-    end
-  end
-
-  describe "when passed an http url" do
-    let(:uri) { double("uri", scheme: "http" ) }
-    before do
-      expect(Chef::Provider::RemoteFile::HTTP).to receive(:new).and_return(fetcher_instance)
-    end
-    it "returns an http fetcher" do
-      expect(described_class.for_resource(uri, new_resource, current_resource)).to eq(fetcher_instance)
-    end
-  end
-
-  describe "when passed an https url" do
-    let(:uri) { double("uri", scheme: "https" ) }
-    before do
-      expect(Chef::Provider::RemoteFile::HTTP).to receive(:new).and_return(fetcher_instance)
-    end
-    it "returns an http fetcher" do
-      expect(described_class.for_resource(uri, new_resource, current_resource)).to eq(fetcher_instance)
-    end
-  end
-
-  describe "when passed an ftp url" do
-    let(:uri) { double("uri", scheme: "ftp" ) }
-    before do
-      expect(Chef::Provider::RemoteFile::FTP).to receive(:new).and_return(fetcher_instance)
-    end
-    it "returns an ftp fetcher" do
-      expect(described_class.for_resource(uri, new_resource, current_resource)).to eq(fetcher_instance)
-    end
-  end
-
-  describe "when passed a file url" do
-    let(:uri) { double("uri", scheme: "file" ) }
-    before do
-      expect(Chef::Provider::RemoteFile::LocalFile).to receive(:new).and_return(fetcher_instance)
-    end
-    it "returns a localfile fetcher" do
-      expect(described_class.for_resource(uri, new_resource, current_resource)).to eq(fetcher_instance)
-    end
-  end
-
-  describe "when passed a url we do not recognize" do
-    let(:uri) { double("uri", scheme: "xyzzy" ) }
-    it "throws an ArgumentError exception" do
-      expect { described_class.for_resource(uri, new_resource, current_resource) }.to raise_error(ArgumentError)
-    end
-  end
-
-end

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

@@ -1,217 +0,0 @@
-#
-# Author:: Jesse Campbell (<hikeit@gmail.com>)
-# Copyright:: Copyright 2013-2016, 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) do
-    canonicalize_path(File.expand_path(File.join(CHEF_SPEC_DATA, "templates")))
-  end
-  let(:resource_path) do
-    canonicalize_path(File.expand_path(File.join(enclosing_directory, "seattle.txt")))
-  end
-
-  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 = double(Net::FTP, {})
-    allow(ftp).to receive(:connect)
-    allow(ftp).to receive(:login)
-    allow(ftp).to receive(:voidcmd)
-    allow(ftp).to receive(:mtime).and_return(Time.now)
-    allow(ftp).to receive(:getbinaryfile)
-    allow(ftp).to receive(:close)
-    allow(ftp).to receive(:passive=)
-    ftp
-  end
-
-  let(:tempfile_path) { "/tmp/somedir/remote-file-ftp-backend-spec-test" }
-
-  let(:tempfile) do
-    t = StringIO.new
-    allow(t).to receive(:path).and_return(tempfile_path)
-    t
-  end
-
-  let(:uri) { URI.parse("ftp://opscode.com/seattle.txt") }
-
-  before(:each) do
-    allow(Net::FTP).to receive(:new).with(no_args).and_return(ftp)
-    allow(Tempfile).to receive(:new).and_return(tempfile)
-  end
-
-  describe "when first created" do
-
-    it "throws an argument exception when no path is given" do
-      uri.path = ""
-      expect { Chef::Provider::RemoteFile::FTP.new(uri, new_resource, current_resource) }.to raise_error(ArgumentError)
-    end
-
-    it "throws an argument exception when only a / is given" do
-      uri.path = "/"
-      expect { Chef::Provider::RemoteFile::FTP.new(uri, new_resource, current_resource) }.to raise_error(ArgumentError)
-    end
-
-    it "throws an argument exception when no filename is given" do
-      uri.path = "/the/whole/path/"
-      expect { Chef::Provider::RemoteFile::FTP.new(uri, new_resource, current_resource) }.to raise_error(ArgumentError)
-    end
-
-    it "throws an argument exception when the typecode is invalid" do
-      uri.typecode = "d"
-      expect { Chef::Provider::RemoteFile::FTP.new(uri, new_resource, current_resource) }.to 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)
-      expect(fetcher.use_passive_mode?).to be_falsey
-    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)
-      expect(fetcher.use_passive_mode?).to be_truthy
-    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
-      expect(ftp).to 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)
-      expect(ftp).to 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)
-      expect(ftp).to receive(:passive=).with(false)
-      fetcher.fetch
-    end
-
-    it "should use anonymous ftp when no userinfo is provided" do
-      expect(ftp).to 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")
-        expect(ftp).to 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
-        expect(ftp).to 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
-        expect(ftp).to 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
-        expect(ftp).to 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
-        expect(ftp).to receive(:voidcmd).with("CWD the").once
-        expect(ftp).to receive(:voidcmd).with("CWD whole").once
-        expect(ftp).to receive(:voidcmd).with("CWD path").once
-        expect(ftp).to 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
-        expect(result).to equal(tempfile)
-      end
-
-    end
-
-    context "and proxying is enabled" do
-      before do
-        stub_const("ENV", "ftp_proxy" => "socks5://bill:ted@socks.example.com:5000")
-      end
-
-      it "fetches the file via the proxy" do
-        current_socks_server = ENV["SOCKS_SERVER"]
-        expect(ENV).to receive(:[]=).with("SOCKS_SERVER", "socks5://bill:ted@socks.example.com:5000").ordered
-        expect(ENV).to receive(:[]=).with("SOCKS_SERVER", current_socks_server).ordered
-        result = fetcher.fetch
-        expect(result).to equal(tempfile)
-      end
-
-    end
-
-  end
-end