dply 0.2.19 → 0.3.0

data/spec/dply/curl_spec.rb

@@ -0,0 +1,41 @@
+require 'dply/curl'
+
+module Dply
+  describe Curl do
+
+    let(:url) { "http://127.0.0.1:8000/build.tar.gz" }
+
+    describe "#download(url, file)" do
+      it "downloads the url to file" do
+        Dir.mktmpdir do |dir|
+          f = "#{dir}/f"
+          curl = Curl.new
+          expect(Logger.logger).to receive(:bullet).with("downloading #{url}")
+          curl.download(url, f)
+          expect(File).to exist(f)
+        end
+      end
+
+      it "raises error when url doesn't exist" do
+        url = "http://127.0.0.1:8000/build"
+        Dir.mktmpdir do |dir|
+          f = "#{dir}/f"
+          curl = Curl.new
+          expect(Logger.logger).to receive(:bullet).with("downloading #{url}")
+          expect { curl.download(url, f) }.to raise_error(Error)
+        end
+      end
+
+      it "logs message to debug when quiet: true" do
+        Dir.mktmpdir do |dir|
+          f = "#{dir}/f"
+          curl = Curl.new(quiet: true)
+          expect(Logger.logger).to receive(:debug).with("downloading #{url}")
+          curl.download(url, f)
+        end
+      end
+    end
+  end
+end
+
+

data/spec/dply/deplist_spec.rb

@@ -0,0 +1,48 @@
+silence_warnings do
+  require 'dply/deplist'
+end
+
+module Dply
+  describe Deplist do
+
+    before :all do
+      @work_dir = "tmp/deplist"
+      FileUtils.rm_rf @work_dir
+      FileUtils.mkdir_p @work_dir
+    end
+
+    def tmp_dir(&block)
+      d = Dir.mktmpdir nil, "#{Dir.pwd}/#{@work_dir}"
+      FileUtils.cp "spec/test_data/sample_repo/lib/libacl.so.1", "#{d}/libacl.so.1"
+      Dir.chdir(d) { yield d }
+    end
+
+    describe "#verify!" do
+
+      it "doesn't throw an error when pkgs.yml has the required pkgs" do
+        pkgs_data = { "pkgs" => ["libattr"], "build_pkgs" => [] }
+        tmp_dir do
+          File.write "pkgs.yml", YAML.dump(pkgs_data)
+          system! "tar czf test.tar.gz pkgs.yml libacl.so.1"
+          deplist = Deplist.new("test.tar.gz")
+          silence_warnings do
+            expect { deplist.verify! }.to output(/all dependencies satisfied/).to_stdout_from_any_process
+          end
+        end
+      end
+
+      it "throws an error when pkgs.yml doesn't have the required pkgs" do
+        pkgs_data = { "pkgs" => [], "build_pkgs" => [] }
+        tmp_dir do
+          File.write "pkgs.yml", YAML.dump(pkgs_data)
+          system! "tar czf test.tar.gz pkgs.yml libacl.so.1"
+          deplist = Deplist.new("test.tar.gz")
+          silence_warnings do
+            expect { deplist.verify! }.to raise_error(Error).and output(/any of \["libattr"\]/).to_stdout_from_any_process
+          end
+        end
+      end
+
+    end
+  end
+end

data/spec/dply/elf_spec.rb

@@ -0,0 +1,64 @@
+silence_warnings do
+  require 'elf'
+end
+require 'dply/elf'
+require 'pathname'
+
+module Dply
+  describe Elf do
+
+    before :all do
+      @verbose = $VERBOSE
+      $VERBOSE = false
+    end
+
+    let(:work_dir) { Pathname.new("#{__dir__}/../test_data/elf").realpath }
+
+    def map_64bit(list)
+      list.map { |i| "#{i}()(64bit)" }
+    end
+
+    describe ".elf?" do
+      it "returns true if file is an ELF" do
+        expect(Elf.elf? "#{work_dir}/elf").to eq(true)
+      end
+
+      it "returns false if file is not an ELF" do
+        expect(Elf.elf? "#{work_dir}/not_elf").to eq(false)
+      end
+
+      it "returns false if file doesn't exist" do
+        expect(Elf.elf? "#{work_dir}/nofile").to eq(false)
+      end
+    end
+
+    describe "#external_libs" do
+      it "returns a list of external libs when elf has no rpath section" do
+        libs = map_64bit ["libattr.so.1", "libc.so.6"]
+        elf = Elf.new("#{work_dir}/elf")
+        expect(elf.external_libs).to match_array(libs)
+      end
+
+      context "when elf has absolute rpath or runpath" do
+        it "returns all external libs ignoring rpath" do
+          libs = map_64bit ["libpq.so.5", "libc.so.6", "libpgtypes.so.3", "libpthread.so.0"]
+          elf = Elf.new("#{work_dir}/libecpg.so")
+          expect(elf.external_libs).to match_array(libs)
+        end
+      end
+
+      context "when elf contains a relative rpath or runpath" do
+        it "returns all external libs excluding the ones found in relative rpath" do
+          libs = map_64bit ["libpq.so.5", "libc.so.6", "libpthread.so.0"]
+          elf = Elf.new("#{work_dir}/rpath_libecpg.so")
+          expect(elf.external_libs).to match_array(libs)
+        end
+      end
+    end
+
+    after :all do
+      $VERBOSE = @verbose
+    end
+
+  end
+end

