liri 0.1.0 → 0.3.0

data/lib/manager/manager.rb

@@ -1,39 +1,38 @@
 =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
-    UDP_REQUEST_DELAY = 3
-    attr_reader :agents
-
     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"
+        setup_manager = Liri.set_setup(source_code_folder_path)
+        manager_folder_path = setup_manager.manager_folder_path
 
-        user, password = get_credentials
-
-        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")
@@ -42,8 +41,8 @@ module Liri
         Liri.kill(threads)
       end
 
-      def test_samples_by_runner
-        Liri.setup.test_samples_by_runner
+      def test_files_by_runner
+        Liri.setup.test_files_by_runner
       end
 
       private
@@ -58,44 +57,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,23 +109,30 @@ 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("Se emite un broadcast cada #{UDP_REQUEST_DELAY} segundos en el puerto UDP: #{@udp_port}
+        Liri.logger.info("Buscando Agentes... Espere")
+        Liri.logger.info("Se emite un broadcast cada #{Liri.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)
-          sleep(UDP_REQUEST_DELAY) # Se pausa un momento antes de efectuar nuevamente la petición broadcast
+          @udp_socket.send(manager_data.to_h.to_json, 0, '<broadcast>', @udp_port)
+          sleep(Liri.udp_request_delay) # Se pausa un momento antes de efectuar nuevamente la petición broadcast
         end
       end
     end
@@ -146,12 +152,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 +171,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 +220,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_files_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

data/liri.gemspec

@@ -55,4 +55,12 @@ Gem::Specification.new do |spec|
   # Ruby internationalization and localization (i18n) solution. https://github.com/ruby-i18n/i18n
   # Este es un requerimiento de la gema to_duration
   spec.add_runtime_dependency('i18n', '~> 1')
+
+  # The ultimate text progress bar library for Ruby!. https://github.com/jfelchner/ruby-progressbar
+  # Para mostrar barras de progreso
+  spec.add_runtime_dependency('ruby-progressbar', '~> 1')
+
+  # Terminal Table is a fast and simple, yet feature rich table generator written in Ruby. https://github.com/tj/terminal-table
+  # Para mostrar resumen de resultados
+  spec.add_runtime_dependency('terminal-table', '~> 3')
 end

data/spec_credentials.yml.example

@@ -0,0 +1,4 @@
+# Este archivo .yml define el usuario y la contraseña a utilizar para ejecutar los tests de manager_spec
+# Debe renombrar este archivo a spec_credentials.yml
+user: user
+password: password

data/template/liri-config.yml

@@ -3,12 +3,15 @@
 # Obs.: Puede que no sea útil para el usuario poder cambiar este nombre
 compressed_file_name: compressed_source_code
 # Configuración de la cantidad de tests a ejecutar por tandas
-test_samples_by_runner: 100
+test_files_by_runner: 10
+print_failures: false
+udp_request_delay: 10
 log:
   stdout:
     # Configuración que define si se muestra el log de ejecución del programa en línea de comando. Puede ser true o false.
     # Por defecto siempre se imprimirá el log en un archivo dentro de la carpeta logs
-    show: true
+    # Si se pone a true, interfiere con la barra de progreso del Manager, mejor tenerlo en false
+    show: false
     # Define los colores del texto del log. Puede ser none (no muestra colores), severity (colorea código de error),
     # severity_date (colorea código de error y fecha), full (colorea el texto entero).
     colorize: full

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: liri
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Rodrigo Fernández
@@ -9,7 +9,7 @@ authors:
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2022-05-08 00:00:00.000000000 Z
+date: 2022-05-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rubyzip
@@ -95,6 +95,34 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1'
+- !ruby/object:Gem::Dependency
+  name: ruby-progressbar
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1'
+- !ruby/object:Gem::Dependency
+  name: terminal-table
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3'
 description: Test distributor executor
 email:
 - rofaccess@gmail.com
@@ -110,6 +138,7 @@ files:
 - ".rubocop.yml"
 - ".ruby-gemset"
 - ".ruby-version"
+- ".simplecov"
 - ".travis.yml"
 - CODE_OF_CONDUCT.md
 - Gemfile
@@ -117,6 +146,7 @@ files:
 - LICENSE.txt
 - README.md
 - Rakefile
+- bash_script_examples.sh
 - bin/bundle
 - bin/coderay
 - bin/commander
@@ -132,6 +162,24 @@ files:
 - bin/yardoc
 - bin/yri
 - config/locales/to_duration_es.yml
+- dummy-app/.gitignore
+- dummy-app/.rspec
+- dummy-app/.ruby-gemset
+- dummy-app/.ruby-version
+- dummy-app/CODE_OF_CONDUCT.md
+- dummy-app/Gemfile
+- dummy-app/Gemfile.lock
+- dummy-app/LICENSE.txt
+- dummy-app/README.md
+- dummy-app/Rakefile
+- dummy-app/bin/console
+- dummy-app/bin/setup
+- dummy-app/dummy-app.gemspec
+- dummy-app/lib/dummy/app.rb
+- dummy-app/lib/dummy/app/version.rb
+- dummy-app/spec/dummy/app_spec.rb
+- dummy-app/spec/dummy/dummy_spec.rb
+- dummy-app/spec/spec_helper.rb
 - exe/liri
 - lib/agent/agent.rb
 - lib/agent/runner.rb
@@ -139,7 +187,11 @@ files:
 - lib/common/benchmarking.rb
 - lib/common/compressor/zip.rb
 - lib/common/log.rb
+- lib/common/manager_data.rb
+- lib/common/progressbar.rb
+- lib/common/setup.rb
 - lib/common/source_code.rb
+- lib/common/tests_result.rb
 - lib/common/unit_test/rspec.rb
 - lib/exe/agent.rb
 - lib/exe/manager.rb
@@ -147,10 +199,9 @@ files:
 - lib/liri.rb
 - lib/manager/credential.rb
 - lib/manager/manager.rb
-- lib/manager/setup.rb
-- lib/manager/test_result.rb
 - lib/task.rb
 - liri.gemspec
+- spec_credentials.yml.example
 - template/liri-config.yml
 homepage: https://github.com/rofaccess/tfg
 licenses:

data/lib/manager/setup.rb

@@ -1,70 +0,0 @@
-=begin
-  Este modulo se encarga de manejar la configuración
-=end
-require 'yaml'
-require 'json'
-
-module Liri
-  class Manager
-    class Setup
-      FILE_NAME = 'liri-config.yml'
-      TEMPLATE_PATH = File.join(File.dirname(File.dirname(File.dirname(__FILE__))), 'template/liri-config.yml')
-
-      def initialize(folder_path)
-        # Crea la carpeta en donde se guardarán los datos relativos a liri, ya sean archivos comprimidos,
-        # archivos descomprimidos, configuraciones, etc.
-        Dir.mkdir(folder_path) unless Dir.exist?(folder_path)
-
-        @file_path = File.join(folder_path, '/', FILE_NAME)
-      end
-
-      # Crea un archivo de configuración en la raiz del proyecto desde un template
-      def create
-        File.open(@file_path, "w") do |output_file|
-          File.foreach(TEMPLATE_PATH) do |input_line|
-            output_file.write(input_line)
-          end
-        end
-        true
-      end
-
-      # Retorna los datos del archivo de configuración
-      def load
-        if File.exist?(@file_path)
-          data = YAML.load(File.read(@file_path))
-          JSON.parse(data.to_json, object_class: OpenStruct)
-        else
-          raise Liri::FileNotFoundError.new(@file_path)
-        end
-      end
-
-      # Borra el archivo de configuración
-      def delete
-        if File.exist?(@file_path)
-          File.delete(@file_path)
-          true
-        else
-          false
-        end
-      end
-
-      def set(value, *keys)
-        data = YAML.load(File.read(@file_path))
-        keys = keys.first
-        aux = data
-        keys.each_with_index do |key, index|
-          if (keys[index + 1])
-            aux = data[key]
-          else
-            aux[key] = value
-          end
-        end
-        File.open(@file_path, 'w') { |f| f.write data.to_yaml }
-      end
-
-      def path
-        @file_path
-      end
-    end
-  end
-end

data/lib/manager/test_result.rb

@@ -1,38 +0,0 @@
-# Procesa el resultado de las pruebas unitarias
-module Liri
-  class Manager
-    class TestResult
-      def initialize
-        @example_quantity = 0
-        @failure_quantity = 0
-        @passed_quantity = 0
-      end
-      def update(test_result)
-        @example_quantity += test_result['example_quantity']
-        @failure_quantity += test_result['failure_quantity']
-        @passed_quantity += (@example_quantity - @failure_quantity)
-      end
-
-      def print_process(test_result)
-        passed_quantity = test_result['example_quantity'] - test_result['failure_quantity']
-        passed_quantity.times do
-          print '.'
-        end
-
-        test_result['failure_quantity'].times do
-          print 'F'
-        end
-      end
-
-      def print_summary
-        print_examples_and_failures
-      end
-
-      private
-
-      def print_examples_and_failures
-        puts "#{@example_quantity} examples, #{@failure_quantity} failures\n\n"
-      end
-    end
-  end
-end