liri 0.1.0 → 0.2.0

data/lib/common/tests_result.rb

@@ -0,0 +1,115 @@
+# = tests_result.rb
+#
+# @author Rodrigo Fernández
+#
+# == Clase TestsResult
+
+module Liri
+  module Common
+    # Esta clase se encarga de guardar y procesar el archivo de resultados
+    class TestsResult
+      def initialize(folder_path)
+        @folder_path = folder_path
+        @example_quantity = 0
+        @failure_quantity = 0
+        @passed_quantity = 0
+        @failures = ''
+      end
+
+      def save(file_name, raw_tests_result)
+        file_path = File.join(@folder_path, '/', file_name)
+        File.write(file_path, raw_tests_result)
+        file_path
+      end
+
+      def build_file_name(agent_ip_address, tests_batch_number)
+        "batch_#{tests_batch_number}_agent_#{agent_ip_address}_tests_results"
+      end
+
+      # Procesa el resultado crudo de las pruebas unitarias y lo devuelve en formato hash manejable
+      # Ejemplo del hash retornado:
+      # {example_quantity: 2, failure_quantity: 1}
+      def process(tests_result_file_name)
+        file_path = File.join(@folder_path, '/', tests_result_file_name)
+        result_hash = process_tests_result_file(file_path)
+        update_partial_result(result_hash)
+        #print_partial_result(result_hash)
+        result_hash
+      end
+
+      def print_summary
+        puts "\n#{@example_quantity} examples, #{@failure_quantity} failures\n"
+      end
+
+      def print_failures
+        puts "\nFailures: " if !@failures.empty?
+        puts @failures
+      end
+
+      private
+
+      # Recibe el resultado crudo de las pruebas unitarias
+      # Procesa el archivo con los resultados crudos y lo devuelve en formato hash manejable
+      # Ejemplo del hash retornado:
+      # {result: '.F', failures: '', example_quantity: 2, failure_quantity: 1, failed_examples: ''}
+      def process_tests_result_file(file_path)
+        result_hash = {failures: '', example_quantity: 0, failure_quantity: 0, passed_quantity: 0, failed_examples: ''}
+        flag = ''
+        File.foreach(file_path) do |line|
+          if flag == '' && line.strip.start_with?('Randomized')
+            flag = 'Randomized'
+            next
+          end
+
+          if ['Randomized', ''].include?(flag) && line.strip.start_with?('Failures')
+            flag = 'Failures'
+            next
+          end
+
+          if ['Randomized', 'Failures', ''].include?(flag) && line.strip.start_with?('Finished')
+            flag = 'Finished'
+            next
+          end
+
+          if ['Finished', ''].include?(flag) && line.strip.start_with?('Failed')
+            flag = 'Failed'
+            next
+          end
+
+          case flag
+          when 'Failures'
+            result_hash[:failures] << line
+          when 'Finished'
+            values = line.to_s.match(/([\d]+) example.?, ([\d]+) failure.?/)
+            result_hash[:example_quantity] = values[1].to_i
+            result_hash[:failure_quantity] = values[2].to_i
+            result_hash[:passed_quantity] = result_hash[:example_quantity] - result_hash[:failure_quantity]
+            flag = ''
+          when 'Failed'
+            result_hash[:failed_examples] << line
+          end
+        end
+
+        result_hash
+      end
+
+      def update_partial_result(hash_result)
+        @example_quantity += hash_result[:example_quantity]
+        @failure_quantity += hash_result[:failure_quantity]
+        @passed_quantity += hash_result[:passed_quantity]
+        @failures << hash_result[:failures]
+      end
+
+      def print_partial_result(result_hash)
+        result_hash[:passed_quantity].times do
+          print '.'
+        end
+
+        result_hash[:failure_quantity].times do
+          print 'F'
+        end
+      end
+
+    end
+  end
+end

data/lib/common/unit_test/rspec.rb

@@ -16,7 +16,10 @@ module Liri
           tests_hash = {}
           test_files.each do |test_file|
             File.open(test_file) do |file|
+              @inside_comment = false
               file.each_with_index do |line, index|
