liri 0.1.0 → 0.3.0

data/lib/agent/agent.rb

@@ -11,16 +11,19 @@ module Liri
     class << self
       # Inicia la ejecución del Agent
       # @param stop [Boolean] el valor true es para que no se ejecute infinitamente el método en el test unitario.
-      def run(stop = false)
-        Liri.create_folders('agent')
+      def run(work_folder_path, stop = false)
+        setup_manager = Liri.set_setup(work_folder_path)
+        agent_folder_path = setup_manager.agent_folder_path
 
-        Liri.set_logger(Liri::AGENT_LOGS_FOLDER_PATH, 'liri-agent.log')
+        Liri.set_logger(setup_manager.logs_folder_path, 'liri-agent.log')
         Liri.logger.info("Proceso Agent iniciado")
-        puts "Presione Ctrl + c para terminar el proceso Agent manualmente\n\n"
+        Liri.logger.info("Presione Ctrl + c para terminar el proceso Agent manualmente\n", true)
 
-        source_code = Liri::Common::SourceCode.new(Liri::AGENT_FOLDER_PATH, Liri.compression_class, Liri.unit_test_class)
-        runner = Liri::Agent::Runner.new(Liri.unit_test_class, source_code.decompressed_file_folder_path)
-        agent = Agent.new(Liri.udp_port, Liri.tcp_port, source_code, runner)
+        decompressed_source_code_path = File.join(agent_folder_path, '/', Common::SourceCode::DECOMPRESSED_FOLDER_NAME)
+        source_code = Common::SourceCode.new(decompressed_source_code_path, agent_folder_path, Liri.compression_class, Liri.unit_test_class)
+        runner = Agent::Runner.new(Liri.unit_test_class, source_code.decompressed_file_folder_path)
+        tests_result = Common::TestsResult.new(agent_folder_path)
+        agent = Agent.new(Liri.udp_port, Liri.tcp_port, source_code, runner, tests_result, agent_folder_path)
         threads = []
         threads << agent.start_server_socket_to_process_manager_connection_request # Esperar y procesar la petición de conexión del Manager
 
@@ -32,15 +35,20 @@ module Liri
       end
     end
 
-    def initialize(udp_port, tcp_port, source_code, runner)
+    def initialize(udp_port, tcp_port, source_code, runner, tests_result, agent_folder_path)
       @udp_port = udp_port
       @udp_socket = UDPSocket.new
       @tcp_port = tcp_port
 
       @source_code = source_code
       @runner = runner
+      @tests_result = tests_result
+
+      @all_tests = {}
 
       @managers = {}
+
+      @agent_folder_path = agent_folder_path
     end
 
     # Inicia un servidor udp que se mantiene en espera de la primera petición de conexión del Manager
@@ -62,48 +70,52 @@ module Liri
         loop do
           @manager_request = @udp_socket.recvfrom(1024)
           manager_ip_address = @manager_request.last.last
-          user, pass, dir = @manager_request.first.split(";")
-          process_manager_connection_request(manager_ip_address, user, pass, dir)
+          manager_data = get_manager_data(JSON.parse(@manager_request.first))
+          process_manager_connection_request(manager_ip_address, manager_data)
         end
       end
     end
 
     # Inicia un cliente tcp para responder a la petición broadcast del Manager para que éste sepa donde enviar las pruebas
-    def start_client_socket_to_process_tests(manager_ip_address)
+    def start_client_socket_to_process_tests(manager_ip_address, manager_data)
       tcp_socket = TCPSocket.open(manager_ip_address, @tcp_port)
 
