teuton 2.5.0 → 2.7.0

data/lib/teuton/{case_manager/case → case}/dsl/goto.rb

@@ -1,13 +1,11 @@
 # frozen_string_literal: true
 
-require_relative "../runner"
+require_relative "../execute/execute_manager"
 
-# Case class -> DSL module:
-# * goto
-# * run
 module DSL
   ##
-  # DLS run: It's the same as goto :localhost
+  # DSL run and goto
+  # run: It's the same as goto :localhost
   # @param command (String)
   # @param args (Hash)
   def run(command, args = {})
@@ -17,7 +15,7 @@ module DSL
     goto(host, args)
   end
 
-  # Run command from the host identify as pHostname
+  # Run command from the host identify as "host"
   # goto :host1, :execute => "command"
   def goto(host = :localhost, args = {})
     @result.reset
@@ -27,9 +25,12 @@ module DSL
     tempfile(args[:tempfile]) if args[:tempfile]
     @action[:encoding] = args[:encoding] || "UTF-8"
 
-    start_time = Time.now
-    run_cmd_on(host)
-    @action[:duration] = (Time.now - start_time).round(3)
+    ExecuteManager.new(self).call(host)
+    @action[:output] = if @result.content.size < 2
+      @result.value.clone
+    else
+      "(#{@result.content.size} lines)"
+    end
   end
   alias_method :on, :goto
 end

data/lib/teuton/{case_manager/case → case}/dsl/log.rb

@@ -1,6 +1,5 @@
 require "rainbow"
-##
-# Define DSL#log function
+
 module DSL
   ##
   # Record log message

data/lib/teuton/{case_manager/case → case}/dsl/macro.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require_relative "../../../application"
+require_relative "../../utils/project"
 
 # DSL module methods: assert, missing_method
 module DSL
@@ -9,7 +9,7 @@ module DSL
   # @param name (String) Macro name
   # @param input (Hash) Macro params
   def macro(name, input = {})
-    macros = Application.instance.macros
+    macros = Project.value[:macros]
     unless macros[name]
       log("Macro #{name} not found!", :error)
       return

data/lib/teuton/{case_manager/case → case}/dsl/send.rb

@@ -1,12 +1,7 @@
 # frozen_string_literal: true
 
-# Case->DSL#
-# * send
-# * tempfile
-# * tempdir
-# * remote_tempdir
-# * remote_tempfile
 module DSL
+  # * send, tempfile, tempdir, remote_tempdir, remote_tempfile
   def send(args = {})
     return if skip?
 
@@ -52,7 +47,7 @@ module DSL
     name = "teuton.tmp" if input == :default
 
     @action[:tempfile] = File.join(@tmpdir, name)
-    @action[:remote_tempfile] = File.join(@remote_tmpdir, name)
+    @action[:remote_tempfile] = File.join(remote_tempdir, name)
 
     @action[:tempfile]
   end
@@ -66,6 +61,6 @@ module DSL
   end
 
   def remote_tempdir
-    @remote_tmpdir
+    File.join("/", "tmp") # TODO: Remove this?
   end
 end

data/lib/teuton/case/execute/execute_base.rb

@@ -0,0 +1,55 @@
+require_relative "../../utils/verbose"
+
+class ExecuteBase
+  include Verbose
+
+  def initialize(parent)
+    @parent = parent
+    # READ: @config, cmd = action[:command]
+    # WRITE: @action, @result, @session
+  end
+
+  private
+
+  def config
+    @parent.config
+  end
+
+  def action
+    @parent.action
+  end
+
+  def result
+    @parent.result
+  end
+
+  def sessions
+    @parent.sessions
+  end
+
+  def log(...)
+    @parent.log(...)
+  end
+
+  def conn_status
+    @parent.conn_status
+  end
+
+  def encode_and_split(encoding, text)
+    # Convert text to UTF-8 deleting unknown chars
+    text ||= "" # Ensure text is not nil
+    flag = [:default, "UTF-8"].include? encoding
+    return text.encode("UTF-8", invalid: :replace).split("\n") if flag
+
+    # Convert text from input ENCODING to UTF-8
+    ec = Encoding::Converter.new(encoding.to_s, "UTF-8")
+    begin
+      text = ec.convert(text)
+    rescue => e
+      puts "[ERROR] #{e}: Declare text encoding..."
+      puts "        run 'command', on: :host, :encoding => 'ISO-8859-1'"
+    end
+
+    text.split("\n")
+  end
+end