+                next if line_inside_comment_block(line)
+
                 if line.strip.start_with?('it')
                   absolute_file_path = file.to_path
                   relative_file_path = absolute_file_path.sub(@source_code_folder_path + '/', '')
@@ -50,40 +53,29 @@ module Liri
               raw_tests_result = %x|bash -lc 'rvm use #{Liri.current_folder_ruby_and_gemset}; rspec #{tests.join(' ')} --format progress'|
             end
 
-            hash_tests_result = process_tests_result(raw_tests_result)
-            hash_tests_result
+            return raw_tests_result
           end
         end
 
         private
+
         def test_files
           Dir[@tests_folder_path + "/**/*spec.rb"]
         end
 
-        # Recibe el resultado crudo de las pruebas unitarias
-        # Procesa el resultado y lo devuelve en formato hash manejable
-        # Ejemplo del hash retornado:
-        # {example_quantity: 2, failure_quantity: 1}
-        def process_tests_result(raw_test_results)
-          result_hash = {example_quantity: 0, failure_quantity: 0}
-          flag = ''
-          raw_test_results.each_line do |line|
-            if line.strip.start_with?('Finished')
-              flag = 'Finished'
-              next
-            end
+        # Revisa si la línea se encuentra dentro de un bloque comentado
+        def line_inside_comment_block(line)
+          if line.strip.start_with?('=begin')
+            @inside_comment = true
+            return true
+          end
 
-            if flag == 'Finished'
-              puts ''
-              Liri.logger.info(line)
-              values = line.to_s.match(/([\d]+) example.?, ([\d]+) failure.?/)
-              result_hash[:example_quantity] = values[1].to_i
-              result_hash[:failure_quantity] = values[2].to_i
-              flag = ''
-            end
+          if line.strip.start_with?('=end')
+            @inside_comment = false
+            return false
           end
 
-          result_hash
+          return true if @inside_comment
         end
       end
     end

data/lib/liri.rb

@@ -3,20 +3,16 @@
 # Este modulo contiene datos del programa que son reutilizados en otras partes de la aplicacion
 module Liri
   NAME = 'liri' # El gemspec requiere que el nombre este en minusculas
-  VERSION = '0.1.0'
-  SETUP_FOLDER_NAME = 'liri'
-  SETUP_FOLDER_PATH = File.join(Dir.pwd, '/', SETUP_FOLDER_NAME)
-  LOGS_FOLDER_NAME = 'logs'
-  MANAGER_LOGS_FOLDER_PATH = File.join(SETUP_FOLDER_PATH, '/', LOGS_FOLDER_NAME)
-  AGENT_LOGS_FOLDER_PATH = MANAGER_LOGS_FOLDER_PATH
-  AGENT_FOLDER_NAME = 'agent'
-  AGENT_FOLDER_PATH = File.join(SETUP_FOLDER_PATH, '/', AGENT_FOLDER_NAME)
-  MANAGER_FOLDER_NAME = 'manager'
-  MANAGER_FOLDER_PATH = File.join(SETUP_FOLDER_PATH, '/', MANAGER_FOLDER_NAME)
+  VERSION = '0.2.0'
 
   class << self
+    def set_setup(destination_folder_path)
+      load_setup_manager(destination_folder_path)
+    end
+
+    # Carga las configuraciones en memoria desde un archivo de configuracion
     def setup
-      @setup ||= load_setup
+      @setup
     end
 
     def logger
@@ -36,30 +32,16 @@ module Liri
       end
     end
 
-    def create_folders(program)
-      Dir.mkdir(SETUP_FOLDER_PATH) unless Dir.exist?(SETUP_FOLDER_PATH)
-
-      case program
-      when 'manager'
-        Dir.mkdir(MANAGER_LOGS_FOLDER_PATH) unless Dir.exist?(MANAGER_LOGS_FOLDER_PATH)
-        Dir.mkdir(MANAGER_FOLDER_PATH) unless Dir.exist?(MANAGER_FOLDER_PATH)
-      when 'agent'
-        Dir.mkdir(AGENT_FOLDER_PATH) unless Dir.exist?(AGENT_FOLDER_PATH)
-        Dir.mkdir(AGENT_LOGS_FOLDER_PATH) unless Dir.exist?(AGENT_LOGS_FOLDER_PATH)
-      end
-    end
-
-    def clean_folder(folder_path)
+    def clean_folder_content(folder_path)
       FileUtils.rm_rf(Dir.glob(folder_path + '/*')) if Dir.exist?(folder_path)
     end
 
     def reload_setup
