buildpack-support 1.0.0

data/spec/buildpack_support/cache/application_cache_spec.rb

@@ -0,0 +1,56 @@
+# Encoding: utf-8
+# Copyright 2013-2014 the original author or authors.
+#
+# 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'
+require 'buildpack_support/cache/application_cache'
+require 'buildpack_support/test/internet_availability_helper'
+require 'buildpack_support/test/logging_helper'
+require 'buildpack_support/test/scratch_helper'
+
+describe BuildpackSupport::Cache::ApplicationCache do
+  include_context 'internet_availability_helper'
+  include_context 'logging_helper'
+  include_context 'scratch_helper'
+
+  previous_arg_value = ARGV[1]
+
+  before do
+    ARGV[1] = nil
+
+    stub_request(:get, 'http://foo-uri/').with(headers: { 'Accept' => '*/*', 'User-Agent' => 'Ruby' })
+    .to_return(status: 200, body: 'foo-cached', headers: { Etag: 'foo-etag', 'Last-Modified' => 'foo-last-modified' })
+
+    stub_request(:head, 'http://foo-uri/')
+    .with(headers: { 'Accept' => '*/*', 'If-Modified-Since' => 'foo-last-modified', 'If-None-Match' => 'foo-etag', 'User-Agent' => 'Ruby' })
+    .to_return(status: 304, body: '', headers: {})
+  end
+
+  after do
+    ARGV[1] = previous_arg_value
+  end
+
+  it 'should raise an error if ARGV[1] is not defined' do
+    expect { described_class.new }.to raise_error
+  end
+
+  it 'should use ARGV[1] directory' do
+    ARGV[1] = scratch_dir
+
+    described_class.new.get('http://foo-uri/') {}
+
+    expect(Pathname.glob(scratch_dir + '*.cached').size).to eq(1)
+  end
+
+end

data/spec/buildpack_support/cache/cached_file_spec.rb

@@ -0,0 +1,94 @@
+# Encoding: utf-8
+# Copyright 2013-2014 the original author or authors.
+#
+# 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'
+require 'buildpack_support/cache/cached_file'
+require 'buildpack_support/cache/yield_file_with_content'
+require 'buildpack_support/test/scratch_helper'
+require 'fileutils'
+
+describe BuildpackSupport::Cache::CachedFile do
+  include_context 'scratch_helper'
+
+  let(:file_cache) { described_class.new(scratch_dir, 'http://foo-uri/') }
+
+  it 'should not create any files on initialization' do
+    %w(cached etag last_modified).each { |extension| expect(cache_file(extension)).not_to exist }
+  end
+
+  it 'should not detect cached file' do
+    expect(file_cache.cached?).not_to be
+  end
+
+  it 'should not detect etag file' do
+    expect(file_cache.etag?).not_to be
+  end
+
+  it 'should not detect last_modified file' do
+    expect(file_cache.last_modified?).not_to be
+  end
+
+  context do
+
+    before do
+      touch('cached', 'foo-cached')
+      touch('etag', 'foo-etag')
+      touch('last_modified', 'foo-last-modified')
+    end
+
+    it 'should call the block with the content of the cache file' do
+      expect { |b| file_cache.cached(File::RDONLY, 'test-arg', &b) }.to yield_file_with_content(/foo-cached/)
+    end
+
+    it 'should detect cached file' do
+      expect(file_cache.cached?).to be
+    end
+
+    it 'should destroy all files' do
+      file_cache.destroy
+
+      %w(cached etag last_modified).each { |extension| expect(cache_file(extension)).not_to exist }
+    end
+
+    it 'should call the block with the content of the etag file' do
+      expect { |b| file_cache.etag(File::RDONLY, 'test-arg', &b) }.to yield_file_with_content(/foo-etag/)
+    end
+
+    it 'should detect etag file' do
+      expect(file_cache.etag?).to be
+    end
+
+    it 'should call the block with the content of the last_modified file' do
+      expect { |b| file_cache.last_modified(File::RDONLY, 'test-arg', &b) }.to yield_file_with_content(/foo-last-modified/)
+    end
+
+    it 'should detect last_modified file' do
+      expect(file_cache.last_modified?).to be
+    end
+  end
+
+  def cache_file(extension)
+    scratch_dir + "http:%2F%2Ffoo-uri%2F.#{extension}"
+  end
+
+  def touch(extension, content = '')
+    file = cache_file extension
+    FileUtils.mkdir_p file.dirname
+    file.open('w') { |f| f.write content }
+
+    file
+  end
+
+end

