loom-core 0.0.5 → 0.0.6

data/spec/.loom/user.loom

@@ -0,0 +1,29 @@
+# Tests for LoomExt::CoreMods::User
+module User
+  include Loom::Pattern
+
+  desc "Adds a bunch of users and then removes them right away"
+  pattern :add_users do |loom, facts|
+    loom.sudo do
+      loom.user.add :nara, uid: 1001, home_dir: "/home/nara"
+      loom.user.add :marrian, home_dir: "/home/marrian"
+
+      loom.user.add_system_user :app, uid: 900
+      loom.user.add_system_user :batch
+
+      loom.user.remove :nara
+      loom.user.remove :marrian
+      loom.user.remove :app
+      loom.user.remove :batch
+    end
+  end
+
+  desc "Makes the postgres user a sudoer"
+  pattern :sudoers do |loom, facts|
+    loom.sudo do
+      loom.user.add_system_user :postgres, uid: 999
+      loom.user.make_sudoer :postgres
+      loom.user.remove :postgres
+    end
+  end
+end

data/spec/.loom/vms.loom

@@ -0,0 +1,22 @@
+# Tests for LoomExt::CoreMods::Vbox.
+# Currently disabled
+module VMs
+  include Loom::Pattern
+
+  desc "Check if some virtualbox vms exist"
+  pattern :vm_exists? do |loom, facts|
+    vm0_exists = loom.local.vbox.check_exists "vm0.local"
+    puts "Virtualbox VM 'vm0.local' exists: #{vm0_exists}"
+  end
+
+  desc "Check if some virtualbox vms exist"
+  pattern :list do |loom, facts|
+    loom.local.vbox.list
+  end
+
+  desc "Takes a snapshot of a VM"
+  pattern :snap do |loom, facts|
+    loom.local.vbox.snapshot "vm0.local", snapshot_name: "test:snap"
+    loom.local.vbox.snapshot "vm0.local", action: :delete, snapshot_name: "test:snap"
+  end
+end

data/spec/loom/facts/fact_set_spec.rb

@@ -0,0 +1,57 @@
+require 'loom/facts'
+
+describe Loom::Facts::FactSet do
+
+  let(:fact_set) { Loom::Facts::FactSet.new hostspec, facts }
+  let(:hostspec) { Loom::HostSpec.new "dummy.host" }
+  let(:facts) {{
+      :fact_a => :a,
+      :fact_b => [:other, :facts]
+    }}
+
+  subject { fact_set }
+
+  let(:other_fact_set) { Loom::Facts::FactSet.new hostspec, other_facts }
+  let(:other_facts) {{
+      :fact_y => :y,
+      :fact_z => :z,
+    }}
+
+  context Loom::Facts::EMPTY do
+
+    subject { Loom::Facts::EMPTY }
+
+    it "should equal Facts.is_empty?" do
+      expect(Loom::Facts.is_empty? subject).to be true
+
+      # sanity
+      expect(Loom::Facts.is_empty?({})).to be false
+      expect(Loom::Facts.is_empty?(fact_set)).to be false
+    end
+  end
+
+  context :merge do
+    it "merges with other fact sets" do
+      new_facts = subject.merge other_fact_set
+      expect(new_facts[:fact_a]).to be :a
+      expect(new_facts[:fact_y]).to be :y
+    end
+
+    it "merges with other hashes" do
+      new_facts = subject.merge :other_stuff => :in_a_hash
+      expect(new_facts[:fact_a]).to be :a
+      expect(new_facts[:other_stuff]).to be :in_a_hash
+    end
+  end
+
+  context :[] do
+
+    it "returns EMPTY for no result" do
+      expect(fact_set[:invalid_key]).to be Loom::Facts::EMPTY
+    end
+
+    it "gets facts by name" do
+      expect(fact_set[:fact_a]).to be :a
+    end
+  end
+end

data/spec/loom/pattern/dsl_spec.rb

@@ -12,7 +12,7 @@ describe Loom::Pattern::DSL do
   end
 
   before do
-    # bit buckets the logs
+    # intercept logs
     @logger_io = StringIO.new
     Loom.configure do |config|
       config.log_device = @logger_io
@@ -28,7 +28,7 @@ describe Loom::Pattern::DSL do
   context "pattern basics" do
 
     let(:loom_file) do
-<<EOS
+<<RB_LOOM
   desc "a description of pattern_under_test"
   pattern :pattern_under_test do |loom, facts|
     loom.do_outer_thing