data/spec/dply/env_spec.rb

@@ -0,0 +1,57 @@
+require 'dply/env'
+
+module Dply
+  describe Env do
+
+    ORIGINAL_ENV = { "O1" => "1", "O2" => "2" }
+    CURRENT_ENV = { "C1" => "1", "C2" => "2" }
+    EXTRA_ENV = { "O1" => "E", "C1" => "E" }
+
+    def stub_env(with_bundler:)
+      allow(ENV).to receive(:to_h).and_return(CURRENT_ENV)
+      if with_bundler
+        stub_const("Bundler", "bundler")
+        allow(Bundler).to receive(:original_env).and_return(ORIGINAL_ENV)
+      else
+        hide_const("Bundler")
+      end
+    end
+
+    describe '.build_env (extra_env, bundled_env:)' do
+      context "when bundler is defined and bundled_env: true" do
+        it "merges current_env with extra_env" do
+          stub_env with_bundler: true
+          env = Env.build_env(EXTRA_ENV, bundled_env: true)
+          expect(env).to eq(CURRENT_ENV.merge(EXTRA_ENV))
+        end
+      end
+
+      context "when bundler is defined and bundled_env: false" do
+        it "merges original_env with extra_env" do
+          stub_env with_bundler: true
+          env = Env.build_env(EXTRA_ENV, bundled_env: false)
+          expect(env).to eq(ORIGINAL_ENV.merge(EXTRA_ENV))
+        end
+      end
+
+      context "when bundler is not defined and bundled_env: true" do
+        it "merges current_env with extra_env" do
+          stub_env with_bundler: false
+          env = Env.build_env(EXTRA_ENV, bundled_env: true)
+          expect(env).to eq(CURRENT_ENV.merge(EXTRA_ENV))
+        end
+      end
+
+      context "when bundler is defined and bundled_env: false" do
+        it "merges current_env with extra_env" do
+          stub_env with_bundler: false
+          env = Env.build_env(EXTRA_ENV, bundled_env: true)
+          expect(env).to eq(CURRENT_ENV.merge(EXTRA_ENV))
+        end
+      end
+
+    end
+  end
+end
+
+

data/spec/dply/git_spec.rb

