proxy_tester 0.0.1 → 0.0.2

data/lib/proxy_tester/actions/clear_environment.rb

@@ -0,0 +1,21 @@
+# encoding: utf-8
+module ProxyTester
+  module Actions
+    class ClearEnvironment
+
+      private
+
+      attr_reader :variables
+
+      public
+
+      def initialize(options = {})
+        @variables = options.fetch(:variables, %w{ http_proxy https_proxy HTTP_PROXY HTTPS_PROXY })
+      end
+
+      def run
+        variables.each { |var| ENV.delete(var) }
+      end
+    end
+  end
+end

data/lib/proxy_tester/actions/fetch_urls.rb

@@ -0,0 +1,94 @@
+# encoding: utf-8
+module ProxyTester
+  module Actions
+    class FetchUrls
+
+      private
+
+      attr_reader :urls, :proxy, :timeout, :count, :result, :reporter, :concurrent, :output
+
+      public
+
+      def initialize(options = {})
+        @urls   = options.fetch(:urls).collect { |u| Addressable::URI.heuristic_parse(u).to_s }
+        @proxy = options.fetch(:proxy)
+        @timeout  = options.fetch(:timeout).to_i
+        @count = options.fetch(:count).to_i
+        @concurrent = options.fetch(:concurrent)
+        
+        ProxyTester.ui_logger.debug "Options: " + options.to_s
+
+        @output   =  options.fetch(:output)
+        @reporter = options.fetch(:reporter, Reporters::FetchUrls.new(output))
+
+        @result = []
+      end
+
+      def run
+        threads = []
+
+        reporter.header
+
+        urls.each do |u|
+          count.times do |n|
+            threads << Thread.new do
+              ProxyTester.ui_logger.info "Starting #{n + 1}-nth thread to fetch \"#{u}\" via \"#{proxy.to_string}\"."
+
+              begin 
+                fetch_url(u)
+              end while concurrent
+            end
+          end
+        end
+
+
+        sleep_time = 0
+        while sleep_time < timeout and threads.any? { |t| t.alive? }
+          sleep 1
+          sleep_time += 1
+        end
+
+        if sleep_time < timeout
+          ProxyTester.ui_logger.info "All threads finished before waiting time \"#{timeout}\" was over."
+        else
+          ProxyTester.ui_logger.info "Waiting time #{timeout} is over. Killing all active threads..."
+        end
+
+        threads.each do |t|
+          Thread.kill(t)
+        end
+
+      end
+
+      private
+
+      def fetch_url(url)
+        begin
+          response = Excon.get(url, 
+                               proxy: proxy.to_string(cleartext: true),
+                               middlewares: Excon.defaults[:middlewares] + [Excon::Middleware::RedirectFollower],
+                               read_timeout: timeout,
+                               write_timeout: timeout,
+                               headers: {
+                                 'User-Agent' => 'ProxyTester',
+                               }
+                              )
+        rescue Excon::Errors::SocketError
+          handler = ErrorHandler.find(Exceptions::ProxyNotReachable)
+          handler.use(host: proxy.host, port: proxy.port)
+
+          ProxyTester.ui_logger.fatal handler.details
+
+          raise Exceptions::ProxyNotReachable, JSON.dump(host: proxy.port, port: proxy.port)
+        end
+
+        reporter.data(
+          headers: response.headers,
+          status: response.status,
+          url: u,
+          proxy: proxy.to_string,
+        )
+      end
+    end
+  end
+end

data/lib/proxy_tester/actions/handle_error.rb

@@ -5,19 +5,23 @@ module ProxyTester
 
       private
 
-      attr_reader :exception, :original_message, :handler_klass
+      attr_reader :handler_klass, :exception
 
       public
 
       def initialize(exception, handler_klass = ErrorHandler)
-        @exception        = exception.class
-        @original_message = exception.message
-        @handler_klass    = handler_klass
+        @exception     = exception
+        @handler_klass = handler_klass
       end
 
       def run
         handler = handler_klass.find exception
