dply 0.2.19 → 0.3.0

data/lib/dplyr/consul.rb

@@ -15,7 +15,7 @@ module Dplyr
         metadata = metadata_tag ? JSON.parse(metadata_tag.partition(":")[2]) : {}
         host[:user] = metadata["user"]
         host[:dir] = metadata["dir"]
-        host[:addr] = i["Address"] 
+        host[:addr] = i["Address"]
         host[:id] = i["Node"]
         hosts << host
       end

data/spec/dply/base_config_spec.rb

@@ -0,0 +1,178 @@
+require 'dply/base_config'
+
+module Dply
+  describe BaseConfig do
+
+    before :all do
+      @work_dir = "tmp/base_config"
+      FileUtils.rm_rf @work_dir
+      FileUtils.mkdir_p @work_dir
+
+      conf_working
+      conf_invalid_type
+      conf_invalid_opt
+      conf_missing_opts
+      conf_override
+      conf_other
+    end
+
+    class TestConfig < BaseConfig
+      define_opts do
+        opt :any
+        opt :int, type: Integer
+        opt :arr, type: Array
+        opt :str1, type: String
+        opt :str2, type: String
+      end
+
+      def default_config
+        any "default_any"
+        arr [:default]
+      end
+    end
+
+    def conf_path(name)
+      "#{@work_dir}/#{name}.rb"
+    end
+
+    def write_conf(name, data)
+      File.write(conf_path(name), data)
+    end
+
+    def conf_working
+      write_conf "working", <<~'EOF'
+        any "1"
+        int 2
+        arr [:myval]
+        str1 { "#{any}#{int}#{str2}" }
+        str2 "s2"
+      EOF
+    end
+
+    def conf_other
+      write_conf "other", <<~'EOF'
+        any "4"
+        any "3"
+      EOF
+    end
+
+    def conf_invalid_type
+      write_conf "invalid_type", <<~'EOF'
+        any "1"
+        int "2"
+      EOF
+    end
+
+    def conf_invalid_opt
+      write_conf "invalid_opt", <<~'EOF'
+        other_opt "2"
+      EOF
+    end
+
+    def conf_missing_opts
+      write_conf "missing_opts", <<~'EOF'
+        any "m"
+      EOF
+    end
+
+    def conf_override
+      write_conf "override", <<~'EOF'
+        any "1"
+        any { "override" }
+      EOF
+    end
+
+    describe ".build" do
+
+      it "parses the config and returns a struct" do
+        path = conf_path "working"
+        conf = TestConfig.build(path)
+        expect(conf.any).to eq("1")
+        expect(conf.int).to eq(2)
+        expect(conf.arr).to eq([:myval])
+        expect(conf.str1).to eq("12s2")
+        expect(conf.str2).to eq("s2")
+      end
+
+      it "calls default_config on opts_struct to set default values" do
+        conf = TestConfig.build
+        expect(conf.any).to eq("default_any")
+        expect(conf.arr).to eq([:default])
+      end
+
+      it "reads config using block" do
+        path = conf_path "working"
+        conf1 = TestConfig.build do
+          read path
+        end
+        conf2 = TestConfig.build(path)
+        expect(conf1.any).to eq(conf2.any)
+        expect(conf2.str1).to eq(conf2.str1)
+      end
+
+      it "reads multiple configs(some can be optional) using block" do
+        path = conf_path "working"
+        other_path = conf_path "other"
+        optional_path = "#{@work_dir}/missing.rb"
+
+        conf = TestConfig.build do
+          read optional_path, optional: true
+          read path
+          read other_path
+        end
+        expect(conf.any).to eq("3")
+        expect(conf.int).to eq(2)
+        expect(conf.arr).to eq([:myval])
+        expect(conf.str1).to eq("32s2")
+        expect(conf.str2).to eq("s2")
+      end
+
+      it "raises error when config file is not readable" do
+        path = "#{@work_dir}/missing.rb"
+        expect { TestConfig.build(path) }.to raise_error(Error)
+      end
+
+      specify "config methods are available inside block" do
+        path = conf_path "working"
+        conf = TestConfig.build do
+          read path
+          any "45"
+          str2 { "block_override" }
+        end
+        expect(conf.any).to eq("45")
+        expect(conf.str2).to eq("block_override")
+      end
+
+      it "overrides values when using block setter" do
+        path = conf_path "override"
+        conf = TestConfig.build(path)
+        expect(conf.any).to eq("override")
+      end
+
+      specify "set method works" do
+        conf = TestConfig.build do
+          set :any, "setval"
+        end
+        expect(conf.any).to eq("setval")
+      end
+
+      it "raises an error on invalid type" do
+        path = conf_path "invalid_type"
+        expect { TestConfig.build(path) }.to raise_error(Error, /Expected: /)
+      end
+
+      it "raises an error on invalid opt" do
+        path = conf_path "invalid_opt"
+        expect { TestConfig.build(path) }.to raise_error(Error, /invalid option/)
+      end
+
+      it "ignores missing options" do
+        path = conf_path "missing_opts"
+        conf = TestConfig.build path
+        expect(conf.any).to eq("m")
+        expect(conf.str2).to eq(nil)
+      end
+
+    end
+  end
+end

