teuton 3.2.0 → 3.2.1

data/lib/teuton/case_manager/dsl.rb

@@ -13,19 +13,19 @@ end
 alias def_macro define_macro
 alias defmacro define_macro
 
-# Define a group of [target/run/expect]s
-# @param name (String) Group name
-# @param block (Block) Tests code
 def group(name, &block)
   Project.value[:groups] << { name: name, block: block }
 end
 alias task group
 
 def play(&block)
-  # Start test
   CaseManager.new.play(&block)
 end
-alias start play
+
+def start(...)
+  Logger.warn "[DEPRECATED] Replace 'start do' by `play do'"
+  play(...)
+end
 
 def use(filename)
   filename += ".rb"
@@ -37,9 +37,6 @@ def use(filename)
     require_relative findfiles.first
     Project.value[:uses] << File.basename(findfiles.first)
   rescue StandardError => e
-    warn Rainbow("[ERROR] case_manager/dsl: #{e}").bright.red
-    warn Rainbow("[ERROR] File not found!").white
-    warn Rainbow("[ERROR] Fix line <use '#{filename}'>").white
-    exit 1
+    raise Teuton::CaseManagerDslError.new(e, filename)
   end
 end

data/lib/teuton/case_manager/export_manager.rb

@@ -14,23 +14,17 @@ class ExportManager
   # @param cases (Array)
   # @param input (Hash) Selected export options
   def call(main_report, cases, args)
-    if args.class != Hash
-      warn Rainbow("[ERROR] ExportManager: argument error!").bright.red
-      warn Rainbow("[ERROR] Fix line <export #{args}>").white
-      warn Rainbow("[ERROR] Replace by <export format: 'txt'>").white
-      warn ""
-      exit 1
-    end
+    raise Teuton::ExportArgumentError, args if args.class != Hash
 
     # Step 1: Validate options
     options = strings2symbols(args)
     options[:format] = Project.value[:format] if options[:format].nil?
 
     unless Formatter.available_formats.include? options[:format]
-      puts Rainbow("[WARN] ExportManager: Unkown format!").yellow.bright
-      puts Rainbow("[WARN] Fix line <export format: #{options[:format]}>").yellow.bright
-      puts Rainbow("[INFO] Available formats: #{Formatter.available_formats.join(", ")}.").white.bright
-      puts Rainbow("[INFO] Using default format <txt>.").white.bright
+      Logger.warn "ExportManager: Unkown format!"
+      Logger.warn "Fix line <export format: #{options[:format]}>"
+      Logger.warn "Available formats: #{Formatter.available_formats.join(", ")}."
+      Logger.warn "Using default format <txt>."
       options[:format] = :txt
     end
 
@@ -84,7 +78,7 @@ class ExportManager
                     "%<hour>02d%<min>02d%<sec>02d", data)
     preserve_dir = File.join(srcdir, subdir)
 
-    puts "[INFO] Preserving files => #{preserve_dir}"
+    Logger.info "Preserving files => #{preserve_dir}"
     FileUtils.mkdir(preserve_dir)
     Dir.glob(File.join(srcdir, "**.*")).each { |file| FileUtils.cp(file, preserve_dir) }
   end

data/lib/teuton/case_manager/ext/check_cases.rb

@@ -69,7 +69,7 @@ module CheckCasesExtension
   # 3) And order to build hall of fame
   def close_reports_for_all_cases(uniques)
     threads = []
-    @cases.each { |c| threads << Thread.new { c.close uniques } }
+    @cases.each { |c| threads << Thread.new { c.close(uniques) } }
     threads.each(&:join)
 
     HallOfFame.new(@cases).call

data/lib/teuton/cli/app.rb