-        handler.original_message = original_message
+
+        if exception.respond_to? :cause
+          handler.cause = exception.cause
+        else
+          handler.cause = exception
+        end
 
         handler.execute(parsed_message)
       end
@@ -25,7 +29,7 @@ module ProxyTester
       private
 
       def parsed_message
-        result = JSON.parse(original_message)
+        result = JSON.parse(exception.message)
         return {} unless result.kind_of? Hash
 
         result

data/lib/proxy_tester/capybara_proxy.rb

@@ -48,7 +48,7 @@ module ProxyTester
     end
 
     def user_string
-      user.to_string.shellescape
+      user.to_string(cleartext: true).shellescape
     end
   end
 end

data/lib/proxy_tester/cli/main.rb

@@ -7,10 +7,14 @@ module ProxyTester
       class_option :debug_mode, type: :boolean, desc: 'Run application in debug mode'
 
       desc 'test', 'Run tests'
+      subcommand 'test', Cli::Test
+
+      desc 'add SOURCE', 'Add new testcases by cloning them via vcs'
+      option :force, type: :boolean, default: false, desc: 'Overwrite existing files?'
       option :test_cases_directory, type: :string, desc: 'Directory with test cases'
-      option :tags, type: :array, desc: 'Filter tests based on tags'
-      def test
+      def add(source)
         ProxyTester.config = ProxyTester::Config.new(options[:config_file]) if options[:config_file]
+
         ProxyTester.config.log_level            = options[:log_level] if options[:log_level]
         ProxyTester.config.debug_mode           = options[:debug_mode] if options[:debug_mode]
         ProxyTester.config.test_cases_directory = options[:test_cases_directory] if options[:test_cases_directory]
@@ -19,7 +23,10 @@ module ProxyTester
         ProxyTester.ui_logger.level = ProxyTester.config.log_level
         ProxyTester.enable_debug_mode if ProxyTester.config.debug_mode
 
-        ProxyTester::RspecRunner.new.run(options[:tags])
+        ProxyTester.ui_logger.debug('Options: ' + options.to_s)
+        ProxyTester.ui_logger.debug("Config:\n" + ProxyTester.config.to_s)
+
+        Actions::AddTestCase.new(RemoteRepository.new(source), ProxyTester.config.test_cases_directory, force: options[:force]).run
       end
 
       desc 'init', 'Create files/directories to use proxy_tester'

data/lib/proxy_tester/cli/test.rb

