teuton 2.7.3 → 2.9.0

data/lib/teuton/check/{builtin.rb → dsl/builtin.rb}

@@ -16,9 +16,7 @@ class Builtin
   end
 end
 
-# Laboratory
-# * service
-class Laboratory
+module CheckDSL
   def service(param)
     log "BUILTIN service(#{param})"
     @builtin ||= Builtin.new(self)

data/lib/teuton/check/dsl/expect.rb

@@ -0,0 +1,90 @@
+require_relative "expect_sequence"
+
+module CheckDSL
+  def expect(cond)
+    unless @target_begin
+      Logger.warn "WARN  'expect' with no previous 'target'"
+    end
+    Logger.info "      alter       #{result.alterations}" unless result.alterations.empty?
+    Logger.info "      expect      #{cond} (#{cond.class})"
+    Logger.info ""
+    @target_begin = false
+  end
+
+  def expect_exit(cond)
+    unless @target_begin
+      Logger.warn "WARN  'expect' with no previous 'target'"
+    end
+    Logger.info "      expect_exit #{cond} (#{cond.class})"
+    Logger.info ""
+    @target_begin = false
+  end
+
+  def expect_fail
+    unless @target_begin
+      Logger.warn "WARN  'expect' with no previous 'target'"
+    end
+    Logger.info "      expect_fail"
+    Logger.info ""
+    @target_begin = false
+  end
+
+  def expect_first(cond)
+    unless @target_begin
+      Logger.warn "WARN  'expect' with no previous 'target'"
+    end
+    Logger.info "      alter        #{result.alterations}" unless result.alterations.empty?
+    Logger.info "      expect_first #{cond} (#{cond.class})"
+    Logger.info ""
+    @target_begin = false
+  end
+
+  def expect_last(cond)
+    unless @target_begin
+      Logger.warn "WARN  'expect' with no previous 'target'"
+    end
+    Logger.info "      alter        #{result.alterations}" unless result.alterations.empty?
+    Logger.info "      expect_last #{cond} (#{cond.class})"
+    Logger.info ""
+    @target_begin = false
+  end
+
+  def expect_none(cond = nil, args = {})
+    unless @target_begin
+      Logger.warn "WARN  'expect' with no previous 'target'"
+    end
+    Logger.info "      alter       #{result.alterations}" unless result.alterations.empty?
+    Logger.info "      expect_none #{cond} (#{cond.class})"
+    Logger.info ""
+    @target_begin = false
+  end
+
+  def expect_nothing
+    expect_none nil, {}
+  end
+
+  def expect_ok
+    expect_exit 0
+  end
+
+  def expect_one(cond)
+    unless @target_begin
+      Logger.warn "WARN  'expect' with no previous 'target'"
+    end
+    Logger.info "      alter       #{result.alterations}" unless result.alterations.empty?
+    Logger.info "      expect_one  #{cond} (#{cond.class})"
+    Logger.info ""
+    @target_begin = false
+  end
+
+  def expect_sequence(&block)
+    unless @target_begin
+      Logger.warn "WARN  'expect' with no previous 'target'"
+    end
+    seq = CheckDSL::ExpectSequence.new
+    seq.is_valid?(&block)
+    Logger.info "      expect_sequence #{seq.expected}"
+    Logger.info ""
+    @target_begin = false
+  end
+end

data/lib/teuton/check/dsl/expect_sequence.rb

@@ -0,0 +1,29 @@
+module CheckDSL
+  class ExpectSequence
+    def initialize
+      @expected = []
+    end
+
+    def is_valid?(&block)
+      instance_eval(&block)
+    end
+
+    def expected
+      @expected.join(">")
+    end
+
+    private
+
+    def find(value)
+      @expected << "find(#{value})"
+    end
+
+    def next_to(value)
+      @expected << "next_to(#{value})"
+    end
+
+    def ignore(value)
+      @expected << "ignore(#{value})"
+    end
+  end
+end

data/lib/teuton/check/dsl/getset.rb