@@ -0,0 +1,123 @@
+require "thor"
+require_relative "../version"
+require_relative "../../teuton"
+
+module Teuton
+  module CLI
+    class App < Thor
+      map ["h", "-h", "--help"] => "help"
+
+      map ["n", "-n", "--new"] => "new"
+      desc "new DIRECTORY", "Create skeleton for a new project"
+      long_desc <<-LONGDESC
+      Create files for a new project.
+      LONGDESC
+      def new(projectpath)
+        Teuton.create(projectpath)
+      end
+
+      map ["c", "-c", "--check"] => "check"
+      option :onlyconfig, type: :boolean
+      option :color, type: :boolean
+      option :cname, type: :string
+      option :cpath, type: :string
+      desc "check [OPTIONS] DIRECTORY", "Check test and config file content"
+      long_desc <<~LONGDESC
+
+        (1) teuton check PATH/TO/DIR , Check content of start.rb and config.yaml files.
+
+        (2) teuton check PATH/TO/DIR --cname=demo , Check content of start.rb and demo.yaml files:
+
+        (3) teuton check PATH/TO/DIR --onlyconfig  , Only show config file recomendations
+
+        (4) teuton check PATH/TO/DIR/foo.rb , Check content of foo.rb and foo.yaml files.
+
+        (5) teuton check PATH/TO/DIR/foo.rb --cname=demo , Check content of foo.rb and demo.yaml files.
+
+      LONGDESC
+      def check(projectpath)
+        Teuton.check(projectpath, options)
+      end
+
+      map ["co", "-co", "--config"] => "config"
+      desc "config [OPTIONS] DIRECTORY", "Suggest configuration."
+      long_desc <<~LONGDESC
+        config DIRECTORY, "Suggest the content of the configuration file based on the test"
+      LONGDESC
+      def config(projectpath)
+        # Check Test: suggest the content of the configuration file based on the test
+        opt = {"onlyconfig" => true}
+        Teuton.check(projectpath, opt)
+      end
+
+      map ["--readme"] => "readme"
+      option :lang, type: :string
+      desc "readme DIRECTORY", "Show README extracted from test contents"
+      long_desc <<-LONGDESC
+
+      (1) teuton readme foo
+      , Create README.md from foo/start.rb.
+
+      (2) teuton readme foo/demo.rb
+      , Create README.md from foo/demo.rb.
+      LONGDESC
+
+      def readme(projectpath)
+        Teuton.readme(projectpath, options)
+      end
+
+      map ["--run", "run"] => "play"
+      option :export, type: :string
+      option :cname, type: :string
+      option :cpath, type: :string
+      option :case, type: :string
+      option :color, type: :boolean
+      option :quiet, type: :boolean
+      desc "[run] [OPTIONS] DIRECTORY", "Run test from directory"
+      long_desc <<-LONGDESC
+      This function execute challenge from specified directory.
+      By default, show progress on the screen.
+
+      Let's see others options:
+
+      (1) teuton foo, run challenge from foo/start.rb with foo/config.yaml config file.
+
+      (2) teuton run foo, same as (1).
+
+      (3) teuton run --export=json foo, run challenge and export using json format.
+      Others output formats availables are: txt, html, yaml, json and colored_text.
+
+      (4) teuton run --cname=demo foo, run challenge from foo/start.rb with foo/demo.yaml config file.
+
+      (5) teuton foo/demo.rb, Run challenge from foo/demo.rb with foo/demo.yaml config file.
+
+      LONGDESC
+      def play(filepath)
+        Teuton.run(filepath, options)
+      end
+
+      map ["v", "-v", "--version"] => "version"
+      desc "version", "Show the program version"
+      def version
+        puts "#{Teuton::APPNAME} version #{Teuton::VERSION}"
+      end
+
+      ##
+      # These inputs are equivalents:
+      # * teuton dir/foo
+      # * teuton run dir/foo
+      def method_missing(method, *_args, &_block)
+        play(method.to_s)
+      end
+
+      def respond_to_missing?(method_name, include_private = false)
+        # Respond to missing methods name
+        super
+      end
+
+      def self.exit_on_failure?
+        true
+      end
+    end
+  end
+end

data/lib/teuton/cli/run.rb