@@ -0,0 +1,79 @@
+# encoding
+module ProxyTester
+  module Cli
+    class Test < Thor
+      desc 'rspec', 'Run rspec tests'
+      option :test_cases_directory, type: :string, desc: 'Directory with test cases'
+      option :tags, type: :array, desc: 'Filter tests based on tags'
+      def rspec
+        ProxyTester.config = ProxyTester::Config.new(options[:config_file]) if options[:config_file]
+        ProxyTester.config.log_level            = options[:log_level] if options[:log_level]
+        ProxyTester.config.debug_mode           = options[:debug_mode] if options[:debug_mode]
+        ProxyTester.config.test_cases_directory = options[:test_cases_directory] if options[:test_cases_directory]
+        ProxyTester.config.lock
+
+        ProxyTester.ui_logger.level = ProxyTester.config.log_level
+        ProxyTester.enable_debug_mode if ProxyTester.config.debug_mode
+
+        ProxyTester::RspecRunner.new.run(options[:tags])
+      end
+
+      desc 'url', 'Fetch url'
+      option :count, type: :numeric, desc: 'Number of requests', default: 10
+      option :timeout, type: :numeric, desc: 'Wait n seconds before kill children', default: 60
+      option :proxy, type: :array, desc: 'System(s) under test', required: true
+      option :user, type: :string, desc: 'User for authentication', default: ENV['USER']
+      option :log_level, type: :string, desc: 'Log level'
+      option :concurrent, type: :boolean, desc: 'Simulate concurrent requests', default: false
+      option :output, type: :string, desc: 'Write output to file'
+      def url(*urls)
+        ProxyTester.config = ProxyTester::Config.new(options[:config_file]) if options[:config_file]
+        ProxyTester.config.log_level            = options[:log_level] if options[:log_level]
+        ProxyTester.config.debug_mode           = options[:debug_mode] if options[:debug_mode]
+        ProxyTester.config.lock
+
+        ProxyTester.ui_logger.level = ProxyTester.config.log_level
+        ProxyTester.enable_debug_mode if ProxyTester.config.debug_mode
+
+        proxies = options[:proxy].collect { |p| HttpProxy.new(p) }
+
+        unless options[:user].blank?
+          user = User.new
+          user.name = options[:user]
+
+          while user.password.blank?
+            user.password = HighLine.new.ask("Enter password for proxy user \"#{user.name}\": ") { |q| q.echo = '*' }
+          end
+
+          puts ''
+
+          proxies.each { |p| p.use_user user }
+        end
+
+        output = options.fetch(:output, $stdout)
+        if output.kind_of? String
+          output = File.open(output, 'w')
+        else
+          output = $stdout
+        end
+
+        Actions::ClearEnvironment.new.run
+
+        proxies.each do |p|
+          ProxyTester.ui_logger.debug "Using proxy \"#{p.to_string}\""
+          ProxyTester.ui_logger.debug "Using user \"#{user.to_string}\""
+
+          action = Actions::FetchUrls.new( urls: urls,
+                                          timeout: options[:timeout],
+                                          count: options[:count],
+                                          proxy: p,
+                                          concurrent: options[:concurrent],
+                                          output: output,
+                                         )
+          action.run
+        end
+      end
+
+    end
+  end
+end

data/lib/proxy_tester/config.rb

@@ -27,7 +27,7 @@ module ProxyTester
           begin
             config[option.to_sym] = value
           rescue RuntimeError
-            raise Exceptions::ConfigLocked
+            raise Exceptions::ConfigLocked, JSON.dump(option: option)
           end
         end
 

data/lib/proxy_tester/error_handler.rb

@@ -16,7 +16,7 @@ module ProxyTester
     public
 
     attr_reader :exception
-    attr_accessor :original_message
+    attr_accessor :cause 
 
     def initialize(options = {})
       @exception    = options.fetch(:exception)
@@ -36,7 +36,7 @@ module ProxyTester
       end
 
       def find(exception)
-        handlers.find(proc { default_handler }) { |h| h.exception == exception }
+        handlers.find(proc { default_handler }) { |h| h.exception == exception.class }
       end
 
       private