data/lib/teuton/case/execute/execute_local.rb

@@ -0,0 +1,29 @@
+require "open3"
+require "rainbow"
+require_relative "../../utils/project"
+require_relative "../../utils/verbose"
+require_relative "execute_base"
+
+class ExecuteLocal < ExecuteBase
+  def call
+    action[:conn_type] = :local
+    response = my_execute(action[:command], action[:encoding])
+    result.exitcode = response[:exitcode]
+    result.content = response[:content]
+  end
+
+  def my_execute(cmd, encoding = "UTF-8")
+    return {exitcode: 0, content: ""} if Project.debug?
+
+    begin
+      text, status = Open3.capture2e(cmd)
+      exitcode = status.exitstatus
+    rescue => e
+      verbose Rainbow("!").green
+      text = e.to_s
+      exitcode = 1
+    end
+    content = encode_and_split(encoding, text)
+    {exitcode: exitcode, content: content}
+  end
+end

data/lib/teuton/case/execute/execute_manager.rb

@@ -0,0 +1,56 @@
+require_relative "execute_local"
+require_relative "execute_ssh"
+require_relative "execute_telnet"
+
+class ExecuteManager
+  def initialize(parent)
+    @parent = parent
+    # READ: @config, cmd = action[:command]
+    # WRITE: @action, @result, @session
+    # my_execute, encode_and_split methods?
+  end
+
+  def call(host)
+    start_time = Time.now
+    run_on(host)
+    action[:duration] = (Time.now - start_time).round(3)
+  end
+
+  private
+
+  def action
+    @parent.action
+  end
+
+  def config
+    @parent.config
+  end
+
+  def log
+    @parent.log
+  end
+
+  def run_on(host)
+    protocol = config.get("#{host}_protocol".to_sym)
+    ip = config.get("#{host}_ip".to_sym)
+
+    if protocol.to_s.downcase == "local" || host.to_s == "localhost"
+      # Protocol force => local
+      ExecuteLocal.new(@parent).call
+    elsif protocol.to_s.downcase == "ssh"
+      # Protocol force => ssh
+      ExecuteSSH.new(@parent).call(host)
+    elsif protocol.to_s.downcase == "telnet"
+      # Protocol force => telnet
+      ExecuteTelnet.new(@parent).call(host)
+    elsif ip.to_s.downcase == "localhost" || ip.to_s.include?("127.0.0.")
+      # run_cmd_localhost
+      ExecuteLocal.new(@parent).call
+    elsif ip == "NODATA"
+      log("#{host} IP not found!", :error)
+    else
+      # run_cmd_remote_ssh host
+      ExecuteSSH.new(@parent).call(host)
+    end
+  end
+end

data/lib/teuton/case/execute/execute_ssh.rb