@@ -0,0 +1,136 @@
+require 'dply/git'
+require 'repo'
+
+module Dply
+  describe Git do
+
+    before :all do
+      @work_dir = "tmp/git"
+      @source_repo = "#{Dir.pwd}/tmp/repo.git"
+      FileUtils.rm_rf @work_dir
+      FileUtils.mkdir_p @work_dir
+    end
+
+    def source_repo
+      @source_repo
+    end
+
+    def tmp_dir(&block)
+      d = Dir.mktmpdir nil, "#{Dir.pwd}/#{@work_dir}"
+      Dir.chdir(d) { yield d }
+    end
+
+    describe ".pull" do
+      it "checks out the given branch and pulls any changes to it from upstream" do
+        tmp_dir do |d|
+          upstream = "#{d}/upstream"
+          system! "git clone #{source_repo} upstream"
+          system! "git clone #{upstream} repo"
+          Dir.chdir "upstream" do
+            system! "git checkout -b new_data"
+            system! "echo 'new_data' > new_data"
+            system! "git add new_data; git commit -m 'commit'"
+          end
+
+          Dir.chdir "repo" do
+            suppress_output { Git.pull "new_data" }
+            expect(`git rev-parse --abbrev-ref HEAD`.chomp).to eq('new_data')
+            expect(File).to exist('new_data')
+          end
+        end
+      end
+    end
+
+    describe ".checkout" do
+      it "checks out the given branch" do
+        upstream = source_repo
+        tmp_dir do
+          system! "git clone #{upstream} repo", quiet: true
+          Dir.chdir "repo" do
+            # local tracking branch doesn't exist
+            suppress_output { Git.checkout "some_branch" }
+            expect(`git rev-parse --abbrev-ref HEAD`.chomp).to eq("some_branch")
+
+            #local tracking branch exists
+            suppress_output { Git.checkout "master" }
+            expect(`git rev-parse --abbrev-ref HEAD`.chomp).to eq("master")
+          end
+        end
+      end
+    end
+
+    describe ".clone" do
+      it "clones the repo from mirror and sets the upstream to original" do
+        mirror = source_repo
+        original = "/some/original/repo.git"
+        tmp_dir do
+          suppress_output { Git.clone original, "repo", mirror: mirror }
+          Dir.chdir "repo" do
+            expect(Git.remote_url).to eq(original)
+          end
+        end
+      end
+
+      it "clones the repo from original source when mirror is not specified" do
+        original = source_repo
+        tmp_dir do
+          suppress_output { Git.clone original, "repo", mirror: nil }
+          Dir.chdir "repo" do
+            expect(Git.remote_url).to eq(original)
+          end
+        end
+      end
+    end
+
+    describe ".clean" do
+      it "cleans any changes made to the working tree (resets HEAD state and removes untracked files)" do
+        upstream = source_repo
+        tmp_dir do
+          system! "git clone #{upstream} repo", quiet: true
+          Dir.chdir "repo" do
+            system! "echo asda > my_new_file"  #new
+            system! "echo existing > Gemfile"  #existing
+            suppress_output { Git.clean }
+            lines = IO.popen(%w(git status --porcelain)) { |f| f.readlines }
+            expect(lines.size).to eq(0)
+          end
+        end
+      end
+    end
+
+    describe ".tracking_branch" do
+      it "returns the tracking branch for given branch" do
+        upstream = source_repo
+        branch = "some_branch"
+        tmp_dir do
+          system! "git clone #{upstream} repo", quiet: true
+          Dir.chdir "repo" do
+            system! "git checkout -b #{branch} -t origin/#{branch}", quiet: true
+            expect(Git.tracking_branch(branch)).to eq("origin/#{branch}")
+          end
+        end
+      end
+    end
+
+    describe ".remote_url" do
+      it "returns the url for origin upstream" do
+        upstream = source_repo
+        tmp_dir do |d|
+          system! "git clone #{upstream} repo", quiet: true
+          Dir.chdir("repo") do
+            expect(Git.remote_url).to eq(upstream)
+          end
+        end
+      end
+    end
+
+    describe ".commit_id" do
+      it "returns the commit id" do
+        Dir.chdir source_repo do
+          commit_id = `git rev-parse HEAD`.chomp
+          expect(Git.commit_id).to eq(commit_id)
+        end
+      end
+    end
+  end
+end

data/spec/dply/helper_spec.rb