@@ -42,7 +42,7 @@ describe Loom::Pattern::DSL do
       loom.do_inner_thing
     end
   end
-EOS
+RB_LOOM
     end
 
     it "defines a Pattern::Reference" do
@@ -67,7 +67,7 @@ EOS
   context "#let" do
 
     let(:loom_file) do
-<<EOS
+<<RB_LOOM
   let(:let_var_1) { "let var 1"}
   let(:let_var_2) { "let var 2"}
 
@@ -92,7 +92,7 @@ EOS
       loom.do_inner_thing(let_var_1, let_var_2, let_var_3)
     end
   end
-EOS
+RB_LOOM
     end
 
     it "defines :let declartions at the top level" do
@@ -117,7 +117,7 @@ EOS
   context "#with_facts" do
 
     let(:loom_file) do
-<<EOS
+<<RB_LOOM
   with_facts :outer_fact => :outer
 
   desc "a description of pattern_under_test"
@@ -135,7 +135,7 @@ EOS
       loom.do_inner_thing(facts[:outer_fact], facts[:inner_fact])
     end
   end
-EOS
+RB_LOOM
     end
 
     it "defines fact sets at the top level" do
@@ -151,10 +151,59 @@ EOS
     end
   end
 
+  context "#report" do
+
+    let(:report_fact_set) { a_fact_set.merge :the_report_facts => [1,2,3] }
+    let(:loom_file) do
+<<RB_LOOM
+  let(:the_let_facts) { [:a, :b] }
+
+  report :the_report_facts
+  report :the_let_facts
+
+  report :the_other_facts do
+    { :some => :other, :stuff => :ok }
+  end
+
+  report :by_another_form, format: :json do
+    { :other => :data }
+  end
+RB_LOOM
+    end
+
+    let(:new_stdio) { StringIO.new }
+    before { $stdout = new_stdio }
+    after { $stdout = STDOUT }
+
+    it 'prints the called report by fact value' do
+      @reference_set['the_report_facts'].call fake_shell, report_fact_set
+      report_output = new_stdio.string
+      expect(report_output).to eql [1,2,3].to_yaml
+    end
+
+    it 'prints the called report by let value' do
+      @reference_set['the_let_facts'].call fake_shell, report_fact_set
+      report_output = new_stdio.string
+      expect(report_output).to eql [:a, :b].to_yaml
+    end
+
+    it 'prints the given report block' do
+      @reference_set['the_other_facts'].call fake_shell, report_fact_set
+      report_output = new_stdio.string
+      expect(report_output).to eql({:some => :other, :stuff => :ok}.to_yaml)
+    end
+
+    it 'prints data in different formats' do
+      @reference_set['by_another_form'].call fake_shell, report_fact_set
+      report_output = new_stdio.string
+      expect(report_output.strip).to eql('{"other":"data"}')
+    end
+  end
+
   context "hooks" do
 
     let(:loom_file) do
-<<EOS
+<<RB_LOOM
 
   let(:hook_order) { [] }
 
@@ -179,7 +228,7 @@ EOS
       loom.do_inner_thing(hook_order)
     end
   end
-EOS
+RB_LOOM
     end
 
     it "executes outer before hooks first and after hooks last" do

data/spec/loom/shell/harness_blob_spec.rb

@@ -1,4 +1,4 @@
-describe Loom::Shell::HarnessBlob do
+xdescribe Loom::Shell::HarnessBlob do
 
   HARNESS = "./scripts/harness.sh"
 

data/spec/loom/shell/harness_command_builder_spec.rb

@@ -1,4 +1,4 @@
-describe Loom::Shell::HarnessCommandBuilder do
+xdescribe Loom::Shell::HarnessCommandBuilder do
 
   let(:cmd) do
     <<CMD

data/spec/loomext/coremods/systemd_spec.rb

@@ -0,0 +1,31 @@
+describe LoomExt::CoreMods::Systemd do
+  include LoomSpec::LoomInternalsHelper
+
+  let(:fake_loom) { create_fake_shell_api }
+  let(:a_fact_set) { create_fact_set }
+  let(:pattern_list_units) { @reference_set['list_units'] }
+
+  before do
+    # intercept logs
+    @logger_io = capture_logs_to_io
+    @reference_set = create_reference_set loom_file
+  end
+
+  context "actions" do
+
+    let(:loom_file) do
+<<RB
+require "loomext/all"
+desc "lists systemd-units"
+pattern :list_units do |l,_|
+  l.systemd.is_loaded?(:my_service)
+end
+RB
+    end
+
+    it "should execute this" do
+      pattern_list_units.call fake_loom, a_fact_set
+      expect(fake_loom.cmd_execution_args.join(' '.strip)).to eql 'my_service'
+    end
+  end
+end

