buildpack-packager 2.3.4

data/spec/integration/buildpack/packager_spec.rb

@@ -0,0 +1,454 @@
+require 'spec_helper'
+require 'tmpdir'
+
+module Buildpack
+  describe Packager do
+    let(:tmp_dir) do
+      dir = FileUtils.mkdir_p(File.join(Dir.mktmpdir, rand.to_s[2..-1]))[0]
+      puts dir
+      dir
+    end
+    let(:buildpack_dir) { File.join(tmp_dir, 'sample-buildpack-root-dir') }
+    let(:cache_dir) { File.join(tmp_dir, 'cache-dir') }
+    let(:file_location) do
+      location = File.join(tmp_dir, 'sample_host')
+      File.write(location, 'contents!')
+      location
+    end
+    let(:translated_file_location) { 'file___' + file_location.gsub(/[:\/]/, '_') }
+
+    let(:md5) { Digest::MD5.file(file_location).hexdigest }
+
+    let(:options) do
+      {
+        root_dir: buildpack_dir,
+        mode: buildpack_mode,
+        cache_dir: cache_dir,
+        manifest_path: manifest_path
+      }
+    end
+
+    let(:manifest_path) { 'manifest.yml' }
+    let(:manifest) do
+      {
+        exclude_files: [],
+        language: 'sample',
+        url_to_dependency_map: [{
+          match: 'ruby-(d+.d+.d+)',
+          name: 'ruby',
+          version: '$1'
+        }],
+        dependencies: [{
+          'version' => '1.0',
+          'name' => 'etc_host',
+          'md5' => md5,
+          'uri' => "file://#{file_location}",
+          'cf_stacks' => ['cflinuxfs2']
+        }]
+      }
+    end
+
+    let(:buildpack_files) do
+      [
+        'VERSION',
+        'README.md',
+        'lib/sai.to',
+        'lib/rash',
+        'log/log.txt',
+        'first-level/log/log.txt',
+        'log.txt',
+        'blog.txt',
+        'blog/blog.txt',
+        '.gitignore',
+        '.gitmodules',
+        'lib/.git'
+      ]
+    end
+
+    let(:git_files) { ['.gitignore', '.gitmodules', 'lib/.git'] }
+    let(:cached_file) { File.join(cache_dir, translated_file_location) }
+
+    def create_manifest(options = {})
+      manifest.merge!(options)
+      File.write(File.join(buildpack_dir, manifest_path), manifest.to_yaml)
+    end
+
+    before do
+      make_fake_files(buildpack_dir, buildpack_files)
+      buildpack_files << 'manifest.yml'
+      create_manifest
+      `echo "1.2.3" > #{File.join(buildpack_dir, 'VERSION')}`
+
+      @pwd ||= Dir.pwd
+      Dir.chdir(buildpack_dir)
+    end
+
+    after do
+      Dir.chdir(@pwd)
+      FileUtils.remove_entry tmp_dir
+    end
+
+    describe '#list' do
+      let(:buildpack_mode) { :list }
+
+      context 'default manifest.yml' do
+        specify do
+          create_manifest
+          table = Packager.list(options)
+          expect(table.to_s).to match(/etc_host.*1\.0.*cflinuxfs2/)
+        end
+      end
+
+      context 'alternate manifest path' do
+        let(:manifest_path) { 'my-manifest.yml' }
+
+        specify do
+          create_manifest
+          table = Packager.list(options)
+          expect(table.to_s).to match(/etc_host.*1\.0.*cflinuxfs2/)
+        end
+      end
+
+      context 'sorted output' do
+        def create_manifest_dependency_skeleton(dependencies)
+          manifest = {}
+          manifest['dependencies'] = []
+          dependencies.each do |dependency|
+            manifest['dependencies'].push('name' => dependency.first,
+                                          'version'   => dependency.last,
+                                          'cf_stacks' => ['cflinuxfs2'])
+          end
+          File.write(File.join(buildpack_dir, manifest_path), manifest.to_yaml)
+        end
+
+        %w(go hhvm jruby node php python ruby).each do |interpreter|
+          it "sorts #{interpreter} interpreter first" do
+            create_manifest_dependency_skeleton([
+                                                  ['aaaaa', '1.0'],
+                                                  [interpreter, '1.0'],
+                                                  ['zzzzz', '1.0']
+                                                ])
+            table = Packager.list(options)
+            stdout = table.to_s.split("\n")
+
+            position_of_a = stdout.index(stdout.grep(/aaaaa/).first)
+            position_of_interpreter = stdout.index(stdout.grep(/ #{interpreter} /).first)
+            position_of_z = stdout.index(stdout.grep(/zzzzz/).first)
+
+            expect(position_of_interpreter).to be < position_of_a
+            expect(position_of_interpreter).to be < position_of_z
+          end
+        end
+
+        it 'sorts using `name` as secondary key' do
+          create_manifest_dependency_skeleton([
+                                                ['b_foobar', '1.0'],
+                                                ['a_foobar', '1.0'],
+                                                ['c_foobar', '1.0']
+                                              ])
+          table = Packager.list(options)
+          stdout = table.to_s.split("\n")
+
+          position_of_a = stdout.index(stdout.grep(/a_foobar/).first)
+          position_of_b = stdout.index(stdout.grep(/b_foobar/).first)
+          position_of_c = stdout.index(stdout.grep(/c_foobar/).first)
+
+          expect(position_of_a).to be < position_of_b
+          expect(position_of_b).to be < position_of_c
+        end
+
+        it 'sorts using `version` as secondary key' do
+          create_manifest_dependency_skeleton([
+                                                ['foobar', '1.1'],
+                                                ['foobar', '1.2'],
+                                                ['foobar', '1.0']
+                                              ])
+          table = Packager.list(options)
+          stdout = table.to_s.split("\n")
+
+          position_of_10 = stdout.index(stdout.grep(/1\.0/).first)
+          position_of_11 = stdout.index(stdout.grep(/1\.1/).first)
+          position_of_12 = stdout.index(stdout.grep(/1\.2/).first)
+
+          expect(position_of_10).to be < position_of_11
+          expect(position_of_11).to be < position_of_12
+        end
+      end
+    end
+
+    describe 'a well formed zip file name' do
+      context 'an uncached buildpack' do
+        let(:buildpack_mode) { :uncached }
+
+        specify do
+          Packager.package(options)
+
+          expect(all_files(buildpack_dir)).to include('sample_buildpack-v1.2.3.zip')
+        end
+      end
+
+      context 'a cached buildpack' do
+        let(:buildpack_mode) { :cached }
+
+        specify do
+          puts `ls #{buildpack_dir}`
+
+          puts Packager.package(options)
+
+          expect(all_files(buildpack_dir)).to include('sample_buildpack-cached-v1.2.3.zip')
+        end
+      end
+    end
+
+    describe 'the zip file contents' do
+      context 'an uncached buildpack' do
+        let(:buildpack_mode) { :uncached }
+
+        specify do
+          Packager.package(options)
+
+          zip_file_path = File.join(buildpack_dir, 'sample_buildpack-v1.2.3.zip')
+          zip_contents = get_zip_contents(zip_file_path)
+
+          expect(zip_contents).to match_array(buildpack_files - git_files)
+        end
+      end
+
+      context 'a cached buildpack' do
+        let(:buildpack_mode) { :cached }
+
+        specify do
+          Packager.package(options)
+
+          zip_file_path = File.join(buildpack_dir, 'sample_buildpack-cached-v1.2.3.zip')
+          zip_contents = get_zip_contents(zip_file_path)
+          dependencies = ["dependencies/#{translated_file_location}"]
+
+          expect(zip_contents).to match_array(buildpack_files + dependencies - git_files)
+        end
+      end
+    end
+
+    describe 'excluded files' do
+      let(:buildpack_mode) { :uncached }
+
+      context 'when specifying files for exclusion' do
+        it 'excludes .git files from zip files' do
+          create_manifest(exclude_files: ['.gitignore'])
+          Packager.package(options)
+
+          zip_file_path = File.join(buildpack_dir, 'sample_buildpack-v1.2.3.zip')
+          zip_contents = get_zip_contents(zip_file_path)
+
+          expect(zip_contents).to_not include('.gitignore')
+          expect(zip_contents).to_not include('.gitmodules')
+          expect(zip_contents).to_not include('lib/.git')
+        end
+      end
+
+      context 'when using a directory pattern in exclude_files' do
+        it 'excludes directories with that name' do
+          create_manifest(exclude_files: ['log/'])
+          Packager.package(options)
+
+          zip_file_path = File.join(buildpack_dir, 'sample_buildpack-v1.2.3.zip')
+          zip_contents = get_zip_contents(zip_file_path)
+
+          expect(zip_contents).to_not include('first-level/log/log.txt')
+          expect(zip_contents).to_not include('log/log.txt')
+          expect(zip_contents).to include('blog/blog.txt')
+          expect(zip_contents).to include('log.txt')
+        end
+      end
+
+      context 'when using glob patterns in exclude_files' do
+        it 'can accept glob patterns' do
+          create_manifest(exclude_files: ['*log.txt'])
+          Packager.package(options)
+
+          zip_file_path = File.join(buildpack_dir, 'sample_buildpack-v1.2.3.zip')
+          zip_contents = get_zip_contents(zip_file_path)
+
+          expect(zip_contents).to_not include('log.txt')
+          expect(zip_contents).to_not include('log/log.txt')
+          expect(zip_contents).to_not include('first-level/log/log.txt')
+          expect(zip_contents).to_not include('blog/blog.txt')
+          expect(zip_contents).to_not include('blog.txt')
+        end
+
+        it 'does not do fuzzy matching by default' do
+          create_manifest(exclude_files: ['log.txt'])
+          Packager.package(options)
+
+          zip_file_path = File.join(buildpack_dir, 'sample_buildpack-v1.2.3.zip')
+          zip_contents = get_zip_contents(zip_file_path)
+
+          expect(zip_contents).to_not include('log.txt')
+          expect(zip_contents).to include('blog.txt')
+        end
+      end
+    end
+
+    describe 'caching of dependencies' do
+      context 'an uncached buildpack' do
+        let(:buildpack_mode) { :uncached }
+
+        specify do
+          Packager.package(options)
+
+          expect(File).to_not exist(cached_file)
+        end
+      end
+
+      context 'a cached buildpack' do
+        let(:buildpack_mode) { :cached }
+
+        context 'by default' do
+          specify do
+            Packager.package(options)
+            expect(File).to exist(cached_file)
+          end
+        end
+
+        context 'with the force download enabled' do
+          context 'and the cached file does not exist' do
+            it 'will overwrite the cache file' do
+              expect(File).to_not exist(cached_file)
+
+              Packager.package(options.merge(force_download: true))
+
+              expect(File).to exist(cached_file)
+              expect(Digest::MD5.file(cached_file).hexdigest).to eq md5
+            end
+          end
+
+          context 'and the request fails' do
+            let(:file_location) { 'fake-file-that-no-one-should-have.txt' }
+            let(:md5) { nil }
+
+            it 'does not cache the file' do
+              expect(File).to_not exist(cached_file)
+
+              expect do
+                Packager.package(options.merge(force_download: true))
+              end.to raise_error(RuntimeError)
+
+              expect(File).to_not exist(cached_file)
+            end
+
+            it 'raises an error about a failed download' do
+              expect do
+                Packager.package(options.merge(force_download: true))
+              end.to raise_error(RuntimeError, 'Failed to download file from file://fake-file-that-no-one-should-have.txt')
+            end
+          end
+
+          context 'on subsequent calls' do
+            context 'and they are successful' do
+              it 'does not use the cached file and overwrites it' do
+                Packager.package(options.merge(force_download: true))
+                File.write(cached_file, 'asdf')
+
+                Packager.package(options.merge(force_download: true))
+                expect(Digest::MD5.file(cached_file).hexdigest).to eq md5
+              end
+            end
+
+            context 'and they fail' do
+              it 'does not override the cached file' do
+                Packager.package(options.merge(force_download: true))
+                File.write(cached_file, 'asdf')
+
+                File.delete(file_location)
+
+                expect do
+                  Packager.package(options.merge(force_download: true))
+                end.to raise_error(RuntimeError)
+
+                expect(File.read(cached_file)).to eq 'asdf'
+              end
+            end
+          end
+        end
+
+        context 'with the force download disabled' do
+          context 'and the cached file does not exist' do
+            it 'will write the cache file' do
+              Packager.package(options.merge(force_download: false))
+              expect(File).to exist(cached_file)
+            end
+          end
+
+          context 'on subsequent calls' do
+            it 'does use the cached file' do
+              Packager.package(options.merge(force_download: false))
+
+              expect_any_instance_of(Packager::Package).not_to receive(:download_file)
+              Packager.package(options.merge(force_download: false))
+            end
+          end
+        end
+      end
+    end
+
+    describe 'when checking checksums' do
+      context 'with an invalid MD5' do
+        let(:md5) { 'wompwomp' }
+
+        context 'in cached mode' do
+          let(:buildpack_mode) { :cached }
+
+          it 'raises an error' do
+            expect do
+              Packager.package(options)
+            end.to raise_error(Packager::CheckSumError)
+          end
+        end
+
+        context 'in uncached mode' do
+          let(:buildpack_mode) { :uncached }
+
+          it 'does not raise an error' do
+            expect do
+              Packager.package(options)
+            end.to_not raise_error
+          end
+        end
+      end
+    end
+
+    describe 'existence of zip' do
+      let(:buildpack_mode) { :uncached }
+
+      context 'zip is installed' do
+        specify do
+          expect { Packager.package(options) }.not_to raise_error
+        end
+      end
+
+      context 'zip is not installed' do
+        before do
+          allow(Open3).to receive(:capture3)
+            .with('which zip')
+            .and_return(['', '', 'exit 1'])
+        end
+
+        specify do
+          expect { Packager.package(options) }.to raise_error(RuntimeError)
+        end
+      end
+    end
+
+    describe 'avoid changing state of buildpack folder, other than creating the artifact (.zip)' do
+      context 'create an cached buildpack' do
+        let(:buildpack_mode) { :cached }
+
+        specify 'user does not see dependencies directory in their buildpack folder' do
+          Packager.package(options)
+
+          expect(all_files(buildpack_dir)).not_to include('dependencies')
+        end
+      end
+    end
+  end
+end