@@ -44,7 +44,7 @@ module ProxyTester
       def default_handler
         mutex.synchronize do
           @default_handler ||= new(
-            exception: StandardError,
+            exception: Exceptions::DefaultError,
             details: 'errors.default.details',
             summary: 'errors.default.summary',
             exit_code: 99,
@@ -76,17 +76,26 @@ module ProxyTester
     end
 
     def use(data)
-      data = JSON.parse(data).symbolize_keys if data.kind_of? String
+      data = JSON.parse(data) if data.kind_of? String
+      data = data.symbolize_keys 
 
-      @details = I18n.t(details_i18n, data)
-      @summary = I18n.t(summary_i18n, data)
+      @details ||= I18n.t(details_i18n, data)
+      @summary ||= I18n.t(summary_i18n, data)
     end
 
     def execute(data = {})
       use(data)
 
       ProxyTester.ui_logger.fatal details
-      ProxyTester.ui_logger.debug original_message if original_message
+      ProxyTester.ui_logger.debug "Resulting Exception: #{exception}"
+      ProxyTester.ui_logger.debug "Resulting Exit Code: #{exit_code}"
+
+      if cause
+        ProxyTester.ui_logger.debug "Cause: #{cause.class}"
+        ProxyTester.ui_logger.debug "Cause Message: #{cause.message}"
+        ProxyTester.ui_logger.debug "Cause Backtrace:\n" + Array(cause.backtrace).join("\n")
+      end
+
       Kernel.exit exit_code
     end
 

data/lib/proxy_tester/error_messages.rb

@@ -3,7 +3,7 @@ module ProxyTester
   module ErrorMessages
 
     ErrorHandler.create(
-      exception: StandardError,
+      exception: Exceptions::DefaultError,
       summary: 'errors.default.summary',
       details: 'errors.default.details',
       exit_code: 99,
@@ -69,14 +69,56 @@ module ProxyTester
       exception: Exceptions::PacResultInvalid,
       details: 'errors.invalid_pac_result.details',
       summary: 'errors.invalid_pac_result.summary',
-      exit_code: 19,
+      exit_code: 9,
     )
 
     ErrorHandler.create(
       exception: Exceptions::ProxyTypeInvalid,
       details: 'errors.invalid_proxy_type.details',
       summary: 'errors.invalid_proxy_type.summary',
-      exit_code: 19,
+      exit_code: 10,
+    )
+
+    ErrorHandler.create(
+      exception: Exceptions::ProxyConnectionStringInvalid,
+      details: 'errors.invalid_proxy_connection_string.details',
+      summary: 'errors.invalid_proxy_connection_string.summary',
+      exit_code: 11,
+    )
+
+    ErrorHandler.create(
+      exception: Interrupt,
+      details: 'errors.sigint.details',
+      summary: 'errors.sigint.summary',
+      exit_code: 12,
+    )
+
+    ErrorHandler.create(
+      exception: Exceptions::SIGTERM,
+      details: 'errors.sigterm.details',
+      summary: 'errors.sigterm.summary',
+      exit_code: 13,
+    )
+
+    ErrorHandler.create(
+      exception: Exceptions::ProxyNotReachable,
+      details: 'errors.unreachable_proxy.details',
+      summary: 'errors.unreachable_proxy.summary',
+      exit_code: 14,
+    )
+
+    ErrorHandler.create(
+      exception: Exceptions::RepositoryDoesNotExist,
+      details: 'errors.unexisting_repository.details',
+      summary: 'errors.unexisting_repository.summary',
+      exit_code: 15,
+    )
+
+    ErrorHandler.create(
+      exception: Exceptions::RepositoryInvalid,
+      details: 'errors.invalid_repository.details',
+      summary: 'errors.invalid_repository.summary',
+      exit_code: 16,
     )
   end
 end

data/lib/proxy_tester/exceptions.rb

@@ -2,11 +2,28 @@
 module ProxyTester
   # Exceptions
   module Exceptions
+    # my standard error
+    if RUBY_VERSION < "2.1"
+      class MyStandardError < StandardError
+        attr_reader :cause
+
+        def initialize(msg, cause = $!)
+          super(msg)
+          @cause = cause;
+        end
+      end
+    else
+      class MyStandardError < StandardError; end
+    end
+
     # raised if user error occurred
-    class UserError < StandardError; end
+    class UserError < MyStandardError; end
+
+    # raised if an internal error occurred
+    class InternalError < MyStandardError; end
 
     # raised if an internal error occurred
-    class InternalError < StandardError; end
+    class DefaultError < MyStandardError; end
 
     # raised if config file does not exist
     class ConfigFileNotReadable < UserError; end
@@ -26,6 +43,9 @@ module ProxyTester
     # raised if repository does not exist
     class RepositoryDoesNotExist < UserError; end
 
+    # raised if repository is not a supported vcs repository
+    class RepositoryInvalid < UserError; end
+
     # raised if proxy user does not exist
     class ProxyUserInvalid < UserError; end
 
@@ -49,5 +69,14 @@ module ProxyTester
 
     # raised if chosen proxy type is invalid
     class ProxyTypeInvalid < UserError; end
+
+    # raised if chosen proxy connection string is invalid
+    class ProxyConnectionStringInvalid< UserError; end
+
+    # raised if program was killed with SIGTERM
+    class SIGTERM < UserError; end
+
+    # raised if proxy is not reachable
+    class ProxyNotReachable < UserError; end
   end
 end