-      @setup = load_setup
+      @setup = (@setup_manager ? @setup_manager.load : nil)
     end
 
     def delete_setup
-      liri_setup = Liri::Manager::Setup.new(SETUP_FOLDER_PATH)
-      liri_setup.delete
+      @setup_manager ? @setup_manager.delete_setup_folder : false
     end
 
     def init_exit(stop, threads, program)
@@ -75,7 +57,7 @@ module Liri
     end
 
     def kill(threads)
-      threads.each{|thread| Thread.kill(thread)}
+      threads.each{ |thread| Thread.kill(thread) }
     end
 
     def current_host_ip_address
@@ -99,22 +81,27 @@ module Liri
       setup.ports.tcp
     end
 
+    def print_failures
+      setup.print_failures
+    end
+
     def current_folder_ruby_and_gemset
       "#{File.read('.ruby-version').strip}@#{File.read('.ruby-gemset').strip}"
     end
 
     private
 
-    # Carga las configuraciones en memoria desde un archivo de configuracion
-    def load_setup
-      liri_setup = Liri::Manager::Setup.new(SETUP_FOLDER_PATH)
-      liri_setup.create unless File.exist?(liri_setup.path)
-      liri_setup.load
+    # Inicializa el objeto que gestiona las configuraciones
+    def load_setup_manager(destination_folder_path)
+      @setup_manager = Liri::Common::Setup.new(destination_folder_path)
+      @setup_manager.init
+      @setup = @setup_manager.load
+      @setup_manager
     end
 
     # Inicializa y configura la librería encargada de loguear
     def load_logger(folder_path = nil, file_name = nil)
-      log = Liri::Common::Log.new('daily', folder_path: folder_path, file_name: file_name, stdout: Liri.setup.log.stdout.show)
+      log = Liri::Common::Log.new('daily', folder_path: folder_path, file_name: file_name, stdout: setup.log.stdout.show)
       log
     end
   end

data/lib/manager/manager.rb

@@ -1,7 +1,11 @@
 =begin
   Este modulo es el punto de entrada del programa principal
 =end
+
+# TODO Para trabajar con hilos y concurrencia recomiendan usar parallel, workers, concurrent-ruby. Fuente: https://www.rubyguides.com/2015/07/ruby-threads/
+
 require 'all_libraries'
+require 'terminal-table'
 
 module Liri
   class Manager
@@ -11,29 +15,27 @@ module Liri
     class << self
       # Inicia la ejecución del Manager
       # @param stop [Boolean] el valor true es para que no se ejecute infinitamente el método en el test unitario.
-      def run(stop = false)
+      def run(source_code_folder_path, stop = false)
         return unless valid_project
-        Liri.create_folders('manager')
-
-        Liri.set_logger(Liri::MANAGER_LOGS_FOLDER_PATH, 'liri-manager.log')
-        Liri.logger.info("Proceso Manager iniciado")
-        puts "Presione Ctrl + c para terminar el proceso Manager manualmente\n\n"
 
-        user, password = get_credentials
+        setup_manager = Liri.set_setup(source_code_folder_path)
+        manager_folder_path = setup_manager.manager_folder_path
 
-        source_code = compress_source_code
-
-        manager_data = manager_data(user, password, source_code)
+        Liri.set_logger(setup_manager.logs_folder_path, 'liri-manager.log')
+        Liri.logger.info("Proceso Manager iniciado")
+        Liri.logger.info("Presione Ctrl + c para terminar el proceso Manager manualmente\n", true)
 
+        user, password = get_credentials(setup_manager.setup_folder_path)
+        source_code = compress_source_code(source_code_folder_path, manager_folder_path)
+        manager_data = get_manager_data(user, password, manager_folder_path, source_code)
         all_tests = get_all_tests(source_code)
