loom-core 0.0.1

data/spec/loom/pattern/dsl_spec.rb

@@ -0,0 +1,207 @@
+require "loom/facts"
+require "loom/pattern"
+require "loom/shell"
+
+describe Loom::Pattern::DSL do
+
+  # Fake API for tests. This object should raise an error on any command
+  # execution.
+  let(:fake_shell) { Loom::Shell::FakeApi.new }
+  let(:a_fact_set) do
+    Loom::Facts::FactSet.new('fake.host', :fact_one => 1, :fact_two => :two)
+  end
+
+  before do
+    # bit buckets the logs
+    @logger_io = StringIO.new
+    Loom.configure do |config|
+      config.log_device = @logger_io
+    end
+
+    @reference_set = Loom::Pattern::ReferenceSet::Builder
+      .create(loom_file, ':loom_file')
+  end
+
+  let(:pattern_under_test) { @reference_set['pattern_under_test'] }
+  let(:inner_pattern) { @reference_set['inner:an_inner_pattern'] }
+
+  context "pattern basics" do
+
+    let(:loom_file) do
+<<EOS
+  desc "a description of pattern_under_test"
+  pattern :pattern_under_test do |loom, facts|
+    loom.do_outer_thing
+  end
+
+  module Inner
+    include Loom::Pattern
+
+    desc "an inner pattern"
+    pattern :an_inner_pattern do |loom, facts|
+      loom.do_inner_thing
+    end
+  end
+EOS
+    end
+
+    it "defines a Pattern::Reference" do
+      expect(pattern_under_test).to be_a Loom::Pattern::Reference
+    end
+
+    it "defines a reference with a desc" do
+      expect(pattern_under_test.desc).to(
+        eql "a description of pattern_under_test")
+    end
+
+    it "defines an inner reference with a desc" do
+      expect(inner_pattern.desc).to eql "an inner pattern"
+    end
+
+    it "is runnable" do
+      pattern_under_test.call fake_shell, a_fact_set
+      expect(fake_shell.cmd_executions.first).to be :do_outer_thing
+    end
+  end
+
+  context "#let" do
+
+    let(:loom_file) do
+<<EOS
+  let(:let_var_1) { "let var 1"}
+  let(:let_var_2) { "let var 2"}
+
+  desc "a description of pattern_under_test"
+  pattern :pattern_under_test do |loom, facts|
+    loom.do_outer_thing(let_var_1, let_var_2)
+  end
+
+  desc "a pattern that will raise an erorr"
+  pattern :bogus_pattern do |loom, facts|
+    loom.do_outer_thing(let_var_3)
+  end
+
+  module Inner
+    include Loom::Pattern
+
+    let(:let_var_2) { "override let var 2"}
+    let(:let_var_3) { "let var 3"}
+
+    desc "an inner pattern"
+    pattern :an_inner_pattern do |loom, facts|
+      loom.do_inner_thing(let_var_1, let_var_2, let_var_3)
+    end
+  end
+EOS
+    end
+
+    it "defines :let declartions at the top level" do
+      pattern_under_test.call fake_shell, a_fact_set
+      expect(fake_shell.cmd_execution_args.first).to(
+        eql ["let var 1", "let var 2"])
+    end
+
+    it "defines :let declartions at inner scopes, innacessible to outer" do
+      expect do
+        @reference_set['bogus_pattern'].call fake_shell, a_fact_set
+      end.to raise_error /^undefined local variable/
+    end
+
+    it "defines :let declarations at inner scopes, overriding outer scope" do
+      inner_pattern.call fake_shell, a_fact_set
+      expect(fake_shell.cmd_execution_args.first).to(
+        eql ["let var 1", "override let var 2", "let var 3"])
+    end
+  end
+
+  context "#with_facts" do
+
+    let(:loom_file) do
+<<EOS
+  with_facts :outer_fact => :outer
+
+  desc "a description of pattern_under_test"
+  pattern :pattern_under_test do |loom, facts|
+    loom.do_outer_thing facts[:outer_fact]
+  end
+
+  module Inner
+    include Loom::Pattern
+
+    with_facts :inner_fact => :inner
+
+    desc "an inner pattern"
+    pattern :an_inner_pattern do |loom, facts|
+      loom.do_inner_thing(facts[:outer_fact], facts[:inner_fact])
+    end
+  end
+EOS
+    end
+
+    it "defines fact sets at the top level" do
+      pattern_under_test.call fake_shell, a_fact_set
+      expect(fake_shell.cmd_execution_args.first).to(
+        eql [:outer])
+    end
+
+    it "provides fact sets that get merged into inner modules" do
+      inner_pattern.call fake_shell, a_fact_set
+      expect(fake_shell.cmd_execution_args.first).to(
+        eql [:outer, :inner])
+    end
+  end
+
+  context "hooks" do
+
+    let(:loom_file) do
+<<EOS
+
+  let(:hook_order) { [] }
+
+  before do hook_order.push("outer before hook") end
+  after do hook_order.push("outer after hook") end
+
+  desc "a description of pattern_under_test"
+  pattern :pattern_under_test do |loom, facts|
+    hook_order.push "execute the pattern"
+    loom.do_outer_thing(hook_order)
+  end
+
+  module Inner
+    include Loom::Pattern
+
+    before do hook_order.push("inner before hook") end
+    after do hook_order.push("inner after hook") end
+
+    desc "an inner pattern"
+    pattern :an_inner_pattern do |loom, facts|
+      hook_order.push "execute inner pattern"
+      loom.do_inner_thing(hook_order)
+    end
+  end
+EOS
+    end
+
+    it "executes outer before hooks first and after hooks last" do
+      pattern_under_test.call fake_shell, a_fact_set
+      expect(fake_shell.cmd_execution_args.first).to eql [[
+        "outer before hook",
+        "execute the pattern",
+        "outer after hook"
+      ]]
+    end
+
+    it "executes nested hooks in wrapped order" do
+      inner_pattern.call fake_shell, a_fact_set
+      expect(fake_shell.cmd_execution_args.first).to eql [[
+        "outer before hook",
+        "inner before hook",
+        "execute inner pattern",
+        "inner after hook",
+        "outer after hook"
+      ]]
+    end
+
+  end
+
+end