-      Liri.logger.info("Se inicia una conexión con el Manager: #{manager_ip_address} en el puerto TCP: #{@tcp_port}
-                                     (Se establece una conexión para procesar la ejecución de las pruebas)
-      ")
+      agent_ip_address = tcp_socket.addr[2]
+
+      tcp_socket.puts({ msg: 'Listo' }) # Se envía un mensaje inicial al Manager
+
+      Liri.logger.info("Se inicia una conexión para procesar pruebas con el Manager: #{manager_ip_address} en el puerto TCP: #{@tcp_port}")
+      Liri.logger.info("\nConexión iniciada con el Manager: #{manager_ip_address}", true)
+
+      # En la siguiente línea se espera un puts desde el Manager, pero el Manager no lo hace
+      response = JSON.parse(tcp_socket.gets)
+      return unless response['exist_tests']
 
-      tcp_socket.print("Listo para ejecutar pruebas") # Se envía un mensaje inicial al Manager
-      puts "\nConexión iniciada con el Manager: #{manager_ip_address}"
+      get_source_code(manager_ip_address, manager_data)
 
-      # Se procesan las pruebas enviadds por el Manager
+      # Se procesan las pruebas enviadas por el Manager
       while line = tcp_socket.gets
         response = line.chop
         break if response == 'exit'
 
-        tests = JSON.parse(response)
-        Liri.logger.debug("Pruebas recibidas del Manager #{manager_ip_address}:")
-        Liri.logger.debug(tests)
+        tests_batch = JSON.parse(response)
+        tests = get_tests(tests_batch, manager_ip_address)
 
-        tests_result = @runner.run_tests(tests)
+        raw_tests_result = @runner.run_tests(tests)
 
-        json_tests_result = tests_result.to_json
-        Liri.logger.debug("Resultados de la ejecución de las pruebas recibidas del Manager #{manager_ip_address}:")
-        Liri.logger.debug(json_tests_result)
+        tests_batch_number = tests_batch['tests_batch_number']
+        tests_result_file_name = @tests_result.build_file_name(agent_ip_address, tests_batch_number)
+        tests_result_file_path = @tests_result.save(tests_result_file_name, raw_tests_result)
 
-        Liri.logger.info("
-                                       #{tests.size} pruebas recibidas, #{tests_result[:example_quantity]} pruebas ejecutadas
-        ")
-        tcp_socket.print(json_tests_result) # Este no logra enviar toda la información, porque? en cambio el cliente recibe un json grande sin problemas
+        send_tests_results_file(manager_ip_address, manager_data, tests_result_file_path)
+        result = { tests_batch_number: tests_batch_number, tests_result_file_name: tests_result_file_name, tests_batch_keys_size: tests_batch['tests_batch_keys'].size}
+        tcp_socket.puts(result.to_json) # Envía el número de lote y el nombre del archivo de resultados.
       end
 
       tcp_socket.close
-      Liri.logger.info("Se termina la conexión con el Manager #{manager_ip_address}")
+      Liri.logger.info("Se termina la conexión con el Manager #{manager_ip_address} en el puerto TCP: #{@tcp_port}")
 
-      Liri.clean_folder(Liri::AGENT_FOLDER_PATH)
+      Liri.clean_folder_content(@agent_folder_path)
 
       start_client_to_close_manager_server(manager_ip_address, 'Conexión Terminada')
       unregister_manager(manager_ip_address)
@@ -112,11 +124,11 @@ module Liri
     rescue Errno::ECONNRESET => e
       tcp_socket.close
       Liri.logger.error("Exception(#{e}) Conexión cerrada en el puerto TCP #{@tcp_port}")
-      Liri.logger.info("Se termina la conexión con el Manager #{manager_ip_address}")
+      Liri.logger.info("Se termina la conexión con el Manager #{manager_ip_address} en el puerto TCP: #{@tcp_port}")
       unregister_manager(manager_ip_address)
     rescue Errno::ECONNREFUSED => e
       Liri.logger.error("Exception(#{e}) Conexión rechazada en el puerto TCP #{@tcp_port}")
-      Liri.logger.info("Se termina la conexión con el Manager #{manager_ip_address}")
+      Liri.logger.info("Se termina la conexión con el Manager #{manager_ip_address} en el puerto TCP: #{@tcp_port}")
       unregister_manager(manager_ip_address)
     end
 
@@ -125,15 +137,15 @@ module Liri
     # Inserta el ip recibido dentro del hash si es que ya no existe en el hash
     # Nota: Se requieren imprimir datos para saber el estado de la aplicación, sería muy útil usar algo para logear
     # estas cosas en los diferentes niveles, debug, info, etc.
-    def process_manager_connection_request(manager_ip_address, user, pass, dir)
+    def process_manager_connection_request(manager_ip_address, manager_data)
       unless registered_manager?(manager_ip_address)
         register_manager(manager_ip_address)
         Liri.logger.info("Petición broadcast UDP recibida del Manager: #{manager_ip_address} en el puerto UDP: #{@udp_port}")
-        if process_manager_connection_scp(manager_ip_address, user, pass, dir)
-          start_client_socket_to_process_tests(manager_ip_address)
-        else
-          unregister_manager(manager_ip_address)
-        end
+        #if get_source_code(manager_ip_address, manager_data)
+          start_client_socket_to_process_tests(manager_ip_address, manager_data)
+        #else
+          #unregister_manager(manager_ip_address)
+        #end
       end
     end
 
@@ -141,27 +153,28 @@ module Liri
     # Esta conexión permitirá al Manager cerrar sus hilos pendientes con servidores TCP en espera y terminar el proceso
     def start_client_to_close_manager_server(manager_ip_address, msg)
       tcp_socket = TCPSocket.open(manager_ip_address, @tcp_port)
-      Liri.logger.info("Se termina cualquier proceso pendiente con el Manager #{manager_ip_address}")
-      tcp_socket.print({msg: msg}.to_json)
+      Liri.logger.info("Se termina cualquier proceso pendiente con el Manager #{manager_ip_address} en el puerto TCP: #{@tcp_port}")
+      tcp_socket.print({ msg: msg }.to_json)
       tcp_socket.close
     end
 
-    def process_manager_connection_scp(manager_ip_address, user, password, dir)
-      # puts "User: #{user} Password: #{password}"
+    def get_source_code(manager_ip_address, manager_data)
+      #puts "#{manager_data.to_h}"
       puts ''
-      Liri::Common::Benchmarking.start(start_msg: "Obteniendo código fuente. Espere... ") do
+      Liri::Common::Benchmarking.start(start_msg: "Obteniendo código fuente. Espere... ", stdout: true) do
         puts ''
-        Net::SCP.start(manager_ip_address, user, :password => password) do |scp|
-          scp.download!(dir, @source_code.compressed_file_folder_path)
+        Net::SCP.start(manager_ip_address, manager_data.user, password: manager_data.password) do |scp|
+          scp.download!(manager_data.compressed_file_path, @source_code.compressed_file_folder_path)
         end
       end
       puts ''
 
-      downloaded_file_name = dir.split('/').last
+      downloaded_file_name = manager_data.compressed_file_path.split('/').last
       downloaded_file_path = File.join(@source_code.compressed_file_folder_path, '/', downloaded_file_name)
 
-      Liri::Common::Benchmarking.start(start_msg: "Descomprimiendo código fuente. Espere... ") do
+      Liri::Common::Benchmarking.start(start_msg: "Descomprimiendo código fuente. Espere... ", stdout: true) do
         @source_code.decompress_file(downloaded_file_path)
+        @all_tests = @source_code.all_tests
       end
       puts ''
 
@@ -180,19 +193,19 @@ module Liri
         # Se setea la versión de ruby y el gemset para el código fuente descomprimido
         # Se especifica el Gemfile del cual se van a instalar los requerimientos
         # Esto se hace porque por defecto se usa la versión de Ruby de Liri y su Gemset y por ello hay que cambiarlos explicitamente aquí
-        Liri::Common::Benchmarking.start(start_msg: "Ejecutando bundle install. Espere... ", end_msg: "Ejecución de bundle install. Duración: ") do
+        Liri::Common::Benchmarking.start(start_msg: "Ejecutando bundle install. Espere... ", end_msg: "Ejecución de bundle install. Duración: ", stdout: true) do
           puts ''
           system("bash -lc 'rvm use #{Liri.current_folder_ruby_and_gemset}; BUNDLE_GEMFILE=Gemfile bundle install'")
         end
         puts ''
 
-        Liri::Common::Benchmarking.start(start_msg: "Ejecutando rake db:migrate RAILS_ENV=test. Espere... ", end_msg: "Ejecución de rake db:migrate RAILS_ENV=test. Duración: ") do
+        Liri::Common::Benchmarking.start(start_msg: "Ejecutando rake db:migrate RAILS_ENV=test. Espere... ", end_msg: "Ejecución de rake db:migrate RAILS_ENV=test. Duración: ", stdout: true) do
           puts ''
           system("bash -lc 'rvm use #{Liri.current_folder_ruby_and_gemset}; rake db:migrate RAILS_ENV=test'")
         end
         puts ''
 
-        #Liri::Common::Benchmarking.start(start_msg: "Ejecutando rake db:migrate:reset RAILS_ENV=test. Espere... ", end_msg: "Ejecución de rake db:migrate:reset RAILS_ENV=test. Duración: ") do
+        #Liri::Common::Benchmarking.start(start_msg: "Ejecutando rake db:migrate:reset RAILS_ENV=test. Espere... ", end_msg: "Ejecución de rake db:migrate:reset RAILS_ENV=test. Duración: ", stdout: true) do
         # puts ''
         # system("bash -lc 'rvm use #{Liri.current_folder_ruby_and_gemset}; rake db:migrate:reset RAILS_ENV=test'")
         #end
@@ -220,6 +233,34 @@ module Liri
       false
     end
 
+    def get_manager_data(manager_data_hash)
+      Common::ManagerData.new(
+        folder_path: manager_data_hash['folder_path'],
+        compressed_file_path: manager_data_hash['compressed_file_path'],
+        user: manager_data_hash['user'],
+        password: manager_data_hash['password']
+      )
+    end
+
+    def send_tests_results_file(manager_ip_address, manager_data, tests_result_file_path)
+      puts ''
+      Liri::Common::Benchmarking.start(start_msg: "Enviando archivo de resultados. Espere... ", stdout: true) do
+        Net::SCP.start(manager_ip_address, manager_data.user, password: manager_data.password) do |scp|
+          scp.upload!(tests_result_file_path, manager_data.folder_path)
+        end
+      end
+      puts ''
+    end
+
+    def get_tests(tests_batch, manager_ip_address)
+      # Se convierte "[5, 9, 13, 1]" a un arreglo [5, 9, 13, 1]
+      tests_keys = tests_batch['tests_batch_keys']
+      Liri.logger.debug("Claves de pruebas recibidas del Manager #{manager_ip_address}: #{tests_keys}")
+      # Se buscan obtienen los tests que coincidan con las claves recibidas de @all_tests = {1=>"spec/hash_spec.rb:2", 2=>"spec/hash_spec.rb:13", 3=>"spec/hash_spec.rb:24", ..., 29=>"spec/liri_spec.rb:62"}
+      # Se retorna un arreglo con los tests a ejecutar ["spec/liri_spec.rb:4", "spec/hash_spec.rb:5", "spec/hash_spec.rb:59", ..., "spec/hash_spec.rb:37"]
+      tests_keys.map { |test_key| @all_tests[test_key] }
+    end
+
     def registered_manager?(manager_ip_address)
       @managers[manager_ip_address]
     end

data/lib/agent/runner.rb

@@ -10,9 +10,7 @@ module Liri
       end
 
       def run_tests(tests)
-        result_hash = @unit_test.run_tests(tests.values)
-        result_hash[:test_keys] = tests.keys
-        result_hash
+        @unit_test.run_tests(tests)
       end
     end
   end

data/lib/all_libraries.rb

@@ -20,11 +20,13 @@ require 'agent/runner'
 
 require 'common/benchmarking'
 require 'common/log'
+require 'common/manager_data'
+require 'common/progressbar'
+require 'common/setup'
 require 'common/source_code'
 require 'common/compressor/zip'
 require 'common/unit_test/rspec'
+require 'common/tests_result'
 
 require 'manager/manager'
-require 'manager/setup'
 require 'manager/credential'
-require 'manager/test_result'

data/lib/common/benchmarking.rb

@@ -6,7 +6,7 @@
 # Este módulo se encarga de medir el tiempo de ejecución de algunos bloques de código
 
 require 'benchmark'
-require 'i18n' # requirimiento de la gema to_duration
+require 'i18n' # requerimiento de la gema to_duration
 require 'to_duration'
 
 # Se configura la ubicación del archivo de internacionalización de la gema to_duration
@@ -17,18 +17,13 @@ module Liri
   module Common
     module Benchmarking
       class << self
-        def start(start_msg: nil, end_msg: 'Duración: ')
-          print start_msg
+        def start(start_msg: nil, end_msg: 'Duración: ', stdout: true)
+          Liri.logger.info(start_msg, stdout)
           seconds = Benchmark.realtime do
             yield
           end
-          print_result(end_msg, seconds)
-        end
-
-        private
-
-        def print_result(msg, seconds)
-          print "#{msg}#{seconds.to_duration}"
+          Liri.logger.info("#{end_msg}#{seconds.to_duration}", stdout)
+          seconds
         end
       end
     end

data/lib/common/log.rb

@@ -26,32 +26,38 @@ module Liri
         create_file_logger
       end
 
-      def debug(text)
+      def debug(text, stdout = false)
+        puts(text) if stdout
         @stdout_logger.debug(text) if @stdout
         @file_logger.debug(text)
       end
 
-      def info(text)
+      def info(text, stdout = false)
+        puts(text) if stdout
         @stdout_logger.info(text) if @stdout
         @file_logger.info(text)
       end
 
-      def warn(text)
+      def warn(text, stdout = false)
+        puts(text) if stdout
         @stdout_logger.warn(text) if @stdout
         @file_logger.warn(text)
       end
 
-      def error(text)
+      def error(text, stdout = false)
+        puts(text) if stdout
         @stdout_logger.error(text) if @stdout
         @file_logger.error(text)
       end
 
-      def fatal(text)
+      def fatal(text, stdout = false)
+        puts(text) if stdout
         @stdout_logger.fatal(text) if @stdout
         @file_logger.fatal(text)
       end
 
-      def unknown(text)
+      def unknown(text, stdout = false)
+        puts(text) if stdout
         @stdout_logger.unknown(text) if @stdout
         @file_logger.unknown(text)
       end

data/lib/common/manager_data.rb

@@ -0,0 +1,30 @@
+# = manager_data.rb
+#
+# @author Rodrigo Fernández
+#
+# == Clase ManagerData
+
+module Liri
+  module Common
+    # Esta clase guarda los datos del Manager
+    class ManagerData
+      attr_accessor :folder_path, :compressed_file_path, :user, :password
+
+      def initialize(folder_path:, compressed_file_path:, user:, password:)
+        @folder_path = folder_path
+        @compressed_file_path = compressed_file_path
+        @user = user
+        @password = password
+      end
+
+      def to_h
+        {
+          folder_path: @folder_path,
+          compressed_file_path: @compressed_file_path,
+          user: @user,
+          password: @password
+        }
+      end
+    end
+  end
+end

data/lib/common/progressbar.rb

@@ -0,0 +1,29 @@
+# = progressbar.rb
+#
+# @author Rodrigo Fernández
+#
+# == Módulo Progressbar
+# Este módulo se encarga de mostrar una barra de progreso
+
+require 'ruby-progressbar'
+
+module Liri
+  module Common
+    module Progressbar
+      class << self
+        def start(params = {})
+          @compressing = true
+          progressbar = ProgressBar.create(params)
+          Thread.new do
+            while @compressing
+              progressbar.increment
+              sleep(0.1)
+            end
+          end
+          yield
+          @compressing = false
+        end
+      end
+    end
+  end
+end

data/lib/common/setup.rb

@@ -0,0 +1,103 @@
+=begin
+  Este modulo se encarga de manejar la configuración
+=end
+require 'yaml'
+require 'json'
+
+module Liri
+  module Common
+    class Setup
+      SETUP_FOLDER_NAME = 'liri'
+      SETUP_FILE_NAME = 'liri-config.yml'
+      TEMPLATE_PATH = File.join(File.dirname(File.dirname(File.dirname(__FILE__))), 'template/liri-config.yml')
+      LOGS_FOLDER_NAME = 'logs'
+      MANAGER_FOLDER_NAME = 'manager'
+      AGENT_FOLDER_NAME = 'agent'
+
+      attr_reader :setup_folder_path, :setup_file_path, :logs_folder_path, :manager_folder_path, :agent_folder_path
+
+      def initialize(destination_folder_path)
+        @setup_folder_path = File.join(destination_folder_path, '/', SETUP_FOLDER_NAME)
+        @setup_file_path = File.join(@setup_folder_path, '/', SETUP_FILE_NAME)
+        @logs_folder_path = File.join(@setup_folder_path, '/', LOGS_FOLDER_NAME)
+        @manager_folder_path = File.join(@setup_folder_path, '/', MANAGER_FOLDER_NAME)
+        @agent_folder_path = File.join(@setup_folder_path, '/', AGENT_FOLDER_NAME)
+      end
+
+      def init
+        create_folder(@setup_folder_path)
+        create_folder(@logs_folder_path)
+        create_folder(@manager_folder_path)
+        create_folder(@agent_folder_path)
+        create_setup_file
+      end
+
+      # Retorna los datos del archivo de configuración
+      def load
+        if File.exist?(@setup_file_path)
+          data = YAML.load(File.read(@setup_file_path))
+          JSON.parse(data.to_json, object_class: OpenStruct)
+        else
+          raise Liri::FileNotFoundError.new(@setup_file_path)
+        end
+      end
+
+      def set(value, *keys)
+        data = YAML.load(File.read(@setup_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(@setup_file_path, 'w') { |f| f.write data.to_yaml }
+      end
+
+      def create_folder(folder_path)
+        if Dir.exist?(folder_path)
+          false
+        else
+          Dir.mkdir(folder_path)
+          Dir.exist?(folder_path) ? true : false
+        end
+      end
+
+      def delete_setup_folder
+        if Dir.exist?(@setup_folder_path)
+          FileUtils.rm_rf(@setup_folder_path)
+          Dir.exist?(@setup_folder_path) ? false : true
+        else
+          false
+        end
+      end
+
+      # Crea un archivo de configuración en la raiz del proyecto desde un template
+      def create_setup_file
+        if File.exist?(@setup_file_path)
+          false
+        else
+          File.open(@setup_file_path, 'w') do |output_file|
+            File.foreach(TEMPLATE_PATH) do |input_line|
+              output_file.write(input_line)
+            end
+          end
+
+          File.exist?(@setup_file_path) ? true : false
+        end
+      end
+
+      # Borra el archivo de configuración
+      def delete_setup_file
+        if File.exist?(@setup_file_path)
+          File.delete(@setup_file_path)
+          File.exist?(@setup_file_path) ? false : true
+        else
+          false
+        end
+      end
+    end
+  end
+end

data/lib/common/source_code.rb

@@ -5,23 +5,23 @@
 module Liri
   module Common
     class SourceCode
-      FOLDER_PATH = Dir.pwd
-      FOLDER_NAME = FOLDER_PATH.split('/').last
       DECOMPRESSED_FOLDER_NAME = 'decompressed'
-      attr_reader :compressed_file_folder_path, :compressed_file_path, :decompressed_file_folder_path
+      attr_reader :folder_path, :compressed_file_folder_path, :compressed_file_path, :decompressed_file_folder_path
 
-      def initialize(compressed_file_folder_path, compression_class, unit_test_class)
+      def initialize(folder_path, compressed_file_folder_path, compression_class, unit_test_class)
+        @folder_path = folder_path
+        @folder_name = @folder_path.split('/').last
         @compressed_file_folder_path = compressed_file_folder_path
         @decompressed_file_folder_path = File.join(@compressed_file_folder_path, '/', DECOMPRESSED_FOLDER_NAME)
-        @compressed_file_path = File.join(@compressed_file_folder_path, '/', "#{FOLDER_NAME}.zip")
+        @compressed_file_path = File.join(@compressed_file_folder_path, '/', "#{@folder_name}.zip")
         # Inicializa un compresor acorde a compression_class, la siguiente línea en realidad hace lo siguiente:
         # @compressor = Liri::Common::Compressor::Zip.new(input_dir, output_file)
         # compression_class en este caso es Zip pero podría ser otro si existiera la implementación, por ejemplo Rar
-        @compressor = Object.const_get(compression_class).new(FOLDER_PATH, @compressed_file_path)
+        @compressor = Object.const_get(compression_class).new(@folder_path, @compressed_file_path)
         # Inicializa un ejecutor de pruebas acorde a unit_test_class, la siguiente línea en realidad hace lo siguiente:
         # @unit_test = Liri::Common::UnitTest::Rspec.new(source_code_folder_path)
         # unit_test_class en este caso es Rspec pero podría ser otro si existiera la implementación, por ejemplo UnitTest
-        @unit_test = Object.const_get(unit_test_class).new(FOLDER_PATH)
+        @unit_test = Object.const_get(unit_test_class).new(@folder_path)
       end
 
       def compress_folder
@@ -29,7 +29,12 @@ module Liri
       end
 
       def decompress_file(compressed_file_path = @compressed_file_path)
-        @compressor.decompress(compressed_file_path, @decompressed_file_folder_path)
+        if File.exist?(compressed_file_path)
+          @compressor.decompress(compressed_file_path, @decompressed_file_folder_path)
+          Dir.exist?(@decompressed_file_folder_path) ? true : false
+        else
+          raise FileNotFoundError, compressed_file_path
+        end
       end
 
       def delete_compressed_file
@@ -41,12 +46,17 @@ module Liri
         end
       end
 
-      def all_tests
-        @unit_test.all_tests
+      def delete_decompressed_file_folder_path
+        if Dir.exist?(@decompressed_file_folder_path)
+          FileUtils.rm_rf(@decompressed_file_folder_path)
+          Dir.exist?(@decompressed_file_folder_path) ? false : true
+        else
+          false
+        end
       end
 
-      def folder_path
-        FOLDER_PATH
+      def all_tests
+        @unit_test.all_tests
       end
     end
   end