@@ -0,0 +1,90 @@
+require "net/ssh"
+require "net/sftp"
+require "rainbow"
+require_relative "../../utils/project"
+require_relative "../../utils/verbose"
+require_relative "execute_base"
+
+class ExecuteSSH < ExecuteBase
+  def call(input_hostname)
+    action[:conn_type] = :ssh
+    hostname = input_hostname.to_s
+    ip = config.get("#{hostname}_ip".to_sym).to_s
+    username = config.get("#{hostname}_username".to_sym).to_s
+    password = config.get("#{hostname}_password".to_sym).to_s
+    port = config.get("#{hostname}_port".to_sym).to_i
+    port = 22 if port.zero?
+
+    unless config.get("#{hostname}_route".to_sym) == "NODATA"
+      # Reconfigure command with gateway. Example host1_route: IP.
+      # hostname2 = hostname ¿not used?
+      ip2 = ip
+      username2 = username
+      password2 = password
+      command2 = action[:command]
+      hostname = config.get("#{hostname}_route".to_sym)
+      ip = config.get("#{hostname}_ip".to_sym).to_s
+      username = config.get("#{hostname}_username".to_sym).to_s
+      password = config.get("#{hostname}_password".to_sym).to_s
+      ostype = config.get("#{hostname}_ostype".to_sym).to_s
+
+      action[:command] = if ostype.downcase.start_with? "win"
+        "echo y | plink #{username2}@#{ip2} -ssh -pw #{password2} \"#{command2}\""
+      else
+        "sshpass -p #{password2} #{username2}@#{ip2} #{command2}"
+      end
+    end
+
+    text = ""
+    exitcode = 0
+    begin
+      if sessions[hostname].nil?
+        sessions[hostname] = Net::SSH.start(
+          ip,
+          username,
+          port: port,
+          password: password,
+          keepalive: true,
+          timeout: 30,
+          non_interactive: true
+        )
+      end
+      text = if sessions[hostname].instance_of? Net::SSH::Connection::Session
+        sessions[hostname].exec!(action[:command])
+      else
+        "SSH: NO CONNECTION!"
+      end
+      exitcode = text.exitstatus
+    rescue Errno::EHOSTUNREACH
+      sessions[hostname] = :nosession
+      conn_status[hostname] = :host_unreachable
+      exitcode = -1
+      log("Host #{ip} unreachable!", :error)
+    rescue Net::SSH::AuthenticationFailed
+      sessions[hostname] = :nosession
+      conn_status[hostname] = :error_authentication_failed
+      exitcode = -1
+      log("SSH::AuthenticationFailed!", :error)
+    rescue Net::SSH::HostKeyMismatch
+      sessions[hostname] = :nosession
+      conn_status[hostname] = :host_key_mismatch
+      exitcode = -1
+      log("SSH::HostKeyMismatch!", :error)
+      log("* The destination server's fingerprint is not matching " \
+          "what is in your local known_hosts file.", :error)
+      log("* Remove the existing entry in your local known_hosts file", :error)
+      log("* Try this => ssh-keygen -f '/home/USERNAME/.ssh/known_hosts' " \
+          "-R #{ip}", :error)
+    rescue => e
+      sessions[hostname] = :nosession
+      conn_status[hostname] = :error
+      exitcode = -1
+      log("[#{e.class}] SSH on <#{username}@#{ip}>" \
+          " exec: #{action[:command]}", :error)
+    end
+    output = encode_and_split(action[:encoding], text)
+    result.exitcode = exitcode
+    result.content = output
+    result.content.compact!
+  end
+end

data/lib/teuton/case/execute/execute_telnet.rb