data/spec/loom/shell/cmd_wrapper_spec.rb

@@ -0,0 +1,239 @@
+require "loom/shell"
+require "yaml"
+
+describe Loom::Shell::CmdWrapper do
+
+  def unescape_cmd(cmd)
+    YAML.load(%Q(---\n"#{cmd.to_s}"\n))
+  end
+
+  context "examples" do
+    it "escapes spaces" do
+      cmd = Loom::Shell::CmdWrapper.new :printf, "print out this string"
+      expect(%x{#{cmd}}).to eql "print out this string"
+    end
+
+    it "skips escaping symbols and frozen string" do
+      cmd = Loom::Shell::CmdWrapper.new :"/bin/echo", :"\"yy\"", "\"xx\""
+      expect(%x{#{cmd}}.strip).to eql "yy \"xx\""
+    end
+  end
+
+  context ".new" do
+    it "does not escape whitespace between joined commands parts" do
+      cmd = Loom::Shell::CmdWrapper.new :echo, "-n", "\"all the rest\""
+      expect(cmd.escape_cmd).to eql "echo -n \\\"all\\ the\\ rest\\\""
+    end
+
+    it "flattens cmd input" do
+      cmd = Loom::Shell::CmdWrapper.new :somecmd, ["-f", "file.txt"], [:a, [:b]]
+      expect(cmd.to_s).to eql "somecmd -f file.txt a b"
+    end
+  end
+
+  context ".escape" do
+    it "escapes CmdWrappers" do
+      cmd = Loom::Shell::CmdWrapper.new '"hi"'
+      expect(Loom::Shell::CmdWrapper.escape cmd).to eql cmd.to_s
+    end
+
+    it "escapes recursively" do
+      content = 'I said "row row row your boat"'
+      cmd_inner = 'echo "%s"' % Loom::Shell::CmdWrapper.escape(content)
+      cmd_outer = '"%s"' % Loom::Shell::CmdWrapper.escape(cmd_inner)
+
+      expected = '"echo\ \"I\\\\\ said\\\\\ ' +
+                 '\\\\\"row\\\\\ row\\\\\ row\\\\\ your\\\\\ boat\\\\\"\""'
+
+      printf_expected = 'echo\\ "I\ said\ "row\ row\ row\ your\ boat""'
+
+      expect(cmd_outer).to eql expected
+      expect(%x{printf #{cmd_outer}}.strip).to eql printf_expected
+    end
+  end
+
+  context "#escape" do
+    it "escapes strings with quotes" do
+      cmd = Loom::Shell::CmdWrapper.new '"hi"'
+
+      expected = '\"hi\"'
+      expect(cmd.escape_cmd).to eql expected
+      expect(%x{printf #{expected}}.strip).to eql unescape_cmd(cmd)
+    end
+
+    it "ignores strings without quotes" do
+      cmd = Loom::Shell::CmdWrapper.new 'hi'
+
+      expected = 'hi'
+      expect(cmd.escape_cmd).to eql expected
+      expect(%x{printf #{expected}}.strip).to eql unescape_cmd(cmd)
+    end
+
+    it "escapes nested quotes" do
+      cmd = Loom::Shell::CmdWrapper.new 'echo "hi"'
+
+      expected = 'echo\\ \"hi\"'
+      expect(cmd.escape_cmd).to eql expected
+      expect(%x{printf #{expected}}.strip).to eql unescape_cmd(cmd)
+    end
+
+    it "respects frozen? string" do
+      cmd = Loom::Shell::CmdWrapper.new :echo, "\"^FROZEN^\"".freeze, :"^", "^"
+
+      expected = 'echo "^FROZEN^" ^ \^'
+      expect(cmd.escape_cmd).to eql expected
+    end
+
+    it "respects wrapped frozen? strings" do
+      cmd_inner = Loom::Shell::CmdWrapper.new :echo, "\"^#FROZEN^\"".freeze
+      cmd = Loom::Shell::CmdWrapper.wrap_cmd :sudo, cmd_inner
+
+      expected = 'sudo echo "^#FROZEN^"'
+      expect(cmd.escape_cmd).to eql expected
+    end
+  end
+
+  # I don't want to think about this shit anymore. Don't touch this unless its
+  # broken.
+  context "#wrap" do
+    it "preserves escaped CmdWrappers: depth 2" do
+      cmd_which = Loom::Shell::CmdWrapper.new :which, :ls
+      cmd_sh = Loom::Shell::CmdWrapper.new :"/bin/sh", "-c", should_quote: true
+
+      composed_cmd = cmd_sh.wrap(cmd_sh.wrap(cmd_which)).to_s
+
+      expected = "/bin/sh -c \"/bin/sh -c \\\"which ls\\\"\""
+
+      expect(composed_cmd).to eql expected
+      # Matches /bin/ls$ for portability, on fedora it's /usr/bin/ls
+      expect(%x{#{composed_cmd}}.strip).to match /\/bin\/ls$/
+    end
+
+    it "preserves escaped CmdWrappers: depth N" do
+      cmd_which = Loom::Shell::CmdWrapper.new :which, :ls
+      cmd_sh = Loom::Shell::CmdWrapper.new :"/bin/sh", "-c", should_quote: true
+
+      composed_cmd = cmd_sh.wrap(cmd_sh.wrap(cmd_sh.wrap(cmd_which))).to_s
+
+      expected =
+        "/bin/sh -c \"/bin/sh -c \\\"/bin/sh -c \\\\\\\"which ls\\\\\\\"\\\"\""
+
+      expect(composed_cmd).to eql expected
+      # Matches /bin/ls$ for portability, on fedora it's /usr/bin/ls
+      expect(%x{#{composed_cmd}}.strip).to match /\/bin\/ls$/
+    end
+  end
+
+  context Loom::Shell::CmdRedirect do
+
+    let(:cmd_parts) { [:"/bin/ls"] }
+
+    it "redirects stdout to file" do
+      redirect = Loom::Shell::CmdRedirect.new "/my/file"
+      cmd = Loom::Shell::CmdWrapper.new *cmd_parts, redirect: redirect
+
+      expect(cmd.to_s).to eql "/bin/ls >/my/file"
+    end
+
+    it "redirects stderr to file" do
+      redirect = Loom::Shell::CmdRedirect.new "/my/file", fd: 2
+      cmd = Loom::Shell::CmdWrapper.new *cmd_parts, redirect: redirect
+
+      expect(cmd.to_s).to eql "/bin/ls 2>/my/file"
+    end
+
+    it "appends stdout to file" do
+      mode = Loom::Shell::CmdRedirect::Mode::APPEND
+
+      redirect = Loom::Shell::CmdRedirect.new "/my/file", mode: mode
+      cmd = Loom::Shell::CmdWrapper.new *cmd_parts, redirect: redirect
+
+      expect(cmd.to_s).to eql "/bin/ls >>/my/file"
+    end
+
+    it "appends stderr to file" do
+      mode = Loom::Shell::CmdRedirect::Mode::APPEND
+
+      redirect = Loom::Shell::CmdRedirect.new "/my/file", fd: 2, mode: mode
+      cmd = Loom::Shell::CmdWrapper.new *cmd_parts, redirect: redirect
+
+      expect(cmd.to_s).to eql "/bin/ls 2>>/my/file"
+    end
+
+    it "redirects stderr to stdout" do
+      redirect = Loom::Shell::CmdRedirect.new 1, fd: 2
+      cmd = Loom::Shell::CmdWrapper.new *cmd_parts, redirect: redirect
+
+      expect(cmd.to_s).to eql "/bin/ls 2>1"
+    end
+
+    it "redirects both stderr and stdout to file" do
+      mode = Loom::Shell::CmdRedirect::Mode::OUTPUT_12
+
+      redirect = Loom::Shell::CmdRedirect.new "/my/file", mode: mode
+      cmd = Loom::Shell::CmdWrapper.new *cmd_parts, redirect: redirect
+
+      expect(cmd.to_s).to eql "/bin/ls &>/my/file"
+    end
+
+    context "helper factories" do
+
+      it "appends to stdout" do
+        redirect = Loom::Shell::CmdRedirect.append_stdout "/my/file"
+        cmd = Loom::Shell::CmdWrapper.new *cmd_parts, redirect: redirect
+
+        expect(cmd.to_s).to eql "/bin/ls >>/my/file"
+      end
+    end
+
+    context "multiple redirects" do
+      it "redirects both stderr and stdout to file" do
+
+        redirects = [
+          Loom::Shell::CmdRedirect.new("/my/file"),
+          Loom::Shell::CmdRedirect.new(1, fd: 2)
+        ]
+        cmd = Loom::Shell::CmdWrapper.new *cmd_parts, redirect: redirects
+
+        expect(cmd.to_s).to eql "/bin/ls >/my/file 2>1"
+      end
+    end
+
+    context "wrapped redirects" do
+      it "does not escape redirects" do
+        skip "fails - this is why I started implementing the harness see " +
+          "`git show 1196d2ec2` for info"
+        r = Loom::Shell::CmdRedirect.append_stdout "/my/file"
+
+        cmd_inner = Loom::Shell::CmdWrapper.new :echo, :hello, redirect: r
+        cmd = Loom::Shell::CmdWrapper.wrap_cmd :sudo, "-u", :root, cmd_inner
+
+        expect(cmd.to_s).to eql "sudo -u root echo hello >>/my/file"
+      end
+    end
+  end
+
+  context Loom::Shell::CmdPipeline do
+
+    let(:cmds) do
+      [
+        Loom::Shell::CmdWrapper.new(:find, ".", "-name", "*foo", "-print0"),
+        Loom::Shell::CmdWrapper.new(:xargs, "-0", "-I-", "ls", "-")
+      ]
+    end
+
+    it "pipes commands together" do
+      pipeline = Loom::Shell::CmdPipeline.new cmds
+
+      expected = "find . -name \\*foo -print0 | xargs -0 -I- ls -"
+      expect(pipeline.to_s).to eql expected
+    end
+
+    it "accepts commands as pre-escaped strings" do
+      pipeline = Loom::Shell::CmdPipeline.new ["I'm already escaped", "me too!"]
+
+      expected = "I'm already escaped | me too!"
+      expect(pipeline.to_s).to eql expected
+    end
+  end
+end

data/spec/loom/shell/harness_blob_spec.rb

@@ -0,0 +1,42 @@
+describe Loom::Shell::HarnessBlob do
+
+  HARNESS = "./scripts/harness.sh"
+
+  # Set debug_script to true in a context to see STDERR debugging.
+  let(:debug_script) { false }
+
+  let(:cmd) { 'echo hi there | (echo "from subshell"; cat);' }
+  let(:encoded_script) do
+    run_harnes_script "--print_base64", :stdin => cmd
+  end
+  let(:golden_checksum) do
+    run_harnes_script "--print_checksum", encoded_script
+  end
+
+
+  def run_harnes_script(cmd, *args, stdin: nil)
+    cmd = %Q{./scripts/harness.sh 2>/dev/null #{cmd}}
+
+    heredoc = nil
+    if stdin
+      heredoc = "<<'EOS'\n#{stdin}\nEOS"
+      cmd << " - #{args.join " "} #{heredoc}"
+    else
+      cmd << " #{args.join " "}"
+    end
+
+    %x{#{cmd}}
+  end
+
+  describe "scripts/harness.sh parity" do
+
+    subject { Loom::Shell::HarnessBlob.new cmd }
+
+    it "computes a valid script checksum" do
+      run_harnes_script "--check", golden_checksum, {
+                          :stdin => subject.encoded_script
+                        }
+      expect($?.exitstatus).to eq 0
+    end
+  end
+end