teuton 2.8.0 → 2.9.1

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/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

data/lib/teuton/readme/main.rb

@@ -0,0 +1,27 @@
+require_relative "../utils/project"
+require_relative "readme"
+
+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 define_macro(name, *args, &block)
+  Project.value[:macros][name] = {args: args, block: block}
+end
+
+def group(name, &block)
+  Project.value[:groups] << {name: name, block: block}
+end
+alias task group
+
+def start(&block)
+  # don't do nothing
+end
+# alias_method "play", "start" # REVISE THIS
+alias play start

data/lib/teuton/readme/readme.rb

@@ -1,44 +1,19 @@
+require_relative "../utils/logger"
 require_relative "../utils/project"
 require_relative "../utils/configfile_reader"
-require_relative "../utils/result/result"
+require_relative "../case/dsl/macro"
 require_relative "../version"
-require_relative "dsl"
+require_relative "dsl/all"
 require_relative "lang"
-
-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 define_macro(name, *args, &block)
-  puts "macro: #{name}"
-  Project.value[:macros][name] = {args: args, block: block}
-end
-
-def group(name, &block)
-  Project.value[:groups] << {name: name, block: block}
-end
-alias task group
-
-def start(&block)
-  # don't do nothing
-end
-# alias_method "play", "start" # REVISE THIS
-alias play start
+require_relative "result"
 
 class Readme
-  # Creates README.md file from RB script file
+  include DSL
+  include ReadmeDSL
   attr_reader :result
   attr_reader :data
 
   def initialize(script_path, config_path)
-    # script_path Path to main rb file (start.rb)
-    # config_path Path to main config file (config.yaml)
     @path = {}
     @path[:script] = script_path
     @path[:dirname] = File.dirname(script_path)
@@ -57,13 +32,11 @@ class Readme
   private
 
   def reset
-    # app = Application.instance
     @config = ConfigFileReader.read(Project.value[:config_path])
     @verbose = Project.value[:verbose]
-    @result = Result.new
+    @result = ReadmeResult.new
     @data = {}
     @data[:macros] = []
-    @data[:logs] = []
     @data[:groups] = []
     @data[:play] = []
     reset_action
@@ -74,11 +47,11 @@ class Readme
   end
 
   def process_content
-    Project.value[:groups].each do |g|
-      @current = {name: g[:name], readme: [], actions: []}
+    Project.value[:groups].each do |group|
+      @current = {name: group[:name], readme: [], actions: []}
       @data[:groups] << @current
       reset_action
-      instance_eval(&g[:block])
+      instance_eval(&group[:block])
     end
   end
 
@@ -88,12 +61,11 @@ class Readme
 
   def show_head
     puts "```"
-    puts format(Lang.get(:testname), Project.value[:test_name])
     puts format(Lang.get(:date), Time.now)
     puts format(Lang.get(:version), Teuton::VERSION)
     puts "```"
     puts "\n"
-    puts "# #{Project.value[:test_name]}\n"
+    puts "# Test: #{Project.value[:test_name]}\n"
 
     i = 1
     unless @required_hosts.empty?
@@ -114,7 +86,6 @@ class Readme
       @cases_params.sort!
       puts Lang.get(:params)
       @cases_params.uniq.each { |i| puts format("* %s", i) }
-      puts "\n> NOTE: Save every 'param: value' into config file."
     end
   end
 
@@ -122,7 +93,7 @@ class Readme
     @data[:groups].each do |group|
       next if group[:actions].empty?
 
-      puts "\n## #{group[:name].capitalize}\n\n"
+      puts "\n## #{group[:name].capitalize}\n"
       group[:readme].each { |line| puts "#{line}\n" }
       previous_host = nil
       group[:actions].each_with_index do |item, index|
@@ -133,10 +104,8 @@ class Readme
           previous_host = item[:host] || "null"
           puts format(Lang.get(:goto), previous_host.upcase)
         end