data/spec/buildpack_support/cache/download_cache_spec.rb

@@ -0,0 +1,293 @@
+# Encoding: utf-8
+# Copyright 2013-2014 the original author or authors.
+#
+# 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'
+require 'buildpack_support/cache/download_cache'
+require 'buildpack_support/test/environment_helper'
+require 'buildpack_support/test/internet_availability_helper'
+require 'buildpack_support/test/logging_helper'
+require 'buildpack_support/test/scratch_helper'
+require 'fileutils'
+require 'net/http'
+
+describe BuildpackSupport::Cache::DownloadCache do
+  include_context 'environment_helper'
+  include_context 'internet_availability_helper'
+  include_context 'logging_helper'
+  include_context 'scratch_helper'
+
+  let(:mutable_cache_root) { scratch_dir + 'mutable' }
+
+  let(:immutable_cache_root) { scratch_dir + 'immutable' }
+
+  let(:uri) { 'http://foo-uri/' }
+
+  let(:uri_credentials) { 'http://test-username:test-password@foo-uri/' }
+
+  let(:uri_secure) { 'https://foo-uri/' }
+
+  let(:download_cache) { described_class.new(mutable_cache_root, immutable_cache_root) }
+
+  it 'should raise error if file cannot be found',
+     :disable_internet do
+
+    expect { download_cache.get uri }.to raise_error('Unable to find cached file for http://foo-uri/')
+  end
+
+  it 'should return file from immutable cache if internet is disabled',
+     :disable_internet do
+
+    touch immutable_cache_root, 'cached', 'foo-cached'
+
+    expect { |b| download_cache.get uri, &b }.to yield_file_with_content(/foo-cached/)
+  end
+
+  it 'should return file from mutable cache if internet is disabled',
+     :disable_internet do
+
+    touch mutable_cache_root, 'cached', 'foo-cached'
+
+    expect { |b| download_cache.get uri, &b }.to yield_file_with_content(/foo-cached/)
+  end
+
+  it 'should download if cached file does not exist' do
+    stub_request(:get, uri)
+    .to_return(status: 200, body: 'foo-cached', headers: { Etag: 'foo-etag', 'Last-Modified' => 'foo-last-modified' })
+
+    allow(Net::HTTP).to receive(:Proxy).and_call_original
+    expect(Net::HTTP).not_to receive(:Proxy).with('proxy', 9000, nil, nil)
+
+    expect { |b| download_cache.get uri, &b }.to yield_file_with_content(/foo-cached/)
+    expect_complete_cache mutable_cache_root
+  end
+
+  it 'should download with credentials if cached file does not exist' do
+    stub_request(:get, uri_credentials)
+    .to_return(status: 200, body: 'foo-cached', headers: { Etag: 'foo-etag', 'Last-Modified' => 'foo-last-modified' })
+
+    allow(Net::HTTP).to receive(:Proxy).and_call_original
+    expect(Net::HTTP).not_to receive(:Proxy).with('proxy', 9000, nil, nil)
+
+    expect { |b| download_cache.get uri_credentials, &b }.to yield_file_with_content(/foo-cached/)
+    expect_complete_credential_cache mutable_cache_root
+  end
+
+  it 'should follow redirects' do
+    stub_request(:get, uri)
+    .to_return(status: 301, headers: { Location: uri_secure })
+    stub_request(:get, uri_secure)
+    .to_return(status: 200, body: 'foo-cached', headers: { Etag: 'foo-etag', 'Last-Modified' => 'foo-last-modified' })
+
+    expect { |b| download_cache.get uri, &b }.to yield_file_with_content(/foo-cached/)
+    expect_complete_cache mutable_cache_root
+  end
+
+  it 'should retry failed downloads' do
+    stub_request(:get, uri)
+    .to_raise(SocketError)
+    .to_return(status: 200, body: 'foo-cached', headers: { Etag: 'foo-etag', 'Last-Modified' => 'foo-last-modified' })
+
+    expect { |b| download_cache.get uri, &b }.to yield_file_with_content(/foo-cached/)
+    expect_complete_cache mutable_cache_root
+  end
+
+  it 'should return cached data if unknown error occurs' do
+    stub_request(:get, uri)
+    .to_raise('DNS Error')
+
+    touch immutable_cache_root, 'cached', 'foo-cached'
+
+    expect { |b| download_cache.get uri, &b }.to yield_file_with_content(/foo-cached/)
+  end
+
+  it 'should return cached data if retry limit is reached' do
+    stub_request(:get, uri)
+    .to_return(status: 500)
+
+    touch immutable_cache_root, 'cached', 'foo-cached'
+
+    expect { |b| download_cache.get uri, &b }.to yield_file_with_content(/foo-cached/)
+  end
+
+  it 'should not overwrite existing information if 304 is received' do
+    stub_request(:get, uri)
+    .with(headers: { 'If-None-Match' => 'foo-etag', 'If-Modified-Since' => 'foo-last-modified' })
+    .to_return(status: 304, body: '', headers: {})
+
+    touch mutable_cache_root, 'cached', 'foo-cached'
+    touch mutable_cache_root, 'etag', 'foo-etag'
+    touch mutable_cache_root, 'last_modified', 'foo-last-modified'
+
+    expect { |b| download_cache.get uri, &b }.to yield_file_with_content(/foo-cached/)
+    expect_complete_cache mutable_cache_root
+  end
+
+  it 'should overwrite existing information if 304 is not received' do
+    stub_request(:get, uri)
+    .with(headers: { 'If-None-Match' => 'old-foo-etag', 'If-Modified-Since' => 'old-foo-last-modified' })
+    .to_return(status: 200, body: 'foo-cached', headers: { Etag: 'foo-etag', 'Last-Modified' => 'foo-last-modified' })
+
+    touch mutable_cache_root, 'cached', 'old-foo-cached'
+    touch mutable_cache_root, 'etag', 'old-foo-etag'
+    touch mutable_cache_root, 'last_modified', 'old-foo-last-modified'
+
+    expect { |b| download_cache.get uri, &b }.to yield_with_args(be_a(File), true)
+
+    touch mutable_cache_root, 'cached', 'old-foo-cached'
+    touch mutable_cache_root, 'etag', 'old-foo-etag'
+    touch mutable_cache_root, 'last_modified', 'old-foo-last-modified'
+
+    expect { |b| download_cache.get uri, &b }.to yield_file_with_content(/foo-cached/)
+
+    expect_complete_cache mutable_cache_root
+  end
+
+  it 'should discard content with incorrect size' do
+    stub_request(:get, uri)
+    .to_return(status: 200, body: 'foo-cac', headers: { Etag:            'foo-etag',
+                                                        'Last-Modified'  => 'foo-last-modified',
+                                                        'Content-Length' => 10 })
+
+    touch immutable_cache_root, 'cached', 'old-foo-cached'
+
+    expect { |b| download_cache.get uri, &b }.to yield_file_with_content(/foo-cached/)
+  end
+
+  context do
+
+    let(:environment) { { 'http_proxy' => 'http://proxy:9000' } }
+
+    it 'should use http_proxy if specified' do
+      stub_request(:get, uri)
+      .to_return(status: 200, body: 'foo-cached', headers: { Etag: 'foo-etag', 'Last-Modified' => 'foo-last-modified' })
+
+      allow(Net::HTTP).to receive(:Proxy).and_call_original
+      expect(Net::HTTP).to receive(:Proxy).with('proxy', 9000, nil, nil).and_call_original
+
+      download_cache.get(uri) {}
+    end
+
+  end
+
+  context do
+
+    let(:environment) { { 'HTTP_PROXY' => 'http://proxy:9000' } }
+
+    it 'should use HTTP_PROXY if specified' do
+      stub_request(:get, uri)
+      .to_return(status: 200, body: 'foo-cached', headers: { Etag: 'foo-etag', 'Last-Modified' => 'foo-last-modified' })
+
+      allow(Net::HTTP).to receive(:Proxy).and_call_original
+      expect(Net::HTTP).to receive(:Proxy).with('proxy', 9000, nil, nil).and_call_original
+
+      download_cache.get(uri) {}
+    end
+
+  end
+
+  context do
+
+    let(:environment) { { 'https_proxy' => 'http://proxy:9000' } }
+
+    it 'should use https_proxy if specified and URL is secure' do
+      stub_request(:get, uri_secure)
+      .to_return(status: 200, body: 'foo-cached', headers: { Etag: 'foo-etag', 'Last-Modified' => 'foo-last-modified' })
+
+      allow(Net::HTTP).to receive(:Proxy).and_call_original
+      expect(Net::HTTP).to receive(:Proxy).with('proxy', 9000, nil, nil).and_call_original
+
+      download_cache.get(uri_secure) {}
+    end
+
+  end
+
+  context do
+
+    let(:environment) { { 'HTTPS_PROXY' => 'http://proxy:9000' } }
+
+    it 'should use HTTPS_PROXY if specified and URL is secure' do
+      stub_request(:get, uri_secure)
+      .to_return(status: 200, body: 'foo-cached', headers: { Etag: 'foo-etag', 'Last-Modified' => 'foo-last-modified' })
+
+      allow(Net::HTTP).to receive(:Proxy).and_call_original
+      expect(Net::HTTP).to receive(:Proxy).with('proxy', 9000, nil, nil).and_call_original
+
+      download_cache.get(uri_secure) {}
+    end
+
+  end
+
+  it 'should delete the cached file if it exists' do
+    expect_file_deleted 'cached'
+  end
+
+  it 'should delete the etag file if it exists' do
+    expect_file_deleted 'etag'
+  end
+
+  it 'should delete the last_modified file if it exists' do
+    expect_file_deleted 'last_modified'
+  end
+
+  def cache_file(root, extension)
+    root + "http:%2F%2Ffoo-uri%2F.#{extension}"
+  end
+
+  def credential_cache_file(root, extension)
+    root + "http:%2F%2Ftest-username:test-password@foo-uri%2F.#{extension}"
+  end
+
+  def expect_complete_cache(root)
+    expect_file_content root, 'cached', 'foo-cached'
+    expect_file_content root, 'etag', 'foo-etag'
+    expect_file_content root, 'last_modified', 'foo-last-modified'
+  end
+
+  def expect_complete_credential_cache(root)
+    expect_credential_file_content root, 'cached', 'foo-cached'
+    expect_credential_file_content root, 'etag', 'foo-etag'
+    expect_credential_file_content root, 'last_modified', 'foo-last-modified'
+  end
+
+  def expect_credential_file_content(root, extension, content = '')
+    file = credential_cache_file root, extension
+    expect(file).to exist
+    expect(file.read).to eq(content)
+  end
+
+  def expect_file_content(root, extension, content = '')
+    file = cache_file root, extension
+    expect(file).to exist
+    expect(file.read).to eq(content)
+  end
+
+  def expect_file_deleted(extension)
+    file = touch mutable_cache_root, extension
+    expect(file).to exist
+
+    download_cache.evict('http://foo-uri/')
+
+    expect(file).not_to exist
+  end
+
+  def touch(root, extension, content = '')
+    file = cache_file root, extension
+    FileUtils.mkdir_p file.dirname
+    file.open('w') { |f| f.write content }
+
+    file
+  end
+
+end