@@ -0,0 +1,23 @@
+module CheckDSL
+  def get(varname)
+    data = @stats[:gets]
+    data[varname] = data[varname] ? (data[varname] + 1) : 1
+    "get(#{varname})"
+  end
+
+  def gett(option)
+    get(option)
+  end
+
+  def set(key, value)
+    key = ":" + key.to_s if key.instance_of? Symbol
+    value = ":" + value.to_s if value.instance_of? Symbol
+
+    @stats[:sets] << "#{key}=#{value}"
+    Logger.info "      set(#{key},#{value})"
+  end
+
+  def unset(key)
+    Logger.info "      unset(#{key})"
+  end
+end

data/lib/teuton/check/dsl/run.rb

@@ -0,0 +1,35 @@
+module CheckDSL
+  def run(command, args = {})
+    args[:exec] = command
+    host = :localhost
+    host = args[:on] if args[:on]
+    goto(host, args)
+  end
+
+  def run_script(command, args = {})
+    host = :localhost
+    host = args[:on] if args[:on]
+    filename = command.split[1]
+    upload filename, to: host
+    run command, args
+  end
+
+  def goto(host = :localhost, args = {})
+    result.reset
+    @stats[:hosts][host] = @stats[:hosts][host] ? (@stats[:hosts][host] + 1) : 1
+    Logger.info "      run         '#{args[:exec]}' on #{host}"
+  end
+
+  def upload(filename, args = {})
+    host = args[:to]
+    args.delete(:to)
+    custom = if args == {}
+      ""
+    else
+      values = args.map { "#{_1}=#{_2}" }
+      "and #{values.join(",")}"
+    end
+    @stats[:uploads] << filename
+    Logger.info "      upload      '#{filename}' to #{host} #{custom}"
+  end
+end

data/lib/teuton/check/main.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require_relative "../utils/project"
+
+def use(filename)
+  filename += ".rb"
+  rbfiles = File.join(Project.value[:project_path], "**", filename)
+  files = Dir.glob(rbfiles)
+  use = []
+  files.sort.each { |f| use << f if f.include?(filename) }
+  require_relative use[0]
+  Project.value[:uses] << use[0]
+end
+
+def group(name, &block)
+  Project.value[:groups] << {name: name, block: block}
+end
+alias task group
+
+def define_macro(name, *args, &block)
+  Project.value[:macros][name] = {args: args, block: block}
+end
+alias def_macro define_macro
+alias defmacro define_macro
+
+def start(&block)
+  # Don't do nothing. We are checking test not running it
+end
+alias play start

data/lib/teuton/check/show.rb

@@ -1,91 +1,29 @@
 require "terminal-table"
 require "rainbow"
 
+require_relative "../utils/logger"
 require_relative "../utils/project"
 require_relative "../utils/configfile_reader"
 
-class Laboratory
-  def show
-    @verbose = true
-    process_content
-    show_stats
-    revise_config_content
+class ShowCheck
+  def initialize(stats:, path:)
+    @stats = stats
+    @path = path
   end
 
-  def show_onlyconfig
-    @verbose = false
-    process_content
-    @verbose = true
-    recomended_panelconfig_content
-  end
-
-  private
-
-  def verbose(text)
-    print text if @verbose
-  end
-
-  def verboseln(text)
-    puts text if @verbose
-  end
-
-  def process_content
-    groups = Project.value[:groups]
-    option = Project.value[:options]
-    @stats[:uses] = Project.value[:uses].size
-    verboseln ""
-    groups.each do |t|
-      @stats[:groups] += 1
-      unless option[:panel]
-        msg = "GROUP: #{t[:name]}"
-        my_screen_table = Terminal::Table.new { |st| st.add_row [msg] }
-        verboseln my_screen_table
-      end
-      instance_eval(&t[:block])
-    end
-  end
-
-  def find_script_vars
-    script_vars = [:tt_members]
-    @hosts.each_key do |k|
-      next if k == :localhost
-
-      if k.instance_of? Symbol
-        script_vars << (k.to_s + "_ip").to_sym
-        script_vars << (k.to_s + "_username").to_sym
-        script_vars << (k.to_s + "_password").to_sym
-      else
-        script_vars << k.to_s + "_ip"
-        script_vars << k.to_s + "_username"
-        script_vars << k.to_s + "_password"
-      end
-    end
-    @gets.each_key { |k| script_vars << k }
-    script_vars
-  end
-
-  def recomended_config_content
-    warn Rainbow("[WARN] Configfile not found").bright.yellow
-    warn Rainbow("       #{@path[:config]}").white
-    warn Rainbow("[INFO] Recomended content:").bright.yellow
-    output = {global: nil, cases: []}
-    output[:cases][0] = {}
-    script_vars = find_script_vars
-    script_vars.each { |i| output[:cases][0][i] = "VALUE" }
-    verboseln Rainbow(YAML.dump(output)).white
-  end
-
-  def recomended_panelconfig_content
-    output = {global: nil, cases: [{}]}
+  def suggest_config_content
+    output = {"global" => nil, "cases" => [{}]}
     script_vars = find_script_vars