data/spec/runloom.sh

@@ -1,35 +1,28 @@
 #!/bin/sh
+pattern_file="${1}"
+if [ "${pattern_file}" = "" ]; then
+    echo "Usage: $0 <spec/path/to/.loom/file>"
+    exit 1
+fi
 
-spec_file="spec/test.loom"
+spec_file="spec/${pattern_file}"
 all_patterns=$(bin/loom patterns --print \
 			-t \
 			-l ${spec_file})
 
+shift
 addl_args="${@}"
 
+# TODO: Fix this to bring up a local container via
+# systemd-nspawn. Either an alpine host, or something else really
+# cheap and fast. NO DOCKER. Will rkt ever be a reasonable option?
 bin/loom weave ${all_patterns} \
 	 -t \
 	 -l ${spec_file} \
 	 -X log_level=info \
-	 -H vm0.local \
+	 -H rp0 \
+         -V \
 	 -X sshkit_log_level=warn \
 	 -X log_device=stderr \
 	 -X run_failure_strategy=cowboy \
 	 ${addl_args}
-rc=$?
-
-# expect exit code 104 (100 for patterns execution error + # expected failures):
-# exec:fail_soft
-# exec:fail_hard
-# exec:timeout_fail
-# net:check_net_fail
-
-if [ "${rc}" = "104" ]; then
-    # runall.sh exits succesfully on this failure because we expect
-    # the "fail" patterns to fail
-    echo "success with exit code ${rc}"
-    exit 0
-else
-    echo "failed with exit code ${rc}"
-    exit $rc
-fi

data/spec/scripts/harness_spec.rb

@@ -1,7 +1,7 @@
 require 'base64'
 require 'tmpdir'
 
-describe 'loom harness script' do
+xdescribe 'loom harness script' do
 
   HARNESS = "./scripts/harness.sh"
 

data/spec/shared/loom_internals_helper.rb

@@ -0,0 +1,41 @@
+require './lib/loom'
+require './lib/loomext/all'
+
+module LoomSpec
+  module LoomInternalsHelper
+    FAKE_FACTS = { :fact_one => 1, :fact_two => :two }
+
+    def create_fact_set(fake_host: 'fake.host', fake_facts: FAKE_FACTS)
+      Loom::Facts::FactSet.new fake_host, fake_facts
+    end
+
+    def create_fake_shell_api
+      Loom::Shell::FakeApi.new
+    end
+
+    def create_reference_set(loom_file_src=nil, path: 'loom/file/path')
+      loom_file_src ||= File.read(path)
+      Loom::Pattern::ReferenceSet::Builder.create(loom_file_src, path)
+    end
+
+    def capture_logs_to_io
+      logger_io = StringIO.new
+      Loom.configure do |config|
+        config.log_device = logger_io
+      end
+      logger_io
+    end
+
+    def create_dry_run_shell
+    end
+
+    def create_config(**config_map)
+      Loom::Config.new config_map
+    end
+
+    def create_mod_loader(config: nil)
+      config ||= create_config
+      Loom::Mod::ModLoader.new config
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -1,6 +1,10 @@
-Dir.glob('./spec/shared/**/*.rb').each { |f| require f }
 require './lib/loom'
 
+Dir.glob('./spec/shared/**/*.rb').each do |f|
+  $stderr.puts "requiring spec helper: #{f}"
+  require f
+end
+
 # This file was generated by the `rspec --init` command. Conventionally, all
 # specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
 # The generated `.rspec` file contains `--require spec_helper` which will cause

data/spec/systemd.loom

@@ -0,0 +1,22 @@
+module Systemd
+  include Loom::Pattern
+
+  report :sshd_status, format: :json do |l, _|
+    l.systemd_units("sshd.service").status
+  end
+
+  report :units, format: :raw do |l, _|
+    l.systemd_units.list
+  end
+
+  report :sockets, format: :raw do |l, _|
+    l.systemd_sockets.list
+  end
+
+  report :timers, format: :raw do |l, _|
+    l.systemd_timers.list
+  end
+end
+
+
+

data/spec/test_loom_spec.rb

@@ -1,5 +1,85 @@
 require 'open3'
 