+        tests_result = Common::TestsResult.new(manager_folder_path)
 
-        test_result = Liri::Manager::TestResult.new
-
-        manager = Manager.new(Liri.udp_port, Liri.tcp_port, all_tests, test_result)
+        manager = Manager.new(Liri.udp_port, Liri.tcp_port, all_tests, tests_result, manager_folder_path)
 
         threads = []
         threads << manager.start_client_socket_to_search_agents(manager_data) # Enviar peticiones broadcast a toda la red para encontrar Agents
-        manager.start_server_socket_to_process_tests(threads[0]) # Esperar y enviar los test unitarios a los Agents
+        manager.start_server_socket_to_process_tests(threads[0]) unless stop # Esperar y enviar los test unitarios a los Agents
 
         Liri.init_exit(stop, threads, 'Manager')
         Liri.logger.info("Proceso Manager terminado")
@@ -58,44 +60,44 @@ module Liri
         end
       end
 
-      def compressed_file_folder_path
-        File.join(Liri::Common.setup_folder_path, '/manager')
-      end
-
-      def decompressed_file_folder_path
-        compressed_file_folder_path
-      end
-
-      def get_credentials
-        credential = Liri::Manager::Credential.new(Liri::SETUP_FOLDER_PATH)
+      def get_credentials(setup_folder_path)
+        credential = Liri::Manager::Credential.new(setup_folder_path)
         credential.get
       end
 
-      def compress_source_code
-        source_code = Liri::Common::SourceCode.new(Liri::MANAGER_FOLDER_PATH, Liri.compression_class, Liri.unit_test_class)
-        Liri::Common::Benchmarking.start(start_msg: "Comprimiendo código fuente. Espere... ") do
+      def compress_source_code(source_code_folder_path, manager_folder_path)
+        source_code = Common::SourceCode.new(source_code_folder_path, manager_folder_path, Liri.compression_class, Liri.unit_test_class)
+
+        Common::Progressbar.start(total: nil, length: 100, format: 'Comprimiendo Código Fuente |%B| %a') do
           source_code.compress_folder
         end
-        puts ''
+        puts "\n\n"
+
         source_code
       end
 
-      def manager_data(user, password, source_code)
-        # puts "User: #{user} Password: #{password}"
-        [user, password, source_code.compressed_file_path].join(';')
+      def get_manager_data(user, password, manager_folder_path, source_code)
+        Common::ManagerData.new(
+          folder_path: manager_folder_path,
+          compressed_file_path: source_code.compressed_file_path,
+          user: user,
+          password: password
+        )
       end
 
       def get_all_tests(source_code)
         all_tests = {}
-        Liri::Common::Benchmarking.start(start_msg: "Obteniendo conjunto de pruebas. Espere... ") do
+
+        Common::Progressbar.start(total: nil, length: 100, format: 'Extrayendo Pruebas Unitarias |%B| %a') do
           all_tests = source_code.all_tests
         end
-        puts ''
+        puts "\n\n"
+
         all_tests
       end
     end
 
-    def initialize(udp_port, tcp_port, all_tests, test_result)
+    def initialize(udp_port, tcp_port, all_tests, tests_result, manager_folder_path)
       @udp_port = udp_port
       @udp_socket = UDPSocket.new
       @tcp_port = tcp_port
@@ -110,22 +112,29 @@ module Liri
       @agents_search_processing_enabled = true
       @test_processing_enabled = true
 
-      @test_result = test_result
+      @tests_batch_number = 0
+      @tests_batches = {}
+
+      @tests_result = tests_result
       @semaphore = Mutex.new
+
+      @manager_folder_path = manager_folder_path
+
+      @progressbar = ProgressBar.create(starting_at: 0, total: @all_tests_count, length: 100, format: 'Progress %c/%C |%b=%i| %p%% | %a')
     end
 
     # Inicia un cliente udp que hace un broadcast en toda la red para iniciar una conexión con los Agent que estén escuchando