-    # script_vars.each { |i| output[:global][i] = "VALUE" }
-    script_vars.each { |i| output[:cases][0][i] = "VALUE" }
-    verboseln YAML.dump(output)
+    script_vars.each { |i| output["cases"][0][i.to_s] = "VALUE" }
+    Logger.info YAML.dump(output)
   end
 
   def revise_config_content
     unless File.exist?(@path[:config])
-      recomended_config_content
+      Logger.warn "[WARN] Configfile not found"
+      Logger.debug "       #{@path[:config]}"
+      Logger.warn "[INFO] Recomended content:"
+      suggest_config_content
       return
     end
 
@@ -100,46 +38,83 @@ class Laboratory
       script_vars.each do |value|
         next unless item[value].nil?
 
-        next unless @sets[":" + value.to_s].nil?
+        setted = false
+        @stats[:sets].each do |assign|
+          setted = true if assign.include?(":#{value}=")
+        end
 
-        verbose Rainbow("  * Define ").red
-        verbose Rainbow(value).red.bright
-        verbose Rainbow(" value for Case[").red
-        verbose Rainbow(index).red.bright
-        verboseln Rainbow("] or set tt_skip = true").red
+        unless setted
+          text = "  * Define '#{value}' value for Case[#{index}] or set tt_skip = true"
+          Logger.error text
+        end
       end
     end
   end
 
-  ##
-  # Display stats on screen
   def show_stats
-    @stats[:hosts] = 0
-    @hosts.each_pair { |_k, v| @stats[:hosts] += v }
-
     my_screen_table = Terminal::Table.new do |st|
       st.add_row ["DSL Stats", "Count"]
       st.add_separator
-      st.add_row ["Uses", @stats[:uses]]
+
+      if Project.value[:uses].size.positive?
+        st.add_row ["Uses", Project.value[:uses].size]
+      end
+      if Project.value[:macros].size.positive?
+        st.add_row ["Macros", Project.value[:macros].size]
+        Project.value[:macros].each_key { st.add_row ["", _1] }
+      end
       st.add_row ["Groups", @stats[:groups]]
       st.add_row ["Targets", @stats[:targets]]
-      st.add_row ["Runs", @stats[:hosts]]
-      @hosts.each_pair { |k, v| st.add_row [" * #{k}", v] }
-      st.add_row ["Uniques", @stats[:uniques]]
-      st.add_row ["Logs", @stats[:uniques]]
-      st.add_row [" ", " "]
-
-      st.add_row ["Gets", @stats[:gets]]
-      if @gets.count > 0
-        list = @gets.sort_by { |_k, v| v }
+      runs = @stats[:hosts].values.inject(0) { |acc, item| acc + item }
+      st.add_row ["Runs", runs]
+      @stats[:hosts].each_pair { |k, v| st.add_row [" * #{k}", v] }
+      if @stats[:uniques].positive?
+        st.add_row ["Uniques", @stats[:uniques]]
+      end
+      if @stats[:logs].positive?
+        st.add_row ["Logs", @stats[:logs]]
+      end
+      if @stats[:readmes].positive?
+        st.add_row ["Readmes", @stats[:readmes]]
+      end
+
+      if @stats[:gets].size.positive?
+        total = @stats[:gets].values.inject(0) { |acc, value| acc + value }
+        st.add_row ["Gets", total]
+        list = @stats[:gets].sort_by { |_k, v| v }
         list.reverse_each { |item| st.add_row [" * #{item[0]}", item[1].to_s] }
       end
 
