proxy_tester 0.0.1

data/lib/proxy_tester/config.rb

@@ -0,0 +1,100 @@
+# encoding: utf-8
+module ProxyTester
+  class Config
+
+    private
+
+    attr_reader :config
+
+    @options = Set.new
+
+    class << self
+
+      public
+
+      attr_reader :options
+
+      def option_reader(option, default_value)
+        define_method option.to_sym do
+          config.fetch(option.to_sym, default_value)
+        end
+
+        @options << option
+      end
+
+      def option_writer(option)
+        define_method "#{option}=".to_sym do |value|
+          begin
+            config[option.to_sym] = value
+          rescue RuntimeError
+            raise Exceptions::ConfigLocked
+          end
+        end
+
+        @options << option
+      end
+
+      def option(option, default_value)
+        option_reader(option, default_value)
+        option_writer(option)
+      end
+    end
+
+    public
+
+    def initialize(file = available_config_file, config_engine = Psych)
+      config_mutex = Mutex.new
+      config_mutex.synchronize do
+        yaml = Psych.load_file(file)
+
+        if yaml.respond_to? :[]
+          @config = yaml.symbolize_keys
+        else
+          @config = {}
+        end
+      end
+    rescue StandardError => e
+      fail Exceptions::ConfigFileNotReadable, JSON.dump(message: e.message, file: file)
+    end
+
+    def lock
+      config.freeze
+    end
+
+    def to_s
+      result = []
+      result << sprintf("%20s | %s", 'option', 'value')
+      result << sprintf("%s + %s", '-' * 20, '-' * 80)
+
+      Config.options.each do |o|
+        result << sprintf("%20s | %s", o, Array(public_send(o)).join(', '))
+      end
+
+      result.join("\n")
+    end
+
+    def allowed_config_file_paths
+      [
+        ::File.expand_path(::File.join(ENV['HOME'], '.config', 'proxy_tester', 'config.yaml')),
+        ::File.expand_path(::File.join(ENV['HOME'], '.proxy_tester', 'config.yaml')),
+        ::File.expand_path(::File.join('/etc', 'proxy_tester', 'config.yaml')),
+        ::File.expand_path('../../../files/config.yaml', __FILE__),
+      ]
+    end
+
+    option :config_file, ::File.expand_path(::File.join(ENV['HOME'], '.config', 'proxy_tester', 'config.yaml'))
+    option :user_file, ::File.expand_path(::File.join(ENV['HOME'], '.config', 'proxy_tester', 'user.csv'))
+    option :test_cases_directory, ::File.expand_path(::File.join(ENV['HOME'], '.config', 'proxy_tester', 'test_cases.d'))
+    option :debug_mode, false
+    option :log_level, :info
+    option :examples_directory, ::File.expand_path(::File.join(ENV['HOME'], '.config', 'proxy_tester', 'test_cases.d', 'examples'))
+    option :reports_directory, ::File.expand_path(::File.join(ENV['HOME'], '.local', 'share', 'proxy_tester', 'reports.d'))
+
+    private
+
+    def available_config_file
+      allowed_config_file_paths.find { |f| ::File.exists? f }
+    end
+
+  end
+end

data/lib/proxy_tester/data.rb

@@ -0,0 +1,23 @@
+module ProxyTester
+  class Data
+    private
+
+    attr_reader :config
+
+    public
+
+    def initialize(config = ProxyTester.config)
+      @config = config
+    end
+
+    def instance_binding
+      binding
+    end
+
+    def lookup(variable)
+      config.public_send variable.to_sym
+    rescue NoMethodError
+      fail "Variable \"#{variable}\" not found."
+    end
+  end
+end

data/lib/proxy_tester/database_session.rb

@@ -0,0 +1,15 @@
+module ProxyTester
+  class DatabaseSession
+    def initialize
+      database = ':memory:'
+      #database = File.expand_path('../../../tmp/database.db', __FILE__)
+
+      FileUtils.rm database if database != ':memory:' and File.exists?( database)
+
+      ActiveRecord::Base.establish_connection adapter: 'sqlite3', database: database
+      silence :stdout do
+        ActiveRecord::Migrator.up File.expand_path( '../../../db/migrate', __FILE__ )
+      end
+    end
+  end
+end

data/lib/proxy_tester/environment.rb