data/spec/dply/bundle_spec.rb

@@ -0,0 +1,100 @@
+require 'dply/bundle'
+
+module Dply
+  describe Bundle do
+
+    def config_content
+      {
+        "BUNDLE_PATH" => "vendor/bundle",
+        "BUNDLE_FROZEN" => "1",
+        "BUNDLE_DISABLE_SHARED_GEMS" => "1"
+      }
+    end
+
+    def expect_config
+      content = YAML.load_file("#{Dir.pwd}/.bundle/config")
+      expect(content).to include(config_content)
+    end
+
+    def bundle_check(ret)
+      allow(bundle).to receive(:system).with("bundle check > /dev/null") do
+        expect_config
+        ret
+      end
+    end
+
+    def expect_install
+      expect(bundle).to receive(:cmd).with(install_cmd) do
+        expect_config
+        true
+      end
+    end
+
+    subject(:bundle) { Bundle.new }
+    let(:install_cmd) { "bundle install -j5 --deployment" }
+
+    describe "#install" do
+
+      it "does nothing when gemfile not present" do
+        Dir.chdir("spec/test_data/bundle/no_gemfile") do
+          expect(File).not_to exist(".bundle/config")
+          expect(bundle).not_to receive(:cmd)
+          bundle.install
+        end
+      end
+
+      context "when gems not installed" do
+        let!(:app_dir) { "#{Dir.pwd}/spec/test_data/bundle/gems_not_installed" }
+
+        before(:each) do
+          FileUtils.rm_rf "#{app_dir}/.bundle"
+        end
+
+        it "writes the bundle config and runs bundle install" do
+          Dir.chdir app_dir do
+            bundle_check false
+            expect_install
+            bundle.install
+          end
+        end
+
+        it "overwrites the bundle config and runs bundle install" do
+          Dir.chdir app_dir do
+            FileUtils.mkdir ".bundle"
+            IO.write ".bundle/config", "some_text"
+            bundle_check false
+            expect_install
+            bundle.install
+          end
+        end
+      end
+
+      context "when gems installed" do
+        let(:app_dir) { "spec/test_data/bundle/gems_installed" }
+
+        it "doesn't run bundle install" do
+          Dir.chdir app_dir do
+            bundle_check true
+            expect(bundle).not_to receive(:cmd).with(install_cmd)
+            bundle.install
+          end
+        end
+      end
+    end
+
+    describe "#clean" do
+      it "doesn't run bundle clean when gemfile is not present" do
+        Dir.chdir("spec") do
+          expect(bundle).not_to receive(:cmd)
+          bundle.clean
+        end
+      end
+
+      it "writes the config and runs bundle clean" do
+        expect_config
+        expect(bundle).to receive(:cmd).with("bundle clean")
+        bundle.clean
+      end
+    end
+  end
+end

data/spec/dply/command_spec.rb

