dply 0.2.19 → 0.3.0

data/spec/dply/linker_spec.rb

@@ -0,0 +1,81 @@
+require 'dply/linker'
+require 'pathname'
+
+module Dply
+  describe Linker do
+
+    before :all do
+      FileUtils.rm_rf "tmp/linker"
+      FileUtils.mkdir_p "tmp/linker"
+    end
+
+    def new_work_dir
+      d = Dir.mktmpdir nil, "tmp/linker"
+      Dir.chdir d do
+        FileUtils.mkdir ["src", "src/dir1", "src/dir2", "dest", "dest/config"]
+        FileUtils.touch ["src/file1", "src/file2"]
+      end
+      "#{Dir.pwd}/#{d}"
+    end
+
+    def linker(map:, work_dir:)
+      src = "#{work_dir}/src"
+      dest = "#{work_dir}/dest"
+      Linker.new src, dest, map: map
+    end
+
+    let(:map) do
+      {
+        "config/1" => "file1",
+        "file2" => "file2",
+        "tmp" => "dir1",
+        "log" => "dir2"
+      }
+    end
+
+    describe ".new" do
+      it "doesn't accept relative path for src_dir" do
+        expect { Linker.new("tmp", "/tmp", map: {}) }.to raise_error(Dply::Error)
+      end
+
+      it "doesn't accept relative path for dest_dir" do
+        expect { Linker.new("/tmp", "tmp", map: {}) }.to raise_error(Dply::Error)
+      end
+
+      it "doesn't accept relative paths in map" do
+        expect { Linker.new("/tmp", "/tmp/1", map: {"/a" => "b"}) }.to raise_error(Dply::Error)
+        expect { Linker.new("/tmp", "/tmp/1", map: {"a" => "/b"}) }.to raise_error(Dply::Error)
+      end
+    end
+
+    describe "#create_symlinks" do
+
+      it "creates expected symlinks" do
+        work_dir = new_work_dir
+        linker = linker(map: map, work_dir: work_dir)
+        linker.create_symlinks
+        map.each do |k, v|
+          dpath = Pathname.new("#{work_dir}/dest/#{k}").realpath
+          spath = Pathname.new("#{work_dir}/src/#{v}")
+          expect(dpath).to eq(spath)
+        end
+      end
+
+      it "errors out if link target already exists" do
+        work_dir = new_work_dir
+        FileUtils.touch "#{work_dir}/dest/tmp"
+        linker = linker(map: map, work_dir: work_dir)
+        expect { linker.create_symlinks }.to raise_error(Dply::Error)
+      end
+
+      it "errors out if link source doesn't exist" do
+        work_dir = new_work_dir
+        FileUtils.touch "#{work_dir}/dest/tmp"
+        map = { "log" => "non_existent" }
+        linker = linker(map: map, work_dir: work_dir)
+        expect { linker.create_symlinks }.to raise_error(Dply::Error)
+      end
+
+    end
+  end
+end

data/spec/dply/lock_spec.rb

@@ -0,0 +1,24 @@
+require 'dply/lock'
+
+module Dply
+  describe Lock do
+    describe "#acquire" do
+      it "acquires an exclusive lock(flock) on the given dir" do
+        lock = Lock.new("tmp")
+        lock.acquire
+        other_lock = Lock.new("tmp")
+        expect { other_lock.acquire }.to raise_error(Error, /exclusive lock/)
+      end
+
+      specify "lock survives GC" do
+        GC.start(full_mark: true, immediate_sweep: true)
+        lock = Lock.new("tmp")
+        lock.acquire
+
+        GC.start(full_mark: true, immediate_sweep: true)
+        other_lock = Lock.new("tmp")
+        expect { other_lock.acquire }.to raise_error(Error, /exclusive lock/)
+      end
+    end
+  end
+end

data/spec/dply/pkgs_spec.rb