-    def start_client_socket_to_search_agents(user_data)
+    def start_client_socket_to_search_agents(manager_data)
       # El cliente udp se ejecuta en bucle dentro de un hilo, esto permite realizar otras tareas mientras este hilo sigue sondeando
       # la red para obtener mas Agents. Una vez que los tests terminan de ejecutarse, este hilo será finalizado.
       Thread.new do
-        puts "\nBuscando Agentes... Espere"
+        Liri.logger.info("Buscando Agentes... Espere")
         Liri.logger.info("Se emite un broadcast cada #{UDP_REQUEST_DELAY} segundos en el puerto UDP: #{@udp_port}
                                      (Se mantiene escaneando la red para encontrar Agents)
         ")
-        while @agents_search_processing_enabled
+        while agents_search_processing_enabled
           @udp_socket.setsockopt(Socket::SOL_SOCKET, Socket::SO_BROADCAST, true)
-          @udp_socket.send(user_data, 0, '<broadcast>', @udp_port)
+          @udp_socket.send(manager_data.to_h.to_json, 0, '<broadcast>', @udp_port)
           sleep(UDP_REQUEST_DELAY) # Se pausa un momento antes de efectuar nuevamente la petición broadcast
         end
       end
@@ -146,12 +155,18 @@ module Liri
       ")
       # El siguiente bucle permite que varios clientes es decir Agents se conecten
       # De: http://www.w3big.com/es/ruby/ruby-socket-programming.html
-      while @test_processing_enabled
+      while test_processing_enabled
         Thread.start(tcp_socket.accept) do |client|
           agent_ip_address = client.remote_address.ip_address
           response = client.recvfrom(1000).first
 
-          if @all_tests.empty?
+          Liri.logger.info("\nConexión iniciada con el Agente: #{agent_ip_address}")
+          Liri.logger.info("Respuesta al broadcast recibida del Agent: #{agent_ip_address} en el puerto TCP: #{@tcp_port}:  #{response}")
+
+          # Se le indica al agente que proceda
+          client.puts({ msg: 'Recibido', exist_tests: all_tests.any? }.to_json)
+
+          if all_tests.empty?
             # No importa lo que le haga, el broadcast udp no se muere al instante y el agente sigue respondiendo
             # Las siguientes dos lineas son para que se deje de hacer el broadcast pero aun asi se llegan a hacer
             # 3 a 4 broadcast antes de que se finalize el proceso, al parecer el broadcast va a tener que quedar asi
@@ -159,49 +174,42 @@ module Liri
             # tests enviados sin resultados, tests finalizados, si se recibe respuesta al broadcast se trata de enviar primero test pendientes
             # luego test enviados sin resultados o sino ignorar
             Thread.kill(search_agents_thread)
-            @agents_search_processing_enabled = false
-            Liri.logger.info("Se termina cualquier proceso pendiente con el Agent #{agent_ip_address}")
-            Liri.logger.info(response)
+            agents_search_processing_enabled = false
+            Liri.logger.info("Se termina cualquier proceso pendiente con el Agent #{agent_ip_address} en el puerto TCP: #{@tcp_port}: #{response}")
             client.close
             Thread.exit
           end
 
-          puts "\nConexión iniciada con el Agente: #{agent_ip_address}"
-          Liri.logger.info("Respuesta al broadcast recibida del Agent: #{agent_ip_address} en el puerto TCP: #{@tcp_port}
-                                         => Agent #{agent_ip_address}: #{response}
-          ")
-
-          while @all_tests.any?
-            tests = samples
-            break if tests.empty?
-            begin
-              client.puts(tests.to_json) # Este envía un hash bastante grande al cliente y siempre llega, pero la respuesta del cliente a veces no llega todo, porque?
-              response = client.recvfrom(1000).first
-            rescue Errno::EPIPE => e
-              # Esto al parecer se da cuando el Agent ya cerró las conexiones y el Manager intenta contactar
-              Liri.logger.error("Exception(#{e}) El Agent #{agent_ip_address} ya terminó la conexión")
-			        # Si el Agente ya no responde es mejor romper el bucle para que no quede colgado
-              break
+          while all_tests.any?
+            time_in_seconds = Liri::Common::Benchmarking.start(start_msg: "Proceso de Ejecución de pruebas. Agent: #{agent_ip_address}. Espere... ", end_msg: "Proceso de Ejecución de pruebas. Agent: #{agent_ip_address}. Duración: ", stdout: false) do
+              tests_batch = tests_batch(agent_ip_address)
+              break unless tests_batch
+
+              begin
+                Liri.logger.debug("Conjunto de pruebas enviadas al Agent #{agent_ip_address}: #{tests_batch}")
+
+                client.puts(tests_batch.to_json) # Se envia el lote de tests
+                response = client.recvfrom(1000).first # Se recibe la respuesta. Cuando mas alto es el parámetro de recvfrom, mas datos se reciben osino se truncan.
+              rescue Errno::EPIPE => e
+                # Esto al parecer se da cuando el Agent ya cerró las conexiones y el Manager intenta contactar
+                Liri.logger.error("Exception(#{e}) El Agent #{agent_ip_address} ya terminó la conexión")
+                # Si el Agente ya no responde es mejor romper el bucle para que no quede colgado
+                break
+              end
             end
-            # TODO A veces se tiene un error de parseo JSON, de ser asi los resultados no pueden procesarse,
-            # hay que arreglar esto, mientras, se captura el error para que no falle
+
+            # Se captura por si acaso los errores de parseo JSON
             begin
-              tests_result = response
-              Liri.logger.debug("Resultados de la ejecución de las pruebas recibidas del Agent #{agent_ip_address}:")
-              Liri.logger.debug("RAW:")
-              Liri.logger.debug(tests_result)
-              json_tests_result = JSON.parse(tests_result)
-              Liri.logger.debug("JSON:")
-              Liri.logger.debug(json_tests_result)
-              process_tests_result(tests, json_tests_result)
+              tests_result = JSON.parse(response)
+              Liri.logger.debug("Respuesta del Agent #{agent_ip_address}: #{tests_result}")
+              process_tests_result(agent_ip_address, tests_result, time_in_seconds)
             rescue JSON::ParserError => e
               Liri.logger.error("Exception(#{e}) Error de parseo JSON")
             end
           end
 
           update_processing_statuses
-          puts ''
-          Liri.logger.info("Se termina la conexión con el Agent #{agent_ip_address}")
+          Liri.logger.info("Se termina la conexión con el Agent #{agent_ip_address} en el puerto TCP: #{@tcp_port}")
           begin
             client.puts('exit') # Se envía el string exit para que el Agent sepa que el proceso terminó
             client.close # se desconecta el cliente
@@ -215,44 +223,101 @@ module Liri
         end
       end
 
-      Liri.clean_folder(Liri::MANAGER_FOLDER_PATH)
-      @test_result.print_summary
+      Liri.clean_folder_content(@manager_folder_path)
+      @tests_result.print_summary
+      print_agents_summary
+      @tests_result.print_failures if Liri.print_failures
+    end
+
+    def all_tests
+      @semaphore.synchronize do
+        @all_tests
+      end
+    end
+
+    def agents_search_processing_enabled=(value)
+      @semaphore.synchronize do
+        @agents_search_processing_enabled = value
+      end
+    end
+
+    def agents_search_processing_enabled
+      @semaphore.synchronize do
+        @agents_search_processing_enabled
+      end
+    end
+
+    def test_processing_enabled
+      @semaphore.synchronize do
+        @test_processing_enabled
+      end
     end
 
     def update_processing_statuses
-      @semaphore.synchronize {
+      @semaphore.synchronize do
         @test_processing_enabled = false if @all_tests_count == @all_tests_results_count
         @agents_search_processing_enabled = false if @all_tests_count == @all_tests_processing_count
-      }
+      end
     end
 
-    def update_all_tests_results_count(new_count)
-      @all_tests_results_count += new_count
-    end
+    def tests_batch(agent_ip_address)
+      # Se inicia un semáforo para evitar que varios hilos actualicen variables compartidas
+      @semaphore.synchronize do
+        return nil if @all_tests.empty?
 
-    def update_all_tests_processing_count(new_count)
-      @all_tests_processing_count += new_count
+        @tests_batch_number += 1 # Se numera cada lote
+        samples = @all_tests.sample!(Manager.test_samples_by_runner) # Se obtiene algunos tests
+        samples_keys = samples.keys # Se obtiene la clave asignada a los tests
+        @all_tests_processing_count += samples_keys.size
+
+        @agents[agent_ip_address] = { agent_ip_address: agent_ip_address, tests_processed_count: 0, examples: 0, failures: 0, time_in_seconds: 0, duration: '' } unless @agents[agent_ip_address]
+
+        #@tests_batches[@tests_batch_number] = { agent_ip_address: agent_ip_address, tests_batch_keys: samples_keys } # Se guarda el lote a enviar
+        tests_batch = { tests_batch_number: @tests_batch_number, tests_batch_keys: samples_keys } # Se construye el lote a enviar
+        tests_batch
+      end
     end
 
-    def samples
-      _samples = nil
-      # Varios hilos no deben acceder simultaneamente al siguiente bloque porque actualiza variables compartidas
-      @semaphore.synchronize {
-        _samples = @all_tests.sample!(Manager.test_samples_by_runner)
-        puts ''
-        Liri.logger.info("Cantidad de pruebas pendientes: #{@all_tests.size}")
-        update_all_tests_processing_count(_samples.size)
-      }
-      _samples
+    def process_tests_result(agent_ip_address, tests_result, time_in_seconds)
+      # Se inicia un semáforo para evitar que varios hilos actualicen variables compartidas
+      @semaphore.synchronize do
+        tests_batch_number = tests_result['tests_batch_number']
+        tests_result_file_name = tests_result['tests_result_file_name']
+        tests_batch_keys_size = tests_result['tests_batch_keys_size']
+
+        #tests_batch_keys = @tests_batches[tests_batch_number][:tests_batch_keys]
+        tests_processed_count = tests_batch_keys_size
+        @all_tests_results_count += tests_processed_count
+
+        @progressbar.progress = @all_tests_results_count
+
+        #@tests_batches[tests_batch_number][:tests_result_file_name] = tests_result_file_name
+
+        tests_result = @tests_result.process(tests_result_file_name)
+
+        @agents[agent_ip_address][:tests_processed_count] += tests_processed_count
+        @agents[agent_ip_address][:examples] += tests_result[:example_quantity]
+        @agents[agent_ip_address][:failures] += tests_result[:failure_quantity]
+        @agents[agent_ip_address][:time_in_seconds] += time_in_seconds
+        @agents[agent_ip_address][:duration] = @agents[agent_ip_address][:time_in_seconds].to_duration
+
+        Liri.logger.info("Pruebas procesadas por Agente: #{agent_ip_address}: #{@agents[agent_ip_address][:tests_processed_count]}")
+      end
     end
 
-    def process_tests_result(tests, tests_result)
-      # Varios hilos no deben acceder simultaneamente al siguiente bloque porque actualiza variables compartidas
-      @semaphore.synchronize {
-        update_all_tests_results_count(tests.size)
-        @test_result.print_process(tests_result)
-        @test_result.update(tests_result)
-      }
+    def print_agents_summary
+      rows = @agents.values.map { |line| line.values }
+      headings = @agents.values.first.keys
+
+      table = Terminal::Table.new title: "Resúmen", headings: headings, rows: rows
+      table.style = {padding_left: 3, border_x: "=", border_i: "x" }
+      table.align_column(1, :right)
+      table.align_column(2, :right)
+      table.align_column(3, :right)
+      table.align_column(4, :right)
+      table.align_column(5, :right)
+
+      puts table
     end
   end
 end

data/lib/task.rb

@@ -5,8 +5,8 @@
 module Liri
   module Task
     class << self
-      def tests_count
-        source_code = Liri::Common::SourceCode.new('', Liri.compression_class, Liri.unit_test_class)
+      def tests_count(source_code_folder_path)
+        source_code = Liri::Common::SourceCode.new(source_code_folder_path,'', Liri.compression_class, Liri.unit_test_class)
         source_code.all_tests.size
       end
     end