@@ -0,0 +1,190 @@
+require 'dply/command'
+require 'fileutils'
+require 'tmpdir'
+
+module Dply
+  describe Command do
+
+    before :all do
+      FileUtils.rm_rf "tmp/command"
+      FileUtils.mkdir_p "tmp/command"
+    end
+
+    CMD = "ruby --disable-gems test.rb #{Process.pid} 'a b' | tee"
+    CMD_ARR = ["ruby", "--disable-gems", "test.rb", "#{Process.pid}", "a b", "|", "tee" ]
+    CMD_ENV = { "E1" => "1", "E2" => "2" }
+
+    def tmp_dir(&block)
+      cwd = Dir.pwd
+      d = Dir.mktmpdir nil, "#{cwd}/tmp/command"
+      FileUtils.cp "#{cwd}/spec/test_data/command/test.rb", "#{d}/test.rb"
+      Dir.chdir(d) { yield d }
+    end
+
+    def deserialize(file)
+      Marshal.load(IO.read file)
+    end
+
+    def expect_run
+      ["env", "shell", "extra_args"].each do |i|
+        expect(File).to exist(i)
+      end
+    end
+
+    def expect_env(expected, shell:)
+      env = deserialize "env"
+      if shell
+        expect(env).to include(expected)
+      else
+        expect(env).to eq(expected)
+      end
+    end
+
+    def expect_args(list)
+      args = deserialize "extra_args"
+      expect(args).to eq list
+    end
+
+    def expect_shell(expected)
+      content = IO.read("shell").chomp
+      expect(content).to eq expected.to_s
+    end
+
+    arg_values = {
+      command: [CMD, CMD_ARR],
+      env: [CMD_ENV],
+      shell: [true, false]
+    }
+
+    hash_product = Proc.new do |h|
+      values = h.values
+      keys = h.keys
+      product = values[0].product(*values[1..-1])
+      product.map { |p| Hash[keys.zip p] }
+    end
+
+    test_cases = hash_product[arg_values].reject { |i| i[:command] == CMD_ARR && i[:shell] }
+
+    result_proc = lambda do |args|
+      shell = args.fetch :shell
+      extra_args = shell ? ["a b"] : ["a b", "|", "tee"]
+      {extra_args: extra_args}
+    end
+
+    describe '#run' do
+
+      test_cases.each do |i|
+        expected = result_proc.call i
+        command = i[:command]
+        shell = i[:shell]
+        env = i[:env]
+
+        context "cmd: #{i[:command].class}, shell: #{shell}, env: #{env}" do
+          it "runs as expected" do
+            tmp_dir do
+              c = Command.new command, shell: shell, env: env
+              retval = nil
+              expect { retval = c.run }.to output("outout").to_stdout_from_any_process
+              expect(retval).to eq(true)
+              expect_run
+              expect_env env, shell: shell
+              expect_args expected[:extra_args]
+              expect_shell shell
+            end
+          end
+        end
+      end
+
+      context "when calling non existent command" do
+        let(:cmd) { "non_existent" }
+        let(:script) { "(non_existent | grep a ) 2>/dev/null >/dev/null" }
+
+        it "raises error when command is not a shell script" do
+          expect { (Command.new cmd, env: {}, shell: false).run }.to raise_error(Error)
+          expect { (Command.new cmd, env: {}, shell: true).run }.to raise_error(Error)
+        end
+
+        it "raises error when command is a shell script" do
+          expect { (Command.new script, env: {}, shell: false).run }.to raise_error(Error)
+          expect { (Command.new script, env: {}, shell: true).run }.to raise_error(Error)
+        end
+      end
+
+      context "when a command returns non-zero exit status" do
+
+        let(:cmd) { "false | grep some_var" }
+
+        it "raises error" do
+          expect { (Command.new cmd, env: {}, shell: false).run }.to raise_error(Error)
+          expect { (Command.new cmd, env: {}, shell: true).run }.to raise_error(Error)
+        end
+      end
+
+      context "command contains shell characters with zero arguments and shell: false" do
+        let(:cmd) { "non_existent;ls" }
+        it "spawns a shell but escapes the command (no workaround for it)" do
+          expect { (Command.new cmd, env: {}, shell: false).run }.to raise_error(Error).and(
+            output("sh: #{cmd}: command not found\n").to_stdout_from_any_process)
+        end
+      end
+    end
+
+    describe '#capture' do
+
+      test_cases.each do |i|
+        expected = result_proc.call i
+        command = i[:command]
+        shell = i[:shell]
+        env = i[:env]
+
+        context "cmd: #{i[:command].class}, shell: #{shell}, env: #{env}" do
+          it "runs as expected" do
+            tmp_dir do
+              c = Command.new command, shell: shell, env: env
+              retval = nil
+              expect { retval = c.capture }.to output("out").to_stderr_from_any_process
+              expect(retval).to eq('out')
+              expect_run
+              expect_env env, shell: shell
+              expect_args expected[:extra_args]
+              expect_shell shell
+            end
+          end
+        end
+      end
+
+      context "when calling non existent command" do
+        let(:cmd) { "non_existent" }
+        let(:script) { "(non_existent | grep a ) 2>/dev/null >/dev/null" }
+
+        it "raises error when command is not a shell script" do
+          expect { (Command.new cmd, env: {}, shell: false).capture }.to raise_error(Errno::ENOENT)
+          expect { (Command.new cmd, env: {}, shell: true).capture }.to raise_error(Errno::ENOENT)
+        end
+
+        it "raises error when command is a shell script" do
+          expect { (Command.new script, env: {}, shell: false).capture }.to raise_error(Errno::ENOENT)
+          expect { (Command.new script, env: {}, shell: true).capture }.to raise_error(Error)
+        end
+      end
+
+      context "when a command returns non-zero exit status" do
+
+        let(:cmd) { "false | grep some_var" }
+
+        it "raises error" do
+          expect { (Command.new cmd, env: {}, shell: false).capture }.to raise_error(Error)
+          expect { (Command.new cmd, env: {}, shell: true).capture }.to raise_error(Error)
+        end
+      end
+
+      context "command contains shell characters with zero arguments and shell: false" do
+        let(:cmd) { "non_existent;ls" }
+        it "doesn't spawn a shell" do
+          expect { (Command.new cmd, env: {}, shell: false).capture }.to raise_error(Errno::ENOENT)
+        end
+      end
+    end
+
+  end
+end