@@ -0,0 +1,105 @@
+require 'dply/pkgs'
+
+module Dply
+  describe Pkgs do
+
+    before :all do
+      FileUtils.rm_rf "tmp/pkgs"
+      FileUtils.mkdir_p "tmp/pkgs"
+    end
+
+    def build_yml(file, data)
+      case data
+      when Hash
+        File.write file, YAML.dump(data)
+      else
+        File.write file, data
+      end
+    end
+
+    def pkgs_yml(data, &block)
+      d = Dir.mktmpdir nil, "tmp/pkgs"
+      file = "p.yml"
+      Dir.chdir(d) do
+        build_yml file, data
+        yield file
+      end
+    end
+
+    def new_data
+      {"build_pkgs" => ["b1"], "pkgs" => ["p1", "p2"]}
+    end
+
+    INVALID_PKG_NAMES = [
+      "a1.rpm",
+      "a1*.pm",
+      "http://a.co/rpm",
+      "/a/b"
+    ]
+
+    describe ".new" do
+      it "reads pkg lists from given pkgs_yml to all/build/runtime" do
+        pkgs_yml(new_data) do |f|
+          pkgs = Pkgs.new f
+          expect(pkgs.build).to eq(["b1"])
+          expect(pkgs.runtime).to eq(["p1", "p2"])
+          expect(pkgs.all.sort).to eq(["b1", "p1", "p2"])
+        end
+      end
+
+      INVALID_PKG_NAMES.each do |i|
+        it "raises error for pkg name #{i}" do
+          d1 = new_data
+          d1["build_pkgs"] << i
+          pkgs_yml(d1) do |f|
+            expect { Pkgs.new f}.to raise_error(Error)
+          end
+
+          d2 = new_data
+          d2["pkgs"] << i
+          pkgs_yml(d2) do |f|
+            expect { Pkgs.new f}.to raise_error(Error)
+          end
+        end
+      end
+    end
+
+    subject(:pkgs) { pkgs_yml(new_data) { |f| Pkgs.new f } }
+
+    describe "#install" do
+      context "when build_mode: true" do
+        it "installs all the packages" do
+          expect(Yum).to receive(:install).with(pkgs.all)
+          expect(pkgs.all.size).to eq(3)
+          pkgs.install build_mode: true
+        end
+      end
+
+      context "when build_mode: false" do
+        it "installs only the runtime packages" do
+          expect(Yum).to receive(:install).with(pkgs.runtime)
+          expect(pkgs.runtime.size).to eq(2)
+          pkgs.install build_mode: false
+        end
+      end
+    end
+
+    describe "#installed?" do
+      context "when build_mode: true" do
+        it "returns install status" do
+          expect(Yum).to receive(:installed?).with(pkgs.all).and_return(:status)
+          expect(pkgs.all.size).to eq(3)
+          expect(pkgs.installed? build_mode: true).to eq(:status)
+        end
+      end
+
+      context "when build_mode: false" do
+        it "returns install status" do
+          expect(Yum).to receive(:installed?).with(pkgs.runtime).and_return(:status)
+          expect(pkgs.runtime.size).to eq(2)
+          expect(pkgs.installed? build_mode: false).to eq(:status)
+        end
+      end
+    end
+  end
+end

data/spec/dply/repo_spec.rb

@@ -0,0 +1,58 @@
+require 'dply/repo'
+require 'repo'
+
+module Dply
+  describe Repo do
+
+    before :all do
+      @work_dir = "tmp/repo"
+      @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
+
+    subject(:repo) { Repo.new "repo", source_repo, mirror: nil }
+
+    describe ".create" do
+      it "creates the repo from the given upstream" do
+        tmp_dir do |d|
+          suppress_output { repo.create }
+          expect(File).to exist("repo/.git")
+        end
+      end
+
+      it "throws an error if a different git repo already exists at [dir]" do
+        tmp_dir do |d|
+          FileUtils.mkdir "repo"
+          Dir.chdir "repo" do
+            system! "touch a"
+            system! "git init"
+            system! "git add a; git commit -m 'commit'"
+            system! "git remote add origin /some/other/upstream"
+          end
+          expect { repo.create }.to raise_error(Error)
+        end
+      end
+
+      it "clones repo from a mirror if specified" do
+        upstream = "/some/upstream.git"
+        repo = Repo.new "repo", upstream, mirror: source_repo
+        tmp_dir do
+          suppress_output { repo.create }
+          Dir.chdir "repo" do
+            expect(Git.remote_url).to eq(upstream)
+          end
+        end
+      end
+    end
+  end
+end

data/spec/dply/rpm_spec.rb

@@ -0,0 +1,32 @@
+require 'dply/rpm'
+
+module Dply
+  describe Rpm do
+
+    def test_cases
+      {
+        "libc.so.6" => [ "glibc" ],
+        "libacl.so.1" => ["libacl"],
+        "libattr.so.1" => ["libattr"]
+      }
+    end
+
+    def to_64bit(lib)
+      "#{lib}()(64bit)"
+    end
+
+    subject(:rpm) { Rpm }
+
+    describe ".libs_pkgs_map" do
+      it "returns the map of lib => [list of pkgs] which provide that lib" do
+        test_cases = test_cases()
+        libs = test_cases.keys.map { |i| to_64bit i }
+        map = rpm.libs_pkgs_map libs
+        test_cases.keys.each do |i|
+          lib = to_64bit(i)
+          expect(map[lib]).to eq(test_cases[i])
+        end
+      end
+    end
+  end
+end

data/spec/dply/yum_spec.rb