-      st.add_row ["Sets", @stats[:sets]]
-      if @sets.count > 0
-        @sets.each_pair { |k, v| st.add_row [" * #{k}", v.to_s] }
+      if @stats[:sets].size.positive?
+        st.add_row ["Sets", @stats[:sets].size]
+        @stats[:sets].each { st.add_row ["", _1] }
+      end
+      if @stats[:uploads].size.positive?
+        st.add_row ["Uploads", @stats[:uploads].size]
+        @stats[:uploads].each { st.add_row ["", _1] }
+      end
+    end
+    Logger.info my_screen_table.to_s + "\n"
+  end
+
+  private
+
+  def find_script_vars
+    script_vars = [:tt_members]
+    @stats[:hosts].each_key do |k|
+      next if k == :localhost
+
+      if k.instance_of? Symbol
+        script_vars << (k.to_s + "_ip").to_sym
+        script_vars << (k.to_s + "_username").to_sym
+        script_vars << (k.to_s + "_password").to_sym
+      else
+        script_vars << k.to_s + "_ip"
+        script_vars << k.to_s + "_username"
+        script_vars << k.to_s + "_password"
       end
     end
-    verboseln my_screen_table.to_s + "\n"
+    @stats[:gets].keys.each { script_vars << _1 }
+    script_vars
   end
 end

data/lib/teuton/{utils → deprecated}/application.rb

@@ -11,10 +11,7 @@ class Application
   attr_accessor :verbose
   attr_accessor :global # Global configuration params
   attr_accessor :ialias # Internal alias
-  attr_accessor :macros # Array of macros
-  attr_accessor :groups # Array of groups
   attr_accessor :uses # Array of uses
-  attr_accessor :hall_of_fame
   attr_accessor :project_path, :script_path, :config_path, :test_name
 
   def initialize
@@ -42,10 +39,7 @@ class Application
 
     @global = {}
     @ialias = {}
-    @macros = {}
-    @groups = []
     @uses = [] # TODO
-    @hall_of_fame = []
   end
 
   def debug

data/lib/teuton/deprecated/application_test.rb

@@ -0,0 +1,32 @@
+require "test/unit"
+require_relative "../../lib/teuton/utils/application"
+
+class ApplicationTest < Test::Unit::TestCase
+  def setup
+    @app = Application.instance
+    @app.reset
+  end
+
+  def test_init_params
+    assert_equal ".", @app.letter[:good]
+    assert_equal "F", @app.letter[:bad]
+    assert_equal "?", @app.letter[:error]
+    assert_equal " ", @app.letter[:none]
+    assert_equal "var", @app.output_basedir
+    assert_equal false, @app.debug
+    assert_equal true, @app.verbose
+
+    assert_equal true, @app.global == {}
+  end
+
+  def test_quiet?
+    @app.verbose = false
+    assert_equal false, @app.verbose
+    assert_equal true, Application.instance.quiet?
+    @app.verbose = true
+    assert_equal true, @app.verbose
+    assert_equal false, Application.instance.quiet?
+    @app.options["quiet"] = true
+    assert_equal true, Application.instance.quiet?
+  end
+end

data/lib/teuton/readme/dsl/all.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require_relative "expect"
+require_relative "getset"
+require_relative "run"
+
+module ReadmeDSL
+  def readme(text)
+    if @action[:target].nil?
+      @current[:readme] << text # It's a group readme
+    else
+      @action[:readme] << text # It's a target readme
+    end
+  end
+
+  def target(desc, args = {})
+    previous_host = @action[:host]
+    @action = {target: desc, host: previous_host, readme: []}
+    weight = 1.0
+    weight = args[:weight].to_f if args[:weight]
+    @action[:weight] = weight
+  end
+  alias_method :goal, :target
+
+  def unique(_key, _value)
+    # Nothing to do
+  end
+
+  def log(text = "", type = :info)
+    # Nothing to do
+  end
+end

data/lib/teuton/readme/dsl/expect.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module ReadmeDSL
+  def expect(_cond, _args = {})
+    @current[:actions] << @action
+    result.reset
+  end
+  alias_method :expect_any, :expect
+  alias_method :expect_exit, :expect
+  alias_method :expect_first, :expect
+  alias_method :expect_last, :expect
+  alias_method :expect_one, :expect
+
+  def expect_fail
+    @current[:actions] << @action
+    result.reset
+  end
+  alias_method :expect_ok, :expect_fail
+
+  def expect_none(cond = nil)
+    expect(cond)
+  end
+  alias_method :expect_nothing, :expect_none
+
+  def expect_sequence(&block)
+    @current[:actions] << @action
+    result.reset
+  end
+end