@@ -0,0 +1,38 @@
+#!/usr/bin/env ruby
+
+require_relative "app"
+
+module Teuton::CLI
+  def self.run(argv)
+    begin
+      Teuton::CLI::App.start(argv)
+      exit 0
+    rescue Interrupt
+      puts "\nExecution cancelled by the user."
+      exit 130
+    rescue Teuton::CaseManagerDslError => e
+      lines = e.message.split("\n")
+      head = lines.shift
+      warn "Error | #{head}"
+      lines.each { |line| warn Rainbow("Error| #{line}").white }
+    rescue Teuton::ConfigFileError => e
+      lines = e.message.split("\n")
+      head = lines.shift
+      warn "Error | #{head}"
+      lines.each { |line| warn Rainbow("Error| #{line}").white }
+    rescue Teuton::MainScriptNotFoundError => e
+      warn "Error | #{e.message}"
+    rescue Teuton::Error => e
+      warn "Controlled error: #{e.message}"
+      e.backtrace&.first(3)&.each do |line|
+        warn Rainbow("Error |   #{line}").white
+      end
+    rescue => e
+      warn "Unexpected error: #{e.message}"
+      raise e if ENV["DEBUG"]
+
+      e.backtrace&.first(3)&.each { |line| warn Rainbow("Error |   #{line}").white }
+    end
+    exit 1
+  end
+end

data/lib/teuton/errors.rb

@@ -0,0 +1,94 @@
+module Teuton
+  class Error < StandardError; end
+
+  class CaseManagerDslError < Error
+    attr_reader :original_error, :filename
+
+    def initialize(original_error, filename)
+      @original_error = original_error
+      @filename = filename
+      super(build_message)
+    end
+
+    private
+
+    def build_message
+      <<~MSG.strip
+        case_manager/dsl: #{@original_error}
+        File not found! Fix line <use '#{@filename}'>
+      MSG
+    end
+  end
+
+  class ConfigurationError < Error; end
+
+  class ConfigFileError < Error
+    attr_reader :filepath, :original_error
+
+    def initialize(filepath, original_error)
+      @filepath = filepath
+      @original_error = original_error
+      super(build_message)
+    end
+
+    private
+
+    def build_message
+      <<~MSG.strip
+        Reading configurations file:
+        - File : #{@filepath}
+        - Type : #{@original_error}
+      MSG
+    end
+  end
+
+  class InputError < Error; end
+  class ExecutionError < Error; end
+
+  class ExportArgumentError < Error
+    attr_reader :args
+
+    def initialize(args)
+      @args = args
+      super(build_message)
+    end
+
+    private
+
+    def build_message
+      <<~MSG.strip
+        ExportManager: argument error!
+        - Fix line <export #{@args}>
+        - Replace by <export format: 'txt'>
+      MSG
+    end
+  end
+
+  class MainScriptNotFoundError < Error
+    attr_reader :script_path
+
+    def initialize(script_path)
+      @script_path = script_path
+      super(build_message)
+    end
+
+    private
+
+    def build_message
+      <<~MSG.strip
+        Main script file not found!
+        - File: #{script_path}
+      MSG
+    end
+  end
+
+  class UnexpectedSequenceTypeError < Error
+    attr_reader :received_class
+
+    def initialize(value_class)
+      super("expect_sequence #{value_class}")
+    end
+  end
+
+  class UploadArgumentError < ArgumentError; end
+end

data/lib/teuton/readme/action.rb

@@ -0,0 +1,29 @@
+class Readme
+  class Action
+    attr_reader :id
+    attr_accessor :description, :weight, :readme, :host, :exec
+
+    def initialize
+      @id = 0
+      @description = nil
+      @host = nil
+      @readme = []
+    end
+
+    def reset
+      @id += 1
+      @description = nil
+      @host = nil
+      @readme = []
+      self
+    end
+
+    def to_h
+      {
+        id: id,
+        description: description, weight: weight, readme: readme,
+        host: host, exec: exec
+      }
+    end
+  end
+end

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

@@ -6,19 +6,21 @@ require_relative "run"
 
 module ReadmeDSL
   def readme(text)
-    if @action[:target].nil?
+    if @action.description.nil?
       @current[:readme] << text # It's a group readme
     else
-      @action[:readme] << text # It's a target readme
+      @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: []}
+    previous_host = @action.host
+    @action.description = desc
+    @action.host = previous_host
+    @action.readme = []
     weight = 1.0
     weight = args[:weight].to_f if args[:weight]
-    @action[:weight] = weight
+    @action.weight = weight
   end
   alias_method :goal, :target
 

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

@@ -2,7 +2,7 @@
 
 module ReadmeDSL
   def expect(_cond, _args = {})
-    @current[:actions] << @action
+    @current[:actions] << @action.to_h
     result.reset
   end
   alias_method :expect_any, :expect
@@ -12,7 +12,7 @@ module ReadmeDSL
   alias_method :expect_one, :expect
 
   def expect_fail