@@ -0,0 +1,21 @@
+# encoding: utf-8
+module ProxyTester
+  class Environment
+
+    private
+
+    attr_reader :stdin, :stderr
+
+    public
+
+    def initialize(stdin = $stdin, stderr = $stderr)
+      @stdin  = stdin
+      @stderr = stderr
+    end
+
+    def password
+      stderr.printf "Please enter password: "
+      @password = stdin.readline.chomp
+    end
+  end
+end

data/lib/proxy_tester/erb_generator.rb

@@ -0,0 +1,34 @@
+# encoding: utf-8
+module ProxyTester
+  # Used to generate the template
+  class ErbGenerator
+    private
+
+    attr_reader :data
+
+    public
+
+    # Create erb generator
+    #
+    # @param [Data] data
+    # The data class to be used within the template
+    def initialize(data)
+      @data = data
+    end
+
+    # Compile the template
+    #
+    # @param [IO] source
+    # The source template to be used
+    # @param [IO] destination
+    # The output io handle
+    def compile(source, destination)
+      erb = ERB.new(source.read, nil, '-')
+      begin
+        destination.puts erb.result(data.instance_binding)
+      rescue SyntaxError => e
+        raise Exceptions::ErbTemplateHasSyntaxErrors, e.message
+      end
+    end
+  end
+end

data/lib/proxy_tester/error_handler.rb

@@ -0,0 +1,107 @@
+# encoding: utf-8
+module ProxyTester
+  class ErrorHandler
+
+    @handlers = []
+    @mutex    = Mutex.new
+
+    class << self
+      attr_reader :handlers, :mutex
+    end
+
+    private
+
+    attr_reader :details_i18n, :summary_i18n, :exit_code
+
+    public
+
+    attr_reader :exception
+    attr_accessor :original_message
+
+    def initialize(options = {})
+      @exception    = options.fetch(:exception)
+      @details_i18n = options.fetch(:details)
+      @summary_i18n = options.fetch(:summary)
+      @exit_code    = options.fetch(:exit_code)
+    rescue KeyError => e
+      raise ArgumentError, e.message
+    end
+
+    class << self
+      def create(options = {}, &block)
+        handler = new(options, &block)
+        handlers << handler
+
+        handler
+      end
+
+      def find(exception)
+        handlers.find(proc { default_handler }) { |h| h.exception == exception }
+      end
+
+      private
+
+      def default_handler
+        mutex.synchronize do
+          @default_handler ||= new(
+            exception: StandardError,
+            details: 'errors.default.details',
+            summary: 'errors.default.summary',
+            exit_code: 99,
+          )
+        end
+      end
+    end
+
+    def details(format = :plain)
+      case format
+      when :plain
+        @details
+      when :html
+        Rack::Utils.escape_html(@details)
+      else
+        @details
+      end
+    end
+
+    def summary(format = :plain)
+      case format
+      when :plain
+        @summary
+      when :html
+        Rack::Utils.escape_html(@summary)
+      else
+        @summary
+      end
+    end
+
+    def use(data)
+      data = JSON.parse(data).symbolize_keys if data.kind_of? String
+
+      @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
+      Kernel.exit exit_code
+    end
+
+    def to_json
+      ErrorHandler.mutex.synchronize do
+        @details ||= I18n.t(details_i18n)
+        @summary ||= I18n.t(summary_i18n)
+      end
+
+      JSON.dump(
+          error_summary: summary,
+          error_details: details,
+          result: :failure,
+      )
+    end
+
+  end
+end

data/lib/proxy_tester/error_messages.rb