data/lib/teuton/readme/dsl/getset.rb

@@ -0,0 +1,33 @@
+module ReadmeDSL
+  def get(value)
+    unless @config[:global][value].nil?
+      @global_params[value] = @config[:global][value]
+      return @config[:global][value]
+    end
+
+    return value.to_s.upcase if @setted_params.include? value
+
+    @cases_params << value
+    value.to_s.upcase
+  end
+
+  def gett(value)
+    a = get(value)
+    if @cases_params.include? value
+      "[#{value}](#required-params)"
+    elsif @setted_params[value]
+      "[#{value}](#created-params)"
+    elsif @global_params.include? value
+      "[#{a}](#global-params)"
+    end
+    a
+  end
+
+  def set(key, value)
+    @setted_params[key] = value
+  end
+
+  def unset(_key)
+    # Nothing to do
+  end
+end

data/lib/teuton/readme/dsl/run.rb

@@ -0,0 +1,51 @@
+module ReadmeDSL
+  def goto(host = :localhost, args = {})
+    unless host == :localhost
+      b = {}
+      a = "#{host}_ip".to_sym
+      if @config[:global][a].nil? && !@setted_params.include?(a)
+        @cases_params << a
+      end
+      b[:ip] = @config[:global][a] if @config[:global][a]
+      b[:ip] = @setted_params[a] if @setted_params[a]
+
+      a = "#{host}_username".to_sym
+      if @config[:global][a].nil? && !@setted_params.include?(a)
+        @cases_params << a
+      end
+      b[:username] = @config[:global][a] if @config[:global][a]
+      b[:username] = @setted_params[a] if @setted_params[a]
+
+      a = "#{host}_password".to_sym
+      if @config[:global][a].nil? && !@setted_params.include?(a)
+        @cases_params << a
+      end
+      b[:password] = @config[:global][a] if @config[:global][a]
+      b[:password] = @setted_params[a] if @setted_params[a]
+
+      @required_hosts[host.to_s] = b
+    end
+    @action[:host] = host
+    @action[:exec] = args[:exec] || "noexec"
+  end
+
+  def run(command, args = {})
+    args[:exec] = command
+    host = :localhost
+    host = args[:on] if args[:on]
+    goto(host, args)
+  end
+
+  def run_script(command, args = {})
+    host = :localhost
+    host = args[:on] if args[:on]
+    filename = command.split[1]
+    upload filename, on: host
+    run command, args = {}
+    goto(host, args)
+  end
+
+  def upload(filename, args = {})
+    # Nothing to do
+  end
+end

data/lib/teuton/readme/lang.rb

@@ -4,24 +4,22 @@ module Lang
   def self.get(key)
     lang = {}
     lang["en"] = {
-      version: "Teuton version : %s",
-      testname: "Test unit name : %s",
-      date: "Date           : %s",
+      version: "Teuton : %s",
+      date: "Date   : %s",
       hosts: "\n### Required hosts\n",
       params: "\n### Required params\n",
       goto: "\nGo to [%s](#required-hosts) host, and do next:\n",
-      global: "\nGlobal parameters that can be modified:\n",
-      created: "\nParams created during challenge execution:\n"
+      global_params: "\nGlobal parameters:\n",
+      created_params: "\nCreated during execution:\n"
     }
     lang["es"] = {
-      version: "Versión de Teuton : %s",
-      testname: "Nombre del test   : %s",
-      date: "Fecha             : %s",
+      version: "Teuton : %s",
+      date: "Fecha  : %s",
       hosts: "\n### Máquinas que se necesitan\n",
       params: "\n### Parámetros de necesarios\n",
       goto: "\nIr a la máquina [%s](#required-hosts), y hacer lo siguiente:\n",
-      global: "\nParámetros globales que pueden ser modificados:\n",
-      created: "\nParámetros creados durante la ejecución del reto:\n"
+      global_params: "\nParámetros globales que pueden ser modificados:\n",
+      created_params: "\nParámetros creados durante la ejecución del reto:\n"
     }
     # locale = Application.instance.options["lang"].downcase
     locale = Project.value[:options]["lang"].downcase