-    @current[:actions] << @action
+    @current[:actions] << @action.to_h
     result.reset
   end
   alias_method :expect_ok, :expect_fail
@@ -23,7 +23,7 @@ module ReadmeDSL
   alias_method :expect_nothing, :expect_none
 
   def expect_sequence(&block)
-    @current[:actions] << @action
+    @current[:actions] << @action.to_h
     result.reset
   end
 end

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

@@ -3,30 +3,24 @@ module ReadmeDSL
     unless host == :localhost
       b = {}
       a = :"#{host}_ip"
-      if @config[:global][a].nil? && !@setted_params.include?(a)
-        @cases_params << a
-      end
+      @cases_params << a if @config[:global][a].nil? && !@setted_params.include?(a)
       b[:ip] = @config[:global][a] if @config[:global][a]
       b[:ip] = @setted_params[a] if @setted_params[a]
 
       a = :"#{host}_username"
-      if @config[:global][a].nil? && !@setted_params.include?(a)
-        @cases_params << a
-      end
+      @cases_params << a if @config[:global][a].nil? && !@setted_params.include?(a)
       b[:username] = @config[:global][a] if @config[:global][a]
       b[:username] = @setted_params[a] if @setted_params[a]
 
       a = :"#{host}_password"
-      if @config[:global][a].nil? && !@setted_params.include?(a)
-        @cases_params << a
-      end
+      @cases_params << a if @config[:global][a].nil? && !@setted_params.include?(a)
       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"
+    @action.host = host
+    @action.exec = args[:exec] || "noexec"
   end
 
   def run(command, args = {})

data/lib/teuton/readme/main.rb

@@ -12,16 +12,23 @@ def use(filename)
 end
 
 def define_macro(name, *args, &block)
-  Project.value[:macros][name] = {args: args, block: block}
+  Project.value[:macros][name] = { args: args, block: block }
 end
 
 def group(name, &block)
-  Project.value[:groups] << {name: name, block: block}
+  Project.value[:groups] << { name: name, block: block }
 end
-alias task group
 
-def start(&block)
+def task(...)
+  Logger.warn "[DEPRECATED] Replace 'task' by 'group'"
+  group(...)
+end
+
+def play(&block)
   # don't do nothing
 end
-# alias_method "play", "start" # REVISE THIS
-alias play start
+
+def start(...)
+  Logger.warn "[DEPRECATED] Replace `start' by' play'"
+  play(...)
+end

data/lib/teuton/readme/readme.rb

@@ -3,12 +3,13 @@ require_relative "../utils/project"
 require_relative "../utils/config_file_reader"
 require_relative "../case/dsl/macro"
 require_relative "../version"
+require_relative "action"
 require_relative "dsl/all"
 require_relative "lang"
 require_relative "result"
 
 class Readme
-  include DSL
+  include DSL # Used by case/dsl/macro
   include ReadmeDSL
 
   attr_reader :result, :data
@@ -39,7 +40,7 @@ class Readme
     @data[:macros] = []
     @data[:groups] = []
     @data[:play] = []
-    reset_action
+    @action = Action.new
     @setted_params = {}
     @cases_params = []
     @global_params = {}
@@ -50,15 +51,11 @@ class Readme
     Project.value[:groups].each do |group|
       @current = {name: group[:name], readme: [], actions: []}
       @data[:groups] << @current
-      reset_action
+      @action.reset
       instance_eval(&group[:block])
     end
   end
 
-  def reset_action
-    @action = {readme: []}
-  end
-
   def show_head
     puts "```"
     puts format(Lang.get(:date), Time.now)
@@ -96,16 +93,16 @@ class Readme
       puts "\n## #{group[:name].capitalize}\n"
       group[:readme].each { |line| puts "#{line}\n" }
       previous_host = nil
-      group[:actions].each_with_index do |item, index|
-        item[:host] = group[:actions][0][:host] if item[:host].nil? && index.positive?
-        if previous_host.nil? || item[:host] != previous_host
-          previous_host = item[:host] || "null"
+      group[:actions].each_with_index do |a, index|
+        a[:host] = group[:actions][0][:host] if a[:host].nil? && index.positive?
+        if previous_host.nil? || a[:host] != previous_host
+          previous_host = a[:host] || "null"
           puts format(Lang.get(:goto), previous_host.upcase)
         end