@@ -0,0 +1,82 @@
+# encoding: utf-8
+module ProxyTester
+  module ErrorMessages
+
+    ErrorHandler.create(
+      exception: StandardError,
+      summary: 'errors.default.summary',
+      details: 'errors.default.details',
+      exit_code: 99,
+    )
+
+    ErrorHandler.create(
+      exception: Exceptions::InternalError,
+      details: 'errors.internal_error.details',
+      summary: 'errors.internal_error.summary',
+      exit_code: 1,
+    )
+    
+    ErrorHandler.create(
+      exception: Exceptions::ConfigFileNotReadable,
+      details: 'errors.unreadable_config_file.details',
+      summary: 'errors.unreadable_config_file.summary',
+      exit_code: 2,
+    )
+
+    ErrorHandler.create(
+      exception: Exceptions::UserError,
+      details: 'errors.user_error.details',
+      summary: 'errors.user_error.summary',
+      exit_code: 3,
+    )
+
+    ErrorHandler.create(
+      exception: Exceptions::UserRecordInvalid,
+      details: 'errors.invalid_user_record.details',
+      summary: 'errors.invalid_user_record.summary',
+      exit_code: 4,
+    )
+
+    ErrorHandler.create(
+      exception: Exceptions::UserFileNotFound,
+      details: 'errors.unreadable_user_file.details',
+      summary: 'errors.unreadable_user_file.summary',
+      exit_code: 5,
+    )
+
+    ErrorHandler.create(
+      exception: Exceptions::FetchUrlTimeout,
+      details: 'errors.request_timeout.details',
+      summary: 'errors.request_timeout.summary',
+      exit_code: 6,
+    )
+
+    ErrorHandler.create(
+      exception: Exceptions::SyntaxInvalid,
+      details: 'errors.invalid_syntax.details',
+      summary: 'errors.invalid_syntax.summary',
+      exit_code: 7,
+    )
+
+    ErrorHandler.create(
+      exception: Exceptions::PacFileNotFound,
+      details: 'errors.not_found_pac_file.details',
+      summary: 'errors.not_found_pac_file.summary',
+      exit_code: 8,
+    )
+
+    ErrorHandler.create(
+      exception: Exceptions::PacResultInvalid,
+      details: 'errors.invalid_pac_result.details',
+      summary: 'errors.invalid_pac_result.summary',
+      exit_code: 19,
+    )
+
+    ErrorHandler.create(
+      exception: Exceptions::ProxyTypeInvalid,
+      details: 'errors.invalid_proxy_type.details',
+      summary: 'errors.invalid_proxy_type.summary',
+      exit_code: 19,
+    )
+  end
+end

data/lib/proxy_tester/exceptions.rb

@@ -0,0 +1,53 @@
+# encoding: utf-8
+module ProxyTester
+  # Exceptions
+  module Exceptions
+    # raised if user error occurred
+    class UserError < StandardError; end
+
+    # raised if an internal error occurred
+    class InternalError < StandardError; end
+
+    # raised if config file does not exist
+    class ConfigFileNotReadable < UserError; end
+
+    # raised if one tries to access a lockec config 
+    class ConfigLocked < UserError; end
+
+    # raise if there are template syntax errrors
+    class ErbTemplateHasSyntaxErrors < InternalError; end
+
+    # raised if Template does not exist
+    class ErbTemplateIsUnknown < InternalError; end
+
+    # raised if commit does not exist
+    class CommitDoesNotExist < InternalError; end
+
+    # raised if repository does not exist
+    class RepositoryDoesNotExist < UserError; end
+
+    # raised if proxy user does not exist
+    class ProxyUserInvalid < UserError; end
+
+    # raised if proxy user record is invalid (missing name, password)
+    class UserRecordInvalid < UserError; end
+
+    # raised if user file not found 
+    class UserFileNotFound < UserError; end
+
+    # raised if user file not found 
+    class SyntaxInvalid < UserError; end
+
+    # raised if pac file not found 
+    class PacFileNotFound < UserError; end
+
+    # raised if pac result is invalid
+    class PacResultInvalid < UserError; end
+
+    # raised if pac result is invalid
+    class FetchUrlTimeout < UserError; end
+
+    # raised if chosen proxy type is invalid
+    class ProxyTypeInvalid < UserError; end
+  end
+end

data/lib/proxy_tester/git_file.rb

@@ -0,0 +1,31 @@
+# encoding: utf-8
+module ProxyTester
+  class GitFile
+    private
+
+    attr_reader :extension
+
+    public
+
+    attr_reader :path, :name, :content
+
+    def initialize(path, content = '')
+      @path      = path
+      @extension = ::File.extname(path)
+      @name      = path.sub(/\.[^.]+$/, '').gsub(%r{/}, '::').downcase.to_sym
+      @content   = content
+    end
+
+    def nil?
+      false
+    end
+
+    def extension?(ext)
+      extension == ext
+    end
+
+    def prepare(handler)
+      handler.prepare(self)
+    end
+  end
+end

data/lib/proxy_tester/git_null_file.rb

@@ -0,0 +1,32 @@
+# encoding: utf-8
+module ProxyTester
+  class GitNullFile
+    def path
+      nil
+    end
+
+    def extension
+      nil
+    end
+
+    def name
+      nil
+    end
+
+    def content
+      nil
+    end
+
+    def compressed_content=(val)
+      nil
+    end
+
+    def prepare(val)
+      nil
+    end
+
+    def nil?
+      true
+    end
+  end
+end