@@ -0,0 +1,56 @@
+require "net/telnet"
+require "rainbow"
+require_relative "../../utils/project"
+require_relative "../../utils/verbose"
+require_relative "execute_base"
+
+class ExecuteTelnet < ExecuteBase
+  def call(input_hostname)
+    action[:conn_type] = :telnet
+    hostname = input_hostname.to_s
+    ip = config.get((hostname + "_ip").to_sym)
+    username = config.get((hostname + "_username").to_sym).to_s
+    password = config.get((hostname + "_password").to_sym).to_s
+    text = ""
+    begin
+      if sessions[hostname].nil? || sessions[hostname] == :ok
+        h = Net::Telnet.new(
+          "Host" => ip,
+          "Timeout" => 30,
+          "Prompt" => /login|teuton|[$%#>]/
+        )
+        # "Prompt" => Regexp.new(username[1, 40]))
+        # "Prompt" => /[$%#>] \z/n)
+        h.login(username, password)
+        h.cmd(action[:command]) { |i| text << i }
+        h.close
+        sessions[hostname] = :ok
+      else
+        text = "TELNET: NO CONNECTION!"
+      end
+    rescue Net::OpenTimeout
+      sessions[hostname] = :nosession
+      conn_status[hostname] = :open_timeout
+      verbose Rainbow(Application.instance.letter[:error]).red.bright
+      log(" ExceptionType=<Net::OpenTimeout> doing <telnet #{ip}>", :error)
+      log(" └── Revise host IP!", :warn)
+    rescue Net::ReadTimeout
+      sessions[hostname] = :nosession
+      conn_status[hostname] = :read_timeout
+      verbose Rainbow(Application.instance.letter[:error]).red.bright
+      log(" ExceptionType=<Net::ReadTimeout> doing <telnet #{ip}>", :error)
+    rescue => e
+      sessions[hostname] = :nosession
+      conn_status[hostname] = :error
+      verbose Rainbow(Application.instance.letter[:error]).red.bright
+      log(" ExceptionType=<#{e.class}> doing telnet on <#{username}@#{ip}>" \
+          " exec: #{action[:command]}", :error)
+      log(" └── username=<#{username}>, password=<#{password}>," \
+          " ip=<#{ip}>, HOSTID=<#{hostname}>", :warn)
+    end
+    output = encode_and_split(action[:encoding], text)
+    result.exitcode = -1
+    result.content = output
+    result.content.compact!
+  end
+end

data/lib/teuton/{case_manager/case → case}/play.rb

@@ -1,27 +1,22 @@
 # frozen_string_literal: true
 
-# Case class:
-# * play
-# * play_in_parallel
-# * play_in_sequence
-# * fill_report
-# * close_opened_sessions
 class Case
+  # Case class: play
+  # TODO: Encapsulate code into PlayManager class
+  # * play_in_parallel, play_in_sequence, fill_report, close_opened_sessions
+  # READ: sessions, config, groups, action, report
+  # TODO: groups from Project or from Case???
   def play
     if skip?
       verbose Rainbow("S").green
       return false
     end
     start_time = Time.now
-    if get(:tt_sequence) == true
-      play_in_sequence
-    else
-      play_in_parallel
-    end
+    play_groups_in_sequence
     fill_report(start_time, Time.now)
     close_opened_sessions
   end
-  alias start play
+  alias_method :start, :play
 
   def close_opened_sessions
     @sessions.each_value do |s|
@@ -31,14 +26,16 @@ class Case
 
   private
 
-  def play_in_parallel
+  def play_groups_in_sequence
+    verboseln "\n=> Starting case [#{@config.get(:tt_members)}]" if get(:tt_sequence) == true
     @groups.each do |t|
       @action[:groupname] = t[:name]
+      # TODO: @parent(case).instance_eval(&t[:block])
       instance_eval(&t[:block])
     end
   end
 
-  def play_in_sequence
+  def play_groups_in_parallel
     verboseln "Starting case [#{@config.get(:tt_members)}]"
     @groups.each do |t|
       verbose "* Processing [#{t[:name]}] "

data/lib/teuton/case_manager/case_manager.rb

@@ -1,15 +1,15 @@
-require "rainbow"
-require "singleton"
-require_relative "../application"
+require_relative "../case/case"
 require_relative "../report/report"
-require_relative "../report/show"
+require_relative "../utils/project"
+require_relative "../utils/verbose"
 require_relative "../utils/configfile_reader"
-require_relative "case/case"
 require_relative "export_manager"
-require_relative "main"
+require_relative "send_manager"
+require_relative "show_report"
+require_relative "check_cases"
+require_relative "report"
+require_relative "utils"
 
-# This class does all the job
-# Organize the hole job, sending orders to others classes
 # * initialize
 # * play
 # Split into several files:
@@ -18,8 +18,8 @@ require_relative "main"
 # * case_manager/hall_of_fame
 # * case_manager/report
 class CaseManager
-  include Singleton
   include Utils
+  include Verbose
   attr_reader :report, :cases
 
   def initialize
@@ -28,51 +28,32 @@ class CaseManager
     @report.filename = "resume"
   end
 
-  ##
-  # Execute "play" order: Start every single case test
-  # @param block (Block)
   def play(&block)
+    # Execute "play" order: Start every single case test
     check_cases!
     instance_eval(&block)
     # Run export if user pass option command "--export=json"
-    i = Application.instance.options["export"]
+    i = Project.value[:options]["export"]
     export(format: i.to_sym) unless i.nil?
     # Accept "configfile" param REVISE There exists?
-    i = Application.instance.options["configfile"]
+    i = Project.value[:options]["configfile"]
     export(format: i.to_sym) unless i.nil?
   end
 
-  ##
-  # Execute "export" order: Export every case report
-  # @param args (Hash) Export options
   def export(args = {})
-    if args.class != Hash
-      puts Rainbow("[ERROR] Argument error with 'export'!").red
-      puts Rainbow("  Code : CaseManager#export").red
-      puts Rainbow("  Line : export #{args}").red
-      puts Rainbow("  Use  : export format: 'txt'").red
-      puts ""
-      exit 1
-    end
-    ExportManager.run(@report, @cases, args)
+    ExportManager.new.call(
+      @report,
+      @cases,
+      args,
+      Project.value[:format]
+    )
   end
 
-  ##
-  # Execute "send" order: Send every case report
-  # @param args (Hash) Send options
   def send(args = {})
-    threads = []
-    puts ""
-    puts Rainbow("-" * 50).green
-    puts Rainbow("Sending files...#{args}").color(:green)
-    @cases.each { |c| threads << Thread.new { c.send(args) } }
-    threads.each(&:join)
-    puts Rainbow("Sending finished!").color(:green)
-    puts Rainbow("-" * 50).green
+    SendManager.new.call(@cases, args)
   end
 
   def show(options = {verbose: 1})
-    verbose = options[:verbose]
-    ShowReport.new(@report).call(verbose)
+    ShowReport.new(@report).call(options[:verbose])
   end
 end

data/lib/teuton/case_manager/check_cases.rb

@@ -1,32 +1,33 @@
 require_relative "hall_of_fame"
+require_relative "../utils/project"
 
 class CaseManager
   private
 
-  ##
-  # Start checking every single case
   def check_cases!
-    app = Application.instance
-
+    # Start checking every single case
+    app = Project.value
     # Load configurations from config file
-    configdata = ConfigFileReader.read(app.config_path)
-    app.ialias = configdata[:alias]
-    app.global = configdata[:global]
-    app.global[:tt_testname] = app.global[:tt_testname] || app.test_name
-    app.global[:tt_sequence] = false if app.global[:tt_sequence].nil?
+    configdata = ConfigFileReader.read(Project.value[:config_path])
+    app[:ialias] = configdata[:alias]
+    app[:global] = configdata[:global]
+    app[:global][:tt_testname] = app[:global][:tt_testname] || app[:test_name]
+    app[:global][:tt_sequence] = false if app[:global][:tt_sequence].nil?
 
     # Create out dir
-    outdir = app.global[:tt_outdir] || File.join("var", app.global[:tt_testname])
+    outdir = app[:global][:tt_outdir] || File.join("var", app[:global][:tt_testname])
     ensure_dir outdir
     @report.output_dir = outdir
 
     # Fill report head
-    open_main_report(app.config_path)
+    open_main_report(app[:config_path])
 
     # create cases and run
     configdata[:cases].each { |config| @cases << Case.new(config) }
     start_time = run_all_cases # run cases
 
+    # TODO: merge these 2 methdos
+    # TODO: CloseManager.call ???
     uniques = collect_uniques_for_all_cases
     close_reports_for_all_cases(uniques)
     close_main_report(start_time)
@@ -36,7 +37,8 @@ class CaseManager
     start_time = Time.now
     verboseln Rainbow("-" * 36).green
     verboseln Rainbow("Started at #{start_time}").green
-    if Application.instance.global[:tt_sequence] == true
+    # if Application.instance.global[:tt_sequence] == true
+    if Project.value[:global][:tt_sequence] == true
       # Run every case in sequence
       @cases.each(&:play)
     else

data/lib/teuton/case_manager/dsl.rb

@@ -1,16 +1,15 @@
-require_relative "../application"
+require_relative "../utils/project"
 require_relative "case_manager"
 
 def use(filename)
   filename += ".rb"
-  app = Application.instance
-  rbfiles = File.join(app.project_path, "**", filename)
+  rbfiles = File.join(Project.value[:project_path], "**", filename)
   files = Dir.glob(rbfiles)
   findfiles = []
   files.sort.each { |f| findfiles << f if f.include?(filename) }
   begin
     require_relative findfiles.first
-    app.uses << File.basename(findfiles.first)
+    Project.value[:uses] << File.basename(findfiles.first)
   rescue
     puts "[ERROR] Unknown file : #{filename}"
     puts "        Check line   : use '#{filename}'"
@@ -19,7 +18,7 @@ def use(filename)
 end
 
 def define_macro(name, *args, &block)
-  Application.instance.macros[name] = {args: args, block: block}
+  Project.value[:macros][name] = {args: args, block: block}
 end
 alias def_macro define_macro
 alias defmacro define_macro
@@ -28,13 +27,12 @@ alias defmacro define_macro
 # @param name (String) Group name
 # @param block (Block) Tests code
 def group(name, &block)
-  Application.instance.groups << {name: name, block: block}
+  Project.value[:groups] << {name: name, block: block}
 end
 alias task group
 
-# Start test
-# @param block (Block) Extra code executed at the end.
 def play(&block)
-  CaseManager.instance.play(&block)
+  # Start test
+  CaseManager.new.play(&block)
 end
 alias start play