data/spec/buildpack_support/cache/internet_availability_spec.rb

@@ -0,0 +1,57 @@
+# Encoding: utf-8
+# Copyright 2013-2014 the original author or authors.
+#
+# 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'
+require 'buildpack_support/cache/internet_availability'
+require 'buildpack_support/configuration_utils'
+require 'buildpack_support/test/internet_availability_helper'
+require 'buildpack_support/test/logging_helper'
+
+describe BuildpackSupport::Cache::InternetAvailability do
+  include_context 'internet_availability_helper'
+  include_context 'logging_helper'
+
+  it 'should use internet by default' do
+    expect(described_class.instance.available?).to be
+  end
+
+  context do
+
+    before do
+      allow_any_instance_of(BuildpackSupport::ConfigurationUtils).to receive(:load).with('cache')
+                                                                     .and_return('remote_downloads' => 'disabled')
+      described_class.instance.send :initialize
+    end
+
+    it 'should not use internet if remote downloads are disabled' do
+      expect(described_class.instance.available?).not_to be
+    end
+  end
+
+  it 'should record availability' do
+    described_class.instance.available false
+
+    expect(described_class.instance.available?).not_to be
+    expect(log_contents).not_to match(/Internet availability set to false/)
+  end
+
+  it 'should record availability with message' do
+    described_class.instance.available false, 'test message'
+
+    expect(described_class.instance.available?).not_to be
+    expect(log_contents).to match(/Internet availability set to false: test message/)
+  end
+
+end