@@ -0,0 +1,168 @@
+require 'dply/helper'
+require 'pathname'
+
+module Dply
+  describe Helper do
+
+    before :all do
+      @work_dir = "tmp/helper"
+      FileUtils.rm_rf @work_dir
+      FileUtils.mkdir_p @work_dir
+    end
+
+    klass = Class.new { include Helper }
+    subject { klass.new }
+
+    def tmp_dir(&block)
+      d = Dir.mktmpdir nil, "#{Dir.pwd}/#{@work_dir}"
+      Dir.chdir(d) { yield d }
+    end
+
+    describe "#cmd" do
+      command = "touch a"
+      display = :a
+      env = {"a" => "1" }
+      bundled_env = :benv
+      new_env = {"e" => "1"}
+
+      let(:cmd_proc) do
+        Proc.new do |return_output|
+          subject.cmd command, env: env, bundled_env: bundled_env,
+            return_output: return_output, display: display
+        end
+      end
+
+      it "runs the command as expected when return_output: true" do
+        return_output = true
+        cmd_double = double
+        output = "output"
+        expect(Logger.logger).to receive(:command).with(command, mode: display)
+        expect(Env).to receive(:build_env).with(env, bundled_env: bundled_env).and_return(new_env)
+        expect(Command).to receive(:new).with(command, env: new_env, shell: false).and_return(cmd_double)
+        expect(cmd_double).to receive(:capture).and_return(output)
+        out = cmd_proc.call(return_output)
+        expect(out).to eq(output)
+      end
+
+      it "runs the command as expected when return_output: false" do
+        return_output = false
+        cmd_double = double
+        expect(Logger.logger).to receive(:command).with(command, mode: display)
+        expect(Env).to receive(:build_env).with(env, bundled_env: bundled_env).and_return(new_env)
+        expect(Command).to receive(:new).with(command, env: new_env, shell: false).and_return(cmd_double)
+        expect(cmd_double).to receive(:run)
+        cmd_proc.call(return_output)
+      end
+    end
+
+    describe "#sh" do
+      command = "touch a"
+      display = :a
+      env = {"a" => "1" }
+      bundled_env = :benv
+      new_env = {"e" => "1"}
+
+      let(:sh_proc) do
+        Proc.new do |return_output|
+          subject.sh command, env: env, bundled_env: bundled_env,
+            return_output: return_output, display: display
+        end
+      end
+
+      it "runs the command as expected when return_output: true" do
+        return_output = true
+        sh_double = double
+        output = "output"
+        expect(Logger.logger).to receive(:command).with(command, mode: display)
+        expect(Env).to receive(:build_env).with(env, bundled_env: bundled_env).and_return(new_env)
+        expect(Command).to receive(:new).with(command, env: new_env, shell: true).and_return(sh_double)
+        expect(sh_double).to receive(:capture).and_return(output)
+        out = sh_proc.call(return_output)
+        expect(out).to eq(output)
+      end
+
+      it "runs the command as expected when return_output: false" do
+        return_output = false
+        sh_double = double
+        expect(Logger.logger).to receive(:command).with(command, mode: display)
+        expect(Env).to receive(:build_env).with(env, bundled_env: bundled_env).and_return(new_env)
+        expect(Command).to receive(:new).with(command, env: new_env, shell: true).and_return(sh_double)
+        expect(sh_double).to receive(:run)
+        sh_proc.call(return_output)
+      end
+    end
+
+    describe "#symlink" do
+      it "creates symlink dst -> src" do
+        tmp_dir do
+          FileUtils.touch "src"
+          subject.symlink "src", "dst"
+          expect(File.realpath("dst")).to eq(File.realpath("src"))
+        end
+      end
+
+      it "does nothing if the link exists" do
+        tmp_dir do
+          FileUtils.touch "src"
+          FileUtils.ln_s "src", "dst"
+          expect(FileUtils).not_to receive(:ln_s)
+          subject.symlink "src", "dst"
+        end
+      end
+
+      it "does not call ln_s when link exists and src/dest are Pathnames" do
+        tmp_dir do
+          FileUtils.touch "src"
+          FileUtils.ln_s "src", "dst"
+          expect(FileUtils).not_to receive(:ln_s)
+          subject.symlink Pathname.new("src"), Pathname.new("dst")
+        end
+      end
+
+      it "replaces existing dst -> src(file) link atomically (using move op)" do
+        tmp_dir do
+          FileUtils.touch "src"
+          FileUtils.touch "src1"
+          FileUtils.ln_s "src1", "dst"
+          prev_inode = File.stat("dst").ino
+
+          #atomic rename
+          dir = File.dirname("dst")
+          expect(subject).to receive(:cmd).with(array_including("mv", dir), display: false).and_call_original
+
+          subject.symlink "src", "dst"
+          current_inode = File.stat("dst").ino
+          expect(File.realpath("dst")).to eq(File.realpath("src"))
+          expect(prev_inode).not_to eq(current_inode)
+        end
+      end
+
+      it "replaces existing dst -> src(dir) link atomically" do
+        tmp_dir do
+          FileUtils.mkdir "src1"
+          FileUtils.mkdir "src"
+          FileUtils.ln_s "src1", "dst"
+          prev_inode = File.stat("dst").ino
+
+          dir = File.dirname("dst")
+
+          expect(subject).to receive(:cmd).with(array_including("mv", dir), display: false).and_call_original
+
+          subject.symlink "src", "dst"
+          current_inode = File.stat("dst").ino
+          expect(File.realpath("dst")).to eq(File.realpath("src"))
+          expect(prev_inode).not_to eq(current_inode)
+        end
+      end
+
+      it "raises an error when dst file already exists" do
+        tmp_dir do
+          FileUtils.touch "src"
+          FileUtils.touch "dst"
+          expect { subject.symlink "src", "dst" }.to raise_error(Error)
+        end
+      end
+
+    end
+  end
+end