+describe "spec .loom files" do
+  include LoomSpec::LoomInternalsHelper
+
+  LOOM_FILES = Dir.glob "spec/.loom/**/*.loom"
+
+  # Tests disabled until this runs on an overlayfs container
+  XFILE_SET = {
+    "error_handling.loom" => true,
+    "files.loom" => true,
+    "pkg.loom" => true,
+    "user.loom" => true,
+    "vms.loom" => true,
+  }
+
+  EXPECTED_EXIT_CODE = {
+    "fail.loom" => 103
+  }
+
+  SPEC_TAGS = {
+    :integration => true,
+    :long => true
+  }
+
+  let(:host) { "rp0" }
+  let(:patterns) { ref_set.slugs }
+  let(:command) {[
+      "bin/loom weave #{patterns.join " "}",
+      "-t",
+      "-l #{loom_file}",
+      "-X log_level=info",
+      "-H #{host}",
+      "-V",
+      "-X sshkit_log_level=warn",
+      "-X log_device=stderr",
+      "-X run_failure_strategy=cowboy",
+    ]}
+
+  # bundle exec rspec --tag smoke
+  context "test.loom" do
+    let(:loom_file) { LOOM_FILES.select { |p| p.match?(/test.loom/) }.first }
+    let(:ref_set) { create_reference_set(path: loom_file) }
+    let(:patterns) { ref_set.slugs.select { |s| s.match?(/^smoke:/) } }
+    let(:host) { "localhost" }
+
+    it "should pass a few tests quickly", :smoke => true do
+      exec = command.join(' ')
+      output = `#{exec}`
+      expect($?.exitstatus).to eq 0
+    end
+  end
+
+  # bundle exec rspec --tag integration
+  LOOM_FILES.each do |loom_file|
+    context File.basename loom_file do
+      let(:loom_file) { loom_file }
+      let(:ref_set) { create_reference_set(path: loom_file) }
+
+      if XFILE_SET[File.basename(loom_file)]
+        xit "should pass all the tests",
+        SPEC_TAGS.merge(:file => File.basename(loom_file)) {}
+      else
+        it "should pass all tests",
+        SPEC_TAGS.merge(:file => File.basename(loom_file)) do
+          exec = command.join(' ')
+          puts exec
+          # TODO pattern match the commands on STDOUT (see comment in
+          # .loom/test.loom)
+          output = `#{exec}`
+
+          basename = File.basename(loom_file)
+          expected_exit_code = EXPECTED_EXIT_CODE[basename] || 0
+          expect($?.exitstatus).to eq expected_exit_code
+        end
+      end
+    end
+  end
+end
+
+# Archived 10/26/2018
+
 # TODO: fix this test to run the runloom.sh script. Currently running
 # the loom script in a child process from ruby runs without a
 # TTY. This causes the sshkit/net:ssh connection to connect abnormally
@@ -33,25 +113,23 @@ require 'open3'
 #       /home/erick/.gem/ruby/gems/sshkit-1.11.3/lib/sshkit/backends/abstract.rb:141:in `tap'
 #       /home/erick/.gem/ruby/gems/sshkit-1.11.3/lib/sshkit/backends/abstract.rb:141:in `create_command_and_execute'
 #       /home/erick/workspace/src/loom/lib/loom/shell.rb:91:in `execute'
+#   xit "executes successfully" do
 
-describe "spec/test.loom file" do
+#     exit_status = nil
 
-  let(:runloom) { File.join File.dirname(__FILE__), 'runloom.sh' }
+#     # https://stackoverflow.com/questions/6338908/ruby-difference-between-exec-system-and-x-or-backticks
+#     output = `#{runloom} -F fact_1=1,fact_2=2,fact_3=3`
 
-  it "executes successfully" do
-    exit_status = nil
-    `#{runloom}`
-#    Open3.popen3(runloom) do |stdin,stdout,stderr,wait_thred|
-#      puts "running #{runloom}"
-#      while line=stderr.gets do
-#        puts line
-#      end
-#
-#      exit_status = wait_thred.value
-#    end
+# #    Open3.popen3(runloom) do |stdin,stdout,stderr,wait_thred|
+# #      puts "running #{runloom}"
+# #      while line=stderr.gets do
+# #        puts line
+# #      end
+# #
+# #      exit_status = wait_thred.value
+# #    end
 
-    puts "exit status: #{$?.exitstatus}"
+#     puts "exit status: #{$?.exitstatus}"
 
-    expect($?.exitstatus).to eq 0
-  end
-end
+#     expect($?.exitstatus).to eq 0
+#   end