data/lib/proxy_tester/git_repository.rb

@@ -0,0 +1,120 @@
+# encoding: utf-8
+module ProxyTester
+  class GitRepository
+    private
+
+    attr_reader :repository, :root_commit, :null_file, :file_creator
+
+    public
+
+    attr_reader :storage_path
+
+    def initialize(storage_path, file_creator = ProxyTester::GitFile, null_file = ProxyTester::GitNullFile.new)
+      @storage_path = ::File.expand_path(storage_path)
+      @repository   = Rugged::Repository.new(storage_path)
+      @file_creator = file_creator
+      @null_file    = null_file
+
+    rescue Rugged::RepositoryError
+      raise Exceptions::RepositoryDoesNotExist, "Sorry, but #{storage_path} is not a git repository."
+    end
+
+    def self.create(storage_path) 
+      storage_path = ::File.expand_path(storage_path)
+      Rugged::Repository.init_at(storage_path, :bare)
+
+      new(storage_path)
+    end
+
+    def self.clone(source, destination, options =  {})
+      bare = options.fetch(:bare, false)
+
+      source = Addressable::URI.heuristic_parse(::File.expand_path(source))
+      if source.scheme.blank?
+        source.scheme = 'file'
+        source.authority = ''
+      end
+      source = source.to_s
+
+      destination = ::File.expand_path(destination)
+
+      if bare
+        Rugged::Repository.clone_at(source, destination, bare: true)
+      else
+        Rugged::Repository.clone_at(source, destination)
+      end
+
+      new(destination)
+    end
+
+    def add_content(path, content = '', mode = 0100644, commit_info = default_commit_info)
+      index = Rugged::Index.new
+
+      unless repository.empty? 
+        root_commit  = repository.lookup(repository.head.target)
+
+        root_commit.tree.walk_blobs(:postorder) do |r, e| 
+          e.merge!( { path: "#{r}#{e[:name]}" } )
+          e.delete(:name)
+
+          index.add(e)
+        end
+      end
+
+      oid = repository.write(content, :blob)
+      index.add(:path => path, :oid => oid, :mode => mode)
+
+      options              = {}
+      options[:tree]       = index.write_tree(repository)
+      options[:parents]    = repository.empty? ? [] : [ repository.head.target ].compact
+      options[:update_ref] = 'HEAD'
+      options.merge! commit_info
+
+      Rugged::Commit.create(repository, options)
+    end
+
+    def find_file(name)
+      files.fetch(name, null_file)
+    end
+
+    def all_files
+      files.collect { |_,f| f }
+    end
+
+    def each_file(&block)
+      all_files.each(&block)
+    end
+
+    private
+
+    def files
+      files_in_repository.reduce({}) do |memo, file| 
+        memo[file.name.to_sym] = file
+
+        memo
+      end
+    end
+
+    def files_in_repository
+      return [] if repository.empty?
+
+      head_commit = repository.lookup(repository.head.target)
+
+      files = []
+      head_commit.tree.walk_blobs(:postorder) do |root, entry| 
+        files << file_creator.new("#{root}#{entry[:name]}", repository.lookup(entry[:oid]).content ) 
+      end
+
+      files
+    end
+
+    def default_commit_info
+      options             = {}
+      options[:author]    = { :email => 'local_pac@local_pac', :name => 'Local Pac', :time => Time.now }
+      options[:committer] = { :email => 'local_pac@local_pac', :name => 'Local Pac', :time => Time.now }
+      options[:message]   = 'Commit made by local pac itself'
+
+      options
+    end
+  end
+end

data/lib/proxy_tester/handle_error.rb

@@ -0,0 +1,37 @@
+# encoding: utf-8
+module ProxyTester
+  module Actions
+    class HandleError
+
+      private
+
+      attr_reader :exception, :original_message, :handler_klass
+
+      public
+
+      def initialize(exception, handler_klass = ErrorHandler)
+        @exception        = exception.class
+        @original_message = exception.message
+        @handler_klass    = handler_klass
+      end
+
+      def run
+        handler = handler_klass.find exception
+        handler.original_message = original_message
+
+        handler.execute(parsed_message)
+      end
+
+      private
+
+      def parsed_message
+        result = JSON.parse(original_message)
+        return {} unless result.kind_of? Hash
+
+        result
+      rescue JSON::ParserError
+        {}
+      end
+    end
+  end
+end