@@ -0,0 +1,29 @@
+require 'dply/yum'
+
+module Dply
+  describe Yum do
+
+    describe ".install" do
+      it "installs the missing packages" do
+        expect(Yum).to receive(:cmd).with(["yum", "install", "-y", "xyz"])
+        expect { Yum.install(["glibc", "xyz"]) }.to raise_error(Error)
+      end
+
+      it "doesn't do anything if packages are already installed" do
+        expect(Yum).not_to receive(:cmd).with(array_including("yum", "install"))
+        Yum.install(["glibc", "bash"])
+      end
+
+    end
+
+    describe ".installed?" do
+      it "returns true if all pkgs are installed" do
+        expect(Yum.installed? ["glibc", "bash"]).to eq(true)
+      end
+
+      it "returns false if some pkgs are not installed" do
+        expect(Yum.installed? ["glibc", "xyz"]).to eq(false)
+      end
+    end
+  end
+end

data/spec/integration/archive_flow_spec.rb

@@ -0,0 +1,87 @@
+require 'repo'
+
+describe "archive flow" do
+
+  before :all do
+    @work_dir = "tmp/archive_flow"
+    @repo_dir = "tmp/repo.git"
+    @build_dir = "#{@work_dir}/build"
+    @deploy_dir = "#{@work_dir}/deploy"
+    @drake = "#{Dir.pwd}/dev_exe/drake"
+    FileUtils.rm_rf @work_dir
+    FileUtils.mkdir_p @work_dir
+
+    puts "=="* 40
+    build_archive
+    deploy_archive
+    puts "=="* 40
+  end
+
+  def system!(command)
+    status = system command
+    raise "error in '#{command}'" if not status
+  end
+
+  def build_config
+    <<~CONFIG
+      repo "#{Dir.pwd}/#{@repo_dir}"
+      dir_map({
+        "tmp" => "tmp",
+        "log" => "log"
+      })
+    CONFIG
+  end
+
+  def deploy_config
+    <<~CONFIG
+      name "test"
+      repo "http://127.0.0.1:8000/#{@build_dir}/build"
+      strategy :archive
+      branch "master"
+
+      build_url do
+        "\#{repo}/\#{name}-\#{revision}-\#{branch}.tar.gz"
+      end
+
+      dir_map ({
+        "log" => "log",
+         "tmp" => "tmp",
+      })
+    CONFIG
+  end
+
+  def build_archive
+    FileUtils.mkdir @build_dir
+    File.write "#{@build_dir}/build.rb", build_config
+    Dir.chdir @build_dir do
+      system! "#{@drake} build -r 0"
+    end
+  end
+
+  def deploy_archive
+    FileUtils.mkdir @deploy_dir
+    IO.write "#{@deploy_dir}/deploy.rb", deploy_config
+    Dir.chdir @deploy_dir do
+      system! "#{@drake} deploy -r 0"
+    end
+  end
+
+  specify "app is deployed" do
+    Dir.chdir @deploy_dir do
+      expect(File).to exist("current")
+      expect(File.directory?("current")).to be(true)
+    end
+  end
+
+  specify "bundler installs the gems" do
+    Dir.chdir @deploy_dir do
+      expect(File).to exist("current/vendor/bundle/ruby")
+    end
+  end
+
+  specify "reload works" do
+    Dir.chdir @deploy_dir do
+      system! "#{@drake} reload"
+    end
+  end
+end

data/spec/integration/git_flow_spec.rb

@@ -0,0 +1,63 @@
+require 'repo'
+
+describe "git flow" do
+
+  before :all do
+    @work_dir = "tmp/git_flow"
+    @repo_dir = "#{Dir.pwd}/tmp/repo.git"
+    @deploy_dir = "#{@work_dir}/deploy"
+    @drake = "#{Dir.pwd}/dev_exe/drake"
+    FileUtils.rm_rf @work_dir
+    FileUtils.mkdir_p @work_dir
+
+    puts "=="* 40
+    deploy_git
+    puts "==" * 40
+  end
+
+  def system!(command)
+    status = system command
+    raise "error in '#{command}'" if not status
+  end
+
+  def deploy_config
+    <<~CONFIG
+      name "test"
+      repo "#{@repo_dir}"
+      strategy :git
+      branch "master"
+
+      dir_map ({
+        "log" => "log",
+        "tmp" => "tmp"
+      })
+    CONFIG
+  end
+
+  def deploy_git
+    FileUtils.mkdir @deploy_dir
+    IO.write "#{@deploy_dir}/deploy.rb", deploy_config
+    Dir.chdir @deploy_dir do
+      system! "#{@drake} deploy"
+    end
+  end
+
+  specify "app is deployed" do
+    Dir.chdir @deploy_dir do
+      expect(File).to exist("current")
+      expect(File.directory?("current")).to be(true)
+    end
+  end
+
+  specify "bundler installs the gems" do
+    Dir.chdir @deploy_dir do
+      expect(File).to exist("current/vendor/bundle/ruby")
+    end
+  end
+
+  specify "reload works" do
+    Dir.chdir @deploy_dir do
+      system! "#{@drake} reload"
+    end
+  end
+end