-        weight = "(x#{item[:weight]}) "
-        last = item[:target].end_with?(".", ":") ? "" : "."
-        puts "* #{weight}#{item[:target]}#{last}"
-        item[:readme].each { |line| puts "    * #{line}\n" }
+        weight = "(x#{a[:weight]}) "
+        last = a[:description].end_with?(".", ":") ? "" : "."
+        puts "* #{weight}#{a[:description]}#{last}"
+        a[:readme].each { |line| puts "    * #{line}\n" }
       end
     end
   end

data/lib/teuton/report/formatter/default/txt.rb

@@ -112,8 +112,8 @@ class TXTFormatter < ArrayFormatter
     when :red
       Rainbow(text).color(:red)
     else
-      puts Rainbow("[ERROR] TXTFormatter#colorize option=#{option}").bright.red
-      exit 1
+      Logger.warn "[TXTFormatter] colorize option=#{option}"
+      text
     end
   end
 end

data/lib/teuton/report/formatter/formatter.rb

@@ -41,10 +41,10 @@ module Formatter
   def self.call(report, options, filename)
     klass = get(options[:format])
     if klass.nil?
-      warn Rainbow("[ERROR] Formatter:").bright.red
-      warn Rainbow("[ERROR] - Unkown format <#{options[:format]}>. Fix line <export format: FORMAT>").white
-      warn Rainbow("[ERROR] - Available formats: #{Formatter.available_formats.join(",")}.").white
-      exit 1
+      Logger.warn "Formatter:"
+      Logger.warn "- Unkown format <#{options[:format]}>. Fix line <export format: FORMAT>"
+      Logger.warn "- Available formats: #{Formatter.available_formats.join(",")}."
+      return
     end
     formatter = klass.new(report)
     formatter.init(filename)
@@ -55,13 +55,4 @@ module Formatter
   def self.get(format)
     LIST[format]
   end
-
-  # def self.hide_feedback(report)
-  #  report2 = report.clone
-  #  report2.groups.each do |group|
-  #    group.each do |item|
-  #      puts item
-  #    end
-  #  end
-  # end
 end

data/lib/teuton/report/formatter/resume/txt.rb

@@ -113,8 +113,8 @@ class ResumeTXTFormatter < ResumeArrayFormatter
     when :red_bright
       Rainbow(text).red.bright
     else
-      puts "[ERROR] ResumeTXTFormatter#colorize option=#{option}"
-      exit 1
+      Logger.warn "[ResumeTXTFormatter] colorize option=#{option}"
+      text
     end
   end
 end

data/lib/teuton/utils/config_file_reader.rb

@@ -61,9 +61,7 @@ module ConfigFileReader
     begin
       data = YAML.load(File.open(filepath))
     rescue => e
-      warn Rainbow("[ERROR] ConfigFileReader.read_yaml: #{e}").bright.red
-      warn Rainbow("[ERROR] Revise file content! <#{filepath}>").white
-      exit 1
+      raise Teuton::ConfigFileError.new(filepath, e)
     end
     data = convert_string_keys_to_symbol(data)
     data[:global] = data[:global] || {}
@@ -111,10 +109,7 @@ module ConfigFileReader
     begin
       data = YAML.load(File.open(filepath))
     rescue => e
-      warn Rainbow("[ERROR] Reading configurations from yaml:").bright.red
-      warn Rainbow("[ERROR] - File : #{filepath}").white
-      warn Rainbow("[ERROR] - Type : #{e}").white
-      exit 1
+      raise Teuton::ConfigFileError.new(filepath, e)
     end
     data[:tt_source_file] = relative_path(filepath)
     convert_string_keys_to_symbol(data)
@@ -124,10 +119,7 @@ module ConfigFileReader
     begin
       data = JSON.parse(File.read(filepath), symbolize_names: true)
     rescue => e
-      warn Rainbow("[ERROR] Reading configurations from json:").bright.red
-      warn Rainboe("[ERROR] - File : #{filepath}").white
-      warn Rainbow("[ERROR] - Type : #{e}").white
-      exit 1
+      raise Teuton::ConfigFileError.new(filepath, e)
     end
     data[:tt_source_file] = relative_path(filepath)
     convert_string_keys_to_symbol(data)