-
-        weight = ""
-        weight = "(x#{item[:weight]}) " if item[:weight].to_i != 1
-        last = (item[:target].end_with?(".") ? "" : ".")
+        weight = "(x#{item[:weight]}) "
+        last = item[:target].end_with?(".", ":") ? "" : "."
         puts "* #{weight}#{item[:target]}#{last}"
         item[:readme].each { |line| puts "    * #{line}\n" }
       end
@@ -144,21 +113,25 @@ class Readme
   end
 
   def show_tail
-    return if @global_params.empty?
+    return if (@global_params.size + @setted_params.size).zero?
 
     puts "\n---"
     puts "# ANEXO"
-    puts "\n## Global params"
-    puts Lang.get(:global)
-    puts "\n"
-    puts "| Global param | Value |"
-    puts "| --- | --- |"
-    @global_params.each_pair { |k, v| puts "|#{k}|#{v}|" }
-    puts "\n## Created params"
-    puts Lang.get(:created)
-    puts "\n"
-    puts "| Created params | Value |"
-    puts "| --- | --- |"
-    @setted_params.each_pair { |k, v| puts "|#{k}|#{v}|" }
+    puts "\n## Params"
+
+    if @global_params.size.positive?
+      puts Lang.get(:global_params)
+      puts "\n"
+      puts "| Param | Value |"
+      puts "| --- | --- |"
+      @global_params.each_pair { |k, v| puts "|#{k}|#{v}|" }
+    end
+    if @setted_params.size.positive?
+      puts Lang.get(:created_params)
+      puts "\n"
+      puts "| Param | Value |"
+      puts "| --- | --- |"
+      @setted_params.each_pair { |k, v| puts "|#{k}|#{v}|" }
+    end
   end
 end

data/lib/teuton/readme/result.rb

@@ -0,0 +1,7 @@
+require_relative "../case/result/result"
+
+class ReadmeResult < Result
+  def debug
+    # Nothing to do
+  end
+end

data/lib/teuton/utils/configfile_reader.rb

@@ -30,11 +30,15 @@ module ConfigFileReader
   def self.read_yaml(filepath)
     begin
       data = YAML.load(File.open(filepath))
+      # data = YAML.safe_load(
+      #   File.open(filepath),
+      #   permitted_classes: [Array, Date, Hash, Symbol]
+      # )
     rescue => e
-      $stderr.puts "\n" + ("=" * 80)
-      $stderr.puts "[ERROR] ConfigFileReader#read <#{filepath}>"
-      $stderr.puts "        I suggest to revise file format!"
-      $stderr.puts "        #{e.message}\n" + ("=" * 80)
+      warn "\n" + ("=" * 80)
+      warn "[ERROR] ConfigFileReader#read <#{filepath}>"
+      warn "        I suggest to revise file format!"
+      warn "        #{e.message}\n" + ("=" * 80)
       exit 1
     end
     data = convert_string_keys_to_symbol(data)
@@ -72,13 +76,24 @@ module ConfigFileReader
     else
       File.join(File.dirname(filepath), data[:global][:tt_include])
     end
-    files = Dir.glob(File.join(basedir, "**/*.yaml"))
-    files += Dir.glob(File.join(basedir, "**/*.yml"))
-    files += Dir.glob(File.join(basedir, "**/*.YAML"))
-    files += Dir.glob(File.join(basedir, "**/*.YML"))
-    files.each { |file|
+    exts = {
+      yaml: ['.yaml', '.YAML', '.yml', '.YML'],
+      json: ['.json', '.JSON']
+      }
+    files = Dir.glob(File.join(basedir, "**/*"))
+    files.each { |filename|
       begin
-        data[:cases] << YAML.load(File.open(file))
+        ext = File.extname(filename)
+        if exts[:yaml].include? ext
+          data[:cases] << YAML.load(File.open(filename))
+        elsif exts[:json].include? ext
+          data[:cases] = JSON.parse(File.read(filename), symbolize_names: true)
+        elsif File.file? filename
+          msg = "[ERROR] Loading configuration files: " \
+              " No yaml/json valid extension " \
+              " (#{file})"
+          warn msg
+        end
       rescue => e
         puts "\n" + ("=" * 80)
         puts "[ERROR] ConfigFileReader#read <#{file}>"